privateer-agent 0.2.1 → 0.3.0

package/src/context/outputStyles.ts

@@ -1,42 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { globalPaths, projectPaths } from "../config/paths.ts";
-import { walkFiles } from "../tools/walk.ts";
-import { parseFrontmatter } from "../commands/custom.ts";
-
-// A persona/behavior preset loaded from .privateer/output-styles/<name>.md. Its body
-// replaces the default tone section of the system prompt while the tool policy,
-// security stance, and environment grounding stay intact.
-export interface OutputStyle {
-  name: string;
-  description?: string;
-  body: string;
-  scope: "project" | "user";
-}
-
-function loadFromDir(dir: string, scope: "project" | "user"): OutputStyle[] {
-  if (!existsSync(dir)) return [];
-  const out: OutputStyle[] = [];
-  for (const rel of walkFiles(dir)) {
-    if (!rel.endsWith(".md")) continue;
-    const { meta, body } = parseFrontmatter(readFileSync(join(dir, rel), "utf8"));
-    out.push({
-      name: rel.replace(/\.md$/, "").split("/").join(":"),
-      description: meta.description,
-      body: body.trim(),
-      scope,
-    });
-  }
-  return out;
-}
-
-export function loadOutputStyles(cwd: string = process.cwd()): OutputStyle[] {
-  const byName = new Map<string, OutputStyle>();
-  for (const s of loadFromDir(globalPaths().outputStyles, "user")) byName.set(s.name, s);
-  for (const s of loadFromDir(projectPaths(cwd).outputStyles, "project")) byName.set(s.name, s);
-  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-export function findOutputStyle(name: string, cwd: string = process.cwd()): OutputStyle | undefined {
-  return loadOutputStyles(cwd).find((s) => s.name === name);
-}

package/src/context/projectInfo.ts

@@ -1,59 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { walkFiles } from "../tools/walk.ts";
-
-// Lightweight, synchronous environment probes used to enrich the system prompt at
-// session start. Everything here fails soft: outside a git repo, or if `git` is
-// missing, the git block is simply omitted rather than throwing.
-
-function git(cwd: string, args: string[]): string | null {
-  try {
-    return execFileSync("git", args, {
-      cwd,
-      encoding: "utf8",
-      timeout: 3_000,
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-
-export interface GitInfo {
-  branch: string;
-  status: string; // short porcelain, possibly truncated
-  recent: string; // last few commit subjects
-}
-
-// A compact git snapshot, or null when cwd isn't a working tree.
-export function gitStatus(cwd: string): GitInfo | null {
-  const inside = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
-  if (inside !== "true") return null;
-
-  const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || "(detached)";
-  const raw = git(cwd, ["status", "--porcelain"]) ?? "";
-  const lines = raw ? raw.split("\n") : [];
-  const status =
-    lines.length === 0
-      ? "(clean)"
-      : lines.slice(0, 20).join("\n") +
-        (lines.length > 20 ? `\n… (+${lines.length - 20} more)` : "");
-  const recent = git(cwd, ["log", "--oneline", "-5"]) ?? "";
-
-  return { branch, status, recent };
-}
-
-// A shallow snapshot of the project's files (respecting walk's skip list), capped
-// so the prompt stays small. Gives the model a sense of layout before it explores.
-export function dirSnapshot(cwd: string, limit = 40): string {
-  let files: string[];
-  try {
-    files = walkFiles(cwd);
-  } catch {
-    return "";
-  }
-  if (files.length === 0) return "";
-  files.sort();
-  const shown = files.slice(0, limit);
-  const more = files.length > limit ? `\n… (+${files.length - limit} more files)` : "";
-  return shown.join("\n") + more;
-}

package/src/context/systemPrompt.ts

@@ -1,176 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { gitStatus, dirSnapshot } from "./projectInfo.ts";
-import { loadMemoryContext } from "../memory/auto.ts";
-
-// The system prompt is assembled from modular sections: static segments first,
-// then a dynamic environment block. Static sections (identity, tone, tool
-// policy) come first so they stay byte-stable across turns and cache well; the
-// dynamic environment block (cwd, git status, snapshot) comes last. `buildSystemPrompt`
-// stays a pure synchronous string builder — the only I/O is reading project files and
-// the soft git/dir probes in projectInfo.ts.
-
-const IDENTITY = `You are Privateer, a provider-agnostic terminal coding agent. You help with software \
-engineering tasks directly from the user's terminal, with the same working style as a senior \
-engineer pairing over a shared shell.`;
-
-const TONE = `Tone and style:
-- Be concise and direct. Minimize preamble and postamble — no "Sure!", no "Here is what I'll do" \
-unless asked. Let your actions and their results speak.
-- Prefer doing over explaining. When a task is clear, use your tools to accomplish it rather than \
-describing how the user could.
-- Keep prose short. Answer the question that was asked; don't volunteer tangents.
-- When you finish a task, stop. Don't summarize work the user just watched you do.`;
-
-const SECURITY = `Security:
-- Assist with defensive security, debugging, and legitimate engineering. Refuse to help create or \
-improve malware, exploits aimed at systems the user doesn't own, or other clearly malicious uses.
-- Never expose or exfiltrate secrets. Don't print API keys or credentials you encounter.`;
-
-const TOOL_POLICY = `Using your tools:
-- Explore before you change: use 'glob' to find files by name and 'grep' to search contents. \
-Read a file with 'read' before editing it.
-- Prefer 'edit' (exact-string replace) over 'write' for changes to existing files; reserve 'write' \
-for new files or full rewrites.
-- Batch independent reads/searches rather than going one at a time.
-- For multi-step work, call 'todo' to lay out and track the plan; keep exactly one item \
-in_progress and mark items completed as you finish them. This keeps the user oriented.
-- For broad, open-ended search or investigation, delegate to a 'task' sub-agent so the details \
-stay out of the main conversation; it returns just a summary.
-- Use 'bash' for builds, tests, git, and other CLI work. Avoid long-running or interactive commands.
-- Each tool call is a separate model round-trip, so chain related shell steps into one \
-'bash' call with '&&' rather than firing them one at a time (e.g. \
-'git add -A && git commit -m "…" && git push', not three calls). Keep commands you need \
-to inspect the output of (a failing test, a diff you'll act on) separate.
-- Scope a commit to how the user asked. An unqualified "commit" / "commit and push" means the \
-whole working tree (stage all changes) — not just files you touched this turn. A scoped request \
-("commit the README", "commit the screenshot") means stage only what that names. When an \
-unqualified commit would sweep in a lot of unrelated changes, say what you're including in one line \
-before doing it.
-- When you create a git commit, end the message with a blank line followed by this trailer so the \
-work is attributed to Privateer as a co-author:
-  Co-Authored-By: Privateer <291203302+privateer-first-mate@users.noreply.github.com>
-- Use 'web_fetch' to read a known URL when the user provides one or you need current docs.
-- When the implementation direction is genuinely ambiguous and the choice materially shapes the \
-work — a structural/architectural fork, which library or data model to adopt, the scope of a \
-change — don't silently guess. Lay out the realistic approaches and call 'ask_user' to let the \
-user pick (2–4 options, most-recommended first, each with its trade-offs). Reserve it for \
-consequential forks: for small, reversible choices, just make the call and proceed. After the \
-user chooses, build that direction without re-litigating it.
-- To try a risky or exploratory approach without disturbing the main tree, use 'worktree' to spin \
-up an isolated branch + working copy, do the work there, and let the user compare its diff before \
-keeping or discarding it.
-- Mutating actions (write/edit/bash) may require user approval; that's expected — proceed and let \
-the gate handle it.`;
-
-const MEMORY = `Memory:
-- You have a persistent memory across sessions. When an index of saved memories is \
-present below, treat each line as something you already know; read the named .md file \
-with 'read' when an entry looks relevant to the current task.
-- Use the 'memory' tool to record durable facts worth remembering long-term: stable user \
-preferences, project conventions, and feedback on how to work — not transient details \
-about the current task. Prefer updating an existing memory (reuse its name) over \
-creating a near-duplicate. Default to project scope; use global only for facts that hold \
-across every project.`;
-
-const RECAP = `Recaps:
-- End every response with a single final line that begins with "recap: " — one plain-language \
-sentence summarizing what the user has accomplished so far this session (their goals and the \
-changes they've driven), not a restatement of what you just did. Keep it to one line; if nothing \
-has happened yet, recap the user's stated goal.`;
-
-const PLAN_MODE = `Plan mode is active. Your write, edit, and bash tools are disabled — do not attempt to \
-modify files or run commands. Investigate with read, glob, and grep, then present a clear, \
-step-by-step implementation plan as your final message. Do not start implementing; wait for the \
-user to approve the plan first.`;
-
-export interface SystemPromptOptions {
-  cwd: string;
-  model: string;
-  // Optional output-style body: replaces the default tone/persona section.
-  outputStyleBody?: string;
-  // When true, append the plan-mode mandate (read-only, produce a plan).
-  planMode?: boolean;
-}
-
-// System prompt for a `task` sub-agent: same environment grounding, but a read-only,
-// report-back mandate. It shares the parent's identity/security stance but swaps the
-// tool policy for the restricted subset.
-export function buildSubAgentPrompt(opts: SystemPromptOptions & { description: string }): string {
-  return [
-    IDENTITY,
-    SECURITY,
-    `You are running as a read-only sub-agent for the task: "${opts.description}".`,
-    `You have read, glob, and grep only — you cannot modify files or run commands. Investigate ` +
-      `thoroughly and efficiently, then return a concise, self-contained summary of your findings ` +
-      `(reference concrete file paths and line numbers). Do not ask the user questions; you run ` +
-      `autonomously and your final message is your whole report.`,
-    `Environment:\n- cwd: ${opts.cwd}\n- platform: ${process.platform}`,
-  ].join("\n\n");
-}
-
-// System prompt for a user-defined sub-agent: the agent's own instructions plus the
-// shared identity/security stance and an autonomous report-back mandate.
-export function buildAgentPrompt(
-  opts: SystemPromptOptions & { description: string; instructions: string },
-): string {
-  return [
-    IDENTITY,
-    opts.instructions,
-    SECURITY,
-    `You are running as a sub-agent for the task: "${opts.description}". Work autonomously and ` +
-      `return a concise, self-contained final report (reference concrete file paths). Do not ask ` +
-      `the user questions — your final message is your whole report.`,
-    `Environment:\n- cwd: ${opts.cwd}\n- platform: ${process.platform}`,
-  ].join("\n\n");
-}
-
-export function buildSystemPrompt(opts: SystemPromptOptions): string {
-  // An active output style replaces the default tone/persona section.
-  const persona = opts.outputStyleBody?.trim() || TONE;
-  const parts: string[] = [IDENTITY, persona, SECURITY, TOOL_POLICY, MEMORY, RECAP];
-  if (opts.planMode) parts.push(PLAN_MODE);
-
-  // --- Dynamic environment section ---
-  const env: string[] = [
-    `Environment:`,
-    `- cwd: ${opts.cwd}`,
-    `- model: ${opts.model}`,
-    `- launched in: ${process.cwd()}`,
-    `- platform: ${process.platform}`,
-    `- date: ${new Date().toISOString().slice(0, 10)}`,
-    `\nTreat cwd as the project scope: interpret relative paths from it and keep your ` +
-      `exploration, searches, and edits inside it. The file tools are confined to cwd — a path ` +
-      `that resolves outside it (an absolute path elsewhere, a sibling directory, or a '../' ` +
-      `escape) is blocked unless the user has explicitly asked you to work there, in which case ` +
-      `they'll be prompted to approve it. Don't reach outside cwd on your own; if a task seems to ` +
-      `need a file outside it, ask the user rather than guessing.`,
-  ];
-
-  const git = gitStatus(opts.cwd);
-  if (git) {
-    env.push(`- git branch: ${git.branch}`);
-    env.push(`\nGit status (porcelain):\n${git.status}`);
-    if (git.recent) env.push(`\nRecent commits:\n${git.recent}`);
-  }
-
-  const snapshot = dirSnapshot(opts.cwd);
-  if (snapshot) env.push(`\nProject files (partial):\n${snapshot}`);
-
-  parts.push(env.join("\n"));
-
-  // Project context file, our CLAUDE.md analog. Loaded last so user-authored
-  // standing instructions carry the most weight.
-  const ctxFile = join(opts.cwd, "PRIVATEER.md");
-  if (existsSync(ctxFile)) {
-    parts.push(`Project context from PRIVATEER.md:\n${readFileSync(ctxFile, "utf8").trim()}`);
-  }
-
-  // Recalled memory index, our auto-memory analog. Read a listed .md for full detail.
-  const memory = loadMemoryContext(opts.cwd);
-  if (memory) {
-    parts.push(`Persistent memory (index — read a file for detail):\n${memory}`);
-  }
-
-  return parts.join("\n\n");
-}

package/src/engine/QueryEngine.ts

@@ -1,399 +0,0 @@
-import {
-  streamText,
-  generateText,
-  generateObject,
-  stepCountIs,
-  type ModelMessage,
-  type ToolSet,
-} from "ai";
-import { z } from "zod";
-import { type EngineEvent, type UsageTotals, emptyUsage, addUsage } from "./events.ts";
-import { type RouteSet, selectRoute, requiredModalities } from "./router.ts";
-import { redactText } from "../util/redact.ts";
-import { describeError, type DescribedError } from "./errors.ts";
-
-// Structured shape for compaction so the summary preserves the parts that matter for
-// continuing the work, rather than a free-form blob.
-const CompactionSchema = z.object({
-  goals: z.string().describe("The user's overall goals for this session."),
-  decisions: z.array(z.string()).describe("Key decisions, approaches, and findings so far."),
-  filesTouched: z.array(z.string()).describe("File paths created or modified, each with a short note."),
-  openThreads: z.array(z.string()).describe("Unfinished tasks, next steps, and open questions."),
-});
-
-export function formatCompaction(o: z.infer<typeof CompactionSchema>): string {
-  const list = (items: string[]) => (items.length ? items.map((i) => `- ${i}`).join("\n") : "- (none)");
-  return [
-    `Goals: ${o.goals}`,
-    `Decisions:\n${list(o.decisions)}`,
-    `Files touched:\n${list(o.filesTouched)}`,
-    `Open threads:\n${list(o.openThreads)}`,
-  ].join("\n\n");
-}
-
-export interface QueryEngineOptions {
-  // The model routes for this session. `routes.default` is always used unless a
-  // turn's data/shape selects a specialized route (see src/engine/router.ts).
-  // Per-route flags (cacheControl/thinkingBudget) travel on each Route. Compaction
-  // always runs on the default route.
-  routes: RouteSet;
-  system: string;
-  tools: ToolSet;
-  maxSteps: number;
-  // Approx token budget; when the estimated context exceeds budget*ratio before a
-  // turn, older history is summarized away. 0/undefined disables auto-compaction.
-  contextBudget?: number;
-  compactRatio?: number;
-}
-
-// Number of most-recent messages kept verbatim when compacting.
-const KEEP_RECENT = 6;
-
-// How many times to auto-retry a turn that failed transiently (rate limit, 5xx,
-// network) before any output streamed. Fatal errors (auth/billing/data-policy/bad
-// model) are never retried — describeError leaves their `retryable` flag unset.
-const MAX_RETRIES = 3;
-
-// The agent loop. Each `send` streams one user turn through the model, letting the
-// AI SDK run the multi-step tool loop internally (executing our tools' execute()),
-// while we translate the raw stream into normalized EngineEvents and accumulate usage.
-// History persists on the instance so follow-up turns keep context. A turn can be
-// interrupted via an AbortSignal; partial output is still persisted to history.
-export class QueryEngine {
-  readonly messages: ModelMessage[] = [];
-  usage: UsageTotals = emptyUsage();
-
-  constructor(private readonly opts: QueryEngineOptions) {}
-
-  // Current context-window occupancy: estimated tokens in history over the budget
-  // that triggers compaction. Drives the Claude-Code-style "% of context" readout.
-  // `budget` is 0 when auto-compaction is disabled.
-  contextUsage(): { used: number; budget: number } {
-    return { used: estimateTokens(this.messages), budget: this.opts.contextBudget ?? 0 };
-  }
-
-  async *send(
-    userText: string,
-    signal?: AbortSignal,
-    attachments?: { data: string; mediaType: string; modality?: string }[],
-  ): AsyncGenerator<EngineEvent, void, void> {
-    // Auto-compact before the turn if the context has grown past the budget.
-    if (this.shouldCompact()) {
-      const res = await this.compact();
-      if (res) yield { type: "compacted", before: res.before, after: res.after };
-    }
-
-    if (attachments && attachments.length > 0) {
-      this.messages.push({
-        role: "user",
-        content: [
-          { type: "text", text: userText },
-          // Images go as image parts; documents/audio/video as generic file parts.
-          ...attachments.map((a) =>
-            a.modality === "image" || a.mediaType.startsWith("image/")
-              ? ({ type: "image" as const, image: a.data, mediaType: a.mediaType })
-              : ({ type: "file" as const, data: a.data, mediaType: a.mediaType })),
-        ],
-      });
-    } else {
-      this.messages.push({ role: "user", content: userText });
-    }
-
-    // Pick the model for this turn from its data/shape. Modality requirements are
-    // sticky over the whole conversation so attachment history never gets replayed to
-    // a model that can't accept it.
-    const sel = selectRoute(this.opts.routes, {
-      modalities: requiredModalities(this.messages),
-      estTokens: estimateTokens(this.messages),
-      promptChars: userText.length,
-    });
-    if (sel.name !== "default" || (sel.missing && sel.missing.length > 0)) {
-      yield {
-        type: "routed",
-        route: sel.name,
-        label: sel.route.label,
-        reason: sel.reason,
-        missing: sel.missing,
-      };
-    }
-    const route = sel.route;
-
-    let result;
-    try {
-      result = streamText({
-        model: route.model,
-        system: this.opts.system,
-        messages: route.cacheControl ? withCacheBreakpoints(this.messages) : this.messages,
-        tools: this.opts.tools,
-        stopWhen: stepCountIs(this.opts.maxSteps),
-        abortSignal: signal,
-        // Re-place the rolling cache breakpoint on every internal tool-loop step.
-        // streamText runs the multi-step loop itself, appending tool-call/result
-        // messages between API calls; without this the breakpoint stays on the
-        // pre-loop tail, so each step's accumulating tool output is re-sent at full
-        // price. Marking the new last message each step caches the prefix the
-        // previous step already sent. (No-op for non-Anthropic routes.)
-        prepareStep: route.cacheControl
-          ? ({ messages }) => ({ messages: withCacheBreakpoints(messages) })
-          : undefined,
-        providerOptions: route.thinkingBudget
-          ? { anthropic: { thinking: { type: "enabled", budgetTokens: route.thinkingBudget } } }
-          : undefined,
-      });
-    } catch (err) {
-      const d = describeError(err);
-      yield { type: "error", error: d.message, hint: d.hint, retryable: d.retryable };
-      return;
-    }
-
-    // The AI SDK exposes several derived promises that reject lazily when the
-    // stream errors. We await some below in their own try/catch, but any we
-    // never touch would surface as an unhandled rejection — which Node dumps,
-    // unredacted, to the terminal (scrambling the TUI and leaking the request
-    // body). Attach no-op catches so a stream error stays inside our channel.
-    for (const key of ["text", "steps", "warnings", "sources", "files", "reasoning"] as const) {
-      const p = (result as unknown as Record<string, unknown>)[key];
-      if (p && typeof (p as Promise<unknown>).then === "function") {
-        (p as Promise<unknown>).catch(() => {});
-      }
-    }
-
-    let assistantText = "";
-    let aborted = false;
-    // Track usage as steps finish so the UI can tick the token count up live,
-    // instead of jumping only when the whole turn ends. `totalUsage` reconciles
-    // the authoritative number at finish.
-    const baseline = this.usage;
-    let stepsUsage = emptyUsage();
-
-    try {
-      for await (const part of result.fullStream) {
-        switch (part.type) {
-          case "text-delta":
-            if (part.text) {
-              assistantText += part.text;
-              yield { type: "text", text: part.text };
-            }
-            break;
-          case "reasoning-delta":
-            if (part.text) yield { type: "reasoning", text: part.text };
-            break;
-          case "tool-call":
-            yield { type: "tool-call", id: part.toolCallId, name: part.toolName, input: part.input };
-            break;
-          case "tool-result":
-            yield {
-              type: "tool-result",
-              id: part.toolCallId,
-              name: part.toolName,
-              output: (part as { output: unknown }).output,
-            };
-            break;
-          case "tool-error":
-            yield {
-              type: "tool-error",
-              id: part.toolCallId,
-              name: part.toolName,
-              error: errMsg((part as { error: unknown }).error),
-            };
-            break;
-          case "finish-step": {
-            const u = (part as { usage?: Partial<UsageTotals> }).usage;
-            if (u) {
-              stepsUsage = addUsage(stepsUsage, {
-                inputTokens: u.inputTokens ?? 0,
-                outputTokens: u.outputTokens ?? 0,
-                totalTokens: u.totalTokens ?? 0,
-                cachedInputTokens: u.cachedInputTokens ?? 0,
-              });
-              this.usage = addUsage(baseline, stepsUsage);
-              yield { type: "usage", usage: this.usage, turn: stepsUsage };
-            }
-            yield { type: "step-finish" };
-            break;
-          }
-          case "abort":
-            aborted = true;
-            break;
-          case "error": {
-            const d = describeError(part.error);
-            yield { type: "error", error: d.message, hint: d.hint, retryable: d.retryable };
-            break;
-          }
-        }
-      }
-    } catch (err) {
-      if (signal?.aborted || isAbortError(err)) {
-        aborted = true;
-      } else {
-        const d = describeError(err);
-        yield { type: "error", error: d.message, hint: d.hint, retryable: d.retryable };
-        return;
-      }
-    }
-
-    // Persist the model's response so the next turn keeps context. On a clean finish
-    // we use the SDK's structured messages; on an interrupt those may be unavailable,
-    // so we fall back to a synthetic assistant message from the text we streamed.
-    let persisted = false;
-    try {
-      const response = await result.response;
-      if (response?.messages?.length) {
-        this.messages.push(...response.messages);
-        persisted = true;
-      }
-    } catch {
-      /* aborted/errored before a response was assembled */
-    }
-    if (!persisted && assistantText.trim()) {
-      this.messages.push({ role: "assistant", content: assistantText });
-    }
-
-    if (aborted) {
-      yield { type: "aborted" };
-      return;
-    }
-
-    const turnUsage = await result.totalUsage.catch(() => ({}) as Record<string, number>);
-    const usage: UsageTotals = {
-      inputTokens: turnUsage.inputTokens ?? 0,
-      outputTokens: turnUsage.outputTokens ?? 0,
-      totalTokens: turnUsage.totalTokens ?? 0,
-      cachedInputTokens: turnUsage.cachedInputTokens ?? 0,
-    };
-    // Reconcile against the authoritative turn total. We already folded per-step
-    // usage into this.usage live; rebase on the baseline so we don't double-count.
-    // Fall back to the accumulated step usage if the provider omitted totalUsage.
-    this.usage = addUsage(baseline, usage.totalTokens > 0 ? usage : stepsUsage);
-
-    const finishReason = await result.finishReason.catch(() => "unknown");
-    yield { type: "finish", usage, finishReason };
-  }
-
-  private shouldCompact(): boolean {
-    const budget = this.opts.contextBudget;
-    if (!budget) return false;
-    const ratio = this.opts.compactRatio ?? 0.8;
-    return this.messages.length > KEEP_RECENT && estimateTokens(this.messages) > budget * ratio;
-  }
-
-  // Summarize older history into a single briefing message, keeping the most recent
-  // messages verbatim. Uses a schema-guided summary (goals / decisions / files /
-  // open threads) so the structure survives, falling back to a plain-text summary if
-  // structured output fails. The cut always lands on a `user` message so tool-call /
-  // result pairs are never orphaned. Returns before/after token estimates, or null
-  // when there's nothing worth compacting. Best-effort: failures leave history intact.
-  async compact(): Promise<{ before: number; after: number } | null> {
-    const before = estimateTokens(this.messages);
-    const cut = safeCutIndex(this.messages, KEEP_RECENT);
-    if (cut <= 0) return null;
-
-    const older = this.messages.slice(0, cut);
-    const recent = this.messages.slice(cut);
-    const transcript = older.map((m) => `${m.role}: ${renderContent(m.content)}`).join("\n\n");
-    const instruction =
-      `Summarize the earlier part of this coding session so the work can continue without the ` +
-      `full history. Be specific and terse.\n\n---\n${transcript}`;
-
-    let summary: string;
-    try {
-      const { object } = await generateObject({
-        model: this.opts.routes.default.model,
-        schema: CompactionSchema,
-        prompt: instruction,
-      });
-      summary = formatCompaction(object);
-    } catch {
-      // Some models/providers handle structured output poorly — fall back to text.
-      try {
-        const { text } = await generateText({ model: this.opts.routes.default.model, prompt: instruction });
-        summary = text.trim();
-      } catch {
-        return null; // leave history untouched on failure
-      }
-    }
-    if (!summary) return null;
-
-    this.messages.length = 0;
-    this.messages.push({ role: "user", content: `[Summary of earlier conversation]\n${summary}` });
-    this.messages.push(...recent);
-
-    return { before, after: estimateTokens(this.messages) };
-  }
-}
-
-// Cheap heuristic token estimate (~4 chars/token) over serialized message content.
-export function estimateTokens(messages: ModelMessage[]): number {
-  let chars = 0;
-  for (const m of messages) chars += renderContent(m.content).length + m.role.length;
-  return Math.ceil(chars / 4);
-}
-
-// Choose a cut so the kept tail starts on a `user` message — never orphaning a tool
-// result from its tool-call. Returns 0 when there's nothing safe to drop.
-function safeCutIndex(messages: ModelMessage[], minKeep: number): number {
-  let cut = messages.length - minKeep;
-  if (cut <= 0) return 0;
-  while (cut < messages.length && messages[cut].role !== "user") cut++;
-  return cut >= messages.length ? 0 : cut;
-}
-
-function renderContent(content: unknown): string {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((p) => {
-        const part = p as { type?: string; text?: string; toolName?: string };
-        if (part.type === "text" && part.text) return part.text;
-        if (part.type === "tool-call") return `[tool-call ${part.toolName ?? ""}]`;
-        if (part.type === "tool-result") return `[tool-result ${part.toolName ?? ""}]`;
-        return `[${part.type ?? "part"}]`;
-      })
-      .join(" ");
-  }
-  return "";
-}
-
-// Attach Anthropic ephemeral cache breakpoints. Anthropic caches the longest prefix
-// ending at a breakpoint, so we mark the first message (stable base: system + tools +
-// first turn) and the last message (rolling: grows with the conversation). Returns a
-// shallow copy so the stored history stays free of provider-specific annotations.
-const CACHE = { anthropic: { cacheControl: { type: "ephemeral" } } } as const;
-
-function withCacheBreakpoints(messages: ModelMessage[]): ModelMessage[] {
-  if (messages.length === 0) return messages;
-  const out = messages.slice();
-  markBreakpoint(out, 0);
-  if (out.length > 1) markBreakpoint(out, out.length - 1);
-  return out;
-}
-
-function markBreakpoint(messages: ModelMessage[], i: number): void {
-  const msg = messages[i] as { role: string; content: unknown };
-  const parts =
-    typeof msg.content === "string"
-      ? [{ type: "text", text: msg.content }]
-      : (msg.content as unknown[]).slice();
-  if (parts.length === 0) return;
-  const last = parts.length - 1;
-  parts[last] = { ...(parts[last] as object), providerOptions: CACHE };
-  messages[i] = { ...msg, content: parts } as unknown as ModelMessage;
-}
-
-function isAbortError(err: unknown): boolean {
-  return err instanceof Error && (err.name === "AbortError" || /abort/i.test(err.message));
-}
-
-function errMsg(err: unknown): string {
-  return redactText(rawErrMsg(err));
-}
-
-function rawErrMsg(err: unknown): string {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}