@co0ontty/wand 4.106.0 → 4.106.1

package/dist/structured-session-manager.js

@@ -3,10 +3,9 @@ import { resolveAutoAssign } from "./model-auto-assign.js";
 import { withModelGroups } from "./model-group-runner.js";
 import { classifyStructuredFailure, hasStructuredExecutionProgress } from "./structured-failure.js";
 import { withAutomaticPiResources } from "./pi-auto-resources.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { waitForSessionProcessExit } from "./session-artifact-cleanup.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
-import { BoundedKeySet } from "./structured-bounded-keys.js";
 import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { fallbackProviderModel } from "./session-model.js";
@@ -36,6 +35,7 @@ import { QoderRunner } from "./structured-qoder-adapter.js";
 import { PiRunner, isMissingPiSession } from "./structured-pi-adapter.js";
 import { PiOutputFile } from "./pi-output-file.js";
 import { PiProtocolReader } from "./pi-protocol-reader.js";
+import { upsertPiAssistantSegment } from "./structured-session-manager-replay.js";
 import { structuredRunId } from "./structured-exec-host.js";
 import { defaultStructuredRunner, defaultStructuredState, isStructuredRunnerForProvider, normalizeThinkingEffort, resolveStructuredRunner } from "./structured-provider-common.js";
 import { TurnQuietHeartbeat } from "./turn-heartbeat.js";
@@ -79,19 +79,18 @@ const EMPLOYEE_CANDIDATE_STARTUP_TIMEOUT_MS = 180_000;
 // second on the event loop.
 const STREAM_SAVE_THROTTLE_MS = 1_000;
 const DETACHED_RECOVERY_RETRY_MS = 500;
-/** Upper bound on remembered (session, idempotency key) pairs; oldest half is dropped past it. */
-const IDEMPOTENCY_KEY_LIMIT = 1024;
 /** The turn recorded for one user prompt; an open AskUserQuestion is answered by it as a tool_result. */
-function buildUserTurn(prompt, pendingAsk, createdAt, requestId) {
+function buildUserTurn(prompt, pendingAsk, createdAt, requestId, messageId) {
+    const identity = { ...(requestId ? { requestId } : {}), ...(messageId ? { messageId } : {}) };
     if (pendingAsk) {
         return {
             role: "user",
-            ...(requestId ? { requestId } : {}),
+            ...identity,
             createdAt,
             content: [{ type: "tool_result", tool_use_id: pendingAsk.id, content: prompt, is_error: false }],
         };
     }
-    return { role: "user", ...(requestId ? { requestId } : {}), createdAt, content: [{ type: "text", text: prompt }] };
+    return { role: "user", ...identity, createdAt, content: [{ type: "text", text: prompt }] };
 }
 export class StructuredSessionManager {
     storage;
@@ -122,19 +121,12 @@ export class StructuredSessionManager {
     interruptedImmediateStart = new Set();
     employeeInputAdmission = null;
     inputSequence = 0;
+    dispatchingAcceptedInputs = new Set();
     /** Last wall-clock time (ms) a streaming checkpoint reached SQLite. */
     lastStreamSaveAt = new Map();
     lastPiCheckpointAt = 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
-     * reset 等场景），客户端 JS 没有重试逻辑也拦不住。这里用 (sessionId, key) 永
-     * 久去重，重复就抛错让前端弹 toast 提示，**不**做任何处理。timestamp 仅用于
-     * map 大小溢出时按时间裁剪。
-     */
-    seenIdempotencyKeys = new BoundedKeySet(IDEMPOTENCY_KEY_LIMIT);
     relayHandlers = new Map();
     systemCallDrainReleases = new Set();
     emitEvent = null;
@@ -163,6 +155,7 @@ export class StructuredSessionManager {
     unsupportedStructuredProviders = new Set();
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     pendingRecoveryIds = [];
+    detachedInventoryReconciled = false;
     detachedRecoveryPromise = null;
     detachedRecoveryRetryTimer = null;
     detachedRecoveryFailureLogged = false;
@@ -309,8 +302,9 @@ export class StructuredSessionManager {
             && !(this.coreRestartDrains > 0 && this.usesCoreEngine(session)))
             .flatMap(session => {
             const metadata = queuedInputScheduling(session);
-            const userIndex = metadata.findIndex(item => item.source === "user");
-            const index = userIndex >= 0 ? userIndex : 0;
+            const available = (item) => !item.acceptanceId || !this.dispatchingAcceptedInputs.has(item.acceptanceId);
+            const userIndex = metadata.findIndex(item => available(item) && item.source === "user");
+            const index = userIndex >= 0 ? userIndex : metadata.findIndex(available);
             // 同一会话只暴露最高来源档的队首，保留用户显式 reorder 的意义。
             return metadata[index] ? [{ session, index, scheduling: metadata[index] }] : [];
         });
@@ -449,7 +443,7 @@ export class StructuredSessionManager {
     // ---------------------------------------------------------------------------
     /** Called once after startup wiring; transient daemon failures retry automatically. */
     recoverDetachedRuns() {
-        if (this.disposed || this.execHost?.persistent !== true || this.pendingRecoveryIds.length === 0) {
+        if (this.disposed || this.execHost?.persistent !== true || (this.detachedInventoryReconciled && this.pendingRecoveryIds.length === 0)) {
             return Promise.resolve();
         }
         if (this.detachedRecoveryPromise)
@@ -485,6 +479,23 @@ export class StructuredSessionManager {
         }
         if (this.disposed)
             return;
+        // The durable UI status may have failed before the actual process exited.
+        // Inventory is authoritative: recover those live owners too, never spawn a
+        // replacement merely because a previous observer wrote idle/failed.
+        for (const run of runs) {
+            if (!run.runId.startsWith("structured:"))
+                continue;
+            const id = run.runId.slice("structured:".length);
+            const session = this.sessions.get(id);
+            if (!session || this.usesCoreEngine(session) || this.unsupportedStructuredProviders.has(id)
+                || this.pendingRecoveryIds.includes(id) || this.pendingRunnerExecutions.has(id))
+                continue;
+            if (run.status === "running")
+                this.pendingRecoveryIds.push(id);
+            else
+                this.execHost.forgetRun(run.runId);
+        }
+        this.detachedInventoryReconciled = true;
         const ids = [...this.pendingRecoveryIds];
         const byRunId = new Map(runs.map((run) => [run.runId, run]));
         for (const sessionId of ids) {
@@ -495,10 +506,13 @@ export class StructuredSessionManager {
             }
             const state = byRunId.get(structuredRunId(sessionId));
             if (!state) {
+                if (session.structuredState?.activeRequestId)
+                    this.settleNativeInputs(sessionId, session.structuredState.activeRequestId, { blocks: [], result: "", sessionId: session.claudeSessionId }, true);
+                const reconciled = this.requireSession(sessionId);
                 // Inventory was read successfully, so this is a genuinely lost run,
                 // not a temporary control-plane outage. Commit the interrupted view.
                 const interrupted = {
-                    ...session,
+                    ...reconciled,
                     status: "idle",
                     exitCode: null,
                     endedAt: null,
@@ -539,7 +553,7 @@ export class StructuredSessionManager {
         this.scheduleDetachedRecovery();
     }
     scheduleDetachedRecovery() {
-        if (this.disposed || this.pendingRecoveryIds.length === 0 || this.detachedRecoveryRetryTimer)
+        if (this.disposed || (this.detachedInventoryReconciled && this.pendingRecoveryIds.length === 0) || this.detachedRecoveryRetryTimer)
             return;
         this.detachedRecoveryRetryTimer = setTimeout(() => {
             this.detachedRecoveryRetryTimer = null;
@@ -654,7 +668,9 @@ export class StructuredSessionManager {
                 content: this.compactContentBlocks([...turnState.blocks], turnState.result),
                 usage: turnState.usage,
             };
-            const messages = upsertAssistantMessage(current.messages, turn, false, !replayingHistory);
+            const messages = turnState.inputMessageId
+                ? upsertPiAssistantSegment(current.messages, turn, turnState.inputMessageId)
+                : upsertAssistantMessage(current.messages, turn, false, !replayingHistory);
             const patched = {
                 ...current,
                 claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
@@ -690,6 +706,10 @@ export class StructuredSessionManager {
         let lastStdoutSeq = initialState.stdoutSeq;
         let lastStderrSeq = initialState.stderrSeq;
         const feedLine = (line) => {
+            if (resumed.provider === "pi" && line.trim().startsWith("{")) {
+                const event = JSON.parse(line);
+                this.handleNativeInputEvent(sessionId, requestId, event, processor.state);
+            }
             onApplied(processor.feed(line, replayingHistory ? undefined : new Date().toISOString()));
         };
         const piReader = resumed.provider === "pi" && resumed.structuredState?.engine !== "core"
@@ -715,10 +735,11 @@ export class StructuredSessionManager {
                 return;
             fileFailed = true;
             stdoutFile?.dispose();
-            processor.primaryError = `Pi 实时事件文件读写失败：${error.message}；送达结果未知，不自动重试。`;
+            processor.primaryError = `CLI 输出观察失败：${error.message}；送达结果未知，不自动重试。`;
             this.finalizeRecoveredRun(sessionId, requestId, processor, replayView, {
                 exitCode: 1, signal: null, stderr: processor.stderr, stdoutTruncated: true,
             });
+            runningHandle?.interrupt();
             flushEmit();
         };
         const captureStdout = (text) => {
@@ -880,6 +901,10 @@ export class StructuredSessionManager {
             processor.stderr += event.data;
         });
         runningHandle.onExit((event) => {
+            if (event.processExited === false) {
+                fileFailure(new Error("CLI 输出连接中断，正在等待原进程停止；新消息会排队。"));
+                return;
+            }
             if (fileFailed)
                 return;
             try {
@@ -911,6 +936,7 @@ export class StructuredSessionManager {
             this.releasePendingRunnerExecution(sessionId, execution);
         else
             this.execHost?.forgetRun(structuredRunId(sessionId));
+        this.settleNativeInputs(sessionId, requestId, processor.state);
         const current = this.sessions.get(sessionId);
         if (!current)
             return;
@@ -1095,8 +1121,6 @@ export class StructuredSessionManager {
             return;
         this.unacceptedTeamStarts.delete(sessionId);
         this.recoveredLogicalRequests.delete(sessionId);
-        const keyPrefix = `${sessionId}:`;
-        this.seenIdempotencyKeys.deleteMatching((key) => key.startsWith(keyPrefix));
     }
     /**
      * Arms the per-session "no protocol output yet" watchdog. It is unref'd so it can
@@ -1136,8 +1160,10 @@ export class StructuredSessionManager {
         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);
+        this.storage.transaction(() => {
+            this.storage.updateSessionRuntimeMetadata(snapshot);
+            this.storage.checkpointSessionMessages(snapshot.id, snapshot.messages ?? [], snapshot.structuredState, includeOutput ? snapshot.output : undefined);
+        });
     }
     list() {
         return Array.from(this.sessions.values())
@@ -1504,6 +1530,138 @@ export class StructuredSessionManager {
         if (this.disposed)
             throw new Error("StructuredSessionManager has been disposed.");
         let session = this.requireSession(id);
+        // Scheduler/interrupt continuation consumes an already accepted item, never
+        // creates a second acceptance or replays an uncertain external execution.
+        if (opts?.scheduling?.acceptanceId)
+            return this.sendAcceptedMessage(id, input, opts);
+        const key = opts?.idempotencyKey;
+        if (key !== undefined && (!key || Buffer.byteLength(key) > 256)) {
+            throw Object.assign(new Error("幂等键必须为 1 至 256 字节。"), { code: "invalid_idempotency_key" });
+        }
+        const signature = createHash("sha256").update(JSON.stringify(opts?.promotion
+            ? { v: 1, action: "promote", index: opts.promotion.index, expectedText: opts.promotion.expectedText ?? null }
+            : { v: 1, action: "message", input: input.trim(), interrupt: !!opts?.interrupt,
+                preserveQueue: !!opts?.interrupt && !!opts?.preserveQueue, source: opts?.source ?? "task" })).digest("hex");
+        const previous = key ? this.storage.getStructuredInputReceipt(id, key, signature) : null;
+        if (previous) {
+            opts?.onAccepted?.(previous);
+            return session;
+        }
+        let prompt = input.trim();
+        if (opts?.promotion) {
+            this.requireRecoveryControl(id);
+            this.assertNativeInputMutable(session);
+            if (this.coreRestartDrains > 0 && this.usesCoreEngine(session)) {
+                throw new Error("服务正在排空 Wand Agent，排队消息已保留，请稍后重试立即发送。");
+            }
+            const { index, expectedText } = opts.promotion;
+            const queue = session.queuedMessages ?? [];
+            if (!Number.isInteger(index) || index < 0 || index >= queue.length)
+                throw new Error("队列中没有该条消息（可能已被处理）。");
+            if (expectedText !== undefined && queue[index] !== expectedText)
+                throw new Error("排队消息已变化，请按最新顺序重试。");
+            prompt = queue[index];
+            session = { ...session, queuedMessages: queue.filter((_, at) => at !== index),
+                queuedInputScheduling: queuedInputScheduling(session).filter((_, at) => at !== index) };
+        }
+        if (!prompt) {
+            opts?.onAccepted?.();
+            return session;
+        }
+        if (this.unsupportedStructuredProviders.has(id))
+            throw new Error("会话使用的 provider 已不受支持，不能继续发送。");
+        const acceptanceId = randomUUID();
+        const acceptedAt = isoNow();
+        const receipt = key
+            ? { accepted: true, acceptanceId, sessionId: id, idempotencyKey: key, acceptedAt } : undefined;
+        const scheduling = { ...(opts?.scheduling
+                ?? { source: opts?.source ?? "task", enqueuedAt: acceptedAt, sequence: ++this.inputSequence,
+                    teamRequestStarted: opts?.teamRequestStarted }), acceptanceId };
+        const relay = this.relayHandlerFor(session);
+        const childActive = this.pendingRunnerExecutions.has(id) || this.pendingRecoveryIds.includes(id) || this.nativeProcessExits.has(id);
+        const interrupt = !!opts?.interrupt && !!session.structuredState?.inFlight && childActive;
+        if (interrupt) {
+            this.requireRecoveryControl(id);
+            this.assertNativeInputMutable(session);
+        }
+        const mustQueue = !relay && ((this.coreRestartDrains > 0 && this.usesCoreEngine(session))
+            || this.autoAssignPending.has(id) || (childActive && !interrupt)
+            || (!!session.employeeId && !!this.employeeInputAdmission
+                && !this.employeeInputAdmission.canStart(session, scheduling, opts?.immediateStart)));
+        if (mustQueue && !opts?.promotion) {
+            if (isDuplicateStructuredQueueInput(session, prompt)) {
+                throw Object.assign(new Error("与上一条消息相同，已忽略，不会加入排队。"), { code: "duplicate_queued_message" });
+            }
+            if ((session.queuedMessages?.length ?? 0) >= 10)
+                throw new Error("排队消息已满（最多 10 条），请等待当前消息处理完成。");
+        }
+        let queue = session.queuedMessages ?? [];
+        let metadata = queuedInputScheduling(session);
+        if (interrupt && !opts?.preserveQueue) {
+            queue = [];
+            metadata = [];
+        }
+        if (interrupt && opts?.preserveQueue && !opts.queueAlreadyRemoved && !opts.promotion) {
+            const at = queue.indexOf(prompt);
+            if (at >= 0) {
+                queue = queue.filter((_, index) => index !== at);
+                metadata = metadata.filter((_, index) => index !== at);
+            }
+        }
+        const accepted = relay
+            ? { ...session, messages: [...(session.messages ?? []), buildUserTurn(prompt, undefined, acceptedAt)] }
+            : { ...session, queuedMessages: interrupt ? [prompt, ...queue] : [...queue, prompt],
+                queuedInputScheduling: interrupt ? [scheduling, ...metadata] : [...metadata, scheduling] };
+        // Persist before publishing state, generating a topic, interrupting or starting a runner.
+        const inserted = receipt ? this.storage.acceptStructuredInput(accepted, signature, receipt, !!relay)
+            : this.storage.transaction(() => {
+                if (relay)
+                    this.checkpointSessionMessages(accepted);
+                else
+                    this.storage.updateSessionRuntimeMetadata(accepted);
+                return true;
+            });
+        if (!inserted) {
+            opts?.onAccepted?.(this.storage.getStructuredInputReceipt(id, key, signature));
+            return this.requireSession(id);
+        }
+        this.sessions.set(id, accepted);
+        opts?.onAccepted?.(receipt);
+        if (relay)
+            return this.relayUserMessage(id, prompt, relay, true);
+        if (mustQueue && !interrupt) {
+            this.emitStructuredSnapshot(accepted);
+            if (accepted.employeeId)
+                this.employeeInputAdmission?.schedule(accepted.employeeId);
+            return accepted;
+        }
+        return this.sendAcceptedMessage(id, prompt, { ...opts, scheduling, queueAlreadyRemoved: true,
+            // Accepted replacement is now itself a durable queue item; the original
+            // clear/preserve intent was applied in the acceptance transaction above.
+            preserveQueue: interrupt ? true : opts?.preserveQueue });
+    }
+    withoutAcceptedQueueItem(session, scheduling) {
+        if (!scheduling?.acceptanceId)
+            return session;
+        const at = queuedInputScheduling(session).findIndex(item => item.acceptanceId === scheduling.acceptanceId);
+        if (at < 0)
+            return session;
+        return { ...session, queuedMessages: session.queuedMessages?.filter((_, index) => index !== at),
+            queuedInputScheduling: queuedInputScheduling(session).filter((_, index) => index !== at) };
+    }
+    sendAcceptedMessage(id, input, opts) {
+        const acceptanceId = opts?.scheduling?.acceptanceId;
+        if (acceptanceId)
+            this.dispatchingAcceptedInputs.add(acceptanceId);
+        return this.runAcceptedMessage(id, input, opts).finally(() => {
+            if (acceptanceId)
+                this.dispatchingAcceptedInputs.delete(acceptanceId);
+        });
+    }
+    async runAcceptedMessage(id, input, opts) {
+        if (this.disposed)
+            throw new Error("StructuredSessionManager has been disposed.");
+        let session = this.withoutAcceptedQueueItem(this.requireSession(id), opts?.scheduling);
         const prompt = input.trim();
         if (!prompt)
             return session;
@@ -1515,8 +1673,6 @@ export class StructuredSessionManager {
         const relay = this.relayHandlerFor(session);
         if (relay)
             return await this.relayUserMessage(id, prompt, relay);
-        if (opts?.idempotencyKey)
-            this.claimIdempotencyKey(id, opts.idempotencyKey);
         // The drain owns Core admission, not CLI admission. Check before any
         // asynchronous selection/topic work; accepted Core inputs remain durable.
         if (this.coreRestartDrains > 0 && this.usesCoreEngine(session))
@@ -1525,6 +1681,8 @@ export class StructuredSessionManager {
         // 「智能分配」结算窗口：还没有 runner 归属，新输入先排队，不能另起一轮。
         if (this.autoAssignPending.has(id))
             return this.enqueueInput(session, prompt, false, scheduling);
+        if (!session.structuredState?.inFlight)
+            this.assertNativeInputMutable(session);
         const inFlight = this.resolveInFlightSend(id, session, prompt, opts);
         if ("result" in inFlight)
             return inFlight.result;
@@ -1533,10 +1691,10 @@ export class StructuredSessionManager {
             return this.enqueueInput(session, prompt, false, scheduling);
         }
         if (isAutoAssignSelector(session.selectedModel)) {
-            const assigned = await this.settleAutoAssignForSend(id, session, prompt);
+            const assigned = await this.settleAutoAssignForSend(id, session, prompt, scheduling.acceptanceId);
             if ("result" in assigned)
                 return assigned.result;
-            session = this.requireSession(id);
+            session = this.withoutAcceptedQueueItem(this.requireSession(id), scheduling);
             // Selection yielded: a drain or another input may now own admission.
             // This request preceded inputs accepted during its selection window.
             if (this.coreRestartDrains > 0 && this.usesCoreEngine(session))
@@ -1563,7 +1721,7 @@ export class StructuredSessionManager {
         // a durable transcript identity. Team startup correlation IDs are private
         // lifecycle tokens and must never be copied into persisted/public messages.
         const transcriptRequestId = session.automationId?.startsWith("wand-task-comment:") ? requestId : undefined;
-        const userTurn = buildUserTurn(prompt, pendingAsk, userTurnAt, transcriptRequestId);
+        const userTurn = buildUserTurn(prompt, pendingAsk, userTurnAt, transcriptRequestId, session.provider === "pi" && session.structuredState?.engine !== "core" ? randomUUID() : undefined);
         this.unacceptedTeamStarts.delete(id);
         if (this.unsupportedStructuredProviders.has(id)) {
             throw new Error(`会话使用的 provider 已不受支持，不能继续发送。`);
@@ -1584,10 +1742,10 @@ export class StructuredSessionManager {
                 lastError: null,
             }),
         };
+        this.checkpointSessionMessages(updated);
         this.sessions.set(id, updated);
         if (updated.automationId?.startsWith("ai-team:"))
             (opts?.teamRequestStarted ?? scheduling.teamRequestStarted)?.(id, requestId);
-        this.checkpointSessionMessages(updated);
         this.emitStructuredSnapshot(updated);
         if (transcriptRequestId)
             this.storage.bindTaskCommentResultStart(id, transcriptRequestId, updated.messages.length - 1);
@@ -1616,8 +1774,11 @@ export class StructuredSessionManager {
         }
     }
     /** 群聊不起 CLI：先落下用户这句话，再交给转发方；转发失败以提示行告诉用户。 */
-    async relayUserMessage(id, prompt, relay) {
-        const posted = this.appendRelayTurns(id, [{ role: "user", content: [{ type: "text", text: prompt }] }]);
+    async relayUserMessage(id, prompt, relay, accepted = false) {
+        const posted = accepted ? this.requireSession(id)
+            : this.appendRelayTurns(id, [{ role: "user", content: [{ type: "text", text: prompt }] }]);
+        if (accepted)
+            this.emitStructuredSnapshot(posted);
         try {
             await relay(id, prompt);
         }
@@ -1628,29 +1789,18 @@ export class StructuredSessionManager {
         }
         return this.sessions.get(id) ?? posted;
     }
-    /** Rejects a repeated (session, key) pair; otherwise remembers it (bounded). */
-    claimIdempotencyKey(id, idempotencyKey) {
-        const mapKey = `${id}:${idempotencyKey}`;
-        if (this.seenIdempotencyKeys.has(mapKey)) {
-            const err = new Error("检测到重复发送，已拦截。");
-            err.code = "duplicate_idempotency_key";
-            throw err;
-        }
-        // Bounded: BoundedKeySet drops the oldest half past IDEMPOTENCY_KEY_LIMIT.
-        this.seenIdempotencyKeys.add(mapKey);
-    }
     /**
      * While a turn is in flight, decide what this send does: recover a turn whose
      * runner is gone, interrupt the current turn, or queue the input. Returns the
      * session to continue with, or the value sendMessage should return now.
      */
     resolveInFlightSend(id, session, prompt, opts) {
-        if (!session.structuredState?.inFlight)
+        if (!session.structuredState?.inFlight && !this.nativeProcessExits.has(id))
             return { session };
         const runnerExecution = this.pendingRunnerExecutions.get(id);
         // interrupt() only requests cancellation; completion can settle later.
         // Treat runner-map ownership as the authoritative in-flight state.
-        const childActive = Boolean(runnerExecution) || this.pendingRecoveryIds.includes(id);
+        const childActive = Boolean(runnerExecution) || this.pendingRecoveryIds.includes(id) || this.nativeProcessExits.has(id);
         if (!childActive) {
             const recovered = {
                 ...session,
@@ -1662,8 +1812,8 @@ export class StructuredSessionManager {
                     activeRequestId: null,
                 },
             };
-            this.sessions.set(id, recovered);
-            this.storage.updateSessionRuntimeMetadata(recovered);
+            // The next start/queue checkpoint persists this transition together with
+            // the accepted item. Do not remove its durable queue entry in a prior write.
             return { session: recovered };
         }
         if (!opts?.interrupt)
@@ -1705,10 +1855,10 @@ export class StructuredSessionManager {
      * 「智能分配」：只有真拿到这一轮提示词才能结算成本次使用的分组。结算后钉在会话上，
      * 后续轮次用同一个分组（不在会话中途换模型）；客户端选择器同步显示实际分组。
      */
-    async settleAutoAssignForSend(id, session, prompt) {
+    async settleAutoAssignForSend(id, session, prompt, acceptanceId) {
         if (!isAutoAssignSelector(session.selectedModel))
             return { session };
-        const token = { cancelled: false };
+        const token = { cancelled: false, acceptanceId };
         this.autoAssignPending.set(id, token);
         let assigned;
         try {
@@ -1854,6 +2004,9 @@ export class StructuredSessionManager {
         // 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)) {
+            if (!this.pendingRunnerExecutions.has(id) && !this.nativeProcessExits.has(id)
+                && !current.structuredState?.inFlight)
+                setImmediate(() => { void this.flushNextQueuedMessage(id); });
             return current;
         }
         const retry = this.retryEmployeeCandidate(id, session, prompt, error, requestId);
@@ -1904,6 +2057,7 @@ export class StructuredSessionManager {
      */
     reorderQueuedMessages(sessionId, order, expectedQueue) {
         const session = this.requireSession(sessionId);
+        this.assertNativeInputMutable(session);
         const queue = session.queuedMessages ?? [];
         this.assertExpectedQueue(queue, expectedQueue);
         if (!Array.isArray(order) || order.length !== queue.length) {
@@ -1930,6 +2084,7 @@ export class StructuredSessionManager {
     /** Edit only the pending item still identified by both index and original text. */
     editQueuedMessage(sessionId, index, expectedText, text) {
         const session = this.requireSession(sessionId);
+        this.assertNativeInputMutable(session);
         const queue = session.queuedMessages ?? [];
         if (!Number.isInteger(index) || index < 0 || index >= queue.length || queue[index] !== expectedText) {
             throw new Error("排队消息已变化，请刷新后重试。");
@@ -1948,6 +2103,7 @@ export class StructuredSessionManager {
     /** Remove a single queued message only while index and text still identify the same item. */
     deleteQueuedMessage(sessionId, index, expectedText) {
         const session = this.requireSession(sessionId);
+        this.assertNativeInputMutable(session);
         const queue = session.queuedMessages ?? [];
         if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
             throw new Error("队列中没有该条消息（可能已被处理）。");
@@ -1971,48 +2127,12 @@ export class StructuredSessionManager {
      * on the server prevents clients from re-sending the text while the original
      * queue entry remains available for the automatic flush path.
      */
-    async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey) {
-        const session = this.requireSession(sessionId);
-        this.requireRecoveryControl(sessionId);
-        if (this.coreRestartDrains > 0 && this.usesCoreEngine(session)) {
-            throw new Error("服务正在排空 Wand Agent，排队消息已保留，请稍后重试立即发送。");
-        }
-        if (idempotencyKey && this.seenIdempotencyKeys.has(`${sessionId}:${idempotencyKey}`)) {
-            return session;
-        }
-        const queue = session.queuedMessages ?? [];
-        if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
-            throw new Error("队列中没有该条消息（可能已被处理）。");
-        }
-        if (expectedText !== undefined && queue[index] !== expectedText) {
-            throw new Error("排队消息已变化，请按最新顺序重试。");
-        }
-        const prompt = queue[index];
-        const remaining = queue.slice(0, index).concat(queue.slice(index + 1));
-        const inFlight = session.status === "running" && session.structuredState?.inFlight === true;
-        const updated = {
-            ...session,
-            queuedMessages: remaining,
-            queuedInputScheduling: queuedInputScheduling(session).filter((_, at) => at !== index),
-        };
-        this.sessions.set(sessionId, updated);
-        this.storage.updateSessionRuntimeMetadata(updated);
-        this.emitStructuredSnapshot(updated);
-        try {
-            return await this.sendMessage(sessionId, prompt, {
-                interrupt: inFlight,
-                preserveQueue: inFlight,
-                queueAlreadyRemoved: true,
-                immediateStart: true,
-                idempotencyKey,
-                source: "user",
-            });
-        }
-        catch {
-            // Once the item has been promoted it must not return to the queue: the
-            // send path may have already persisted its user turn before a runner error.
-            return this.requireSession(sessionId);
-        }
+    async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey, onAccepted) {
+        return this.sendMessage(sessionId, "", {
+            onAccepted,
+            interrupt: true, preserveQueue: true, queueAlreadyRemoved: true,
+            immediateStart: true, idempotencyKey, source: "user", promotion: { index, expectedText },
+        });
     }
     assertExpectedQueue(queue, expected) {
         if (expected !== undefined && (!Array.isArray(expected) || expected.length !== queue.length
@@ -2023,6 +2143,7 @@ export class StructuredSessionManager {
     /** Clear all queued messages. No-op when queue is already empty. */
     clearQueuedMessages(sessionId, expectedQueue) {
         const session = this.requireSession(sessionId);
+        this.assertNativeInputMutable(session);
         this.assertExpectedQueue(session.queuedMessages ?? [], expectedQueue);
         if (!session.queuedMessages || session.queuedMessages.length === 0) {
             return session;
@@ -2236,10 +2357,12 @@ export class StructuredSessionManager {
         const updated = { ...session, piSettings: updatedSettings };
         // Do not publish a setting that did not reach durable storage.
         this.storage.updateSessionRuntimeMetadata(updated);
-        // 记住这次设置：新建 Pi CLI 会话以它起步。只合并本次真正改动的字段——
+        // 只记住交互会话的选择，自动化/启动会话的临时工具限制不能污染用户默认。
+        // automationId 也用于用户单聊关联，不能用它判断会话来源。
+        // 新建 Pi CLI 会话以默认起步。只合并本次真正改动的字段——
         // 从旧默认起步的会话不能用自己的 stale 值（例如 autoResources=false）覆盖后来在别处开启的默认。
         // SDK 会话表达不出资源/CodeMode，不写回默认。
-        if (resolution.engine === "cli") {
+        if (resolution.engine === "cli" && (session.sessionSource ?? "interactive") === "interactive") {
             const defaults = this.storage.getPiSessionDefaults() ?? defaultPiCliSessionSettings(this.config.harness?.compaction?.enabled ?? true);
             this.storage.setPiSessionDefaults(mergePiSessionDefaults(defaults, patch));
         }
@@ -2397,8 +2520,13 @@ export class StructuredSessionManager {
     }
     stop(id) {
         this.unacceptedTeamStarts.delete(id);
-        const session = this.requireSession(id);
+        let session = this.requireSession(id);
         this.requireRecoveryControl(id);
+        if (session.structuredState?.activeRequestId) {
+            this.settleNativeInputs(id, session.structuredState.activeRequestId, { blocks: [], result: "", sessionId: session.claudeSessionId }, true);
+            session = this.requireSession(id);
+        }
+        session = this.withoutAcceptedQueueItem(session, this.autoAssignPending.get(id));
         // 结算中的智能分配还没有 runner：置位取消，结算回来后不得再启动。
         this.disposeSession(id, "run");
         // Clearing activeRequestId is the generation barrier: late data/close callbacks
@@ -2506,7 +2634,26 @@ export class StructuredSessionManager {
     releasePendingRunnerExecution(sessionId, execution, forgetRun = true) {
         if (this.pendingRunnerExecutions.get(sessionId) !== execution)
             return false;
+        const exits = this.nativeProcessExits.get(sessionId);
+        if (forgetRun && exits?.size) {
+            // A protocol/observation result is not an OS exit. Keep the handle usable
+            // for stop and prevent a new input from colliding with the live tmux owner.
+            void Promise.all([...exits]).then(() => {
+                if (!this.releasePendingRunnerExecution(sessionId, execution, forgetRun))
+                    return;
+                const current = this.sessions.get(sessionId);
+                if (!this.disposed && (this.execHost?.persistent || current?.status === "idle")
+                    && current?.status !== "running" && !current?.structuredState?.inFlight) {
+                    void this.flushNextQueuedMessage(sessionId);
+                }
+            }, () => { });
+            return false;
+        }
         this.pendingRunnerExecutions.delete(sessionId);
+        const current = this.sessions.get(sessionId);
+        if (forgetRun && !this.disposed && current?.status === "idle" && !current.structuredState?.inFlight) {
+            setImmediate(() => { void this.flushNextQueuedMessage(sessionId); });
+        }
         // A failed recovery attach must retain the daemon record for the next retry.
         if (forgetRun) {
             const exits = this.nativeProcessExits.get(sessionId);
@@ -2532,7 +2679,7 @@ export class StructuredSessionManager {
     beginTurn(sessionId, state) {
         const at = isoNow();
         this.turnHeartbeat.observe(sessionId);
-        return { ...state, turnStartedAt: at, lastActivityAt: at };
+        return { ...state, inputMode: state.engine === "core" ? "steer" : "turn-end", turnStartedAt: at, lastActivityAt: at };
     }
     /**
      * 领养 daemon 里仍在飞的回合：起点是重启前那一轮的真实时刻，不能改写成重连时刻；
@@ -2607,14 +2754,126 @@ export class StructuredSessionManager {
             data,
         });
     }
+    /** Native Pi claims one durable queue item; the reservation survives until its transcript commit. */
+    reserveNativeInput(sessionId, requestId, identity) {
+        const current = this.currentSessionForRequest(sessionId, requestId);
+        if (!current || this.disposed || this.interruptedWith.has(sessionId))
+            return null;
+        const scheduling = queuedInputScheduling(current);
+        const index = scheduling.findIndex(item => item.source === "user");
+        const text = index >= 0 ? current.queuedMessages?.[index] : undefined;
+        if (text === undefined || scheduling.some(item => item.handoff))
+            return null;
+        const reserved = scheduling.map((item, at) => at === index ? { ...item, handoff: identity } : item);
+        const updated = { ...current, queuedInputScheduling: reserved };
+        this.storage.updateSessionRuntimeMetadata(updated);
+        this.sessions.set(sessionId, updated);
+        this.emitStructuredSnapshot(updated);
+        return text;
+    }
+    /** A claim is the native transcript commit: persist the boundary and remove only that reservation. */
+    commitNativeInput(sessionId, requestId, offer, state) {
+        const current = this.currentSessionForRequest(sessionId, requestId);
+        if (!current)
+            return;
+        const scheduling = queuedInputScheduling(current);
+        const index = scheduling.findIndex(item => item.handoff?.id === offer.id);
+        const alreadyCommitted = current.messages?.some(turn => turn.role === "user" && turn.messageId === offer.id);
+        if (state.inputMessageId === offer.id || (index < 0 && !alreadyCommitted)
+            || (index >= 0 && current.queuedMessages?.[index] !== offer.text))
+            return;
+        const preceding = state.blocks.length || state.result
+            ? this.buildCompletedAssistantMessages(current, state) : [...(current.messages ?? [])];
+        const committed = {
+            ...current,
+            queuedMessages: current.queuedMessages?.filter((_, at) => at !== index),
+            queuedInputScheduling: scheduling.filter((_, at) => at !== index),
+            messages: preceding.some(turn => turn.messageId === offer.id) ? preceding
+                : [...preceding, buildUserTurn(offer.text, undefined, isoNow(), undefined, offer.id)],
+        };
+        this.saveAuthoritativeSession(committed);
+        state.blocks = [];
+        state.result = "";
+        state.usage = undefined;
+        state.inputMessageId = offer.id;
+        this.sessions.set(sessionId, committed);
+        this.emitStructuredSnapshot(committed);
+    }
+    handleNativeInputEvent(sessionId, requestId, event, state) {
+        if (event.type === "wand_input_boundary" && typeof event.id === "string") {
+            this.execHost?.offerPiInput?.(structuredRunId(sessionId), event.id, identity => this.reserveNativeInput(sessionId, requestId, identity));
+        }
+        if (event.type === "wand_input_ready" && typeof event.id === "string")
+            state.inputMessageId = event.id;
+        if (event.type === "wand_input_boundary") {
+            const current = this.currentSessionForRequest(sessionId, requestId);
+            if (current && current.structuredState?.inputMode !== "steer") {
+                const updated = { ...current, structuredState: { ...current.structuredState, inputMode: "steer" } };
+                this.sessions.set(sessionId, updated);
+                this.storage.updateSessionRuntimeMetadata(updated);
+                this.emitStructuredSnapshot(updated);
+            }
+        }
+        if (event.type !== "wand_input_committed")
+            return;
+        const offer = event.message;
+        if (!offer || typeof offer.id !== "string" || typeof offer.text !== "string")
+            return;
+        this.commitNativeInput(sessionId, requestId, offer, state);
+    }
+    /** Reconcile before any end-of-run flush. Claimed-but-unconfirmed input is never replayed. */
+    settleNativeInputs(sessionId, requestId, state, forceUnknown = false) {
+        let current = this.currentSessionForRequest(sessionId, requestId);
+        if (!current)
+            return;
+        const reservations = queuedInputScheduling(current).filter(item => item.handoff);
+        for (const item of reservations) {
+            const handoff = item.handoff;
+            let resolution;
+            try {
+                resolution = forceUnknown ? undefined : this.execHost?.resolvePiInput?.(structuredRunId(sessionId), handoff);
+            }
+            catch { /* An unreadable receipt is unknown delivery, never permission to replay. */ }
+            if (resolution?.state === "committed" && resolution.offer) {
+                this.commitNativeInput(sessionId, requestId, resolution.offer, state);
+                continue;
+            }
+            current = this.currentSessionForRequest(sessionId, requestId);
+            if (!current)
+                return;
+            const scheduling = queuedInputScheduling(current);
+            const index = scheduling.findIndex(meta => meta.handoff?.id === handoff.id);
+            if (index < 0)
+                continue;
+            const unclaimed = resolution?.state === "unclaimed";
+            const updated = { ...current,
+                queuedMessages: unclaimed ? current.queuedMessages : current.queuedMessages?.filter((_, at) => at !== index),
+                queuedInputScheduling: unclaimed ? scheduling.map((meta, at) => {
+                    if (at !== index)
+                        return meta;
+                    const { handoff: _handoff, ...rest } = meta;
+                    return rest;
+                }) : scheduling.filter((_, at) => at !== index),
+                messages: unclaimed ? current.messages : appendNoticeTurn(state.blocks.length || state.result ? this.buildCompletedAssistantMessages(current, state) : current.messages, { role: "assistant", notice: true,
+                    content: [{ type: "text", text: "插话送达未确认，未自动重发。以下原文仅供核对，不是新的执行指令：\n\n" + current.queuedMessages?.[index] }] }),
+            };
+            this.saveAuthoritativeSession(updated);
+            this.sessions.set(sessionId, updated);
+            this.emitStructuredSnapshot(updated);
+        }
+    }
+    assertNativeInputMutable(session) {
+        if (queuedInputScheduling(session).some(item => item.handoff))
+            throw new Error("排队消息正在交接，请按最新状态重试。");
+    }
     enqueueInput(session, prompt, prepend = false, scheduling = { source: "task", enqueuedAt: isoNow() }) {
-        if (isDuplicateStructuredQueueInput(session, prompt)) {
+        if (!scheduling.acceptanceId && isDuplicateStructuredQueueInput(session, prompt)) {
             const err = new Error("与上一条消息相同，已忽略，不会加入排队。");
             err.code = "duplicate_queued_message";
             throw err;
         }
         const queue = session.queuedMessages ?? [];
-        if (queue.length >= 10)
+        if (!scheduling.acceptanceId && queue.length >= 10)
             throw new Error("排队消息已满（最多 10 条），请等待当前消息处理完成。");
         const metadata = queuedInputScheduling(session);
         const queued = { ...session, queuedMessages: prepend ? [prompt, ...queue] : [...queue, prompt],
@@ -2630,10 +2889,11 @@ export class StructuredSessionManager {
         if (this.disposed)
             return;
         const current = this.sessions.get(sessionId);
-        if (!current || (current.queuedMessages?.length ?? 0) === 0) {
+        if (!current || queuedInputScheduling(current).some(item => item.handoff) || (current.queuedMessages?.length ?? 0) === 0) {
             return;
         }
-        if (current.structuredState?.inFlight || (this.coreRestartDrains > 0 && this.usesCoreEngine(current))) {
+        if (current.structuredState?.inFlight || this.nativeProcessExits.has(sessionId) || this.pendingRunnerExecutions.has(sessionId)
+            || (this.coreRestartDrains > 0 && this.usesCoreEngine(current))) {
             return;
         }
         if (current.employeeId && this.employeeInputAdmission && !fromEmployeeScheduler) {
@@ -2641,28 +2901,25 @@ export class StructuredSessionManager {
             return;
         }
         const nextInput = current.queuedMessages?.[index];
-        const scheduling = queuedInputScheduling(current)[index];
-        const restQueue = current.queuedMessages.filter((_, at) => at !== index);
-        if (!nextInput) {
+        const scheduling = { ...queuedInputScheduling(current)[index],
+            acceptanceId: queuedInputScheduling(current)[index]?.acceptanceId ?? randomUUID() };
+        if (!nextInput)
             return;
-        }
-        const nextSession = {
-            ...current,
-            queuedMessages: restQueue,
-            queuedInputScheduling: queuedInputScheduling(current).filter((_, at) => at !== index),
-        };
-        this.sessions.set(sessionId, nextSession);
-        this.storage.updateSessionRuntimeMetadata(nextSession);
-        this.emitStructuredSnapshot(nextSession);
+        // Legacy queues acquire an identity before dispatch too. The queue item stays
+        // durable until its user turn and removal commit together.
+        const identified = { ...current, queuedInputScheduling: queuedInputScheduling(current).map((item, at) => at === index ? scheduling : item) };
+        this.storage.updateSessionRuntimeMetadata(identified);
+        this.sessions.set(sessionId, identified);
         try {
-            await this.sendMessage(sessionId, nextInput, { scheduling });
+            await this.sendAcceptedMessage(sessionId, nextInput, { scheduling });
         }
         catch (error) {
             console.error("[WAND] flushNextQueuedMessage failed:", error);
             // Only an explicit pre-execution rejection permits replay. A persisted
             // runner failure or arbitrary exception can mean delivery is unknown.
             const afterFail = this.sessions.get(sessionId);
-            if (afterFail && error instanceof UnacceptedStructuredInputError) {
+            const stillQueued = afterFail && queuedInputScheduling(afterFail).some(item => item.acceptanceId === scheduling.acceptanceId);
+            if (afterFail && error instanceof UnacceptedStructuredInputError && !stillQueued) {
                 const rescued = {
                     ...afterFail,
                     queuedMessages: [nextInput, ...(afterFail.queuedMessages ?? [])],
@@ -2672,7 +2929,7 @@ export class StructuredSessionManager {
                 this.storage.updateSessionRuntimeMetadata(rescued);
                 this.emitStructuredSnapshot(rescued);
             }
-            else if (afterFail && (afterFail.messages?.length ?? 0) <= (current.messages?.length ?? 0)) {
+            else if (afterFail && !stillQueued && (afterFail.messages?.length ?? 0) <= (current.messages?.length ?? 0)) {
                 // If dispatch failed before a user turn was checkpointed, retain the
                 // original visibly for reconciliation, never as another sendable item.
                 const retained = { ...afterFail, messages: appendNoticeTurn(afterFail.messages, {
@@ -2721,7 +2978,9 @@ export class StructuredSessionManager {
                     usage: turnState.usage,
                     ...(turnState.resourceSelection ? { resourceSelection: turnState.resourceSelection } : {}),
                 };
-                messages = upsertAssistantMessage(current.messages, turn);
+                messages = turnState.inputMessageId
+                    ? upsertPiAssistantSegment(current.messages, turn, turnState.inputMessageId)
+                    : upsertAssistantMessage(current.messages, turn);
             }
             const patched = {
                 ...current,
@@ -2767,6 +3026,9 @@ export class StructuredSessionManager {
             session,
             prompt,
             env: buildChildEnv(this.config.inheritEnv !== false),
+            ...(provider === "pi" && session.structuredState?.engine !== "core" ? {
+                onPiInputEvent: (event, state) => this.handleNativeInputEvent(sessionId, requestId, event, state),
+            } : {}),
             ...(provider === "pi" && session.structuredState?.engine === "core" ? {
                 takeSteering: (turnState) => {
                     const current = this.currentSessionForRequest(sessionId, requestId);
@@ -2834,6 +3096,10 @@ export class StructuredSessionManager {
         let result;
         try {
             result = await execution.completion;
+            // Wrappers may resolve their exit promise a microtask after completion.
+            // Only an explicit observation-only result keeps ownership after return.
+            if (result.processExited !== false && execution.exited)
+                await execution.exited;
         }
         finally {
             turnCompleted = true;
@@ -2871,6 +3137,8 @@ export class StructuredSessionManager {
             primaryError: result.primaryError,
             ...(provider === "codex" ? { codexErrors: result.errors, codexTurnFailed: result.primaryError } : {}),
         });
+        if (provider === "pi")
+            this.settleNativeInputs(sessionId, requestId, result.state);
         const current = this.currentSessionForRequest(sessionId, requestId);
         if (!current)
             return;
@@ -3018,7 +3286,16 @@ export class StructuredSessionManager {
             usage: turnState.usage,
             ...(turnState.resourceSelection ? { resourceSelection: turnState.resourceSelection } : {}),
         };
-        return upsertAssistantMessage(current.messages, assistantTurn, true, stampNewTools);
+        if (turnState.inputMessageId && !turnState.blocks.length && !turnState.result && current.messages?.at(-1)?.role === "user")
+            return [...current.messages];
+        if (turnState.inputMessageId)
+            return upsertPiAssistantSegment(current.messages, assistantTurn, turnState.inputMessageId, true);
+        // A delivery notice is independent of the preceding assistant segment.
+        const messages = [...(current.messages ?? [])];
+        const notices = [];
+        while (messages.at(-1)?.notice)
+            notices.unshift(messages.pop());
+        return [...upsertAssistantMessage(messages, assistantTurn, true, stampNewTools), ...notices];
     }
     /**
      * Rebuild the trailing assistant turn when the replayed log was truncated.