@co0ontty/wand 3.1.1 → 4.0.0

package/dist/structured-session-manager.js

@@ -1,92 +1,27 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import path from "node:path";
 import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { truncateMessagesForTransport } from "./message-truncator.js";
-import { buildChildEnv, isRunningAsRoot } from "./env-utils.js";
+import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { resolveSdkClaudeBinary } from "./claude-sdk-runner.js";
-import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { generateSessionTopic } from "./session-topic.js";
 import { resolveSessionCwd } from "./session-cwd.js";
-function defaultStructuredRunner(provider) {
-    return provider === "codex" ? "codex-cli-exec" : provider === "opencode" ? "opencode-cli-run" : "claude-cli-print";
-}
-function defaultStructuredState(provider, runner = defaultStructuredRunner(provider)) {
-    return {
-        provider,
-        runner,
-        lastError: null,
-        inFlight: false,
-        activeRequestId: null,
-    };
-}
-/**
- * 把任意外部输入收敛到合法的 thinkingEffort 枚举值。`null` / 非法值都视为
- * "未设置"——上层调用方再根据 provider 决定是否填默认值。
- */
-export function normalizeThinkingEffort(value) {
-    if (typeof value !== "string")
-        return null;
-    const v = value.trim().toLowerCase();
-    if (v === "off" || v === "standard" || v === "deep" || v === "max")
-        return v;
-    if (/^codex:[a-z0-9][a-z0-9_-]{0,31}$/.test(v))
-        return v;
-    return null;
-}
-/** Claude SDK 用：把 thinkingEffort 映射成 `thinking.budget_tokens`。off / 空 → 0（不启用）。 */
-export function thinkingEffortToSdkBudget(effort) {
-    switch (effort) {
-        case "standard": return 4096;
-        case "deep": return 16000;
-        case "max": return 31999;
-        case "off":
-        default: return 0;
+import { buildCodexArgs } from "./structured-codex-adapter.js";
+import { buildAppendSystemPromptParts, buildClaudeCliArgs, buildClaudeSdkThinking, derivePermissionPolicy, } from "./structured-claude-adapter.js";
+import { applyOpenCodeEvent, buildOpenCodeArgs } from "./structured-opencode-adapter.js";
+import { defaultStructuredRunner, defaultStructuredState, isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, } from "./structured-provider-common.js";
+export { isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner, thinkingEffortToClaudeCliEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToOpenCodeVariant, thinkingEffortToSdkBudget, } from "./structured-provider-common.js";
+/** The runner already persisted/emitted its detailed terminal snapshot. */
+class PersistedStructuredRunnerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PersistedStructuredRunnerError";
     }
 }
-/** Claude CLI 用：把 thinkingEffort 映射到 `--effort` / `/effort` 支持的等级。off → 不覆盖默认值。 */
-export function thinkingEffortToClaudeCliEffort(effort) {
-    switch (effort) {
-        case "standard": return "low";
-        case "deep": return "medium";
-        case "max": return "max";
-        case "off":
-        default: return null;
-    }
-}
-/** Claude PTY slash-command 用：off 表示恢复模型默认 effort。 */
-export function thinkingEffortToClaudeSlashEffort(effort) {
-    return thinkingEffortToClaudeCliEffort(effort) ?? "auto";
-}
-/** Codex CLI 用：把 thinkingEffort 映射到 model_reasoning_effort 配置。off → 不覆盖 Codex 默认。 */
-export function thinkingEffortToCodexReasoningEffort(effort) {
-    if (typeof effort === "string" && effort.startsWith("codex:")) {
-        return effort.slice("codex:".length) || null;
-    }
-    switch (effort) {
-        case "standard": return "low";
-        case "deep": return "medium";
-        case "max": return "xhigh";
-        case "off": return null;
-        default: return null;
-    }
-}
-/** OpenCode exposes provider-specific reasoning presets through `--variant`. */
-export function thinkingEffortToOpenCodeVariant(effort) {
-    if (!effort || effort === "off")
-        return null;
-    if (effort === "standard")
-        return "low";
-    if (effort === "deep")
-        return "high";
-    if (effort === "max")
-        return "max";
-    return effort.startsWith("codex:") ? effort.slice("codex:".length) || null : null;
-}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -516,7 +451,11 @@ const STREAM_EMIT_DEBOUNCE_MS = 16;
  *  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;
+// Full message snapshots become increasingly expensive during long turns.
+// Terminal paths always force an authoritative save, so a one-second crash
+// checkpoint keeps recovery useful without rewriting megabytes five times a
+// second on the event loop.
+const STREAM_SAVE_THROTTLE_MS = 1_000;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 /**
  * 找出最后一条 assistant turn 中尚未配对 tool_result 的 AskUserQuestion tool_use。
@@ -573,132 +512,6 @@ function withSummary(snapshot) {
 function shouldAutoApproveForMode(mode) {
     return mode === "full-access" || mode === "managed" || mode === "auto-edit";
 }
-/**
- * Root 模式下绕过权限的工具白名单。Claude CLI 拒绝以 root 身份用 bypassPermissions，
- * 退而求其次用 acceptEdits + 显式 allowedTools 覆盖 CWD 之外的路径。
- */
-const ROOT_FALLBACK_ALLOWED_TOOLS = [
-    "Bash", "Edit", "Write", "Read", "Glob", "Grep", "NotebookEdit", "WebFetch", "WebSearch",
-];
-/**
- * 收集当前会话可见的 MCP server 名字。
- * claude -p / SDK runner 没有交互式权限弹窗，碰到 mcp__* 工具会直接 fail with
- * "haven't granted"。用户已经在 claude 这边配过的 MCP server 视为可信，
- * 在 --allowedTools 里加 `mcp__<server>` 放行整台 server 的所有工具。
- *
- * 来源（取并集）：
- *   - ~/.claude.json 顶层 mcpServers
- *   - ~/.claude.json projects[<cwd>].mcpServers（仅当前 cwd 精确匹配）
- *   - <cwd>/.mcp.json mcpServers
- *
- * 结果按 (cwd, 各文件 mtime) 缓存，避免每次 spawn 都重读。
- */
-const mcpServerCache = new Map();
-function readJsonSafe(filePath) {
-    try {
-        const raw = readFileSync(filePath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === "object")
-            return parsed;
-    }
-    catch { /* missing/invalid — return null */ }
-    return null;
-}
-function mtimeOf(filePath) {
-    try {
-        return statSync(filePath).mtimeMs;
-    }
-    catch {
-        return 0;
-    }
-}
-function extractMcpServerKeys(node) {
-    if (!node || typeof node !== "object")
-        return [];
-    const mcpServers = node.mcpServers;
-    if (!mcpServers || typeof mcpServers !== "object")
-        return [];
-    return Object.keys(mcpServers);
-}
-function collectMcpServerNames(cwd) {
-    const userConfigPath = path.join(homedir(), ".claude.json");
-    const projectMcpPath = path.join(cwd, ".mcp.json");
-    const fingerprint = `${mtimeOf(userConfigPath)}:${mtimeOf(projectMcpPath)}`;
-    const cached = mcpServerCache.get(cwd);
-    if (cached && cached.mtimeFingerprint === fingerprint)
-        return cached.names;
-    const names = new Set();
-    const userConfig = readJsonSafe(userConfigPath);
-    if (userConfig) {
-        for (const k of extractMcpServerKeys(userConfig))
-            names.add(k);
-        const projects = userConfig.projects;
-        if (projects && typeof projects === "object") {
-            const entry = projects[cwd];
-            for (const k of extractMcpServerKeys(entry))
-                names.add(k);
-        }
-    }
-    const projectMcp = readJsonSafe(projectMcpPath);
-    for (const k of extractMcpServerKeys(projectMcp))
-        names.add(k);
-    const result = Array.from(names);
-    mcpServerCache.set(cwd, { mtimeFingerprint: fingerprint, names: result });
-    return result;
-}
-function mcpAllowEntries(cwd) {
-    // `mcp__<server>` 形式放行该 server 的所有工具，等价于 `mcp__<server>__*`。
-    return collectMcpServerNames(cwd).map((name) => `mcp__${name}`);
-}
-/**
- * 把 (执行模式, 自动批准开关) 映射成 Claude CLI / SDK 的权限决策。
- * CLI runner 把它转成 --permission-mode / --allowedTools flag，
- * SDK runner 直接塞进 Options。两边的决策规则保持一字不差。
- *
- * cwd 用来枚举该会话能看到的 MCP server，把 `mcp__<server>` 加进 allowedTools；
- * bypassPermissions 模式下整个白名单都没意义，不附加。
- */
-function derivePermissionPolicy(mode, autoApprove, cwd) {
-    const shouldBypass = autoApprove || mode === "full-access" || mode === "managed";
-    const shouldAcceptEdits = mode === "auto-edit";
-    const mcpAllow = shouldBypass ? [] : mcpAllowEntries(cwd);
-    const withMcp = (base) => {
-        if (!mcpAllow.length)
-            return base;
-        return base ? [...base, ...mcpAllow] : [...mcpAllow];
-    };
-    if (!isRunningAsRoot()) {
-        if (shouldBypass)
-            return { permissionMode: "bypassPermissions", allowedTools: undefined };
-        if (shouldAcceptEdits)
-            return { permissionMode: "acceptEdits", allowedTools: withMcp(undefined) };
-        return { permissionMode: "default", allowedTools: withMcp(undefined) };
-    }
-    if (shouldBypass || shouldAcceptEdits) {
-        return { permissionMode: "acceptEdits", allowedTools: withMcp(ROOT_FALLBACK_ALLOWED_TOOLS) };
-    }
-    return { permissionMode: "default", allowedTools: withMcp(undefined) };
-}
-/**
- * 拼装要追加到系统提示词里的片段：托管模式的自主决策提示 + 用户配置的语言偏好。
- * CLI runner 每段单独 push 一对 `--append-system-prompt <part>` flag，
- * SDK runner 用 "\n\n" 串成一个 appendSystemPrompt 字符串塞 Options。
- * 文本统一到这里维护，避免两个 runner 各抄一份导致漂移。
- */
-function buildAppendSystemPromptParts(language, mode) {
-    const trimmedLanguage = language?.trim();
-    const isChinese = trimmedLanguage === "中文";
-    const parts = [];
-    if (mode === "managed") {
-        parts.push(buildManagedAutonomyDirective(isChinese));
-    }
-    if (trimmedLanguage) {
-        const directive = buildLanguageDirective(trimmedLanguage);
-        if (directive)
-            parts.push(directive);
-    }
-    return parts;
-}
 function buildStructuredOutputPayload(snapshot) {
     return {
         output: snapshot.output,
@@ -769,6 +582,7 @@ export class StructuredSessionManager {
     storage;
     config;
     logger;
+    sdkQueryFactory;
     sessions = new Map();
     pendingChildren = new Map();
     pendingSdkAbort = new Map();
@@ -779,12 +593,6 @@ export class StructuredSessionManager {
      */
     pendingSdkQueries = new Map();
     interruptedWith = new Map();
-    /**
-     * 用户主动点了「停止」的会话。异步收尾（claude -p / codex 的 close、SDK 的 abort）
-     * 据此跳过"结构化会话执行失败"路径——主动停止不是失败，按正常 idle 收尾、保留历史内容。
-     * 用 Set.delete 消费：读取的同时清除，下一轮真失败不会被旧标记误抑制。
-     */
-    userStopped = new Set();
     /**
      * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
      * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
@@ -793,8 +601,10 @@ export class StructuredSessionManager {
      * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
      */
     preserveQueueOnInterrupt = new Set();
-    /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
+    /** Last wall-clock time (ms) a streaming checkpoint reached SQLite. */
     lastStreamSaveAt = new Map();
+    streamCheckpointTimers = new Map();
+    streamCheckpointDirty = new Map();
     /**
      * Idempotency keys we've already accepted, mapped to their wall-clock timestamp.
      * Android WebView 在进程恢复时偶尔会重发上一个未收到响应的 POST（HTTP/2 stream
@@ -806,21 +616,34 @@ export class StructuredSessionManager {
     emitEvent = null;
     archiveTimer = null;
     topicRequests = new Set();
-    constructor(storage, config, logger = null) {
+    streamEmitTimers = new Set();
+    disposed = false;
+    constructor(storage, config, logger = null, sdkQueryFactory = sdkQuery) {
         this.storage = storage;
         this.config = config;
         this.logger = logger;
+        this.sdkQueryFactory = sdkQueryFactory;
         for (const snapshot of this.storage.loadSessions()) {
             if ((snapshot.sessionKind ?? "pty") !== "structured")
                 continue;
             const restoredStatus = snapshot.status === "running" ? "idle" : snapshot.status;
+            const storedProvider = snapshot.provider ?? snapshot.structuredState?.provider;
+            const provider = storedProvider === "codex" || storedProvider === "opencode"
+                ? storedProvider
+                : "claude";
+            const storedRunner = snapshot.runner ?? snapshot.structuredState?.runner;
+            // Legacy/corrupt snapshots are normalized on restore so send dispatch can
+            // rely on the provider/runner invariant without making startup fail.
+            const runner = isStructuredRunnerForProvider(provider, storedRunner)
+                ? storedRunner
+                : defaultStructuredRunner(provider, this.config.structuredRunner);
             const restored = {
                 ...snapshot,
                 sessionKind: "structured",
                 sessionSource: snapshot.sessionSource ?? "interactive",
                 automationId: snapshot.automationId,
-                provider: snapshot.provider ?? snapshot.structuredState?.provider ?? "claude",
-                runner: snapshot.runner ?? snapshot.structuredState?.runner ?? defaultStructuredRunner(snapshot.provider ?? snapshot.structuredState?.provider ?? "claude"),
+                provider,
+                runner,
                 status: restoredStatus,
                 autoApprovePermissions: snapshot.autoApprovePermissions ?? shouldAutoApproveForMode(snapshot.mode),
                 approvalStats: snapshot.approvalStats ?? { tool: 0, command: 0, file: 0, total: 0 },
@@ -828,8 +651,8 @@ export class StructuredSessionManager {
                 pendingEscalation: null,
                 permissionBlocked: false,
                 structuredState: {
-                    provider: snapshot.structuredState?.provider ?? snapshot.provider ?? "claude",
-                    runner: snapshot.runner ?? snapshot.structuredState?.runner ?? defaultStructuredRunner(snapshot.structuredState?.provider ?? snapshot.provider ?? "claude"),
+                    provider,
+                    runner,
                     model: snapshot.structuredState?.model ?? snapshot.selectedModel ?? undefined,
                     lastError: snapshot.structuredState?.lastError ?? null,
                     inFlight: false,
@@ -862,25 +685,160 @@ export class StructuredSessionManager {
                 continue;
             session.archived = true;
             session.archivedAt = new Date(now).toISOString();
-            this.storage.saveSession(session);
+            this.storage.updateSessionRuntimeMetadata(session);
         }
     }
     setEventEmitter(emitEvent) {
+        if (this.disposed)
+            return;
         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) {
+    /** Stop every runner and flush terminal state before storage is closed. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (this.archiveTimer) {
+            clearInterval(this.archiveTimer);
+            this.archiveTimer = null;
+        }
+        for (const timer of this.streamEmitTimers)
+            clearTimeout(timer);
+        this.streamEmitTimers.clear();
+        const activeSessionIds = new Set([
+            ...this.pendingChildren.keys(),
+            ...this.pendingSdkQueries.keys(),
+            ...this.pendingSdkAbort.keys(),
+            ...Array.from(this.sessions.values())
+                .filter((session) => session.structuredState?.inFlight)
+                .map((session) => session.id),
+        ]);
+        for (const id of activeSessionIds) {
+            const session = this.sessions.get(id);
+            if (!session)
+                continue;
+            const cancelled = {
+                ...session,
+                status: "idle",
+                exitCode: null,
+                endedAt: null,
+                pendingEscalation: null,
+                permissionBlocked: false,
+                structuredState: {
+                    ...(session.structuredState ?? defaultStructuredState(session.provider ?? "claude", session.runner)),
+                    inFlight: false,
+                    activeRequestId: null,
+                    lastError: null,
+                },
+            };
+            this.sessions.set(id, cancelled);
+            try {
+                this.saveAuthoritativeSession(cancelled);
+            }
+            catch { /* best-effort shutdown flush */ }
+        }
+        for (const child of this.pendingChildren.values()) {
+            try {
+                child.kill();
+            }
+            catch { /* ignore */ }
+        }
+        for (const query of this.pendingSdkQueries.values()) {
+            void query.interrupt().catch(() => { });
+        }
+        for (const controller of this.pendingSdkAbort.values())
+            controller.abort();
+        this.pendingChildren.clear();
+        this.pendingSdkQueries.clear();
+        this.pendingSdkAbort.clear();
+        this.interruptedWith.clear();
+        this.preserveQueueOnInterrupt.clear();
+        for (const timer of this.streamCheckpointTimers.values())
+            clearTimeout(timer);
+        this.streamCheckpointTimers.clear();
+        this.streamCheckpointDirty.clear();
+        this.lastStreamSaveAt.clear();
+        this.topicRequests.clear();
+        this.emitEvent = null;
+    }
+    trackStreamEmitTimer(timer) {
+        this.streamEmitTimers.add(timer);
+        return timer;
+    }
+    clearStreamEmitTimer(timer) {
+        clearTimeout(timer);
+        this.streamEmitTimers.delete(timer);
+    }
+    /** Mark streaming payload dirty and enforce both leading and trailing checkpoints. */
+    saveStreamingSnapshot(snapshot, changed = { messages: true, output: true }) {
+        if (this.disposed)
+            return;
+        const dirty = this.streamCheckpointDirty.get(snapshot.id) ?? { metadata: false, output: false, messages: false };
+        if (changed.metadata)
+            dirty.metadata = true;
+        if (changed.output)
+            dirty.output = true;
+        if (changed.messages)
+            dirty.messages = true;
+        this.streamCheckpointDirty.set(snapshot.id, dirty);
         const now = Date.now();
         const last = this.lastStreamSaveAt.get(snapshot.id) ?? 0;
-        if (now - last < STREAM_SAVE_THROTTLE_MS)
+        const remaining = STREAM_SAVE_THROTTLE_MS - (now - last);
+        if (remaining <= 0) {
+            this.flushStreamingCheckpoint(snapshot.id);
             return;
-        this.lastStreamSaveAt.set(snapshot.id, now);
+        }
+        if (this.streamCheckpointTimers.has(snapshot.id))
+            return;
+        const timer = setTimeout(() => {
+            this.streamCheckpointTimers.delete(snapshot.id);
+            if (!this.disposed)
+                this.flushStreamingCheckpoint(snapshot.id);
+        }, remaining);
+        timer.unref?.();
+        this.streamCheckpointTimers.set(snapshot.id, timer);
+    }
+    flushStreamingCheckpoint(sessionId) {
+        const timer = this.streamCheckpointTimers.get(sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.streamCheckpointTimers.delete(sessionId);
+        }
+        const dirty = this.streamCheckpointDirty.get(sessionId);
+        const snapshot = this.sessions.get(sessionId);
+        if (!dirty || !snapshot) {
+            this.streamCheckpointDirty.delete(sessionId);
+            return;
+        }
+        if (dirty.metadata)
+            this.storage.updateSessionRuntimeMetadata(snapshot);
+        if (dirty.messages) {
+            this.storage.checkpointSessionMessages(sessionId, snapshot.messages ?? [], snapshot.structuredState, dirty.output ? snapshot.output : undefined);
+        }
+        else if (dirty.output) {
+            this.storage.checkpointSessionOutput(sessionId, snapshot.output);
+        }
+        this.streamCheckpointDirty.delete(sessionId);
+        this.lastStreamSaveAt.set(sessionId, Date.now());
+    }
+    clearStreamingCheckpoint(sessionId) {
+        this.cancelStreamingCheckpointTimer(sessionId);
+        this.streamCheckpointDirty.delete(sessionId);
+        this.lastStreamSaveAt.delete(sessionId);
+    }
+    cancelStreamingCheckpointTimer(sessionId) {
+        const timer = this.streamCheckpointTimers.get(sessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.streamCheckpointTimers.delete(sessionId);
+    }
+    saveAuthoritativeSession(snapshot) {
         this.storage.saveSession(snapshot);
+        this.clearStreamingCheckpoint(snapshot.id);
+    }
+    checkpointSessionMessages(snapshot, includeOutput = false) {
+        this.storage.updateSessionRuntimeMetadata(snapshot);
+        this.storage.checkpointSessionMessages(snapshot.id, snapshot.messages ?? [], snapshot.structuredState, includeOutput ? snapshot.output : undefined);
     }
     list() {
         return Array.from(this.sessions.values())
@@ -905,28 +863,60 @@ export class StructuredSessionManager {
         const current = this.requireSession(id);
         const updated = { ...current, title, description, summary: description };
         this.sessions.set(id, updated);
-        this.storage.saveSessionMetadata(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /**
+     * Update worktree merge progress on the canonical in-memory snapshot before
+     * persisting it. A null result means this manager does not own the session.
+     */
+    setWorktreeMergeState(id, status, info) {
+        const current = this.sessions.get(id);
+        if (!current)
+            return null;
+        const updated = {
+            ...current,
+            worktreeMergeStatus: status,
+            worktreeMergeInfo: info ?? null,
+        };
+        this.sessions.set(id, updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
+        this.emit({
+            type: "status",
+            sessionId: id,
+            data: {
+                sessionKind: "structured",
+                worktreeMergeStatus: status,
+                worktreeMergeInfo: updated.worktreeMergeInfo,
+            },
+        });
+        return updated;
+    }
     maybeGenerateSessionTopic(id, input) {
         const session = this.sessions.get(id);
-        if (!session || session.title || this.topicRequests.has(id))
+        if (this.disposed || !session || session.title || this.topicRequests.has(id))
             return;
         this.topicRequests.add(id);
         void generateSessionTopic(input, session.cwd, this.config.language)
             .then(({ title, description }) => {
-            if (this.sessions.has(id))
+            if (!this.disposed && this.sessions.has(id))
                 this.setSessionTopic(id, title, description);
         })
             .catch((error) => console.error(`[StructuredSessionManager] Failed to generate session topic ${id}:`, getErrorMessage(error)))
             .finally(() => this.topicRequests.delete(id));
     }
     createSession(options) {
+        if (this.disposed)
+            throw new Error("StructuredSessionManager has been disposed.");
         const id = randomUUID();
         const startedAt = new Date().toISOString();
-        const provider = options.provider === "codex" || options.provider === "opencode" ? options.provider : "claude";
-        const runner = options.runner ?? defaultStructuredRunner(provider);
+        const requestedProvider = options.provider ?? "claude";
+        if (requestedProvider !== "claude" && requestedProvider !== "codex" && requestedProvider !== "opencode") {
+            throw new Error(`不支持的结构化 provider: ${String(requestedProvider)}`);
+        }
+        const provider = requestedProvider;
+        const runner = resolveStructuredRunner(provider, options.runner, this.config.structuredRunner);
         const baseCwd = resolveSessionCwd(options.cwd, this.config.defaultCwd);
         const worktreeSetup = options.worktreeEnabled
             ? prepareSessionWorktree({ cwd: baseCwd, sessionId: id })
@@ -981,6 +971,8 @@ export class StructuredSessionManager {
         return snapshot;
     }
     async sendMessage(id, input, opts) {
+        if (this.disposed)
+            throw new Error("StructuredSessionManager has been disposed.");
         let session = this.requireSession(id);
         const prompt = input.trim();
         if (!prompt)
@@ -1004,10 +996,18 @@ export class StructuredSessionManager {
         }
         if (session.structuredState?.inFlight) {
             const child = this.pendingChildren.get(id);
-            const childAlive = child && !child.killed && child.exitCode === null;
-            if (!childAlive) {
+            const sdkAbort = this.pendingSdkAbort.get(id);
+            const sdkQueryHandle = this.pendingSdkQueries.get(id);
+            // ChildProcess.killed only means kill() successfully sent a signal; the
+            // process can keep running until its close/error callback releases this
+            // exact handle. Treat map ownership as the authoritative in-flight state.
+            const childActive = Boolean(child);
+            const sdkAlive = Boolean(sdkQueryHandle || (sdkAbort && !sdkAbort.signal.aborted));
+            if (!childActive && !sdkAlive) {
                 if (child)
-                    this.pendingChildren.delete(id);
+                    this.releasePendingChild(id, child);
+                if (sdkAbort)
+                    this.releasePendingSdkAbort(id, sdkAbort);
                 const recovered = {
                     ...session,
                     status: "idle",
@@ -1019,7 +1019,7 @@ export class StructuredSessionManager {
                     },
                 };
                 this.sessions.set(id, recovered);
-                this.storage.saveSession(recovered);
+                this.storage.updateSessionRuntimeMetadata(recovered);
                 session = recovered;
             }
             else if (opts?.interrupt) {
@@ -1038,7 +1038,7 @@ export class StructuredSessionManager {
                             const trimmedQueue = queue.slice(0, removeAt).concat(queue.slice(removeAt + 1));
                             session = { ...session, queuedMessages: trimmedQueue };
                             this.sessions.set(id, session);
-                            this.storage.saveSession(session);
+                            this.storage.updateSessionRuntimeMetadata(session);
                             this.emitStructuredSnapshot(session);
                         }
                     }
@@ -1046,15 +1046,15 @@ export class StructuredSessionManager {
                 else {
                     this.preserveQueueOnInterrupt.delete(id);
                 }
-                try {
-                    child.kill("SIGTERM");
+                if (childActive && child) {
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch (_err) { /* ignore */ }
                 }
-                catch (_err) { /* ignore */ }
-                const sdkQueryHandle = this.pendingSdkQueries.get(id);
                 if (sdkQueryHandle) {
                     void sdkQueryHandle.interrupt().catch(() => { });
                 }
-                const sdkAbort = this.pendingSdkAbort.get(id);
                 if (sdkAbort)
                     sdkAbort.abort();
                 return session;
@@ -1074,7 +1074,7 @@ export class StructuredSessionManager {
                     queuedMessages: [...queue, prompt],
                 };
                 this.sessions.set(id, queued);
-                this.storage.saveSession(queued);
+                this.storage.updateSessionRuntimeMetadata(queued);
                 this.emitStructuredSnapshot(queued);
                 return queued;
             }
@@ -1114,7 +1114,7 @@ export class StructuredSessionManager {
             },
         };
         this.sessions.set(id, updated);
-        this.storage.saveSession(updated);
+        this.checkpointSessionMessages(updated);
         this.emitStructuredSnapshot(updated);
         this.emit({
             type: "status",
@@ -1132,26 +1132,41 @@ export class StructuredSessionManager {
             ? `[对刚才 AskUserQuestion 工具的回答 — 结构化模式不支持工具结果回传，下面是用户从选项中的选择]\n${prompt}`
             : prompt;
         try {
-            if ((updated.provider ?? "claude") === "codex") {
-                await this.runCodexStreaming(id, updated, prompt);
+            const provider = updated.provider ?? updated.structuredState?.provider ?? "claude";
+            const runner = updated.runner ?? updated.structuredState?.runner;
+            if (!isStructuredRunnerForProvider(provider, runner)) {
+                throw new Error(`会话 runner ${String(runner)} 与 provider ${provider} 不匹配。`);
             }
-            else if ((updated.provider ?? "claude") === "opencode") {
-                await this.runOpenCodeStreaming(id, updated, prompt);
+            if (provider === "codex") {
+                await this.runCodexStreaming(id, updated, prompt, requestId);
             }
-            else if (this.config.structuredRunner === "sdk") {
-                await this.runClaudeSdkStreaming(id, updated, prompt);
+            else if (provider === "opencode") {
+                await this.runOpenCodeStreaming(id, updated, prompt, requestId);
+            }
+            else if (runner === "claude-sdk") {
+                await this.runClaudeSdkStreaming(id, updated, prompt, requestId);
             }
             else {
-                await this.runClaudeStreaming(id, updated, cliClaudePrompt);
+                await this.runClaudeStreaming(id, updated, cliClaudePrompt, requestId);
             }
             const finished = this.requireSession(id);
             return finished;
         }
         catch (error) {
             const message = getErrorMessage(error);
+            // Close handlers use this tagged error after they have already persisted
+            // the detailed failure. Re-throw even if an ended-event listener removed
+            // the session synchronously; there is no request-id marker to leak.
+            if (error instanceof PersistedStructuredRunnerError)
+                throw error;
             const current = this.sessions.get(id);
             if (!current)
                 throw error;
+            // stop() or a newer turn may have invalidated this execution while its
+            // runner was unwinding. A stale rejection must never fail the new turn.
+            if (!this.isCurrentRequest(id, requestId)) {
+                return current;
+            }
             const failed = {
                 ...current,
                 status: "failed",
@@ -1165,7 +1180,7 @@ export class StructuredSessionManager {
                 },
             };
             this.sessions.set(id, failed);
-            this.storage.saveSession(failed);
+            this.saveAuthoritativeSession(failed);
             this.emit({
                 type: "status",
                 sessionId: id,
@@ -1199,7 +1214,7 @@ export class StructuredSessionManager {
         const reordered = order.map((idx) => queue[idx]);
         const updated = { ...session, queuedMessages: reordered };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emitStructuredSnapshot(updated);
         return updated;
     }
@@ -1213,7 +1228,7 @@ export class StructuredSessionManager {
         const next = queue.slice(0, index).concat(queue.slice(index + 1));
         const updated = { ...session, queuedMessages: next };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emitStructuredSnapshot(updated);
         return updated;
     }
@@ -1239,7 +1254,7 @@ export class StructuredSessionManager {
         const inFlight = session.status === "running" && session.structuredState?.inFlight === true;
         const updated = { ...session, queuedMessages: remaining };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emitStructuredSnapshot(updated);
         try {
             return await this.sendMessage(sessionId, prompt, {
@@ -1263,7 +1278,7 @@ export class StructuredSessionManager {
         }
         const updated = { ...session, queuedMessages: [] };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emitStructuredSnapshot(updated);
         return updated;
     }
@@ -1280,7 +1295,7 @@ export class StructuredSessionManager {
             },
         };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emit({
             type: "status",
             sessionId,
@@ -1301,7 +1316,7 @@ export class StructuredSessionManager {
             thinkingEffort: normalized,
         };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emit({
             type: "status",
             sessionId,
@@ -1324,7 +1339,7 @@ export class StructuredSessionManager {
             autoApprovePermissions: autoApprove,
         };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emit({
             type: "status",
             sessionId,
@@ -1338,14 +1353,24 @@ export class StructuredSessionManager {
         const newVal = !session.autoApprovePermissions;
         const updated = { ...session, autoApprovePermissions: newVal };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         return updated;
     }
     /** Resolve a specific escalation by requestId. */
     resolveEscalation(sessionId, requestId, resolution) {
-        const approved = resolution !== "deny";
         const session = this.requireSession(sessionId);
-        const scope = session.pendingEscalation?.scope;
+        const pending = session.pendingEscalation;
+        if (!pending) {
+            throw new Error("当前会话没有待处理的授权请求。");
+        }
+        if (pending.requestId !== requestId) {
+            throw new Error("授权请求已失效，请刷新后重试。");
+        }
+        if (resolution !== "approve_once" && resolution !== "approve_turn" && resolution !== "deny") {
+            throw new Error("resolution 必须是 approve_once、approve_turn 或 deny。");
+        }
+        const approved = resolution !== "deny";
+        const scope = pending.scope;
         if (approved && scope) {
             this.incrementApprovalStats(session, scope);
         }
@@ -1353,14 +1378,14 @@ export class StructuredSessionManager {
             ...session,
             pendingEscalation: null,
             permissionBlocked: false,
-            lastEscalationResult: session.pendingEscalation ? {
-                requestId: session.pendingEscalation.requestId,
-                resolution: approved ? "approve_once" : "deny",
+            lastEscalationResult: {
+                requestId: pending.requestId,
+                resolution,
                 reason: approved ? "user_approved" : "user_denied",
-            } : session.lastEscalationResult ?? null,
+            },
         };
         this.sessions.set(sessionId, updated);
-        this.storage.saveSession(updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
         this.emit({
             type: "status",
             sessionId,
@@ -1372,26 +1397,8 @@ export class StructuredSessionManager {
         const session = this.requireSession(id);
         this.interruptedWith.delete(id);
         this.preserveQueueOnInterrupt.delete(id);
-        // 标记本会话为「用户主动停止」，让被 kill 的子进程 close / SDK abort 收尾时
-        // 走正常 idle 收尾而不是失败路径。
-        this.userStopped.add(id);
-        const child = this.pendingChildren.get(id);
-        if (child) {
-            child.kill();
-            this.pendingChildren.delete(id);
-        }
-        // SDK runner：先尝试 query.interrupt() 优雅停止，失败再走 abort。
-        // 两个都清掉避免后续重复操作。
-        const sdkQuery = this.pendingSdkQueries.get(id);
-        if (sdkQuery) {
-            void sdkQuery.interrupt().catch(() => { });
-            this.pendingSdkQueries.delete(id);
-        }
-        const sdkAbort = this.pendingSdkAbort.get(id);
-        if (sdkAbort) {
-            sdkAbort.abort();
-            this.pendingSdkAbort.delete(id);
-        }
+        // Clearing activeRequestId is the generation barrier: late data/close callbacks
+        // from the cancelled runner can no longer mutate this session or a replacement turn.
         // 主动停止只是取消「当前回合」，结构化会话本身并没有结束——置为 idle 而非 stopped。
         // 这样前端不会进入"会话已结束/恢复会话"终止态，输入框保持可用，直接展示历史内容。
         const cancelled = {
@@ -1409,29 +1416,48 @@ export class StructuredSessionManager {
             },
         };
         this.sessions.set(id, cancelled);
-        this.storage.saveSession(cancelled);
+        const child = this.pendingChildren.get(id);
+        if (child) {
+            child.kill();
+            this.releasePendingChild(id, child);
+        }
+        // SDK runner：先尝试 query.interrupt() 优雅停止，失败再走 abort。
+        // 两个都清掉避免后续重复操作。
+        const sdkQuery = this.pendingSdkQueries.get(id);
+        if (sdkQuery) {
+            void sdkQuery.interrupt().catch(() => { });
+            this.releasePendingSdkQuery(id, sdkQuery);
+        }
+        const sdkAbort = this.pendingSdkAbort.get(id);
+        if (sdkAbort) {
+            sdkAbort.abort();
+            this.releasePendingSdkAbort(id, sdkAbort);
+        }
+        this.saveAuthoritativeSession(cancelled);
         // 仍发 "ended" 事件让各端停掉"回复中"指示 / 灵动岛，但携带的 status 是 idle。
         this.emitStructuredSnapshot(cancelled, "ended");
         return cancelled;
     }
     delete(id) {
         const child = this.pendingChildren.get(id);
+        const sdkQuery = this.pendingSdkQueries.get(id);
+        const sdkAbort = this.pendingSdkAbort.get(id);
+        // Invalidate callback ownership before signalling the runner. Abort/kill can
+        // synchronously wake listeners in some SDK/ChildProcess implementations.
+        this.sessions.delete(id);
         if (child) {
             child.kill();
-            this.pendingChildren.delete(id);
+            this.releasePendingChild(id, child);
         }
-        const sdkQuery = this.pendingSdkQueries.get(id);
         if (sdkQuery) {
             void sdkQuery.interrupt().catch(() => { });
-            this.pendingSdkQueries.delete(id);
+            this.releasePendingSdkQuery(id, sdkQuery);
         }
-        const sdkAbort = this.pendingSdkAbort.get(id);
         if (sdkAbort) {
             sdkAbort.abort();
-            this.pendingSdkAbort.delete(id);
+            this.releasePendingSdkAbort(id, sdkAbort);
         }
-        this.sessions.delete(id);
-        this.lastStreamSaveAt.delete(id);
+        this.clearStreamingCheckpoint(id);
         this.interruptedWith.delete(id);
         this.preserveQueueOnInterrupt.delete(id);
         this.storage.deleteSession(id);
@@ -1447,6 +1473,34 @@ export class StructuredSessionManager {
         }
         return session;
     }
+    /** True only while this exact turn still owns the session's mutable state. */
+    isCurrentRequest(sessionId, requestId) {
+        return this.sessions.get(sessionId)?.structuredState?.activeRequestId === requestId;
+    }
+    currentSessionForRequest(sessionId, requestId) {
+        if (!this.isCurrentRequest(sessionId, requestId))
+            return null;
+        return this.sessions.get(sessionId) ?? null;
+    }
+    /** Delete a handle only if it still belongs to the execution doing cleanup. */
+    releasePendingChild(sessionId, child) {
+        if (this.pendingChildren.get(sessionId) !== child)
+            return false;
+        this.pendingChildren.delete(sessionId);
+        return true;
+    }
+    releasePendingSdkAbort(sessionId, controller) {
+        if (this.pendingSdkAbort.get(sessionId) !== controller)
+            return false;
+        this.pendingSdkAbort.delete(sessionId);
+        return true;
+    }
+    releasePendingSdkQuery(sessionId, query) {
+        if (this.pendingSdkQueries.get(sessionId) !== query)
+            return false;
+        this.pendingSdkQueries.delete(sessionId);
+        return true;
+    }
     emitStructuredSnapshot(session, eventType = "output") {
         // 排队消息只通过 payload.queuedMessages 单独下发，由各端在消息卡片外的「排队条」
         // 里纵向渲染——绝不再把它们当成 __queued 占位 turn 混进 messages 消息流里，否则会
@@ -1464,6 +1518,8 @@ export class StructuredSessionManager {
         });
     }
     async flushNextQueuedMessage(sessionId) {
+        if (this.disposed)
+            return;
         const current = this.sessions.get(sessionId);
         if (!current || (current.queuedMessages?.length ?? 0) === 0) {
             return;
@@ -1480,7 +1536,7 @@ export class StructuredSessionManager {
             queuedMessages: restQueue,
         };
         this.sessions.set(sessionId, nextSession);
-        this.storage.saveSession(nextSession);
+        this.storage.updateSessionRuntimeMetadata(nextSession);
         this.emitStructuredSnapshot(nextSession);
         try {
             await this.sendMessage(sessionId, nextInput);
@@ -1495,13 +1551,13 @@ export class StructuredSessionManager {
                     queuedMessages: [nextInput, ...(afterFail.queuedMessages ?? [])],
                 };
                 this.sessions.set(sessionId, rescued);
-                this.storage.saveSession(rescued);
+                this.storage.updateSessionRuntimeMetadata(rescued);
                 this.emitStructuredSnapshot(rescued);
             }
         }
     }
     emit(event) {
-        if (this.emitEvent) {
+        if (!this.disposed && this.emitEvent) {
             this.emitEvent(event);
         }
     }
@@ -1521,49 +1577,11 @@ export class StructuredSessionManager {
         session.approvalStats = stats;
     }
     // ---------------------------------------------------------------------------
-    // CLI argument construction
-    // ---------------------------------------------------------------------------
-    // claude CLI 的权限/系统提示 flag 由模块级 derivePermissionPolicy() +
-    // buildAppendSystemPromptParts() 派生，定义在文件顶部，与 SDK runner 共用。
-    buildCodexArgs(session) {
-        const args = ["exec", "--json", "--color", "never"];
-        const shouldBypass = session.autoApprovePermissions === true || session.mode === "full-access" || session.mode === "managed";
-        if (shouldBypass) {
-            args.push("--dangerously-bypass-approvals-and-sandbox");
-        }
-        else if (session.mode === "auto-edit" || session.mode === "agent" || session.mode === "agent-max") {
-            args.push("--sandbox", "workspace-write");
-        }
-        else {
-            args.push("--sandbox", "read-only");
-        }
-        args.push("--skip-git-repo-check");
-        const modelChoice = session.selectedModel?.trim();
-        if (modelChoice && modelChoice !== "default") {
-            args.push("--model", modelChoice);
-        }
-        // 思考深度 → model_reasoning_effort（off → 不覆盖，standard → low，deep → medium，max → xhigh）
-        // Newer Codex CLI versions removed the old dedicated exec flag, but still
-        // accept config overrides through `-c`.
-        const reasoningEffort = thinkingEffortToCodexReasoningEffort(session.thinkingEffort);
-        if (reasoningEffort) {
-            args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
-        }
-        if (session.claudeSessionId) {
-            args.push("resume", session.claudeSessionId, "-");
-        }
-        else {
-            args.push("-");
-        }
-        return args;
-    }
-    // ---------------------------------------------------------------------------
     // Streaming codex exec --json execution
     // ---------------------------------------------------------------------------
-    runCodexStreaming(sessionId, session, prompt) {
-        this.userStopped.delete(sessionId);
+    runCodexStreaming(sessionId, session, prompt, requestId) {
         return new Promise((resolve, reject) => {
-            const args = this.buildCodexArgs(session);
+            const args = buildCodexArgs(session);
             const spawnedAt = new Date().toISOString();
             const child = spawn("codex", args, {
                 cwd: session.cwd,
@@ -1596,6 +1614,7 @@ export class StructuredSessionManager {
             let lineBuf = "";
             let stderr = "";
             let emitTimer = null;
+            let settled = false;
             // codex 把所有错误（包括重试日志和最终失败原因）都通过 stdout 的 NDJSON 事件
             // 输出，stderr 通常是空的。我们在 processLine 里收集这些，然后在 close 中
             // 决定真正的报错文本。
@@ -1603,20 +1622,20 @@ export class StructuredSessionManager {
             let codexTurnFailed = null;
             const flushEmit = () => {
                 if (emitTimer) {
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
                     emitTimer = null;
                 }
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 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);
+                    emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
             };
             const syncSnapshot = () => {
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current)
                     return;
                 refreshEstimatedCodexUsage(turnState);
@@ -1647,6 +1666,8 @@ export class StructuredSessionManager {
                 this.saveStreamingSnapshot(patched);
             };
             const processLine = (line) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const trimmed = line.trim();
                 if (!trimmed)
                     return;
@@ -1720,6 +1741,8 @@ export class StructuredSessionManager {
                 }
             };
             child.stdout?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStdout(sessionId, text);
                 lineBuf += text;
@@ -1729,15 +1752,26 @@ export class StructuredSessionManager {
                     processLine(line);
             });
             child.stderr?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStderr(sessionId, text);
                 stderr += text;
             });
             child.on("error", (error) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
                 if (emitTimer)
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    settled = true;
+                    resolve();
+                    return;
+                }
+                settled = true;
                 this.logger?.appendStructuredSpawn(sessionId, {
                     kind: "codex-exec-error",
                     pid: child.pid ?? null,
@@ -1756,8 +1790,18 @@ export class StructuredSessionManager {
                 reject(new Error(`codex exec 启动失败：${error.message}${hint}`));
             });
             child.on("close", (code, signal) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    if (emitTimer)
+                        this.clearStreamEmitTimer(emitTimer);
+                    settled = true;
+                    resolve();
+                    return;
+                }
                 if (lineBuf.trim()) {
                     processLine(lineBuf);
                     lineBuf = "";
@@ -1774,20 +1818,19 @@ export class StructuredSessionManager {
                     codexErrors,
                     codexTurnFailed,
                 });
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current) {
-                    reject(new Error("Session removed during execution."));
+                    settled = true;
+                    resolve();
                     return;
                 }
                 // 主动中断时（interruptedWith 里有新消息），不走失败路径
                 const interruptedByUser = this.interruptedWith.has(sessionId);
                 const interruptPrompt = this.interruptedWith.get(sessionId);
-                // 用户点「停止」kill 掉 codex 后会非零退出，但这不是失败——按正常 idle 收尾。
-                const userStopped = this.userStopped.delete(sessionId);
                 // codex 把模型/网络/沙箱等错误写到 stdout 的 NDJSON 流（type: error / turn.failed），
                 // 而不是 stderr。我们以 turn.failed 的 message 为准，其次是最后一个 error 事件。
                 const codexFailed = codexTurnFailed !== null;
-                if ((codexFailed || (code !== 0 && code !== null) || signal) && !interruptedByUser && !userStopped) {
+                if ((codexFailed || (code !== 0 && code !== null) || signal) && !interruptedByUser) {
                     const errorText = this.formatStructuredExitError("codex exec", code, signal, {
                         stderr,
                         primary: codexTurnFailed,
@@ -1796,10 +1839,11 @@ export class StructuredSessionManager {
                     const exitForSnapshot = typeof code === "number" ? code : 1;
                     const failed = this.finishStructuredFailure(current, exitForSnapshot, errorText, turnState);
                     this.sessions.set(sessionId, failed);
-                    this.storage.saveSession(failed);
+                    this.saveAuthoritativeSession(failed);
                     this.emitStructuredSnapshot(failed);
                     this.emitStructuredSnapshot(failed, "ended");
-                    reject(new Error(errorText));
+                    settled = true;
+                    reject(new PersistedStructuredRunnerError(errorText));
                     return;
                 }
                 const msgs = this.buildCompletedAssistantMessages(current, turnState);
@@ -1824,7 +1868,7 @@ export class StructuredSessionManager {
                     },
                 };
                 this.sessions.set(sessionId, finished);
-                this.storage.saveSession(finished);
+                this.saveAuthoritativeSession(finished);
                 this.emitStructuredSnapshot(finished);
                 if (!keepRunning) {
                     this.emitStructuredSnapshot(finished, "ended");
@@ -1836,131 +1880,24 @@ export class StructuredSessionManager {
                     // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
                     // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
                     this.preserveQueueOnInterrupt.delete(sessionId);
+                    settled = true;
                     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;
                 }
+                settled = true;
                 resolve();
                 setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
             });
         });
     }
-    buildOpenCodeArgs(session) {
-        const args = ["run", "--format", "json", "--thinking"];
-        const modelChoice = session.selectedModel?.trim();
-        if (modelChoice && modelChoice !== "default") {
-            args.push("--model", modelChoice);
-        }
-        const variant = thinkingEffortToOpenCodeVariant(session.thinkingEffort);
-        if (variant)
-            args.push("--variant", variant);
-        if (session.autoApprovePermissions === true || session.mode === "full-access" || session.mode === "managed" || session.mode === "auto-edit") {
-            args.push("--dangerously-skip-permissions");
-        }
-        if (session.claudeSessionId) {
-            args.push("--session", session.claudeSessionId);
-        }
-        return args;
-    }
-    openCodeToolName(name) {
-        const mapped = {
-            bash: "Bash",
-            shell: "Bash",
-            read: "Read",
-            edit: "Edit",
-            write: "Write",
-            glob: "Glob",
-            grep: "Grep",
-            webfetch: "WebFetch",
-            websearch: "WebSearch",
-            todowrite: "TodoWrite",
-            task: "Task",
-            skill: "Skill",
-        };
-        return mapped[name.toLowerCase()] ?? `OpenCode/${name}`;
-    }
-    applyOpenCodeEvent(turnState, event) {
-        if (typeof event.sessionID === "string" && event.sessionID)
-            turnState.sessionId = event.sessionID;
-        const type = typeof event.type === "string" ? event.type : "";
-        const part = asRecord(event.part);
-        if (!part) {
-            if (type === "error")
-                return this.extractCodexText(event.error) || "OpenCode run failed";
-            return null;
-        }
-        if (type === "text" && typeof part.text === "string" && part.text.trim()) {
-            turnState.blocks.push({ type: "text", text: part.text });
-            turnState.result += (turnState.result ? "\n" : "") + part.text;
-            return null;
-        }
-        if (type === "reasoning" && typeof part.text === "string" && part.text.trim()) {
-            turnState.blocks.push({ type: "thinking", thinking: part.text });
-            return null;
-        }
-        if (type === "tool_use") {
-            const state = asRecord(part.state) ?? {};
-            const tool = typeof part.tool === "string" && part.tool ? part.tool : "tool";
-            const toolId = typeof part.callID === "string" && part.callID
-                ? part.callID
-                : typeof part.id === "string" && part.id
-                    ? part.id
-                    : randomUUID();
-            const input = asRecord(state.input) ?? {};
-            turnState.blocks.push({
-                type: "tool_use",
-                id: toolId,
-                name: this.openCodeToolName(tool),
-                description: typeof state.title === "string" ? state.title : undefined,
-                input,
-            });
-            const failed = state.status === "error";
-            const content = failed
-                ? (typeof state.error === "string" ? state.error : "OpenCode tool failed")
-                : (typeof state.output === "string" ? state.output : "");
-            turnState.blocks.push({ type: "tool_result", tool_use_id: toolId, content, is_error: failed });
-            return null;
-        }
-        if (type === "step_finish") {
-            const tokens = asRecord(part.tokens);
-            const cache = asRecord(tokens?.cache);
-            const previous = turnState.usage ?? {};
-            turnState.usage = {
-                inputTokens: (previous.inputTokens ?? 0) + (typeof tokens?.input === "number" ? tokens.input : 0),
-                outputTokens: (previous.outputTokens ?? 0) + (typeof tokens?.output === "number" ? tokens.output : 0),
-                reasoningOutputTokens: (previous.reasoningOutputTokens ?? 0) + (typeof tokens?.reasoning === "number" ? tokens.reasoning : 0),
-                cacheReadInputTokens: (previous.cacheReadInputTokens ?? 0) + (typeof cache?.read === "number" ? cache.read : 0),
-                cacheCreationInputTokens: (previous.cacheCreationInputTokens ?? 0) + (typeof cache?.write === "number" ? cache.write : 0),
-                totalCostUsd: (previous.totalCostUsd ?? 0) + (typeof part.cost === "number" ? part.cost : 0),
-            };
-        }
-        return null;
-    }
-    runOpenCodeStreaming(sessionId, session, prompt) {
-        this.userStopped.delete(sessionId);
+    runOpenCodeStreaming(sessionId, session, prompt, requestId) {
         return new Promise((resolve, reject) => {
-            const args = this.buildOpenCodeArgs(session);
+            const args = buildOpenCodeArgs(session);
             const spawnedAt = new Date().toISOString();
             const child = spawn("opencode", args, {
                 cwd: session.cwd,
@@ -1993,8 +1930,9 @@ export class StructuredSessionManager {
             let stderr = "";
             let primaryError = null;
             let emitTimer = null;
+            let settled = false;
             const syncSnapshot = () => {
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current)
                     return;
                 const turn = {
@@ -2018,17 +1956,19 @@ export class StructuredSessionManager {
             };
             const flushEmit = () => {
                 if (emitTimer)
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
                 emitTimer = null;
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (current)
                     this.emit({ type: "output", sessionId, data: buildIncrementalStructuredPayload(current, this.config.cardDefaults ?? {}) });
             };
             const scheduleEmit = () => {
                 if (!emitTimer)
-                    emitTimer = setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS);
+                    emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
             };
             const processLine = (line) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const trimmed = line.trim();
                 if (!trimmed)
                     return;
@@ -2040,13 +1980,15 @@ export class StructuredSessionManager {
                     return;
                 }
                 this.logger?.appendStreamEvent(sessionId, event);
-                const error = this.applyOpenCodeEvent(turnState, event);
+                const error = applyOpenCodeEvent(turnState, event);
                 if (error)
                     primaryError = error;
                 syncSnapshot();
                 scheduleEmit();
             };
             child.stdout?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStdout(sessionId, text);
                 lineBuf += text;
@@ -2056,15 +1998,26 @@ export class StructuredSessionManager {
                     processLine(line);
             });
             child.stderr?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStderr(sessionId, text);
                 stderr += text;
             });
             child.on("error", (error) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
                 if (emitTimer)
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    settled = true;
+                    resolve();
+                    return;
+                }
+                settled = true;
                 const nodeError = error;
                 const hint = nodeError.code === "ENOENT"
                     ? "（PATH 中找不到 opencode；请安装 opencode-ai，或重跑 `wand service:install` 刷新服务 PATH）"
@@ -2072,30 +2025,41 @@ export class StructuredSessionManager {
                 reject(new Error(`opencode run 启动失败：${error.message}${hint}`));
             });
             child.on("close", (code, signal) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    if (emitTimer)
+                        this.clearStreamEmitTimer(emitTimer);
+                    settled = true;
+                    resolve();
+                    return;
+                }
                 if (lineBuf.trim())
                     processLine(lineBuf);
                 flushEmit();
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current) {
-                    reject(new Error("Session removed during execution."));
+                    settled = true;
+                    resolve();
                     return;
                 }
                 const interruptedByUser = this.interruptedWith.has(sessionId);
                 const interruptPrompt = this.interruptedWith.get(sessionId);
-                const userStopped = this.userStopped.delete(sessionId);
-                if ((primaryError || (code !== 0 && code !== null) || signal) && !interruptedByUser && !userStopped) {
+                if ((primaryError || (code !== 0 && code !== null) || signal) && !interruptedByUser) {
                     const legacyHint = /unknown command|unknown flag|No help topic for 'run'/i.test(stderr)
                         ? "\n检测到旧版 OpenCode CLI；请卸载 0.0.x 旧包并安装 `opencode-ai@latest`。"
                         : "";
                     const errorText = this.formatStructuredExitError("opencode run", code, signal, { stderr, primary: primaryError }) + legacyHint;
                     const failed = this.finishStructuredFailure(current, typeof code === "number" ? code : 1, errorText, turnState);
                     this.sessions.set(sessionId, failed);
-                    this.storage.saveSession(failed);
+                    this.saveAuthoritativeSession(failed);
                     this.emitStructuredSnapshot(failed);
                     this.emitStructuredSnapshot(failed, "ended");
-                    reject(new Error(errorText));
+                    settled = true;
+                    reject(new PersistedStructuredRunnerError(errorText));
                     return;
                 }
                 const messages = this.buildCompletedAssistantMessages(current, turnState);
@@ -2120,13 +2084,14 @@ export class StructuredSessionManager {
                     },
                 };
                 this.sessions.set(sessionId, finished);
-                this.storage.saveSession(finished);
+                this.saveAuthoritativeSession(finished);
                 this.emitStructuredSnapshot(finished);
                 if (!keepRunning)
                     this.emitStructuredSnapshot(finished, "ended");
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
                     this.preserveQueueOnInterrupt.delete(sessionId);
+                    settled = true;
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((error) => {
@@ -2135,6 +2100,7 @@ export class StructuredSessionManager {
                     });
                     return;
                 }
+                settled = true;
                 resolve();
                 setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
             });
@@ -2154,43 +2120,14 @@ export class StructuredSessionManager {
      * - Root: --permission-mode acceptEdits + --allowedTools (extends approval
      *   outside CWD). stdin is always "ignore" — no ACP bidirectional control.
      */
-    runClaudeStreaming(sessionId, session, prompt) {
-        this.userStopped.delete(sessionId);
+    runClaudeStreaming(sessionId, session, prompt, requestId) {
         return new Promise((resolve, reject) => {
-            const args = ["-p", "--verbose", "--output-format", "stream-json"];
-            // 权限策略：决策规则与 SDK runner 共享 derivePermissionPolicy()，CLI 这边把
-            // 结果转成对应的 flag。--allowedTools 是 commander 的 variadic（<tools...>），
-            // 紧跟其后的所有非 flag 形 token 都会被吞进工具列表，因此后面任何位置参数
-            // 都得是 -- 开头的 flag——下面追加 --append-system-prompt / --model / --resume
-            // 都满足这个条件。
             const permPolicy = derivePermissionPolicy(session.mode, session.autoApprovePermissions ?? false, session.cwd);
-            if (permPolicy.permissionMode !== "default") {
-                args.push("--permission-mode", permPolicy.permissionMode);
-            }
-            if (permPolicy.allowedTools) {
-                args.push("--allowedTools", ...permPolicy.allowedTools);
-            }
-            // 追加系统提示词（托管模式自主决策 + 语言偏好），文本与 SDK runner 共享。
-            for (const part of buildAppendSystemPromptParts(this.config.language, session.mode)) {
-                args.push("--append-system-prompt", part);
-            }
-            const modelChoice = session.selectedModel?.trim();
-            if (modelChoice && modelChoice !== "default") {
-                args.push("--model", modelChoice);
-            }
-            const claudeEffort = thinkingEffortToClaudeCliEffort(session.thinkingEffort);
-            if (claudeEffort) {
-                args.push("--effort", claudeEffort);
-            }
-            // 托管模式：禁用 AskUserQuestion，让 agent 自己拍板，不要等用户决策。
-            // 非托管模式：保留工具，靠 processLine 检测后主动 kill child 触发"中断+续接"流程。
             const isManaged = session.mode === "managed";
-            if (isManaged) {
-                args.push("--disallowedTools", "AskUserQuestion");
-            }
-            if (session.claudeSessionId) {
-                args.push("--resume", session.claudeSessionId);
-            }
+            const args = buildClaudeCliArgs(session, {
+                permissionPolicy: permPolicy,
+                systemPromptParts: buildAppendSystemPromptParts(this.config.language, session.mode),
+            });
             // 通过 stdin 传 prompt，避免被 --allowedTools / --disallowedTools 这类
             // variadic 参数贪婪吞掉（commander 的 <tools...> 会一直吃 positional 直到
             // 下一个 flag）。表现为 claude 报 "Input must be provided either through
@@ -2375,16 +2312,17 @@ export class StructuredSessionManager {
             let lineBuf = "";
             // Debounce output events to avoid flooding the WebSocket.
             let emitTimer = null;
+            let settled = false;
             // 当 Claude 在非托管模式调用 AskUserQuestion 时，stdin 关闭导致它会 hang 等
             // tool_result。我们检测到后主动 kill child，让它顺利退出，UI 把 tool_use 卡片
             // 渲染成可交互选项；用户提交后由 sendMessage() 通过 --resume 续接。
             let killedForAskUserQuestion = false;
             const flushEmit = () => {
                 if (emitTimer) {
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
                     emitTimer = null;
                 }
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current)
                     return;
                 this.emit({
@@ -2395,12 +2333,12 @@ export class StructuredSessionManager {
             };
             const scheduleEmit = () => {
                 if (!emitTimer) {
-                    emitTimer = setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS);
+                    emitTimer = this.trackStreamEmitTimer(setTimeout(flushEmit, STREAM_EMIT_DEBOUNCE_MS));
                 }
             };
             /** Update the session snapshot with the current in-progress assistant turn. */
             const syncSnapshot = () => {
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current)
                     return;
                 const inProgressTurn = {
@@ -2445,14 +2383,16 @@ export class StructuredSessionManager {
                 if (turnState.sessionId === sid)
                     return;
                 turnState.sessionId = sid;
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (current && current.claudeSessionId !== sid) {
                     const patched = { ...current, claudeSessionId: sid };
                     this.sessions.set(sessionId, patched);
-                    this.saveStreamingSnapshot(patched);
+                    this.saveStreamingSnapshot(patched, { metadata: true });
                 }
             };
             const processLine = (line) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const trimmed = line.trim();
                 if (!trimmed)
                     return;
@@ -2554,6 +2494,8 @@ export class StructuredSessionManager {
             // 纯文本（非 JSON）打到 stdout 然后非零退出，之前的实现会丢掉这部分。
             let lastRawStdoutChunk = "";
             child.stdout?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStdout(sessionId, text);
                 const trimmed = text.trim();
@@ -2568,15 +2510,26 @@ export class StructuredSessionManager {
                 }
             });
             child.stderr?.on("data", (chunk) => {
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 const text = chunk.toString();
                 this.logger?.appendStructuredStderr(sessionId, text);
                 stderr += text;
             });
             child.on("error", (error) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
                 if (emitTimer)
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    settled = true;
+                    resolve();
+                    return;
+                }
+                settled = true;
                 this.logger?.appendStructuredSpawn(sessionId, {
                     kind: "claude-print-error",
                     pid: child.pid ?? null,
@@ -2592,8 +2545,18 @@ export class StructuredSessionManager {
                 reject(new Error(`claude -p 启动失败：${error.message}${hint}`));
             });
             child.on("close", (code, signal) => {
-                this.pendingChildren.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const released = this.releasePendingChild(sessionId, child);
+                if (released)
+                    this.cancelStreamingCheckpointTimer(sessionId);
+                if (settled)
+                    return;
+                if (!this.isCurrentRequest(sessionId, requestId)) {
+                    if (emitTimer)
+                        this.clearStreamEmitTimer(emitTimer);
+                    settled = true;
+                    resolve();
+                    return;
+                }
                 this.logger?.appendStructuredSpawn(sessionId, {
                     kind: "claude-print-close",
                     pid: child.pid ?? null,
@@ -2610,19 +2573,18 @@ export class StructuredSessionManager {
                 // Flush any pending debounced emit before finalizing.
                 flushEmit();
                 // Finalize the session snapshot.
-                const current = this.sessions.get(sessionId);
+                const current = this.currentSessionForRequest(sessionId, requestId);
                 if (!current) {
-                    reject(new Error("Session removed during execution."));
+                    settled = true;
+                    resolve();
                     return;
                 }
                 // 如果是用户主动中断（interruptedWith 里有新消息），claude -p 收到 SIGTERM 后
                 // 可能以非零 exit code 退出（内部 handler 调了 exit(1)）。这种情况属于正常
                 // 中断流程，不应走失败路径——后续 interruptedWith 逻辑会发送新消息。
                 const interruptedByUser = this.interruptedWith.has(sessionId);
-                // 用户点「停止」kill 掉 claude -p 后会非零退出，但这不是失败——按正常 idle 收尾。
-                const userStopped = this.userStopped.delete(sessionId);
                 const failedExit = (code !== null && code !== 0) || signal !== null;
-                if (failedExit && !interruptedByUser && !userStopped) {
+                if (failedExit && !interruptedByUser && !killedForAskUserQuestion) {
                     const errorText = this.formatStructuredExitError("claude -p", code, signal, {
                         stderr,
                         // claude -p 没有 codex 那种独立的 turn.failed 事件，所以 primary 留空；
@@ -2662,10 +2624,11 @@ export class StructuredSessionManager {
                         },
                     };
                     this.sessions.set(sessionId, failed);
-                    this.storage.saveSession(failed);
+                    this.saveAuthoritativeSession(failed);
                     this.emitStructuredSnapshot(failed);
                     this.emitStructuredSnapshot(failed, "ended");
-                    reject(new Error(errorText));
+                    settled = true;
+                    reject(new PersistedStructuredRunnerError(errorText));
                     return;
                 }
                 const msgs = this.buildCompletedAssistantMessages(current, turnState);
@@ -2693,16 +2656,11 @@ export class StructuredSessionManager {
                     },
                 };
                 this.sessions.set(sessionId, finished);
-                this.storage.saveSession(finished);
+                this.saveAuthoritativeSession(finished);
                 this.emitStructuredSnapshot(finished);
                 if (!keepRunning) {
                     this.emitStructuredSnapshot(finished, "ended");
                 }
-                // 等待用户回答 AskUserQuestion 时，跳过后续自续接和队列推进。
-                if (killedForAskUserQuestion) {
-                    resolve();
-                    return;
-                }
                 // 用户中断当前回复：保存部分回复后立即发送新消息。
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
@@ -2711,38 +2669,33 @@ export class StructuredSessionManager {
                     // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
                     // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
                     this.preserveQueueOnInterrupt.delete(sessionId);
+                    settled = true;
                     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;
                 }
+                if (killedForAskUserQuestion) {
+                    settled = true;
+                    resolve();
+                    // An answer can arrive after AskUserQuestion triggered SIGTERM but
+                    // before close finalized the turn. It was queued while inFlight; now
+                    // advance it normally so it becomes the matching tool_result.
+                    if ((finished.queuedMessages?.length ?? 0) > 0) {
+                        setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+                    }
+                    return;
+                }
                 // Auto-continue after plan mode exit: when Claude calls ExitPlanMode,
                 // the `-p` process exits because stdin is "ignore" and it cannot get
                 // user confirmation.  Detect this and automatically resume execution
                 // 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) {
+                    settled = true;
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, "Plan approved. Proceed with the implementation.").catch((err) => {
@@ -2751,6 +2704,7 @@ export class StructuredSessionManager {
                     });
                     return;
                 }
+                settled = true;
                 resolve();
                 setImmediate(() => {
                     void this.flushNextQueuedMessage(sessionId);
@@ -2771,8 +2725,7 @@ export class StructuredSessionManager {
      * payloads for incremental text/thinking/tool_use updates, followed by a final
      * SDKAssistantMessage with the authoritative complete content.
      */
-    async runClaudeSdkStreaming(sessionId, session, prompt) {
-        this.userStopped.delete(sessionId);
+    async runClaudeSdkStreaming(sessionId, session, prompt, requestId) {
         const abortController = new AbortController();
         this.pendingSdkAbort.set(sessionId, abortController);
         const isManaged = session.mode === "managed";
@@ -2784,12 +2737,7 @@ export class StructuredSessionManager {
         // SDK 默认会把整个 process.env 透传给 claude 子进程；这里显式按 inheritEnv 配置组装，
         // 否则关闭"继承环境变量"开关时 SDK 路径会被静默忽略。
         const sdkEnv = buildChildEnv(this.config.inheritEnv !== false);
-        // 思考深度：off → 显式禁用 thinking，其他 → 给一个固定 budget。
-        // SDK 类型用驼峰 budgetTokens（API 层是 budget_tokens，SDK 内部已做转换）。
-        const sdkThinkingBudget = thinkingEffortToSdkBudget(session.thinkingEffort);
-        const sdkThinking = sdkThinkingBudget > 0
-            ? { type: "enabled", budgetTokens: sdkThinkingBudget }
-            : { type: "disabled" };
+        const sdkThinking = buildClaudeSdkThinking(session.thinkingEffort);
         const sdkOptions = {
             cwd: session.cwd,
             abortController,
@@ -2883,17 +2831,17 @@ export class StructuredSessionManager {
         let emitTimer = null;
         const flushEmit = () => {
             if (emitTimer) {
-                clearTimeout(emitTimer);
+                this.clearStreamEmitTimer(emitTimer);
                 emitTimer = null;
             }
-            const current = this.sessions.get(sessionId);
+            const current = this.currentSessionForRequest(sessionId, requestId);
             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);
+                emitTimer = this.trackStreamEmitTimer(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
@@ -2938,7 +2886,7 @@ export class StructuredSessionManager {
             return [...finalizedBlocks, ...stampedStreaming];
         };
         const syncSnapshot = () => {
-            const current = this.sessions.get(sessionId);
+            const current = this.currentSessionForRequest(sessionId, requestId);
             if (!current)
                 return;
             const inProgressTurn = {
@@ -2976,11 +2924,18 @@ export class StructuredSessionManager {
             claudeSessionId: session.claudeSessionId,
             spawnedAt,
         });
-        const queryHandle = sdkQuery({ prompt: singleShotPrompt(), options: sdkOptions });
+        let queryHandle;
+        try {
+            queryHandle = this.sdkQueryFactory({ prompt: singleShotPrompt(), options: sdkOptions });
+        }
+        catch (error) {
+            this.releasePendingSdkAbort(sessionId, abortController);
+            throw error;
+        }
         this.pendingSdkQueries.set(sessionId, queryHandle);
         try {
             for await (const msg of queryHandle) {
-                if (abortController.signal.aborted)
+                if (abortController.signal.aborted || !this.isCurrentRequest(sessionId, requestId))
                     break;
                 // 同 CLI runner 的关键修复：从任何带 session_id 的 SDK 消息（system / assistant /
                 // user / result）即时捕获并落库。AskUserQuestion 的 interrupt 发生在 assistant
@@ -2989,11 +2944,11 @@ export class StructuredSessionManager {
                 const msgSessionId = msg.session_id;
                 if (typeof msgSessionId === "string" && msgSessionId && turnState.sessionId !== msgSessionId) {
                     turnState.sessionId = msgSessionId;
-                    const cur = this.sessions.get(sessionId);
+                    const cur = this.currentSessionForRequest(sessionId, requestId);
                     if (cur && cur.claudeSessionId !== msgSessionId) {
                         const patched = { ...cur, claudeSessionId: msgSessionId };
                         this.sessions.set(sessionId, patched);
-                        this.saveStreamingSnapshot(patched);
+                        this.saveStreamingSnapshot(patched, { metadata: true });
                     }
                 }
                 // Incremental streaming events (opt-in via includePartialMessages: true)
@@ -3145,11 +3100,14 @@ export class StructuredSessionManager {
             // 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.pendingSdkQueries.delete(sessionId);
-                this.lastStreamSaveAt.delete(sessionId);
+                const releasedAbort = this.releasePendingSdkAbort(sessionId, abortController);
+                const releasedQuery = this.releasePendingSdkQuery(sessionId, queryHandle);
+                if (releasedAbort || releasedQuery)
+                    this.cancelStreamingCheckpointTimer(sessionId);
                 if (emitTimer)
-                    clearTimeout(emitTimer);
+                    this.clearStreamEmitTimer(emitTimer);
+                if (!this.isCurrentRequest(sessionId, requestId))
+                    return;
                 this.logger?.appendStructuredSpawn(sessionId, {
                     kind: "claude-sdk-error",
                     spawnedAt,
@@ -3160,17 +3118,18 @@ export class StructuredSessionManager {
             }
         }
         // Cleanup
-        this.pendingSdkAbort.delete(sessionId);
-        this.pendingSdkQueries.delete(sessionId);
-        this.lastStreamSaveAt.delete(sessionId);
-        // SDK abort 收尾本就走 idle（不产生失败串），这里只是顺手清掉用户停止标记避免泄漏。
-        this.userStopped.delete(sessionId);
+        const releasedAbort = this.releasePendingSdkAbort(sessionId, abortController);
+        const releasedQuery = this.releasePendingSdkQuery(sessionId, queryHandle);
+        if (releasedAbort || releasedQuery)
+            this.cancelStreamingCheckpointTimer(sessionId);
         if (emitTimer)
-            clearTimeout(emitTimer);
+            this.clearStreamEmitTimer(emitTimer);
+        if (!this.isCurrentRequest(sessionId, requestId))
+            return;
         flushEmit();
-        const current = this.sessions.get(sessionId);
+        const current = this.currentSessionForRequest(sessionId, requestId);
         if (!current)
-            throw new Error("Session removed during execution.");
+            return;
         this.logger?.appendStructuredSpawn(sessionId, {
             kind: "claude-sdk-close",
             spawnedAt,
@@ -3201,12 +3160,10 @@ export class StructuredSessionManager {
             },
         };
         this.sessions.set(sessionId, finished);
-        this.storage.saveSession(finished);
+        this.saveAuthoritativeSession(finished);
         this.emitStructuredSnapshot(finished);
         if (!keepRunning)
             this.emitStructuredSnapshot(finished, "ended");
-        if (killedForAskUserQuestion)
-            return;
         if (interruptPrompt) {
             this.interruptedWith.delete(sessionId);
             // 与 codex/cli runner 对齐：清掉"保留队列"标记，避免 stale flag 影响下一次普通 interrupt。
@@ -3214,27 +3171,16 @@ export class StructuredSessionManager {
             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;
         }
+        if (killedForAskUserQuestion) {
+            if ((finished.queuedMessages?.length ?? 0) > 0) {
+                setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+            }
+            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) {