chatccc 0.2.282 → 0.2.284

package/README.md

@@ -449,9 +449,13 @@ 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`。
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
+
+Agent 的初始化、输入回显与重连通知不代表任务成功。Cursor、Codex 和 Claude 缺少成功完成事件，或任一 Agent 没有产生有效回复时，会明确提示异常；已生成的部分回复会保留并标为可能不完整。Cursor 重连过程显示在状态区，上游的 `resource_exhausted` / `unavailable` 分别提示请求受限 / 服务暂不可用，不推断为余额耗尽。执行失败不会自动重放整条任务。
 
 > **Codex Fast 模式**：Web UI 中的“Fast 模式”设置新 Codex 会话的全局默认值，默认关闭。进入 Codex 会话后，`/fast` 查询当前状态，`/fast on` 和 `/fast off` 只覆盖当前会话并从下一条消息生效。ChatCCC 会显式向 Codex CLI 传入 `service_tier="fast"` 或 `service_tier="default"`，因此关闭时不会继承用户 `config.toml` 中可能开启的 Fast。
 

package/deepccc-agent/README.md

@@ -8,6 +8,8 @@ DeepCCC 是一个本地优先的开源 Coding Agent，同时提供浏览器多
 
 ## 安装与快速开始
 
+模型原生流未收到完成事件、返回错误结束原因或达到输出长度限制时，会报告异常并保留已经输出的内容，不将不完整回复判为成功。没有回复且没有工具执行的空结果也会明确报错。用户主动取消仍按中断处理。
+
 全局安装：
 
 ```bash

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [

package/dist/deepccc-agent/src/index.js

@@ -478,16 +478,25 @@ export class ChatSession {
                     messages: attemptMessages,
                 };
                 let stream;
+                let requiresFinish = false;
+                let receivedFinish = false;
+                let finishReason;
                 if (this.streaming) {
                     const result = streamText(generationOptions);
+                    requiresFinish = result.fullStream != null;
                     stream = result.fullStream ?? textStreamToFullStream(result.textStream);
                 }
                 else {
                     const result = await generateText(generationOptions);
+                    finishReason = result.finishReason;
                     stream = generateResultToFullStream(result);
                 }
                 for await (const part of stream) {
                     rawLog?.writeLine(safeRawStreamJson(part));
+                    if (part.type === "finish") {
+                        receivedFinish = true;
+                        finishReason = part.finishReason;
+                    }
                     if (part.type === "reasoning-start" || part.type === "reasoning-delta") {
                         // Reasoning content remains private. A throttled heartbeat is enough
                         // for ChatCCC to distinguish active inference from a stalled stream.
@@ -561,6 +570,14 @@ export class ChatSession {
                         throw new Error(message);
                     }
                 }
+                if (!signal?.aborted) {
+                    if (requiresFinish && !receivedFinish)
+                        throw new Error("DeepCCC 输出流中断：未收到模型完成事件，回复可能不完整");
+                    if (finishReason === "error" || finishReason === "length")
+                        throw new Error(`DeepCCC 未正常完成：finishReason=${finishReason}，回复可能不完整`);
+                    if (!fullText.trim() && toolCallOrder.length === 0)
+                        throw new Error("DeepCCC 本轮未产生有效回复");
+                }
                 if (hasMalformedToolProtocolText(fullText)) {
                     console.warn(`[DeepCCC] malformed tool protocol text detected for ${this.context.sessionId} `
                         + `(attempt ${attempt + 1}/2, structuredToolCalls=${toolCallOrder.length})`);

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

@@ -2,6 +2,7 @@ import { ChatSession } from "../../deepccc-agent/src/index.js";
 import { config as deepCccConfig } from "../../deepccc-agent/src/config.js";
 import { getBuiltinContextSession, newBuiltinSessionId, normalizeBuiltinSessionId, } from "../../deepccc-agent/src/context.js";
 import { config, CCC_SESSION_PREFIX } from "../config.js";
+import { createTurnCompletion } from "./turn-completion.js";
 function toChatSessionOptions(sessionId, cwd, options) {
     return {
         cwd,
@@ -50,7 +51,12 @@ export function createCccAdapter(options = {}) {
         async *prompt(sessionId, userText, cwd, signal, _promptOptions) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
             const session = new ChatSession(chatConfig, toChatSessionOptions(normalizedSessionId, cwd, options));
+            const completion = createTurnCompletion("CCC Agent");
             for await (const event of session.chat(userText, signal)) {
+                if (event.type === "text")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text", text: event.text }] });
+                if (event.type === "text_reset")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text_reset" }] });
                 if (event.type === "status") {
                     yield {
                         type: "assistant",
@@ -101,6 +107,7 @@ export function createCccAdapter(options = {}) {
                     };
                 }
                 else if (event.type === "done" && !signal?.aborted) {
+                    completion.complete();
                     yield {
                         type: "assistant",
                         blocks: [],
@@ -111,6 +118,8 @@ export function createCccAdapter(options = {}) {
                     throw new Error(event.message);
                 }
             }
+            if (!signal?.aborted)
+                completion.assertComplete();
         },
         async getSessionInfo(sessionId) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);

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

@@ -11,6 +11,8 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseUserCommand } from "./adapter-interface.js";
+import { createTurnCompletion } from "./turn-completion.js";
+import { sanitizeTerminalErrorDetail } from "../terminal-error.js";
 import { CHATCCC_PORT, config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultClaudeSessionMetaStore, } from "./claude-session-meta-store.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
@@ -127,6 +129,9 @@ function logMcpConfig() {
     }
 }
 export function normalizeSdkMessage(msg) {
+    if (msg.type === "result" && (msg.subtype !== "success" || msg.is_error === true)) {
+        throw new Error(`Claude 执行失败：${sanitizeTerminalErrorDetail(JSON.stringify(msg.errors ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
     // SDK result/success 是 Claude 对本轮完整结束的权威确认。文本已经由之前的
     // assistant 消息累计，因此这里只发送终态信号，避免重复追加 result 文本。
     if (msg.type === "result" && msg.subtype === "success") {
@@ -399,6 +404,7 @@ class ClaudeAdapter {
             return;
         let aborted = false;
         let completed = false;
+        const completion = createTurnCompletion("Claude");
         const rawLogConfig = config.rawStreamLogs.claude;
         let rawLog = null;
         const sdk = await loadClaudeSdkModule();
@@ -449,10 +455,24 @@ class ClaudeAdapter {
                     }
                 }
                 const normalized = normalizeSdkMessage(msg);
+                completion.observe(normalized);
+                if (msg.type === "result") {
+                    // Some SDK modes only put the final reply in result.result.
+                    if (msg.result?.trim()) {
+                        const final = { type: "assistant", blocks: [{ type: "text_final", text: msg.result }] };
+                        completion.observe(final);
+                        yield final;
+                    }
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
-            completed = !aborted && !abortController.signal.aborted;
+            if (!aborted && !abortController.signal.aborted)
+                completion.assertComplete();
         }
         finally {
             removeAbortListener?.();

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

@@ -7,12 +7,13 @@
 // - getSessionInfo: 从持久化映射读取 cwd / threadId
 // =============================================================================
 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";
@@ -71,8 +72,8 @@ function resolveCodexEffort() {
 // normalizeCodexMessage — Codex 事件 → UnifiedStreamMessage | null
 // ---------------------------------------------------------------------------
 export function normalizeCodexMessage(msg) {
-    if (msg.type === "error" && msg.message?.trim()) {
-        throw new Error(`Codex turn failed: ${msg.message.trim()}`);
+    if (msg.type === "error") {
+        throw new Error(`Codex turn failed: ${msg.message?.trim() || "未提供错误详情"}`);
     }
     if (msg.type === "turn.failed") {
         const detail = typeof msg.error === "string" ? msg.error : msg.error?.message;
@@ -158,12 +159,21 @@ 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;
+    let signal = null;
+    let settleClose = () => { };
+    const closed = new Promise(resolve => { settleClose = resolve; });
+    proc.once("error", (error) => { stderr += `\n${error.message}`; settleClose(); });
     proc.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
     });
-    proc.on("close", (code) => {
+    proc.on("close", (code, exitSignal) => {
+        exitCode = code;
+        signal = exitSignal;
+        settleClose();
         if (code !== 0 && stderr.trim()) {
             console.error(`[Codex stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`);
         }
@@ -172,7 +182,17 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         proc.stdin.write(stdinText);
         proc.stdin.end();
     }
-    return proc;
+    return { proc, async failureDetail() {
+            let timer;
+            try {
+                await Promise.race([closed, new Promise(resolve => { timer = setTimeout(resolve, 2_000); })]);
+                return `exit=${exitCode ?? "unknown"}; signal=${signal ?? "none"}; ${stderr.trim() || "无 stderr 详情"}`;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        } };
 }
 async function* readJsonLines(proc, signal, rawLog) {
     yield* readJsonLinesWithBadJsonIdleWatchdog({
@@ -207,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;
@@ -219,7 +242,9 @@ class CodexAdapter {
         const args = isFirstPrompt
             ? [...baseArgs, "-C", cwd, "-"]
             : [...baseArgs, "resume", threadId, "-"];
-        const proc = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
+        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;
@@ -242,15 +267,14 @@ 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");
         try {
             for await (const raw of readJsonLines(proc, signal, rawLog)) {
                 if (signal?.aborted)
                     break;
-                if (raw.type === "turn.completed")
-                    completed = true;
                 if (isFirstPrompt &&
                     raw.type === "thread.started" &&
                     raw.thread_id) {
@@ -259,16 +283,31 @@ class CodexAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCodexMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "turn.completed") {
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
+            if (!signal?.aborted && !completed)
+                completion.assertComplete(await handle.failureDetail());
         }
         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

@@ -8,6 +8,8 @@ import { spawn } from "node:child_process";
 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";
@@ -106,6 +108,15 @@ function mapToolCallKey(key) {
     return KEY_MAP[key] ?? key;
 }
 export function normalizeCursorMessage(msg) {
+    if (msg.type === "error" || (msg.type === "result" && (msg.is_error === true || msg.subtype?.startsWith("error")))) {
+        throw new Error(`Cursor 执行失败：${formatCursorVisibleStderr(JSON.stringify(msg.errors ?? msg.error ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
+    if (msg.type === "connection" || msg.type === "retry") {
+        return { type: "system", blocks: [{ type: "agent_status",
+                    status: msg.subtype === "reconnected" ? "responding" : "reconnecting",
+                    ...(Number.isInteger(msg.attempt) && msg.attempt > 0 ? { attempt: msg.attempt } : {}),
+                }] };
+    }
     if (msg.type === "assistant" && msg.message?.content) {
         // 按 cursor 官方 stream-json 规范区分三类 assistant 事件，避免 text 重复累加：
         //   ┌────────────────┬───────────────┬─────────────────┐
@@ -278,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，子进程异常退出时输出到日志，方便排查静默失败
@@ -312,8 +324,17 @@ function spawnAgent(extraArgs, cwd, stdinText, modelOverride, mode, spawnImpl =
         waitForClose: async () => {
             if (closeInfo)
                 return { ...closeInfo, stderr };
-            const info = await closePromise;
-            return { ...info, stderr };
+            let timer;
+            try {
+                const info = await Promise.race([closePromise, new Promise(resolve => {
+                        timer = setTimeout(() => resolve({ code: null, signal: null, stderr }), 2_000);
+                    })]);
+                return { ...info, stderr };
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
         },
     };
 }
@@ -392,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 });
@@ -422,9 +448,10 @@ 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");
         const stats = createCursorStreamStats();
         try {
             for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats, this.badJsonIdleTimeoutMs)) {
@@ -439,12 +466,17 @@ class CursorAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCursorMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "result")
+                    completion.complete();
                 if (normalized)
                     yield normalized;
                 // result 是流末事件，收到后立即结束进程，防止 CLI 僵死导致 readline 挂起。
                 if (raw.type === "result") {
+                    if (!normalized?.isFinalResponse)
+                        yield { type: "assistant", blocks: [], isFinalResponse: true };
                     sawResult = true;
-                    void killProcessTree(proc.pid);
+                    void ownership.stop().catch(() => { });
                     break;
                 }
             }
@@ -462,15 +494,22 @@ class CursorAdapter {
                     };
                     throw createCursorAgentFailureError(closeInfo);
                 }
+                completion.assertComplete(`exit=${closeInfo.code ?? "unknown"}; signal=${closeInfo.signal ?? "none"}; ${formatCursorVisibleStderr(closeInfo.stderr) || "无 stderr 详情"}`);
             }
         }
         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/dsh-adapter.js

@@ -125,22 +125,18 @@ export function createDshAdapter(options = {}) {
                                 queue.push(message);
                         },
                     });
-                    if (result.finalResponse) {
+                    if (turnError) {
+                        if (result.finalResponse?.trim())
+                            queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }] });
+                        queue.fail(turnError);
+                    }
+                    else if (result.finalResponse?.trim()) {
                         rawLog?.writeLine(JSON.stringify({ type: "run.result", result }));
                         queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }], isFinalResponse: true });
                         completed = true;
                     }
-                    else if (turnError) {
-                        queue.fail(turnError);
-                    }
                     else {
-                        // 引擎正常结束但零输出（无错误、无回复）：给出明确提示，避免用户只看到"失败"。
-                        queue.push({
-                            type: "assistant",
-                            blocks: [{ type: "text_final", text: "DeepSeek Harness 本轮未产生任何回复（引擎未报告错误）。" }],
-                            isFinalResponse: true,
-                        });
-                        completed = true;
+                        queue.fail(new Error("DeepSeek Harness 本轮未产生有效回复（引擎未报告错误）。"));
                     }
                     if (completed) {
                         knownSessions.set(sessionId, { sessionId, cwd, lastModified: Date.now(), model: options.model ?? "deepseek-v4-flash" });

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/adapters/turn-completion.js

@@ -0,0 +1,25 @@
+import { sanitizeTerminalErrorDetail } from "../terminal-error.js";
+/** Protocol output (init, echo, heartbeat, tools) is not a successful reply. */
+export function createTurnCompletion(tool) {
+    let hasReply = false;
+    let completed = false;
+    return {
+        observe(message) {
+            for (const block of message?.blocks ?? []) {
+                if (block.type === "text_reset")
+                    hasReply = false;
+                if (message?.type === "assistant" && (block.type === "text" || block.type === "text_final") && block.text.trim())
+                    hasReply = true;
+            }
+        },
+        complete() {
+            if (!hasReply)
+                throw new Error(`${tool} 本轮未产生有效回复（收到结束事件，但回复为空）。`);
+            completed = true;
+        },
+        assertComplete(detail = "") {
+            if (!completed)
+                throw new Error(`${tool} 未正常完成：输出流结束但未收到成功完成事件${detail ? `；${sanitizeTerminalErrorDetail(detail)}` : ""}。`);
+        },
+    };
+}

package/dist/src/agent-activity.js

@@ -7,6 +7,7 @@ export function createAgentActivityTracker(now = Date.now()) {
 }
 function sameVisibleActivity(left, right) {
     return left.kind === right.kind
+        && left.attempt === right.attempt
         && left.toolName === right.toolName
         && left.toolCount === right.toolCount;
 }
@@ -73,8 +74,9 @@ export function updateAgentActivity(tracker, block, now = Date.now()) {
             return setActivity(tracker, { kind: "responding", startedAt: now });
         case "agent_status":
             return setActivity(tracker, {
-                kind: block.status === "compacting" ? "compacting" : "responding",
+                kind: block.status,
                 startedAt: now,
+                ...(block.attempt ? { attempt: block.attempt } : {}),
             });
         case "thinking":
         case "redacted_thinking":
@@ -126,6 +128,9 @@ export function formatAgentActivityTitle(activity, now = Date.now()) {
         case "responding":
             label = "正在生成回复";
             break;
+        case "reconnecting":
+            label = `正在重新连接模型服务${activity.attempt ? `（第 ${activity.attempt} 次）` : ""}`;
+            break;
         case "searching":
             label = "正在处理搜索结果";
             break;

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,9 +35,12 @@ 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/.test(lower)) {
+    if (/\b429\b|rate[ _-]?limit|too many requests|resource_exhausted/.test(lower)) {
         return {
             kind: "rate_limit",
             title: "请求受到限流",
@@ -73,7 +76,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
         };
     }
     const httpStatus = raw.match(/\b(?:HTTP\s*)?(5\d\d)\b/i)?.[1];
-    if (httpStatus || /service unavailable|bad gateway|gateway timeout|provider error/.test(lower)) {
+    if (httpStatus || /service unavailable|\[unavailable\]|bad gateway|gateway timeout|provider error/.test(lower)) {
         return {
             kind: "provider",
             title: "模型服务暂时不可用",

package/package.json

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