@botconnector/bccli 0.5.0-rc.4 → 0.5.1

package/dist/args-XA77XUMD.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  helpText,
+  parseCliArgs
+} from "./chunk-M5T4AM4I.js";
+import "./chunk-YYTFJUO2.js";
+import "./chunk-NGFWBVHD.js";
+import "./chunk-ZXWRLN7E.js";
+import "./chunk-IDZLHEVL.js";
+export {
+  helpText,
+  parseCliArgs
+};

package/dist/args.d.ts

@@ -0,0 +1,59 @@
+import { type PermissionMode } from './config';
+import { type ReasoningLevel } from './reasoning';
+import { type Lang } from './i18n';
+export interface CliArgs {
+    command: 'run' | 'login' | 'models' | 'update' | 'acp' | 'serve' | 'plugins' | 'gh-bot' | 'provider' | 'mcp' | 'connect' | 'disconnect' | 'integrations' | 'completion' | 'stats' | 'export' | 'import' | 'pr';
+    subArgs: string[];
+    url?: string;
+    /** `bccli mcp add <name> --command <cmd>`: server stdio, bukan HTTP. */
+    stdioCommand?: string;
+    /** Argumen untuk server stdio (dipisah spasi). */
+    stdioArgs?: string;
+    name?: string;
+    keyEnv?: string;
+    values: string[];
+    prompt?: string;
+    print: boolean;
+    model?: string;
+    reasoning?: ReasoningLevel;
+    lang?: Lang;
+    continue: boolean;
+    resume: boolean;
+    allowAll: boolean;
+    /** `-p` untuk CI: kegagalan tool apa pun membuat exit code 1. */
+    failOnToolError: boolean;
+    allowedTools: string[];
+    worktree?: string;
+    outputFormat?: 'text' | 'json' | 'stream-json';
+    permissionMode?: PermissionMode;
+    help: boolean;
+    version: boolean;
+    loginProvider?: string;
+    /** `bccli login` — pakai prompt API key lama, bukan OAuth. */
+    key: boolean;
+    /** `bccli login` — hapus credential tersimpan (hanya openrouter via OAuth path). */
+    logout: boolean;
+    /** `bccli serve` listener port (0 = ephemeral). */
+    port?: number;
+    /** `bccli serve` bind address — loopback only. */
+    host?: string;
+    /** `bccli serve` bearer token override. */
+    token?: string;
+    /** Base URL override for `bccli mcp serve`. */
+    baseUrl?: string;
+    /** `bccli stats` — only count sessions from the last N days (default 7). */
+    days?: number;
+    /** `bccli stats` - cap the tool-usage list to the top N tools. */
+    tools?: number;
+    /** `bccli stats [--models [N|all]]` - show per-model token usage (top N or all). */
+    models?: string;
+    /** `bccli stats --project <slug>` - filter rows; empty string = current project. */
+    project?: string;
+    /** `bccli pr` — explicit owner/name repo when cwd is not a git checkout of the PR. */
+    repo?: string;
+    /** Automatic fallback model ref when the primary model fails with 429 or 5xx. */
+    fallbackModel?: string;
+}
+/** Help text in the current language (call it after the language is set). */
+export declare const helpText: () => string;
+export declare function parseCliArgs(argv: string[]): CliArgs;

package/dist/budget.d.ts

@@ -0,0 +1,26 @@
+export interface UsageCap {
+    /** Total tokens (input + output) per session. */
+    tokens?: number;
+    /** Total USD per session; requires `prices`. */
+    usd?: number;
+    /** USD per 1M tokens. `cachedInput` is optional: without it cache reads cost the input price. */
+    prices?: Record<string, {
+        input: number;
+        output: number;
+        cachedInput?: number;
+    }>;
+}
+export declare function priceFor(cap: UsageCap, model: string): {
+    input: number;
+    output: number;
+    cachedInput?: number;
+} | undefined;
+export declare function budgetStatus(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+}, cap: UsageCap | undefined, model: string): {
+    kind: 'tokens' | 'usd';
+    used: number;
+    limit: number;
+} | undefined;

package/dist/checkpoints.d.ts

@@ -0,0 +1,35 @@
+interface UndoResult {
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+export declare class CheckpointStore {
+    private readonly history;
+    private current;
+    private pendingRedo;
+    private offset;
+    beginTurn(): void;
+    /** Call before writing a file; only the first snapshot per file per turn is kept. */
+    snapshot(path: string): Promise<void>;
+    turns(): number;
+    /** Total entries including empty ones; used to align file snapshots with conversation turns. */
+    entries(): number;
+    undo(): Promise<UndoResult | undefined>;
+    /**
+     * Revert every snapshot taken at or after the `keep`-th entry, newest first, so the files
+     * end in the state from before the turn that created entry `keep`. Used by /rewind, which
+     * pairs conversation turns with the entry count recorded when each turn started.
+     */
+    undoTo(keep: number): Promise<UndoResult | undefined>;
+    /**
+     * Re-apply the file state captured right before the last undo/undoTo.
+     * Only file edits are redone, never conversation history. Invalidated by
+     * any new snapshot turn or clear(), so redo can't resurrect stale content.
+     */
+    redo(): Promise<UndoResult | undefined>;
+    /** Records the on-disk state of a turn's paths so redo() can put it back. */
+    private captureFor;
+    clear(): void;
+}
+export {};

package/dist/chunk-2IP5F3EK.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName
+} from "./chunk-FY543EQW.js";
+import {
+  createProvider
+} from "./chunk-OCEQ2TRJ.js";
+import {
+  PRESETS,
+  readCredentials
+} from "./chunk-ZXWRLN7E.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/models.ts
+function order(ids) {
+  const presetIds = PRESETS.map((p) => p.id);
+  const presets = presetIds.filter((id) => ids.includes(id));
+  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
+  return [...presets, ...custom];
+}
+async function listAllModels(config, env = process.env, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const baseFetch = opts.fetch ?? fetch;
+  const untrusted = new Set(config.projectProviders ?? []);
+  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
+  const results = await Promise.all(
+    ids.map(async (id) => {
+      const provider = config.providers[id];
+      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || readCredentials(env)[id] || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || void 0;
+      const local = !provider.apiKeyEnv;
+      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const models = await Promise.race([list, timeout]);
+        return { providerId: id, providerName: providerName(config, id), models };
+      } catch {
+        if (local && !opts.only) return void 0;
+        return { providerId: id, providerName: providerName(config, id), models: [], error: t("could not be reached") };
+      } finally {
+        clearTimeout(timer);
+      }
+    })
+  );
+  return results.filter((g) => !!g);
+}
+
+export {
+  listAllModels
+};

package/dist/chunk-5CVHTYBQ.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import {
+  runCommand,
+  runHooks
+} from "./chunk-7U7CMKKI.js";
+import {
+  ConfigError
+} from "./chunk-ZXWRLN7E.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/verify.ts
+var MAX_VERIFY_ROUNDS = 2;
+async function runVerify(commands, opts) {
+  const run = opts.run ?? runCommand;
+  const failures = [];
+  for (const cmd of commands) {
+    const r = await run(cmd, { cwd: opts.cwd, timeoutMs: opts.timeoutMs ?? 3e5, signal: opts.signal, env: opts.env });
+    const exitCode = r.exitCode ?? -1;
+    if (exitCode !== 0) failures.push({ cmd, exitCode, output: r.output });
+  }
+  return failures;
+}
+function verifyFollowup(failures, maxBytes = 8e3) {
+  const blocks = failures.map((f) => {
+    const output = f.output.length > maxBytes ? `${f.output.slice(0, maxBytes)}
+[truncated]` : f.output;
+    return `$ ${f.cmd}
+[exit code ${f.exitCode}]
+${output}`;
+  });
+  return t("Automatic verification after your edits failed. Fix the problems so these commands pass, then stop.\n\n{blocks}", {
+    blocks: blocks.join("\n\n")
+  });
+}
+
+// src/print.ts
+function toolLabel(tool) {
+  if (tool === "web_search") return "Search";
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+function resolvePrintPrompt(prompt, stdinText) {
+  const cleanStdin = stdinText?.trim();
+  const cleanPrompt = prompt?.trim();
+  if (cleanStdin && cleanPrompt) return `${cleanStdin}
+
+${cleanPrompt}`;
+  return cleanPrompt || cleanStdin || void 0;
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
+  const format = opts.outputFormat ?? "text";
+  const emit = (line) => io.out.write(`${JSON.stringify(line)}
+`);
+  const startedMs = Date.now();
+  let result = "";
+  const toolNames = /* @__PURE__ */ new Map();
+  rt.interaction.approvePlan = async () => {
+    if (opts.allowAll) return "allowAll";
+    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
+`);
+    return "no";
+  };
+  let failed = false;
+  let wroteText = false;
+  let edited = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        if (format === "text") {
+          io.out.write(event.delta);
+          wroteText = true;
+        } else {
+          result += event.delta;
+          if (format === "stream-json") emit({ type: "text_delta", delta: event.delta });
+        }
+        break;
+      case "thinking":
+        if (format === "stream-json") emit({ type: "thinking_delta", delta: event.delta });
+        break;
+      case "textReplace":
+        result = event.text;
+        break;
+      case "toolStart":
+        toolNames.set(event.id, event.tool);
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        if (format === "stream-json") emit({ type: "tool_use", tool: event.tool, target: event.target });
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        if (event.isError && opts.failOnToolError) failed = true;
+        if ((event.tool === "edit" || event.tool === "write") && !event.isError) edited = true;
+        if (format === "stream-json") emit({ type: "tool_result", tool: toolNames.get(event.id), isError: !!event.isError, output: event.output });
+        break;
+      case "stepLimit":
+        io.err.write(`${t("Step limit reached.")}
+`);
+        failed = true;
+        break;
+      case "budgetExceeded":
+        io.err.write(`${t("Budget exceeded ({kind}): {used} of {limit}. Further model calls are blocked; raise usageCap in ~/.bccli/config.json.", { kind: event.kind, used: Math.round(event.used * 100) / 100, limit: event.limit })}
+`);
+        if (format === "stream-json") emit({ type: "error", message: "budgetExceeded" });
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write(`${t("Cancelled.")}
+`);
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        if (format === "stream-json") emit({ type: "error", message: event.message });
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  const onSigbreak = () => controller.abort();
+  const useSigbreak = process.platform === "win32";
+  if (useSigbreak) process.once("SIGBREAK", onSigbreak);
+  const start = await runHooks(rt.config.hooks, "SessionStart", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of start.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("SessionStart");
+  try {
+    await rt.agent.run(prompt, controller.signal);
+    const commands = rt.config.verifyCommands;
+    if (edited && commands.length && !controller.signal.aborted) {
+      for (let round = 0; round < MAX_VERIFY_ROUNDS; round++) {
+        io.err.write(`${t("Verifying edits: {cmds}", { cmds: commands.join(", ") })}
+`);
+        const failures = await runVerify(commands, { cwd: rt.cwd, env: rt.env, signal: controller.signal });
+        if (!failures.length) {
+          io.err.write(`${t("Verification passed.")}
+`);
+          break;
+        }
+        if (round === MAX_VERIFY_ROUNDS - 1 || controller.signal.aborted) {
+          io.err.write(`${t("Verification still failing after {n} fix round(s). Run the commands manually to see why.", { n: MAX_VERIFY_ROUNDS })}
+`);
+          failed = true;
+          break;
+        }
+        await rt.agent.run(verifyFollowup(failures), controller.signal);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+    if (useSigbreak) process.off("SIGBREAK", onSigbreak);
+  }
+  const stop = await runHooks(rt.config.hooks, "Stop", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of stop.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("Stop");
+  const durationMs = Math.max(0, Date.now() - startedMs);
+  if (format === "json") {
+    io.out.write(
+      `${JSON.stringify({
+        status: failed ? "failed" : "ok",
+        model: rt.modelRef,
+        session_id: rt.session.id,
+        usage: rt.agent.totalUsage,
+        duration_ms: durationMs,
+        result
+      })}
+`
+    );
+  } else if (format === "stream-json") {
+    if (result) emit({ type: "message", text: result });
+    emit({
+      type: "result",
+      status: failed ? "failed" : "ok",
+      model: rt.modelRef,
+      session_id: rt.session.id,
+      usage: rt.agent.totalUsage,
+      duration_ms: durationMs
+    });
+  } else if (wroteText) {
+    io.out.write("\n");
+  }
+  return failed ? 1 : 0;
+}
+
+// src/worktree.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+function git(cwd, args, bin = "git") {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
+    );
+  });
+}
+var NAME_RE = /^[A-Za-z0-9._-]+$/;
+function samePath(a, b) {
+  const norm = (p) => process.platform === "win32" ? p.replace(/\//g, "\\").toLowerCase() : p.replace(/\\/g, "/");
+  return norm(a) === norm(b);
+}
+function worktreeEntries(porcelain) {
+  return porcelain.split(/\r?\n\r?\n/).map((block) => {
+    const path = /^worktree (.+)$/m.exec(block)?.[1]?.trim();
+    if (!path) return void 0;
+    const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
+    return branch ? { path, branch } : { path };
+  }).filter((entry) => !!entry);
+}
+async function resolveWorktree(cwd, name, bin = "git") {
+  if (!NAME_RE.test(name)) {
+    throw new ConfigError(t('Invalid worktree name "{name}": use letters, digits, dot, dash, or underscore (no slashes).', { name }));
+  }
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) throw new ConfigError(t("git is not installed or not on PATH, so -w cannot be used."));
+  if (!inside.ok || inside.out.trim() !== "true") throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const entries = worktreeEntries(list.out);
+  const main = entries[0]?.path;
+  if (!main) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const path = join(dirname(main), `${basename(main)}.worktrees`, name);
+  if (entries.some((entry) => samePath(entry.path, path))) return { path, created: false };
+  if (existsSync(path)) {
+    throw new ConfigError(t("Worktree path {path} already exists but is not a registered worktree; remove or rename it first.", { path }));
+  }
+  const branch = `bccli/${name}`;
+  const hasBranch = (await git(main, ["rev-parse", "--verify", "-q", `refs/heads/${branch}`], bin)).ok;
+  const add = hasBranch ? await git(main, ["worktree", "add", path, branch], bin) : await git(main, ["worktree", "add", "-b", branch, path], bin);
+  if (!add.ok) throw new ConfigError(add.out.trim() || t("This folder is not a git repository, so -w cannot create a worktree."));
+  return { path, created: true };
+}
+async function worktreeListText(cwd, bin = "git") {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) return t("git is not installed or not on PATH, so /worktree cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) return t("This folder is not a git repository, so there is no diff.");
+  const rows = worktreeEntries(list.out).map((entry) => `  ${entry.path}${entry.branch ? ` (${entry.branch})` : ""}`);
+  return [
+    t("Git worktrees:"),
+    ...rows,
+    "",
+    t("Create one with: bccli -w <name>"),
+    t("Remove with: git worktree remove <path>")
+  ].join("\n");
+}
+
+export {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  verifyFollowup,
+  toolLabel,
+  resolvePrintPrompt,
+  runPrint,
+  resolveWorktree,
+  worktreeListText
+};

package/dist/chunk-6LO6YRDY.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import {
+  contentText
+} from "./chunk-OCEQ2TRJ.js";
+
+// src/session.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { basename, dirname, join } from "path";
+function projectDir(home, cwd) {
+  const slug = cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+  return join(home, "sessions", slug);
+}
+function repairTail(messages) {
+  const out = [...messages];
+  for (let i = out.length - 1; i >= 0; i--) {
+    const m = out[i];
+    if (m.role !== "assistant" || !m.tool_calls?.length) continue;
+    const answered = new Set(out.slice(i + 1).flatMap((x) => x.role === "tool" ? [x.tool_call_id] : []));
+    if (!m.tool_calls.every((c) => answered.has(c.id))) out.length = i;
+    break;
+  }
+  return out;
+}
+var Session = class _Session {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  get id() {
+    return basename(this.file, ".jsonl");
+  }
+  static create(home, cwd, now = /* @__PURE__ */ new Date()) {
+    const dir = projectDir(home, cwd);
+    const stamp = now.toISOString().replace(/[:.]/g, "-");
+    return new _Session(join(dir, `${stamp}-${randomBytes(3).toString("hex")}.jsonl`));
+  }
+  static list(home, cwd) {
+    const dir = projectDir(home, cwd);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const session = new _Session(join(dir, f));
+      const first = session.loadHistory().find((m) => m.role === "user");
+      return { session, mtime: statSync(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
+    }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
+  }
+  static latest(home, cwd) {
+    return _Session.list(home, cwd)[0]?.session;
+  }
+  write(record) {
+    mkdirSync(dirname(this.file), { recursive: true });
+    appendFileSync(this.file, `${JSON.stringify(record)}
+`);
+  }
+  append(message) {
+    this.write({ t: "msg", m: message });
+  }
+  appendUsage(usage) {
+    this.write({ t: "usage", ...usage });
+  }
+  reset() {
+    this.write({ t: "reset" });
+  }
+  records() {
+    if (!existsSync(this.file)) return [];
+    const out = [];
+    for (const line of readFileSync(this.file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+  load() {
+    let messages = [];
+    for (const record of this.records()) {
+      if (record.t === "reset") messages = [];
+      else if (record.t === "msg") messages.push(record.m);
+    }
+    return repairTail(messages);
+  }
+  /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+  lastModel() {
+    const records = this.records();
+    for (let i = records.length - 1; i >= 0; i--) {
+      const record = records[i];
+      if (record.t === "usage" && record.model) return record.model;
+    }
+    return void 0;
+  }
+  /** Accumulated token usage since the last non-compaction reset. */
+  totalUsage() {
+    const segments = [{ msgs: [], usage: { inputTokens: 0, outputTokens: 0 } }];
+    for (const record of this.records()) {
+      const cur = segments[segments.length - 1];
+      if (record.t === "reset") {
+        segments.push({ msgs: [], usage: { inputTokens: 0, outputTokens: 0 } });
+      } else if (record.t === "msg") {
+        cur.msgs.push(record.m);
+      } else if (record.t === "usage") {
+        cur.usage.inputTokens += record.inputTokens;
+        cur.usage.outputTokens += record.outputTokens;
+        if (record.cachedInputTokens) cur.usage.cachedInputTokens = (cur.usage.cachedInputTokens ?? 0) + record.cachedInputTokens;
+        if (record.cacheWriteTokens) cur.usage.cacheWriteTokens = (cur.usage.cacheWriteTokens ?? 0) + record.cacheWriteTokens;
+      }
+    }
+    let total = { ...segments[0].usage };
+    for (const seg of segments.slice(1)) {
+      if (!isCompactionSummary(seg.msgs[0])) {
+        total = { ...seg.usage };
+      } else {
+        total.inputTokens += seg.usage.inputTokens;
+        total.outputTokens += seg.usage.outputTokens;
+        if (seg.usage.cachedInputTokens) total.cachedInputTokens = (total.cachedInputTokens ?? 0) + seg.usage.cachedInputTokens;
+        if (seg.usage.cacheWriteTokens) total.cacheWriteTokens = (total.cacheWriteTokens ?? 0) + seg.usage.cacheWriteTokens;
+      }
+    }
+    return total;
+  }
+  /**
+   * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+   * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+   * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+   */
+  loadHistory() {
+    const segments = [[]];
+    for (const record of this.records()) {
+      if (record.t === "reset") segments.push([]);
+      else if (record.t === "msg") segments[segments.length - 1].push(record.m);
+    }
+    let shown = segments[0];
+    let lastSummary;
+    for (const segment of segments.slice(1)) {
+      if (!isCompactionSummary(segment[0])) {
+        shown = segment;
+        lastSummary = void 0;
+        continue;
+      }
+      const kept = segment.slice(2);
+      if (lastSummary && sameMessage(segment[0], lastSummary)) {
+        const subIdx = findContiguousSlice(shown, kept);
+        if (subIdx !== -1) {
+          shown = shown.slice(0, subIdx + kept.length);
+          continue;
+        }
+      }
+      lastSummary = segment[0];
+      let at = 0;
+      while (at <= shown.length && !endsWithPrefixOf(shown, at, kept)) at++;
+      shown = [...shown, ...kept.slice(shown.length - at)];
+    }
+    return repairTail(shown.filter((m) => !isCompactionSummary(m) && !isCompactionAck(m)));
+  }
+};
+var SUMMARY_PREFIX = "Summary of the previous conversation:";
+var SUMMARY_ACK = "OK, I will continue from this summary.";
+function isCompactionSummary(m) {
+  return m?.role === "user" && typeof m.content === "string" && m.content.startsWith(SUMMARY_PREFIX);
+}
+function isCompactionAck(m) {
+  return m.role === "assistant" && m.content === SUMMARY_ACK;
+}
+function sameMessage(a, b) {
+  if (a.role !== b.role) return false;
+  if (a.role === "tool" && b.role === "tool") return a.tool_call_id === b.tool_call_id;
+  return JSON.stringify(a.content) === JSON.stringify(b.content) && JSON.stringify("tool_calls" in a && a.tool_calls) === JSON.stringify("tool_calls" in b && b.tool_calls);
+}
+function endsWithPrefixOf(shown, at, kept) {
+  const n = shown.length - at;
+  if (n > kept.length) return false;
+  for (let j = 0; j < n; j++) if (!sameMessage(shown[at + j], kept[j])) return false;
+  return true;
+}
+function findContiguousSlice(shown, slice) {
+  if (slice.length === 0) return shown.length;
+  for (let i = 0; i + slice.length <= shown.length; i++) {
+    let ok = true;
+    for (let j = 0; j < slice.length; j++) {
+      if (!sameMessage(shown[i + j], slice[j])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return i;
+  }
+  return -1;
+}
+function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
+  const root = join(home, "sessions");
+  if (!existsSync(root)) return 0;
+  let removed = 0;
+  for (const project of readdirSync(root)) {
+    const dir = join(root, project);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    for (const file of readdirSync(dir)) {
+      const path = join(dir, file);
+      if (now - statSync(path).mtimeMs > maxAgeDays * 864e5) {
+        rmSync(path);
+        removed++;
+      }
+    }
+  }
+  return removed;
+}
+
+export {
+  Session,
+  pruneSessions
+};