chatccc 0.2.286 → 0.2.287

package/deepccc-agent/package.json

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

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

@@ -459,6 +459,10 @@ async function runRepl(args) {
     }
     let currentAbort = null;
     const ctrlCState = createCtrlCState();
+    // 协作式让位：agent 运行期间用户仍可输入，新行进入注入队列，由内核在每个
+    // model step 边界 drain 后吸收到当前 turn（而非等待整轮结束）。
+    let chatRunning = false;
+    const pendingInjections = [];
     rl.prompt();
     rl.on("line", async (line) => {
         ctrlCState.reset();
@@ -467,6 +471,17 @@ async function runRepl(args) {
             rl.prompt();
             return;
         }
+        if (chatRunning) {
+            // 运行期间不并发启动新 turn：把输入注入当前 turn 的 step 边界。
+            if (input === "exit" || input.startsWith("/")) {
+                process.stdout.write(`${C.dim}[running] 命令将在本轮结束后生效；或按两次 Ctrl+C 中断${C.reset}\n`);
+                return;
+            }
+            pendingInjections.push(buildAttachmentPrompt(input, pendingAttachments));
+            pendingAttachments = [];
+            process.stdout.write(`${C.dim}[queued] 消息将在当前步骤后注入本轮${C.reset}\n`);
+            return;
+        }
         if (input === "exit") {
             process.stdout.write(`${C.dim}bye${C.reset}\n`);
             rl.close();
@@ -510,10 +525,11 @@ async function runRepl(args) {
             const chatInput = buildAttachmentPrompt(input, pendingAttachments);
             pendingAttachments = [];
             let lastAccumulated = "";
-            for await (const event of session.chat(chatInput, signal)) {
+            chatRunning = true;
+            for await (const event of session.chat(chatInput, signal, () => pendingInjections.shift())) {
                 if (renderer && view) {
                     view = reduceProgress(view, event);
-                    if (event.type === "text" || event.type === "compact" || event.type === "status") {
+                    if (event.type === "text" || event.type === "compact" || event.type === "status" || event.type === "input_injected") {
                         renderer.render(view);
                     }
                     else {
@@ -543,6 +559,9 @@ async function runRepl(args) {
                     const status = event.is_error ? "error" : "ok";
                     console.log(`${C.dim}[tool result] ${event.name ?? event.tool_use_id} ${status}${C.reset}`);
                 }
+                else if (event.type === "input_injected") {
+                    console.log(`\n${C.dim}[injected] ${event.text}${C.reset}`);
+                }
                 else if (event.type === "error") {
                     console.log(`\n${C.yellow}[error] ${event.message}${C.reset}`);
                 }
@@ -561,6 +580,7 @@ async function runRepl(args) {
         finally {
             activeRenderer = null;
             activeView = null;
+            chatRunning = false;
             if (renderer && view && !rendererEnded) {
                 // 定型终态区块（完成/已停止/异常结束）留在屏幕上，恢复光标
                 renderer.end(view);

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

@@ -246,6 +246,17 @@ function normalizeAnthropicBaseURL(baseURL) {
     // DeepSeek Anthropic 端点示例：https://api.deepseek.com/anthropic/v1。
     return baseURL.trim().replace(/\/+$/, "");
 }
+/**
+ * 协作式让位的内部中断信号：在 prepareStep（每个模型 step 前）检测到外部
+ * 注入消息时抛出，触发 chat() 持久化当前中间态 → 注入 user 消息 → 以新
+ * messages 重启 streamText，让 agent 在当前 turn 内吸收新指令而非结束整轮。
+ */
+class InputInjectionInterrupt extends Error {
+    constructor() {
+        super("input injection requested at step boundary");
+        this.name = "InputInjectionInterrupt";
+    }
+}
 export class ChatSession {
     model;
     /** 子模型实例；未配置 subModel 时与主模型同一实例 */
@@ -396,7 +407,7 @@ export class ChatSession {
         }
         return systemContent.join("\n");
     }
-    async *chat(userMessage, signal) {
+    async *chat(userMessage, signal, drainInput) {
         this.context.appendMessage({ role: "user", content: userMessage });
         let fullText = "";
         let safeAccumulated = "";
@@ -469,6 +480,13 @@ export class ChatSession {
                     ? { [OPENAI_COMPATIBLE_PROVIDER_NAME]: { reasoningEffort: this.effort } }
                     : { anthropic: { effort: this.effort } };
             }
+            // 协作式让位（仅 streaming 模式）：外部可在每个 model step 边界 drain 一条
+            // 新消息注入当前 turn。non-streaming 下 generateText 是原子请求，无法在 step
+            // 边界取回中间工具结果，因此忽略 drainInput（消息留在上层队列，整轮结束后消费）。
+            const canInject = this.streaming && typeof drainInput === "function";
+            // pendingInjection 是 prepareStep 与 catch 之间的注入信号槽。用标志而非
+            // instanceof 判断，因为 provider SDK 可能包装抛出的错误。
+            let pendingInjection = null;
             const baseGenerationOptions = {
                 model: this.model,
                 system,
@@ -483,6 +501,13 @@ export class ChatSession {
                 stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
                 abortSignal: signal,
                 prepareStep: ({ messages, stepNumber }) => {
+                    if (canInject) {
+                        const injected = drainInput();
+                        if (injected) {
+                            pendingInjection = injected;
+                            throw new InputInjectionInterrupt();
+                        }
+                    }
                     const compacted = compactToolLoopMessages(messages);
                     if (compacted.compactedResults > 0) {
                         rawLog?.writeLine(safeRawStreamJson({
@@ -500,151 +525,198 @@ export class ChatSession {
                     : {}),
                 ...(effortProviderOptions ? { providerOptions: effortProviderOptions } : {}),
             };
-            for (let attempt = 0; attempt < 2; attempt += 1) {
-                fullText = "";
-                safeAccumulated = "";
-                toolContext = [];
-                toolCallsById.clear();
-                toolCallOrder.length = 0;
-                timeline.length = 0;
-                let lastReasoningProgressAt;
-                const attemptMessages = attempt === 0
-                    ? modelMessages
-                    : [...modelMessages, { role: "user", content: TOOL_PROTOCOL_RECOVERY_PROMPT }];
-                const generationOptions = {
-                    ...baseGenerationOptions,
-                    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.
-                        const now = Date.now();
-                        if (lastReasoningProgressAt === undefined || now - lastReasoningProgressAt >= 1_000) {
-                            lastReasoningProgressAt = now;
-                            yield { type: "progress", phase: "reasoning" };
-                        }
-                    }
-                    else if (part.type === "text-delta") {
-                        fullText += part.text;
-                        const previous = timeline[timeline.length - 1];
-                        if (previous?.type === "text")
-                            previous.text += part.text;
-                        else
-                            timeline.push({ type: "text", text: part.text });
-                        // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
-                        // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
-                        const safeText = applyPrivacy(part.text);
-                        safeAccumulated += safeText;
-                        yield { type: "text", text: safeText, accumulated: safeAccumulated };
-                    }
-                    else if (part.type === "tool-call") {
-                        const input = safeJson(part.input);
-                        toolContext.push(`tool_call ${part.toolName}: ${input}`);
-                        toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input });
-                        toolCallOrder.push(part.toolCallId);
-                        timeline.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input });
-                        yield {
-                            type: "tool_use",
-                            id: part.toolCallId,
-                            name: part.toolName,
-                            input: applyPrivacyToJson(part.input),
-                        };
-                    }
-                    else if (part.type === "tool-result") {
-                        const output = truncateToolContext(safeJson(part.output));
-                        toolContext.push(`tool_result ${part.toolName}: ${output}`);
-                        const call = toolCallsById.get(part.toolCallId);
-                        if (call)
-                            call.output = output;
-                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output });
-                        yield {
-                            type: "tool_result",
-                            tool_use_id: part.toolCallId,
-                            name: part.toolName,
-                            content: applyPrivacyToJson(part.output),
-                            is_error: false,
+            // 注入重启后 context 已变（中间 assistant + 注入 user），需要重新构建并应用
+            // 与首次一致的 recovery-hint / anthropic 兼容提示。
+            const decorateMessages = (msgs) => {
+                const hinted = maybeAppendCompactionRecoveryHint(msgs, this.context.summary, appConfig.rawStreamLogs.enabled, this.context.sessionId);
+                return this.provider === "anthropic"
+                    ? addAnthropicToolJsonCompatibilityNote(hinted)
+                    : hinted;
+            };
+            let currentMessages = modelMessages;
+            while (true) {
+                pendingInjection = null;
+                try {
+                    for (let attempt = 0; attempt < 2; attempt += 1) {
+                        fullText = "";
+                        toolContext = [];
+                        toolCallsById.clear();
+                        toolCallOrder.length = 0;
+                        timeline.length = 0;
+                        // safeAccumulated 是整轮展示累积：注入延续时不重置，只有工具协议恢复
+                        // （重新生成、已 yield text_reset）才重置。
+                        if (attempt === 1)
+                            safeAccumulated = "";
+                        let lastReasoningProgressAt;
+                        const attemptMessages = attempt === 0
+                            ? currentMessages
+                            : [...currentMessages, { role: "user", content: TOOL_PROTOCOL_RECOVERY_PROMPT }];
+                        const generationOptions = {
+                            ...baseGenerationOptions,
+                            messages: attemptMessages,
                         };
-                    }
-                    else if (part.type === "tool-error") {
-                        const message = errorMessage(part.error);
-                        toolContext.push(`tool_error ${part.toolName}: ${message}`);
-                        const call = toolCallsById.get(part.toolCallId);
-                        if (call) {
-                            call.output = message;
-                            call.is_error = true;
+                        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);
                         }
-                        timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output: message, is_error: true });
-                        yield {
-                            type: "tool_result",
-                            tool_use_id: part.toolCallId,
-                            name: part.toolName,
-                            content: applyPrivacy(message),
-                            is_error: true,
-                        };
-                    }
-                    else if (part.type === "error") {
-                        const message = errorMessage(part.error);
-                        yield { type: "error", message: applyPrivacy(message) };
-                        throw new Error(message);
+                        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.
+                                const now = Date.now();
+                                if (lastReasoningProgressAt === undefined || now - lastReasoningProgressAt >= 1_000) {
+                                    lastReasoningProgressAt = now;
+                                    yield { type: "progress", phase: "reasoning" };
+                                }
+                            }
+                            else if (part.type === "text-delta") {
+                                fullText += part.text;
+                                const previous = timeline[timeline.length - 1];
+                                if (previous?.type === "text")
+                                    previous.text += part.text;
+                                else
+                                    timeline.push({ type: "text", text: part.text });
+                                // 隐私替换只在展示层：safeAccumulated 供事件消费者（终端/JSONL）使用，
+                                // fullText 原文用于持久化上下文，避免替换结果回流污染上下文。
+                                const safeText = applyPrivacy(part.text);
+                                safeAccumulated += safeText;
+                                yield { type: "text", text: safeText, accumulated: safeAccumulated };
+                            }
+                            else if (part.type === "tool-call") {
+                                const input = safeJson(part.input);
+                                toolContext.push(`tool_call ${part.toolName}: ${input}`);
+                                toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input });
+                                toolCallOrder.push(part.toolCallId);
+                                timeline.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input });
+                                yield {
+                                    type: "tool_use",
+                                    id: part.toolCallId,
+                                    name: part.toolName,
+                                    input: applyPrivacyToJson(part.input),
+                                };
+                            }
+                            else if (part.type === "tool-result") {
+                                const output = truncateToolContext(safeJson(part.output));
+                                toolContext.push(`tool_result ${part.toolName}: ${output}`);
+                                const call = toolCallsById.get(part.toolCallId);
+                                if (call)
+                                    call.output = output;
+                                timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output });
+                                yield {
+                                    type: "tool_result",
+                                    tool_use_id: part.toolCallId,
+                                    name: part.toolName,
+                                    content: applyPrivacyToJson(part.output),
+                                    is_error: false,
+                                };
+                            }
+                            else if (part.type === "tool-error") {
+                                const message = errorMessage(part.error);
+                                toolContext.push(`tool_error ${part.toolName}: ${message}`);
+                                const call = toolCallsById.get(part.toolCallId);
+                                if (call) {
+                                    call.output = message;
+                                    call.is_error = true;
+                                }
+                                timeline.push({ type: "tool_result", tool_use_id: part.toolCallId, name: part.toolName, output: message, is_error: true });
+                                yield {
+                                    type: "tool_result",
+                                    tool_use_id: part.toolCallId,
+                                    name: part.toolName,
+                                    content: applyPrivacy(message),
+                                    is_error: true,
+                                };
+                            }
+                            else if (part.type === "error") {
+                                if (pendingInjection !== null) {
+                                    // prepareStep 里的注入中断被 provider 转成了 error part。
+                                    throw new InputInjectionInterrupt();
+                                }
+                                const message = errorMessage(part.error);
+                                yield { type: "error", message: applyPrivacy(message) };
+                                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})`);
+                            rawLog?.writeLine(safeRawStreamJson({
+                                type: "deepccc_tool_protocol_recovery",
+                                attempt: attempt + 1,
+                                structuredToolCalls: toolCallOrder.length,
+                            }));
+                            yield { type: "text_reset" };
+                            if (attempt === 0 && toolCallOrder.length === 0) {
+                                yield { type: "status", phase: "generating" };
+                                continue;
+                            }
+                            throw new Error(toolCallOrder.length > 0
+                                ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
+                                : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
+                        }
+                        completed = true;
+                        const collectedToolCalls = toolCallOrder
+                            .map((id) => toolCallsById.get(id))
+                            .filter((call) => call !== undefined);
+                        this.context.appendMessage(buildPersistedAssistantMessage({
+                            fullText,
+                            transcriptLines: toolContext,
+                            toolCalls: collectedToolCalls,
+                            timeline,
+                        }));
+                        yield { type: "done", text: safeAccumulated };
+                        return;
                     }
                 }
-                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})`);
-                    rawLog?.writeLine(safeRawStreamJson({
-                        type: "deepccc_tool_protocol_recovery",
-                        attempt: attempt + 1,
-                        structuredToolCalls: toolCallOrder.length,
-                    }));
-                    yield { type: "text_reset" };
-                    if (attempt === 0 && toolCallOrder.length === 0) {
-                        yield { type: "status", phase: "generating" };
+                catch (err) {
+                    if (pendingInjection !== null) {
+                        // 协作式让位：持久化本段中间态 → 注入 user → 重建 messages → 继续当前 turn。
+                        if (fullText.trim() || toolCallOrder.length > 0) {
+                            const collectedToolCalls = toolCallOrder
+                                .map((id) => toolCallsById.get(id))
+                                .filter((call) => call !== undefined);
+                            this.context.appendMessage(buildPersistedAssistantMessage({
+                                fullText,
+                                transcriptLines: toolContext,
+                                toolCalls: collectedToolCalls,
+                                timeline: timeline.map((entry) => ({ ...entry })),
+                            }));
+                        }
+                        const injectedText = pendingInjection;
+                        this.context.appendMessage({ role: "user", content: injectedText });
+                        rawLog?.writeLine(safeRawStreamJson({
+                            type: "deepccc_input_injected",
+                            text: injectedText,
+                        }));
+                        yield { type: "input_injected", text: injectedText };
+                        currentMessages = decorateMessages(this.context.buildModelMessages());
                         continue;
                     }
-                    throw new Error(toolCallOrder.length > 0
-                        ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
-                        : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
+                    throw err;
                 }
-                completed = true;
-                const collectedToolCalls = toolCallOrder
-                    .map((id) => toolCallsById.get(id))
-                    .filter((call) => call !== undefined);
-                this.context.appendMessage(buildPersistedAssistantMessage({
-                    fullText,
-                    transcriptLines: toolContext,
-                    toolCalls: collectedToolCalls,
-                    timeline,
-                }));
-                yield { type: "done", text: safeAccumulated };
-                return;
             }
         }
         catch (err) {

package/dist/deepccc-agent/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/adapters/ccc-adapter.js

@@ -52,7 +52,7 @@ export function createCccAdapter(options = {}) {
             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)) {
+            for await (const event of session.chat(userText, signal, _promptOptions?.drainInput)) {
                 if (event.type === "text")
                     completion.observe({ type: "assistant", blocks: [{ type: "text", text: event.text }] });
                 if (event.type === "text_reset")
@@ -78,6 +78,12 @@ export function createCccAdapter(options = {}) {
                         blocks: [{ type: "text_reset" }],
                     };
                 }
+                else if (event.type === "input_injected") {
+                    yield {
+                        type: "assistant",
+                        blocks: [{ type: "input_injected", text: event.text }],
+                    };
+                }
                 else if (event.type === "text") {
                     yield {
                         type: "assistant",

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/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/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,34 @@ async function handleCommandInternal(platform, text, chatId, openId, msgTimestam
         }
         // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
         if (isSessionRunning(sessionId)) {
+            // ccc 内核支持协作式让位：运行期新消息进入注入队列，由 drainInput 在每个
+            // model step 边界逐条吸收进当前 turn（不新开 turn）。其他 agent 保持整轮队列。
+            if (descriptionTool === "ccc") {
+                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`);
+                    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} (ccc) 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,42 @@ export function hasQueuedMessage(sessionId) {
     return queuedMessages.has(sessionId);
 }
 // ---------------------------------------------------------------------------
+// pendingInjections: sessionId → 运行中待注入消息（仅 ccc 内核）
+// 与上面的 queuedMessages（整轮队列，深度 1）分离：ccc 运行期的新消息进入
+// 这里，由 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;
+}
+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 +223,7 @@ export function resetBindingState() {
     finalizingSessions.clear();
     autoRecoveryReservations.clear();
     queuedMessages.clear();
+    pendingInjections.clear();
     displayCards.clear();
     if (unifiedDisplayLoopHandle !== null) {
         clearInterval(unifiedDisplayLoopHandle);

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, 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, 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)
@@ -827,6 +827,10 @@ export function accumulateBlockContent(block, state, toolCallMap) {
         }
         case "agent_status":
             break;
+        case "input_injected":
+            // 协作式让位：显示一条轻量注入标记（仅过程展示，不进入最终回复）。
+            state.accumulatedContent += `\n\n↳ 已注入新消息：${block.text}\n`;
+            break;
     }
 }
 export async function switchChatBinding(args) {
@@ -1299,6 +1303,16 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 if (prompt)
                     prompt.closeSession = closeSession;
             },
+            // ccc 内核支持协作式让位：同步从注入队列取队首文本，供内核在每个
+            // model step 边界吸收。非 ccc adapter 忽略该字段。
+            drainInput: tool === "ccc" ? () => {
+                const injected = shiftInjection(sessionId);
+                if (!injected)
+                    return undefined;
+                // 与首次消息保持一致的结构化包装；imSkillsPrompt 已在首次消息中，
+                // 此处不重复注入，避免多轮注入导致上下文膨胀。
+                return `[User message]\n${injected.text}\n[/User message]`;
+            } : undefined,
         })) {
             if (unifiedMsg.isFinalResponse) {
                 const prompt = activePrompts.get(sessionId);
@@ -1630,11 +1644,20 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 if (discarded) {
                     console.log(`[${ts()}] [QUEUE] Discarding queued message for stopped session ${sessionId}`);
                 }
+                const discardedInjections = drainRemainingInjections(sessionId);
+                if (discardedInjections.length > 0) {
+                    console.log(`[${ts()}] [INJECT] Discarding ${discardedInjections.length} pending injection(s) for stopped session ${sessionId}`);
+                }
             }
             else if (!shouldScheduleAutoRecovery) {
                 // 第一次 response-stall 后保留普通缓存；恢复轮结束后由恢复轮的
                 // finally 再消费，顺序固定为“自动恢复 → 用户缓存”。
                 queuedForConsumption = dequeueMessage(sessionId);
+                // ccc 注入队列剩余（turn 期间未注入完，如 non-streaming 或收尾窗口到达）
+                // 取第一条转普通消费，其余留待下一轮结束后继续消费。
+                if (!queuedForConsumption) {
+                    queuedForConsumption = shiftInjection(sessionId);
+                }
             }
             if (queuedForConsumption) {
                 const queued = queuedForConsumption;
@@ -2043,6 +2066,7 @@ export function stopSession(sessionId) {
     if (!prompt) {
         if (cancelledRecovery) {
             cancelQueuedMessage(sessionId);
+            clearInjections(sessionId);
             console.log(`[${ts()}] [STOP] Reserved automatic recovery for ${sessionId} cancelled`);
             return true;
         }
@@ -2054,6 +2078,7 @@ export function stopSession(sessionId) {
     clearPromptAvatarRefreshTimer(sessionId);
     clearPromptFinalResponseCloseTimer(sessionId);
     cancelQueuedMessage(sessionId);
+    clearInjections(sessionId);
     // 先发起整棵进程树清理，再触发 close/abort。Windows 上 CLI 由
     // cmd.exe → node → 实际二进制组成；若先 process.kill(cmd.exe)，taskkill
     // 随后便无法从已消失的根 PID 找到后代，正是幽灵 Codex/Cursor 的来源。

package/package.json

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