bareloop 0.5.1 → 0.6.0

package/src/run.js

@@ -1,83 +1,23 @@
-// The N2 runner — the shell's top layer. It owns everything the emergent parts
+// The runner — the shell's top layer. It owns everything the emergent parts
 // must never touch: the approval gate (human-signs-always), the primitive
 // smoke, the ONE budget ledger (cap-not-estimate; unpriced is never free, F6),
-// step sequencing, and the decision-ready stops. It composes the pieces below
-// it (drafting → validateConfig → per-step interpret loops) and interprets
-// nothing itself. Design record: docs/plans/2026-07-12-n2-headless-loop-design.md.
+// and the decision-ready stops. It composes the plan flow below it and
+// interprets nothing itself.
+// Design record: docs/plans/2026-07-12-n2-headless-loop-design.md.
+//
+// The legacy operator-authored `steps[]` path was DELETED 2026-07-26 (PRD
+// v1.32): the drafting call, config-v1, the per-step interpret loops and the
+// hitl draft-PR step went with it. runJob is now approval → smoke → ledger →
+// runPlan, and `hitl`/`soft-green` return as a Layer 3 decision, rebuilt in the
+// plan shape rather than ported.
 
-import { createRequire } from 'node:module';
 import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { LiteCtx, COMPRESS_LEVELS, KINDS } from 'litectx';
-import { redact } from 'bareguard';
+import { LiteCtx } from 'litectx';
 import { validateJob, jobSpecHash, checkApproval } from './job.js';
-import { validateConfig, LOOP_SHAPES, SLOTS, VERBS, globToPrefix, SECRET_PATTERNS, REMEMBER_KINDS } from './validate.js';
-import { interpret } from './interpret.js';
 import { runPlan } from './planrun.js';
-import { runClose, CLOSE_FAULTS } from './ralph.js';
-import { extractArtifact, priceOf } from './text.js';
-
-const require = createRequire(import.meta.url);
-const { Loop } = require('bare-agent');
 
 /** @typedef {{code: string, path: string, detail?: string}} Red */
 
-/**
- * The shell's own drafting allowance, carved out of the job budget (F9).
- * Drafting is a paid shell call that happens BEFORE the config it produces is
- * validated — so a ceiling advertised as the whole job budget is invalidated by
- * the very call that answers it, and a rational drafter (one that claims the
- * ceiling it is given) deadlocks every run. The shell therefore reserves this
- * slice for itself and advertises `budget − reserve` as the ceiling the config
- * may claim. It is a CAP, not an estimate: overspend it and the run stops on
- * the budget story it is, never on a config-red blaming the drafter.
- */
-const DRAFT_RESERVE_FRAC = 0.05;
-/** truncate (never round up) — an advertised ceiling must be one the shell can honour */
-const floor4 = (/** @type {number} */ n) => Math.floor(n * 10_000) / 10_000;
-
-// The drafting prompt: a schema DESCRIPTION built from the live validator
-// menus — never a copyable example config (the drafter must author, not echo;
-// the N2 drafting probe proved a frontier model greens on this, F6). The
-// DRAFT-CONFIG sentinel is fixed shell vocabulary, not content.
-// REMEMBER_KINDS comes from the validator: the prompt advertises the SAME menu
-// the validator enforces — one source, no drift.
-/** @param {any} job @param {Red[]|null} reds @param {number} ceiling the budget the config may actually claim (F9) */
-function draftPrompt(job, reds, ceiling) {
-  const doc = `DRAFT-CONFIG
-You are drafting a workflow config (schema "v1") for the job spec below. The config is
-pure declarative JSON validated by a strict schema; ANY unknown field, wrong enum value,
-or out-of-bounds number is rejected. Output ONLY the JSON object, no fences, no commentary.
-
-Required top-level fields (no others exist):
-- "schema": must be exactly "v1"
-- "loop": { "shape": one of ${JSON.stringify([...LOOP_SHAPES])}, "maxIterations": optional integer 1..8 }
-- "memory": { "store": must be "litectx",
-    "recall": optional { "k": integer 1..20, "kinds": optional non-empty subset of ${JSON.stringify([...KINDS])} },
-    "compressLevel": optional, one of ${JSON.stringify([...COMPRESS_LEVELS])} }
-- "gate": { "budgetUsd": number, 0 < n <= the ceiling stated below, "writeScope": array of path-prefix globs like "src/**" }
-- "escalation": { "mode": must be "decision-ready" }
-- "hooks": optional; keys from ${JSON.stringify([...SLOTS])}, each an array of ops.
-  Each op is { "op": one of ${JSON.stringify([...VERBS])}, ...params }. STRICT slot legality:
-  "recall" (optional "k", "kinds") and "compress" (optional "level") ONLY in "before-attempt";
-  "stash" (no params) ONLY in "after-red"; "remember" (optional "kind", one of
-  ${JSON.stringify(REMEMBER_KINDS)}) ONLY in "on-green".
-
-Hard constraints from the job spec (violations are rejected):
-- Every writeScope entry must fit INSIDE the job's writeScope (${JSON.stringify(job.writeScope)}).
-  No "..", no absolute paths, no mid-path wildcards.
-- gate.budgetUsd must be <= ${ceiling}. (This is ONE STEP's share of the job's
-  $${job.budgetUsd} budget, minus the shell's own drafting allowance: this config is drafted
-  once and reused for every step, so the number must still fit after earlier steps have
-  spent. Claiming exactly ${ceiling} is legal and validates.)
-- The config CANNOT contain close commands, provider choice, retry caps, or minting claims.
-
-Job spec:
-${JSON.stringify(job, null, 2)}`;
-  return reds
-    ? `${doc}\n\nYour previous draft was REJECTED with these reds (code:path):\n${JSON.stringify(reds)}\nFix every red. Output ONLY the corrected JSON object.`
-    : doc;
-}
 
 /**
  * Known-answer smoke on the primitive the run is about to trust (PRD v1.5 §4,
@@ -99,71 +39,6 @@ async function primitiveSmoke(workdir) {
   }
 }
 
-/** @typedef {(argv: string[], opts?: {cwd?: string}) => {status: number|null, stdout: string, stderr: string}} ExecCmd */
-
-/** default process runner for the hitl PR mechanics — real spawnSync, no shell
- * @type {ExecCmd} */
-const defaultExec = (argv, { cwd } = {}) => {
-  const r = spawnSync(argv[0], argv.slice(1), { cwd, encoding: 'utf8', timeout: 60_000 });
-  if (r.error) return { status: null, stdout: '', stderr: String(r.error) };
-  return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
-};
-
-/**
- * The hitl middle's work (2b): branch → stage the job fence ONLY → commit →
- * push → draft PR. Deterministic runner code, never model tools (the model
- * never sees a git or gh surface — design addendum 2026-07-12b). Staging is
- * fence-scoped so spines, audit logs, and anything else living in the workdir
- * never enter the PR. Any failure is an honest red carrying the failed argv;
- * the caller still escalates — a broken PR path must never swallow the
- * escalation (the pain channel, law #7).
- * The checkout is handed back exactly as it was found: the starting branch is
- * read BEFORE anything moves and restored on EVERY path, success or failure
- * (found by the real job #1 run, 2026-07-13 — the workdir was left sitting on
- * the bareloop branch, so the next cadenced run would branch off yesterday's
- * unmerged branch and judge its close against that state). A restore that
- * itself fails is loud (`strandedOn`), never silent.
- *
- * @param {{workdir: string, branch: string, title: string, body: string, addPaths: string[], exec: ExecCmd}} o
- * @returns {Promise<{url: string|null, red: {argv: string, detail: string}|null, strandedOn: string|null}>}
- */
-async function openDraftPr({ workdir, branch, title, body, addPaths, exec }) {
-  // Subprocess output is scrubbed AT CAPTURE with the ONE shape inventory —
-  // the same doctrine as the close path (interpret wires SECRET_PATTERNS into
-  // ralph): git/gh error text can echo a credentialed remote URL, and the
-  // detail lands on the append-only spine (pr-red + the escalation's pr.error).
-  const scrub = (/** @type {string} */ s) => redact(s, { patterns: SECRET_PATTERNS });
-  const head = exec(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], { cwd: workdir });
-  const startBranch = head.status === 0 ? head.stdout.trim() : '';
-  /** put the checkout back where it started; report the branch it is stranded on if that fails */
-  const restore = () => {
-    if (!startBranch) return null; // never knew where we started — nothing honest to restore to
-    const r = exec(['git', 'checkout', startBranch], { cwd: workdir });
-    return r.status === 0 ? null : branch;
-  };
-  /** @param {{url?: string|null, red?: {argv: string, detail: string}|null}} o */
-  const done = ({ url = null, red = null }) => ({ url, red, strandedOn: restore() });
-
-  const steps = [
-    ['git', 'checkout', '-b', branch],
-    ['git', 'add', '--', ...addPaths],
-    ['git', 'commit', '-m', title],
-    ['git', 'push', '-u', 'origin', branch],
-    ['gh', 'pr', 'create', '--draft', '--title', title, '--body', body],
-  ];
-  for (const argv of steps) {
-    const r = exec(argv, { cwd: workdir });
-    if (r.status !== 0) {
-      return done({ red: { argv: argv.join(' '), detail: `${argv.slice(0, 2).join(' ')} failed: ${scrub((r.stderr || r.stdout || `exit ${r.status}`)).trim().slice(0, 500)}` } });
-    }
-    if (argv[0] === 'gh') {
-      const url = (r.stdout.match(/https?:\/\/\S+/) ?? [null])[0];
-      // a "successful" gh with no link is not a PR the human can act on
-      return url ? done({ url }) : done({ red: { argv: argv.join(' '), detail: 'no PR URL in gh output' } });
-    }
-  }
-  return done({ red: { argv: 'gh pr create', detail: 'PR step never ran' } }); // unreachable while gh is last; belt for edits
-}
 
 /**
  * Run an approved job end to end: approval gate → primitive smoke → sequential
@@ -194,35 +69,52 @@ async function openDraftPr({ workdir, branch, title, body, addPaths, exec }) {
  * @param {object} opts
  * @param {unknown} opts.approvals `{ specHash, signer, ts }` records (from OUTSIDE the spec)
  * @param {string} opts.workdir the run directory (the fence's root)
- * @param {string} [opts.target] the step artifact path (text-mode steps; unused by tool-mode steps)
  * @param {any} opts.provider shell-owned LLM binding (never the config's; the Loop path)
  * @param {(o: {policy: Function, onTurn?: Function, maxTurns: number, hasTools: boolean}) => any} [opts.nativeProvider]
  *   native clipipe provider factory (BA-16), required for a `clipipe-subscription` plan-shape job —
  *   threaded to runPlan, which builds one per worker (native tool mode when `hasTools`, else a
  *   metered claude-json text provider for the toolless drafter); ignored on every Loop-driven provider
  * @param {(type: string, data?: object) => object} opts.emit spine emitter
- * @param {number} [opts.capRuns] shell-owned per-step iteration cap
+ * @param {(tier: string) => any} [opts.providerFor] P: per-step model-tier provider factory (forwarded to the plan flow)
+ * @param {number} [opts.capRuns] shell-owned per-step attempt cap
  * @param {number} [opts.shellCapUsd] the shell's hard USD ceiling
  * @param {number} [opts.closeTimeoutMs] close wall-clock cap (shell territory)
- * @param {ExecCmd} [opts.execCmd] process runner for the hitl PR mechanics
  * @param {boolean} [opts.layerRoot=false] Layer R (within-run ratchet) — shell
- *        territory, threaded to every predicate step's interpreter. Defaults OFF
+ *        territory, threaded to the plan flow. Defaults OFF
  *        (decided 2026-07-21): fixation is extinct on every current job (F41), so
  *        ON has never won its own A/B — the acceptance read defers to Layer 2 (or
  *        a manufactured-fixation probe). `true` is the ON/experimental arm; the
  *        default is the OFF arm. (Shell-owned seam, same doctrine as the provider
  *        binding.)
- * @returns {Promise<string>} outcome: 'green' | 'escalated' | 'unapproved-spec' |
- *   'job-red' | 'smoke-red' | 'config-red' | 'pricing-red' | 'provider-red' |
- *   'cap-halt' | 'close-unsupported' | `step-red:<id>`
+ * @returns {Promise<string>} outcome: 'green' | 'already-green' | 'escalated' |
+ *   'unapproved-spec' | 'job-red' | 'smoke-red' | 'plan-red' | 'check-red' |
+ *   'close-red' | 'close-unsupported' | 'pricing-red' | 'provider-red' |
+ *   'interpreter-red' | 'cap-halt' | 'wall-halt' | 'step-stalled' | `step-red:<id>`
  */
-export async function runJob(rawSpec, { approvals, workdir, target, provider, nativeProvider, emit, capRuns = 3, shellCapUsd = 2, closeTimeoutMs, execCmd = defaultExec, layerRoot = false }) {
+export async function runJob(rawSpec, { approvals, workdir, provider, nativeProvider, providerFor, emit, capRuns = 3, shellCapUsd = 2, closeTimeoutMs, layerRoot = false }) {
   // 0. the ledger's counters, declared FIRST so that every job-end — including
   // the pre-token reds below — can state a real figure. An omitted `spentUsd` is
   // not a zero: a consumer reads `undefined` and either crashes or launders it
   // into $0 (F12's class, at the terminal record instead of mid-attempt).
   let spentUsd = 0;
   let unpriced = false;
+  // W1: did this run ABSORB a stall? The terminal `step-stalled` is the rare case;
+  // the common one self-heals (src/stall.js abandons the hung call and reissues),
+  // and an abandoned call may already have been billed — a reissue can pay twice
+  // and the provider never told us. So a run that stalls and then ends green (or
+  // escalated, or at the cap) also holds a FLOOR, not a total.
+  let stalled = false;
+  // F64: did the wall cut this run from INSIDE a provider call? A `wall-halt` is two
+  // stops wearing one name. Read between rounds (or between attempts, W-2) it is the
+  // cleanest terminal there is — nothing was in flight, every round the sum counted
+  // came back priced, and the figure is exact. But the deadline can also land inside a
+  // call and come back as the provider's own timeout, and THAT call returned no usage
+  // at all: it may already have been billed and will never say so. Same unknown as the
+  // transport floor and the self-healed stall, so the same honest answer.
+  // The discriminator is the wall-halt record's own `cutMidCall` field, never the
+  // outcome — keying on the outcome would floor the exact stop too, which is the same
+  // dishonesty pointing the other way.
+  let cutMidCall = false;
   // The money on the terminal record, and whether the money is EXACT. `spentUsd`
   // is the accumulated sum of PRICED rounds ONLY — never an estimate derived
   // from tokens or averages (cap-not-estimate). When any round came back
@@ -230,7 +122,7 @@ export async function runJob(rawSpec, { approvals, workdir, target, provider, na
   // says so machine-readably instead of dressing a floor up as exact. Emitted on
   // EVERY job-end (true when everything was priced) so no consumer ever has to
   // branch on field presence.
-  const spend = () => ({ spentUsd, spendComplete: !unpriced });
+  const spend = () => ({ spentUsd, spendComplete: !unpriced && !stalled && !cutMidCall });
   // 1. human-signs-always — before ANY provider call (N1 decision #1)
   if (!checkApproval(rawSpec, approvals)) {
     emit('job-end', { outcome: 'unapproved-spec', detail: 'no approval record matches this exact spec version', ...spend() });
@@ -243,22 +135,9 @@ export async function runJob(rawSpec, { approvals, workdir, target, provider, na
     return 'job-red';
   }
   const job = /** @type {any} */ (jv.job);
-  // Layer 2: the two exclusive shapes (decision 6). A plan-shape spec (goal/
-  // verdictType/close/checks[]) has no steps[] and its steps are tool-mode by
-  // construction — the text-mode target rule below is a legacy-steps rule only.
-  const planShape = job.goal !== undefined;
-  // Reds-before-tokens: a text-mode predicate step writes ONE artifact — with
-  // no target it would burn a draft + a worker call and then crash inside the
-  // middle as a misfiled interpreter-red. The spec is fine; the CALL is not.
-  if (!planShape && (typeof target !== 'string' || !target)
-      && job.steps.some((/** @type {any} */ s) => s.close.type === 'predicate' && (s.mode ?? 'text') === 'text')) {
-    emit('job-red', { code: 'missing-required', path: 'opts.target', detail: 'text-mode steps write ONE artifact — pass opts.target (reds-before-tokens)' });
-    emit('job-end', { outcome: 'job-red', ...spend() });
-    return 'job-red';
-  }
   emit('job-start', {
     job: job.job, specHash: jobSpecHash(job), budgetUsd: job.budgetUsd,
-    ...(planShape ? { shape: 'plan', goal: job.goal } : { steps: job.steps.map((/** @type {any} */ s) => s.id) }),
+    shape: 'plan', goal: job.goal,
   });
 
   // 2. known-answer smoke before tokens (A3: silent degradation throws nothing)
@@ -288,6 +167,15 @@ export async function runJob(rawSpec, { approvals, workdir, target, provider, na
     // unknown, never $0 — F6): per-round metering means a partially-unpriced run
     // is caught natively, round by round, with no separate unpricedRounds tally.
     if (type === 'worker-round') account(/** @type {any} */ (data)?.costUsd);
+    // W1: a `stall` is the plan flow announcing it ABANDONED a call and reissued
+    // it. The abandoned call's spend is unknowable from here (billed or not,
+    // indistinguishable), so from this point the priced sum is a floor no matter
+    // how the run ends — the flag is one-way and read by `spend()`.
+    if (type === 'stall') stalled = true;
+    // F64: the plan flow's own TIME record says which of the two wall stops this was.
+    // One-way, and read by `spend()` — the run ends on this record either way, but the
+    // between-rounds stop must keep its exact figure rather than inheriting a floor.
+    if (type === 'wall-halt' && /** @type {any} */ (data)?.cutMidCall === true) cutMidCall = true;
     return emit(type, data);
   };
   const pricingRed = () => {
@@ -296,249 +184,32 @@ export async function runJob(rawSpec, { approvals, workdir, target, provider, na
     return 'pricing-red';
   };
 
-  // ── Layer 2 dispatch: the plan flow (SCOUT → PLAN → EXECUTE → close) under
-  // the SAME approval gate, smoke, and ledger — runJob stays the one entry
-  // (N2 lock). runPlan emits every provider round as worker-round, so the
-  // metered emit above accounts the plan flow natively (F12); the job-end
-  // money contract is identical to the legacy path.
-  if (planShape) {
+  // ── the plan flow (SCOUT → PLAN → EXECUTE → close) under the approval gate,
+  // the smoke and the ledger above — runJob stays the one entry (N2 lock).
+  // runPlan emits every provider round as worker-round, so the metered emit
+  // accounts it natively (F12) and the job-end money contract is unchanged.
+  {
     const outcome = await runPlan(job, {
-      workdir, provider, nativeProvider, emit: meter, capRuns, closeTimeoutMs, layerRoot,
+      workdir, provider, nativeProvider, providerFor, emit: meter, capRuns, closeTimeoutMs, layerRoot,
       remainingUsd: () => Math.min(shellCapUsd, job.budgetUsd - spentUsd),
       isUnpriced: () => unpriced, // F6: let the plan flow bail in-flight, not just after it returns
     });
     if (unpriced) return pricingRed();
     if (outcome.startsWith('step-red:')) {
       emit('job-end', { outcome: 'step-red', step: outcome.slice('step-red:'.length), ...spend() });
-    } else if (outcome === 'provider-red') {
+    } else if (outcome === 'provider-red' || outcome === 'step-stalled') {
       // F44: a transport-throw provider-red never returned a usage figure for the
-      // failed call, so the priced sum is a FLOOR, not the total — mirror the
-      // legacy providerRed(): spendComplete false, never overclaim an exact total.
+      // failed call, so the priced sum is a FLOOR, not the total — spendComplete
+      // false, never an exact-looking total.
+      // F66: `step-stalled` carries the same unknown. Every abandoned call MAY
+      // already have been billed by the provider before it went quiet — that is
+      // the known cost of self-heal — and an unbilled reissue is indistinguishable
+      // from a billed one from here. Reporting the priced sum as exact would be F6
+      // in a self-heal coat.
       emit('job-end', { outcome, ...spend(), spendComplete: false });
     } else {
       emit('job-end', { outcome, ...spend() });
     }
     return outcome;
   }
-
-  // 4. sealed drafting: one shot + one redraft, reds fed back, PRICED path
-  // (through Loop, the same accounting the worker uses — never around it, F6)
-  const drafter = new Loop({ provider, system: 'You draft workflow configs as pure JSON. Output only the JSON object.' });
-  /** @type {string|null} a transport throw from the drafting call — spend UNKNOWN, terminal */
-  let transportRed = null;
-  /** @type {string|null} a drafting round the API TRUNCATED (BA-6, bare-agent 0.27.0) — provider-red like
-   * a throw, but the round WAS metered so spend is known; must never launder into a config-red (F25). */
-  let draftTruncated = null;
-  /** @param {Red[]|null} reds */
-  const draft = async (reds) => {
-    let r;
-    try {
-      r = await drafter.run([{ role: 'user', content: draftPrompt(job, reds, ceilingNow()) }]);
-    } catch (e) {
-      // Loop defaults throwOnError: true — a misconfigured binding or a bare
-      // transient 500 REJECTS here. The spend is UNKNOWN (F6), and the spine
-      // must still terminate: never an unhandled rejection out of the runner.
-      transportRed = String(/** @type {Error} */ (e)?.message ?? e);
-      emit('draft-result', { costUsd: null, redraft: reds !== null, error: transportRed });
-      return null;
-    }
-    const { costUsd, unpricedRounds } = priceOf(r); // the ONE honest-null cost read (F6)
-    account(costUsd);
-    if (unpricedRounds > 0) unpriced = true;
-    emit('draft-result', { costUsd, redraft: reds !== null, error: r.error ?? null });
-    // BA-6: the API cut the drafting round off mid-JSON. That is provider-red (the API's
-    // fault, not the drafter's), so it must NOT be laundered into a config-red blaming the
-    // drafter (F25's class) and must NOT consume the redraft — retrying a truncation blindly
-    // just burns budget; the human decides. Metered above, so unlike transportRed spend is known.
-    if (typeof r.error === 'string' && r.error.startsWith('truncated:')) { draftTruncated = r.error; return null; }
-    return r.error ? null : (extractArtifact(r.text).code ?? '');
-  };
-  const providerRed = () => {
-    emit('escalation', { category: 'provider-red', decisionReady: true, decision: 'The provider path threw before a result existed — spend for the failed call is unknown (F6), and no drafting verdict exists.', options: ['fix the provider binding', 'retry the run', 'abandon the run'], detail: transportRed, spentUsd });
-    // A transport THROW never returned a usage figure, so the floor is NOT the total
-    // (F6): spendComplete must be false — spend()'s `!unpriced` only knows about priced
-    // rounds that came back unpriced, not a call that never returned at all. Leaving it
-    // true would have the job-end contradict the escalation's own "spend … is unknown".
-    emit('job-end', { outcome: 'provider-red', ...spend(), spendComplete: false });
-    return 'provider-red';
-  };
-  const capNow = () => Math.min(shellCapUsd, job.budgetUsd - spentUsd);
-  // The ceiling the CONFIG may claim (F9): the job budget minus the shell's own
-  // drafting allowance, and never above what is actually left. Advertised in the
-  // prompt and enforced by the validator — ONE number, so a drafter that claims
-  // the ceiling it was given always validates. (Before: the prompt advertised the
-  // whole job budget while the validator enforced budget − drafting-spend, a bound
-  // the drafter was never told and could not satisfy.)
-  // ...and a PER-STEP share of it, not the whole pot. The config is drafted ONCE
-  // and re-validated at every step against what is LEFT, so a ceiling sized to the
-  // whole budget is stale the moment step 1 spends: step 2 then reds `bounds` on an
-  // unchanged config with plenty of money still in the pot (review 2026-07-18).
-  // Dividing by the steps that will actually run a worker makes the number the
-  // drafter is handed one that still fits after its predecessors have spent —
-  // sum(shares) = budget − reserve, so every step can claim its share. This is a
-  // DRAFTING change, not an enforcement one: cap-not-estimate is untouched, and a
-  // step that needs more than its share still cap-halts cleanly with a resume
-  // point. Single-step jobs (every shipped job today) are arithmetically unchanged.
-  const loopSteps = Math.max(1, job.steps.filter((s) => s.close.type === 'predicate').length);
-  const workerCeiling = floor4(job.budgetUsd * (1 - DRAFT_RESERVE_FRAC) / loopSteps);
-  const ceilingNow = () => Math.min(workerCeiling, capNow());
-  const cOpts = () => ({ shellCapUsd: ceilingNow(), jobWriteScope: job.writeScope });
-  // Drafting is DEFERRED to the first step that needs a worker (resume model,
-  // design addendum 2026-07-13): a step whose close already greens skips for
-  // zero tokens, so a clean rerun may need no config at all — drafting one no
-  // interpret will ever read is spend for nothing (F6's spirit). Decision #3
-  // holds: when a config IS needed, it is drafted fresh THIS run, never inherited.
-  /** @type {any} the validated config, drafted on first need */
-  let config = null;
-  /** @returns {Promise<string|null>} a terminal job outcome, or null with `config` set */
-  const ensureConfig = async () => {
-    if (config) return null;
-    let text = await draft(null);
-    let cv = validateConfig(text ?? '', cOpts());
-    emit('config-validate', { ok: cv.ok, reds: cv.reds, phase: 'draft-1' });
-    // the redraft only fires when it can still help: not over a transport red,
-    // not over unpriced spend, and never over an already-blown budget (a paid
-    // call against a negative cap can only red again — budget story, not drafter)
-    if (!cv.ok && !unpriced && !transportRed && !draftTruncated && capNow() > 0) {
-      text = await draft(cv.reds);
-      cv = validateConfig(text ?? '', cOpts());
-      emit('config-validate', { ok: cv.ok, reds: cv.reds, phase: 'draft-2' });
-    }
-    if (transportRed) return providerRed();
-    if (draftTruncated) {
-      // A truncated draft is provider-red, NOT config-red — the API cut it off; the drafter is
-      // not on trial. Mirrors the worker path (interpret.js) and the human's options: the round
-      // was metered, so this is a fault with a known cost, not a spend-unknown transport throw.
-      emit('escalation', { category: 'provider-red', decisionReady: true, decision: 'The drafting round was truncated at the output cap (BA-6) — the API cut the config off mid-generation, so no valid config exists. Not the drafter\'s competence (never a config-red), and not silently retried.', options: ['raise the drafting cap and rerun', 'retry the run', 'abandon the run'], detail: draftTruncated, spentUsd });
-      emit('job-end', { outcome: 'provider-red', ...spend() });
-      return 'provider-red';
-    }
-    if (unpriced) return pricingRed();
-    if (!cv.ok) {
-      if (capNow() <= 0) {
-        // drafting consumed the whole job budget before a valid config existed —
-        // the honest stop is a cap story, never a config-red blaming the drafter
-        emit('cap-halt', { category: 'cap-halt', meaning: 'not under cap — not "can\'t"', spentUsd, budgetUsd: job.budgetUsd });
-        emit('escalation', { category: 'cap-halt', decisionReady: true, decision: `Drafting spend ($${spentUsd.toFixed(4)}) consumed the job budget ($${job.budgetUsd}) before a valid config existed.`, options: ['raise the job budget and rerun', 'abandon the run'], spentUsd });
-        emit('job-end', { outcome: 'cap-halt', ...spend() });
-        return 'cap-halt';
-      }
-      for (const r of cv.reds) emit('config-red', r);
-      emit('job-end', { outcome: 'config-red', ...spend() });
-      return 'config-red';
-    }
-    config = cv.config;
-    return null;
-  };
-
-  // 5. sequential per-step loops under the one ledger; a step-red stops the
-  // job and the stop is a result (ladder discipline applied to steps)
-  for (const step of job.steps) {
-    if (step.close.type === 'hitl') {
-      // Nothing changed in the fence → nothing for a human to review (found by
-      // the real job #1 run, 2026-07-13): a cadenced run whose steps all skip
-      // already-green would otherwise branch/add/commit, and `git commit`
-      // correctly fails ("nothing added to commit") — a broken-PR escalation
-      // every single day. A hitl close is a human decision point; with no
-      // changes there IS no decision. Only an AFFIRMATIVE clean answer skips:
-      // a failed check (not a repo, broken git) falls through to the PR path
-      // and reds honestly there — an unknown fence state is never a green.
-      const fence = job.writeScope.map((/** @type {string} */ g) => globToPrefix(g));
-      const st = execCmd(['git', 'status', '--porcelain', '--', ...fence], { cwd: workdir });
-      if (st.status === 0 && st.stdout.trim() === '') {
-        emit('pr-skipped', { step: step.id, reason: 'no changes in the job fence — nothing for a human to review' });
-        emit('step-end', { step: step.id, outcome: 'already-green', spentUsd });
-        continue;
-      }
-      // the hitl middle's work (2b): deterministic branch/commit/draft-PR —
-      // model tools never touch git; a PR failure is red + escalation, never a
-      // swallowed escalation
-      const branch = `bareloop/${job.job}-${Date.now().toString(36)}`;
-      const title = `bareloop draft: ${job.job}`;
-      const pr = await openDraftPr({
-        workdir, branch, title,
-        body: `${job.description}\n\nstep: ${step.id}\nprompt: ${step.close.prompt}\nspent: $${spentUsd.toFixed(4)} of $${job.budgetUsd}\n\nDraft by bareloop — merge stays human, forever.`,
-        addPaths: job.writeScope.map((/** @type {string} */ g) => globToPrefix(g)),
-        exec: execCmd,
-      });
-      if (pr.red) emit('pr-red', { step: step.id, ...pr.red });
-      else emit('pr-opened', { step: step.id, branch, url: pr.url });
-      // a checkout left on a bareloop branch poisons the NEXT cadenced run's
-      // baseline — loud, and never allowed to un-open a real PR
-      if (pr.strandedOn) emit('workdir-red', { step: step.id, branch: pr.strandedOn, detail: 'the run could not return the checkout to its starting branch — the next run would build on this one' });
-      emit('escalation', { category: 'hitl-close', decisionReady: true, step: step.id, prompt: step.close.prompt, spentUsd, decision: step.close.prompt, options: ['approve', 'reject'], pr: { url: pr.url, branch, error: pr.red?.detail ?? null } });
-      emit('job-end', { outcome: 'escalated', step: step.id, ...spend() });
-      return 'escalated'; // by design: the human acts outside the run, forever
-    }
-    if (step.close.type !== 'predicate') {
-      // honest refusal: gold/rubric EXECUTION lands with the verdict classes
-      // (N4); a fake verdict here would poison every contrast downstream
-      emit('escalation', { category: 'close-unsupported', decisionReady: true, step: step.id, decision: `Step "${step.id}" has a ${step.close.type} close — N2 executes predicate and hitl closes only.`, options: ['restate the close as a predicate', 'wait for the verdict-classes rung'] });
-      emit('job-end', { outcome: 'close-unsupported', step: step.id, ...spend() });
-      return 'close-unsupported';
-    }
-    emit('step-start', { step: step.id, remainingUsd: job.budgetUsd - spentUsd, spentUsd, mode: step.mode ?? 'text' });
-    // Close-first skip (resume model): the workdir + the close ARE the
-    // checkpoint. Run the step's own arbiter BEFORE any tokens — already-green
-    // means the step's work is done, and the step skips as a DISTINCT record
-    // (already-green, never plain green: nothing was done, so it mints no
-    // learning credit and runs no on-green retention). Same instrument as
-    // ralph's verdict (runClose), same at-capture scrub as every close output.
-    // trim before splitting: validateJob reds whitespace-padded cmds, but an
-    // empty argv[0] would THROW at spawn — belt for any path around the validator
-    const closeArgv = step.close.cmd.trim().split(/\s+/);
-    const closeOpts = { timeoutMs: closeTimeoutMs, cwd: workdir, expect: step.close.expect, judged: step.close.judged, gapKeep: step.close.gapKeep };
-    const pre = runClose(closeArgv, (/** @type {string} */ s) => redact(s, { patterns: SECRET_PATTERNS }), closeOpts);
-    emit('close-precheck', { step: step.id, ...pre });
-    if (pre.verdict === 'satisfied') {
-      emit('step-end', { step: step.id, outcome: 'already-green', spentUsd });
-      continue;
-    }
-    // reds-before-tokens: the forbidden zone is checked BEFORE the draft and the
-    // worker call. A close that cannot run, never finished, died by signal, or
-    // judged nothing rendered NO VERDICT — escalate by its own name (the SAME
-    // map ralph uses; two maps would be two instruments), never spend on it.
-    const fault = Object.hasOwn(CLOSE_FAULTS, pre.verdict) ? CLOSE_FAULTS[pre.verdict] : undefined;
-    if (fault) {
-      emit('escalation', { category: fault.category, decisionReady: true, step: step.id, decision: fault.decision, options: fault.options, detail: pre.detail, spentUsd });
-      emit('job-end', { outcome: 'step-red', step: step.id, cause: fault.category, ...spend() });
-      return `step-red:${step.id}`;
-    }
-    // The precheck's gap goes to the worker as what it IS: the close's output on
-    // the tree as it stands (F13). It is never framed as an attempt — no attempt
-    // has happened — so the contrast evidence stays clean. Withholding it (the
-    // original call) left the worker unable to see the failure it was hired to
-    // fix: `run` is a locked verb, so it cannot execute the close itself.
-    const halted = await ensureConfig();
-    if (halted) return halted;
-    let outcome;
-    try {
-      outcome = await interpret(config, {
-        task: `${job.description} — step: ${step.id}`,
-        target, close: closeArgv, workdir, capRuns,
-        emit: meter, provider, ...cOpts(), closeTimeoutMs, closeState: pre.gap,
-        // the SPEC's grant, threaded verbatim (2b decision #2) — the drafted
-        // config cannot express mode or tools, so there is nothing to merge.
-        // expect/judged/gapKeep ride the same rail for the same reason: they are
-        // arbiter territory (PRD v1.11; F28 for gapKeep).
-        mode: step.mode ?? 'text', tools: step.tools,
-        closeExpect: step.close.expect, closeJudged: step.close.judged, closeGapKeep: step.close.gapKeep,
-        layerRoot,
-      });
-    } catch (e) {
-      // ralph belts throws INSIDE the loop; this belts the interpreter's own
-      // setup (gate.init, store ctor) — the spine must terminate, never dangle
-      emit('escalation', { category: 'interpreter-red', decisionReady: true, step: step.id, decision: 'The interpreter broke outside the loop — no harness verdict is trustworthy until it is fixed.', options: ['fix the interpreter/run directory', 'abandon the run'], detail: String(/** @type {Error} */ (e)?.message ?? e), spentUsd });
-      emit('job-end', { outcome: 'step-red', step: step.id, cause: 'interpreter-red', ...spend() });
-      return `step-red:${step.id}`;
-    }
-    emit('step-end', { step: step.id, outcome, spentUsd });
-    if (unpriced) return pricingRed();
-    if (outcome !== 'green') {
-      emit('job-end', { outcome: 'step-red', step: step.id, cause: outcome, ...spend() });
-      return `step-red:${step.id}`;
-    }
-  }
-  emit('job-end', { outcome: 'green', ...spend() });
-  return 'green';
 }