chatccc 0.2.287 → 0.2.288

package/dist/src/adapters/codex-app-server.js

@@ -0,0 +1,280 @@
+// =============================================================================
+// codex-app-server.ts — Codex CLI app-server 进程管理 + JSON-RPC 客户端
+// =============================================================================
+// Codex CLI 的 app-server 模式：一个常驻进程托管多个 thread（会话），每个
+// thread 内可有一个活跃 turn。相比 `codex exec` 一次性子进程，app-server 支持：
+//   - turn/steer   : 运行中向当前 turn 注入新消息（协作式让位，对齐 ccc）
+//   - turn/interrupt : 打断当前 turn（不影响同进程内其他 thread）
+//   - thread/resume  : 按 thread_id 从磁盘恢复持久化线程
+//
+// 本文件提供：
+//   - JsonRpcClient         : WebSocket JSON-RPC 客户端
+//   - CodexAppServerManager : 单例常驻进程生命周期（懒启动 + 跨平台收尸）
+//
+// 协议字段名以 `codex app-server generate-ts` 导出的官方绑定为准：
+//   - thread/start 用 `sandbox: "danger-full-access"`（字符串枚举）
+//   - turn/start   用 `sandboxPolicy: { type: "dangerFullAccess" }`（对象）
+// =============================================================================
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:net";
+import WebSocket from "ws";
+import { killProcessTree } from "./proc-tree-kill.js";
+// ---------------------------------------------------------------------------
+// AsyncQueue — 把 WebSocket 通知流转换成 async iterable
+// ---------------------------------------------------------------------------
+export class AsyncQueue {
+    items = [];
+    waiters = [];
+    ended = false;
+    push(item) {
+        if (this.ended)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter(item);
+        else
+            this.items.push(item);
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter(null);
+    }
+    [Symbol.asyncIterator]() {
+        const queue = this;
+        return {
+            async next() {
+                if (queue.items.length > 0) {
+                    return { value: queue.items.shift(), done: false };
+                }
+                if (queue.ended) {
+                    return { value: undefined, done: true };
+                }
+                const value = await new Promise((resolve) => {
+                    queue.waiters.push(resolve);
+                });
+                if (value === null) {
+                    return { value: undefined, done: true };
+                }
+                return { value, done: false };
+            },
+        };
+    }
+}
+export class JsonRpcClient {
+    ws;
+    nextId = 1;
+    pending = new Map();
+    onNotification = null;
+    onServerRequest = null;
+    onClose = null;
+    constructor(ws) {
+        this.ws = ws;
+        ws.on("message", (data) => this.handleMessage(data.toString()));
+        ws.on("close", () => this.handleClose());
+        ws.on("error", () => {
+            /* 关闭路径统一走 close 事件 */
+        });
+    }
+    static async connect(url) {
+        const ws = new WebSocket(url);
+        await new Promise((resolve, reject) => {
+            ws.once("open", () => resolve());
+            ws.once("error", (err) => reject(new Error(`codex app-server 连接失败: ${err.message}`)));
+        });
+        return new JsonRpcClient(ws);
+    }
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        // 响应（有 id、无 method）→ resolve 对应 pending 请求
+        if (msg.id !== undefined && msg.method === undefined) {
+            const pendingReq = this.pending.get(msg.id);
+            if (pendingReq) {
+                this.pending.delete(msg.id);
+                clearTimeout(pendingReq.timer);
+                if (msg.error !== undefined && msg.error !== null) {
+                    pendingReq.reject(new Error(JSON.stringify(msg.error)));
+                }
+                else {
+                    pendingReq.resolve(msg.result);
+                }
+            }
+            return;
+        }
+        // 服务端请求（有 method + id）→ 需要客户端 respond
+        if (msg.method !== undefined && msg.id !== undefined) {
+            this.onServerRequest?.(msg.method, msg.params ?? {}, msg.id);
+            return;
+        }
+        // 服务端通知（有 method、无 id）
+        if (msg.method !== undefined) {
+            this.onNotification?.(msg.method, msg.params ?? {});
+        }
+    }
+    handleClose() {
+        const err = new Error("codex app-server 连接已关闭");
+        for (const [id, p] of this.pending) {
+            this.pending.delete(id);
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.onClose?.();
+    }
+    request(method, params, timeoutMs = 120000) {
+        const id = this.nextId++;
+        this.ws.send(JSON.stringify({ method, id, params }));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`codex app-server 请求超时: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+    }
+    respond(id, result) {
+        this.ws.send(JSON.stringify({ id, result }));
+    }
+    respondError(id, code, message) {
+        this.ws.send(JSON.stringify({ id, error: { code, message } }));
+    }
+    close() {
+        try {
+            this.ws.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 端口选择 / 就绪等待（跨平台）
+// ---------------------------------------------------------------------------
+async function pickFreePort() {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
+    return port;
+}
+async function waitForReady(port, timeoutMs = 20000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const r = await fetch(`http://127.0.0.1:${port}/readyz`);
+            if (r.ok)
+                return;
+        }
+        catch {
+            /* not ready yet */
+        }
+        await new Promise((r) => setTimeout(r, 150));
+    }
+    throw new Error("codex app-server 启动超时（readyz 未就绪）");
+}
+// ---------------------------------------------------------------------------
+// CodexAppServerManager — 单例常驻进程生命周期
+// ---------------------------------------------------------------------------
+export class CodexAppServerManager {
+    static instance = null;
+    proc = null;
+    port = null;
+    starting = null;
+    cleanupRegistered = false;
+    static get() {
+        if (!CodexAppServerManager.instance) {
+            CodexAppServerManager.instance = new CodexAppServerManager();
+        }
+        return CodexAppServerManager.instance;
+    }
+    ensureStarted(command) {
+        if (this.port !== null)
+            return Promise.resolve(this.port);
+        if (this.starting)
+            return this.starting;
+        this.starting = this.start(command);
+        return this.starting;
+    }
+    async start(command) {
+        const port = await pickFreePort();
+        const proc = spawn(command, ["app-server", "--listen", `ws://127.0.0.1:${port}`], {
+            stdio: ["ignore", "ignore", "pipe"],
+            windowsHide: true,
+            // Windows 下 npm 全局安装的 codex 是 .cmd shim，需经 shell 解析；
+            // Unix 下直接 exec 二进制，避免 shell:true 的转义风险与 deprecation 警告。
+            shell: process.platform === "win32",
+        });
+        let stderr = "";
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.once("error", (err) => {
+            console.error(`[Codex app-server] spawn 失败: ${err.message}`);
+        });
+        proc.on("close", (code) => {
+            if (this.proc === proc) {
+                this.proc = null;
+                this.port = null;
+            }
+            if (code !== 0 && stderr.trim()) {
+                console.error(`[Codex app-server] 退出码=${code}: ${stderr.trim().slice(0, 2000)}`);
+            }
+        });
+        try {
+            await waitForReady(port);
+        }
+        catch (err) {
+            void killProcessTree(proc.pid);
+            throw err;
+        }
+        this.proc = proc;
+        this.port = port;
+        this.registerCleanup();
+        return port;
+    }
+    /** 主进程退出时尽力收尸（Windows taskkill / Unix SIGTERM），避免孤儿常驻进程。 */
+    registerCleanup() {
+        if (this.cleanupRegistered)
+            return;
+        this.cleanupRegistered = true;
+        const cleanup = () => {
+            const pid = this.proc?.pid;
+            if (pid === undefined)
+                return;
+            try {
+                if (process.platform === "win32") {
+                    spawnSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+                }
+                else {
+                    this.proc?.kill("SIGTERM");
+                }
+            }
+            catch {
+                /* best effort */
+            }
+        };
+        process.once("exit", cleanup);
+        process.once("SIGINT", cleanup);
+        process.once("SIGTERM", cleanup);
+    }
+    async shutdown() {
+        this.starting = null;
+        const proc = this.proc;
+        this.proc = null;
+        this.port = null;
+        if (proc) {
+            await killProcessTree(proc.pid);
+        }
+    }
+}

package/dist/src/config-utils.js

@@ -147,3 +147,39 @@ export function readToolCliPath(raw, options) {
     }
     return "";
 }
+// ---------------------------------------------------------------------------
+// Codex CLI 版本检查（app-server 模式要求的最低版本）
+// ---------------------------------------------------------------------------
+/**
+ * app-server 模式（thread/start + turn 注入）官方推荐的最低 Codex CLI 版本。
+ * 版本不足时仅警告、不阻断启动——当前默认仍是 `codex exec` 模式，exec 不依赖
+ * 该最低版本。
+ */
+export const CODEX_MIN_APP_SERVER_VERSION = "0.60.0";
+/**
+ * 从 `codex --version` 的输出中解析三段式版本号。
+ * 实际输出形如 `codex-cli 0.153.4`（可能带换行或附加后缀）。
+ * 找不到形如 x.y.z 的版本号时返回 null。
+ */
+export function parseCodexVersion(output) {
+    const match = output.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : null;
+}
+/**
+ * 轻量 semver 比较（按数值逐段比较，缺段按 0 补齐，忽略 prerelease/build）。
+ * 返回 -1（a < b）、0（a == b）、1（a > b）。
+ */
+export function compareSemver(a, b) {
+    const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i += 1) {
+        const x = pa[i] ?? 0;
+        const y = pb[i] ?? 0;
+        if (x < y)
+            return -1;
+        if (x > y)
+            return 1;
+    }
+    return 0;
+}

package/dist/src/config.js

@@ -8,7 +8,7 @@ import { AGENT_TOOLS } from "./agent-tool.js";
 import { CHATCCC_PACKAGE_ROOT } from "./package-root.js";
 import { printServiceDidNotStart } from "./exit-banner.js";
 import { appendStartupTrace, setupFileLogging } from "./shared.js";
-import { anthropicConfigDisplay, autoDetectCodexPath, autoDetectCursorPath, normalizeCccProviderOverride, normalizeOptionalConfigField, readToolCliPath, resolveCccEnabled, } from "./config-utils.js";
+import { CODEX_MIN_APP_SERVER_VERSION, anthropicConfigDisplay, autoDetectCodexPath, autoDetectCursorPath, compareSemver, normalizeCccProviderOverride, normalizeOptionalConfigField, parseCodexVersion, readToolCliPath, resolveCccEnabled, } from "./config-utils.js";
 export { AGENT_TOOLS } from "./agent-tool.js";
 // 重新导出 config-utils 中的纯函数/常量，保持对外 API 不变
 // （历史上这些符号都从 ./config.ts 导入；新代码可直接从 ./config-utils.ts 导入以避免触发本文件的副作用）
@@ -795,6 +795,39 @@ export function reportEnvironmentVariableReadout() {
     console.log(`         /git 命令超时: ${GIT_TIMEOUT_SECONDS}s`);
     console.log("  ------------------------------------------------------------------");
 }
+/**
+ * 启动时检查 Codex CLI 版本是否满足 app-server 模式的最低要求。
+ *
+ * 版本不足 / 无法探测时仅打印 warning，不阻断启动：当前默认仍是 `codex exec`
+ * 模式，exec 并不依赖该最低版本。待未来全面切到 app-server 时，再把这里升级为
+ * spawn 前的硬校验。
+ */
+export function reportCodexVersionCheck() {
+    const codexPath = config.codex.path.trim() || "codex";
+    let version = null;
+    try {
+        const out = execFileSync(codexPath, ["--version"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+            timeout: 5000,
+        }).toString();
+        version = parseCodexVersion(out);
+    }
+    catch {
+        version = null;
+    }
+    if (!version) {
+        console.warn(`  [警告] [可选] codex 版本：无法探测 Codex CLI 版本（命令: ${codexPath}）。` +
+            `切换 app-server 模式前需 Codex CLI >= ${CODEX_MIN_APP_SERVER_VERSION}。`);
+        return;
+    }
+    if (compareSemver(version, CODEX_MIN_APP_SERVER_VERSION) < 0) {
+        console.warn(`  [警告] [可选] codex 版本：当前 ${version} 低于 app-server 要求的最低 ${CODEX_MIN_APP_SERVER_VERSION}。` +
+            `现有 exec 模式不受影响；切换 app-server 模式前请升级 Codex CLI。`);
+        return;
+    }
+    console.log(`  [成功] [可选] codex 版本：${version}（满足 app-server 最低 ${CODEX_MIN_APP_SERVER_VERSION}）`);
+}
 /** 飞书凭证缺失时打印可操作的说明并退出 */
 export function explainMissingFeishuCredentialsAndExit() {
     appendStartupTrace("explainMissingFeishuCredentialsAndExit: exiting", {

package/dist/src/index.js

@@ -31,7 +31,7 @@ import { configureAgentTeamMainAgent } from "./agent-team/main-agent-bootstrap.j
 import { buildWebUiUrl, createServiceLifecycleGuard, announceInternalRestartReady, INTERNAL_RESTART_ENV_VAR, openWebUiInDefaultBrowser, shouldAutoOpenWebUi, } from "./startup-lifecycle.js";
 import { buildPlatformStartupPlan } from "./platform-startup.js";
 import { makeTraceId, logTrace } from "./trace.js";
-import { CHATCCC_PORT, config, APP_ID, APP_SECRET, FEISHU_ENABLED, FEISHU_PLATFORM_TYPE, ILINK_ENABLED, ILINK_REUSE_TOKEN_ON_START, BASE_URL, LOCAL_RELAY_URL, PID_FILE, PROJECT_ROOT, USE_LOCAL, USE_SIMULATE, appendChatLog, fileLog, reportEnvironmentVariableReadout, maskAppId, resolveDefaultAgentTool, toolDisplayName, ts, } from "./config.js";
+import { CHATCCC_PORT, config, APP_ID, APP_SECRET, FEISHU_ENABLED, FEISHU_PLATFORM_TYPE, ILINK_ENABLED, ILINK_REUSE_TOKEN_ON_START, BASE_URL, LOCAL_RELAY_URL, PID_FILE, PROJECT_ROOT, USE_LOCAL, USE_SIMULATE, appendChatLog, fileLog, reportEnvironmentVariableReadout, reportCodexVersionCheck, maskAppId, resolveDefaultAgentTool, toolDisplayName, ts, } from "./config.js";
 import { printServiceDidNotStart, printServiceRunningHint } from "./exit-banner.js";
 import { addReaction, createGroupChat, extractSessionInfo, formatDelayNotice, getChatInfo, getTenantAccessToken, recallMessage, sendCardReply, sendRawCard, sendTextReply, setChatAvatar, updateCardMessage, updateChatInfo, disbandChat, sendRestartCard, verifyAllPermissions, reportPermissionResults, setPlatform, consumeCodexRateLimitResetCredit, } from "./feishu-platform.js";
 import { SimulatedPlatform, SIM_DEFAULT_CHAT_ID } from "./sim-platform.js";
@@ -665,6 +665,7 @@ async function main() {
     });
     console.log(`[启动 2/7] 环境与凭证检查`);
     reportEnvironmentVariableReadout();
+    reportCodexVersionCheck();
     console.log(`  工作目录: ${process.cwd()}`);
     console.log(`  包根目录: ${PROJECT_ROOT}`);
     if (FEISHU_ENABLED) {

package/dist/src/orchestrator.js

@@ -2239,15 +2239,16 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         }
         // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
         if (isSessionRunning(sessionId)) {
-            // ccc 内核支持协作式让位：运行期新消息进入注入队列，由 drainInput 在每个
-            // model step 边界逐条吸收进当前 turn（不新开 turn）。其他 agent 保持整轮队列。
-            if (descriptionTool === "ccc") {
+            // ccc 内核与 codex app-server 支持协作式让位：运行期新消息进入注入队列，
+            // 由 drainInput 在每个 model step 边界逐条吸收进当前 turn（不新开 turn）。
+            // 其他 agent 保持整轮队列。
+            if (descriptionTool === "ccc" || descriptionTool === "codex") {
                 const injected = pushInjection(sessionId, {
                     text: promptText, chatId, openId, msgTimestamp, chatType, traceId: tid,
                 });
                 if (injected) {
                     logTrace(tid, "INJECT_QUEUED", { sessionId });
-                    console.log(`[${ts()}] [INJECT_QUEUED] Session ${sessionId} (ccc) busy, message from chat ${chatId} queued for step-boundary injection`);
+                    console.log(`[${ts()}] [INJECT_QUEUED] Session ${sessionId} (${descriptionTool}) busy, message from chat ${chatId} queued for step-boundary injection`);
                     if (platform.kind === "wechat") {
                         await platform.sendText(chatId, "当前会话正在生成中，你的消息会在当前步骤结束后注入本轮处理。").catch(() => { });
                     }
@@ -2257,7 +2258,7 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
                 }
                 else {
                     logTrace(tid, "INJECT_QUEUE_FULL", { sessionId });
-                    console.log(`[${ts()}] [INJECT_QUEUE_FULL] Session ${sessionId} (ccc) injection queue full, rejecting message from chat ${chatId}`);
+                    console.log(`[${ts()}] [INJECT_QUEUE_FULL] Session ${sessionId} (${descriptionTool}) injection queue full, rejecting message from chat ${chatId}`);
                     if (platform.kind === "wechat") {
                         await platform.sendText(chatId, "当前待注入消息过多，请等待或发送 /stop（停止生成）或 /cancel（清空注入）。").catch(() => { });
                     }

package/dist/src/session-chat-binding.js

@@ -163,10 +163,10 @@ export function hasQueuedMessage(sessionId) {
     return queuedMessages.has(sessionId);
 }
 // ---------------------------------------------------------------------------
-// pendingInjections: sessionId → 运行中待注入消息（仅 ccc 内核）
-// 与上面的 queuedMessages（整轮队列，深度 1）分离：ccc 运行期的新消息进入
-// 这里，由 drainInput 在每个 model step 边界逐条吸收进当前 turn；其他 agent
-// 继续走整轮队列。turn 结束后剩余未注入的消息转回普通队列消费。
+// pendingInjections: sessionId → 运行中待注入消息（ccc 内核与 codex app-server）
+// 与上面的 queuedMessages（整轮队列，深度 1）分离：ccc/codex 运行期的新消息
+// 进入这里，由 drainInput 在每个 model step 边界逐条吸收进当前 turn；其他
+// agent 继续走整轮队列。turn 结束后剩余未注入的消息转回普通队列消费。
 // ---------------------------------------------------------------------------
 export const MAX_PENDING_INJECTIONS = 50;
 export const pendingInjections = new Map();
@@ -187,6 +187,12 @@ export function shiftInjection(sessionId) {
         pendingInjections.delete(sessionId);
     return msg;
 }
+/** 注入未能被运行中 turn 吸收时，把消息退回队列头部。 */
+export function unshiftInjection(sessionId, msg) {
+    const list = pendingInjections.get(sessionId) ?? [];
+    list.unshift(msg);
+    pendingInjections.set(sessionId, list);
+}
 export function drainRemainingInjections(sessionId) {
     const list = pendingInjections.get(sessionId);
     pendingInjections.delete(sessionId);

package/dist/src/session.js

@@ -29,7 +29,7 @@ function compressWechatDisplayText(text) {
 }
 import { readStreamState, writeStreamState, createEmptyStreamState, isFinalReplySentForTurn, markFinalReplySent, } from "./stream-state.js";
 import { addCardToTurn, finalizeTurnCards, markCardDone } from "./turn-cards.js";
-import { bindChatToSession, unbindChatFromSession, getChatsForSession, activePrompts, displayCards, unifiedDisplayLoopHandle, setUnifiedDisplayLoopHandle, rebuildSessionChatsFromRegistry, recordLastActiveChat, getLastActiveChat, pickDisplayChat, dequeueMessage, consumeQueuedMessage, cancelQueuedMessage, shiftInjection, drainRemainingInjections, clearInjections, setQueuePreservedChat, consumeQueuePreservedChat, markSessionFinalizing, clearSessionFinalizing, reserveAutoRecovery, consumeAutoRecoveryReservation, cancelAutoRecoveryReservation, hasAutoRecoveryReservation, } from "./session-chat-binding.js";
+import { bindChatToSession, unbindChatFromSession, getChatsForSession, activePrompts, displayCards, unifiedDisplayLoopHandle, setUnifiedDisplayLoopHandle, rebuildSessionChatsFromRegistry, recordLastActiveChat, getLastActiveChat, pickDisplayChat, dequeueMessage, consumeQueuedMessage, cancelQueuedMessage, shiftInjection, unshiftInjection, drainRemainingInjections, clearInjections, setQueuePreservedChat, consumeQueuePreservedChat, markSessionFinalizing, clearSessionFinalizing, reserveAutoRecovery, consumeAutoRecoveryReservation, cancelAutoRecoveryReservation, hasAutoRecoveryReservation, } from "./session-chat-binding.js";
 async function sendFinalReplyTextOnce(platform, chatId, sessionId, turnCount, text) {
     const sent = await platform.sendText(chatId, text).then((ok) => ok !== false).catch(() => false);
     if (sent)
@@ -1287,6 +1287,8 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
         }
     }
     try {
+        // 供 onInjectionRejected 退回的“最后一条已取出但未成功注入”的消息
+        let lastShiftedInjection = null;
         for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
             onProcessStart: (processInfo) => {
                 startPromptProcessMonitor(sessionId, processInfo);
@@ -1303,16 +1305,24 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 if (prompt)
                     prompt.closeSession = closeSession;
             },
-            // ccc 内核支持协作式让位：同步从注入队列取队首文本，供内核在每个
-            // model step 边界吸收。非 ccc adapter 忽略该字段。
-            drainInput: tool === "ccc" ? () => {
+            // ccc 内核与 codex app-server 支持协作式让位：同步从注入队列取队首文本，
+            // 供适配器在每个 model step 边界吸收。其他 adapter 忽略该字段。
+            drainInput: tool === "ccc" || tool === "codex" ? () => {
                 const injected = shiftInjection(sessionId);
                 if (!injected)
                     return undefined;
+                lastShiftedInjection = injected;
                 // 与首次消息保持一致的结构化包装；imSkillsPrompt 已在首次消息中，
                 // 此处不重复注入，避免多轮注入导致上下文膨胀。
                 return `[User message]\n${injected.text}\n[/User message]`;
             } : undefined,
+            // 注入未被当前 turn 吸收（如 turn 恰好已结束）时，退回队列头部，避免丢消息。
+            onInjectionRejected: tool === "ccc" || tool === "codex" ? () => {
+                if (lastShiftedInjection) {
+                    unshiftInjection(sessionId, lastShiftedInjection);
+                    lastShiftedInjection = null;
+                }
+            } : undefined,
         })) {
             if (unifiedMsg.isFinalResponse) {
                 const prompt = activePrompts.get(sessionId);
@@ -1653,7 +1663,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 // 第一次 response-stall 后保留普通缓存；恢复轮结束后由恢复轮的
                 // finally 再消费，顺序固定为“自动恢复 → 用户缓存”。
                 queuedForConsumption = dequeueMessage(sessionId);
-                // ccc 注入队列剩余（turn 期间未注入完，如 non-streaming 或收尾窗口到达）
+                // ccc/codex 注入队列剩余（turn 期间未注入完，如 non-streaming 或收尾窗口到达）
                 // 取第一条转普通消费，其余留待下一轮结束后继续消费。
                 if (!queuedForConsumption) {
                     queuedForConsumption = shiftInjection(sessionId);

package/package.json

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