deepccc 0.1.1

package/dist/cli.js

@@ -0,0 +1,513 @@
+/**
+ * DeepCCC terminal REPL and JSONL streaming entrypoint — 同步自 ChatCCC
+ *
+ * Usage:
+ *   node bin/deepccc.mjs
+ *   node bin/deepccc.mjs --model deepseek-v4-pro
+ *   node bin/deepccc.mjs --stream-json --prompt "hello"
+ *
+ * 交互模式（TTY）下，单轮回复渲染为固定"过程区块"：状态行 + 折叠工具行 +
+ * 原地更新正文，不再滚屏刷 JSON；完成/停止/异常后定型留在屏幕上。
+ * 非 TTY（管道/CI）或 --plain 回退为纯文本流式输出；--stream-json 机器接口不变。
+ */
+import * as readline from "node:readline";
+import * as process from "node:process";
+import { appendFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { listBuiltinContextSessions } from "./context.js";
+import { resolveBuiltinSession } from "./session-select.js";
+import { createCtrlCState } from "./sigint.js";
+import { reduceProgress } from "./progress/reducer.js";
+import { TerminalProgressRenderer } from "./progress/terminal-renderer.js";
+import { progressView } from "./progress/view.js";
+import { defaultLogDir, setupFileLogging } from "./file-log.js";
+function parsePositiveIntegerOption(name, value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return parsed;
+}
+function parseArgs(argv = process.argv.slice(2)) {
+    const config = {};
+    const options = {};
+    let listSessions = false;
+    let resume;
+    let help = false;
+    let streamJson = false;
+    let prompt = null;
+    let plain = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        if (arg === "--model" && next !== undefined) {
+            config.model = next;
+            i++;
+        }
+        else if (arg === "--effort" && next !== undefined) {
+            config.effort = next;
+            i++;
+        }
+        else if (arg === "--base-url" && next !== undefined) {
+            config.baseURL = next;
+            i++;
+        }
+        else if (arg === "--api-key" && next !== undefined) {
+            config.apiKey = next;
+            i++;
+        }
+        else if (arg === "--cwd" && next !== undefined) {
+            options.cwd = next;
+            i++;
+        }
+        else if (arg === "--max-steps" && next !== undefined) {
+            options.maxSteps = parsePositiveIntegerOption("--max-steps", next);
+            i++;
+        }
+        else if (arg === "--resume") {
+            if (next !== undefined && !next.startsWith("--")) {
+                resume = next;
+                i++;
+            }
+            else {
+                resume = true;
+            }
+        }
+        else if (arg === "--list-sessions") {
+            listSessions = true;
+        }
+        else if (arg === "--stream-json") {
+            streamJson = true;
+        }
+        else if (arg === "--prompt" && next !== undefined) {
+            prompt = next;
+            i++;
+        }
+        else if (arg === "--plain") {
+            plain = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+    }
+    return { config, options, listSessions, resume, help, streamJson, prompt, plain };
+}
+async function loadRuntime() {
+    const [{ ChatSession }, { config: appConfig }] = await Promise.all([
+        import("./index.js"),
+        import("./config.js"),
+    ]);
+    return { ChatSession, appConfig };
+}
+function printHelp(appConfig) {
+    console.log([
+        "DeepCCC terminal agent",
+        "",
+        "Usage: deepccc [options]",
+        "",
+        "Options:",
+        `  --model <name>       Model name (current default ${appConfig.model})`,
+        `  --effort <level>     Reasoning effort: none/minimal/low/medium/high/xhigh/max (overrides config.effort)`,
+        `  --base-url <url>     OpenAI-compatible API base URL (current default ${appConfig.baseURL})`,
+        "  --api-key <key>      API key",
+        "  --cwd <path>         Working directory",
+        "  --max-steps <n>      Optional tool-step limit. Omit for no step limit",
+        "  --resume [id]        Resume latest cwd session, or the explicit session id",
+        "  --list-sessions      List saved sessions and exit",
+        "  --stream-json        One-shot mode: write JSONL events to stdout",
+        "  --prompt <text>      Prompt text for --stream-json",
+        "  --plain              Force plain streaming output (no progress block renderer)",
+        "  --help, -h           Show help",
+        "",
+        "Default config source:",
+        "  ~/.deepccc/config.json, DEEPCCC_* environment variables, or DEEPSEEK_* aliases",
+        "",
+    ].join("\n"));
+}
+function formatTime(ms) {
+    return new Date(ms).toLocaleString();
+}
+function printSessions(streamJson = false) {
+    const sessions = listBuiltinContextSessions();
+    if (streamJson) {
+        writeJsonLine({
+            type: "sessions",
+            sessions: sessions.map((session) => ({
+                session_id: session.sessionId,
+                turns: session.totalMessages,
+                compacted_messages: session.compactedMessages,
+                has_summary: session.hasSummary,
+                updated_at: session.updatedAt,
+                cwd: session.cwd,
+            })),
+        });
+        return;
+    }
+    if (sessions.length === 0) {
+        console.log("No saved DeepCCC sessions");
+        return;
+    }
+    for (const session of sessions) {
+        const summary = session.hasSummary ? " summary=yes" : "";
+        const cwd = session.cwd ? ` cwd=${session.cwd}` : "";
+        console.log(`${session.sessionId}  turns=${session.totalMessages} compacted=${session.compactedMessages}${summary} updated=${formatTime(session.updatedAt)}${cwd}`);
+    }
+}
+function stringifyConsoleArg(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Error)
+        return value.stack ?? value.message;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function redirectConsoleLogsToStderr() {
+    const write = (...args) => {
+        process.stderr.write(`${args.map(stringifyConsoleArg).join(" ")}\n`);
+    };
+    console.log = write;
+    console.info = write;
+    console.warn = write;
+}
+function writeJsonLine(event) {
+    process.stdout.write(`${JSON.stringify(event)}\n`);
+}
+function streamJsonEvent(event) {
+    if (event.type === "text") {
+        writeJsonLine({
+            type: "text_delta",
+            text: event.text,
+            accumulated: event.accumulated,
+        });
+    }
+    else if (event.type === "compact") {
+        writeJsonLine({
+            type: "compact",
+            compacted_messages: event.compactedMessages,
+        });
+    }
+    else if (event.type === "tool_use") {
+        writeJsonLine({
+            type: "tool_call",
+            id: event.id,
+            name: event.name,
+            input: event.input,
+        });
+    }
+    else if (event.type === "tool_result") {
+        writeJsonLine({
+            type: "tool_result",
+            tool_call_id: event.tool_use_id,
+            name: event.name,
+            content: event.content,
+            is_error: event.is_error,
+        });
+    }
+    else if (event.type === "done") {
+        writeJsonLine({
+            type: "done",
+            text: event.text,
+        });
+    }
+    else if (event.type === "error") {
+        writeJsonLine({
+            type: "error",
+            message: event.message,
+        });
+    }
+}
+async function readPromptFromStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function runStreamJson(args) {
+    redirectConsoleLogsToStderr();
+    if (args.listSessions) {
+        printSessions(true);
+        return 0;
+    }
+    const prompt = args.prompt ?? (!process.stdin.isTTY ? await readPromptFromStdin() : "");
+    if (!prompt.trim()) {
+        writeJsonLine({ type: "error", message: "--stream-json requires --prompt <text> or stdin input" });
+        return 1;
+    }
+    let runtime;
+    try {
+        runtime = await loadRuntime();
+    }
+    catch (err) {
+        writeJsonLine({ type: "error", message: err.message });
+        return 1;
+    }
+    const cwd = resolvePath(args.options.cwd ?? process.cwd());
+    let resolvedSession;
+    try {
+        resolvedSession = resolveBuiltinSession({ cwd, resume: args.resume });
+    }
+    catch (err) {
+        writeJsonLine({ type: "error", message: err.message });
+        return 1;
+    }
+    let session;
+    try {
+        session = new runtime.ChatSession(args.config, {
+            ...args.options,
+            cwd,
+            persist: true,
+            sessionId: resolvedSession.sessionId,
+        });
+    }
+    catch (err) {
+        writeJsonLine({ type: "error", message: err.message });
+        return 1;
+    }
+    writeJsonLine({
+        type: "start",
+        session_id: resolvedSession.sessionId,
+        mode: resolvedSession.mode,
+        cwd,
+        model: args.config.model ?? runtime.appConfig.model,
+    });
+    try {
+        for await (const event of session.chat(prompt)) {
+            streamJsonEvent(event);
+        }
+        return 0;
+    }
+    catch (err) {
+        writeJsonLine({ type: "error", message: err.message });
+        return 1;
+    }
+}
+const C = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+};
+/**
+ * 交互模式下渲染器独占终端 stdout：普通日志只写日志文件、不回显到终端，
+ * 避免生成过程中任何 console 输出混入过程区块、破坏行数计数（导致重绘
+ * 上移不足、把上方历史内容"吃掉"）。错误提示（console.error）保留回显。
+ */
+function muteConsoleLogToFile(logPath) {
+    const writeFile = (level, args) => {
+        try {
+            const text = args
+                .map((a) => typeof a === "string" ? a
+                : a instanceof Error ? (a.stack ?? a.message)
+                    : JSON.stringify(a))
+                .join(" ");
+            appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${text}\n`, "utf8");
+        }
+        catch {
+            // 日志系统自身失败不影响主流程
+        }
+    };
+    console.log = (...args) => writeFile("LOG", args);
+    console.info = (...args) => writeFile("INFO", args);
+    console.warn = (...args) => writeFile("WARN", args);
+}
+async function runRepl(args) {
+    const { ChatSession, appConfig } = await loadRuntime();
+    const cwd = resolvePath(args.options.cwd ?? process.cwd());
+    let resolvedSession;
+    try {
+        resolvedSession = resolveBuiltinSession({ cwd, resume: args.resume });
+    }
+    catch (err) {
+        console.error(`${C.yellow}${err.message}${C.reset}`);
+        process.exit(1);
+    }
+    console.log(`${C.dim}DeepCCC agent${C.reset}`);
+    console.log(`${C.dim}Model: ${args.config.model ?? appConfig.model}${C.reset}`);
+    console.log(`${C.dim}Directory: ${cwd}${C.reset}`);
+    console.log(`${C.dim}Session: ${resolvedSession.sessionId} (${resolvedSession.mode === "new" ? "new" : "resumed"})${C.reset}`);
+    console.log(`${C.dim}Type a message to chat. Double Ctrl+C interrupts generation or exits. Type exit to quit.${C.reset}`);
+    console.log("");
+    // 交互渲染模式下 console 输出只写日志文件、不回显到终端（渲染器独占 stdout，
+    // 避免生成中日志混入区块破坏行数）。--plain 无渲染器，不需要静音。
+    if (process.stdout.isTTY === true && !args.plain) {
+        muteConsoleLogToFile(setupFileLogging(defaultLogDir(), "index").logPath);
+    }
+    let session;
+    try {
+        session = new ChatSession(args.config, {
+            ...args.options,
+            cwd,
+            persist: true,
+            sessionId: resolvedSession.sessionId,
+        });
+    }
+    catch (err) {
+        console.error(`${C.yellow}${err.message}${C.reset}`);
+        process.exit(1);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `${C.green}>${C.reset} `,
+    });
+    let currentAbort = null;
+    const ctrlCState = createCtrlCState();
+    rl.prompt();
+    rl.on("line", async (line) => {
+        ctrlCState.reset();
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input === "exit") {
+            process.stdout.write(`${C.dim}bye${C.reset}\n`);
+            rl.close();
+            return;
+        }
+        if (input === "/clear") {
+            session.reset();
+            process.stdout.write(`${C.dim}session cleared${C.reset}\n`);
+            rl.prompt();
+            return;
+        }
+        if (input === "/history") {
+            process.stdout.write(`${C.dim}${session.turnCount} conversation turns${C.reset}\n`);
+            rl.prompt();
+            return;
+        }
+        currentAbort = new AbortController();
+        const signal = currentAbort.signal;
+        // TTY 下用"过程区块"（飞书过程卡片的终端形态）：固定区域原地更新、
+        // 工具调用折叠为单行；非 TTY（管道/CI）或 --plain 回退为纯文本流式输出。
+        const useTerminalBlock = process.stdout.isTTY === true && !args.plain;
+        const renderer = useTerminalBlock ? new TerminalProgressRenderer() : null;
+        let view = null;
+        if (renderer) {
+            view = progressView({ headerTitle: "生成中..." });
+            // 先回行首换行再 begin：让过程区块从输入行下方开始，避免首帧 \r\x1b[2K
+            // 清掉用户刚输入的问题行（历史文本不被刷掉）。\r\n 兼容 readline
+            // 行提交后光标仍停在输入行行尾的情况。
+            process.stdout.write("\r\n");
+            renderer.begin(view);
+        }
+        let rendererEnded = false;
+        try {
+            let lastAccumulated = "";
+            for await (const event of session.chat(input, signal)) {
+                if (renderer && view) {
+                    view = reduceProgress(view, event);
+                    if (event.type === "text" || event.type === "compact") {
+                        renderer.render(view);
+                    }
+                    else {
+                        renderer.flush();
+                    }
+                }
+                else if (event.type === "text") {
+                    const newText = event.accumulated.slice(lastAccumulated.length);
+                    process.stdout.write(newText);
+                    lastAccumulated = event.accumulated;
+                }
+                else if (event.type === "done") {
+                    if (lastAccumulated)
+                        console.log("");
+                    console.log(`${C.dim}[done]${C.reset}`);
+                }
+                else if (event.type === "compact") {
+                    console.log(`${C.dim}[context compacted: ${event.compactedMessages} old messages]${C.reset}`);
+                }
+                else if (event.type === "tool_use") {
+                    console.log(`\n${C.dim}[tool] ${event.name} ${stringifyConsoleArg(event.input)}${C.reset}`);
+                }
+                else if (event.type === "tool_result") {
+                    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 === "error") {
+                    console.log(`\n${C.yellow}[error] ${event.message}${C.reset}`);
+                }
+            }
+        }
+        catch (err) {
+            if (renderer && view) {
+                const aborted = err instanceof Error && err.name === "AbortError";
+                view = progressView({ ...view, status: aborted ? "stopped" : "error", showStop: false });
+                renderer.end(view);
+                rendererEnded = true;
+                process.stdout.write("\n");
+            }
+            console.error(`\n${C.yellow}[error] ${err.message}${C.reset}`);
+        }
+        finally {
+            if (renderer && view && !rendererEnded) {
+                // 定型终态区块（完成/已停止/异常结束）留在屏幕上，恢复光标
+                renderer.end(view);
+                process.stdout.write("\n");
+            }
+            currentAbort = null;
+            ctrlCState.reset();
+        }
+        rl.prompt();
+    });
+    rl.on("SIGINT", () => {
+        const action = ctrlCState.press(currentAbort !== null);
+        if (action === "exit") {
+            console.error(`\n${C.dim}bye${C.reset}`);
+            rl.close();
+            return;
+        }
+        if (action === "interrupt") {
+            console.error(`\n${C.yellow}[interrupting...]${C.reset}`);
+            currentAbort?.abort();
+            currentAbort = null;
+            return;
+        }
+        if (action === "arm-interrupt") {
+            console.error(`\n${C.dim}Press Ctrl+C again to interrupt current response${C.reset}`);
+            return;
+        }
+        if (action === "arm-exit") {
+            console.error(`\n${C.dim}Press Ctrl+C again to exit, or type exit${C.reset}`);
+            rl.prompt();
+        }
+    });
+    rl.on("close", () => {
+        process.stdout.write("\n");
+        process.exit(0);
+    });
+}
+async function main() {
+    const args = parseArgs();
+    if (args.streamJson) {
+        const code = await runStreamJson(args);
+        process.exit(code);
+    }
+    if (args.help) {
+        const { appConfig } = await loadRuntime();
+        printHelp(appConfig);
+        return;
+    }
+    if (args.listSessions) {
+        printSessions();
+        return;
+    }
+    await runRepl(args);
+}
+function isDirectCliInvocation() {
+    const current = resolvePath(fileURLToPath(import.meta.url));
+    const invoked = process.argv[1] ? resolvePath(process.argv[1]) : "";
+    return current === invoked;
+}
+if (isDirectCliInvocation()) {
+    main().catch((err) => {
+        console.error(`${C.yellow}startup failed: ${err.message}${C.reset}`);
+        process.exit(1);
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+export interface DeepCccConfig {
+    apiKey: string;
+    baseURL: string;
+    model: string;
+    /** Reasoning effort（none/minimal/low/medium/high/xhigh/max），留空不传 reasoning_effort */
+    effort: string;
+    rawStreamLogs: {
+        enabled: boolean;
+        maxBytesPerTurn: number;
+        retentionDays: number;
+        keepCompleted: boolean;
+    };
+}
+export declare const DEEPCCC_HOME: string;
+export declare const RAW_STREAM_LOGS_DIR: string;
+export declare function ensureConfigDir(): void;
+export declare const config: DeepCccConfig;

package/dist/config.js

@@ -0,0 +1,64 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const DEEPCCC_HOME = join(homedir(), ".deepccc");
+export const RAW_STREAM_LOGS_DIR = join(DEEPCCC_HOME, "raw-stream-logs");
+const CONFIG_PATH = join(DEEPCCC_HOME, "config.json");
+const DEFAULT_CONFIG = {
+    apiKey: "",
+    baseURL: "https://api.deepseek.com/v1",
+    model: "deepseek-v4-pro",
+    effort: "",
+    rawStreamLogs: {
+        enabled: false,
+        maxBytesPerTurn: 1024 * 1024,
+        retentionDays: 7,
+        keepCompleted: false,
+    },
+};
+function readConfigFile() {
+    if (!existsSync(CONFIG_PATH))
+        return {};
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+}
+function env(name) {
+    const value = process.env[name]?.trim();
+    return value ? value : undefined;
+}
+function boolEnv(name) {
+    const value = env(name)?.toLowerCase();
+    if (value === undefined)
+        return undefined;
+    if (["1", "true", "yes", "on"].includes(value))
+        return true;
+    if (["0", "false", "no", "off"].includes(value))
+        return false;
+    return undefined;
+}
+function numberEnv(name) {
+    const value = Number(env(name));
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function loadConfig() {
+    const file = readConfigFile();
+    const rawLogs = file.rawStreamLogs && typeof file.rawStreamLogs === "object"
+        ? file.rawStreamLogs
+        : {};
+    return {
+        apiKey: env("DEEPCCC_API_KEY") ?? env("DEEPSEEK_API_KEY") ?? file.apiKey ?? DEFAULT_CONFIG.apiKey,
+        baseURL: env("DEEPCCC_BASE_URL") ?? env("DEEPSEEK_BASE_URL") ?? file.baseURL ?? DEFAULT_CONFIG.baseURL,
+        model: env("DEEPCCC_MODEL") ?? env("DEEPSEEK_MODEL") ?? file.model ?? DEFAULT_CONFIG.model,
+        effort: env("DEEPCCC_EFFORT") ?? env("DEEPSEEK_EFFORT") ?? file.effort ?? DEFAULT_CONFIG.effort,
+        rawStreamLogs: {
+            enabled: boolEnv("DEEPCCC_RAW_STREAM_LOGS") ?? rawLogs.enabled ?? DEFAULT_CONFIG.rawStreamLogs.enabled,
+            maxBytesPerTurn: numberEnv("DEEPCCC_RAW_STREAM_MAX_BYTES") ?? rawLogs.maxBytesPerTurn ?? DEFAULT_CONFIG.rawStreamLogs.maxBytesPerTurn,
+            retentionDays: numberEnv("DEEPCCC_RAW_STREAM_RETENTION_DAYS") ?? rawLogs.retentionDays ?? DEFAULT_CONFIG.rawStreamLogs.retentionDays,
+            keepCompleted: boolEnv("DEEPCCC_RAW_STREAM_KEEP_COMPLETED") ?? rawLogs.keepCompleted ?? DEFAULT_CONFIG.rawStreamLogs.keepCompleted,
+        },
+    };
+}
+export function ensureConfigDir() {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+}
+export const config = loadConfig();

package/dist/context.d.ts

@@ -0,0 +1,73 @@
+export type BuiltinContextRole = "user" | "assistant";
+export interface BuiltinContextMessage {
+    role: BuiltinContextRole;
+    content: string;
+}
+export interface BuiltinContextState {
+    version: 1;
+    createdAt: number;
+    updatedAt: number;
+    sessionId: string;
+    cwd?: string;
+    summary: string;
+    messages: BuiltinContextMessage[];
+    totalMessages: number;
+    compactedMessages: number;
+}
+export interface BuiltinContextSessionInfo {
+    sessionId: string;
+    createdAt: number;
+    updatedAt: number;
+    cwd?: string;
+    totalMessages: number;
+    compactedMessages: number;
+    hasSummary: boolean;
+    contextFilePath: string;
+}
+export interface BuiltinCompactionPlan {
+    previousSummary: string;
+    oldMessages: BuiltinContextMessage[];
+    recentMessages: BuiltinContextMessage[];
+}
+export interface BuiltinContextOptions {
+    persist?: boolean;
+    contextDir?: string;
+    sessionId?: string;
+    cwd?: string;
+    compactAtTokens?: number;
+    keepRecentMessages?: number;
+}
+export declare const DEFAULT_BUILTIN_CONTEXT_DIR: string;
+export declare const DEFAULT_COMPACT_AT_TOKENS = 48000;
+export declare const DEFAULT_KEEP_RECENT_MESSAGES = 16;
+export declare function normalizeBuiltinSessionId(value: string): string;
+export declare function defaultBuiltinSessionId(cwd?: string): string;
+export declare function newBuiltinSessionId(now?: Date, suffix?: string): string;
+export declare function getBuiltinContextSession(sessionId: string, contextDir?: string): BuiltinContextSessionInfo | null;
+export declare function listBuiltinContextSessions(contextDir?: string): BuiltinContextSessionInfo[];
+export declare function latestBuiltinSessionForCwd(cwd: string, contextDir?: string): BuiltinContextSessionInfo | null;
+export declare function estimateBuiltinContextTokens(summary: string, messages: readonly BuiltinContextMessage[]): number;
+export declare function serializeMessagesForSummary(messages: readonly BuiltinContextMessage[]): string;
+export declare function buildSummaryPrompt(plan: BuiltinCompactionPlan): string;
+export declare class BuiltinContextManager {
+    readonly persist: boolean;
+    readonly contextDir: string;
+    readonly sessionId: string;
+    readonly compactAtTokens: number;
+    readonly keepRecentMessages: number;
+    private readonly cwd?;
+    private state;
+    constructor(options?: BuiltinContextOptions);
+    get summary(): string;
+    get messages(): BuiltinContextMessage[];
+    get totalMessages(): number;
+    get contextFilePath(): string;
+    appendMessage(message: BuiltinContextMessage): void;
+    setSummary(summary: string): void;
+    buildModelMessages(): BuiltinContextMessage[];
+    planCompaction(): BuiltinCompactionPlan | null;
+    applyCompaction(summary: string, plan: BuiltinCompactionPlan): void;
+    reset(): void;
+    save(): void;
+    private load;
+}