@co0ontty/wand 4.67.0 → 4.68.0-beta.gb5f5a70

package/README.md

@@ -322,6 +322,7 @@ wand/
 ├── android/                      # Android 客户端（submodule）
 ├── ios/                          # iOS 客户端（submodule）
 ├── macos/                        # macOS 客户端（submodule）
+├── 架构图.md                     # 运行时架构与代码边界（mermaid）
 └── docs/                         # 文档与截图
 ```
 

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "19d226c7839da00873a245da7e252395f095d730",
-  "builtAt": "2026-09-16T23:41:08.180Z",
-  "version": "4.67.0",
-  "channel": "stable"
+  "commit": "b5f5a70e88309c0a06e988480b76760251c1935b",
+  "builtAt": "2026-09-17T01:40:08.544Z",
+  "version": "4.68.0-beta.gb5f5a70",
+  "channel": "beta"
 }

package/dist/server-file-routes.js

@@ -182,7 +182,11 @@ export function registerFileRoutes(app, deps) {
             return;
         }
         try {
-            const fileStat = await stat(resolvedPath);
+            const fileStat = await lstat(resolvedPath);
+            if (fileStat.isSymbolicLink()) {
+                res.status(400).json({ error: "无法保存符号链接，请打开目标文件后编辑。" });
+                return;
+            }
             if (fileStat.isDirectory()) {
                 res.status(400).json({ error: "目标是目录，无法写入。" });
                 return;

package/dist/server-workspace-routes.js

@@ -485,8 +485,20 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             groups.set(id, created);
             return created;
         };
+        const tasksByWorkspace = new Map(workspaces.map((workspace) => [
+            workspace.id, storage.listWorkspaceTasks(workspace.id),
+        ]));
+        const sessionsByTask = new Map();
+        const taskSessions = (taskId) => {
+            let snapshots = sessionsByTask.get(taskId);
+            if (!snapshots) {
+                snapshots = storage.listSessionsByWorkspaceTask(taskId);
+                sessionsByTask.set(taskId, snapshots);
+            }
+            return snapshots;
+        };
         const appendTask = (target, workspace, task) => {
-            const allSessions = storage.listSessionsByWorkspaceTask(task.id);
+            const allSessions = taskSessions(task.id);
             const sessions = allSessions
                 .slice(0, sessionLimit ?? undefined)
                 .map((session) => ({
@@ -508,7 +520,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             if (!base)
                 continue;
             const global = isGlobalWorkspace(workspace);
-            for (const task of storage.listWorkspaceTasks(workspace.id).slice(0, taskLimit ?? undefined)) {
+            for (const task of tasksByWorkspace.get(workspace.id).slice(0, taskLimit ?? undefined)) {
                 const taskCwd = taskRuntimeCwd(task, workspace);
                 const target = global && taskCwd
                     && normalizeProjectCwd(taskCwd) !== normalizeProjectCwd(workspace.cwd)
@@ -518,9 +530,10 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
             }
         }
         const taskBoundSessionIds = new Set();
-        for (const workspace of workspaces) {
-            for (const task of storage.listWorkspaceTasks(workspace.id)) {
-                for (const session of storage.listSessionsByWorkspaceTask(task.id))
+        // Membership must include tasks/sessions hidden by the response limits.
+        for (const tasks of tasksByWorkspace.values()) {
+            for (const task of tasks) {
+                for (const session of taskSessions(task.id))
                     taskBoundSessionIds.add(session.id);
             }
         }

package/dist/server.js

@@ -319,8 +319,8 @@ export async function startServer(config, configPath, options = {}) {
     const terminalHost = options.terminalHost ?? await createTerminalHost(configPath);
     const processes = new ProcessManager(config, storage, configDir, terminalHost);
     const structuredLogger = new SessionLogger(configDir, config.shortcutLogMaxBytes);
-    // Only the daemon-backed host keeps structured CLI runs alive across restarts;
-    // the in-process fallback keeps the legacy die-with-server lifecycle.
+    // Production startup requires the daemon-backed host so CLI runs outlive web
+    // restarts. In-process hosts are retained only for explicit test injection.
     const structuredExecHost = terminalHost instanceof TerminalDaemonClient ? terminalHost : undefined;
     const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger, undefined, {}, structuredExecHost);
     const sessionRegistry = new SessionRegistry(processes, structuredSessions, storage);

package/dist/session-registry.js

@@ -1,9 +1,5 @@
 import { cleanupWorktreeSync } from "./git-worktree.js";
 import { inferProviderFromCommand } from "./session-provider.js";
-function slimSnapshot(snapshot) {
-    const { output: _output, messages: _messages, ...slim } = snapshot;
-    return { ...slim, output: "" };
-}
 /** 读取 `hidden_claude_session_ids`；坏数据 / 空值按空集合处理，不抛错。 */
 export function readHiddenSessionIds(storage) {
     const raw = storage.getConfigValue("hidden_claude_session_ids");
@@ -82,9 +78,9 @@ export class SessionRegistry {
             if (!byId.has(snapshot.id))
                 byId.set(snapshot.id, snapshot);
         }
-        for (const snapshot of this.storage.loadSessions()) {
+        for (const snapshot of this.storage.loadSessionsSlim()) {
             if (!byId.has(snapshot.id))
-                byId.set(snapshot.id, slimSnapshot(snapshot));
+                byId.set(snapshot.id, snapshot);
         }
         return Array.from(byId.values()).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
     }

package/dist/storage.d.ts

@@ -229,6 +229,8 @@ export declare class WandStorage {
     getSession(id: string): SessionSnapshot | null;
     getLatestSessionByClaudeSessionId(claudeSessionId: string): SessionSnapshot | null;
     loadSessions(): SessionSnapshot[];
+    /** List durable metadata without reading or parsing output/messages payloads. */
+    loadSessionsSlim(): SessionSnapshot[];
     private mapSessionRow;
     deleteSession(id: string): void;
 }

package/dist/storage.js

@@ -251,8 +251,8 @@ function mapWorktreeMergeFields(row) {
         worktreeMergeInfo: parseWorktreeMergeInfo(row.worktree_merge_info) ?? null,
     };
 }
-function sessionSelectFields() {
-    return `id, session_source, automation_id, provider, session_kind, runner, command, cwd, mode, status, exit_code, started_at, ended_at, output, pty_output_seq, archived, archived_at, claude_session_id, messages, queued_messages, queued_message_skills, structured_state
+function sessionSelectFields(slim = false) {
+    return `id, session_source, automation_id, provider, session_kind, runner, command, cwd, mode, status, exit_code, started_at, ended_at, ${slim ? "'' AS output" : "output"}, pty_output_seq, archived, archived_at, claude_session_id, ${slim ? "NULL AS messages" : "messages"}, queued_messages, queued_message_skills, structured_state
              , resumed_from_session_id, auto_recovered, worktree_enabled, worktree_info, worktree_merge_status, worktree_merge_info, title, description, session_options, workspace_id, workspace_task_id`;
 }
 function mapWorkspaceKind(raw) {
@@ -1149,11 +1149,11 @@ export class WandStorage {
               COALESCE(MAX(ended_at), '') AS ended,
               COALESCE(MAX(title), '') AS title
        FROM command_sessions`).get();
-        const tasks = this.db.prepare(`SELECT COUNT(*) AS count,
-              COALESCE(MAX(created_at), '') AS created,
-              COALESCE(MAX(last_opened_at), '') AS opened,
-              COALESCE(MAX(layout_revision), 0) AS revision
-       FROM workspace_tasks`).get();
+        // Per-task metadata catches edits even when another task owns the maximum
+        // timestamp/revision. Layout payloads are represented by their own revision.
+        const tasks = this.db.prepare(`SELECT id, workspace_id, name, status, cwd, worktree_json, milestone_id,
+              created_at, last_opened_at, layout_revision
+       FROM workspace_tasks ORDER BY id`).all();
         const workspaces = this.db.prepare(`SELECT COUNT(*) AS count, COALESCE(MAX(last_opened_at), '') AS opened FROM workspaces`).get();
         // 名称也进指纹：改名（含工作区/项目名与目录自定义名）后客户端才肯重拉任务列表。
         const names = this.db.prepare(`SELECT
@@ -1725,6 +1725,11 @@ export class WandStorage {
             .all();
         return rows.map((row) => this.mapSessionRow(row));
     }
+    /** List durable metadata without reading or parsing output/messages payloads. */
+    loadSessionsSlim() {
+        const rows = this.db.prepare(`SELECT ${sessionSelectFields(true)} FROM command_sessions ORDER BY started_at DESC`).all();
+        return rows.map((row) => this.mapSessionRow(row));
+    }
     mapSessionRow(row) {
         return mapSessionCore(row);
     }

package/dist/structured-pi-adapter.js

@@ -95,7 +95,11 @@ export function applyPiEvent(state, event) {
     // created when an assistant message is saved, so this ID is not resumable yet.
     if (event.type === "session" && typeof event.id === "string")
         state.pendingSessionId = event.id;
+    if (event.type === "turn_start" || event.type === "message_start" || event.type === "tool_execution_start") {
+        state.phase = "responding";
+    }
     if (event.type === "message_update") {
+        state.phase = "responding";
         const update = asRecord(event.assistantMessageEvent);
         const delta = typeof update?.delta === "string" ? update.delta : "";
         if (update?.type === "text_delta" && delta) {
@@ -144,7 +148,14 @@ export function applyPiEvent(state, event) {
         if (message?.role === "assistant") {
             if (state.pendingSessionId)
                 state.sessionId = state.pendingSessionId;
-            return applyPiAssistantMessage(state, message);
+            const error = applyPiAssistantMessage(state, message);
+            if (event.type === "turn_end") {
+                const content = Array.isArray(message.content) ? message.content : [];
+                const hasToolCall = content.some((part) => asRecord(part)?.type === "toolCall");
+                if (!hasToolCall && message.stopReason !== "toolUse")
+                    state.phase = "background";
+            }
+            return error;
         }
     }
     if (event.type === "agent_end" && Array.isArray(event.messages)) {
@@ -170,7 +181,13 @@ export class PiRunner {
     }
     start(context, observer) {
         const args = buildPiArgs(context.session, context.prompt);
-        const state = { blocks: [], result: "", sessionId: context.session.claudeSessionId, model: context.session.selectedModel ?? undefined };
+        const state = {
+            blocks: [],
+            result: "",
+            sessionId: context.session.claudeSessionId,
+            model: context.session.selectedModel ?? undefined,
+            phase: "responding",
+        };
         let primaryError = null;
         return startStructuredCli({
             sessionId: context.session.id,

package/dist/structured-runner.d.ts

@@ -5,6 +5,8 @@ export interface StructuredRunnerTurnState {
     sessionId: string | null;
     model?: string;
     usage?: ConversationTurn["usage"];
+    /** Provider turn phase when the CLI stays alive after its visible reply. */
+    phase?: "responding" | "background";
 }
 export interface StructuredRunnerContext {
     session: SessionSnapshot;

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

@@ -101,14 +101,19 @@ export declare class StructuredSessionManager {
     private readonly piRunner;
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     private pendingRecoveryIds;
+    private detachedRecoveryPromise;
+    private detachedRecoveryRetryTimer;
+    private detachedRecoveryFailureLogged;
     private disposed;
     constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null, sdkQueryFactory?: typeof sdkQuery, runners?: StructuredSessionManagerRunners, execHost?: StructuredExecHost | undefined);
     private archiveExpiredSessions;
     setEventEmitter(emitEvent: (event: ProcessEvent) => void): void;
     /** Stop every runner and flush terminal state before storage is closed. */
     dispose(): void;
-    /** Called once after startup wiring; safe to skip when no host or candidates. */
+    /** Called once after startup wiring; transient daemon failures retry automatically. */
     recoverDetachedRuns(): Promise<void>;
+    private recoverDetachedRunsOnce;
+    private scheduleDetachedRecovery;
     private resumeDetachedRun;
     private finalizeRecoveredRun;
     private trackStreamEmitTimer;

package/dist/structured-session-manager.js

@@ -145,6 +145,7 @@ const STREAM_EMIT_DEBOUNCE_MS = 16;
 // checkpoint keeps recovery useful without rewriting megabytes five times a
 // second on the event loop.
 const STREAM_SAVE_THROTTLE_MS = 1_000;
+const DETACHED_RECOVERY_RETRY_MS = 500;
 const ARCHIVE_AFTER_MS = 1000 * 60 * 60 * 24;
 /**
  * 找出最后一条 assistant turn 中尚未配对 tool_result 的 AskUserQuestion tool_use。
@@ -348,6 +349,9 @@ export class StructuredSessionManager {
     piRunner;
     /** Structured CLI runs that were mid-flight when the previous web process died. */
     pendingRecoveryIds = [];
+    detachedRecoveryPromise = null;
+    detachedRecoveryRetryTimer = null;
+    detachedRecoveryFailureLogged = false;
     disposed = false;
     constructor(storage, config, logger = null, sdkQueryFactory = sdkQuery, runners = {}, execHost) {
         this.storage = storage;
@@ -373,9 +377,11 @@ export class StructuredSessionManager {
             const runner = isStructuredRunnerForProvider(provider, storedRunner)
                 ? storedRunner
                 : defaultStructuredRunner(provider, this.config.structuredRunner);
-            if (snapshot.status === "running" && runner !== "claude-sdk") {
+            const recoverableDetachedRun = snapshot.status === "running"
+                && runner !== "claude-sdk"
+                && this.execHost?.persistent === true;
+            if (recoverableDetachedRun)
                 this.pendingRecoveryIds.push(snapshot.id);
-            }
             const restored = {
                 ...snapshot,
                 sessionKind: "structured",
@@ -383,7 +389,7 @@ export class StructuredSessionManager {
                 automationId: snapshot.automationId,
                 provider,
                 runner,
-                status: restoredStatus,
+                status: recoverableDetachedRun ? "running" : restoredStatus,
                 autoApprovePermissions: snapshot.autoApprovePermissions ?? shouldAutoApproveForMode(snapshot.mode),
                 approvalStats: snapshot.approvalStats ?? { tool: 0, command: 0, file: 0, total: 0 },
                 queuedMessages: snapshot.queuedMessages ?? [],
@@ -395,16 +401,22 @@ export class StructuredSessionManager {
                     runner,
                     model: snapshot.structuredState?.model ?? snapshot.selectedModel ?? undefined,
                     lastError: snapshot.status === "running"
-                        ? "服务重启，上一轮已中断。"
+                        ? recoverableDetachedRun ? null : "服务重启，上一轮已中断。"
                         : snapshot.structuredState?.lastError ?? null,
-                    inFlight: false,
-                    activeRequestId: null,
+                    inFlight: recoverableDetachedRun,
+                    activeRequestId: recoverableDetachedRun
+                        ? snapshot.structuredState?.activeRequestId ?? `recover-pending-${snapshot.id}`
+                        : null,
                 },
                 selectedModel: snapshot.selectedModel ?? null,
                 titleGenerating: false,
             };
             this.sessions.set(restored.id, restored);
-            this.storage.saveSession(restored);
+            // Keep the durable running marker until terminald inventory has been
+            // reconciled. If web is restarted again during startup, the next owner
+            // must still know there is a daemon run to adopt.
+            if (!recoverableDetachedRun)
+                this.storage.saveSession(restored);
         }
         this.archiveExpiredSessions();
         this.archiveTimer = setInterval(() => {
@@ -445,6 +457,10 @@ export class StructuredSessionManager {
             clearInterval(this.archiveTimer);
             this.archiveTimer = null;
         }
+        if (this.detachedRecoveryRetryTimer) {
+            clearTimeout(this.detachedRecoveryRetryTimer);
+            this.detachedRecoveryRetryTimer = null;
+        }
         for (const timer of this.streamEmitTimers)
             clearTimeout(timer);
         this.streamEmitTimers.clear();
@@ -518,33 +534,90 @@ export class StructuredSessionManager {
     // Detached-run recovery: re-attach CLI runs that kept going inside terminald
     // while the previous web process was down.
     // ---------------------------------------------------------------------------
-    /** Called once after startup wiring; safe to skip when no host or candidates. */
-    async recoverDetachedRuns() {
-        if (this.disposed || this.execHost?.persistent !== true || this.pendingRecoveryIds.length === 0)
+    /** Called once after startup wiring; transient daemon failures retry automatically. */
+    recoverDetachedRuns() {
+        if (this.disposed || this.execHost?.persistent !== true || this.pendingRecoveryIds.length === 0) {
+            return Promise.resolve();
+        }
+        if (this.detachedRecoveryPromise)
+            return this.detachedRecoveryPromise;
+        if (this.detachedRecoveryRetryTimer) {
+            clearTimeout(this.detachedRecoveryRetryTimer);
+            this.detachedRecoveryRetryTimer = null;
+        }
+        const recovery = this.recoverDetachedRunsOnce();
+        this.detachedRecoveryPromise = recovery;
+        const clearRecovery = () => {
+            if (this.detachedRecoveryPromise === recovery)
+                this.detachedRecoveryPromise = null;
+        };
+        void recovery.then(clearRecovery, clearRecovery);
+        return recovery;
+    }
+    async recoverDetachedRunsOnce() {
+        if (this.disposed || !this.execHost)
             return;
-        const ids = this.pendingRecoveryIds;
-        this.pendingRecoveryIds = [];
         let runs;
         try {
             runs = await this.execHost.listRuns();
+            this.detachedRecoveryFailureLogged = false;
         }
         catch (error) {
-            process.stderr.write(`[wand] structured run recovery skipped: ${getErrorMessage(error)}\n`);
+            if (!this.detachedRecoveryFailureLogged) {
+                this.detachedRecoveryFailureLogged = true;
+                process.stderr.write(`[wand] structured run recovery waiting for terminal daemon: ${getErrorMessage(error)}\n`);
+            }
+            this.scheduleDetachedRecovery();
             return;
         }
+        const ids = this.pendingRecoveryIds;
+        this.pendingRecoveryIds = [];
         const byRunId = new Map(runs.map((run) => [run.runId, run]));
         for (const sessionId of ids) {
-            const state = byRunId.get(structuredRunId(sessionId));
             const session = this.sessions.get(sessionId);
-            if (!state || !session)
+            if (!session)
+                continue;
+            const state = byRunId.get(structuredRunId(sessionId));
+            if (!state) {
+                // Inventory was read successfully, so this is a genuinely lost run,
+                // not a temporary control-plane outage. Commit the interrupted view.
+                const interrupted = {
+                    ...session,
+                    status: "idle",
+                    exitCode: null,
+                    endedAt: null,
+                    structuredState: {
+                        ...session.structuredState,
+                        inFlight: false,
+                        activeRequestId: null,
+                        lastError: "服务重启，上一轮已中断。",
+                    },
+                };
+                this.sessions.set(sessionId, interrupted);
+                this.saveAuthoritativeSession(interrupted);
+                this.emitStructuredSnapshot(interrupted);
                 continue;
+            }
             try {
                 await this.resumeDetachedRun(session, state);
             }
             catch (error) {
                 console.error(`[WAND] structured run recovery failed for ${sessionId}:`, error);
+                if (!this.disposed && !this.pendingRecoveryIds.includes(sessionId)) {
+                    this.pendingRecoveryIds.push(sessionId);
+                }
             }
         }
+        this.scheduleDetachedRecovery();
+    }
+    scheduleDetachedRecovery() {
+        if (this.disposed || this.pendingRecoveryIds.length === 0 || this.detachedRecoveryRetryTimer)
+            return;
+        this.detachedRecoveryRetryTimer = setTimeout(() => {
+            this.detachedRecoveryRetryTimer = null;
+            void this.recoverDetachedRuns();
+        }, DETACHED_RECOVERY_RETRY_MS);
+        this.detachedRecoveryRetryTimer.unref?.();
     }
     async resumeDetachedRun(snapshot, initialState) {
         const sessionId = snapshot.id;
@@ -589,6 +662,7 @@ export class StructuredSessionManager {
                 structuredState: {
                     ...current.structuredState,
                     model: turnState.model ?? current.structuredState?.model,
+                    phase: turnState.phase ?? current.structuredState?.phase,
                 },
             };
             this.sessions.set(sessionId, patched);
@@ -617,24 +691,12 @@ export class StructuredSessionManager {
             }
         };
         let runningHandle = null;
-        let fedChars = 0;
-        const snapshotChars = initialState.stdoutLog.length;
+        let lastStdoutSeq = initialState.stdoutSeq;
+        let lastStderrSeq = initialState.stderrSeq;
         const feedLine = (line) => {
             onApplied(processor.feed(line));
         };
         const feedDelta = (text) => {
-            // Skip the portion already covered by the attach snapshot to avoid
-            // double-feeding overlapping events buffered during adoption.
-            if (fedChars < snapshotChars) {
-                const remaining = snapshotChars - fedChars;
-                if (text.length <= remaining) {
-                    fedChars += text.length;
-                    return;
-                }
-                text = text.slice(remaining);
-                fedChars = snapshotChars;
-            }
-            fedChars += text.length;
             carry += text;
             const lines = carry.split("\n");
             carry = lines.pop() ?? "";
@@ -669,7 +731,6 @@ export class StructuredSessionManager {
             carry = lines.pop() ?? "";
             for (const line of lines)
                 feedLine(line);
-            fedChars = initialState.stdoutLog.length - carry.length;
         }
         runningHandle = await this.execHost.adoptRun(structuredRunId(sessionId));
         if (!runningHandle) {
@@ -685,10 +746,20 @@ export class StructuredSessionManager {
             return;
         }
         runningHandle.onStream((event) => {
-            if (event.stream === "stdout")
+            // Events may be buffered while structuredAttach is in flight. Sequence
+            // watermarks distinguish overlap with the snapshot from genuinely new
+            // output; character-count skipping corrupts a new short event.
+            if (event.stream === "stdout") {
+                if (event.seq <= lastStdoutSeq)
+                    return;
+                lastStdoutSeq = event.seq;
                 feedDelta(event.data);
-            else
-                processor.stderr += event.data;
+                return;
+            }
+            if (event.seq <= lastStderrSeq)
+                return;
+            lastStderrSeq = event.seq;
+            processor.stderr += event.data;
         });
         runningHandle.onExit((event) => {
             if (carry.trim())
@@ -750,6 +821,7 @@ export class StructuredSessionManager {
                 inFlight: false,
                 activeRequestId: null,
                 lastError: null,
+                phase: undefined,
             },
         };
         this.sessions.set(sessionId, finished);
@@ -2317,6 +2389,7 @@ export class StructuredSessionManager {
                 structuredState: {
                     ...current.structuredState,
                     model: turnState.model ?? current.structuredState?.model,
+                    phase: turnState.phase ?? current.structuredState?.phase,
                 },
             };
             this.sessions.set(sessionId, patched);
@@ -2441,6 +2514,7 @@ export class StructuredSessionManager {
                 inFlight: false,
                 activeRequestId: null,
                 lastError: null,
+                phase: undefined,
             },
         };
         this.sessions.set(sessionId, finished);
@@ -3072,6 +3146,7 @@ export class StructuredSessionManager {
                 inFlight: false,
                 activeRequestId: null,
                 lastError: errorText,
+                phase: undefined,
             },
         };
     }

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

@@ -6,7 +6,7 @@ export declare class TerminalDaemonClient implements TerminalHost, StructuredExe
     private readonly token;
     readonly persistent = true;
     private socket;
-    private buffer;
+    private frameParts;
     /** Decodes daemon NDJSON frames without splitting multi-byte chars. */
     private decoder;
     private nextRequestId;

package/dist/terminal-daemon-client.js

@@ -223,7 +223,7 @@ export class TerminalDaemonClient {
     token;
     persistent = true;
     socket = null;
-    buffer = "";
+    frameParts = [];
     /** Decodes daemon NDJSON frames without splitting multi-byte chars. */
     decoder = new StringDecoder("utf8");
     nextRequestId = 1;
@@ -263,6 +263,7 @@ export class TerminalDaemonClient {
         // 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) => {
@@ -563,13 +564,20 @@ export class TerminalDaemonClient {
         };
     }
     consume(chunk) {
-        this.buffer += chunk;
-        while (true) {
-            const newline = this.buffer.indexOf("\n");
-            if (newline < 0)
+        // Replay inventories can span tens of MB. Scan only the incoming chunk;
+        // concatenating and rescanning the partial frame on every socket read is
+        // quadratic and can starve unrelated create/attach requests until timeout.
+        let offset = 0;
+        while (offset < chunk.length) {
+            const newline = chunk.indexOf("\n", offset);
+            if (newline < 0) {
+                this.frameParts.push(chunk.slice(offset));
                 return;
-            const line = this.buffer.slice(0, newline);
-            this.buffer = this.buffer.slice(newline + 1);
+            }
+            this.frameParts.push(chunk.slice(offset, newline));
+            const line = this.frameParts.join("");
+            this.frameParts = [];
+            offset = newline + 1;
             if (!line)
                 continue;
             let message;
@@ -694,8 +702,7 @@ export async function createTerminalHost(configPath) {
             const starting = await waitForTerminalDaemon(paths.socketPath, paths.tokenPath, 5_000);
             if (starting)
                 return starting;
-            process.stderr.write("[wand] Existing terminal daemon rejected adoption; using non-persistent PTYs without replacing it.\n");
-            return new InProcessTerminalHost();
+            throw new Error("Existing terminal daemon rejected adoption; refusing non-persistent fallback because web restarts must not stop running tasks.");
         }
     }
     // Service managers can start terminald and the web process at nearly the
@@ -705,8 +712,7 @@ export async function createTerminalHost(configPath) {
         const adopted = await waitForTerminalDaemon(paths.socketPath, paths.tokenPath, 5_000);
         if (adopted)
             return adopted;
-        process.stderr.write("[wand] Terminal daemon process is alive but its socket is unavailable; using non-persistent PTYs without replacing it.\n");
-        return new InProcessTerminalHost();
+        throw new Error("Terminal daemon process is alive but its socket is unavailable; refusing non-persistent fallback because web restarts must not stop running tasks.");
     }
     try {
         startDetachedDaemon(configPath);
@@ -717,8 +723,7 @@ export async function createTerminalHost(configPath) {
     catch (error) {
         process.stderr.write(`[wand] Failed to start terminal daemon: ${error instanceof Error ? error.message : String(error)}\n`);
     }
-    process.stderr.write("[wand] Terminal daemon unavailable; falling back to in-process PTYs.\n");
-    return new InProcessTerminalHost();
+    throw new Error("Terminal daemon unavailable; refusing non-persistent fallback because web restarts must not stop running tasks.");
 }
 async function waitForTerminalDaemon(socketPath, tokenPath, timeoutMs) {
     const deadline = Date.now() + timeoutMs;

package/dist/types.d.ts

@@ -519,6 +519,8 @@ export interface StructuredSessionState {
     lastError: string | null;
     inFlight: boolean;
     activeRequestId: string | null;
+    /** Pi 已结束前台回复、但 CLI 仍在等待异步子任务收尾。 */
+    phase?: "responding" | "background";
 }
 export interface SessionSnapshot {
     id: string;