@co0ontty/wand 4.89.5 → 4.90.0

package/dist/structured-claude-adapter.js

@@ -6,6 +6,7 @@ import { startStructuredCli } from "./structured-exec-pump.js";
 import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { thinkingEffortToClaudeCliEffort } from "./structured-provider-common.js";
 import { ClaudeCliProtocolReducer } from "./structured-claude-protocol.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 const ROOT_FALLBACK_ALLOWED_TOOLS = [
     "Bash", "Edit", "Write", "Read", "Glob", "Grep", "NotebookEdit", "WebFetch", "WebSearch",
 ];
@@ -143,6 +144,7 @@ export class ClaudeCliRunner {
         const reducer = new ClaudeCliProtocolReducer(context.session);
         let killedForQuestion = false;
         let stdoutTail = "";
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file: "claude",
@@ -164,6 +166,7 @@ export class ClaudeCliRunner {
                     event = JSON.parse(trimmed);
                 }
                 catch {
+                    unparsedStdout = true;
                     return;
                 }
                 if (event && typeof event === "object" && !Array.isArray(event)) {
@@ -191,6 +194,15 @@ export class ClaudeCliRunner {
                 primaryError: reducer.errorText,
                 stopReason: killedForQuestion ? "ask-user-question" : undefined,
                 spawnError,
+                ...cliUnacceptedFacts({
+                    state: reducer.state,
+                    primaryError: reducer.errorText,
+                    protocolError: reducer.errorResultObserved,
+                    unparsedStdout,
+                    signal,
+                    progressed: reducer.assistantWorkObserved,
+                    ...(spawnError ? { spawnError } : {}),
+                }),
             }),
         });
     }

package/dist/structured-claude-protocol.d.ts

@@ -22,6 +22,10 @@ export declare class ClaudeCliProtocolReducer {
     askUserQuestionDetected: boolean;
     /** result 事件带 is_error 时的说明（如「API Error: 503 …」），作为这一轮的主错误。 */
     errorText: string | null;
+    /** 协议里出现过带 is_error 的 result 事件；没有本轮助手内容时才是可降级的执行前拒绝。 */
+    errorResultObserved: boolean;
+    /** 本轮真正跑出来的助手/工具内容，错误回显不算。 */
+    assistantWorkObserved: boolean;
     private readonly blocksByKey;
     private readonly keyOrder;
     private readonly taskMetaRegistry;

package/dist/structured-claude-protocol.js

@@ -123,6 +123,10 @@ export class ClaudeCliProtocolReducer {
     askUserQuestionDetected = false;
     /** result 事件带 is_error 时的说明（如「API Error: 503 …」），作为这一轮的主错误。 */
     errorText = null;
+    /** 协议里出现过带 is_error 的 result 事件；没有本轮助手内容时才是可降级的执行前拒绝。 */
+    errorResultObserved = false;
+    /** 本轮真正跑出来的助手/工具内容，错误回显不算。 */
+    assistantWorkObserved = false;
     blocksByKey = new Map();
     keyOrder = [];
     taskMetaRegistry = new Map();
@@ -150,8 +154,10 @@ export class ClaudeCliProtocolReducer {
             const stamped = parentId === null
                 ? stampSelfTask(extracted.content, this.taskMetaRegistry)
                 : tagSubagentBlocks(extracted.content, parentId, this.taskMetaRegistry);
-            if (stamped.length > 0)
+            if (stamped.length > 0) {
+                this.assistantWorkObserved = true;
                 this.upsertBlocks(key, stamped);
+            }
             if (!managed && extracted.content.some((block) => block.type === "tool_use" && block.name === "AskUserQuestion")) {
                 this.askUserQuestionDetected = true;
             }
@@ -181,15 +187,23 @@ export class ClaudeCliProtocolReducer {
             const stamped = parentId === null
                 ? stampParentTaskResults(collected, this.taskMetaRegistry)
                 : tagSubagentBlocks(collected, parentId, this.taskMetaRegistry);
-            if (stamped.length > 0)
+            if (stamped.length > 0) {
+                this.assistantWorkObserved = true;
                 this.upsertBlocks(`tool_result:${this.toolResultSequence++}`, stamped);
+            }
             return true;
         }
         if (event.type === "result") {
             if (typeof event.result === "string")
                 this.state.result = event.result.trim();
-            if (event.is_error === true && this.state.result)
-                this.errorText = this.state.result;
+            if (event.is_error === true) {
+                this.errorResultObserved = true;
+                const detail = this.state.result
+                    || (typeof event.subtype === "string" && event.subtype && event.subtype !== "success"
+                        ? `Claude 以 ${event.subtype} 结束，未产生任何输出。` : "");
+                if (detail)
+                    this.errorText = detail;
+            }
             this.state.model = extractClaudeModelName(event.modelUsage && typeof event.modelUsage === "object"
                 ? event.modelUsage
                 : undefined) ?? this.state.model;

package/dist/structured-codex-adapter.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { CodexProtocolReducer } from "./structured-codex-protocol.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 import { whichSync } from "./path-repair.js";
 import { thinkingEffortToCodexReasoningEffort, promptWithSystemFallback } from "./structured-provider-common.js";
 /** Build the stable CLI contract for a structured Codex turn. */
@@ -43,6 +44,7 @@ export class CodexRunner {
         const args = buildCodexArgs(context.session);
         const file = whichSync("codex", { env: context.env }) ?? "codex";
         const reducer = new CodexProtocolReducer(context.session);
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file,
@@ -65,6 +67,7 @@ export class CodexRunner {
                     event = JSON.parse(trimmed);
                 }
                 catch {
+                    unparsedStdout = true;
                     return;
                 }
                 if (event && typeof event === "object" && !Array.isArray(event)) {
@@ -81,6 +84,14 @@ export class CodexRunner {
                 primaryError: reducer.primaryError,
                 errors: reducer.errors,
                 spawnError,
+                ...cliUnacceptedFacts({
+                    state: reducer.state,
+                    primaryError: reducer.primaryError,
+                    protocolError: !!reducer.primaryError,
+                    unparsedStdout,
+                    signal,
+                    ...(spawnError ? { spawnError } : {}),
+                }),
             }),
         });
     }

package/dist/structured-exec-pump.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { appendDiagnosticTail, MAX_PROTOCOL_LINE_BYTES } from "./bounded-process-output.js";
 import { createUtf8TextDecoder, } from "./structured-exec-host.js";
 import { signalNameFromNumber } from "./signal-utils.js";
 export function startStructuredCli(options) {
@@ -8,41 +9,87 @@ export function startStructuredCli(options) {
         state: options.createState(),
         stderr: "",
         observer,
-        requestStop: () => source?.interrupt(),
+        requestStop: () => requestStop(),
     };
     let source = null;
-    let sourceReady;
     let lineBuffer = "";
+    let lineBytes = 0;
     let settled = false;
+    let stopRequested = false;
+    let stopDelivered = false;
+    // A pending spawn has no cancellable handle yet. Remember one request and
+    // deliver it once when ready; never install a self-referential placeholder.
+    function interruptSource() {
+        if (!source || stopDelivered)
+            return;
+        stopDelivered = true;
+        try {
+            source.interrupt();
+        }
+        catch { /* best-effort interruption */ }
+    }
+    function requestStop() {
+        if (settled || stopRequested)
+            return;
+        stopRequested = true;
+        interruptSource();
+    }
     let resolveCompletion;
-    const completion = new Promise((resolve) => {
+    let rejectCompletion;
+    const completion = new Promise((resolve, reject) => {
         resolveCompletion = resolve;
+        rejectCompletion = reject;
     });
-    const finish = (exitCode, signal, spawnError) => {
+    const finish = (exitCode, signal, spawnError, protocolError) => {
         if (settled)
             return;
         settled = true;
-        if (lineBuffer.trim())
-            options.processLine(lineBuffer, ctx);
-        lineBuffer = "";
-        resolveCompletion(options.finalize(ctx, exitCode, signal, spawnError));
+        try {
+            if (!protocolError && lineBuffer.trim())
+                options.processLine(lineBuffer, ctx);
+            const result = options.finalize(ctx, exitCode, signal, spawnError);
+            resolveCompletion(protocolError ? { ...result, exitCode: 1, primaryError: protocolError.message,
+                retryForbidden: true, failure: { kind: "runtime", delivery: "unknown", retryable: false } } : result);
+        }
+        catch (error) {
+            rejectCompletion(error);
+        }
+        finally {
+            lineBuffer = "";
+            lineBytes = 0;
+        }
     };
     const handleStdoutText = (text) => {
-        if (!text || !observer.isActive())
+        if (settled || !text || !observer.isActive())
             return;
         observer.onStdout?.(text);
         options.onStdoutText?.(text);
-        lineBuffer += text;
-        const lines = lineBuffer.split("\n");
-        lineBuffer = lines.pop() ?? "";
-        for (const line of lines)
-            options.processLine(line, ctx);
+        try {
+            const parts = text.split("\n");
+            for (let index = 0; index < parts.length; index++) {
+                const part = parts[index];
+                lineBytes += Buffer.byteLength(part, "utf8");
+                if (lineBytes > MAX_PROTOCOL_LINE_BYTES)
+                    throw new Error("CLI 协议单行超过 8 MiB 上限；本轮已停止，送达结果不能据此推定为未接受。");
+                lineBuffer += part;
+                if (index < parts.length - 1) {
+                    options.processLine(lineBuffer, ctx);
+                    lineBuffer = "";
+                    lineBytes = 0;
+                }
+            }
+        }
+        catch (error) {
+            // Settle the failure before kill can synchronously deliver a close event.
+            finish(1, null, undefined, error instanceof Error ? error : new Error(String(error)));
+            interruptSource();
+        }
     };
     const handleStderrText = (text) => {
-        if (!text || !observer.isActive())
+        if (settled || !text || !observer.isActive())
             return;
         observer.onStderr?.(text);
-        ctx.stderr += text;
+        ctx.stderr = appendDiagnosticTail(ctx.stderr, text);
     };
     const host = options.execHost;
     if (host?.persistent) {
@@ -54,23 +101,23 @@ export function startStructuredCli(options) {
             env: options.env,
             ...(options.stdinData !== undefined ? { stdinData: options.stdinData } : {}),
         };
-        let pendingInterrupt = null;
-        sourceReady = host.spawnStructured(request).then((handle) => {
-            source = { pid: handle.pid, interrupt: () => handle.interrupt() };
-            if (pendingInterrupt !== null)
-                handle.interrupt(pendingInterrupt);
-            wireRemoteHandle(handle, handleStdoutText, handleStderrText, finish);
-        }, () => {
+        const unavailable = () => {
+            source = null;
             // Daemon vanished between health check and spawn; surface as spawn error.
             finish(null, null, Object.assign(new Error(`terminal daemon unavailable for ${options.file}`), { code: "EDAEMON" }));
-        });
-        source = {
-            pid: null,
-            interrupt: (signal) => {
-                pendingInterrupt = signal ?? "SIGTERM";
-                void sourceReady.then(() => source?.interrupt());
-            },
         };
+        try {
+            void host.spawnStructured(request).then((handle) => {
+                source = { pid: handle.pid, interrupt: () => handle.interrupt() };
+                // Replay and subscribe before applying a pending external cancellation.
+                wireRemoteHandle(handle, handleStdoutText, handleStderrText, finish);
+                if (stopRequested && !settled)
+                    interruptSource();
+            }, unavailable);
+        }
+        catch {
+            unavailable();
+        }
     }
     else {
         const spawnProcess = options.spawnProcess ?? spawn;
@@ -87,8 +134,8 @@ export function startStructuredCli(options) {
         child.stderr?.on("data", (chunk) => handleStderrText(stderrDecoder.write(chunk)));
         child.on("error", (error) => finish(null, null, error));
         child.stdin?.on("error", (error) => {
+            requestStop();
             finish(null, null, error);
-            child.kill("SIGTERM");
         });
         child.on("close", (exitCode, signalName) => {
             handleStdoutText(stdoutDecoder.end());
@@ -97,7 +144,6 @@ export function startStructuredCli(options) {
         });
         if (wantsStdin)
             child.stdin?.end(options.stdinData);
-        sourceReady = Promise.resolve();
     }
     return {
         args: options.args,
@@ -106,12 +152,7 @@ export function startStructuredCli(options) {
             return source?.pid ?? null;
         },
         completion,
-        interrupt: () => {
-            try {
-                source?.interrupt();
-            }
-            catch { /* best-effort external interruption */ }
-        },
+        interrupt: requestStop,
     };
 }
 function wireRemoteHandle(handle, onStdout, onStderr, finish) {

package/dist/structured-failure.d.ts

@@ -5,6 +5,27 @@ export interface StructuredFailure {
     delivery: "rejected" | "accepted" | "unknown";
     retryable: boolean;
 }
+/** Extra facts a CLI-backed adapter adds to its finalize() result. */
+export type StructuredCliUnacceptedFacts = Pick<StructuredRunnerResult, "inputAccepted" | "rejection">;
+/**
+ * An in-band provider protocol error is the only evidence that lets a CLI adapter claim the input
+ * was never taken: the reply arrived from the provider itself, this turn produced no block, usage
+ * or cost, and stdout held nothing we could not account for as protocol traffic. Anything else —
+ * unparsed stdout, a signal, a spawn failure or work already done — stays unknown/accepted so no
+ * executed turn can be replayed on another candidate.
+ */
+export declare function cliUnacceptedFacts(input: {
+    state: StructuredRunnerTurnState;
+    primaryError: string | null;
+    /** The provider reported this error inside its own protocol stream. */
+    protocolError: boolean;
+    /** Stdout carried bytes the adapter could not parse as protocol events. */
+    unparsedStdout: boolean;
+    signal: NodeJS.Signals | null;
+    spawnError?: NodeJS.ErrnoException;
+    /** Adapters whose protocol echoes the failure text into `result` state what really ran. */
+    progressed?: boolean;
+}): StructuredCliUnacceptedFacts;
 /** Only call for a provider protocol error, never assistant text, stderr or a caught transport error. */
 export declare function classifyProviderRejection(message: string | null | undefined): ProviderRejectionKind | null;
 /** Monotonic observations matter: a final error can replace earlier usage or content. */

package/dist/structured-failure.js

@@ -1,3 +1,17 @@
+/**
+ * An in-band provider protocol error is the only evidence that lets a CLI adapter claim the input
+ * was never taken: the reply arrived from the provider itself, this turn produced no block, usage
+ * or cost, and stdout held nothing we could not account for as protocol traffic. Anything else —
+ * unparsed stdout, a signal, a spawn failure or work already done — stays unknown/accepted so no
+ * executed turn can be replayed on another candidate.
+ */
+export function cliUnacceptedFacts(input) {
+    if (!input.protocolError || input.unparsedStdout || input.signal || input.spawnError || !input.primaryError?.trim())
+        return {};
+    if (input.progressed ?? hasStructuredExecutionProgress(input.state))
+        return {};
+    return { inputAccepted: false, rejection: classifyProviderRejection(input.primaryError) ?? "model-unavailable" };
+}
 /** Only call for a provider protocol error, never assistant text, stderr or a caught transport error. */
 export function classifyProviderRejection(message) {
     const text = message?.trim() ?? "";

package/dist/structured-gemini-adapter.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { asRecord } from "./structured-content.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 import { promptWithSystemFallback } from "./structured-provider-common.js";
 /**
  * Gemini CLI 的会话写在 `~/.gemini/tmp/<project_hash>/chats/`。ID 找不回来时 headless
@@ -163,6 +164,8 @@ export class GeminiRunner {
             phase: "responding",
         };
         let primaryError = null;
+        let protocolError = false;
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file: "gemini",
@@ -180,10 +183,16 @@ export class GeminiRunner {
                 try {
                     const event = JSON.parse(line);
                     observer.onEvent?.(event);
-                    primaryError = applyGeminiEvent(state, event) ?? primaryError;
+                    const error = applyGeminiEvent(state, event);
+                    if (error) {
+                        primaryError = primaryError ?? error;
+                        protocolError = true;
+                    }
                     observer.onUpdate(state);
                 }
-                catch { /* Gemini stdout is NDJSON; ignore non-protocol noise. */ }
+                catch {
+                    unparsedStdout = true; /* Non-protocol stdout is not evidence of a safe refusal. */
+                }
             },
             finalize: (ctx, exitCode, signal, spawnError) => ({
                 state,
@@ -192,6 +201,7 @@ export class GeminiRunner {
                 stderr: ctx.stderr,
                 primaryError,
                 ...(spawnError ? { spawnError } : {}),
+                ...cliUnacceptedFacts({ state, primaryError, protocolError, unparsedStdout, signal, ...(spawnError ? { spawnError } : {}) }),
             }),
         });
     }

package/dist/structured-grok-adapter.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { asRecord } from "./structured-content.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 import { systemPromptArgs, thinkingEffortToGrokEffort } from "./structured-provider-common.js";
 function grokText(value) {
     if (typeof value === "string")
@@ -220,6 +221,8 @@ export class GrokRunner {
             model: context.session.selectedModel ?? context.session.structuredState?.model,
         };
         let primaryError = null;
+        let protocolError = false;
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file: "grok",
@@ -239,13 +242,20 @@ export class GrokRunner {
                 try {
                     const event = JSON.parse(trimmed);
                     observer.onEvent?.(event);
-                    primaryError = applyGrokEvent(state, event) ?? primaryError;
+                    const error = applyGrokEvent(state, event);
+                    if (error) {
+                        primaryError = primaryError ?? error;
+                        protocolError = true;
+                    }
                     observer.onUpdate(state);
                 }
-                catch { /* Grok diagnostics belong on stderr; ignore non-JSON stdout defensively. */ }
+                catch {
+                    unparsedStdout = true; /* Non-protocol stdout is not evidence of a safe refusal. */
+                }
             },
             finalize: (ctx, exitCode, signal, spawnError) => ({
                 state, exitCode, signal, stderr: ctx.stderr, primaryError, ...(spawnError ? { spawnError } : {}),
+                ...cliUnacceptedFacts({ state, primaryError, protocolError, unparsedStdout, signal, ...(spawnError ? { spawnError } : {}) }),
             }),
         });
     }

package/dist/structured-opencode-adapter.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { asRecord } from "./structured-content.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 import { thinkingEffortToOpenCodeVariant, promptWithSystemFallback } from "./structured-provider-common.js";
 function extractStructuredText(value) {
     if (typeof value === "string")
@@ -129,6 +130,8 @@ export class OpenCodeRunner {
             usage: undefined,
         };
         let primaryError = null;
+        let protocolError = false;
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file: "opencode",
@@ -151,12 +154,15 @@ export class OpenCodeRunner {
                     event = JSON.parse(trimmed);
                 }
                 catch {
+                    unparsedStdout = true;
                     return;
                 }
                 observer.onEvent?.(event);
                 const error = applyOpenCodeEvent(state, event);
-                if (error)
+                if (error) {
                     primaryError = error;
+                    protocolError = true;
+                }
                 observer.onUpdate(state);
             },
             finalize: (ctx, exitCode, signal, spawnError) => ({
@@ -166,6 +172,7 @@ export class OpenCodeRunner {
                 stderr: ctx.stderr,
                 primaryError,
                 ...(spawnError ? { spawnError } : {}),
+                ...cliUnacceptedFacts({ state, primaryError, protocolError, unparsedStdout, signal, ...(spawnError ? { spawnError } : {}) }),
             }),
         });
     }

package/dist/structured-qoder-adapter.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { ClaudeCliProtocolReducer } from "./structured-claude-protocol.js";
+import { cliUnacceptedFacts } from "./structured-failure.js";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { systemPromptArgs, thinkingEffortToQoderEffort } from "./structured-provider-common.js";
 export function buildQoderArgs(session, prompt) {
@@ -31,6 +32,8 @@ export class QoderRunner {
         const reducer = new ClaudeCliProtocolReducer(context.session);
         let stdoutTail = "";
         let primaryError = null;
+        let protocolError = false;
+        let unparsedStdout = false;
         return startStructuredCli({
             sessionId: context.session.id,
             file: "qodercli",
@@ -52,6 +55,7 @@ export class QoderRunner {
                     event = JSON.parse(trimmed);
                 }
                 catch {
+                    unparsedStdout = true;
                     return;
                 }
                 if (event && typeof event === "object" && !Array.isArray(event)) {
@@ -62,6 +66,7 @@ export class QoderRunner {
                             ? record.errors.filter((item) => typeof item === "string")
                             : [];
                         primaryError = errors.join("\n") || "Qoder CLI execution failed";
+                        protocolError = true;
                     }
                 }
                 if (reducer.apply(event, context.session.mode === "managed"))
@@ -80,6 +85,15 @@ export class QoderRunner {
                 stdoutTail,
                 primaryError,
                 ...(spawnError ? { spawnError } : {}),
+                ...cliUnacceptedFacts({
+                    state: reducer.state,
+                    primaryError,
+                    protocolError: protocolError || reducer.errorResultObserved,
+                    unparsedStdout,
+                    signal,
+                    progressed: reducer.assistantWorkObserved,
+                    ...(spawnError ? { spawnError } : {}),
+                }),
             }),
         });
     }

package/dist/structured-session-manager.d.ts

@@ -70,6 +70,8 @@ interface CreateStructuredSessionOptions {
  * 按 automationId 前缀识别，重启后照样生效。
  */
 export type StructuredRelayHandler = (sessionId: string, text: string) => void | Promise<void>;
+/** Quiet heartbeat is a status ping, not another copy of the transcript or uploaded avatar. */
+export declare function structuredQuietStatusData(session: SessionSnapshot): Record<string, unknown>;
 /**
  * 返回最近一次真正提交给结构化会话的用户输入。
  *
@@ -113,7 +115,6 @@ export declare class StructuredSessionManager {
     private readonly seenIdempotencyKeys;
     private readonly relayHandlers;
     private emitEvent;
-    private archiveTimer;
     /**
      * 静默期心跳：回合在飞且连续 TURN_QUIET_HEARTBEAT_MS 没有任何事件时，用现有的
      * status 事件重发一次权威快照（含最新 turn 锚点）。timer 只在 inFlight 期间存在。
@@ -122,6 +123,8 @@ export declare class StructuredSessionManager {
     private readonly topicCoordinator;
     private readonly nativeTitles;
     private readonly streamEmitTimers;
+    /** 员工候选链的「本轮还没开始执行」看门狗，按会话一个；首个协议事件或回合收敛即撤销。 */
+    private readonly candidateStartupWatchdogs;
     private readonly claudeCliRunner;
     private readonly codexRunner;
     private readonly openCodeRunner;
@@ -144,7 +147,6 @@ export declare class StructuredSessionManager {
     constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, runners?: StructuredSessionManagerRunners, execHost?: StructuredExecHost | undefined, decisionRuntime?: () => DecisionRuntimeAccess | null, openRouter?: OpenRouterFreeModelsService | undefined, 
     /** 「智能分配」专用的本地决策入口：只有真正能跑时才注入，没注入则用系统员工回退。 */
     autoAssignEvaluate?: () => DecisionRuntimeAccess["evaluate"]);
-    private archiveExpiredSessions;
     setEventEmitter(emitEvent: (event: ProcessEvent) => void): void;
     getCoreTurnStatus(): CoreStatus;
     /** Keep current turns running; new Pi inputs stay in the durable input queue. */
@@ -172,6 +174,7 @@ export declare class StructuredSessionManager {
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
     get(id: string): SessionSnapshot | null;
+    getSlim(id: string): SessionSnapshot | null;
     setSessionWorkspace(id: string, membership: Pick<SessionSnapshot, "workspaceId" | "workspaceTaskId">): void;
     setSessionTopic(id: string, title: string, description: string): SessionSnapshot;
     /** 归档只写标记，正在执行的回合和历史继续保留。 */
@@ -199,7 +202,12 @@ export declare class StructuredSessionManager {
     /** Consume only the exact failed request observed by dispatch, once, before a newer request can replace it. */
     consumeUnacceptedTeamFailure(id: string, requestId: string): StructuredFailure | null;
     private employeeCandidateModel;
-    /** Only an unstarted employee conversation may replay its explicitly rejected first input. */
+    /**
+     * A turn the provider rejected before it accepted any input may replay on the next candidate.
+     * Same-tool switches carry the conversation as it stood before this turn — history plus the native
+     * session it already had — so they also cover an already-started chat. A cross-tool switch cannot
+     * hand that context over, so it stays limited to conversations that have not produced a turn yet.
+     */
     private retryEmployeeCandidate;
     private throwUnacceptedInput;
     /** 往转发会话里追加别的参与者的发言。 */
@@ -315,21 +323,8 @@ export declare class StructuredSessionManager {
     private flushNextQueuedMessage;
     private emit;
     private incrementApprovalStats;
-    private runCodexStreaming;
-    private runGrokStreaming;
-    private runOpenCodeStreaming;
-    /**
-     * Spawn `claude -p --output-format stream-json` and parse NDJSON lines as
-     * they arrive, emitting incremental WebSocket events so the UI can render
-     * text / thinking / tool_use blocks in real-time.
-     *
-     * Permission handling:
-     * - Non-root + full-access/managed: --permission-mode bypassPermissions
-     * - Non-root + auto-edit: --permission-mode acceptEdits
-     * - Root: --permission-mode acceptEdits + --allowedTools (extends approval
-     *   outside CWD). stdin is always "ignore" — no ACP bidirectional control.
-     */
-    private runClaudeStreaming;
+    /** One turn lifecycle for every structured adapter; provider protocol reducers stay separate. */
+    private runStructuredStreaming;
     private compactContentBlocks;
     private buildCompletedAssistantMessages;
     /**