@hyzyn/dsh-tty 0.9.0 → 0.10.1

package/lib/index.js

@@ -20,6 +20,7 @@ import { parseSshConfig } from './ssh-config.js';
 import { parseKnownHosts } from './known-hosts.js';
 import { TunnelManager } from './tunnels.js';
 import { SftpManager } from './sftp.js';
+import { buildTmuxSpawnPlan, ensureTmuxAssets, killTmuxSession, listTmuxSessions, probeTmux, refreshTmuxClient, sanitizePersistName } from './tmux.js';
 const SSH_HOST_SCHEMA = z.object({
     name: z.string(),
     host: z.string(),
@@ -30,6 +31,8 @@ const SSH_HOST_SCHEMA = z.object({
     passphrase: z.string().default(''),
     password: z.string().default(''),
     agentForward: z.boolean().default(false),
+    /** 该条目的 SSH 标签默认以 tmux 持久会话打开（仅 persistence=tmux 时生效）。 */
+    persist: z.boolean().default(false),
 });
 const HOST_KEY_SCHEMA = z.object({
     host: z.string(),
@@ -62,6 +65,9 @@ const TTY_SETTINGS_SCHEMA = z.object({
     tunnels: z.array(TUNNEL_SCHEMA).default([]),
     shellIntegration: z.boolean().default(true),
     sftpStyle: z.union([z.const('dialog'), z.const('dual')]).default('dialog'),
+    persistence: z.union([z.const('off'), z.const('tmux')]).default('off'),
+    endOnPageClose: z.boolean().default(false),
+    persistSessions: z.array(z.object({ tmuxName: z.string() })).default([]),
 });
 /* ------------------------------------------------------------------ *
  * 常量
@@ -79,7 +85,7 @@ const BUFFER_CAP = 256 * 1024;
 const TERM_RE = /^[A-Za-z0-9_.+-]+$/;
 /** 孤儿会话回收器的扫描间隔。 */
 const REAPER_INTERVAL_MS = 10_000;
-const TTY_GUIDANCE = '本机已安装 dsh-tty 插件（终端面板）：Web GUI 侧边栏的「终端」入口可打开交互终端（xterm.js + PTY），可运行任意命令与 TUI 程序（vim/htop 等），支持多标签页与断线自动重连（刷新页面/网络抖动后会话保活并恢复现场）；新标签默认在当前会话工作目录打开。标签栏「+」菜单还能开 SSH 标签页（ssh2 原生连接，连接簿在设置卡片维护，支持 agent forwarding 与主机指纹 TOFU 钉扎），像本地终端一样操作远程主机。长驻进程（dev server、watch、交互式程序）应引导用户到终端面板里运行，不要在 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 钉扎），像本地终端一样操作远程主机。设置卡片开启「会话持久化（tmux）」后，新开的本地/SSH 标签默认由 tmux server 托管（宿主重启/断线超时后重开即恢复现场），长任务建议在持久化开启时运行。长驻进程（dev server、watch、交互式程序）应引导用户到终端面板里运行，不要在 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;
@@ -131,6 +137,12 @@ class LiveConfig {
     shellIntegration;
     /** 端口转发隧道规格。 */
     tunnels;
+    /** 会话持久化模式（off / tmux）。 */
+    persistence;
+    /** 页面断开且保活期结束时是否结束 tmux 持久会话（默认 false = 留存）。 */
+    endOnPageClose;
+    /** SSH 持久会话名（远程 tmux 托管；本机 socket 清单看不到，随 settings 留存）。 */
+    persistSessions;
     constructor(init) {
         this.shell = init.shell;
         this.term = sanitizeTermValue(init.term, 'xterm-256color');
@@ -141,6 +153,9 @@ class LiveConfig {
         this.hostKeys = init.hostKeys ?? [];
         this.shellIntegration = init.shellIntegration;
         this.tunnels = init.tunnels ?? [];
+        this.persistence = init.persistence === 'tmux' ? 'tmux' : 'off';
+        this.endOnPageClose = init.endOnPageClose === true;
+        this.persistSessions = init.persistSessions ?? [];
     }
     /** 合并部分更新；空字符串/undefined 保持原值；sshHosts/hostKeys/tunnels 传数组即整体替换。 */
     apply(partial) {
@@ -163,6 +178,12 @@ class LiveConfig {
             this.shellIntegration = partial.shellIntegration;
         if (Array.isArray(partial.tunnels))
             this.tunnels = partial.tunnels;
+        if (partial.persistence === 'tmux' || partial.persistence === 'off')
+            this.persistence = partial.persistence;
+        if (typeof partial.endOnPageClose === 'boolean')
+            this.endOnPageClose = partial.endOnPageClose;
+        if (Array.isArray(partial.persistSessions))
+            this.persistSessions = partial.persistSessions;
     }
     findSshHost(name) {
         return this.sshHosts.find((entry) => entry.name === name);
@@ -207,8 +228,11 @@ function cleanAnsiTail(raw) {
         return idx === -1 ? line : line.slice(idx + 1);
     }).join('\n');
 }
-/** OSC 133 命令标记帧：\x1b]133;<A|B|D>[;<exit>](BEL|ST)。 */
-const OSC133_RE = /\x1b\]133;([ABDC])(?:;(\d+))?(?:\x07|\x1b\\)/g;
+/** OSC 133 命令标记帧：\x1b]133;<A|B|D|T>[;<payload>](BEL|ST)。
+ * T（0.10.0）= tmux 持久标签的 pane 内容快照（base64）：tmux 的 pane 重画是
+ * 异步批量的，命令输出会落在 D 标记之后逃出 B..D 捕获窗口，故由钩子在发 D
+ * 前 capture-pane 随流直送，宿主优先采用。 */
+const OSC133_RE = /\x1b\]133;([ABDCT])(?:;([^\x07\x1b]*))?(?:\x07|\x1b\\)/g;
 /** OSC 7 cwd 上报帧：\x1b]7;file://<host><path>(BEL|ST)。 */
 const OSC7_RE = /\x1b\]7;([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
 /** 单条命令输出捕获上限（环形，超出丢头部）。 */
@@ -218,7 +242,14 @@ const FLUSH_INTERVAL_MS = 12;
 /** 待发输出超过该字符数时跳过窗口立即冲刷（防超长输出无限延迟）。 */
 const FLUSH_SIZE_CHARS = 64 * 1024;
 function createShellState() {
-    return { carry: '', inCommand: false, cmdBuffer: '', lastCommand: null };
+    return { carry: '', inCommand: false, cmdBuffer: '', pendingT: null, lastCommand: null };
+}
+/** OSC 133;T 的 base64 payload → utf8 文本（无效输入返回 null）。 */
+function decodeBase64Utf8(payload) {
+    if (payload === undefined || payload === '')
+        return null;
+    const text = Buffer.from(payload, 'base64').toString('utf8');
+    return text !== '' ? text : null;
 }
 /** OSC 7 body（file://host/path）→ 解码后的路径；解析失败返回 undefined。 */
 function osc7Path(body) {
@@ -248,11 +279,11 @@ function feedShellIntegration(session, text) {
     if (lastOpen !== -1) {
         const tail = data.slice(lastOpen);
         if (!/\x07|\x1b\\/.test(tail)) {
-            if (tail.length <= 512) {
+            if (tail.length <= 64 * 1024) {
                 state.carry = tail;
                 data = data.slice(0, lastOpen);
             }
-            // 超过 512B 仍不闭合视为垃圾：放弃扣留，整块照常处理
+            // 超过 64KB 仍不闭合视为垃圾：放弃扣留，整块照常处理（上限容纳 T 快照）
         }
     }
     for (const match of data.matchAll(OSC7_RE)) {
@@ -271,17 +302,22 @@ function feedShellIntegration(session, text) {
         if (kind === 'B') {
             state.inCommand = true;
             state.cmdBuffer = '';
+            state.pendingT = null;
+        }
+        else if (kind === 'T') {
+            state.pendingT = decodeBase64Utf8(match[2]);
         }
         else if (kind === 'D') {
             if (state.inCommand) {
-                const exitCode = match[2] !== undefined ? Number(match[2]) : null;
+                const exitCode = match[2] !== undefined && /^\d+$/.test(match[2]) ? Number(match[2]) : null;
                 state.lastCommand = {
-                    output: state.cmdBuffer.slice(-COMMAND_CAP),
+                    output: (state.pendingT ?? state.cmdBuffer).slice(-COMMAND_CAP),
                     exitCode: exitCode !== null && Number.isFinite(exitCode) ? exitCode : null,
                     endedAt: Date.now(),
                 };
                 state.inCommand = false;
                 state.cmdBuffer = '';
+                state.pendingT = null;
             }
         }
         // A（prompt 开始）无需记录
@@ -400,6 +436,7 @@ function sanitizeSshHosts(input) {
             passphrase: typeof raw.passphrase === 'string' ? raw.passphrase : '',
             password: typeof raw.password === 'string' ? raw.password : '',
             agentForward: raw.agentForward === true,
+            persist: raw.persist === true,
         });
     }
     return out;
@@ -435,6 +472,9 @@ function validateSshHosts(input) {
         if (raw.agentForward !== undefined && typeof raw.agentForward !== 'boolean') {
             return { error: 'sshHosts.agentForward 必须是布尔值' };
         }
+        if (raw.persist !== undefined && typeof raw.persist !== 'boolean') {
+            return { error: 'sshHosts.persist 必须是布尔值' };
+        }
         if ((raw.auth === 'key') && (typeof raw.keyPath !== 'string' || raw.keyPath.trim() === '')) {
             return { error: `sshHosts「${String(raw.name)}」auth=key 需要 keyPath` };
         }
@@ -486,6 +526,20 @@ function validateHostKeys(input) {
     }
     return { keys: sanitizeHostKeys(input) };
 }
+/** 宽松清洗一份 persistSessions（内部状态：SSH 持久会话名）；非法条目丢弃。 */
+function sanitizePersistSessions(input) {
+    if (!Array.isArray(input))
+        return undefined;
+    const out = [];
+    for (const item of input) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const name = item.tmuxName;
+        if (typeof name === 'string' && /^dsh-[A-Za-z0-9_-]{1,64}$/.test(name) && !out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
 /**
  * TOFU 主机指纹存储：get/record 面向 spawnSsh 的 hostVerifier；
  * record 时经 persist 回调写入 settings（宿主重启后钉扎仍在）。
@@ -547,8 +601,12 @@ function isLoopbackUpgrade(req) {
 class SessionManager {
     sessions = new Map();
     limit;
-    constructor(maxSessions) {
+    /** 回收器销毁孤儿时是否连 tmux 持久会话一起结束（endOnPageClose 策略）。 */
+    endTmuxOnReap = () => false;
+    constructor(maxSessions, endTmuxOnReap) {
         this.limit = maxSessions;
+        if (endTmuxOnReap !== undefined)
+            this.endTmuxOnReap = endTmuxOnReap;
     }
     get limitValue() {
         return this.limit;
@@ -572,7 +630,7 @@ class SessionManager {
     get(id) {
         return this.sessions.get(id);
     }
-    /** 会话的只读快照（SSH 会话无本地 pid，该字段省略）。 */
+    /** 会话的只读快照（SSH 会话无本地 pid，该字段省略；tmux 持久会话带 persist）。 */
     snapshotOf(session) {
         const base = {
             sid: session.id,
@@ -581,6 +639,7 @@ class SessionManager {
             target: session.target,
             startedAt: session.startedAt,
             lastOutputAt: session.lastOutputAt,
+            ...(session.tmuxName !== null ? { persist: true } : {}),
         };
         return session.handle.pid === null ? base : { ...base, pid: session.handle.pid };
     }
@@ -592,9 +651,17 @@ class SessionManager {
     listForAttach() {
         return [...this.sessions.values()].map((session) => ({
             ...this.snapshotOf(session),
-            attachable: session.ws === null && !session.closed,
+            attachable: session.clients.size === 0 && !session.closed,
         }));
     }
+    /** 按 tmux 持久会话名查找存活会话（跨窗口共享用）；不存在/已关闭返回 undefined。 */
+    findByTmuxName(tmuxName) {
+        for (const session of this.sessions.values()) {
+            if (session.tmuxName === tmuxName && !session.closed)
+                return session;
+        }
+        return undefined;
+    }
     /** 同步退役：移出全局表 + 释放虚拟屏（幂等，不杀进程）。 */
     retire(session) {
         session.closed = true;
@@ -606,9 +673,18 @@ class SessionManager {
             /* 已释放 */
         }
     }
-    /** 释放并销毁会话：退役 + 树级终止（等待 terminate 完成，最慢 ~20s）。 */
+    /** 释放并销毁会话：退役 + 树级终止（等待 terminate 完成，最慢 ~20s）。
+     *  endOnPageClose 策略下，回收器销毁孤儿时连 tmux 持久会话一起结束。 */
     async destroy(session) {
         this.retire(session);
+        if (session.tmuxName !== null && this.endTmuxOnReap()) {
+            try {
+                await session.handle.tmuxTeardown?.();
+            }
+            catch {
+                /* tmux 收尾失败不阻断回收 */
+            }
+        }
         await forceKill(session.handle);
     }
     /** 回收超过保活期的孤儿会话（回收器定时调用；graceMs<=0 时不动作）。 */
@@ -645,12 +721,18 @@ class TtyServer {
     sessions;
     options;
     hostKeyStore;
+    trackPersist;
     wss = new WebSocketServer({ noServer: true });
-    constructor(ctx, sessions, options, hostKeyStore) {
+    /** 在途的持久会话创建（tmuxName → 创建 promise）：dsh 重启后多页面并发恢复时收敛竞态。 */
+    pendingTmux = new Map();
+    constructor(ctx, sessions, options, hostKeyStore, 
+    /** SSH 持久会话名留存回调（apply 闭包实现，settings 落盘）。 */
+    trackPersist) {
         this.ctx = ctx;
         this.sessions = sessions;
         this.options = options;
         this.hostKeyStore = hostKeyStore;
+        this.trackPersist = trackPersist;
         this.wss.on('connection', (ws) => this.onConnection(ws));
     }
     /** registerUpgrade 的 handler（loopback 围栏 + ws 握手）。 */
@@ -667,16 +749,21 @@ class TtyServer {
         /** 本连接上的会话表（sid → session）；单连接多会话（标签页）。 */
         const local = new Map();
         const cleanupAll = async () => {
-            const all = [...local.values()];
+            const all = [...local.entries()];
             local.clear();
-            await Promise.all(all.map(async (session) => {
+            await Promise.all(all.map(async ([clientSid, session]) => {
                 if (session.closed)
                     return;
+                // 解绑本连接的客户端；其余窗口仍绑定着（跨连接共享）时会话继续在线
+                session.clients.delete(clientSid);
+                if (session.clients.size > 0) {
+                    this.flushPendingOutput(session);
+                    return;
+                }
                 if (this.options.reconnectGraceMs > 0) {
                     // 客户端正常关面板会先逐个 kill（会话已移出 local），走到这里的都是
                     // 「异常断开仍有存活会话」：转孤儿保活，等待新连接 attach，到点由回收器清理
                     this.flushPendingOutput(session); // 没了收件人，待发帧直接丢弃（回放走环形缓冲）
-                    session.ws = null;
                     session.orphanedAt = Date.now();
                     return;
                 }
@@ -724,13 +811,66 @@ class TtyServer {
         send(ws, { t: 'error', m: local.size === 0 ? '没有可用会话（先发 spawn）' : '存在多个会话，请指定 sid' });
         return undefined;
     }
+    /** 把一个客户端连接重绑定到既有会话（跨窗口共享 / 并发恢复收敛共用）。 */
+    rebindClient(session, sid, ws, local) {
+        session.clients.set(sid, ws);
+        session.orphanedAt = null;
+        if (session.paused) {
+            session.paused = false;
+            try {
+                session.handle.output.resume();
+            }
+            catch {
+                /* 已退出 */
+            }
+        }
+        local.set(sid, session);
+        send(ws, {
+            t: 'ready',
+            sid,
+            pid: session.handle.pid,
+            kind: session.kind,
+            target: session.target !== '' ? session.target : undefined,
+            ...(session.tmuxName !== null ? { persist: true } : {}),
+        });
+        if (session.tmuxName !== null)
+            void session.handle.tmuxRefresh?.();
+    }
+    /** 等待同 tmuxName 的在途创建完成；返回可重绑定的会话（null = 无在途/已失败）。 */
+    async waitPendingTmux(tmuxName) {
+        const inflight = this.pendingTmux.get(tmuxName);
+        if (inflight === undefined)
+            return null;
+        try {
+            return await inflight;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * 立即终止会话：同步退役 + 顶层 shell 直接 SIGKILL，让 done/exit 帧立刻可发；
      * 树级子进程清理（SIGTERM→grace→SIGKILL，交互式 zsh 忽略 SIGTERM 时最慢
      * 可拖 ~20s）由 terminate 在后台继续收尾，不阻塞 kill 帧处理。
+     * tmux 背书会话先向 tmux server 发 kill-session（杀客户端只会 detach，
+     * 会话会留在 tmux server 上）；2.5s 兜底 forceKill 防收尾悬挂。
      */
     killSessionNow(session) {
         this.sessions.retire(session);
+        const teardown = session.handle.tmuxTeardown;
+        if (teardown !== undefined) {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                void forceKill(session.handle);
+            };
+            const timer = setTimeout(finish, 2500);
+            timer.unref?.();
+            void teardown().catch(() => { }).then(finish);
+            return;
+        }
         try {
             session.handle.forceKill?.();
         }
@@ -761,8 +901,25 @@ class TtyServer {
                     send(ws, { t: 'error', sid, m: 'sid 已存在' });
                     return;
                 }
+                // 持久化（0.10.0）：配置 persistence=tmux 且帧带 persist 时，spawn 包装层
+                // 换成 `exec tmux -L dsh-tty -A -s <名>`（tmux 托管）；tmux 未安装则降级
+                // 普通会话并回灰字提示。持久名稳定（客户端生成、随标签规格保存），
+                // 宿主重启后重开标签按同名 attach 回原 tmux 会话
+                const persistName = msg.persist === true && this.options.persistence === 'tmux'
+                    ? sanitizePersistName(msg.persistName, sid)
+                    : null;
+                // 跨窗口共享（0.10.1）：同 tmuxName 的宿主会话还活着（别的窗口接回过，
+                // 或同刻并发恢复的在途创建）时不再新建 PTY，本连接重绑定到它——
+                // 单 PTY 多客户端扇出，名额不翻倍
+                if (persistName !== null) {
+                    const existing = (this.sessions.findByTmuxName(persistName) ?? (await this.waitPendingTmux(persistName))) ?? null;
+                    if (existing !== null) {
+                        this.rebindClient(existing, sid, ws, local);
+                        return;
+                    }
+                }
                 if (!this.sessions.canSpawn()) {
-                    send(ws, { t: 'error', sid, m: `会话数已达上限（${this.sessions.limitValue}）` });
+                    send(ws, { t: 'error', sid, m: `会话数已达上限（${this.sessions.limitValue}）——每个窗口的每个标签各占一个名额：关闭不用的窗口/标签，或在设置卡片调大「并发会话上限」` });
                     return;
                 }
                 // 客户端（当前会话）cwd 优先；校验存在性，避免 node-pty 抛难懂错误
@@ -776,37 +933,70 @@ class TtyServer {
                     send(ws, { t: 'error', sid, m: 'subprocess 服务不可用' });
                     return;
                 }
-                const spawnPlan = buildShellSpawn(this.options.shell, this.options.term, this.options.colorTerm, this.options.shellIntegration);
-                const handle = wrapLocalPty(await subprocess.spawnTerminal({
-                    argv: spawnPlan.argv,
-                    rows: Number(msg.rows) || 24,
-                    cols: Number(msg.cols) || 80,
-                    cwd,
-                    env: { TERM: this.options.term, COLORTERM: this.options.colorTerm, ...spawnPlan.env },
-                    graceMs: 5000,
-                }));
-                const next = {
-                    id: sid,
-                    handle,
-                    ws,
-                    closed: false,
-                    paused: false,
-                    cwd,
-                    kind: 'local',
-                    target: '',
-                    startedAt: Date.now(),
-                    lastOutputAt: Date.now(),
-                    buffer: '',
-                    decoder: new StringDecoder('utf8'),
-                    screen: this.createScreen(Number(msg.cols) || 80, Number(msg.rows) || 24),
-                    orphanedAt: null,
-                    shellState: createShellState(),
-                    pendingOutput: '',
-                    flushTimer: null,
-                };
-                local.set(sid, next);
-                this.sessions.add(next);
-                send(ws, { t: 'ready', sid, pid: handle.pid, kind: 'local' });
+                const wantsPersist = persistName !== null;
+                let spawnPlan = buildShellSpawn(this.options.shell, this.options.term, this.options.colorTerm, this.options.shellIntegration);
+                let tmuxName = null;
+                if (wantsPersist) {
+                    const probe = await probeTmux();
+                    if (probe.available) {
+                        tmuxName = persistName;
+                        ensureTmuxAssets({ shell: this.options.shell, colorTerm: this.options.colorTerm, shellIntegration: this.options.shellIntegration, passthrough: probe.passthrough });
+                        spawnPlan = buildTmuxSpawnPlan({ shell: this.options.shell, term: this.options.term, colorTerm: this.options.colorTerm, tmuxName });
+                    }
+                }
+                // 在途注册：tmuxName 相同的并发 spawn 等本次创建完成后重绑定（防竞态翻倍）
+                const create = (async () => {
+                    const handle = wrapLocalPty(await subprocess.spawnTerminal({
+                        argv: spawnPlan.argv,
+                        rows: Number(msg.rows) || 24,
+                        cols: Number(msg.cols) || 80,
+                        cwd,
+                        env: { TERM: this.options.term, COLORTERM: this.options.colorTerm, ...spawnPlan.env },
+                        graceMs: 5000,
+                    }));
+                    if (tmuxName !== null) {
+                        handle.tmuxTeardown = () => killTmuxSession(tmuxName);
+                        handle.tmuxRefresh = () => refreshTmuxClient(tmuxName);
+                    }
+                    const next = {
+                        id: sid,
+                        handle,
+                        clients: new Map([[sid, ws]]),
+                        closed: false,
+                        paused: false,
+                        cwd,
+                        kind: 'local',
+                        target: '',
+                        startedAt: Date.now(),
+                        lastOutputAt: Date.now(),
+                        buffer: '',
+                        decoder: new StringDecoder('utf8'),
+                        screen: this.createScreen(Number(msg.cols) || 80, Number(msg.rows) || 24),
+                        orphanedAt: null,
+                        shellState: createShellState(),
+                        pendingOutput: '',
+                        flushTimer: null,
+                        tmuxName,
+                    };
+                    local.set(sid, next);
+                    this.sessions.add(next);
+                    return next;
+                })();
+                if (tmuxName !== null) {
+                    const registered = create.catch(() => null);
+                    this.pendingTmux.set(tmuxName, registered);
+                    void registered.finally(() => {
+                        if (this.pendingTmux.get(tmuxName) === registered)
+                            this.pendingTmux.delete(tmuxName);
+                    });
+                }
+                const next = await create;
+                send(ws, { t: 'ready', sid, pid: next.handle.pid, kind: 'local', ...(tmuxName !== null ? { persist: true } : {}) });
+                if (wantsPersist && tmuxName === null) {
+                    const notice = '\x1b[2m[dsh-tty] 未检测到 tmux，本标签以普通会话运行；安装 tmux 后持久化标签可跨宿主重启恢复现场\x1b[0m\r\n';
+                    next.buffer = (next.buffer + notice).slice(-BUFFER_CAP);
+                    send(ws, { t: 'data', sid, d: notice });
+                }
                 this.attachOutput(next);
                 this.watchDone(next, local);
             }
@@ -820,8 +1010,20 @@ class TtyServer {
                     send(ws, { t: 'error', sid, m: 'sid 已存在' });
                     return;
                 }
+                // 跨窗口共享（0.10.1）：同 tmuxName 的 SSH 持久会话还活着时不重建远程
+                // 连接，本连接重绑定到现有会话（单 PTY 多客户端扇出）
+                const persistName = msg.persist === true && this.options.persistence === 'tmux'
+                    ? sanitizePersistName(msg.persistName, sid)
+                    : null;
+                if (persistName !== null) {
+                    const existing = (this.sessions.findByTmuxName(persistName) ?? (await this.waitPendingTmux(persistName))) ?? null;
+                    if (existing !== null && existing.kind === 'ssh' && !existing.closed) {
+                        this.rebindClient(existing, sid, ws, local);
+                        return;
+                    }
+                }
                 if (!this.sessions.canSpawn()) {
-                    send(ws, { t: 'error', sid, m: `会话数已达上限（${this.sessions.limitValue}）` });
+                    send(ws, { t: 'error', sid, m: `会话数已达上限（${this.sessions.limitValue}）——每个窗口的每个标签各占一个名额：关闭不用的窗口/标签，或在设置卡片调大「并发会话上限」` });
                     return;
                 }
                 // name 引用连接簿条目作基底，内联字段可逐项覆盖（与 SFTP 路由共用 mergeSshSpec）
@@ -833,51 +1035,83 @@ class TtyServer {
                 const spec = merged.spec;
                 const target = sshTarget(spec);
                 send(ws, { t: 'data', sid, d: `\x1b[2mConnecting ${target} …\x1b[0m\r\n` });
-                let handle;
-                try {
-                    handle = await spawnSsh(spec, {
-                        term: this.options.term,
-                        cols: Number(msg.cols) || 80,
-                        rows: Number(msg.rows) || 24,
-                        logger: { info: (m) => this.ctx.logger.info(m), warn: (m) => this.ctx.logger.warn(m) },
-                        hostKeyStore: this.hostKeyStore,
+                // 持久化（0.10.0）：远程 `exec tmux new-session -A` 托管；远程无 tmux 时
+                // spawnSsh 降级普通 shell channel 并经 startupNotice 回灰字提示
+                const wantsPersist = persistName !== null;
+                const persistOpt = wantsPersist ? { name: persistName } : undefined;
+                // 在途注册：同 persistName 的并发恢复等待本次创建完成后重绑定（防竞态翻倍）
+                const create = (async () => {
+                    let handle;
+                    try {
+                        handle = await spawnSsh(spec, {
+                            term: this.options.term,
+                            cols: Number(msg.cols) || 80,
+                            rows: Number(msg.rows) || 24,
+                            logger: { info: (m) => this.ctx.logger.info(m), warn: (m) => this.ctx.logger.warn(m) },
+                            hostKeyStore: this.hostKeyStore,
+                            ...(persistOpt !== undefined ? { persist: persistOpt } : {}),
+                        });
+                    }
+                    catch (error) {
+                        send(ws, { t: 'error', sid, m: error instanceof Error ? error.message : String(error) });
+                        throw error;
+                    }
+                    const tmuxName = persistOpt !== undefined && handle.startupNotice === undefined ? persistOpt.name : null;
+                    const next = {
+                        id: sid,
+                        handle,
+                        clients: new Map([[sid, ws]]),
+                        closed: false,
+                        paused: false,
+                        cwd: '',
+                        kind: 'ssh',
+                        target,
+                        startedAt: Date.now(),
+                        lastOutputAt: Date.now(),
+                        buffer: '',
+                        decoder: new StringDecoder('utf8'),
+                        screen: this.createScreen(Number(msg.cols) || 80, Number(msg.rows) || 24),
+                        orphanedAt: null,
+                        shellState: createShellState(),
+                        pendingOutput: '',
+                        flushTimer: null,
+                        tmuxName,
+                    };
+                    local.set(sid, next);
+                    this.sessions.add(next);
+                    send(ws, { t: 'ready', sid, pid: null, kind: 'ssh', target, ...(tmuxName !== null ? { persist: true } : {}) });
+                    if (tmuxName !== null)
+                        this.trackPersist(tmuxName, true); // 留存：远程 tmux 本机清单看不到
+                    if (handle.startupNotice !== undefined) {
+                        const notice = `\x1b[2m[dsh-tty] ${handle.startupNotice}\x1b[0m\r\n`;
+                        next.buffer = (next.buffer + notice).slice(-BUFFER_CAP);
+                        send(ws, { t: 'data', sid, d: notice });
+                    }
+                    this.attachOutput(next);
+                    this.watchDone(next, local);
+                    return next;
+                })();
+                if (persistName !== null) {
+                    const registered = create.catch(() => null);
+                    this.pendingTmux.set(persistName, registered);
+                    void registered.finally(() => {
+                        if (this.pendingTmux.get(persistName) === registered)
+                            this.pendingTmux.delete(persistName);
                     });
                 }
-                catch (error) {
-                    send(ws, { t: 'error', sid, m: error instanceof Error ? error.message : String(error) });
-                    return;
+                try {
+                    await create;
+                }
+                catch {
+                    return; // 错误帧已在创建闭包内发送
                 }
-                const next = {
-                    id: sid,
-                    handle,
-                    ws,
-                    closed: false,
-                    paused: false,
-                    cwd: '',
-                    kind: 'ssh',
-                    target,
-                    startedAt: Date.now(),
-                    lastOutputAt: Date.now(),
-                    buffer: '',
-                    decoder: new StringDecoder('utf8'),
-                    screen: this.createScreen(Number(msg.cols) || 80, Number(msg.rows) || 24),
-                    orphanedAt: null,
-                    shellState: createShellState(),
-                    pendingOutput: '',
-                    flushTimer: null,
-                };
-                local.set(sid, next);
-                this.sessions.add(next);
-                send(ws, { t: 'ready', sid, pid: null, kind: 'ssh', target });
-                this.attachOutput(next);
-                this.watchDone(next, local);
             }
             else if (msg.t === 'input') {
                 const resolved = this.resolveSid(ws, msg, local);
                 if (resolved === undefined || 'unknown' in resolved)
                     return;
                 const session = local.get(resolved.sid);
-                if (session !== undefined)
+                if (session !== undefined && !session.closed)
                     await session.handle.write(String(msg.d ?? ''));
             }
             else if (msg.t === 'resize') {
@@ -897,6 +1131,18 @@ class TtyServer {
                     }
                 }
             }
+            else if (msg.t === 'refresh') {
+                // 强制 tmux 重画（0.10.1）：客户端 reset 清掉残 scrollback 后请宿主
+                // refresh-client 重画现场——不碰尺寸，规避隐藏标签下 proposeDimensions
+                // 返回垃圾尺寸把 pane 压扁的隐患；非 tmux 会话为无害 no-op
+                const resolved = this.resolveSid(ws, msg, local);
+                if (resolved === undefined || 'unknown' in resolved)
+                    return;
+                const session = local.get(resolved.sid);
+                if (session !== undefined && !session.closed && session.tmuxName !== null) {
+                    void session.handle.tmuxRefresh?.();
+                }
+            }
             else if (msg.t === 'kill') {
                 const resolved = this.resolveSid(ws, msg, local);
                 if (resolved === undefined)
@@ -918,7 +1164,12 @@ class TtyServer {
                 this.killSessionNow(session);
             }
             else if (msg.t === 'sessions') {
-                send(ws, { t: 'sessions', list: this.sessions.listForAttach() });
+                // tmux 字段（0.10.1）：本机 socket 现存持久会话 + SSH 持久会话名（远程
+                // tmux 托管、本机清单看不到，从 settings 留存读取）——客户端用它确认
+                // localStorage 里的持久标签规格是否仍可恢复（新窗口/新浏览器）
+                const localTmux = await listTmuxSessions();
+                const tmuxSessions = [...new Set([...localTmux, ...this.options.persistSessions])];
+                send(ws, { t: 'sessions', list: this.sessions.listForAttach(), tmux: tmuxSessions });
             }
             else if (msg.t === 'attach') {
                 const raw = msg.sid;
@@ -931,14 +1182,16 @@ class TtyServer {
                     send(ws, { t: 'error', sid: raw, m: `会话不存在或已结束: ${raw}` });
                     return;
                 }
-                if (session.ws !== null) {
+                // 跨连接共享（0.10.1）：tmux 持久会话允许多窗口同时绑定（单 PTY 扇出）；
+                // 非 tmux 会话仍独占（两个视图交错输入无意义）
+                if (session.clients.size > 0 && session.tmuxName === null) {
                     send(ws, { t: 'error', sid: raw, m: '会话已连接到其它窗口' });
                     return;
                 }
-                // 重新绑定到本连接：解孤儿态，恢复被背压暂停的输出流
-                session.ws = ws;
+                // 重新绑定到本连接（key = 本连接侧的 sid）：解孤儿态，恢复被背压暂停的输出流
+                session.clients.set(raw, ws);
                 session.orphanedAt = null;
-                local.set(session.id, session);
+                local.set(raw, session);
                 if (session.paused) {
                     session.paused = false;
                     try {
@@ -948,10 +1201,17 @@ class TtyServer {
                         /* 已退出 */
                     }
                 }
-                send(ws, { t: 'ready', sid: session.id, pid: session.handle.pid, kind: session.kind, target: session.target !== '' ? session.target : undefined, reattached: true });
-                // 断线期间的输出经 256KB 环形缓冲回放（缓冲为空则跳过）
-                if (session.buffer !== '')
-                    send(ws, { t: 'data', sid: session.id, d: session.buffer });
+                send(ws, { t: 'ready', sid: raw, pid: session.handle.pid, kind: session.kind, target: session.target !== '' ? session.target : undefined, reattached: true, ...(session.tmuxName !== null ? { persist: true } : {}) });
+                // 断线期间的输出经 256KB 环形缓冲回放（缓冲为空则跳过）。
+                // tmux 背书会话例外：现场由 tmux 负责重画——回放会把缓冲里的可见屏
+                // 先写进全新 xterm（制造屏外幽灵滚动历史 → 莫名滚动条），随后 tmux
+                // 整屏重画再画一遍（内容重影）；故跳过回放，强制 tmux 重画一次
+                if (session.tmuxName !== null) {
+                    void session.handle.tmuxRefresh?.();
+                }
+                else if (session.buffer !== '') {
+                    send(ws, { t: 'data', sid: raw, d: session.buffer });
+                }
             }
         }
         catch (error) {
@@ -969,6 +1229,8 @@ class TtyServer {
             session.closed = true;
             local.delete(session.id);
             this.sessions.remove(session.id);
+            if (session.kind === 'ssh' && session.tmuxName !== null)
+                this.trackPersist(session.tmuxName, false);
             try {
                 session.screen?.dispose();
             }
@@ -976,7 +1238,11 @@ class TtyServer {
                 /* 已释放 */
             }
             this.flushPendingOutput(session); // exit 前冲掉合并窗口里的尾巴，保序
-            send(session.ws, { t: 'exit', sid: session.id, code: outcome.exitCode, signal: outcome.signal });
+            // exit 广播到所有绑定连接（跨窗口共享），各客户端按自己的 sid 收址
+            for (const [clientSid, clientWs] of session.clients) {
+                send(clientWs, { t: 'exit', sid: clientSid, code: outcome.exitCode, signal: outcome.signal });
+            }
+            session.clients.clear();
         }).catch(() => { });
     }
     /** 输出下行 + 基于 ws.bufferedAmount 的背压（暂停/恢复 PassThrough）。 */
@@ -984,17 +1250,25 @@ class TtyServer {
         const output = session.handle.output;
         const flush = () => {
             session.flushTimer = null;
-            const ws = session.ws;
             const pending = session.pendingOutput;
-            if (session.closed || ws === null || pending === '')
+            if (session.closed || session.clients.size === 0 || pending === '')
                 return;
             session.pendingOutput = '';
-            ws.send(JSON.stringify({ t: 'data', sid: session.id, d: pending }), () => {
-                if (session.paused && ws.bufferedAmount < BACKPRESSURE_LOW && output.readableFlowing === false) {
-                    output.resume();
+            let maxBuffered = 0;
+            for (const [clientSid, clientWs] of session.clients) {
+                try {
+                    clientWs.send(JSON.stringify({ t: 'data', sid: clientSid, d: pending }), () => {
+                        if (session.paused && clientWs.bufferedAmount < BACKPRESSURE_LOW && output.readableFlowing === false) {
+                            output.resume();
+                        }
+                    });
+                    maxBuffered = Math.max(maxBuffered, clientWs.bufferedAmount);
                 }
-            });
-            if (!session.paused && ws.bufferedAmount > BACKPRESSURE_HIGH) {
+                catch {
+                    /* 客户端已断开 */
+                }
+            }
+            if (!session.paused && maxBuffered > BACKPRESSURE_HIGH) {
                 session.paused = true;
                 output.pause();
             }
@@ -1013,8 +1287,7 @@ class TtyServer {
             catch {
                 /* 虚拟屏异常不阻断输出链路 */
             }
-            const ws = session.ws;
-            if (ws === null)
+            if (session.clients.size === 0)
                 return; // 孤儿会话：仅积累缓冲，等待重连 attach 回放
             // data 帧合并：窗口内攒批，超阈值立即冲刷；exit/kill 前会强制 flush 保序
             session.pendingOutput += text;
@@ -1039,12 +1312,13 @@ class TtyServer {
             clearTimeout(session.flushTimer);
             session.flushTimer = null;
         }
-        const ws = session.ws;
         const pending = session.pendingOutput;
         session.pendingOutput = '';
-        if (session.closed || ws === null || pending === '')
+        if (session.closed || session.clients.size === 0 || pending === '')
             return;
-        send(ws, { t: 'data', sid: session.id, d: pending });
+        for (const [clientSid, clientWs] of session.clients) {
+            send(clientWs, { t: 'data', sid: clientSid, d: pending });
+        }
     }
     close() {
         for (const client of this.wss.clients) {
@@ -1280,8 +1554,11 @@ const plugin = definePlugin({
             hostKeys: Array.isArray(config?.hostKeys) ? config.hostKeys : [],
             shellIntegration: config?.shellIntegration !== false,
             tunnels: Array.isArray(config?.tunnels) ? config.tunnels : [],
+            persistence: config?.persistence === 'tmux' ? 'tmux' : 'off',
+            endOnPageClose: config?.endOnPageClose === true,
+            persistSessions: sanitizePersistSessions(config?.persistSessions) ?? [],
         });
-        const sessions = new SessionManager(config?.maxSessions ?? DEFAULT_MAX_SESSIONS);
+        const sessions = new SessionManager(config?.maxSessions ?? DEFAULT_MAX_SESSIONS, () => live.endOnPageClose);
         /** TOFU 指纹记录持久化：写入 settings 命名空间（合并语义），失败不影响连接。 */
         const persistHostKeys = (records) => {
             const scope = settingsScope;
@@ -1292,11 +1569,30 @@ const plugin = definePlugin({
             });
         };
         const hostKeyStore = new HostKeyStore(live, persistHostKeys);
+        /** SSH 持久会话名留存（远程 tmux 本机 socket 看不到；新窗口恢复确认的数据源）。 */
+        const persistPersistSessions = () => {
+            const scope = settingsScope;
+            if (scope === undefined)
+                return;
+            void Promise.resolve(scope.update({ persistSessions: live.persistSessions.map((name) => ({ tmuxName: name })) })).catch((error) => {
+                console.warn('[dsh-tty] 持久会话名留存失败: ' + (error instanceof Error ? error.message : String(error)));
+            });
+        };
+        /** 记录/移除一个 SSH 持久会话名并落盘（幂等）。 */
+        const trackPersistSession = (tmuxName, present) => {
+            const next = present
+                ? (live.persistSessions.includes(tmuxName) ? live.persistSessions : [...live.persistSessions, tmuxName])
+                : live.persistSessions.filter((name) => name !== tmuxName);
+            if (next.join('|') === live.persistSessions.join('|'))
+                return;
+            live.persistSessions = next;
+            persistPersistSessions();
+        };
         const tunnelManager = new TunnelManager({ info: (m) => ctx.logger.info(m), warn: (m) => ctx.logger.warn(m) }, hostKeyStore, (bookName) => live.findSshHost(bookName));
         // SFTP 文件传输：懒连接池 + TOFU 同源（见 src/sftp.ts）；spec 由各请求携带
         // （连接簿名或内联字段），连接簿凭证热改后天然生效
         const sftpManager = new SftpManager({ info: (m) => ctx.logger.info(m), warn: (m) => ctx.logger.warn(m) }, hostKeyStore);
-        const server = new TtyServer(ctx, sessions, live, hostKeyStore);
+        const server = new TtyServer(ctx, sessions, live, hostKeyStore, trackPersistSession);
         const stateRef = { enabled: true, announceToAgent: config?.announceToAgent !== false, toolsRegistered: false, sftpStyle: config?.sftpStyle === 'dual' ? 'dual' : 'dialog' };
         let settingsScope;
         const snapshot = () => ({
@@ -1313,6 +1609,8 @@ const plugin = definePlugin({
             tunnels: live.tunnels,
             shellIntegration: live.shellIntegration,
             sftpStyle: stateRef.sftpStyle,
+            persistence: live.persistence,
+            endOnPageClose: live.endOnPageClose,
             toolsRegistered: stateRef.toolsRegistered,
         });
         /** 规范化并应用一份配置补丁（settings/updated 事件与 HTTP POST 共用；幂等）。 */
@@ -1327,6 +1625,9 @@ const plugin = definePlugin({
                 hostKeys: sanitizeHostKeys(section.hostKeys),
                 shellIntegration: typeof section.shellIntegration === 'boolean' ? section.shellIntegration : undefined,
                 tunnels: sanitizeTunnels(section.tunnels),
+                persistence: section.persistence === 'tmux' || section.persistence === 'off' ? section.persistence : undefined,
+                endOnPageClose: typeof section.endOnPageClose === 'boolean' ? section.endOnPageClose : undefined,
+                persistSessions: sanitizePersistSessions(section.persistSessions),
             });
             // 隧道按最新规格对齐（幂等；sshHosts 变更也会触发，让重连取到新凭证）
             tunnelManager.reconcile(live.tunnels);
@@ -1344,7 +1645,7 @@ const plugin = definePlugin({
         /** 校验 HTTP POST 的配置体；返回规范化补丁或错误信息。 */
         const normalizePatch = (input) => {
             const patch = {};
-            const known = new Set(['enabled', 'announceToAgent', 'maxSessions', 'shell', 'term', 'colorTerm', 'cwd', 'reconnectGraceSec', 'sshHosts', 'hostKeys', 'tunnels', 'shellIntegration', 'sftpStyle']);
+            const known = new Set(['enabled', 'announceToAgent', 'maxSessions', 'shell', 'term', 'colorTerm', 'cwd', 'reconnectGraceSec', 'sshHosts', 'hostKeys', 'tunnels', 'shellIntegration', 'sftpStyle', 'persistence', 'endOnPageClose']);
             for (const key of Object.keys(input)) {
                 if (!known.has(key))
                     return { error: '未知配置项: ' + key };
@@ -1381,6 +1682,16 @@ const plugin = definePlugin({
                     return { error: 'sftpStyle 必须是 dialog 或 dual' };
                 patch.sftpStyle = input.sftpStyle;
             }
+            if (input.persistence !== undefined) {
+                if (input.persistence !== 'off' && input.persistence !== 'tmux')
+                    return { error: 'persistence 必须是 off 或 tmux' };
+                patch.persistence = input.persistence;
+            }
+            if (input.endOnPageClose !== undefined) {
+                if (typeof input.endOnPageClose !== 'boolean')
+                    return { error: 'endOnPageClose 必须是布尔值' };
+                patch.endOnPageClose = input.endOnPageClose;
+            }
             for (const key of ['shell', 'term', 'colorTerm']) {
                 if (input[key] === undefined)
                     continue;
@@ -1834,6 +2145,13 @@ const plugin = definePlugin({
                     startup.shellIntegration = false;
                 if (stored.sftpStyle === 'dual')
                     startup.sftpStyle = 'dual';
+                if (stored.persistence === 'tmux')
+                    startup.persistence = 'tmux';
+                if (stored.endOnPageClose === true)
+                    startup.endOnPageClose = true;
+                const storedPersistSessions = sanitizePersistSessions(stored.persistSessions);
+                if (storedPersistSessions !== undefined && storedPersistSessions.length > 0)
+                    startup.persistSessions = storedPersistSessions;
                 const storedHosts = sanitizeSshHosts(stored.sshHosts);
                 if (storedHosts !== undefined && storedHosts.length > 0)
                     startup.sshHosts = storedHosts;
@@ -1893,6 +2211,7 @@ const plugin = definePlugin({
                                             cwd: { type: 'string', required: true },
                                             startedAt: { type: 'number', required: true },
                                             lastOutputAt: { type: 'number', required: true },
+                                            persist: { type: 'boolean' },
                                         },
                                     },
                                 },
@@ -1904,7 +2223,8 @@ const plugin = definePlugin({
                                 ? '当前没有活跃的终端面板会话（请引导用户先打开终端面板，或用户尚未打开）'
                                 : '终端面板会话：' + sessions.map((s) => {
                                     const where = s.kind === 'ssh' ? `ssh ${s.target}` : `pid=${String(s.pid ?? '?')} cwd=${s.cwd}`;
-                                    return `\n- sid=${s.sid} [${s.kind}] ${where} (启动于 ${new Date(s.startedAt).toLocaleString()})`;
+                                    const persist = s.persist === true ? ' [tmux 持久]' : '';
+                                    return `\n- sid=${s.sid} [${s.kind}]${persist} ${where} (启动于 ${new Date(s.startedAt).toLocaleString()})`;
                                 }).join('');
                             return [{ type: 'text', text }];
                         },
@@ -2524,7 +2844,7 @@ const plugin = definePlugin({
                                 return '当前没有活跃的终端面板会话（可引导用户打开「终端」面板，或用 spawn 类工作流替代）。';
                             return '当前活跃的终端面板会话（可用 tty_capture / tty_screen / tty_expect / tty_send 操作，sid 如下）：\n' + list.map((s) => {
                                 const where = s.kind === 'ssh' ? `ssh ${s.target}` : `pid=${String(s.pid ?? '?')} cwd=${s.cwd}`;
-                                return `- sid=${s.sid} [${s.kind}] ${where} (最后活动 ${new Date(s.lastOutputAt).toLocaleTimeString()})`;
+                                return `- sid=${s.sid} [${s.kind}]${s.persist === true ? ' [tmux 持久]' : ''} ${where} (最后活动 ${new Date(s.lastOutputAt).toLocaleTimeString()})`;
                             }).join('\n');
                         },
                     });