@co0ontty/wand 4.72.2 → 4.75.0-beta.g1d477a2

package/dist/task-types.d.ts

@@ -7,7 +7,8 @@ export declare const DEFAULT_WAND_TASK_PRIORITY: WandTaskPriority;
 /** 任务派发时选择的 CLI 工具；空串表示尚未指定。 */
 export type WandTaskAgentProvider = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi";
 export type WandTaskAgentModel = string;
-export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max";
+/** 与会话思考档位同一套：旧四档，或 `provider:level` 原生档。 */
+export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max" | `${WandTaskAgentProvider}:${string}`;
 /**
  * 派发时的执行模式，只暴露三种：
  *   - managed：托管，自动确认全部权限并使用完全自主提示词；
@@ -120,6 +121,8 @@ export interface WandTask {
     workspaceId: string | null;
     /** 关联的侧栏工作任务；归档/新建时用来对账，不随 WorkspaceTask 删除而消失。 */
     workspaceTaskId: string | null;
+    /** 认领到处理中的父任务；子任务仍有独立 Agent 会话。 */
+    parentTaskId: string | null;
     identifier: string;
     title: string;
     /** 'user' = 用户自己填的标题；'auto' = 用户留空后按描述/会话内容自动生成。 */

package/dist/terminal-daemon-client.d.ts

@@ -3,7 +3,8 @@ import { type TerminalAttachResult, type TerminalHost, type TerminalSpawnRequest
 import { type StructuredExecHost, type StructuredExecProcess, type StructuredSpawnRequest, type StructuredRunState } from "./structured-exec-host.js";
 export declare class TerminalDaemonClient implements TerminalHost, StructuredExecHost {
     private readonly socketPath;
-    private readonly token;
+    private token;
+    private readonly tokenPath;
     readonly persistent = true;
     private socket;
     private frameParts;
@@ -15,14 +16,19 @@ export declare class TerminalDaemonClient implements TerminalHost, StructuredExe
     private readonly handles;
     private readonly pendingEvents;
     private readonly structuredInventory;
+    /** Immutable read cursors; live sdata may mutate inventory but not the caller's last snapshot. */
+    private readonly structuredObserved;
     private readonly structuredHandles;
     private readonly pendingStructuredEvents;
     private disposed;
     private reconnectTimer;
     private reconnectDelayMs;
     private reconnectFailureLogged;
-    constructor(socketPath: string, token: string);
+    private connecting;
+    private stopHeartbeat;
+    constructor(socketPath: string, token: string, tokenPath?: string | null);
     connect(): Promise<void>;
+    private open;
     attach(sessionId: string, afterSeq?: number): TerminalAttachResult | null;
     createOrAttach(request: TerminalSpawnRequest, afterSeq?: number): Promise<TerminalAttachResult>;
     forget(sessionId: string): void;
@@ -33,6 +39,7 @@ export declare class TerminalDaemonClient implements TerminalHost, StructuredExe
     forgetRun(runId: string): void;
     /** Refresh the structured inventory and catch live handles up after a reconnect. */
     private refreshStructuredAfterReconnect;
+    private rememberStructuredSnapshot;
     private handleFromState;
     private deliverStructuredEvent;
     disconnect(): void;

package/dist/terminal-daemon-client.js

@@ -6,6 +6,7 @@ import { StringDecoder } from "node:string_decoder";
 import { TERMINAL_DAEMON_PROTOCOL_VERSION, terminalDaemonPaths, } from "./terminal-daemon-protocol.js";
 import { appendTerminalChunkWindow, InProcessTerminalHost, } from "./terminal-host.js";
 import { STRUCTURED_RUN_LOG_MAX_CHARS, } from "./structured-exec-host.js";
+import { startDaemonHeartbeat, waitForDaemonSocket } from "./daemon-connection.js";
 import { appendWindow, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
 const TERMINAL_DAEMON_RECONNECT_INITIAL_MS = 500;
 const TERMINAL_DAEMON_RECONNECT_MAX_MS = 10_000;
@@ -29,6 +30,9 @@ class RemoteTerminalProcess {
             this.client.reportOperationError(this.sessionId, error);
         });
     }
+    async writeConfirmed(data) {
+        await this.client.request("write", { sessionId: this.sessionId, data });
+    }
     resize(cols, rows) {
         void this.client.request("resize", { sessionId: this.sessionId, cols, rows }).catch((error) => {
             this.client.reportOperationError(this.sessionId, error);
@@ -128,11 +132,14 @@ class RemoteStructuredProcess {
         return { dispose: () => this.exitListeners.delete(listener) };
     }
     acceptStream(event) {
+        const previousSeq = event.stream === "stdout" ? this.lastStdoutSeq : this.lastStderrSeq;
+        if (event.seq <= previousSeq)
+            return;
         this.deliveredChars[event.stream] += event.data.length;
         if (event.stream === "stdout")
-            this.lastStdoutSeq = Math.max(this.lastStdoutSeq, event.seq);
+            this.lastStdoutSeq = event.seq;
         else
-            this.lastStderrSeq = Math.max(this.lastStderrSeq, event.seq);
+            this.lastStderrSeq = event.seq;
         if (this.streamListeners.size === 0) {
             this.undeliveredEvents.push(event);
             if (this.undeliveredEvents.length > 4096)
@@ -153,14 +160,14 @@ class RemoteStructuredProcess {
             process.stderr.write(`[wand] structured run ${this.runId} stdout log no longer aligns with delivered output; skipping catch-up\n`);
         }
         else if (stdoutDelta) {
-            this.acceptStream({ stream: "stdout", data: stdoutDelta, seq: ++this.syntheticSeq });
+            this.acceptStream({ stream: "stdout", data: stdoutDelta, seq: state.stdoutSeq });
         }
         const stderrDelta = alignedDelta(state.stderrLog, state.stderrTruncated, this.deliveredChars.stderr);
         if (stderrDelta === null) {
             process.stderr.write(`[wand] structured run ${this.runId} stderr log no longer aligns with delivered output; skipping catch-up\n`);
         }
         else if (stderrDelta) {
-            this.acceptStream({ stream: "stderr", data: stderrDelta, seq: ++this.syntheticSeq });
+            this.acceptStream({ stream: "stderr", data: stderrDelta, seq: state.stderrSeq });
         }
     }
     emitStream(event) {
@@ -168,7 +175,6 @@ class RemoteStructuredProcess {
             listener(event);
     }
     deliveredChars = { stdout: 0, stderr: 0 };
-    syntheticSeq = 1_000_000_000_000;
 }
 /**
  * Deliver the suffix of the daemon's replay log beyond what this handle has
@@ -185,6 +191,7 @@ function alignedDelta(log, truncated, deliveredChars) {
 export class TerminalDaemonClient {
     socketPath;
     token;
+    tokenPath;
     persistent = true;
     socket = null;
     frameParts = [];
@@ -196,44 +203,60 @@ export class TerminalDaemonClient {
     handles = new Map();
     pendingEvents = new Map();
     structuredInventory = new Map();
+    /** Immutable read cursors; live sdata may mutate inventory but not the caller's last snapshot. */
+    structuredObserved = new Map();
     structuredHandles = new Map();
     pendingStructuredEvents = new Map();
     disposed = false;
     reconnectTimer = null;
     reconnectDelayMs = TERMINAL_DAEMON_RECONNECT_INITIAL_MS;
     reconnectFailureLogged = false;
-    constructor(socketPath, token) {
+    connecting = null;
+    stopHeartbeat = null;
+    constructor(socketPath, token, tokenPath = null) {
         this.socketPath = socketPath;
         this.token = token;
+        this.tokenPath = tokenPath;
     }
-    async connect() {
+    connect() {
         if (this.disposed)
-            throw new Error("Terminal daemon client disposed");
+            return Promise.reject(new Error("Terminal daemon client disposed"));
+        if (this.connecting)
+            return this.connecting;
         if (this.socket && !this.socket.destroyed)
-            return;
+            return Promise.resolve();
+        const connecting = this.open();
+        this.connecting = connecting;
+        void connecting.finally(() => {
+            if (this.connecting === connecting)
+                this.connecting = null;
+        }).catch(() => { });
+        return connecting;
+    }
+    async open() {
+        if (this.tokenPath)
+            this.token = readFileSync(this.tokenPath, "utf8").trim();
         const socket = net.createConnection(this.socketPath);
         socket.setNoDelay(true);
         this.socket = socket;
-        await new Promise((resolve, reject) => {
-            const onConnect = () => { cleanup(); resolve(); };
-            const onError = (error) => { cleanup(); reject(error); };
-            const cleanup = () => {
-                socket.off("connect", onConnect);
-                socket.off("error", onError);
-            };
-            socket.once("connect", onConnect);
-            socket.once("error", onError);
-        });
+        try {
+            await waitForDaemonSocket(socket);
+        }
+        catch (error) {
+            if (this.socket === socket)
+                this.socket = null;
+            throw error;
+        }
         // Each socket decodes from a clean slate; a half-written character from a
         // previous connection must not leak into the next frame.
         this.decoder = new StringDecoder("utf8");
         this.frameParts = [];
-        socket.on("data", (data) => this.consume(this.decoder.write(data)));
-        socket.on("close", () => this.handleDisconnect());
-        socket.on("error", (error) => {
-            this.rejectPending(error instanceof Error ? error : new Error(String(error)));
-            this.handleDisconnect();
+        socket.on("data", (data) => {
+            if (this.socket === socket)
+                this.consume(this.decoder.write(data));
         });
+        socket.on("close", () => this.handleDisconnect(socket));
+        socket.on("error", () => this.handleDisconnect(socket));
         try {
             await this.request("hello");
             const previous = new Map(this.inventory);
@@ -246,6 +269,10 @@ export class TerminalDaemonClient {
                 process.stderr.write("[wand] Reconnected to terminal daemon; reconciled PTY inventory.\n");
             }
             await this.refreshStructuredAfterReconnect();
+            if (this.disposed || this.socket !== socket)
+                throw new Error("Terminal daemon disconnected during adoption");
+            this.stopHeartbeat?.();
+            this.stopHeartbeat = startDaemonHeartbeat(socket, () => this.request("hello"), { socketPath: this.socketPath });
         }
         catch (error) {
             if (!this.disposed) {
@@ -253,7 +280,7 @@ export class TerminalDaemonClient {
                     socket.destroy();
                 }
                 catch { /* best-effort cleanup */ }
-                this.handleDisconnect();
+                this.handleDisconnect(socket);
             }
             throw error;
         }
@@ -279,6 +306,8 @@ export class TerminalDaemonClient {
         void this.request("forget", { sessionId }).catch((error) => this.reportOperationError(sessionId, error));
     }
     // ---------------------------------------------------------------------------
+    // MIGRATION-COMPAT: keep this legacy StructuredExecHost adapter for owned
+    // runs and rollback after Rust adoption; remove only on explicit request.
     // StructuredExecHost: daemon-owned CLI runs that survive web restarts.
     // ---------------------------------------------------------------------------
     async spawnStructured(request) {
@@ -289,32 +318,44 @@ export class TerminalDaemonClient {
         }
         this.structuredHandles.delete(request.runId);
         const state = await this.request("structuredSpawn", { ...request });
-        return this.handleFromState(state, existingHandle ?? null);
+        return this.handleFromState(state, existingHandle ?? null, true);
     }
     async attachRun(runId) {
         const payload = await this.request("structuredAttach", { runId });
-        if (!payload.state)
+        if (!payload.state) {
+            this.structuredInventory.delete(runId);
+            this.structuredObserved.delete(runId);
             return null;
-        this.structuredInventory.set(runId, payload.state);
+        }
+        this.rememberStructuredSnapshot(payload.state);
         return payload.state;
     }
     async adoptRun(runId) {
+        // The caller may have already replayed a list/attach snapshot. Keep its
+        // watermarks: events arriving during the attach RPC still need delivery.
+        const observed = this.structuredObserved.get(runId);
         const state = await this.attachRun(runId);
         if (!state || state.status !== "running")
             return null;
         const existing = this.structuredHandles.get(runId);
         if (existing && existing.incarnationId === state.incarnationId)
             return existing;
-        return this.handleFromState(state, existing ?? null);
+        return this.handleFromState(state, existing ?? null, false, observed?.incarnationId === state.incarnationId ? observed : state);
     }
     async listRuns() {
         const result = await this.request("structuredList");
         // Defensive against protocol skew with older daemons that answer unknown
         // methods with a generic { ok: true }.
-        return Array.isArray(result) ? result : [];
+        if (!Array.isArray(result))
+            return [];
+        const runs = result;
+        for (const run of runs)
+            this.rememberStructuredSnapshot(run);
+        return runs;
     }
     forgetRun(runId) {
         this.structuredInventory.delete(runId);
+        this.structuredObserved.delete(runId);
         this.structuredHandles.delete(runId);
         this.pendingStructuredEvents.delete(runId);
         void this.request("structuredForget", { runId }).catch((error) => this.reportOperationError(runId, error));
@@ -331,7 +372,7 @@ export class TerminalDaemonClient {
         }
         this.structuredInventory.clear();
         for (const run of runs)
-            this.structuredInventory.set(run.runId, run);
+            this.structuredInventory.set(run.runId, { ...run });
         for (const [runId, oldState] of previous) {
             const current = this.structuredInventory.get(runId);
             const handle = this.structuredHandles.get(runId);
@@ -346,8 +387,19 @@ export class TerminalDaemonClient {
             handle.acceptExit({ exitCode: current?.exitCode ?? -1, signal: current?.signal ?? null });
         }
     }
-    handleFromState(state, reuse) {
-        this.structuredInventory.set(state.runId, state);
+    rememberStructuredSnapshot(state) {
+        // A reducer may be feeding the returned list/attach object while events
+        // keep arriving. Never let routeStructuredEvent mutate that object or the
+        // watermarks used to bridge list -> attach -> live adoption.
+        this.structuredInventory.set(state.runId, { ...state });
+        this.structuredObserved.set(state.runId, {
+            incarnationId: state.incarnationId,
+            stdoutSeq: state.stdoutSeq,
+            stderrSeq: state.stderrSeq,
+        });
+    }
+    handleFromState(state, reuse, replaySnapshot = false, observed = state) {
+        this.rememberStructuredSnapshot(state);
         let process = this.structuredHandles.get(state.runId) ?? null;
         if (!process || process.incarnationId !== state.incarnationId) {
             process = reuse && reuse.incarnationId === state.incarnationId
@@ -358,18 +410,29 @@ export class TerminalDaemonClient {
             this.structuredHandles.set(state.runId, process);
         else
             this.structuredHandles.delete(state.runId);
-        // Events can arrive (and the child can even exit) before this RPC returns.
-        // Always drain the backlog onto THIS handle. If the run already finished,
-        // also replay daemon logs and synthesize exit so a fast Codex/Pi turn is
-        // not lost just because listeners were not attached yet.
+        // A fresh spawn must replay the RPC snapshot. For adoption, the caller may
+        // have replayed an earlier inventory/attach state, so retain that earlier
+        // watermark while draining the events received during the attach RPC.
+        // Do not redeliver events already present in the caller's snapshot.
+        if (replaySnapshot || state.status !== "running")
+            process.replayFromLogs(state);
         const pending = this.pendingStructuredEvents.get(state.runId) ?? [];
         this.pendingStructuredEvents.delete(state.runId);
-        for (const event of pending)
+        for (const event of pending) {
+            if (event.incarnationId !== state.incarnationId)
+                continue;
+            if (event.event === "sdata" && typeof event.seq === "number") {
+                const known = replaySnapshot ? state : observed;
+                const knownSeq = event.stream === "stderr" ? known.stderrSeq : known.stdoutSeq;
+                if (event.seq <= knownSeq)
+                    continue;
+            }
+            if (event.event === "sexit" && state.status === "exited")
+                continue;
             this.deliverStructuredEvent(process, event);
-        if (state.status !== "running") {
-            process.replayFromLogs(state);
-            process.acceptExit({ exitCode: state.exitCode, signal: state.signal });
         }
+        if (state.status !== "running")
+            process.acceptExit({ exitCode: state.exitCode, signal: state.signal });
         return process;
     }
     deliverStructuredEvent(handle, event) {
@@ -389,6 +452,8 @@ export class TerminalDaemonClient {
     }
     disconnect() {
         this.disposed = true;
+        this.stopHeartbeat?.();
+        this.stopHeartbeat = null;
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
@@ -408,9 +473,13 @@ export class TerminalDaemonClient {
      * every RemoteTerminalProcess silently dead while ProcessManager keeps the
      * session status at "running" forever.
      */
-    handleDisconnect() {
-        if (this.socket?.destroyed)
-            this.socket = null;
+    handleDisconnect(socket) {
+        if (this.socket !== socket)
+            return;
+        this.socket = null;
+        this.stopHeartbeat?.();
+        this.stopHeartbeat = null;
+        socket.destroy();
         this.rejectPending(new Error("Terminal daemon disconnected"));
         if (this.disposed)
             return;
@@ -727,7 +796,7 @@ async function tryConnect(socketPath, tokenPath) {
     }
     if (!token)
         return null;
-    const client = new TerminalDaemonClient(socketPath, token);
+    const client = new TerminalDaemonClient(socketPath, token, tokenPath);
     try {
         await client.connect();
         return client;
@@ -745,8 +814,12 @@ export async function connectExistingTerminalHost(configPath) {
 function probeSocket(socketPath) {
     return new Promise((resolve) => {
         const socket = net.createConnection(socketPath);
+        let settled = false;
         const finish = (alive) => {
-            socket.removeAllListeners();
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
             socket.destroy();
             resolve(alive);
         };

package/dist/terminal-daemon-server.js

@@ -5,6 +5,7 @@ import net from "node:net";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import pty from "node-pty";
+import { keepUnixSocketAlive } from "./unix-socket-keepalive.js";
 import { ensureNodePtyHelperExecutable } from "./ensure-node-pty-helper.js";
 import { signalNumberFromName } from "./signal-utils.js";
 import { STRUCTURED_RUN_LOG_MAX_CHARS, createUtf8TextDecoder, } from "./structured-exec-host.js";
@@ -184,6 +185,9 @@ export async function runTerminalDaemon(configPath) {
         session.terminalState.dispose();
     };
     // ---------------------------------------------------------------------------
+    // MIGRATION-COMPAT: Node-owned structured CLI runs must remain available
+    // throughout the Rust migration for existing owners and explicit rollback.
+    // Do not remove until the user separately requests legacy cleanup.
     // Structured CLI runs: plain child_process ownership with full replay logs.
     // ---------------------------------------------------------------------------
     const appendRunLog = (run, stream, data) => {
@@ -234,7 +238,9 @@ export async function runTerminalDaemon(configPath) {
     };
     const structuredSpawn = (request) => {
         const existing = structuredRuns.get(request.runId);
-        if (existing && existing.status === "running")
+        // A lost spawn response must never re-execute the input, even if the
+        // child exited before the caller could retry. Only forget permits reuse.
+        if (existing)
             return serializeStructuredRun(existing);
         const wantsStdin = typeof request.stdinData === "string";
         const child = nodeSpawn(request.file, request.args, {
@@ -242,8 +248,7 @@ export async function runTerminalDaemon(configPath) {
             env: request.env,
             stdio: wantsStdin ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
         });
-        if (wantsStdin)
-            child.stdin?.end(request.stdinData);
+        let stdinFailed = false;
         const run = {
             request,
             incarnationId: randomUUID(),
@@ -295,7 +300,7 @@ export async function runTerminalDaemon(configPath) {
             emitDecoded("stderr", run.stderrDecoder.end());
             run.child = null;
             run.status = "exited";
-            run.exitCode = code;
+            run.exitCode = stdinFailed ? -1 : code;
             run.exitedAt = Date.now();
             run.signal = signalName === null || signalName === undefined ? null : Number(signalName) || signalNumberFromName(signalName);
             broadcast({
@@ -308,6 +313,13 @@ export async function runTerminalDaemon(configPath) {
             });
             evictStaleStructuredRuns();
         });
+        child.stdin?.on("error", () => {
+            // Stream errors are independent of the child's error/close events.
+            stdinFailed = true;
+            child.kill("SIGTERM");
+        });
+        if (wantsStdin)
+            child.stdin?.end(request.stdinData);
         return serializeStructuredRun(run);
     };
     const structuredForget = (runId) => {
@@ -469,7 +481,11 @@ export async function runTerminalDaemon(configPath) {
             resolve();
         });
     });
+    const stopSocketKeepalive = keepUnixSocketAlive(server, paths.socketPath, () => {
+        chmodSync(paths.socketPath, 0o600);
+    });
     const shutdown = () => {
+        stopSocketKeepalive();
         for (const sessionId of Array.from(sessions.keys()))
             forget(sessionId);
         for (const runId of Array.from(structuredRuns.keys()))
@@ -477,14 +493,28 @@ export async function runTerminalDaemon(configPath) {
         for (const client of clients)
             client.socket.destroy();
         server.close(() => process.exit(0));
-        cleanupDaemonFiles(paths.socketPath, paths.tokenPath, paths.pidPath);
+        cleanupDaemonFiles(paths, { token, pid: process.pid });
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
 }
-function cleanupDaemonFiles(socketPath, tokenPath, pidPath) {
-    for (const file of [socketPath, tokenPath, pidPath]) {
-        if (process.platform === "win32" && file === socketPath)
+/**
+ * 只清理**自己拥有**的 daemon 文件。
+ *
+ * 升级期/僵尸期可能有两个 daemon 指向同一个 config（老进程端点已被清理、新进程刚接上）：
+ * 老进程退出时无条件 unlink，会把新进程正在使用的 token/pid 一起删掉 —— 新 daemon 随即变成
+ * 「进程活着但凭据不见了」，所有终端永久断联。所以凭据按**内容**判归属，不是自己写的就不动。
+ * socket 仍然照删：它属于本进程的监听（真正被占时 bind 会 EADDRINUSE）。
+ */
+function cleanupDaemonFiles(paths, owner) {
+    if (process.platform !== "win32") {
+        try {
+            unlinkSync(paths.socketPath);
+        }
+        catch { /* already absent */ }
+    }
+    for (const file of [paths.tokenPath, paths.pidPath]) {
+        if (!fileHoldsValue(file, file === paths.tokenPath ? owner.token : String(owner.pid)))
             continue;
         try {
             unlinkSync(file);
@@ -492,6 +522,15 @@ function cleanupDaemonFiles(socketPath, tokenPath, pidPath) {
         catch { /* already absent */ }
     }
 }
+/** 文件内容是否还是本进程写进去的值（读不到/已被别人改写都算「不是自己的」）。 */
+function fileHoldsValue(filePath, expected) {
+    try {
+        return readFileSync(filePath, "utf8").trim() === expected;
+    }
+    catch {
+        return false;
+    }
+}
 export function readTerminalDaemonPid(configPath) {
     try {
         const value = Number(readFileSync(terminalDaemonPaths(configPath).pidPath, "utf8").trim());

package/dist/terminal-host.d.ts

@@ -13,6 +13,8 @@ export interface TerminalProcess {
     readonly incarnationId: string;
     readonly pid: number;
     write(data: string): void;
+    /** Resolve only after a persistent host has acknowledged an interactive write. */
+    writeConfirmed?(data: string): Promise<void>;
     resize(cols: number, rows: number): void;
     kill(signal?: string): void;
     onData(listener: (event: TerminalDataEvent) => void): {
@@ -21,6 +23,10 @@ export interface TerminalProcess {
     onExit(listener: (event: TerminalExitEvent) => void): {
         dispose(): void;
     };
+    /** Persistent hosts call this when bounded replay cannot bridge a disconnect. */
+    onResync?(listener: (state: TerminalSessionState) => void): {
+        dispose(): void;
+    };
 }
 export interface TerminalSessionState {
     sessionId: string;

package/dist/terminal-host.js

@@ -17,6 +17,9 @@ class InProcessTerminalProcess {
     write(data) {
         this.child.write(data);
     }
+    async writeConfirmed(data) {
+        this.child.write(data);
+    }
     resize(cols, rows) {
         this.child.resize(cols, rows);
     }