termdock 1.4.42 → 1.4.45

package/dist/server/ptyHost.js

@@ -148,6 +148,10 @@ function handleControl(msg) {
         case 'attach':
             attachChannel(msg.id, msg.since);
             return;
+        case 'ping':
+            // 服务端心跳：host 事件循环活着就立即回 pong；连续不回 = wedge。
+            send({ op: 'pong', t: msg.t });
+            return;
         case 'resize': {
             const ch = channels.get(msg.id);
             if (ch && !ch.exited) {
@@ -235,8 +239,15 @@ function shutdown() {
         fs.unlinkSync(SOCKET_PATH);
     }
     catch { /* already gone */ }
+    try {
+        fs.unlinkSync(pidFilePath());
+    }
+    catch { /* already gone */ }
     process.exit(0);
 }
+function pidFilePath() {
+    return `${SOCKET_PATH}.pid`;
+}
 function main() {
     fs.mkdirSync(path.dirname(SOCKET_PATH), { recursive: true, mode: 0o700 });
     // Stale socket from a crashed host: only our own pid could own it, and we
@@ -251,6 +262,12 @@ function main() {
             fs.chmodSync(SOCKET_PATH, 0o600);
         }
         catch { /* best effort */ }
+        // 写 pid 文件：服务端检测到这个 host wedge（心跳超时）时需要知道
+        // 杀谁——host 是 detached 的，pid 没法靠父子关系找回。
+        try {
+            fs.writeFileSync(pidFilePath(), String(process.pid), { mode: 0o600 });
+        }
+        catch { /* best effort */ }
         console.log(`[pty-host] listening on ${SOCKET_PATH} (pid ${process.pid})`);
     });
     // The host is meant to run forever; a dropped server connection is normal

package/dist/server/ptyhost/manager.js

@@ -17,6 +17,16 @@ import { FRAME_CONTROL, FRAME_DATA, FRAME_INPUT, FRAME_REPLAY, PTY_HOST_PROTOCOL
 const HOST_STARTUP_TIMEOUT_MS = 5_000;
 const HOST_STARTUP_POLL_MS = 50;
 const RECONNECT_DELAY_MS = 500;
+/** connect + helloAck 的总等待上限。host 活着但 wedge（内核 backlog 收下
+ * 连接、事件循环不回包）时，没有这个上限 promise 会永不 settle——且
+ * ensureConnected 的 connecting 锁存器会让之后所有调用挂在同一个
+ * promise 上，表现为"一次卡住、之后全部卡住"。 */
+const CONNECT_HANDSHAKE_TIMEOUT_MS = 4_000;
+/** spawn 发出后等 host 回 spawned 的上限。 */
+const SPAWN_RESPONSE_TIMEOUT_MS = 10_000;
+/** 心跳：连续 HEARTBEAT_MISS_LIMIT 个间隔没有 pong 判定 host wedge。 */
+const HEARTBEAT_INTERVAL_MS = 15_000;
+const HEARTBEAT_MISS_LIMIT = 2;
 function hostSocketDir() {
     return path.join(os.homedir(), '.termdock', 'pty-hosts');
 }
@@ -143,6 +153,9 @@ export class PtyHostManager {
     helloResolve = null;
     pendingSpawns = new Map();
     reconnectTimer = null;
+    heartbeatTimer = null;
+    lastPongAt = 0;
+    killingWedgedHost = null;
     stopped = false;
     /** Resolve when the host is connected + handshaken; returns live channels. */
     ensureConnected() {
@@ -157,12 +170,20 @@ export class PtyHostManager {
             return await this.connectOnce();
         }
         catch (error) {
-            if (error.code !== 'ENOENT'
-                && error.code !== 'ECONNREFUSED') {
+            const code = error.code;
+            if (code === 'ENOENT' || code === 'ECONNREFUSED') {
+                this.spawnHostDaemon();
+            }
+            else if (code === 'PTY_HOST_HANDSHAKE_TIMEOUT') {
+                // host 活着但 wedge（accept 连接不回 helloAck）：杀掉再重生。
+                console.warn('[pty-host] handshake timed out — replacing wedged host:', ptyHostSocketPath());
+                await this.killWedgedHost();
+                this.spawnHostDaemon();
+            }
+            else {
                 throw error;
             }
         }
-        this.spawnHostDaemon();
         const deadline = Date.now() + HOST_STARTUP_TIMEOUT_MS;
         let lastError = null;
         while (Date.now() < deadline) {
@@ -176,6 +197,66 @@ export class PtyHostManager {
         }
         throw new Error(`pty-host did not start listening in time: ${lastError?.message ?? lastError}`);
     }
+    /** 杀掉 wedge 的 host（SIGTERM → 1s 后 SIGKILL）并清理 socket/pid 文件。
+     * 等旧 host 确实死了才返回——否则旧 host 的 SIGTERM shutdown 可能删掉
+     * 新 host 刚 bind 的 socket 文件。并发调用共享同一次 kill。 */
+    killWedgedHost() {
+        if (!this.killingWedgedHost) {
+            this.killingWedgedHost = this.doKillWedgedHost().finally(() => {
+                this.killingWedgedHost = null;
+            });
+        }
+        return this.killingWedgedHost;
+    }
+    async doKillWedgedHost() {
+        const sockPath = ptyHostSocketPath();
+        const pidPath = `${sockPath}.pid`;
+        let pid = null;
+        try {
+            const parsed = Number(fs.readFileSync(pidPath, 'utf8').trim());
+            if (Number.isInteger(parsed) && parsed > 1)
+                pid = parsed;
+        }
+        catch { /* 无 pid 文件（host 早于该特性）——只能放弃精准击杀 */ }
+        if (pid) {
+            const alive = () => {
+                try {
+                    process.kill(pid, 0);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            };
+            console.warn(`[pty-host] killing wedged host (pid ${pid})`);
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch { /* already gone */ }
+            let deadline = Date.now() + 1_000;
+            while (alive() && Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            if (alive()) {
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch { /* already gone */ }
+                deadline = Date.now() + 1_000;
+                while (alive() && Date.now() < deadline) {
+                    await new Promise((r) => setTimeout(r, 50));
+                }
+            }
+        }
+        try {
+            fs.unlinkSync(sockPath);
+        }
+        catch { /* gone */ }
+        try {
+            fs.unlinkSync(pidPath);
+        }
+        catch { /* gone */ }
+    }
     spawnHostDaemon() {
         const { command, args } = resolveHostEntry();
         fs.mkdirSync(hostSocketDir(), { recursive: true, mode: 0o700 });
@@ -192,7 +273,14 @@ export class PtyHostManager {
     connectOnce() {
         return new Promise((resolvePromise, rejectPromise) => {
             const conn = net.createConnection(ptyHostSocketPath());
+            const timer = setTimeout(() => {
+                const error = new Error('pty-host handshake timed out');
+                error.code = 'PTY_HOST_HANDSHAKE_TIMEOUT';
+                conn.destroy();
+                rejectPromise(error);
+            }, CONNECT_HANDSHAKE_TIMEOUT_MS);
             const onError = (error) => {
+                clearTimeout(timer);
                 conn.destroy();
                 rejectPromise(error);
             };
@@ -200,11 +288,42 @@ export class PtyHostManager {
             conn.once('connect', () => {
                 conn.removeListener('error', onError);
                 this.attachConnection(conn);
-                this.helloResolve = resolvePromise;
+                this.helloResolve = (channels) => {
+                    clearTimeout(timer);
+                    // handleDisconnect 会用 [] 兜底调用这里——连接已死时不开心跳。
+                    if (this.conn === conn && !conn.destroyed)
+                        this.startHeartbeat();
+                    resolvePromise(channels);
+                };
                 conn.write(encodeControl({ op: 'hello', v: PTY_HOST_PROTOCOL_VERSION }));
             });
         });
     }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.lastPongAt = Date.now();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.conn || this.conn.destroyed) {
+                this.stopHeartbeat();
+                return;
+            }
+            if (Date.now() - this.lastPongAt > HEARTBEAT_INTERVAL_MS * HEARTBEAT_MISS_LIMIT) {
+                // host 事件循环 wedge：杀旧 host（新 host 由重连路径 respawn）。
+                console.warn('[pty-host] heartbeat missed — host appears wedged, replacing it:', ptyHostSocketPath());
+                this.stopHeartbeat();
+                this.conn.destroy();
+                void this.killWedgedHost();
+                return;
+            }
+            this.send({ op: 'ping', t: Date.now() });
+        }, HEARTBEAT_INTERVAL_MS);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
     attachConnection(conn) {
         if (this.conn && !this.conn.destroyed)
             this.conn.destroy();
@@ -264,6 +383,9 @@ export class PtyHostManager {
             case 'replayEnd':
                 this.clients.get(control.id)?.handleReplayEnd(control.offset);
                 return;
+            case 'pong':
+                this.lastPongAt = Date.now();
+                return;
             case 'exit': {
                 const client = this.clients.get(control.id);
                 if (client) {
@@ -276,6 +398,7 @@ export class PtyHostManager {
         }
     }
     handleDisconnect() {
+        this.stopHeartbeat();
         this.helloResolve?.([]);
         this.helloResolve = null;
         for (const pending of this.pendingSpawns.values()) {
@@ -336,8 +459,26 @@ export class PtyHostManager {
         await this.ensureConnected();
         const client = new PtyHostClient(this, id);
         this.clients.set(id, client);
+        let spawnTimer = null;
         const spawned = new Promise((resolvePromise, rejectPromise) => {
-            this.pendingSpawns.set(id, { resolve: resolvePromise, reject: rejectPromise });
+            // host wedge 时 spawned 永远不会来——必须有超时，否则这里永挂。
+            spawnTimer = setTimeout(() => {
+                const error = new Error('pty-host spawn timed out');
+                error.code = 'PTY_HOST_SPAWN_TIMEOUT';
+                rejectPromise(error);
+            }, SPAWN_RESPONSE_TIMEOUT_MS);
+            this.pendingSpawns.set(id, {
+                resolve: (result) => {
+                    if (spawnTimer)
+                        clearTimeout(spawnTimer);
+                    resolvePromise(result);
+                },
+                reject: (error) => {
+                    if (spawnTimer)
+                        clearTimeout(spawnTimer);
+                    rejectPromise(error);
+                },
+            });
         });
         this.send({ op: 'spawn', id, spec });
         try {
@@ -351,6 +492,12 @@ export class PtyHostManager {
         }
         catch (error) {
             this.clients.delete(id);
+            this.pendingSpawns.delete(id);
+            // spawn 超时 ≈ host wedge：断连触发 handleDisconnect 的自愈重连。
+            if (error.code === 'PTY_HOST_SPAWN_TIMEOUT') {
+                console.warn('[pty-host] spawn timed out — host may be wedged, dropping connection:', ptyHostSocketPath());
+                this.conn?.destroy();
+            }
             throw error;
         }
     }

package/dist/server/quota/tokenDiscovery.js

@@ -142,8 +142,33 @@ export function discoverCodexTokens() {
     return discoverCodexFromEnv();
 }
 // ── Kimi ─────────────────────────────────────────────────────────────
+/** Kimi Code CLI stores OAuth device-code credentials here (`kimi login`). */
+function discoverKimiFromCredentials() {
+    const credPath = path.join(HOME, '.kimi-code', 'credentials', 'kimi-code.json');
+    try {
+        const raw = fs.readFileSync(credPath, 'utf-8');
+        const cred = JSON.parse(raw);
+        if (typeof cred.access_token !== 'string' || !cred.access_token.trim()) {
+            return [];
+        }
+        // expires_at: epoch seconds (or ms on some versions); expired → skip so
+        // the env/opencode fallbacks still get a chance.
+        const exp = Number(cred.expires_at);
+        if (Number.isFinite(exp) && exp > 0) {
+            const expMs = exp > 1e12 ? exp : exp * 1000;
+            if (Date.now() >= expMs)
+                return [];
+        }
+        return [{ token: cred.access_token.trim(), source: 'kimi-code credentials' }];
+    }
+    catch {
+        return [];
+    }
+}
 export function discoverKimiTokens() {
     const results = [];
+    // Priority: kimi-code OAuth credentials > env > legacy config > OpenCode auth
+    results.push(...discoverKimiFromCredentials());
     // Check KIMI_API_KEY env
     const envKey = process.env.KIMI_API_KEY;
     if (envKey?.trim()) {

package/dist/server/routes/filesystem.js

@@ -2455,8 +2455,10 @@ router.get('/read', async (req, res) => {
             throwIfAborted(controller.signal, 'fs.read');
             const stat = await fs.promises.stat(resolvedPath);
             throwIfAborted(controller.signal, 'fs.read');
-            if (stat.isDirectory()) {
-                throw new Error('Path is a directory, not a file');
+            // 只允许常规文件：FIFO / unix socket / 设备文件的 open() 会永久占住
+            // 一个 libuv 线程且不可取消（线程池耗尽 = 整个服务 IO 假死）。
+            if (!stat.isFile()) {
+                throw new Error('Path is not a regular file');
             }
             const bytesToRead = Math.min(stat.size, MAX_FILE_SIZE);
             const truncated = stat.size > bytesToRead;

package/dist/server/routes/notifications.js

@@ -17,6 +17,7 @@ router.get('/status', (req, res) => {
                 endpoint: subscription.endpoint,
                 expirationTime: subscription.expirationTime,
                 aiEnabled: subscription.aiEnabled,
+                exitEnabled: subscription.exitEnabled,
                 alertStyle: subscription.alertStyle,
                 locale: subscription.locale,
                 updatedAt: subscription.updatedAt,
@@ -26,7 +27,7 @@ router.get('/status', (req, res) => {
 });
 router.post('/subscribe', (req, res) => {
     const clientId = clientIdFromRequest(req);
-    const { subscription, aiEnabled, alertStyle, locale } = req.body ?? {};
+    const { subscription, aiEnabled, exitEnabled, alertStyle, locale } = req.body ?? {};
     if (!clientId
         || typeof subscription?.endpoint !== 'string'
         || subscription.endpoint.length > 4096
@@ -49,19 +50,24 @@ router.post('/subscribe', (req, res) => {
             auth: subscription.keys.auth,
         },
         aiEnabled: aiEnabled !== false,
+        exitEnabled: exitEnabled === true,
         alertStyle,
         locale: typeof locale === 'string' ? locale.slice(0, 32) : 'zh-CN',
     });
     res.json({ ok: true, updatedAt: saved.updatedAt });
 });
 router.post('/preferences', (req, res) => {
-    const { aiEnabled, alertStyle, locale } = req.body ?? {};
-    if (typeof aiEnabled !== 'boolean' || !validAlertStyle(alertStyle)) {
+    const { aiEnabled, exitEnabled, alertStyle, locale } = req.body ?? {};
+    if (typeof aiEnabled !== 'boolean'
+        || (exitEnabled !== undefined && typeof exitEnabled !== 'boolean')
+        || !validAlertStyle(alertStyle)) {
         res.status(400).json({ error: 'Invalid notification preferences' });
         return;
     }
     const updated = updatePushPreferences(clientIdFromRequest(req), {
         aiEnabled,
+        // Optional so stale cached clients don't wipe the newer toggle.
+        ...(typeof exitEnabled === 'boolean' ? { exitEnabled } : {}),
         alertStyle,
         locale: typeof locale === 'string' ? locale.slice(0, 32) : 'zh-CN',
     });

package/dist/server/routes/terminal.js

@@ -14,7 +14,8 @@ import { getPtyHostManager } from '../ptyhost/manager.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { TERMINAL, TMUX } from '../config.js';
 import { localAccessManager } from '../utils/localAccess.js';
-import { normalizeLocalAccessName, getActivityReorderSetting, getLocaleSetting, setActivityReorderSetting, setLocaleSetting, } from '../utils/settings.js';
+import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, } from '../utils/settings.js';
+import { loadContextDraft, saveContextDraft } from '../utils/contextDraft.js';
 import { getOnboardingServerUrl } from '../onboardingServer.js';
 import { getFocusSequence, removeClientFocusState, scanFocusTrackingMode, setClientFocusState, } from '../utils/tmuxFocus.js';
 import { extractProgramLabelFromArgs, normalizeProgramName, normalizeTmuxMetadataProgram, selectTmuxForegroundProgram, tmuxMetadataChanged, } from '../utils/tmuxProgramDetection.js';
@@ -23,7 +24,8 @@ import { applyAgentEvent, defaultAgentSessionState, parseAgentEvent, } from '../
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.js';
 import { loadPlugins, savePlugin, removePlugin, readPluginIcon, } from '../agent/plugins.js';
 import { registerPluginAgents } from '../agent/registry.js';
-import { notifyAgentTransition } from '../notifications/pushService.js';
+import { notifyAgentTransition, notifyTerminalExit } from '../notifications/pushService.js';
+import { setClientViewingSession } from '../notifications/pushViewers.js';
 import { getQuotaStatus, refreshQuota, startQuotaManager, } from '../quota/QuotaManager.js';
 const router = express.Router();
 const execFileAsync = promisify(execFile);
@@ -106,81 +108,6 @@ let lastBroadcastClientStateSignature = null;
 const inventoryOpenLocks = new Map();
 const CONTROL_BROADCAST_COALESCE_MS = 50;
 const SESSION_INVENTORY_CACHE_TTL_MS = 1500;
-// 最近活跃优先排序：不是竞速榜，只分「最近活跃」和「非活跃」两组。
-// 活跃组整体在前，组内保持当前相对顺序，避免两个持续输出的 session
-// 按毫秒级 lastActivity 来回抢第一个位置。
-const RECENT_ACTIVITY_WINDOW_MS = 60_000;
-const ACTIVITY_REORDER_COOLDOWN_MS = 5_000;
-const ACTIVITY_REORDER_PERIODIC_MS = 30_000;
-let activityReorderTimer = null;
-let activityReorderPeriodicTimer = null;
-let activityReorderEnabled = getActivityReorderSetting();
-function getEffectiveLastActivity(session) {
-    // 只用 PTY 输出时间判断「最近活跃」——resize / input / connect
-    // 不参与排序，避免拖窗口尺寸等非输出操作导致 session 跳到前面。
-    if (session.backendSessionId) {
-        const backend = terminalSessions.get(session.backendSessionId);
-        if (backend)
-            return backend.lastOutputAt;
-    }
-    return session.lastActivity;
-}
-function applyActivityBasedReorder() {
-    if (!activityReorderEnabled)
-        return;
-    const sessions = globalSessionState.sessions;
-    if (sessions.length <= 1)
-        return;
-    const now = Date.now();
-    const recentlyActive = [];
-    const inactive = [];
-    for (const session of sessions) {
-        const la = getEffectiveLastActivity(session);
-        if (now - la <= RECENT_ACTIVITY_WINDOW_MS) {
-            recentlyActive.push(session);
-        }
-        else {
-            inactive.push(session);
-        }
-    }
-    // 两个 bucket 内各自保持原有相对顺序，只是活跃组整体提前
-    const reordered = [...recentlyActive, ...inactive];
-    const orderChanged = sessions.map(s => s.sessionId).join('\x00') !== reordered.map(s => s.sessionId).join('\x00');
-    if (!orderChanged)
-        return;
-    globalSessionState = {
-        sessions: reordered,
-        updatedAt: Date.now(),
-    };
-    persistAndBroadcastGlobalState();
-}
-function scheduleActivityReorder() {
-    if (activityReorderTimer)
-        return;
-    activityReorderTimer = setTimeout(() => {
-        activityReorderTimer = null;
-        applyActivityBasedReorder();
-    }, ACTIVITY_REORDER_COOLDOWN_MS);
-    activityReorderTimer.unref?.();
-}
-function startActivityReorderPeriodic() {
-    if (activityReorderPeriodicTimer)
-        return;
-    activityReorderPeriodicTimer = setInterval(() => {
-        applyActivityBasedReorder();
-    }, ACTIVITY_REORDER_PERIODIC_MS);
-    activityReorderPeriodicTimer.unref?.();
-}
-function stopActivityReorderPeriodic() {
-    if (activityReorderPeriodicTimer) {
-        clearInterval(activityReorderPeriodicTimer);
-        activityReorderPeriodicTimer = null;
-    }
-    if (activityReorderTimer) {
-        clearTimeout(activityReorderTimer);
-        activityReorderTimer = null;
-    }
-}
 async function getSessionInventorySnapshot(options = {}) {
     const now = Date.now();
     if (!options.refresh && latestSessionInventory && now - latestSessionInventoryAt < SESSION_INVENTORY_CACHE_TTL_MS) {
@@ -462,8 +389,8 @@ function flushPersistAndExit() {
     }
     catch { /* best effort */ }
 }
-process.on('SIGTERM', () => { stopActivityReorderPeriodic(); flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
-process.on('SIGINT', () => { stopActivityReorderPeriodic(); flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
+process.on('SIGTERM', () => { flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
+process.on('SIGINT', () => { flushPersistAndExit(); void persistToolbarPresetsNow(); caffeinateManager.shutdown(); process.exit(0); });
 // 服务启动时从磁盘加载（带去重，防止历史累积的重复条目复活）
 void (async () => {
     await loadGlobalSessionStateFromDisk();
@@ -476,8 +403,6 @@ void (async () => {
     });
     pruneOrphanSessions();
     await backfillPersistedTmuxMetadata();
-    startActivityReorderPeriodic();
-    applyActivityBasedReorder();
 })();
 caffeinateManager.startNetworkMonitor();
 // 清理磁盘恢复后后端已不存在的 session 引用。
@@ -2777,10 +2702,26 @@ async function enableTmuxFocusEvents() {
     await runTmux(['set-option', '-g', 'focus-events', 'on']);
     console.log('[tmux-focus] enabled global focus-events');
 }
+// Let tmux forward modified Enter keys (Ctrl/Shift/Alt+Enter) to pane apps.
+// The option only exists in tmux >= 3.2; on older versions the probe fails
+// and we silently skip.
+async function enableTmuxExtendedKeys() {
+    try {
+        const current = (await runTmux(['show-options', '-gqv', 'extended-keys'])).trim();
+        if (current === 'on')
+            return;
+        await runTmux(['set-option', '-g', 'extended-keys', 'on']);
+        console.log('[tmux] enabled global extended-keys');
+    }
+    catch {
+        // extended-keys unsupported on this tmux; nothing to do
+    }
+}
 async function ensureSharedTmuxServerReady() {
     await ensureTmuxColorEnvironment();
     await applyTmuxScrollbackProfile();
     await enableTmuxFocusEvents();
+    await enableTmuxExtendedKeys();
     await configureTmuxWheelBindings();
 }
 async function stampTmuxMetadata(sessionName) {
@@ -3310,7 +3251,6 @@ function processSessionOutput(sessionId, session, data, opts) {
         session.lastActivity = Date.now();
         session.lastOutputAt = Date.now();
         session.hasWrittenData = true;
-        scheduleActivityReorder();
     }
     let seq;
     if (session.mode === 'shell') {
@@ -3384,6 +3324,17 @@ function setupPtyHandlers(sessionId, session) {
     session.exitDisposable = session.ptyProcess.onExit(({ exitCode, signal }) => {
         console.log(`Terminal session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
         broadcastEvent(sessionId, { type: 'exit', exitCode, signal });
+        // User-initiated closes dispose this listener before killing the pty, so
+        // reaching here means the process exited on its own. Sessions with a live
+        // agent already get their exit covered by notifyAgentTransition — skip
+        // those to avoid two notifications for one event.
+        const snapshot = lastAgentStatusSnapshots.get(sessionId);
+        const hasLiveAgent = snapshot
+            ? JSON.parse(snapshot).agentStatus !== null
+            : false;
+        if (!hasLiveAgent) {
+            notifyTerminalExit(sessionId, typeof exitCode === 'number' ? exitCode : null);
+        }
         cleanupSession(sessionId, { killProcess: false });
     });
 }
@@ -3982,7 +3933,6 @@ router.get('/client-state', async (_req, res) => {
 });
 router.get('/session-inventory', async (_req, res) => {
     try {
-        applyActivityBasedReorder();
         const inventory = await getSessionInventorySnapshot();
         res.json(inventory);
     }
@@ -4153,6 +4103,7 @@ async function getSettingsPayload() {
         caffeinateActive: caffeinateManager.isActive(),
         networkAvailable: caffeinateManager.isNetworkAvailable(),
         locale: getLocaleSetting(),
+        contextDraftHeight: getContextDraftHeightSetting(),
         localAccess: {
             ...localAccess,
             interfaces,
@@ -4160,29 +4111,6 @@ async function getSettingsPayload() {
         },
     };
 }
-// ── Activity reorder preference ──────────────────────────────────────
-router.get('/settings/activity-reorder', (_req, res) => {
-    res.json({ enabled: activityReorderEnabled });
-});
-router.put('/settings/activity-reorder', (req, res) => {
-    const body = req.body ?? {};
-    if (typeof body.enabled === 'boolean') {
-        setActivityReorderSetting(body.enabled);
-        activityReorderEnabled = body.enabled;
-        // 关闭后立刻停掉还在队列里的 reorder timer
-        if (!activityReorderEnabled && activityReorderTimer) {
-            clearTimeout(activityReorderTimer);
-            activityReorderTimer = null;
-        }
-        // 如果重新开启,立刻执行一次排序
-        if (activityReorderEnabled) {
-            applyActivityBasedReorder();
-        }
-        res.json({ enabled: activityReorderEnabled });
-        return;
-    }
-    res.status(400).json({ error: '"enabled" must be a boolean' });
-});
 // ── Settings (prevent sleep) ──────────────────────────────────────────
 router.get('/settings', async (_req, res) => {
     res.json(await getSettingsPayload());
@@ -4195,6 +4123,18 @@ router.put('/settings', async (req, res) => {
     if (typeof body.locale === 'string' && (body.locale === 'zh' || body.locale === 'en')) {
         setLocaleSetting(body.locale);
     }
+    if (body.contextDraftHeight && typeof body.contextDraftHeight === 'object') {
+        const heightBody = body.contextDraftHeight;
+        for (const device of ['mobile', 'desktop']) {
+            const value = heightBody[device];
+            if (value === null) {
+                setContextDraftHeightSetting(device, null);
+            }
+            else if (typeof value === 'number' && Number.isFinite(value) && value >= 56 && value <= 4000) {
+                setContextDraftHeightSetting(device, Math.round(value));
+            }
+        }
+    }
     if (body.localAccess && typeof body.localAccess === 'object') {
         const localAccessBody = body.localAccess;
         if (localAccessBody.reset === true) {
@@ -4215,6 +4155,27 @@ router.put('/settings', async (req, res) => {
     }
     res.json(await getSettingsPayload());
 });
+// ── Context draft (cross-device realtime sync) ────────────────────────
+// 草稿内容存服务端（~/.termdock/context-draft.json），PUT 后通过 control
+// WebSocket 广播给其它客户端；携带 origin 让发送方忽略自己的回声。
+router.get('/context-draft', (_req, res) => {
+    res.json(loadContextDraft());
+});
+router.put('/context-draft', (req, res) => {
+    const body = req.body ?? {};
+    if (typeof body.text !== 'string') {
+        res.status(400).json({ error: 'Invalid draft text', code: 'INVALID_CONTEXT_DRAFT' });
+        return;
+    }
+    const doc = saveContextDraft(body.text);
+    broadcastControlEvent({
+        type: 'context-draft',
+        text: doc.text,
+        updatedAt: doc.updatedAt,
+        origin: typeof body.origin === 'string' ? body.origin : null,
+    });
+    res.json(doc);
+});
 // ── Agent hooks API (rich status channel installers, built-in + plugin) ──
 router.get('/agent-hooks', (_req, res) => {
     res.json({ agents: listAllHookAgents() });
@@ -5355,6 +5316,18 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}) {
                     updateClientFocusState(sessionId, session, clientId, focused, reason);
                     break;
                 }
+                case 'viewing': {
+                    // Push suppression: while this client is actively viewing the
+                    // session, its agent-transition push is redundant — skip it.
+                    // Kept separate from 'focus' (which requires textarea focus for
+                    // tmux focus tracking): on mobile the keyboard is routinely
+                    // dismissed while the user is still watching the session.
+                    if (options.pushClientId) {
+                        const viewing = msg.viewing === true;
+                        setClientViewingSession(options.pushClientId, sessionId, viewing);
+                    }
+                    break;
+                }
                 case 'flow-control': {
                     if (typeof msg.paused === 'boolean') {
                         const reason = typeof msg.reason === 'string' ? msg.reason : 'client-flow-control';
@@ -5404,6 +5377,9 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}) {
             }
         }
         removeClientFocus(sessionId, session, clientId);
+        if (options.pushClientId) {
+            setClientViewingSession(options.pushClientId, sessionId, false);
+        }
         removeClientFlowPaused(sessionId, session, clientId, 'client-disconnect');
         syncClientCountToTmux(sessionId);
         broadcastClientState();