@seamnet/client 0.19.0 → 0.20.1

package/bin/seam.js

@@ -57,11 +57,12 @@ function printHelp() {
     '  seam self schedule --id <id> --every <duration> --text <text>',
     '  seam self cancel --id <id>',
     '  seam self list',
-    '  seam cc list',
-    '  seam cc read --session <name> [--lines N]',
-    '  seam cc send --session <name> --text <msg>',
-    '  seam cc start --dir <path> [--session <name>]',
-    '  seam cc restart --session <name> [--no-continue]  重启某个 CC 实例',
+    '  seam term list',
+    '  seam term read --session <name> [--lines N | --full]',
+    '  seam term send --session <name> [--text <msg> [--no-enter]] [--key <K> ...]',
+    '  seam term start --kind cc|codex|shell [--session <name>] [--dir <path>] [--cmd "..."]',
+    '  seam term stop --session <name>',
+    '  seam term restart --session <name> [--no-continue]',
     '',
     '输出：JSON { ok: true, data } 或 { ok: false, error }。',
   ].join('\n');
@@ -401,15 +402,13 @@ async function cmdInvite(subAction, restArgs) {
   output(false, `Unknown invite action: ${subAction}. Try: seam invite generate`);
 }
 
-// === cc (Claude Code 管理) ===
+// === term (通用终端操作) ===
 
 const tmuxUtils = require('../lib/tmux-utils.cjs');
 
-async function cmdCc(subAction, restArgs) {
+async function cmdTerm(subAction, restArgs) {
   if (!subAction || subAction === 'list') {
-    const sessions = tmuxUtils.listSessions();
-    if (sessions.length === 0) output(true, { sessions: [], message: 'no tmux sessions' });
-    output(true, { sessions });
+    output(true, { terms: tmuxUtils.listTerms() });
     return;
   }
 
@@ -419,12 +418,16 @@ async function cmdCc(subAction, restArgs) {
       options: {
         session: { type: 'string' },
         lines: { type: 'string', default: '20' },
+        full: { type: 'boolean' },
       },
       strict: false,
     });
     if (!values.session) output(false, '--session required');
     try {
-      const text = tmuxUtils.readOutput(values.session, parseInt(values.lines) || 20);
+      const text = tmuxUtils.readTerm(values.session, {
+        lines: parseInt(values.lines, 10) || 20,
+        full: !!values.full,
+      });
       output(true, { session: values.session, lines: text.trimEnd().split('\n') });
     } catch (e) {
       output(false, `read failed: ${e.message}`);
@@ -438,14 +441,23 @@ async function cmdCc(subAction, restArgs) {
       options: {
         session: { type: 'string' },
         text: { type: 'string' },
+        'no-enter': { type: 'boolean' },
+        key: { type: 'string', multiple: true },
       },
       strict: false,
     });
     if (!values.session) output(false, '--session required');
-    if (!values.text) output(false, '--text required');
+    const keys = values.key || [];
+    if (values.text == null && keys.length === 0) {
+      output(false, '需要 --text 或 --key 至少一个');
+    }
     try {
-      tmuxUtils.sendToCC(values.session, values.text);
-      output(true, { session: values.session, sent: values.text });
+      tmuxUtils.sendTerm(values.session, {
+        text: values.text,
+        noEnter: !!values['no-enter'],
+        keys,
+      });
+      output(true, { session: values.session, text: values.text ?? null, keys });
     } catch (e) {
       output(false, e.message);
     }
@@ -456,16 +468,58 @@ async function cmdCc(subAction, restArgs) {
     const { values } = parseArgs({
       args: restArgs,
       options: {
-        dir: { type: 'string' },
+        kind: { type: 'string' },
         session: { type: 'string' },
+        dir: { type: 'string' },
+        cmd: { type: 'string' },
       },
       strict: false,
     });
-    if (!values.dir) output(false, '--dir required');
-    const sessionName = values.session || values.dir.split('/').pop();
+    if (!values.kind) output(false, '--kind required (cc|codex|shell)');
     try {
-      tmuxUtils.startCC(values.dir, sessionName);
-      output(true, { session: sessionName, dir: values.dir, started: true });
+      const res = tmuxUtils.startTerm({
+        kind: values.kind,
+        cmd: values.cmd,
+        session: values.session,
+        dir: values.dir,
+      });
+      output(true, { ...res, started: true });
+    } catch (e) {
+      output(false, e.message);
+    }
+    return;
+  }
+
+  if (subAction === 'stop') {
+    const { values } = parseArgs({
+      args: restArgs,
+      options: { session: { type: 'string' } },
+      strict: false,
+    });
+    if (!values.session) output(false, '--session required');
+    // 关之前查 registry：这个 session 是否绑着一个 guardian
+    let guardianEntry = null;
+    let registryReadError = null;
+    try {
+      const { readAll } = await import('../lib/registry.js');
+      guardianEntry = readAll().find((e) => e.tmux_session === values.session) || null;
+    } catch (e) {
+      // registry 读失败不静默——stop 杀了 guardian 不能悄无声息
+      registryReadError = e.message;
+    }
+    try {
+      const { kind } = tmuxUtils.stopTerm(values.session);
+      const result = { session: values.session, kind, stopped: true };
+      if (guardianEntry) {
+        result.guardian_killed = true;
+        result.warning = `注意：已一并终止该 home 的 guardian（userId=${guardianEntry.userId}, home=${guardianEntry.seam_home}）`;
+      } else if (registryReadError) {
+        result.warning = `registry 读取失败（${registryReadError}）——无法确认该会话是否绑 guardian；`
+          + `若这是 cc 会话（kind=${kind}），guardian 可能已随会话一并终止`;
+      } else if (kind === 'cc') {
+        result.warning = '注意：这是个 cc 会话——若它绑着 guardian，guardian 已随会话一并终止';
+      }
+      output(true, result);
     } catch (e) {
       output(false, e.message);
     }
@@ -485,11 +539,13 @@ async function cmdCc(subAction, restArgs) {
     if (!values.session) output(false, '--session required');
     const continueSession = values['no-continue'] ? false : true;
     try {
-      const ok = await tmuxUtils.restartCC(values.session, { continueSession });
-      if (ok) {
-        output(true, { session: values.session, restarted: true });
+      const r = await tmuxUtils.restartTerm(values.session, { continueSession });
+      if (r.ok) {
+        const result = { session: values.session, restarted: true, startCmd: r.startCmd };
+        if (r.warning) result.warning = r.warning;
+        output(true, result);
       } else {
-        output(false, 'restart failed: CC 未在超时内退出或重启');
+        output(false, r.warning || 'restart failed: 终端未在超时内退出或重启');
       }
     } catch (e) {
       output(false, e.message);
@@ -497,7 +553,7 @@ async function cmdCc(subAction, restArgs) {
     return;
   }
 
-  output(false, `Unknown cc action: ${subAction}. Try: list, read, send, start, restart`);
+  output(false, `Unknown term action: ${subAction}. Try: list, read, send, start, stop, restart`);
 }
 
 function parseDuration(str) {
@@ -529,7 +585,7 @@ function parseDuration(str) {
     if (domain === 'inbox') return await cmdInbox(action, rest);
     if (domain === 'self') return await cmdSelf(action, rest);
     if (domain === 'invite') return await cmdInvite(action, rest);
-    if (domain === 'cc') return await cmdCc(action, rest);
+    if (domain === 'term') return await cmdTerm(action, rest);
     output(false, `Unknown domain: ${domain}. Try: seam --help`);
   } catch (e) {
     output(false, e.message);

package/lib/guardian.js

@@ -252,14 +252,15 @@ export async function guardianRun() {
     hub.inject(notice);
     setTimeout(async () => {
       try {
-        const { restartCC } = require('./tmux-utils.cjs');
-        const ok = await restartCC(safeSession, { socketPath: ccSocket, continueSession: true });
-        if (ok) {
+        const { restartTerm } = require('./tmux-utils.cjs');
+        const r = await restartTerm(safeSession, { socketPath: ccSocket, continueSession: true });
+        if (r.ok) {
           guardianState.set('cc_restarted', new Date().toISOString());
           if (isUpgradeRestart) guardianState.delete('pending_upgrade_restart');
           hub.logger('guardian').info('cc_restart_injected');
+          if (r.warning) hub.logger('guardian').warn('cc_restart_warning', { warning: r.warning });
         } else {
-          hub.logger('guardian').error('cc_restart_failed', new Error('restartCC returned false'));
+          hub.logger('guardian').error('cc_restart_failed', new Error(r.warning || 'restartTerm returned ok:false'));
         }
       } catch (e) {
         hub.logger('guardian').error('cc_restart_failed', e);

package/lib/tell.js

@@ -1,7 +1,7 @@
 /**
  * seam tell：跨 AI 单条投递。
  *
- * 优先走 cross-AI registry —— 目标 AI 在本机 → 直接调 tmux sendToCC 注入；
+ * 优先走 cross-AI registry —— 目标 AI 在本机 → 直接调 tmux sendTerm 注入；
  * 不在或 socket 死 → fallback 走 IM 发到对方 userId。
  *
  * 入站 inject 加 from header：`💬 [本机 ← <from>] <text>`
@@ -40,9 +40,9 @@ export async function tell({ to, from, text, guardianRequest }) {
   const entry = findByAlias(to);
   if (entry?.tmux_session) {
     try {
-      const { sendToCC } = require('./tmux-utils.cjs');
+      const { sendTerm } = require('./tmux-utils.cjs');
       const injectText = formatLocalInject(fromName, text);
-      sendToCC(entry.tmux_session, injectText, { socketPath: entry.tmux_socket || undefined });
+      sendTerm(entry.tmux_session, { text: injectText, socketPath: entry.tmux_socket || undefined });
       return { ok: true, channel: 'local', target: entry.userId };
     } catch (e) {
       // 本机命中但 CC 不在线 / tmux session 死了 → 落 IM

package/lib/tmux-utils.cjs

@@ -1,157 +1,307 @@
 /**
- * tmux-utils — 可靠的 tmux 交互。
+ * tmux-utils — 通用 tmux 终端操作（transport 层）。
  *
- * CC 用 raw terminal mode，tmux send-keys 需要特殊处理：
- * 1. 文本用 -l (literal) 发，不解释特殊键
- * 2. Enter 单独发
- * 3. 发完验证是否被接收
+ * 只做 transport：读屏（capture-pane）、发键（send-keys）、起/停/重启会话。
+ * 这层与 pane 里跑什么无关。交互语义（审批流、idle 判断等）故意不抽象——
+ * 由操作者读屏自己决定按什么键。
+ *
+ * 唯一的 per-kind 知识：KIND_CMD 表（kind → 启动/续命/退出/超时）。restart
+ * 时 cc 与 codex 都走对称的优雅路径，差别全在表里。
  */
 
 const { execSync } = require('node:child_process');
-const { existsSync, readFileSync } = require('node:fs');
-const { join } = require('node:path');
+const { existsSync } = require('node:fs');
+const { basename } = require('node:path');
 
 const EXEC_OPTS = { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] };
 
+// kind → 启动命令族。声明式数据小表，不是 adapter。新增 kind 加一行即可。
+// - fresh：全新会话的启动命令
+// - resume：续上一次会话的命令（restart 默认走这个；--no-continue 走 fresh）
+// - exit：TUI 内的优雅退出命令（restart 发它 + Enter）
+// - downTimeout：发了 exit 后等进程退出的轮询超时（ms）
+const KIND_CMD = {
+  cc: {
+    fresh: 'claude --dangerously-skip-permissions',
+    resume: 'claude --dangerously-skip-permissions --continue',
+    exit: '/exit',
+    downTimeout: 120000, // cc 退出跑 Stop hook（auto-save / semantic_memory）要 ~90s
+  },
+  codex: {
+    fresh: 'codex -m gpt-5.4',
+    resume: 'codex resume --last',
+    exit: '/exit',
+    downTimeout: 60000, // 实测 codex /exit ~25s（退出存 session），留余量
+  },
+  shell: {
+    fresh: 'bash',
+    // shell 无优雅 restart——restartTerm 对 shell 直接报错
+  },
+};
+const KIND_PREFIX = { cc: 'cc', codex: 'codex', shell: 'sh' };
+
 function tmuxCmd(socketPath) {
   return socketPath ? `tmux -S "${socketPath}"` : 'tmux';
 }
 
-function listSessions(socketPath) {
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * 检测 session 里跑的是什么：'cc' | 'codex' | 'shell'。session 不存在返回 null。
+ *
+ * 从 pane_pid BFS 进程子树，遇到第一个 comm 含 claude/codex 的进程即返回——
+ * 「最浅命中」。npm 装的 codex 是 node 包装脚本（comm 看到的是 node/MainThread），
+ * 真 codex 是更深一层的 Rust 二进制（comm=codex），所以必须穿透子树。
+ *
+ * 为什么是「最浅命中」而非「收集全部」：cc 会话可能 spawn codex 子进程
+ * （比如 AI 用 codex skill）——那个 codex 在很深的层。最浅命中保证最外层的
+ * 那个有意义进程（panePid 处或附近的 claude）决定 kind，不被深层 codex 干扰。
+ */
+function detectKind(session, socketPath) {
   const tmux = tmuxCmd(socketPath);
-  let lines;
+  let panePid;
   try {
-    lines = execSync(`${tmux} list-sessions -F "#{session_name}"`, EXEC_OPTS)
-      .trim().split('\n').filter(Boolean);
+    panePid = execSync(`${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS).trim();
   } catch {
-    return [];
+    return null;
   }
-  return lines.map(name => {
-    const cc = isCCRunning(name, socketPath);
-    return { session: name, cc };
-  });
+  let table;
+  try {
+    table = execSync('ps -e -o pid=,ppid=,comm=', { ...EXEC_OPTS, maxBuffer: 4 * 1024 * 1024 });
+  } catch {
+    return 'shell';
+  }
+  const childrenOf = new Map();
+  const commOf = new Map();
+  for (const line of table.split('\n')) {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const [, pid, ppid, comm] = m;
+    commOf.set(pid, comm);
+    if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
+    childrenOf.get(ppid).push(pid);
+  }
+  // BFS：最浅命中即返回
+  const queue = [String(panePid)];
+  const seen = new Set();
+  let guard = 0;
+  while (queue.length && guard++ < 5000) {
+    const pid = queue.shift();
+    if (seen.has(pid)) continue;
+    seen.add(pid);
+    const comm = (commOf.get(pid) || '').toLowerCase();
+    if (comm.includes('claude')) return 'cc';
+    if (comm.includes('codex')) return 'codex';
+    for (const c of childrenOf.get(pid) || []) queue.push(c);
+  }
+  return 'shell';
 }
 
-function isCCRunning(session, socketPath) {
+/**
+ * 列出所有 tmux 会话 + 每个的 kind。
+ */
+function listTerms(socketPath) {
   const tmux = tmuxCmd(socketPath);
+  let lines;
   try {
-    const panePid = execSync(
-      `${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS
-    ).trim();
-    const self = execSync(`ps -o comm= -p ${panePid} 2>/dev/null`, EXEC_OPTS).trim();
-    if (['claude', 'claude-code'].includes(self)) return true;
-    try {
-      const child = execSync(`ps -o comm= --ppid ${panePid} 2>/dev/null`, EXEC_OPTS)
-        .trim().split('\n').pop() || '';
-      if (['claude', 'claude-code'].includes(child)) return true;
-    } catch {}
-  } catch {}
-  return false;
+    lines = execSync(`${tmux} list-sessions -F "#{session_name}"`, EXEC_OPTS)
+      .trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+  return lines.map((name) => ({ session: name, kind: detectKind(name, socketPath) }));
 }
 
 /**
- * 给 tmux session 里的 CC 发用户消息。
- * 用 -l (literal) 发文本 + 单独 Enter，保证 raw terminal mode 下不丢回车。
+ * 读 session 屏幕。默认 last N 行；full=true 读整屏 + scrollback 历史。
+ *
+ * 一律 `capture-pane -p -S -` 抓全量，在 JS 里去掉尾部空行再切最后 N 行。
+ * 不用 shell `| tail`——capture-pane 会把光标下方的空 viewport 行也输出，
+ * shell 的 tail 先抓到空行，内容稀疏的会话就读不到东西。
  */
-function sendToCC(session, text, { socketPath, skipCheck = false } = {}) {
+function readTerm(session, { lines = 20, full = false, socketPath } = {}) {
   const tmux = tmuxCmd(socketPath);
-  if (!skipCheck && !isCCRunning(session, socketPath)) {
-    throw new Error(`session "${session}": CC not running`);
-  }
-  // 用 -l 发纯文本（不解释特殊键）
-  execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(text)}`, EXEC_OPTS);
-  // 单独发 Enter 提交
-  execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+  const raw = execSync(
+    `${tmux} capture-pane -t "${session}" -p -S -`,
+    { ...EXEC_OPTS, maxBuffer: 16 * 1024 * 1024 }
+  );
+  if (full) return raw;
+  const n = parseInt(lines, 10) || 20;
+  return raw.replace(/\s+$/, '').split('\n').slice(-n).join('\n');
 }
 
 /**
- * 读 tmux session 的最后 N 行输出。
+ * 给 session 发文本和/或命名按键。
+ * - text：字面文本（-l）。默认末尾自动 Enter；noEnter 或同时有 keys 时抑制自动 Enter。
+ * - keys：tmux 命名按键（C-c / Enter / Escape / Up / Tab ...），按顺序发，不加 Enter。
+ * 二者可叠加：text 先发，再按顺序发 keys。
  */
-function readOutput(session, lines = 20, socketPath) {
+function sendTerm(session, { text, noEnter = false, keys = [], socketPath } = {}) {
   const tmux = tmuxCmd(socketPath);
-  return execSync(
-    `${tmux} capture-pane -t "${session}" -p | tail -${parseInt(lines) || 20}`,
-    EXEC_OPTS
-  );
+  const hasText = text != null && text !== '';
+  const hasKeys = Array.isArray(keys) && keys.length > 0;
+  if (!hasText && !hasKeys) {
+    throw new Error('sendTerm: 需要 text 或 keys 至少一个');
+  }
+  if (hasText) {
+    execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(text)}`, EXEC_OPTS);
+    if (!noEnter && !hasKeys) {
+      execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+    }
+  }
+  for (const k of (hasKeys ? keys : [])) {
+    execSync(`${tmux} send-keys -t "${session}" ${JSON.stringify(k)}`, EXEC_OPTS);
+  }
 }
 
 /**
- * 在新 tmux session 里启动 CC。
+ * 新建 tmux 会话并在里面起东西。会话名带 kind 前缀（cc-/codex-/sh-）。
+ * 会话先跑 bash，再 send 启动命令进去——这样程序退出后 bash 还在、
+ * 会话不死，restart 能在原会话里重起。
  */
-function startCC(dir, session, socketPath) {
+function startTerm({ kind, cmd, session, dir, socketPath } = {}) {
   const tmux = tmuxCmd(socketPath);
-  if (!existsSync(dir)) throw new Error(`dir not found: ${dir}`);
+  if (!kind || !(kind in KIND_CMD)) {
+    throw new Error(`startTerm: --kind 必须是 ${Object.keys(KIND_CMD).join('|')}`);
+  }
+  if (dir && !existsSync(dir)) throw new Error(`dir not found: ${dir}`);
+  const base = session || (dir ? basename(dir) : null);
+  if (!base) throw new Error('startTerm: 需要 --session 或 --dir');
+  const sessionName = `${KIND_PREFIX[kind]}-${base}`;
   try {
-    execSync(`${tmux} has-session -t "${session}" 2>/dev/null`, EXEC_OPTS);
-    throw new Error(`session "${session}" already exists`);
+    execSync(`${tmux} has-session -t "${sessionName}" 2>/dev/null`, EXEC_OPTS);
+    throw new Error(`session "${sessionName}" already exists`);
   } catch (e) {
     if (e.message.includes('already exists')) throw e;
   }
-  execSync(
-    `${tmux} new-session -d -s "${session}" -c "${dir}" 'claude --dangerously-skip-permissions'`,
-    { ...EXEC_OPTS, timeout: 10000 }
-  );
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+  const cwdArg = dir ? `-c "${dir}"` : '';
+  execSync(`${tmux} new-session -d -s "${sessionName}" ${cwdArg}`.trim(), { ...EXEC_OPTS, timeout: 10000 });
+  // kind=shell 且无 --cmd：new-session 本身就是 bash，不必再 send。
+  const startCmd = cmd || KIND_CMD[kind].fresh;
+  if (cmd || kind !== 'shell') {
+    execSync(`${tmux} send-keys -t "${sessionName}" -l ${JSON.stringify(startCmd)}`, EXEC_OPTS);
+    execSync(`${tmux} send-keys -t "${sessionName}" Enter`, EXEC_OPTS);
+  }
+  return { session: sessionName, kind, cmd: startCmd };
 }
 
 /**
- * 给 CC 发 /exit 然后重启（带 --continue）。
- * guardian 升级后自动重启 CC 用这个。
+ * restart 通用骨架：停 → 轮询确认停了 → 起 → 轮询确认起了 → 5s 存活复检。
+ * 返回 { ok, warning }。
  *
- * 不再固定等 3s——有 Stop hook（auto-save / semantic_memory）的 AI 退出要
- * 60-90s，3s 时旧 claude 还活着，重启命令会被当成旧 TUI 的 queued message，
- * CC 永远没重启。改成轮询 isCCRunning 确认状态再动作。
+ * 三个兜底（0.20.1 加）：
+ * - poll-down 超时：强制 kill（C-c → 不行再 kill pane 子进程）+ warning，然后照常 relaunch
+ * - poll-up 后 ~5s 存活复检：化解「起来一瞬间被检测到、随即自更新退出」的假 success
+ * - poll-up 失败：C-c 清半行重试一次
  */
-async function restartCC(session, { socketPath, continueSession = true } = {}) {
+async function restartSkeleton(session, socketPath, { targetKind, stopAction, downTimeout, startCmd }) {
   const tmux = tmuxCmd(socketPath);
-  const restartCmd = continueSession
-    ? 'claude --dangerously-skip-permissions --continue'
-    : 'claude --dangerously-skip-permissions';
-
-  // 1. 发 /exit
-  execSync(`${tmux} send-keys -t "${session}" -l '/exit'`, EXEC_OPTS);
-  execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
-
-  // 2. 轮询直到 CC 退出（120s 覆盖 90s Stop hook + 余量）
-  const exitDeadline = Date.now() + 120000;
-  while (isCCRunning(session, socketPath)) {
-    if (Date.now() >= exitDeadline) {
-      // 旧 CC 还没退，发重启命令会变成 queued message 污染 TUI——放弃
-      return false;
+  let warning = null;
+
+  // 1. 停
+  stopAction();
+
+  // 2. poll-down：轮询直到 kind 不再是 targetKind；超时强制 kill 兜底
+  const downDeadline = Date.now() + downTimeout;
+  while (detectKind(session, socketPath) === targetKind) {
+    if (Date.now() >= downDeadline) {
+      warning = `${targetKind} 未在 ${Math.round(downTimeout / 1000)}s 内优雅退出，已强制终止；`
+        + (targetKind === 'codex' ? 'resume 的会话可能不完整' : '会话状态可能不完整');
+      try { execSync(`${tmux} send-keys -t "${session}" C-c`, EXEC_OPTS); } catch {}
+      await sleep(2000);
+      if (detectKind(session, socketPath) === targetKind) {
+        try {
+          const panePid = execSync(
+            `${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS
+          ).trim();
+          execSync(`pkill -KILL -P ${panePid} 2>/dev/null || true`, EXEC_OPTS);
+        } catch {}
+        await sleep(2000);
+      }
+      break;
     }
     await sleep(1000);
   }
 
-  // 3. 退出确认后等 shell prompt 落定
+  // 3. 等 shell prompt 落定
   await sleep(500);
 
-  // 4-5. 发重启命令 + 轮询确认 CC 起来（30s 超时）
+  // 4-5. 起 + poll-up（30s）+ 5s 存活复检
   const tryStart = async () => {
     try {
-      execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(restartCmd)}`, EXEC_OPTS);
+      execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(startCmd)}`, EXEC_OPTS);
       execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
     } catch {
       return false;
     }
     const upDeadline = Date.now() + 30000;
-    while (!isCCRunning(session, socketPath)) {
+    while (detectKind(session, socketPath) !== targetKind) {
       if (Date.now() >= upDeadline) return false;
       await sleep(1000);
     }
-    return true;
+    // 存活复检：起来后等 5s 再确认还在（codex 启动可能撞自更新菜单、随即自退）
+    await sleep(5000);
+    return detectKind(session, socketPath) === targetKind;
   };
 
-  if (await tryStart()) return true;
+  if (await tryStart()) return { ok: true, warning, startCmd };
 
-  // 6. 超时没起来：C-c 清掉可能的半行，重试一次
-  try {
-    execSync(`${tmux} send-keys -t "${session}" C-c`, EXEC_OPTS);
-  } catch {}
+  // 6. 没起来 / 起来又随即退：C-c 清半行后重试一次
+  try { execSync(`${tmux} send-keys -t "${session}" C-c`, EXEC_OPTS); } catch {}
   await sleep(500);
-  return tryStart();
+  if (await tryStart()) return { ok: true, warning, startCmd };
+
+  return {
+    ok: false,
+    startCmd,
+    warning: warning
+      || `${targetKind} 启动后未稳定存活（可能启动时撞自更新随即退出），请 seam term read 确认`,
+  };
+}
+
+/**
+ * 重启 session 里跑的东西。只对 cc / codex 有意义——非 cc/codex（shell 或
+ * 自定义命令）直接报错，不静默重启成 bash。
+ *
+ * cc 与 codex 都走对称的优雅路径（发 exit 命令 → 轮询退出 → 续命命令重起），
+ * 差别（退出命令 / 超时 / 续命命令）全在 KIND_CMD 表里。
+ * 返回 { ok, warning }。
+ */
+async function restartTerm(session, { socketPath, continueSession = true } = {}) {
+  const tmux = tmuxCmd(socketPath);
+  const kind = detectKind(session, socketPath);
+  if (kind !== 'cc' && kind !== 'codex') {
+    throw new Error(
+      `"${session}" 不是 cc/codex 会话（检测到 kind=${kind === null ? '会话不存在' : kind}），`
+      + 'restart 不知道该用什么命令重启它。要重起请用 `seam term start --kind ... --cmd "..."`。'
+    );
+  }
+  const spec = KIND_CMD[kind];
+  const startCmd = continueSession ? spec.resume : spec.fresh;
+  return restartSkeleton(session, socketPath, {
+    targetKind: kind,
+    stopAction: () => {
+      execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(spec.exit)}`, EXEC_OPTS);
+      execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
+    },
+    downTimeout: spec.downTimeout,
+    startCmd,
+  });
+}
+
+/**
+ * 关掉整个终端（kill-session）。返回关之前检测到的 kind。
+ */
+function stopTerm(session, { socketPath } = {}) {
+  const tmux = tmuxCmd(socketPath);
+  const kind = detectKind(session, socketPath);
+  execSync(`${tmux} kill-session -t "${session}"`, EXEC_OPTS);
+  return { kind };
 }
 
-module.exports = { listSessions, isCCRunning, sendToCC, readOutput, startCC, restartCC, tmuxCmd };
+module.exports = {
+  tmuxCmd, detectKind, listTerms, readTerm, sendTerm,
+  startTerm, restartTerm, stopTerm, KIND_CMD,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamnet/client",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "One command to join Seam — the network where people and AI stay in sync.",
   "bin": {
     "seam-client": "bin/cli.js",