@hyzyn/dsh-tty 0.21.0 → 0.22.0-rc.2

package/lib/index.js

@@ -12,12 +12,13 @@ import WebSocket, { WebSocketServer } from 'ws';
 // found），必须默认导入后取 Terminal；类型用 InstanceType 别名保持同名可用
 import xtermHeadless from '@xterm/headless';
 const HeadlessTerminal = xtermHeadless.Terminal;
-import { definePlugin, dshHome as resolveDshHome, plainConfig, settingsEntryScope, suppressAutoSettingsPage } from '@hyzyn/dsh-kit';
+import { definePlugin, dshHome as resolveDshHome, hasSameOriginProof, isLoopbackRequestStrict, plainConfig, settingsEntryScope, suppressAutoSettingsPage } from '@hyzyn/dsh-kit';
 import { defineTool } from '@deepseek-ai/dsh-tools';
-import { spawnSsh, sshTarget, expandHome, setCredentialResolver } from './ssh.js';
+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 { parseSshConfig } from './ssh-config.js';
+import { parseSshConfigDetailed } from './ssh-config.js';
 import { parseKnownHostsDetailed } from './known-hosts.js';
 import { TunnelManager } from './tunnels.js';
 import { SftpManager } from './sftp.js';
@@ -25,6 +26,22 @@ import { buildTmuxSpawnPlan, ensureTmuxAssets, killTmuxSession, listTmuxSessions
 import { buildRemoteStatsCommand, buildWindowsStatsCommand, hasStatsData, localStatsSampler, parseStatsLine } from './stats.js';
 /** SFTP 传输限制默认值。 */
 const DEFAULT_SFTP_LIMITS = { maxDownloadMb: 1024, maxUploadMb: 2048, maxUploadFiles: 1000 };
+/**
+ * 跳板机（ProxyJump 单跳）的 settings schema。
+ *
+ * 刻意**不给 `auth` / `keyPath` / `passphrase` / `password` / `username` 默认值**：
+ * 缺省的含义是「继承目标那一跳的凭据」，一旦给默认值（如 auth 默认 agent）就会把
+ * 「继承」变成「显式 agent」，用户配了密码的跳板机就会认证失败。
+ */
+const SSH_JUMP_SCHEMA = z.object({
+    host: z.string(),
+    port: z.natural().max(65535).default(22),
+    username: z.string().default(''),
+    auth: z.union([z.const('agent'), z.const('key'), z.const('password')]),
+    keyPath: z.string().default(''),
+    passphrase: z.string().default(''),
+    password: z.string().default(''),
+});
 const SSH_HOST_SCHEMA = z.object({
     name: z.string(),
     host: z.string(),
@@ -35,6 +52,13 @@ const SSH_HOST_SCHEMA = z.object({
     passphrase: z.string().default(''),
     password: z.string().default(''),
     agentForward: z.boolean().default(false),
+    /** 经跳板机连接（ProxyJump 单跳）；缺省 = 直连。 */
+    jump: SSH_JUMP_SCHEMA,
+    /**
+     * 代理命令（ProxyCommand）：本机执行、stdio 当 SSH 传输。**需要 allowProxyCommand 才生效**。
+     * `~/.ssh/config` 导入永不自动带入（那一档信任级要用户自己开开关并手填）。
+     */
+    proxyCommand: z.string().default(''),
     /** 该条目的 SSH 标签默认以 tmux 持久会话打开（仅 persistence=tmux 时生效）。 */
     persist: z.boolean().default(false),
 });
@@ -85,15 +109,69 @@ export const Config = z.object({
         maxUploadMb: z.natural().max(1024 * 1024).default(2048),
         maxUploadFiles: z.natural().max(100000).default(1000),
     }).default({ maxDownloadMb: 1024, maxUploadMb: 2048, maxUploadFiles: 1000 }).volatile(),
+    /**
+     * 允许 ProxyCommand（本机命令执行）：**默认 false**。
+     *
+     * 这是本插件唯一「由设置字段驱动本机任意命令执行」的开关，与跳板机（只连一跳 TCP）不同档；
+     * 关着时携带 proxyCommand 的连接**明确失败**（不退回直连），导入也永不自动带入该字段。
+     */
+    allowProxyCommand: z.boolean().default(false).volatile(),
     persistSessions: z.array(z.object({ tmuxName: z.string() })).default([]).volatile(),
 });
 /* ------------------------------------------------------------------ *
  * 常量
  * ------------------------------------------------------------------ */
 const WS_PATH = '/api/dsh-tty/ws';
+/**
+ * 代理命令这条能力的宿主侧授权（见 kit 的 capability.js 与 docs/architecture.md）。
+ *
+ * 两条提权通道（见 kit 的 capability.ts）：
+ *   ① 启动环境变量（最严档，判定源是宿主的启动环境快照）；
+ *   ② 就地提权（免重启）：卡片上点开关 → 在宿主文件系统上落地一个随机名确认文件。
+ * HTTP 侧**不能凭空打开**它——回环围栏与同源证明都拦不住跨站页面与页内脚本，配置路由若能
+ * 凭空提权，这道闸门等于没有；而「关掉」永远可用（紧急刹车不依赖重启）。
+ */
+const CAP_PROXY_COMMAND = { env: 'DSH_TTY_ALLOW_PROXY_COMMAND', label: '代理命令（ProxyCommand）' };
 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`](#) 兜（8 条，
+ *   单条几百 KB~一两 MB），而「永久」还有一条天然上界——保留是**内存态**，
+ *   宿主 / 插件重启即清空，不会跨天累积；
+ * - 连续跑很多短命令时，淘汰节奏变成「超过 8 条按最旧淘汰」（`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;
@@ -134,7 +212,7 @@ const TERM_RE = /^[A-Za-z0-9_.+-]+$/;
 const REAPER_INTERVAL_MS = 10_000;
 /** 服务器状态条的采集/推送间隔（mvp 固定 1s，不做配置项）。 */
 const STATS_INTERVAL_MS = 1000;
-const TTY_GUIDANCE = '本机已安装 dsh-tty 插件（终端面板）：Web GUI 侧边栏的「终端」入口可打开交互终端（xterm.js + PTY），可运行任意命令与 TUI 程序（vim/htop 等），支持多标签页与断线自动重连（刷新页面/网络抖动后会话保活并恢复现场）；新标签默认在当前会话工作目录打开。标签栏「+」菜单还能开 SSH 标签页（ssh2 原生连接，连接簿在设置卡片维护，支持 agent forwarding 与主机指纹 TOFU 钉扎），像本地终端一样操作远程主机。设置卡片开启「会话持久化（tmux）」后，新开的本地/SSH 标签默认由 tmux server 托管（宿主重启/断线超时后重开即恢复现场），长任务建议在持久化开启时运行。长驻进程（dev server、watch、交互式程序）用 tty_open 开一个会话跑（或引导用户到终端面板里运行），不要在 bash 工具里挂起等待；用户提到「开个终端 / 在终端里跑 / SSH 到某台机器」时引导其打开该面板。agent 侧配套工具：tty_list 列出活跃终端会话（含 SSH 的 target 与实时 cwd），tty_capture 读取近期输出（默认清洗 ANSI；last:true 拿「上一条命令」的输出+退出码），tty_screen 读取当前可见屏幕（可读懂 vim/htop 等 TUI），tty_expect 用正则等待输出中的就绪信号（如 dev server URL、构建完成），tty_send 发送按键，tunnel_list 列出端口转发隧道状态——操作会实时显示在用户终端里。SFTP 文件传输：面板内可对 SSH 连接簿条目（或 SSH 连接对话框当前填写的信息）打开文件浏览（上传/下载/建目录/重命名/删除），传输期间进度条右侧 ✕ 可取消（半截文件自动清理）；agent 配套 sftp_list 列远程目录、sftp_tree 递归看目录结构、sftp_read 读远程文本文件（≤1MB）、sftp_write 写远程文本文件（≤1MB，可追加）、sftp_mkdir 建目录（parents 可逐级补齐）、sftp_rename 重命名/移动、sftp_remove 删除（目录需 recursive），book 参数为连接簿条目名。端口转发：连接簿条目可配本地/远程隧道（如把远程数据库映射到本地端口），宿主自动保活重连，用户提到「转发端口 / 访问远程库」时引导其到终端面板设置卡片配置。推荐流程：tty_send 启动长任务 → tty_expect 等就绪标记 → tty_capture{last:true} 拿结果。';
+const TTY_GUIDANCE = '本机已安装 dsh-tty 插件（终端面板）：Web GUI 侧边栏的「终端」入口可打开交互终端（xterm.js + PTY），可运行任意命令与 TUI 程序（vim/htop 等），支持多标签页与断线自动重连（刷新页面/网络抖动后会话保活并恢复现场）；新标签默认在当前会话工作目录打开。标签栏「+」菜单还能开 SSH 标签页（ssh2 原生连接，连接簿在设置卡片维护，支持 agent forwarding 与主机指纹 TOFU 钉扎；连接簿条目可配单跳跳板机 ProxyJump），像本地终端一样操作远程主机。设置卡片开启「会话持久化（tmux）」后，新开的本地/SSH 标签默认由 tmux server 托管（宿主重启/断线超时后重开即恢复现场），长任务建议在持久化开启时运行。长驻进程（dev server、watch、交互式程序）用 tty_open 开一个会话跑（或引导用户到终端面板里运行），不要在 bash 工具里挂起等待；用户提到「开个终端 / 在终端里跑 / SSH 到某台机器」时引导其打开该面板。agent 侧配套工具：tty_list 列出活跃终端会话（含 SSH 的 target 与实时 cwd），tty_capture 读取近期输出（默认清洗 ANSI；last:true 拿「上一条命令」的输出+退出码），tty_screen 读取当前可见屏幕（可读懂 vim/htop 等 TUI），tty_expect 用正则等待输出中的就绪信号（如 dev server URL、构建完成；它**先回看还没读过的已到达输出**，命令瞬间跑完也不会白等——超时若只返回一句诊断文案，别当成「命令没执行」），tty_send 发送按键，tunnel_list 列出端口转发隧道状态——操作会实时显示在用户终端里。SFTP 文件传输：面板内可对 SSH 连接簿条目（或 SSH 连接对话框当前填写的信息）打开文件浏览（上传/下载/建目录/重命名/删除），传输期间进度条右侧 ✕ 可取消（半截文件自动清理）；agent 配套 sftp_list 列远程目录、sftp_tree 递归看目录结构、sftp_read 读远程文本文件（≤1MB）、sftp_write 写远程文本文件（≤1MB，可追加）、sftp_mkdir 建目录（parents 可逐级补齐）、sftp_rename 重命名/移动、sftp_remove 删除（目录需 recursive），book 参数为连接簿条目名。端口转发：连接簿条目可配本地/远程隧道（如把远程数据库映射到本地端口），宿主自动保活重连，用户提到「转发端口 / 访问远程库」时引导其到终端面板设置卡片配置。推荐流程：tty_send 启动长任务 → tty_expect 等就绪标记 → tty_capture{last:true} 拿结果。';
 /** 本地 PTY 包装成 TermHandle（resize/kill 仍是透传 node-pty 的内部耦合；防御性降级）。 */
 function wrapLocalPty(handle) {
     let resizeWarned = false;
@@ -188,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();
@@ -217,6 +334,8 @@ class LiveConfig {
     persistSessions;
     /** SFTP 传输限制（客户端浏览器侧执行）。 */
     sftpLimits;
+    /** 允许 ProxyCommand（本机命令执行）：默认关（见 Config.allowProxyCommand）。 */
+    allowProxyCommand;
     constructor(init) {
         this.shell = init.shell;
         this.term = sanitizeTermValue(init.term, 'xterm-256color');
@@ -232,6 +351,8 @@ class LiveConfig {
         // 只有显式 false 才关（缺省/旧配置一律视为开）
         this.statsEnabled = init.statsEnabled !== false;
         this.sftpLimits = sanitizeSftpLimits(init.sftpLimits);
+        // 缺省/旧配置一律视为**关**（这一档是「本机命令执行」，只有显式 true 才开）
+        this.allowProxyCommand = init.allowProxyCommand === true;
         this.persistSessions = init.persistSessions ?? [];
     }
     /** 合并部分更新；空字符串/undefined 保持原值；sshHosts/hostKeys/tunnels 传数组即整体替换。 */
@@ -263,6 +384,8 @@ class LiveConfig {
             this.statsEnabled = partial.statsEnabled;
         if (partial.sftpLimits !== undefined)
             this.sftpLimits = sanitizeSftpLimits({ ...this.sftpLimits, ...partial.sftpLimits });
+        if (typeof partial.allowProxyCommand === 'boolean')
+            this.allowProxyCommand = partial.allowProxyCommand;
         if (Array.isArray(partial.persistSessions))
             this.persistSessions = partial.persistSessions;
     }
@@ -501,6 +624,144 @@ export function feedShellIntegration(session, text) {
             state.cmdBuffer = (state.cmdBuffer + rest).slice(-COMMAND_CAP);
     }
 }
+/**
+ * 唯一追加点（D72）：环形缓冲与单调字符计数一起维护。水位线用绝对值定位
+ * 未读区（`buffer 起点 = outputSeq - buffer.length`，裁剪只会前移起点，
+ * 公式恒成立），漏掉任何一处追加都会让它错位——notice 注入那两处此前也是
+ * 各写各的 `tailFromSafeBoundary`。
+ */
+function appendOutput(session, text) {
+    session.outputSeq += text.length;
+    session.buffer = tailFromSafeBoundary(session.buffer + text, BUFFER_CAP);
+}
+/** 原始流里最后一个「命令开始」B 标记的结束位置；-1 = 窗口内没有（无 shell 集成 → 降级）。 */
+function lastCommandStart(text) {
+    OSC133_RE.lastIndex = 0;
+    let end = -1;
+    for (const match of text.matchAll(OSC133_RE)) {
+        if (match[1] === 'B')
+            end = (match.index ?? 0) + match[0].length;
+    }
+    OSC133_RE.lastIndex = 0; // 归位：这个正则是共用的（feedShellIntegration 也用它）
+    return end;
+}
+/** 首次被 agent 工具触达时把水位线落在当下——否则第一次回扫会把用户此前的历史输出当成「还没读过」。 */
+function ensureReadMark(session) {
+    if (session.readSeq >= 0)
+        return;
+    session.readSeq = session.outputSeq;
+    session.readMarkAt = Date.now();
+}
+/** 读侧工具返回前推进水位线：返回时刻 = 「AI 真正看到的内容」的上界。 */
+function advanceReadMark(session) {
+    session.readSeq = session.outputSeq;
+    session.readMarkAt = Date.now();
+}
+/**
+ * 水位线之后的**未读**原始输出。下界再抬到「最后一个 B 标记之后」：回显落在
+ * A（prompt 开始）与 B（命令开始）之间，所以这样能零启发式地排除回显——按
+ * 文本比对「跳过与发送内容相同的行」会被折行 / ANSI / 多行粘贴打碎。
+ * 没有 B 标记（未开 shell 集成 / Windows PowerShell / 远端未装集成）时无法按边界切片：
+ * D75 起改用「最近提交过的输入」这份回显候选把回显行从匹配窗口里剔掉（见 echoOnlyMatch），
+ * 不再直接拿回显当命中。
+ */
+function unreadRegion(session) {
+    ensureReadMark(session);
+    const bufferStart = session.outputSeq - session.buffer.length;
+    const text = session.buffer.slice(Math.max(0, session.readSeq - bufferStart));
+    const start = lastCommandStart(text);
+    return start === -1 ? text : text.slice(start);
+}
+/**
+ * pattern 匹配的统一入口（D72）：先对含 ANSI 的原始流试（live 路径原语义），
+ * 未命中再对清洗后文本试一次——这样承诺才是「tty_capture 里看得到的，
+ * tty_expect 也能匹配到」，而不是回扫命中、返回文案里却看不到。
+ */
+function testPattern(re, text) {
+    re.lastIndex = 0;
+    if (re.test(text))
+        return true;
+    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))
@@ -610,6 +871,14 @@ function sanitizeSshHosts(input) {
             agentForward: raw.agentForward === true,
             persist: raw.persist === true,
         });
+        // 跳板机：清洗不出可用对象（host 为空）就当没配——不给下游留半个对象
+        const jump = sanitizeJumpSpec(raw.jump);
+        if (jump !== undefined)
+            out[out.length - 1].jump = jump;
+        // 代理命令：形状不合法（含换行 / 超长 / 非字符串）就当没配（**失败方向是关**）
+        const proxyCommand = sanitizeProxyCommand(raw.proxyCommand);
+        if (proxyCommand !== undefined)
+            out[out.length - 1].proxyCommand = proxyCommand;
     }
     return out;
 }
@@ -650,6 +919,16 @@ function validateSshHosts(input) {
         if ((raw.auth === 'key') && (typeof raw.keyPath !== 'string' || raw.keyPath.trim() === '')) {
             return { error: `sshHosts「${String(raw.name)}」auth=key 需要 keyPath` };
         }
+        if (raw.jump !== undefined) {
+            const checked = validateJumpSpec(raw.jump);
+            if (checked.error !== undefined)
+                return { error: `sshHosts「${String(raw.name)}」${checked.error}` };
+        }
+        if (raw.proxyCommand !== undefined) {
+            const checked = validateProxyCommand(raw.proxyCommand);
+            if (checked.error !== undefined)
+                return { error: `sshHosts「${String(raw.name)}」${checked.error}` };
+        }
     }
     return { hosts: sanitizeSshHosts(input) };
 }
@@ -788,34 +1067,16 @@ class HostKeyStore {
         this.persist(next);
     }
 }
-/** upgrade 路由的 loopback 信任围栏（与 dsh-mcp 的 HTTP 围栏同思路，socket 版）。 */
+/**
+ * upgrade 路由的 loopback 信任围栏（socket 版）：直接用 kit 的加固档（docker D31/D80/D110）。
+ *
+ * 与 HTTP 路由的差别只有一处刻意为之：**不放开 Cookie 例外**。升级请求在浏览器里必带
+ * `Origin`，而加固档「Origin 有就必须与 Host 同源」这条已经等价于同源证明；而长连
+ * （PTY / 隧道帧）一旦建立就一直活着，没必要为桌面壳那种「只带 Cookie」的转发链开口子
+ * ——真要支持，也应该先在桌面壳上验一条真机链路（docker 的 D139 是那样定下来的）。
+ */
 function isLoopbackUpgrade(req) {
-    const address = req.socket.remoteAddress;
-    if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1')
-        return false;
-    const host = req.headers.host;
-    if (typeof host !== 'string')
-        return false;
-    let hostUrl;
-    try {
-        hostUrl = new URL('http://' + host);
-    }
-    catch {
-        return false;
-    }
-    if (hostUrl.hostname !== '127.0.0.1' && hostUrl.hostname !== 'localhost' && hostUrl.hostname !== '[::1]')
-        return false;
-    if (req.headers['sec-fetch-site'] === 'cross-site')
-        return false;
-    const origin = req.headers.origin;
-    if (origin === undefined)
-        return true;
-    try {
-        return new URL(origin).host === hostUrl.host;
-    }
-    catch {
-        return false;
-    }
+    return isLoopbackRequestStrict(req);
 }
 /* ------------------------------------------------------------------ *
  * 虚拟屏（xterm-headless）——构造与异常兜底（D57）
@@ -1007,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();
@@ -1031,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);
@@ -1043,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,
@@ -1054,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 };
     }
@@ -1065,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,
         }));
     }
     /** 遍历全部会话（状态条采集器的批量收尾等按会话维度的操作）。 */
@@ -1073,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;
@@ -1121,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) {
@@ -1128,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();
@@ -1140,6 +1473,9 @@ export class SessionManager {
             catch {
                 /* 已释放 */
             }
+            // D77：只读保留态（进程已退出）没有要收的进程——`forceKill` 只会对死句柄再戳一遍
+            if (session.exited !== null)
+                return Promise.resolve(true);
             return forceKill(session.handle);
         }));
     }
@@ -1245,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();
@@ -1361,10 +1698,26 @@ export class TtyServer {
     }
     /** registerUpgrade 的 handler（loopback 围栏 + ws 握手）。 */
     handleUpgrade(req, socket, head) {
-        if (!isLoopbackUpgrade(req)) {
+        const loopback = isLoopbackUpgrade(req);
+        // 字面量环回同步判定（绝大多数请求：握手第一拍就继续，不引入额外时序）；
+        // 只有主机名 / /etc/hosts 别名才等一次 DNS 确认（≤500ms），期间不碰 socket
+        if (loopback instanceof Promise) {
+            void loopback.then((ok) => {
+                if (ok)
+                    this.finishUpgrade(req, socket, head);
+                else
+                    socket.destroy();
+            }).catch(() => { socket.destroy(); });
+            return;
+        }
+        if (!loopback) {
             socket.destroy();
             return;
         }
+        this.finishUpgrade(req, socket, head);
+    }
+    /** 围栏放行之后的实际握手（与上面的异步分支共用）。 */
+    finishUpgrade(req, socket, head) {
         if (!this.wsGateOpen) {
             socket.destroy();
             return;
@@ -1423,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 }        目标会话；
@@ -1512,6 +1879,10 @@ export class TtyServer {
             local: new Map(),
             owner: 'agent',
         });
+        // D72：agent 自己开的会话从出生起「什么都没读过」（水位线落在 seq 0）——
+        // 包括 `command` 型会话在第一次 expect 之前打印的启动输出。用户开的标签
+        // 相反：历史输出不算未读，首次被 agent 触达时才把水位线落在当下。
+        ensureReadMark(session);
         // 面板可见性：新会话推给所有已连接的面板（客户端据此建「agent 开的」标签）
         this.broadcastSessions();
         return { sid: session.id, persist: session.tmuxName !== null && !degraded };
@@ -1524,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();
@@ -1676,6 +2049,7 @@ export class TtyServer {
                 handle,
                 clients: new Map(),
                 closed: false,
+                exited: null,
                 paused: false,
                 owner,
                 cwd,
@@ -1684,6 +2058,10 @@ export class TtyServer {
                 startedAt: Date.now(),
                 lastOutputAt: Date.now(),
                 lastInputAt: Date.now(),
+                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)),
@@ -1740,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;
@@ -1809,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 未安装则降级
                 // 普通会话并回灰字提示。持久名稳定（客户端生成、随标签规格保存），
@@ -1869,7 +2256,7 @@ export class TtyServer {
                 send(ws, { t: 'ready', sid, pid: next.handle.pid, kind: 'local', ...(next.tmuxName !== null ? { persist: true } : {}) });
                 if (created.wantsPersist && created.degraded) {
                     const notice = '\x1b[2m[dsh-tty] 未检测到 tmux，本标签以普通会话运行；安装 tmux 后持久化标签可跨宿主重启恢复现场\x1b[0m\r\n';
-                    next.buffer = tailFromSafeBoundary(next.buffer + notice, BUFFER_CAP);
+                    appendOutput(next, notice);
                     send(ws, { t: 'data', sid, d: notice });
                 }
             }
@@ -1883,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);
@@ -1896,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);
@@ -1944,6 +2332,7 @@ export class TtyServer {
                         handle,
                         clients: new Map([[conn.id + ':' + sid, { ws, sid }]]),
                         closed: false,
+                        exited: null,
                         paused: false,
                         owner: 'user',
                         cwd: '',
@@ -1952,6 +2341,10 @@ export class TtyServer {
                         startedAt: Date.now(),
                         lastOutputAt: Date.now(),
                         lastInputAt: Date.now(),
+                        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)),
@@ -1980,7 +2373,7 @@ export class TtyServer {
                         this.trackPersist(tmuxName, true); // 留存：远程 tmux 本机清单看不到
                     if (handle.startupNotice !== undefined) {
                         const notice = `\x1b[2m[dsh-tty] ${handle.startupNotice}\x1b[0m\r\n`;
-                        next.buffer = tailFromSafeBoundary(next.buffer + notice, BUFFER_CAP);
+                        appendOutput(next, notice);
                         send(ws, { t: 'data', sid, d: notice });
                     }
                     this.attachOutput(next);
@@ -2014,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);
                 }
@@ -2024,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);
@@ -2044,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?.();
                 }
             }
@@ -2093,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) {
@@ -2143,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');
     }
@@ -2155,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) {
@@ -2219,7 +2631,7 @@ export class TtyServer {
             // StringDecoder 兜跨 chunk 多字节序列，再喂 shell 集成解析与虚拟屏
             const text = session.decoder.write(chunk);
             session.lastOutputAt = Date.now();
-            session.buffer = tailFromSafeBoundary(session.buffer + text, BUFFER_CAP);
+            appendOutput(session, text);
             feedShellIntegration(session, text);
             const screen = session.screen;
             if (screen !== null) {
@@ -2247,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 });
@@ -2335,8 +2754,7 @@ function readManagedEnvKeys() {
  * 值在任何分支都不进响应——SSH 对话框的选择器只需要「我存过哪些名字」。
  */
 export async function handleCredentialRefsRoute(req, res) {
-    if (!isLoopbackHttp(req)) {
-        writeJson(res, 403, { error: 'forbidden: loopback-only' });
+    if (!(await gateRoute(req, res))) {
         return;
     }
     if (req.method !== 'GET') {
@@ -2448,38 +2866,84 @@ function mergeSshSpec(findSshHost, name, inline) {
         password: typeof inline.password === 'string' && inline.password !== '' ? inline.password : profile?.password,
         agentForward: typeof inline.agentForward === 'boolean' ? inline.agentForward : profile?.agentForward ?? false,
     };
+    /*
+     * 跳板机：内联给了就以它为准（清洗不出可用对象则退回连接簿那一份），否则用连接簿的。
+     * `jump` 只在**目标那一跳**之外多一跳，不支持嵌套（单跳），所以这里不做递归解析。
+     */
+    const inlineJump = inline.jump === undefined ? undefined : sanitizeJumpSpec(inline.jump);
+    const jump = inlineJump ?? profile?.jump;
+    if (jump !== undefined)
+        spec.jump = jump;
+    /*
+     * 代理命令：与跳板机同款「内联优先、否则用连接簿那一份」。两者同时存在**不在这里二选一**：
+     * 优先关系（ProxyJump 优先）在拨号处 `attachSshTransport` 一处决定，并记 warn——否则
+     * 「配了代理命令却走了跳板机」会被这里静默掉。
+     */
+    const inlineProxyCommand = inline.proxyCommand === undefined ? undefined : sanitizeProxyCommand(inline.proxyCommand);
+    const proxyCommand = inlineProxyCommand ?? profile?.proxyCommand;
+    if (proxyCommand !== undefined)
+        spec.proxyCommand = proxyCommand;
     if (spec.host === '' || spec.username === '')
         return { error: 'SSH 会话需要 host 与 username（或用 name 引用连接簿）' };
     return { spec };
 }
-/** HTTP 路由的 loopback 信任围栏（与 dsh-mcp 同思路）。 */
-function isLoopbackHttp(req) {
-    const address = req.socket.remoteAddress;
-    if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1')
-        return false;
-    const host = req.headers.host;
-    if (typeof host !== 'string')
-        return false;
-    let hostUrl;
-    try {
-        hostUrl = new URL('http://' + host);
-    }
-    catch {
-        return false;
-    }
-    if (hostUrl.hostname !== '127.0.0.1' && hostUrl.hostname !== 'localhost' && hostUrl.hostname !== '[::1]')
-        return false;
-    if (req.headers['sec-fetch-site'] === 'cross-site')
+/*
+ * 回环围栏与同源证明：**实现已收敛到 `@hyzyn/dsh-kit`**（2026-09-25，项目级 ROADMAP 第 1
+ * 项）。本包此前那份只认 `127.0.0.1` 一个字面量的同步围栏已删除，改走 kit 的加固档
+ * （docker D31/D80/D110），并给变更端点补上同源证明（docker D32/D139）——成因与桌面版
+ * 例外（桌面壳转发会删掉 Origin / Sec-Fetch-Site，但必带宿主 Cookie）的唯一归宿在
+ * `packages/kit/src/http.ts`，这里只留指针。
+ */
+/**
+ * 数据路由的统一闸门（**导出仅供单测**）：回环围栏（加固档）+ 变更端点的同源证明。
+ * 十二处路由此前各抄一遍 403 样板，`mutation` 这条判据一加就会各写各的——收敛成一处后
+ * 「拒绝分支」只有一份，负例也只测这一份。
+ *
+ * 哪些是变更端点（`mutation: true`）——**判据是「这次请求会不会改状态」**：
+ *   - `POST /probe`：真的拨号，且连接簿条目测试会当场 TOFU 记录主机指纹；
+ *   - `POST /sftp/{mkdir,rename,remove,upload}`、`POST /local-fs/{mkdir,rename,remove,transfer}`：
+ *     写远端 / 写本机 / 起传输任务；
+ *   - `POST /config`**刻意不在其列**（与 docker 同口径）：它是插件被禁用后唯一的恢复入口
+ *     ——卡片靠它渲染、也是重新启用的唯一 UI 入口；跨站 POST 已由上面那条围栏的
+ *     `sec-fetch-site: cross-site` 与 Origin 比对拦住。
+ * 只读端点（GET 全家 + `sftp /list` `/download`、`local-fs /list`）维持 loopback-only：
+ * 它们读的是用户自己主动要的东西，读路由加证明只会把旧 Safari / 裸 curl 一起挡在门外。
+ *
+ * **WS upgrade 不走这里**（那是 socket 握手，不是 req/res 路由）：见 `handleUpgrade`
+ * 用的 `isLoopbackRequestStrict`——它自带「Origin 有则必须同源」这条判据，等价于给
+ * 升级请求也上了证明，但**刻意不放开 Cookie 例外**：长连的生命周期比一次 POST 长得多。
+ */
+export async function gateRoute(req, res, options) {
+    if (!(await isLoopbackRequestStrict(req))) {
+        writeJson(res, 403, { error: 'forbidden: loopback-only' });
         return false;
-    const origin = req.headers.origin;
-    if (origin === undefined)
-        return true;
-    try {
-        return new URL(origin).host === hostUrl.host;
     }
-    catch {
+    if (options?.mutation === true && !hasSameOriginProof(req)) {
+        writeJson(res, 403, { error: '缺少同源证明（需要 Origin 或 Sec-Fetch-Site: same-origin）：变更端点拒绝无来源请求' });
         return false;
     }
+    return true;
+}
+/** 变更动作的子路由（见 gateRoute 的判据）：前缀路由先取 sub、再连 mutation 一起过闸。 */
+const MUTATION_SUBROUTES = {
+    '/api/dsh-tty/sftp': new Set(['/mkdir', '/rename', '/remove', '/upload']),
+    '/api/dsh-tty/local-fs': new Set(['/mkdir', '/rename', '/remove', '/transfer']),
+    /*
+     * 就地提权：三条子路由**逐条**列（docker D144 的教训）——判据是「精确子路径 + POST」，
+     * 只写一条的话另外两条就是裸的（跨站页面能撤销授权、能反复对着确认挑战试错）。
+     */
+    '/api/dsh-tty/elevate': new Set(['', '/status', '/revoke']),
+};
+/**
+ * 这个前缀路由的子路径是否**会改状态**（导出仅供单测）。
+ *
+ * 为什么单独抽出来：`/list` 与 `/download` 也是 POST（凭证走 body、不进 URL），但它们只是
+ * 读——如果把「POST 就要求证明」一刀切下去，读路由会连带把旧 Safari / 裸 curl 挡在门外，
+ * 而它们本来就没有可被跨站利用的副作用。判据是**动作**不是**方法**，所以名单必须显式。
+ * 没见过的子路径一律 false（几步之后就是 404，不给它额外的信息量）。
+ */
+export function isMutationSubroute(prefix, sub) {
+    return MUTATION_SUBROUTES[prefix]?.has(sub) === true;
 }
 function writeJson(res, status, body) {
     res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'referrer-policy': 'no-referrer' });
@@ -2586,6 +3050,24 @@ const plugin = definePlugin({
     // 均拿不到，实测 mcp-client 同款模式），声明后 ctx.get('tools') 才能取到。
     inject: ['tools'],
     apply(ctx, rawConfig) {
+        /*
+         * 授权来源必须在**第一次 capabilityGranted 之前**绑定（见 kit 的 capability.ts）。两条通道：
+         *   ① 启动环境快照（最严档，只认继承来的 `process` 层）；
+         *   ② 就地提权（免重启）：卡片上点开关 → 宿主文件系统上落地一个随机名确认文件 → 授权写进
+         *      grant-store（HTTP 写不到）。落点全部来自 kit 的 `capabilityPaths`（路径只在那里拼一次）。
+         * 存储每次 apply 新建一个实例 —— 这就是「宿主重启后重新读盘」的语义。
+         */
+        const paths = capabilityPaths(resolveDshHome());
+        // **共享实例**（kit D11）：tty 与 docker 同装时各 new 一个会各自缓存一份文件快照，
+        // 后绑定的那个看不到另一个后来写进去的授权（实测：tty 授权成功后自己的快照仍是 false）
+        const grantStore = sharedGrantStore(paths.dir);
+        bindCapabilitySources(ctx, grantStore);
+        /*
+         * 启动期审计：盘上已有的带外授权是**持久**的（重启后直接生效、不再有任何一次确认），所以那次
+         * 「静默继承」必须在日志里留下痕迹（kit D09）。刻意放在 `enabled` 判定**之前**：授权是宿主级的，
+         * 与插件这次是否启用无关。
+         */
+        auditLoadedGrants(grantStore, [CAP_PROXY_COMMAND.env], { info: (msg) => ctx.logger.info(msg), warn: (msg) => ctx.logger.warn(msg) }, '[dsh-tty]');
         // volatile 字段解析后是 `{ get() }` 引用，先还原成纯数据（见 @hyzyn/dsh-kit 的 plainConfig）。
         const config = plainConfig((rawConfig ?? {}));
         if (config?.enabled === false)
@@ -2609,8 +3091,20 @@ const plugin = definePlugin({
             endOnPageClose: config?.endOnPageClose === true,
             statsEnabled: config?.statsEnabled !== false,
             sftpLimits: sanitizeSftpLimits(config?.sftpLimits),
+            allowProxyCommand: config?.allowProxyCommand === true,
             persistSessions: sanitizePersistSessions(config?.persistSessions) ?? [],
         });
+        /*
+         * 闸门在**挂载时先初始化一次**（tty D70）。
+         *
+         * 它的唯一写入方是 `applyPatch`，而 `applyPatch` 在启动期**只在「settings 里存过东西」时才跑**
+         * （见那里 `if (Object.keys(startup).length > 0)`）。于是「配置里写着 `allowProxyCommand: true`
+         * + 已授权（环境变量或授权文件）+ 重启宿主」这条最平常的路径会停在模块级默认值
+         * `{granted:false, enabled:false}` 上：fail-closed（不是安全问题），但症状正是本仓最忌讳的
+         * 「配了没反应」——卡片显示已授权，代理命令却仍被拒。这条在接入就地提权后才致命：授权是
+         * **持久**的，重启后更要保证「界面上说已授权」与「闸门真的放行」一致。
+         */
+        setProxyCommandPolicy({ granted: capabilityGranted(CAP_PROXY_COMMAND), enabled: live.allowProxyCommand });
         const sessions = new SessionManager(config?.maxSessions ?? DEFAULT_MAX_SESSIONS, () => live.endOnPageClose);
         /** TOFU 指纹记录持久化：写入 settings 命名空间（合并语义），失败不影响连接。 */
         const persistHostKeys = (records) => {
@@ -2672,6 +3166,18 @@ const plugin = definePlugin({
             endOnPageClose: live.endOnPageClose,
             statsEnabled: live.statsEnabled,
             sftpLimits: live.sftpLimits,
+            allowProxyCommand: live.allowProxyCommand,
+            allowProxyCommandGranted: capabilityGranted(CAP_PROXY_COMMAND),
+            /*
+             * 授权来源：'env' = 启动环境变量（界面不给「撤销」按钮，它只能靠改启动环境撤销）、
+             * 'file' = 就地确认写下的带外授权（界面可撤销）、null = 没授权。
+             */
+            allowProxyCommandGrantSource: capabilityGrantVia(CAP_PROXY_COMMAND) ?? null,
+            /*
+             * 授权时刻（Unix 秒；只有 file 通道有值）。授权是**持久**的：重启后它直接生效、不再确认，
+             * 界面至少要能说出它是什么时候来的（kit D09）。
+             */
+            allowProxyCommandGrantedAt: capabilityGrantAt(CAP_PROXY_COMMAND) ?? null,
             toolsRegistered: stateRef.toolsRegistered,
             /**
              * 宿主平台（`process.platform`）：客户端据此把「Shell 路径 / shell 集成」的说明与候选
@@ -2695,8 +3201,16 @@ const plugin = definePlugin({
                 endOnPageClose: typeof section.endOnPageClose === 'boolean' ? section.endOnPageClose : undefined,
                 statsEnabled: typeof section.statsEnabled === 'boolean' ? section.statsEnabled : undefined,
                 sftpLimits: typeof section.sftpLimits === 'object' && section.sftpLimits !== null ? section.sftpLimits : undefined,
+                allowProxyCommand: typeof section.allowProxyCommand === 'boolean' ? section.allowProxyCommand : undefined,
                 persistSessions: sanitizePersistSessions(section.persistSessions),
             });
+            /*
+             * ProxyCommand 闸门跟着 settings 走（**每次热应用都写一次**）：这一档是「设置字段驱动的
+             * 本机任意命令执行」，关掉之后必须**立刻**对四条建连路径全部生效（终端 / SFTP / 隧道 /
+             * 探针共用 ssh.ts 的模块级策略，见 setProxyCommandPolicy）。启动路径也走这里
+             * （settings 就绪时 applyPatch 会被调用一次），所以不存在「忘了初始化 → 意外为开」。
+             */
+            setProxyCommandPolicy({ granted: capabilityGranted(CAP_PROXY_COMMAND), enabled: live.allowProxyCommand });
             if (typeof section.enabled === 'boolean')
                 stateRef.enabled = section.enabled;
             if (typeof section.announceToAgent === 'boolean')
@@ -2717,12 +3231,12 @@ const plugin = definePlugin({
             server.setWsGate(stateRef.enabled);
             // 状态条开关热生效：关的时候停掉全部采集（本地定时器 + 远端 exec channel）
             server.setStatsEnabled(live.statsEnabled);
-            console.log(`[dsh-tty] config applied (shell=${live.shell}, term=${live.term}, cwd=${live.cwd}, maxSessions=${sessions.limitValue}, sshHosts=${live.sshHosts.length}, enabled=${String(stateRef.enabled)})`);
+            console.log(`[dsh-tty] config applied (shell=${live.shell}, term=${live.term}, cwd=${live.cwd}, maxSessions=${sessions.limitValue}, sshHosts=${live.sshHosts.length}, allowProxyCommand=${String(live.allowProxyCommand)}, enabled=${String(stateRef.enabled)})`);
         };
         /** 校验 HTTP POST 的配置体；返回规范化补丁或错误信息。 */
         const normalizePatch = (input) => {
             const patch = {};
-            const known = new Set(['enabled', 'announceToAgent', 'maxSessions', 'shell', 'term', 'colorTerm', 'cwd', 'reconnectGraceSec', 'sshHosts', 'hostKeys', 'tunnels', 'shellIntegration', 'sftpStyle', 'persistence', 'endOnPageClose', 'statsEnabled', 'sftpLimits']);
+            const known = new Set(['enabled', 'announceToAgent', 'maxSessions', 'shell', 'term', 'colorTerm', 'cwd', 'reconnectGraceSec', 'sshHosts', 'hostKeys', 'tunnels', 'shellIntegration', 'sftpStyle', 'persistence', 'endOnPageClose', 'statsEnabled', 'sftpLimits', 'allowProxyCommand']);
             for (const key of Object.keys(input)) {
                 if (!known.has(key))
                     return { error: '未知配置项: ' + key };
@@ -2774,6 +3288,19 @@ const plugin = definePlugin({
                     return { error: 'statsEnabled 必须是布尔值' };
                 patch.statsEnabled = input.statsEnabled;
             }
+            if (input.allowProxyCommand !== undefined) {
+                if (typeof input.allowProxyCommand !== 'boolean')
+                    return { error: 'allowProxyCommand 必须是布尔值' };
+                /*
+                 * **只能降不能升**：提权只认宿主侧的环境变量（进程启动时采样一次），HTTP 侧给 true
+                 * 一律驳回并说清怎么做。这不是「输入不合法」，而是「没获授权」——所以文案必须同时
+                 * 给出变量名与「要重启宿主」，否则用户会对着一个点不动的开关反复点。
+                 */
+                if (input.allowProxyCommand && !capabilityGranted(CAP_PROXY_COMMAND)) {
+                    return { error: capabilityDeniedMessage(CAP_PROXY_COMMAND, { inPlace: true }) };
+                }
+                patch.allowProxyCommand = input.allowProxyCommand;
+            }
             for (const key of ['shell', 'term', 'colorTerm']) {
                 if (input[key] === undefined)
                     continue;
@@ -2847,6 +3374,30 @@ const plugin = definePlugin({
             setCredentialResolver(credCtx.credentials ?? null);
             return () => { setCredentialResolver(null); };
         });
+        /*
+         * 就地提权（见 kit 的 elevation.ts）：卡片上点开关 → 宿主在确认目录里等一个随机名文件出现
+         * → 授权写进 grant-store。
+         *
+         * `onGrantChange` 是这一段里**最容易漏、也最要紧**的一下：`setProxyCommandPolicy` 是终端 /
+         * SFTP / 隧道 / 探针**四条建连路径共用**的模块级闸门，只写存储不重算就会留下两种半个状态——
+         *   - 授权侧：授权到了，代理命令仍然被拒（用户以为没生效，再去点开关）；
+         *   - 撤销侧：记录没了，本机仍在跑连接簿里那条命令（这一侧是安全问题，不是体验问题）。
+         * `applyPatch({})` 用当前 live 兜底重算一次即可（它本来就每次都写一次策略，见那里的注释）。
+         */
+        const elevation = createElevationManager({
+            confirmDir: paths.confirmDir,
+            store: grantStore,
+            logger: { info: (msg) => ctx.logger.info(msg), warn: (msg) => ctx.logger.warn(msg) },
+            logPrefix: '[dsh-tty]',
+            onGrantChange: () => {
+                applyPatch({});
+            },
+        });
+        ctx.effect(() => {
+            return () => {
+                elevation.dispose();
+            };
+        }, 'dsh-tty: elevation cleanup');
         // webServer：WS upgrade 路由 + 配置读写路由（/api/dsh-tty/config）
         ctx.inject(['webServer'], (webCtx) => {
             webCtx.effect(() => {
@@ -2873,8 +3424,7 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/config',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method === 'GET') {
@@ -2913,13 +3463,74 @@ const plugin = definePlugin({
                         writeJson(res, 200, { ok: true, config: snapshot() });
                     },
                 }));
-                // ~/.ssh/config 导入候选（连接簿）：loopback 围栏，只回解析结果不落盘
+                /*
+                 * 就地提权（`/elevate`、`/elevate/status`、`/elevate/revoke`）。
+                 *
+                 * 三条**全 POST**、**逐条**进 MUTATION_SUBROUTES（判据是「精确子路径 + POST」，只写一条
+                 * 另外两条就是裸的 → docker D144），且分发必须在证明检查**之后**——`sub` 一旦拿去分支，
+                 * 后面再补证明就晚了。
+                 *
+                 * 刻意**不走** registerGated：授权是宿主级的，插件当前禁用时也该能在卡片里提权/撤销
+                 * （卡片本身是禁用后唯一的恢复入口，与 /config 同一条理由）。
+                 */
+                disposers.push(webServer.register({
+                    kind: 'prefix',
+                    path: '/api/dsh-tty/elevate',
+                    handler: async (req, res) => {
+                        const sub = new URL(req.url ?? '/', 'http://loopback').pathname.slice('/api/dsh-tty/elevate'.length);
+                        if (!(await gateRoute(req, res, { mutation: isMutationSubroute('/api/dsh-tty/elevate', sub) }))) {
+                            return;
+                        }
+                        if (req.method !== 'POST') {
+                            writeJson(res, 405, { error: 'method not allowed: ' + String(req.method) });
+                            return;
+                        }
+                        if (sub !== '' && sub !== '/status' && sub !== '/revoke') {
+                            writeJson(res, 404, { error: 'not found' });
+                            return;
+                        }
+                        const body = await readJsonBody(req);
+                        if (body === undefined) {
+                            writeJson(res, 400, { error: 'invalid JSON body' });
+                            return;
+                        }
+                        // 白名单：别让请求方决定查哪个键（那张表是宿主侧的策略来源）
+                        if (body.capability !== undefined && body.capability !== CAP_PROXY_COMMAND.env) {
+                            writeJson(res, 400, { error: '未知能力: ' + String(body.capability) });
+                            return;
+                        }
+                        if (sub === '/status') {
+                            writeJson(res, 200, elevation.status(CAP_PROXY_COMMAND.env));
+                            return;
+                        }
+                        if (sub === '/revoke') {
+                            // 降权零门槛：撤销不要求任何确认（紧急刹车不等重启）。撤销带来的策略重算由
+                            // elevation 的 onGrantChange 负责——不重算就会留下「记录没了、本机还在跑命令」
+                            writeJson(res, 200, { revoked: elevation.revoke(CAP_PROXY_COMMAND.env) });
+                            return;
+                        }
+                        const result = elevation.begin(CAP_PROXY_COMMAND.env);
+                        if (result.status === 'rate-limited') {
+                            writeJson(res, 429, { error: '请求过于频繁，请稍后再试', retryAfterMs: result.retryAfterMs });
+                            return;
+                        }
+                        if (result.status === 'error') {
+                            writeJson(res, 500, { error: result.error });
+                            return;
+                        }
+                        // 只回状态与一次性命令；nonce 就在命令里，**不进日志**（见 elevation.ts 的不变量）
+                        writeJson(res, 200, result);
+                    },
+                }));
+                // ~/.ssh/config 导入候选（连接簿）：loopback 围栏，只回解析结果不落盘。
+                // 除了候选，还**如实回报丢弃了什么**（依赖跳板机 / 通配 / 无 User / 超上限）：
+                // 静默少列是本仓反复出现的一类缺陷，而「导进来的条目注定连不上」更难排——见
+                // 项目级 ROADMAP 第 2 项。
                 registerGated({
                     kind: 'exact',
                     path: '/api/dsh-tty/ssh-config',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method !== 'GET') {
@@ -2928,7 +3539,7 @@ const plugin = definePlugin({
                         }
                         try {
                             const text = readFileSync(expandHome('~/.ssh/config'), 'utf8');
-                            writeJson(res, 200, { ok: true, entries: parseSshConfig(text) });
+                            writeJson(res, 200, { ok: true, ...parseSshConfigDetailed(text) });
                         }
                         catch (error) {
                             writeJson(res, 200, { ok: false, error: '无法读取 ~/.ssh/config: ' + (error instanceof Error ? error.message : String(error)) });
@@ -2940,8 +3551,7 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/env-vars',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method !== 'GET') {
@@ -2965,8 +3575,7 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/known-hosts',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method !== 'GET') {
@@ -2994,8 +3603,8 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/probe',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        // 变更端点：这次请求真的拨号，且连接簿条目测试会当场记录主机指纹（TOFU）
+                        if (!(await gateRoute(req, res, { mutation: true }))) {
                             return;
                         }
                         if (req.method !== 'POST') {
@@ -3024,6 +3633,22 @@ const plugin = definePlugin({
                         }
                         const auth = body.auth === 'key' || body.auth === 'password' ? body.auth : 'agent';
                         const spec = { host, port, username, auth };
+                        // 对话框「试连」可能带跳板机（连接簿条目由客户端先行展开；跳板机同理）
+                        const probeJump = validateJumpSpec(body.jump);
+                        if (body.jump !== undefined && probeJump.error !== undefined) {
+                            writeJson(res, 200, { ok: false, error: probeJump.error });
+                            return;
+                        }
+                        if (probeJump.jump !== undefined)
+                            spec.jump = probeJump.jump;
+                        // 代理命令同理（对话框试连会带上当前填写值）：形状非法就明确报错，别静默当没填
+                        const probeProxy = validateProxyCommand(body.proxyCommand ?? '');
+                        if (probeProxy.error !== undefined) {
+                            writeJson(res, 200, { ok: false, error: probeProxy.error });
+                            return;
+                        }
+                        if (probeProxy.proxyCommand !== undefined)
+                            spec.proxyCommand = probeProxy.proxyCommand;
                         if (auth === 'key') {
                             const keyPath = typeof body.keyPath === 'string' ? body.keyPath.trim() : '';
                             if (keyPath === '') {
@@ -3056,8 +3681,7 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/shells',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method !== 'GET') {
@@ -3072,8 +3696,7 @@ const plugin = definePlugin({
                     kind: 'exact',
                     path: '/api/dsh-tty/tunnels',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        if (!(await gateRoute(req, res))) {
                             return;
                         }
                         if (req.method !== 'GET') {
@@ -3093,11 +3716,11 @@ const plugin = definePlugin({
                     kind: 'prefix',
                     path: '/api/dsh-tty/sftp',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        const sub = new URL(req.url ?? '/', 'http://loopback').pathname.slice('/api/dsh-tty/sftp'.length);
+                        // 改状态的三个动作 + 上传要同源证明；/list 与 /download 只读（判据见 gateRoute）
+                        if (!(await gateRoute(req, res, { mutation: isMutationSubroute('/api/dsh-tty/sftp', sub) }))) {
                             return;
                         }
-                        const sub = new URL(req.url ?? '/', 'http://loopback').pathname.slice('/api/dsh-tty/sftp'.length);
                         const jsonAction = ['/list', '/mkdir', '/rename', '/remove', '/download'].find((action) => action === sub);
                         if (jsonAction !== undefined) {
                             if (req.method !== 'POST') {
@@ -3253,11 +3876,11 @@ const plugin = definePlugin({
                     kind: 'prefix',
                     path: '/api/dsh-tty/local-fs',
                     handler: async (req, res) => {
-                        if (!isLoopbackHttp(req)) {
-                            writeJson(res, 403, { error: 'forbidden: loopback-only' });
+                        const sub = new URL(req.url ?? '/', 'http://loopback').pathname.slice('/api/dsh-tty/local-fs'.length);
+                        // 改状态的四个动作（含起一个传输任务）要同源证明；/list 只读（判据见 gateRoute）
+                        if (!(await gateRoute(req, res, { mutation: isMutationSubroute('/api/dsh-tty/local-fs', sub) }))) {
                             return;
                         }
-                        const sub = new URL(req.url ?? '/', 'http://loopback').pathname.slice('/api/dsh-tty/local-fs'.length);
                         if (req.method !== 'POST') {
                             writeJson(res, 405, { error: 'method not allowed: ' + String(req.method) });
                             return;
@@ -3458,7 +4081,9 @@ const plugin = definePlugin({
                     }
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_list',
-                        description: '列出当前活跃的终端面板会话（sid / kind(local|ssh) / target / pid / cwd / 创建与最后活动时间）。用户开了终端面板后，用 tty_capture 读取某个 sid 的终端输出，用 tty_send 向该终端发送按键。',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
+                        description: '列出当前终端面板会话（sid / kind(local|ssh) / target / pid / cwd / 创建与最后活动时间），**含进程已退出但仍只读保留着的会话**（带 exited:true + 退出码/信号；按时间释放时另带 retainMs）：用户开了终端面板后，用 tty_capture 读取某个 sid 的输出、用 tty_send 向该会话发送按键。已退出的会话只能读（写会报错），要接着操作请 tty_open 新开一条。',
                         parameters: {},
                         output: {
                             schema: {
@@ -3481,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: '只读保留的剩余毫秒；省略 = 不按时间释放' },
                                             },
                                         },
                                     },
@@ -3489,26 +4118,33 @@ 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 }];
                             },
                         },
                         async execute() {
+                            // D72：agent 第一次「看见」这些会话时把水位线落在当下——否则第一次
+                            // tty_expect 会把用户早先的历史输出当成「还没读过的输出」回扫过来
+                            sessions.forEach((session) => { ensureReadMark(session); });
                             return { sessions: sessions.list() };
                         },
                     })));
                     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 语法整体**执行（`cd dir && cmd`、`a; b`、`for …; do …; done` 都可以，D78：旧版本里 `exec` 包装只跑第一条）；**它跑完退出后会话不会立刻消失**：会转成只读保留（留到显式关闭，最多留 8 条），退出前最后的输出与退出码都还能用 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）' },
@@ -3540,7 +4176,7 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_close',
-                        description: '关闭一个由 tty_open 开的终端会话（结束其中的进程）。**只能关 agent 自己开的会话**：用户在面板里开的标签会被拒绝，请让用户自己在面板里关，不要越权结束用户正在用的终端。',
+                        description: '关闭一个由 tty_open 开的终端会话（结束其中的进程）。**只能关 agent 自己开的会话**：用户在面板里开的标签会被拒绝，请让用户自己在面板里关，不要越权结束用户正在用的终端。对**进程已退出但仍只读保留着**的会话同样可用——那就是它的释放入口（把屏与缓冲还回去）。只读保留默认留到显式关闭（宿主重启也会清空），不按时间释放；同时最多留 8 条，超出按最旧淘汰。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（tty_open 或 tty_list 提供）' },
                         },
@@ -3564,6 +4200,8 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_stats',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
                         description: '读取某个终端会话所在机器的实时指标（CPU / 内存 / 磁盘 / TCP 连接数 / 网速 / 温度 / 在线时长）——本地会话取宿主机，SSH 会话取那台远程主机（另开一条非 PTY 通道，不影响终端）。部署、压测、排查「机器是不是满了」之前先看它。仅 Linux 远端字段齐全，Windows 远端部分字段可采，macOS/BSD 远端取不到。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（tty_list 提供）' },
@@ -3616,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 ?? '未知原因' };
@@ -3625,7 +4268,9 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tty_capture',
-                        description: '读取某个终端面板会话（tty_list 提供 sid）的近期输出。默认读取尾部 N 行（60，最多 500，已剥离 ANSI 转义序列并收敛同行覆盖）；last:true 时只返回「上一条已完成命令」的输出与退出码（依赖 shell 集成标记，更适合拿单条命令的结果）——若命令在途（刚发送/未收到完成标记）返回 inProgress:true 且不携带旧结果，请稍后重试或改用 tty_expect。',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
+                        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 时忽略' },
@@ -3642,6 +4287,8 @@ const plugin = definePlugin({
                                     source: { type: 'string' },
                                     exitCode: { type: 'number' },
                                     inProgress: { type: 'boolean' },
+                                    exited: { type: 'boolean' },
+                                    signal: { type: 'string' },
                                 },
                             },
                             render: (_args, value) => {
@@ -3652,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) {
@@ -3663,6 +4314,15 @@ 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 刻意**不**推进：它是「当前可见屏幕」这一种表示，不是
+                            // 文本流，推进它会把 AI 从未在文本里看过的输出标记成已读。
+                            advanceReadMark(session);
                             if (input.last === true) {
                                 const state = session.shellState;
                                 const last = state.lastCommand;
@@ -3680,16 +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',
-                        description: '读取某个终端面板会话（tty_list 提供 sid）当前可见屏幕的渲染结果（纯文本，等价于用户此刻看到的画面）。适合查看全屏交互程序（vim / htop / 菜单选择）的当前界面状态；要历史滚动输出用 tty_capture。',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
+                        description: '读取某个终端面板会话（tty_list 提供 sid）当前可见屏幕的渲染结果（纯文本，等价于用户此刻看到的画面）。适合查看全屏交互程序（vim / htop / 菜单选择）的当前界面状态；要历史滚动输出用 tty_capture。**进程已退出的会话也能读**（结果带 exited:true）：屏在只读保留期内不释放，读到的就是它退出那一刻的画面。',
                         parameters: {
                             sid: { type: 'string', required: true, description: '会话 id（来自 tty_list）' },
                         },
@@ -3702,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) {
@@ -3730,12 +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',
-                        description: '在某个终端面板会话（tty_list 提供 sid）的后续输出中等待一个正则出现（如 dev server 的 ready/URL、构建完成标记、交互提示）。匹配到立即返回 matched:true 与周边输出；超时不抛错，返回 matched:false + 尾部输出供判断重试或放弃；期间该命令若已结束（shell 集成标记）也会提前返回并带退出码。适合先 tty_send 启动长任务、再 tty_expect 等就绪信号的流程。',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
+                        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 语法）' },
@@ -3750,12 +4432,31 @@ const plugin = definePlugin({
                                     timedOut: { type: 'boolean', required: true },
                                     text: { type: 'string', required: true },
                                     exitCode: { type: 'number' },
+                                    matchedFrom: { type: 'string' },
+                                    echoOnly: { type: 'boolean' },
+                                    exited: { type: 'boolean' },
                                 },
                             },
                             render: (_args, value) => {
                                 const v = value;
-                                if (v.matched === true)
-                                    return [{ type: 'text', text: `已匹配到等待的模式：\n\n${v.text ?? ''}` }];
+                                if (v.matched === true) {
+                                    const from = v.matchedFrom === 'last'
+                                        ? '（回溯自「上一条命令」的输出）'
+                                        : 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} 复核那条命令的输出与退出码，别把这段空白当成「没执行」。' }];
+                                }
                                 const why = v.timedOut === true ? '等待超时' : `命令已结束（exitCode=${String(v.exitCode ?? '?')}）但未出现匹配`;
                                 return [{ type: 'text', text: `${why}。尾部输出：\n\n${v.text ?? ''}` }];
                             },
@@ -3787,48 +4488,93 @@ const plugin = definePlugin({
                             expectCounts.set(session, inflight + 1);
                             return await new Promise((resolve) => {
                                 const startedAt = Date.now();
-                                const startedInCommand = session.shellState.inCommand;
+                                const state = session.shellState;
+                                const startedInCommand = state.inCommand;
                                 // 尾部窗口：匹配只看最近 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;
-                                const finish = (result) => {
+                                /**
+                                 * 结算时的水位线（D72）：
+                                 *  - 匹配成功 / 会话结束 → 推进到当下（这段输出已经交回给 AI 了）；
+                                 *  - **超时不动**：那次只把注册之后的增量交回去，注册前就在缓冲里的
+                                 *    未读输出没被读过，而且下一次换个 pattern 还要靠它回溯——吞掉
+                                 *    它等于「等一次没等到，这段输出就作废了」。
+                                 */
+                                const finish = (result, consumeBacklog = true) => {
                                     if (settled)
                                         return;
                                     settled = true;
-                                    clearTimeout(timer);
+                                    if (timer !== null)
+                                        clearTimeout(timer);
                                     output.off('data', onData);
                                     expectCounts.set(session, Math.max(0, (expectCounts.get(session) ?? 1) - 1));
+                                    if (consumeBacklog)
+                                        advanceReadMark(session);
                                     resolve(result);
                                 };
+                                // 箭头函数（不是 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 (re.test(hay)) {
-                                        finish({ matched: true, timedOut: false, text: cleanAnsiTail(hay.slice(-6 * 1024)) });
-                                        return;
+                                    if (testPattern(re, hay)) {
+                                        // 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 已到仍未匹配
-                                    const state = session.shellState;
                                     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)) });
                                     }
                                 };
-                                const timer = setTimeout(() => {
-                                    finish({ matched: false, timedOut: true, text: cleanAnsiTail(acc.slice(-6 * 1024)) });
+                                // ── 注册**之前**就已到达的输出（D72）─────────────────────────
+                                // 这段此前完全不匹配：acc 从空开始，所以「命令瞬间完成」时标记
+                                // 早就躺在缓冲区里、acc 里永远没有它 → 白等满超时、还只返回空白。
+                                ensureReadMark(session);
+                                // ① 上一条命令的完整输出（B..D 窗口：无回显、无提示符、自带退出码）。
+                                //    两个闸门保证它「还没被读过」：不晚于最后一次输入（否则是上一条
+                                //    命令的旧结果），且晚于水位线时刻（否则 AI 已经用 capture 看过了）。
+                                const last = state.lastCommand;
+                                if (!state.inCommand && last !== null && last.endedAt > session.readMarkAt && last.endedAt >= session.lastInputAt && testPattern(re, last.output)) {
+                                    finish({ matched: true, timedOut: false, matchedFrom: 'last', ...(last.exitCode === null ? {} : { exitCode: last.exitCode }), text: cleanAnsiTail(last.output.slice(-6 * 1024)) });
+                                    return;
+                                }
+                                // ② 泛化：水位线之后的未读缓冲（长驻输出落在多条命令之间、无 shell 集成……）
+                                const backlog = unreadRegion(session);
+                                if (backlog !== '' && testPattern(re, backlog)) {
+                                    // 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, ...(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: '要发送的文本（含换行则直接发送命令）' },
@@ -3856,13 +4602,27 @@ 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();
-                            await session.handle.write(input.data);
-                            return { ok: true, sent: input.data.length };
+                            // D72：只初始化水位线，**不推进**——刚发出去的这条命令的输出 AI 还没看见；
+                            // 但这一刻之前的积压不该被第一次 expect 当成「未读」回扫。
+                            ensureReadMark(session);
+                            // D75：记下这行命令的回显候选，供 tty_expect 剔除「命中回显」的假阳性
+                            noteSubmittedInput(session, data);
+                            await session.handle.write(data);
+                            return { ok: true, sent: data.length };
                         },
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'tunnel_list',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
                         description: '列出端口转发隧道及其实时状态（活跃/连接中/错误/停止、规则、当前与累计连接数、最近错误）。用户说「隧道连不上 / 转发挂了 / 端口转发不通」时先用它诊断；隧道在 插件配置 → 终端面板 卡片维护。',
                         parameters: {},
                         output: {
@@ -3941,6 +4701,8 @@ const plugin = definePlugin({
                     };
                     activeDisposers.push(tools.register(defineTool({
                         name: 'sftp_list',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
                         description: '列出 SSH 远程目录内容（名称/类型/大小/修改时间，目录在前；isSymlink 区分符号链接与真目录）。book 为 SSH 连接簿条目名；path 缺省为远程登录 home。默认最多列 500 项（超限 truncated:true，可按子目录分批）。',
                         parameters: {
                             book: { type: 'string', required: true, description: 'SSH 连接簿条目名（插件配置 → 终端面板 维护）' },
@@ -3992,6 +4754,8 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'sftp_read',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
                         description: '读取 SSH 远程文本文件（book 连接簿条目 + path）。默认最多 256KB（可调至 1MB，非法值直接报错）；offset 可从指定字节起读（配合 maxBytes 分页拿到大文件尾部）；二进制判定用 NUL + 非法 UTF-8 占比双重检测，拒绝时说明原因。',
                         parameters: {
                             book: { type: 'string', required: true, description: 'SSH 连接簿条目名' },
@@ -4199,6 +4963,8 @@ const plugin = definePlugin({
                     })));
                     activeDisposers.push(tools.register(defineTool({
                         name: 'sftp_tree',
+                        // 只读工具：与同轮其它工具并发执行（宿主默认把未声明的工具当独占，见项目级 ROADMAP 第 4 项）
+                        isConcurrencySafe: () => true,
                         description: '递归列举 SSH 远程目录结构（book 连接簿条目 + path）：深度优先、目录优先，maxDepth（1~8，默认 3）限层、maxEntries（1~2000，默认 500）限条数，超限 truncated:true；符号链接不跟随；读取失败的子目录列入 errors。适合先看远程项目结构再定位文件。',
                         parameters: {
                             book: { type: 'string', required: true, description: 'SSH 连接簿条目名' },
@@ -4325,12 +5091,26 @@ const plugin = definePlugin({
                         text: () => {
                             const list = sessions.list();
                             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 自己开一个，或引导用户打开「终端」面板）。';
+                            // D77：只读保留态（进程已退出）**不能冒充活会话**——模型会以为那个长驻
+                            // 任务还在跑、或者对它发命令。这里把两者分开：活会话逐条列，保留态压成
+                            // 一行汇总（每轮 prompt 的增量是常数，不随条数线性膨胀）。
+                            const live = list.filter((s) => s.exited !== true);
+                            const gone = list.filter((s) => s.exited === true);
+                            const head = live.length === 0
+                                ? '当前没有活着的终端面板会话。'
+                                : '当前活跃的终端面板会话（可用 tty_capture / tty_screen / tty_expect / tty_send 操作，用 tty_open / tty_close 开关，sid 如下）：\n' + live.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;
                         },
                     });
                     sectionDisposable = systemPrompt.section({ name: 'plugin:dsh-tty', order: 150, text: TTY_GUIDANCE });
@@ -4362,6 +5142,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');