bareloop 0.6.0 → 0.7.0

package/src/clock.js

@@ -68,6 +68,14 @@ export const MIN_CALL_TIMEOUT_MS = 30_000;
  * it as transport. */
 export const TIMEOUT_CODE = 'ETIMEDOUT';
 
+/** bare-agent's rejection code when its TOTAL-duration deadline trips (BA-19,
+ * `provider-http.js` → `applyRequestDeadline`). A DIFFERENT code from the idle
+ * bound's on purpose — upstream splits them precisely so a consumer routing
+ * governance stops apart from transport casualties can tell which timer fired. Like
+ * `TIMEOUT_CODE` it carries no `category`, so every default-to-transport catch site
+ * would file it as a casualty. */
+export const DEADLINE_CODE = 'EDEADLINE';
+
 /**
  * F64 — is this throw the run's OWN deadline coming back dressed as a provider
  * error? `callTimeoutMs()` hands the provider a bound derived from the wall, so
@@ -90,12 +98,20 @@ export const TIMEOUT_CODE = 'ETIMEDOUT';
  * the same (raise `maxWallMs`), and the alternative — calling a governance stop
  * transport on the chance that it was — is the failure this closes.
  *
+ * BOTH derived bounds land here, because both are derived from the same wall:
+ * BA-18's idle timeout (`callTimeoutMs`) and BA-19's total-duration deadline
+ * (`callDeadlineMs`). Adding the second CODE does not widen the rule — the
+ * discriminator is still `clock.expired()`, never the code. That matters for the
+ * deadline specifically: a provider someone else constructed with its own
+ * `deadlineMs` could throw this code on a run with time left, and that is transport,
+ * exactly as it was before.
+ *
  * @param {any} err the throw as caught
  * @param {Clock} clock the run's clock
  * @returns {boolean}
  */
 export function isWallTimeout(err, clock) {
-  return !!err && err.code === TIMEOUT_CODE && clock.expired();
+  return !!err && (err.code === TIMEOUT_CODE || err.code === DEADLINE_CODE) && clock.expired();
 }
 
 /**
@@ -108,21 +124,37 @@ export function isWallTimeout(err, clock) {
  * @property {() => boolean} expired whether the deadline has passed (always false when unbounded)
  * @property {(closeTimeoutMs: number) => number|null} enforcedMs the HONEST worst case
  * @property {(providerDefaultMs?: number) => number} callTimeoutMs the derived per-call bound
+ * @property {() => number|null} callDeadlineMs the derived per-call TOTAL-duration ceiling; `null` when unbounded
  * @property {(closeTimeoutMs: number) => object} report one spine-safe shape carrying both numbers
  */
 
 /**
  * Start a wall clock for one run.
- * @param {{ maxWallMs?: number|null, closeStages?: number, now?: () => number }} [opts]
+ * @param {{ maxWallMs?: number|null, closeStages?: number, now?: () => number, priorElapsedMs?: number }} [opts]
  *   `maxWallMs`: the signed operator cap, or absent/null for an honestly unbounded
  *   run. `closeStages`: how many stages the job's close runs (W5) — each one gets
  *   the FULL `closeTimeoutMs`, so this is the multiplier on the overshoot, not a
  *   decoration. Defaults to 1, the single-predicate close. `now`: injected for
- *   tests — the default is the real clock.
+ *   tests — the default is the real clock. `priorElapsedMs`: time this attempt's
+ *   PREDECESSOR already consumed (see below).
  * @returns {Clock}
  */
-export function createClock({ maxWallMs = null, closeStages = 1, now = () => Date.now() } = {}) {
-  const startedAt = now();
+export function createClock({ maxWallMs = null, closeStages = 1, now = () => Date.now(), priorElapsedMs = 0 } = {}) {
+  // RESUME (module C) — hamr's checkpoint ruling in a time coat: a run killed
+  // mid-try restarts THAT try under the REMAINDER of its signed per-try numbers,
+  // because "a budget ceiling folds in prior spend so re-invoking cannot silently
+  // widen it". The fold happens HERE rather than by editing `maxWallMs`, and that
+  // is the whole point: the cap the operator signed stays the number reported and
+  // the number hashed (a rewritten cap is a new spec version needing a new
+  // signature), while the clock simply starts already partly spent. A fresh
+  // allotment on every kill would let a resumed run outlive the worst case the
+  // operator signed, one kill at a time.
+  //
+  // Belted like `maxWallMs` above: a non-finite, negative or garbage fold is 0. A
+  // NaN here would make every comparison false and silently unbound the run, which
+  // is the inverse of what the fold exists to do.
+  const prior = typeof priorElapsedMs === 'number' && Number.isFinite(priorElapsedMs) && priorElapsedMs > 0 ? priorElapsedMs : 0;
+  const startedAt = now() - prior;
   // A cap is only a cap if it is a usable positive number. validateJob already
   // reds anything else, so this is the belt (a caller that hand-builds a spec
   // must not be able to turn a garbage value into a silent unbounded run OR a
@@ -162,6 +194,26 @@ export function createClock({ maxWallMs = null, closeStages = 1, now = () => Dat
       // would restore the ~2h OS-TCP hang on the last round of a tight budget.
       return Math.min(providerDefaultMs, Math.max(MIN_CALL_TIMEOUT_MS, remainingMs()));
     },
+    // BA-19 (F72 park D) — the TOTAL-duration ceiling beside the idle one. The idle
+    // bound resets on every byte, so a response that trickles forever never trips it
+    // (F66's 274-minute call, and F67's 81.5-minute freeze happened above it); this
+    // one is a plain timer that no byte resets.
+    //
+    // Three properties, each a rule this repo already paid for:
+    //   - NULL when unbounded. An operator who set no wall gets no ceiling — a
+    //     defaulted cap is a silent second ceiling (F45, and the reason `maxWallMs`
+    //     has no default). The caller must OMIT the knob on null, not pass a number.
+    //   - REMAINING, read at call time. A constant would bound the last call by the
+    //     first call's budget, which is the thing `callTimeoutMs` already refuses.
+    //   - NOT clamped to the provider default. That upper clamp exists on the idle
+    //     bound because a value above the provider's own default is inert; a
+    //     total-duration ceiling above it is the entire point of BA-19.
+    // The lower floor is shared with `callTimeoutMs` and for the same two reasons: a
+    // bound certain to trip manufactures a stop out of arithmetic, and `0` DISABLES
+    // the bound upstream (`if (!(deadlineMs > 0)) return`) — the exact inverse of the
+    // intent. A trip past the floor is still honest: the wall has expired by then, so
+    // `isWallTimeout` reads it as the governance stop it is.
+    callDeadlineMs: () => (cap === null ? null : Math.max(MIN_CALL_TIMEOUT_MS, remainingMs())),
     report: (closeTimeoutMs) => ({
       bounded,
       requestedMs: cap,

package/src/index.js

@@ -32,4 +32,33 @@ export { validatePlan, stageClose, EXIT_TYPES, MAX_EXITS_PER_STEP, MAX_PLAN_STEP
 export { snapshotScope, evalExits } from './exits.js';
 export { runPlan } from './planrun.js';
 export { runJob } 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.
+export {
+  BRIDGE_SCHEMA, validateBridge, deriveStatus, listingRow, loadGate,
+  mintBridge, appendGreen, appendRed,
+  loadBridge, loadRegistry, saveBridge, makeRegistry, registryExists,
+} 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
+// 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
+// count multiplies the worst case, so a signature over the per-try spec alone leaves it
+// unsigned — a runner showing `jobSpecHash(resolveTrySpec(...))` prints the same hash for
+// 0 tries and for 9.
+// Module C (resume after a kill) exports its two operator-side halves for the same
+// reason: `readResume` is what turns a dead run's spine back into the state a resume
+// continues from (which tries completed, which one restarts, on what remainder), and
+// `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 } from './reuse.js';
 export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES } from './ledger.js';

package/src/ladder.js

@@ -0,0 +1,196 @@
+// The step ladder's governor — PROGRESS, not a count (design 2026-08-03).
+//
+// MEASURED reason this exists. The step loop was bounded by a fixed number of
+// check-iterations (`capRuns`, 4 in the operator's runner). Two real spines show
+// what that cost: u-msd916dh went 30 → 22 → 17 → 11 scope errors across its
+// iterations and was cut with $1.30 and ~6 minutes still unspent; u-mscxuziw went
+// 13 → 1 and was cut the same way. The count could not tell converging work from
+// thrash, so it stopped both at the same place. And the one lever the plan could
+// pull — a step's `attempts` field — could only ever TIGHTEN below the shell's
+// number, so the correct heal was inexpressible: drafters measurably tightened to
+// 3, then to 2 on replan.
+//
+// The replacement asks the question the count could not: **is this iteration
+// making progress?** Two signals, read per RED iteration:
+//
+//   gap-new  the failing exits' text, normalized and hashed, against every gap
+//            hash seen so far in this step's ladder. A SEEN-SET, never last-only:
+//            a real A→B→A oscillator exists in the archive and last-only reads it
+//            as progress.
+//   wrote    did the worker make real write-class actions THIS iteration — read
+//            from the gate audit's own record COUNT (the F32 instrument:
+//            run-scoped, allow-decision, write AND edit). Never git status, never
+//            a tree diff. It must be a COUNT and not the path SET, because a plan
+//            step rewrites its one target every attempt — the set is constant
+//            after iteration 1 and would read every later iteration as idle (the
+//            same Finding-3 trap Layer R documents one module over).
+//
+// A **strike** is a red iteration that is a repeat OR wrote nothing. Strikes are
+// STICKY — never reset, never repaid by a good iteration in between — because the
+// question the ceiling answers is "has this step spent enough of the run failing
+// to make progress", and a counter that a single good iteration zeroes can be held
+// open forever by alternating.
+//
+// What still bounds a converging step, so this cannot run away: the wallet (the
+// worker's Gate carries the run's remaining budget), the run's wall clock (W-2, at
+// the head of every attempt), the variance meter (A), and the stall fuse. Those
+// are unchanged and each still ends the ladder on its own authority. This module
+// replaces exactly ONE of the old bounds: exhaustion-by-count.
+
+import { createHash } from 'node:crypto';
+
+/**
+ * The strike ceiling. Shell-owned, exactly where the fixed count was: the runner
+ * sets it, the agent cannot express it, and it is arbiter territory — a step's own
+ * plan may not tighten it and may not raise it. Two is hamr's number.
+ */
+export const STRIKE_LIMIT = 2;
+
+/**
+ * The volatile bytes, stripped before hashing. COMPARISON-ONLY: the gap the worker
+ * sees is never rewritten (the `normalizeRedLine` rule, one module over).
+ *
+ * Every entry is a byte a re-run changes while the failure does not. Without them
+ * a `node --test` gap is never byte-stable (its duration stamps move every run),
+ * so every repeat would read as a novel gap and the repeat signal would be dead —
+ * an instrument that cannot see the variable.
+ * @type {[RegExp, string][]}
+ */
+const VOLATILE = [
+  // TAP's own timing line, dropped WHOLE: its value is the only thing on it
+  [/^[ \t]*#?[ \t]*duration_ms[ \t]*[:=].*$/gm, ''],
+  // ISO-8601 stamps, wherever they appear in a close's output
+  [/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, '<ts>'],
+  // any millisecond figure (`(1.738ms)`, `took 12 ms`)
+  [/\d+(?:\.\d+)?[ \t]*ms\b/g, '<ms>'],
+];
+
+/**
+ * Normalize a gap for comparison. Deliberately NARROW: only bytes a re-run changes
+ * on its own are removed. Error COUNTS, file names and line numbers all survive —
+ * a trajectory like "30 errors" → "22 errors" must read as two different gaps, and
+ * a normalizer that scrubbed numbers would turn the converging case this module
+ * exists to protect into an instant strike.
+ * @param {string} text @returns {string}
+ */
+export function normalizeGap(text) {
+  let s = String(text ?? '');
+  for (const [re, to] of VOLATILE) s = s.replace(re, to);
+  // runs of spaces/tabs collapse (a re-run can re-pad a column); newlines do NOT —
+  // line structure is real content
+  return s.replace(/[ \t]+/g, ' ').replace(/[ \t]+$/gm, '').trim();
+}
+
+/**
+ * The comparable key for a gap: the normalized text, hashed. Hashed rather than
+ * kept whole because the seen-set lives for the whole step and a close's output
+ * can be tens of KB — and because the set holds no content, nothing here can leak
+ * model or file bytes into a record.
+ * @param {string} text @returns {string}
+ */
+export function gapKey(text) {
+  return createHash('sha256').update(normalizeGap(text), 'utf8').digest('hex');
+}
+
+/**
+ * Build one ladder. ONE PER STEP: the seen-set and the strike count are the step's
+ * own history, and a ladder shared across steps would strike a fresh step for a gap
+ * an earlier one had already seen.
+ *
+ * @param {object} opts
+ * @param {number} [opts.limit] strikes that end the step (default `STRIKE_LIMIT`)
+ * @param {() => number} opts.writeCount the CUMULATIVE count of the worker's
+ *   allow-decision write/edit records so far this step (planrun reads it off the
+ *   gate audit). Required, and a throw when it is missing rather than a silent
+ *   degradation to repeats-only: a strike rule running on one of its two signals
+ *   with nothing on the record saying so is the blind-instrument class, and this
+ *   is the BA-4 param-guard class where a throw is the right answer.
+ */
+export function createLadder({ limit = STRIKE_LIMIT, writeCount }) {
+  if (typeof writeCount !== 'function') {
+    throw new TypeError('createLadder requires a writeCount seam — a strike rule with one signal wired is prose, not a bound');
+  }
+  /** @type {Map<string, number>} gap key → the iteration it was FIRST seen at */
+  const firstSeen = new Map();
+  /** @type {{at: number, firstAt: number}[]} */
+  const repeats = [];
+  /** @type {number[]} iterations in which the worker wrote nothing */
+  const idle = [];
+  let strikes = 0;
+  let iterations = 0;
+  let priorWrites = 0;
+
+  return {
+    /**
+     * Read one RED iteration. Called by ralph after the judge has rendered a
+     * non-green, non-fault verdict — a green never reaches here, so every reading
+     * is a failing iteration by construction.
+     * @param {{iteration: number, gap?: string}} o
+     * @returns {{governor: string, iteration: number, strike: boolean, strikes: number,
+     *   limit: number, wrote: boolean, repeatOf: number|null, distinctGaps: number}}
+     */
+    record({ iteration, gap }) {
+      iterations = iteration;
+      const key = gapKey(gap ?? '');
+      const firstAt = firstSeen.get(key);
+      const repeated = firstAt !== undefined;
+      if (repeated) repeats.push({ at: iteration, firstAt: /** @type {number} */ (firstAt) });
+      else firstSeen.set(key, iteration);
+
+      // the DELTA, not the total: the audit is append-only across the whole step
+      const total = writeCount();
+      const wrote = total > priorWrites;
+      priorWrites = total;
+      if (!wrote) idle.push(iteration);
+
+      const strike = repeated || !wrote;
+      if (strike) strikes += 1; // sticky: nothing anywhere decrements this
+      return {
+        // WHICH governor produced this reading. Two of them emit under the one
+        // `ladder` spine type now (this one, and the close-fix loop's per-stage trend
+        // reader), and their fields differ — a reader that cannot tell them apart
+        // would average two different instruments into one number.
+        governor: 'step-ladder',
+        iteration, strike, strikes, limit, wrote,
+        repeatOf: repeated ? /** @type {number} */ (firstAt) : null,
+        distinctGaps: firstSeen.size,
+      };
+    },
+    /** has the step run out of strikes? */
+    struckOut: () => strikes >= limit,
+    /** the ladder's own books — counts and iteration numbers, never gap content */
+    report: () => ({
+      iterations, strikes, limit, distinctGaps: firstSeen.size,
+      repeats: repeats.map((r) => ({ ...r })),
+      idle: [...idle],
+    }),
+    /**
+     * The mechanism, in one sentence, for the replan brief. It is the only channel
+     * the redrafting planner adapts to, so it states WHICH shape ended the step and
+     * the evidence for it — never a label on its own, and never a culprit file
+     * beyond what the close itself reported (F28): the inputs here are iteration
+     * numbers and counts, so naming one is inexpressible.
+     * @returns {string}
+     */
+    brief() {
+      const parts = [];
+      if (repeats.length) {
+        const last = repeats[repeats.length - 1];
+        parts.push(`it repeated itself — the exit output at iteration ${last.at} had already been seen at iteration ${last.firstAt}`);
+      }
+      if (idle.length) parts.push(`it stalled — no file was written in iteration(s) ${idle.join(', ')}`);
+      const trajectory = `${firstSeen.size} distinct exit output(s) over ${iterations} iteration(s)`;
+      // BOTH signals gate it, because "converging" is a claim about the WORK and a
+      // moving exit output is only half the evidence for one. Gated on repeats alone
+      // it fired on an idle strike-out — "no file was written in iteration(s) 1, 2"
+      // and "the step was converging" in the same paragraph, handed to the one
+      // channel the redrafting planner adapts to. A step that wrote nothing was not
+      // converging whatever its exit bytes did (a close re-run moves its own).
+      const converging = repeats.length === 0 && idle.length === 0
+        ? ' Every attempt moved the exit output, so the step was converging when it struck out.'
+        : '';
+      return `The step ladder ended it on ${strikes} strike(s) of ${limit}: ${parts.join('; ')}. `
+        + `Gap trajectory: ${trajectory}.${converging}`;
+    },
+  };
+}

package/src/ledger.js

@@ -79,6 +79,33 @@ const EXCLUDED_ESCALATIONS = new Set([
   'smoke-red',          // already counted via primitive-smoke
   'hitl-close',         // by design: a human is the close
   'close-unsupported',  // honest refusal, by design
+  // Layer 3 (D2 split): the bridge load gate refused a wrong-KIND recipe at the door.
+  // That is the mechanism WORKING — every recipe from a different day is a candidate for
+  // refusal, and the run stopped having spent nothing. Filing it upstream would aim a bug
+  // report at a library for our own gate doing its job (the step-stalled lesson).
+  'recipe-stale',
+  // Layer 3 (D7/D3) — the reuse runner's own three stops. Each is the ENVELOPE or the
+  // OPERATOR speaking, never a library failing: `reuse-exhausted` is the pre-authorized
+  // number of tries being spent (the money/time story, exactly like cap-halt);
+  // `selection-refused` is the model declining a pinned workflow, which D3 requires it to
+  // be able to do; `selection-red` is a model answer that was not the one JSON object it
+  // was asked for — a behaviour, not a transport fault (a real transport fault out of the
+  // selection call is classified as `provider-red` and is NOT excluded).
+  'reuse-exhausted',
+  'selection-refused',
+  'selection-red',
+  // Layer 3 (module C) — a RESUME that refuses to continue: the seed was signed under a
+  // different envelope, or the workflow the killed run was part-way through is no longer
+  // in the registry. Both are the operator's own state speaking (a stale signature, an
+  // edited registry), and both stop having run nothing.
+  'resume-red',
+  'registry-red',       // the operator-supplied registry path does not exist — a typo, not a bug
+  'envelope-red',       // the envelope does not compose with the signed spec — operator input
+  // the reuse runner also STOPS on the three answers no further try could change, and
+  // escalates each under its own name. Both are operator-input stories: an unsigned spec
+  // version and a spec that will not validate. (`smoke-red` is already excluded above.)
+  'unapproved-spec',
+  'job-red',
   'close-timeout',      // close-verdict reds: the arbiter's own named terminals
   'close-killed',       // (F17) — operator/environment stories, never a suite lib
   'close-crashed',

package/src/plan.js

@@ -246,7 +246,7 @@ export function stageClose(close) {
  * job spec. Never throws on JSON text or plain parsed data; every failure is
  * a named red. Returns the parsed plan on ok (single parse), null on any red.
  * @param {object|string} input parsed plan, or raw JSON text (parse failures are a red)
- * @param {{ job?: any, maxStepRounds?: number, scopes?: string[], capRuns?: number }} [opts] `job`: the
+ * @param {{ job?: any, maxStepRounds?: number, scopes?: string[], seedRed?: string[], priorChecks?: string[] }} [opts] `job`: the
  *   validateJob-GREEN four-field spec (the ceiling, the fence, and the checks
  *   menu all come from it — a missing or non-plan-shape job fails CLOSED);
  *   `maxStepRounds`: the shell's per-step rounds ceiling (interpret's
@@ -254,9 +254,23 @@ export function stageClose(close) {
  *   `scopes`: the offered `tree-changed` menu from `legalScopes` (the SAME array
  *   the drafting prompt enumerated). Omitted, it derives from the signed
  *   writeScope — never a free-text fallback (F50).
+ *
+ *   The two shape-lottery gate rules (2026-08-04) — both keyed on RECORDED
+ *   facts, never an LLM judgment of "is this job small", and both inactive
+ *   when their fact is omitted (resume/reuse callers stay byte-identical):
+ *   `seedRed`: check names whose PREFLIGHT verdict was needs_revision. Rule
+ *   A-v2 — a seed-red check is the goal itself, not a milestone; it may only
+ *   sit on the plan's FINAL write step (`check-placement`). The $0 archive
+ *   sweep: seed-red-check-on-an-early-step has 0 honest greens ever; the one
+ *   wide closing step greens 7/7. Green-at-seed checks stay free mid-plan
+ *   (the 20 TESTGEN mid-plan greens — a guard, not a goal).
+ *   `priorChecks`: the check names the PREDECESSOR plan carried (replan gate
+ *   only). Rule B — a redraft may not drop one (`check-shed`): exits without
+ *   the check verify FORM alone, so a shed lets the run "green" unearned
+ *   (u-msdsmkid mechanism b; the 3 archived sheds were all on step-red runs).
  * @returns {{ ok: boolean, reds: Red[], plan: object|null }}
  */
-export function validatePlan(input, { job, maxStepRounds = 40, scopes, capRuns = 3 } = {}) {
+export function validatePlan(input, { job, maxStepRounds = 40, scopes, seedRed, priorChecks } = {}) {
   /** @type {Red[]} */
   const reds = [];
   /** @type {(code: string, path: string, detail?: string) => void} */
@@ -319,6 +333,14 @@ export function validatePlan(input, { job, maxStepRounds = 40, scopes, capRuns =
   } else if (plan.steps.length > MAX_PLAN_STEPS) {
     red('bounds', 'steps', `max ${MAX_PLAN_STEPS} steps — per-step rounds bound the spend, the step count bounds the claim on the wallet`);
   } else {
+    // Rule A-v2's anchor: the index of the plan's FINAL write-granted step. Read
+    // off the RAW steps (a step whose grant didn't parse counts as non-write —
+    // its own missing-required/invalid-value red already fired; deriving a
+    // placement charge from the false default would be a second red for one
+    // defect). -1 when no step writes: every check then reds as a mailbox anyway.
+    const lastWriteIdx = plan.steps.reduce((/** @type {number} */ acc, /** @type {any} */ s, /** @type {number} */ i) => (
+      isObj(s) && Array.isArray(s.tools) && s.tools.some((/** @type {unknown} */ t) => WRITE_VERBS.includes(/** @type {string} */ (t))) ? i : acc), -1);
+    const seedRedNames = Array.isArray(seedRed) ? seedRed.filter(isNonEmptyString) : [];
     const seen = new Set();
     plan.steps.forEach((/** @type {any} */ s, /** @type {number} */ i) => {
       const at = `steps.${i}`;
@@ -370,8 +392,24 @@ export function validatePlan(input, { job, maxStepRounds = 40, scopes, capRuns =
       if (s.model !== undefined && !STEP_MODELS.includes(s.model)) {
         red('invalid-value', `${at}.model`, `menu: ${STEP_MODELS.join('|')} — the tier menu is signed; the agent picks a tier, never names a model`);
       }
-      if (s.attempts !== undefined && !(Number.isInteger(s.attempts) && s.attempts >= 1 && s.attempts <= capRuns)) {
-        red('bounds', `${at}.attempts`, `integer 1..${capRuns} — a step may tighten the shell's attempt cap, never exceed it`);
+      // `attempts` is TOLERATED-INERT (step ladder, 2026-08-03). It once tightened a
+      // fixed per-step attempt count; that count is gone — a step's iterations are
+      // governed by the strike ladder, and a field that could only ever TIGHTEN is
+      // the wrong shape for a progress rule (drafters measurably tightened it to 3,
+      // then to 2 on replan, which is the opposite of the heal a converging step
+      // needs). It is no longer OFFERED in the drafting prompt, and the runner
+      // ignores it.
+      //
+      // It is not REJECTED, and that is the load-bearing half: the frozen bridge
+      // registry's stored plans carry `attempts`, and a bridge rides into the drafter
+      // as a starting draft after passing the ordinary validator. Redding it here
+      // would refuse every stored recipe minted before today and ruin a frozen
+      // contrast experiment. The SHAPE is still checked — a known field holding
+      // garbage stays a named red — but the upper bound is gone with the cap it
+      // named: keeping `<= capRuns` would make a plan stored under one runner's
+      // number invalid under another's, for a field that decides nothing.
+      if (s.attempts !== undefined && !(Number.isInteger(s.attempts) && s.attempts >= 1)) {
+        red('bounds', `${at}.attempts`, 'integer >= 1 — the field is accepted for stored-plan compatibility and bounds nothing (the step ladder governs iterations)');
       }
       if (s.scope !== undefined && !scopeMenu.includes(s.scope)) {
         red('invalid-value', `${at}.scope`, `menu: [${scopeMenu.join(', ')}] — a per-step write scope narrows the fence from the same menu tree-changed uses`);
@@ -435,8 +473,26 @@ export function validatePlan(input, { job, maxStepRounds = 40, scopes, capRuns =
         red('step-scope-escape', `${at}.target`, `"${s.target}" is inside the signed fence but outside this step's own scope "${stepScope}" — the step's gate is built from that narrowed prefix, so every write to this target would be denied`);
       }
 
-      validateExit(s, at, red, { checkNames, fence: spec.writeScope, insideFence, writeStep, toolsParsed, scopeMenu, stepScope, overlapsStepScope });
+      validateExit(s, at, red, { checkNames, fence: spec.writeScope, insideFence, writeStep, toolsParsed, scopeMenu, stepScope, overlapsStepScope, seedRedNames, isFinalWrite: i === lastWriteIdx });
     });
+
+    // Rule B (`check-shed`, replan gate): the caller hands over the check names
+    // the PREDECESSOR plan carried; a redraft that drops one is refused. Exits
+    // without the check verify FORM alone (tree-changed/artifact-written), so a
+    // shed lets a step "green" with the truth unjudged — u-msdsmkid's replan
+    // dropped check-passes from BOTH steps and greened unearned on form. Set
+    // semantics on NAMES: where the check sits may move (A-v2 forces it to the
+    // final write step); that it is judged at all may not. One red listing every
+    // dropped name — one defect (the shed), one red.
+    if (Array.isArray(priorChecks)) {
+      const carried = new Set(plan.steps.flatMap((/** @type {any} */ s) => (isObj(s) && Array.isArray(s.exit)
+        ? s.exit.filter((/** @type {any} */ e) => isObj(e) && e.type === 'check-passes' && isNonEmptyString(e.name)).map((/** @type {any} */ e) => e.name)
+        : [])));
+      const dropped = priorChecks.filter(isNonEmptyString).filter((n) => !carried.has(n));
+      if (dropped.length) {
+        red('check-shed', 'steps', `the predecessor plan carried check-passes(${dropped.join(', ')}) and this redraft drops ${dropped.length === 1 ? 'it' : 'them'} — a replan may move a check, never shed it (the remaining exits verify form only, so a shed green would be unearned)`);
+      }
+    }
   }
 
   // 3. secrets sweep — the agent-authored document is the riskier entry point
@@ -452,13 +508,15 @@ export function validatePlan(input, { job, maxStepRounds = 40, scopes, capRuns =
  * @param {Record<string, any>} s the step
  * @param {string} at step path prefix
  * @param {(code: string, path: string, detail?: string) => void} red
- * @param {{ checkNames: string[], fence: string[], insideFence: (p: string) => boolean, writeStep: boolean, toolsParsed: boolean, scopeMenu: string[], stepScope: string|null, overlapsStepScope: (p: string) => boolean }} ctx
+ * @param {{ checkNames: string[], fence: string[], insideFence: (p: string) => boolean, writeStep: boolean, toolsParsed: boolean, scopeMenu: string[], stepScope: string|null, overlapsStepScope: (p: string) => boolean, seedRedNames: string[], isFinalWrite: boolean }} ctx
  *   `stepScope`/`overlapsStepScope` (W3): the step's OWN narrowed fence when it
  *   declared a legal `scope`, null/always-true otherwise. Exits are OBSERVATIONS,
  *   not writes, so only `tree-changed` is constrained by it and only against
  *   DISJOINTness — see the arm for the measured semantics.
+ *   `seedRedNames`/`isFinalWrite` (Rule A-v2): the preflight-red check names and
+ *   whether THIS step is the plan's final write step — see the check-passes arm.
  */
-function validateExit(s, at, red, { checkNames, fence, insideFence, writeStep, toolsParsed, scopeMenu, stepScope, overlapsStepScope }) {
+function validateExit(s, at, red, { checkNames, fence, insideFence, writeStep, toolsParsed, scopeMenu, stepScope, overlapsStepScope, seedRedNames, isFinalWrite }) {
   if (!Array.isArray(s.exit) || s.exit.length === 0) {
     red('missing-required', `${at}.exit`, `non-empty array from the closed menu ${EXIT_TYPES.join('|')} — ALL listed exits must pass (AND-only); a step without an exit has no progress gate`);
     return;
@@ -485,6 +543,16 @@ function validateExit(s, at, red, { checkNames, fence, insideFence, writeStep, t
         // decision 1: a check the spec doesn't sign DOES NOT EXIST — and the
         // detail names the signed menu so the replan can aim, not guess
         red('check-unknown', eAt, `"${e.name}" is not an offered close stage — the agent references stages of the operator's close, never authors a ruler; offered: [${checkNames.join(', ') || 'none'}]`);
+      } else if (seedRedNames.includes(e.name) && writeStep && !isFinalWrite) {
+        // Rule A-v2 (`check-placement`): a check that was RED at preflight is
+        // the GOAL itself, not a milestone — it judges the whole territory, so
+        // an earlier step scoped to a slice can never satisfy it without
+        // crossing its own boundary (the bareagent-u death shape: 0 honest
+        // greens in the whole archive; the wide closing step greens 7/7). Only
+        // on a WRITE step and only when the anchor exists elsewhere: a
+        // read-only step already redded as a mailbox (one defect, one red),
+        // and a green-at-seed check is a guard, free to sit anywhere.
+        red('check-placement', eAt, `"${e.name}" was RED at preflight — a failing check is the goal itself and may only gate the plan's FINAL write step (make that step wide: free to edit any file it reports, iterating until it passes); an earlier step scoped to a slice can never satisfy a whole-goal check`);
       }
     } else if (e.type === 'tree-changed') {
       hasTreeChanged = true;