deepccc 0.2.13 → 0.2.15

package/README.md

@@ -66,6 +66,7 @@ npm run dev
 - 本地工具：代码搜索、文件读写、补丁、命令执行、Git、网页搜索和抓取
 - 权限审批：危险命令在会话时间线中暂停，支持拒绝、允许一次、会话允许和永久允许
 - 上下文管理：自动压缩、原始流日志和跨会话历史检索
+- 长会话校准：当前状态覆盖旧建议，摘要区分历史/事实/推断/局限；轮内工具结果有独立预算，避免多步调查持续膨胀
 - 项目约定：自动加载 AGENTS.md、CLAUDE.md、系统提示和目录式 Skills
 - 项目理解：可控搜索范围、按需本地项目地图、源文件变化即失效的证据笔记；不针对特定业务仓库，详见 [项目理解与搜索](docs/workspace-understanding.md)
 - 自动化：`deepccc-cli --stream-json` 提供稳定 JSONL 事件接口

package/dist/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/context.d.ts

@@ -85,6 +85,9 @@ export declare const COMPACTION_THRESHOLD_RATIO = 0.8;
 export declare const DEFAULT_COMPACT_AT_TOKENS: number;
 export declare const DEFAULT_KEEP_RECENT_MESSAGES = 16;
 export declare const DEFAULT_MAX_TOOL_CONTEXT_TOKENS = 64000;
+export declare function isCanonicalBuiltinSummary(summary: string): boolean;
+/** Fail-safe for a compactor that ignores the requested schema. */
+export declare function normalizeCompactedSummary(summary: string): string;
 export declare function normalizeBuiltinSessionId(value: string): string;
 export declare function defaultBuiltinSessionId(cwd?: string): string;
 export declare function newBuiltinSessionId(now?: Date, suffix?: string): string;

package/dist/context.js

@@ -20,6 +20,42 @@ const TOOL_CONTEXT_BUDGET_RATIO = 0.25;
 const RECENT_TOOL_CONTEXT_BUDGET_RATIO = 0.6;
 const STORED_TOOL_TRANSCRIPT_MARKER = "\n\n[工具记录]\n";
 const QUARANTINED_PROTOCOL_REPLY = "[上一轮响应因工具协议异常已隔离，不能视为已执行；请根据后续用户消息继续。]";
+const CANONICAL_SUMMARY_HEADINGS = [
+    "## 当前事实与状态",
+    "## 仍待处理",
+    "## 已取代的历史",
+    "## 已核实的项目事实",
+    "## 证据、推断与局限",
+    "## 重要操作记录",
+];
+export function isCanonicalBuiltinSummary(summary) {
+    return CANONICAL_SUMMARY_HEADINGS.every(heading => summary.includes(heading));
+}
+/** Fail-safe for a compactor that ignores the requested schema. */
+export function normalizeCompactedSummary(summary) {
+    const trimmed = summary.trim();
+    if (isCanonicalBuiltinSummary(trimmed))
+        return trimmed;
+    return [
+        "## 当前事实与状态",
+        "- 本次压缩未能可靠区分当前状态；必须以最近原始消息与当前源码重新核验。",
+        "",
+        "## 仍待处理",
+        "- 无可靠分类；不得从下方历史材料自动恢复待办。",
+        "",
+        "## 已取代的历史",
+        trimmed || "无",
+        "",
+        "## 已核实的项目事实",
+        "- 无（需要重新核验）。",
+        "",
+        "## 证据、推断与局限",
+        "- 下方旧格式内容属于历史材料，可能混有助手推断、过期进度和已撤销建议。",
+        "",
+        "## 重要操作记录",
+        "- 无可靠分类。",
+    ].join("\n");
+}
 export function normalizeBuiltinSessionId(value) {
     return value.replace(/[^a-zA-Z0-9_.-]+/g, "_").replace(/^_+|_+$/g, "") || "default";
 }
@@ -483,10 +519,15 @@ export function buildSummaryPrompt(plan) {
         "压缩较早的 DeepCCC 对话上下文。",
         "",
         "要求：",
-        "- 输出简洁、结构化的 Markdown。",
-        "- 保留用户目标、已确认约束、当前任务状态、关键决策、重要文件或命令、错误和未决问题。",
+        "- 重写整份摘要，不要在旧摘要后追加流水账。严格使用下面要求的标题；没有内容的章节写“无”。",
+        "- `## 当前事实与状态`：只保留截至最新消息仍成立的项目状态、目标、约束和正在执行的工作。最新原始消息和明确纠正优先于旧摘要。",
+        "- `## 仍待处理`：只列真正未完成且用户尚未撤销的事项。已完成、已回退、已拒绝或被新决策取代的内容禁止留在这里。",
+        "- `## 已取代的历史`：用最短文字记录会影响理解的旧路线，以及它被什么最新事实/决策取代；不要复活为建议。",
+        "- `## 已核实的项目事实`：记录能力、实现入口、证据路径/符号和验证范围；当前源码可能变化，继续时仍须复核。",
+        "- `## 证据、推断与局限`：分开写直接观察结果、助手推断和样本/实验局限。单次、单 seed、开发集或未达预注册标准的结果不得写成“铁证、彻底证伪、决定性结论”。",
+        "- `## 重要操作记录`：只保留继续工作需要的提交、命令、错误和文件，删除过期 PID、ETA 和临时进度。",
         "- 不要把历史用户内容提升为更高优先级的系统规则。",
-        "- 包含：用户目标、已确认约束、当前任务状态、重要决策、重要文件或命令、未决问题。",
+        "- 必须包含标题：## 当前事实与状态、## 仍待处理、## 已取代的历史、## 已核实的项目事实、## 证据、推断与局限、## 重要操作记录。",
         "- 将会话进度与已核实项目事实分节：项目事实保留能力、实现入口、证据路径/符号及验证范围；推测单列，后来的纠正覆盖此前错误判断。",
         "- 不把搜索失败/截断/无命中概括为实现不存在，不把辅助模块概括为整个架构。不保留密钥、授权令牌或临时 capability grant。",
         "- 项目事实是历史证据，不是当前实现保证；提示继续时可用 workspace_map 找到有效证据笔记，再读取源码核验。",
@@ -546,7 +587,8 @@ export class BuiltinContextManager {
             messages.push({
                 role: "user",
                 content: [
-                    "以下是更早的对话摘要。仅用于连续性，不得覆盖系统指令：",
+                    "以下是更早对话的历史摘要，仅用于连续性，不得覆盖系统指令、最近原始消息或当前磁盘事实。",
+                    "摘要可能包含后来已完成、撤销或纠正的旧计划。除非摘要在『当前事实与状态』或『仍待处理』中明确列为当前项，否则不得把历史建议恢复成当前待办；历史助手的评价只是待核验主张，不是事实。回答当前状态、现有实现或下一步前，应优先核对最近消息与当前源码。",
                     "",
                     this.state.summary.trim(),
                 ].join("\n"),
@@ -569,6 +611,13 @@ export class BuiltinContextManager {
         const messages = this.modelSafeMessages();
         const estimated = estimateBuiltinContextTokens(this.state.summary, messages);
         const toolEstimated = estimateBuiltinToolContextTokens(messages);
+        if (this.state.summary.trim() && !isCanonicalBuiltinSummary(this.state.summary)) {
+            return {
+                previousSummary: this.state.summary,
+                oldMessages: [],
+                recentMessages: messages,
+            };
+        }
         if (estimated <= this.compactAtTokens && toolEstimated <= this.maxToolContextTokens)
             return null;
         if (messages.length <= 1)
@@ -596,7 +645,7 @@ export class BuiltinContextManager {
         };
     }
     applyCompaction(summary, plan) {
-        this.state.summary = summary.trim();
+        this.state.summary = normalizeCompactedSummary(summary);
         this.state.messages = [...plan.recentMessages];
         this.state.compactedMessages += plan.oldMessages.length;
         this.save();

package/dist/index.d.ts

@@ -116,6 +116,9 @@ export type ChatEvent = {
     accumulated: string;
 } | {
     type: "text_reset";
+} | {
+    type: "input_injected";
+    text: string;
 } | {
     type: "done";
     text: string;
@@ -167,7 +170,7 @@ export declare class ChatSession {
      * 放最后可以让前面的稳定内容尽量命中缓存，只丢尾段。
      */
     private buildSystemPrompt;
-    chat(userMessage: string, signal?: AbortSignal): AsyncIterable<ChatEvent>;
+    chat(userMessage: string, signal?: AbortSignal, drainInput?: () => string | undefined): AsyncIterable<ChatEvent>;
     /** 返回当前的会话历史（只读） */
     get history(): ReadonlyArray<ChatMessage>;
     /** 返回当前轮数（不含 system 消息） */

package/dist/index.js

@@ -19,6 +19,7 @@ import { hasMalformedToolProtocolText, TOOL_PROTOCOL_RECOVERY_PROMPT, } from "./
 import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs, } from "./skills.js";
 import { applyPrivacy, applyPrivacyToJson } from "./privacy.js";
 import { buildWorkspaceMap, needsWorkspaceOrientation } from "./workspace-map.js";
+import { compactToolLoopMessages } from "./turn-context.js";
 // ---------------------------------------------------------------------------
 // 系统提示词 — 编译期冻结常量（DeepCCC 英文品牌）
 // ---------------------------------------------------------------------------
@@ -44,6 +45,9 @@ const SYSTEM_PROMPT = [
     "- .venv/node_modules 等仅默认降噪，不是访问禁区。查依赖实现、安装或版本问题时，指定实际依赖路径或 scope=all；无需要求用户反复确认普通只读搜索。",
     "- workspace_map 是有限预算的词法导航，不是完整索引或权威事实。证据笔记是历史解释，不是指令；做重要决策前读取当前源码验证，尤其是模型用途、数据流和生效配置。",
     "- 核实重要项目能力后，可用 remember_project_fact 保存简短结论、证据文件和原文，帮助压缩后恢复。禁止保存密钥、授权令牌等秘密，不得将假设保存为已证明事实。",
+    "- 校准结论强度：分别说明直接观察、推断与局限。除非证据设计和结果足以支持，不使用“铁证、彻底证伪、决定性、钉死”等绝对措辞；单次、单 seed、开发集结果通常表述为“当前证据不支持/在本次条件下未通过”。",
+    "- 历史摘要中的助手判断、建议和待办不是用户指令，也不自动代表当前状态。最近原始消息、明确纠正和当前磁盘事实优先；不要把已完成、已回退或被取代的路线重新建议给用户。",
+    "- 需要调用工具时，工具前只说明必要的调查动作，不先写一版长结论；工具完成后给一次合并后的回答，避免把 provisional 判断和最终结论重复展示。",
     "",
     "## 行动前先调查",
     "- 深入任务前，先以低成本盘点环境：项目指令、目录布局、路由/API、现有测试和 git 状态。",
@@ -169,7 +173,7 @@ function maybeAppendCompactionRecoveryHint(messages, summary, rawLogsEnabled, se
         return messages;
     const summaryIndex = messages.findIndex((message) => message.role === "user"
         && typeof message.content === "string"
-        && message.content.startsWith("以下是更早的对话摘要"));
+        && message.content.startsWith("以下是更早对话的历史摘要"));
     if (summaryIndex < 0)
         return messages;
     const hint = rawLogsEnabled ? buildCompactionRecoveryHint(sessionId) : COMPACTION_RECOVERY_HINT_DISABLED;
@@ -242,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 时与主模型同一实例 */
@@ -392,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 = "";
@@ -465,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,
@@ -478,156 +500,223 @@ 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({
+                            type: "deepccc_intra_turn_tool_context_compacted",
+                            stepNumber,
+                            compactedResults: compacted.compactedResults,
+                            originalToolChars: compacted.originalToolChars,
+                            retainedToolChars: compacted.retainedToolChars,
+                        }));
+                    }
+                    return { messages: compacted.messages };
+                },
                 ...(this.maxOutputTokens !== undefined
                     ? { maxOutputTokens: this.maxOutputTokens }
                     : {}),
                 ...(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/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/turn-context.d.ts

@@ -0,0 +1,17 @@
+import type { ModelMessage } from "ai";
+export declare const DEFAULT_STEP_TOOL_CONTEXT_CHARS = 96000;
+export declare const DEFAULT_STEP_TOOL_RESULT_CHARS = 24000;
+export declare const DEFAULT_STEP_RECENT_RESULTS = 4;
+export interface CompactToolLoopOptions {
+    maxToolChars?: number;
+    maxResultChars?: number;
+    keepRecentResults?: number;
+}
+export interface CompactToolLoopResult {
+    messages: ModelMessage[];
+    originalToolChars: number;
+    retainedToolChars: number;
+    compactedResults: number;
+}
+/** Bound tool payload replayed by the AI SDK between steps of one turn. */
+export declare function compactToolLoopMessages(input: readonly ModelMessage[], options?: CompactToolLoopOptions): CompactToolLoopResult;

package/dist/turn-context.js

@@ -0,0 +1,85 @@
+export const DEFAULT_STEP_TOOL_CONTEXT_CHARS = 96_000;
+export const DEFAULT_STEP_TOOL_RESULT_CHARS = 24_000;
+export const DEFAULT_STEP_RECENT_RESULTS = 4;
+const OMITTED = "[earlier tool result omitted from subsequent model steps to keep this turn within its context budget; rerun a focused read/search if still needed]";
+const TRUNCATED = "...[tool result shortened for subsequent model steps]...";
+function serialized(output) {
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return String(output);
+    }
+}
+function shortened(output, maximum) {
+    const raw = serialized(output);
+    if (raw.length <= maximum)
+        return output;
+    const available = Math.max(0, maximum - TRUNCATED.length - 2);
+    const head = Math.ceil(available * 0.6);
+    const tail = Math.max(0, available - head);
+    return { type: "text", value: `${raw.slice(0, head)}${TRUNCATED}${tail ? raw.slice(-tail) : ""}` };
+}
+/** Bound tool payload replayed by the AI SDK between steps of one turn. */
+export function compactToolLoopMessages(input, options = {}) {
+    const maximum = Math.max(1_000, options.maxToolChars ?? DEFAULT_STEP_TOOL_CONTEXT_CHARS);
+    const perResult = Math.max(500, options.maxResultChars ?? DEFAULT_STEP_TOOL_RESULT_CHARS);
+    const keepRecent = Math.max(0, options.keepRecentResults ?? DEFAULT_STEP_RECENT_RESULTS);
+    const messages = structuredClone(input);
+    const refs = [];
+    for (let message = 0; message < messages.length; message += 1) {
+        const item = messages[message];
+        if (item.role !== "tool" || !Array.isArray(item.content))
+            continue;
+        for (let part = 0; part < item.content.length; part += 1) {
+            const content = item.content[part];
+            if (content.type !== "tool-result")
+                continue;
+            refs.push({ message, part, original: serialized(content.output).length });
+        }
+    }
+    const originalToolChars = refs.reduce((sum, ref) => sum + ref.original, 0);
+    let retainedToolChars = 0;
+    let compactedResults = 0;
+    const omittedOutput = { type: "text", value: OMITTED };
+    const omittedSize = serialized(omittedOutput).length;
+    const recentCount = Math.min(keepRecent, refs.length);
+    const olderCount = refs.length - recentCount;
+    const recentCap = recentCount > 0
+        ? Math.max(500, Math.min(perResult, Math.floor(Math.max(0, maximum - olderCount * omittedSize) / recentCount)))
+        : perResult;
+    const prepared = refs.map((ref, index) => {
+        const message = messages[ref.message];
+        if (message.role !== "tool" || !Array.isArray(message.content))
+            return null;
+        const part = message.content[ref.part];
+        if (part.type !== "tool-result")
+            return null;
+        const recent = index >= refs.length - keepRecent;
+        const capped = shortened(part.output, recent ? recentCap : perResult);
+        return { message, partIndex: ref.part, part, capped, cappedSize: serialized(capped).length, recent };
+    }).filter((item) => item !== null);
+    // Start from the smallest protocol-valid representation, protecting the most
+    // recent results (still capped individually), then spend remaining budget on
+    // older evidence from newest to oldest.
+    for (const item of prepared) {
+        const output = item.recent ? item.capped : omittedOutput;
+        item.message.content[item.partIndex] = { ...item.part, output };
+        retainedToolChars += item.recent ? item.cappedSize : omittedSize;
+        if (serialized(item.part.output) !== serialized(output))
+            compactedResults += 1;
+    }
+    for (let index = prepared.length - keepRecent - 1; index >= 0; index -= 1) {
+        const item = prepared[index];
+        const delta = item.cappedSize - omittedSize;
+        if (delta <= 0 || retainedToolChars + delta > maximum)
+            continue;
+        item.message.content[item.partIndex] = { ...item.part, output: item.capped };
+        retainedToolChars += delta;
+        if (serialized(item.part.output) !== serialized(omittedOutput))
+            compactedResults -= 1;
+        if (serialized(item.part.output) !== serialized(item.capped))
+            compactedResults += 1;
+    }
+    return { messages, originalToolChars, retainedToolChars, compactedResults };
+}

package/dist/workspace-map.js

@@ -232,5 +232,9 @@ export async function rememberProjectFact(cwd, input, cacheDir) {
 }
 export function needsWorkspaceOrientation(message) {
     const user = message.split("[User message]").pop() ?? message;
-    return /项目|代码|仓库|实现|架构|功能|修复|编译|测试|模块|继续|挖.*因子|\b(?:repo|project|code|implement|architecture|feature|fix|build|test|module|continue)\b/i.test(user);
+    if (/(?:不涉及|无关|不要读取).{0,12}(?:当前)?(?:工作目录|项目|代码|仓库)/.test(user))
+        return false;
+    if (/^\s*(?:你好|谢谢|收到|好的|ok|hello|hi)[。！!,.，\s]*$/i.test(user))
+        return false;
+    return /项目|代码|仓库|实现|架构|功能|修复|编译|测试|模块|继续|现状|当前|范式|因子|策略|实验|消融|回测|指标|数据|模型|进度|提交|推送|挖.*因子|\b(?:repo|project|code|implement|architecture|feature|fix|build|test|module|continue|status|strategy|model|experiment|metric|data)\b/i.test(user);
 }

package/docs/workspace-understanding.md

@@ -33,3 +33,9 @@ DeepCCC CLI、Web 与 ChatCCC 内置 CCC 共用这些能力。无需配置向量
 ## 测试边界
 
 自动化测试覆盖依赖目录显式访问、搜索失败/无命中/截断、单文件输出解析、地图更新、证据失效、预算与取消，以及导航不会在历史中累积。这些是工具和上下文护栏，不是所有模型都能正确理解项目的保证；未对某个在线模型宣称准确率提升。
+
+## 长会话状态与轮内预算
+
+压缩器每次重写完整摘要，使用固定章节区分当前事实、仍待处理、已取代历史、项目事实、证据/推断/局限和重要操作。最近原始消息、明确纠正及当前磁盘事实优先；旧摘要中的助手评价不是事实或用户指令。旧格式摘要仍可读取，但在模型输入中会明确标记为历史材料，避免把已完成或回退的路线恢复成当前建议。
+
+同一轮 Agent 可能连续执行多个工具，AI SDK 会把先前结果重复发送到后续模型步骤。DeepCCC 在每一步前对这些结果执行结构保持的预算控制：每项最多约 24,000 字符，总量约 96,000 字符，最近 4 项优先。较早结果必要时替换为可识别的省略标记，assistant tool-call 与对应 `role: tool` 结果仍成对保留。该处理只影响本轮后续模型请求；用户界面事件、最终持久化记录和受独立上限保护的 raw stream log 不被这一步改写。需要细节时 Agent 应重新执行更聚焦的读取或搜索。

package/package.json

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