@hicaru/pi-rlm 0.2.0 → 0.2.2

package/src/state/index.ts

@@ -1,24 +0,0 @@
-/**
- * Barrel for the RLM run-state module.
- *
- * Re-exports every public symbol so `core/engine.ts` and `mode/rlm-mode.ts`
- * import from one door. Type-only re-exports use `export type`.
- */
-
-export { generateRunId, runsDir, runDir, trailPath, contextPath, snapshotPath } from "./paths.ts";
-export type {
-  UsageRow,
-  RunHeader,
-  TurnRow,
-  CompactionRow,
-  TerminalRow,
-  TodoRow,
-  PhaseRow,
-  Row,
-} from "./rows.ts";
-export { STATE_SCHEMA_VERSION, isHeader, isTurn, isCompaction, isPhase, isTodo, isTerminal, isRow } from "./rows.ts";
-export { appendRow, appendTodoRow, pruneRuns, writeContextSidecar } from "./writes.ts";
-export { readRows, readHeader, readContextSidecar, readLibrarySidecars, listRunIds, resolveRunId } from "./reads.ts";
-export type { LibrarySlot } from "./reads.ts";
-export { reconstructRlmState } from "./resume.ts";
-export type { PhaseRecon, ReconstructResult } from "./resume.ts";

package/src/state/internal.ts

@@ -1,46 +0,0 @@
-/** Internal helpers shared across the RLM run-state module. */
-
-import { access, readdir } from "node:fs/promises";
-import { errorMessage } from "../util/errors.ts";
-
-export { errorMessage } from "../util/errors.ts";
-
-export interface FailSoftOptions {
-  readonly label?: string;
-  readonly warn?: boolean;
-}
-
-const DEFAULT_FAIL_SOFT_OPTIONS = Object.freeze({});
-
-export const warn = (e: unknown): void => console.warn(`[rlm-state] ${errorMessage(e)}`);
-
-export async function failSoft<T>(
-  fn: () => Promise<T>,
-  fallback: T,
-  options: FailSoftOptions = DEFAULT_FAIL_SOFT_OPTIONS,
-): Promise<T> {
-  try {
-    return await fn();
-  } catch (e) {
-    if (options.warn !== false) warn(options.label ? `${options.label}: ${errorMessage(e)}` : e);
-    return fallback;
-  }
-}
-
-export async function listDirectoriesSorted(root: string): Promise<string[]> {
-  const entries = await readdir(root, { withFileTypes: true });
-  return entries
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort()
-    .reverse();
-}
-
-export async function pathExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/state/paths.ts

@@ -1,44 +0,0 @@
-/**
- * Pure path/id helpers for the RLM run-state module.
- *
- * Run-IDs are filename-sortable ISO-like slugs with a random hex suffix
- * for sub-second collision safety. All helpers are pure — no I/O.
- */
-
-import { randomBytes } from "node:crypto";
-import { isAbsolute, join } from "node:path";
-
-const RUN_ID_SUFFIX_BYTES = 2;
-const ISO_DATETIME_LENGTH = 19;
-
-/** `YYYY-MM-DD_HH-MM-SS-<4hex>` — filename-sortable, sub-second collision-safe.
- *
- * Prune ordering in writes.ts:pruneRuns depends on the ISO-slug format producing
- * chronologically sortable strings. If the format changes, update pruning logic
- * to maintain oldest-first deletion. */
-export function generateRunId(
-  now: Date = new Date(),
-  suffix: string = randomBytes(RUN_ID_SUFFIX_BYTES).toString("hex"),
-): string {
-  const pad = (n: number): string => String(n).padStart(2, "0");
-  const iso = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}T${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
-  return `${iso.slice(0, ISO_DATETIME_LENGTH).replaceAll(":", "-").replace("T", "_")}-${suffix}`;
-}
-
-export const runsDir = (cwd: string, dir: string): string =>
-  isAbsolute(dir) ? dir : join(cwd, dir);
-
-export const runDir = (cwd: string, dir: string, runId: string): string => join(runsDir(cwd, dir), runId);
-
-export const trailPath = (cwd: string, dir: string, runId: string): string => join(runDir(cwd, dir, runId), "trail.jsonl");
-
-export const contextPath = (cwd: string, dir: string, runId: string, json: boolean, index = 0): string =>
-  join(runDir(cwd, dir, runId), index === 0
-    ? (json ? "context.json" : "context.txt")
-    : `context.${index}.${json ? "json" : "txt"}`);
-
-/** R-C1: per-turn snapshot files — `sandbox-<turn>.pkl` so resume can fall back to a prior turn if the latest rename failed. */
-export function snapshotPath(cwd: string, dir: string, runId: string, turn?: number): string {
-  const name = turn !== undefined ? `sandbox-${turn}.pkl` : "sandbox.pkl";
-  return join(runDir(cwd, dir, runId), name);
-}

package/src/state/reads.ts

@@ -1,133 +0,0 @@
-/**
- * Fail-soft JSONL readers for the RLM run-state module.
- *
- * `readRows` parses each line in its own try/catch so a truncated trailing
- * line cannot erase prior rows. `listRunIds` sorts directories newest-first
- * by the slug (ISO-like timestamps are self-sorting).
- */
-
-import { open, readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { runsDir, runDir, trailPath, contextPath } from "./paths.ts";
-import { isHeader, isRow, type RunHeader, type Row } from "./rows.ts";
-import { errorMessage, failSoft, listDirectoriesSorted, pathExists, warn } from "./internal.ts";
-
-/**
- * Raw JSONL lines of a run's trail, in order. Missing or unreadable file → [].
- * Shared by the fail-soft reader here and the hole-detecting reader in resume.ts, which
- * differ only in how they treat a bad line.
- */
-export async function readTrailLines(cwd: string, dir: string, runId: string): Promise<string[]> {
-  const path = trailPath(cwd, dir, runId);
-  if (!await pathExists(path)) return [];
-  const content = await failSoft(
-    () => readFile(path, "utf-8"),
-    undefined as string | undefined,
-  );
-  const trimmed = content?.trim();
-  return trimmed ? trimmed.split("\n") : [];
-}
-
-/** Every well-formed row, in trail order. Malformed line → one warn, skipped. */
-export async function readRows(cwd: string, dir: string, runId: string): Promise<Row[]> {
-  const lines = await readTrailLines(cwd, dir, runId);
-  const rows: Row[] = [];
-  for (const line of lines) {
-    try {
-      const row = JSON.parse(line) as unknown;
-      if (isRow(row)) rows.push(row);
-      else warn("skipping invalid JSONL row shape");
-    } catch (e) {
-      warn(`skipping malformed JSONL row — ${errorMessage(e)}`);
-    }
-  }
-  return rows;
-}
-
-/** Read the first line of a trail file without reading the entire file (P1). */
-async function readFirstLine(path: string): Promise<string | undefined> {
-  return await failSoft(async () => {
-    const file = await open(path, "r");
-    try {
-      const stats = await file.stat();
-      const size = Math.min(stats.size, 65536);
-      if (size <= 0) return undefined;
-      const buffer = Buffer.alloc(size);
-      const { bytesRead } = await file.read(buffer, 0, size, 0);
-      const content = buffer.toString("utf-8", 0, bytesRead);
-      const nl = content.indexOf("\n");
-      return nl >= 0 ? content.slice(0, nl) : content.trim() || undefined;
-    } finally {
-      await file.close();
-    }
-  }, undefined as string | undefined, { warn: false });
-}
-
-/** First well-formed header row, or undefined. Bounded read — never reads the full trail (P1). */
-export async function readHeader(cwd: string, dir: string, runId: string): Promise<RunHeader | undefined> {
-  const line = await readFirstLine(trailPath(cwd, dir, runId));
-  if (!line) return undefined;
-  try {
-    const row = JSON.parse(line) as unknown;
-    return isHeader(row) ? row : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Reload context from a persistent sidecar file. */
-export async function readContextSidecar(cwd: string, dir: string, runId: string, json: boolean): Promise<unknown> {
-  const path = contextPath(cwd, dir, runId, json);
-  if (!await pathExists(path)) return undefined;
-  const content = await failSoft(
-    () => readFile(path, "utf-8"),
-    undefined as string | undefined,
-  );
-  if (content === undefined) return undefined;
-  try {
-    return json ? JSON.parse(content) as unknown : content;
-  } catch (e) {
-    warn(e);
-    return undefined;
-  }
-}
-
-const LIBRARY_SIDECAR = /^context\.(\d+)\.(json|txt)$/;
-
-export interface LibrarySlot {
-  readonly index: number;
-  readonly payload: unknown;
-}
-
-/** Fail-soft lister for load_library resume sidecars (`context.<index>.json|txt`). */
-export async function readLibrarySidecars(cwd: string, dir: string, runId: string): Promise<LibrarySlot[]> {
-  const entries = await failSoft(() => readdir(runDir(cwd, dir, runId)), [] as string[]);
-  const slots: LibrarySlot[] = [];
-  for (const name of entries) {
-    const m = LIBRARY_SIDECAR.exec(name);
-    if (!m) continue;
-    const index = Number(m[1]);
-    const json = m[2] === "json";
-    const content = await failSoft(
-      () => readFile(join(runDir(cwd, dir, runId), name), "utf-8"),
-      undefined as string | undefined,
-    );
-    if (content === undefined) continue;
-    try {
-      slots.push({ index, payload: json ? JSON.parse(content) as unknown : content });
-    } catch (e) { warn(e); }
-  }
-  return slots.sort((a, b) => a.index - b.index);
-}
-
-/** Enumerate run-ids by directory listing; newest first (slug sorts chronologically). */
-export async function listRunIds(cwd: string, dir: string): Promise<string[]> {
-  return await failSoft(() => listDirectoriesSorted(runsDir(cwd, dir)), [], { warn: false });
-}
-
-/** `@latest` / explicit id resolution. */
-export async function resolveRunId(cwd: string, dir: string, ref: string): Promise<string | undefined> {
-  const ids = await listRunIds(cwd, dir);
-  if (ref === "@latest") return ids[0];
-  return ids.includes(ref) ? ref : undefined;
-}

package/src/state/resume.ts

@@ -1,173 +0,0 @@
-/**
- * Resume fold — rebuilds engine state from a JSONL trail in one pass.
- *
- * The fold reuses the live engine's own prompt builders (`buildTurnPrompt`) so
- * the rebuilt history is faithful — DRY: the fold and the live loop share the
- * same message-construction helpers. Mid-file malformed rows fail; trailing
- * garbage from a crash is tolerated.
- */
-
-import { type ChatMsg } from "../bridge/model.ts";
-import { appendUserMessage } from "../core/history.ts";
-import { buildTurnPrompt } from "../prompts/user.ts";
-import { readHeader, readTrailLines } from "./reads.ts";
-import {
-  isCompaction,
-  isHeader,
-  isPhase,
-  isRow,
-  isTerminal,
-  isTodo,
-  isTurn,
-  STATE_SCHEMA_VERSION,
-  type Row,
-  type RunHeader,
-} from "./rows.ts";
-import { snapshotPath } from "./paths.ts";
-import { pathExists } from "./internal.ts";
-
-/** Artifact path + supersede flag reconstructed from phase rows. */
-export interface PhaseReconArtifact {
-  readonly path: string;
-  readonly superseded: boolean;
-}
-
-export interface PhaseRecon {
-  readonly current: string;
-  readonly advancedAt: number;
-  readonly summary?: string;
-  /** Repo-relative artifacts keyed by the phase that produced them. */
-  readonly artifacts?: Readonly<Partial<Record<string, PhaseReconArtifact>>>;
-  readonly backwardJumps?: number;
-}
-
-export type ReconstructResult =
-  | {
-      readonly ok: true;
-      readonly header: RunHeader;
-      readonly history: ChatMsg[];
-      readonly pendingReplOutputs?: string;
-      readonly usageSeed: { readonly costUsd: number; readonly inputTokens: number; readonly outputTokens: number; readonly durationMs: number };
-      readonly best: string;
-      readonly completedTurns: number;
-      readonly compactions: number;
-      /** R-C1: the latest turn whose per-turn snapshot file exists on disk (undefined ⇒ no restore). */
-      readonly snapshotTurn: number | undefined;
-      readonly todoRows: readonly { readonly action: string; readonly params: Record<string, unknown>; readonly result: string }[];
-      readonly terminated: boolean;
-      /** Reconstructed pipeline phase state. undefined ⇒ pre-v3 trail (treats as research). */
-      readonly phase?: PhaseRecon;
-    }
-  | { readonly ok: false; readonly reason: "no-header" | "version-mismatch" | "no-turns" | "mid-file-hole"; readonly detail: string };
-
-/** QB: single read + parse — detects mid-file holes without reading the trail twice. */
-async function readRowsStrict(cwd: string, dir: string, runId: string): Promise<{ readonly rows: Row[]; readonly hole: boolean }> {
-  const lines = await readTrailLines(cwd, dir, runId);
-  const rows: Row[] = [];
-  let sawBad = false;
-  for (const line of lines) {
-    try {
-      const row = JSON.parse(line) as unknown;
-      if (!isRow(row)) {
-        sawBad = true;
-        continue;
-      }
-      rows.push(row);
-      if (sawBad) return { rows, hole: true }; // good line after a bad one = mid-file hole
-    } catch {
-      sawBad = true; // trailing bad line tolerated; a subsequent good line means a hole
-    }
-  }
-  return { rows, hole: false };
-}
-
-export async function reconstructRlmState(
-  cwd: string,
-  dir: string,
-  runId: string,
-  systemPrompt: string,
-): Promise<ReconstructResult> {
-  const header = await readHeader(cwd, dir, runId);
-  if (!header) return { ok: false, reason: "no-header", detail: runId };
-  // QB: ??1 backward-compat — when bumping STATE_SCHEMA_VERSION, also bump this default
-  // so trails written without an explicit `v` field are rejected rather than silently passed.
-  if ((header.v ?? 1) !== STATE_SCHEMA_VERSION)
-    return { ok: false, reason: "version-mismatch", detail: `run ${runId} written under schema v${header.v}` };
-
-  const { rows, hole } = await readRowsStrict(cwd, dir, runId);
-  if (hole) return { ok: false, reason: "mid-file-hole", detail: runId };
-
-  let history: ChatMsg[] = [{ role: "system", content: systemPrompt }];
-  const usageSeed = { costUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 };
-  let best = "";
-  let completedTurns = 0;
-  let compactions = 0;
-  let snapshotTurn: number | undefined; // R-C1: latest turn with an existing snapshot file
-  let pendingReplOutputs: string | undefined;
-  const todoRows: { action: string; params: Record<string, unknown>; result: string }[] = [];
-  let terminated = false;
-  let phase: PhaseRecon | undefined;
-  // Append-only journal: paths stay; supersededPath flips the blueprint slot.
-  const artifactsAcc = new Map<string, PhaseReconArtifact>();
-
-  for (const row of rows) {
-    if (isHeader(row)) continue;
-    if (isCompaction(row)) {
-      history = [...row.history];
-      compactions++;
-      usageSeed.costUsd += row.usage.costUsd;
-      usageSeed.inputTokens += row.usage.inputTokens;
-      usageSeed.outputTokens += row.usage.outputTokens;
-      pendingReplOutputs = undefined;
-      continue;
-    }
-    if (isTurn(row)) {
-      const i = row.turn - 1;
-      if (pendingReplOutputs) appendUserMessage(history, pendingReplOutputs);
-      appendUserMessage(history, buildTurnPrompt(i, header.meta.maxIterations));
-      history.push({ role: "assistant", content: row.response });
-      usageSeed.costUsd += row.usage.costUsd;
-      usageSeed.inputTokens += row.usage.inputTokens;
-      usageSeed.outputTokens += row.usage.outputTokens;
-      if (row.answerContent) best = row.answerContent;
-      else if (!best && row.response.trim()) best = row.response; // C3: mirror engine fallback
-      completedTurns = row.turn;
-      // R-C1: verify the per-turn snapshot file exists — a crashed finalize leaves the row claiming snapshotOk:true with no pkl.
-      if (row.snapshotOk && await pathExists(snapshotPath(cwd, dir, runId, row.turn)))
-        snapshotTurn = row.turn;
-      usageSeed.durationMs = row.cumulativeDurationMs; // C2: seed wall-clock
-      pendingReplOutputs = row.replOutputs;
-      continue;
-    }
-    if (isPhase(row)) {
-      if (row.artifactPath !== undefined && row.artifactPhase !== undefined) {
-        artifactsAcc.set(row.artifactPhase, { path: row.artifactPath, superseded: false });
-      }
-      // Append-only: a superseded artifact keeps its slot, flipped to superseded.
-      if (row.supersededPath !== undefined) {
-        const prior = artifactsAcc.get("blueprint");
-        if (prior !== undefined) {
-          artifactsAcc.set("blueprint", { path: prior.path, superseded: true });
-        }
-      }
-      const artifactsObj: Record<string, PhaseReconArtifact> = {};
-      for (const [k, v] of artifactsAcc) artifactsObj[k] = v;
-      phase = {
-        current: row.phase,
-        advancedAt: row.turn - 1,
-        summary: row.summary,
-        artifacts: artifactsAcc.size > 0 ? artifactsObj : undefined,
-        backwardJumps: row.backwardJumps,
-      };
-      continue;
-    }
-    if (isTodo(row)) {
-      todoRows.push({ action: row.action, params: row.params, result: row.result });
-      continue;
-    }
-    if (isTerminal(row)) terminated = true;
-  }
-
-  if (completedTurns === 0 && !terminated) return { ok: false, reason: "no-turns", detail: runId };
-  return { ok: true, header, history, pendingReplOutputs, usageSeed, best, completedTurns, compactions, snapshotTurn, todoRows, terminated, phase };
-}

package/src/state/rows.ts

@@ -1,123 +0,0 @@
-/**
- * Run-state row shapes for the RLM JSONL audit trail.
- *
- * REPLAY CONTRACT: every field below is part of the resume fold's reconstruction.
- * If any field is added, removed, or its semantics change, bump STATE_SCHEMA_VERSION
- * so older trails are rejected rather than mis-replayed.
- *
- * Guards accept `unknown` and narrow via `hasKind` — no `any`, no `!`.
- */
-
-import type { ChatMsg } from "../bridge/model.ts";
-
-/** Bump when a row shape changes such that the resume fold cannot replay older files. */
-export const STATE_SCHEMA_VERSION = 5;
-
-export interface UsageRow {
-  readonly costUsd: number;
-  readonly inputTokens: number;
-  readonly outputTokens: number;
-}
-
-/** Line 1 of every trail. Carries everything the fold needs to rebuild the system prompt + reload context. */
-export interface RunHeader {
-  readonly kind: "header";
-  readonly v: number;
-  readonly runId: string;
-  readonly ts: string;
-  readonly rootPrompt: string;
-  readonly context: { readonly type: string; readonly chars: number; readonly json: boolean };
-  readonly models: { readonly model: string; readonly worker: string };
-  /** Snapshot of the replay-affecting config (maxIterations, orchestrator, pipeline…). */
-  readonly meta: {
-    readonly maxIterations: number;
-    readonly maxDepth: number;
-    readonly orchestrator: boolean;
-    /** pipeline-enabled gate behaviour (always true from v4 on). */
-    readonly pipeline?: boolean;
-  };
-}
-
-/** One completed turn. `response`+`replOutputs` rebuild history; the rest restore scalars. */
-export interface TurnRow {
-  readonly kind: "turn";
-  readonly turn: number;            // 1-based (== engine `i + 1`)
-  readonly ts: string;
-  readonly response: string;        // assistant message
-  readonly replOutputs?: string;    // formatReplOutputs(results) → next user message
-  readonly answerContent?: string;  // restores `best`
-  readonly error: boolean;          // turnHadError → limits.observe on resume
-  readonly usage: UsageRow;
-  readonly cumulativeDurationMs: number; // limits.usage().durationMs at turn-write time
-  readonly snapshotOk: boolean;     // whether sandbox.pkl reflects THIS turn
-}
-
-/** Emitted when compaction rewrites history; the fold replaces history wholesale. */
-export interface CompactionRow {
-  readonly kind: "compaction";
-  readonly turn: number;
-  readonly ts: string;
-  readonly history: readonly ChatMsg[]; // post-compaction array (small by design)
-  readonly usage: UsageRow;             // compaction model cost added to limits
-}
-
-export interface TodoRow {
-  readonly kind: "todo";
-  readonly turn: number;
-  readonly ts: string;
-  readonly action: string;
-  readonly params: Record<string, unknown>;
-  readonly result: string;
-}
-
-export interface TerminalRow {
-  readonly kind: "terminal";
-  readonly ts: string;
-  readonly status: "completed" | "finalized" | "aborted" | "stopped";
-  readonly answer: string;
-  readonly iterations: number;
-  readonly usage: UsageRow;
-}
-
-/** Emitted when the root RLM advances to a new pipeline phase. */
-export interface PhaseRow {
-  readonly kind: "phase";
-  readonly turn: number; // 1-based turn when advanced
-  readonly ts: string;
-  readonly phase: string;
-  readonly summary?: string;
-  /** Optional fields (no schema-version break — isPhase guard unchanged). */
-  readonly artifactPath?: string;
-  /** Phase that produced `artifactPath` (not inferred from order — loop-back safe). */
-  readonly artifactPhase?: string;
-  readonly blockersCount?: number;
-  readonly backwardJumps?: number;
-  /** Path of the artifact this transition superseded (validate loop-back). */
-  readonly supersededPath?: string;
-}
-
-export type Row = RunHeader | TurnRow | CompactionRow | TodoRow | TerminalRow | PhaseRow;
-
-const hasKind = (r: unknown, k: Row["kind"]): boolean =>
-  typeof r === "object" && r !== null && (r as { kind?: unknown }).kind === k;
-
-export const isHeader = (r: unknown): r is RunHeader =>
-  hasKind(r, "header") && typeof (r as RunHeader).runId === "string" && typeof (r as RunHeader).rootPrompt === "string"
-  && typeof (r as RunHeader).meta?.maxIterations === "number";
-
-export const isTurn = (r: unknown): r is TurnRow =>
-  hasKind(r, "turn") && typeof (r as TurnRow).turn === "number" && typeof (r as TurnRow).response === "string";
-
-export const isCompaction = (r: unknown): r is CompactionRow =>
-  hasKind(r, "compaction") && Array.isArray((r as CompactionRow).history);
-
-export const isTodo = (r: unknown): r is TodoRow =>
-  hasKind(r, "todo") && typeof (r as TodoRow).action === "string" && typeof (r as TodoRow).result === "string";
-
-export const isTerminal = (r: unknown): r is TerminalRow => hasKind(r, "terminal");
-
-export const isPhase = (r: unknown): r is PhaseRow =>
-  hasKind(r, "phase") && typeof (r as PhaseRow).phase === "string" && typeof (r as PhaseRow).turn === "number";
-
-export const isRow = (r: unknown): r is Row =>
-  isHeader(r) || isTurn(r) || isCompaction(r) || isTodo(r) || isTerminal(r) || isPhase(r);

package/src/state/writes.ts

@@ -1,58 +0,0 @@
-/**
- * Fail-soft JSONL writes for the RLM run-state module.
- *
- * Every writer returns `boolean` and warns on failure — never throws into
- * the engine loop. A failed `appendRow` disables persistence for the rest
- * of the run without aborting the answer.
- */
-
-import { appendFile, mkdir, open, rm, writeFile } from "node:fs/promises";
-import { contextPath, runDir, runsDir, trailPath } from "./paths.ts";
-import type { Row, TodoRow } from "./rows.ts";
-import { errorMessage, failSoft, listDirectoriesSorted, warn } from "./internal.ts";
-
-/** mkdir + append one JSON line. Returns true on success; warns + false on throw. Never throws. */
-export async function appendRow(cwd: string, dir: string, runId: string, row: Row): Promise<boolean> {
-  return await failSoft(async () => {
-    await mkdir(runDir(cwd, dir, runId), { recursive: true });
-    const path = trailPath(cwd, dir, runId);
-    await appendFile(path, `${JSON.stringify(row)}\n`, "utf-8");
-    // QC: fsync to flush kernel buffers — crash between write and sync would lose the last row
-    const file = await open(path, "r+");
-    try {
-      await file.sync();
-    } finally {
-      await file.close();
-    }
-    return true;
-  }, false);
-}
-
-export async function appendTodoRow(cwd: string, dir: string, runId: string, row: Omit<TodoRow, "kind">): Promise<boolean> {
-  return await appendRow(cwd, dir, runId, { kind: "todo", ...row });
-}
-
-/** Persist a context payload for resume. Slot 0 = repo context; index ≥ 1 = load_library slots. */
-export async function writeContextSidecar(
-  cwd: string, dir: string, runId: string, context: unknown, json: boolean, index = 0,
-): Promise<boolean> {
-  return await failSoft(async () => {
-    await mkdir(runDir(cwd, dir, runId), { recursive: true });
-    await writeFile(contextPath(cwd, dir, runId, json, index), json ? JSON.stringify(context) : String(context), "utf-8");
-    return true;
-  }, false);
-}
-
-/** Prune oldest run directories beyond maxRuns. Best-effort; never throws. */
-export async function pruneRuns(cwd: string, dir: string, maxRuns: number): Promise<void> {
-  try {
-    const ids = await listDirectoriesSorted(runsDir(cwd, dir)); // newest first (slug sorts chronologically)
-    const pruned = ids.slice(maxRuns);
-    if (pruned.length > 0) console.log(`[rlm-state] pruning ${pruned.length} runs (maxRuns=${maxRuns})`);
-    for (const id of pruned) {
-      await rm(runDir(cwd, dir, id), { recursive: true, force: true });
-    }
-  } catch (e) {
-    warn(`pruneRuns failed: ${errorMessage(e)}`);
-  }
-}