@co0ontty/wand 4.72.0 → 4.72.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "fc5673635615d567540a2a3e636041a4a3422cad",
-  "builtAt": "2026-09-21T22:45:17.210Z",
-  "version": "4.72.0",
+  "commit": "78b791818f725d606571f7c36f245a85388b19a5",
+  "builtAt": "2026-09-22T01:56:32.828Z",
+  "version": "4.72.1",
   "channel": "stable"
 }

package/dist/process-manager.d.ts

@@ -109,8 +109,6 @@ export declare class ProcessManager extends EventEmitter {
     sendInput(id: string, input: string, view?: "chat" | "terminal", shortcutKey?: string, trackUserInput?: boolean): SessionSnapshot;
     resize(id: string, cols: number, rows: number): SessionSnapshot;
     getTerminalState(id: string): PtyTerminalSnapshot | null;
-    pauseOutput(id: string): void;
-    resumeOutput(id: string): void;
     /**
      * Finalize provider-only state while leaving the owning PTY shell alive. The
      * session itself remains running so terminal input can continue normally.

package/dist/process-manager.js

@@ -1553,16 +1553,6 @@ export class ProcessManager extends EventEmitter {
         }
         return record.terminalState.snapshot();
     }
-    pauseOutput(id) {
-        const record = this.sessions.get(id);
-        if (record?.ptyProcess && record.status === "running")
-            record.ptyProcess.pause();
-    }
-    resumeOutput(id) {
-        const record = this.sessions.get(id);
-        if (record?.ptyProcess && record.status === "running")
-            record.ptyProcess.resume();
-    }
     /**
      * Finalize provider-only state while leaving the owning PTY shell alive. The
      * session itself remains running so terminal input can continue normally.

package/dist/pty-terminal-state.d.ts

@@ -22,8 +22,11 @@ export declare class PtyTerminalState {
     private readonly serializer;
     private readonly unicode;
     private pending;
+    private buffered;
     private tail;
+    private flushTimer?;
     private checkpointTimer?;
+    private checkpointQueued;
     private nextId;
     private committedData;
     private committedCols;
@@ -35,5 +38,9 @@ export declare class PtyTerminalState {
     snapshot(): PtyTerminalSnapshot;
     dispose(): void;
     private addPending;
+    private scheduleFlush;
+    /** Publish buffered bytes as one pending data operation and queue one write. */
+    private flushBuffered;
     private scheduleCheckpoint;
+    private commitCheckpoint;
 }

package/dist/pty-terminal-state.js

@@ -2,6 +2,49 @@ import headless from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 import { Unicode11Addon } from "@xterm/addon-unicode11";
 const { Terminal } = headless;
+/**
+ * Incoming PTY chunks are coalesced into one xterm write per flush. xterm's
+ * write callback costs a timer turn per call, so one write per node-pty chunk
+ * caps a session at roughly 1 MB/s of mirrored output; batching removes that
+ * ceiling without changing what a snapshot contains (the delay below is far
+ * shorter than the client's own output debounce).
+ */
+const WRITE_BATCH_MAX_CHARS = 64 * 1024;
+const WRITE_BATCH_DELAY_MS = 16;
+/**
+ * Re-serializing the screen costs ~20ms and allocates a few hundred KB, so a
+ * checkpoint must not run on a fixed cadence while a session streams. Writes
+ * pause between turns, which is when a fresh baseline is actually useful; the
+ * size bounds only exist so a session that never pauses stays bounded.
+ */
+const CHECKPOINT_QUIET_MS = 100;
+const CHECKPOINT_PENDING_MAX_CHARS = 256 * 1024;
+const CHECKPOINT_PENDING_MAX_OPS = 1024;
+function pendingChars(pending) {
+    let chars = 0;
+    for (const entry of pending) {
+        if (entry.operation.type === "data")
+            chars += entry.operation.data.length;
+    }
+    return chars;
+}
+/**
+ * Merge adjacent data operations so a snapshot exposes as few replay steps as
+ * possible: clients write pending operations one awaited call at a time, and a
+ * session that streamed without pausing can hold hundreds of them.
+ */
+function coalesceOperations(pending) {
+    const operations = [];
+    for (const { operation } of pending) {
+        const last = operations.at(-1);
+        if (operation.type === "data" && last?.type === "data") {
+            operations[operations.length - 1] = { type: "data", data: last.data + operation.data };
+            continue;
+        }
+        operations.push({ ...operation });
+    }
+    return operations;
+}
 /**
  * Server-side xterm screen model used only for reconnect snapshots. Live PTY
  * bytes still travel unchanged from node-pty to the browser terminal.
@@ -11,8 +54,11 @@ export class PtyTerminalState {
     serializer = new SerializeAddon();
     unicode = new Unicode11Addon();
     pending = [];
+    buffered = "";
     tail = Promise.resolve();
+    flushTimer;
     checkpointTimer;
+    checkpointQueued = false;
     nextId = 1;
     committedData = "";
     committedCols;
@@ -31,63 +77,134 @@ export class PtyTerminalState {
     write(data) {
         if (this.disposed || !data)
             return;
-        const pending = this.addPending({ type: "data", data });
-        this.tail = this.tail.then(() => new Promise((resolve) => {
-            if (this.disposed)
-                return resolve();
-            this.terminal.write(data, () => resolve());
-        }));
-        this.scheduleCheckpoint(pending.id);
+        this.buffered += data;
+        if (this.buffered.length >= WRITE_BATCH_MAX_CHARS)
+            this.flushBuffered();
+        else
+            this.scheduleFlush();
     }
     resize(cols, rows) {
         if (this.disposed)
             return;
-        const pending = this.addPending({ type: "resize", cols, rows });
+        // Bytes that arrived before the resize must land before it.
+        this.flushBuffered();
+        this.addPending({ type: "resize", cols, rows });
         this.tail = this.tail.then(() => {
             if (!this.disposed)
                 this.terminal.resize(cols, rows);
         });
-        this.scheduleCheckpoint(pending.id);
+        this.scheduleCheckpoint();
     }
     snapshot() {
+        // Unflushed bytes would be invisible to a snapshot, so publish them as
+        // pending operations the client replays after `data`.
+        this.flushBuffered();
         return {
             version: 1,
             data: this.committedData,
             cols: this.committedCols,
             rows: this.committedRows,
-            pending: this.pending.map(({ operation }) => ({ ...operation })),
+            pending: coalesceOperations(this.pending),
         };
     }
     dispose() {
         if (this.disposed)
             return;
         this.disposed = true;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
         if (this.checkpointTimer)
             clearTimeout(this.checkpointTimer);
         this.checkpointTimer = undefined;
+        this.buffered = "";
         this.pending = [];
         this.terminal.dispose();
     }
     addPending(operation) {
-        const pending = { id: this.nextId++, operation };
-        this.pending.push(pending);
-        return pending;
+        this.pending.push({ id: this.nextId++, operation });
     }
-    scheduleCheckpoint(_operationId) {
-        if (this.checkpointTimer || this.disposed)
+    scheduleFlush() {
+        if (this.flushTimer || this.disposed)
             return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.flushBuffered();
+        }, WRITE_BATCH_DELAY_MS);
+        this.flushTimer.unref?.();
+    }
+    /** Publish buffered bytes as one pending data operation and queue one write. */
+    flushBuffered() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        const data = this.buffered;
+        if (!data)
+            return;
+        this.buffered = "";
+        this.addPending({ type: "data", data });
+        this.tail = this.tail.then(() => new Promise((resolve) => {
+            if (this.disposed)
+                return resolve();
+            try {
+                this.terminal.write(data, () => resolve());
+            }
+            catch {
+                // A throwing write must not poison the ordering chain: every later
+                // chunk would then be dropped without any signal.
+                resolve();
+            }
+        }));
+        this.scheduleCheckpoint();
+    }
+    scheduleCheckpoint() {
+        if (this.disposed || this.checkpointQueued)
+            return;
+        if (pendingChars(this.pending) >= CHECKPOINT_PENDING_MAX_CHARS
+            || this.pending.length >= CHECKPOINT_PENDING_MAX_OPS) {
+            this.commitCheckpoint();
+            return;
+        }
+        // Quiet-period trigger: one checkpoint after a streaming burst ends,
+        // instead of one every 100ms while it runs.
+        if (this.checkpointTimer)
+            clearTimeout(this.checkpointTimer);
         this.checkpointTimer = setTimeout(() => {
             this.checkpointTimer = undefined;
-            const cutoff = this.pending.at(-1)?.id ?? 0;
-            this.tail = this.tail.then(() => {
-                if (this.disposed)
-                    return;
+            this.commitCheckpoint();
+        }, CHECKPOINT_QUIET_MS);
+        this.checkpointTimer.unref?.();
+    }
+    commitCheckpoint() {
+        if (this.disposed || this.checkpointQueued)
+            return;
+        if (this.checkpointTimer) {
+            clearTimeout(this.checkpointTimer);
+            this.checkpointTimer = undefined;
+        }
+        const cutoff = this.pending.at(-1)?.id ?? 0;
+        if (!cutoff)
+            return;
+        this.checkpointQueued = true;
+        this.tail = this.tail.then(() => {
+            if (this.disposed)
+                return;
+            try {
                 this.committedData = this.serializer.serialize({ scrollback: 5000 });
                 this.committedCols = this.terminal.cols;
                 this.committedRows = this.terminal.rows;
                 this.pending = this.pending.filter((entry) => entry.id > cutoff);
-            });
-        }, 100);
-        this.checkpointTimer.unref?.();
+            }
+            catch {
+                // Keep the mirror alive; the next checkpoint re-serializes.
+            }
+        }).then(() => {
+            this.checkpointQueued = false;
+            // Operations that arrived while this checkpoint drained still need a
+            // baseline of their own once the writer goes quiet again.
+            if (this.pending.length > 0)
+                this.scheduleCheckpoint();
+        });
     }
 }

package/dist/server.js

@@ -815,8 +815,6 @@ export async function startServer(config, configPath, options = {}) {
         resizePty: (id, cols, rows) => {
             processes.resize(id, cols, rows);
         },
-        pausePtyOutput: (id) => processes.pauseOutput(id),
-        resumePtyOutput: (id) => processes.resumeOutput(id),
     });
     disconnectAuthenticatedSockets = () => wsManager.disconnectAll();
     wss.on("error", (err) => {

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

@@ -231,6 +231,16 @@ export declare class StructuredSessionManager {
     private runClaudeSdkStreaming;
     private compactContentBlocks;
     private buildCompletedAssistantMessages;
+    /**
+     * Rebuild the trailing assistant turn when the replayed log was truncated.
+     *
+     * 重启后在 daemon 里继续跑的 CLI，它的 stdout 只保留最后
+     * STRUCTURED_RUN_LOG_MAX_CHARS 字符，所以 replay 出来的 turn 是「半截尾巴」：
+     * 直接覆盖会丢掉重启前用户已经看到的全部输出。这里用与流式期间同一个
+     * TruncatedReplayView（本地已存 turn + replay 新增段），保证收尾视图和前端
+     * 中途看到的完全一致。
+     */
+    private mergeTruncatedReplayTurn;
     private resolveQueuedMessagesAfterInterrupt;
     private resolveQueuedMessageSkillsAfterInterrupt;
     private normalizeToolResultContent;

package/dist/structured-session-manager.js

@@ -279,6 +279,84 @@ function buildIncrementalStructuredPayload(snapshot, cardDefaults) {
 function isoNow() {
     return new Date().toISOString();
 }
+/**
+ * Identity of one content block inside an assistant turn. Tool ids are copied
+ * verbatim from the CLI stream and never mutate, so they are the anchors used to
+ * align a replayed turn with the transcript we already stored.
+ */
+function replayBlockAnchor(block) {
+    switch (block.type) {
+        case "tool_use": return `tool_use:${block.id}`;
+        case "tool_result": return `tool_result:${block.tool_use_id}`;
+        case "thinking": return `thinking:${block.thinking}`;
+        case "text": return `text:${block.text}`;
+        default: return null;
+    }
+}
+/**
+ * Index of the last replayed block the stored turn already contains, or -1 when
+ * no overlap can be proven.
+ *
+ * Needed because a daemon replay log can start mid-stream
+ * (STRUCTURED_RUN_LOG_MAX_CHARS), so the first replayed blocks usually repeat the
+ * tail of the turn we accumulated live before the restart.
+ */
+function lastStoredAnchorIndex(stored, replayed) {
+    if (!stored || stored.length === 0)
+        return -1;
+    const known = new Set();
+    for (const block of stored) {
+        const anchor = replayBlockAnchor(block);
+        if (anchor !== null)
+            known.add(anchor);
+    }
+    let cut = -1;
+    for (let index = 0; index < replayed.length; index += 1) {
+        const anchor = replayBlockAnchor(replayed[index]);
+        if (anchor !== null && known.has(anchor))
+            cut = index;
+    }
+    return cut;
+}
+/**
+ * 截断重放期间「本地已存 turn + replay 新增段」的合并视图。
+ *
+ * 重启后在 terminald 里继续跑的 CLI 只保留最后 STRUCTURED_RUN_LOG_MAX_CHARS 字符的
+ * stdout，replay 出来的是「半截尾巴」：直接用它覆盖会删掉重启前用户已经看到的输出，
+ * 完全不用它又会让前端冻结到本轮结束。所以把 checkpoint 里的 turn 当固定底，只把
+ * replay 里能证明是新增的那段拼在后面。cut 只算一次，视图随 replay 增长而增长
+ * （保持流式），且重复调用幂等（不会重复追加、也不会丢底）。
+ */
+class TruncatedReplayView {
+    base;
+    cut = -1;
+    primed = false;
+    constructor(messages) {
+        const last = messages && messages.length > 0 ? messages[messages.length - 1] : undefined;
+        this.base = last && last.role === "assistant" ? last.content : null;
+    }
+    get ready() {
+        return this.primed;
+    }
+    /** 必须在 replay 首轮 feed 完成后再定锚点：feed 途中的半截 blocks 会把重叠判错。 */
+    prime(replayed) {
+        this.cut = lastStoredAnchorIndex(this.base, replayed);
+        this.primed = true;
+    }
+    content(replayed) {
+        if (!this.base || this.base.length === 0)
+            return replayed;
+        // 证明不了重叠就只信本地已存内容（宁可暂不追加，也不要重复整段）。
+        if (!this.primed || this.cut === -1)
+            return this.base;
+        const extra = replayed.slice(this.cut + 1);
+        return extra.length === 0 ? this.base : [...this.base, ...extra];
+    }
+}
+/** Append a standalone notice turn without touching the previous assistant turn. */
+function appendNoticeTurn(messages, turn) {
+    return [...(messages ?? []), { ...turn, createdAt: isoNow(), completedAt: isoNow() }];
+}
 function upsertAssistantMessage(messages, turn, complete = false) {
     const msgs = [...(messages ?? [])];
     const last = msgs[msgs.length - 1];
@@ -643,12 +721,54 @@ export class StructuredSessionManager {
         this.saveAuthoritativeSession(resumed);
         this.emitStructuredSnapshot(resumed);
         process.stderr.write(`[wand] resuming structured run for session ${sessionId} (daemon pid ${initialState.pid})\n`);
+        this.logger?.appendStructuredSpawn(sessionId, {
+            kind: `${resumed.runner ?? "structured"}-recovered`,
+            provider: resumed.provider,
+            pid: initialState.pid,
+            cwd: resumed.cwd,
+            status: initialState.status,
+            exitCode: initialState.exitCode,
+            stdoutTruncated: initialState.stdoutTruncated,
+            recoveredAt: new Date().toISOString(),
+        });
         const processor = buildReplayProcessor(resumed);
         let emitTimer = null;
+        // 日志被截断时 reducer 只看到半截历史，重建出的 turn 远比本地已存的少；
+        // 不能用它覆盖 messages/output，也不能就此冻结前端。
+        const replayTruncated = initialState.stdoutTruncated;
+        const replayView = new TruncatedReplayView(resumed.messages);
         const syncTurn = (turnState) => {
             const current = this.currentSessionForRequest(sessionId, requestId);
             if (!current)
                 return;
+            const structuredState = {
+                ...current.structuredState,
+                model: turnState.model ?? current.structuredState?.model,
+                phase: turnState.phase ?? current.structuredState?.phase,
+            };
+            if (replayTruncated) {
+                // 锚点未定前（首轮 feed 中）只有半截 blocks，先只落元数据。
+                if (!replayView.ready) {
+                    const patched = { ...current, structuredState };
+                    this.sessions.set(sessionId, patched);
+                    this.saveStreamingSnapshot(patched, { metadata: true });
+                    return;
+                }
+                // 已存底 + replay 新增段：前端继续流式拿到增长中的 turn，库里也不会丢底。
+                const merged = {
+                    role: "assistant",
+                    content: this.compactContentBlocks(replayView.content([...turnState.blocks]), turnState.result),
+                    usage: turnState.usage,
+                };
+                const patched = {
+                    ...current,
+                    messages: upsertAssistantMessage(current.messages, merged),
+                    structuredState,
+                };
+                this.sessions.set(sessionId, patched);
+                this.saveStreamingSnapshot(patched);
+                return;
+            }
             const turn = {
                 role: "assistant",
                 content: this.compactContentBlocks([...turnState.blocks], turnState.result),
@@ -660,11 +780,7 @@ export class StructuredSessionManager {
                 claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                 messages,
                 output: turnState.result || current.output,
-                structuredState: {
-                    ...current.structuredState,
-                    model: turnState.model ?? current.structuredState?.model,
-                    phase: turnState.phase ?? current.structuredState?.phase,
-                },
+                structuredState,
             };
             this.sessions.set(sessionId, patched);
             this.saveStreamingSnapshot(patched);
@@ -716,7 +832,8 @@ export class StructuredSessionManager {
         };
         if (initialState.status === "exited") {
             feedFullLog();
-            this.finalizeRecoveredRun(sessionId, requestId, processor, {
+            replayView.prime([...processor.state.blocks]);
+            this.finalizeRecoveredRun(sessionId, requestId, processor, replayView, {
                 exitCode: initialState.exitCode,
                 signal: initialState.signal === null ? null : signalNameFromNumber(initialState.signal),
                 stderr: initialState.stderrLog,
@@ -736,7 +853,7 @@ export class StructuredSessionManager {
         runningHandle = await this.execHost.adoptRun(structuredRunId(sessionId));
         if (!runningHandle) {
             // Run vanished between listing and adoption; fall back to failure notes.
-            this.finalizeRecoveredRun(sessionId, requestId, processor, {
+            this.finalizeRecoveredRun(sessionId, requestId, processor, replayView, {
                 exitCode: null,
                 signal: null,
                 stderr: initialState.stderrLog,
@@ -746,6 +863,8 @@ export class StructuredSessionManager {
             flushEmit();
             return;
         }
+        // 首轮 feed + attach 完成后再定锚点，之后 onStream 的事件都走合并视图。
+        replayView.prime([...processor.state.blocks]);
         runningHandle.onStream((event) => {
             // Events may be buffered while structuredAttach is in flight. Sequence
             // watermarks distinguish overlap with the snapshot from genuinely new
@@ -754,19 +873,23 @@ export class StructuredSessionManager {
                 if (event.seq <= lastStdoutSeq)
                     return;
                 lastStdoutSeq = event.seq;
+                // 重启后 daemon 继续吐出的输出也要落回会话制品，否则会话日志在重启点断掉，
+                // 事后无从核对这一轮到底产出了什么。
+                this.logger?.appendStructuredStdout(sessionId, event.data);
                 feedDelta(event.data);
                 return;
             }
             if (event.seq <= lastStderrSeq)
                 return;
             lastStderrSeq = event.seq;
+            this.logger?.appendStructuredStderr(sessionId, event.data);
             processor.stderr += event.data;
         });
         runningHandle.onExit((event) => {
             if (carry.trim())
                 feedLine(carry);
             carry = "";
-            this.finalizeRecoveredRun(sessionId, requestId, processor, {
+            this.finalizeRecoveredRun(sessionId, requestId, processor, replayView, {
                 exitCode: event.exitCode,
                 signal: event.signal === null ? null : signalNameFromNumber(event.signal),
                 stderr: processor.stderr,
@@ -775,7 +898,7 @@ export class StructuredSessionManager {
             flushEmit();
         });
     }
-    finalizeRecoveredRun(sessionId, requestId, processor, outcome) {
+    finalizeRecoveredRun(sessionId, requestId, processor, replayView, outcome) {
         this.execHost?.forgetRun(structuredRunId(sessionId));
         if (!this.isCurrentRequest(sessionId, requestId))
             return;
@@ -784,8 +907,10 @@ export class StructuredSessionManager {
             return;
         const commandLabel = recoveredCommandLabel(current.runner);
         const interruptedForQuestion = processor.stopReason === "ask-user-question";
+        // 退出码/信号是 CLI 的权威结论：daemon 的 replay 日志被截断只说明我们重建不出
+        // 完整过程记录，不代表这一轮失败（否则 exit 0 会被报成 "exited with code 0"）。
+        const replayTruncated = outcome.stdoutTruncated;
         const failedExit = outcome.lost
-            || outcome.stdoutTruncated
             || (outcome.exitCode !== null && outcome.exitCode !== 0)
             || outcome.signal !== null;
         if ((processor.primaryError || failedExit) && !interruptedForQuestion) {
@@ -797,21 +922,24 @@ export class StructuredSessionManager {
                     extras: processor.errors,
                     stdoutTail: processor.stdoutTail,
                 });
-            const failed = this.finishStructuredFailure(current, typeof outcome.exitCode === "number" ? outcome.exitCode : 1, errorText, processor.state);
+            const failed = this.finishStructuredFailure(current, typeof outcome.exitCode === "number" ? outcome.exitCode : 1, errorText, processor.state, { keepTranscript: replayTruncated });
             this.sessions.set(sessionId, failed);
             this.saveAuthoritativeSession(failed);
             this.emitStructuredSnapshot(failed);
             this.emitStructuredSnapshot(failed, "ended");
             return;
         }
-        const messages = this.buildCompletedAssistantMessages(current, processor.state);
         const keepRunning = interruptedForQuestion;
+        const messages = replayTruncated
+            ? this.mergeTruncatedReplayTurn(current, processor, replayView, !keepRunning)
+            : this.buildCompletedAssistantMessages(current, processor.state);
         const finished = {
             ...current,
             status: keepRunning ? "running" : "idle",
             exitCode: keepRunning ? null : 0,
             endedAt: keepRunning ? null : new Date().toISOString(),
-            output: processor.state.result,
+            // 日志被截断时 output 保留重启前的版本：replay 只覆盖尾部，用它反而丢掉前半段。
+            output: replayTruncated ? current.output || processor.state.result : processor.state.result,
             claudeSessionId: processor.state.sessionId ?? current.claudeSessionId,
             messages,
             pendingEscalation: null,
@@ -3090,6 +3218,23 @@ export class StructuredSessionManager {
         };
         return upsertAssistantMessage(current.messages, assistantTurn, true);
     }
+    /**
+     * Rebuild the trailing assistant turn when the replayed log was truncated.
+     *
+     * 重启后在 daemon 里继续跑的 CLI，它的 stdout 只保留最后
+     * STRUCTURED_RUN_LOG_MAX_CHARS 字符，所以 replay 出来的 turn 是「半截尾巴」：
+     * 直接覆盖会丢掉重启前用户已经看到的全部输出。这里用与流式期间同一个
+     * TruncatedReplayView（本地已存 turn + replay 新增段），保证收尾视图和前端
+     * 中途看到的完全一致。
+     */
+    mergeTruncatedReplayTurn(current, processor, view, complete) {
+        const turn = {
+            role: "assistant",
+            content: this.compactContentBlocks(view.content([...processor.state.blocks]), processor.state.result),
+            usage: processor.state.usage,
+        };
+        return upsertAssistantMessage([...(current.messages ?? [])], turn, complete);
+    }
     resolveQueuedMessagesAfterInterrupt(sessionId, current, interruptPrompt) {
         if (interruptPrompt && !this.preserveQueueOnInterrupt.has(sessionId))
             return [];
@@ -3134,12 +3279,16 @@ export class StructuredSessionManager {
         const trimmed = detail.length > 2048 ? `...${detail.slice(-2048)}` : detail;
         return `${head}\n${trimmed}`;
     }
-    finishStructuredFailure(current, code, errorText, turnState) {
+    finishStructuredFailure(current, code, errorText, turnState, options = {}) {
         const failureTurn = {
             role: "assistant",
             content: [{ type: "text", text: `结构化会话执行失败：${errorText}` }],
         };
-        const msgs = upsertAssistantMessage(current.messages, failureTurn, true);
+        // 日志被截断时本地已存的 turn 是重启前唯一完整的记录：失败提示追加成独立一轮，
+        // 不能把整段 turn 换成错误文本（那会把用户看到过的输出全删掉）。
+        const msgs = options.keepTranscript
+            ? appendNoticeTurn(current.messages, failureTurn)
+            : upsertAssistantMessage(current.messages, failureTurn, true);
         return {
             ...current,
             status: "failed",

package/dist/terminal-daemon-client.js

@@ -16,8 +16,6 @@ class RemoteTerminalProcess {
     client;
     dataListeners = new Set();
     exitListeners = new Set();
-    paused = false;
-    pausedEvents = [];
     undeliveredEvents = [];
     pendingExit = null;
     constructor(sessionId, incarnationId, pid, client) {
@@ -41,18 +39,6 @@ class RemoteTerminalProcess {
             this.client.reportOperationError(this.sessionId, error);
         });
     }
-    pause() {
-        this.paused = true;
-    }
-    resume() {
-        if (!this.paused)
-            return;
-        this.paused = false;
-        const pending = this.pausedEvents;
-        this.pausedEvents = [];
-        for (const event of pending)
-            this.emitData(event);
-    }
     onData(listener) {
         this.dataListeners.add(listener);
         if (this.undeliveredEvents.length > 0) {
@@ -79,10 +65,6 @@ class RemoteTerminalProcess {
         return { dispose: () => this.exitListeners.delete(listener) };
     }
     acceptData(event) {
-        if (this.paused) {
-            this.pausedEvents = appendTerminalChunkWindow(this.pausedEvents, event);
-            return;
-        }
         if (this.dataListeners.size === 0) {
             this.undeliveredEvents = appendTerminalChunkWindow(this.undeliveredEvents, event);
             return;
@@ -107,8 +89,6 @@ class RemoteStructuredProcess {
     client;
     streamListeners = new Set();
     exitListeners = new Set();
-    paused = false;
-    pausedEvents = [];
     undeliveredEvents = [];
     pendingExit = null;
     lastStdoutSeq = 0;
@@ -153,10 +133,6 @@ class RemoteStructuredProcess {
             this.lastStdoutSeq = Math.max(this.lastStdoutSeq, event.seq);
         else
             this.lastStderrSeq = Math.max(this.lastStderrSeq, event.seq);
-        if (this.paused) {
-            this.pausedEvents.push(event);
-            return;
-        }
         if (this.streamListeners.size === 0) {
             this.undeliveredEvents.push(event);
             if (this.undeliveredEvents.length > 4096)
@@ -187,18 +163,6 @@ class RemoteStructuredProcess {
             this.acceptStream({ stream: "stderr", data: stderrDelta, seq: ++this.syntheticSeq });
         }
     }
-    pause() {
-        this.paused = true;
-    }
-    resume() {
-        if (!this.paused)
-            return;
-        this.paused = false;
-        const pending = this.pausedEvents;
-        this.pausedEvents = [];
-        for (const event of pending)
-            this.emitStream(event);
-    }
     emitStream(event) {
         for (const listener of Array.from(this.streamListeners))
             listener(event);