@co0ontty/wand 4.106.0 → 4.106.1

package/dist/structured-exec-pump.js

@@ -22,6 +22,7 @@ export function startStructuredCli(options) {
     // history snapshot must not exhaust the raw-file quota before SAX can read it.
     const captureReader = options.stdoutFile ? options.createProtocolReader?.((line) => stdoutFile?.append(line + "\n")) : undefined;
     let settled = false;
+    let processExited = false;
     let stopRequested = false;
     let stopDelivered = false;
     // A pending spawn has no cancellable handle yet. Remember one request and
@@ -36,14 +37,14 @@ export function startStructuredCli(options) {
         catch { /* best-effort interruption */ }
     }
     function requestStop() {
-        if (settled || stopRequested)
+        if (processExited || stopRequested)
             return;
         stopRequested = true;
         launchController?.abort();
         interruptSource();
     }
     let acknowledgeExit = () => { };
-    const exited = new Promise((resolve) => { acknowledgeExit = resolve; });
+    const exited = new Promise((resolve) => { acknowledgeExit = () => { processExited = true; resolve(); }; });
     let resolveCompletion;
     let rejectCompletion;
     const completion = new Promise((resolve, reject) => {
@@ -78,7 +79,7 @@ export function startStructuredCli(options) {
         try {
             if (!protocolError && lineBuffer.trim())
                 options.processLine(lineBuffer, ctx);
-            const result = options.finalize(ctx, exitCode, signal, spawnError);
+            const result = { ...options.finalize(ctx, exitCode, signal, spawnError), processExited };
             resolveCompletion(beforeSpawn ? { ...result, primaryError: spawnError?.message ?? "Pi 实时事件文件初始化失败。",
                 inputAccepted: false, retryForbidden: true, failure: { kind: "preflight", delivery: "rejected", retryable: false } }
                 : protocolError ? { ...result, exitCode: 1, primaryError: protocolError.message,
@@ -185,7 +186,7 @@ export function startStructuredCli(options) {
             cwd: options.cwd,
             env: options.env,
             ...(options.stdinData !== undefined ? { stdinData: options.stdinData } : {}),
-            ...(options.nativePi ? { nativePi: true } : {}),
+            ...(options.nativePi ? { nativePi: true, nativeInputMessageId: options.nativeInputMessageId } : {}),
             ...(options.requestId ? { requestId: options.requestId } : {}),
             ...(launchController ? { launchSignal: launchController.signal } : {}),
         };
@@ -209,7 +210,7 @@ export function startStructuredCli(options) {
             void host.spawnStructured(request).then((handle) => {
                 source = { pid: handle.pid, interrupt: () => handle.interrupt() };
                 // Replay and subscribe before applying a pending external cancellation.
-                wireRemoteHandle(handle, captureStdout, handleStderrText, finish, acknowledgeExit, (event) => {
+                wireRemoteHandle(handle, captureStdout, handleStderrText, finish, acknowledgeExit, () => finish(1, null, undefined, new Error("CLI 输出连接中断，正在等待原进程停止；新消息会排队。")), (event) => {
                     if (!settled && options.nativePi && event.stream === "stdout" && handle.protocolSource
                         && protocolReader?.atBoundary && observer.isActive()) {
                         options.checkpoint?.({ incarnationId: handle.incarnationId, source: handle.protocolSource, offset: event.seq });
@@ -236,7 +237,11 @@ export function startStructuredCli(options) {
         const stderrDecoder = createUtf8TextDecoder();
         child.stdout?.on("data", (chunk) => captureStdout(stdoutDecoder.write(chunk)));
         child.stderr?.on("data", (chunk) => handleStderrText(stderrDecoder.write(chunk)));
-        child.on("error", (error) => finish(null, null, error));
+        child.on("error", (error) => {
+            if (!child.pid)
+                acknowledgeExit(); // Spawn failed before any process existed.
+            finish(null, null, error);
+        });
         child.stdin?.on("error", (error) => {
             requestStop();
             finish(null, null, error);
@@ -252,7 +257,7 @@ export function startStructuredCli(options) {
     }
     return execution;
 }
-function wireRemoteHandle(handle, onStdout, onStderr, finish, acknowledgeExit, afterStream) {
+function wireRemoteHandle(handle, onStdout, onStderr, finish, acknowledgeExit, observationFailed, afterStream) {
     const stream = handle.onStream((event) => {
         if (event.stream === "stdout")
             onStdout(event.data);
@@ -264,11 +269,13 @@ function wireRemoteHandle(handle, onStdout, onStderr, finish, acknowledgeExit, a
     let ended = false;
     exit = handle.onExit((event) => {
         stream.dispose();
-        if (event.processExited !== false) {
-            ended = true;
-            exit?.dispose();
-            acknowledgeExit();
+        if (event.processExited === false) {
+            observationFailed();
+            return;
         }
+        ended = true;
+        exit?.dispose();
+        acknowledgeExit();
         finish(event.exitCode, signalNameFromNumber(event.signal));
     });
     if (ended)

package/dist/structured-opencode-adapter.d.ts

@@ -3,7 +3,7 @@ import type { StructuredExecHost } from "./structured-exec-host.js";
 import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver, StructuredRunnerTurnState } from "./structured-runner.js";
 import type { SessionSnapshot } from "./types.js";
 export type OpenCodeTurnState = StructuredRunnerTurnState;
-export declare function buildOpenCodeArgs(session: SessionSnapshot): string[];
+export declare function buildOpenCodeArgs(session: SessionSnapshot, major?: number): string[];
 /** Apply one OpenCode NDJSON event to the current transport-neutral turn state. */
 export declare function applyOpenCodeEvent(turnState: OpenCodeTurnState, event: Record<string, unknown>, createId?: () => string): string | null;
 /** Production adapter for the external `opencode run --format json` process. */
@@ -12,4 +12,5 @@ export declare class OpenCodeRunner implements StructuredRunnerAdapter {
     private readonly execHost?;
     constructor(spawnProcess?: typeof spawn, execHost?: StructuredExecHost | undefined);
     start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+    private startCli;
 }

package/dist/structured-opencode-adapter.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import { openCodeMajorVersion, openCodeModelArgs } from "./opencode-cli.js";
 import { startStructuredCli } from "./structured-exec-pump.js";
 import { asRecord } from "./structured-content.js";
 import { buildStructuredCliResult } from "./structured-failure.js";
@@ -19,14 +20,11 @@ function extractStructuredText(value) {
     }
     return "";
 }
-export function buildOpenCodeArgs(session) {
+export function buildOpenCodeArgs(session, major = 1) {
     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 (major >= 2)
+        args.push("--standalone");
+    args.push(...openCodeModelArgs(session.selectedModel, thinkingEffortToOpenCodeVariant(session.thinkingEffort), major));
     if (session.autoApprovePermissions === true
         || session.mode === "full-access"
         || session.mode === "managed"
@@ -121,7 +119,33 @@ export class OpenCodeRunner {
         this.execHost = execHost;
     }
     start(context, observer) {
-        const args = buildOpenCodeArgs(context.session);
+        const abort = new AbortController();
+        let execution;
+        const spawnedAt = new Date().toISOString();
+        const completion = Promise.resolve().then(async () => {
+            const major = await openCodeMajorVersion(context.env, abort.signal);
+            if (abort.signal.aborted || !observer.isActive())
+                throw new Error("OpenCode 启动已取消。");
+            execution = this.startCli(context, observer, major);
+            return execution.completion;
+        }).catch((error) => {
+            // Once launched, keep the runner's delivery facts; preparation is the only known rejection.
+            if (execution)
+                throw error;
+            return {
+                state: { blocks: [], result: "", sessionId: context.session.claudeSessionId },
+                exitCode: 1, signal: null, stderr: "", primaryError: error instanceof Error ? error.message : "OpenCode 启动准备失败。",
+                processExited: true, inputAccepted: false, retryForbidden: true,
+            };
+        });
+        return { spawnedAt, completion,
+            get args() { return execution?.args ?? []; }, get pid() { return execution?.pid ?? null; },
+            exited: completion.then(() => execution?.exited, () => execution?.exited).then(() => { }),
+            interrupt() { abort.abort(); execution?.interrupt(); },
+        };
+    }
+    startCli(context, observer, major) {
+        const args = buildOpenCodeArgs(context.session, major);
         const state = {
             blocks: [],
             result: "",

package/dist/structured-pi-adapter.js

@@ -296,6 +296,7 @@ export class PiRunner {
         const state = {
             blocks: [],
             result: "",
+            inputMessageId: [...(context.session.messages ?? [])].reverse().find(turn => turn.role === "user")?.messageId,
             sessionId: context.session.claudeSessionId,
             model: context.session.selectedModel ?? undefined,
             phase: "responding",
@@ -317,7 +318,7 @@ export class PiRunner {
             observer,
             execHost: this.execHost,
             spawnProcess: this.spawnProcess,
-            ...(nativePi ? { nativePi: true } : { stdoutFile: this.outputFiles?.(context.session.id) ?? {} }),
+            ...(nativePi ? { nativePi: true, nativeInputMessageId: state.inputMessageId } : { stdoutFile: this.outputFiles?.(context.session.id) ?? {} }),
             requestId: context.session.structuredState?.activeRequestId ?? undefined,
             createState: () => state,
             createProtocolReader: (onLine) => new PiProtocolReader(onLine),
@@ -329,8 +330,18 @@ export class PiRunner {
             processLine: (line) => {
                 if (!observer.isActive() || !line.trim())
                     return;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    unparsedOutput = true;
+                    return;
+                }
+                // Control/storage failures must reach the pump and stop this execution;
+                // they cannot be swallowed as harmless unparsed provider stdout.
+                context.onPiInputEvent?.(event, state);
                 try {
-                    const event = JSON.parse(line);
                     observer.onEvent?.(event);
                     protocolEventObserved = true;
                     const eventError = applyPiEvent(state, event, new Date().toISOString());

package/dist/structured-runner.d.ts

@@ -29,6 +29,8 @@ export interface StructuredCompactionNotice {
 export interface StructuredRunnerTurnState {
     blocks: ContentBlock[];
     result: string;
+    /** Native Pi segment identity, also retained in replay checkpoints. */
+    inputMessageId?: string;
     sessionId: string | null;
     model?: string;
     usage?: ConversationTurn["usage"];
@@ -51,6 +53,8 @@ export interface StructuredRunnerContext {
     modelGroupModels?: readonly string[];
     /** Core-only: synchronously persist one queued user turn and the preceding assistant segment. */
     takeSteering?(state: StructuredRunnerTurnState): string | null;
+    /** Native CLI control events, before the provider reducer mutates its segment. */
+    onPiInputEvent?(event: Record<string, unknown>, state: StructuredRunnerTurnState): void;
 }
 export interface StructuredRunnerObserver {
     isActive(): boolean;
@@ -67,6 +71,8 @@ export interface StructuredRunnerResult {
     signal: NodeJS.Signals | null;
     stderr: string;
     primaryError: string | null;
+    /** false means only observation settled; the CLI still owns its execution. */
+    processExited?: boolean;
     errors?: string[];
     stdoutTail?: string;
     stopReason?: "ask-user-question";

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

@@ -68,4 +68,6 @@ export declare function appendNoticeTurn(messages: ConversationTurn[] | undefine
 /** core 引擎的压缩通知 → 可持久化的会话上下文（历史不删，只记切点与摘要）。 */
 export declare function compactionToSessionContext(notice: StructuredCompactionNotice): HarnessSessionContext;
 export declare function cancelPendingResourceSelection(messages: ConversationTurn[] | undefined): ConversationTurn[] | undefined;
+/** Replace one Pi segment after a native steering input; earlier turns stay untouched. */
+export declare function upsertPiAssistantSegment(messages: ConversationTurn[] | undefined, turn: ConversationTurn, inputMessageId: string, complete?: boolean): ConversationTurn[];
 export declare function upsertAssistantMessage(messages: ConversationTurn[] | undefined, turn: ConversationTurn, complete?: boolean, stampNewTools?: boolean): ConversationTurn[];

package/dist/structured-session-manager-replay.js

@@ -373,6 +373,33 @@ export function cancelPendingResourceSelection(messages) {
                 ...last.resourceSelection, status: "cancelled", label: "本轮自动选择已取消",
             } }];
 }
+/** Replace one Pi segment after a native steering input; earlier turns stay untouched. */
+export function upsertPiAssistantSegment(messages, turn, inputMessageId, complete = false) {
+    const msgs = [...(messages ?? [])];
+    let at = -1;
+    for (let index = msgs.length - 1; index >= 0; index--) {
+        if (msgs[index].role === "user" && msgs[index].messageId === inputMessageId) {
+            at = index;
+            break;
+        }
+    }
+    if (at < 0)
+        return upsertAssistantMessage(msgs, turn, complete, false);
+    const previous = msgs[at + 1]?.role === "assistant" && !msgs[at + 1].notice ? msgs[at + 1] : undefined;
+    const next = { ...turn, createdAt: previous?.createdAt ?? turn.createdAt ?? isoNow(),
+        content: stampNewToolUseTimes(turn.content, previous?.content, isoNow(), true),
+        ...(turn.resourceSelection ? {} : previous?.resourceSelection ? { resourceSelection: previous.resourceSelection } : {}),
+    };
+    if (complete)
+        next.completedAt = previous?.completedAt ?? isoNow();
+    else if (previous?.completedAt)
+        next.completedAt = previous.completedAt;
+    if (previous)
+        msgs[at + 1] = next;
+    else
+        msgs.splice(at + 1, 0, next);
+    return msgs;
+}
 export function upsertAssistantMessage(messages, turn, complete = false, stampNewTools = true) {
     const msgs = [...(messages ?? [])];
     const last = msgs[msgs.length - 1];

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

@@ -1,5 +1,6 @@
 import { type OpenRouterFreeModelsService } from "./openrouter-free-models.js";
 import { type StructuredFailure } from "./structured-failure.js";
+import type { StructuredInputReceipt } from "./storage/session-input-repository.js";
 import { type WorktreeSetupSpec } from "./git-worktree.js";
 import { SessionLogger } from "./session-logger.js";
 import { WandStorage } from "./storage.js";
@@ -73,6 +74,21 @@ interface CreateStructuredSessionOptions {
  * 按 automationId 前缀识别，重启后照样生效。
  */
 export type StructuredRelayHandler = (sessionId: string, text: string) => void | Promise<void>;
+interface StructuredSendOptions {
+    interrupt?: boolean;
+    idempotencyKey?: string;
+    preserveQueue?: boolean;
+    queueAlreadyRemoved?: boolean;
+    immediateStart?: boolean;
+    teamRequestStarted?: (sessionId: string, requestId: string) => void;
+    source?: EmployeeInputScheduling["source"];
+    scheduling?: EmployeeInputScheduling;
+    onAccepted?: (receipt?: StructuredInputReceipt) => void;
+    promotion?: {
+        index: number;
+        expectedText?: string;
+    };
+}
 export declare class StructuredSessionManager {
     private readonly storage;
     private readonly config;
@@ -100,19 +116,12 @@ export declare class StructuredSessionManager {
     private readonly interruptedImmediateStart;
     private employeeInputAdmission;
     private inputSequence;
+    private readonly dispatchingAcceptedInputs;
     /** Last wall-clock time (ms) a streaming checkpoint reached SQLite. */
     private readonly lastStreamSaveAt;
     private readonly lastPiCheckpointAt;
     private readonly streamCheckpointTimers;
     private readonly streamCheckpointDirty;
-    /**
-     * 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 大小溢出时按时间裁剪。
-     */
-    private readonly seenIdempotencyKeys;
     private readonly relayHandlers;
     private readonly systemCallDrainReleases;
     private emitEvent;
@@ -141,6 +150,7 @@ export declare class StructuredSessionManager {
     private readonly unsupportedStructuredProviders;
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     private pendingRecoveryIds;
+    private detachedInventoryReconciled;
     private detachedRecoveryPromise;
     private detachedRecoveryRetryTimer;
     private detachedRecoveryFailureLogged;
@@ -204,6 +214,7 @@ export declare class StructuredSessionManager {
      */
     collectNativeGarbage(options: {
         liveSessionIds: ReadonlySet<string>;
+        activeSessionIds?: ReadonlySet<string>;
         retentionMs: number;
         now?: number;
     }): PiNativeGcReport | null;
@@ -246,20 +257,12 @@ export declare class StructuredSessionManager {
     private throwUnacceptedInput;
     /** 往转发会话里追加别的参与者的发言。 */
     appendRelayTurns(id: string, turns: ConversationTurn[]): SessionSnapshot | null;
-    sendMessage(id: string, input: string, opts?: {
-        interrupt?: boolean;
-        idempotencyKey?: string;
-        preserveQueue?: boolean;
-        queueAlreadyRemoved?: boolean;
-        immediateStart?: boolean;
-        teamRequestStarted?: (sessionId: string, requestId: string) => void;
-        source?: EmployeeInputScheduling["source"];
-        scheduling?: EmployeeInputScheduling;
-    }): Promise<SessionSnapshot>;
+    sendMessage(id: string, input: string, opts?: StructuredSendOptions): Promise<SessionSnapshot>;
+    private withoutAcceptedQueueItem;
+    private sendAcceptedMessage;
+    private runAcceptedMessage;
     /** 群聊不起 CLI：先落下用户这句话，再交给转发方；转发失败以提示行告诉用户。 */
     private relayUserMessage;
-    /** Rejects a repeated (session, key) pair; otherwise remembers it (bounded). */
-    private claimIdempotencyKey;
     /**
      * 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
@@ -299,7 +302,7 @@ export declare class StructuredSessionManager {
      * on the server prevents clients from re-sending the text while the original
      * queue entry remains available for the automatic flush path.
      */
-    promoteQueuedMessage(sessionId: string, index: number, expectedText?: string, idempotencyKey?: string): Promise<SessionSnapshot>;
+    promoteQueuedMessage(sessionId: string, index: number, expectedText?: string, idempotencyKey?: string, onAccepted?: (receipt?: StructuredInputReceipt) => void): Promise<SessionSnapshot>;
     private assertExpectedQueue;
     /** Clear all queued messages. No-op when queue is already empty. */
     clearQueuedMessages(sessionId: string, expectedQueue?: readonly string[]): SessionSnapshot;
@@ -387,6 +390,14 @@ export declare class StructuredSessionManager {
     private publishQuietHeartbeat;
     private commentTerminalEvent;
     private emitStructuredSnapshot;
+    /** Native Pi claims one durable queue item; the reservation survives until its transcript commit. */
+    private reserveNativeInput;
+    /** A claim is the native transcript commit: persist the boundary and remove only that reservation. */
+    private commitNativeInput;
+    private handleNativeInputEvent;
+    /** Reconcile before any end-of-run flush. Claimed-but-unconfirmed input is never replayed. */
+    private settleNativeInputs;
+    private assertNativeInputMutable;
     private enqueueInput;
     private flushNextQueuedMessage;
     private emit;