fix: 任务输出回放合并活事件镜像，修复重启后 store 会话滞后导致新读取不可见

- host 半挂 ctx.on('session/event')（api-proxy 同款 API），镜像 task_output 的 tool/call + tool/result 活事件（每会话 200 条有界环，无关结果不缓存） - tasks.output 回放合并「store 事件日志 + 活事件镜像」，按 seq 去重排序配对 - 零 DSH 写入：会话 store 在宿主重启后可能冻结在再水合边界（持久化文件停在重启时刻），活事件只走 append 推送链；镜像绕开该滞后 - 测试：新增镜像用例（live 事件、跨会话隔离、种子+镜像合并不双计），全量 373 通过
2026-08-12 23:04:30 +08:00
parent 88f116338a
commit 6e4474cd2e
3 changed files with 226 additions and 34 deletions
@@ -388,6 +388,15 @@ declare module 'cordis' {
     * {@link ./client/index.tsx}); undefined on the host side.
     */
    betterSidebar: BetterSidebarService
+    /**
+     * Subscribe to the session append feed (mirror of the cordis event API):
+     * the listener receives every appended session event with the LIVE
+     * Session instance that appended it. The api-proxy pushes the same feed
+     * to browsers; the sidebar uses it to mirror task_output events the
+     * session store's own log can lag behind (restart divergence). Returns
+     * the disposer.
+     */
+    on(event: string, listener: (session: unknown, event: SidebarSessionEvent) => void): () => void
    /**
     * Register a lifecycle callback (DSH-vendored cordis): runs at plugin
     * activation; its returned cleanup runs at disposal.
@@ -4,18 +4,21 @@
 * harness's `session/tasks` push mirror (`tasksBySession` in the sessions
 * list feed). The routes:
 *
- * - 'tasks.output' — REPLAYS the output the MODEL has read so far from the
- *   owner session's OWN event log: `tool/call` rows of `task_output` name
- *   the task via `arguments.task_id`, and the paired `tool/result` rows
- *   carry the finalized content the model actually received. This touches
- *   NO DSH source (no peek seam, no consuming read): the model's
- *   `task_output` cursor is untouched by construction, and the pane stays
- *   empty until the agent reads the task.
+ * - 'tasks.output' — REPLAYS the output the MODEL has read so far for one
+ *   task. The source is the owner session's own event log: `tool/call` rows
+ *   of `task_output` name the task via `arguments.task_id`, and the paired
+ *   `tool/result` rows carry the finalized content the model received.
+ *   Because the session store's in-memory log can lag the live append feed
+ *   after a host restart (the store session stays frozen at its
+ *   rehydration boundary), the plugin ALSO mirrors task_output events from
+ *   the live `session/event` feed and merges both sources (deduped by seq).
+ *   This touches NO DSH source: the model's `task_output` cursor is never
+ *   consumed, and the pane stays empty until the agent reads the task.
 * - 'tasks.kill' — the registry's stock `kill` (a pristine DSH API),
 *   fenced by the owning session via the live agent caller. Absent registry
 *   → 503, mirroring the settings routes' optional-service downgrade.
 */
-import type { Context } from './context-types.ts'
+import type { Context, SidebarSessionEvent } from './context-types.ts'
 import { requireString, SidebarError } from './wire.ts'

 /** The two background-task routes of the sidebar API. */
@@ -50,7 +53,7 @@ function resultText(message: ToolResultMessageLike): string | undefined {
  for (const block of message.content) {
    if (block === null || typeof block !== 'object') continue
    const candidate = block as ToolResultBlockLike
-    if (candidate.type !== 'tool-result' || candidate.isError === true) continue
+    if (candidate.type !== 'tool-result') continue
    const inner = candidate.content
    if (!Array.isArray(inner)) continue
    for (const item of inner) {
@@ -64,16 +67,130 @@ function resultText(message: ToolResultMessageLike): string | undefined {
  return parts.length > 0 ? parts.join('\n') : undefined
 }

+/** Whether a tool/result is an error result (the inner block's isError flag). */
+function resultIsError(message: ToolResultMessageLike): boolean {
+  if (!Array.isArray(message.content)) return false
+  return message.content.some((block) => {
+    if (block === null || typeof block !== 'object') return false
+    return (block as ToolResultBlockLike).type === 'tool-result'
+      && (block as ToolResultBlockLike).isError === true
+  })
+}
+
 /** Whether a task_output result carries no new output — the controller's
 *  model-facing "(no new output)" body, noise for the human pane. */
 function isNoNewOutput(text: string): boolean {
  return text.startsWith('(no new output)')
 }

+/** One compact task_output trace (a tool/call or its paired tool/result). */
+interface TaskOutputTrace {
+  seq: number
+  kind: 'call' | 'result'
+  /** The tool call identity pairing the two rows. */
+  callId: string
+  /** tool/call: the task id parsed from the model arguments. */
+  taskId?: string
+  /** tool/result: the finalized text the model received. */
+  text?: string
+  /** tool/result: whether the result was an error (read counts, text skipped). */
+  isError?: boolean
+}
+
+/** Extract the task_output trace of one raw session event (undefined = unrelated). */
+function traceOf(event: SidebarSessionEvent): TaskOutputTrace | undefined {
+  if (event.type === 'tool/call') {
+    const data = event.data as { name?: unknown; callId?: unknown; arguments?: unknown }
+    if (data.name !== 'task_output' || typeof data.callId !== 'string') return undefined
+    let taskId: string | undefined
+    try {
+      const args = JSON.parse(typeof data.arguments === 'string' ? data.arguments : '') as { task_id?: unknown }
+      if (typeof args.task_id === 'string') taskId = args.task_id
+    } catch {
+      // Malformed model arguments: not a task_output pair.
+    }
+    if (taskId === undefined) return undefined
+    return { seq: event.seq, kind: 'call', callId: data.callId, taskId }
+  }
+  if (event.type === 'tool/result') {
+    const message = (event.data as { message?: unknown }).message as ToolResultMessageLike | undefined
+    if (message === undefined) return undefined
+    const callId = message.source?.callId
+    if (typeof callId !== 'string') return undefined
+    return {
+      seq: event.seq,
+      kind: 'result',
+      callId,
+      text: resultText(message),
+      isError: resultIsError(message),
+    }
+  }
+  return undefined
+}
+
+/** Per-session cap of mirrored live traces (a bounded, lossy ring). */
+const MIRROR_MAX_ENTRIES = 200
+
 /**
- * Build the tasks routes bound to the plugin context. `output` reads only
- * the session store; `kill` reads the tasks/agents services lazily and
- * degrades to a 503 when the deployment lacks the registry.
+ * The live task_output mirror: subscribes to the session append feed and
+ * caches the task_output traces the session store's own log can lag behind
+ * (after a host restart the store session stays frozen at its rehydration
+ * boundary, so `session.events` misses everything appended since — the very
+ * reads the pane exists to show). Zero DSH writes: the api-proxy pushes the
+ * same feed to browsers.
+ */
+function createTaskOutputMirror(ctx: Context): { entries(sessionId: string): readonly TaskOutputTrace[] } {
+  const perSession = new Map<string, TaskOutputTrace[]>()
+  // tool/call identities per session, so unrelated tool/result rows are
+  // never cached (only task_output results pair with a cached call).
+  const callIds = new Map<string, Set<string>>()
+  if (typeof ctx.on !== 'function') {
+    // Test doubles without the event API degrade to seed-only replay.
+    return { entries: () => [] }
+  }
+  const dispose = ctx.on('session/event', (session, event) => {
+    const sessionId = (session as { id?: unknown } | null)?.id
+    if (typeof sessionId !== 'string') return
+    if (event.type === 'tool/call') {
+      const trace = traceOf(event)
+      if (trace?.kind !== 'call') return
+      let ids = callIds.get(sessionId)
+      if (ids === undefined) callIds.set(sessionId, ids = new Set())
+      ids.add(trace.callId)
+      push(sessionId, trace)
+    } else if (event.type === 'tool/result') {
+      const trace = traceOf(event)
+      if (trace?.kind !== 'result') return
+      if (!callIds.get(sessionId)?.has(trace.callId)) return
+      push(sessionId, trace)
+    }
+  })
+  ctx.effect(() => dispose, 'dsh-better-sidebar: task-output event mirror')
+
+  const push = (sessionId: string, trace: TaskOutputTrace): void => {
+    let list = perSession.get(sessionId)
+    if (list === undefined) perSession.set(sessionId, list = [])
+    list.push(trace)
+    if (list.length > MIRROR_MAX_ENTRIES) {
+      const removed = list.splice(0, list.length - MIRROR_MAX_ENTRIES)
+      const ids = callIds.get(sessionId)
+      if (ids !== undefined) {
+        for (const entry of removed) {
+          if (entry.kind === 'call') ids.delete(entry.callId)
+        }
+        if (ids.size === 0) callIds.delete(sessionId)
+      }
+    }
+  }
+
+  return { entries: (sessionId) => perSession.get(sessionId) ?? [] }
+}
+
+/**
+ * Build the tasks routes bound to the plugin context. `output` merges the
+ * owner session's own event log with the live task_output mirror; `kill`
+ * reads the tasks/agents services lazily and degrades to a 503 when the
+ * deployment lacks the registry.
 * @param ctx - host plugin context.
 * @param outputLimit - response cap for one output replay in bytes; longer
 *   texts are sliced and flagged `truncated` (mirrors the fs.read cap).
@@ -81,6 +198,7 @@ function isNoNewOutput(text: string): boolean {
 export function buildTasksApi(ctx: Context, outputLimit: number): SidebarTasksRoutes {
  const tasks = ctx.get('tasks')
  const agents = ctx.get('agents')
+  const mirror = createTaskOutputMirror(ctx)
  /** The live caller whose session id the registry fence compares against. */
  const callerOf = (sessionId: string) => agents?.get(sessionId)
  /** Registry refusals become a 404 task-error; unknown and foreign ids are indistinguishable. */
@@ -90,32 +208,26 @@ export function buildTasksApi(ctx: Context, outputLimit: number): SidebarTasksRo
    output(payload) {
      const sessionId = requireString(payload, 'sessionId')
      const id = requireString(payload, 'id')
-      // One pass over the owner session's event log: tool/call rows first
-      // map callId → task_id (a call always precedes its result), then each
-      // matching tool/result contributes the finalized text the model saw.
-      const session = ctx.sessions.get(sessionId)
+      // Merge the store's event log (durable seed + whatever it received)
+      // with the live mirror, deduped by seq — a trace never double-counts.
+      const bySeq = new Map<number, TaskOutputTrace>()
+      for (const event of ctx.sessions.get(sessionId)?.events ?? []) {
+        const trace = traceOf(event)
+        if (trace !== undefined) bySeq.set(trace.seq, trace)
+      }
+      for (const trace of mirror.entries(sessionId)) bySeq.set(trace.seq, trace)
+      // Pair calls with results in seq order: the model's reads, oldest first.
      const taskOf = new Map<string, string>()
      const parts: string[] = []
      let read = false
-      for (const event of session?.events ?? []) {
-        if (event.type === 'tool/call') {
-          const data = event.data as { name?: unknown; callId?: unknown; arguments?: unknown }
-          if (data.name !== 'task_output' || typeof data.callId !== 'string') continue
-          try {
-            const args = JSON.parse(typeof data.arguments === 'string' ? data.arguments : '') as { task_id?: unknown }
-            if (typeof args.task_id === 'string') taskOf.set(data.callId, args.task_id)
-          } catch {
-            // Malformed model arguments: not a task_output pair.
-          }
-        } else if (event.type === 'tool/result') {
-          const message = (event.data as { message?: unknown }).message as ToolResultMessageLike | undefined
-          if (message === undefined) continue
-          const callId = message.source?.callId
-          if (typeof callId !== 'string') continue
-          if (taskOf.get(callId) !== id) continue
+      for (const trace of [...bySeq.values()].sort((left, right) => left.seq - right.seq)) {
+        if (trace.kind === 'call') {
+          if (trace.taskId !== undefined) taskOf.set(trace.callId, trace.taskId)
+        } else if (taskOf.get(trace.callId) === id) {
          read = true
-          const text = resultText(message)
-          if (text !== undefined && !isNoNewOutput(text)) parts.push(text)
+          if (trace.isError !== true && trace.text !== undefined && !isNoNewOutput(trace.text)) {
+            parts.push(trace.text)
+          }
        }
      }
      const text = parts.join('\n')