@hicaru/pi-rlm 0.1.9 → 0.2.1

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,11 +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 { readHeader } from "./reads.ts";
+import { readHeader, readTrailLines } from "./reads.ts";
 import {
   isCompaction,
   isHeader,
@@ -24,8 +23,8 @@ 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 {
@@ -63,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)) {

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/tool/background-tasks.ts

@@ -0,0 +1,95 @@
+/**
+ * Session-scoped home for detached `spawn()` work in native repl() mode.
+ *
+ * A spawned sub-call may settle after the repl() call that started it has returned, when
+ * that turn's RlmEmitter has been shut down and its LimitGuard discarded. Both live here for
+ * the whole session instead. The turn that awaits a task — or simply the next turn to run —
+ * adopts its settled subtree into its own ReplDetails, so background spend is reported even
+ * when the model never collects the result.
+ *
+ * The headless engine needs none of this: its emitter and guard already outlive every
+ * sub-call it services (see core/engine.ts).
+ */
+
+import { RlmEmitter } from "./rlm-events.ts";
+import { SubcallStore, type SubcallTotals } from "./subcall-store.ts";
+import type { RlmSubcall } from "./rlm-details.ts";
+import { LimitGuard, type Limits } from "../core/limits.ts";
+import type { Invocation } from "../bridge/subcall-handlers.ts";
+import { trace, traceEnabled } from "../util/trace.ts";
+
+/** What a drain hands to the turn that is reporting it. */
+export interface BackgroundDrain {
+  readonly subcalls: readonly RlmSubcall[];
+  readonly totals: SubcallTotals;
+}
+
+export class BackgroundTasks {
+  /** "bg" prefix so these IDs can never collide with a turn emitter's `s1, s2, …`. */
+  private readonly _emitter = new RlmEmitter("bg");
+  private readonly store = new SubcallStore(this._emitter);
+  private readonly limits: LimitGuard;
+  private active = 0;
+
+  constructor(limits: Limits) {
+    this.limits = new LimitGuard(limits);
+  }
+
+  /** Read-only access for the progressive tracer (scope "background"). */
+  get emitter(): RlmEmitter {
+    return this._emitter;
+  }
+
+  /** The Invocation detached sub-calls resolve to. Stable for the session. */
+  get invocation(): Invocation {
+    return {
+      emitter: this._emitter,
+      parentId: undefined,
+      depth: 0,
+      limits: this.limits,
+    };
+  }
+
+  /** Detached sub-calls still in flight. The single pending counter for the session. */
+  get pending(): number {
+    return this.active;
+  }
+
+  /** Live snapshot of detached sub-calls, settled or not — progressive rendering only. */
+  liveSubcalls(): readonly RlmSubcall[] {
+    return this.store.getSubcalls();
+  }
+
+  /** Live totals for that same snapshot. Accounting still flows through `drain()`. */
+  liveTotals(): SubcallTotals {
+    return this.store.getTotals();
+  }
+
+  /** Count `run` as in-flight detached work for its duration. */
+  async track<T>(run: () => Promise<T>): Promise<T> {
+    this.active += 1;
+    const startedAt = Date.now();
+    if (traceEnabled) trace("bg.start", { pending: this.active });
+    try {
+      return await run();
+    } finally {
+      this.active -= 1;
+      if (traceEnabled) trace("bg.settle", { pending: this.active, durationMs: Date.now() - startedAt });
+    }
+  }
+
+  /**
+   * Hand over every fully-settled subtree and forget it.
+   *
+   * Called at the end of every repl() call, not only when a task was awaited, so a spawn
+   * the model never collects still reaches the user's cost totals.
+   */
+  drain(): BackgroundDrain {
+    return this.store.takeSettledSubtrees();
+  }
+
+  dispose(): void {
+    this.store.dispose();
+    this._emitter.shutdown();
+  }
+}

package/src/tool/repl-details.ts

@@ -22,6 +22,8 @@ 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;
+  /** Detached spawn() sub-calls still running when this call returned. Absent when none. */
+  readonly backgroundPending?: number;
   /** Advisory diagnostics — surfaced to the user, never a failure. */
   readonly warnings?: readonly string[];
 }