bareloop 0.37.0 → 0.39.0

package/CHANGELOG.md

@@ -4,6 +4,59 @@ All notable changes to bareloop are documented here. Format:
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning:
 [SemVer](https://semver.org/spec/v2.0.0.html). Pre-1.0: **minor** = a ladder rung or
 feature lands, **patch** = docs, fixes, scaffolding.
+
+## [0.39.0] - 2026-10-10
+
+### Added
+
+- **Rubric judge rulebook (F192).** `says-what`: the doc description must say more than the function's own name; name words match by prefix (init/initialize; a shorter word of 4+ letters), and with no doc block `has-doc` alone owns the red. `params` also reds an extra `@param` that names no parameter, and a missing field of a destructured parameter once the doc names any field. `has-doc` checks the artifact itself: the judge only points at the declaration, code finds the `/**` block above it. Quote matching uses bareguard `quoteIn` with `wholeLines`, so a quote that dropped a leading `* ` still matches. The injection facts check shares `has-doc`'s acceptance, and every rule carries a plain-words `means` for the case-proposal prompt.
+- **A calibration case may not expect a red the rulebook cannot raise** (a `has-doc` red on a function that has a JSDoc block); it is refused before any locate call.
+- **Calibration record.** A per-case `diag` (locate facts, full reds, per-attempt cause) is recorded beside the graded rows, and each failing case gets one plain why-line. Grading, hashes and verdicts are untouched.
+- **Judged write fence.** A judged stage may only judge files inside the job's write fence; otherwise the red `judged-outside-write-scope` fires at draft time, before signing, on every door (authoring revise loop, signing, runner pre-flight, hand-written or reused specs).
+- **Worker warning.** When a job's close carries the js no-suppressions check, the worker is told up front that it reads comment lines too.
+- **Panel.**
+  - A refused rubric proposal and a refused signing each say why in plain words (panel and CLI share one owner); the full reds go to `draft-log.jsonl`.
+  - The calibrating line shows the gate's real score (8 of 10 / 3 of 5), not a stale check mark.
+  - The confirm plan reads as headed sections (#PLAN / #CHECKS / #NOT CHECKED, and #QUESTIONS when raised).
+  - The step map is fit-to-text chips with arrows, a line-start arrow on wrapped lines, and ↻N plus a dashed box for retries.
+
+### Changed
+
+- **Strike governor.** A judged stage's trend number is its distinct red count, compared to best-so-far; the gap headline reads "N red(s) across X of Y artifact(s)". Identical, flip-flopping or growing judged reds now strike (they read as not comparable before).
+- **Judge thinking is off** for the rubric judge on deepseek-flash, per call and allow-listed; workers and the drafter are unchanged and `JUDGE_MAX_TOKENS` stays 4000.
+- **Revise reopens the job's boxes**, filled as drafted; Start drafting then drafts fresh. The typed change request is gone: `POST /api/author/:id/revise`, `session.revise`, the "N changes left" hint and `revisesLeft` are removed. The CLI confirm turn is unchanged.
+- Dependencies: `bareguard` ^0.13.0 to ^0.21.0, `bare-agent` ^0.43.0 to ^0.49.0.
+
+### Fixed
+
+- **A passed calibration satisfies the seed-red gate for any close with a judged stage**, mixed or pure. The old test read a function's arity (always true), so signing refused a mixed rubric close after calibration passed 10/10 (live session smv0tasvb0u89).
+
+### Known limits
+
+- The judge's false-red classes seen on live run mv1j01sl are parked (FINDINGS F192 f), not fixed.
+- The step-map chips and the new panel text were not checked at phone width by a person.
+
+## [0.38.0] - 2026-10-08
+
+### Added
+
+- **Edit in chat on every run that did not finish green.** The Chat card opens filled from the run's signed job with every box open; Start drafting works as for any new job. The Ended block's NEXT line points at the button, and a refused Resume says so too.
+- **Resume moves to the left Chat card.** Resume mode locks the signed job and opens only the two caps (money and time); Sign & resume posts the same body as before.
+- **Expanded jobs show their latest 7 other runs;** older runs are reached by search.
+
+### Changed
+
+- The run page's Job tab is read-only on every run; the Job-tab resume mode is gone.
+- A stopped run wears `[■]` (red), not `[✗]`, on every surface.
+- Reuse workflow is offered only from a run that earned its green. The Reuse list shows only jobs with a real green run; an already-green run offers Edit in chat instead; `POST /api/author/start` refuses a reuse of any local run that did not finish green (the server owns the rule, not just the pickers); and a delivery-refused ending offers Reuse only on a run that earned its green.
+- The Reuse picker reads "Loading…" until its list arrives, and switching the Check type radios no longer blanks the New job boxes.
+
+### Fixed
+
+- A run cut by the money or wall cap reads `capped` on every surface: a leg that ended escalated on a money-halt or wall-halt, and a cap-cut open step on a single-leg run, no longer read as failed. One helper (`capKindOf`) owns the rule.
+- A Stop clicked in the fix loop reads "during the fix phase ... a resume continues the run" instead of the step text "a resume re-enters this step", which was wrong where no step exists (found on run muxwwrgs).
+- Small cleanups with unchanged behaviour: the `npm ci` comment matches the code, a dead pid above `pid_max` is handled, and tests follow the new panel behaviour.
+
 ## [0.37.0] - 2026-10-07
 
 ### Added

package/bareloop.context.md

@@ -67,7 +67,7 @@ inherited rule carries the green that minted it and the contrast that attributed
   an unknown provider name THROWS there, it never falls back to a default. Per-model
   request-key gating lives in that table: `deepseek-flash` sets bare-agent's
   `legacyMaxTokens`, because DeepSeek silently ignores `max_completion_tokens` and an
-  output cap that does not bind is a money hazard. `provider: 'gemini-api'` (PRD item 31.3)
+  output cap that does not bind is a money hazard. The judge's calls additionally carry a per-model, judge-only `thinking:{type:'disabled'}` (allow-list `OPENAI_JUDGE_CALL_OPTIONS`, read through `judgeCallOptions`, applied by `defaultJudgeLoop`; F192) because deepseek-flash's default thinking ate the 4000-token locate budget; workers and the drafter are untouched. `provider: 'gemini-api'` (PRD item 31.3)
   takes the same `Loop` path, reads `GEMINI_API_KEY`, and maps two real tiers
   (`sonnet` → `gemini-2.5-pro`, `haiku` → `gemini-2.5-flash`). It is
   **ADMITTED-PENDING-PROBE**: it has ZERO runs, and the probe rule is not waived for it —
@@ -677,6 +677,16 @@ attempt PLUS its close. Unpriced is never free: a null cost is a `pricing-red` s
 never retried, and the ladder is otherwise ONE retry (`JUDGE_ATTEMPTS`) — after that a broken
 judge is an instrument stop, never a red about the tree.
 
+**The rulebook, and what each rule can raise** (`JUDGE_RULES` in `src/judged.js`; every rule carries a plain-words `means` the case-proposal prompt renders, so a proposed practice case never expects a red the rule cannot raise). The judge only POINTS (quotes lines verbatim); code does every check; unsure is red; the judge never says pass/fail. Quotes are matched by bareguard's `quoteIn(..., {wholeLines:true})` (bareguard `^0.21.0`): a contiguous run of whole artifact lines, so a bare fragment cannot pass by hiding in a longer line, while a dropped leading `* ` of a JSDoc tag line still matches. `has-doc` checks only that a JSDoc block sits directly above the function (read off the artifact by `docBlockAbove`; the judge's quote is a pointer that must lie inside that block), so a documented function never breaks it. **`says-what`** (the doc's description must say more than the function's own name) reds when the described prose, minus a fixed list of function words and the name's own words (camel/snake/kebab, light inflections, and a prefix echo such as `init`/`initialize` when the shorter word is at least 4 letters), leaves nothing; no description, or an unlocatable quote, reds. It catches a pure name echo only ("Returns the total." for `getTotal` passes), and with NO doc block at all it stays silent and leaves the red to `has-doc` (the card is not required to carry both). `params` reds a declared parameter with no tag, an `@param` naming no parameter (each destructured slot absorbs one unmatched root tag), and, when the doc names any field of a simple destructured parameter, a missing field; `@param options` alone for `{ x, y }` passes. `returns` reds a returning function with no `@returns`. A practice case that expects a `has-doc` red on a function that has a block is refused as a legality red before any call (`validateCalibrationSet`).
+
+**A judged stage may only judge files inside the job's write fence** (`judgedOutsideFence`, `src/authoring.js`, called from `validateDeclaration`, which every door reaches: the authoring revise loop, `validateCloseDecl` at signing and runner pre-flight, and `validateJob` for hand-written or reused specs). A path outside `writeScope` reds `judged-outside-write-scope` at draft time, because a finding on a file the run is fenced out of can never be fixed. With no fence to compare against (the plain-folder deferral) the rule is not run.
+
+**One red count.** A judged stage's red COUNT is the number of distinct failing functions it itemizes (`redCount`/`redSet` on the stage detail, `src/kinds.js`; an unsure entry counts as one). The same number is the gap headline ("N red(s) across M of K artifact(s)") and the trend value the close-trend governor compares to best-so-far, direction always down (`trendValueOf`, `src/declaredclose.js`), so a repeated or growing judged failure strikes like any numeric stage instead of running to the wall. Spines written before this change carry the old headline (the card-item count).
+
+**A refused draft or signing says WHY in plain words.** `proposalStopText` (a refused rubric proposal: `proposal-invalid` / `rubric-invalid`) and `signingStopText` (refused signing gates) in `src/authorreadout.js` are the one owner of the wording, printed by the panel's failed step and the CLI alike: code-written sentences per red kind naming the case and function, the real spend so far, and what to do; a practice-case/check mismatch is not claimed to be anyone's fault; an unknown red code is quoted, never dropped. The full scrubbed reds go into the session's `draft-log.jsonl` as a `step-reds` record, and the calibrating line shows the gate's real result (`calibrationSummary`: "N of 10 practice cases graded right, M of 5 attack tests resisted").
+
+**The worker is warned about the `any` suppression guard.** A job whose actual close stages carry the js `any` suppression pattern gets one extra genre-owned line in the worker system prompt (`ANY_SUPPRESSION_WARNING`, `anySuppressionWarning`, `src/authoring.js`): the guard scans added comment lines too, so prose like `, any` trips it. The guard regex itself is unchanged.
+
 **The two SIGNED artifacts of a judged close** (softgreen module 4, design §4.3/§4.4). The
 softgreen interview's Judge Examples answer (PRD item 33 M3 piece 3 — one example to pass, one
 to fail, and why; formerly two questions, Q6+Q7) compiles into the RUBRIC CARD and the FROZEN
@@ -745,12 +755,13 @@ signing record keeps WHAT was certified — `cardHash`, `casesHash`, `setHash` (
 resolved judge identity), the graded rows and the battery — beside `judgeModel` itself.
 `runCalibration` takes `judgeModel` as a REQUIRED argument and throws without one.
 
-**D9.3 for a judged-ONLY close** (ruling 3, hamr: *"fix it now, we are delivering softgreen"*).
-A judged stage skips the seed read (ruling 8), so a close whose only work stage is judged has no
-seed red and used to be unsignable — the one job shape softgreen exists for. For that shape only,
-a PASSED calibration gate plays the seed-red role (the polarity law makes *this close can fail* a
-demonstrated fact), and the record says so: `gates.seedVerdict.satisfiedBy === 'calibration'`. A
-close with any mechanical work stage is UNCHANGED and still needs its seed red.
+**D9.3 for a close with a judged stage** (ruling 3, hamr: *"fix it now, we are delivering softgreen"*;
+widened 2026-10-09: *"a rubric job should check if judge can judge (calibration) ... we can't close
+everything upfront"*). A judged stage skips the seed read (ruling 8), so it can never be red at seed. For
+ANY close carrying a judged stage, pure or mixed with mechanical stages, a PASSED calibration gate plays the
+seed-red role (`seedProofIsCalibration`), and the record says so when no mechanical stage is red itself:
+`gates.seedVerdict.satisfiedBy === 'calibration'`. A failed or missing calibration never satisfies it. A close
+with NO judged stage is UNCHANGED and still needs a work stage red at the seed.
 
 **THE JUDGE TIER IS INSIDE THE SIGNATURE, and the stage refuses a mismatch.** *"A judge-model
 bump forces a full recalibration"* used to be an operator-side rule with nothing to fire on,
@@ -1863,7 +1874,7 @@ hand them to the one `Loop` that drives worker, scout and planner rounds; the ru
 them once. No price on the row = no `rates` key anywhere = the guesstimate above, byte-identical to
 before. bareloop keeps no price list of its own, ever.
 
-**The provenance is on the record, per round (`rateSource`).** The pinned bare-agent (`^0.43.0`)
+**The provenance is on the record, per round (`rateSource`).** The pinned bare-agent (`^0.49.0`)
 carries it on every metering payload, and bareloop forwards it VERBATIM (`rateSourceFields`,
 `src/planrun.js`): every API `worker-round` (worker, scout, planner, fix loop) carries it beside
 `pricing` today — `'caller'` when a customer price is on the key's row, else `'tier'`/`'default'`
@@ -3453,13 +3464,13 @@ key you want first (the panel picks the row by the Model menu).
   re-attaches to it from the server's session map (nothing is stored page-side). A panel restart mints a new token and
   loses the in-memory sessions: the page then shows one "reload this page" line and stops the Chat poll (no auto-reload;
   drafting money already spent stays booked via `draft-spend.json`, below). `GET /api/author/:id` polls the session's state
-  (phase, chat messages, cost, `revisesLeft`, `specHash` once prepared). `POST /api/author/
+  (phase, chat messages, cost, `specHash` once prepared). `POST /api/author/
   :id/send {text}` answers whatever the confirm turn is currently asking (the `language` pick or a plan's
   own follow-up question — the old `worseThanBefore` ask is retired, 2026-09-28) — refused outright when the pending ask is the
-  plan MENU itself (`{ok:false}`, no route from chat text to a plan decision, ever). `POST
-  /api/author/:id/revise {text}` is the menu's own `fix` pick, with the chat text as the
-  correction (D3: max 2 rounds, `revisesLeft` derived from the confirm turn's own round
-  number, never a second hardcoded cap). `POST /api/author/:id/sign-prepare` is the menu's
+  plan MENU itself (`{ok:false}`, no route from chat text to a plan decision, ever). There is no
+  typed-revise route (2026-10-09): the panel's **Revise** button, shown only while a plan waits for the OK,
+  abandons the draft (`/abandon`; spend already booked stays booked) and reopens the New job card with the same
+  values in every box, editable, for a fresh Start drafting; no change request is ever sent to the model. `POST /api/author/:id/sign-prepare` is the menu's
   own `confirm` pick — it runs gates 1–4 and reaches `phase:'prepared'` with a `specHash`; it
   NEVER signs. `POST /api/author/:id/sign {specHash}` is the ONLY route that spawns a run —
   it refuses unless `phase==='prepared'` and the posted hash matches the session's own
@@ -3471,7 +3482,7 @@ key you want first (the panel picks the row by the Model menu).
   server's environment with `~/.config/bareloop/.env` merged in per request (a key is never read
   into or sent to the page — a missing one refuses the session at $0, naming only the env var). `src/panel/authorsession.js` takes
   test-only DI seams (`scout`/`generate`/`confirmGenerate`/`authorFn`/`prepareSigningFn`) so
-  a test can drive the real ask()-channel/revise/hash wiring without a live provider call;
+  a test can drive the real ask()-channel/hash wiring without a live provider call;
   none of them are reachable from `authorroutes.js`'s real construction path. Sessions live
   under `~/.config/bareloop/panel-sessions/<id>/` (each one's own `resolved-spec.json` and
   `signing.json`, the two files `bareloop author` itself already writes). Edit/re-sign, the
@@ -3503,20 +3514,20 @@ key you want first (the panel picks the row by the Model menu).
   result glyphs are unchanged. The reuse button is described under Reuse workflow, below.
   **Status words (click-through 2026-10-04)** → every run row, run detail and imported row carries `status`
   `{key, sign, word}` from ONE table (`src/panel/status.js`): `[▶] running · [·] waiting · [✓] passed · [✗] failed ·
-  [✗] capped · [✗] stopped · [?] died`; `glyph` is that sign. Mapping: green/already-green/satisfied → passed; no
+  [✗] capped · [■] stopped · [?] died`; `glyph` is that sign (the Runs `✗` filter chip also finds a `[■]` run). Mapping: green/already-green/satisfied → passed; no
   job-end + runner alive → running, gone → died; cap-halt, wall-halt, and an escalation that is a money-halt or wall-halt
-  → capped; `stopped` → stopped; every other outcome (plan-red, check-red, step-red, close-red, provider-red,
+  → capped (ONE rule, `capKindOf` in `src/legs.js`, shared by the run status, a leg's stop reason and the part cards); `stopped` → stopped; every other outcome (plan-red, check-red, step-red, close-red, provider-red,
   step-stalled, other escalations, refusals) → failed. The detail also carries `startedAt` and `endedAt` (the last
   `job-end` timestamp, null while live or died). `GET /api/imports` rows and `GET /api/imports/:id` carry `runStatus`
   (passed, or null when the bundle shows no green) and `runReason` (`goal met`). The Ended block's lines for died and
   stopped runs are `no ending recorded` and `you pressed Stop` (each `— resume` when Resume is offered).
   Every PART of a run detail (`parts[]`) also carries its own `status` `{key, sign, word}` from the same table
   (`partStatusFor`, `src/panel/status.js`): drafting, a green outcome and a part with no verdict and no cut-off → passed; a red
-  outcome → its run-outcome word; a part its leg's halt cut off → capped (money cap / time cap), stopped (you stopped it),
+  outcome → its run-outcome word; a part its leg's halt cut off → capped (money cap / time cap — also a leg that ended `escalated` on a money-halt or wall-halt, and the open step of a single-leg run that ended on a cap), stopped (you stopped it),
   died, else failed. A run that DIED (no `job-end`, runner gone) leaves its last part in flight: when that part has no outcome
   and no cut-off, the server marks it `died` (`[?] died`), never the "happened, so passed" default — replay alone cannot tell
   died from still running, so `getRunDetail` decides it from the same `death` verdict as the run's status. A live run's open
-  part stays running; a part that finished before the death keeps its own status. The page's map box reads `[sign] word` (the live part reads `[▶] running`); the step cards and Audit rows
+  part stays running; a part that finished before the death keeps its own status. The page's step map is a row of fit-to-text chips that flow and wrap (no truncation, no horizontal scroll), `[sign title]` each, in plan order, with an arrow between neighbours and a leading arrow on a wrapped line; the status word (from the same table) rides in the chip's tooltip, a retried step has a dashed border and a `↻N` tries mark, a leg boundary a dotted right edge, and a click jumps to that part's Audit row (the live part reads `[▶]`); the step cards and Audit rows
   show the word only; no surface says "done".
   **Resume (item 2)** → `POST /api/runs/:runid/resume` (`src/panel/runroutes.js`), behind
   `checkHumanGuard` (token + own address, like `/api/author/*`); body `{budgetUsd?, maxWallMin?}`
@@ -3534,7 +3545,9 @@ key you want first (the panel picks the row by the Model menu).
   the log tail is returned as `error` verbatim; otherwise `{ok:true, runid, specHash, capsChanged,
   log}`. The run keeps its runid and its one list row: the resumed leg appends to the same spine (P5-R,
   `leg-start` in the run list), it never appears as a new run. The page's Resume button opens the
-  caps form (prefilled, "spent so far") and `Sign & resume` is the human click.
+  Chat card in RESUME mode (title `RESUME <job> (run-N)`, filled from `GET /api/author/start-from`, every box locked
+  except the two caps, "spent so far" shown, Clear/Start drafting hidden) and `Sign & resume` on that card is the human
+  click, posting this same route; the run's Job tab is read-only on every run.
   **Stop (item 5)** → `POST /api/runs/:runid/stop` (`src/panel/runroutes.js`, `checkHumanGuard`, no body).
   It writes the run's STOP REQUEST, a file `<spine>.stop` (`stopFilePath(spine)`, `src/legs.js` — the one
   spelling), and signals nothing. `404` unknown run; `409` when the run's LATEST leg is not live
@@ -3556,11 +3569,18 @@ key you want first (the panel picks the row by the Model menu).
   in the Run tab's action area while live, "stopping after this turn…" after the click, and the same
   `[Resume]` there once the engine would accept one. A Stop clicked while the run is in the
   scout, plan or close-fix phase is honoured at that phase's next round boundary, the same as in a step (it used to be read in
-  step workers only).
-  **Reuse workflow (replaces P5 item 3's Start from this, 2026-10-03)** — a button on GREEN runs only (the Run tab's
-  action row and the Ended block; `ended.actions` carries `{id:'reuse', label:'Reuse workflow'}` on green and
-  green-with-destination-refused rows, and on no other: a red row's next line is "Change the job: Clear the card and draft a new one.", and
-  stopped/capped/died rows offer `resume` only) and on every imported job; the Chat card's Check type is one radio group of three
+  step workers only). A stop in the close-fix loop reads "You stopped the run during the fix phase … a resume continues the
+  run" (`ralph`'s `phase` option; the step loop keeps "a resume re-enters this step").
+  **Edit in chat (2026-10-08)** — `ended.actions` carries `{id:'edit', label:'Edit in chat'}` on EVERY ending that is not a
+  real green (failed, capped, stopped, died, every other red, and an already-green or delivery-refused already-green),
+  after `resume` when both show. The button reads `GET /api/author/start-from` and opens the Chat card filled from the
+  signed job with EVERY box open and the normal Start drafting path (no reuse state, no borrowed track record), under a
+  code-owned origin line ("Copied from <job> (run-N) — <status word>. …").
+  **Reuse workflow (replaces P5 item 3's Start from this, 2026-10-03)** — a button on runs that EARNED their green only
+  (the Run tab's action row and the Ended block; `ended.actions` carries `{id:'reuse', label:'Reuse workflow'}` on `green`
+  and green-with-destination-refused `green` rows, and on no other: an `already-green` run (the check passed before any
+  work) offers Edit in chat instead, and a red row's next line is "Change the job: press Edit in chat."; stopped/capped/died
+  rows offer `resume` and `edit`) and on every imported job; the Chat card's Check type is one radio group of three
   (Deterministic · Rubric · Reuse workflow), and the third opens a search picker over `GET /api/author/reuse-jobs` (below) that
   fills the card through this same path (a pick, then `change` returns to the empty search; Deterministic or Rubric leaves reuse).
   It opens the Chat tab's New job card
@@ -3574,10 +3594,12 @@ key you want first (the panel picks the row by the Model menu).
   green, notGreen, live, finished, avgSpendUsd, avgWallMs}, line}` (`404` unknown, `409` with an `error` when
   there is nothing to copy: no log, the run's signed job is not on disk, or an imported job that changed, lost its
   dependency or no longer matches its signed bytes); `POST /api/author/start` accepts `startFrom: <runid>` or
-  `startFrom: {importId}` beside the card and answers `{ok, sessionId, reuse, state}`. The old
+  `startFrom: {importId}` beside the card and answers `{ok, sessionId, reuse, state}`; a local `startFrom: <runid>` whose
+  latest outcome is not `green` (`start-from` carries that `outcome`) is refused `409 "only a run that finished green can
+  be reused — this one did not"` — the server owns the rule, not just the pickers. The old
   `POST /api/author/start-from-check` and the "Changed — new job" mode are gone. `GET /api/author/reuse-jobs[?model=<Name>]` →
   `{ok, jobs:[{job, runid, checkType:'deterministic'|'rubric', line}]}` is the Chat card's Reuse workflow picker list: one entry per
-  job (same `workflowKey`) with at least one GREEN local run, `runid` = its newest green run (hand it to `start-from`), `line` =
+  job (same `workflowKey`) with at least one real `green` local run (`already-green` is not a reuse source), `runid` = its newest green run (hand it to `start-from`), `line` =
   start-from's own estimate line, newest green first; imported jobs are not listed. **Identity, two keys:** the
   signature hash `jobSpecHash` is unchanged (it covers the caps and the write fence — what the person signs);
   `workflowKey(spec)` (`src/job.js`, not exported from the package root) is a sha256 over the signed spec WITHOUT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bareloop",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Workflows that earn their own design, with receipts — agent-authored workflows for repeated, long, verifiable jobs that improve across runs under an un-gameable gate.",
   "type": "module",
   "main": "./src/index.js",
@@ -27,8 +27,8 @@
     "check:lockfile": "node scripts/check-lockfile.mjs"
   },
   "dependencies": {
-    "bare-agent": "^0.43.0",
-    "bareguard": "^0.13.0",
+    "bare-agent": "^0.49.0",
+    "bareguard": "^0.21.0",
     "litectx": "^0.32.0"
   },
   "devDependencies": {

package/src/authorflow.js

@@ -384,7 +384,8 @@ export const CLASS_STATEMENTS = Object.freeze({
     + 'the result and deciding whether it is any good — and no command can render it. Compose the mechanical part '
     + 'first: everything about this repository a command can decide is still a mechanical stage, exactly as it would '
     + 'be for a green job. Then put ONE judged-floor stage AFTER them, carrying the few things the person said they '
-    + 'actually look for and the real files the work lands in. A judged stage decides only the lines its card names, '
+    + 'actually look for and the real files the work lands in (files the job may EDIT, inside the write fence, '
+    + 'because a finding on a file the run is fenced out of can never be fixed). A judged stage decides only the lines its card names, '
     + 'so name each thing they look for as its own line, and leave nothing to be inferred.',
   // N4 slice 1. The mechanical-first composition law is stated as an ORDER
   // because first-red-wins makes the order the mechanism: the cheap stages shield
@@ -2389,7 +2390,7 @@ export async function authorClose({
       }
       previous = ask.declaration;
 
-      const v = validateDeclaration(ask.declaration, { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType });
+      const v = validateDeclaration(ask.declaration, { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType, writeScope });
       // SCRUBBED HERE, once, where the reds enter this module's records — the same
       // boundary rule `renderRejectBlock` already states, applied to the OTHER
       // channel they travel down. A validation red quotes what the model declared

package/src/authoring.js

@@ -516,6 +516,32 @@ export const TYPES_GENRE_TEMPLATE = `1. The STRICT form of the language's type c
 
 export const GENRE_LANGUAGES = Object.freeze(['js', 'python']);
 
+/**
+ * The js `any` suppression pattern's regex, ONE spelling: the TYPES js battery
+ * below composes it into the signed guard, and `anySuppressionWarning` keys on
+ * it, so the warning and the guard cannot drift. The guard scans every ADDED
+ * line, comments included, so plain prose like ", any" trips it.
+ */
+const JS_ANY_REGEX = '(?:[{<|(\\[:,]|\\bas)\\s*any\\b|\\bany\\[\\]';
+
+/** The worker-facing line that rides with the js `any` guard (run mv13ery3). */
+export const ANY_SUPPRESSION_WARNING = '\nThe no-suppressions check also reads comments: never write the word any right after a comma, colon, bracket, brace, < or | '
+  + "(e.g. ', any', ': any', '(any'), even in plain English — write 'every', start the clause differently, or put it in backticks.";
+
+/**
+ * The warning line for a job whose ACTUAL stages carry the js `any` pattern, else
+ * ''. Derived from the stages' patterns (never goal prose), so a job without the
+ * guard is told nothing about it.
+ * @param {any[]|null|undefined} stages
+ * @returns {string}
+ */
+export function anySuppressionWarning(stages) {
+  const has = Array.isArray(stages) && stages.some((s) => isObj(s) && s.kind === 'pattern-absent-in-diff'
+    && isObj(s.params) && Array.isArray(s.params.patterns)
+    && s.params.patterns.some((/** @type {any} */ q) => isObj(q) && q.regex === JS_ANY_REGEX));
+  return has ? ANY_SUPPRESSION_WARNING : '';
+}
+
 /**
  * THE GENRE, as data. The suppression batteries are the hand-written closes'
  * own `SUPPRESSIONS` tables (`scripts/u-pulselog-close.mjs:35`,
@@ -541,7 +567,7 @@ export const TYPES_GENRE = Object.freeze({
         Object.freeze({ id: 'ts-expect-error', regex: '@ts-expect-error' }),
         Object.freeze({ id: 'ts-nocheck', regex: '@ts-nocheck' }),
         Object.freeze({ id: 'eslint-disable', regex: 'eslint-disable' }),
-        Object.freeze({ id: 'any', regex: '(?:[{<|(\\[:,]|\\bas)\\s*any\\b|\\bany\\[\\]' }),
+        Object.freeze({ id: 'any', regex: JS_ANY_REGEX }),
         Object.freeze({ id: 'any-star', regex: '@\\w+\\s*\\{\\s*[*?]\\s*\\}' }),
         Object.freeze({ id: 'cast', regex: '@type\\s*\\{.*\\}\\s*\\*\\/\\s*\\(' }),
       ]),
@@ -1057,6 +1083,25 @@ function scopeOfJob(declaration, idx, guards) {
   return { scoped: false, via: null };
 }
 
+/**
+ * Which of a judged stage's paths lie OUTSIDE the job's write fence? One owner of the rule "a check must be
+ * free to edit every file it can report on", called from every door that validates a declaration. It uses
+ * the shipped fence spelling (`globToPrefix`, the same containment reading plan.js's `insideFence` has) and
+ * returns `[]` when there is no fence to compare against or the paths are not a string list (shape is the
+ * schema walk's business).
+ * @param {unknown} paths @param {string[]|null|undefined} writeScope
+ * @returns {string[]}
+ */
+export function judgedOutsideFence(paths, writeScope) {
+  if (!Array.isArray(writeScope) || writeScope.length === 0 || !Array.isArray(paths)) return [];
+  const fence = writeScope.filter(isNonEmptyString).map(globToPrefix);
+  if (fence.length === 0) return [];
+  return paths.filter(isNonEmptyString).filter((raw) => {
+    const n = normPrefix(raw);
+    return !fence.some((f) => f === '.' || n === f || n.startsWith(`${f}/`));
+  });
+}
+
 /**
  * Kinds a declaration may carry AT MOST ONCE, as data beside the catalogue.
  *
@@ -1154,7 +1199,9 @@ function readPath(p, dotted) {
  * @param {{catalogue?: Record<string, KindSpec>, listing?: string[]|null,
  *   guards?: {name: string, kind: string, params: Record<string, any>, fill: string[]}[]|null,
  *   envOwned?: string[]|null, envInjected?: Record<string, string>|null, deferListing?: boolean,
- *   verdictType?: string|null}} [opts]
+ *   verdictType?: string|null, writeScope?: string[]|null}} [opts]
+ *   `writeScope` — the job's signed write fence. Every path a judged stage judges must sit inside it
+ *     ({@link judgedOutsideFence}); absent, the rule is not run (the plain-folder deferral has no fence).
  *   `listing` — repo-relative paths at the seed (`git ls-tree -r --name-only`).
  *   `guards` — the picked class's injected guards (`classGuards`).
  *   `verdictType` — the class the USER picked (`VERDICT_CLASSES`).
@@ -1171,7 +1218,7 @@ function readPath(p, dotted) {
 export function validateDeclaration(declaration, opts = {}) {
   const {
     catalogue = KIND_CATALOGUE, listing = null, guards = null, envOwned = null, envInjected = null,
-    verdictType = null,
+    verdictType = null, writeScope = null,
   } = opts;
   const deferListing = opts.deferListing === true;
   /** @type {Red[]} */
@@ -1314,6 +1361,18 @@ export function validateDeclaration(declaration, opts = {}) {
       } else kindOwners.set(s.kind, label);
     }
 
+    // A judged stage may only judge what the run can fix: a path outside the write fence is a
+    // finding the worker can never act on (run mv13ery3: bin/pulselog.js, fence src/**).
+    if (s.kind === JUDGED_FLOOR_KIND && isObj(s.params)) {
+      const outside = judgedOutsideFence(s.params.paths, writeScope);
+      if (outside.length > 0) {
+        red('judged-outside-write-scope', `${at}.params.paths`, `stage "${label}" judges ${outside.join(', ')}, but the `
+          + `job may only edit ${writeScope?.join(', ')}. A check that reports on a file the run is fenced out of can `
+          + 'never be satisfied — every finding on it is one the worker cannot fix. Name files inside the write fence',
+        { stage: label, outside, fence: (writeScope ?? []).map(globToPrefix) });
+      }
+    }
+
     // ── RULING 5, AS LAW: judged and human stages are `offer: false`, and the
     // law is checked rather than applied. `checkMenu` filters `offer !== false`,
     // so a declaration that says nothing is silent about a rule the runner

package/src/authorjob.js

@@ -99,7 +99,7 @@
 // in the stored declaration (forward-compat point 3), and the suite pins it.
 
 import { jobSpecHash, validateJob } from './job.js';
-import { seedAtHead, seedListing, seedRead as runSeedRead, makeSeedTrees, SEED_EXEMPT_KINDS, judgedStages, closeJudges } from './kinds.js';
+import { seedAtHead, seedListing, seedRead as runSeedRead, makeSeedTrees, judgedStages, closeJudges } from './kinds.js';
 // SOFTGREEN modules 4 and 5 — the compile the interview's Q6/Q7 answers land in,
 // and the gate that decides whether the ruler they describe is a ruler.
 import { proposeJudgedArtifacts, signJudgedArtifacts, foldJudgedArtifacts } from './cardauthor.js';
@@ -950,6 +950,17 @@ const scrubRed = (r) => /** @type {any} */ (Object.fromEntries(
   Object.entries(r).map(([k, v]) => [k, typeof v === 'string' ? redactSecrets(v) : v]),
 ));
 
+/**
+ * THE one spelling of "a passed calibration gate stands in for the seed red": the
+ * close carries a judged stage AND the gate ran and passed. A failed or missing
+ * calibration never satisfies it, and a close with no judged stage never reaches it.
+ * @param {any[]} judged `judgedStages(closeDecl)` @param {any} calibration `gates.calibration`
+ * @returns {boolean}
+ */
+export function seedProofIsCalibration(judged, calibration) {
+  return judged.length > 0 && calibration?.ok === true;
+}
+
 /**
  * GATE 4 — the calibration gate, and the only gate here that spends money.
  *
@@ -1033,7 +1044,10 @@ async function calibrationGate({ spec, judgedStages, judgeLoop, judgeModel, onJu
 
   /** what the signing evidence KEEPS about this gate. The per-case artifacts are
    * deliberately not in it — they are already in the signed spec, and a second
-   * copy in the evidence file is a second thing to keep in step. What IS kept is
+   * copy in the evidence file is a second thing to keep in step. Each graded row's
+   * `diag` (F192) keeps the judge's own facts and the decision's reds — scrubbed
+   * and bounded quotes, never an artifact body — so a refusal reads from its own
+   * record. What IS kept is
    * WHICH BYTES were certified (`cardHash`/`casesHash`/`setHash`) and BY WHICH
    * MODEL (`judgeModel`), which is what makes a judge-model bump detectable at
    * all. */
@@ -1135,16 +1149,15 @@ async function calibrationGate({ spec, judgedStages, judgeLoop, judgeModel, onJu
  *      has already had its chance, and nobody pays to discover a broken
  *      declaration.
  *
- * D9.3 AND THE JUDGED-ONLY CLOSE (2026-08-18 second addendum, ruling 3; hamr:
- * *"fix it now, we are delivering softgreen, isn't that the whole point?"*). Gate
- * 3 protects against a close that cannot fail — one that scans nothing and reads
- * green at seed against a true red. A judged stage SKIPS the seed read by ruling
- * 8, so a close whose only work stage is judged has no seed red to show and used
- * to be unsignable: the one job shape softgreen exists for. For that shape, and
- * ONLY that shape, a PASSED calibration gate plays the seed-red role — it is that
- * close's own proof of failability, held to the same all-or-nothing bar. A close
- * with a mechanical work stage is UNCHANGED: it still needs a seed red, whatever
- * its calibration says.
+ * D9.3 AND THE JUDGED CLOSE (2026-08-18 second addendum, ruling 3; hamr: *"fix it now,
+ * we are delivering softgreen, isn't that the whole point?"*; widened 2026-10-09 to mixed
+ * closes, hamr: *"a rubric job should check if judge can judge (calibration) and judge
+ * rules can apply properly to pass ... we can't close everything upfront"*). Gate 3
+ * protects against a close that cannot fail. A judged stage SKIPS the seed read by ruling
+ * 8, so it can never show red there. For ANY close carrying a judged stage (pure or
+ * mixed with mechanical stages), a PASSED calibration gate plays the seed-red role
+ * (`seedProofIsCalibration`). A close with NO judged stage is UNCHANGED: some work stage
+ * must be red at the seed. A failed or missing calibration never satisfies it.
  *
  * Gates 2 and 3 share ONE execution, and that is stated rather than hidden: at
  * job creation the tree IS the seed, so "does every stage run against the real
@@ -1240,7 +1253,7 @@ export async function prepareSigning({
   }
   // the class rides from the SPEC (PRD v1.57 §2) — gate 1a already refused a spec
   // whose class is unknown or locked, so this is the class D5's battery hangs off
-  const dv = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: spec.verdictType });
+  const dv = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: spec.verdictType, writeScope: spec.writeScope });
   // the grounded gate's reds quote BOTH untrusted sources — the declaration, and
   // the seed listing itself (the listing rule names what really sits beside an
   // invented path). The listing half is a channel gate 1a structurally cannot
@@ -1349,17 +1362,17 @@ export async function prepareSigning({
   // the close-authoring layer, and this gate is what refuses it BEFORE a
   // signature rather than after a paid run.
   //
-  // THE JUDGED-ONLY ROUTE (ruling 3). A close whose work stages are ALL
-  // seed-exempt has no seed verdict to be red — not because it measures nothing,
-  // but because ruling 8 exempts a judged stage from being measured at seed. Its
-  // proof of failability is the calibration gate, which has just run and passed
-  // (a failed one returned above), and which contains signed cases the pipe must
-  // RED as well as ones it must pass — the polarity law makes "this close can
-  // fail" a thing that was demonstrated rather than assumed. A close with any
-  // mechanical work stage takes the original path unchanged.
-  const mechanicalWork = work.filter((r) => !SEED_EXEMPT_KINDS.includes(r.kind));
-  const judgedOnly = judgedStages.length > 0 && mechanicalWork.length === 0;
-  if (judgedOnly && base.gates.calibration?.ok) {
+  // THE JUDGED ROUTE (ruling 3, widened 2026-10-09 by hamr: "a rubric job should
+  // check if judge can judge (calibration) and judge rules can apply properly to
+  // pass ... we can't close everything upfront"). A close carrying ANY judged stage
+  // has a work-bearing stage that ruling 8 exempts from the seed read, so the seed
+  // cannot show it red — not because it measures nothing, but because it is not
+  // measured there. Its proof of failability is the calibration gate, which has
+  // just run and passed (a failed one returned above), and which contains signed
+  // cases the pipe must RED as well as ones it must pass. That holds for a PURE
+  // judged close and a MIXED one alike; a close with NO judged stage takes the
+  // original path unchanged (some work stage must be red at the seed).
+  if (workRed.length === 0 && seedProofIsCalibration(judged, base.gates.calibration)) {
     // said out loud in the record: this close passed gate 3 on a DIFFERENT proof,
     // and a reader must never have to infer which one from an empty workRed list
     base.gates.seedVerdict.satisfiedBy = 'calibration';