bareloop 0.27.0 → 0.29.0

package/src/behaviour.js

@@ -126,11 +126,14 @@ export function runBehaviour(events, { runId } = {}) {
  * Render a {@link runBehaviour} summary as the agreed printable block
  * (2–4 short lines). A zero-call run formats plainly ("0 tool calls") rather
  * than a NaN-laced percentage — an empty run is a complete, reportable
- * answer, not a division error.
- * @param {ReturnType<typeof runBehaviour>} summary
+ * answer, not a division error. `summary === null` means the caller never
+ * had a gate-audit sidecar to read at all (see `replayRun`'s `auditAvailable`
+ * option) — that reads as "unknown", never coerced to a 0-call summary.
+ * @param {ReturnType<typeof runBehaviour>|null} summary
  * @returns {string}
  */
 export function formatBehaviour(summary) {
+  if (summary === null) return 'unknown (no gate-audit sidecar found for this run)';
   const { totalCalls, byTool, denied, repeats, repeatPct } = summary; // uniquePaths: data-only, not in the agreed printed shape
   const lines = [];
 

package/src/cli.js

@@ -34,6 +34,41 @@ import {
   runJob, makeSpine, loadRegistry, listingRow, jobSpecHash, resolveWorkerModel, resolveJudge,
 } from './index.js';
 import { resolveProvider, buildRunnerProviders, apiKeyProblem } from './providers.js';
+// PANEL-BUILD.md P0 task 2/4 — `bareloop run-u` wraps the person-path run
+// flow's own argv-parsing entry (`src/userrun.js`'s `main(argv, deps)`,
+// itself the lift target of P0 task 1). This is the SAME function
+// `scripts/run-u.mjs` calls directly — routing this command through it
+// rather than re-parsing argv a second time here keeps exactly one code
+// path for the flag grammar; `src/cli.js` only supplies the deps shape
+// (`out`/`err`/`env`) this command's own callers already use.
+import { main as runUMain } from './userrun.js';
+// PANEL-BUILD.md P0 task 3/4 — `bareloop interview` and `bareloop author`
+// wrap the close-authoring interview and authoring-pipeline flows' own
+// argv-parsing entries (`src/interviewrun.js`/`src/authorrun.js`, lifted out
+// of `scripts/run-interview.mjs`/`scripts/run-author.mjs` the same way task
+// 1/2 lifted `scripts/run-u.mjs`). `scripts/run-interview.mjs`/`scripts/
+// run-author.mjs` call these SAME functions directly, so there is exactly
+// one place each flag grammar is parsed.
+import { main as interviewMain } from './interviewrun.js';
+import { main as authorMain } from './authorrun.js';
+// PANEL-BUILD.md P0 — the spine/gate-audit read side (`bareloop replay`,
+// and `doHistory`'s reader below), lifted out of `scripts/run-replay.mjs`
+// into `src/replayio.js` the same way tasks 1-3 lifted their own scripts.
+import {
+  parseJsonl, looksLikeSpine, replayOne, listSpines, readHistoryLog,
+} from './replayio.js';
+import { formatReplay, formatAllLines } from './replay.js';
+// PANEL-BUILD.md P1 — the read-only panel HTTP server (`bareloop panel`).
+// One more caller of the same `src/` library functions this file already
+// calls (the layering law, PANEL-BUILD.md §2) — `src/panel/server.js` never
+// re-implements the spine/run-list read side, it calls `src/replayio.js`/
+// `src/runlist.js` directly, in-process.
+import { panelMain } from './panel/server.js';
+// PANEL-BUILD.md P1 (2026-09-24 rulings) — the one run list
+// (`~/.config/bareloop/runs.jsonl`) and its backfill scan. `bareloop runs`
+// (list) and `bareloop runs backfill <dir>` (reconstruct rows from archived
+// spines already on disk) are this rung's only new commands.
+import { appendRun, readRunList, backfillRuns, formatRunRow } from './runlist.js';
 
 // The tier->model tables live in `src/providers.js` now (PRD item 28's
 // factory) — one seam instead of a copy hardcoded in each runner. A
@@ -369,6 +404,23 @@ async function doRun(args, { out, err, cwd, env, now, deps }) {
   const closeDir = join(runsDir, 'close');
   mkdirSync(closeDir, { recursive: true });
 
+  // PANEL-BUILD.md P1 — one row in the run list, BEFORE the first paid call
+  // (runJob, right below). A list-append failure must never block a real,
+  // already-signed run: caught and named loudly, never rethrown.
+  // `deps.runlistHome` — the SAME test seam shape `deps.provider`/`deps.now`
+  // already are on this ctx (never a new env var, see src/runlist.js's own
+  // header comment): a caller that injects it (every test in
+  // tests/cli.test.js that reaches this line) writes its row under a temp
+  // home instead of the real `~/.config/bareloop`; production never sets it,
+  // so `appendRun` falls through to `runlistHome()`'s own `os.homedir()`.
+  try {
+    appendRun({
+      at: new Date(now()).toISOString(), runid, job: runSpec.job, spine: spineFile, patient: worktree, via: 'bundle',
+    }, { home: deps.runlistHome });
+  } catch (e) {
+    err(`WARNING: could not add this run to ~/.config/bareloop/runs.jsonl (${/** @type {Error} */ (e).message}) — the run continues; the panel's list will be missing this row.`);
+  }
+
   let outcome;
   try {
     outcome = await runJob(runSpec, {
@@ -397,8 +449,12 @@ async function doRun(args, { out, err, cwd, env, now, deps }) {
   if (existsSync(auditSrc)) renameSync(auditSrc, join(runsDir, 'gate-audit.jsonl'));
 
   // the job-end record off THIS run's own spine — never fabricate a 0 for an
-  // unknown spend (F6/F12's class).
-  const events = readFileSync(spineFile, 'utf8').trimEnd().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  // unknown spend (F6/F12's class). PANEL-BUILD.md P0: read via the same
+  // named library reader `doHistory`/`doReplay` already use (`parseJsonl`,
+  // `src/replayio.js`) instead of hand-rolling the parse again here — it
+  // tolerates a malformed/truncated line (a process killed mid-append)
+  // instead of throwing uncaught and crashing this run's exit tail.
+  const { records: events } = parseJsonl(spineFile);
   const je = events.findLast((/** @type {any} */ e) => e.type === 'job-end');
   const spentUsd = je?.spentUsd ?? null;
   const spendComplete = je?.spendComplete ?? null;
@@ -450,10 +506,17 @@ function doHistory(args, { out, err, cwd }) {
   const dir = resolve(cwd, bundleDirArg);
   const historyFile = join(dir, 'history.jsonl');
   if (existsSync(historyFile)) {
+    // PANEL-BUILD.md P0 — the one reader for `history.jsonl` (`src/replayio.js`'s
+    // `readHistoryLog`), replacing this command's own hand-rolled
+    // `readFileSync`/split. Each row is re-printed with `JSON.stringify`
+    // (byte-identical to the original trimmed line for every well-formed
+    // row, since `appendHistory` itself writes `JSON.stringify(row)` —
+    // src/bundle.js:712); a malformed line is counted, never silently
+    // dropped or reprinted corrupt.
+    const { rows, skipped } = readHistoryLog(historyFile);
     out('history:');
-    for (const line of readFileSync(historyFile, 'utf8').split('\n')) {
-      if (line.trim()) out(`  ${line.trim()}`);
-    }
+    for (const row of rows) out(`  ${JSON.stringify(row)}`);
+    if (skipped > 0) out(`  (${skipped} malformed line${skipped === 1 ? '' : 's'} skipped)`);
   } else out('history: (no runs yet)');
   const reg = loadRegistry(join(dir, 'bridges'));
   if (reg.bridges.length > 0) {
@@ -463,9 +526,88 @@ function doHistory(args, { out, err, cwd }) {
   return 0;
 }
 
+/**
+ * `bareloop replay <spine.jsonl>` — one run's whole story, reconstructed
+ * from its spine + gate-audit sidecar, printed as one page
+ * ({@link formatReplay}). `bareloop replay --all <dir>` — every spine found
+ * directly in `dir`, one aligned table row each ({@link formatAllLines}).
+ * Read-only, $0, mints no verdict, writes nothing (PANEL-BUILD.md P0: this
+ * is the CLI the gap table marked "No" for "Replay an archived run at $0").
+ * Logic lifted verbatim from `scripts/run-replay.mjs` into
+ * `src/replayio.js`; this command is that script's one caller now, the same
+ * shape `bareloop history`/`bareloop run` already are over their own
+ * library functions.
+ * @param {string[]} args @param {{ out: (s: string) => void, err: (s: string) => void, cwd: string }} ctx
+ */
+function doReplay(args, { out, err, cwd }) {
+  if (args[0] === '--all') {
+    const dirArg = args[1];
+    if (!dirArg) { err('usage: bareloop replay --all <dir>'); return 1; }
+    const dir = resolve(cwd, dirArg);
+    if (!existsSync(dir)) { err(`no such directory: ${dir}`); return 1; }
+    const entries = listSpines(dir);
+    if (entries.length === 0) { out(`no .jsonl files found in ${dir}`); return 0; }
+    out(formatAllLines(entries));
+    return 0;
+  }
+  const spinePathArg = args[0];
+  if (!spinePathArg) {
+    err('usage: bareloop replay <spine.jsonl>');
+    err('       bareloop replay --all <dir>');
+    return 1;
+  }
+  const spinePath = resolve(cwd, spinePathArg);
+  if (!existsSync(spinePath)) { err(`no such file: ${spinePath}`); return 1; }
+  const spine = parseJsonl(spinePath);
+  if (!looksLikeSpine(spine.records)) {
+    err(`${spinePath} does not look like a spine (no job-start or run-start record found)`);
+    return 1;
+  }
+  const summary = replayOne(spinePath, { preParsedSpine: spine });
+  out(formatReplay(summary));
+  return 0;
+}
+
+/**
+ * `bareloop runs` — print the one run list, one line per row
+ * ({@link formatRunRow}). `bareloop runs backfill <dir>` — scan `dir` for
+ * archived spines and add a row per one not already listed
+ * ({@link backfillRuns}), printing the count added/already-listed/skipped
+ * (never silent). Read-only, $0: no interview, no author, no run trigger, no
+ * key ever read.
+ * @param {string[]} args @param {{ out: (s: string) => void, err: (s: string) => void, cwd: string }} ctx
+ */
+function doRuns(args, { out, err, cwd }) {
+  if (args[0] === 'backfill') {
+    const dirArg = args[1];
+    if (!dirArg) { err('usage: bareloop runs backfill <dir>'); return 1; }
+    const dir = resolve(cwd, dirArg);
+    if (!existsSync(dir)) { err(`no such directory: ${dir}`); return 1; }
+    let result;
+    try {
+      result = backfillRuns(dir);
+    } catch (e) {
+      err(`backfill failed: ${/** @type {Error} */ (e).message}`);
+      return 1;
+    }
+    out(`backfill ${dir}: added ${result.added}, already listed ${result.alreadyListed}, skipped ${result.skipped} (not a spine or unreadable)`);
+    return 0;
+  }
+  const { rows, skipped } = readRunList();
+  if (rows.length === 0) { out('runs: (none listed yet — see `bareloop runs backfill <dir>`)'); }
+  else for (const row of rows) out(formatRunRow(row));
+  if (skipped > 0) out(`(${skipped} malformed line${skipped === 1 ? '' : 's'} skipped)`);
+  return 0;
+}
+
 /**
  * The bare `bareloop` menu: `1 export  2 run  3 history  q quit`, then the
- * SAME code path as the sub-command, asking its args line by line.
+ * SAME code path as the sub-command, asking its args line by line. `run-u`,
+ * `interview`, `author` and `replay` are NOT wizarded here — a line-at-a-time
+ * prompt for `run-u`'s 13 flags (or the others' own argv shapes) would be
+ * inventing new interactive UX, not wiring, and that judgement stands. This
+ * menu is fixed instead: it now says those four commands exist and how to
+ * reach them, rather than implying only three commands do at all.
  * @param {any} deps @param {{ out: (s: string) => void, err: (s: string) => void, cwd: string, env: any, now: () => number }} ctx
  */
 async function runMenu(deps, ctx) {
@@ -474,6 +616,7 @@ async function runMenu(deps, ctx) {
   const rl = createInterface({ input: stdin, output: stdout });
   try {
     ctx.out('1 export  2 run  3 history  q quit');
+    ctx.out('(also on the command line, not wizarded here: run-u, interview, author, replay, runs, panel — run `bareloop <name>` with its own flags)');
     const choice = (await rl.question('> ')).trim().toLowerCase();
     if (choice === '' || choice === 'q' || choice === 'quit') return 0;
     if (choice === '1') {
@@ -510,7 +653,7 @@ async function runMenu(deps, ctx) {
  * code, so `bin/bareloop.mjs` can set `process.exitCode` and let node flush
  * queued stdout on its own (F-something: `process.exit()` can discard it).
  * @param {string[]} argv
- * @param {{ env?: Record<string,string|undefined>, stdout?: any, stderr?: any, cwd?: string, provider?: any, providerFor?: any, judgeProvider?: any, judgeModel?: string|null, now?: () => number, stdin?: any }} deps
+ * @param {{ env?: Record<string,string|undefined>, stdout?: any, stderr?: any, cwd?: string, provider?: any, providerFor?: any, judgeProvider?: any, judgeModel?: string|null, now?: () => number, stdin?: any, runlistHome?: string }} deps
  * @returns {Promise<number>}
  */
 export async function main(argv, deps = {}) {
@@ -528,6 +671,45 @@ export async function main(argv, deps = {}) {
   if (cmd === 'export') return doExport(rest, ctx);
   if (cmd === 'run') return doRun(rest, ctx);
   if (cmd === 'history') return doHistory(rest, ctx);
-  err(`unknown command ${JSON.stringify(cmd)} — one of: export, run, history`);
+  // `bareloop run-u` — the person-path run flow (PANEL-BUILD.md P0 task
+  // 2/4). `rest` is handed straight to `src/userrun.js`'s own `main(argv,
+  // deps)`, unparsed: that function is this flag grammar's one owner
+  // (`--job`/`--spec`/`--resume`/`--door`/`--decide`/`--text`/
+  // `--review-door`/`--approve`/`--registry`/`--workflow`/`--model`/
+  // `--read-shim`/`--scout`). `deps` is spread first so an injected test
+  // seam (`deps.provider`/`providerFor`/`judgeProvider`) still reaches it,
+  // then `env`/`out`/`err` are overridden to the SAME resolved values every
+  // other command here prints through, so `run-u`'s output lands on the
+  // `stdout`/`stderr` a caller of `main` actually passed.
+  if (cmd === 'run-u') return runUMain(rest, { ...deps, env, out, err });
+  // `bareloop interview` — the close-authoring interview (PANEL-BUILD.md P0
+  // task 3/4). This flow reads a TTY (or a piped stdin) directly rather than
+  // through the `out`/`err` line-functions every other command here uses, so
+  // it needs the raw streams, not the wrapped ones — `stdout`/`stderr` (both
+  // already resolved above) are handed through instead.
+  // `invokedAs: 'bareloop interview'` — the usage message names the command a
+  // person actually typed, never a script path they never invoked and may
+  // not have on disk (a branch-review nit; `scripts/run-interview.mjs` still
+  // supplies none, so it keeps naming itself when run directly).
+  if (cmd === 'interview') return interviewMain(rest, { ...deps, env, stdin: deps.stdin ?? process.stdin, stdout, stderr, invokedAs: 'bareloop interview' });
+  // `bareloop author` — the authoring pipeline (scout, declaration, D9's
+  // gates), same task. Same raw-stream reasoning: its one interactive seam
+  // (the confirm turn) reads stdin directly. Same `invokedAs` reasoning too.
+  if (cmd === 'author') return authorMain(rest, { ...deps, env, stdin: deps.stdin ?? process.stdin, stdout, stderr, invokedAs: 'bareloop author' });
+  // `bareloop replay` — the spine/gate-audit read side (PANEL-BUILD.md P0,
+  // last of the rung's four tasks). Synchronous, file-based, no interactive
+  // seam — same shape as `doHistory`/`doExport`, not the argv-owning
+  // `main(argv, deps)` modules the flows above delegate to.
+  if (cmd === 'replay') return doReplay(rest, ctx);
+  // `bareloop runs` / `bareloop runs backfill <dir>` — PANEL-BUILD.md P1's
+  // one run list. Read-only ($0): no interview, no author, no run trigger,
+  // no key ever read.
+  if (cmd === 'runs') return doRuns(rest, ctx);
+  // `bareloop panel [--port N]` — PANEL-BUILD.md P1's read-only HTTP panel.
+  // Never runs a job, spends money, or reads a key: it serves the run list
+  // and spine/gate-audit reads over `127.0.0.1` only. `deps.runlistHome`
+  // rides through the same injectable seam `run`/`run-u` already use.
+  if (cmd === 'panel') return panelMain(rest, { out, err, runlistHome: deps.runlistHome });
+  err(`unknown command ${JSON.stringify(cmd)} — one of: export, run, history, run-u, interview, author, replay, runs, panel`);
   return 1;
 }

package/src/index.js

@@ -237,7 +237,19 @@ export { runBehaviour, formatBehaviour } from './behaviour.js';
 // (`replayRun`) or one printable page (`formatReplay`). Reads only, mints no
 // verdict, writes nothing to the spine — reuses `runBehaviour` rather than
 // re-implementing the tool-call count.
-export { replayRun, formatReplay } from './replay.js';
+export { replayRun, formatReplay, summarizeForAllLine, formatAllLines } from './replay.js';
+// PANEL-BUILD.md P0 — the IO layer over `replayRun`: read one run's spine
+// (+ its gate-audit sibling) off disk, or list every spine directly in a
+// directory (content-detected, never by filename pattern — see the module
+// header) as `--all`-style rows. `readHistoryLog` is the one reader for a
+// bundle's `history.jsonl`, replacing `src/cli.js`'s own former hand-rolled
+// read. `src/replayio.js` also exports lower-level plumbing this package
+// root deliberately does NOT re-export (`parseJsonl`, `isSidecarByName`,
+// `looksLikeSpine`, `resolveSiblings`): a raw JSONL parser, a filename
+// predicate, and a sibling-path resolver are internal steps these three
+// functions already compose for a caller — not their own adopter-facing
+// promise, and an export here is a promise kept forever.
+export { replayOne, listSpines, readHistoryLog } from './replayio.js';
 // M4b — the interview, the refusal, the composition, and D9's three gates.
 // `prepareSigning` returns the resolved spec's HASH and the seed evidence; it
 // never signs — the approvals array and the human's word are unchanged.