chatccc 0.2.286 → 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/agent-activity.js

@@ -88,6 +88,9 @@ export function updateAgentActivity(tracker, block, now = Date.now()) {
             return setActivity(tracker, { kind: "searching", startedAt: now });
         case "compact_boundary":
             return setActivity(tracker, { kind: "compacting", startedAt: now });
+        case "input_injected":
+            // 协作式让位：注入本身不是 agent 活动，不改变状态标题。
+            return false;
     }
 }
 function formatElapsed(startedAt, now) {

package/dist/src/cards.js

@@ -394,6 +394,44 @@ export function buildQueueFullCard() {
         ],
     });
 }
+// 协作式让位卡片（仅 ccc）：消息进入注入队列，将在 step 边界吸收进本轮。
+// 与上面的整轮队列卡片区分，强调“无需等待整轮结束”。
+export function buildInjectionQueuedCard(text) {
+    const preview = text.length > 100 ? text.slice(0, 100) + "…" : text;
+    return JSON.stringify({
+        config: { wide_screen_mode: true },
+        header: { template: "blue", title: { content: "消息将注入本轮", tag: "plain_text" } },
+        elements: [
+            { tag: "div", text: { tag: "lark_md", content: `当前会话正在生成中，你的消息会在**当前步骤结束后立即注入本轮**，无需等待整轮结束。\n\n> ${preview}` } },
+            { tag: "hr" },
+            {
+                tag: "action",
+                actions: [
+                    { tag: "button", text: { tag: "plain_text", content: "清空注入（/cancel）" }, type: "danger", value: { action: "cancel" } },
+                    { tag: "button", text: { tag: "plain_text", content: "停止生成（/stop）" }, type: "default", value: { action: "stop" } },
+                ],
+            },
+        ],
+    });
+}
+// 注入队列满卡片（仅 ccc）
+export function buildInjectionQueueFullCard() {
+    return JSON.stringify({
+        config: { wide_screen_mode: true },
+        header: { template: "yellow", title: { content: "待注入消息过多", tag: "plain_text" } },
+        elements: [
+            { tag: "div", text: { tag: "lark_md", content: "当前已有较多消息等待注入本轮，请稍候或发送指令：\n- **/stop** — 停止当前生成\n- **/cancel** — 清空待注入消息" } },
+            { tag: "hr" },
+            {
+                tag: "action",
+                actions: [
+                    { tag: "button", text: { tag: "plain_text", content: "清空注入（/cancel）" }, type: "danger", value: { action: "cancel" } },
+                    { tag: "button", text: { tag: "plain_text", content: "停止生成（/stop）" }, type: "default", value: { action: "stop" } },
+                ],
+            },
+        ],
+    });
+}
 // 状态卡片（带关闭按钮）
 export function buildStatusCard(statusText, template = "blue") {
     return JSON.stringify({

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/execution-transcript.js

@@ -58,6 +58,9 @@ export function appendExecutionTranscriptBlock(block, state, at = new Date().toI
             // Heartbeats carry no content and can occur very frequently. Persisting them
             // would add noise without helping users reconstruct what happened.
             return;
+        case "input_injected":
+            appendEntry(state, { type: "notice", at, text: `已注入新消息：${block.text}` });
+            return;
     }
 }
 export function isExecutionTranscriptEntry(value) {

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

@@ -14,10 +14,10 @@ import { withGitCoAuthor } from "../deepccc-agent/src/file-tools.js";
 import { makeTraceId, logTrace } from "./trace.js";
 import { appendStartupTrace } from "./shared.js";
 import { CLAUDE_MODEL, GIT_TIMEOUT_MS, PROJECT_ROOT, anthropicConfigDisplay, config, fileLog, getAllEffortsForTool, getAllModelsForTool, getDefaultEffortForTool, getDefaultCwd, LOG_DIR, setDefaultCwd, getRecentDirs, addRecentDir, resolveDefaultAgentTool, sessionPrefixForTool, toolDisplayName, ts, } from "./config.js";
-import { buildHelpCard, buildEffortCard, buildFastModeCard, buildModelCard, buildStatusCard, buildCdContent, buildCdCard, buildSessionsCard, buildQueuedCard, buildQueueFullCard, buildCodexUsageCard, } from "./cards.js";
+import { buildHelpCard, buildEffortCard, buildFastModeCard, buildModelCard, buildStatusCard, buildCdContent, buildCdCard, buildSessionsCard, buildQueuedCard, buildQueueFullCard, buildInjectionQueuedCard, buildInjectionQueueFullCard, buildCodexUsageCard, } from "./cards.js";
 import { formatGitResult, gitResultHeaderTemplate, runGitCommand, } from "./git-command.js";
 import { clearSessionModelOverride, clearSessionEffortOverride, getSessionStatus, getAllSessionsStatus, initClaudeSession, lastMsgTimestamps, resumeAndPrompt, sessionInfoMap, setSessionModelOverride, setSessionEffortOverride, switchChatBinding, recordSessionRegistry, getAdapterForTool, getEffectiveModelForTool, getEffectiveEffortForTool, getEffectiveFastModeForTool, setSessionFastModeOverride, stopSession, loadSessionRegistryForBinding, removeSessionRegistryRecord, saveSessionTool, saveSessionPresentation, recordChatPlatform, } from "./session.js";
-import { bindChatToSession, unbindChatFromSession, isSessionRunning, displayCards, enqueueMessage, cancelQueuedMessage, getSessionDrainSnapshot, } from "./session-chat-binding.js";
+import { bindChatToSession, unbindChatFromSession, isSessionRunning, displayCards, enqueueMessage, cancelQueuedMessage, pushInjection, clearInjections, getSessionDrainSnapshot, } from "./session-chat-binding.js";
 import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.js";
 import { getCursorUsageSummary } from "./cursor-usage.js";
 import { getChatGptSubscriptionStatus } from "./chatgpt-subscription.js";
@@ -1675,9 +1675,11 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         }
         if (isCommandText && textLower === "/cancel") {
             logTrace(tid, "BRANCH", { cmd: "/cancel" });
-            if (cancelQueuedMessage(sessionId)) {
+            const cancelledQueue = cancelQueuedMessage(sessionId);
+            const cancelledInjections = clearInjections(sessionId);
+            if (cancelledQueue || cancelledInjections) {
                 console.log(`[${ts()}] [CANCEL] Queue cancelled for session=${sessionId}`);
-                await platform.sendText(chatId, "已取消缓存队列中的消息。").catch(() => { });
+                await platform.sendText(chatId, "已取消缓存队列与待注入的消息。").catch(() => { });
                 logTrace(tid, "DONE", { outcome: "cancelled" });
             }
             else {
@@ -2237,6 +2239,35 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         }
         // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
         if (isSessionRunning(sessionId)) {
+            // 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} (${descriptionTool}) busy, message from chat ${chatId} queued for step-boundary injection`);
+                    if (platform.kind === "wechat") {
+                        await platform.sendText(chatId, "当前会话正在生成中，你的消息会在当前步骤结束后注入本轮处理。").catch(() => { });
+                    }
+                    else {
+                        await platform.sendRawCard(chatId, buildInjectionQueuedCard(text)).catch(() => { });
+                    }
+                }
+                else {
+                    logTrace(tid, "INJECT_QUEUE_FULL", { sessionId });
+                    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(() => { });
+                    }
+                    else {
+                        await platform.sendRawCard(chatId, buildInjectionQueueFullCard()).catch(() => { });
+                    }
+                }
+                return;
+            }
             const queued = enqueueMessage(sessionId, {
                 text: promptText, chatId, openId, msgTimestamp, chatType, traceId: tid,
             });

package/dist/src/progress/reducer.js

@@ -102,5 +102,11 @@ export function reduceProgress(prev, event) {
         case "compact":
             // 旧上下文压缩不影响当前过程展示
             return prev;
+        case "input_injected": {
+            // 协作式让位：在当前 turn 的 step 边界注入了新消息，仅在头部提示，
+            // 不改动正文与工具状态。
+            const preview = event.text.length > 40 ? `${event.text.slice(0, 40)}…` : event.text;
+            return withProgressView(prev, { headerTitle: `已注入新消息：${preview}` });
+        }
     }
 }

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

@@ -163,6 +163,48 @@ export function hasQueuedMessage(sessionId) {
     return queuedMessages.has(sessionId);
 }
 // ---------------------------------------------------------------------------
+// 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();
+export function pushInjection(sessionId, msg) {
+    const list = pendingInjections.get(sessionId) ?? [];
+    if (list.length >= MAX_PENDING_INJECTIONS)
+        return false;
+    list.push(msg);
+    pendingInjections.set(sessionId, list);
+    return true;
+}
+export function shiftInjection(sessionId) {
+    const list = pendingInjections.get(sessionId);
+    if (!list || list.length === 0)
+        return undefined;
+    const msg = list.shift();
+    if (list.length === 0)
+        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);
+    return list ?? [];
+}
+export function hasPendingInjection(sessionId) {
+    return (pendingInjections.get(sessionId)?.length ?? 0) > 0;
+}
+export function clearInjections(sessionId) {
+    pendingInjections.delete(sessionId);
+}
+// ---------------------------------------------------------------------------
 // 队列消费回调（由 index.ts 注入，避免 session.ts → orchestrator.ts 循环依赖）
 // ---------------------------------------------------------------------------
 let onConsumeQueuedMessage = null;
@@ -187,6 +229,7 @@ export function resetBindingState() {
     finalizingSessions.clear();
     autoRecoveryReservations.clear();
     queuedMessages.clear();
+    pendingInjections.clear();
     displayCards.clear();
     if (unifiedDisplayLoopHandle !== null) {
         clearInterval(unifiedDisplayLoopHandle);