@co0ontty/wand 4.72.2-beta.gcc5d57e → 4.73.0

package/dist/structured-session-manager.js

@@ -207,7 +207,7 @@ function buildStructuredOutputPayload(snapshot) {
     return {
         wandProtocolVersion: WAND_PROTOCOL_VERSION,
         output: snapshot.output,
-        messages: snapshot.messages ? enrichStructuredMessages(snapshot.messages) : undefined,
+        messages: snapshot.messages ? enrichStructuredMessages(snapshot.messages, snapshot.id) : undefined,
         queuedMessages: snapshot.queuedMessages,
         queuedMessageSkills: snapshot.queuedMessageSkills,
         sessionKind: "structured",
@@ -259,7 +259,7 @@ function buildIncrementalStructuredPayload(snapshot, cardDefaults) {
     const messages = snapshot.messages ?? [];
     // Derive semantics from the complete current turn before taking the
     // incremental tail; TaskCreate results can live in an earlier provider frame.
-    const clientMessages = enrichStructuredMessages(messages);
+    const clientMessages = enrichStructuredMessages(messages, snapshot.id);
     const lastTurn = clientMessages.length > 0 ? clientMessages[clientMessages.length - 1] : undefined;
     // Streaming turn (index 0 here) is preserved verbatim; truncation only kicks
     // in if the live response is already bigger than the transport threshold,
@@ -678,7 +678,13 @@ export class StructuredSessionManager {
                 continue;
             }
             try {
-                await this.resumeDetachedRun(session, state);
+                // listRuns is metadata-only on Render v2. Fetch the authoritative
+                // paged replay from the owner before feeding any provider reducer.
+                const attached = await this.execHost.attachRun(state.runId);
+                if (!attached || attached.incarnationId !== state.incarnationId) {
+                    throw new Error("Structured run changed owner between inventory and replay");
+                }
+                await this.resumeDetachedRun(session, attached);
             }
             catch (error) {
                 console.error(`[WAND] structured run recovery failed for ${sessionId}:`, error);
@@ -1497,6 +1503,24 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /** Edit only the pending item still identified by both index and original text. */
+    editQueuedMessage(sessionId, index, expectedText, text) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length || queue[index] !== expectedText) {
+            throw new Error("排队消息已变化，请刷新后重试。");
+        }
+        const trimmed = text.trim();
+        if (!trimmed)
+            throw new Error("排队消息不能为空。");
+        const next = queue.slice();
+        next[index] = trimmed;
+        const updated = { ...session, queuedMessages: next };
+        this.sessions.set(sessionId, updated);
+        this.storage.updateSessionRuntimeMetadata(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
     /** Remove a single queued message only while index and text still identify the same item. */
     deleteQueuedMessage(sessionId, index, expectedText) {
         const session = this.requireSession(sessionId);

package/dist/task-types.d.ts

@@ -120,6 +120,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()))

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);
     }

package/dist/tui/ipc-server.js

@@ -8,6 +8,7 @@ import { chmodSync, chownSync, existsSync, statSync, unlinkSync } from "node:fs"
 import { StringDecoder } from "node:string_decoder";
 import path from "node:path";
 import { getErrorMessage } from "../error-utils.js";
+import { keepUnixSocketAlive } from "../unix-socket-keepalive.js";
 export function startIpcServer(deps) {
     if (!deps.socketPath)
         return null;
@@ -86,11 +87,22 @@ export function startIpcServer(deps) {
         // 不要崩进程；attach 模式不可用也不影响主功能。
         process.stderr.write(`[wand] IPC server error: ${err.message}\n`);
     });
+    let stopSocketKeepalive = () => { };
+    let closed = false;
     server.listen(deps.socketPath, () => {
+        if (closed) {
+            server.close();
+            return;
+        }
         applySocketOwnership(deps.socketPath);
+        stopSocketKeepalive = keepUnixSocketAlive(server, deps.socketPath, () => {
+            applySocketOwnership(deps.socketPath);
+        });
     });
     return {
         close: async () => {
+            closed = true;
+            stopSocketKeepalive();
             await new Promise((resolve) => {
                 server.close(() => resolve());
                 // 兜底：1s 内强制 resolve

package/dist/types.d.ts

@@ -12,7 +12,7 @@ type EscalationResolution = "approve_once" | "approve_turn" | "deny" | "fallback
 type EscalationSource = "tool_permission_request" | "sandbox_hard_block" | "workspace_policy_limit" | "cli_capability_limit" | "unknown";
 /** WebSocket / ProcessManager event envelope used throughout the app. */
 export interface ProcessEvent {
-    type: "output" | "status" | "started" | "ended" | "usage" | "task" | "notification";
+    type: "output" | "status" | "started" | "ended" | "usage" | "task" | "notification" | "resync";
     sessionId: string;
     data?: unknown;
     /** Monotonic per-session sequence stamped by the WS broadcast layer for
@@ -65,6 +65,20 @@ export interface AndroidApkConfig {
     apkDir?: string;
     currentApkFile?: string;
 }
+/**
+ * PTY 归属引擎。`auto` 优先 Rust Render（找到了二进制才用），`rust` 强制 Rust，
+ * `legacy` 保留现有 terminald 行为。仅切换所有权，DB/客户端契约不变。
+ */
+export type RenderEngine = "auto" | "rust" | "legacy";
+export interface RenderConfig {
+    engine: RenderEngine;
+    /** 显式指定 wand-render 可执行文件；留空则按约定顺序自动查找。 */
+    binaryPath?: string;
+}
+/** Deployment-only owner for new structured CLI runs. Existing runs follow daemon inventory. */
+export interface StructuredProcessConfig {
+    processHost: "legacy" | "rust";
+}
 export interface MacosDmgConfig {
     enabled?: boolean;
     dmgDir?: string;
@@ -123,6 +137,10 @@ export interface WandConfig {
     android?: AndroidApkConfig;
     macos?: MacosDmgConfig;
     ios?: IosIpaConfig;
+    /** Render（常驻 PTY 持有者）引擎选择。默认 auto。 */
+    render?: RenderConfig;
+    /** Structured CLI process owner for new runs; default legacy. SDK stays in Node. */
+    structured?: StructuredProcessConfig;
     /** Default expand/collapse state for card types in structured chat view */
     cardDefaults?: CardExpandDefaults;
     /** 新建会话时默认使用的 Claude 模型（别名或完整 ID）。留空则不传 --model，由 claude 自行决定。 */

package/dist/unix-socket-keepalive.d.ts

@@ -0,0 +1,3 @@
+import type net from "node:net";
+/** Restore only a missing endpoint; existing connections and their owners stay alive. */
+export declare function keepUnixSocketAlive(server: net.Server, socketPath: string, onListening: () => void, intervalMs?: number): () => void;