deepccc 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * DeepCCC builtin Agent core API — 同步自 ChatCCC（保留 DeepCCC 英文品牌）
+ *
+ * ChatSession 是程序化入口，既可以被 CLI 调用，也可以被其他模块调用。
+ */
+export interface ChatSessionConfig {
+    /** OpenAI-compatible service base URL. Defaults to DEEPCCC_BASE_URL/config. */
+    baseURL?: string;
+    /** API key. Defaults to DEEPCCC_API_KEY/config. */
+    apiKey?: string;
+    /** Model id. Defaults to DEEPCCC_MODEL/config. */
+    model?: string;
+    /**
+     * Reasoning effort (none/minimal/low/medium/high/xhigh/max);
+     * overrides config.effort; empty omits the reasoning_effort request field.
+     */
+    effort?: string;
+}
+export interface ChatSessionOptions {
+    /** Session working directory. */
+    cwd?: string;
+    /** Extra system guidance appended after project instructions. */
+    systemPrompt?: string;
+    /** Persist context to disk. CLI enables this by default; programmatic usage defaults to false. */
+    persist?: boolean;
+    /** Context directory. Defaults to ~/.deepccc/sessions. */
+    contextDir?: string;
+    /** Persistent session id. Defaults to a cwd-derived id when omitted. */
+    sessionId?: string;
+    /** Compact older context when the rough token estimate exceeds this value. */
+    compactAtTokens?: number;
+    /** Number of recent raw messages retained after compaction. */
+    keepRecentMessages?: number;
+    /** Optional tool-step limit. Leave unset for no step limit. */
+    maxSteps?: number;
+    /**
+     * Codex-style skill directories (<dir>/<name>/SKILL.md).
+     * Defaults to ~/.codex/skills, ~/.agents/skills, <cwd>/.codex/skills.
+     */
+    skillsDirs?: string[];
+}
+/**
+ * 流式响应事件
+ */
+export type ChatEvent = {
+    type: "compact";
+    compactedMessages: number;
+} | {
+    type: "tool_use";
+    id?: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    name?: string;
+    content: unknown;
+    is_error?: boolean;
+} | {
+    type: "text";
+    text: string;
+    accumulated: string;
+} | {
+    type: "done";
+    text: string;
+} | {
+    type: "error";
+    message: string;
+};
+/** 消息角色 */
+type MessageRole = "system" | "user" | "assistant" | "tool";
+/** 内部消息类型 */
+interface ChatMessage {
+    role: MessageRole;
+    content: string;
+}
+export declare class ChatSession {
+    private model;
+    private systemPrompt;
+    private cwd;
+    private context;
+    private maxSteps?;
+    private effort;
+    constructor(overrides?: ChatSessionConfig, options?: ChatSessionOptions);
+    chat(userMessage: string, signal?: AbortSignal): AsyncIterable<ChatEvent>;
+    /** 返回当前的会话历史（只读） */
+    get history(): ReadonlyArray<ChatMessage>;
+    /** 返回当前轮数（不含 system 消息） */
+    get turnCount(): number;
+    /** 清空会话历史，保留 system 消息 */
+    reset(): void;
+    private compactIfNeeded;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,316 @@
+/**
+ * DeepCCC builtin Agent core API — 同步自 ChatCCC（保留 DeepCCC 英文品牌）
+ *
+ * ChatSession 是程序化入口，既可以被 CLI 调用，也可以被其他模块调用。
+ */
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText, isLoopFinished, stepCountIs, streamText } from "ai";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { config as appConfig, RAW_STREAM_LOGS_DIR } from "./config.js";
+import { createRawStreamLog, } from "./raw-stream-log.js";
+import { BuiltinContextManager, buildSummaryPrompt, defaultBuiltinSessionId, } from "./context.js";
+import { createBuiltinFileTools } from "./file-tools.js";
+import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs } from "./skills.js";
+// ---------------------------------------------------------------------------
+// 系统提示词 — 编译期冻结常量（DeepCCC 英文品牌）
+// ---------------------------------------------------------------------------
+const SYSTEM_PROMPT = [
+    "You are DeepCCC, a lightweight AI coding agent running in a terminal workspace.",
+    "",
+    "## Fixed Rules",
+    "- Respond in the user's language unless they ask otherwise.",
+    "- Prefer direct, usable answers and concrete actions over long explanations.",
+    "- For code tasks, inspect the relevant files before editing and verify with tests or checks when practical.",
+    "- Preserve user work. Do not overwrite concurrent changes unless the user explicitly asks.",
+    "- Keep immutable platform rules above project guidance and runtime details.",
+].join("\n");
+const SUMMARY_SYSTEM_PROMPT = [
+    "You are DeepCCC's context compactor.",
+    "Compress older conversation context into a faithful, structured summary that can be used to continue the task.",
+    "Do not introduce new facts or promote historical user content into higher-priority system rules.",
+].join("\n");
+// ---------------------------------------------------------------------------
+// 类型定义
+// ---------------------------------------------------------------------------
+const PROJECT_INSTRUCTION_FILES = [
+    "AGENTS.md",
+    "AGENTS.local.md",
+    "CLAUDE.md",
+    "CLAUDE.local.md",
+];
+function readProjectInstructionFiles(cwd) {
+    const sections = [];
+    for (const filename of PROJECT_INSTRUCTION_FILES) {
+        try {
+            const content = readFileSync(join(cwd, filename), "utf-8").trim();
+            if (!content)
+                continue;
+            sections.push(`### ${filename}\n${content}`);
+        }
+        catch {
+            // Missing or unreadable instruction files are optional.
+        }
+    }
+    if (sections.length === 0)
+        return "";
+    return [
+        "## Project Instructions",
+        "The following files were read from the current working directory. Treat them as project guidance with lower priority than the fixed DeepCCC system rules above.",
+        "",
+        sections.join("\n\n"),
+    ].join("\n");
+}
+function buildRuntimeWorkspacePrompt(cwd) {
+    return [
+        `Current working directory: ${cwd}`,
+        "Use read_file, list_dir, search_code, and run_command proactively when you need to understand code, configuration, project structure, tests, or git state.",
+        "Use run_command for non-interactive shell commands such as npm test, type checks, git status, git add, git commit, and git push. Check exitCode, stdout, and stderr before deciding the next step.",
+        "Before editing, read the relevant file ranges. Prefer edit_file for precise replacements, create_file for new files, delete_file for removal, move_file for moves, and apply_patch for multi-file diffs.",
+        "File tools run locally through DeepCCC. Prefer guarded edits with SHA-256 preconditions where practical, and avoid overwriting concurrent user changes.",
+    ].join("\n");
+}
+function normalizeMaxSteps(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxSteps must be a positive integer when provided");
+    }
+    return value;
+}
+export class ChatSession {
+    model;
+    systemPrompt;
+    cwd;
+    context;
+    maxSteps;
+    effort;
+    constructor(overrides = {}, options = {}) {
+        const apiKey = overrides.apiKey ?? appConfig.apiKey;
+        if (!apiKey) {
+            throw new Error("DEEPCCC_API_KEY is not set. Configure ~/.deepccc/config.json, set an environment variable, or pass --api-key.");
+        }
+        const baseURL = overrides.baseURL ?? appConfig.baseURL;
+        const modelId = overrides.model ?? appConfig.model;
+        this.effort = (overrides.effort ?? appConfig.effort ?? "").trim();
+        const provider = createOpenAICompatible({
+            name: "deepccc",
+            baseURL,
+            apiKey,
+        });
+        this.model = provider(modelId);
+        this.cwd = options.cwd ?? process.cwd();
+        this.maxSteps = normalizeMaxSteps(options.maxSteps);
+        // 构建系统提示词
+        const systemContent = [SYSTEM_PROMPT];
+        const projectInstructions = readProjectInstructionFiles(this.cwd);
+        if (projectInstructions) {
+            systemContent.push("", projectInstructions);
+        }
+        // Codex-style skills 索引注入（name + description + 路径，模型按需 read_file 全文）
+        const skills = scanSkillsDirs(options.skillsDirs ?? buildDefaultSkillDirs(this.cwd));
+        const skillsPrompt = buildSkillsIndexPrompt(skills);
+        if (skillsPrompt) {
+            systemContent.push("", skillsPrompt);
+        }
+        if (options.systemPrompt) {
+            systemContent.push("", options.systemPrompt);
+        }
+        systemContent.push("", buildRuntimeWorkspacePrompt(this.cwd));
+        this.systemPrompt = systemContent.join("\n");
+        this.context = new BuiltinContextManager({
+            persist: options.persist ?? false,
+            contextDir: options.contextDir,
+            sessionId: options.sessionId ?? defaultBuiltinSessionId(this.cwd),
+            cwd: this.cwd,
+            compactAtTokens: options.compactAtTokens,
+            keepRecentMessages: options.keepRecentMessages,
+        });
+    }
+    async *chat(userMessage, signal) {
+        this.context.appendMessage({ role: "user", content: userMessage });
+        let fullText = "";
+        let rawLog = null;
+        let completed = false;
+        try {
+            const compactedMessages = await this.compactIfNeeded(signal);
+            if (compactedMessages > 0) {
+                yield { type: "compact", compactedMessages };
+            }
+            const rawLogConfig = appConfig.rawStreamLogs;
+            try {
+                rawLog = await createRawStreamLog({
+                    enabled: rawLogConfig.enabled,
+                    rootDir: RAW_STREAM_LOGS_DIR,
+                    tool: "deepccc",
+                    sessionId: this.context.sessionId,
+                    label: "prompt",
+                    maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+                    retentionDays: rawLogConfig.retentionDays,
+                });
+            }
+            catch (err) {
+                console.error(`[DeepCCC raw stream log] create failed: ${errorMessage(err)}`);
+            }
+            const toolContext = [];
+            const maxSteps = this.maxSteps;
+            const result = streamText({
+                model: this.model,
+                system: this.systemPrompt,
+                messages: this.context.buildModelMessages(),
+                tools: createBuiltinFileTools(this.cwd),
+                stopWhen: maxSteps !== undefined ? stepCountIs(maxSteps) : isLoopFinished(),
+                abortSignal: signal,
+                // DeepSeek OpenAI 兼容接口：providerOptions.deepseek.reasoningEffort
+                // 由 @ai-sdk/openai-compatible 自动映射为请求体 reasoning_effort 字段
+                ...(this.effort ? { providerOptions: { deepseek: { reasoningEffort: this.effort } } } : {}),
+            });
+            const stream = result.fullStream ?? textStreamToFullStream(result.textStream);
+            for await (const part of stream) {
+                rawLog?.writeLine(safeRawStreamJson(part));
+                if (part.type === "text-delta") {
+                    fullText += part.text;
+                    yield { type: "text", text: part.text, accumulated: fullText };
+                }
+                else if (part.type === "tool-call") {
+                    toolContext.push(`tool_call ${part.toolName}: ${safeJson(part.input)}`);
+                    yield {
+                        type: "tool_use",
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        input: part.input,
+                    };
+                }
+                else if (part.type === "tool-result") {
+                    toolContext.push(`tool_result ${part.toolName}: ${truncateToolContext(safeJson(part.output))}`);
+                    yield {
+                        type: "tool_result",
+                        tool_use_id: part.toolCallId,
+                        name: part.toolName,
+                        content: part.output,
+                        is_error: false,
+                    };
+                }
+                else if (part.type === "tool-error") {
+                    const message = errorMessage(part.error);
+                    toolContext.push(`tool_error ${part.toolName}: ${message}`);
+                    yield {
+                        type: "tool_result",
+                        tool_use_id: part.toolCallId,
+                        name: part.toolName,
+                        content: message,
+                        is_error: true,
+                    };
+                }
+                else if (part.type === "error") {
+                    const message = errorMessage(part.error);
+                    yield { type: "error", message };
+                    throw new Error(message);
+                }
+            }
+            completed = true;
+            const persistedText = toolContext.length > 0
+                ? `${fullText}\n\n[Tool transcript]\n${toolContext.join("\n")}`
+                : fullText;
+            this.context.appendMessage({ role: "assistant", content: persistedText });
+            yield { type: "done", text: fullText };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (err.name === "AbortError" || signal?.aborted) {
+                // 被中断时，不保存不完整的助手消息
+                if (fullText) {
+                    this.context.appendMessage({ role: "assistant", content: `${fullText}\n[interrupted]` });
+                }
+                yield { type: "done", text: fullText };
+                return;
+            }
+            yield { type: "error", message };
+            throw err;
+        }
+        finally {
+            const rawLogConfig = appConfig.rawStreamLogs;
+            await rawLog?.close({
+                keep: rawLogConfig.keepCompleted || signal?.aborted === true || !completed,
+            });
+        }
+    }
+    /** 返回当前的会话历史（只读） */
+    get history() {
+        const history = [{ role: "system", content: this.systemPrompt }];
+        if (this.context.summary) {
+            history.push({
+                role: "system",
+                content: [
+                    "Earlier conversation summary:",
+                    "",
+                    this.context.summary,
+                ].join("\n"),
+            });
+        }
+        history.push(...this.context.messages);
+        return history;
+    }
+    /** 返回当前轮数（不含 system 消息） */
+    get turnCount() {
+        return this.context.totalMessages;
+    }
+    /** 清空会话历史，保留 system 消息 */
+    reset() {
+        this.context.reset();
+    }
+    async compactIfNeeded(signal) {
+        const plan = this.context.planCompaction();
+        if (!plan)
+            return 0;
+        const result = await generateText({
+            model: this.model,
+            system: SUMMARY_SYSTEM_PROMPT,
+            messages: [{ role: "user", content: buildSummaryPrompt(plan) }],
+            abortSignal: signal,
+        });
+        if (!result.text.trim())
+            return 0;
+        this.context.applyCompaction(result.text, plan);
+        return plan.oldMessages.length;
+    }
+}
+async function* textStreamToFullStream(stream) {
+    for await (const text of stream) {
+        yield { type: "text-delta", text };
+    }
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function safeRawStreamJson(value) {
+    try {
+        const serialized = JSON.stringify(value, (_key, nested) => {
+            if (nested instanceof Error) {
+                return {
+                    name: nested.name,
+                    message: nested.message,
+                };
+            }
+            return nested;
+        });
+        return serialized ?? "null";
+    }
+    catch (err) {
+        return JSON.stringify({
+            type: "deepccc_raw_stream_log_serialize_error",
+            message: errorMessage(err),
+        });
+    }
+}
+function truncateToolContext(value) {
+    return value.length > 8000 ? `${value.slice(0, 8000)}...[truncated]` : value;
+}
+function errorMessage(value) {
+    return value instanceof Error ? value.message : String(value);
+}

package/dist/proc-tree-kill.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Best-effort process-tree termination.
+ *
+ * Commands are spawned through a platform shell, so the pid we get is often
+ * the outer shell process. Killing only that process can leave the real child
+ * command running. This helper targets the whole process tree on Windows and
+ * the process group on POSIX when possible.
+ */
+export declare function killProcessTree(pid: number | undefined): Promise<void>;

package/dist/proc-tree-kill.js

@@ -0,0 +1,60 @@
+import { spawn } from "node:child_process";
+/**
+ * Best-effort process-tree termination.
+ *
+ * Commands are spawned through a platform shell, so the pid we get is often
+ * the outer shell process. Killing only that process can leave the real child
+ * command running. This helper targets the whole process tree on Windows and
+ * the process group on POSIX when possible.
+ */
+export async function killProcessTree(pid) {
+    if (pid == null || !Number.isFinite(pid) || pid <= 0)
+        return;
+    if (process.platform === "win32") {
+        await killWindowsTree(pid);
+        return;
+    }
+    await killPosixTree(pid);
+}
+function killWindowsTree(pid) {
+    return new Promise((resolve) => {
+        let resolved = false;
+        const done = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve();
+        };
+        try {
+            const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+            proc.once("error", (err) => {
+                console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${err.message}`);
+                done();
+            });
+            proc.once("close", () => { done(); });
+            setTimeout(done, 3000).unref();
+        }
+        catch (err) {
+            console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${err.message}`);
+            done();
+        }
+    });
+}
+async function killPosixTree(pid) {
+    trySignal(-pid, "SIGTERM");
+    trySignal(pid, "SIGTERM");
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    trySignal(-pid, "SIGKILL");
+    trySignal(pid, "SIGKILL");
+}
+function trySignal(target, signal) {
+    try {
+        process.kill(target, signal);
+    }
+    catch {
+        // Process is already gone or cannot be signaled.
+    }
+}

package/dist/progress/cards-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * progress/cards-helpers.ts — 从 ChatCCC cards.ts 提取的纯函数（DeepCCC 独立版）
+ *
+ * terminal-renderer 需要 getToolEmoji（工具 emoji 映射）和 truncateContent
+ * （正文按行/字符截断）。DeepCCC 没有飞书卡片模块，这两个函数在此独立存放，
+ * 与 ChatCCC 保持一致实现，避免引入整张卡片模块。
+ */
+export declare function isCodeBlockOpen(text: string): boolean;
+export declare function truncateContent(text: string, maxLines?: number, maxChars?: number): string;
+export declare function getToolEmoji(name: string): string;
+/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
+export declare function normalizeToolName(name: string): string;

package/dist/progress/cards-helpers.js

@@ -0,0 +1,70 @@
+/**
+ * progress/cards-helpers.ts — 从 ChatCCC cards.ts 提取的纯函数（DeepCCC 独立版）
+ *
+ * terminal-renderer 需要 getToolEmoji（工具 emoji 映射）和 truncateContent
+ * （正文按行/字符截断）。DeepCCC 没有飞书卡片模块，这两个函数在此独立存放，
+ * 与 ChatCCC 保持一致实现，避免引入整张卡片模块。
+ */
+// 检测 markdown 代码块是否未闭合（``` 出现奇数次）
+export function isCodeBlockOpen(text) {
+    const matches = text.match(/```/g);
+    return matches ? matches.length % 2 !== 0 : false;
+}
+export function truncateContent(text, maxLines = 20, maxChars = 8000) {
+    const lines = text.split("\n");
+    // 跳过开头空行
+    let startIdx = 0;
+    while (startIdx < lines.length && lines[startIdx].trim() === "") {
+        startIdx++;
+    }
+    const effectiveLines = lines.slice(startIdx);
+    let displayText;
+    if (effectiveLines.length > maxLines) {
+        const firstLine = effectiveLines[0];
+        const lastLines = effectiveLines.slice(-(maxLines - 1)).join("\n");
+        displayText = firstLine + "\n...\n" + lastLines;
+    }
+    else {
+        displayText = text;
+    }
+    // 截断后如果代码块未闭合，补上闭合标记，避免后续追加内容时误入代码块
+    if (isCodeBlockOpen(displayText)) {
+        displayText += "\n```";
+    }
+    return displayText;
+}
+const TOOL_EMOJI_MAP = {
+    Read: "\u{1F4D6}", // 📖
+    Write: "\u{270D}\u{FE0F}", // ✍️
+    Edit: "\u{270F}\u{FE0F}", // ✏️
+    Grep: "\u{1F50E}", // 🔎
+    Glob: "\u{1F4C2}", // 📂
+    Bash: "\u{1F5A5}\u{FE0F}", // 🖥️
+    WebSearch: "\u{1F310}", // 🌐
+    WebFetch: "\u{1F4E5}", // 📥
+    TodoWrite: "\u{2705}", // ✅
+    Agent: "\u{1F916}", // 🤖
+    NotebookEdit: "\u{1F4D3}", // 📓
+    AskUserQuestion: "\u{2753}", // ❓
+    // CCC 内置 Agent 下划线命名（getToolEmoji 会先把下划线转驼峰再查表，这里保留蛇形条目以便直接命中）
+    read_file: "\u{1F4D6}", // 📖
+    list_dir: "\u{1F4C2}", // 📂
+    search_code: "\u{1F50E}", // 🔎
+    run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
+    edit_file: "\u{270F}\u{FE0F}", // ✏️
+    create_file: "\u{270D}\u{FE0F}", // ✍️
+    delete_file: "\u{1F5D1}\u{FE0F}", // 🗑️
+    move_file: "\u{1F4E6}", // 📦
+    apply_patch: "\u{1F4CB}", // 📋
+};
+export function getToolEmoji(name) {
+    return TOOL_EMOJI_MAP[name] ?? TOOL_EMOJI_MAP[normalizeToolName(name)] ?? "\u{1F527}"; // 🔧
+}
+/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
+export function normalizeToolName(name) {
+    return name
+        .split("_")
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}

package/dist/progress/reducer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
+ *
+ * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
+ * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
+ * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
+ * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
+ */
+import type { ChatEvent } from "../index.js";
+import { type ProgressView } from "./view.js";
+/** 工具调用 input 单行摘要（终端折叠行展示用） */
+export declare function summarizeToolInput(input: unknown, maxChars?: number): string;
+/** 工具结果单行摘要（成功/失败各取首行） */
+export declare function summarizeToolResult(content: unknown, maxChars?: number): string;
+/**
+ * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
+ * 未识别的/不影响展示的事件（如 compact）返回原视图。
+ */
+export declare function reduceProgress(prev: ProgressView, event: ChatEvent): ProgressView;

package/dist/progress/reducer.js

@@ -0,0 +1,98 @@
+/**
+ * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
+ *
+ * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
+ * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
+ * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
+ * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
+ */
+import { withProgressView, } from "./view.js";
+/** 工具调用 input 单行摘要（终端折叠行展示用） */
+export function summarizeToolInput(input, maxChars = 120) {
+    let raw;
+    if (typeof input === "string") {
+        raw = input;
+    }
+    else {
+        try {
+            raw = JSON.stringify(input);
+        }
+        catch {
+            raw = String(input);
+        }
+    }
+    const oneLine = raw.replace(/\s+/g, " ").trim();
+    return oneLine.length > maxChars ? oneLine.slice(0, maxChars) + "…" : oneLine;
+}
+/** 工具结果单行摘要（成功/失败各取首行） */
+export function summarizeToolResult(content, maxChars = 120) {
+    let raw;
+    if (typeof content === "string") {
+        raw = content;
+    }
+    else if (content instanceof Error) {
+        raw = content.message;
+    }
+    else {
+        try {
+            raw = JSON.stringify(content);
+        }
+        catch {
+            raw = String(content);
+        }
+    }
+    const firstLine = raw.split("\n")[0] ?? "";
+    return firstLine.length > maxChars ? firstLine.slice(0, maxChars) + "…" : firstLine;
+}
+/**
+ * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
+ * 未识别的/不影响展示的事件（如 compact）返回原视图。
+ */
+export function reduceProgress(prev, event) {
+    switch (event.type) {
+        case "text":
+            // accumulated 是全文累积，直接全量替换，天然幂等
+            return withProgressView(prev, { text: event.accumulated });
+        case "tool_use": {
+            const tool = {
+                id: event.id ?? `tool-${prev.tools.length + 1}`,
+                name: event.name,
+                status: "running",
+                detail: summarizeToolInput(event.input),
+            };
+            return withProgressView(prev, { tools: [...prev.tools, tool] });
+        }
+        case "tool_result": {
+            const nextStatus = event.is_error ? "error" : "ok";
+            const summary = summarizeToolResult(event.content);
+            let matched = false;
+            const tools = prev.tools.map((t) => {
+                if (matched || t.id !== event.tool_use_id)
+                    return t;
+                matched = true;
+                return { ...t, status: nextStatus, summary };
+            });
+            if (!matched) {
+                // id 缺失或失配：兜底更新最后一个 running 工具，避免状态悬挂
+                const lastRunning = [...prev.tools].reverse().findIndex((t) => t.status === "running");
+                if (lastRunning >= 0) {
+                    const idx = prev.tools.length - 1 - lastRunning;
+                    const updated = prev.tools.map((t, i) => i === idx ? { ...t, status: nextStatus, summary } : t);
+                    return withProgressView(prev, { tools: updated });
+                }
+            }
+            return withProgressView(prev, { tools });
+        }
+        case "done":
+            return withProgressView(prev, {
+                status: "done",
+                showStop: false,
+                text: event.text,
+            });
+        case "error":
+            return withProgressView(prev, { status: "error", showStop: false });
+        case "compact":
+            // 旧上下文压缩不影响当前过程展示
+            return prev;
+    }
+}