deepccc 0.2.7 → 0.2.9

package/README.md

@@ -155,7 +155,7 @@ deepccc
 
 Web UI 支持新建、恢复、重命名和删除多会话，多个会话可以同时运行，即使它们指向同一个工作目录。每个会话可独立选择 model、subModel 和 effort，并持续复用 CLI 已保存的历史。注意：当前版本不自动创建 Git worktree；同目录的多个运行中 Agent 直接修改同一组文件，页面会提示覆盖与冲突风险。
 
-模型文本、reasoning 心跳和工具事件通过 SSE 实时更新。每次工具调用与对应结果合并成一张卡片，折叠态显示 emoji、工具名、状态和关键参数；展开后调用参数默认保留前 8/后 4 行，工具结果保留前 12/后 6 行，省略内容可继续展开。工具卡及省略行的展开状态保存在当前浏览器标签页的 `sessionStorage`，持续生成、切换会话和刷新页面均不会自动收起。消息正文支持标题、表格、列表、引用、链接和代码块等常用 Markdown。
+模型文本、reasoning 心跳和工具事件通过 SSE 实时更新。每轮消息按真实发生顺序持久化和回放，因此刷新后仍会保持“阶段说明 → 工具调用 → 后续结论”的交错时间线；旧版会话没有顺序数据时，会兼容显示为“工具调用 → 最终回答”。每次工具调用与对应结果合并成一张卡片，折叠态显示 emoji、工具名、状态和关键参数；展开后调用参数默认保留前 8/后 4 行，工具结果保留前 12/后 6 行，省略内容可继续展开。工具卡及省略行的展开状态保存在当前浏览器标签页的 `sessionStorage`，持续生成、切换会话和刷新页面均不会自动收起。消息正文支持标题、表格、列表、引用、链接和代码块等常用 Markdown。
 
 图片始终按本地附件处理，不转换为 Provider 原生多模态消息。Web 支持文件选择、剪贴板粘贴和拖拽，每条消息最多 10 张 PNG/JPEG/WebP、单张最大 20 MB；附件复制到 `~/.deepccc/attachments/<session-id>/`，Agent 收到本地绝对路径后使用可用工具自行处理。Agent 可调用 `present_file` 把当前工作目录或会话附件目录中的图片直接展示在会话中；删除会话时对应附件一并清理。
 
@@ -180,8 +180,9 @@ Provider 发送 `max_tokens`，使用模型服务端默认值。可通过 `DEEPC
 或命令行 `--max-output-tokens` 覆盖；只接受正整数。该限制会同时覆盖模型思考内容、
 工具参数和最终回答，设置过小可能导致工具调用或长回复被截断。
 
-`contextWindow` 是模型上下文窗口（token），默认 `1048576`（1M，DeepSeek V4 Pro/Flash
-原生规格）；上下文压缩阈值自动 = `contextWindow × 0.8`（超出即把较早消息压缩为摘要）。
+`contextWindow` 是模型上下文窗口（token），默认 `1048576`（1M，DeepSeek V4 Pro/Flash
+原生规格）；常规上下文压缩阈值自动 = `contextWindow × 0.8`。工具输入与结果另有独立预算：
+默认取 `min(64000, 常规压缩阈值 × 25%)`，超过后会提前压缩，避免长会话积累大量低信号工具输出。
 可通过 `DEEPCCC_CONTEXT_WINDOW` 环境变量覆盖。⚠️ 超过模型/服务端实际上限时请求会被
 API 拒绝（context length exceeded），实际窗口以模型与所用服务端为准（如 litellm 的
 `max_input_tokens`）。
@@ -324,7 +325,7 @@ deepccc-cli --dangerously-bypass-permissions
 
 交互模式下，每轮回复渲染为固定"过程区块"：状态行（压缩上下文中/生成回复中/完成/已停止/异常结束）+ 折叠工具行 + 原地更新正文，不滚屏刷 JSON。活动状态有心跳点号动画；完成/停止/异常后区块定型留在屏幕上。
 
-持久化上下文达到 token 阈值时，deepccc 会先按 token 预算保留最近消息，再压缩较早内容；超长历史消息、工具记录和压缩输入会被限长，避免单次摘要请求反复吞入巨量文本。一次压缩最多等待 5 分钟，超时或摘要失败会给出明确错误，不会自动重放用户请求。
+持久化上下文达到常规 token 阈值或独立工具预算时，deepccc 会先按预算保留最近消息，再压缩较早内容；工具历史使用标准结构化 tool-call/tool-result 消息重放，不会把内部 `[工具记录]` 文本重复送回模型。若模型仍输出伪工具记录，系统会丢弃并重试一次；重复失败时安全终止，避免把未执行命令当成真实结果。超长历史消息、工具记录和压缩输入会被限长，一次压缩最多等待 5 分钟。
 
 如果终端渲染出现异常，可以强制回退为纯文本流式输出：
 

package/dist/context.d.ts

@@ -1,7 +1,8 @@
+import type { ModelMessage } from "ai";
 export type BuiltinContextRole = "user" | "assistant";
 /**
- * 结构化工具调用存档（与 content 里的 [Tool transcript] 文本互为冗余视图）：
- * content 文本保持不变供模型消费；toolCalls 数组提供可检索、可回放的结构化数据。
+ * 结构化工具调用存档。content 只保存面向用户的回答正文；工具输入与结果
+ * 独立保存，供模型按标准 tool-call/tool-result 消息重放以及 UI 检索、回放。
  */
 export interface BuiltinContextToolCall {
     /** Provider tool-call id，用于 Web 在流式运行与持久化消息之间保持同一张工具卡状态。 */
@@ -13,11 +14,28 @@ export interface BuiltinContextToolCall {
     output?: string;
     is_error?: boolean;
 }
+export type BuiltinContextTimelineEntry = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input?: string;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    name?: string;
+    output?: string;
+    is_error?: boolean;
+};
 export interface BuiltinContextMessage {
     role: BuiltinContextRole;
     content: string;
     /** 可选结构化工具调用记录（assistant 消息专用） */
     toolCalls?: BuiltinContextToolCall[];
+    /** 文本与工具事件的真实发生顺序，同时用于 UI 与模型的结构化历史重放。 */
+    timeline?: BuiltinContextTimelineEntry[];
 }
 export interface BuiltinContextState {
     version: 1;
@@ -54,6 +72,8 @@ export interface BuiltinContextOptions {
     contextWindow?: number;
     /** 直接指定压缩阈值（token），优先于 contextWindow 的 80% 派生。 */
     compactAtTokens?: number;
+    /** Independent budget for retained structured tool inputs/results. */
+    maxToolContextTokens?: number;
     keepRecentMessages?: number;
 }
 export declare const DEFAULT_BUILTIN_CONTEXT_DIR: string;
@@ -64,6 +84,7 @@ export declare const COMPACTION_THRESHOLD_RATIO = 0.8;
 /** 默认压缩阈值 = 1M × 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 normalizeBuiltinSessionId(value: string): string;
 export declare function defaultBuiltinSessionId(cwd?: string): string;
 export declare function newBuiltinSessionId(now?: Date, suffix?: string): string;
@@ -71,25 +92,23 @@ export declare function getBuiltinContextSession(sessionId: string, contextDir?:
 export declare function readBuiltinContextState(sessionId: string, contextDir?: string): BuiltinContextState | null;
 export declare function listBuiltinContextSessions(contextDir?: string): BuiltinContextSessionInfo[];
 export declare function latestBuiltinSessionForCwd(cwd: string, contextDir?: string): BuiltinContextSessionInfo | null;
-/**
- * 估算上下文的 token 数（用于决定何时压缩）。
- * 按字符类型加权，比旧版 chars/3 更接近真实：CJK 字符 ≈ 1 token/字，
- * 其他字符 ≈ 3.5 chars/token。避免中文长上下文被严重低估导致压缩过晚。
- */
+export declare function estimateBuiltinToolContextTokens(messages: readonly BuiltinContextMessage[]): number;
 export declare function estimateBuiltinContextTokens(summary: string, messages: readonly BuiltinContextMessage[]): number;
 export declare function serializeMessagesForSummary(messages: readonly BuiltinContextMessage[]): string;
 export declare const DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS = 32000;
 export declare const DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24000;
 /**
- * 构造持久化的 assistant 消息：content 保持既有"正文 + [Tool transcript]"文本格式
- * （模型上下文行为不变），同时附加结构化 toolCalls 存档（供 session-search 等检索）。
+ * 构造持久化 assistant 消息。content 仅保存回答正文，工具事件保存在
+ * toolCalls/timeline，避免内部 transcript 语法回流并诱导模型伪造工具执行。
  */
 export declare function buildPersistedAssistantMessage(params: {
     fullText: string;
-    /** [Tool transcript] 的文本行（按原始流顺序，含 tool_call / tool_result / tool_error） */
+    /** @deprecated 兼容旧调用方；工具记录只从 toolCalls/timeline 持久化。 */
     transcriptLines: readonly string[];
     /** 结构化工具调用（按调用顺序）；有则写入消息的 toolCalls 字段 */
     toolCalls?: readonly BuiltinContextToolCall[];
+    /** 文本和工具事件的有序时间线；不参与模型输入。 */
+    timeline?: readonly BuiltinContextTimelineEntry[];
     maxAssistantChars?: number;
     maxTranscriptChars?: number;
 }): BuiltinContextMessage;
@@ -99,6 +118,7 @@ export declare class BuiltinContextManager {
     readonly contextDir: string;
     readonly sessionId: string;
     readonly compactAtTokens: number;
+    readonly maxToolContextTokens: number;
     readonly keepRecentMessages: number;
     private readonly cwd?;
     private state;
@@ -109,7 +129,7 @@ export declare class BuiltinContextManager {
     get contextFilePath(): string;
     appendMessage(message: BuiltinContextMessage): void;
     setSummary(summary: string): void;
-    buildModelMessages(): BuiltinContextMessage[];
+    buildModelMessages(): ModelMessage[];
     planCompaction(): BuiltinCompactionPlan | null;
     applyCompaction(summary: string, plan: BuiltinCompactionPlan): void;
     reset(): void;

package/dist/context.js

@@ -2,7 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { hasMalformedToolProtocolText } from "./tool-protocol.js";
+import { hasImitatedToolTranscriptText, hasMalformedToolProtocolText, } from "./tool-protocol.js";
 export const DEFAULT_BUILTIN_CONTEXT_DIR = join(homedir(), ".deepccc", "sessions");
 /** 默认模型上下文窗口：1M（DeepSeek V4 Pro/Flash 原生规格）。 */
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 1_048_576;
@@ -15,6 +15,11 @@ const RECENT_CONTEXT_BUDGET_RATIO = 0.6;
 const MAX_COMPACTION_SUMMARY_CHARS = 8_000;
 const MAX_COMPACTION_MESSAGE_CHARS = 24_000;
 const MAX_COMPACTION_SOURCE_CHARS = 64_000;
+export const DEFAULT_MAX_TOOL_CONTEXT_TOKENS = 64_000;
+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 = "[上一轮响应因工具协议异常已隔离，不能视为已执行；请根据后续用户消息继续。]";
 export function normalizeBuiltinSessionId(value) {
     return value.replace(/[^a-zA-Z0-9_.-]+/g, "_").replace(/^_+|_+$/g, "") || "default";
 }
@@ -49,8 +54,42 @@ function normalizeMessage(value) {
     const toolCalls = normalizeToolCalls(raw.toolCalls);
     if (toolCalls.length > 0)
         message.toolCalls = toolCalls;
+    const timeline = normalizeTimeline(raw.timeline);
+    if (timeline.length > 0)
+        message.timeline = timeline;
     return message;
 }
+function normalizeTimeline(value) {
+    if (!Array.isArray(value))
+        return [];
+    const entries = [];
+    for (const item of value.slice(0, 1000)) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const raw = item;
+        if (raw.type === "text" && typeof raw.text === "string") {
+            entries.push({ type: "text", text: raw.text });
+        }
+        else if (raw.type === "tool_use" && typeof raw.id === "string" && typeof raw.name === "string") {
+            entries.push({
+                type: "tool_use",
+                id: raw.id,
+                name: raw.name,
+                ...(typeof raw.input === "string" ? { input: raw.input } : {}),
+            });
+        }
+        else if (raw.type === "tool_result" && typeof raw.tool_use_id === "string") {
+            entries.push({
+                type: "tool_result",
+                tool_use_id: raw.tool_use_id,
+                ...(typeof raw.name === "string" ? { name: raw.name } : {}),
+                ...(typeof raw.output === "string" ? { output: raw.output } : {}),
+                ...(typeof raw.is_error === "boolean" ? { is_error: raw.is_error } : {}),
+            });
+        }
+    }
+    return entries;
+}
 function normalizeToolCalls(value) {
     if (!Array.isArray(value))
         return [];
@@ -175,8 +214,11 @@ export function latestBuiltinSessionForCwd(cwd, contextDir = DEFAULT_BUILTIN_CON
  * 按字符类型加权，比旧版 chars/3 更接近真实：CJK 字符 ≈ 1 token/字，
  * 其他字符 ≈ 3.5 chars/token。避免中文长上下文被严重低估导致压缩过晚。
  */
-export function estimateBuiltinContextTokens(summary, messages) {
-    const text = summary + messages.reduce((sum, m) => sum + `${m.role}\n${m.content}\n`, "");
+function stripStoredToolTranscript(content) {
+    const markerIndex = content.indexOf(STORED_TOOL_TRANSCRIPT_MARKER);
+    return markerIndex >= 0 ? content.slice(0, markerIndex) : content;
+}
+function estimateTextTokens(text) {
     let cjk = 0;
     for (const ch of text) {
         if (/[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF\u3000-\u303F\uFF00-\uFFEF]/.test(ch))
@@ -185,6 +227,30 @@ export function estimateBuiltinContextTokens(summary, messages) {
     const other = text.length - cjk;
     return Math.ceil(cjk + other / 3.5);
 }
+export function estimateBuiltinToolContextTokens(messages) {
+    let text = "";
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        if (message.toolCalls?.length) {
+            for (const call of message.toolCalls) {
+                text += `${call.name}\n${call.input ?? ""}\n${call.output ?? ""}\n`;
+            }
+            continue;
+        }
+        for (const entry of message.timeline ?? []) {
+            if (entry.type === "tool_use")
+                text += `${entry.name}\n${entry.input ?? ""}\n`;
+            if (entry.type === "tool_result")
+                text += `${entry.name ?? ""}\n${entry.output ?? ""}\n`;
+        }
+    }
+    return estimateTextTokens(text);
+}
+export function estimateBuiltinContextTokens(summary, messages) {
+    const text = summary + messages.reduce((sum, message) => sum + `${message.role}\n${stripStoredToolTranscript(message.content)}\n`, "");
+    return estimateTextTokens(text) + estimateBuiltinToolContextTokens(messages);
+}
 export function serializeMessagesForSummary(messages) {
     return messages
         .map((message, index) => `### ${index + 1}. ${message.role}\n${message.content}`)
@@ -202,23 +268,196 @@ export const DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS = 32_000;
 export const DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS = 24_000;
 const ASSISTANT_TRUNCATED_MARKER = "...[助手回复已在上下文中截断]...";
 const TOOL_TRANSCRIPT_TRUNCATED_MARKER = "...[工具记录已截断]...";
+function truncateStructuredToolCalls(calls, maxChars) {
+    const payloads = calls.flatMap((call) => [call.input ?? "", call.output ?? ""]).filter(Boolean);
+    const total = payloads.reduce((sum, value) => sum + value.length, 0);
+    if (total <= maxChars)
+        return calls;
+    const sharedBudget = Math.max(0, maxChars - payloads.length);
+    const truncatePayload = (value) => {
+        if (value === undefined || value.length === 0)
+            return value;
+        const budget = 1 + Math.floor(sharedBudget * value.length / Math.max(1, total));
+        return truncateMiddle(value, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER);
+    };
+    return calls.map((call) => ({
+        ...call,
+        ...(call.input !== undefined ? { input: truncatePayload(call.input) } : {}),
+        ...(call.output !== undefined ? { output: truncatePayload(call.output) } : {}),
+    }));
+}
 /**
- * 构造持久化的 assistant 消息：content 保持既有"正文 + [Tool transcript]"文本格式
- * （模型上下文行为不变），同时附加结构化 toolCalls 存档（供 session-search 等检索）。
+ * 构造持久化 assistant 消息。content 仅保存回答正文，工具事件保存在
+ * toolCalls/timeline，避免内部 transcript 语法回流并诱导模型伪造工具执行。
  */
 export function buildPersistedAssistantMessage(params) {
     const maxAssistantChars = params.maxAssistantChars ?? DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS;
     const maxTranscriptChars = params.maxTranscriptChars ?? DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS;
     const persistedAssistantText = truncateMiddle(params.fullText, maxAssistantChars, ASSISTANT_TRUNCATED_MARKER);
-    const content = params.transcriptLines.length > 0
-        ? `${persistedAssistantText}\n\n[工具记录]\n${truncateMiddle(params.transcriptLines.join("\n"), maxTranscriptChars, TOOL_TRANSCRIPT_TRUNCATED_MARKER)}`
-        : persistedAssistantText;
-    const message = { role: "assistant", content };
-    const toolCalls = normalizeToolCalls(params.toolCalls);
+    const message = { role: "assistant", content: persistedAssistantText };
+    const toolCalls = truncateStructuredToolCalls(normalizeToolCalls(params.toolCalls), maxTranscriptChars);
     if (toolCalls.length > 0)
         message.toolCalls = toolCalls;
+    const timeline = truncatePersistedTimeline(normalizeTimeline(params.timeline));
+    if (timeline.length > 0)
+        message.timeline = timeline;
     return message;
 }
+function truncatePersistedTimeline(entries) {
+    const maxTextChars = DEFAULT_PERSISTED_ASSISTANT_TEXT_CHARS;
+    const maxToolChars = DEFAULT_PERSISTED_TOOL_TRANSCRIPT_CHARS;
+    const totalText = entries.reduce((sum, entry) => sum + (entry.type === "text" ? entry.text.length : 0), 0);
+    const textPayloads = entries.filter((entry) => entry.type === "text" && entry.text.length > 0).length;
+    const totalTool = entries.reduce((sum, entry) => {
+        if (entry.type === "tool_use")
+            return sum + (entry.input?.length ?? 0);
+        if (entry.type === "tool_result")
+            return sum + (entry.output?.length ?? 0);
+        return sum;
+    }, 0);
+    const toolPayloads = entries.filter((entry) => (entry.type === "tool_use" && (entry.input?.length ?? 0) > 0)
+        || (entry.type === "tool_result" && (entry.output?.length ?? 0) > 0)).length;
+    const payloadBudget = (length, total, count, maximum) => {
+        if (total <= maximum)
+            return length;
+        const sharedBudget = Math.max(0, maximum - count);
+        return length > 0 ? 1 + Math.floor(sharedBudget * length / Math.max(1, total)) : 0;
+    };
+    const truncatePayload = (value, budget, marker) => {
+        if (value.length <= budget)
+            return value;
+        if (budget <= marker.length + 2)
+            return value.slice(0, budget);
+        return truncateMiddle(value, budget, marker);
+    };
+    return entries.map((entry) => {
+        if (entry.type === "text") {
+            const budget = payloadBudget(entry.text.length, totalText, textPayloads, maxTextChars);
+            return { ...entry, text: truncatePayload(entry.text, budget, ASSISTANT_TRUNCATED_MARKER) };
+        }
+        if (entry.type === "tool_use" && entry.input !== undefined) {
+            const budget = payloadBudget(entry.input.length, totalTool, toolPayloads, maxToolChars);
+            return { ...entry, input: truncatePayload(entry.input, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER) };
+        }
+        if (entry.type === "tool_result" && entry.output !== undefined) {
+            const budget = payloadBudget(entry.output.length, totalTool, toolPayloads, maxToolChars);
+            return { ...entry, output: truncatePayload(entry.output, budget, TOOL_TRANSCRIPT_TRUNCATED_MARKER) };
+        }
+        return entry;
+    });
+}
+function parseToolInput(value) {
+    if (!value?.trim())
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { raw: value };
+    }
+}
+function parseToolOutput(value) {
+    if (!value?.trim())
+        return { type: "text", value: "" };
+    try {
+        return { type: "json", value: JSON.parse(value) };
+    }
+    catch {
+        return { type: "text", value };
+    }
+}
+function replayStructuredAssistantMessage(message, messageIndex) {
+    const plainText = stripStoredToolTranscript(message.content);
+    const hasStructuredTools = Boolean(message.toolCalls?.length
+        || message.timeline?.some((entry) => entry.type === "tool_use" || entry.type === "tool_result"));
+    if (!hasStructuredTools)
+        return [{ role: "assistant", content: plainText }];
+    const timeline = message.timeline?.length
+        ? message.timeline
+        : [
+            ...(message.toolCalls ?? []).map((call, callIndex) => ({
+                type: "tool_use",
+                id: call.id ?? `context-tool-${messageIndex}-${callIndex}`,
+                name: call.name,
+                ...(call.input !== undefined ? { input: call.input } : {}),
+            })),
+            ...(message.toolCalls ?? []).map((call, callIndex) => ({
+                type: "tool_result",
+                tool_use_id: call.id ?? `context-tool-${messageIndex}-${callIndex}`,
+                name: call.name,
+                ...(call.output !== undefined ? { output: call.output } : {}),
+                ...(call.is_error !== undefined ? { is_error: call.is_error } : {}),
+            })),
+            ...(plainText ? [{ type: "text", text: plainText }] : []),
+        ];
+    const messages = [];
+    let assistantParts = [];
+    let toolParts = [];
+    const pendingCalls = new Map();
+    const knownNames = new Map();
+    const emittedCallIds = new Set();
+    const flushAssistant = () => {
+        if (!assistantParts.length)
+            return;
+        messages.push({ role: "assistant", content: assistantParts });
+        assistantParts = [];
+    };
+    const flushTools = () => {
+        for (const [toolCallId, toolName] of pendingCalls) {
+            toolParts.push({
+                type: "tool-result",
+                toolCallId,
+                toolName,
+                output: { type: "text", value: "[tool execution interrupted; result unavailable]" },
+            });
+        }
+        pendingCalls.clear();
+        if (!toolParts.length)
+            return;
+        messages.push({ role: "tool", content: toolParts });
+        toolParts = [];
+    };
+    for (const entry of timeline) {
+        if (entry.type === "text") {
+            flushTools();
+            const previous = assistantParts[assistantParts.length - 1];
+            if (previous?.type === "text")
+                previous.text += entry.text;
+            else if (entry.text)
+                assistantParts.push({ type: "text", text: entry.text });
+        }
+        else if (entry.type === "tool_use") {
+            flushTools();
+            knownNames.set(entry.id, entry.name);
+            pendingCalls.set(entry.id, entry.name);
+            emittedCallIds.add(entry.id);
+            assistantParts.push({
+                type: "tool-call",
+                toolCallId: entry.id,
+                toolName: entry.name,
+                input: parseToolInput(entry.input),
+            });
+        }
+        else {
+            if (!emittedCallIds.has(entry.tool_use_id))
+                continue;
+            const toolName = entry.name ?? knownNames.get(entry.tool_use_id);
+            if (!toolName)
+                continue;
+            flushAssistant();
+            pendingCalls.delete(entry.tool_use_id);
+            toolParts.push({
+                type: "tool-result",
+                toolCallId: entry.tool_use_id,
+                toolName,
+                output: parseToolOutput(entry.output),
+            });
+        }
+    }
+    flushAssistant();
+    flushTools();
+    return messages;
+}
 function serializeMessagesForCompaction(messages) {
     const sections = [];
     let remaining = MAX_COMPACTION_SOURCE_CHARS;
@@ -259,6 +498,7 @@ export class BuiltinContextManager {
     contextDir;
     sessionId;
     compactAtTokens;
+    maxToolContextTokens;
     keepRecentMessages;
     cwd;
     state;
@@ -269,6 +509,8 @@ export class BuiltinContextManager {
         this.cwd = options.cwd;
         this.compactAtTokens = options.compactAtTokens
             ?? Math.floor((options.contextWindow ?? DEFAULT_CONTEXT_WINDOW_TOKENS) * COMPACTION_THRESHOLD_RATIO);
+        this.maxToolContextTokens = Math.max(1, options.maxToolContextTokens
+            ?? Math.min(DEFAULT_MAX_TOOL_CONTEXT_TOKENS, Math.floor(this.compactAtTokens * TOOL_CONTEXT_BUDGET_RATIO)));
         this.keepRecentMessages = Math.max(1, options.keepRecentMessages ?? DEFAULT_KEEP_RECENT_MESSAGES);
         this.state = this.load();
     }
@@ -308,7 +550,12 @@ export class BuiltinContextManager {
         // Keep malformed provider output on disk for diagnosis, but quarantine it
         // from future prompts so one protocol failure cannot teach the model to
         // repeat the same invalid tool syntax on every later turn.
-        messages.push(...this.modelSafeMessages());
+        for (const [index, message] of this.modelSafeMessages().entries()) {
+            if (message.role === "user")
+                messages.push({ role: "user", content: message.content });
+            else
+                messages.push(...replayStructuredAssistantMessage(message, index));
+        }
         return messages;
     }
     planCompaction() {
@@ -316,16 +563,19 @@ export class BuiltinContextManager {
         // leaks here too, otherwise a later summary could reintroduce the bad syntax.
         const messages = this.modelSafeMessages();
         const estimated = estimateBuiltinContextTokens(this.state.summary, messages);
-        if (estimated <= this.compactAtTokens)
+        const toolEstimated = estimateBuiltinToolContextTokens(messages);
+        if (estimated <= this.compactAtTokens && toolEstimated <= this.maxToolContextTokens)
             return null;
         if (messages.length <= 1)
             return null;
         const earliestAllowed = Math.max(0, messages.length - this.keepRecentMessages);
         const recentTokenBudget = Math.max(1, Math.floor(this.compactAtTokens * RECENT_CONTEXT_BUDGET_RATIO));
+        const recentToolBudget = Math.max(1, Math.floor(this.maxToolContextTokens * RECENT_TOOL_CONTEXT_BUDGET_RATIO));
         let splitAt = messages.length - 1;
         for (let index = messages.length - 2; index >= earliestAllowed; index -= 1) {
             const candidate = messages.slice(index);
-            if (estimateBuiltinContextTokens("", candidate) > recentTokenBudget)
+            if (estimateBuiltinContextTokens("", candidate) > recentTokenBudget
+                || estimateBuiltinToolContextTokens(candidate) > recentToolBudget)
                 break;
             splitAt = index;
         }
@@ -336,8 +586,8 @@ export class BuiltinContextManager {
             splitAt = 1;
         return {
             previousSummary: this.state.summary,
-            oldMessages: this.state.messages.slice(0, splitAt),
-            recentMessages: this.state.messages.slice(splitAt),
+            oldMessages: messages.slice(0, splitAt),
+            recentMessages: messages.slice(splitAt),
         };
     }
     applyCompaction(summary, plan) {
@@ -361,7 +611,17 @@ export class BuiltinContextManager {
         renameSync(tmp, this.contextFilePath);
     }
     modelSafeMessages() {
-        return this.state.messages.filter((message) => message.role !== "assistant" || !hasMalformedToolProtocolText(message.content));
+        return this.state.messages.map((message) => {
+            if (message.role !== "assistant")
+                return message;
+            const hasStructuredTools = Boolean(message.toolCalls?.length
+                || message.timeline?.some((entry) => entry.type === "tool_use" || entry.type === "tool_result"));
+            const copiedStoredTranscript = hasImitatedToolTranscriptText(message.content) && hasStructuredTools;
+            if (hasMalformedToolProtocolText(message.content) && !copiedStoredTranscript) {
+                return { role: "assistant", content: QUARANTINED_PROTOCOL_REPLY };
+            }
+            return { ...message, content: stripStoredToolTranscript(message.content) };
+        });
     }
     load() {
         if (!this.persist || !existsSync(this.contextFilePath))

package/dist/index.d.ts

@@ -55,6 +55,8 @@ export interface ChatSessionOptions {
     sessionId?: string;
     /** Compact older context when the rough token estimate exceeds this value. */
     compactAtTokens?: number;
+    /** Independent retained-tool budget; defaults to min(64K, compaction threshold x 25%). */
+    maxToolContextTokens?: number;
     /**
      * 模型上下文窗口（token），默认 1048576（1M）。压缩阈值自动 = contextWindow × 0.8；
      * 显式 compactAtTokens 优先于该派生值。

package/dist/index.js

@@ -5,7 +5,7 @@
  */
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { generateText, isLoopFinished, stepCountIs, streamText } from "ai";
+import { generateText, isLoopFinished, stepCountIs, streamText, } from "ai";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
@@ -144,7 +144,7 @@ function addAnthropicToolJsonCompatibilityNote(messages) {
     // 部分 Anthropic→OpenAI/Ark 转换器会用 response_format=json_object
     // 实现工具调用，却只在 messages 中校验 JSON 关键词、不读取顶层 system。
     // 这里仅声明工具参数的编码方式，并明确不要求普通最终回复输出 JSON。
-    return messages.map((message, index) => (index === lastUserIndex
+    return messages.map((message, index) => (index === lastUserIndex && message.role === "user" && typeof message.content === "string"
         ? {
             ...message,
             content: `${message.content}\n\n${ANTHROPIC_TOOL_JSON_COMPATIBILITY_NOTE}`,
@@ -161,11 +161,13 @@ function addAnthropicToolJsonCompatibilityNote(messages) {
 function maybeAppendCompactionRecoveryHint(messages, summary, rawLogsEnabled, sessionId) {
     if (!summary.trim())
         return messages;
-    const summaryIndex = messages.findIndex((message) => message.role === "user" && message.content.startsWith("以下是更早的对话摘要"));
+    const summaryIndex = messages.findIndex((message) => message.role === "user"
+        && typeof message.content === "string"
+        && message.content.startsWith("以下是更早的对话摘要"));
     if (summaryIndex < 0)
         return messages;
     const hint = rawLogsEnabled ? buildCompactionRecoveryHint(sessionId) : COMPACTION_RECOVERY_HINT_DISABLED;
-    return messages.map((message, index) => (index === summaryIndex
+    return messages.map((message, index) => (index === summaryIndex && message.role === "user" && typeof message.content === "string"
         ? { ...message, content: `${message.content}\n\n${hint}` }
         : message));
 }
@@ -353,6 +355,7 @@ export class ChatSession {
             cwd: this.cwd,
             contextWindow: options.contextWindow ?? appConfig.contextWindow,
             compactAtTokens: options.compactAtTokens,
+            maxToolContextTokens: options.maxToolContextTokens,
             keepRecentMessages: options.keepRecentMessages,
         });
         this.permissionGate = new PermissionGate(this.permissionMode, this.permissionResolver);
@@ -393,6 +396,8 @@ export class ChatSession {
         // assistant 消息 toolCalls 字段；[Tool transcript] 文本视图仍按原格式生成。
         const toolCallsById = new Map();
         const toolCallOrder = [];
+        const timeline = [];
+        let toolContext = [];
         try {
             if (this.context.planCompaction()) {
                 yield { type: "status", phase: "compacting" };
@@ -460,9 +465,10 @@ export class ChatSession {
             for (let attempt = 0; attempt < 2; attempt += 1) {
                 fullText = "";
                 safeAccumulated = "";
-                const toolContext = [];
+                toolContext = [];
                 toolCallsById.clear();
                 toolCallOrder.length = 0;
+                timeline.length = 0;
                 let lastReasoningProgressAt;
                 const attemptMessages = attempt === 0
                     ? modelMessages
@@ -493,6 +499,11 @@ export class ChatSession {
                     }
                     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);
@@ -500,9 +511,11 @@ export class ChatSession {
                         yield { type: "text", text: safeText, accumulated: safeAccumulated };
                     }
                     else if (part.type === "tool-call") {
-                        toolContext.push(`tool_call ${part.toolName}: ${safeJson(part.input)}`);
-                        toolCallsById.set(part.toolCallId, { id: part.toolCallId, name: part.toolName, input: safeJson(part.input) });
+                        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,
@@ -511,10 +524,12 @@ export class ChatSession {
                         };
                     }
                     else if (part.type === "tool-result") {
-                        toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                        const output = truncateToolContext(safeJson(part.output));
+                        toolContext.push(`tool_result ${part.toolName}: ${output}`);
                         const call = toolCallsById.get(part.toolCallId);
                         if (call)
-                            call.output = truncateToolContext(safeJson(part.output));
+                            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,
@@ -531,6 +546,7 @@ export class ChatSession {
                             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,
@@ -546,7 +562,7 @@ export class ChatSession {
                     }
                 }
                 if (hasMalformedToolProtocolText(fullText)) {
-                    console.warn(`[DeepCCC] malformed DSML tool output detected for ${this.context.sessionId} `
+                    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",
@@ -559,8 +575,8 @@ export class ChatSession {
                         continue;
                     }
                     throw new Error(toolCallOrder.length > 0
-                        ? "工具调用协议异常：检测到混合的结构化与 DSML 文本调用，为避免重复执行工具，本轮已安全终止"
-                        : "工具调用协议异常：模型重试后仍输出了无效的 DSML 工具调用");
+                        ? "工具调用协议异常：检测到混合的结构化调用与伪造工具文本，为避免重复执行工具，本轮已安全终止"
+                        : "工具调用协议异常：模型重试后仍输出了无效或伪造的工具调用文本");
                 }
                 completed = true;
                 const collectedToolCalls = toolCallOrder
@@ -570,6 +586,7 @@ export class ChatSession {
                     fullText,
                     transcriptLines: toolContext,
                     toolCalls: collectedToolCalls,
+                    timeline,
                 }));
                 yield { type: "done", text: safeAccumulated };
                 return;
@@ -581,9 +598,22 @@ export class ChatSession {
             if (malformedProtocolOutput)
                 yield { type: "text_reset" };
             if (err.name === "AbortError" || signal?.aborted) {
-                // 被中断时，不保存不完整的助手消息
-                if (fullText && !malformedProtocolOutput) {
-                    this.context.appendMessage({ role: "assistant", content: `${fullText}\n[interrupted]` });
+                if ((fullText || toolCallOrder.length > 0) && !malformedProtocolOutput) {
+                    const collectedToolCalls = toolCallOrder
+                        .map((id) => toolCallsById.get(id))
+                        .filter((call) => call !== undefined);
+                    const interruptedTimeline = timeline.map((entry) => ({ ...entry }));
+                    const previous = interruptedTimeline[interruptedTimeline.length - 1];
+                    if (previous?.type === "text")
+                        previous.text += "\n[interrupted]";
+                    else
+                        interruptedTimeline.push({ type: "text", text: "[interrupted]" });
+                    this.context.appendMessage(buildPersistedAssistantMessage({
+                        fullText: `${fullText}\n[interrupted]`,
+                        transcriptLines: toolContext,
+                        toolCalls: collectedToolCalls,
+                        timeline: interruptedTimeline,
+                    }));
                 }
                 yield { type: "done", text: safeAccumulated };
                 return;

package/dist/tool-protocol.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Detects a model copying DeepCCC's persisted/debug transcript syntax into
+ * normal assistant text. Both the dedicated header and an event line are
+ * required so documentation and ordinary discussion remain valid.
+ */
+export declare function hasImitatedToolTranscriptText(text: string): boolean;
 export declare function hasMalformedToolProtocolText(text: string): boolean;
 export declare const TOOL_PROTOCOL_RECOVERY_PROMPT: string;

package/dist/tool-protocol.js

@@ -6,12 +6,23 @@
 const MALFORMED_DSML_TRAILER = /<\/[|｜]{2}DSML[|｜]{2}(?:parameter|invoke)>\s*$/iu;
 const RENDERED_TOOL_CALL = /\[调用\s+[A-Za-z_][\w.-]*\]/u;
 const DSML_INVOKE_TAG = /<[|｜]{2}DSML[|｜]{2}invoke\b/iu;
+const TOOL_TRANSCRIPT_HEADER = /(?:^|\n)\s*\[工具记录\]\s*(?:\n|$)/u;
+const TOOL_TRANSCRIPT_EVENT = /(?:^|\n)\s*tool_(?:call|result|error)\s+[A-Za-z_][\w.-]*\s*:/u;
+/**
+ * Detects a model copying DeepCCC's persisted/debug transcript syntax into
+ * normal assistant text. Both the dedicated header and an event line are
+ * required so documentation and ordinary discussion remain valid.
+ */
+export function hasImitatedToolTranscriptText(text) {
+    return TOOL_TRANSCRIPT_HEADER.test(text) && TOOL_TRANSCRIPT_EVENT.test(text);
+}
 export function hasMalformedToolProtocolText(text) {
-    return MALFORMED_DSML_TRAILER.test(text)
+    const malformedDsml = MALFORMED_DSML_TRAILER.test(text)
         && (RENDERED_TOOL_CALL.test(text) || DSML_INVOKE_TAG.test(text));
+    return malformedDsml || hasImitatedToolTranscriptText(text);
 }
 export const TOOL_PROTOCOL_RECOVERY_PROMPT = [
     "[系统恢复提示] 上一次响应泄漏了内部工具调用协议，因此已被丢弃。",
-    "请重新完成当前用户请求。需要调用工具时，只能使用 API 提供的结构化工具调用；不要把 DSML 或工具参数作为普通文本输出。",
-    "不要提及本恢复提示，也不要假装工具已经执行。",
+    "请重新完成当前用户请求。需要调用工具时，只能使用 API 提供的结构化工具调用；不要把 DSML、[工具调用]、[工具记录] 或工具参数作为普通文本输出。",
+    "不要提及本恢复提示，不要伪造工具已执行，也不要根据未执行的命令声称得到了结果。",
 ].join("\n");

package/dist/web-page.js

@@ -325,7 +325,10 @@ export const DEEPCCC_WEB_PAGE = `<!DOCTYPE html>
   function setToolState(key,value){try{sessionStorage.setItem(toolStorageKey(key),value?'1':'0');}catch(error){}}
   function clearToolSessionState(sessionId){try{var prefix='deepccc:tool-ui:v1:'+sessionId+':';for(var index=sessionStorage.length-1;index>=0;index--){var key=sessionStorage.key(index);if(key&&key.indexOf(prefix)===0)sessionStorage.removeItem(key);}}catch(error){}}
   function toolSectionHtml(call,kind,value,headLines,tailLines){if(value===undefined)return'';var result=truncateToolPayload(value,headLines,tailLines);var stateKey=call.uiKey+':'+kind+'-full';var expanded=toolState(stateKey);var text=expanded?result.full:result.preview;var label=kind==='input'?'调用参数':'工具结果';var button=result.truncated?'<button type="button" class="tool-overflow-toggle" data-tool-overflow="'+escapeHtml(stateKey)+'">'+escapeHtml(expanded?'收起省略内容':(result.omittedLines>0?'展开省略的 '+result.omittedLines+' 行':'展开完整内容'))+'</button>':'';return'<section class="tool-section"><div class="tool-section-title">'+label+'</div><pre>'+escapeHtml(text)+'</pre>'+button+'</section>';}
-  function messageHtml(role,content,toolCalls,messageIndex){var decoded=role==='user'?decodeAttachmentMessage(content):{text:withoutToolTranscript(content),attachments:[]};var tools='';(toolCalls||[]).forEach(function(call,index){tools+=toolCardHtml({uiKey:call.id?'tool:'+call.id:'message:'+messageIndex+':tool:'+index,name:call.name,input:call.input,output:call.output,isError:!!call.is_error,pending:false});});return '<article class="message '+role+'"><div class="avatar">'+(role==='user'?'你':'D')+'</div><div class="bubble"><div class="role">'+(role==='user'?'YOU':'DEEPCCC')+'</div><div class="markdown">'+markdown(decoded.text)+'</div>'+attachmentGallery(decoded.attachments,state.detail.sessionId)+tools+'</div></article>';}
+  function timelineHtml(timeline,messageIndex){var results={};(timeline||[]).forEach(function(item){if(item&&item.type==='tool_result'&&item.tool_use_id)results[item.tool_use_id]=item;});var renderedCalls={};var html='';(timeline||[]).forEach(function(item,index){if(!item)return;if(item.type==='text'){if(item.text)html+='<div class="markdown">'+markdown(item.text)+'</div>';return;}if(item.type==='tool_use'){var id=item.id||('timeline-'+messageIndex+'-'+index);var result=results[id];renderedCalls[id]=true;html+=toolCardHtml({uiKey:'tool:'+id,name:item.name||'tool',input:item.input,output:result?result.output:undefined,isError:!!(result&&result.is_error),pending:!result});return;}if(item.type==='tool_result'&&!renderedCalls[item.tool_use_id]){var fallbackId=item.tool_use_id||('result-'+messageIndex+'-'+index);renderedCalls[fallbackId]=true;html+=toolCardHtml({uiKey:'tool:'+fallbackId,name:item.name||'tool',output:item.output,isError:!!item.is_error,pending:false});}});return html;}
+  function liveTimeline(events){var timeline=[];(events||[]).forEach(function(event){if(event.type!=='agent'||!event.data)return;var item=event.data;if(item.type==='text_reset'){timeline.length=0;return;}if(item.type==='text'){var previous=timeline[timeline.length-1];if(previous&&previous.type==='text')previous.text+=(item.text||'');else timeline.push({type:'text',text:item.text||''});return;}if(item.type==='tool_use')timeline.push({type:'tool_use',id:item.id,name:item.name,input:item.input});else if(item.type==='tool_result')timeline.push({type:'tool_result',tool_use_id:item.tool_use_id,name:item.name,output:item.content,is_error:!!item.is_error});});return timeline;}
+  function legacyToolsHtml(toolCalls,messageIndex){var tools='';(toolCalls||[]).forEach(function(call,index){tools+=toolCardHtml({uiKey:call.id?'tool:'+call.id:'message:'+messageIndex+':tool:'+index,name:call.name,input:call.input,output:call.output,isError:!!call.is_error,pending:false});});return tools;}
+  function messageHtml(role,content,toolCalls,messageIndex,timeline){var decoded=role==='user'?decodeAttachmentMessage(content):{text:withoutToolTranscript(content),attachments:[]};var body;if(role==='user')body='<div class="markdown">'+markdown(decoded.text)+'</div>'+attachmentGallery(decoded.attachments,state.detail.sessionId);else if(timeline&&timeline.length)body=timelineHtml(timeline,messageIndex);else body=legacyToolsHtml(toolCalls,messageIndex)+'<div class="markdown">'+markdown(decoded.text)+'</div>';return '<article class="message '+role+'"><div class="avatar">'+(role==='user'?'你':'D')+'</div><div class="bubble"><div class="role">'+(role==='user'?'YOU':'DEEPCCC')+'</div>'+body+'</div></article>';}
   function buildToolGroups(events){var groups=[];var byId={};var order=[];(events||[]).forEach(function(event){if(event.type!=='agent'||!event.data)return;var item=event.data;if(item.type==='tool_use'){var id=item.id||('call-'+order.length);var group={id:id,uiKey:'tool:'+id,name:item.name||'tool',input:item.input,output:undefined,isError:false,pending:true};byId[id]=group;order.push(id);groups.push(group);}else if(item.type==='tool_result'){var key=item.tool_use_id;var target=key?byId[key]:null;if(target){target.output=item.content;target.isError=!!item.is_error;target.pending=false;}}});return groups;}
   function toolCardHtml(call){var open=toolState(call.uiKey+':card');var present=call.name==='present_file'&&!call.pending?artifactFromOutput(call.output):null;var inputHtml=toolSectionHtml(call,'input',call.input,8,4);var outputHtml=call.pending?'':(present?'<section class="tool-section"><div class="tool-section-title">工具结果</div>'+artifactGallery([{name:'present_file',output:call.output}],state.detail.sessionId)+'</section>':toolSectionHtml(call,'output',call.output==null?'(无输出)':call.output,12,6));return'<details class="tool-card" data-tool-state="'+escapeHtml(call.uiKey+':card')+'"'+(open?' open':'')+'><summary><span class="tool-summary-text">'+escapeHtml(toolSummary(call))+'</span></summary>'+inputHtml+outputHtml+'</details>';}
   function toolCardsHtml(calls){return (calls||[]).map(toolCardHtml).join('');}
@@ -356,11 +359,10 @@ export const DEEPCCC_WEB_PAGE = `<!DOCTYPE html>
     renderAttachmentDrafts();
     var html='<div class="thread">';
     if(!(detail.messages||[]).length&&detail.status!=='running')html+='<div class="empty-thread"><strong>准备开始这个会话</strong><span>在下方输入任务，可附加截图。DeepCCC 会读取当前项目指令、调用工具并持续保存上下文。</span></div>';
-    (detail.messages||[]).forEach(function(message,index){html+=messageHtml(message.role,message.content,message.toolCalls,index);});
+    (detail.messages||[]).forEach(function(message,index){html+=messageHtml(message.role,message.content,message.toolCalls,index,message.timeline);});
     if(detail.status==='running'){
-      var live=(detail.events||[]).slice().reverse().find(function(event){return event.type==='agent'&&event.data&&event.data.type==='text';});
-      if(live)html+=messageHtml('assistant',live.data.accumulated||live.data.text||'',[],'live');
-      html+=toolCardsHtml(buildToolGroups(detail.events));
+      var currentTimeline=liveTimeline(detail.events);
+      if(currentTimeline.length)html+=messageHtml('assistant','',[],'live',currentTimeline);
     }
     var approvals=(detail.approvals||[]).slice();
     if(detail.pendingApproval&&!approvals.some(function(item){return item.approvalId===detail.pendingApproval.approvalId;}))approvals.push(Object.assign({status:'pending'},detail.pendingApproval));

package/package.json

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