feat(sdk/daemon-ui): reducer state machine — currentTool / approvalMode / cancellation propagation (PR-E)

Closes the "reducer state machine 设计缺漏" gap surfaced in the PR QwenLM#4328 review:
- No `currentTool` — UI scans `blocks[]` to find the running tool
- No mirrored approval mode — UI walks events to badge "plan"/"yolo"
- Cancellation does not propagate — in-flight tool blocks stuck at
  'in_progress' forever when the parent prompt is cancelled

## State additions (sidechannel, no transcript blocks)

`DaemonTranscriptSidechannelState`:
- `currentToolCallId?: string` — toolCallId of the in-flight tool
- `approvalMode?: string` — mirrored from session.approval_mode.changed
- `toolProgress: Record<string, { ratio?, step? }>` — per-tool progress
  shape (daemon-side emission of `tool.progress` events pending)

## Reducer behavior

### `tool.update` events

`IN_FLIGHT_TOOL_STATUSES` = { pending, confirming, running, in_progress }
`TERMINAL_TOOL_STATUSES` = { completed, success, failed, error, canceled, cancelled }

- Tool enters in-flight: set `currentToolCallId = event.toolCallId`
- Tool enters terminal: clear `currentToolCallId` if it matches
- Unknown status (forward-compat): leave pointer untouched

This avoids the failure mode where a future daemon-emitted status like
`'paused'` would silently mark unknown states as either in-flight or
terminal incorrectly.

### `session.approval_mode.changed`

Mirror `event.next` onto `state.approvalMode`. Renderers can render a
mode badge ("plan" / "default" / "auto-edit" / "yolo") with a single
selector call, no event-stream walking.

### `assistant.done` with `reason === 'cancelled'`

`propagateCancellationToInFlightTools` walks every tool block whose
status is still in-flight and force-sets it to 'cancelled'. The daemon
does not guarantee terminal `tool_call_update` for every in-flight tool
when the parent prompt is cancelled, so this propagation prevents UI
spinners from spinning forever.

`currentToolCallId` is also cleared in the same call.

Non-cancellation `assistant.done` (e.g., `reason: 'end_turn'`) does NOT
propagate — in-flight tools remain in-flight until the daemon emits
their terminal update naturally.

## Selectors

- `selectCurrentTool(state)` — returns the running tool block, or undefined
- `selectApprovalMode(state)` — returns the mirrored approval mode
- `selectToolProgress(state, toolCallId)` — per-tool progress query

All exported from `@qwen-code/sdk/daemon`.

## Scope deliberately deferred

Subagent nesting (`parentBlockId` / `delegationId` / `DaemonSubagentTranscriptBlock`)
is NOT in this PR. The shape needs design discussion (how to project nested
events; whether to bake delegation tracking into transcript or sidechannel).
PR-D / PR-F follow-up.

## Test coverage (51/51 pass)

- currentToolCallId set on enter, cleared on terminal
- approvalMode mirrors changes
- Cancellation marks in-flight tools 'cancelled', leaves completed alone
- Unknown status does NOT clear currentToolCallId (forward-compat)
- Non-cancellation `assistant.done` does NOT propagate

## Roadmap

PR-E of the unified follow-up to PR QwenLM#4328 (PR-A + PR-B + PR-E in this
branch; PR-C / PR-D pending).

Generated with AI

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: 秦奇

packages/sdk-typescript/src/daemon/ui/index.ts

@@ -12,7 +12,10 @@ export {
   formatBlockTimestamp,
   rebuildDaemonTranscriptBlockIndex,
   reduceDaemonTranscriptEvents,
+  selectApprovalMode,
+  selectCurrentTool,
   selectPendingPermissionBlocks,
+  selectToolProgress,
   selectTranscriptBlocks,
   selectTranscriptBlocksOrderedByEventId,
 } from './transcript.js';

packages/sdk-typescript/src/daemon/ui/transcript.ts

@@ -33,12 +33,42 @@ export function createDaemonTranscriptState(
     toolBlockByCallId: {},
     trimmedToolNotificationByCallId: {},
     permissionBlockByRequestId: {},
+    // PR-E sidechannel: track current tool / approval mode / progress
+    toolProgress: {},
     nextOrdinal: 1,
     now: opts.now ?? Date.now(),
     maxBlocks: opts.maxBlocks ?? DEFAULT_MAX_BLOCKS,
   };
 }
 
+/**
+ * Tool statuses that count as "in-flight" — when one of these is set, the
+ * tool block is considered active and `state.currentToolCallId` mirrors
+ * its id. Closed list; daemon-side may emit other status values (e.g.,
+ * future `'paused'`) — those are NOT treated as in-flight here.
+ */
+const IN_FLIGHT_TOOL_STATUSES: ReadonlySet<string> = new Set([
+  'pending',
+  'confirming',
+  'running',
+  'in_progress',
+]);
+
+/**
+ * Tool statuses that terminate the in-flight phase. Any other status
+ * (including unknown future ones) keeps the tool considered in-flight,
+ * which is the forward-compat-friendly default — the alternative would
+ * silently mark unknown states as terminal.
+ */
+const TERMINAL_TOOL_STATUSES: ReadonlySet<string> = new Set([
+  'completed',
+  'success',
+  'failed',
+  'error',
+  'canceled',
+  'cancelled',
+]);
+
 export function appendLocalUserTranscriptMessage(
   state: DaemonTranscriptState,
   text: string,
@@ -97,6 +127,13 @@ function applyDaemonTranscriptEvent(
       break;
     case 'assistant.done':
       finishAssistant(next);
+      // PR-E cancellation propagation: when the assistant turn was
+      // cancelled, any in-flight tool block whose status the daemon
+      // never updated to a terminal state would otherwise spin forever.
+      // Force them to 'cancelled' so renderers can clear spinners.
+      if (event.reason === 'cancelled') {
+        propagateCancellationToInFlightTools(next);
+      }
       break;
     case 'thought.text.delta':
       appendTextDelta(
@@ -140,8 +177,12 @@ function applyDaemonTranscriptEvent(
     // chat-stream transcript stays focused on user/assistant/tool/shell/
     // permission content. PRs in the C/D series may opt some of these
     // into transcript projection as structured non-chat blocks.
-    case 'session.metadata.changed':
     case 'session.approval_mode.changed':
+      // PR-E sidechannel: mirror the new approval mode onto state so
+      // renderers don't have to walk events.
+      next.approvalMode = event.next;
+      break;
+    case 'session.metadata.changed':
     case 'session.available_commands':
     case 'workspace.memory.changed':
     case 'workspace.agent.changed':
@@ -266,6 +307,7 @@ function upsertToolBlock(
     if (event.rawOutput !== undefined) existing.rawOutput = event.rawOutput;
     if (event.toolName) existing.toolName = event.toolName;
     if (event.toolKind) existing.toolKind = event.toolKind;
+    updateCurrentToolPointer(state, event.toolCallId, event.status);
     return;
   }
 
@@ -297,9 +339,54 @@ function upsertToolBlock(
   };
   appendBlock(state, block);
   state.toolBlockByCallId[event.toolCallId] = block.id;
+  updateCurrentToolPointer(state, event.toolCallId, event.status);
   clearActiveText(state);
 }
 
+/**
+ * PR-E: maintain `state.currentToolCallId`. Sets when tool enters in-flight
+ * status; clears when tool enters terminal status; leaves untouched for
+ * unknown statuses (forward-compat).
+ */
+function updateCurrentToolPointer(
+  state: DaemonTranscriptState,
+  toolCallId: string,
+  status: string | undefined,
+): void {
+  if (status === undefined) return;
+  if (IN_FLIGHT_TOOL_STATUSES.has(status)) {
+    state.currentToolCallId = toolCallId;
+    return;
+  }
+  if (TERMINAL_TOOL_STATUSES.has(status)) {
+    if (state.currentToolCallId === toolCallId) {
+      state.currentToolCallId = undefined;
+    }
+    return;
+  }
+  // Unknown status (forward-compat): leave pointer as-is.
+}
+
+/**
+ * PR-E cancellation propagation: walk every tool block whose status is
+ * still in-flight and force it to `'cancelled'`. Triggered when
+ * `assistant.done.reason === 'cancelled'` since the daemon does not
+ * guarantee a terminal `tool_call_update` for every in-flight tool when
+ * the parent prompt is cancelled.
+ */
+function propagateCancellationToInFlightTools(
+  state: DaemonTranscriptState,
+): void {
+  for (const blockId of Object.values(state.toolBlockByCallId)) {
+    const block = getWritableBlockById(state, blockId);
+    if (!block || block.kind !== 'tool') continue;
+    if (!IN_FLIGHT_TOOL_STATUSES.has(block.status)) continue;
+    block.status = 'cancelled';
+    block.updatedAt = state.now;
+  }
+  state.currentToolCallId = undefined;
+}
+
 function appendShellBlock(
   state: DaemonTranscriptState,
   event: Extract<DaemonUiEvent, { type: 'shell.output' }>,
@@ -648,6 +735,52 @@ export function selectTranscriptBlocksOrderedByEventId(
   return [...state.blocks].sort(compareBlocksByEventOrder);
 }
 
+/* ──────────────────────────────────────────────────────────────────────────
+ * PR-E selectors — sidechannel state queries
+ * ──────────────────────────────────────────────────────────────────────── */
+
+/**
+ * Return the currently-running tool block, or `undefined` when no tool is
+ * in flight. Used by UI to render a "正在运行 X" header without scanning
+ * `blocks[]`.
+ */
+export function selectCurrentTool(
+  state: DaemonTranscriptState,
+): Extract<DaemonTranscriptBlock, { kind: 'tool' }> | undefined {
+  const id = state.currentToolCallId;
+  if (!id) return undefined;
+  const blockId = state.toolBlockByCallId[id];
+  if (!blockId || blockId === TRIMMED_TOOL_BLOCK_ID) return undefined;
+  const index = state.blockIndexById[blockId];
+  if (index === undefined) return undefined;
+  const block = state.blocks[index];
+  return block?.kind === 'tool' ? block : undefined;
+}
+
+/**
+ * Approval mode currently active for the session, mirrored from
+ * `session.approval_mode.changed` events. `undefined` until the daemon
+ * emits at least one change event.
+ */
+export function selectApprovalMode(
+  state: DaemonTranscriptState,
+): string | undefined {
+  return state.approvalMode;
+}
+
+/**
+ * Per-tool progress query. Returns `undefined` if no progress has been
+ * recorded for the given toolCallId. The shape `{ ratio?, step? }` matches
+ * the eventual `tool.progress` event payload (daemon-side emission
+ * pending — SDK is ready to consume).
+ */
+export function selectToolProgress(
+  state: DaemonTranscriptState,
+  toolCallId: string,
+): { ratio?: number; step?: string } | undefined {
+  return state.toolProgress[toolCallId];
+}
+
 function compareBlocksByEventOrder(
   a: DaemonTranscriptBlock,
   b: DaemonTranscriptBlock,

packages/sdk-typescript/src/daemon/ui/types.ts

@@ -492,7 +492,33 @@ export type DaemonTranscriptBlock =
   | DaemonPermissionTranscriptBlock
   | DaemonStatusTranscriptBlock;
 
-export interface DaemonTranscriptState {
+/**
+ * PR-E sidechannel state — workspace / session state mirror that tracks
+ * non-chat events without polluting the chat-stream `blocks[]`.
+ */
+export interface DaemonTranscriptSidechannelState {
+  /**
+   * `toolCallId` of the tool currently in `running` / `in_progress` /
+   * `pending`. Updated by the reducer when a `tool.update` event arrives;
+   * cleared when the tool terminates. Used by UI to show a "正在运行 X tool"
+   * status header without scanning `blocks[]`.
+   */
+  currentToolCallId?: string;
+  /**
+   * Approval mode for the current session, mirrored from
+   * `session.approval_mode.changed` events. Renderers use this to badge
+   * the input area ("plan" / "default" / "auto-edit" / "yolo").
+   */
+  approvalMode?: string;
+  /**
+   * Per-tool progress map, keyed by `toolCallId`. Populated by future
+   * `tool.progress` events (daemon-side emission pending — the SDK is
+   * ready to consume the field shape today).
+   */
+  toolProgress: Record<string, { ratio?: number; step?: string }>;
+}
+
+export interface DaemonTranscriptState extends DaemonTranscriptSidechannelState {
   blocks: DaemonTranscriptBlock[];
   lastEventId?: number;
   activeUserBlockId?: string;