@co0ontty/wand 1.21.4 → 1.21.7

package/dist/structured-session-manager.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { prepareSessionWorktree } from "./git-worktree.js";
+import { truncateMessagesForTransport } from "./message-truncator.js";
 function defaultStructuredRunner(provider) {
     return provider === "codex" ? "codex-cli-exec" : "claude-cli-print";
 }
@@ -14,6 +15,11 @@ function defaultStructuredState(provider, runner = defaultStructuredRunner(provi
     };
 }
 const STREAM_EMIT_DEBOUNCE_MS = 16;
+/** Min interval between full saveSession() calls for an in-progress streaming turn.
+ *  saveSession serializes the entire messages array, so doing it on every NDJSON
+ *  event is N². close-path always calls saveSession unconditionally to take the
+ *  authoritative final snapshot. */
+const STREAM_SAVE_THROTTLE_MS = 200;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 function isRunningAsRoot() {
     return process.getuid?.() === 0 || process.geteuid?.() === 0;
@@ -82,14 +88,19 @@ function buildStructuredOutputPayload(snapshot) {
         structuredState: snapshot.structuredState,
     };
 }
-function buildIncrementalStructuredPayload(snapshot) {
+function buildIncrementalStructuredPayload(snapshot, cardDefaults) {
     const messages = snapshot.messages ?? [];
+    const lastTurn = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    // Streaming turn (index 0 here) is preserved verbatim; truncation only kicks
+    // in if the live response is already bigger than the transport threshold,
+    // matching the PTY runner's behaviour in process-manager.ts.
+    const lastMessage = lastTurn ? truncateMessagesForTransport([lastTurn], cardDefaults, 0)[0] : undefined;
     return {
         incremental: true,
         queuedMessages: snapshot.queuedMessages,
         sessionKind: "structured",
         structuredState: snapshot.structuredState,
-        lastMessage: messages.length > 0 ? messages[messages.length - 1] : undefined,
+        lastMessage,
         messageCount: messages.length,
     };
 }
@@ -99,7 +110,18 @@ export class StructuredSessionManager {
     logger;
     sessions = new Map();
     pendingChildren = new Map();
+    pendingSdkAbort = new Map();
     interruptedWith = new Map();
+    /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
+    lastStreamSaveAt = new Map();
+    /**
+     * Idempotency keys we've already accepted, mapped to their wall-clock timestamp.
+     * Android WebView 在进程恢复时偶尔会重发上一个未收到响应的 POST（HTTP/2 stream
+     * reset 等场景），客户端 JS 没有重试逻辑也拦不住。这里用 (sessionId, key) 永
+     * 久去重，重复就抛错让前端弹 toast 提示，**不**做任何处理。timestamp 仅用于
+     * map 大小溢出时按时间裁剪。
+     */
+    seenIdempotencyKeys = new Map();
     emitEvent = null;
     archiveTimer = null;
     constructor(storage, config, logger = null) {
@@ -162,6 +184,20 @@ export class StructuredSessionManager {
     setEventEmitter(emitEvent) {
         this.emitEvent = emitEvent;
     }
+    /**
+     * In-memory snapshot is updated unconditionally; the SQLite write is rate-
+     * limited to once per STREAM_SAVE_THROTTLE_MS. Caller must still invoke
+     * `storage.saveSession` directly at terminal events (close / failure) so the
+     * final state is durable.
+     */
+    saveStreamingSnapshot(snapshot) {
+        const now = Date.now();
+        const last = this.lastStreamSaveAt.get(snapshot.id) ?? 0;
+        if (now - last < STREAM_SAVE_THROTTLE_MS)
+            return;
+        this.lastStreamSaveAt.set(snapshot.id, now);
+        this.storage.saveSession(snapshot);
+    }
     list() {
         return Array.from(this.sessions.values())
             .map(withSummary)
@@ -234,7 +270,23 @@ export class StructuredSessionManager {
         const prompt = input.trim();
         if (!prompt)
             return session;
-        console.log("[WAND] StructuredSessionManager.sendMessage id:", id, "inFlight:", session.structuredState?.inFlight, "hasPendingChild:", this.pendingChildren.has(id), "status:", session.status);
+        if (opts?.idempotencyKey) {
+            const mapKey = `${id}:${opts.idempotencyKey}`;
+            if (this.seenIdempotencyKeys.has(mapKey)) {
+                console.log("[WAND] sendMessage: duplicate idempotency key rejected", { id, key: opts.idempotencyKey });
+                const err = new Error("检测到重复发送，已拦截。");
+                err.code = "duplicate_idempotency_key";
+                throw err;
+            }
+            this.seenIdempotencyKeys.set(mapKey, Date.now());
+            // 防止 map 无限增长：超过 1024 条时按时间裁掉一半最早的
+            if (this.seenIdempotencyKeys.size > 1024) {
+                const sorted = Array.from(this.seenIdempotencyKeys.entries()).sort((a, b) => a[1] - b[1]);
+                for (let i = 0; i < sorted.length / 2; i++) {
+                    this.seenIdempotencyKeys.delete(sorted[i][0]);
+                }
+            }
+        }
         if (session.structuredState?.inFlight) {
             const child = this.pendingChildren.get(id);
             const childAlive = child && !child.killed && child.exitCode === null;
@@ -261,6 +313,9 @@ export class StructuredSessionManager {
                     child.kill("SIGTERM");
                 }
                 catch (_err) { /* ignore */ }
+                const sdkAbort = this.pendingSdkAbort.get(id);
+                if (sdkAbort)
+                    sdkAbort.abort();
                 return session;
             }
             else {
@@ -329,6 +384,9 @@ export class StructuredSessionManager {
             if ((updated.provider ?? "claude") === "codex") {
                 await this.runCodexStreaming(id, updated, prompt);
             }
+            else if (this.config.structuredRunner === "sdk") {
+                await this.runClaudeSdkStreaming(id, updated, claudePrompt);
+            }
             else {
                 await this.runClaudeStreaming(id, updated, claudePrompt);
             }
@@ -439,6 +497,11 @@ export class StructuredSessionManager {
             child.kill();
             this.pendingChildren.delete(id);
         }
+        const sdkAbort = this.pendingSdkAbort.get(id);
+        if (sdkAbort) {
+            sdkAbort.abort();
+            this.pendingSdkAbort.delete(id);
+        }
         const stopped = {
             ...session,
             status: "stopped",
@@ -462,7 +525,13 @@ export class StructuredSessionManager {
             child.kill();
             this.pendingChildren.delete(id);
         }
+        const sdkAbort = this.pendingSdkAbort.get(id);
+        if (sdkAbort) {
+            sdkAbort.abort();
+            this.pendingSdkAbort.delete(id);
+        }
         this.sessions.delete(id);
+        this.lastStreamSaveAt.delete(id);
         this.storage.deleteSession(id);
         this.logger?.deleteSession(id);
     }
@@ -526,6 +595,17 @@ export class StructuredSessionManager {
         }
         catch (error) {
             console.error("[WAND] flushNextQueuedMessage failed:", error);
+            // 发送失败时把消息放回队首，避免永久丢失
+            const afterFail = this.sessions.get(sessionId);
+            if (afterFail) {
+                const rescued = {
+                    ...afterFail,
+                    queuedMessages: [nextInput, ...(afterFail.queuedMessages ?? [])],
+                };
+                this.sessions.set(sessionId, rescued);
+                this.storage.saveSession(rescued);
+                this.emitStructuredSnapshot(rescued);
+            }
         }
     }
     emit(event) {
@@ -630,14 +710,12 @@ export class StructuredSessionManager {
     runCodexStreaming(sessionId, session, prompt) {
         return new Promise((resolve, reject) => {
             const args = this.buildCodexArgs(session);
-            console.log("[WAND] runCodexStreaming sessionId:", sessionId, "mode:", session.mode, "threadId:", session.claudeSessionId);
             const spawnedAt = new Date().toISOString();
             const child = spawn("codex", args, {
                 cwd: session.cwd,
                 env: process.env,
                 stdio: ["pipe", "pipe", "pipe"],
             });
-            console.log("[WAND] spawned codex exec pid:", child.pid, "args:", args.join(" "));
             this.logger?.appendStructuredSpawn(sessionId, {
                 kind: "codex-exec",
                 provider: "codex",
@@ -674,7 +752,7 @@ export class StructuredSessionManager {
                 const current = this.sessions.get(sessionId);
                 if (!current)
                     return;
-                this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current) });
+                this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}) });
             };
             const scheduleEmit = () => {
                 if (!emitTimer)
@@ -708,7 +786,7 @@ export class StructuredSessionManager {
                     },
                 };
                 this.sessions.set(sessionId, patched);
-                this.storage.saveSession(patched);
+                this.saveStreamingSnapshot(patched);
             };
             const processLine = (line) => {
                 const trimmed = line.trim();
@@ -755,10 +833,8 @@ export class StructuredSessionManager {
                 }
                 if (parsed?.type === "error") {
                     const message = typeof parsed.message === "string" ? parsed.message : "";
-                    if (message) {
-                        console.log("[WAND] codex error event:", message.slice(0, 300));
+                    if (message)
                         codexErrors.push(message);
-                    }
                     return;
                 }
                 if (parsed?.type === "turn.failed") {
@@ -766,7 +842,6 @@ export class StructuredSessionManager {
                     const message = (errObj && typeof errObj.message === "string" && errObj.message)
                         || (typeof parsed.message === "string" ? parsed.message : "")
                         || "codex turn failed";
-                    console.log("[WAND] codex turn.failed:", message.slice(0, 300));
                     codexTurnFailed = message;
                     return;
                 }
@@ -786,8 +861,8 @@ export class StructuredSessionManager {
                 stderr += text;
             });
             child.on("error", (error) => {
-                console.log("[WAND] codex exec child error:", error.message);
                 this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
                 if (emitTimer)
                     clearTimeout(emitTimer);
                 this.logger?.appendStructuredSpawn(sessionId, {
@@ -800,8 +875,8 @@ export class StructuredSessionManager {
                 reject(error);
             });
             child.on("close", (code) => {
-                console.log("[WAND] codex exec child close code:", code, "stderr:", stderr.substring(0, 200), "errors:", codexErrors.length, "turnFailed:", codexTurnFailed?.slice(0, 100));
                 this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
                 if (lineBuf.trim()) {
                     processLine(lineBuf);
                     lineBuf = "";
@@ -823,10 +898,13 @@ export class StructuredSessionManager {
                     reject(new Error("Session removed during execution."));
                     return;
                 }
+                // 主动中断时（interruptedWith 里有新消息），不走失败路径
+                const interruptedByUser = this.interruptedWith.has(sessionId);
+                const interruptPrompt = this.interruptedWith.get(sessionId);
                 // codex 把模型/网络/沙箱等错误写到 stdout 的 NDJSON 流（type: error / turn.failed），
                 // 而不是 stderr。我们以 turn.failed 的 message 为准，其次是最后一个 error 事件。
                 const codexFailed = codexTurnFailed !== null;
-                if (codexFailed || (code !== 0 && code !== null)) {
+                if ((codexFailed || (code !== 0 && code !== null)) && !interruptedByUser) {
                     const errorText = (codexTurnFailed && codexTurnFailed.trim())
                         || (codexErrors.length > 0 ? codexErrors[codexErrors.length - 1] : "")
                         || stderr.trim()
@@ -851,14 +929,16 @@ export class StructuredSessionManager {
                     msgs[msgs.length - 1] = assistantTurn;
                 else
                     msgs.push(assistantTurn);
+                const keepRunning = !!interruptPrompt;
                 const finished = {
                     ...current,
-                    status: "idle",
-                    exitCode: 0,
-                    endedAt: new Date().toISOString(),
+                    status: keepRunning ? "running" : "idle",
+                    exitCode: keepRunning ? null : 0,
+                    endedAt: keepRunning ? null : new Date().toISOString(),
                     output: turnState.result,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
+                    queuedMessages: interruptPrompt ? [] : current.queuedMessages,
                     pendingEscalation: null,
                     permissionBlocked: false,
                     structuredState: {
@@ -872,7 +952,36 @@ export class StructuredSessionManager {
                 this.sessions.set(sessionId, finished);
                 this.storage.saveSession(finished);
                 this.emitStructuredSnapshot(finished);
-                this.emitStructuredSnapshot(finished, "ended");
+                if (!keepRunning) {
+                    this.emitStructuredSnapshot(finished, "ended");
+                }
+                if (interruptPrompt) {
+                    this.interruptedWith.delete(sessionId);
+                    resolve();
+                    setImmediate(() => {
+                        this.sendMessage(sessionId, interruptPrompt).catch((err) => {
+                            console.error("[WAND] codex interrupt-and-send failed:", err);
+                            const afterFail = this.sessions.get(sessionId);
+                            if (afterFail) {
+                                const recovered = {
+                                    ...afterFail,
+                                    status: "idle",
+                                    exitCode: 0,
+                                    endedAt: new Date().toISOString(),
+                                    structuredState: {
+                                        ...afterFail.structuredState,
+                                        inFlight: false,
+                                        activeRequestId: null,
+                                    },
+                                };
+                                this.sessions.set(sessionId, recovered);
+                                this.storage.saveSession(recovered);
+                                this.emitStructuredSnapshot(recovered);
+                            }
+                        });
+                    });
+                    return;
+                }
                 resolve();
                 setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
             });
@@ -895,7 +1004,6 @@ export class StructuredSessionManager {
     runClaudeStreaming(sessionId, session, prompt) {
         return new Promise((resolve, reject) => {
             const args = ["-p", "--verbose", "--output-format", "stream-json"];
-            console.log("[WAND] runClaudeStreaming sessionId:", sessionId, "mode:", session.mode, "claudeSessionId:", session.claudeSessionId);
             // Add permission args based on mode + autoApprovePermissions toggle
             const permArgs = this.buildPermissionArgs(session.mode, session.autoApprovePermissions ?? false);
             args.push(...permArgs);
@@ -937,7 +1045,6 @@ export class StructuredSessionManager {
                 env: process.env,
                 stdio: ["pipe", "pipe", "pipe"],
             });
-            console.log("[WAND] spawned claude -p pid:", child.pid, "args:", args.join(" "));
             this.logger?.appendStructuredSpawn(sessionId, {
                 kind: "claude-print",
                 provider: "claude",
@@ -958,6 +1065,30 @@ export class StructuredSessionManager {
                 model: undefined,
                 usage: undefined,
             };
+            // claude -p --output-format stream-json 在同一条消息流式生成期间会重复
+            // emit 同一个 message.id 的 "assistant" 事件，每次 content 略多一些；子
+            // agent 流（Task 工具）则会插入若干 parent_tool_use_id 不同的 message.id。
+            // 朴素的 push(...content) 会让早期片段被反复合并复制，最终被 compact 出
+            // 怪异结果，导致 UI 上 tool_use / 子 agent 输出"显示一下就消失"。
+            // 这里按 (message.id) 去重，相同 id 视作同一消息的更新覆盖；tool_result
+            // 用单调递增的合成 key 顺序追加。每次事件后用插入顺序重建 turnState.blocks。
+            const blocksByKey = new Map();
+            const keyOrder = [];
+            let toolResultSeq = 0;
+            const upsertBlocks = (key, blocks) => {
+                if (!blocksByKey.has(key))
+                    keyOrder.push(key);
+                blocksByKey.set(key, blocks);
+            };
+            const rebuildTurnBlocks = () => {
+                const flat = [];
+                for (const key of keyOrder) {
+                    const entry = blocksByKey.get(key);
+                    if (entry && entry.length > 0)
+                        flat.push(...entry);
+                }
+                turnState.blocks = flat;
+            };
             // Line buffer for NDJSON: chunks from stdout may split mid-line.
             let lineBuf = "";
             // Debounce output events to avoid flooding the WebSocket.
@@ -977,7 +1108,7 @@ export class StructuredSessionManager {
                 this.emit({
                     type: "output",
                     sessionId,
-                    data: buildIncrementalStructuredPayload(current),
+                    data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}),
                 });
             };
             const scheduleEmit = () => {
@@ -1016,8 +1147,9 @@ export class StructuredSessionManager {
                 };
                 this.sessions.set(sessionId, patched);
                 // Persist streaming progress so a server restart does not roll back the
-                // latest assistant turn to the pre-stream snapshot.
-                this.storage.saveSession(patched);
+                // latest assistant turn to the pre-stream snapshot. Throttled because
+                // saveSession serializes the full messages array.
+                this.saveStreamingSnapshot(patched);
             };
             const processLine = (line) => {
                 const trimmed = line.trim();
@@ -1033,8 +1165,15 @@ export class StructuredSessionManager {
                 this.logger?.appendStreamEvent(sessionId, parsed);
                 if (parsed && parsed.type === "assistant" && parsed.message) {
                     const extracted = this.extractAssistantMessage(parsed.message);
+                    // 用 message.id 作为 key：claude -p 流式重发同一条消息时整段覆盖
+                    // （而不是与早期片段累加），子 agent 的不同消息 id 各占一格、保留
+                    // 父子完整顺序。没有 id 时退化为合成 key 走追加模式。
+                    const msgId = typeof parsed.message.id === "string" && parsed.message.id
+                        ? `assistant:${parsed.message.id}`
+                        : `assistant:anon:${keyOrder.length}`;
                     if (extracted.content.length > 0) {
-                        turnState.blocks.push(...extracted.content);
+                        upsertBlocks(msgId, extracted.content);
+                        rebuildTurnBlocks();
                     }
                     // NOTE: usage from streaming "assistant" events contains partial/incremental
                     // token counts (e.g. output_tokens=1 during streaming) and is NOT accurate.
@@ -1058,9 +1197,11 @@ export class StructuredSessionManager {
                     return;
                 }
                 if (parsed && parsed.type === "user" && parsed.message && Array.isArray(parsed.message.content)) {
+                    // tool_result 没有自身 id，按到达顺序用合成 key 追加（永远不被覆盖）。
+                    const collected = [];
                     for (const block of parsed.message.content) {
                         if (block && block.type === "tool_result") {
-                            turnState.blocks.push({
+                            collected.push({
                                 type: "tool_result",
                                 tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
                                 content: this.normalizeToolResultContent(block.content),
@@ -1068,6 +1209,10 @@ export class StructuredSessionManager {
                             });
                         }
                     }
+                    if (collected.length > 0) {
+                        upsertBlocks(`tool_result:${toolResultSeq++}`, collected);
+                        rebuildTurnBlocks();
+                    }
                     syncSnapshot();
                     scheduleEmit();
                     return;
@@ -1103,8 +1248,8 @@ export class StructuredSessionManager {
                 stderr += text;
             });
             child.on("error", (error) => {
-                console.log("[WAND] claude -p child error:", error.message);
                 this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
                 if (emitTimer)
                     clearTimeout(emitTimer);
                 this.logger?.appendStructuredSpawn(sessionId, {
@@ -1117,8 +1262,8 @@ export class StructuredSessionManager {
                 reject(error);
             });
             child.on("close", (code) => {
-                console.log("[WAND] claude -p child close code:", code, "stderr:", stderr.substring(0, 200));
                 this.pendingChildren.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
                 this.logger?.appendStructuredSpawn(sessionId, {
                     kind: "claude-print-close",
                     pid: child.pid ?? null,
@@ -1140,7 +1285,11 @@ export class StructuredSessionManager {
                     reject(new Error("Session removed during execution."));
                     return;
                 }
-                if (code !== 0 && code !== null) {
+                // 如果是用户主动中断（interruptedWith 里有新消息），claude -p 收到 SIGTERM 后
+                // 可能以非零 exit code 退出（内部 handler 调了 exit(1)）。这种情况属于正常
+                // 中断流程，不应走失败路径——后续 interruptedWith 逻辑会发送新消息。
+                const interruptedByUser = this.interruptedWith.has(sessionId);
+                if (code !== 0 && code !== null && !interruptedByUser) {
                     const errorText = stderr.trim() || `claude -p exited with code ${code}`;
                     const failureTurn = {
                         role: "assistant",
@@ -1232,11 +1381,28 @@ export class StructuredSessionManager {
                 // 用户中断当前回复：保存部分回复后立即发送新消息。
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
-                    console.log("[WAND] interrupt-and-send for session:", sessionId, "prompt:", interruptPrompt.substring(0, 50));
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((err) => {
                             console.error("[WAND] interrupt-and-send failed:", err);
+                            // 续接失败：把状态回滚到 idle，让用户可以重新输入而不是卡在 running 状态
+                            const afterFail = this.sessions.get(sessionId);
+                            if (afterFail) {
+                                const recovered = {
+                                    ...afterFail,
+                                    status: "idle",
+                                    exitCode: 0,
+                                    endedAt: new Date().toISOString(),
+                                    structuredState: {
+                                        ...afterFail.structuredState,
+                                        inFlight: false,
+                                        activeRequestId: null,
+                                    },
+                                };
+                                this.sessions.set(sessionId, recovered);
+                                this.storage.saveSession(recovered);
+                                this.emitStructuredSnapshot(recovered);
+                            }
                         });
                     });
                     return;
@@ -1247,7 +1413,6 @@ export class StructuredSessionManager {
                 // so the plan is actually carried out.
                 const lastToolUse = [...turnState.blocks].reverse().find((b) => b.type === "tool_use");
                 if (lastToolUse && lastToolUse.name === "ExitPlanMode" && turnState.sessionId) {
-                    console.log("[WAND] ExitPlanMode detected – auto-continuing plan execution for session:", sessionId);
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, "Plan approved. Proceed with the implementation.").catch((err) => {
@@ -1264,6 +1429,409 @@ export class StructuredSessionManager {
         });
     }
     // ---------------------------------------------------------------------------
+    // Streaming claude-agent-sdk execution
+    // ---------------------------------------------------------------------------
+    /**
+     * Use @anthropic-ai/claude-agent-sdk instead of spawning claude -p directly.
+     * The SDK still spawns the claude binary but provides typed AsyncGenerator<SDKMessage>
+     * messages, so we skip NDJSON parsing. Options are 1:1 with the CLI flags.
+     *
+     * Streaming is enabled via includePartialMessages: true — the SDK emits
+     * SDKPartialAssistantMessage (type: "stream_event") with BetaRawMessageStreamEvent
+     * payloads for incremental text/thinking/tool_use updates, followed by a final
+     * SDKAssistantMessage with the authoritative complete content.
+     */
+    runClaudeSdkStreaming(sessionId, session, prompt) {
+        return new Promise((resolve, reject) => {
+            void this._runClaudeSdkStreamingAsync(sessionId, session, prompt).then(resolve, reject);
+        });
+    }
+    async _runClaudeSdkStreamingAsync(sessionId, session, prompt) {
+        let sdkQuery;
+        try {
+            const sdkMod = await import("@anthropic-ai/claude-agent-sdk");
+            sdkQuery = sdkMod.query;
+        }
+        catch {
+            throw new Error("@anthropic-ai/claude-agent-sdk 未安装，无法使用 SDK runner。");
+        }
+        const abortController = new AbortController();
+        this.pendingSdkAbort.set(sessionId, abortController);
+        const isManaged = session.mode === "managed";
+        let killedForAskUserQuestion = false;
+        // Derive permission mode (mirrors buildPermissionArgs logic)
+        const shouldBypass = (session.autoApprovePermissions ?? false) || session.mode === "full-access" || session.mode === "managed";
+        const shouldAcceptEdits = session.mode === "auto-edit";
+        let permissionMode = "default";
+        let allowedToolsForRoot;
+        if (!isRunningAsRoot()) {
+            if (shouldBypass)
+                permissionMode = "bypassPermissions";
+            else if (shouldAcceptEdits)
+                permissionMode = "acceptEdits";
+        }
+        else {
+            // Root: acceptEdits + allowedTools (same workaround as CLI runner)
+            if (shouldBypass || shouldAcceptEdits) {
+                permissionMode = "acceptEdits";
+                allowedToolsForRoot = ["Bash", "Edit", "Write", "Read", "Glob", "Grep", "NotebookEdit", "WebFetch", "WebSearch"];
+            }
+        }
+        // System prompt additions
+        const isChinese = this.config.language?.trim() === "中文";
+        const systemPromptParts = [];
+        if (isManaged) {
+            systemPromptParts.push(isChinese
+                ? "你正在完全托管的自主模式下运行。用户可能无法及时回复问题或确认。你必须独立做出所有决策——自行选择最佳方案，而不是向用户询问偏好、确认或澄清。如果有多种可行方案，选择你认为最合适的并继续执行。除非任务本身存在根本性的歧义且无法合理推断，否则不要等待用户输入。果断行动，自主决策。"
+                : "You are running in a fully managed, autonomous mode. The user may not be available to respond to questions or confirmations in a timely manner. You MUST make all decisions independently — choose the best approach yourself instead of asking the user for preferences, confirmations, or clarifications. If multiple approaches are viable, pick the one you judge most appropriate and proceed. Never block on user input unless the task is fundamentally ambiguous and cannot be reasonably inferred. Be decisive and self-directed.");
+        }
+        const language = this.config.language?.trim();
+        if (language) {
+            systemPromptParts.push(isChinese
+                ? "请使用中文回复。所有解释、注释和对话文本都使用中文。"
+                : `Please respond in ${language}. Use ${language} for all your explanations, comments, and conversational text.`);
+        }
+        const sdkOptions = {
+            cwd: session.cwd,
+            abortController,
+            permissionMode,
+            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(allowedToolsForRoot ? { allowedTools: allowedToolsForRoot } : {}),
+            ...(isManaged ? { disallowedTools: ["AskUserQuestion"] } : {}),
+            includePartialMessages: true,
+            ...(systemPromptParts.length > 0 ? { appendSystemPrompt: systemPromptParts.join("\n\n") } : {}),
+        };
+        if (session.claudeSessionId)
+            sdkOptions.resume = session.claudeSessionId;
+        const modelChoice = session.selectedModel?.trim();
+        if (modelChoice && modelChoice !== "default")
+            sdkOptions.model = modelChoice;
+        const turnState = {
+            blocks: [],
+            result: "",
+            sessionId: null,
+            model: undefined,
+            usage: undefined,
+        };
+        // Tracks in-progress streaming blocks keyed by content_block index from stream_event.
+        // The map is cleared whenever a complete `assistant` message arrives — its blocks
+        // are then promoted into `finalizedBlocks` below.
+        const streamingBlockByIndex = new Map();
+        // Blocks from messages that have already completed within this turn — including
+        // the parent assistant's prior messages, every subagent assistant message, and
+        // every tool_result. Subagent (Task tool) flows produce many assistant messages
+        // back-to-back; without this list, each new streaming message would visually
+        // erase everything that came before it in the same turn.
+        const finalizedBlocks = [];
+        let emitTimer = null;
+        const flushEmit = () => {
+            if (emitTimer) {
+                clearTimeout(emitTimer);
+                emitTimer = null;
+            }
+            const current = this.sessions.get(sessionId);
+            if (!current)
+                return;
+            this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}) });
+        };
+        const scheduleEmit = () => {
+            if (!emitTimer)
+                emitTimer = setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS);
+        };
+        // Rebuild ContentBlock[] from finalized history + the in-progress streaming map.
+        // Returning only the streaming blocks would drop every prior parent/subagent
+        // message in this turn (the original disappearing-output bug).
+        const rebuildStreamingBlocks = () => {
+            const sorted = [...streamingBlockByIndex.entries()].sort((a, b) => a[0] - b[0]);
+            const streaming = [];
+            for (const [, sb] of sorted) {
+                if (sb.type === "text") {
+                    streaming.push({ type: "text", text: sb.text });
+                }
+                else if (sb.type === "thinking") {
+                    streaming.push({ type: "thinking", thinking: sb.thinking });
+                }
+                else if (sb.type === "tool_use" && sb.id && sb.name) {
+                    let input = {};
+                    if (sb.finalized && sb.partialInput) {
+                        try {
+                            input = JSON.parse(sb.partialInput);
+                        }
+                        catch { /* partial json */ }
+                    }
+                    streaming.push({ type: "tool_use", id: sb.id, name: sb.name, input });
+                }
+            }
+            return [...finalizedBlocks, ...streaming];
+        };
+        const syncSnapshot = () => {
+            const current = this.sessions.get(sessionId);
+            if (!current)
+                return;
+            const inProgressTurn = {
+                role: "assistant",
+                content: this.compactContentBlocks([...turnState.blocks], turnState.result),
+                usage: turnState.usage,
+            };
+            const msgs = [...(current.messages ?? [])];
+            const lastMsg = msgs[msgs.length - 1];
+            if (lastMsg && lastMsg.role === "assistant")
+                msgs[msgs.length - 1] = inProgressTurn;
+            else
+                msgs.push(inProgressTurn);
+            const patched = {
+                ...current,
+                claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+                messages: msgs,
+                output: turnState.result || current.output,
+                structuredState: {
+                    ...current.structuredState,
+                    model: turnState.model ?? current.structuredState?.model,
+                },
+            };
+            this.sessions.set(sessionId, patched);
+            this.saveStreamingSnapshot(patched);
+        };
+        const spawnedAt = new Date().toISOString();
+        this.logger?.appendStructuredSpawn(sessionId, {
+            kind: "claude-sdk",
+            provider: "claude",
+            cwd: session.cwd,
+            permissionMode,
+            prompt: prompt.slice(0, 2048),
+            promptLength: prompt.length,
+            claudeSessionId: session.claudeSessionId,
+            spawnedAt,
+        });
+        try {
+            for await (const msg of sdkQuery({ prompt, options: sdkOptions })) {
+                if (abortController.signal.aborted)
+                    break;
+                // Incremental streaming events (opt-in via includePartialMessages: true)
+                if (msg.type === "stream_event") {
+                    const ev = msg.event;
+                    if (ev.type === "content_block_start") {
+                        const cb = ev.content_block;
+                        const blockType = cb.type;
+                        if (blockType === "text" || blockType === "thinking" || blockType === "tool_use") {
+                            streamingBlockByIndex.set(ev.index, {
+                                type: blockType,
+                                id: typeof cb.id === "string" ? cb.id : undefined,
+                                name: typeof cb.name === "string" ? cb.name : undefined,
+                                text: typeof cb.text === "string" ? cb.text : "",
+                                thinking: typeof cb.thinking === "string" ? cb.thinking : "",
+                                partialInput: "",
+                                finalized: false,
+                            });
+                            turnState.blocks = rebuildStreamingBlocks();
+                            syncSnapshot();
+                            scheduleEmit();
+                        }
+                    }
+                    else if (ev.type === "content_block_delta") {
+                        const sb = streamingBlockByIndex.get(ev.index);
+                        if (sb) {
+                            const delta = ev.delta;
+                            if (delta.type === "text_delta" && typeof delta.text === "string") {
+                                sb.text += delta.text;
+                                turnState.result = sb.text;
+                            }
+                            else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+                                sb.thinking += delta.thinking;
+                            }
+                            else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+                                sb.partialInput += delta.partial_json;
+                            }
+                            turnState.blocks = rebuildStreamingBlocks();
+                            syncSnapshot();
+                            scheduleEmit();
+                        }
+                    }
+                    else if (ev.type === "content_block_stop") {
+                        const sb = streamingBlockByIndex.get(ev.index);
+                        if (sb) {
+                            sb.finalized = true;
+                            turnState.blocks = rebuildStreamingBlocks();
+                            syncSnapshot();
+                            scheduleEmit();
+                        }
+                    }
+                    continue;
+                }
+                // Complete assistant turn — promote streaming content into the finalized
+                // history so subsequent messages (subagents, follow-up parent messages)
+                // append to it instead of erasing it.
+                if (msg.type === "assistant") {
+                    const assistantMsg = msg;
+                    const extracted = this.extractAssistantMessage(assistantMsg.message);
+                    finalizedBlocks.push(...extracted.content);
+                    streamingBlockByIndex.clear();
+                    turnState.blocks = rebuildStreamingBlocks();
+                    if (assistantMsg.session_id)
+                        turnState.sessionId = assistantMsg.session_id;
+                    syncSnapshot();
+                    scheduleEmit();
+                    // Non-managed mode: detect AskUserQuestion, abort to let user answer
+                    if (!isManaged && !killedForAskUserQuestion) {
+                        const askBlock = extracted.content.find((b) => b.type === "tool_use" && b.name === "AskUserQuestion");
+                        if (askBlock) {
+                            killedForAskUserQuestion = true;
+                            flushEmit();
+                            abortController.abort();
+                        }
+                    }
+                    continue;
+                }
+                // Tool results fed back from the claude subprocess (parent's view of a
+                // tool call, or a subagent's tool_result during Task execution).
+                if (msg.type === "user") {
+                    const userMsg = msg;
+                    const content = Array.isArray(userMsg.message?.content) ? userMsg.message.content : [];
+                    for (const block of content) {
+                        const b = block;
+                        if (b?.type === "tool_result") {
+                            finalizedBlocks.push({
+                                type: "tool_result",
+                                tool_use_id: typeof b.tool_use_id === "string" ? b.tool_use_id : "",
+                                content: this.normalizeToolResultContent(b.content),
+                                is_error: b.is_error === true,
+                            });
+                        }
+                    }
+                    turnState.blocks = rebuildStreamingBlocks();
+                    syncSnapshot();
+                    scheduleEmit();
+                    continue;
+                }
+                // Final result — capture session_id, usage, model
+                if (msg.type === "result") {
+                    const resultMsg = msg;
+                    if (typeof resultMsg.result === "string")
+                        turnState.result = resultMsg.result.trim();
+                    if (typeof resultMsg.session_id === "string")
+                        turnState.sessionId = resultMsg.session_id;
+                    turnState.model = this.extractModelName(resultMsg.modelUsage) ?? turnState.model;
+                    turnState.usage = this.extractSdkUsage(resultMsg);
+                    syncSnapshot();
+                    scheduleEmit();
+                    continue;
+                }
+            }
+        }
+        catch (err) {
+            // AbortError from abortController.abort() is intentional — fall through to finish logic
+            const isAbort = abortController.signal.aborted || (err instanceof Error && err.name === "AbortError");
+            if (!isAbort) {
+                this.pendingSdkAbort.delete(sessionId);
+                this.lastStreamSaveAt.delete(sessionId);
+                if (emitTimer)
+                    clearTimeout(emitTimer);
+                this.logger?.appendStructuredSpawn(sessionId, {
+                    kind: "claude-sdk-error",
+                    spawnedAt,
+                    closedAt: new Date().toISOString(),
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                throw err;
+            }
+        }
+        // Cleanup
+        this.pendingSdkAbort.delete(sessionId);
+        this.lastStreamSaveAt.delete(sessionId);
+        if (emitTimer)
+            clearTimeout(emitTimer);
+        flushEmit();
+        const current = this.sessions.get(sessionId);
+        if (!current)
+            throw new Error("Session removed during execution.");
+        this.logger?.appendStructuredSpawn(sessionId, {
+            kind: "claude-sdk-close",
+            spawnedAt,
+            closedAt: new Date().toISOString(),
+            killedForAskUserQuestion,
+            sessionId: turnState.sessionId,
+        });
+        const interruptedByUser = this.interruptedWith.has(sessionId);
+        // Build final assistant turn
+        const finalContent = this.compactContentBlocks([...turnState.blocks], turnState.result);
+        const assistantTurn = {
+            role: "assistant",
+            content: finalContent,
+            usage: turnState.usage,
+        };
+        const msgs = [...(current.messages ?? [])];
+        const lastMsg = msgs[msgs.length - 1];
+        if (lastMsg && lastMsg.role === "assistant")
+            msgs[msgs.length - 1] = assistantTurn;
+        else
+            msgs.push(assistantTurn);
+        const interruptPrompt = this.interruptedWith.get(sessionId);
+        const keepRunning = killedForAskUserQuestion || !!interruptPrompt;
+        const finished = {
+            ...current,
+            status: keepRunning ? "running" : "idle",
+            exitCode: keepRunning ? null : 0,
+            endedAt: keepRunning ? null : new Date().toISOString(),
+            output: turnState.result,
+            claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
+            messages: msgs,
+            queuedMessages: interruptPrompt ? [] : current.queuedMessages,
+            pendingEscalation: null,
+            permissionBlocked: false,
+            structuredState: {
+                ...current.structuredState,
+                model: turnState.model ?? current.structuredState?.model,
+                inFlight: false,
+                activeRequestId: null,
+                lastError: null,
+            },
+        };
+        this.sessions.set(sessionId, finished);
+        this.storage.saveSession(finished);
+        this.emitStructuredSnapshot(finished);
+        if (!keepRunning)
+            this.emitStructuredSnapshot(finished, "ended");
+        if (killedForAskUserQuestion)
+            return;
+        if (interruptPrompt) {
+            this.interruptedWith.delete(sessionId);
+            setImmediate(() => {
+                this.sendMessage(sessionId, interruptPrompt).catch((err) => {
+                    console.error("[WAND] sdk interrupt-and-send failed:", err);
+                    const afterFail = this.sessions.get(sessionId);
+                    if (afterFail) {
+                        const recovered = {
+                            ...afterFail,
+                            status: "idle",
+                            exitCode: 0,
+                            endedAt: new Date().toISOString(),
+                            structuredState: {
+                                ...afterFail.structuredState,
+                                inFlight: false,
+                                activeRequestId: null,
+                            },
+                        };
+                        this.sessions.set(sessionId, recovered);
+                        this.storage.saveSession(recovered);
+                        this.emitStructuredSnapshot(recovered);
+                    }
+                });
+            });
+            return;
+        }
+        // Auto-continue after ExitPlanMode (same as CLI runner)
+        const lastToolUse = [...turnState.blocks].reverse().find((b) => b.type === "tool_use");
+        if (lastToolUse && lastToolUse.name === "ExitPlanMode" && turnState.sessionId) {
+            setImmediate(() => {
+                this.sendMessage(sessionId, "Plan approved. Proceed with the implementation.").catch((err) => {
+                    console.error("[WAND] sdk auto-continue after ExitPlanMode failed:", err);
+                });
+            });
+            return;
+        }
+        setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+    }
+    // ---------------------------------------------------------------------------
     // Parsing helpers (unchanged logic, extracted from previous implementation)
     // ---------------------------------------------------------------------------
     extractAssistantMessage(message) {
@@ -1303,7 +1871,10 @@ export class StructuredSessionManager {
             if (previous
                 && previous.type === "text"
                 && block.type === "text") {
-                previous.text = `${previous.text}${block.text}`;
+                // 用新对象替换 compacted 末尾，**不要**就地改 previous.text —— previous
+                // 通常和调用方持有的 turnState.blocks 共享引用，原地 mutate 会让下次
+                // syncSnapshot 把已合并的内容再合并一次，呈指数级复制。
+                compacted[compacted.length - 1] = { type: "text", text: `${previous.text}${block.text}` };
                 continue;
             }
             compacted.push(block);
@@ -1459,6 +2030,20 @@ export class StructuredSessionManager {
         }
         return value;
     }
+    /** Extract usage from an SDKResultSuccess message (sdk runner). */
+    extractSdkUsage(result) {
+        const usage = result?.usage;
+        const value = {
+            inputTokens: typeof usage?.input_tokens === "number" ? usage.input_tokens : undefined,
+            outputTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : undefined,
+            cacheReadInputTokens: typeof usage?.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : undefined,
+            cacheCreationInputTokens: typeof usage?.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : undefined,
+            totalCostUsd: typeof result?.total_cost_usd === "number" ? result.total_cost_usd : undefined,
+        };
+        if (Object.values(value).every(v => v === undefined))
+            return undefined;
+        return value;
+    }
     extractCodexUsage(source) {
         if (!source || typeof source !== "object")
             return undefined;