chatccc 0.2.283 → 0.2.284

package/README.md

@@ -449,6 +449,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ChatCCC 的内部重启和更新使用跨平台父子进程握手：替代进程完成启动预检后通知父进程退出，再等待旧监听端口实际释放并接管 PID；替代进程未就绪或握手超时时，父进程会保留并继续服务。
 
+Codex 和 Cursor 在 Linux/macOS 下使用独立进程组。停止时先显示“正在停止”，待进程组内后代退出后再显示“已停止”；仅外层 shell 退出不算清理完成。重复停止请求合并处理，清理失败会保留会话进程占用保护并报告“Agent 停止未完成”，后续请求必须先完成清理才能启动新 Agent。Windows 继续使用 `taskkill /T /F`，命令失败或超时不会当作成功。
+
 飞书接收长连接启用 15 秒握手超时和 30 秒心跳应答超时；首次启动最多等待 45 秒真实连接确认后才提示就绪。运行期间连接持续异常 90 秒时，会关闭并重新建立接收连接，保留会话、消息去重和正在执行的任务。没有用户消息不会触发重连。连接状态与恢复记录写入运行日志和 `startup-trace.log`（`FEISHU-CONNECTION` / `feishu-connection`）。卡片更新遇到网络失败或序号冲突时不会当成送达成功，错误通知保留文本兜底；TLS 断线会明确显示为网络连接失败，已中断的 Agent 任务不会因此自动重放。
 
 > **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。

package/dist/src/adapters/codex-adapter.js

@@ -8,12 +8,12 @@
 // =============================================================================
 import { spawn } from "node:child_process";
 import { createTurnCompletion } from "./turn-completion.js";
+import { cliProcessOptions, ensureCliSessionReleased, ownCliProcess } from "./managed-cli-process.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseUserCommand } from "./adapter-interface.js";
 import { defaultCodexSessionMetaStore, } from "./codex-session-meta-store.js";
-import { killProcessTree } from "./proc-tree-kill.js";
 import { config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
 import { readJsonLinesWithBadJsonIdleWatchdog } from "./jsonl-stream.js";
@@ -159,6 +159,7 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
         windowsHide: true,
         shell: true,
+        ...cliProcessOptions(),
     });
     let stderr = "";
     let exitCode = null;
@@ -226,6 +227,9 @@ class CodexAdapter {
         return { sessionId };
     }
     async *prompt(sessionId, userText, cwd, signal, options) {
+        if (signal?.aborted)
+            return;
+        await ensureCliSessionReleased(sessionId);
         let meta = await this.metaStore.get(sessionId);
         const threadId = meta?.threadId;
         const isFirstPrompt = !threadId;
@@ -240,6 +244,7 @@ class CodexAdapter {
             : [...baseArgs, "resume", threadId, "-"];
         const handle = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
         const proc = handle.proc;
+        const ownership = ownCliProcess(sessionId, proc.pid);
         if (proc.pid !== undefined)
             options?.onProcessStart?.({ pid: proc.pid });
         const rawLogConfig = config.rawStreamLogs.codex;
@@ -262,7 +267,7 @@ class CodexAdapter {
         // 真正干活的是壳的孙子 codex.exe。普通 proc.kill() 在 Windows 上只杀第一层，
         // 会留下幽灵 node + codex.exe 继续烧 token、stream-state 永远停在 running。
         // 因此 abort 与 finally 都必须用 killProcessTree 整棵进程树一起收尸。
-        const onAbort = () => { void killProcessTree(proc.pid); };
+        const onAbort = () => { void ownership.stop().catch(() => { }); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let completed = false;
         const completion = createTurnCompletion("Codex");
@@ -293,10 +298,16 @@ class CodexAdapter {
         }
         finally {
             signal?.removeEventListener("abort", onAbort);
-            await killProcessTree(proc.pid);
-            await rawLog?.close({ keep: rawLogConfig.keepCompleted || signal?.aborted === true || !completed });
-            if (proc.pid !== undefined)
-                options?.onProcessExit?.({ pid: proc.pid });
+            let released = false;
+            try {
+                await ownership.stop();
+                released = true;
+            }
+            finally {
+                await rawLog?.close({ keep: !released || rawLogConfig.keepCompleted || signal?.aborted === true || !completed });
+                if (released && proc.pid !== undefined)
+                    options?.onProcessExit?.({ pid: proc.pid });
+            }
         }
     }
     async getSessionInfo(sessionId) {

package/dist/src/adapters/cursor-adapter.js

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseUserCommand } from "./adapter-interface.js";
 import { createTurnCompletion } from "./turn-completion.js";
+import { cliProcessOptions, ensureCliSessionReleased, ownCliProcess } from "./managed-cli-process.js";
 import { config, CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultCursorSessionMetaStore, } from "./cursor-session-meta-store.js";
 import { killProcessTree } from "./proc-tree-kill.js";
@@ -288,6 +289,7 @@ function spawnAgent(extraArgs, cwd, stdinText, modelOverride, mode, spawnImpl =
         stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
         windowsHide: true,
         shell: true,
+        ...cliProcessOptions(),
     });
     console.log(`[Cursor debug] spawn: cmd=${CURSOR_AGENT_COMMAND}, args=[${allArgs.join(", ")}], cwd=${cwd ?? "(none)"}, stdinLen=${stdinText?.length ?? 0}, pid=${proc.pid}`);
     // 收集 stderr，子进程异常退出时输出到日志，方便排查静默失败
@@ -411,15 +413,20 @@ class CursorAdapter {
         }
         finally {
             signal?.removeEventListener("abort", onAbort);
-            await killProcessTree(proc.pid);
+            if (await killProcessTree(proc.pid) === false)
+                throw new Error(`Cursor 初始化进程未确认退出（PID ${proc.pid}）`);
             this.activeProcs.delete(proc);
         }
     }
     async *prompt(sessionId, userText, cwd, signal, options) {
+        if (signal?.aborted)
+            return;
+        await ensureCliSessionReleased(sessionId);
         console.log(`[Cursor debug] prompt start: sessionId=${sessionId}, cwd=${cwd}, userTextLen=${userText.length}`);
         const cmd = parseUserCommand(userText);
         const handle = spawnAgent(["--resume", sessionId], cwd, buildCursorPromptText(userText), this.modelOverride, cmd.mode ?? undefined, this.spawnImpl);
         const proc = handle.proc;
+        const ownership = ownCliProcess(sessionId, proc.pid);
         this.activeProcs.add(proc);
         if (proc.pid !== undefined)
             options?.onProcessStart?.({ pid: proc.pid });
@@ -441,7 +448,7 @@ class CursorAdapter {
         }
         // 见 codex-adapter.ts 同位置注释：spawn 用了 shell:true，必须杀整棵树，
         // 否则 abort 后真正在跑的孙进程 cursor-agent 还会继续输出 & 占用资源。
-        const onAbort = () => { void killProcessTree(proc.pid); };
+        const onAbort = () => { void ownership.stop().catch(() => { }); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let sawResult = false;
         const completion = createTurnCompletion("Cursor");
@@ -469,7 +476,7 @@ class CursorAdapter {
                     if (!normalized?.isFinalResponse)
                         yield { type: "assistant", blocks: [], isFinalResponse: true };
                     sawResult = true;
-                    void killProcessTree(proc.pid);
+                    void ownership.stop().catch(() => { });
                     break;
                 }
             }
@@ -492,11 +499,17 @@ class CursorAdapter {
         }
         finally {
             signal?.removeEventListener("abort", onAbort);
-            await killProcessTree(proc.pid);
-            await rawLog?.close({ keep: rawLogConfig.keepCompleted || signal?.aborted === true || !sawResult });
-            this.activeProcs.delete(proc);
-            if (proc.pid !== undefined)
-                options?.onProcessExit?.({ pid: proc.pid });
+            let released = false;
+            try {
+                await ownership.stop();
+                released = true;
+            }
+            finally {
+                await rawLog?.close({ keep: !released || rawLogConfig.keepCompleted || signal?.aborted === true || !sawResult });
+                this.activeProcs.delete(proc);
+                if (released && proc.pid !== undefined)
+                    options?.onProcessExit?.({ pid: proc.pid });
+            }
             console.log(`[Cursor debug] prompt end: sessionId=${sessionId}, signalAborted=${signal?.aborted ?? false}`);
         }
     }

package/dist/src/adapters/managed-cli-process.js

@@ -0,0 +1,43 @@
+import { killProcessTree } from "./proc-tree-kill.js";
+export function cliProcessOptions(platform = process.platform) {
+    return { detached: platform !== "win32" };
+}
+const owners = new Map();
+export class ProcessCleanupError extends Error {
+    code = "PROCESS_CLEANUP_FAILED";
+}
+/** A new adapter instance must not bypass a previous failed cleanup. */
+export async function ensureCliSessionReleased(sessionId) {
+    const owner = owners.get(sessionId);
+    if (!owner)
+        return;
+    if (!owner.stopping)
+        throw new Error("该会话的 Agent 仍在执行，暂不能启动另一个进程");
+    await owner.stop();
+}
+export function ownCliProcess(sessionId, pid) {
+    let pending;
+    let finished = false;
+    const owner = {
+        stopping: false,
+        stop() {
+            if (finished)
+                return Promise.resolve();
+            if (pending)
+                return pending;
+            owner.stopping = true;
+            pending = killProcessTree(pid).then(ok => {
+                if (ok === false)
+                    throw new ProcessCleanupError(`Agent 进程未确认退出（PID ${pid}），会话仍受保护；请重试停止或检查残留进程后再继续。`);
+                finished = true;
+                if (owners.get(sessionId) === owner)
+                    owners.delete(sessionId);
+            }).finally(() => { pending = undefined; });
+            return pending;
+        },
+    };
+    // Test/non-process adapters can have no PID; they own no OS resource.
+    if (pid !== undefined)
+        owners.set(sessionId, owner);
+    return owner;
+}

package/dist/src/adapters/proc-tree-kill.js

@@ -1,94 +1,95 @@
-// =============================================================================
-// proc-tree-kill.ts — 跨平台进程树强杀工具
-// =============================================================================
-// 背景：codex / cursor adapter 通过 `spawn(cmd, args, { shell: true })` 启动 CLI
-// 时，Node 拿到的 proc.pid 是最外层 cmd.exe（Windows）或 /bin/sh（其它）的
-// PID。真正干活的是它再 spawn 出来的：
-//
-//     cmd.exe              ← proc.kill() 只能杀到这一层
-//       └─ node codex.js   ← Codex CLI 入口
-//            └─ codex.exe  ← 实际 Rust 二进制（继续烧 token）
-//
-// 单纯 proc.kill() 在 Windows 上等价于 TerminateProcess 顶层壳，孙子进程不会
-// 收到任何信号、继续运行，导致用户 /stop 看似生效（adapter 标记 stopped）但
-// 实际 codex 仍在后台跑、stream-state 一直停在 "running"。
-//
-// 解决方案：abort 时不要走 proc.kill()，而是用本工具按 pid 杀掉整棵进程树。
-//   - Windows: `taskkill /pid <pid> /T /F`（/T = 递归子进程, /F = 强制）
-//   - 其它：`process.kill(-pgid, "SIGTERM")` + 兜底 SIGKILL（adapter spawn 时
-//           需配合 detached:true 让子进程拥有独立 process group）
-// =============================================================================
-import { spawn } from "node:child_process";
-/** 异步杀掉以 pid 为根的整棵进程树。
- *
- * 设计目标：永不抛错、永不阻塞调用者。
- * - pid 不存在、参数缺失 → 静默返回
- * - 子进程 spawn 失败 → console.warn 但不 reject
- * - Windows 上 taskkill 异步执行，不阻塞 event loop
- *
- * 调用方约定：返回的 Promise 在 kill 命令发出后立即 resolve。
- * 真正的进程退出由 OS 异步完成，调用方如果需要确认"已死透"，应自己再轮询
- * `process.kill(pid, 0)`。
- */
-export async function killProcessTree(pid) {
-    if (pid == null || !Number.isFinite(pid) || pid <= 0)
-        return;
-    if (process.platform === "win32") {
-        await killWindowsTree(pid);
-        return;
+// Process groups are created by cliProcessOptions on POSIX. Never target a
+// shared parent group. A false result means callers must retain ownership.
+import { spawn, execFile } from "node:child_process";
+const pending = new Map();
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
     }
-    await killPosixTree(pid);
 }
-// ---------------------------------------------------------------------------
-// Windows: taskkill /T /F
-// ---------------------------------------------------------------------------
-function killWindowsTree(pid) {
-    return new Promise((resolve) => {
-        let resolved = false;
-        const done = () => {
-            if (resolved)
+/** Confirm the group, not only its leader: descendants may outlive the shell. */
+export async function terminatePosixGroup(pid, deps) {
+    const send = (target, signal) => {
+        try {
+            deps.signal(target, signal);
+        }
+        catch { /* confirmation below decides success */ }
+    };
+    send(-pid, "SIGTERM");
+    send(pid, "SIGTERM");
+    for (let attempt = 0; attempt < 10; attempt++) {
+        if (!await deps.hasLiveMembers(pid))
+            return true;
+        await deps.sleep(100);
+    }
+    send(-pid, "SIGKILL");
+    send(pid, "SIGKILL");
+    for (let attempt = 0; attempt < 40; attempt++) {
+        if (!await deps.hasLiveMembers(pid))
+            return true;
+        await deps.sleep(100);
+    }
+    return !await deps.hasLiveMembers(pid);
+}
+function posixMembersAlive(pid) {
+    return new Promise(resolve => {
+        execFile("ps", ["-eo", "pid=,pgid=,stat="], { timeout: 2_000, maxBuffer: 4 * 1024 * 1024 }, (error, output) => {
+            if (error) {
+                resolve(alive(-pid) || alive(pid));
                 return;
-            resolved = true;
-            resolve();
-        };
+            }
+            // Zombies have already released files/locks; waiting for init to reap
+            // them would otherwise block containers with a non-reaping PID 1.
+            resolve(output.split("\n").some(line => {
+                const [id, group, state] = line.trim().split(/\s+/);
+                return (Number(id) === pid || Number(group) === pid) && !!state && !/^[ZX]/.test(state);
+            }));
+        });
+    });
+}
+function killWindowsTree(pid) {
+    if (!alive(pid))
+        return Promise.resolve(true);
+    return new Promise(resolve => {
+        let settled = false;
+        let timer;
+        const done = (ok) => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(ok);
+        } };
+        timer = setTimeout(() => done(false), 5_000);
         try {
-            const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-                stdio: "ignore",
-                windowsHide: true,
-                // taskkill 本身很快（<200ms），不需要 detached
-            });
-            proc.once("error", (err) => {
-                console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${err.message}`);
-                done();
-            });
-            proc.once("close", () => { done(); });
-            // 兜底超时：3 秒后强制 resolve，避免极端情况下 hang 住调用方
-            setTimeout(done, 3000).unref();
+            const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+            killer.once("error", () => done(false));
+            killer.once("close", (code) => done(code === 0 && !alive(pid)));
         }
-        catch (err) {
-            console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${err.message}`);
-            done();
+        catch {
+            done(false);
         }
     });
 }
-// ---------------------------------------------------------------------------
-// POSIX: 优先按 process group 杀，回退到按 pid 杀
-// ---------------------------------------------------------------------------
-async function killPosixTree(pid) {
-    // 第一次尝试：按 process group 发 SIGTERM。要求 spawn 时 detached:true。
-    trySignal(-pid, "SIGTERM");
-    trySignal(pid, "SIGTERM");
-    // 给进程 1 秒优雅退出机会
-    await new Promise((r) => setTimeout(r, 1000));
-    // 兜底：SIGKILL
-    trySignal(-pid, "SIGKILL");
-    trySignal(pid, "SIGKILL");
-}
-function trySignal(target, signal) {
-    try {
-        process.kill(target, signal);
-    }
-    catch {
-        // 进程已不存在或权限不足，忽略
-    }
+/** Coalesce abort/watchdog/finally calls; success requires observed termination. */
+export function killProcessTree(pid) {
+    if (pid == null)
+        return Promise.resolve(true);
+    if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid || pid === process.ppid)
+        return Promise.resolve(false);
+    const existing = pending.get(pid);
+    if (existing)
+        return existing;
+    const operation = (process.platform === "win32" ? killWindowsTree(pid) : terminatePosixGroup(pid, {
+        signal: (target, signal) => { process.kill(target, signal); }, hasLiveMembers: posixMembersAlive, sleep: delay,
+    })).catch(() => false).then(ok => {
+        if (!ok)
+            console.error(`[killProcessTree] cleanup not confirmed for PID ${pid}`);
+        return ok;
+    }).finally(() => pending.delete(pid));
+    pending.set(pid, operation);
+    return operation;
 }

package/dist/src/session.js

@@ -1199,6 +1199,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
     const FILE_WRITE_INTERVAL_MS = 2000;
     const toolCallMap = new Map();
     let streamErrored = false;
+    let cleanupFailed = false;
     let streamTerminalError;
     let runOutcome = "error";
     const responseStallDetectionEnabled = adapter.responseStallDetectionEnabled !== false;
@@ -1369,6 +1370,9 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
     }
     catch (streamErr) {
         streamErrored = true;
+        cleanupFailed = streamErr?.code === "PROCESS_CLEANUP_FAILED";
+        if (cleanupFailed)
+            cancelAutoRecoveryReservation(sessionId);
         streamTerminalError = classifyTerminalError(streamErr);
         console.error(`[${ts()}] [STREAM] Error in stream loop for ${sessionId}: ${streamErr.message}`);
     }
@@ -1407,7 +1411,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
             // 读到新状态并终结旧卡片。否则 setImmediate 在 CHECK 阶段先于
             // writeFile I/O（POLL 阶段）执行，display loop 会误以为旧轮仍在
             // 运行中并更新旧卡片，而不是新建卡片。
-            const finalStatus = completedAtTimeoutBoundary
+            const finalStatus = cleanupFailed ? "error" : completedAtTimeoutBoundary
                 ? "done"
                 : wasAutoEnded
                     ? "auto_ended"
@@ -1468,7 +1472,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
             });
             // display loop 下一轮会读到最终状态并发送消息
             let autoRecoveryTarget;
-            if (wasStopped) {
+            if (wasStopped && !cleanupFailed) {
                 for (const cid of finalizationChatIds) {
                     const finfo = sessionInfoMap.get(cid);
                     await recordSessionRegistry({
@@ -1490,7 +1494,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 if (tid)
                     logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
             }
-            else if (wasAutoEnded) {
+            else if (wasAutoEnded && !cleanupFailed) {
                 for (const cid of finalizationChatIds) {
                     const finfo = sessionInfoMap.get(cid);
                     await recordSessionRegistry({
@@ -1874,7 +1878,9 @@ export function startUnifiedDisplayLoop() {
                                     displayCards.delete(chatId);
                                     continue;
                                 }
-                                const activityHeaderTitle = formatAgentActivityTitle(state.activity, Date.now());
+                                const activityHeaderTitle = activePrompts.get(sessionId)?.stopped
+                                    ? "正在停止 · 等待 Agent 退出"
+                                    : formatAgentActivityTitle(state.activity, Date.now());
                                 // 卡片轮转
                                 if (Date.now() - display.cardCreatedAt > CARD_ROTATE_MS) {
                                     display.cardBusy = true;
@@ -2027,11 +2033,8 @@ export function stopUnifiedDisplayLoop() {
 //    收尸；之前用 proc.kill() 在 Windows + shell:true 下只能杀第一层 cmd.exe，
 //    会留下"幽灵 CLI 子进程"继续跑、stream-state 永远停在 running。
 //
-// 2) 立刻 fire-and-forget 把 stream-state 标 stopped，不依赖 runAgentSession
-//    的 finally。原因：generator 自然结束依赖子进程 stdout 关闭，killProcessTree
-//    虽然很快但仍是异步，期间 display loop 可能多读到 1–2 帧 "running"，
-//    用户体验上"按下停止后还要等几秒卡片才变成已停止"。先把状态标好，
-//    finally 后续再写一次也不冲突——status 最终值仍然是 stopped。
+// 2) 保留 running 与会话占用，界面先显示正在停止；只有 adapter finally 确认
+//    进程退出后才由 runAgentSession 写 stopped，清理失败则显示错误。
 export function stopSession(sessionId) {
     // /stop 拥有高于内部自动恢复的优先级。旧轮已经完成、恢复轮尚在 200ms
     // 预约窗口时 activePrompts 为空，因此必须单独取消 reservation。
@@ -2064,26 +2067,8 @@ export function stopSession(sessionId) {
     }
     prompt.controller.abort();
     console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
-    // fire-and-forget：立刻把 stream-state.status 改成 stopped，
-    // 让 display loop 下一次扫到立刻渲染"已停止"卡片，不必再等几秒。
-    void (async () => {
-        try {
-            const current = await readStreamState(sessionId);
-            if (!current)
-                return;
-            // 已经是终态就别再覆盖，避免把 done/error 误改成 stopped
-            if (current.status !== "running")
-                return;
-            await writeStreamState({
-                ...current,
-                status: "stopped",
-                updatedAt: Date.now(),
-            });
-        }
-        catch (err) {
-            console.warn(`[${ts()}] [STOP] writeStreamState(stopped) failed for ${sessionId}: ${err.message}`);
-        }
-    })();
+    // Keep durable state running until the adapter confirms process cleanup.
+    // The display loop renders the in-memory stop request as "正在停止".
     return true;
 }
 // ---------------------------------------------------------------------------
@@ -2148,7 +2133,7 @@ export async function getSessionStatus(chatId) {
     if (!info)
         return null;
     const activePrompt = activePrompts.get(info.sessionId);
-    const isActive = !!activePrompt && !activePrompt.stopped && !activePrompt.abnormalExit;
+    const isActive = !!activePrompt;
     const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
     const registry = await loadSessionRegistry();
     const chatName = registry[chatId]?.chatName ?? "";
@@ -2217,9 +2202,7 @@ export async function getAllSessionsStatus(options = {}) {
             displayTitle: info.displayTitle || "",
             pinned: info.pinned ?? false,
             ...(info.archivedAt ? { archivedAt: info.archivedAt } : {}),
-            active: !!activePrompts.get(info.sessionId) &&
-                !activePrompts.get(info.sessionId)?.stopped &&
-                !activePrompts.get(info.sessionId)?.abnormalExit,
+            active: activePrompts.has(info.sessionId),
             turnCount: info.turnCount,
             startTime: info.startTime,
             model,

package/dist/src/terminal-error.js

@@ -35,6 +35,9 @@ function formatSeconds(milliseconds) {
 export function classifyTerminalError(error, occurredAt = Date.now()) {
     const raw = errorMessage(error);
     const lower = raw.toLowerCase();
+    if (error?.code === "PROCESS_CLEANUP_FAILED") {
+        return { kind: "process", title: "Agent 停止未完成", message: sanitizeTerminalErrorDetail(raw), occurredAt };
+    }
     const attempts = parsePositiveInt(raw, /\bafter\s+(\d+)\s+attempts?\b/i);
     const timeoutMs = parsePositiveInt(raw, /\btimeout\s*:\s*(\d+)\s*ms\b/i);
     if (/\b429\b|rate[ _-]?limit|too many requests|resource_exhausted/.test(lower)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.283",
+  "version": "0.2.284",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",