bareloop 0.20.0 → 0.22.0

package/types/planrun.d.ts

@@ -221,7 +221,14 @@ export function planPrompt(job: any, scoutBlob: string, reds: any[] | null, maxS
  *   ladder (src/ladder.js). Arbiter territory exactly as the count it replaced was —
  *   the runner sets it, the plan cannot express it, and no step may tighten or raise
  *   it.
- * @param {number} [opts.closeTimeoutMs] close/check wall-clock cap (shell territory)
+ * @param {number} [opts.closeTimeoutMs] close/check wall-clock cap (shell territory).
+ *   OPTIONAL as of PRD item 27/M3: absent, this run autosets it from a $0 seed
+ *   timing pass (or the spec's own signed `closeTimeoutMs` override) — an
+ *   explicit value here still wins outright (backward compatibility/test
+ *   control only, F133: `scripts/run-u.mjs`/`src/cli.js` never pass this).
+ * @param {string|null} [opts.closeDir] the close's own books directory (PRD
+ *   item 27/M3 Part B), forwarded to every close invocation as
+ *   `BARELOOP_CLOSE_DIR`
  * @param {number} [opts.maxStepRounds] the shell's per-step rounds ceiling (validatePlan's bound)
  * @param {boolean} [opts.scout=true] operator-only switch (docs/product/SCOUT-CONTRAST.md):
  *        `false` on a FRESH run (no `resumeSeed`) skips the survey entirely — `scoutBlob`
@@ -392,12 +399,18 @@ export function planPrompt(job: any, scoutBlob: string, reds: any[] | null, maxS
  *   precisely the state the person rejected), and the words reach the PLANNER as new
  *   authoring. It is never a `humanRuling` — that answers a close's human STAGE, and
  *   a green-class job has none. Empty words are refused at the same seam every door is.
+ * @param {boolean} [opts.resumable=true] PRD item 27(c)/F130 — does THIS runner
+ *   support `--resume`? Forwarded verbatim from `runJob`; `run-u.mjs` leaves it at
+ *   the default (byte-identical to before this param existed), the bundle CLI
+ *   passes `false` so the three `--resume`-naming readouts below (`MONEY_OPTIONS`,
+ *   the resume-plan-red option, the fix-loop terminal) say "resume is `run-u`-only
+ *   in v1" instead of naming a flag that would fail if typed.
  * @returns {Promise<string>} 'green' | 'already-green' | 'escalated' | 'plan-red' |
  *   'check-red' | 'close-red' | 'close-unsupported' | 'recipe-stale' | 'pricing-red' |
  *   'branch-red' | 'cap-halt' | 'wall-halt' | 'provider-red' | 'interpreter-red' |
  *   'step-stalled' | 'hitl-pause' | 'hitl-decision-red' | `step-red:<id>`
  */
-export function runPlan(job: any, { workdir, provider, nativeProvider, providerFor, judgeProvider, emit, remainingUsd, isUnpriced, spendComplete, capRuns, strikeLimit, closeTimeoutMs, maxStepRounds, layerRoot, readShim, scout, scoutRounds, bridge, now, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, priorSpentUsd, reviewDoor, doorRerun }: {
+export function runPlan(job: any, { workdir, provider, nativeProvider, providerFor, judgeProvider, emit, remainingUsd, isUnpriced, spendComplete, capRuns, strikeLimit, closeTimeoutMs, closeDir, maxStepRounds, layerRoot, readShim, scout, scoutRounds, bridge, now, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, priorSpentUsd, reviewDoor, doorRerun, resumable }: {
     workdir: string;
     provider: any;
     nativeProvider?: ((o: {
@@ -414,6 +427,7 @@ export function runPlan(job: any, { workdir, provider, nativeProvider, providerF
     capRuns?: number | undefined;
     strikeLimit?: number | undefined;
     closeTimeoutMs?: number | undefined;
+    closeDir?: string | null | undefined;
     maxStepRounds?: number | undefined;
     scout?: boolean | undefined;
     scoutRounds?: number | undefined;
@@ -449,6 +463,7 @@ export function runPlan(job: any, { workdir, provider, nativeProvider, providerF
         fromRunid?: string | null;
         receivedAt?: string | null;
     } | null | undefined;
+    resumable?: boolean | undefined;
 }): Promise<string>;
 /**
  * The recorded bound-reason's ceiling in the WORKER-facing note. The reason is a

package/types/ralph.d.ts

@@ -54,17 +54,24 @@
  *
  * @param {string[]} close argv, e.g. ['node', '--test', 'close/']
  * @param {(s: string) => string} [redact] source scrubber; identity by default
- * @param {{ timeoutMs?: number, cwd?: string, expect?: number, judged?: {pattern: string, min: number}, gapKeep?: string }} [opts]
+ * @param {{ timeoutMs?: number, cwd?: string, expect?: number, judged?: {pattern: string, min: number}, gapKeep?: string, closeDir?: string|null }} [opts]
  *   close wall-clock cap (operator-set via the runner, never the config's — the
  *   agent must not author its arbiter's clock), the directory the close runs in
  *   (the workdir — the tree it is judging), the exit code the SIGNED spec calls
  *   success, the judgment-rendered signal, and the kept-failures pattern. All
  *   five are arbiter territory: the drafted workflow config cannot express any.
+ *   `closeDir` (PRD item 27/M3 Part B) is the close's OWN books directory —
+ *   pristine copies, calibration thresholds, logs — deliberately outside the
+ *   patient tree (the worker must never read the arbiter's books). Handed to
+ *   the child as `BARELOOP_CLOSE_DIR` (`CLOSE_DIR_ENV_VAR`,
+ *   src/close-integrity.js); a close script that needs one and gets none
+ *   instrument-stops itself, by the script's own contract — this seam only
+ *   ever THREADS the value, it never invents one.
  * @returns {Promise<{verdict: 'satisfied'|'needs_revision'|'failed'|'timed-out'|'killed'|'crashed',
  *   gap?: string, exitCode?: number, signal?: string, detail?: string,
  *   judgedCount?: number|null, unaudited?: boolean}>}
  */
-export function runClose(close: string[], redact?: (s: string) => string, { timeoutMs, cwd, expect, judged, gapKeep }?: {
+export function runClose(close: string[], redact?: (s: string) => string, { timeoutMs, cwd, expect, judged, gapKeep, closeDir }?: {
     timeoutMs?: number;
     cwd?: string;
     expect?: number;
@@ -73,6 +80,7 @@ export function runClose(close: string[], redact?: (s: string) => string, { time
         min: number;
     };
     gapKeep?: string;
+    closeDir?: string | null;
 }): Promise<{
     verdict: "satisfied" | "needs_revision" | "failed" | "timed-out" | "killed" | "crashed";
     gap?: string;
@@ -104,12 +112,13 @@ export function runClose(close: string[], redact?: (s: string) => string, { time
  *
  * @param {any[]} stages the stage list (already validated by validateJob)
  * @param {(s: string) => string} [redact] scrub, applied at capture on EVERY stage
- * @param {{timeoutMs?: number, cwd?: string}} [opts]
+ * @param {{timeoutMs?: number, cwd?: string, closeDir?: string|null}} [opts]
  * @returns {Promise<any>} runClose's verdict shape, plus `stage` and `stages`
  */
-export function runStages(stages: any[], redact?: (s: string) => string, { timeoutMs, cwd }?: {
+export function runStages(stages: any[], redact?: (s: string) => string, { timeoutMs, cwd, closeDir }?: {
     timeoutMs?: number;
     cwd?: string;
+    closeDir?: string | null;
 }): Promise<any>;
 /**
  * Bound an over-long close stream to a head sample + elided middle + tail. When
@@ -210,9 +219,13 @@ export function boundGap(s: string, keepPattern?: string): string;
  *   it to the gate audit's allow-decision writes. Injected like `redact` so the shell
  *   stays stdlib-only and dumb; consulted ONLY at a crashed verdict. With no seam, or
  *   with zero writes, a crash stays what it always was: an instrument stop.
+ * @param {string|null} [opts.closeDir] the close's own books directory
+ *   (PRD item 27/M3 Part B), forwarded to the raw `close` path's `runClose`
+ *   call unchanged; a caller supplying `judge` instead already closed over
+ *   its own `closeDir` and this param does nothing for it.
  * @returns {Promise<'green'|'escalated'>}
  */
-export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites }: {
+export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir }: {
     middle: (iteration: number, gap?: string) => void | Promise<void>;
     close?: string[] | undefined;
     judge?: (() => Promise<{
@@ -237,6 +250,7 @@ export function ralph({ middle, close, judge, capRuns, ladder, emit, redact, clo
     } | undefined;
     gapKeep?: string | undefined;
     workerWrites?: (() => string[]) | undefined;
+    closeDir?: string | null | undefined;
 }): Promise<"green" | "escalated">;
 /**
  * What the close child must NOT be able to read (operator ruling, 2026-07-31:

package/types/reuse.d.ts

@@ -1,3 +1,17 @@
+/**
+ * The name a cold green FORKS to when the entry of the job's own name greened a
+ * different close. Derived from the shape itself, so it is deterministic: the same
+ * close always lands in the same file, and the next green of that shape appends there
+ * instead of minting a third entry.
+ *
+ * The separator is a HYPHEN, not the `~` first proposed: the registry name IS the
+ * filename and `validateBridge` holds it to the same kebab alphabet the job validator
+ * uses (`^[a-z0-9][a-z0-9-]*$`), so a `~` name would be refused by the entry's own
+ * validator and the green would be lost — which is the exact failure this fork exists
+ * to prevent.
+ * @param {string} name @param {string[]} stageNames @returns {string}
+ */
+export function shapeForkName(name: string, stageNames: string[]): string;
 /**
  * Validate the reuse envelope — the three numbers the operator signs before the run.
  *
@@ -363,6 +377,7 @@ export function resumeTreeGate({ head, seed, dirty }: {
  * @param {number} [opts.capRuns] forwarded
  * @param {number} [opts.strikeLimit] forwarded (a plan step's strike ceiling)
  * @param {number} [opts.closeTimeoutMs] forwarded
+ * @param {string} [opts.closeDir] forwarded (PRD item 27/M3 Part B)
  * @param {boolean} [opts.layerRoot] forwarded
  * @param {boolean|'cap'|'diff'} [opts.readShim] the read shim's ARM (A0/A1/A2/A3), forwarded verbatim
  * @param {any} [opts.resume] RESUME (module C) — a `readResume` reading of the KILLED
@@ -397,6 +412,7 @@ export function runReuse(opts: {
     capRuns?: number | undefined;
     strikeLimit?: number | undefined;
     closeTimeoutMs?: number | undefined;
+    closeDir?: string | undefined;
     layerRoot?: boolean | undefined;
     readShim?: boolean | "cap" | "diff" | undefined;
     resume?: any;

package/types/reviewdoor.d.ts

@@ -40,6 +40,7 @@ export function doorAgeGate(door: any, { now, ttlMs }?: {
  * @param {string} opts.decision one of the three doors
  * @param {string|null} [opts.text] the rerun's words — the gap, and refused when empty
  * @param {number} [opts.closeTimeoutMs] the per-stage bound for the accept's re-run
+ * @param {string|null} [opts.closeDir] the close's own books directory (PRD item 27/M3 Part B), forwarded to the accept's re-run
  * @param {string|null} [opts.registryDir] the workflow registry, when the runner keeps one
  * @param {string|null} [opts.name] the workflow this run wrote its row against
  * @param {string|null} [opts.runid] the RUN's id, exactly as the bridge row records it
@@ -51,13 +52,14 @@ export function doorAgeGate(door: any, { now, ttlMs }?: {
  *   doorRecorded: boolean, reds: any[], mechanical: any, door: any, text: string|null,
  *   options: string[], ttlMs: number, note: string|null}>}
  */
-export function answerReviewDoor({ job, workdir, events, decision, text, closeTimeoutMs, registryDir, name, runid, at, now, ttlMs, emit, }: {
+export function answerReviewDoor({ job, workdir, events, decision, text, closeTimeoutMs, closeDir, registryDir, name, runid, at, now, ttlMs, emit, }: {
     job: any;
     workdir: string;
     events: any[];
     decision: string;
     text?: string | null | undefined;
     closeTimeoutMs?: number | undefined;
+    closeDir?: string | null | undefined;
     registryDir?: string | null | undefined;
     name?: string | null | undefined;
     runid?: string | null | undefined;

package/types/run.d.ts

@@ -45,7 +45,22 @@
  *   CLOSE-FIX loop (a plan STEP runs under the strike ladder instead)
  * @param {number} [opts.strikeLimit] shell-owned strike ceiling for a plan step's ladder
  * @param {number} [opts.shellCapUsd] the shell's hard USD ceiling
- * @param {number} [opts.closeTimeoutMs] close wall-clock cap (shell territory)
+ * @param {number} [opts.closeTimeoutMs] close wall-clock cap (shell territory).
+ *   OPTIONAL as of PRD item 27/M3: absent, the plan flow autosets it from a $0
+ *   seed timing pass (or reads the spec's own signed `closeTimeoutMs`
+ *   override) — a caller passing an explicit value here still wins outright
+ *   (backward compatibility / test control), but production callers
+ *   (`src/cli.js`, `scripts/run-u.mjs`) pass nothing (F133, run mtqwmb9l: a
+ *   runner that resolves this itself for its own purposes — e.g. `run-u.mjs`
+ *   sizing its outside watchdog, F67 — must never feed the number back in
+ *   here too, or this call's own autoset/override banner prints a SECOND,
+ *   mislabelled "explicit runner override" line on top of the runner's own
+ *   correctly-labelled one).
+ * @param {string|null} [opts.closeDir] the close's own books directory (PRD item
+ *   27/M3 Part B) — pristine copies, calibration thresholds, logs — outside
+ *   the patient tree. Forwarded to every close invocation as
+ *   `BARELOOP_CLOSE_DIR`; a close script that needs one and gets none
+ *   instrument-stops itself (`checkCloseDirRequired`, src/close-integrity.js).
  * @param {unknown} [opts.bridge] Layer 3 — a bridge-v1 entry to reuse as the drafter's
  *   STARTING DRAFT (design record 2026-08-01, D4), forwarded to the plan flow. Omitted is
  *   the cold path and is byte-identical to a pre-Layer-3 run. WHICH entry (the listing, an
@@ -141,13 +156,19 @@
  * @param {{text: string, fromRunid?: string|null, receivedAt?: string|null}|null} [opts.doorRerun]
  *   MODULE 8 — this leg IS the fresh engagement a signer commissioned at a previous
  *   run's review door, carrying their words. Forwarded verbatim.
+ * @param {boolean} [opts.resumable=true] PRD item 27(c)/F130 — does THIS runner
+ *   support `--resume` at all? `run-u.mjs` does (the default, `true`, byte-identical
+ *   to before this param existed); the exported bundle CLI does not (F130) and
+ *   passes `false` so the escalation tail's option strings say "resume is
+ *   `run-u`-only in v1" instead of naming a flag that would fail if typed. Forwarded
+ *   verbatim to the plan flow, which owns the three `--resume`-naming readouts.
  * @returns {Promise<string>} outcome: 'green' | 'already-green' | 'escalated' |
  *   'unapproved-spec' | 'job-red' | 'smoke-red' | 'plan-red' | 'check-red' |
  *   'close-red' | 'close-unsupported' | 'recipe-stale' | 'branch-red' | 'pricing-red' | 'provider-red' |
  *   'interpreter-red' | 'cap-halt' | 'wall-halt' | 'step-stalled' |
  *   'hitl-pause' | 'hitl-decision-red' | `step-red:<id>`
  */
-export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, layerRoot, readShim, scout, bridge, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun }: {
+export function runJob(rawSpec: object | string, { approvals, workdir, provider, nativeProvider, providerFor, judgeProvider, emit, capRuns, strikeLimit, shellCapUsd, closeTimeoutMs, closeDir, layerRoot, readShim, scout, bridge, priorSpentUsd, priorSpendComplete, priorWallMs, resumeSeed, resumeGrades, resumeReplans, resumeBranch, humanRuling, heldRuling, reviewDoor, doorRerun, resumable }: {
     approvals: unknown;
     workdir: string;
     provider: any;
@@ -164,6 +185,7 @@ export function runJob(rawSpec: object | string, { approvals, workdir, provider,
     strikeLimit?: number | undefined;
     shellCapUsd?: number | undefined;
     closeTimeoutMs?: number | undefined;
+    closeDir?: string | null | undefined;
     bridge?: unknown;
     priorSpentUsd?: number | undefined;
     priorSpendComplete?: boolean | undefined;
@@ -196,6 +218,7 @@ export function runJob(rawSpec: object | string, { approvals, workdir, provider,
         fromRunid?: string | null;
         receivedAt?: string | null;
     } | null | undefined;
+    resumable?: boolean | undefined;
 }): Promise<string>;
 /** @typedef {{code: string, path: string, detail?: string}} Red */
 /**

package/types/validate.d.ts

@@ -25,6 +25,34 @@ export function scopeContained(s: string): boolean;
 export function isObj(v: unknown): boolean;
 /** @param {unknown} v @returns {v is string} */
 export function isNonEmptyString(v: unknown): v is string;
+/**
+ * The candidate script path TOKEN a close stage's `cmd` names, by SHAPE
+ * alone — no fs, no cwd resolution, so this is safe for `validateJob` (pure)
+ * to call directly. Two recognized forms, first match wins:
+ *   - an INTERPRETER cmd: the token is the first argv[1..] element that is
+ *     PATH-SHAPED (not a `-`-prefixed flag, and either contains `/` or ends
+ *     in one of `.mjs .cjs .js .ts .sh .py`) — never just argv[1] outright.
+ *     `node --enable-source-maps ./close/x.mjs stage` names `./close/x.mjs`,
+ *     not `--enable-source-maps`; `python -m pytest` and `npx tsc --noEmit`
+ *     name NOTHING (`-m`/`--noEmit` are flags, `pytest`/`tsc` are bare
+ *     command names with no path shape) — fixed 2026-09-06 (orchestrator
+ *     audit) after the earlier bare-argv[1] version demanded a sha256 for a
+ *     token that named no file, making such a spec unsignable forever (the
+ *     sign helper reads nothing, the validator reds permanently);
+ *   - a bare cmd whose argv[0] ITSELF is an absolute path (no interpreter
+ *     prefix — a `.sh`/other directly-executable close script) → the token
+ *     is argv[0].
+ * Anything else — a relative bare executable (`true`, `pytest`), an
+ * interpreter with no path-shaped argument (`python -m pytest`, `npx tsc
+ * --noEmit`), a non-string/empty cmd — names no addressable file under this
+ * scheme and returns null; those stages carry no sha256 demand and are
+ * invisible to the byte/path detectors, exactly as they always were (most
+ * test-fixture closes use exactly this shape on purpose, to exercise
+ * runtime behaviour with no real script file at all).
+ * @param {unknown} cmd
+ * @returns {string|null}
+ */
+export function closeScriptCandidateToken(cmd: unknown): string | null;
 /**
  * Scan a RAW text stream (a spine file, a close's output, a transcript) for
  * known secret shapes and return the literal matches. The ONE spelling of the
@@ -177,4 +205,24 @@ export function hasNestedQuantifier(src: string): boolean;
  * @param {(code: string, path: string, detail?: string) => void} red
  */
 export function sweepNestedQuantifiers(root: any, red: (code: string, path: string, detail?: string) => void): void;
+/**
+ * PRD item 27/M2 close-bytes signature, orchestrator-flagged gap
+ * (2026-09-06): a close stage's `cmd` can name an addressable script TWO
+ * ways — `node <path> …` (M1's original scope) or a BARE directly-executable
+ * absolute path (a `.sh` wrapper, e.g. `jobs/aurora-testgen-cold.json`'s
+ * close, which `readCloseScripts` used to skip entirely, leaving both
+ * `close-absolute-path` and the sha256 signature blind to it — a "blind
+ * instrument" the audit named directly). This list is the shared, STATIC
+ * (no fs) shape test both `src/job.js` (which only needs to know WHETHER a
+ * stage names an addressable script, to decide whether `sha256` is
+ * demanded) and `src/close-integrity.js` (which resolves the token against
+ * a real cwd and reads it off disk) key off — one spelling, so the demand
+ * and the detector can never drift apart about which stages are in scope.
+ * A leading-interpreter cmd (`sh`/`bash`/`python`/`python3`/`npx` besides
+ * `node`) is included for the same reason `node` is: a close author may use
+ * any of them, and a scope that only recognized `node` would just move the
+ * blind spot rather than close it.
+ * @type {readonly string[]}
+ */
+export const CLOSE_SCRIPT_INTERPRETERS: readonly string[];
 export const SECRET_PATTERNS: RegExp[];