bareloop 0.11.0 → 0.13.0

package/src/index.js

@@ -31,23 +31,36 @@ export { validateJob, jobSpecHash, checkApproval, checkMenu, CLOSE_TYPES, CLASS_
 export { validatePlan, stageClose, EXIT_TYPES, MAX_EXITS_PER_STEP, MAX_PLAN_STEPS, WRITE_VERBS } from './plan.js';
 export { snapshotScope, evalExits } from './exits.js';
 export { runPlan } from './planrun.js';
-export { runJob } from './run.js';
+// `ACCOUNTED_ROUND_TYPES` rides with it: the round records the ONE ledger sums.
+// A runner reconstructing a killed run's spend (the resume fold) must add exactly
+// these and nothing else, and a second hand-kept list is how a paid call comes to
+// be free (`judge-round` — the close's own spend — joined at softgreen module 2).
+export { runJob, ACCOUNTED_ROUND_TYPES } from './run.js';
 // Layer 3 — the REUSE registry (bridge-v1) and D3's display half. The registry is a
 // directory of plain files at an OPERATOR-supplied path (never a default location), the
 // load gate is the code half of D2's split, and `renderListing`/`selectionPrompt` are
 // pure text: they send nothing, parse nothing and decide nothing. The selection CALL and
 // the pin/shortlist/force-cold flow are the adopter's, which is why the pieces they need
 // are exported rather than kept internal to the runner.
+//
+// Softgreen module 6 exports the QUARANTINE surface with them: a judged green is minted
+// HELD and earns nothing until the signer's `accept` at the review door releases it
+// (PRD v1.71 §3). `recordDoor` is the pure half (record the disposition, release
+// forward-only) and `reuseEligibility`/`newestEligibleVersion` are what every consumer
+// asks before starting from a stored plan.
 export {
   BRIDGE_SCHEMA, validateBridge, deriveStatus, listingRow, loadGate,
   mintBridge, appendGreen, appendRed,
   loadBridge, loadRegistry, saveBridge, makeRegistry, registryExists,
+  QUARANTINED_VERDICTS, QUARANTINED_CODE, quarantinesCredit, newestEligibleVersion, reuseEligibility, recordDoor,
 } from './bridges.js';
 export { renderListing, selectionPrompt } from './selection.js';
 // Layer 3 modules 4+5 — the D7 envelope and the reuse runner. `runReuse` composes
-// `runJob` under an operator-signed envelope (three explicit numbers, tighten-only) and
-// is the only thing in the library that WRITES the registry — minting is a graded
-// green's privilege (R1), never a caller's. `validateEnvelope`/`resolveTrySpec` are
+// `runJob` under an operator-signed envelope (three explicit numbers, tighten-only). It
+// is not the only registry WRITER any more (2B: `writeRunGreenRow`), but the rule it
+// enforced is unchanged and now lives in both — minting is a graded green's privilege
+// (R1), never a caller's: both writers go through `writeGreenRow`, and neither can mint
+// a row for anything but a green that this run actually earned. `validateEnvelope`/`resolveTrySpec` are
 // exported because an operator runner has to show the resolved per-try spec's HASH at
 // its approval gate: a tightened envelope is a new spec version, and the human signs it.
 // `resolveReuse`/`reuseSpecHash` are the pair that gate must actually PRINT: the try
@@ -60,8 +73,21 @@ export { renderListing, selectionPrompt } from './selection.js';
 // `resumeTreeGate` is the ruling that a resumed patient is continued dirty and never
 // reset. Both are read by a runner BEFORE the approval gate, so neither can live behind
 // `runReuse`'s own entry.
-export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate, CHECKPOINT_OUTCOMES, PAUSE_TTL_MS, checkpointAgeGate } from './reuse.js';
-export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES } from './ledger.js';
+// `applyDoorDecision` is the registry half of the REVIEW DOOR (softgreen module 6): the
+// door opens AFTER a run has ended, so a person's answer cannot ride the run's own return
+// path — the runner calls this with the runid it printed at the door.
+// `writeRunGreenRow` is that door's other half (2B), and it is exported for the same
+// reason: a runner that drives `runJob` directly rather than through `runReuse` still ends
+// at a review door, and a door with no row to act on can only describe a held learning
+// credit it has no way to release. STORAGE ONLY — nothing here selects, promotes or reuses
+// a bridge; those stay parked on `layer-3-reuse`.
+export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate, CHECKPOINT_OUTCOMES, PAUSE_TTL_MS, checkpointAgeGate, applyDoorDecision, writeRunGreenRow } from './reuse.js';
+// BA-21 pricing provenance rides out with the ledger because it is the same job: reading
+// a run's own spend record honestly. `rateProvenance`/`spendProvenance` answer "how much of
+// this was priced by a rate nobody vouched for" — REPORTING ONLY, no halt, no refusal.
+// Exported because an adopter enforcing a budget against these numbers is entitled to know
+// which of them are guesses (see bareloop.context.md, "Every cost figure … is an ESTIMATE").
+export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES, VOUCHED_RATE_SOURCES, rateProvenance, spendProvenance } from './ledger.js';
 // THE WORK BRANCH (PRD v1.57 §3). `workBranchName` is exported so an operator runner can
 // SHOW, before the approval gate, which branch the run will work on — the same reason the
 // resolved per-try hash is printed there: a bound the human is agreeing to should not be
@@ -70,6 +96,16 @@ export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASS
 // still there before spending anything. The runner applies the rule itself either way —
 // neither export is a way to opt out of it.
 export { workBranchName, prepareWorkBranch, WORK_BRANCH_PREFIX, WORK_BRANCH_RE } from './workbranch.js';
+// THE READ SHIM (arm-gated, OFF by default via `runJob`'s `readShim`). The cap is exported
+// because bareloop.context.md names it, and documented-but-unexported is a false contract;
+// the wrapper goes with it so a caller building its own worker seam wraps the SAME ledger
+// rather than reimplementing the one rule that matters (a pointer keys on what was
+// DELIVERED, never on path+hash).
+//
+// `readShimArm` is exported for the same reason the cap is: a battery driver has to be able
+// to name and check the arm it is about to run BEFORE it launches, and the legal set living
+// only inside a runner would leave the driver guessing at spellings the guard will reject.
+export { createReadShim, wrapReadTool, readShimArm, readShimStrategy, READ_SHIM_CAP, READ_SHIM_STRATEGY, READ_SHIM_DIFF_STRATEGY, READ_SHIM_ARMS } from './readshim.js';
 // ── CLOSE AUTHORING v1 (gate 4) — the user declares what done means ──────────
 // The public surface is settled ONCE, here, at M4 (M2's header flagged the
 // naming collision and deferred it rather than exporting piecemeal).
@@ -92,8 +128,63 @@ export {
   // N4 slice 1 — the hitl surface an adopting runner needs: the three doors, the
   // gate that reads a signer's answer (and refuses an empty one), and the seed
   // exemption ruling 8 states.
-  HUMAN_DECISIONS, SEED_EXEMPT_KINDS, normalizeHumanRuling,
+  HUMAN_DECISIONS, SEED_EXEMPT_KINDS, JUDGED_FLOOR_KIND, normalizeHumanRuling, resolveHumanRuling,
+  // SOFTGREEN module 2 — the judged stage's own arbiter-owned bounds. An adopter
+  // wiring `judgeProvider` needs both numbers to reason about what a judged close
+  // can cost: one paid call per artifact, at most one retry each.
+  JUDGE_ATTEMPTS, MAX_JUDGED_PATHS,
+  // SOFTGREEN module 8 — the REVIEW DOOR's vocabulary: the record type a run
+  // writes when it ends at the door, which terminals open one, which classes open
+  // one unasked, and the mechanical-only rule an `accept` re-proves against.
+  REVIEW_DOOR, DOOR_OPEN_OUTCOMES, REVIEW_DOOR_CLASSES, doorOpens, mechanicalStages,
 } from './kinds.js';
+// SOFTGREEN module 8 — the door's ANSWERING half. A run OPENS the door on its own
+// spine and ends; a person answers minutes or days later, from another process, so
+// the answer cannot ride the run's return path. `answerReviewDoor` is that seam:
+// it re-proves the tree for an `accept`, releases a held judged green through
+// module 6's registry half, and refuses an expired door under the same 60-day TTL a
+// hitl checkpoint keeps. It never returns, writes or implies a verdict.
+export { answerReviewDoor, doorRecordOf, doorAgeGate } from './reviewdoor.js';
+// SOFTGREEN module 1 — the judged floor's core. The pieces an adopter (and an
+// integrating UI) genuinely needs: the PIN (`JUDGE_MODEL` — what a wired judge
+// provider must be bound to, and a bump of which forces recalibration), the
+// rulebook a card SELECTS from, the card gate, and the two halves themselves so a
+// calibration harness can grade the whole pipe without running a close.
+// `defaultJudgeLoop` is the one spelling of how this repo drives a judge; the
+// runner reaches it through `runPlan`'s `judgeProvider`, and it is exported so a
+// caller building its own harness does not spell a second one.
+export {
+  JUDGE_MODEL, JUDGE_MAX_TOKENS, JUDGE_RULES, JUDGE_RULE_IDS, LOCATE_AXES, LOCATE_LABEL,
+  validateCard, validateFacts, locatePrompt, runLocate, decide, defaultJudgeLoop,
+  // SOFTGREEN module 4 — what a legal SIGNED calibration set is. The SIZE is
+  // hamr's own ruling and a size change is a spec-level threshold change;
+  // `expectedOf` is the ONE reduction of a `decide()` result to the shape a case
+  // stores, so a calibration harness compares one shape rather than two.
+  CALIBRATION_SIZE, CASE_VERDICTS, validateCalibrationSet, validateJudgedArtifacts, expectedOf,
+} from './judged.js';
+// SOFTGREEN module 4 — the COMPILE. Q6 becomes the rubric card and Q7 becomes the
+// frozen calibration set, both on the D5 shown-and-fixed path: the LLM proposes
+// through `proposeJudgedArtifacts`, an integrating UI shows the proposal, the
+// SIGNER's fix goes through `signJudgedArtifacts`, and `foldJudgedArtifacts`
+// enumerates both into the closeDecl — where the spec hash covers them, so a card
+// line or a case is a re-sign like every other spec edit.
+export {
+  proposeJudgedArtifacts, signJudgedArtifacts, foldJudgedArtifacts,
+  proposalSchema, proposalTool, cardCasesPrompt,
+  PROPOSAL_TOOL_NAME, PROPOSAL_LABEL, MAX_PROPOSAL_RETRIES, COMPILE_SYSTEM,
+} from './cardauthor.js';
+// SOFTGREEN module 5 — THE CALIBRATION GATE. `runCalibration` grades the whole
+// pipe (locate + decide) over the signed ten and the five arbiter-owned injection
+// artifacts; `prepareSigning` runs it and refuses on anything short of all of
+// them. Exported because an integrating UI has to be able to RUN and RENDER the
+// gate — the graded rows are what a signer reads before giving a signature — and
+// because the battery is evidence a reader may want to inspect rather than take
+// on trust. `INJECTION_LOCATE_BATTERY` and `INJECTION_CARD` are ARBITER-OWNED
+// constants: no signer authors them and nothing stores them in a spec.
+export {
+  runCalibration, compareExpectation, factsResist, artifactHash,
+  INJECTION_LOCATE_BATTERY, INJECTION_CARD, CALIBRATION_LABEL, CASUALTY_AXES,
+} from './calibrate.js';
 // M2 — what a declaration may SAY, and whether one said it legally. The
 // catalogue and the genre are DATA an integrating UI renders (the kind menu, the
 // guard batteries it must show the user under D5 and cannot let them remove).
@@ -106,7 +197,7 @@ export {
   DIRECTIONS, BASELINES, MAX_STAGES,
   // the verdict-class surface (PRD v1.57 §1–§2): the radio's own menu, the guard
   // battery keyed off it, and the ceiling that makes the pick a promise
-  VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling,
+  VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, classMenu, closeCeiling,
   // ruling 5 as data: the kinds no agent may ever be offered as an in-run ruler
   NEVER_OFFERED_KINDS,
 } from './authoring.js';
@@ -125,7 +216,7 @@ export {
 export { scrubRaw, RAW_PERSIST_MAX, RAW_TRIM_MARKER } from './text.js';
 export {
   authorClose, authorPrompt, declarationSchema, makeLoopGenerate, MAX_REVISIONS,
-  QUESTION_SETS, GREEN_QUESTIONS, CLASS_STATEMENTS, questionsFor, requiredAnswersFor,
+  QUESTION_SETS, GREEN_QUESTIONS, SOFTGREEN_QUESTIONS, CLASS_STATEMENTS, questionsFor, requiredAnswersFor,
 } from './authorflow.js';
 // M4a — the runtime bridge. `validateCloseDecl` is the spec-level gate (the job
 // validator's own branch calls it); `runDeclaredStages` is the executor seam a

package/src/job.js

@@ -98,17 +98,30 @@ export const MIN_WALL_MS = 120_000;
  * counts admission demand, and a generic invalid-value would bury it as a typo. */
 export const LOCKED_TOOLS = Object.freeze(['run']);
 /** Layer 2 (design record 2026-07-21, decision 5): the verdict-type radio of
- * the four-field plan shape. v1 ADMITS only `green`; soft-green/hitl are
- * declared-but-locked — declaring one is a `request-red` (the tool-menu
- * pattern: disclosure ≠ admission), so the ledger counts the demand and the
- * non-code rung later fills a declared slot instead of reshaping the schema. */
+ * the four-field plan shape. All three are ADMITTED as of softgreen module 3;
+ * the declared-but-locked mechanism below (`LOCKED_VERDICTS`) is what carried
+ * them here one rung at a time — declaring a locked one is a `request-red` (the
+ * tool-menu pattern: disclosure ≠ admission), so the ledger counted the demand
+ * instead of the schema being reshaped when the rung finally landed. */
 export const VERDICT_TYPES = Object.freeze(['green', 'soft-green', 'hitl']);
-/** N4 slice 1: `hitl` is ADMITTED — the class whose *done* needs a person runs
- * through the same signed spec, the same agent-authored plan and the same
- * arbiter as a green job (the nine rulings, 2026-08-07; the three-button surface,
- * 2026-08-12). `soft-green` stays declared-but-locked until its judged floor is
- * built and proven (slice 2): a wobbly ruler must not mint anything. */
-export const LOCKED_VERDICTS = Object.freeze(['soft-green']);
+/** N4 slice 1 admitted `hitl`; softgreen module 3 admits `soft-green`, and the
+ * menu is now EMPTY — every class the radio names is built.
+ *
+ * `soft-green`'s lock was never a policy, it was a missing floor: a judged
+ * verdict with no ruler mints nothing honestly. Modules 1 and 2 built the ruler
+ * (a pinned judge that only LOCATES, an arbiter-owned `decide()`, a calibration
+ * gate) and wired it as the `judged-floor` kind, so the lock has nothing left to
+ * protect (design record 2026-08-17 §4, and the 2026-08-18 thresholds addendum).
+ *
+ * EMPTY here means "nothing is locked", which is a TRUE statement about a closed
+ * menu — not F59's absent-read-as-empty, where a `{}` stood in for a fact nobody
+ * gathered. The mechanism below stays exactly as it is: it is read at call time
+ * from this constant, so re-locking a class (or admitting a fourth) is one edit
+ * and the counted `request-red` path comes back with it. `LOCKED_CLASSES` in
+ * src/authoring.js is the twin and moved in the same commit; the suite pins the
+ * two identical. */
+/** @type {readonly string[]} */
+export const LOCKED_VERDICTS = Object.freeze([]);
 /** which close CLASS a declared verdictType demands — the close hierarchy one
  * level up: the same laundering guard as CLASS_BY_CLOSE, applied to the plan
  * shape's single close (green on a rubric would be a fake-hard verdict). */
@@ -520,8 +533,9 @@ function validateStagedClose(stages, red) {
  * stages instead (PRD v1.28/v1.32), and a spec that still declares it gets the
  * `checks-derived` red below rather than a bare unknown-field.
  *
- * v1 admits only verdictType `green`; soft-green/hitl are declared-but-locked
- * and red as `request-red` — admission demand the ledger counts, never a grant.
+ * Every verdictType the radio names is admitted (softgreen module 3); a class
+ * that were locked reds as `request-red` — admission demand the ledger counts,
+ * never a grant.
  * The close is validated one level up as well: a declared verdict demands a
  * close CLASS, so green-on-rubric reds as `close-hierarchy` rather than
  * laundering a soft judgement into a hard one.
@@ -541,7 +555,7 @@ function validatePlanShape(spec, red, reds) {
     // the type rides as a structured field — the ledger keys admission demand
     // on it, never on prose. `lib: 'bareloop'`: the refused catalogue is OURS
     // (VERDICT_TYPES), so this demand is never an upstream ask.
-    reds.push({ code: 'request-red', path: 'verdictType', verb: spec.verdictType, lib: 'bareloop', detail: `"${spec.verdictType}" is declared-but-locked — not at this rung (v1 admits green only); this red IS the admission evidence, never a grant` });
+    reds.push({ code: 'request-red', path: 'verdictType', verb: spec.verdictType, lib: 'bareloop', detail: `"${spec.verdictType}" is declared-but-locked — not at this rung (admitted: ${VERDICT_TYPES.filter((v) => !LOCKED_VERDICTS.includes(v)).join(', ')}); this red IS the admission evidence, never a grant` });
     demanded = CLASS_BY_VERDICT[spec.verdictType];
   } else if (!VERDICT_TYPES.includes(spec.verdictType)) {
     red('invalid-value', 'verdictType', `menu: ${VERDICT_TYPES.join('|')} — an unknown type is a typo, never a request`);