@xiaoqiong0v0/opencode-ssh-tool 0.6.14 → 0.6.16

package/dist/base-session.js

@@ -1,48 +1,98 @@
 // BaseSession：SSH(SshSession) 与本地(LocalSession) 终端的公共基类
-// 统一完成标记法：注入 PROMPT_COMMAND 脚本，命令完成时输出 <SSH_DONE:退出码>
+// 统一完成标记法：每条命令后追加一条标记命令，完成后输出 <SSH_DONE:nonce:seq:退出码>（不依赖 PROMPT_COMMAND/PS1 钩子）
 // 子类仅需实现：连接建立(connect)、数据写入(_write)、传输层清理(_closeTransport)、状态字段(getStatus)
 import { randomUUID } from "node:crypto";
-import { ANIMATION_WINDOW_MS, MAX_OUTPUT_LEN, RAW_LOG_MAX, DONE_TAG, SYNTAX_QUIET_MS, SYNTAX_MAX_WAIT_MS, FALLBACK_WATCH_INTERVAL_MS, INTERRUPT_PROBE_INTERVAL_DEFAULT_SEC, } from "./constants.js";
-import log, { debug, describeSend, isDebugEnabled, tailLines, tailSummary } from "./log.js";
+import { ANIMATION_WINDOW_MS, MAX_OUTPUT_LEN, RAW_LOG_MAX, DONE_TAG, PROBE_TAG, SYNTAX_QUIET_MS, SYNTAX_MAX_WAIT_MS, FALLBACK_WATCH_INTERVAL_MS, INTERRUPT_PROBE_INTERVAL_DEFAULT_SEC, } from "./constants.js";
+import log, { debug, describeSend, infoDedup, isDebugEnabled, tailLines, tailSummary } from "./log.js";
 import { decodeTerminalEscapes } from "./escapes.js";
 import { SessionHistory } from "./history.js";
-import { toModelText, extractOutputStart, stripTrailingPromptLine, ECHO_REGEX_MAX_CMD_CHARS, echoRegexSourceLength } from "./utils.js";
-import { detectLastDoneMarker, stripMarkers, detectInterrupt, detectSyntaxError, adapters } from "./shell-adapter.js";
+import { toModelText, extractOutputStart, removeProbeEchoLines, ECHO_REGEX_MAX_CMD_CHARS, echoRegexSourceLength } from "./utils.js";
+import { detectLastDoneMarker, detectLastProbeMarker, stripMarkers, detectInterrupt, detectSyntaxError, adapters } from "./shell-adapter.js";
 import { tr } from "./i18n.js";
 /** buffer 最大长度（未消费输出超限时截断头部，防内存膨胀） */
 const MAX_BUFFER_LEN = 2 * 1024 * 1024;
 /** Shell 探测等待超时 */
 const PROBE_TIMEOUT_MS = 5_000;
+/** 探针回显 seq 保留上限：只保留最近 N 条，防长会话 Set 无界增长与剔除成本 O(N×行) */
+const PROBE_SEQ_KEEP = 8;
 /**
- * 剥离命令尾部注释：仅当 `#` 在行首或前有空白、且不在单双引号内（支持反斜杠转义）时视为注释，
- * 避免 `echo "a#b"` / `echo 'a#b'` 引号内的 # 被误剥，也避免 marker 被真注释吞掉。
- * @param s 命令文本
+ * 剥离命令尾部注释：只在**最后一行**、`#` 位于引号外且处于词首时视为注释。
+ * 扫描整条命令以维护跨行引号状态（bash/pwsh 字符串都可跨行），避免 `"line2 # x"` 被误截断。
+ * - pwsh：反引号是转义符；单引号内 `''` 表示字面单引号。
+ * - bash/zsh：反斜杠转义；反引号是命令替换，内部 `#` 不剥（保守处理）。
+ * - cmd：不支持 `#` 注释，跳过。
+ * @param s 完整命令文本
+ * @param shell 适配器名（bash/zsh/pwsh/cmd；空串按 POSIX 处理）
  * @returns 剥离尾注释（若有）后的文本
  */
-function stripTrailingComment(s) {
+function stripTrailingComment(s, shell) {
+    if (shell === "cmd")
+        return s.trimEnd();
+    const pwsh = shell === "pwsh" || shell === "powershell";
+    const lastLineStart = s.lastIndexOf("\n") + 1;
     let inSingle = false;
     let inDouble = false;
-    let escaped = false;
+    let inBacktick = false;
     for (let i = 0; i < s.length; i++) {
         const c = s[i];
-        if (escaped) {
-            escaped = false;
+        if (c === "\n")
+            continue;
+        if (inSingle) {
+            if (pwsh && c === "'" && s[i + 1] === "'") {
+                i++;
+                continue;
+            }
+            if (c === "'")
+                inSingle = false;
+            continue;
+        }
+        if (inDouble) {
+            if (pwsh && c === "`") {
+                i++;
+                continue;
+            }
+            if (!pwsh && c === "\\") {
+                i++;
+                continue;
+            }
+            if (c === '"')
+                inDouble = false;
+            continue;
+        }
+        if (inBacktick) {
+            if (c === "`")
+                inBacktick = false;
+            continue;
+        }
+        if (pwsh && c === "`") {
+            i++;
+            continue;
+        }
+        if (!pwsh && c === "\\") {
+            i++;
             continue;
         }
-        if (c === "\\") {
-            escaped = true;
+        if (c === "'") {
+            inSingle = true;
             continue;
         }
-        if (c === "'" && !inDouble) {
-            inSingle = !inSingle;
+        if (c === '"') {
+            inDouble = true;
             continue;
         }
-        if (c === '"' && !inSingle) {
-            inDouble = !inDouble;
+        if (!pwsh && c === "`") {
+            inBacktick = true;
             continue;
         }
-        if (c === "#" && !inSingle && !inDouble && (i === 0 || /\s/.test(s[i - 1]))) {
-            return s.slice(0, i).trimEnd();
+        // 注释起始：行首/空白/语句分隔符/括号之后（`;#`、`&#`、`)#` 都能正确识别）
+        if (c === "#" && (i === 0 || /[\s;&|(){}]/.test(s[i - 1]))) {
+            if (i >= lastLineStart)
+                return s.slice(0, i).trimEnd();
+            // 前面的行上的注释：跳过本行剩余内容，继续扫描后续行
+            const nl = s.indexOf("\n", i);
+            if (nl < 0)
+                break;
+            i = nl;
         }
     }
     return s.trimEnd();
@@ -52,16 +102,17 @@ function stripTrailingComment(s) {
  * - 尾注释 `# xxx` 把 marker 整行吞掉 → 检测不到完成
  * - 尾运算符 `&`、`;`、`&&`、`||` 与拼接的 `;` 形成 `&;`/`;;` 等语法错误
  * @param command 原始命令
+ * @param shell 适配器名（用于正确的引号/转义语义；空串按 POSIX 处理）
  * @returns 可安全拼装 marker 的命令体
  */
-function stripCommandTail(command) {
-    // 仅处理最后一行：多行命令（如 heredoc 正文）中间的 `#` 是内容，若在此截断会把命令切断
-    const nl = command.lastIndexOf("\n");
-    const head = nl >= 0 ? command.slice(0, nl + 1) : "";
-    const last = nl >= 0 ? command.slice(nl + 1) : command;
-    let s = stripTrailingComment(last);
-    s = s.replace(/(?:&&|\|\||[;&|])[\s]*$/, "");
-    return (head + s).trimEnd();
+export function stripCommandTail(command, shell = "") {
+    const withoutComment = stripTrailingComment(command, shell);
+    // 仅处理最后一行：多行命令（如 heredoc 正文）中间的 `#`/运算符是内容，不能在这里截断
+    const nl = withoutComment.lastIndexOf("\n");
+    const head = nl >= 0 ? withoutComment.slice(0, nl + 1) : "";
+    const last = nl >= 0 ? withoutComment.slice(nl + 1) : withoutComment;
+    const cleaned = last.replace(/(?:&&|\|\||[;&|])[\s]*$/, "");
+    return (head + cleaned).trimEnd();
 }
 /**
  * 诊断辅助：转义控制字符，使日志单行可读（\r\n\t 转义、ESC 写成 \x1b）。
@@ -150,11 +201,6 @@ export class BaseSession {
      * 只认自己 nonce：重放标记不再冒充本会话标记。
      */
     _nonce = randomUUID().replace(/-/g, "").slice(0, 8);
-    /**
-     * 命令发起前缓冲的末行（旧提示符行）：语法错误收尾时 shell 会重印同形提示符，
-     * 据此把它从输出尾部剥掉（exec 的输出窗口自命令回显起，旧提示符在窗口之外，需单独记录）。
-     */
-    _promptRef = "";
     /** 下次捕获窗口起点（相对当前 buffer）：前一条命令结束后，标记/残留从此处开始 */
     _cursor = 0;
     /** WS 实时流已发送位置（相对 buffer 偏移）；null = 尚未定位命令回显结束点 */
@@ -163,6 +209,12 @@ export class BaseSession {
     _adapter = null;
     /** 多行命令写入 PTY 的行分隔符：Unix PTY 用 \n；Windows ConPTY（本地会话）用 \r（裸 \n 不提交行） */
     _lineSep = "\n";
+    /**
+     * 当前会话终端是否为 Windows ConPTY：决定提交分隔符。
+     * 本地会话按宿主平台设置；SSH 会话在 shell 探测后按 pwsh 的 `$PSHOME` 路径判断
+     *（Windows `C:\...` → true，Unix `/...` → false），不能只看 adapter 类型。
+     */
+    _windowsPTY = process.platform === "win32";
     _closed = false;
     /** 当前运行命令的输入时刻（history 记录展示命令发起时间用） */
     _runningStartTs = 0;
@@ -262,7 +314,7 @@ export class BaseSession {
         const completion = this._awaitCompletion();
         this._write(this._composeCommand(command));
         const outcome = await completion;
-        log.info(`exec ${this._logTag} seq=${this._runningSeq} cmdLen=${command.length} -> ${outcome.kind}${outcome.kind === "running" ? "" : " markerPos=" + outcome.markerPos + " exitCode=" + outcome.exitCode + " duration=" + (Date.now() - startTs) + "ms"} (busy=${this._remoteBusy})`);
+        debug(`exec ${this._logTag} seq=${this._runningSeq} cmdLen=${command.length} -> ${outcome.kind}${outcome.kind === "running" ? "" : " markerPos=" + outcome.markerPos + " exitCode=" + outcome.exitCode + " duration=" + (Date.now() - startTs) + "ms"} (busy=${this._remoteBusy})`);
         debug(`exec ${this._logTag} seq=${this._runningSeq} cmd=${tailLines(command, 3)}`);
         switch (outcome.kind) {
             case "done": {
@@ -351,6 +403,14 @@ export class BaseSession {
      * @returns 8 位十六进制会话串
      */
     get nonce() { return this._nonce; }
+    /**
+     * 当前 shell 适配器名（"zsh" / "bash" / "pwsh" / "cmd"）：供发送前语法预检选校验器。
+     * 只读暴露探测结果，不触发探测（未连接时为 null，调用方按"不校验"处理）。
+     * @returns 适配器名；未连接/未探测到适配器时为 null
+     */
+    get shellName() { return this._adapter?.name ?? null; }
+    /** 是否本地会话：发送前语法预检只接本地（SSH 远程需会话内往返，另开一轮） */
+    get isLocal() { return false; }
     getRunningOutput() {
         if (this._runningStartPos === null || !this._connected || !this._runningCommand)
             return "";
@@ -389,12 +449,18 @@ export class BaseSession {
      * 供事后对齐状态时间线（busy 每次翻转都能对应到具体原因，不再出现"忙了却查不出为何"）。
      * @param next 目标 busy 值
      * @param reason 翻转原因（cmdStart / cmdRunning / cmdDone / 会话关闭 / 断连补 done 等）
+     * @param quiet true 时该行降为 debug：用于"释放"与紧随其后的收尾行（如 [run] 结束）重复的场景，
+     *   避免同一事件打两条 info（busy 时间线仍可由该收尾行还原）
      */
-    _setBusy(next, reason) {
+    _setBusy(next, reason, quiet = false) {
         if (this._remoteBusy === next)
             return;
         this._remoteBusy = next;
-        log.info(`[busy] ${this._logTag} seq=${this._runningSeq} busy=${next} reason=${reason}`);
+        const line = `[busy] ${this._logTag} seq=${this._runningSeq} busy=${next} reason=${reason}`;
+        if (quiet)
+            debug(line);
+        else
+            log.info(line);
         // 通知插件同步状态文件（busy 已更新，getStatus 读到新值）；监听器异常不打断执行
         try {
             this._busyListener?.(next, reason);
@@ -459,10 +525,7 @@ export class BaseSession {
         }
         const raw = this._buffer.slice(this._streamPos, windowEnd);
         this._streamPos = windowEnd;
-        let data = stripMarkers(raw);
-        if (this._adapter)
-            data = data.replace(this._markerCmd(this._runningSeq), "");
-        data = this._stripProbeEchoes(data);
+        const data = this._stripProbeEchoes(stripMarkers(raw));
         return { data, done: marker.done };
     }
     /** 关闭终端，清理会话态（幂等） */
@@ -472,7 +535,10 @@ export class BaseSession {
         this._closed = true;
         if (this._watchTimer)
             clearInterval(this._watchTimer);
-        this._stopInterruptCycle("会话关闭");
+        this._watchTimer = null;
+        // 先清运行上下文（含语法/中断定时器），再释放 history：
+        // 否则 close 后定时器仍可能触发写已关闭终端，并在 history 已 dispose 时 append 抛未捕获 ENOENT
+        this._clearRunningContext();
         this._closeTransport();
         this._connected = false;
         this._setBusy(false, "会话关闭");
@@ -493,28 +559,39 @@ export class BaseSession {
     _markerCmd(seq) {
         return this._adapter ? this._adapter.markerCmd(this._nonce, seq) : `printf '\\n${DONE_TAG}${this._nonce}:${seq}:%s>' $?`;
     }
+    /**
+     * 补发探针命令：与完成标记命令**同构**，仅把 tag 换成 PROBE_TAG。
+     * 复用各 adapter 的 markerCmd，避免四套 shell 各维护一份退出码表达式；
+     * 独立 tag 让「探针标记」与「原命令真实完成标记」在字节流里可严格区分。
+     * @param seq 命令序号
+     * @returns 探针标记命令文本
+     */
+    _probeCmd(seq) {
+        const marker = this._markerCmd(seq);
+        // cmd 的 marker 用 ^< 转义，DONE_TAG 不再是连续子串；此时只替换 tag 主体
+        return marker.includes(DONE_TAG) ? marker.replace(DONE_TAG, PROBE_TAG) : marker.replace("SSH_DONE:", "SSH_PROBE:");
+    }
     /**
      * 组合实际写入 PTY 的命令：在规范形式（`_composeEchoText`）基础上把换行改写为行分隔符并补尾部回车。
-     * 行分隔符按**探测到的 shell 类型/平台**决定，而非按传输类型（本地/SSH）：
-     * - Windows shell（pwsh/cmd，控制台为 ConPTY）→ `\r`；本地 ConPTY 会话（无 adapter 时由 `_lineSep` 覆盖为 `\r`）→ `\r`；
-     * - SSH + POSIX（zsh/bash，走 Unix PTY）→ `\n`（`_lineSep` 默认值）。
+     * 行分隔符按**探测到的终端平台**决定，而非按传输类型（本地/SSH）：
+     * - Windows ConPTY（本机 Windows，或 SSH 到 Windows pwsh/cmd）→ `\r`；
+     * - Unix PTY（bash/zsh，含 Linux/macOS 上的 pwsh）→ `_lineSep`（通常 `\n`）。
+     * SSH 的 pwsh 平台由探测输出里的 `$PSHOME` 路径区分（`C:\...` vs `/...`）。
      * 原因：ConPTY 下裸 `\n` 只下移不复位、不提交行 → 多行命令逆序执行并卡在 `>>` 续行，须用 `\r`；
-     * 实测 SSH 连到 Windows 的 pwsh：用 `\n` 分隔时命令逆序卡死，改用 `\r` 后行序正确、组内作用域保留、输出正常。
-     * Unix PTY 下 `\n` 可正常提交行，保持不变。
+     * Unix PTY 下 `\n` 可正常提交行。
      * @param command 原始命令（history 存干净版本）
-     * @returns 实际写入 PTY 的文本（尾部带 \r，行分隔已按 shell 类型/平台规范化）
+     * @returns 实际写入 PTY 的文本（尾部带提交分隔符，行分隔已按平台规范化）
      */
     _composeCommand(command) {
-        // 行分隔符按 shell 类型/平台判定（见 _ptyLineSep）
-        return this._composeEchoText(command).replace(/\n/g, this._ptyLineSep()) + "\r";
+        // 行分隔符按终端平台判定（见 _ptyLineSep）
+        return this._composeEchoText(command).replace(/\n/g, this._ptyLineSep()) + this._ptyLineSep();
     }
     /**
-     * 当前 shell 的 PTY **提交分隔符**（让 shell 执行该行）：Windows shell（pwsh/cmd，ConPTY）→ `\r`
-     * （裸 \n 不提交行）；其余沿用会话 `_lineSep`（Unix PTY 为 \n，本地会话为 \r）。
+     * 当前终端的 PTY **提交分隔符**：Windows ConPTY → `\r`；Unix PTY → `_lineSep`（通常 `\n`）。
      * @returns 提交分隔符字符串
      */
     _ptyLineSep() {
-        return this._adapter?.windowsShell ? "\r" : this._lineSep;
+        return this._windowsPTY ? "\r" : this._lineSep;
     }
     /**
      * 组合中断探针写入文本：**不加任何前缀换行**，直接写一条独立的当前 seq 完成标记命令，
@@ -529,26 +606,39 @@ export class BaseSession {
      * @returns 写入 PTY 的探针文本
      */
     _composeProbe(seq) {
-        return this._markerCmd(seq) + "\r";
+        return this._probeCmd(seq) + this._ptyLineSep();
+    }
+    /** 记录探针 seq，只保留最近 PROBE_SEQ_KEEP 条（迟到回显跨命令有限，避免 Set 无界增长） */
+    _rememberProbeSeq(seq) {
+        this._probeSeqs.add(seq);
+        while (this._probeSeqs.size > PROBE_SEQ_KEEP) {
+            const first = this._probeSeqs.values().next().value;
+            if (first === undefined)
+                break;
+            this._probeSeqs.delete(first);
+        }
     }
     /**
-     * 补发一次中断探针：用户显式 Ctrl+C 后，前台命令可能已死、shell 已回到提示符，
-     * 但命令列表被中断丢弃 → 原命令的完成标记永不执行 → busy 卡死。
-     * 补写一条"裸标记命令"作为探针：shell 若已回到提示符会读它并打印当前 seq 标记，
-     * 使命令正常收尾；若前台程序未死，字节留在 tty 输入缓冲，待 shell 拿回控制权时再读
-     * （两种情况均符合预期，保持 busy、绝不误判完成）。
-     * 由中断周期调用：写完 \x03 时立即调用一次，之后定时器每间隔调用一次（见 _startInterruptCycle）。
-     * 幂等：同一条被中断命令多次补发（立即 1 条 + 每间隔 1 条），先到的当前 seq 标记胜出。
+     * 补发一次当前命令的探针标记（仅中断收尾使用）：
+     * 写入一条独立的本 seq 标记命令，并记录 seq，使其回显迟到落入后续窗口时仍能被剔除。
+     * - 中断场景：用户显式 Ctrl+C 后前台命令可能已死、原命令的完成标记永不执行 → busy 卡死；
+     *   补写探针后 shell 若已回到提示符会读它并打印当前 seq 标记使命令收尾；若前台程序未死，
+     *   字节留在 tty 输入缓冲待 shell 拿回控制权再读（两种情况均符合预期，绝不误判完成）。
+     *   由中断周期调用：写完 \x03 时立即补发一次，之后定时器每间隔补发一次（见 _startInterruptCycle）。
+     * 幂等：同一条命令多次补发时，先到的当前 seq 标记胜出。仅在确实追踪着命令时补发（空闲补发只污染缓冲）。
+     * 注意：语法错误路径**不再补发探针**（会写进仍在运行程序的 stdin），改为安静窗口到点直接收尾。
+     * @param reason 补发原因（仅用于日志：中断探针）
      * @returns 无
      */
-    _sendInterruptProbe() {
-        // 仅在确实有正在追踪的命令时补发：空闲期 Ctrl+C 无待收尾命令，补发只会污染缓冲
+    _sendProbe(reason) {
+        if (!this._connected)
+            return;
         if (this._runningStartPos === null || this._runningCommand === "")
             return;
         const seq = this._runningSeq;
-        this._probeSeqs.add(seq);
+        this._rememberProbeSeq(seq);
         const probe = this._composeProbe(seq);
-        debug(`中断探针 ${this._logTag} seq=${seq} ${JSON.stringify(probe)} (busy=${this._remoteBusy})`);
+        debug(`${reason} ${this._logTag} seq=${seq} ${JSON.stringify(probe)} (busy=${this._remoteBusy})`);
         this._write(probe);
     }
     /**
@@ -570,7 +660,7 @@ export class BaseSession {
         const intervalSec = this._interruptProbeIntervalMs / 1000;
         log.info(`中断周期开始 ${this._logTag} seq=${seq}，已立即补发首条探针，之后每 ${intervalSec}s 一条`);
         // 写完 \x03 后立即补发首条探针（t0），后续 setInterval 自此刻起按间隔补发（t0+N、t0+2N…）
-        this._sendInterruptProbe();
+        this._sendProbe("中断探针");
         this._interruptTimer = setInterval(() => { this._onInterruptTick(); }, this._interruptProbeIntervalMs);
     }
     /**
@@ -583,7 +673,7 @@ export class BaseSession {
             this._stopInterruptCycle("命令已结束或会话关闭");
             return;
         }
-        this._sendInterruptProbe();
+        this._sendProbe("中断探针");
     }
     /**
      * 停止中断周期并清周期状态：清定时器，日志记录结束原因（幂等，未在周期内时不做任何事）。
@@ -599,23 +689,24 @@ export class BaseSession {
         log.info(`中断周期结束 ${this._logTag} seq=${this._runningSeq}，原因=${reason}`);
     }
     /**
-     * 从可见输出中剔除中断探针留下的痕迹（探针命令的回显）。
-     * 探针在用户中断时补发，其回显可能迟到落到后续命令的输出窗口里；按已记录探针 seq
-     * 生成精确回显文本并删除全部出现，从而无论何时到达都剔除。完成标记本身由 stripMarkers
-     * 按标记模式统一去除（不限 seq）。Raw 视图不经此函数，保留原始字节。
+     * 从可见输出中剔除探针留下的痕迹（探针命令的回显）。
+     * 探针命令已改为独立 PROBE tag，但其回显仍是"一条标记命令"；同时保留对当前命令 DONE 标记回显的剔除。
+     * 对每个已记录探针 seq（以及当前命令自身）做 **ANSI 容忍定位**：即便 pwsh 语法高亮在 token 间插入
+     * SGR、行首带提示符与 `\x1b[?25l`，也能命中并整段剔除（见 removeProbeEchoLines）。
+     * 三处调用点（本函数、getRunningStream、readBuffer）统一收敛至此；Raw 视图保留原始字节。
      * @param text 可见输出文本
      * @returns 剔除探针回显后的文本
      */
     _stripProbeEchoes(text) {
-        if (this._probeSeqs.size === 0)
-            return text;
-        let out = text;
+        const needles = new Set();
         for (const seq of this._probeSeqs) {
-            const echo = this._markerCmd(seq);
-            if (out.includes(echo))
-                out = out.split(echo).join("");
+            needles.add(this._markerCmd(seq));
+            needles.add(this._probeCmd(seq));
         }
-        return out;
+        // 当前命令的标记命令回显：与上面可能重复，Set 去重避免同一 needle 反复扫描
+        needles.add(this._markerCmd(this._runningSeq));
+        needles.add(this._probeCmd(this._runningSeq));
+        return removeProbeEchoLines(text, [...needles]);
     }
     /**
      * 组合命令文本（规范/匹配用形式，始终以 `\n` 分隔行、无尾部回车）：命令 + 完成标记。
@@ -636,8 +727,11 @@ export class BaseSession {
      */
     _composeEchoText(command) {
         const marker = this._markerCmd(this._runningSeq);
-        const body = stripCommandTail(command);
+        const body = stripCommandTail(command, this._adapter?.name ?? "");
         const sep = this._adapter?.stmtSep ?? ";";
+        // cmd：marker 必须独占下一行——%errorlevel% 是整行解析期展开，同行拼接会取到旧值
+        if (this._adapter?.name === "cmd")
+            return `${body}\n${marker}`;
         // 多行命令：尝试包组（cmd 返回 null → 回退原样拼接），使整段作为一条命令执行
         if (body.includes("\n")) {
             const grouped = this._adapter?.groupWrap(body);
@@ -654,7 +748,7 @@ export class BaseSession {
      * 语法错误路径（syntaxMode）另作两处特殊处理：
      * - 回显定位取**首次**匹配：pwsh 错误块的 `   1 |  <命令>` 行会重印含标记的整行命令，
      *   末次匹配会落到该拷贝上，导致 `ParserError:`/`Line |` 等错误块前半被裁掉；
-     * - 剥掉尾部 shell 重印的提示符行（与旧提示符行同形，属画面噪音）。
+     * - 输出窗口右界取缓冲区末尾（不再补发语法探针），尾部最多多 1 行提示符噪音。
      * @param raw 本次执行窗口原始字节流
      * @param command 原始命令（历史用）
      * @param syntaxMode true 表示语法/解析错误收尾（无完成标记，整行命令作废）
@@ -663,33 +757,29 @@ export class BaseSession {
     _extractOutput(raw, command, syntaxMode = false) {
         // 完成标记先定位：marker 自带唯一 seq，从窗口起点搜索即可（echoEnd 可能被连续输入的后序回显带偏）
         const marker = detectLastDoneMarker(raw, 0, this._nonce, this._runningSeq);
+        // 中断探针路径没有真实完成标记，右界取 PROBE 标记结束位置，避免把探针之后的提示符污染带进输出；
+        // 语法错误路径不补发探针，boundary 退到 raw.length（尾部最多多 1 行提示符噪音）
+        const probe = marker.done ? null : detectLastProbeMarker(raw, 0, this._nonce, this._runningSeq);
+        const boundary = marker.done ? marker.pos : (probe?.done ? probe.pos : raw.length);
         const echoText = this._composeEchoText(command);
         const echoLen = echoText.trim().length;
         // 超长回显：extractOutputStart 会降级为"首/尾锚点"匹配（否则模式源约 265×长度，JSC 下会抛 too large）
         if (echoLen > ECHO_REGEX_MAX_CMD_CHARS) {
-            log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 回显定位降级为首/尾锚点: echoLen=${echoLen} regexSrcLen=${echoRegexSourceLength(echoText)} (>阈值 ${ECHO_REGEX_MAX_CMD_CHARS})`);
+            debug(`[extract] ${this._logTag} seq=${this._runningSeq} 回显定位降级为首/尾锚点: echoLen=${echoLen} regexSrcLen=${echoRegexSourceLength(echoText)} (>阈值 ${ECHO_REGEX_MAX_CMD_CHARS})`);
         }
         let end;
-        const extractStart = Date.now();
         try {
-            end = marker.done
-                ? extractOutputStart(raw, echoText, marker.pos)
-                : extractOutputStart(raw, echoText, raw.length, syntaxMode);
+            end = extractOutputStart(raw, echoText, boundary, syntaxMode);
         }
         catch (e) {
             // 回显定位异常绝不上抛（否则会中断完成收尾）：记一行后退回整窗输出
             log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 回显定位失败, 退回整窗: echoLen=${echoLen} err=${e instanceof Error ? e.message : String(e)}`);
             end = -1;
         }
-        // 诊断：定位结果与耗时（ret<=0 显眼标注"定位失败"）
-        log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 定位: inLen=${raw.length} patternLen=${echoRegexSourceLength(echoText)} ret=${end <= 0 ? `<${end}> 定位失败` : end} elapsedMs=${Date.now() - extractStart}`);
         // 诊断：输出窗口坐标 + 是否退回整窗（startPos=回显结束偏移，endPos=窗口末尾；窗口长=endPos-startPos）
         const winStart = end <= 0 ? 0 : end;
-        const winEnd = marker.done ? marker.pos : raw.length;
-        log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 窗口: startPos=${winStart} endPos=${winEnd} 窗口长=${winEnd - winStart} markerSeq=${this._runningSeq} 是否退回整窗=${end <= 0 ? `是(定位失败, syntaxMode=${syntaxMode})` : "否"}`);
-        // 诊断：只扫本命令窗口 [winStart, winEnd) 内的完成标记（最多列 5 个，位置为相对窗口起点的偏移）——定位"输出里混进的标记来自哪条命令"
-        const hits = scanDoneMarkers(raw.slice(winStart, winEnd));
-        log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 窗口内含标记: ${hits.length === 0 ? "无" : hits.slice(0, 5).map((h) => `@${h.pos}=${h.seq ?? "?"}`).join(" ")}`);
+        const winEnd = boundary;
+        debug(`[extract] ${this._logTag} seq=${this._runningSeq} 窗口: startPos=${winStart} endPos=${winEnd} 窗口长=${winEnd - winStart} markerSeq=${this._runningSeq} 是否退回整窗=${end <= 0 ? `是(定位失败, syntaxMode=${syntaxMode})` : "否"}`);
         // 诊断：窗口前 120 字符（仅 SSH_TOOL_DEBUG=1 时落盘）
         debug(`[extract] ${this._logTag} seq=${this._runningSeq} 窗口前120: ${escapeCtl(raw.slice(0, 120))}`);
         if (end <= 0) {
@@ -697,16 +787,16 @@ export class BaseSession {
             // **不得退回整窗**——整窗会把重放的别会话命令行/标记当输出落盘（旧 bug：outLen=14019 全是杂物）。
             // 改为按窗口内已有标记边界裁剪：取"本命令自己的标记之前、所有非本 seq 标记之后"的边界，
             // 先把重放段整段切掉，再剥行首残余控制码噪音；定位仍失败也只剩边界之后的少量内容。
-            const ownEnd = marker.done ? marker.pos : raw.length;
-            const boundary = this._fallbackBoundary(raw, ownEnd);
-            let fallback = boundary > 0 ? raw.slice(boundary) : raw;
+            const ownEnd = boundary;
+            const fbBoundary = this._fallbackBoundary(raw, ownEnd);
+            let fallback = fbBoundary > 0 ? raw.slice(fbBoundary) : raw;
             // 边界裁剪后"再试一次定位"：此时窗口已剔除重放段，回显残片可能恢复成可匹配的连续文本
             const retry = extractOutputStart(fallback, echoText, fallback.length, false);
             if (retry > 0)
                 fallback = fallback.slice(retry);
             else
                 fallback = this._stripLeadingControlNoise(fallback);
-            log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 定位失败改用标记边界: boundary=${boundary} retry=${retry} 裁剪后长=${fallback.length} 原窗长=${raw.length}`);
+            log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 定位失败改用标记边界: boundary=${fbBoundary} retry=${retry} 裁剪后长=${fallback.length} 原窗长=${raw.length}`);
             // 中断命令再截到首个 ^C 回显，避免输出残留 ^C 与探针后 shell 重印的提示符（与旧版中断收尾语义一致）
             if (this._interruptSent) {
                 const intr = detectInterrupt(fallback, 0);
@@ -716,10 +806,15 @@ export class BaseSession {
             return this._stripProbeEchoes(stripMarkers(fallback));
         }
         let out;
-        if (marker.done) {
-            // 中断命令：完成标记由探针补发，输出窗口会多出 ^C 回显、重印提示符与探针回显；
+        if (syntaxMode) {
+            // 语法错误：命令整行作废、本条标记未执行 → 输出 = 回显结束 → 缓冲区末尾（含整段错误块）
+            //（不补发探针；尾部最多多 1 行提示符噪音，按设计接受）
+            out = raw.slice(end, boundary);
+        }
+        else if (marker.done || probe?.done) {
+            // 中断命令：完成由补发探针标记（SSH_PROBE）触发，输出窗口会多出 ^C 回显、重印提示符与探针回显；
             // 输出在首个 ^C 回显处截断，保留中断前程序输出（探针回显另由 _stripProbeEchoes 剔除）
-            let endPos = marker.pos;
+            let endPos = boundary;
             if (this._interruptSent) {
                 const intr = detectInterrupt(raw, end);
                 if (intr.interrupted)
@@ -727,16 +822,18 @@ export class BaseSession {
             }
             out = raw.slice(end, endPos);
         }
-        else if (syntaxMode) {
-            // 语法错误：命令整行作废、无 marker → 输出 = 回显结束 → 窗口末尾（含整段错误块），再剥尾部重印提示符
-            out = stripTrailingPromptLine(raw.slice(end), raw, this._promptRef);
-        }
         else {
-            const intr = detectInterrupt(raw, end);
-            out = intr.interrupted ? raw.slice(end, intr.pos) : raw.slice(end);
+            // 无完成标记：仅当插件确实发过中断（_interruptSent）才把首个 ^C 当中断回显截断；
+            // 否则真实输出里的字面量 ^C（cat/echo 含 ^C 的文本、工具日志、记录过 Ctrl+C 的 transcript）
+            // 会被误当中断回显，导致输出在那里被切甚至全空
+            if (this._interruptSent) {
+                const intr = detectInterrupt(raw, end);
+                out = intr.interrupted ? raw.slice(end, intr.pos) : raw.slice(end);
+            }
+            else {
+                out = raw.slice(end);
+            }
         }
-        if (this._adapter)
-            out = out.replace(this._markerCmd(this._runningSeq), "");
         return this._stripProbeEchoes(stripMarkers(out.replace(/^[\r\n]+/, "")));
     }
     /**
@@ -794,9 +891,7 @@ export class BaseSession {
         // 诊断：本次窗口起点取自"自身找到的 lastMarkerPos"（无标记时为 0，即缓冲起点）；
         // captureStart=裁剪后残留长度（exec 的实际捕获起点，与缓冲内容相关，仅供参考）
         const winStartPos = marker.done ? marker.pos : 0;
-        log.info(`[capture] ${this._logTag} seq=${this._cmdSeq + 1} 起点=${winStartPos} captureStart=${this._buffer.length}(参考) entryCursor=${entryCursor} bufLen=${entryBufLen} lastMarkerPos=${marker.done ? marker.pos : -1}`);
-        // 记录命令发起前缓冲末行（旧提示符行）：语法错误收尾时 shell 会重印同形提示符，供输出尾部剥离
-        this._promptRef = this._buffer.split("\n").pop() ?? "";
+        debug(`[capture] ${this._logTag} seq=${this._cmdSeq + 1} 起点=${winStartPos} captureStart=${this._buffer.length}(参考) entryCursor=${entryCursor} bufLen=${entryBufLen} lastMarkerPos=${marker.done ? marker.pos : -1}`);
         this._runningStartPos = 0;
         this._runningCommand = command;
         this._runningStartTs = Date.now();
@@ -805,7 +900,7 @@ export class BaseSession {
         this._runningSeq = this._cmdSeq;
         this._setBusy(true, "cmdStart");
         this._lastActive = Date.now();
-        log.info(`[run] 开始 ${this._logTag} seq=${this._runningSeq} startPos=0 cmdLen=${command.length}`);
+        debug(`[run] 开始 ${this._logTag} seq=${this._runningSeq} startPos=0 cmdLen=${command.length}`);
         debug(`[run] 开始 ${this._logTag} seq=${this._runningSeq} cmd=${JSON.stringify(command.slice(0, 120))}`);
         this._emitStart(command, this._runningStartTs);
     }
@@ -832,7 +927,7 @@ export class BaseSession {
         if (text.includes(DONE_TAG)) {
             const found = scanDoneMarkers(text).map((h) => h.seq ?? "?").join(",");
             // 非内容信息保持 info（排障主力）；命令/输出片段前缀（prefix）降级为 debug，避免泄漏内容
-            log.info(`[chunk] ${this._logTag} seq=${this._runningSeq} runningStart=${this._runningStartPos} chunkLen=${text.length} found=[${found}]`);
+            debug(`[chunk] ${this._logTag} seq=${this._runningSeq} runningStart=${this._runningStartPos} chunkLen=${text.length} found=[${found}]`);
             debug(`[chunk] ${this._logTag} seq=${this._runningSeq} prefix=${escapeCtl(text.slice(0, 60))}`);
         }
         // 数据已落缓冲：通知数据到达监听器（agent 据此做节流合并推流；异常不打断数据写入）
@@ -854,8 +949,8 @@ export class BaseSession {
      * @returns 无
      */
     _sendBaselineMarker() {
-        const baseline = this._markerCmd(0) + "\r";
-        log.info(`[baseline] ${this._logTag} 初始化完成，发送基线标记 nonce=${this._nonce} seq=0 cmd=${JSON.stringify(this._markerCmd(0))}`);
+        const baseline = this._markerCmd(0) + this._ptyLineSep();
+        debug(`[baseline] ${this._logTag} 初始化完成，发送基线标记 nonce=${this._nonce} seq=0`);
         this._write(baseline);
     }
     /** 探测 shell 类型：按各适配器 probeCommand 逐个探测（POSIX 系优先，pwsh/cmd 用各自独有命令），
@@ -866,8 +961,16 @@ export class BaseSession {
                 this._write(candidate.probeCommand + "\r");
                 const output = await this._waitProbeOutput(Math.min(PROBE_TIMEOUT_MS, deadline - Date.now()));
                 this._buffer = "";
-                if (output !== null && candidate.parseProbe(output))
+                if (output !== null && candidate.parseProbe(output)) {
+                    // 终端平台按真实 shell 判断：cmd 必为 Windows；pwsh 看 $PSHOME 是 Windows 路径还是 Unix 路径；
+                    // bash/zsh 走 Unix PTY。这样 SSH 到 Linux 上的 pwsh 也会用 \n（不依赖 ICRNL）。
+                    this._windowsPTY = candidate.name === "cmd"
+                        ? true
+                        : candidate.name === "pwsh"
+                            ? /__SHELL_ID__pwsh_[A-Za-z]:[\\/]/.test(output)
+                            : false;
                     return candidate;
+                }
             }
         }
         return null;
@@ -938,13 +1041,21 @@ export class BaseSession {
             return;
         }
         try {
-            // 完成判定（权威且唯一）：命令后追加的 printf 输出 <SSH_DONE:seq:code>；marker 自带唯一 seq，从命令起点搜索
+            // 真实完成（权威且唯一）：只认本会话 nonce + 本 seq 的 SSH_DONE 标记。
+            // 探针已改用独立 SSH_PROBE tag，二者不再混淆——语法误判时真实退出码不会被覆盖。
             const marker = detectLastDoneMarker(this._buffer, this._runningStartPos, this._nonce, this._runningSeq);
             if (marker.done) {
                 this._settleCompletion({ kind: "done", markerPos: marker.pos, exitCode: marker.exitCode });
                 return;
             }
-            // 语法/解析错误：整行命令作废（含同行拼装的完成标记也不会执行）→ 输出安静后按完成收尾
+            // 中断探针（SSH_PROBE）：Ctrl+C 后 shell 回到提示符执行补发的标记命令。
+            // 语法错误路径不再补发探针（见 _armSyntaxQuiet）：避免把命令写进仍在运行的程序 stdin。
+            const probe = detectLastProbeMarker(this._buffer, this._runningStartPos, this._nonce, this._runningSeq);
+            if (probe.done) {
+                this._settleCompletion({ kind: "done", markerPos: probe.pos, exitCode: probe.exitCode });
+                return;
+            }
+            // 语法/解析错误：整行命令作废（含同行拼装的完成标记也不会执行）→ 输出安静后补发探针按完成收尾
             if (detectSyntaxError(this._adapter, this._buffer, this._watchStartPos)) {
                 // 兜底 tick 不重置已挂的静默计时（否则每周期顺延、永不收尾）；数据到达时才推进
                 if (fromData || this._syntaxTimer === null)
@@ -988,9 +1099,11 @@ export class BaseSession {
         this._completeRunning(this._watchStartPos, o.markerPos ?? this._buffer.length, o.exitCode ?? null, this._watchCommand);
     }
     /**
-     * 推进语法错误安静窗口（一次性定时器，非轮询）：识别到语法错误后等输出停止增长 SYNTAX_QUIET_MS 再收尾，
-     * 确保 pwsh 异步/批量渲染的多行错误块被完整收进输出窗口；自首次识别起上限 SYNTAX_MAX_WAIT_MS。
-     * 数据到达（输出变化）时重置安静窗口；兜底 tick 不重置（见 _checkCompletion）。
+     * 推进语法错误安静窗口（一次性定时器，非轮询）：
+     * 识别到语法错误后等输出停止增长 SYNTAX_QUIET_MS，确保 pwsh 异步/批量渲染的多行错误块完整收进输出窗口；
+     * 到点**直接按语法错误收尾，不再补发探针**——探针会被写进仍在运行的程序 stdin（如 `cat >file` / REPL），
+     * 且语法误判时会提前收尾、丢弃迟到的真实完成标记；尾部最多多 1 行提示符噪音，按设计接受。
+     * 自首次识别起硬上限 SYNTAX_MAX_WAIT_MS；数据到达（输出变化）时重置安静窗口；兜底 tick 不重置（见 _checkCompletion）。
      * @returns 无
      */
     _armSyntaxQuiet() {
@@ -1007,7 +1120,7 @@ export class BaseSession {
         }
         if (now - this._syntaxSeenAt >= SYNTAX_MAX_WAIT_MS) {
             this._clearSyntaxTimer();
-            this._settleCompletion({ kind: "done", exitCode: null, syntaxError: true });
+            this._settleSyntaxError();
             return;
         }
         const remain = Math.max(0, SYNTAX_QUIET_MS - (now - this._syntaxQuietAt));
@@ -1016,14 +1129,18 @@ export class BaseSession {
             this._syntaxTimer = null;
             if (this._runningStartPos === null)
                 return;
-            try {
-                this._settleCompletion({ kind: "done", exitCode: null, syntaxError: true });
-            }
-            catch (e) {
-                log.info(`[watch] ${this._logTag} seq=${this._runningSeq} 语法静默收尾异常: err=${e instanceof Error ? e.message : String(e)}`);
-            }
+            this._settleSyntaxError();
         }, remain);
     }
+    /** 按语法错误收尾（含异常兜底：收尾本身再抛也不能变成未捕获异常） */
+    _settleSyntaxError() {
+        try {
+            this._settleCompletion({ kind: "done", exitCode: null, syntaxError: true });
+        }
+        catch (e) {
+            log.info(`[watch] ${this._logTag} seq=${this._runningSeq} 语法错误收尾异常: err=${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
     /**
      * 断连收尾（由后台兜底 tick 判定 _connected=false 触发）：命令视为结束（可能从未完成），
      * 补发 done 防 server busy 卡死；不写 history（输出窗口从未定案，无可信尾部可摘）。
@@ -1043,7 +1160,7 @@ export class BaseSession {
         }
     }
     /**
-     * 开始一次命令的后台追踪：记录兜底判定所需的捕获窗口起点/命令，并复位语法静默状态。
+     * 开始一次命令的后台追踪：记录兜底判定所需的捕获窗口起点/命令，并复位语法错误状态。
      * 不做任何轮询——完成判定由数据到达事件驱动（见 `_onDataArrived`）。
      * @param startPos 捕获窗口起点（相对当前 buffer；submit 为 0，exec 转后台为 captureStart）
      * @param command 命令（history 记录用）
@@ -1082,7 +1199,7 @@ export class BaseSession {
         }
         catch (e) {
             // tick 内异常：记一行后继续下一轮监听（完成判定仍只认当前 seq 标记）
-            log.info(`[watch] ${this._logTag} seq=${this._runningSeq} tick 异常, 保持监听: err=${e instanceof Error ? e.message : String(e)}`);
+            infoDedup(`tick-exc:${this._logTag}:${this._runningSeq}`, `[watch] ${this._logTag} seq=${this._runningSeq} tick 异常, 保持监听: err=${e instanceof Error ? e.message : String(e)}`);
         }
     }
     /** 清除 exec 同步等待的 animation 一次性定时器（幂等） */
@@ -1121,10 +1238,16 @@ export class BaseSession {
             log.info(`[extract] ${this._logTag} seq=${this._runningSeq} 输出提取异常, 使用整窗输出: cmdLen=${command.length} err=${e instanceof Error ? e.message : String(e)}`);
             output = raw;
         }
-        this._history.append(command, output, this._runningStartTs, undefined, exitCode ?? undefined);
+        try {
+            this._history.append(command, output, this._runningStartTs, undefined, exitCode ?? undefined);
+        }
+        catch (e) {
+            // history 落盘失败（目录被删/权限/磁盘）不得阻断 done/busy 收尾，否则会话永久 busy
+            log.info(`[history] ${this._logTag} seq=${this._runningSeq} 追加失败: err=${e instanceof Error ? e.message : String(e)}`);
+        }
         this._emitDone(exitCode, Date.now(), output);
         this._cursor = Math.max(startPos, endPos);
-        this._setBusy(false, "cmdDone"); // 命令完成即清 busy（"保持 busy 到排队序列结束"的机制已移除）
+        this._setBusy(false, "cmdDone", true); // 命令完成即清 busy（"保持 busy 到排队序列结束"的机制已移除）；释放行紧随 [run] 结束，降 debug 免重复
         // 结束日志：非内容信息（长度/耗时/退出码/原因）保持 info；有界输出尾部摘要降级为 debug，避免泄漏输出内容
         log.info(`[run] 结束 ${this._logTag} seq=${this._runningSeq} endPos=${endPos} exitCode=${exitCode} outLen=${output.length} duration=${Date.now() - this._runningStartTs}ms reason=${reason}`);
         if (isDebugEnabled()) {