@hicaru/pi-rlm 0.1.0

package/src/config/settings.ts

@@ -0,0 +1,185 @@
+/** Persist RLM settings (tunable config + chosen worker model id). */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getAgentDir, type ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+import type { RlmConfig, RunLogConfig, TelemetryConfig } from "../core/types.ts";
+import { DEFAULT_CONFIG } from "./defaults.ts";
+
+export interface PersistedSettings {
+  readonly config: Partial<RlmConfig>;
+  readonly worker?: string;
+}
+
+type MutablePartialRlmConfig = { -readonly [K in keyof RlmConfig]?: RlmConfig[K] };
+
+function settingsPath(): string {
+  return join(getAgentDir(), "rlm.json");
+}
+
+function validateNumber(v: unknown, min: number): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) && v >= min ? v : undefined;
+}
+
+function validateBoolean(v: unknown): boolean | undefined {
+  return typeof v === "boolean" ? v : undefined;
+}
+
+function validateString(v: unknown): string | undefined {
+  return typeof v === "string" && v.trim() ? v : undefined;
+}
+
+function validateTelemetry(raw: unknown): TelemetryConfig | undefined {
+  if (typeof raw !== "object" || raw === null) return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: {
+    enabled?: boolean;
+    trackingUri?: string;
+    experimentId?: string;
+    maxQueueSize?: number;
+  } = {};
+  const enabled = validateBoolean(r.enabled);
+  if (enabled !== undefined) out.enabled = enabled;
+  const trackingUri = validateString(r.trackingUri);
+  if (trackingUri !== undefined) out.trackingUri = trackingUri;
+  const experimentId = validateString(r.experimentId);
+  if (experimentId !== undefined) out.experimentId = experimentId;
+  const maxQueueSize = validateNumber(r.maxQueueSize, 1);
+  if (maxQueueSize !== undefined) out.maxQueueSize = maxQueueSize;
+  return Object.freeze(out);
+}
+
+function validateRunLog(raw: unknown): Partial<RunLogConfig> | undefined {
+  if (typeof raw !== "object" || raw === null) return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: { enabled?: boolean; dir?: string; snapshot?: boolean; maxRuns?: number } = {};
+  const enabled = validateBoolean(r.enabled);
+  if (enabled !== undefined) out.enabled = enabled;
+  const dir = validateString(r.dir);
+  if (dir !== undefined) out.dir = dir;
+  const snapshot = validateBoolean(r.snapshot);
+  if (snapshot !== undefined) out.snapshot = snapshot;
+  const maxRuns = validateNumber(r.maxRuns, 1);
+  if (maxRuns !== undefined) out.maxRuns = maxRuns;
+  return Object.keys(out).length > 0 ? Object.freeze(out) : undefined;
+}
+
+function validateConfig(raw: unknown): Partial<RlmConfig> {
+  if (typeof raw !== "object" || raw === null) return {};
+  const r = raw as Record<string, unknown>;
+  const out: MutablePartialRlmConfig = {};
+  const enabled = validateBoolean(r.enabled);
+  if (enabled !== undefined) out.enabled = enabled;
+  const maxDepth = validateNumber(r.maxDepth, 1);
+  if (maxDepth !== undefined) out.maxDepth = maxDepth;
+  const maxIterations = validateNumber(r.maxIterations, 1);
+  if (maxIterations !== undefined) out.maxIterations = maxIterations;
+  const execTimeoutS = validateNumber(r.execTimeoutS, 1);
+  if (execTimeoutS !== undefined) out.execTimeoutS = execTimeoutS;
+  const requestTimeoutMs = validateNumber(r.requestTimeoutMs, 1000);
+  if (requestTimeoutMs !== undefined) out.requestTimeoutMs = requestTimeoutMs;
+  const maxConcurrentSubcalls = validateNumber(r.maxConcurrentSubcalls, 1);
+  if (maxConcurrentSubcalls !== undefined) out.maxConcurrentSubcalls = maxConcurrentSubcalls;
+  const maxPromptChars = validateNumber(r.maxPromptChars, 1000);
+  if (maxPromptChars !== undefined) out.maxPromptChars = maxPromptChars;
+  const maxBudgetUsd = validateNumber(r.maxBudgetUsd, 0.01);
+  if (maxBudgetUsd !== undefined) out.maxBudgetUsd = maxBudgetUsd;
+  const maxTimeoutMs = validateNumber(r.maxTimeoutMs, 1000);
+  if (maxTimeoutMs !== undefined) out.maxTimeoutMs = maxTimeoutMs;
+  const maxTokens = validateNumber(r.maxTokens, 1);
+  if (maxTokens !== undefined) out.maxTokens = maxTokens;
+  const maxErrors = validateNumber(r.maxErrors, 1);
+  if (maxErrors !== undefined) out.maxErrors = maxErrors;
+  const orchestrator = validateBoolean(r.orchestrator);
+  if (orchestrator !== undefined) out.orchestrator = orchestrator;
+  const compaction = validateBoolean(r.compaction);
+  if (compaction !== undefined) out.compaction = compaction;
+  const compactionThresholdPct = validateNumber(r.compactionThresholdPct, 0);
+  if (compactionThresholdPct !== undefined && compactionThresholdPct <= 1) out.compactionThresholdPct = compactionThresholdPct;
+  const python = validateString(r.python);
+  if (python !== undefined) out.python = python;
+  if (typeof r.smartReasoning === "string") out.smartReasoning = r.smartReasoning as ThinkingLevel;
+  const subSystemPrompt = validateString(r.subSystemPrompt);
+  if (subSystemPrompt !== undefined) out.subSystemPrompt = subSystemPrompt;
+  const telemetry = validateTelemetry(r.telemetry);
+  if (telemetry) out.telemetry = telemetry;
+  const runLog = validateRunLog(r.runLog);
+  if (runLog) out.runLog = runLog;
+  const sandboxInitTimeoutMs = validateNumber(r.sandboxInitTimeoutMs, 100);
+  if (sandboxInitTimeoutMs !== undefined) out.sandboxInitTimeoutMs = sandboxInitTimeoutMs;
+  const askUserQuestion = validateBoolean(r.askUserQuestion);
+  if (askUserQuestion !== undefined) out.askUserQuestion = askUserQuestion;
+  const todo = validateBoolean(r.todo);
+  if (todo !== undefined) out.todo = todo;
+  if (typeof r.subSampling === "object" && r.subSampling !== null) {
+    const ss = r.subSampling as Record<string, unknown>;
+    const sampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};
+    const maxTokensValue = validateNumber(ss.maxTokens, 1);
+    if (maxTokensValue !== undefined) sampling.maxTokens = maxTokensValue;
+    const temperature = validateNumber(ss.temperature, 0);
+    if (temperature !== undefined) sampling.temperature = temperature;
+    if (typeof ss.reasoning === "string") sampling.reasoning = ss.reasoning as ThinkingLevel;
+    out.subSampling = sampling;
+  }
+  if (typeof r.rootSampling === "object" && r.rootSampling !== null) {
+    const rs = r.rootSampling as Record<string, unknown>;
+    const rootSampling: { maxTokens?: number; temperature?: number; reasoning?: ThinkingLevel } = {};
+    const rsMaxTokens = validateNumber(rs.maxTokens, 1);
+    if (rsMaxTokens !== undefined) rootSampling.maxTokens = rsMaxTokens;
+    const rsTemperature = validateNumber(rs.temperature, 0);
+    if (rsTemperature !== undefined) rootSampling.temperature = rsTemperature;
+    if (typeof rs.reasoning === "string") rootSampling.reasoning = rs.reasoning as ThinkingLevel;
+    out.rootSampling = Object.freeze(rootSampling);
+  }
+  return out;
+}
+
+export async function loadSettings(): Promise<PersistedSettings> {
+  try {
+    const raw = JSON.parse(await readFile(settingsPath(), "utf8")) as unknown;
+    if (typeof raw !== "object" || raw === null) return { config: {} };
+    const r = raw as Record<string, unknown>;
+    return {
+      config: validateConfig(r.config),
+      worker: typeof r.worker === "string" ? r.worker : undefined,
+    };
+  } catch {
+    return { config: {} };
+  }
+}
+
+export async function saveSettings(s: PersistedSettings): Promise<boolean> {
+  try {
+    const p = settingsPath();
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, `${JSON.stringify(s, null, 2)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Merge persisted tunables over the defaults. */
+export function mergeConfig(partial: Partial<RlmConfig>): RlmConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    ...partial,
+    subSampling: { ...DEFAULT_CONFIG.subSampling, ...partial.subSampling },
+    rootSampling: Object.freeze({ ...DEFAULT_CONFIG.rootSampling, ...partial.rootSampling }),
+    ...(partial.telemetry ? { telemetry: Object.freeze({ ...partial.telemetry }) } : {}),
+    ...(partial.runLog ? { runLog: Object.freeze({ ...DEFAULT_CONFIG.runLog, ...partial.runLog }) } : {}),
+  };
+}
+
+/** Resolve a "provider/id" string against the registry. */
+export function resolveModelId(registry: ModelRegistry, ref?: string): Model<Api> | undefined {
+  if (!ref) return undefined;
+  const slash = ref.indexOf("/");
+  if (slash < 0) return undefined;
+  return registry.find(ref.slice(0, slash), ref.slice(slash + 1));
+}
+
+export function modelRef(model: Model<Api> | undefined): string | undefined {
+  return model ? `${model.provider}/${model.id}` : undefined;
+}

package/src/context/repomix-context.ts

@@ -0,0 +1,253 @@
+/**
+ * repomix-context — pre-packs the entire codebase into a structured JSON array
+ * for the RLM sandbox. Replaces the legacy filesystem-tool context
+ * (buildProjectManifest / listProjectFiles / gitLsFiles).
+ *
+ * Uses repomix internally (worker-thread pool, built-in gitignore support)
+ * and caches results in a module-level Map with TTL to avoid re-packing on
+ * every run within the same process. `patchContextAfterEdits` updates the
+ * cached bundle in-memory after file edits are applied to disk — no re-packing.
+ */
+
+import { pack } from "repomix";
+import type { PackResult as RepomixPackResult } from "repomix";
+import { resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { errorMessage } from "../util/errors.ts";
+
+// ── Public types ──
+
+export interface ContextFile {
+  readonly path: string;
+  readonly content: string;
+  readonly tokens: number;
+}
+
+export interface ContextBundle {
+  readonly files: readonly ContextFile[];
+  readonly totalFiles: number;
+  readonly totalTokens: number;
+  readonly totalChars: number;
+}
+
+export interface PackSuccess {
+  readonly ok: true;
+  readonly value: ContextBundle;
+}
+
+export interface PackFailure {
+  readonly ok: false;
+  readonly error: string;
+}
+
+export type PackResult = PackSuccess | PackFailure;
+
+// ── Module-level cache ──
+
+interface CacheEntry {
+  readonly bundle: ContextBundle;
+  readonly ts: number;
+}
+
+const cache = new Map<string, CacheEntry>();
+const DEFAULT_CACHE_TTL_MS = 30_000;
+
+/** Exported for tests — empties the module-level cache. */
+export function clearCache(): void {
+  cache.clear();
+}
+
+function cacheKey(cwd: string): string {
+  return resolve(cwd);
+}
+
+function cacheGet(key: string, ttlMs: number): ContextBundle | undefined {
+  const entry = cache.get(key);
+  if (!entry) return undefined;
+  if (Date.now() - entry.ts > ttlMs) {
+    cache.delete(key);
+    return undefined;
+  }
+  return entry.bundle;
+}
+
+function cacheSet(key: string, bundle: ContextBundle): void {
+  cache.set(key, { bundle, ts: Date.now() });
+}
+
+// ── Core functions ──
+
+const ESTIMATED_CHARS_PER_TOKEN = 4;
+
+export async function packRepository(
+  cwd: string,
+  signal?: AbortSignal,
+  ttlMs: number = DEFAULT_CACHE_TTL_MS,
+): Promise<PackResult> {
+  if (signal?.aborted) return { ok: false, error: "aborted" };
+
+  const key = cacheKey(cwd);
+  const cached = cacheGet(key, ttlMs);
+  if (cached) return { ok: true, value: cached };
+
+  try {
+    const result: RepomixPackResult = await Promise.race([
+      pack([cwd], {
+        input: { maxFileSize: 1048576 },
+        cwd,
+        output: {
+          filePath: `${tmpdir()}/repomix-out-${Date.now()}.txt`,
+          style: "plain",
+          parsableStyle: false,
+          headerText: undefined,
+          instructionFilePath: undefined,
+          fileSummary: false,
+          directoryStructure: false,
+          files: true,
+          removeComments: false,
+          removeEmptyLines: false,
+          compress: false,
+          topFilesLength: 5,
+          showLineNumbers: false,
+          truncateBase64: false,
+          copyToClipboard: false,
+          includeEmptyDirectories: undefined,
+          includeFullDirectoryStructure: false,
+          splitOutput: undefined,
+          tokenCountTree: false,
+          tokenBudget: undefined,
+          git: {
+            sortByChanges: true,
+            sortByChangesMaxCommits: 100,
+            includeDiffs: false,
+            includeLogs: false,
+            includeLogsCount: 50,
+          },
+        },
+        include: [],
+        ignore: {
+          useGitignore: true,
+          useDotIgnore: true,
+          useDefaultPatterns: true,
+          customPatterns: [],
+        },
+        security: { enableSecurityCheck: false },
+        tokenCount: { encoding: "o200k_base" as const },
+      } as Parameters<typeof pack>[1]),
+      new Promise<never>((_, reject) => {
+        signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+      }),
+    ]);
+
+    const processedFiles = result.processedFiles;
+    const files = new Array<ContextFile>(processedFiles.length);
+    const tokenCounts = result.fileTokenCounts;
+    let totalTokens = 0;
+    let totalChars = 0;
+
+    for (let i = 0; i < processedFiles.length; i++) {
+      const file = processedFiles[i];
+      const tokens = tokenCounts[file.path]
+        ?? Math.ceil(file.content.length / ESTIMATED_CHARS_PER_TOKEN);
+      files[i] = { path: file.path, content: file.content, tokens };
+      totalTokens += tokens;
+      totalChars += file.content.length;
+    }
+
+    const bundle: ContextBundle = {
+      files,
+      totalFiles: files.length,
+      totalTokens,
+      totalChars,
+    };
+    cacheSet(key, bundle);
+    return { ok: true, value: bundle };
+  } catch (err: unknown) {
+    if (signal?.aborted) return { ok: false, error: "aborted" };
+    return {
+      ok: false,
+      error: errorMessage(err),
+    };
+  }
+}
+
+export function patchContextAfterEdits(
+  cached: ContextBundle,
+  edits: readonly { readonly path: string; readonly newContent: string }[],
+): ContextBundle {
+  const editMap = new Map<string, string>();
+  for (const edit of edits) {
+    editMap.set(edit.path, edit.newContent);
+  }
+
+  const files = new Array<ContextFile>(cached.files.length);
+  let totalTokens = 0;
+  let totalChars = 0;
+
+  for (let i = 0; i < cached.files.length; i++) {
+    const file = cached.files[i];
+    const newContent = editMap.get(file.path);
+    if (newContent !== undefined) {
+      const tokens = Math.ceil(newContent.length / ESTIMATED_CHARS_PER_TOKEN);
+      files[i] = { path: file.path, content: newContent, tokens };
+      totalTokens += tokens;
+      totalChars += newContent.length;
+    } else {
+      files[i] = file;
+      totalTokens += file.tokens;
+      totalChars += file.content.length;
+    }
+  }
+
+  return {
+    files,
+    totalFiles: files.length,
+    totalTokens,
+    totalChars,
+  };
+}
+
+export function serializeForSandbox(
+  bundle: ContextBundle,
+): readonly ContextFile[] {
+  return bundle.files;
+}
+
+/** Maximum files shown in the compact LLM listing before truncation. */
+const MAX_LLM_LISTING_FILES = 200;
+
+/**
+ * Produces a compact human-readable text block for the parent LLM's context window.
+ * Shows file paths and token estimates — NOT full file contents (those are too large
+ * for the context window). The LLM uses its file-reading tools to inspect specific files.
+ */
+export function formatForLLM(bundle: ContextBundle): string {
+  const files = bundle.files.slice(0, MAX_LLM_LISTING_FILES);
+  const truncated = bundle.totalFiles > MAX_LLM_LISTING_FILES
+    ? `... and ${bundle.totalFiles - MAX_LLM_LISTING_FILES} more files (truncated)`
+    : "";
+
+  const listing = files.map((f) =>
+    `${f.path} (${f.tokens.toLocaleString()} tok, ${f.content.length.toLocaleString()} chars)`,
+  ).join("\n");
+
+  return [
+    `Repository context: ${bundle.totalFiles.toLocaleString()} files, ${bundle.totalTokens.toLocaleString()} estimated tokens, ${bundle.totalChars.toLocaleString()} total characters.`,
+    "",
+    listing,
+    truncated,
+    "",
+    "To read a file, use the file-reading tools with the exact path.",
+  ].join("\n");
+}
+
+export function patchCachedContext(
+  cwd: string,
+  edits: readonly { readonly path: string; readonly newContent: string }[],
+): void {
+  const key = cacheKey(cwd);
+  const entry = cache.get(key);
+  if (!entry) return;
+  const patched = patchContextAfterEdits(entry.bundle, edits);
+  cache.set(key, { bundle: patched, ts: entry.ts });
+}

package/src/core/answer.ts

@@ -0,0 +1,97 @@
+/** Helpers for detecting and formatting the RLM final answer from a turn's REPL results. */
+
+import type { ProposedDiffEdit, ProposedEdit, ReplResult } from "../sandbox/protocol.ts";
+import { truncateOutput } from "../text/parsing.ts";
+
+/** First non-null final answer across a turn's executed blocks, or null. */
+export function finalAnswerOf(results: readonly ReplResult[]): string | null {
+  for (const r of results) if (r.finalAnswer != null) return r.finalAnswer;
+  return null;
+}
+
+/** Last non-empty answer content set by the REPL, even if answer.ready was not flipped. */
+export function latestAnswerContentOf(results: readonly ReplResult[]): string | null {
+  for (let i = results.length - 1; i >= 0; i--) {
+    const content = results[i]?.answerContent.trim();
+    if (content) return content;
+  }
+  return null;
+}
+
+/** Last cumulative legacy anchor proposed-edit set reported by a turn. */
+export function collectEdits(results: readonly ReplResult[]): ProposedEdit[] {
+  for (let i = results.length - 1; i >= 0; i--) {
+    const edits = results[i]?.edits;
+    if (edits && edits.length > 0) return [...edits];
+  }
+  return [];
+}
+
+/** Last cumulative diff proposal set reported by a turn. */
+export function collectDiffs(results: readonly ReplResult[]): ProposedDiffEdit[] {
+  for (let i = results.length - 1; i >= 0; i--) {
+    const diffs = results[i]?.diffs;
+    if (diffs && diffs.length > 0) return [...diffs];
+  }
+  return [];
+}
+
+/** Parses a ```diff fence from answer text; returns [] if none found. */
+export function tryExtractDiff(answer: string): ProposedDiffEdit[] {
+  const match = /```diff\n([\s\S]*?)```/.exec(answer);
+  if (!match) return [];
+  return [{ diff: match[1].trim() }];
+}
+
+/** True if any block in the turn raised an exception. Plain stderr does not count. */
+export function turnHadError(results: readonly ReplResult[]): boolean {
+  return results.some((r) => r.raised);
+}
+
+/** Max stdout kept verbatim in history. Larger outputs collapse to a small preview + elision note —
+ * the full content persists in REPL variables, never in the root model's history (Algorithm 1:
+ * hist ← hist ∥ code ∥ Metadata(stdout)). */
+const SMALL_STDOUT_LIMIT = 800;
+const STDOUT_PREVIEW_LIMIT = 200;
+const STDERR_LIMIT = 8_000;
+
+/** The REPL output fed back to the model as the next user message. */
+export function formatReplOutputs(results: readonly ReplResult[]): string {
+  if (results.length === 0) {
+    return "No ```repl``` block found in your response. Write one to interact with the REPL.";
+  }
+  const multi = results.length > 1;
+  const parts: string[] = [];
+  let hadElision = false;
+  for (const [i, r] of results.entries()) {
+    const head = multi ? `[block ${i + 1}]\n` : "";
+    const { text, elided } = formatStdout(r);
+    hadElision ||= elided;
+    parts.push(`${head}${text}${formatStderr(r)}`);
+  }
+  const body = parts.join("\n\n");
+  // Orientation hint only when the model lost output to elision — otherwise it sees everything.
+  if (!hadElision) return body;
+  // The REPL namespace is persistent across blocks in a turn, so the last block's varNames reflect
+  // every variable created in any earlier block too.
+  const varNames = results.at(-1)?.varNames ?? [];
+  const hint = varNames.length > 0
+    ? `REPL vars: ${varNames.join(", ")}`
+    : `No REPL vars yet — assign results to variables before printing large outputs.`;
+  return `${body}\n\n${hint}`;
+}
+
+/** Stdout ≤ SMALL_STDOUT_LIMIT flows through verbatim; larger output keeps a short head + a note
+ * telling the model how to inspect it in slices. Returns whether elision occurred (drives the var-list). */
+function formatStdout(r: ReplResult): { text: string; elided: boolean } {
+  const out = r.stdout.trim();
+  if (!out) return { text: "(no stdout)", elided: false };
+  if (out.length <= SMALL_STDOUT_LIMIT) return { text: out, elided: false };
+  const note = `[+${out.length - STDOUT_PREVIEW_LIMIT} chars elided — use slices to inspect: print(result[:500])]`;
+  return { text: `${out.slice(0, STDOUT_PREVIEW_LIMIT)}\n${note}`, elided: true };
+}
+
+function formatStderr(r: ReplResult): string {
+  const err = r.stderr.trim();
+  return err ? `\n[stderr]\n${truncateOutput(err, STDERR_LIMIT)}` : "";
+}

package/src/core/compaction.ts

@@ -0,0 +1,64 @@
+/**
+ * Trajectory compaction (port of rlm/core/rlm.py `_compact_history`).
+ *
+ * When the root history grows past a fraction of the model's context window, replace the middle
+ * of the conversation with a single running summary — a bounded-memory recap (the linear-space
+ * idea from DP sequence alignment). Keeps the system message + a fresh "continue" instruction.
+ */
+
+import type { Api, Model, Usage } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { type ChatMsg, modelComplete } from "../bridge/model.ts";
+import { estimateMessageTokens } from "../text/tokens.ts";
+
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+
+const SUMMARY_REQUEST =
+  "Summarize your progress so far. Include: (1) which sub-tasks are done and which remain; " +
+  "(2) any concrete intermediate results — numbers, values, variable names — preserved exactly; " +
+  "(3) your next action. Be concise (1–3 paragraphs) but preserve all key results.";
+
+export interface CompactionDeps {
+  readonly model: Model<Api>;
+  readonly registry: ModelRegistry;
+  readonly contextWindow?: number;
+  readonly thresholdPct?: number;
+  readonly signal?: AbortSignal;
+}
+
+/** True if the history is at/over the compaction threshold. */
+export function shouldCompact(history: ChatMsg[], deps: CompactionDeps): boolean {
+  const contextWindow = deps.contextWindow && deps.contextWindow > 0 ? deps.contextWindow : DEFAULT_CONTEXT_WINDOW;
+  const threshold = (deps.thresholdPct ?? 0.85) * contextWindow;
+  return estimateMessageTokens(history) >= threshold;
+}
+
+/**
+ * Summarize the trajectory and return a compacted history: [system, summary(assistant),
+ * continue(user)]. The caller continues appending turns from there.
+ */
+export async function compactHistory(
+  history: ChatMsg[],
+  deps: CompactionDeps,
+  count = 1,
+  onUsage?: (u: Usage) => void,
+): Promise<ChatMsg[]> {
+  const { text: summary, usage } = await modelComplete([...history, { role: "user", content: SUMMARY_REQUEST }], {
+    model: deps.model,
+    registry: deps.registry,
+    signal: deps.signal,
+  });
+  onUsage?.(usage);
+  const system = history.find((m) => m.role === "system");
+  const head: ChatMsg[] = system ? [system] : [];
+  return [
+    ...head,
+    { role: "assistant", content: summary },
+    {
+      role: "user",
+      content:
+        `Your conversation has been compacted ${count} time(s). Continue from the summary above. ` +
+        "Do NOT repeat completed work. Use SHOW_VARS() to see existing REPL variables. Your next action:",
+    },
+  ];
+}