fix(daemon-ui): wenshao R6 — recovery flow chicken-and-egg + pending pointer

Three Criticals from R6 review (4351217188) all pointing at real bugs
introduced by R4/R5 work — not false positives. Fixes plus regression
tests.

## Critical 1 — same-session reconnect never clears the latch

When the daemon emitted `state_resync_required`, the reducer set
`awaitingResync = true`. The webui provider dispatched
`assistant.done { reason: 'reconnected' }` after re-attaching SSE but
never called `store.clearAwaitingResync()`. Result: events flowed in
on the fresh stream but every one got dropped by the
`applyDaemonTranscriptEvent` passthrough guard. Transcript appeared
permanently frozen with no diagnostic clue (the `console.warn` fired
on each drop, but the user wouldn't necessarily check DevTools).

Fix: in `DaemonSessionProvider.tsx`, after dispatching the synthetic
`reconnected` `assistant.done`, check `awaitingResync` and clear it
BEFORE the new SSE event loop starts.

## Critical 2 — updateCurrentToolPointer breaks on undefined status

In `upsertToolBlock`, a new tool block is created with
`status: event.status ?? 'pending'`. But `updateCurrentToolPointer`
was called with raw `event.status` — when undefined, the function's
own `if (status === undefined) return;` guard short-circuited without
ever pointing at the new (visually-pending) block.

Result: `selectCurrentTool` returned `undefined` for daemon events
that omitted the explicit `status` field, while the block sat at
"pending" in the UI — invisible to the current-tool selector.

Fix: pass the EFFECTIVE status (`event.status ?? 'pending'`) so the
pointer logic mirrors the actual stored status.

## Critical 3 — clearAwaitingResync flow chicken-and-egg

The earlier (R4) JSDoc documented the recovery flow as: "re-subscribe
with `Last-Event-ID: 0`, then call clearAwaitingResync after replay
drains." But while the latch is true, EVERY non-passthrough event is
dropped at `applyDaemonTranscriptEvent`. So during the replay drain,
zero events made it into state, and clearing the latch afterward did
nothing — transcript permanently empty.

Correct flow: clear FIRST, then stream events. Updated JSDoc on both
`types.ts` interface and `store.ts` impl to document this clearly.

Added a regression test (`clearAwaitingResync AFTER dispatching events:
events ARE dropped`) that pins the correct flow in code.

## Regression tests (+3)

- `undefined status` creates pending block AND sets currentToolCallId
- clear-then-dispatch ✓ events flow
- dispatch-then-clear ✗ events dropped (correct flow documentation)

## Validation

| | |
|---|---|
| SDK tests | **175/175** (was 172, +3) |
| WebUI tests | **9/9** |
| SDK typecheck | clean |
| WebUI typecheck | clean |

## Note on doudouOUC heads-up

QwenLM#4469 (main → daemon_mode_b_main sync, 45 commits since 2026-05-19)
will land soon. doudouOUC's note says rebase should be smooth (no
daemon-ui surface conflicts). Will rebase on the cron's next pass
after QwenLM#4469 merges.

Generated with AI

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

Author: 秦奇

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

@@ -68,16 +68,26 @@ export function createDaemonTranscriptStore(
       });
       scheduleNotify();
     },
-    // wenshao R4 (qwen3.7-max): explicit recovery from the
-    // `awaitingResync` one-way latch. After the client receives a
-    // `session.state_resync_required` event, it should:
-    //   1. Drop local state if a full replay isn't feasible, OR
-    //   2. Re-subscribe with `Last-Event-ID: 0` to receive a full
-    //      replay, then call `clearAwaitingResync()` once the replay
-    //      stream has drained.
-    // Without this API the latch could only be cleared by `reset()`,
-    // which forces session-id reset semantics — wrong shape for the
-    // same-session-with-replay recovery flow.
+    // wenshao R4-R6 (qwen3.7-max): explicit recovery from the
+    // `awaitingResync` one-way latch.
+    //
+    // RECOVERY FLOW (correct order — wenshao R6 caught a flow bug):
+    //   1. Daemon emits `session.state_resync_required`; reducer sets
+    //      `state.awaitingResync = true` and starts dropping events.
+    //   2. Consumer decides on recovery strategy and calls EITHER:
+    //        a. `reset()` — clean slate, discard local blocks
+    //        b. `clearAwaitingResync()` — keep local blocks, accept
+    //           new events. Call BEFORE the new SSE stream starts
+    //           delivering events (or BEFORE a `Last-Event-ID: 0`
+    //           replay starts), otherwise the replay events get
+    //           dropped by the latch guard.
+    //   3. Re-subscribe to SSE; events flow normally.
+    //
+    // (The earlier JSDoc said "after replay drains" — that was wrong.
+    // While the latch is set, every replay event is dropped, so the
+    // window between latch-clear and stream-start is what receives
+    // events. Clear early; if dispatch order misses something the
+    // daemon will eventually emit a new `state_resync_required`.)
     clearAwaitingResync() {
       if (!state.awaitingResync) return;
       state = {

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

@@ -498,7 +498,17 @@ function upsertToolBlock(
       }
     }
   }
-  updateCurrentToolPointer(state, event.toolCallId, event.status);
+  // wenshao R6 (qwen3.7-max): pass the EFFECTIVE status — the block
+  // was just created with `event.status ?? 'pending'`. If we pass
+  // raw `event.status === undefined`, `updateCurrentToolPointer` early-
+  // returns and the block sits as visually-pending but currentToolCallId
+  // never points at it. Effective-status keeps the pointer in sync
+  // with what was actually written to the block.
+  updateCurrentToolPointer(
+    state,
+    event.toolCallId,
+    event.status ?? 'pending',
+  );
   clearActiveText(state);
 }
 

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

@@ -695,11 +695,16 @@ export interface DaemonTranscriptStore {
   reset(seed?: Partial<DaemonTranscriptState>): void;
   /**
    * Clear the `awaitingResync` latch that gets set when the daemon emits
-   * `session.state_resync_required`. Call this after re-subscribing to
-   * SSE with `Last-Event-ID: 0` and the replay stream has fully drained
-   * (or after dropping state via your own flow). Without this API, the
-   * latch could only be cleared by `reset()`, which forces session-id
-   * change semantics that don't fit same-session reconnect.
+   * `session.state_resync_required`.
+   *
+   * **Recovery flow (call BEFORE the new SSE stream starts):**
+   * 1. Receive `session.state_resync_required` event → latch sets
+   * 2. Call `clearAwaitingResync()` (keep blocks) OR `reset()` (clean slate)
+   * 3. Re-subscribe to SSE (optionally with `Last-Event-ID: 0` for replay)
+   *
+   * (R6 review caught a flow bug — the earlier JSDoc said "after replay
+   * drains" but while the latch is set every replay event is dropped.
+   * Clear FIRST, then stream events.)
    */
   clearAwaitingResync(): void;
 }

packages/sdk-typescript/test/unit/daemonUi.test.ts

@@ -4783,3 +4783,111 @@ describe('R5 review batch — coverage additions', () => {
     expect(store.getSnapshot().awaitingResync).toBe(false);
   });
 });
+
+describe('R6 review batch — recovery flow + pending pointer', () => {
+  it('newly-created tool block with undefined status sets currentToolCallId to its default `pending`', () => {
+    let state = createDaemonTranscriptState({ now: 1 });
+    state = reduceDaemonTranscriptEvents(
+      state,
+      normalizeDaemonEvent({
+        id: 1,
+        v: 1,
+        type: 'session_update',
+        data: {
+          update: {
+            sessionUpdate: 'tool_call',
+            toolCallId: 'unspecified',
+            title: 'starting',
+            // no status — daemon emit without explicit status field
+          },
+        },
+      } as never),
+      { now: 2 },
+    );
+    // Block has effective status 'pending' AND currentToolCallId points to it.
+    const block = state.blocks.find(
+      (b): b is Extract<typeof b, { kind: 'tool' }> =>
+        b.kind === 'tool' && b.toolCallId === 'unspecified',
+    )!;
+    expect(block.status).toBe('pending');
+    expect(state.currentToolCallId).toBe('unspecified');
+  });
+
+  it('clearAwaitingResync FIRST then dispatch new events: events flow', async () => {
+    const { createDaemonTranscriptStore } = await import(
+      '../../src/daemon/ui/index.js'
+    );
+    const store = createDaemonTranscriptStore();
+    // Set the latch.
+    store.dispatch({
+      type: 'session.state_resync_required',
+      reason: 'sse_eviction',
+      lastDeliveredId: 5,
+      earliestAvailableId: 12,
+    } as never);
+    expect(store.getSnapshot().awaitingResync).toBe(true);
+    // Clear BEFORE the new event stream.
+    store.clearAwaitingResync();
+    expect(store.getSnapshot().awaitingResync).toBe(false);
+    // Now dispatch a normal event — should land in transcript.
+    store.dispatch(
+      normalizeDaemonEvent({
+        id: 100,
+        v: 1,
+        type: 'session_update',
+        data: {
+          update: {
+            sessionUpdate: 'agent_message_chunk',
+            content: { type: 'text', text: 'replay-event-1' },
+          },
+        },
+      } as never),
+    );
+    const text = store
+      .getSnapshot()
+      .blocks.map((b) =>
+        b.kind === 'assistant' ? (b as { text: string }).text : '',
+      )
+      .join('');
+    expect(text).toContain('replay-event-1');
+  });
+
+  it('clearAwaitingResync AFTER dispatching events: events ARE dropped (documents the flow)', async () => {
+    // This test pins the correct flow as documented: latch drops everything
+    // until cleared. If a consumer dispatches events FIRST then clears, the
+    // events are lost.
+    const { createDaemonTranscriptStore } = await import(
+      '../../src/daemon/ui/index.js'
+    );
+    const store = createDaemonTranscriptStore();
+    store.dispatch({
+      type: 'session.state_resync_required',
+      reason: 'sse_eviction',
+      lastDeliveredId: 5,
+      earliestAvailableId: 12,
+    } as never);
+    // WRONG order — dispatch BEFORE clear (replay window).
+    store.dispatch(
+      normalizeDaemonEvent({
+        id: 101,
+        v: 1,
+        type: 'session_update',
+        data: {
+          update: {
+            sessionUpdate: 'agent_message_chunk',
+            content: { type: 'text', text: 'replay-event-2' },
+          },
+        },
+      } as never),
+    );
+    store.clearAwaitingResync();
+    // Event was dropped by the latch.
+    const text = store
+      .getSnapshot()
+      .blocks.map((b) =>
+        b.kind === 'assistant' ? (b as { text: string }).text : '',
+      )
+      .join('');
+    expect(text).not.toContain('replay-event-2');
+  });
+});

packages/webui/src/daemon/DaemonSessionProvider.tsx

@@ -154,6 +154,17 @@ export function DaemonSessionProvider({
               store.reset();
             } else if (previousSessionId !== undefined) {
               store.dispatch({ type: 'assistant.done', reason: 'reconnected' });
+              // wenshao R6 (qwen3.7-max): clear the awaitingResync latch
+              // BEFORE the new SSE event loop starts. Otherwise, if the
+              // prior connection ended after `state_resync_required` set
+              // the latch, every event from the fresh stream gets dropped
+              // by `applyDaemonTranscriptEvent`'s passthrough guard —
+              // transcript stays permanently frozen even though the
+              // connection is healthy. Same-session reconnect IS the
+              // recovery path; signal it to the reducer now.
+              if (store.getSnapshot().awaitingResync) {
+                store.clearAwaitingResync();
+              }
             }
             session = nextSession;
             lastSessionIdRef.current = session.sessionId;