bareloop 0.38.0 → 0.40.0

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,12 @@ 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, jobLines?: {n: number}[]|null}} [opts]
+ *   `jobLines` — the person's numbered job lines (P7). Present, every stage must name the line it serves and every
+ *     line needs a stage or a refusal ({@link checkJobLines}); absent (every spec that predates the job block), the
+ *     rule is not run.
+ *   `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 +1221,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, jobLines = null,
   } = opts;
   const deferListing = opts.deferListing === true;
   /** @type {Red[]} */
@@ -1314,6 +1364,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
@@ -1384,11 +1446,71 @@ export function validateDeclaration(declaration, opts = {}) {
   });
 
   if (haveGuards) checkGuards({ declaration, guards: /** @type {any[]} */ (guards), red });
+  checkJobLines({ declaration, stages, jobLines, guards: haveGuards ? /** @type {any[]} */ (guards) : [], red });
 
   const ok = reds.length === 0;
   return { ok, reds, declaration: ok ? normalizeDeclaration(declaration) : null, grounded: haveListing, scoped, ceiling };
 }
 
+/**
+ * P7 rules 1-3 of the job block, at $0, in the gate that can still revise: every `fromLine` is a non-empty, duplicate-free array of real job line numbers (one check may serve several lines);
+ * every numbered job line has at least one stage OR a refusal reason in `refused` (a note in `notes` does NOT cover a
+ * line); the mandatory guards serve no line and carry no `fromLine`. The SHAPE of `fromLine` / `refused` is checked
+ * whenever they appear; the coverage half runs only when the person's `jobLines` were handed in.
+ * @param {{declaration: any, stages: any[], jobLines: {n: number}[]|null|undefined,
+ *   guards: {name: string}[], red: (c: string, p: string, d: string, e?: object) => void}} o
+ */
+function checkJobLines({ declaration, stages, jobLines, guards, red }) {
+  const known = Array.isArray(jobLines) && jobLines.length > 0 ? jobLines.map((l) => l.n) : null;
+  const guardNames = new Set(guards.map((g) => g.name));
+  /** @type {Set<number>} */
+  const served = new Set();
+  stages.forEach((/** @type {any} */ s, /** @type {number} */ i) => {
+    if (!isObj(s)) return;
+    const at = `stages[${i}].fromLine`;
+    const label = isNonEmptyString(s.name) ? s.name : `stages[${i}]`;
+    const guard = isNonEmptyString(s.name) && guardNames.has(s.name);
+    if (Object.hasOwn(s, 'fromLine')) {
+      if (guard) {
+        red('invalid-value', at, `stage "${label}" is a mandatory guard and serves no job line — remove its fromLine`);
+      } else if (!Array.isArray(s.fromLine) || s.fromLine.length === 0 || !s.fromLine.every((/** @type {any} */ x) => Number.isInteger(x) && x >= 1)) {
+        red('invalid-value', at, `stage "${label}" has fromLine ${JSON.stringify(s.fromLine)} — a non-empty array of job line numbers, e.g. [1] or [1, 3]`);
+      } else if (new Set(s.fromLine).size !== s.fromLine.length) {
+        red('invalid-value', at, `stage "${label}" lists a job line twice in fromLine ${JSON.stringify(s.fromLine)}`);
+      } else if (known !== null && s.fromLine.some((/** @type {number} */ x) => !known.includes(x))) {
+        red('invalid-value', at, `stage "${label}" has fromLine ${JSON.stringify(s.fromLine)}, but the job has lines ${known.join(', ')} only`);
+      } else for (const x of s.fromLine) served.add(x);
+    } else if (known !== null && !guard) {
+      red('missing-field', at, `stage "${label}" does not say which job lines it serves — give it fromLine: [N, ...] (${known.join(', ')}); `
+        + 'only a mandatory guard carries none');
+    }
+  });
+  /** @type {Set<number>} */
+  const refused = new Set();
+  if (declaration.refused !== undefined) {
+    if (!Array.isArray(declaration.refused)) {
+      red('invalid-value', 'refused', 'an array of {line, reason} — the job lines no stage can check, each with a reason');
+    } else {
+      declaration.refused.forEach((/** @type {any} */ r, /** @type {number} */ j) => {
+        const at = `refused[${j}]`;
+        if (!isObj(r) || !Number.isInteger(r.line) || r.line < 1 || !isNonEmptyString(r.reason)) {
+          red('invalid-value', at, '{line, reason}: a job line number and a plain-words reason');
+        } else if (known !== null && !known.includes(r.line)) {
+          red('invalid-value', `${at}.line`, `refused line ${r.line}, but the job has lines ${known.join(', ')} only`);
+        } else refused.add(r.line);
+      });
+    }
+  }
+  if (known !== null) {
+    for (const n of known) {
+      if (!served.has(n) && !refused.has(n)) {
+        red('job-line-uncovered', 'stages', `job line ${n} has no stage and no refusal. Give it a stage whose fromLine lists ${n}, or list `
+          + `it in "refused" as {"line": ${n}, "reason": "..."} — a note does not cover a line`, { line: n });
+      }
+    }
+  }
+}
+
 /**
  * COMPLETENESS — the deletion half of the owned-env rule, and the half a
  * by-VALUE comparison structurally cannot cover.

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';
@@ -113,6 +113,7 @@ import {
   QUESTION_SETS, questionsFor, requiredAnswersFor, authorClose, makeCostBook,
   runConfirmTurn, LANGUAGE_PICK_FIELD,
 } from './authorflow.js';
+import { draftCallOptions, assertDraftThinking } from './providers.js';
 import { runAuthorScout, buildSeedListing, SCOUT_ATTEMPTS } from './authorscout.js';
 import {
   DECLARED_GAP_PREFIX, DECLARED_GENRES, guardNames, isDeclaredClose, validateCloseDecl,
@@ -416,16 +417,19 @@ function composerRefusal(reds) {
  * one-genre-at-a-time law is untouched.
  *
  * @param {{answers: Record<string|number, any>, repoPath?: string|null, lang: string,
+ *   jobLines?: {n: number, text: string}[]|null, inputs?: {n: number, label: string, value: string}[]|null,
  *   verdictType?: string|null,
  *   questions?: Record<string|number, string>|null, generate?: Function, provider?: any,
  *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null, judgeModel?: string|null,
- *   rates?: {in: number, out: number}|null,
+ *   rates?: {in: number, out: number}|null, draftThinking?: 'on'|'off',
  *   onPhase?: (phase: string, data?: any) => void,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
  *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
  *   authorFn?: Function, authorOpts?: object, writeScope?: string[]|null,
  *   signerFix?: Function|any, proposeFn?: Function, compileOpts?: object,
  *   ask?: ((step: {kind: string, [k: string]: any}) => Promise<string|null>)|null,
+ *   answerQuestions?: ((o: {questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
+ *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>}|null>)|null,
  *   confirmGenerate?: Function|null, isRepo?: boolean,
  *   langResult?: {kind: string, candidates?: string[], [k: string]: any}|null}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
@@ -434,9 +438,15 @@ function composerRefusal(reds) {
  */
 export async function authorCloseForJob({
   answers, repoPath = null, lang, verdictType = null, questions = null,
+  // P7: the person's numbered job lines and numbered inputs (src/jobblock.js). Absent = every caller that predates the
+  // job block (no line tagging, no coverage rule).
+  jobLines = null, inputs = null,
   generate, provider = null, seedRef = null, scout = null, listing = null,
   ceilingUsd = null,
   rates = null,
+  // The drafter's THINKING knob ('on' | 'off', default 'off'; an operator param, never read from env here). It reaches the scout through
+  // `callOptions`; the `generate`/`confirmGenerate` the caller passes must be built with the SAME mode (`makeLoopGenerate`).
+  draftThinking = 'off',
   // Q2 IS GONE from the numbered interview (PRD item 33 M3 piece 3) — the
   // fence it used to describe in prose is now Destination's own proven
   // `writeScope`, and this is what carries it into the composer prompt
@@ -479,7 +489,14 @@ export async function authorCloseForJob({
   //                  shape matters here (a $0 language pick before the scout,
   //                  D7); every other kind leaves `lang` exactly as given.
   ask = null, confirmGenerate = null, isRepo = false, langResult = null,
+  // P7 item 5 (fwdloop am24/25): the seam that can really ASK the person. Present = the last drafting try, and only after
+  // the two before it both failed, may ask (`offerQuestions` below); the seam takes the machine-filtered questions, gets
+  // each answer (required, no skip), and hands back the job lines with the answers added as `~` rules plus the matching
+  // answers text. ABSENT (the CLI, every older caller) = nothing is ever offered and this file is byte-identical.
+  answerQuestions = null,
 }) {
+  // an operator-param guard: a typo never silently means "default" (throws before any work, even when the survey is supplied)
+  assertDraftThinking(draftThinking);
   /** @type {any} */
   const base = {
     ok: false, refusal: null, verdictType: null, closeDecl: null, seedRef: null,
@@ -580,7 +597,8 @@ export async function authorCloseForJob({
     // real tree. `attempts` is the ceiling the scout enforces on itself, so the
     // reader knows how many the line could repeat for.
     onPhase('scout', { attempts: SCOUT_ATTEMPTS });
-    survey = await scoutFn({ workdir, provider, ceilingUsd, onCall, ...(rates ? { rates } : {}) });
+    const scoutCallOptions = draftCallOptions(provider, draftThinking);
+    survey = await scoutFn({ workdir, provider, ceilingUsd, onCall, ...(rates ? { rates } : {}), ...(Object.keys(scoutCallOptions).length ? { callOptions: scoutCallOptions } : {}) });
     // …and the survey's own VERDICT, said the moment it lands. `state` is what
     // every downstream refusal keys on (F59: absent is never "no facts needed"),
     // and the fact count is the one number that says whether the ladder came
@@ -627,7 +645,7 @@ export async function authorCloseForJob({
     onPhase('confirm', {});
     const confirm = await runConfirmTurn({
       verdictType: picked, answers: interview.answers, questions: questions ?? questionsFor(picked),
-      facts: survey.facts, listing: null, writeScope, isRepo, lang, worseThanBefore,
+      facts: survey.facts, listing: null, writeScope, isRepo, lang, worseThanBefore, inputs,
       generate: confirmGenerate, book: confirmBook, ask, onPhase,
     });
     // DISTINCT from `runConfirmTurn`'s own per-round 'confirm-done' (fired once
@@ -671,13 +689,38 @@ export async function authorCloseForJob({
   // loop obeys — `author-call` carries the enforced cap instead, from where it
   // is computed.
   onPhase('author', {});
-  const authored = await authorFn({
+  /** the answers text the later stages read; the try-3 redraft replaces it (the person's answers are new `~` rules) @type {Record<string|number, any>} */
+  let stageAnswers = interview.answers;
+  let authored = await authorFn({
     workdir, seedRef: seed, lang, verdictType: picked,
-    answers: interview.answers, questions: questions ?? questionsFor(picked),
+    answers: stageAnswers, questions: questions ?? questionsFor(picked),
     scout: survey, listing: seeds, generate, ceilingUsd, onPhase, onCall, writeScope,
-    priorCalls: confirmPriorCalls, priorRaws: confirmPriorRaws, confirmed,
+    priorCalls: confirmPriorCalls, priorRaws: confirmPriorRaws, confirmed, jobLines, inputs,
+    ...(answerQuestions ? { offerQuestions: true } : {}),
     ...authorOpts,
   });
+  // P7 item 5: the drafter, on the last try after two failed ones, asked. The person answers (required, no skip); each
+  // answer becomes a `~` rule on its job line; the draft then runs ONCE more over the same survey, listing and confirmed
+  // plan, and may not ask again. The first leg's calls are carried as prior spend so the one ceiling still binds.
+  if (!authored.ok && authored.stop === 'questions-open' && answerQuestions && Array.isArray(authored.questions) && authored.questions.length) {
+    const dropped = (authored.iterations ?? []).flatMap((/** @type {any} */ it) => it?.droppedQuestions ?? []);
+    const updated = await answerQuestions({ questions: authored.questions, dropped, confirmed });
+    if (updated === null) return { ...base, interview, authoring: authored, reds: [], stop: 'confirm-abandoned', cost: authored.cost };
+    const scoutCalls = (survey?.calls ?? []).length;
+    const scoutRaws = (survey?.raws ?? []).length;
+    jobLines = updated.jobLines;
+    stageAnswers = updated.answers;
+    onPhase('author', {});
+    authored = await authorFn({
+      workdir, seedRef: seed, lang, verdictType: picked,
+      answers: stageAnswers, questions: questions ?? questionsFor(picked),
+      scout: survey, listing: seeds, generate, ceilingUsd, onPhase, onCall, writeScope,
+      priorCalls: (authored.cost?.calls ?? []).slice(scoutCalls), priorRaws: (authored.raws ?? []).slice(scoutRaws),
+      confirmed, jobLines, inputs,
+      ...authorOpts,
+      offerQuestions: false,
+    });
+  }
 
   if (!authored.ok) {
     return {
@@ -724,6 +767,11 @@ export async function authorCloseForJob({
     ...(authored.declaration.notes?.length
       ? { notes: authored.declaration.notes.map((/** @type {any} */ n) => (typeof n === 'string' ? redactSecrets(n) : n)) }
       : {}),
+    // P7: the job lines the drafter could not turn into a stage, each with its reason — the Job tab shows them. Free
+    // text the model wrote, so it rides the same redactor `notes` does.
+    ...(authored.declaration.refused?.length
+      ? { refused: authored.declaration.refused.map((/** @type {any} */ r) => ({ line: r.line, reason: redactSecrets(String(r.reason)) })) }
+      : {}),
   };
 
   // ── THE TWO SIGNED ARTIFACTS (softgreen module 4, wired here by module 5) ──
@@ -750,7 +798,7 @@ export async function authorCloseForJob({
     book.absorb(authored.cost?.calls ?? []);
     onPhase('rubric', { size: CALIBRATION_SIZE });
     const proposed = await proposeFn({
-      answers: interview.answers,
+      answers: stageAnswers,
       questions: questions ?? questionsFor(picked),
       generate,
       book,
@@ -950,6 +998,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 +1092,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 +1197,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 +1301,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, jobLines: Array.isArray(spec.jobLines) ? spec.jobLines : null });
   // 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 +1410,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';