@co0ontty/wand 1.20.4 → 1.21.4

package/dist/claude-pty-bridge.d.ts

@@ -179,6 +179,14 @@ export declare class ClaudePtyBridge extends EventEmitter {
      * Find the end index of the echoed user input in the PTY buffer.
      * The echo may contain ANSI codes between characters.
      * Returns the index after the last character of the echo.
+     *
+     * Matching strategy:
+     * - Keep every printable codepoint of `userInput` (anything that is not a
+     *   control char or whitespace) for comparison. The previous version dropped
+     *   common symbols like `/`, `(`, `:`, space — which made commands such as
+     *   `ls /tmp` mismatch and start parsing the chat response from a wrong offset.
+     * - In the buffer, skip ANSI escape sequences entirely, and skip whitespace
+     *   so wrapped echoes (line continuation, padded columns) still align.
      */
     private findEchoEndIndex;
     private cleanForChat;

package/dist/claude-pty-bridge.js

@@ -7,9 +7,14 @@
  * 2. Structured messages for chat view (parsed)
  */
 import { EventEmitter } from "node:events";
-import { stripAnsi, isNoiseLine, appendWindow, normalizePromptText, hasExplicitConfirmSyntax, hasPermissionActionContext, scorePermissionLikelihood, FALLBACK_SCORE_THRESHOLD, isSlashCommandMenu } from "./pty-text-utils.js";
+import { stripAnsi, isNoiseLine, appendWindow, normalizePromptText, hasExplicitConfirmSyntax, hasPermissionActionContext, scorePermissionLikelihood, FALLBACK_SCORE_THRESHOLD, isSlashCommandMenu, stripForEchoMatch, skipAnsiSequence } from "./pty-text-utils.js";
 // ── Constants ──
-const OUTPUT_MAX_SIZE = 120000;
+/**
+ * Hard cap on the in-memory PTY replay buffer. Aligned with the non-bridge
+ * branch of `ProcessManager.start()` so a session keeps the same amount of
+ * history regardless of which capture path is active.
+ */
+const OUTPUT_MAX_SIZE = 200000;
 const SESSION_ID_WINDOW_SIZE = 16384;
 const PERMISSION_WINDOW_SIZE = 2000;
 const AUTO_APPROVE_DELAY_MS = 350;
@@ -832,27 +837,45 @@ export class ClaudePtyBridge extends EventEmitter {
      * Find the end index of the echoed user input in the PTY buffer.
      * The echo may contain ANSI codes between characters.
      * Returns the index after the last character of the echo.
+     *
+     * Matching strategy:
+     * - Keep every printable codepoint of `userInput` (anything that is not a
+     *   control char or whitespace) for comparison. The previous version dropped
+     *   common symbols like `/`, `(`, `:`, space — which made commands such as
+     *   `ls /tmp` mismatch and start parsing the chat response from a wrong offset.
+     * - In the buffer, skip ANSI escape sequences entirely, and skip whitespace
+     *   so wrapped echoes (line continuation, padded columns) still align.
      */
     findEchoEndIndex(buffer, userInput) {
-        // Keep alphanumeric and common symbols for matching
-        const inputChars = userInput.replace(/[^a-zA-Z0-9+=?!\-]/g, "");
+        const inputChars = stripForEchoMatch(userInput);
         if (inputChars.length === 0)
             return 0;
         let matchedChars = 0;
         let endIndex = 0;
-        for (let i = 0; i < buffer.length && matchedChars < inputChars.length; i++) {
+        let i = 0;
+        while (i < buffer.length && matchedChars < inputChars.length) {
             const ch = buffer[i];
-            // Check if this printable char matches the next expected char
-            if (/[a-zA-Z0-9+=?!\-]/.test(ch) && ch.toLowerCase() === inputChars[matchedChars].toLowerCase()) {
+            const code = ch.charCodeAt(0);
+            // Skip a complete ANSI escape sequence (CSI/OSC/etc.).
+            if (code === 0x1b) {
+                i = skipAnsiSequence(buffer, i);
+                continue;
+            }
+            // Skip control chars and whitespace — they do not appear in `inputChars`.
+            if (code < 0x20 || code === 0x7f || code === 0x20) {
+                i++;
+                continue;
+            }
+            if (ch.toLowerCase() === inputChars[matchedChars].toLowerCase()) {
                 matchedChars++;
                 endIndex = i + 1;
             }
-            // Skip ANSI codes and other non-matching characters
+            i++;
         }
         // Look for a newline or prompt marker after the echo
-        for (let i = endIndex; i < buffer.length && i < endIndex + 50; i++) {
-            if (buffer[i] === "\n" || buffer[i] === "\r") {
-                endIndex = i + 1;
+        for (let j = endIndex; j < buffer.length && j < endIndex + 50; j++) {
+            if (buffer[j] === "\n" || buffer[j] === "\r") {
+                endIndex = j + 1;
                 break;
             }
         }

package/dist/git-quick-commit.js

@@ -341,9 +341,19 @@ export async function runQuickCommit(opts) {
     if (push) {
         try {
             let hasUpstream = false;
+            let pushRemote = "origin";
             try {
                 runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
                 hasUpstream = true;
+                try {
+                    const currentBranch = runGit(["branch", "--show-current"], cwd);
+                    if (currentBranch) {
+                        pushRemote = runGit(["config", "--get", `branch.${currentBranch}.remote`], cwd) || "origin";
+                    }
+                }
+                catch {
+                    pushRemote = "origin";
+                }
             }
             catch {
                 hasUpstream = false;
@@ -352,11 +362,9 @@ export async function runQuickCommit(opts) {
                 runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
             }
             else {
-                runGit(["push", "-u", "--recurse-submodules=on-demand", "origin", "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
-            }
-            if (tagName) {
-                runGit(["push", "origin", `refs/tags/${tagName}`], cwd, GIT_PUSH_TIMEOUT_MS);
+                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
             }
+            runGit(["push", pushRemote, "--tags"], cwd, GIT_PUSH_TIMEOUT_MS);
             pushed = true;
         }
         catch (error) {

package/dist/models.d.ts

@@ -1,11 +1,13 @@
-import { ClaudeModelInfo } from "./types.js";
+import { ClaudeModelInfo, SessionProvider } from "./types.js";
 interface ModelCache {
     models: ClaudeModelInfo[];
+    codexModels: ClaudeModelInfo[];
     claudeVersion: string | null;
     refreshedAt: string;
 }
 export declare function getCachedModels(): ModelCache;
 export declare function refreshModels(): Promise<ModelCache>;
+export declare function getModelsForProvider(provider: SessionProvider): ClaudeModelInfo[];
 /** 返回可用于 claude CLI 的全部已知 model id（含别名） */
 export declare function knownModelIds(): string[];
 /** 判断传入值是否是已知模型；允许自由文本，因此总是返回 true。保留接口以便将来严格校验。 */

package/dist/models.js

@@ -1,7 +1,7 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
-const BUILT_IN_MODELS = [
+const CLAUDE_MODELS = [
     { id: "default", label: "default（跟随 Claude Code 默认）", alias: true },
     { id: "opus", label: "opus（最新 Opus）", alias: true },
     { id: "sonnet", label: "sonnet（最新 Sonnet）", alias: true },
@@ -11,9 +11,12 @@ const BUILT_IN_MODELS = [
     { id: "claude-sonnet-4-6", label: "Sonnet 4.6 · claude-sonnet-4-6" },
     { id: "claude-haiku-4-5-20251001", label: "Haiku 4.5 · claude-haiku-4-5-20251001" },
 ];
+const CODEX_FALLBACK_MODELS = [
+    { id: "default", label: "default（跟随 Codex 默认）", alias: true },
+];
 let cache = null;
-function cloneDefaults() {
-    return BUILT_IN_MODELS.map((m) => ({ ...m }));
+function cloneClaudeModels() {
+    return CLAUDE_MODELS.map((m) => ({ ...m }));
 }
 async function probeClaudeVersion() {
     try {
@@ -25,10 +28,37 @@ async function probeClaudeVersion() {
         return null;
     }
 }
+async function probeCodexModels() {
+    try {
+        const { stdout } = await execAsync("codex debug models", { timeout: 8000 });
+        const data = JSON.parse(stdout);
+        const visible = data.models
+            .filter((m) => m.visibility === "list")
+            .sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99));
+        if (!visible.length)
+            return CODEX_FALLBACK_MODELS.map((m) => ({ ...m }));
+        const result = [
+            { id: "default", label: "default（跟随 Codex 默认）", alias: true },
+        ];
+        for (const m of visible) {
+            result.push({
+                id: m.slug,
+                label: m.display_name && m.display_name !== m.slug
+                    ? `${m.display_name} · ${m.slug}`
+                    : m.slug,
+            });
+        }
+        return result;
+    }
+    catch {
+        return CODEX_FALLBACK_MODELS.map((m) => ({ ...m }));
+    }
+}
 export function getCachedModels() {
     if (!cache) {
         cache = {
-            models: cloneDefaults(),
+            models: cloneClaudeModels(),
+            codexModels: CODEX_FALLBACK_MODELS.map((m) => ({ ...m })),
             claudeVersion: null,
             refreshedAt: new Date().toISOString(),
         };
@@ -36,17 +66,25 @@ export function getCachedModels() {
     return cache;
 }
 export async function refreshModels() {
-    const version = await probeClaudeVersion();
+    const [version, codexModels] = await Promise.all([
+        probeClaudeVersion(),
+        probeCodexModels(),
+    ]);
     cache = {
-        models: cloneDefaults(),
+        models: cloneClaudeModels(),
+        codexModels,
         claudeVersion: version,
         refreshedAt: new Date().toISOString(),
     };
     return cache;
 }
+export function getModelsForProvider(provider) {
+    const cached = getCachedModels();
+    return provider === "codex" ? cached.codexModels : cached.models;
+}
 /** 返回可用于 claude CLI 的全部已知 model id（含别名） */
 export function knownModelIds() {
-    return BUILT_IN_MODELS.map((m) => m.id);
+    return CLAUDE_MODELS.map((m) => m.id);
 }
 /** 判断传入值是否是已知模型；允许自由文本，因此总是返回 true。保留接口以便将来严格校验。 */
 export function isKnownModel(_value) {

package/dist/process-manager.d.ts

@@ -50,6 +50,8 @@ export declare class ProcessManager extends EventEmitter {
         provider?: SessionProvider;
         model?: string;
         reuseId?: string;
+        cols?: number;
+        rows?: number;
     }): SessionSnapshot;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */

package/dist/process-manager.js

@@ -108,6 +108,10 @@ function hasRecentProjectActivity(candidate, startedAt) {
 }
 function selectClaudeProjectSessionForRecord(record) {
     const knownMtimes = record.knownClaudeProjectMtimes ?? new Map();
+    // Only consider files created/touched AFTER this wand session started — those
+    // are the ones a fresh `claude` invocation could have produced. Files that
+    // existed before (knownMtimes entry present) are tolerated only if they
+    // grew since we observed them, but we de-prioritize them below.
     const candidates = listClaudeProjectSessionCandidates(record.cwd)
         .filter((candidate) => {
         const previousMtime = knownMtimes.get(candidate.id);
@@ -125,7 +129,19 @@ function selectClaudeProjectSessionForRecord(record) {
     if (!hasUserTurn) {
         return null;
     }
-    return candidates[0] ?? null;
+    // Prefer brand-new files (id not in knownMtimes at session start). When more
+    // than one fresh candidate exists in parallel sessions, refuse to bind —
+    // mis-binding another session's history is worse than waiting for the bridge
+    // to capture the canonical session id from PTY output.
+    const fresh = candidates.filter((candidate) => !knownMtimes.has(candidate.id));
+    if (fresh.length === 1) {
+        return fresh[0];
+    }
+    if (fresh.length > 1) {
+        return null;
+    }
+    // Fallback: existing file that grew. Only bind if a single grown candidate.
+    return candidates.length === 1 ? candidates[0] : null;
 }
 function getLatestClaudeProjectSessionId(record) {
     return selectClaudeProjectSessionForRecord(record)?.id ?? null;
@@ -407,7 +423,10 @@ export class ProcessManager extends EventEmitter {
                     confirmWindow: "",
                     ptyPermissionBlocked: false,
                     lastAutoConfirmAt: 0,
-                    autoApprovePermissions: this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode, provider),
+                    // Preserve a user-toggled auto-approve setting across server restarts
+                    // instead of recomputing it from the command/mode pair.
+                    autoApprovePermissions: snapshot.autoApprovePermissions
+                        ?? this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode, provider),
                     pendingEscalation: snapshot.pendingEscalation ?? null,
                     lastEscalationResult: snapshot.lastEscalationResult ?? null,
                     autonomyPolicy: snapshot.autonomyPolicy ?? this.defaultAutonomyPolicy(snapshot.mode),
@@ -426,7 +445,9 @@ export class ProcessManager extends EventEmitter {
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
                     claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
-                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
+                    ptyCols: snapshot.ptyCols ?? 120,
+                    ptyRows: snapshot.ptyRows ?? 36,
                 });
                 this.orphanRecoveredCount += 1;
             }
@@ -440,7 +461,8 @@ export class ProcessManager extends EventEmitter {
                     confirmWindow: "",
                     ptyPermissionBlocked: false,
                     lastAutoConfirmAt: 0,
-                    autoApprovePermissions: this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode, provider),
+                    autoApprovePermissions: snapshot.autoApprovePermissions
+                        ?? this.shouldAutoApprovePermissions(snapshot.command, snapshot.mode, provider),
                     pendingEscalation: snapshot.pendingEscalation ?? null,
                     lastEscalationResult: snapshot.lastEscalationResult ?? null,
                     autonomyPolicy: snapshot.autonomyPolicy ?? this.defaultAutonomyPolicy(snapshot.mode),
@@ -459,7 +481,9 @@ export class ProcessManager extends EventEmitter {
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
                     claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId,
-                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
+                    ptyCols: snapshot.ptyCols ?? 120,
+                    ptyRows: snapshot.ptyRows ?? 36,
                 });
             }
         }
@@ -531,12 +555,22 @@ export class ProcessManager extends EventEmitter {
             ? path.resolve(process.cwd(), cwd)
             : path.resolve(process.cwd(), this.config.defaultCwd);
         const id = opts?.reuseId || randomUUID();
+        // When a session is being resumed under the same id, capture its prior
+        // structured messages so the new bridge can present them as the chat
+        // history. We deliberately do NOT carry over rawOutput — `claude --resume`
+        // re-prints its own banner and replayed history into the new PTY, and
+        // mixing the two would surface every line twice in the terminal view.
+        let priorMessages = [];
         if (opts?.reuseId) {
             const oldRecord = this.sessions.get(id);
             if (oldRecord) {
+                priorMessages = oldRecord.ptyBridge?.getMessages() ?? oldRecord.messages ?? [];
                 this.cleanupRecord(oldRecord);
                 this.sessions.delete(id);
             }
+            else {
+                priorMessages = this.storage.getSession(id)?.messages ?? [];
+            }
         }
         const worktreeSetup = opts?.worktreeEnabled
             ? prepareSessionWorktree({ cwd: baseCwd, sessionId: id })
@@ -588,7 +622,7 @@ export class ProcessManager extends EventEmitter {
             rememberedEscalationScopes: new Set(),
             rememberedEscalationTargets: new Set(),
             storedOutput: "",
-            messages: [],
+            messages: priorMessages,
             childProcess: null,
             ptyBridge: null,
             currentTask: null,
@@ -599,6 +633,8 @@ export class ProcessManager extends EventEmitter {
             knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
             approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
             selectedModel: selectedModel ?? null,
+            ptyCols: opts?.cols !== undefined ? clampDimension(opts.cols, 20, 400) : 120,
+            ptyRows: opts?.rows !== undefined ? clampDimension(opts.rows, 10, 160) : 36,
         };
         if (isClaudeProvider) {
             record.ptyBridge = new ClaudePtyBridge({
@@ -606,6 +642,7 @@ export class ProcessManager extends EventEmitter {
                 isClaudeCommand: true,
                 autoApprove: record.autoApprovePermissions,
                 approvalPolicy: record.approvalPolicy,
+                initialMessages: priorMessages,
             });
             record.ptyBridge.on("event", (event) => {
                 this.handleBridgeEvent(record, event);
@@ -629,8 +666,10 @@ export class ProcessManager extends EventEmitter {
                     WAND_AUTO_EDIT: effectiveMode === "auto-edit" ? "1" : "0"
                 },
                 name: "xterm-color",
-                cols: 120,
-                rows: 36
+                // 使用 record 上由前端协商好的真实尺寸，避免"先 120 列、几百毫秒后再 resize"
+                // 期间 Claude/Codex 用错列宽渲染出 \x1b[120G 这类绝对列定位序列。
+                cols: record.ptyCols,
+                rows: record.ptyRows
             });
         }
         catch (err) {
@@ -874,12 +913,9 @@ export class ProcessManager extends EventEmitter {
      */
     setSessionModel(id, model) {
         const record = this.mustGet(id);
-        if (record.provider !== "claude") {
-            throw new Error("仅 Claude 会话支持切换模型。");
-        }
         const normalized = model?.trim() || null;
         record.selectedModel = normalized;
-        if (record.status === "running" && record.ptyProcess) {
+        if (record.provider === "claude" && record.status === "running" && record.ptyProcess) {
             const value = normalized && normalized !== "default" ? normalized : "default";
             record.ptyProcess.write(`/model ${value}\r`);
         }
@@ -952,7 +988,20 @@ export class ProcessManager extends EventEmitter {
         }
         const safeCols = clampDimension(cols, 20, 400);
         const safeRows = clampDimension(rows, 10, 160);
+        const changed = safeCols !== record.ptyCols || safeRows !== record.ptyRows;
         record.ptyProcess.resize(safeCols, safeRows);
+        record.ptyCols = safeCols;
+        record.ptyRows = safeRows;
+        if (changed) {
+            // Notify every subscribed client of the new authoritative dimensions so
+            // any other tab/device can re-fit its terminal instead of rendering
+            // wrap-broken output sized for someone else's viewport.
+            this.emitEvent({
+                type: "status",
+                sessionId: id,
+                data: { ptyCols: safeCols, ptyRows: safeRows },
+            });
+        }
         return this.snapshot(record);
     }
     stop(id) {
@@ -1151,6 +1200,8 @@ export class ProcessManager extends EventEmitter {
             summary: deriveSessionSummary(messages, record.currentTask?.title ?? null),
             currentTaskTitle: record.status === "running" ? record.currentTask?.title ?? undefined : undefined,
             selectedModel: record.selectedModel ?? null,
+            ptyCols: record.ptyCols,
+            ptyRows: record.ptyRows,
         };
     }
     /** Lightweight snapshot for list views — omits output and messages. */
@@ -1369,9 +1420,16 @@ export class ProcessManager extends EventEmitter {
                 record.output = record.ptyBridge?.getRawOutput() ?? record.output;
                 const rawMessages = record.ptyBridge?.getMessages() ?? [];
                 const isStreaming = record.status === "running";
+                const bridgeData = event.data;
                 const data = {
                     permissionBlocked: this.isPermissionBlocked(record),
                 };
+                // 透传 bridge 给出的 isResponding（true=流式中, false=本轮已完成）。
+                // 前端用它检测 thinking→idle 边界并主动做一次终端 resync，把 Claude/Codex
+                // 在流式渲染过程中残留的错位光标定位序列洗掉（等价于按一次右上角缩放）。
+                if (bridgeData && typeof bridgeData.isResponding === "boolean") {
+                    data.isResponding = bridgeData.isResponding;
+                }
                 if (isStreaming && rawMessages.length > 0) {
                     data.incremental = true;
                     const lastTurn = rawMessages[rawMessages.length - 1];
@@ -1523,13 +1581,18 @@ export class ProcessManager extends EventEmitter {
     }
     processCommandForMode(command, mode, provider, model) {
         if (provider === "codex") {
-            if (mode !== "full-access") {
-                return command;
+            let result = command;
+            const trimmedModel = model?.trim();
+            if (trimmedModel && trimmedModel !== "default" && !/--model\s/.test(command) && !/-m\s/.test(command)) {
+                const escapedModel = trimmedModel.replace(/'/g, "'\\''");
+                result += ` --model '${escapedModel}'`;
             }
-            if (/--dangerously-bypass-approvals-and-sandbox(?:\s|$)/.test(command)) {
-                return command;
+            if (mode === "full-access") {
+                if (!/--dangerously-bypass-approvals-and-sandbox(?:\s|$)/.test(result)) {
+                    result += " --dangerously-bypass-approvals-and-sandbox";
+                }
             }
-            return `${command} --dangerously-bypass-approvals-and-sandbox`;
+            return result;
         }
         const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
         if (!isClaudeCmd)

package/dist/pty-text-utils.d.ts

@@ -5,8 +5,32 @@
 export declare function stripAnsi(text: string): string;
 /** Lines considered as UI noise that should be excluded from chat view. */
 export declare function isNoiseLine(line: string): boolean;
-/** Append text to a windowed buffer, trimming from start if over max size. */
+/**
+ * Append text to a windowed buffer, trimming from start if over max size.
+ *
+ * The cut point is chosen so it never lands inside:
+ * - a UTF-16 surrogate pair (would corrupt the leading codepoint)
+ * - an unterminated ANSI escape sequence (would feed orphan "[31m..."
+ *   text to a downstream terminal renderer)
+ *
+ * The returned buffer may be slightly shorter than maxSize.
+ */
 export declare function appendWindow(buffer: string, chunk: string, maxSize: number): string;
+/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
+export declare function safeSliceTail(text: string, maxSize: number): string;
+/**
+ * Strip a string down to the printable codepoints used for echo matching.
+ * Removes control characters, whitespace and ANSI escapes; keeps all other
+ * visible characters (including `/`, `()`, `:`, CJK, emoji, etc.) so that
+ * echo alignment works for any user input.
+ */
+export declare function stripForEchoMatch(input: string): string;
+/**
+ * Given an index pointing at ESC (0x1b), return the index of the first
+ * character AFTER the escape sequence. Handles CSI, OSC and simple ESC-
+ * letter forms. Returns idx+1 if nothing matches (best-effort skip).
+ */
+export declare function skipAnsiSequence(text: string, idx: number): number;
 export declare function hasExplicitConfirmSyntax(normalized: string): boolean;
 export declare function hasPermissionActionContext(normalized: string): boolean;
 /**

package/dist/pty-text-utils.js

@@ -115,10 +115,166 @@ export function isNoiseLine(line) {
         return true;
     return false;
 }
-/** Append text to a windowed buffer, trimming from start if over max size. */
+/**
+ * Append text to a windowed buffer, trimming from start if over max size.
+ *
+ * The cut point is chosen so it never lands inside:
+ * - a UTF-16 surrogate pair (would corrupt the leading codepoint)
+ * - an unterminated ANSI escape sequence (would feed orphan "[31m..."
+ *   text to a downstream terminal renderer)
+ *
+ * The returned buffer may be slightly shorter than maxSize.
+ */
 export function appendWindow(buffer, chunk, maxSize) {
     const next = buffer + chunk;
-    return next.length > maxSize ? next.slice(-maxSize) : next;
+    if (next.length <= maxSize)
+        return next;
+    return safeSliceTail(next, maxSize);
+}
+/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
+export function safeSliceTail(text, maxSize) {
+    if (text.length <= maxSize)
+        return text;
+    let start = text.length - maxSize;
+    // 1. Skip UTF-16 low surrogate half so we don't strand a high surrogate.
+    if (start > 0 && start < text.length) {
+        const code = text.charCodeAt(start);
+        if (code >= 0xdc00 && code <= 0xdfff)
+            start++;
+    }
+    // 2. Prefer cutting at the next newline within a small lookahead window.
+    //    Newlines are always safe boundaries (no ANSI sequence spans a newline
+    //    in well-formed terminal output) and keep lines aligned for replay.
+    const LOOKAHEAD = 4096;
+    const upper = Math.min(start + LOOKAHEAD, text.length);
+    for (let i = start; i < upper; i++) {
+        if (text.charCodeAt(i) === 0x0a)
+            return text.slice(i + 1);
+    }
+    // 3. No nearby newline. Detect whether `start` lands inside an open ANSI
+    //    escape sequence by scanning backward for an ESC (0x1b). If we find one
+    //    that is not yet terminated, advance past the sequence's final byte.
+    const lookback = Math.max(0, start - 256);
+    let escAt = -1;
+    for (let i = start - 1; i >= lookback; i--) {
+        const code = text.charCodeAt(i);
+        if (code === 0x1b) {
+            escAt = i;
+            break;
+        }
+        // If we hit a terminator before an ESC, the previous sequence is closed.
+        if (code === 0x07)
+            break;
+        if (code >= 0x40 && code <= 0x7e && i > 0 && isLikelyAnsiBody(text, i - 1))
+            break;
+    }
+    if (escAt !== -1) {
+        // OSC 序列以 `ESC ]` (0x1b 0x5d) 开头，必须用 BEL (0x07) 或
+        // ST (`ESC \\` = 0x1b 0x5c) 终止。其它范围内字节（包括裸 `\`）
+        // 都属于 payload，不能当终止符。CSI 等序列才用 0x40-0x7e final byte。
+        const isOsc = escAt + 1 < text.length && text.charCodeAt(escAt + 1) === 0x5d;
+        let terminated = false;
+        for (let i = escAt + 1; i < start; i++) {
+            const code = text.charCodeAt(i);
+            if (code === 0x07) {
+                terminated = true;
+                break;
+            }
+            if (isOsc) {
+                if (code === 0x1b && i + 1 < start && text.charCodeAt(i + 1) === 0x5c) {
+                    terminated = true;
+                    break;
+                }
+                continue;
+            }
+            if (code >= 0x40 && code <= 0x7e) {
+                terminated = true;
+                break;
+            }
+        }
+        if (!terminated) {
+            const ansiUpper = Math.min(start + 256, text.length);
+            for (let i = start; i < ansiUpper; i++) {
+                const code = text.charCodeAt(i);
+                if (code === 0x07)
+                    return text.slice(i + 1);
+                if (isOsc) {
+                    if (code === 0x1b && i + 1 < ansiUpper && text.charCodeAt(i + 1) === 0x5c) {
+                        return text.slice(i + 2);
+                    }
+                    continue;
+                }
+                if (code >= 0x40 && code <= 0x7e)
+                    return text.slice(i + 1);
+            }
+        }
+    }
+    return text.slice(start);
+}
+function isLikelyAnsiBody(text, idx) {
+    // CSI parameter/intermediate range covers most common ANSI bodies.
+    const code = text.charCodeAt(idx);
+    return code === 0x5b /* [ */ || code === 0x3f /* ? */ || (code >= 0x30 && code <= 0x3f);
+}
+/**
+ * Strip a string down to the printable codepoints used for echo matching.
+ * Removes control characters, whitespace and ANSI escapes; keeps all other
+ * visible characters (including `/`, `()`, `:`, CJK, emoji, etc.) so that
+ * echo alignment works for any user input.
+ */
+export function stripForEchoMatch(input) {
+    let out = "";
+    for (let i = 0; i < input.length; i++) {
+        const code = input.charCodeAt(i);
+        if (code === 0x1b) {
+            i = skipAnsiSequence(input, i) - 1;
+            continue;
+        }
+        if (code < 0x20 || code === 0x7f)
+            continue;
+        if (code === 0x20)
+            continue;
+        out += input[i];
+    }
+    return out;
+}
+/**
+ * Given an index pointing at ESC (0x1b), return the index of the first
+ * character AFTER the escape sequence. Handles CSI, OSC and simple ESC-
+ * letter forms. Returns idx+1 if nothing matches (best-effort skip).
+ */
+export function skipAnsiSequence(text, idx) {
+    if (text.charCodeAt(idx) !== 0x1b)
+        return idx;
+    const next = text.charCodeAt(idx + 1);
+    if (Number.isNaN(next))
+        return idx + 1;
+    // CSI: ESC [ ... final-byte (0x40-0x7E)
+    if (next === 0x5b /* [ */) {
+        let i = idx + 2;
+        while (i < text.length) {
+            const code = text.charCodeAt(i);
+            if (code >= 0x40 && code <= 0x7e)
+                return i + 1;
+            i++;
+        }
+        return text.length;
+    }
+    // OSC: ESC ] ... terminator (BEL or ESC \)
+    if (next === 0x5d /* ] */) {
+        let i = idx + 2;
+        while (i < text.length) {
+            const code = text.charCodeAt(i);
+            if (code === 0x07)
+                return i + 1;
+            if (code === 0x1b && text.charCodeAt(i + 1) === 0x5c)
+                return i + 2;
+            i++;
+        }
+        return text.length;
+    }
+    // Two-character ESC sequences (ESC = / ESC > / ESC M / etc.)
+    return idx + 2;
 }
 const EXPLICIT_CONFIRM_PATTERNS = [
     /(?:^|\b)(?:press\s+)?(?:y|yes)\s*(?:\/|\bor\b)\s*(?:n|no)(?:\b|$)/i,