@hyzyn/dsh-tty 0.22.0-rc.1 → 0.22.0

package/lib/index.js

@@ -17,7 +17,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { sanitizeJumpSpec, sanitizeProxyCommand, spawnSsh, sshTarget, expandHome, setCredentialResolver, setProxyCommandPolicy, validateJumpSpec, validateProxyCommand } from './ssh.js';
 import { sharedGrantStore, auditLoadedGrants, bindCapabilitySources, capabilityDeniedMessage, capabilityGrantAt, capabilityGrantVia, capabilityGranted, capabilityPaths, createElevationManager, } from '@hyzyn/dsh-kit';
 import { probeSsh } from './probe.js';
-import { buildCommandSpawn, buildShellSpawn, defaultShellPath } from './shell-integration.js';
+import { buildCommandSpawn, buildShellSpawn, commandShellHint, defaultShellPath } from './shell-integration.js';
 import { parseSshConfigDetailed } from './ssh-config.js';
 import { parseKnownHostsDetailed } from './known-hosts.js';
 import { TunnelManager } from './tunnels.js';
@@ -135,6 +135,43 @@ const CAP_PROXY_COMMAND = { env: 'DSH_TTY_ALLOW_PROXY_COMMAND', label: '代理
 const DEFAULT_MAX_SESSIONS = 4;
 /** 断线保活默认秒数（reconnectGraceSec；0 = 旧行为，断开立即结束会话）。 */
 const DEFAULT_RECONNECT_GRACE_SEC = 120;
+/**
+ * 会话退出后的**只读保留策略**（D77）。
+ *
+ * 进程没了之后把会话留在 `sessions` 表里：`tty_list` / `tty_capture` / `tty_screen`
+ * 照常能读到它最后那些输出（用户上报的痛点原话：「结果明明就在那里但我看不到」——
+ * `tty_open` 跑一条命令，跑完会话就退役，AI 一个字符都取不回来，逼得人先开
+ * `/bin/sh` 再往里发命令）。
+ *
+ * 取 **∞ = 保留到显式关闭**（`tty_close` / 面板关标签 / 宿主重启），不由时间淘汰：
+ *
+ * - 时间上界对用户是**第二重惊喜**——「命令跑完 → 下一轮读结果」之间隔着人离开、
+ *   模型排队，多久都有可能；一个到期就消失的输出比「要主动关」更难理解；
+ * - 内存与句柄本来也不由时间决定：条数由 [`MAX_EXITED_SESSIONS`](#) 兜（16 条，
+ *   单条几百 KB~一两 MB），而「永久」还有一条天然上界——保留是**内存态**，
+ *   宿主 / 插件重启即清空，不会跨天累积；
+ * - 连续跑很多短命令时，淘汰节奏变成「超过 16 条按最旧淘汰」（`capExited`），
+ *   正是想要的语义：近的才有人读。
+ *
+ * 需要时间上界的人把这里改成任意毫秒数即可——`reapExited` 那条通路还在
+ * （回收器每轮都会调它）。导出仅供单测（test/host-frames.test.ts）：到点退役与
+ * 条数上限的行为护栏。
+ */
+export const EXITED_RETAIN_MS = Number.POSITIVE_INFINITY;
+/**
+ * 只读保留的会话数上限（超出按最旧淘汰，见 SessionManager.capExited）。
+ *
+ * 与「并发会话上限」（maxSessions，默认 4）是两个口径：那个数**只数活着的会话**
+ * （retained 的不占名额，否则跑几条短命令就把面板顶成「会话数已达上限」，
+ * 比原缺陷更糟）。这里兜的是内存：每条 retained 约 = 256KB 环形缓冲 + 一块
+ * xterm-headless 虚拟屏，16 条仍在 ~20MB 量级。
+ *
+ * 为什么从 8 抬到 16（D77 补，2026-09-27 真机验收反馈）：保留改成「留到显式关闭」
+ * 之后，上限就是唯一会**自动**挤掉结果的东西，而 agent 一口气开二十几条一次性
+ * 会话是常态——8 条意味着「几分钟前那份结果」被最旧淘汰挤掉，用户只看到「没了」。
+ * 淘汰一律 `logger.warn` 留痕（见 finishSession），否则这件事在事后完全不可查。
+ */
+export const MAX_EXITED_SESSIONS = 16;
 /** 下行背压阈值（ws.bufferedAmount 字节）。 */
 const BACKPRESSURE_HIGH = 512 * 1024;
 const BACKPRESSURE_LOW = 128 * 1024;
@@ -229,6 +266,45 @@ export function killLocalShellTerminal(terminal, platform = process.platform) {
         /* 已退出 */
     }
 }
+/**
+ * Windows 本地 PTY 的**输入归一化**（D74，2026-09-27 真机报告）：conhost 把 Enter 当
+ * **CR**，裸 LF 只把光标下移一格、**不提交命令行**——于是 `tty_send` 按工具描述发
+ * `echo X\n` 时，命令停在输入行上：没有输出、没有新提示符，看起来像「发出去了但没执行」。
+ *
+ * 修法取报告建议里改动最小的一条：win32 上把行尾补成 CRLF（已有 CR 的不重复补），
+ * 让「照描述写 `\n`」这条主路径直接可用。非 win32 原样透传（POSIX 的 Enter 就是 LF），
+ * SSH 会话也不归一化（远端是什么系统、什么 shell 插件不知道，乱改会破坏 `cat` 之类的原始输入）。
+ *
+ * 导出仅供单测：平台参数注入，两个分支都能在 macOS/Linux 断言。
+ */
+export function normalizePtyInput(data, platform = process.platform) {
+    if (platform !== 'win32')
+        return data;
+    return data.replace(/\r\n/g, '\n').replace(/\n/g, '\r\n');
+}
+/** 退出事实的一句话描述（工具文案共用同一措辞：`exitCode=3` / `signal=SIGSEGV`）。 */
+function describeExit(exited) {
+    if (exited.signal !== null && exited.signal !== '')
+        return `signal=${exited.signal}`;
+    return exited.code === null ? '退出码未知' : `exitCode=${String(exited.code)}`;
+}
+/**
+ * 只读保留的剩余毫秒（D77）；`null` = **不按时间释放**（策略为 ∞）或不是保留态。
+ *
+ * 工具结果带上它，agent 才知道「这个 sid 还能读多久」——否则它会以为读到的
+ * 是一具刚刚咽气的尸体、下次照样能读，而实际上屏与缓冲到点就释放了。
+ *
+ * 注意这个值会进工具输出：**不能返回 `Infinity`**——`JSON.stringify` 会把它变成
+ * `null`，撞上宿主对 `output.schema`（`type: 'number'`）的校验，整个工具调用直接
+ * 变成 Error（B33 抓过同一类）。所以「无限期」一律用**省略该字段**表达。
+ */
+function retainLeftMs(session, now = Date.now()) {
+    if (session.exited === null)
+        return null;
+    if (!Number.isFinite(EXITED_RETAIN_MS))
+        return null;
+    return Math.max(0, session.exited.at + EXITED_RETAIN_MS - now);
+}
 /** TERM/COLORTERM 值白名单校验：不合法回退 fallback（防止破坏 -c 包装层）。 */
 function sanitizeTermValue(value, fallback) {
     const trimmed = value.trim();
@@ -585,8 +661,9 @@ function advanceReadMark(session) {
  * 水位线之后的**未读**原始输出。下界再抬到「最后一个 B 标记之后」：回显落在
  * A（prompt 开始）与 B（命令开始）之间，所以这样能零启发式地排除回显——按
  * 文本比对「跳过与发送内容相同的行」会被折行 / ANSI / 多行粘贴打碎。
- * 没有 B 标记（未开 shell 集成 / Windows PowerShell / 远端未装集成）时无法
- * 区分回显，退化为从水位线起扫（可能匹配到回显本身，文档已声明）。
+ * 没有 B 标记（未开 shell 集成 / Windows PowerShell / 远端未装集成）时无法按边界切片：
+ * D75 起改用「最近提交过的输入」这份回显候选把回显行从匹配窗口里剔掉（见 echoOnlyMatch），
+ * 不再直接拿回显当命中。
  */
 function unreadRegion(session) {
     ensureReadMark(session);
@@ -607,6 +684,84 @@ function testPattern(re, text) {
     re.lastIndex = 0;
     return re.test(cleanAnsiTail(text));
 }
+/* ------------------------------------------------------------------ *
+ * 回显命中剔除（D75）
+ *
+ * 症状：`tty_expect` 会命中**命令回显本身**——命令还没执行（Windows 上裸 LF 不提交，
+ * 见 D74；或只是被 shell 集成之外的环境回显），`tty_send` 写进去的那行文本先回到了
+ * 输出流里，于是「等就绪标记」立刻返回 matched。报告侧的现场：LF 没提交、命令一次
+ * 都没跑，`tty_expect pattern="echo ECHO_DEMO_2"` 秒回 matched（来源标注 buffered）。
+ *
+ * 判据（不动 B 标记那条零启发式路径，只补它够不着的场景）：把**最近提交过的命令行**
+ * 从候选文本里削掉再试一次，只有「削掉后不再命中」才算纯回显。这样：
+ *   - 真实输出里也出现的标记照旧命中（不误杀）；
+ *   - 只在回显行**末尾**匹配才削（cmd 的回显与提示符同行，所以按行尾切）；
+ *   - 有 B 标记 / 命令正在跑（TUI 全屏重画里出现输入文本是正常输出）时不启用。
+ * ------------------------------------------------------------------ */
+/** 回显候选的行数上限（最近几条提交的输入）与单行长度上限。 */
+const ECHO_INPUT_CAP = 8;
+const ECHO_LINE_CAP = 512;
+/**
+ * 记录一次「提交过的输入」的回显候选（只在 `tty_send` 且带行尾时调用）：
+ * 单键按键（TUI 的 `q` / 方向键）不是命令行，不记——否则一个 `q` 就能把
+ * 之后任何只匹配到 `q` 的等待吞掉。
+ */
+function noteSubmittedInput(session, data) {
+    if (!/[\r\n]/.test(data))
+        return;
+    const lines = data
+        .split(/\r\n|\r|\n/)
+        .map((line) => line.trim())
+        // 控制字符（多为转义序列，如 `vim` 的 `\x1b:wq`）不做行编辑模拟，直接不记
+        .filter((line) => line !== '' && line.length <= ECHO_LINE_CAP && !/[\x00-\x1f\x7f]/.test(line));
+    if (lines.length === 0)
+        return;
+    session.recentInputs = [...session.recentInputs, ...lines].slice(-ECHO_INPUT_CAP);
+}
+/**
+ * 这批回显候选在当前现场是否该启用剔除。三条都得成立：
+ *   - 有候选（没 `tty_send` 过就无从判断，保持原语义）；
+ *   - 命令没在跑（`inCommand`：TUI 重画 / 长任务把输入文本画到屏上是真实输出）；
+ *   - 候选文本里没有 B 标记（有 B 就说明 shell 集成在管边界，回显已被切掉）。
+ */
+function echoStrippable(session, text) {
+    if (session.recentInputs.length === 0)
+        return false;
+    if (session.shellState.inCommand)
+        return false;
+    return lastCommandStart(text) === -1;
+}
+/**
+ * 把回显候选行从文本里削掉（保行结构）。按**行尾**匹配：cmd 的回显与提示符同行
+ * （`C:\>echo X`），所以只削后缀、保留提示符前缀。行尾空白（含 `\r`）先归一。
+ */
+function stripEchoLines(text, echoes) {
+    if (echoes.length === 0)
+        return text;
+    const sorted = [...echoes].sort((a, b) => b.length - a.length);
+    return text
+        .split('\n')
+        .map((line) => {
+        const trimmed = line.replace(/[ \t\r]+$/, '');
+        for (const echo of sorted) {
+            if (trimmed.endsWith(echo))
+                return trimmed.slice(0, trimmed.length - echo.length);
+        }
+        return line;
+    })
+        .join('\n');
+}
+/**
+ * 命中是否**只**落在回显上（纯回显 → 不算命中）。
+ * 原始流与清洗后文本各削一次：回显行里可能夹着 ANSI（zsh 的 zle / 彩色提示符）。
+ */
+function echoOnlyMatch(re, text, session) {
+    if (!echoStrippable(session, text))
+        return false;
+    const stripped = stripEchoLines(text, session.recentInputs);
+    const strippedClean = stripEchoLines(cleanAnsiTail(text), session.recentInputs);
+    return !testPattern(re, stripped) && !testPattern(re, strippedClean);
+}
 /** 宽松清洗一份 tunnels 输入；输入不是数组时返回 undefined（表示「未提供，保持原值」）。 */
 function sanitizeTunnels(input) {
     if (!Array.isArray(input))
@@ -1113,9 +1268,6 @@ export function writeToScreen(screen, heartbeat, text, onStall, stallMs = SCREEN
         heartbeat.watchdog.unref?.();
     }
 }
-/* ------------------------------------------------------------------ *
- * 会话管理
- * ------------------------------------------------------------------ */
 /** 导出仅供单测（test/host-frames.test.ts）：上限 / 孤儿回收 / grace 热改的行为护栏。 */
 export class SessionManager {
     sessions = new Map();
@@ -1137,8 +1289,29 @@ export class SessionManager {
     get count() {
         return this.sessions.size;
     }
+    /** 活着的会话数（**不含**只读保留的，见 canSpawn）。 */
+    get liveCount() {
+        let live = 0;
+        for (const session of this.sessions.values())
+            if (session.exited === null)
+                live += 1;
+        return live;
+    }
+    /** 只读保留的会话数（D77）。 */
+    get exitedCount() {
+        let exited = 0;
+        for (const session of this.sessions.values())
+            if (session.exited !== null)
+                exited += 1;
+        return exited;
+    }
+    /**
+     * 名额判据**只数活着的会话**（D77）：只读保留的不占名额。不这样分的话，
+     * 「跑几条短命令」就能把面板顶成「会话数已达上限」——用户一条会话都没开，
+     * 比原来那个「AI 取不到结果」的缺陷更糟。
+     */
     canSpawn() {
-        return this.sessions.size < this.limit;
+        return this.liveCount < this.limit;
     }
     add(session) {
         this.sessions.set(session.id, session);
@@ -1149,8 +1322,19 @@ export class SessionManager {
     get(id) {
         return this.sessions.get(id);
     }
-    /** 会话的只读快照（SSH 会话无本地 pid，该字段省略；tmux 持久会话带 persist）。 */
+    /** 会话的只读快照（SSH 会话无本地 pid，该字段省略；tmux 持久会话带 persist；
+     *  只读保留态（D77）额外带 exited/exitCode|signal/retainMs）。 */
     snapshotOf(session) {
+        const exitRetainMs = retainLeftMs(session);
+        const exitInfo = session.exited === null
+            ? {}
+            : {
+                exited: true,
+                ...(session.exited.code === null ? {} : { exitCode: session.exited.code }),
+                ...(session.exited.signal === null ? {} : { signal: session.exited.signal }),
+                // 省略 = 不按时间释放（策略 ∞）：不能塞 Infinity，理由见 retainLeftMs
+                ...(exitRetainMs === null ? {} : { retainMs: exitRetainMs }),
+            };
         const base = {
             sid: session.id,
             cwd: session.cwd,
@@ -1160,6 +1344,7 @@ export class SessionManager {
             lastOutputAt: session.lastOutputAt,
             owner: session.owner,
             ...(session.tmuxName !== null ? { persist: true } : {}),
+            ...exitInfo,
         };
         return session.handle.pid === null ? base : { ...base, pid: session.handle.pid };
     }
@@ -1171,7 +1356,8 @@ export class SessionManager {
     listForAttach() {
         return [...this.sessions.values()].map((session) => ({
             ...this.snapshotOf(session),
-            attachable: session.clients.size === 0 && !session.closed,
+            // 只读保留态不可 attach（没有活着的 PTY 可接）：客户端据此不建幽灵标签
+            attachable: session.clients.size === 0 && !session.closed && session.exited === null,
         }));
     }
     /** 遍历全部会话（状态条采集器的批量收尾等按会话维度的操作）。 */
@@ -1179,10 +1365,12 @@ export class SessionManager {
         for (const session of this.sessions.values())
             fn(session);
     }
-    /** 按 tmux 持久会话名查找存活会话（跨窗口共享用）；不存在/已关闭返回 undefined。 */
+    /** 按 tmux 持久会话名查找**活着**的会话（跨窗口共享用）；不存在/已关闭/只读保留态返回 undefined。
+     *  D77：保留态必须排除——否则「同名 persistName 的新标签」会 rebind 到一具尸体上，
+     *  拿到 ready 却永远没有输出。 */
     findByTmuxName(tmuxName) {
         for (const session of this.sessions.values()) {
-            if (session.tmuxName === tmuxName && !session.closed)
+            if (session.tmuxName === tmuxName && !session.closed && session.exited === null)
                 return session;
         }
         return undefined;
@@ -1227,6 +1415,11 @@ export class SessionManager {
         for (const session of [...this.sessions.values()]) {
             if (session.owner === 'agent')
                 continue;
+            // D77：只读保留态不归孤儿回收管——它可能本来就带着 orphanedAt（断线后
+            // 才退出），被这里收掉就等于「退出即退役」，保留期形同虚设。它的到点
+            // 退役由 reapExited 统一负责。
+            if (session.exited !== null)
+                continue;
             if (session.orphanedAt === null)
                 continue;
             if (graceMs <= 0 || now - session.orphanedAt >= graceMs) {
@@ -1234,6 +1427,40 @@ export class SessionManager {
             }
         }
     }
+    /**
+     * 只读保留到点退役（D77；回收器每轮调用）：超过保留期的会话出表 + 释放屏。
+     *
+     * 默认策略是 ∞（保留到显式关闭）⇒ 本方法是 no-op，条数由 `capExited` 兜；
+     * 把 `EXITED_RETAIN_MS` 改成有限值它就照常工作（策略可调，通路留着）。
+     *
+     * **不 kill 进程**：这里收的全是已经退出的会话（进程早没了），`retire()` 就够；
+     * 真退役（显式 `tty_close` / 面板关标签）走 `killSessionNow`，那条路要处理
+     * tmux teardown 与 forceKill 的兜底。
+     */
+    reapExited(retainMs) {
+        const now = Date.now();
+        for (const session of [...this.sessions.values()]) {
+            if (session.exited === null)
+                continue;
+            if (retainMs <= 0 || now - session.exited.at >= retainMs)
+                this.retire(session);
+        }
+    }
+    /**
+     * 只读保留的数量上限（超出按最旧淘汰，D77）：返回被淘汰的会话，便于单测断言。
+     *
+     * 为什么必须有：`owner:'agent'` 的会话不会走孤儿回收，agent 若不显式 `tty_close`
+     * （它常常不会），保留态就是**永久泄漏**——屏与 256KB 缓冲一直挂着。
+     */
+    capExited(max) {
+        const exited = [...this.sessions.values()]
+            .filter((session) => session.exited !== null)
+            .sort((a, b) => (a.exited?.at ?? 0) - (b.exited?.at ?? 0));
+        const victims = exited.slice(0, Math.max(0, exited.length - max));
+        for (const session of victims)
+            this.retire(session);
+        return victims;
+    }
     async disposeAll() {
         const all = [...this.sessions.values()];
         this.sessions.clear();
@@ -1246,6 +1473,9 @@ export class SessionManager {
             catch {
                 /* 已释放 */
             }
+            // D77：只读保留态（进程已退出）没有要收的进程——`forceKill` 只会对死句柄再戳一遍
+            if (session.exited !== null)
+                return Promise.resolve(true);
             return forceKill(session.handle);
         }));
     }
@@ -1351,7 +1581,8 @@ export class TtyServer {
      * 隐藏状态条，PTY 数据路径与终端体验完全不受影响。
      */
     startStats(session) {
-        if (!this.statsOn || session.closed || session.stats !== null || session.statsFailed)
+        // D77：只读保留态没有进程可采（本地会取到宿主、远端 channel 早断了）——直接不起表
+        if (!this.statsOn || session.closed || session.exited !== null || session.stats !== null || session.statsFailed)
             return;
         if (session.kind === 'local') {
             const sampler = localStatsSampler();
@@ -1545,6 +1776,20 @@ export class TtyServer {
             this.ctx.logger.warn('[dsh-tty] ws error: ' + error.message);
         });
     }
+    /**
+     * 摘掉同 sid 上残留的**只读保留**会话（D77）：spawn / ssh 新建同名会话前调用。
+     *
+     * 不摘会真泄漏：`sessions.add()` 用同一个键把旧对象顶出表，而旧对象的虚拟屏与
+     * 256KB 环形缓冲再没有任何引用能释放它们（`retire` 是唯一的释放口）。只处理
+     * 保留态——活着的同 sid 会话属于「跨连接同名」的既有语义，不在这里动。
+     */
+    retireStaleExited(sid) {
+        const stale = this.sessions.get(sid);
+        if (stale === undefined || stale.exited === null)
+            return;
+        this.sessionLocals.get(stale)?.delete(stale.id);
+        this.sessions.retire(stale);
+    }
     /**
      * 解析帧里的 sid。返回：
      *   { sid }        目标会话；
@@ -1650,6 +1895,8 @@ export class TtyServer {
         if (session.owner !== 'agent') {
             throw new Error(`会话 ${sid} 是用户在面板里开的（owner=user）：请在面板里关闭那个标签，不要由 agent 越权结束`);
         }
+        // D77：只读保留态（进程已退出）也走这条路——`killSessionNow` 对死句柄是安全的，
+        // 它做的正是「退役 + 释放屏」。这也是 issue 里要的那个「显式关闭」入口。
         this.flushPendingOutput(session);
         this.killSessionNow(session);
         this.broadcastSessions();
@@ -1802,6 +2049,7 @@ export class TtyServer {
                 handle,
                 clients: new Map(),
                 closed: false,
+                exited: null,
                 paused: false,
                 owner,
                 cwd,
@@ -1813,6 +2061,7 @@ export class TtyServer {
                 outputSeq: 0,
                 readSeq: -1,
                 readMarkAt: 0,
+                recentInputs: [],
                 buffer: '',
                 decoder: new StringDecoder('utf8'),
                 screen: this.createScreen(clampInt(cols, 80, 2, 500), clampInt(rows, 24, 2, 200)),
@@ -1869,6 +2118,14 @@ export class TtyServer {
         session.statsSubs.clear();
         this.stopStats(session);
         this.sessions.retire(session);
+        if (session.exited !== null) {
+            // D77：只读保留态（进程已经退出）**只退役、不再碰句柄**。下面那几条收尾
+            // （tmux kill-session / forceKill / done 兜底）语义都是「把一个还活着的 PTY
+            // 收掉」；对一具尸体再戳一遍收益为零，而在个别后端（win-arm64 的 ConPTY）
+            // 恰好是纯风险。tmux 那条也不做：D77 之前「退出」本来就不 teardown（tmux
+            // 会话留存），保持一致。
+            return;
+        }
         const teardown = session.handle.tmuxTeardown;
         if (teardown !== undefined) {
             let settled = false;
@@ -1938,6 +2195,7 @@ export class TtyServer {
                     send(ws, { t: 'error', sid, m: 'sid 已存在' });
                     return;
                 }
+                this.retireStaleExited(sid); // D77：同 sid 上的只读保留态先摘掉，别让 add() 把它顶成泄漏
                 // 持久化（0.10.0）：配置 persistence=tmux 且帧带 persist 时，spawn 包装层
                 // 换成 `exec tmux -L dsh-tty -A -s <名>`（tmux 托管）；tmux 未安装则降级
                 // 普通会话并回灰字提示。持久名稳定（客户端生成、随标签规格保存），
@@ -2012,6 +2270,7 @@ export class TtyServer {
                     send(ws, { t: 'error', sid, m: 'sid 已存在' });
                     return;
                 }
+                this.retireStaleExited(sid); // D77：同上，SSH 分支同规则
                 // 跨窗口共享（0.10.1）：同 tmuxName 的 SSH 持久会话还活着时不重建远程
                 // 连接，本连接重绑定到现有会话（单 PTY 多客户端扇出）
                 const parsedCommand = sanitizeCommand(msg.command);
@@ -2025,7 +2284,7 @@ export class TtyServer {
                     : null;
                 if (persistName !== null) {
                     const existing = (this.sessions.findByTmuxName(persistName) ?? (await this.waitPendingTmux(persistName))) ?? null;
-                    if (existing !== null && existing.kind === 'ssh' && !existing.closed) {
+                    if (existing !== null && existing.kind === 'ssh' && !existing.closed && existing.exited === null) {
                         if (!conn.open)
                             return; // 等待在途创建期间连接断了：不往死连接上绑
                         this.rebindClient(existing, sid, ws, local, conn.id);
@@ -2073,6 +2332,7 @@ export class TtyServer {
                         handle,
                         clients: new Map([[conn.id + ':' + sid, { ws, sid }]]),
                         closed: false,
+                        exited: null,
                         paused: false,
                         owner: 'user',
                         cwd: '',
@@ -2084,6 +2344,7 @@ export class TtyServer {
                         outputSeq: 0,
                         readSeq: -1,
                         readMarkAt: 0,
+                        recentInputs: [],
                         buffer: '',
                         decoder: new StringDecoder('utf8'),
                         screen: this.createScreen(clampInt(msg.cols, 80, 2, 500), clampInt(msg.rows, 24, 2, 200)),
@@ -2146,7 +2407,8 @@ export class TtyServer {
                 if (resolved === undefined || 'unknown' in resolved)
                     return;
                 const session = local.get(resolved.sid);
-                if (session !== undefined && !session.closed) {
+                // D77：保留态是**只读**的——面板那边不该再发输入，真发了也不能写进死 PTY
+                if (session !== undefined && !session.closed && session.exited === null) {
                     session.lastInputAt = Date.now();
                     await session.handle.write(data);
                 }
@@ -2156,7 +2418,7 @@ export class TtyServer {
                 if (resolved === undefined || 'unknown' in resolved)
                     return;
                 const session = local.get(resolved.sid);
-                if (session !== undefined) {
+                if (session !== undefined && session.exited === null) {
                     const cols = clampInt(msg.cols, 80, 2, 500);
                     const rows = clampInt(msg.rows, 24, 2, 200);
                     session.handle.resize(cols, rows);
@@ -2176,7 +2438,7 @@ export class TtyServer {
                 if (resolved === undefined || 'unknown' in resolved)
                     return;
                 const session = local.get(resolved.sid);
-                if (session !== undefined && !session.closed && session.tmuxName !== null) {
+                if (session !== undefined && !session.closed && session.exited === null && session.tmuxName !== null) {
                     void session.handle.tmuxRefresh?.();
                 }
             }
@@ -2225,6 +2487,12 @@ export class TtyServer {
                     send(ws, { t: 'error', sid: raw, m: `会话不存在或已结束: ${raw}` });
                     return;
                 }
+                if (session.exited !== null) {
+                    // D77：保留态没有活着的 PTY 可接回（缓冲里的输出由 tty_capture 读），
+                    // 如实说明而不是让客户端拿到一个永远不出输出的「假在线」标签
+                    send(ws, { t: 'error', sid: raw, m: `会话已退出（${describeExit(session.exited)}），只读保留中：不能再接回终端；要接着操作请重新打开标签或 tty_open 新会话` });
+                    return;
+                }
                 // 跨连接共享（0.10.1）：tmux 持久会话允许多窗口同时绑定（单 PTY 扇出）；
                 // 非 tmux 会话仍独占（两个视图交错输入无意义）
                 if (session.clients.size > 0 && session.tmuxName === null) {
@@ -2275,7 +2543,7 @@ export class TtyServer {
         if (resolved === undefined || 'unknown' in resolved)
             return;
         const session = local.get(resolved.sid);
-        if (session === undefined || session.closed)
+        if (session === undefined || session.closed || session.exited !== null)
             return;
         this.setStatsSub(session, connId + ':' + resolved.sid, msg.t === 'statsOn');
     }
@@ -2287,35 +2555,47 @@ export class TtyServer {
         }).catch(() => { });
     }
     /**
-     * 会话终局的**唯一出口**：退役 + 清理 + 给所有绑定连接发 exit 帧（恰好一次）。
+     * 会话终局的**唯一出口**：给所有绑定连接发 exit 帧（恰好一次）+ 转只读保留（D77）。
      *
      * `outcome` 正常来自 PTY 句柄的 done；显式 kill 的兜底（KILL_EXIT_FALLBACK_MS）
      * 也走这里，带 code=null / signal=SIGKILL。exit 广播到所有绑定连接（跨窗口共享），
      * 各客户端按自己的 sid 收址。
+     *
+     * **D77 起「进程退出」不再等于「退役」**：会话留在 `sessions` 表里转只读保留态，
+     * 读侧工具（tty_list / tty_capture / tty_screen / tty_expect）照常可用，写侧拒写，
+     * 直到显式关闭（tty_close / 面板关标签）或保留期到点（reapExited）。退役只剩
+     * `SessionManager.retire` 那一处（出表 + 释放屏）。
      */
     finishSession(session, outcome) {
         if (session.exitSent === true)
             return;
         session.exitSent = true;
-        session.closed = true;
         session.statsSubs.clear();
         this.stopStats(session);
-        this.sessionLocals.get(session)?.delete(session.id);
-        this.sessions.remove(session.id);
         if (session.kind === 'ssh' && session.tmuxName !== null)
             this.trackPersist(session.tmuxName, false);
+        // 心跳停掉，但**屏不 dispose**（D77）：保留期内 tty_screen 还要读它。
         clearScreenWatchdog(session.screenHeartbeat);
-        try {
-            session.screen?.dispose();
-        }
-        catch {
-            /* 已释放 */
-        }
-        this.flushPendingOutput(session); // exit 前冲掉合并窗口里的尾巴，保序
+        this.flushPendingOutput(session, true); // exit 前冲掉合并窗口里的尾巴，保序（D76：必须 force）
         for (const client of session.clients.values()) {
             send(client.ws, { t: 'exit', sid: client.sid, code: outcome.exitCode, signal: outcome.signal });
         }
         session.clients.clear();
+        // ── 只读保留 ────────────────────────────────────────────────────────
+        // 刻意**不**置 `closed`：那个位表示「真退役（出表 + 释放屏）」，读侧工具的
+        // `session.closed` 守卫要放保留态过去。终局之后的字节因 clients 已清空而不再
+        // 成帧（`onData` 照常入环形缓冲与屏：读到的是更完整的尾巴，不是更少的）。
+        session.exited = { code: outcome.exitCode, signal: outcome.signal, at: Date.now() };
+        for (const victim of this.sessions.capExited(MAX_EXITED_SESSIONS)) {
+            // 被条数上限淘汰的：连同它在连接侧 local 表里的绑定一起摘掉（否则那条连接
+            // 还拿得到 sid、却指着一个已退役的会话）
+            this.sessionLocals.get(victim)?.delete(victim.id);
+            // D77 补：淘汰必须留痕——否则用户侧只有「刚才那份结果怎么没了」这一种观测，
+            // 排查时既不知道发生过淘汰、也不知道被挤掉的是哪个 sid。
+            this.ctx.logger.warn(`[dsh-tty] 只读保留已达上限（${String(MAX_EXITED_SESSIONS)} 条，MAX_EXITED_SESSIONS）：最旧的会话 ${victim.id} 被淘汰，它的输出不再可读；想留住结果请在淘汰前 tty_capture / tty_screen 读走`);
+        }
+        // 面板即时看到保留态（第二个窗口据此不建幽灵标签；agent 标签由 exit 帧标记）
+        this.broadcastSessions();
     }
     /** 输出下行 + 基于 ws.bufferedAmount 的背压（暂停/恢复 PassThrough）。 */
     attachOutput(session) {
@@ -2379,15 +2659,22 @@ export class TtyServer {
         };
         output.on('data', onData);
     }
-    /** 立即冲刷待发的合并输出（exit/kill 前调用，保证 exit 帧永远在最后一帧 data 之后）。 */
-    flushPendingOutput(session) {
+    /** 立即冲刷待发的合并输出（exit/kill 前调用，保证 exit 帧永远在最后一帧 data 之后）。
+     *
+     *  D76：`force` 是**终局路径专用**的开关。`finishSession` 必须先置 `closed`（否则终局
+     *  之后到达的字节会继续往合并窗口里塞），可它同时又要交出**已经攒在 `pendingOutput`
+     *  里的**那批输出——两者共用同一个 `closed` 判据时，尾巴会被下面这行自己的守卫整批
+     *  吞掉：进程「打印完就退出」时那正是崩溃堆栈的最后一行 / 命令的结论行。传 `force`
+     *  即「我知道它已 closed，这一批仍然要发」。
+     */
+    flushPendingOutput(session, force = false) {
         if (session.flushTimer !== null) {
             clearTimeout(session.flushTimer);
             session.flushTimer = null;
         }
         const pending = session.pendingOutput;
         session.pendingOutput = '';
-        if (session.closed || session.clients.size === 0 || pending === '')
+        if ((session.closed && !force) || session.clients.size === 0 || pending === '')
             return;
         for (const client of session.clients.values()) {
             send(client.ws, { t: 'data', sid: client.sid, d: pending });
@@ -3796,7 +4083,7 @@ const plugin = definePlugin({
                         name: 'tty_list',
                         // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
                         isConcurrencySafe: () => true,
-                        description: '列出当前活跃的终端面板会话（sid / kind(local|ssh) / target / pid / cwd / 创建与最后活动时间）。用户开了终端面板后，用 tty_capture 读取某个 sid 的终端输出，用 tty_send 向该终端发送按键。',
+                        description: '列出当前终端面板会话（sid / kind(local|ssh) / target / pid / cwd / 创建与最后活动时间），**含进程已退出但仍只读保留着的会话**（带 exited:true + 退出码/信号；按时间释放时另带 retainMs）：用户开了终端面板后，用 tty_capture 读取某个 sid 的输出、用 tty_send 向该会话发送按键。已退出的会话只能读（写会报错），要接着操作请 tty_open 新开一条。',
                         parameters: {},
                         output: {
                             schema: {
@@ -3819,6 +4106,10 @@ const plugin = definePlugin({
                                                 lastOutputAt: { type: 'number', required: true },
                                                 persist: { type: 'boolean' },
                                                 owner: { type: 'string', required: true },
+                                                exited: { type: 'boolean' },
+                                                exitCode: { type: 'number' },
+                                                signal: { type: 'string' },
+                                                retainMs: { type: 'number', description: '只读保留的剩余毫秒；省略 = 不按时间释放' },
                                             },
                                         },
                                     },
@@ -3827,12 +4118,16 @@ const plugin = definePlugin({
                             render: (_args, value) => {
                                 const sessions = value?.sessions ?? [];
                                 const text = sessions.length === 0
-                                    ? '当前没有活跃的终端面板会话（可用 tty_open 自己开一个，或引导用户打开终端面板）'
+                                    ? '当前没有终端面板会话（可用 tty_open 自己开一个，或引导用户打开终端面板）'
                                     : '终端面板会话：' + sessions.map((s) => {
                                         const where = s.kind === 'ssh' ? `ssh ${s.target}` : `pid=${String(s.pid ?? '?')} cwd=${s.cwd}`;
                                         const persist = s.persist === true ? ' [tmux 持久]' : '';
                                         const owner = s.owner === 'agent' ? ' [agent 开的]' : '';
-                                        return `\n- sid=${s.sid} [${s.kind}]${owner}${persist} ${where} (启动于 ${new Date(s.startedAt).toLocaleString()})`;
+                                        // D77：只读保留态必须显眼——否则 AI 会对着一个已经死掉的会话发命令
+                                        const detail = s.signal !== undefined && s.signal !== '' ? `signal=${s.signal}` : s.exitCode === undefined ? '退出码未知' : `exitCode=${String(s.exitCode)}`;
+                                        const left = s.retainMs === undefined ? '（显式关闭前一直都在）' : ` ${String(Math.ceil(s.retainMs / 60000))} 分钟`;
+                                        const gone = s.exited === true ? ` [已退出 ${detail}·只读保留${left}——只能读，写会报错]` : '';
+                                        return `\n- sid=${s.sid} [${s.kind}]${owner}${persist}${gone} ${where} (启动于 ${new Date(s.startedAt).toLocaleString()})`;
                                     }).join('');
                                 return [{ type: 'text', text }];
                             },
@@ -3846,10 +4141,10 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_open',
-                        description: '开一个新的终端会话（本地 shell，或 `command` 直接跑一条长驻命令，如 dev server）。会话出现在用户的终端面板里、用户可见可接管，长驻进程与 watch 类任务应该用它（不要在 bash 工具里挂起等待）。开了之后用 tty_expect 等就绪信号、tty_capture{last:true} 拿结果；用完用 tty_close 关闭。cwd 缺省为插件配置的工作目录。',
+                        description: '开一个新的终端会话（本地 shell，或 `command` 直接跑一条命令，如 dev server）。会话出现在用户的终端面板里、用户可见可接管，长驻进程与 watch 类任务应该用它（不要在 bash 工具里挂起等待）。开了之后用 tty_expect 等就绪信号、tty_capture{last:true} 拿结果；用完用 tty_close 关闭。`command` 按 **宿主 shell 的语法整段执行**（D78：旧版本里 `exec` 包装只跑第一条）——POSIX shell 上 `cd dir && cmd`、`a; b`、`for …; do …; done` 都可以，**Windows 的 cmd / PowerShell 则按它们自己的语法**（当前执行命令的 shell 与语法见 systemPrompt 里的终端一行）；**它跑完退出后会话不会立刻消失**：会转成只读保留（留到显式关闭，最多留 16 条），退出前最后的输出与退出码都还能用 tty_capture / tty_screen 读——所以「跑一条会结束的命令、回头再取结果」不需要套一层 `sh`。cwd 缺省为插件配置的工作目录。',
                         parameters: {
                             cwd: { type: 'string', description: '工作目录（必须是已存在的绝对路径）；缺省用插件配置的 cwd' },
-                            command: { type: 'string', description: '直接执行的命令（非交互）；给出时不做 tmux 持久化。缺省 = 交互式 shell' },
+                            command: { type: 'string', description: '直接执行的命令（非交互）：按**整段 shell 代码**执行，`cd x && cmd`、`a; b`、管道、多行脚本都可以（D78）；给出时不做 tmux 持久化。省略或全空白 = 交互式 shell' },
                             persistName: { type: 'string', description: 'tmux 持久会话名（开启「会话持久化」时有效；同名复用既有会话）。适合宿主重启后仍需存活的长任务' },
                             cols: { type: 'number', description: '列数（2~500，默认 80）' },
                             rows: { type: 'number', description: '行数（2~200，默认 24）' },
@@ -3865,7 +4160,7 @@ const plugin = definePlugin({
                             },
                             render: (_args, value) => {
                                 const v = value;
-                                return [{ type: 'text', text: `已开终端会话 sid=${v.sid ?? '?'}${v.persist === true ? '（tmux 持久）' : ''}。它在用户的终端面板里可见；下一步可用 tty_send 执行命令、tty_expect 等就绪信号。` }];
+                                return [{ type: 'text', text: `已开终端会话 sid=${v.sid ?? '?'}${v.persist === true ? '（tmux 持久）' : ''}。它在用户的终端面板里可见；下一步可用 tty_send 执行命令、tty_expect 等就绪信号。\n${commandShellHint(live.shell)}` }];
                             },
                         },
                         async execute(args) {
@@ -3881,7 +4176,7 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_close',
-                        description: '关闭一个由 tty_open 开的终端会话（结束其中的进程）。**只能关 agent 自己开的会话**：用户在面板里开的标签会被拒绝，请让用户自己在面板里关，不要越权结束用户正在用的终端。',
+                        description: '关闭一个由 tty_open 开的终端会话（结束其中的进程）。**只能关 agent 自己开的会话**：用户在面板里开的标签会被拒绝，请让用户自己在面板里关，不要越权结束用户正在用的终端。对**进程已退出但仍只读保留着**的会话同样可用——那就是它的释放入口（把屏与缓冲还回去）。只读保留默认留到显式关闭（宿主重启也会清空），不按时间释放；同时最多留 16 条，超出按最旧淘汰。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（tty_open 或 tty_list 提供）' },
                         },
@@ -3959,6 +4254,11 @@ const plugin = definePlugin({
                             const session = sessions.get(input.sid);
                             if (session === undefined || session.closed)
                                 throw new Error(`会话不存在或已退出: ${input.sid}`);
+                            if (session.exited !== null) {
+                                // D77：进程没了就没有「这台会话所在机器」的此刻指标可言（本地会话会取到
+                                // 宿主自己、远端连接早断了）——如实回 available:false，不给过期数据
+                                return { sid: input.sid, available: false, reason: `会话的进程已退出（${describeExit(session.exited)}），只读保留中：取不到它的资源指标` };
+                            }
                             const result = await server.sampleStats(session);
                             if (result.available !== true || result.frame === undefined) {
                                 return { sid: input.sid, available: false, reason: result.reason ?? '未知原因' };
@@ -3970,7 +4270,7 @@ const plugin = definePlugin({
                         name: 'tty_capture',
                         // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
                         isConcurrencySafe: () => true,
-                        description: '读取某个终端面板会话（tty_list 提供 sid）的近期输出。默认读取尾部 N 行（60，最多 500，已剥离 ANSI 转义序列并收敛同行覆盖）；last:true 时只返回「上一条已完成命令」的输出与退出码（依赖 shell 集成标记，更适合拿单条命令的结果）——若命令在途（刚发送/未收到完成标记）返回 inProgress:true 且不携带旧结果，请稍后重试或改用 tty_expect。',
+                        description: '读取某个终端面板会话（tty_list 提供 sid）的近期输出。默认读取尾部 N 行（60，最多 500，已剥离 ANSI 转义序列并收敛同行覆盖）；last:true 时只返回「上一条已完成命令」的输出与退出码（依赖 shell 集成标记，更适合拿单条命令的结果）——若命令在途（刚发送/未收到完成标记）返回 inProgress:true 且不携带旧结果，请稍后重试或改用 tty_expect。**进程已退出的会话也能读**（结果带 exited:true + 退出码/信号）：输出在只读保留期里一直都在（保留到显式关闭或宿主重启，`tty_open command=...` 跑完一条命令后就这么用）；这类会话不能再写，要接着操作请 tty_open 新开一条。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（来自 tty_list）' },
                             lines: { type: 'number', description: '读取尾部行数（1~500，默认 60）；last:true 时忽略' },
@@ -3987,6 +4287,8 @@ const plugin = definePlugin({
                                     source: { type: 'string' },
                                     exitCode: { type: 'number' },
                                     inProgress: { type: 'boolean' },
+                                    exited: { type: 'boolean' },
+                                    signal: { type: 'string' },
                                 },
                             },
                             render: (_args, value) => {
@@ -3997,7 +4299,11 @@ const plugin = definePlugin({
                                 const head = v.source === 'last'
                                     ? `终端会话 ${v.sid ?? '?'} 上一条命令的输出（exitCode=${String(v.exitCode ?? '?')}）：\n\n`
                                     : `终端会话 ${v.sid ?? '?'} 尾部输出：\n\n`;
-                                return [{ type: 'text', text: head + (v.tail ?? '') }];
+                                // D77：读的是已退出会话时显式说明——免得 AI 把它当成「还在跑的终端」继续发命令
+                                const note = v.exited === true
+                                    ? `（⚠️ 该会话的进程已退出${v.signal !== undefined && v.signal !== '' ? `（signal=${v.signal}）` : ''}，这是只读保留的输出；此会话不能再写入，要接着操作请 tty_open 新开一条）\n\n`
+                                    : '';
+                                return [{ type: 'text', text: note + head + (v.tail ?? '') }];
                             },
                         },
                         async execute(args) {
@@ -4008,6 +4314,10 @@ const plugin = definePlugin({
                             if (session === undefined || session.closed)
                                 throw new Error(`会话不存在或已退出: ${input.sid}`);
                             const useRaw = input.raw === true;
+                            // D77：只读保留态的标记（读得到，但要如实告诉 agent 这是已退出会话的输出）
+                            const exitMark = session.exited === null
+                                ? {}
+                                : { exited: true, ...(session.exited.signal === null || session.exited.signal === '' ? {} : { signal: session.exited.signal }) };
                             // D72：读侧工具返回前推进水位线——这里读到的内容算「已读」，后续
                             // tty_expect 不再把它们当未读回扫（想回看更早的内容再用本工具）。
                             // tty_screen 刻意**不**推进：它是「当前可见屏幕」这一种表示，不是
@@ -4030,18 +4340,24 @@ const plugin = definePlugin({
                                 // 收一刀也保尾——最近输出才是 agent 要的。
                                 // exitCode 用「键不存在」表达缺失（`?? undefined` 会留下一个
                                 // undefined 键，不是无损 JSON 值，宿主输出校验会判工具错，见 B33）。
-                                return { sid: input.sid, source: 'last', ...(last.exitCode === null ? {} : { exitCode: last.exitCode }), tail: (useRaw ? last.output : cleanAnsiTail(last.output)).slice(-128 * 1024) };
+                                return { sid: input.sid, source: 'last', ...exitMark, ...(last.exitCode === null ? {} : { exitCode: last.exitCode }), tail: (useRaw ? last.output : cleanAnsiTail(last.output)).slice(-128 * 1024) };
                             }
                             const lines = Math.max(1, Math.min(500, typeof input.lines === 'number' && Number.isInteger(input.lines) && input.lines >= 1 ? input.lines : 60));
                             const rawTail = tailLines(session, lines);
-                            return { sid: input.sid, source: 'tail', tail: useRaw ? rawTail : cleanAnsiTail(rawTail) };
+                            return {
+                                sid: input.sid,
+                                source: 'tail',
+                                ...exitMark,
+                                ...(session.exited === null || session.exited.code === null ? {} : { exitCode: session.exited.code }),
+                                tail: useRaw ? rawTail : cleanAnsiTail(rawTail),
+                            };
                         },
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_screen',
                         // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
                         isConcurrencySafe: () => true,
-                        description: '读取某个终端面板会话（tty_list 提供 sid）当前可见屏幕的渲染结果（纯文本，等价于用户此刻看到的画面）。适合查看全屏交互程序（vim / htop / 菜单选择）的当前界面状态；要历史滚动输出用 tty_capture。',
+                        description: '读取某个终端面板会话（tty_list 提供 sid）当前可见屏幕的渲染结果（纯文本，等价于用户此刻看到的画面）。适合查看全屏交互程序（vim / htop / 菜单选择）的当前界面状态；要历史滚动输出用 tty_capture。**进程已退出的会话也能读**（结果带 exited:true）：屏在只读保留期内不释放，读到的就是它退出那一刻的画面。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（来自 tty_list）' },
                         },
@@ -4054,11 +4370,16 @@ const plugin = definePlugin({
                                     cols: { type: 'number', required: true },
                                     rows: { type: 'number', required: true },
                                     text: { type: 'string', required: true },
+                                    exited: { type: 'boolean' },
+                                    signal: { type: 'string' },
                                 },
                             },
                             render: (_args, value) => {
                                 const v = value;
-                                return [{ type: 'text', text: `终端会话 ${v.sid ?? '?'} 当前屏幕（${String(v.cols ?? '?')}×${String(v.rows ?? '?')}）：\n\n${v.text ?? ''}` }];
+                                const note = v.exited === true
+                                    ? `（⚠️ 该会话的进程已退出${v.signal !== undefined && v.signal !== '' ? `（signal=${v.signal}）` : ''}：这是退出那一刻的屏幕，只读保留中）`
+                                    : '';
+                                return [{ type: 'text', text: `终端会话 ${v.sid ?? '?'} 当前屏幕（${String(v.cols ?? '?')}×${String(v.rows ?? '?')}）${note}：\n\n${v.text ?? ''}` }];
                             },
                         },
                         async execute(args) {
@@ -4082,14 +4403,21 @@ const plugin = definePlugin({
                             while (lines.length > 0 && lines[lines.length - 1].trim() === '')
                                 lines.pop();
                             // 保尾截断：屏幕末尾（提示符行）才是有效区，丢头部不丢尾部
-                            return { sid: input.sid, cols: screen.cols, rows: screen.rows, text: lines.join('\n').slice(-32 * 1024) };
+                            return {
+                                sid: input.sid,
+                                cols: screen.cols,
+                                rows: screen.rows,
+                                // D77：只读保留态如实标注（屏不再更新，「当前屏幕」= 退出那一刻）
+                                ...(session.exited === null ? {} : { exited: true, ...(session.exited.signal === null || session.exited.signal === '' ? {} : { signal: session.exited.signal }) }),
+                                text: lines.join('\n').slice(-32 * 1024),
+                            };
                         },
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_expect',
                         // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
                         isConcurrencySafe: () => true,
-                        description: '在某个终端面板会话（tty_list 提供 sid）等待一个正则出现（如 dev server 的 ready/URL、构建完成标记、交互提示）。**先回溯**还没被读过的输出（含「上一条命令」的完整输出），再等后续输出——所以命令瞬间跑完也不会白等；匹配到立即返回 matched:true（matchedFrom 说明匹配来自哪里：live=本次等待期间新产生 / last=上一条命令的输出 / buffered=此前已到达的缓冲输出）与周边输出。超时不抛错，返回 matched:false + 尾部输出；期间该命令若已结束（shell 集成标记）也会提前返回并带退出码。适合先 tty_send 启动长任务、再 tty_expect 等就绪信号的流程。注意：只对「还没读过的输出」负责——要回看更早的内容用 tty_capture。',
+                        description: '在某个终端面板会话（tty_list 提供 sid）等待一个正则出现（如 dev server 的 ready/URL、构建完成标记、交互提示）。**先回溯**还没被读过的输出（含「上一条命令」的完整输出），再等后续输出——所以命令瞬间跑完也不会白等；匹配到立即返回 matched:true（matchedFrom 说明匹配来自哪里：live=本次等待期间新产生 / last=上一条命令的输出 / buffered=此前已到达的缓冲输出）与周边输出。**刚发进去的命令回显不算命中**（命令还没执行时回显先到，命中它等于谎报）；若等满超时且 pattern 只命中过回显，结果带 echoOnly:true——那说明命中的只是回显、不是输出（命令可能没被执行），先复核它到底跑没跑。超时不抛错，返回 matched:false + 尾部输出；期间该命令若已结束（shell 集成标记）也会提前返回并带退出码。适合先 tty_send 启动长任务、再 tty_expect 等就绪信号的流程。注意：只对「还没读过的输出」负责——要回看更早的内容用 tty_capture。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（来自 tty_list）' },
                             pattern: { type: 'string', required: true, description: '等待匹配的正则表达式（JavaScript RegExp 语法）' },
@@ -4105,6 +4433,8 @@ const plugin = definePlugin({
                                     text: { type: 'string', required: true },
                                     exitCode: { type: 'number' },
                                     matchedFrom: { type: 'string' },
+                                    echoOnly: { type: 'boolean' },
+                                    exited: { type: 'boolean' },
                                 },
                             },
                             render: (_args, value) => {
@@ -4115,6 +4445,14 @@ const plugin = definePlugin({
                                         : v.matchedFrom === 'buffered' ? '（回溯自此前已到达、还没读过的缓冲输出）' : '';
                                     return [{ type: 'text', text: `已匹配到等待的模式${from}：\n\n${v.text ?? ''}` }];
                                 }
+                                if (v.echoOnly === true) {
+                                    // D75：只命中过回显 —— 这不是「命令跑了但没输出」，而是「等的东西一次都没出现在输出里」
+                                    return [{ type: 'text', text: `等待超时：pattern **只匹配到刚发进去的命令回显**，没有匹配到任何真正的输出——命令可能没有被执行（回显先到、输出没来），也可能执行了但输出里没有这个 pattern。先复核它到底跑没跑（tty_capture 读尾部、或在面板里看那一行是否还停在输入行），再决定重发命令还是换 pattern。尾部输出：\n\n${v.text ?? ''}` }];
+                                }
+                                if (v.exited === true) {
+                                    // D77：会话的进程已经退出（只读保留）——不会再有任何新输出，别让它以为还能等
+                                    return [{ type: 'text', text: `会话的进程已退出（只读保留中），不会再有新输出：这一轮按现存输出结算，没有匹配到 pattern。要看它最后的输出用 tty_capture（默认读尾部）/ tty_screen（退出那一刻的屏）；要接着跑命令请 tty_open 新开一条会话。尾部输出：\n\n${v.text ?? ''}` }];
+                                }
                                 if (v.timedOut === true && (v.text ?? '').trim() === '') {
                                     // D72：这段空白此前被当成「命令没执行」——命令若是瞬间完成的，它早就跑完了
                                     return [{ type: 'text', text: '等待超时，且注册之后没有任何新输出。命令若是瞬间完成的，它早已在开始等待之前跑完：用 tty_capture{last:true} 复核那条命令的输出与退出码，别把这段空白当成「没执行」。' }];
@@ -4155,6 +4493,8 @@ const plugin = definePlugin({
                                 // 尾部窗口：匹配只看最近 16KB，acc 全量囤积对刷屏会话可涨到数百 MB
                                 let acc = '';
                                 let settled = false;
+                                /** D75：pattern 只命中过回显（被剔除了）——超时文案据此如实说明「命令可能没跑」。 */
+                                let sawEchoOnly = false;
                                 let timer = null;
                                 const decoder = new StringDecoder('utf8');
                                 const output = session.handle.output;
@@ -4177,18 +4517,25 @@ const plugin = definePlugin({
                                         advanceReadMark(session);
                                     resolve(result);
                                 };
-                                function onData(chunk) {
+                                // 箭头函数（不是 function 声明）：后者会被提升，TS 不保留外层 `const session`
+                                // 的收窄，闭包里就得再判一次 undefined。
+                                const onData = (chunk) => {
                                     acc = (acc + decoder.write(chunk)).slice(-64 * 1024);
                                     const hay = acc.length > 16 * 1024 ? acc.slice(-16 * 1024) : acc;
                                     if (testPattern(re, hay)) {
-                                        finish({ matched: true, timedOut: false, matchedFrom: 'live', text: cleanAnsiTail(hay.slice(-6 * 1024)) });
-                                        return;
+                                        // D75：命中的若**只是刚送进去那行命令的回显**，不算命中——继续等真输出
+                                        if (echoOnlyMatch(re, hay, session))
+                                            sawEchoOnly = true;
+                                        else {
+                                            finish({ matched: true, timedOut: false, matchedFrom: 'live', text: cleanAnsiTail(hay.slice(-6 * 1024)) });
+                                            return;
+                                        }
                                     }
                                     // 命令早停：注册时命令在飞（B..D 之间），如今 D 已到仍未匹配
                                     if (startedInCommand && !state.inCommand && state.lastCommand !== null && state.lastCommand.endedAt >= startedAt) {
-                                        finish({ matched: false, timedOut: false, ...(state.lastCommand.exitCode === null ? {} : { exitCode: state.lastCommand.exitCode }), text: cleanAnsiTail(acc.slice(-6 * 1024)) });
+                                        finish({ matched: false, timedOut: false, ...(state.lastCommand.exitCode === null ? {} : { exitCode: state.lastCommand.exitCode }), ...(sawEchoOnly ? { echoOnly: true } : {}), text: cleanAnsiTail(acc.slice(-6 * 1024)) });
                                     }
-                                }
+                                };
                                 // ── 注册**之前**就已到达的输出（D72）─────────────────────────
                                 // 这段此前完全不匹配：acc 从空开始，所以「命令瞬间完成」时标记
                                 // 早就躺在缓冲区里、acc 里永远没有它 → 白等满超时、还只返回空白。
@@ -4204,23 +4551,30 @@ const plugin = definePlugin({
                                 // ② 泛化：水位线之后的未读缓冲（长驻输出落在多条命令之间、无 shell 集成……）
                                 const backlog = unreadRegion(session);
                                 if (backlog !== '' && testPattern(re, backlog)) {
-                                    finish({ matched: true, timedOut: false, matchedFrom: 'buffered', text: cleanAnsiTail(backlog.slice(-6 * 1024)) });
-                                    return;
+                                    // D75：同上——纯回显不算命中（Windows 上 LF 没提交时，这里命中的就只有回显）
+                                    if (echoOnlyMatch(re, backlog, session))
+                                        sawEchoOnly = true;
+                                    else {
+                                        finish({ matched: true, timedOut: false, matchedFrom: 'buffered', text: cleanAnsiTail(backlog.slice(-6 * 1024)) });
+                                        return;
+                                    }
                                 }
                                 timer = setTimeout(() => {
-                                    finish({ matched: false, timedOut: true, text: cleanAnsiTail(acc.slice(-6 * 1024)) }, false);
+                                    finish({ matched: false, timedOut: true, ...(sawEchoOnly ? { echoOnly: true } : {}), text: cleanAnsiTail(acc.slice(-6 * 1024)) }, false);
                                 }, timeoutMs);
                                 timer.unref?.();
                                 output.on('data', onData);
                                 void session.handle.done.then(() => {
-                                    finish({ matched: false, timedOut: false, text: cleanAnsiTail(acc.slice(-6 * 1024)) });
+                                    // 会话结束（命令跑完 / 进程退出）：不能再等——D77 的只读保留态也走这里
+                                    // （done 早已兑现，所以退出后调用 expect 不再白等满超时）
+                                    finish({ matched: false, timedOut: false, ...(session.exited === null ? {} : { exited: true }), text: cleanAnsiTail(acc.slice(-6 * 1024)) });
                                 });
                             });
                         },
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_send',
-                        description: '向某个终端面板会话（tty_list 提供 sid）的 PTY 发送按键/文本（命令以 \\n 结尾）。适合给用户终端里运行的程序发交互输入（如 dev server 的 q 键、menu 选择、回答提示）。操作会实时显示在用户的终端面板里。',
+                        description: '向某个终端面板会话（tty_list 提供 sid）的 PTY 发送按键/文本（命令以 \\n 结尾；Windows 本地会话上插件会把 `\\n` 归一成 CRLF，照常写 `\\n` 即可）。适合给用户终端里运行的程序发交互输入（如 dev server 的 q 键、menu 选择、回答提示）。操作会实时显示在用户的终端面板里。**对已退出（只读保留）的会话会报错**——那种会话只能读，要接着操作请 tty_open 新开一条。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（来自 tty_list）' },
                             data: { type: 'string', required: true, description: '要发送的文本（含换行则直接发送命令）' },
@@ -4248,12 +4602,21 @@ const plugin = definePlugin({
                             const session = sessions.get(input.sid);
                             if (session === undefined || session.closed)
                                 throw new Error(`会话不存在或已退出: ${input.sid}`);
+                            if (session.exited !== null) {
+                                // D77：只读保留态明确拒写——进程已经没了，写进去只会在死 PTY 上静默消失
+                                throw new Error(`会话 ${input.sid} 的进程已退出（${describeExit(session.exited)}），只读保留中，写不进去：要接着操作请 tty_open 新开一条会话（它最后的输出仍可用 tty_capture / tty_screen 读）`);
+                            }
+                            // D74：Windows 本地 PTY 的 Enter 是 CR，裸 LF 不提交命令行——按平台归一化。
+                            // SSH 会话不动：远端是什么系统插件不知道。
+                            const data = session.kind === 'local' ? normalizePtyInput(input.data) : input.data;
                             session.lastInputAt = Date.now();
                             // D72：只初始化水位线，**不推进**——刚发出去的这条命令的输出 AI 还没看见；
                             // 但这一刻之前的积压不该被第一次 expect 当成「未读」回扫。
                             ensureReadMark(session);
-                            await session.handle.write(input.data);
-                            return { ok: true, sent: input.data.length };
+                            // D75：记下这行命令的回显候选，供 tty_expect 剔除「命中回显」的假阳性
+                            noteSubmittedInput(session, data);
+                            await session.handle.write(data);
+                            return { ok: true, sent: data.length };
                         },
                     })));
                     activeDisposers.push(tools.register(defineTool({
@@ -4727,13 +5090,30 @@ const plugin = definePlugin({
                         order: 150,
                         text: () => {
                             const list = sessions.list();
+                            // D78 补：本地命令的语法随宿主 shell 变（POSIX / cmd / PowerShell），
+                            // 而「Shell 路径」是热改的配置——所以这行每轮现算，不冻在工具描述里。
+                            const shellLine = commandShellHint(live.shell);
                             if (list.length === 0)
-                                return '当前没有活跃的终端面板会话（可用 tty_open 自己开一个，或引导用户打开「终端」面板）。';
-                            return '当前活跃的终端面板会话（可用 tty_capture / tty_screen / tty_expect / tty_send 操作，用 tty_open / tty_close 开关，sid 如下）：\n' + list.map((s) => {
-                                const where = s.kind === 'ssh' ? `ssh ${s.target}` : `pid=${String(s.pid ?? '?')} cwd=${s.cwd}`;
-                                const owner = s.owner === 'agent' ? ' [agent 开的]' : '';
-                                return `- sid=${s.sid} [${s.kind}]${owner}${s.persist === true ? ' [tmux 持久]' : ''} ${where} (最后活动 ${new Date(s.lastOutputAt).toLocaleTimeString()})`;
-                            }).join('\n');
+                                return `当前没有终端面板会话（可用 tty_open 自己开一个，或引导用户打开「终端」面板）。\n${shellLine}`;
+                            // D77：只读保留态（进程已退出）**不能冒充活会话**——模型会以为那个长驻
+                            // 任务还在跑、或者对它发命令。这里把两者分开：活会话逐条列，保留态压成
+                            // 一行汇总（每轮 prompt 的增量是常数，不随条数线性膨胀）。
+                            const alive = list.filter((s) => s.exited !== true);
+                            const gone = list.filter((s) => s.exited === true);
+                            const head = alive.length === 0
+                                ? '当前没有活着的终端面板会话。'
+                                : '当前活跃的终端面板会话（可用 tty_capture / tty_screen / tty_expect / tty_send 操作，用 tty_open / tty_close 开关，sid 如下）：\n' + alive.map((s) => {
+                                    const where = s.kind === 'ssh' ? `ssh ${s.target}` : `pid=${String(s.pid ?? '?')} cwd=${s.cwd}`;
+                                    const owner = s.owner === 'agent' ? ' [agent 开的]' : '';
+                                    return `- sid=${s.sid} [${s.kind}]${owner}${s.persist === true ? ' [tmux 持久]' : ''} ${where} (最后活动 ${new Date(s.lastOutputAt).toLocaleTimeString()})`;
+                                }).join('\n');
+                            const tail = gone.length === 0
+                                ? ''
+                                : `\n另有 ${String(gone.length)} 条已退出但输出仍可读的会话（只读：tty_send 会报错，要用 tty_capture / tty_screen 读）：` + gone.map((s) => {
+                                    const how = s.signal !== undefined ? `signal=${s.signal}` : s.exitCode === undefined ? '退出码未知' : `exitCode=${String(s.exitCode)}`;
+                                    return `sid=${s.sid} (${how})`;
+                                }).join('、');
+                            return head + tail + '\n' + shellLine;
                         },
                     });
                     sectionDisposable = systemPrompt.section({ name: 'plugin:dsh-tty', order: 150, text: TTY_GUIDANCE });
@@ -4765,6 +5145,7 @@ const plugin = definePlugin({
         // 断开时立即结束）；插件卸载时随 effect 一起停掉
         const reaperTimer = setInterval(() => {
             void sessions.reapOrphans(live.reconnectGraceMs);
+            sessions.reapExited(EXITED_RETAIN_MS); // D77：保留期策略为有限值时到点退役（∞ 时不动作，条数由 capExited 兜）
         }, REAPER_INTERVAL_MS);
         reaperTimer.unref?.();
         ctx.effect(() => () => clearInterval(reaperTimer), 'dsh-tty: orphan reaper');