@co0ontty/wand 4.85.1 → 4.87.0-beta.gd2f0f8f

package/dist/process-manager.js

@@ -723,24 +723,32 @@ export class ProcessManager extends EventEmitter {
             && record.ptyProcess !== null
             && !record.ptyBridge
             && typeof record.processId === "number"
-            && record.processId > 0));
+            && record.processId > 0)).map((record) => ({ record, pid: record.processId, process: record.ptyProcess }));
         if (candidates.length === 0)
             return;
         this.ptyForegroundSampling = true;
         try {
-            const samples = await this.probePtyForegrounds(candidates.map((record) => record.processId));
+            const samples = await this.probePtyForegrounds(candidates.map(({ pid }) => pid));
             if (!samples || this.disposed)
                 return;
-            for (const record of candidates) {
-                if (this.sessions.get(record.id) !== record)
+            for (const { record, pid, process } of candidates) {
+                // ps is asynchronous: a stopped/replaced terminal must not inherit an old probe.
+                if (this.sessions.get(record.id) !== record || record.status !== "running"
+                    || record.ptyProcess !== process || record.processId !== pid)
                     continue;
-                const next = samples.get(record.processId);
+                const next = samples.get(pid);
                 if (next === undefined || record.ptyForeground === next)
                     continue;
+                const wasForeground = record.ptyForeground === true;
                 record.ptyForeground = next;
                 // CLI 退回提示符：这一轮立刻结束，不必再等静默窗口。
                 if (!next)
                     this.closePtyTurn(record);
+                // 空白终端里的手动命令也有运行事实，但没有 provider 回合边界。
+                // 不复用 ptyBusy，避免一次前台切换冒充 AI 成功完成；静默命令也保持活动。
+                if (!record.provider && wasForeground !== next) {
+                    this.emitEvent({ type: "status", sessionId: record.id, data: { ptyCommandRunning: next } });
+                }
             }
         }
         catch {
@@ -1099,6 +1107,7 @@ export class ProcessManager extends EventEmitter {
     dispose() {
         if (this.disposed)
             return;
+        this.terminalHost.flush?.();
         this.disposed = true;
         // 静默心跳不跨服务关闭存活；每个会话的 timer 也在 cleanupRecord 里单独撤销。
         this.ptyHeartbeat.dispose();
@@ -1195,7 +1204,7 @@ export class ProcessManager extends EventEmitter {
         if (this.disposed)
             throw new Error("ProcessManager has been disposed.");
         if (isOpenRouterFreeSelector(opts?.model))
-            throw new Error("免费分组仅支持 one 的 Agent 结构化对话。");
+            throw new Error("免费分组仅支持 Pi 结构化对话。");
         if (!opts?.interactiveShell)
             this.assertCommandAllowed(command);
         const groupProvider = opts?.interactiveShell ? undefined : opts?.provider ?? inferProviderFromCommand(command);
@@ -1239,7 +1248,7 @@ export class ProcessManager extends EventEmitter {
             preferDefault: !requested || requested === "default",
         }) : [requested ?? ""];
         if (preferredModels.some(isOpenRouterFreeSelector))
-            throw new Error("免费模型分组仅支持 one 的 Agent 结构化对话。");
+            throw new Error("免费模型分组仅支持 Pi 结构化对话。");
         const baseCwd = resolveSessionCwd(cwd, this.config.defaultCwd);
         const id = opts?.reuseId || randomUUID();
         // When a session is being resumed under the same id, capture its prior
@@ -1729,6 +1738,7 @@ export class ProcessManager extends EventEmitter {
     }
     /** Return only a session owned by this manager, without the SQLite fallback used by get(). */
     getOwned(id) {
+        this.terminalHost.flush?.();
         const record = this.sessions.get(id);
         if (!record)
             return null;
@@ -1754,7 +1764,7 @@ export class ProcessManager extends EventEmitter {
             preferDefault: !normalized || normalized === "default",
         });
         if (members.some(isOpenRouterFreeSelector))
-            throw new Error("免费分组仅支持 one 的 Agent 结构化对话。");
+            throw new Error("免费分组仅支持 Pi 结构化对话。");
         record.selectedModel = normalized;
         if (record.providerCliActive && record.provider === "claude" && record.status === "running" && record.ptyProcess) {
             const value = members[0] && members[0] !== "default" ? members[0] : "default";
@@ -1922,6 +1932,7 @@ export class ProcessManager extends EventEmitter {
         return this.snapshot(record);
     }
     getTerminalState(id) {
+        this.terminalHost.flush?.();
         const record = this.sessions.get(id);
         if (!record)
             return null;
@@ -2215,6 +2226,8 @@ export class ProcessManager extends EventEmitter {
             providerCliActive: record.providerCliActive,
             providerCliExitCode: record.providerCliExitCode,
             ptyBusy: record.ptyBridge ? record.ptyBridge.isResponding() : record.ptyBusy === true,
+            ptyCommandRunning: record.status === "running" && record.ptyProcess !== null
+                && !record.provider && record.ptyForeground === true,
             // 与 ptyBusy 同生命周期的本轮锚点。运行时事实：存储没有对应列，重启后为 null。
             ptyTurnStartedAt: record.ptyTurnStartedAt ?? null,
             ptyLastActivityAt: record.ptyLastActivityAt ?? null,

package/dist/provider-catalog.d.ts

@@ -21,8 +21,20 @@ export declare function isNativeThinkingEffort(value: unknown): boolean;
 export declare function isSessionProvider(value: unknown): value is SessionProvider;
 /** provider 对应的 CLI 可执行文件名（Qoder 的 CLI 叫 qodercli）。 */
 export declare function providerCliCommand(provider: SessionProvider): string;
-/** provider 的展示名。缺省不认识的字符串一律回落到 "AI"。 */
+/**
+ * provider 的展示名。缺省不认识的字符串一律回落到 "AI"。
+ *
+ * `pi` 指的是 Pi CLI（结构化 JSON / PTY 终端），与 Wand 自带的 Agent 是两条独立执行路径：
+ * 后者走进程内 SDK，展示名用 `WAND_AGENT_LABEL`，不要拿 provider 名字冒充它。
+ */
 export declare const PROVIDER_LABELS: Readonly<Record<SessionProvider, string>>;
+/**
+ * Wand 自带 Agent（进程内 `core` harness / SDK）的展示名。
+ *
+ * 它和 `pi` provider 不是同一个东西：`pi` 起 Pi CLI 进程，Wand Agent 在 Wand 进程内用 SDK 跑 agent loop，
+ * 因此能力边界（会话级 Skills / MCP、CodeMode、持久化恢复）也不一样。
+ */
+export declare const WAND_AGENT_LABEL = "Wand Agent";
 /**
  * provider id 别名表：既接受用户/客户端可能写出的别名（`anthropic`、`open-code`），
  * 也接受历史 runner 名（`claude-cli-print`、`codex-cli-exec` …），

package/dist/provider-catalog.js

@@ -28,16 +28,28 @@ export function isSessionProvider(value) {
 export function providerCliCommand(provider) {
     return provider === "qoder" ? "qodercli" : provider;
 }
-/** provider 的展示名。缺省不认识的字符串一律回落到 "AI"。 */
+/**
+ * provider 的展示名。缺省不认识的字符串一律回落到 "AI"。
+ *
+ * `pi` 指的是 Pi CLI（结构化 JSON / PTY 终端），与 Wand 自带的 Agent 是两条独立执行路径：
+ * 后者走进程内 SDK，展示名用 `WAND_AGENT_LABEL`，不要拿 provider 名字冒充它。
+ */
 export const PROVIDER_LABELS = {
     claude: "Claude",
     codex: "Codex",
     opencode: "OpenCode",
     grok: "Grok",
     qoder: "Qoder",
-    pi: "one 的 Agent",
+    pi: "Pi",
     gemini: "Gemini",
 };
+/**
+ * Wand 自带 Agent（进程内 `core` harness / SDK）的展示名。
+ *
+ * 它和 `pi` provider 不是同一个东西：`pi` 起 Pi CLI 进程，Wand Agent 在 Wand 进程内用 SDK 跑 agent loop，
+ * 因此能力边界（会话级 Skills / MCP、CodeMode、持久化恢复）也不一样。
+ */
+export const WAND_AGENT_LABEL = "Wand Agent";
 /**
  * provider id 别名表：既接受用户/客户端可能写出的别名（`anthropic`、`open-code`），
  * 也接受历史 runner 名（`claude-cli-print`、`codex-cli-exec` …），

package/dist/render-binary.d.ts

@@ -56,6 +56,6 @@ export declare function resolveRenderBinaryPath(configPath: string): string | nu
  * `wand-render --version` —— 启动路径上不该无谓地执行一个进程。
  * 两种方式都失败时返回 null：调用方只要一个展示用版本号，拿不到不能影响启动。
  */
-export declare function readRenderBinaryVersion(binaryPath: string): Promise<string | null>;
+export declare function readRenderBinaryVersion(binaryPath: string, versionFile?: string): Promise<string | null>;
 export declare function isExecutableFile(candidate: string): boolean;
 export {};

package/dist/render-binary.js

@@ -158,8 +158,8 @@ export function resolveRenderBinaryPath(configPath) {
  * `wand-render --version` —— 启动路径上不该无谓地执行一个进程。
  * 两种方式都失败时返回 null：调用方只要一个展示用版本号，拿不到不能影响启动。
  */
-export function readRenderBinaryVersion(binaryPath) {
-    const sidecar = readVersionSidecar(binaryPath);
+export function readRenderBinaryVersion(binaryPath, versionFile = path.join(path.dirname(binaryPath), "wand-render.version")) {
+    const sidecar = readVersionSidecar(versionFile);
     if (sidecar)
         return Promise.resolve(sidecar);
     return new Promise((resolve) => {
@@ -174,9 +174,9 @@ export function readRenderBinaryVersion(binaryPath) {
         });
     });
 }
-function readVersionSidecar(binaryPath) {
+function readVersionSidecar(versionFile) {
     try {
-        const raw = readFileSync(path.join(path.dirname(binaryPath), "wand-render.version"), "utf8").trim();
+        const raw = readFileSync(versionFile, "utf8").trim();
         const version = /^(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.]+)?)$/.exec(raw);
         return version ? version[1] : null;
     }

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

@@ -1,4 +1,4 @@
-import { type RenderMethod } from "./render-protocol.js";
+import { type RenderHelloResult, type RenderMethod } from "./render-protocol.js";
 import { type TerminalAttachResult, type TerminalHost, type TerminalSessionState, type TerminalSpawnRequest } from "./terminal-host.js";
 /**
  * 鉴权层面的失败（与网络抖动区分）。
@@ -59,6 +59,8 @@ export declare class RenderDaemonClient implements TerminalHost {
     private bodyParts;
     private bodyBytes;
     private frameLength;
+    private liveDataBatch;
+    private liveFlushTimer;
     private disposed;
     private reconnectTimer;
     private reconnectDelayMs;
@@ -100,6 +102,12 @@ export declare class RenderDaemonClient implements TerminalHost {
      * 调用它会杀掉用户的 shell。
      */
     requestShutdownNow(): Promise<void>;
+    /** Fresh, authenticated inventory; never infer idleness from reconnect caches. */
+    maintenanceSnapshot(includeInventory?: boolean): Promise<{
+        hello: RenderHelloResult;
+        sessions: TerminalSessionState[] | null;
+    }>;
+    requestShutdownDrain(): Promise<void>;
     connect(): Promise<void>;
     private open;
     /**
@@ -142,6 +150,9 @@ export declare class RenderDaemonClient implements TerminalHost {
     private handleFrame;
     private handleResponse;
     private routeEvent;
+    private queueLiveData;
+    flush(): void;
+    private flushLiveData;
     private queuePendingEvent;
     /** Repair a bounded event-buffer overflow without replaying a partial stream. */
     private refreshSession;

package/dist/render-daemon-client.js

@@ -5,7 +5,7 @@ import { startDaemonHeartbeat, waitForDaemonSocket } from "./daemon-connection.j
 import { getErrorMessage } from "./error-utils.js";
 import { appendWindow, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
 import { MAX_FRAME_BYTES, RENDER_PROTOCOL_VERSION, encodeRenderFrame, renderPaths, } from "./render-protocol.js";
-import { appendTerminalChunkWindow, } from "./terminal-host.js";
+import { appendTerminalChunkBatch, appendTerminalChunkWindow, } from "./terminal-host.js";
 const RECONNECT_INITIAL_MS = 500;
 const RECONNECT_MAX_MS = 10_000;
 /**
@@ -19,6 +19,10 @@ const AUTH_FAILURE_RETRY_MS = 60_000;
 const REQUEST_TIMEOUT_MS = 10_000;
 /** 未挂上 listener 时的缓存上限，与 legacy 客户端保持一致。 */
 const MAX_PENDING_EVENTS = 512;
+/** Tiny fixed window bounds projection cost even when IPC reads arrive one by one. */
+const LIVE_BATCH_FLUSH_MS = 4;
+const LIVE_BATCH_MAX_CHARS = 64 * 1024;
+const LIVE_BATCH_MAX_EVENTS = 1024;
 /**
  * 鉴权层面的失败（与网络抖动区分）。
  *
@@ -164,6 +168,8 @@ export class RenderDaemonClient {
     bodyParts = [];
     bodyBytes = 0;
     frameLength = null;
+    liveDataBatch = null;
+    liveFlushTimer = null;
     disposed = false;
     reconnectTimer = null;
     reconnectDelayMs = RECONNECT_INITIAL_MS;
@@ -218,6 +224,15 @@ export class RenderDaemonClient {
     async requestShutdownNow() {
         await this.request("shutdown", { mode: "now" });
     }
+    /** Fresh, authenticated inventory; never infer idleness from reconnect caches. */
+    async maintenanceSnapshot(includeInventory = true) {
+        const hello = await this.request("hello");
+        const sessions = includeInventory ? await this.listSessions() : null;
+        return { hello, sessions };
+    }
+    async requestShutdownDrain() {
+        await this.request("shutdown", { mode: "drain" });
+    }
     connect() {
         if (this.disposed)
             return Promise.reject(new Error("Render client disposed"));
@@ -367,6 +382,7 @@ export class RenderDaemonClient {
         state.rows = rows;
     }
     attach(sessionId, afterSeq = 0) {
+        this.flushLiveData();
         const state = this.inventory.get(sessionId);
         if (!state)
             return null;
@@ -409,6 +425,7 @@ export class RenderDaemonClient {
      * 这是 Server / Render 分离的核心 —— 下一次启动 attach 回来仍拿到同一批会话。
      */
     disconnect() {
+        this.flushLiveData();
         this.disposed = true;
         this.stopHeartbeat?.();
         this.stopHeartbeat = null;
@@ -618,6 +635,7 @@ export class RenderDaemonClient {
         this.routeEvent(message);
     }
     handleResponse(message) {
+        this.flushLiveData();
         if (typeof message.id !== "number")
             return;
         const pending = this.pending.get(message.id);
@@ -634,6 +652,8 @@ export class RenderDaemonClient {
         pending.reject(new Error(`Render ${pending.method} failed (${code})${detail ? `: ${detail}` : ""}`));
     }
     routeEvent(event) {
+        if (event.event !== "data")
+            this.flushLiveData();
         if (this.reconciling) {
             if (event.event === "reconcile") {
                 this.reconcileDuringSync = event;
@@ -670,13 +690,16 @@ export class RenderDaemonClient {
                 if (event.seq <= state.seq)
                     return;
                 if (event.seq > state.seq + 1) {
+                    this.flushLiveData();
                     this.queuePendingEvent(sessionId, event);
                     void this.refreshSession(sessionId, handle);
                     return;
                 }
-                state.seq = Math.max(state.seq, event.seq);
-                state.output = appendWindow(state.output, event.data, PTY_OUTPUT_MAX_SIZE);
-                state.chunks = appendTerminalChunkWindow(state.chunks, { data: event.data, seq: event.seq });
+                // Validate every wire sequence independently. Only local projection is
+                // batched; attach/reconnect still retain the original per-frame cursors.
+                state.seq = event.seq;
+                this.queueLiveData(state, handle, { data: event.data, seq: event.seq });
+                return;
             }
             else if (event.event === "exit") {
                 state.status = "exited";
@@ -684,6 +707,7 @@ export class RenderDaemonClient {
             }
         }
         if (event.event === "data" && typeof event.data === "string" && typeof event.seq === "number") {
+            this.flushLiveData();
             handle.acceptData({ data: event.data, seq: event.seq });
         }
         else if (event.event === "exit") {
@@ -691,6 +715,49 @@ export class RenderDaemonClient {
             this.handles.delete(sessionId);
         }
     }
+    queueLiveData(state, handle, event) {
+        if (this.liveDataBatch && (this.liveDataBatch.state !== state || this.liveDataBatch.handle !== handle)) {
+            this.flushLiveData();
+        }
+        const batch = this.liveDataBatch ?? { state, handle, events: [], chars: 0 };
+        this.liveDataBatch = batch;
+        batch.events.push(event);
+        batch.chars += event.data.length;
+        if (batch.chars >= LIVE_BATCH_MAX_CHARS || batch.events.length >= LIVE_BATCH_MAX_EVENTS) {
+            this.flushLiveData();
+        }
+        else if (!this.liveFlushTimer) {
+            // IPC can deliver many tiny reads on successive turns. A check-phase
+            // flush alone still projects each read on a busy installed Server. Keep
+            // the first read's deadline (never reset on more data): continuous output
+            // cannot starve, while idle echo pays at most one 4ms window.
+            this.liveFlushTimer = setTimeout(() => {
+                this.liveFlushTimer = null;
+                this.flushLiveData();
+            }, LIVE_BATCH_FLUSH_MS);
+            this.liveFlushTimer.unref();
+        }
+    }
+    flush() {
+        this.flushLiveData();
+    }
+    flushLiveData() {
+        if (this.liveFlushTimer) {
+            clearTimeout(this.liveFlushTimer);
+            this.liveFlushTimer = null;
+        }
+        const batch = this.liveDataBatch;
+        if (!batch)
+            return;
+        this.liveDataBatch = null;
+        if (this.disposed || this.handles.get(batch.state.sessionId) !== batch.handle
+            || this.inventory.get(batch.state.sessionId) !== batch.state)
+            return;
+        const data = batch.events.map(event => event.data).join("");
+        batch.state.output = appendWindow(batch.state.output, data, PTY_OUTPUT_MAX_SIZE);
+        batch.state.chunks = appendTerminalChunkBatch(batch.state.chunks, batch.events);
+        batch.handle.acceptData({ data, seq: batch.events[batch.events.length - 1].seq });
+    }
     queuePendingEvent(sessionId, event) {
         const buffered = this.pendingEvents.get(sessionId) ?? [];
         buffered.push(event);
@@ -770,6 +837,7 @@ export class RenderDaemonClient {
     handleDisconnect(origin) {
         if (this.socket !== origin)
             return;
+        this.flushLiveData();
         this.socket = null;
         this.stopHeartbeat?.();
         this.stopHeartbeat = null;

package/dist/render-host.d.ts

@@ -47,6 +47,7 @@ export declare class CompositeTerminalHost implements TerminalHost {
     attach(sessionId: string, afterSeq?: number): TerminalAttachResult | null;
     createOrAttach(request: TerminalSpawnRequest, afterSeq?: number): Promise<TerminalAttachResult>;
     forget(sessionId: string): void;
+    flush(): void;
     /**
      * 两侧都只是解绑：legacy daemon 可能还持有升级前的旧 PTY，Render 更是必须
      * 跨 Server 重启继续活着。**这里绝不能 kill 任何东西。**

package/dist/render-host.js

@@ -13,8 +13,6 @@ import { InProcessTerminalHost, } from "./terminal-host.js";
 const RENDER_READY_TIMEOUT_MS = 5_000;
 /** 自愈 revive 的最小间隔：重连退避可能很密集，窗口内只 spawn 一次。 */
 const RENDER_REVIVE_BACKOFF_MS = 5_000;
-/** 空闲 daemon 升级时等它退出的上限（超过就当升级失败，交给上层决定）。 */
-const RENDER_SHUTDOWN_TIMEOUT_MS = 5_000;
 /** 陈留 socket 的二次确认间隔（避开「刚 bind、还没 accept」的启动窗口）。 */
 const RENDER_STALE_PROBE_DELAY_MS = 250;
 /**
@@ -109,6 +107,10 @@ export class CompositeTerminalHost {
         this.legacy?.forget(sessionId);
         this.render.forget(sessionId);
     }
+    flush() {
+        this.legacy?.flush?.();
+        this.render.flush?.();
+    }
     /**
      * 两侧都只是解绑：legacy daemon 可能还持有升级前的旧 PTY，Render 更是必须
      * 跨 Server 重启继续活着。**这里绝不能 kill 任何东西。**
@@ -234,8 +236,8 @@ export async function createUpgradeAwareTerminalHost(configPath, options = {}) {
  */
 export async function createRenderTerminalHost(configPath, options = {}) {
     const binaryPath = options.binaryPath ?? resolveRenderBinaryPath(configPath);
-    // adopt 到的是已经在跑的 daemon：它可能是 npm 升级前启动的旧二进制。
-    const adopt = (client) => upgradeRenderDaemonIfIdle(configPath, binaryPath, options.knownSessionIds, client);
+    // Adoption never restarts an owner. The server maintenance worker waits for
+    // every execution family and closes admission before replacing idle daemons.
     const paths = renderPaths(configPath);
     const endpointExists = process.platform !== "win32" && existsSync(paths.socketPath);
     // 已经 adopt 过的客户端需要能自己把 daemon 拉回来：adopt 完 binaryPath 就丢了，
@@ -244,12 +246,12 @@ export async function createRenderTerminalHost(configPath, options = {}) {
     if (endpointExists) {
         const adopted = await connectExistingRenderClient(configPath, options.knownSessionIds, reviveDaemon);
         if (adopted)
-            return adopt(adopted);
+            return adopted;
         if (await isSocketListening(paths.socketPath)) {
             // 有人监听却拒绝 adopt（协议版本不符 / token 不符）：这是错误配置，必须报出来而不是绕开。
             const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds, reviveDaemon);
             if (starting)
-                return adopt(starting);
+                return starting;
             throw new Error(`A Render daemon is listening on ${paths.socketPath} but rejected adoption. Refusing to spawn a competing Render; ` +
                 "check the protocol version/token of the running binary, or stop it first.");
         }
@@ -268,7 +270,7 @@ export async function createRenderTerminalHost(configPath, options = {}) {
     if (livePid !== null) {
         const starting = await waitForRender(configPath, RENDER_READY_TIMEOUT_MS, options.knownSessionIds, reviveDaemon);
         if (starting)
-            return adopt(starting);
+            return starting;
         throw new Error(`Render process ${livePid} is alive but its socket ${paths.socketPath} is unavailable; refusing to spawn a second daemon.`);
     }
     if (!binaryPath)
@@ -286,55 +288,6 @@ export function shouldUpgradeRenderDaemon(daemonVersion, binaryVersion, sessionC
         return false;
     return sessionCount === 0;
 }
-/**
- * 装好的二进制比正在跑的 daemon 新时怎么办。
- *
- * npm 升级 / `./start.sh` 都不会重启正在跑的 daemon（不能杀别人的 PTY），所以升级后
- * 一直在跑旧代码 —— 2026-09-24 的线上事故就是这么来的：端点自愈是 9/23 21:26 补上的，
- * 但 terminald 是 9/19 启的老进程、Render 是 9/23 10:49 的老二进制，socket 被临时目录
- * 清理器删掉后永远回不来。
- *
- * 所以：daemon 空闲（没有 PTY）就直接把它换到新二进制上 —— 升级完就好；
- * 还有会话就只大声告警，让人在会话结束后跑 `./start.sh --restart-daemons`。
- */
-async function upgradeRenderDaemonIfIdle(configPath, binaryPath, knownSessionIds, client) {
-    if (!binaryPath)
-        return client;
-    const daemonVersion = client.version;
-    if (!daemonVersion)
-        return client;
-    const binaryVersion = await readRenderBinaryVersion(binaryPath);
-    if (!binaryVersion || compareSemver(daemonVersion, binaryVersion) >= 0)
-        return client;
-    const sessions = client.sessionCount;
-    if (!shouldUpgradeRenderDaemon(daemonVersion, binaryVersion, sessions)) {
-        process.stderr.write(`[wand] WARNING: Render daemon ${daemonVersion} is older than the installed binary ${binaryVersion} but still owns ` +
-            `${sessions} PTY session(s); it keeps running the old code. Restart it when those sessions are done: ./start.sh --restart-daemons\n`);
-        return client;
-    }
-    try {
-        await client.requestShutdownNow();
-        client.disconnect();
-        await waitForRenderProcessExit(renderPaths(configPath).pidPath, RENDER_SHUTDOWN_TIMEOUT_MS);
-        const upgraded = await spawnDetachedRender(configPath, binaryPath, knownSessionIds);
-        process.stderr.write(`[wand] Render daemon upgraded ${daemonVersion} -> ${binaryVersion} (it was idle).\n`);
-        return upgraded;
-    }
-    catch (error) {
-        // 已经让它收摊了：回不去旧 client，报清楚并让上层（auto 模式）回退 legacy。
-        throw new Error(`Render daemon ${daemonVersion} was stopped for an upgrade to ${binaryVersion} but the replacement did not come up: ` +
-            getErrorMessage(error));
-    }
-}
-/** 等旧 daemon 真的退出（新 daemon 会因为 pid 活着而拒绝启动）。 */
-async function waitForRenderProcessExit(pidPath, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (readLiveRenderPid(pidPath) === null)
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-}
 /**
  * detached spawn（stdio 忽略、unref），返回子进程 pid。
  *

package/dist/render-structured-host.d.ts

@@ -3,6 +3,7 @@ import type { StructuredExecHost, StructuredExecProcess, StructuredRunState, Str
 type Owner = "legacy" | "rust";
 /** Resolve the separate v2 executable; do not confuse it with PTY v1 wand-render. */
 export declare function resolveStructuredRenderBinary(configPath: string): string | null;
+export declare function startStructuredRenderHost(configPath: string): Promise<RenderStructuredClient>;
 /**
  * A stable runId can belong to exactly one persistent daemon. Configuration
  * chooses only new runs; existing owners are always resolved by inventories.

package/dist/render-structured-host.js

@@ -81,7 +81,7 @@ async function connectExisting(configPath) {
         return null;
     }
 }
-async function startV2(configPath) {
+export async function startStructuredRenderHost(configPath) {
     const existing = await connectExisting(configPath);
     if (existing)
         return existing;
@@ -211,7 +211,7 @@ export async function createUpgradeAwareStructuredHost(configPath, legacy, proce
     if (process.env.WAND_TEST_MODE === "1" || process.env.NODE_TEST_CONTEXT) {
         return { host: legacy ?? undefined, rustClient: null };
     }
-    const rustClient = processHost === "rust" ? await startV2(configPath) : await connectExisting(configPath);
+    const rustClient = processHost === "rust" ? await startStructuredRenderHost(configPath) : await connectExisting(configPath);
     if (!rustClient && !legacy)
         return { host: undefined, rustClient: null };
     return { host: new CompositeStructuredExecHost(legacy, rustClient, processHost), rustClient };

package/dist/server-employee-routes.js

@@ -107,7 +107,7 @@ export function parseSystemEmployeeAgents(value, existing) {
     const agents = body.agents.map((rawAgent) => {
         const parsed = parseTaskAgent(rawAgent ?? {});
         if (!parsed)
-            throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
+            throw new Error("请选择有效的 CLI 工具或 Wand Agent。");
         if (parsed.kind !== "structured")
             throw new Error("硅基员工只支持结构化会话。");
         return parsed;
@@ -136,7 +136,7 @@ export function parseSiliconEmployeeInput(value, existing, now) {
         agents = body.agents.map((rawAgent) => {
             const parsed = parseTaskAgent(rawAgent ?? {});
             if (!parsed)
-                throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
+                throw new Error("请选择有效的 CLI 工具或 Wand Agent。");
             if (parsed.kind !== "structured")
                 throw new Error("硅基员工只支持结构化会话。");
             return parsed;
@@ -148,7 +148,7 @@ export function parseSiliconEmployeeInput(value, existing, now) {
     else if (body.agent !== undefined && body.agent !== null) {
         const singleAgent = parseTaskAgent(body.agent);
         if (!singleAgent)
-            throw new Error("请选择有效的 CLI 工具或 SDK 执行引擎。");
+            throw new Error("请选择有效的 CLI 工具或 Wand Agent。");
         if (singleAgent.kind !== "structured")
             throw new Error("硅基员工只支持结构化会话。");
         agents = [singleAgent];

package/dist/server-local-model-routes.d.ts

@@ -0,0 +1,8 @@
+import type { Express, RequestHandler } from "express";
+import type { LocalModelSetupService } from "./local-model-setup.js";
+/** Behind generic /api authentication; inference-only capabilities cannot install dependencies. */
+export declare function registerLocalModelRoutes(app: Express, deps: {
+    models: LocalModelSetupService;
+    requireSessions: RequestHandler;
+    requireAdmin: RequestHandler;
+}): void;

package/dist/server-local-model-routes.js

@@ -0,0 +1,62 @@
+import { DecisionError } from "./decision-types.js";
+import { SpeechError } from "./speech-service.js";
+/** Behind generic /api authentication; inference-only capabilities cannot install dependencies. */
+export function registerLocalModelRoutes(app, deps) {
+    app.use("/api/local-models", deps.requireSessions, (_req, res, next) => { res.set("Cache-Control", "no-store"); next(); });
+    const kind = (req, res, next) => {
+        if (req.params.kind !== "laya" && req.params.kind !== "speech") {
+            res.status(404).json({ error: "未知本地模型。" });
+            return;
+        }
+        next();
+    };
+    app.get("/api/local-models/status", async (_req, res, next) => {
+        try {
+            res.json(await deps.models.status());
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    for (const action of ["download", "initialize"]) {
+        app.post(`/api/local-models/:kind/${action}`, deps.requireAdmin, kind, async (req, res, next) => {
+            try {
+                deps.models.start(req.params.kind, action, req.body ?? {});
+                res.status(202).json(await deps.models.status());
+            }
+            catch (error) {
+                next(error);
+            }
+        });
+    }
+    app.post("/api/local-models/:kind/cancel", deps.requireAdmin, kind, async (req, res, next) => {
+        try {
+            if (req.body && Object.keys(req.body).length)
+                throw new DecisionError("INVALID_REQUEST", "取消操作不接受命令参数。");
+            deps.models.cancel(req.params.kind);
+            res.status(202).json(await deps.models.status());
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    app.patch("/api/local-models/laya/settings", deps.requireAdmin, async (req, res, next) => {
+        try {
+            if (!req.body || Object.keys(req.body).length !== 1 || typeof req.body.enabled !== "boolean")
+                throw new DecisionError("INVALID_REQUEST", "仅允许修改 LAYA 启用状态；路径由受信任安装入口确定。");
+            deps.models.setLayaEnabled(req.body.enabled);
+            res.json(await deps.models.status());
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    const errors = (error, _req, res, _next) => {
+        if (error instanceof DecisionError || error instanceof SpeechError) {
+            res.status(error.status).json({ error: error.message, code: error.code });
+            return;
+        }
+        res.status(500).json({ error: "本地模型管理失败，请刷新状态后重试。", code: "SETUP_FAILED" });
+    };
+    app.use("/api/local-models", errors);
+}

package/dist/server-resume-routes.js

@@ -65,7 +65,7 @@ const STRUCTURED_RESUME_SPECS = [
         path: "/api/pi-sessions/:nativeId/resume",
         param: "nativeId",
         spec: {
-            label: "one 的 Agent",
+            label: "Pi",
             provider: "pi",
             runner: "pi-cli-json",
             nativeIdKey: "claudeSessionId",