@hicaru/pi-rlm 0.1.8 → 0.2.0

package/src/state/paths.ts

@@ -20,7 +20,7 @@ export function generateRunId(
   now: Date = new Date(),
   suffix: string = randomBytes(RUN_ID_SUFFIX_BYTES).toString("hex"),
 ): string {
-  const pad = (n: number) => String(n).padStart(2, "0");
+  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}`;
 }

package/src/state/reads.ts

@@ -12,8 +12,12 @@ 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";
 
-/** Every well-formed row, in trail order. Malformed line → one warn, skipped. */
-export async function readRows(cwd: string, dir: string, runId: string): Promise<Row[]> {
+/**
+ * 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(
@@ -21,10 +25,14 @@ export async function readRows(cwd: string, dir: string, runId: string): Promise
     undefined as string | undefined,
   );
   const trimmed = content?.trim();
-  if (!trimmed) return [];
+  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 trimmed.split("\n")) {
+  for (const line of lines) {
     try {
       const row = JSON.parse(line) as unknown;
       if (isRow(row)) rows.push(row);

package/src/state/resume.ts

@@ -7,12 +7,10 @@
  * garbage from a crash is tolerated.
  */
 
-import { readFile } from "node:fs/promises";
 import { type ChatMsg } from "../bridge/model.ts";
 import { appendUserMessage } from "../core/history.ts";
 import { buildTurnPrompt } from "../prompts/user.ts";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-import { readHeader } from "./reads.ts";
+import { readHeader, readTrailLines } from "./reads.ts";
 import {
   isCompaction,
   isHeader,
@@ -25,15 +23,21 @@ import {
   type Row,
   type RunHeader,
 } from "./rows.ts";
-import { trailPath, snapshotPath } from "./paths.ts";
-import { failSoft, pathExists } from "./internal.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 artifact paths keyed by the phase that produced them. */
-  readonly artifacts?: Readonly<Partial<Record<string, string>>>;
+  /** Repo-relative artifacts keyed by the phase that produced them. */
+  readonly artifacts?: Readonly<Partial<Record<string, PhaseReconArtifact>>>;
   readonly backwardJumps?: number;
 }
 
@@ -45,7 +49,6 @@ export type ReconstructResult =
       readonly pendingReplOutputs?: string;
       readonly usageSeed: { readonly costUsd: number; readonly inputTokens: number; readonly outputTokens: number; readonly durationMs: number };
       readonly best: string;
-      readonly editsAcc: ProposedEdit[];
       readonly completedTurns: number;
       readonly compactions: number;
       /** R-C1: the latest turn whose per-turn snapshot file exists on disk (undefined ⇒ no restore). */
@@ -59,15 +62,10 @@ export type ReconstructResult =
 
 /** 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 path = trailPath(cwd, dir, runId);
-  if (!await pathExists(path)) return { rows: [], hole: false };
-  const content = await failSoft(() => readFile(path, "utf-8"), undefined as string | undefined);
-  const trimmed = content?.trim();
-  if (!trimmed) return { rows: [], hole: false };
-
+  const lines = await readTrailLines(cwd, dir, runId);
   const rows: Row[] = [];
   let sawBad = false;
-  for (const line of trimmed.split("\n")) {
+  for (const line of lines) {
     try {
       const row = JSON.parse(line) as unknown;
       if (!isRow(row)) {
@@ -102,7 +100,6 @@ export async function reconstructRlmState(
   let history: ChatMsg[] = [{ role: "system", content: systemPrompt }];
   const usageSeed = { costUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 };
   let best = "";
-  let editsAcc: ProposedEdit[] = [];
   let completedTurns = 0;
   let compactions = 0;
   let snapshotTurn: number | undefined; // R-C1: latest turn with an existing snapshot file
@@ -110,8 +107,8 @@ export async function reconstructRlmState(
   const todoRows: { action: string; params: Record<string, unknown>; result: string }[] = [];
   let terminated = false;
   let phase: PhaseRecon | undefined;
-  // Accumulate artifact paths keyed by the producing phase (artifactPhase on the row).
-  const artifactsAcc: Record<string, string> = {};
+  // 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;
@@ -134,7 +131,6 @@ export async function reconstructRlmState(
       usageSeed.outputTokens += row.usage.outputTokens;
       if (row.answerContent) best = row.answerContent;
       else if (!best && row.response.trim()) best = row.response; // C3: mirror engine fallback
-      if (row.edits && row.edits.length > 0) editsAcc = [...row.edits];
       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)))
@@ -145,17 +141,22 @@ export async function reconstructRlmState(
     }
     if (isPhase(row)) {
       if (row.artifactPath !== undefined && row.artifactPhase !== undefined) {
-        artifactsAcc[row.artifactPhase] = row.artifactPath;
+        artifactsAcc.set(row.artifactPhase, { path: row.artifactPath, superseded: false });
       }
-      // On loop-back to blueprint, drop stale plan so resume cannot re-gate with it.
-      if (row.phase === "blueprint" && row.backwardJumps !== undefined && row.backwardJumps > 0) {
-        delete artifactsAcc.blueprint;
+      // 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: Object.keys(artifactsAcc).length > 0 ? { ...artifactsAcc } : undefined,
+        artifacts: artifactsAcc.size > 0 ? artifactsObj : undefined,
         backwardJumps: row.backwardJumps,
       };
       continue;
@@ -168,5 +169,5 @@ export async function reconstructRlmState(
   }
 
   if (completedTurns === 0 && !terminated) return { ok: false, reason: "no-turns", detail: runId };
-  return { ok: true, header, history, pendingReplOutputs, usageSeed, best, editsAcc, completedTurns, compactions, snapshotTurn, todoRows, terminated, phase };
+  return { ok: true, header, history, pendingReplOutputs, usageSeed, best, completedTurns, compactions, snapshotTurn, todoRows, terminated, phase };
 }

package/src/state/rows.ts

@@ -9,7 +9,6 @@
  */
 
 import type { ChatMsg } from "../bridge/model.ts";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
 
 /** Bump when a row shape changes such that the resume fold cannot replay older files. */
 export const STATE_SCHEMA_VERSION = 5;
@@ -47,7 +46,6 @@ export interface TurnRow {
   readonly response: string;        // assistant message
   readonly replOutputs?: string;    // formatReplOutputs(results) → next user message
   readonly answerContent?: string;  // restores `best`
-  readonly edits?: readonly ProposedEdit[]; // restores editsAcc (latest wins)
   readonly error: boolean;          // turnHadError → limits.observe on resume
   readonly usage: UsageRow;
   readonly cumulativeDurationMs: number; // limits.usage().durationMs at turn-write time
@@ -94,6 +92,8 @@ export interface PhaseRow {
   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;

package/src/text/parsing.ts

@@ -19,12 +19,6 @@ export function findReplBlocks(text: string): string[] {
   return blocks;
 }
 
-/** True if the response contains at least one runnable ```repl``` block. */
-export function hasReplBlock(text: string): boolean {
-  FENCE.lastIndex = 0;
-  return FENCE.test(text);
-}
-
 /** Truncate REPL stdout for the model's context window (head + tail, with an elision note). */
 export function truncateOutput(text: string, limit = 20_000): string {
   if (text.length <= limit) return text;

package/src/text/tokens.ts

@@ -8,11 +8,17 @@
 
 const CHARS_PER_TOKEN = 4;
 
+/** Rough token count for a character length (≈4 chars/token). Always ≥ 1 for non-empty text. */
+export function estimateTokens(charCount: number): number {
+  if (charCount <= 0) return 0;
+  return Math.ceil(charCount / CHARS_PER_TOKEN);
+}
+
 /** Rough token count for a list of role/content messages. */
 export function estimateMessageTokens(messages: { content: string }[]): number {
   let chars = 0;
   for (const m of messages) chars += m.content.length + 8; // small per-message overhead
-  return Math.ceil(chars / CHARS_PER_TOKEN);
+  return estimateTokens(chars);
 }
 
 /** Total character length of a context payload (string or list of strings). */

package/src/tool/repl-details.ts

@@ -6,7 +6,6 @@
  * accumulated into the subcalls array for tree rendering.
  */
 
-import type { ProposedEdit } from "../sandbox/protocol.ts";
 import type { RlmSubcall } from "./rlm-details.ts";
 
 export interface ReplDetails {
@@ -23,6 +22,6 @@ export interface ReplDetails {
   readonly totals: { readonly costUsd: number; readonly tokens: number };
   /** Final answer submitted through answer["ready"] without echoing it to the model. */
   readonly finalAnswer?: string;
-  /** File edits staged inside the REPL for native relay through apply_edits(). */
-  readonly edits?: readonly ProposedEdit[];
+  /** Advisory diagnostics — surfaced to the user, never a failure. */
+  readonly warnings?: readonly string[];
 }