feat(sdk/daemon-ui): unified completeness follow-up to #4328 (PR-A through PR-E)

[chiga0]

Summary

Unified follow-up to PR #4328 — closes every SDK-only gap from the unified-renderer-layer review. PR #4328 alone shipped ~55%; this PR brings the daemon UI surface to ~95% (remainder requires daemon/Core coordination — see TODO §B/§C/§D).

9 commits, each independently reviewable, +5080 LOC (additive only):

#	Commit	Scope	LOC	New tests
1	5128ff03f	PR-A — event coverage 13→28+ types, errorKind, tool provenance	+1297	+29
2	bdffe3a34	PR-B — server timestamps + eventId-based ordering	+394	+5
3	2c3bca107	PR-E — state machine: currentTool / approvalMode / cancellation	+400	+5
4	e6f5758db	PR-C — tool preview taxonomy (4 new kinds) + multimodal content	+494	+16
5	86cd62fed	PR-D — render contract: markdown / HTML / plainText helpers	+595	+10
6	0856a2fd5	PR-F — 5 additional preview kinds (code_block / search / tabular / image_generation / subagent_delegation)	+604	+14
7	768cae43d	PR-G — adapter conformance test framework + fixture corpus (10 fixtures)	+641	+6
8	1785f5ff9	PR-H — WebUI transcriptAdapter migration to SDK render contract	+75	(typecheck)
9	768eb4e1d	PR-I — developer guide + migration cookbook (docs/developers/daemon-ui/)	+593	(docs)

Tests: 97/97 pass (vitest run test/unit/daemonUi.test.ts), full SDK + WebUI typecheck green.

🟢 Daemon-side status update (2026-05-22, post-rebase onto daemon_mode_b_main @ d0563ecf5+)

After rebasing onto current daemon_mode_b_main, source-verified against the new base:

TODO item	Status now
§C1 _meta.serverTimestamp envelope stamping	✅ DONE in server.ts:2670 (cited "chiga0 issue #19 P0"); my extractServerTimestamp 3-location probe lights up automatically
§C2 tool_call provenance + serverId stamping	✅ DONE in ToolCallEmitter.emitStart via resolveToolProvenance; my MCP heuristic now redundant on stamped paths
§C3 errorKind on stream_error	✅ DONE in server.ts:2046
§C3 errorKind on session_died	⚠ Equivalent: daemon stamps closed-enum reason (channel_closed / killed / daemon_shutdown) instead — semantically covers the same UI affordance need
§B1 subagent nesting (parentToolCallId)	✅ DONE daemon-side — SubAgentTracker.getSubagentMeta() returns {parentToolCallId, subagentType}, flowed via ToolCallEmitter._meta; SDK consumption is the only gap (see follow-up below)
§B2 tool.progress event	❌ Still not emitted by daemon
§D Multimodal MessageEmitter.emitUserContent + HistoryReplayer inlineData/fileData branches	❌ Still not implemented in Core

Net: 5 of 7 declared dependencies are now satisfied on daemon_mode_b_main. Once #4353 merges, serverTimestamp / provenance / serverId / errorKind / subagent stamping all light up automatically through the SDK's forward-compat code paths shipped in PR-A / PR-B.

Remaining:

• Subagent SDK consumption (PR-E deferred subagent nesting; daemon now stamps, SDK can consume — ~150 LOC follow-up)
• tool.progress (~50 LOC daemon)
• Multimodal echo (~80 LOC Core + ~80 LOC SDK)

Validation

# SDK
cd packages/sdk-typescript
npx vitest run test/unit/daemonUi.test.ts    # 97/97 pass
npx tsc --noEmit                              # no errors

# WebUI
cd packages/webui
npx tsc --noEmit                              # no errors

Reference adapter conformance:

runAdapterConformanceSuite({
  reduce: (events) => reduceDaemonTranscriptEvents(createDaemonTranscriptState(), events),
  renderToText: (s) => s.blocks.map(daemonBlockToMarkdown).join('\n\n'),
});
// → { passed: 10, failed: [], total: 10 }

CHANGELOG (per commit)

PR-A — Event coverage (5128ff03f)

DaemonUiEventType 13 → 28; daemon's full Wave 3-4 event surface reaches UI as typed events instead of debug fallbacks. New events split across 3 categories: session-meta (3), workspace (8), auth device-flow (5). Closed-enum propagation for errorKind and tool provenance + serverId (with mcp__<server>__<tool> heuristic fallback).

PR-B — Time schema (bdffe3a34)

DaemonUiEventBase.serverTimestamp? + DaemonTranscriptBlockBase.serverTimestamp? + clientReceivedAt. Forward-compat 3-location extraction; selectTranscriptBlocksOrderedByEventId ordering helper; formatBlockTimestamp(block, opts) Intl-based formatter.

PR-E — State machine (2c3bca107)

currentToolCallId + approvalMode + toolProgress sidechannel state. propagateCancellationToInFlightTools on assistant.done.reason === 'cancelled'. Forward-compat: unknown statuses leave pointer untouched. Selectors: selectCurrentTool / selectApprovalMode / selectToolProgress.

PR-C — Tool preview + content extraction (e6f5758db)

DaemonToolPreview 4 → 8 kinds: file_diff / file_read / web_fetch / mcp_invocation. extractContentPart() helper + DaemonUiContentPart discriminated union for multimodal (text / image / audio / resource). Helper shipped but NOT yet wired into reducer — see §D below.

PR-D — Render contract (86cd62fed)

daemonBlockToMarkdown / daemonBlockToHtml / daemonBlockToPlainText / daemonToolPreviewToMarkdown. Conservative HTML sanitizer (ANSI strip → HTML escape; role="alert" for errors). sanitizeUrls strips token-like query params. maxFieldLength truncation (default 8192).

PR-F — 5 additional preview kinds (0856a2fd5)

DaemonToolPreview 8 → 13 kinds: code_block / search / tabular / image_generation / subagent_delegation. Each with markdown + plain-text projections. Detector priority extended (most-specific-wins).

PR-G — Adapter conformance framework (768cae43d)

runAdapterConformanceSuite(adapter, opts?) + embedded DAEMON_UI_CONFORMANCE_FIXTURES corpus (10 fixtures). Format-agnostic semantic assertions via expectedContains + expectedAbsent. SDK reference adapter (markdown + plainText) passes all 10 fixtures.

PR-H — WebUI migration (1785f5ff9)

daemonTranscriptToUnifiedMessages(blocks, options?) gains opt-in useMarkdown + enrichToolDetailsWithPreview flags. Defaults preserve legacy behavior (additive). WebUI's transcriptAdapter now bridges to SDK's render contract — file_diff / mcp_invocation / tabular previews surface as markdown when opted in. SDK daemon root index.ts updated to re-export PR-B/D/E/F/G helpers (15+ symbols).

PR-I — Documentation (768eb4e1d)

docs/developers/daemon-ui/README.md (full API reference with cookbook) + docs/developers/daemon-ui/MIGRATION.md (9-step adapter author migration guide with before/after code).

TODO — Categorized by who needs to do the work

✅ A. Pure SDK work — COMPLETE in this PR

• ✅ 5 additional preview kinds — PR-F
• ✅ Adapter conformance framework — PR-G
• ✅ WebUI transcriptAdapter.ts migration — PR-H (opt-in additive)
• ✅ Migration guide + render cookbook — PR-I

B. Daemon must emit new event types (2 items)

• Subagent nesting — requires daemon to stamp parentToolCallId / delegationId on tool_call events, OR introduce subagent.delegation.started events. PR-F already ships the subagent_delegation preview kind via heuristic; full nesting requires daemon-side context.
• tool.progress event — ACP doesn't have this notification today. SDK state shape (toolProgress: Record<...>) ready in PR-E.

C. SDK already forward-compat ready — daemon "just" needs to stamp the field (3 items)

• _meta.serverTimestamp stamping — PR-B extracts from 3 envelope locations.
• provenance + serverId stamping on tool_call events — PR-A has mcp__<server>__<tool> heuristic; explicit stamping removes the guess for builtin / subagent.
• errorKind stamping on session_died / stream_error — PR-A already forwards if present.

D. Multimodal parts integration — Core dependency (3 items)

Source-verified in packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts and HistoryReplayer.ts:

// MessageEmitter.ts — all 3 methods hardcode 'text'
async emitUserMessage(text: string, ...) {
  await this.sendUpdate({
    sessionUpdate: 'user_message_chunk',
    content: { type: 'text', text },     // ← hardcoded 'text'
  });
}

// HistoryReplayer.ts:134 — only walks part.text and part.functionCall
for (const part of content.parts ?? []) {
  if ('text' in part && part.text) { ... }
  if ('functionCall' in part && part.functionCall) { ... }
  // No 'inlineData' (image/audio) branch
  // No 'fileData' (resource) branch
}

#resolvePrompt handles multimodal INPUT (line 2421-2455) but echo direction drops everything except text. User image attachments silently dropped on replay.

To unlock multimodal in UI:

• Daemon-side: new MessageEmitter.emitUserContent(parts: ContentBlock[]) (~50 LOC)
• Daemon-side: HistoryReplayer.replayContent add inlineData + fileData branches (~30 LOC)
• SDK-side: wire extractContentPart (already shipped in PR-C) into normalizer + reducer; text blocks accumulate parts: DaemonUiContentPart[] (~80 LOC)

Net: ~160 LOC of coordinated Core + SDK work. Marked for follow-up PR (PR-J: "Core+SDK multimodal echo").

Dependencies

Base commit: current tip of feat/daemon-ui-core (PR #4328). Diff includes PR #4328's content as base layer; will be clean once #4328 lands.

Scope / Risk

• Scale: 9 commits = ~5080 LOC of net additive code. All changes are additive to the public API; no existing API broken or removed. createdAt field preserved as @deprecated alias.
• Backward-compat: every existing v1 consumer continues to work. New behavior is opt-in via additional parameters.
• Forward-compat: SDK is ready to consume daemon-side fields (serverTimestamp / provenance / errorKind) the moment daemon emits them; graceful degradation when absent.
• Not covered: multimodal Core integration (TODO §D); subagent nesting (TODO §B); tool.progress event (TODO §B).

Linked

• PR feat(daemon): add shared UI transcript layer #4328 (base) — feat(daemon): add shared UI transcript layer
• Issue Daemon mode (qwen serve): proposal & open decisions #3803 (daemon proposal)
• Issue proposal(serve): Mode B feature-priority roadmap toward v0.16 production-ready #4175 (Mode B v0.16 implementation tracker)
• PR feat(daemon): add shared UI transcript layer #4328 unified-renderer-layer review: feat(daemon): add shared UI transcript layer #4328 (comment)

cc @wenshao @doudouOUC

---

Generated with assistance from Claude Opus 4.7 (claude-opus-4-7). 9 commits authored interactively; full diff reviewed for typecheck + 97 unit tests pass before each push. TODO §D classification corrected after source inspection of MessageEmitter.ts and HistoryReplayer.ts.

[github-actions]

📋 Review Summary

This PR delivers a comprehensive follow-up to #4328, implementing a unified daemon UI layer across 5 coordinated commits (PR-A through PR-E). The changes introduce typed event schemas, server-side timestamps, state machine tracking, tool preview taxonomy, and render contract helpers. Test coverage is strong (77/77 passing), and the implementation demonstrates solid architectural thinking around forward-compatibility and cross-client consistency.

🔍 General Feedback

Positive aspects:

• Excellent commit organization—each of the 5 commits is independently reviewable and addresses a specific gap
• Strong forward-compatibility patterns throughout (3-location timestamp extraction, unknown status handling)
• Comprehensive test coverage with defensive edge cases (ANSI stripping, C1 controls, bidi characters)
• Clear separation between sidechannel state and transcript blocks
• Well-documented roadmap and gap-closing rationale in commit messages

Architectural decisions:

• Monotonic eventId as primary ordering key with serverTimestamp fallback is sound
• Deliberate deferral of subagent nesting design shows good judgment
• Tool provenance heuristic (mcp__<server>__<tool>) is pragmatic

Potential concerns:

• Large diff (+6956/-1991 across 34 files) makes holistic review challenging
• Some files deleted (DaemonTuiAdapter) while new SDK files added—ensure no functionality regression
• Heavy reliance on AI co-authorship—verify all type safety and edge cases manually

🎯 Specific Feedback

🟡 High

• packages/sdk-typescript/src/daemon/ui/store.ts — The reducer handles many event types but lacks explicit handling for all 28+ DaemonUiEventType variants. Verify that session-meta, workspace, and auth events properly update sidechannel state without unintended no-ops.

• packages/webui/src/daemon/transcriptAdapter.ts:144-156 — normalizeToolStatus defaults unknown statuses to 'in_progress'. While the comment mentions forward-compat, this could cause future statuses like 'paused' to incorrectly display as active. Consider returning a distinct 'unknown' status or leaving the pointer untouched as PR-E does for currentToolCallId.

• packages/sdk-typescript/src/daemon/ui/transcript.ts — The propagateCancellationToInFlightTools function walks all blocks to mark in-flight tools as cancelled. For long sessions with many tools, this could be O(n) on every cancel. Consider maintaining an index of in-flight tool IDs for O(1) lookup.

🟢 Medium

• packages/sdk-typescript/src/daemon/ui/types.ts:58-72 — The DaemonTranscriptBlockBase has both serverTimestamp? and clientReceivedAt with a deprecated createdAt alias. While well-documented, this creates three timestamp fields that could confuse consumers. Consider consolidating documentation or providing a single getTimestamp() helper that returns the most authoritative available value.

• packages/sdk-typescript/src/daemon/ui/utils.ts — The extractContentPart function handles multimodal content but silently returns undefined for unknown types. This is defensive but could hide daemon evolution. Consider logging unknown content kinds to debug output for observability.

• packages/webui/src/daemon/DaemonSessionProvider.tsx:155-175 — The getReconnectDelayMs function implements exponential backoff but doesn't expose jitter. In a thundering herd scenario (many clients reconnecting simultaneously), synchronized retries could overload the daemon. Add optional randomization (e.g., ±20% jitter).

• packages/sdk-typescript/src/daemon/ui/terminal.ts — The daemonUiEventToTerminalText function handles many event types but the switch statement is lengthy. Consider extracting per-kind handlers into separate functions for better testability and readability.

🔵 Low

• packages/sdk-typescript/src/daemon/ui/types.ts:104 — The DaemonUiToolProvenance type includes 'unknown' as a catch-all. Consider adding JSDoc examples of when each provenance is assigned, especially the heuristic fallback logic for mcp__ prefix detection.

• packages/webui/src/types/toolCall.ts:10-16 — The ToolCallStatus union now includes 'cancelled', but existing tool call components (GenericToolCall, ShellToolCall, etc.) may need updates to handle the new status visually. Verify all consumers render cancelled state appropriately.

• packages/sdk-typescript/src/daemon/ui/render.ts — The daemonBlockToMarkdown and daemonBlockToHtml functions accept opts? but default parameter handling could be clearer. Consider using explicit default options object pattern for better discoverability.

• packages/webui/vite.config.ts:23-30 — The alias configuration duplicates the tsconfig.json paths. While necessary for Vite, consider documenting this duplication or extracting to a shared config to avoid drift.

• docs/developers/daemon-client-adapters/tui.md — This file is deleted. Ensure the new web-ui.md documentation covers equivalent guidance for TUI consumers, or migrate relevant content rather than removing.

✅ Highlights

• Event coverage expansion (13→28 types) — Comprehensive typing for session-meta, workspace, and auth events closes significant gaps in daemon observability

• Server timestamp extraction — The 3-location forward-compat pattern (event.serverTimestamp, event._meta.serverTimestamp, event.data._meta.serverTimestamp) is elegantly designed for gradual daemon adoption

• Security sanitization — sanitizeDaemonTerminalText handles ANSI escapes, C1 controls, OSC/DCS sequences, and bidi characters comprehensively. HTML output escapes XSS vectors while preserving content integrity.

• Tool preview taxonomy — The 8-kind DaemonToolPreview union (file_diff, file_read, web_fetch, mcp_invocation, etc.) provides rich structured display without over-engineering

• Cancellation propagation — The propagateCancellationToInFlightTools logic prevents infinite spinner scenarios when daemon doesn't guarantee terminal events for all tools on cancel

• Test quality — Tests cover edge cases like secret field redaction, malformed payloads, protocol version mismatches, and ANSI control sequence stripping

[wenshao]

A deterministic typecheck also reports TS4111 in packages/webui/src/components/toolcalls/ShellToolCall.tsx for existing Record<string, unknown> dot-property accesses (description / command). Those lines are not part of the PR diff, so I am not posting them as inline comments, but the changed-file typecheck will still need to be clean before merge.

— gpt-5.5 via Qwen Code /review

[chiga0]

Self-review — PR #4353 多轮审计 (9 commits / +5080 LOC)

Multi-round self-review covering correctness / coverage / side effects / bundle size + cold start impact + React dependency check.

Round 1 — 依赖与 bundle 影响

React dependency

Check	Result
packages/sdk-typescript/package.json deps	@modelcontextprotocol/sdk + zod (unchanged)
packages/sdk-typescript/package.json peer	typescript only
grep -r "from 'react'" packages/sdk-typescript/src/	empty
grep -r "@types/react" packages/sdk-typescript/src/	empty
webui's React import	inherited from PR #4328, this PR adds none

Conclusion: SDK has zero React dependency. This PR adds no new external deps.

Bundle size — actual measurement

@qwen-code/sdk/daemon subpath (full):
  pre-PR  #4353 (= PR #4328 head):    54 KB min / 13.7 KB gzip
  after PR #4353:                      80 KB min / 20.8 KB gzip
  Δ:                                  +26 KB min / +7 KB gzip

Critical caveat — tree-shaking measurement. Simulated webui's actual import surface (daemonBlockToMarkdown + daemonToolPreviewToMarkdown + sanitizeDaemonTerminalText):

tree-shaken (webui actual subset):    4.9 KB min / 2.2 KB gzip

Implication:

• Full bundle grows ~26 KB only if a consumer imports the entire API surface
• typical webui consumer adds ~2.2 KB gzip — for React + markdown-it (~500 KB total) webui, <0.5% cold-start impact
• The conformance framework (641 LOC + 10 fixtures), 16 unused selectors, and 9 unused normalizers all tree-shake out

Cold-start analysis

• daemon subpath has no top-level side effects — pure functions + type defs + static fixture arrays
• No top-level IIFE / no fs reads / no fetch / no Date.now() at module-load
• Parse + compile cost on modern V8: 1-3ms for 80 KB minified
• With tree-shaking, webui parses only ~5 KB → cold start impact negligible

---

Round 2 — Test regression

SDK pre-PR:      77/77 pass
SDK after PR:    97/97 pass (+20 new tests)
SDK FULL suite (14 files): 521/521 pass
  - DaemonAuthFlow.test.ts: untouched, passes
  - DaemonClient.test.ts: untouched, passes
  - Query.test.ts: untouched, passes
  - All others untouched
typecheck:       SDK + WebUI both clean

0 regressions across the entire SDK test suite.

---

Round 3 — Per-commit correctness audit

PR-A (event coverage)

• ✅ 16 new event normalizers; each with malformed-payload fallback to debug
• ✅ Reducer no-op on new events; lastEventId still advances monotonically
• ✅ errorKind validated via Set.has() (closed enum)
• ✅ Provenance MCP heuristic (mcp__<server>__<tool>) correctly parsed

PR-B (time schema)

• ✅ extractServerTimestamp checks 3 candidates + Number.isFinite guard
• ✅ compareBlocksByEventOrder 3-level fallback (eventId → serverTimestamp → clientReceivedAt)
• ✅ formatBlockTimestamp Intl.DateTimeFormat with safe-value guard
• ⚠ Minor: clientReceivedAt made required — every mock block in external code needs the field. Already fixed in this PR's webui transcriptAdapter.test.ts (11 occurrences).

PR-E (state machine)

• ✅ IN_FLIGHT_TOOL_STATUSES + TERMINAL_TOOL_STATUSES closed sets
• ✅ Unknown status leaves pointer untouched — forward-compat
• ✅ propagateCancellationToInFlightTools uses getWritableBlockById COW path
• ✅ assistant.done.reason !== 'cancelled' does NOT propagate — test-verified

PR-C (preview taxonomy + content extraction)

• ✅ 4 new detector priority order correct (MCP > file_diff > file_read > web_fetch)
• ✅ extractContentPart handles 4 kinds + undefined fallback
• ✅ Legacy getTextContent preserved for backward compat

PR-D (render contract)

• ✅ HTML sanitizer strips ANSI BEFORE HTML escape — defends against agent-emitted escape sequences in HTML output
• ✅ sanitizeUrls only strips token-like query params (token=, key=, auth=, signature=, x-amz-*, x-goog-*)
• ✅ maxFieldLength default 8192 with truncation indicator
• ✅ role="alert" for error blocks (a11y)

PR-F (5 additional preview kinds)

• ✅ Detector priority order: specific-first (MCP > subagent > search > image_gen > file_diff > ...)
• ✅ MCP heuristic wins over subagent — mcp__editor__delegate_task correctly classified as mcp_invocation
• ✅ Tabular row cap MAX_TABULAR_ROWS = 50 + totalRows truncation indicator
• ✅ Search top results cap MAX_SEARCH_TOP_RESULTS = 5
• ✅ Code block requires explicit language OR REPL-style toolName — no false positives on arbitrary code: fields

PR-G (conformance framework)

• ✅ Reference adapters (markdown + plainText projections) both pass all 10 fixtures
• ✅ Buggy adapter (empty string) surfaces missing phrases per-fixture
• ✅ Buggy adapter (raw JSON dump) caught by redaction fixture's expectedAbsent
• ✅ only / skip filter options work
• ⚠ 6 of 10 fixtures have expectedContains: [] — intentional (observation-only fixtures for events where adapter chooses rendering strategy, e.g., auth modal vs banner). Stronger assertions could be added in follow-up.

PR-H (WebUI migration)

• ✅ useMarkdown + enrichToolDetailsWithPreview are opt-in flags (default false) — additive, zero breaking risk
• ⚠ Tradeoff noted: WebUI default behavior unchanged — downstream needs to explicitly opt in to get richer markdown rendering. A follow-up PR could default useMarkdown: true in DaemonSessionProvider to make the benefit automatic.
• ✅ SDK daemon root index.ts re-exports for PR-B/D/E/F/G surfaces (15+ symbols)

PR-I (docs)

• ✅ README + MIGRATION cover all 9 commits with code examples
• ⚠ No separate cookbook file, but README has a cookbook section — can split later based on user feedback

---

Round 4 — Side effect scan

Public API breaking changes

Concern	Status
Deleted exports	0
Renamed exports	0 (createdAt preserved as @deprecated alias for clientReceivedAt)
Changed signatures	daemonTranscriptToUnifiedMessages gains optional options parameter — additive
Behavior change on existing functions	0 (available_commands_update becomes typed event but this lives only on feat/daemon-ui-core, not yet merged to main)

Type-level changes (additive widening only)

1. DaemonTranscriptBlockBase.clientReceivedAt: number required — external mock blocks need the field. Risk localized: any private fork / IDE extension manually constructing blocks. Mitigation: trivial sed (every createdAt: N gets paired clientReceivedAt: N).

2. DaemonUiEventType union expanded — exhaustive switches on the union require new cases. Already handled in SDK internals. This is intentional/healthy — forces downstream adapters to explicitly observe new events.

---

Round 5 — Coverage completeness audit (against original review)

Cross-check each gap in the PR #4328 unified renderer review:

Original review item	Status in this PR
§1 — 12+ daemon events fall through to debug	✅ All normalized (PR-A)
§2 — Free-string schema (tool/error/status)	⚠ Partial: errorKind + provenance closed enums (PR-A); status / outcome still strings
§3 — Time not standardized	✅ eventId ordering + serverTimestamp + Intl formatter (PR-B)
§4 — Provider differences leak 3 ways	⚠ Partial: provenance closed enum + content discrimination helper; reasoning signature still daemon-layer concern
§5 — Reducer state machine gaps (in-flight / nesting / progress / cancel)	⚠ Most: currentTool + approvalMode + cancellation propagation (PR-E); subagent nesting deferred to daemon
§6 — Render contract terminal-only	✅ markdown / HTML / plainText + conformance + webui wired + docs (PR-D/G/H/I)
§7 — Tool preview only 4 kinds	✅ Extended to 13 (PR-C + PR-F)

Completion ~95%, matching the PR description. Remaining 5% all declared in the daemon dependency declaration — waiting on daemon/Core landing.

---

Round 6 — Known minor issues

⚠ Minor 1 — Empty user.text produces trailing newlines in markdown

daemonBlockToMarkdown for user block: **You**\n\n${cap(block.text)}. If block.text === '', output is **You**\n\n (trailing empty paragraph after rendering).
Impact: cosmetic; user blocks rarely empty in practice.
Fix path: early-return '' when text empty — follow-up PR.

⚠ Minor 2 — MCP heuristic parses mcp__a__b__c__d greedily

mcp__a__b__c__d parses as serverId=a, toolName=b__c__d.
Whether triggered: depends on daemon naming convention. If server names contain __, heuristic misclassifies. Daemon side provenance stamping (declared in deps) eliminates the heuristic entirely — no fix needed in SDK.

⚠ Minor 3 — 6 conformance fixtures with expectedContains: []

Intentional: those fixtures verify "adapter observes the event without throwing", not "adapter renders specific text". Adapter rendering strategy for auth/mcp/system events varies (modal vs banner vs hidden).
Not a bug, but stronger fixtures could be added (e.g., expectedKindObserved: 'auth_event') in a follow-up.

❌ No critical issues

---

Aggregate verdict

Dimension	Assessment
React dependency	❌ None added — SDK pure
Full bundle size	+26 KB minified (acceptable for the feature surface)
Webui actual increase	+2.2 KB gzip (tree-shaking removes 75%)
Cold start	<0.5% impact, negligible
Side effects	0 critical; 3 documented minor issues
Test regression	0 (521/521 SDK tests pass)
Type-level breaking	clientReceivedAt required + union widening — internally self-consistent; downstream exhaustive switches need new cases (healthy)
Coverage completeness	~95% of original review (rest explicitly declared as daemon/Core deps)
Mergeable	✅ — no rollback or rewrite required

The three minor issues are not blockers and can be follow-up.

---

Generated with assistance from Claude Opus 4.7 (claude-opus-4-7) — bundle sizes measured via esbuild --minify --bundle against the actual PR branch worktree; tree-shaking simulated with the webui's verbatim import set; full SDK test suite (vitest run) executed against post-PR HEAD.

[chiga0]

Updated this PR in ae729357e.

Handled the latest review threads as follows:

• Rebased feat/daemon-ui-completeness-followup onto the latest feat(daemon): add shared UI transcript layer #4328 head (6dbfffaaf) so the WebUI reconnect / assistant.done / prompt cancel / text trimming fixes are now included in this stacked PR.
• Fixed the valid SDK/UI feedback: public daemon barrel re-exports, local-block ordering, qwen-oauth device-flow provider, per-listener store notification isolation, permission trim tombstone, selected permission status false positives, markdown code-fence escaping, createdAt JSDoc, selectToolProgress alpha marker, and cached Intl.DateTimeFormat usage.
• Updated daemon UI docs to clarify the current web chat / web terminal adoption target. Native TUI, channel, and IDE remain on their existing default paths.
• Rechecked the earlier WebUI typecheck concerns. packages/webui typecheck now passes locally after the update. The @qwen-code/sdk/daemon import resolves through the package tsconfig path mapping, and CreateSessionRequest exposes explicit fields rather than only an index signature.

Verification:

• cd packages/sdk-typescript && npm run typecheck
• cd packages/sdk-typescript && npx vitest run test/unit/daemonUi.test.ts --reporter dot -> 105 passed
• cd packages/webui && npm run typecheck

Note: packages/webui Vitest startup is still blocked in my local worktree by missing vite-plugin-dts, before running assertions. I did not count that as a PR assertion failure.

Generated by GPT-5 model.

[doudouOUC]

Daemon-side dependencies landed — F4 prereq #4360 merged

@chiga0 — PR #4360 (F4 prereq — daemon protocol completion) merged into daemon_mode_b_main at 2026-05-21 03:11Z (commit a60c1c52a). This addresses the 3 P0 stamping items you listed in #4175 comment #19.

What's now emitted on the wire:

Field	Location	SDK consumer
_meta.serverTimestamp	every SSE frame via formatSseFrame boundary stamp	your extractServerTimestamp 3-location probe (PR-B bdffe3a34)
tool_call _meta.provenance ('builtin' | 'mcp' | 'subagent') + optional _meta.serverId	ToolCallEmitter.emitStart/emitResult/emitError via ToolCallEmitter.resolveToolProvenance(toolName, subagentMeta) heuristic on mcp__<server>__<tool>	your DaemonUiToolUpdateEvent.provenance/serverId (PR-A 5128ff03f)
stream_error.errorKind (typed as DaemonErrorKind | (string & {}) for forward-compat)	server.ts stream-error frame via mapDomainErrorToErrorKind(err)	your DaemonUiErrorEvent.errorKind + asDaemonErrorKind validator (PR-A)

Plus addressed the state-divergence hazard Ilya0527 raised in #15 — SDK reducer now has awaitingResync + lastResyncRequired view state that flips on a new state_resync_required synthetic frame the daemon emits when consumers reconnect past the SSE ring eviction point.

SDK PR #4353 unblocking: the forward-compat field slots you preserved are no longer dead code on daemon_mode_b_main HEAD. The 5% gap you flagged ("daemon-side stamps SDK already-ready to consume") is now 0%. The 3-location probe, provenance dispatch, errorKind classification, and state_resync_required reducer case all have real wire data flowing from daemon to SDK.

Caveat: my PR #4360 implements daemon→SDK protocol fields, but I left the SDK-side type definitions in your domain — the extractServerTimestamp helper and the _meta-typed envelope still need to ship via #4353 for SDK consumers to read them without as any. Filed as a Codex-round review note on #4360 cross-referencing #4353 so the dependency is visible.

Anything else from your comment #19 P1 (subagent nesting + tool.progress) or P2 (multimodal echo) you want me to look at next? Those touch Core (MessageEmitter + HistoryReplayer + ACP child-side emitter plumbing) so they're separate scope from #4360, but I can pick them up if the timing's right.

🤖 Generated with Qwen Code

[wenshao]

[Critical] resolvePermissionBlock (transcript.ts:581) does not guard against TRIMMED_PERMISSION_BLOCK_ID. The sibling upsertPermissionBlock (line 544) correctly returns early when existingId === TRIMMED_PERMISSION_BLOCK_ID, but resolvePermissionBlock lacks this check. When maxBlocks trimming evicts a pending permission request, a subsequent permission.resolved event creates a dangling orphan block — wasting a block slot, accelerating further trimming, and silently breaking the trimmed-block contract.

function resolvePermissionBlock(
  state: DaemonTranscriptState,
  event: DaemonUiPermissionResolvedEvent,
): void {
  const existingId = state.permissionBlockByRequestId[event.requestId];
  if (existingId === TRIMMED_PERMISSION_BLOCK_ID) return;

---

[Suggestion] permissionBlockByRequestId (transcript.ts:693-709) grows unboundedly in long sessions. Unlike toolBlockByCallId which has pruneTrimmedToolIndexes, trimmed permission entries (TRIMMED_PERMISSION_BLOCK_ID) are never pruned. Add a pruneTrimmedPermissionIndexes function analogous to the tool index pruning.

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Critical] awaitingResync permanently freezes the transcript on same-session reconnect.

When state_resync_required sets awaitingResync = true (line 244), all non-terminal events are blocked. If the SSE connection then drops and reconnects to the same session, store.reset() is NOT called (only on session-id change in DaemonSessionProvider.tsx:155-162). awaitingResync stays true forever — all replayed events from the new SSE stream are silently dropped.

The connection shows "connected" while the transcript is dead. No console error, no thrown exception, no automatic recovery.

Suggested fix: In DaemonSessionProvider.tsx, when reconnecting the same session and awaitingResync is true, call store.reset():

} else if (previousSessionId !== undefined) {
  if (store.getSnapshot().awaitingResync) {
    promptAbortRef.current?.abort();
    promptAbortRef.current = undefined;
    promptBusyRef.current = false;
    store.reset();
  }
  store.dispatch({ type: 'assistant.done', reason: 'reconnected' });
}

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Critical] detectFileRead regex matches substrings — "concat", "locate", "catalog", "preview" all match.

The regex /read|view|cat/i is not anchored. A tool named concat_files or locate_binary would be misidentified as a file-read tool, producing an incorrect file_read preview with a path instead of falling through to the correct command preview.

Suggested change

	toolName !== undefined && /read|view|cat/i.test(toolName);
	toolName !== undefined && /\b(?:read|view|cat)\b/i.test(toolName);

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Critical] ESLint @typescript-eslint/array-type: ReadonlyArray<DaemonToolTranscriptBlock> is forbidden for simple types. Use readonly DaemonToolTranscriptBlock[] instead.

Suggested change

	): ReadonlyArray<DaemonToolTranscriptBlock> {
	readonly DaemonToolTranscriptBlock[],

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Suggestion] daemonBlockToHtml uses the custom sanitizer for HTML attribute context (data-status="${safeStatus}"). DOMPurify and similar HTML-focused sanitizers do not escape " in text-node mode, so a tool status string like ok" onclick="alert(1) from a malicious MCP server would break out of the data-status attribute and inject arbitrary HTML attributes.

The default defaultEscapeHtml escapes " to ", so this only triggers with a custom sanitizer.

Fix: Always use defaultEscapeHtml for attribute-context values regardless of the custom sanitizer:

const attrEscape = defaultEscapeHtml;
// In tool block:
const safeStatus = attrEscape(block.status);
// In shell block:
const safeStream = attrEscape(block.stream ?? 'stdout');

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Suggestion] escapeTableCell doesn't strip newlines — multi-line cell values break GFM table structure.

GFM table rows are delimited by newlines. A cell value containing \n (e.g., a multi-line error message in tabular tool output) splits the row across lines, producing malformed markdown that renders as a garbled table.

Suggested change

	return escapeMarkdownText(raw, opts).replace(/\|/g, '\\|');
	return escapeMarkdownText(raw, opts).replace(/\|/g, '\\|').replace(/\n/g, ' ');

— qwen-latest-series-invite-beta-v34 via Qwen Code /review

[wenshao]

[Suggestion] renderToolHeader doesn't accept DaemonRenderOptions, so maxFieldLength truncation is not applied to tool header fields.

All other 16+ calls to escapeMarkdownText and 11+ calls to inlineCode correctly pass opts, but this function calls them without opts. A tool with a very long title or name renders without truncation, violating the render contract's consistency.

Fix: Add opts parameter and pass it through:

function renderToolHeader(
  block: Extract<DaemonTranscriptBlock, { kind: 'tool' }>,
  opts: DaemonRenderOptions = {},
): string {
  const parts: string[] = [`### ${escapeMarkdownText(block.title, opts)}`];
  if (block.toolName) parts.push(inlineCode(block.toolName, opts));
  if (block.toolKind) parts.push(`(${escapeMarkdownText(block.toolKind, opts)})`);
  return parts.join(' ');
}

And update the call site: const header = renderToolHeader(block, opts);

— qwen-latest-series-invite-beta-v34 via Qwen Code /review