bareloop 0.37.0 → 0.39.0

package/src/panel/server.js

@@ -74,7 +74,7 @@ export const RUNID_RE = /^[A-Za-z0-9._~-]+$/;
 export const DEFAULT_PORT = 4700;
 
 /**
- * `[✓]`/`[✗]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
+ * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
  * anywhere in the page). `null` (no `job-end` reached — a killed-mid-run or
  * still-running spine) reads `▶` — the same "in progress / unresolved" glyph
@@ -82,10 +82,10 @@ export const DEFAULT_PORT = 4700;
  * running attempt and an archived spine that never reached its own end are
  * the same fact from this read-only side: no verdict has been recorded yet.
  * @param {string|null} outcome
- * @returns {'✓'|'✗'|'▶'}
+ * @returns {'✓'|'✗'|'■'|'▶'}
  */
 export function glyphForOutcome(outcome) {
-  return /** @type {'✓'|'✗'|'▶'} */ (statusFor({ outcome }).sign);
+  return /** @type {'✓'|'✗'|'■'|'▶'} */ (statusFor({ outcome }).sign);
 }
 
 /**
@@ -417,7 +417,7 @@ const GOAL_NOT_MET = new Set(['plan-red', 'check-red', 'step-red', 'escalated'])
  * @returns {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null}
  */
 export function endedFor(summary, death, o = {}) {
-  const base = endedBase(summary, death, o);
+  const base = withEditAction(endedBase(summary, death, o));
   const wt = o.worktree;
   if (!base || !wt) return base;
   // P6 item 1 — the run worked on a worktree in the person's own repo. GREEN: the branch carries the work (the folder is
@@ -432,21 +432,31 @@ export function endedFor(summary, death, o = {}) {
   return wt.exists ? { ...base, next: `${base.next} Your work is in ${wt.folder}.` } : base;
 }
 
+/**
+ * "Edit in chat" (hamr 2026-10-07): offered on EVERY non-green ending (failed, capped, stopped, died, every other red),
+ * after Resume when both show; a green ending keeps Reuse workflow only. ONE place, so no ending branch can forget it.
+ * @param {{reason: string, next: string, line: string, actions: {id: string, label: string}[]}|null} ended
+ */
+function withEditAction(ended) {
+  if (!ended || ended.actions.some((a) => a.id === 'reuse')) return ended;
+  return { ...ended, actions: [...ended.actions, { id: 'edit', label: 'Edit in chat' }] };
+}
+
 /** @param {any} summary @param {any} death @param {any} o */
 function endedBase(summary, death, o) {
   const resumeOk = !!(o.resume && o.resume.ok);
   /** @type {{id: string, label: string}[]} */
   const RESUME = [{ id: 'resume', label: 'Resume' }];
   /** Reuse workflow (replaces P5 item 3's Start from this, hamr 2026-10-03): the same signed job on a new source — a NEW
-   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: Clear the card and draft a new one" instead. */
+   *  run, never a rerun. Offered on GREEN rows only; every red row says "Change the job: press Edit in chat" instead. */
   const REUSE = [{ id: 'reuse', label: 'Reuse workflow' }];
-  const CHANGE = 'Change the job: Clear the card and draft a new one.';
+  const CHANGE = 'Change the job: press Edit in chat.';
   const detailOf = (/** @type {string|null} */ s) => {
     if (typeof s !== 'string' || s.length === 0) return '';
     return s.length > 120 ? `${s.slice(0, 120)}…` : s;
   };
   /** a resumable ending whose Resume the engine would refuse: say so, never offer the button */
-  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}.`);
+  const resumeOr = (/** @type {string} */ okNext) => (resumeOk ? okNext : `Resume is not available for this run${o.resume && o.resume.why ? ` (${o.resume.why})` : ''}. ${CHANGE}`);
 
   if (death.died) {
     return {
@@ -497,13 +507,20 @@ function endedBase(summary, death, o) {
 
   if (outcome === 'green' || outcome === 'already-green' || outcome === 'satisfied') {
     if (o.destinationRefused) {
+      // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); the rest take Edit in chat
+      // (withEditAction adds it) and are told to change the job, not to reuse it
+      const earned = outcome === 'green';
       return {
         reason: 'Goal met, but the output could not be delivered.',
-        next: 'Fix the destination, then Reuse workflow.',
+        next: earned ? 'Fix the destination, then Reuse workflow.' : CHANGE,
         line: `${GOAL_MET_LINE} — not delivered`,
-        actions: REUSE,
+        actions: earned ? REUSE : [],
       };
     }
+    // hamr 2026-10-08: already-green (the check passed before any work) is not a reusable job — only a run that
+    // earned its green offers Reuse workflow; the rest take Edit in chat (withEditAction adds it). `satisfied` is a
+    // close VERDICT, never a run outcome (ralph and the job-end emitters write `green`), so it rides with already-green.
+    if (outcome !== 'green') return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
     return { reason: 'Goal met.', next: 'Nothing to do.', line: GOAL_MET_LINE, actions: REUSE };
   }
   if (outcome === 'cap-halt') {
@@ -545,7 +562,7 @@ function endedBase(summary, death, o) {
   if (outcome === 'step-stalled') {
     return {
       reason: 'A step stopped making progress.',
-      next: resumeOr('Resume, or change the job: Clear the card and draft a new one.'),
+      next: resumeOr('Resume, or change the job: press Edit in chat.'),
       line: resumeOk ? 'step stalled — resume' : 'step stalled',
       actions: resumeOk ? RESUME : [],
     };
@@ -2408,7 +2425,7 @@ export function reuseLine(record) {
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: string }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
- * @returns {{ok: true, origin: {runid: string, job: string}, card: Record<string, any>, from: 'signed job',
+ * @returns {{ok: true, origin: {runid: string, job: string}, outcome: string|null, card: Record<string, any>, from: 'signed job',
  *   locked: readonly string[], open: readonly string[], note: string|null,
  *   specHash: string, workflowKey: string, spec: any, specPath: string,
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -2447,6 +2464,8 @@ export function getStartFrom(runid, opts = {}) {
   return {
     ok: true,
     origin: { runid, job: row.job },
+    // the run's terminal outcome — the Reuse start (POST /api/author/start) refuses anything but a real green
+    outcome: legsOf(records).at(-1)?.outcome ?? null,
     card,
     from: 'signed job',
     locked: REUSE_LOCKED_FIELDS,
@@ -2480,8 +2499,9 @@ export function listReuseJobs(opts = {}) {
     let records;
     try { records = parseJsonl(row.spine).records; } catch { continue; }
     const outcome = legsOf(records).at(-1)?.outcome ?? null;
-    // the same endings the Run tab's own Reuse button is offered on (`endedBase`)
-    if (outcome !== 'green' && outcome !== 'already-green' && outcome !== 'satisfied') continue;
+    // only a REAL green (hamr 2026-10-08): `already-green` means the check passed before any work, so there is nothing to reuse
+    // (src/reuse.js 'green-predates-run'). Narrower than the Run tab's Reuse button on purpose.
+    if (outcome !== 'green') continue;
     const signed = signedSpecForRun(row, records);
     if (!signed) continue;
     const key = workflowKey(signed.spec);

package/src/panel/status.js

@@ -2,7 +2,7 @@
 // hamr's ruling 2026-10-04 (option A): every surface (run cards, expanded run rows, the right-side header, imported
 // rows) reads `status` from the server; the page never maps an outcome to a word itself.
 //
-//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [✗] stopped · [?] died
+//   [▶] running · [·] waiting · [✓] passed · [✗] failed · [✗] capped · [■] stopped · [?] died
 //
 // Outcome -> word (every outcome the panel knows; anything not listed is `failed`):
 //   green, already-green, satisfied                      -> passed
@@ -15,6 +15,8 @@
 //   and every other outcome (refusals, instrument stops)  -> failed
 // `waiting` is the step-level sign for a step that has not started; no run outcome maps to it.
 
+import { capKindOf } from '../legs.js';
+
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE = 'goal met';
 
@@ -27,7 +29,7 @@ export const STATUS = Object.freeze({
   passed: Object.freeze({ sign: '✓', word: 'passed' }),
   failed: Object.freeze({ sign: '✗', word: 'failed' }),
   capped: Object.freeze({ sign: '✗', word: 'capped' }),
-  stopped: Object.freeze({ sign: '✗', word: 'stopped' }),
+  stopped: Object.freeze({ sign: '■', word: 'stopped' }),
   died: Object.freeze({ sign: '?', word: 'died' }),
 });
 
@@ -44,9 +46,8 @@ export function statusFor(o) {
   if (o.died) key = 'died';
   else if (out === null || out === undefined) key = 'running';
   else if (out === 'green' || out === 'already-green' || out === 'satisfied') key = 'passed';
-  else if (out === 'cap-halt' || out === 'wall-halt') key = 'capped';
+  else if (capKindOf(o) !== null) key = 'capped';
   else if (out === 'stopped') key = 'stopped';
-  else if (out === 'escalated' && ((o.category === 'cap-halt' && o.moneyHalt) || o.category === 'wall-halt')) key = 'capped';
   return { key, ...STATUS[key] };
 }
 

package/src/planrun.js

@@ -36,6 +36,7 @@ import { createLadder, STRIKE_LIMIT } from './ladder.js';
 import { createTrend, FIX_STRIKE_LIMIT } from './trend.js';
 import { TOOL_MENU, STORE_VERBS, checkMenu } from './job.js';
 import { TOOL_BY_VERB, CTX_TOOLS, createCtxTools, toolAction, PERSONA_TOOLS, strategyFor } from './tools.js';
+import { anySuppressionWarning } from './authoring.js';
 import { createReadShim, readShimArm, readShimStrategy } from './readshim.js';
 import { globToPrefix, redactSecrets, SECRET_PATTERNS } from './validate.js';
 import { validateBridge, loadGate, newestEligibleVersion, reuseEligibility, quarantinesCredit, QUARANTINED_CODE } from './bridges.js';
@@ -2035,7 +2036,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     }
     const listed = await seedListing(workdir, s.seedRef);
     const v = listed.stop === null
-      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType })
+      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType, writeScope: job.writeScope })
       : { ok: false, grounded: false, reds: [{ code: 'listing-unreadable', path: 'closeDecl', detail: listed.stop }] };
     emit('close-decl', {
       genre: job.closeDecl.genre,
@@ -2546,7 +2547,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     const readLines = grantedNames.has(TOOL_BY_VERB.read)
       ? (native && !shimArm.cap ? NATIVE_READ_STRATEGY : '') + readShimStrategy(shimArm)
       : '';
-    const system = PERSONA_TOOLS + strategyFor(granted) + readLines;
+    const system = PERSONA_TOOLS + strategyFor(granted) + readLines + anySuppressionWarning(closeStagesOf(job));
     /** @param {any} u @returns {{inputTokens: number, outputTokens: number, cacheReadTokens: number, cacheCreationTokens: number}} */
     const usageOf = (u) => ({ inputTokens: u?.inputTokens ?? 0, outputTokens: u?.outputTokens ?? 0, cacheReadTokens: u?.cacheReadTokens ?? 0, cacheCreationTokens: u?.cacheCreationTokens ?? 0 });
 
@@ -4108,7 +4109,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       // is not passed — it survives only inside the governor, as the bound for the
       // case the trend instrument is blind.
       middle, judge: async () => judgeClose(), ladder: fixGovernor, emit: emitL, redact: scrub,
-      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir,
+      closeTimeoutMs, cwd: workdir, workerWrites: w.workerWrites, closeDir, phase: 'fix',
     });
   } catch (e) {
     planExecuted();

package/src/providers.js

@@ -115,6 +115,33 @@ const OPENAI_MODEL_OPTIONS = Object.freeze({
   'deepseek-flash': Object.freeze({ legacyMaxTokens: true }),
 });
 
+/**
+ * Per-MODEL JUDGE-ONLY request options (F192, hamr ruling A 2026-10-09). deepseek-flash
+ * thinks by default and bills the reasoning as output: run mv117wde's rubric judge locate
+ * truncated at JUDGE_MAX_TOKENS=4000 four times, and a probe measured 1835 of 2409
+ * completion tokens as reasoning. The judge extracts quotes and decides nothing, so it
+ * runs with thinking off. These are PER-CALL options (bare-agent >=0.49 forwards
+ * `thinking` verbatim to `body.thinking`), never constructor options: the judge may be
+ * the very same provider instance as the worker (`buildRunnerProviders` reuses it), and
+ * the worker is deliberately left as it was. A model with no entry gets nothing; the
+ * field is never sent to a model not listed here (OpenAI/Anthropic would reject or
+ * misread it). Read through `judgeCallOptions` only — one owner.
+ */
+const OPENAI_JUDGE_CALL_OPTIONS = Object.freeze({
+  'deepseek-flash': Object.freeze({ thinking: Object.freeze({ type: 'disabled' }) }),
+});
+
+/**
+ * The per-call options the rubric JUDGE's model calls carry for this provider
+ * instance, from the allow-list above. Empty for any provider/model not listed.
+ * @param {any} provider a constructed bare-agent provider
+ * @returns {Record<string, any>}
+ */
+export function judgeCallOptions(provider) {
+  if (!(provider instanceof OpenAIProvider)) return {};
+  return OPENAI_JUDGE_CALL_OPTIONS[/** @type {keyof typeof OPENAI_JUDGE_CALL_OPTIONS} */ (provider.model)] ?? {};
+}
+
 /**
  * @typedef {object} ProviderTableEntry
  * @property {new (options: any) => any} ctor the bare-agent provider class

package/src/ralph.js

@@ -562,9 +562,13 @@ export const CLOSE_FAULTS = Object.freeze({
  *   (PRD item 27/M3 Part B), forwarded to the raw `close` path's `runClose`
  *   call unchanged; a caller supplying `judge` instead already closed over
  *   its own `closeDir` and this param does nothing for it.
+ * @param {string} [opts.phase] the phase this loop runs in, when it is not the step loop
+ *   (the fix loop passes `'fix'`): the person's-stop text then names it ("during the fix
+ *   phase") instead of saying a resume re-enters "this step", which only the step loop has.
+ *   Text only — it changes no category, outcome or option.
  * @returns {Promise<'green'|'escalated'>}
  */
-export async function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir }) {
+export async function ralph({ middle, close, judge, capRuns, ladder, emit, redact, closeTimeoutMs, cwd, expect, judged, gapKeep, workerWrites, closeDir, phase }) {
   // PARAM GUARD (the BA-4 class — a caller's malformed argument, which is the one
   // thing this shell throws for; a WORKER's bad reach comes back as a refusal
   // RESULT instead, and that rule is about feedback, not about the API contract).
@@ -654,7 +658,9 @@ export async function ralph({ middle, close, judge, capRuns, ladder, emit, redac
             'revise the goal/spec so the work fits the time (same re-approval)',
             'abandon the task']],
         // P5 item 5 — the PERSON asked to stop at a round boundary: nothing failed, nothing is discarded.
-        'stopped': ['You stopped the run. Nothing is discarded: the work on disk stands, and a resume re-enters this step.',
+        'stopped': [phase
+          ? `You stopped the run during the ${phase} phase. Nothing is discarded: the work on disk stands, and a resume continues the run.`
+          : 'You stopped the run. Nothing is discarded: the work on disk stands, and a resume re-enters this step.',
           ['resume (the same run continues)', 'abandon the task']],
         // F66 — the STALL WATCHDOG gave up: no round completed for the stall window,
         // three times over, and reissuing the call did not recover it. It borrows both

package/src/replay.js

@@ -104,7 +104,7 @@
 import { runBehaviour, formatBehaviour } from './behaviour.js';
 import { shortSha } from './codeversion.js';
 import { SPEND_RECORD_TYPES, chainSpend } from './ledger.js';
-import { legsOf } from './legs.js';
+import { legsOf, capKindOf } from './legs.js';
 
 /**
  * @param {unknown} e
@@ -234,6 +234,16 @@ const ALL_REASON_MAX = 60;
  * record fired) — printed literally, never blank, never a fabricated 0. */
 const NONE_RECORDED = 'none recorded';
 
+/**
+ * Did this leg end on a cap? Reads the leg's own last escalation and `money-halt` record.
+ * @param {import('./legs.js').Leg} leg
+ * @returns {'money'|'time'|null}
+ */
+function legCapKind(leg) {
+  const esc = leg.outcome === 'escalated' ? leg.records.findLast((r) => r && r.type === 'escalation') : null;
+  return capKindOf({ outcome: leg.outcome, category: esc?.category ?? null, moneyHalt: leg.records.some((r) => r && r.type === 'money-halt') });
+}
+
 /**
  * `stopReason` for a non-green outcome: `category — decision — detail`, every
  * part present that the escalation actually carries (see the field-site
@@ -737,11 +747,21 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     // why this leg stopped the step (code-owned words); null for a step that ended itself or is still running
     /** @type {string|null} */
     let stopReason = null;
+    // a single-leg run has no leg boundary to cut a step, but a cap still ends it: its open step reads capped too
+    // (hamr 2026-10-08), from the same rule (`capKindOf`) the run's own status word uses
+    if (!end && myLeg === null) {
+      const only = legs[0];
+      const capKind = only ? legCapKind(only) : null;
+      if (capKind !== null) stopReason = capKind === 'money' ? 'money cap' : 'time cap';
+    }
     if (!end && myLeg !== null) {
       const o = myLeg.outcome;
       const isLastLeg = myLegIdx === legs.length - 1;
       if (cutByLeg || (isLastLeg && o !== null && o !== 'green' && o !== 'already-green')) {
-        stopReason = o === 'cap-halt' ? 'money cap' : o === 'wall-halt' ? 'time cap' : o === 'provider-red' ? 'provider failed'
+        // hamr 2026-10-08: a leg that ended `escalated` on a money-halt / wall-halt reads as the cap, exactly as the
+        // run's own status word does (src/panel/status.js statusFor) — derived HERE so every surface follows
+        const capKind = legCapKind(myLeg);
+        stopReason = capKind === 'money' ? 'money cap' : capKind === 'time' ? 'time cap' : o === 'provider-red' ? 'provider failed'
           : o === 'step-stalled' ? 'step stalled' : o === 'stopped' ? 'you stopped it' : o === null ? 'died' : o;
       }
     }
@@ -832,7 +852,7 @@ export function replayRun(spineEvents, auditEvents = [], { runId = null, auditAv
     return {
       id,
       occurrence: idOccurrence.get(id),
-      ...(myLeg === null ? {} : { stopReason, continued, tryNumber }),
+      ...(myLeg === null && stopReason === null ? {} : { stopReason, continued, tryNumber }),
       outcome: end ? (end.outcome ?? null) : null,
       ...buildOccurrenceMetrics(startSeq, startTs, endSeq, endTs, roundsInWindow),
       checks: { passed, failed },

package/src/trend.js

@@ -272,6 +272,7 @@ export function createTrend({ stageOrder = [], limit = FIX_STRIKE_LIMIT, blindCa
      * @param {{gap?: string, stage?: string|null, value?: number|null}} o either a
      *   raw gap (parsed here) or an already-read `{stage, value}` — never both
      *   spellings of the same reading in one call.
+     *   (A judged stage's value is its distinct red COUNT, supplied by the caller.)
      * @returns {{iteration: number, stage: string, value: number|null, improved: boolean,
      *   comparable: boolean, noProgress: number, limit: number, stageIndex: number}}
      */

package/types/authoring.d.ts

@@ -80,6 +80,14 @@ export function envCapableKind(kind: string, catalogue?: Record<string, KindSpec
  * @param {string} cmd @returns {string|null}
  */
 export function deniedCommandReason(cmd: string): string | null;
+/**
+ * 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: any[] | null | undefined): string;
 /**
  * The picked class's mandatory guards, FULLY ENUMERATED (D13 forward-compat
  * point 3: an omittable-with-a-default field is the omitted-`tools` shape, where
@@ -219,6 +227,16 @@ export function ungroundedGenreEnv(lang: string, recorded: Record<string, string
     element: string;
     resolved: string;
 }[];
+/**
+ * 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: unknown, writeScope: string[] | null | undefined): string[];
 /**
  * Validate an authored close DECLARATION. Never throws on model output — every
  * failure is a named red, in the shipped `{ok, reds, <parsed>}` shape, and the
@@ -256,7 +274,9 @@ export function ungroundedGenreEnv(lang: string, recorded: Record<string, string
  * @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`).
@@ -283,6 +303,7 @@ export function validateDeclaration(declaration: any, opts?: {
     envInjected?: Record<string, string> | null;
     deferListing?: boolean;
     verdictType?: string | null;
+    writeScope?: string[] | null;
 }): {
     ok: boolean;
     reds: Red[];
@@ -455,6 +476,8 @@ export const DENIED_COMMANDS: readonly string[];
  */
 export const TYPES_GENRE_TEMPLATE: "1. The STRICT form of the language's type checker is used only when a confirmed check \u2014 or,\n   absent a confirm turn, the goal and interview answers \u2014 asks for strict typing; otherwise the\n   checker runs at whatever strictness the repo's own scripts already use.\n2. Tools are invoked so their binaries actually resolve \u2014 through the project's own package\n   runner or language module runner, never a bare binary name.\n3. The WORK stages \u2014 typecheck (error count IN the target scope, baseline 0, lower-is-better),\n   typecheck-outside (error count OUTSIDE the target scope, baseline measured at seed, a\n   ceiling \u2014 required whenever a typecheck stage is scoped to a subset of the tree), tests-kept\n   (a floor on tests that actually EXECUTED, baseline at seed, higher-is-better; a skipped or\n   deselected test did not run and must not count), and suite-green (the suite exits clean AND\n   reports zero failing tests \u2014 two assertions) \u2014 are composed ONLY for the checks a confirmed\n   plan asked for (or, absent a confirm turn, the goal and interview answers). The GUARDS \u2014\n   changed-from-seed and no-suppressions \u2014 are composed always, first-red-wins:\n   changed-from-seed before every WORK stage, no-suppressions last.\n4. One population per stage \u2014 two structurally different counts never share a stage.\n5. The checker must judge the PATIENT's own tree: if imports could resolve to an installed or\n   editable copy elsewhere, the environment is set so they resolve inside the patient.\n6. A number the tool did not report is unknown, never zero.";
 export const GENRE_LANGUAGES: readonly string[];
+/** The worker-facing line that rides with the js `any` guard (run mv13ery3). */
+export const ANY_SUPPRESSION_WARNING: string;
 /**
  * THE GENRE, as data. The suppression batteries are the hand-written closes'
  * own `SUPPRESSIONS` tables (`scripts/u-pulselog-close.mjs:35`,

package/types/authorjob.d.ts

@@ -185,6 +185,14 @@ export function assembleSpec(specDraft: any, { closeDecl, verdictType }: {
     closeDecl: any;
     verdictType: string;
 }): any;
+/**
+ * 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: any[], calibration: any): boolean;
 /**
  * D9, in code: *nothing JUDGES the close; three mechanical gates plus a
  * signature.* No LLM validates another LLM's close, here or anywhere.
@@ -206,16 +214,15 @@ export function assembleSpec(specDraft: any, { closeDecl, verdictType }: {
  *      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

package/types/authorreadout.d.ts

@@ -87,6 +87,20 @@ export function answeredQuestionLines(confirmed: {
  * @returns {string[]}
  */
 export function calibrationLines(calibration: any): string[];
+/**
+ * The calibration gate's real result as one line a person reads next to the step (hamr, 2026-10-09: the panel
+ * showed `calibrating ✓` over a gate that graded 8 of 10 and let 2 attack styles leak). PASS IS THE GATE'S OWN:
+ * `ok` is `calibration.ok` as `runCalibration` decided it (every case right as a SET of reds, every style
+ * resisted), never recomputed here, so there is no second spelling of the floor. The counts are read from the
+ * record (`graded[].ok` is `compareExpectation`, which compares reds as sets); the denominators are the live
+ * constants (CALIBRATION_SIZE, the battery length), so a gate that stopped part-way reads "x of 10", not "x of x".
+ * @param {any} calibration `signing.gates.calibration`
+ * @returns {{ok: boolean, note: string}|null} null when the gate was not reached
+ */
+export function calibrationSummary(calibration: any): {
+    ok: boolean;
+    note: string;
+} | null;
 /**
  * THE AUTHORING CEILING, parsed from `--budget`. Housed here for the same reason
  * the readout above is: the runner is a script, and a rule no test can reach is a
@@ -169,4 +183,96 @@ export function crashRecord(err: unknown): {
     code: string | null;
     raw: ReturnType<typeof scrubRaw>;
 };
+/**
+ * Every plain kind the table can emit — the list the test enumerates against.
+ * @returns {string[]}
+ */
+export function plainKinds(): string[];
+/**
+ * Map the technical reds of a refused proposal to plain sentences, one per red.
+ * An unknown code is NEVER dropped: it becomes a generic sentence that still
+ * quotes the code and path, under the kind `unmapped`.
+ * @param {PlainRed[]} reds
+ * @param {{cases?: any}} [o] the proposed cases, to name a case by its own id
+ * @returns {PlainReason[]}
+ */
+export function plainReasons(reds: PlainRed[], { cases }?: {
+    cases?: any;
+}): PlainReason[];
+/**
+ * THE MESSAGE a person reads when the rubric proposal was refused. Both doors
+ * (the panel's failed step and the CLI) print exactly this.
+ * @param {{stop: string, reds: PlainRed[], cases?: any, spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null,
+ *   source?: 'proposal'|'signer'}} o
+ * @returns {string}
+ */
+export function proposalStopText({ stop, reds, cases, spend, source }: {
+    stop: string;
+    reds: PlainRed[];
+    cases?: any;
+    spend?: {
+        knownUsd?: number | null;
+        spendComplete?: boolean | null;
+    } | null;
+    source?: "proposal" | "signer";
+}): string;
+/**
+ * Plain sentences for the reds of a refused signing, one or more per red. Card and practice-case reds reuse the
+ * proposal table; an unknown code is a generic sentence that quotes the code.
+ * @param {PlainRed[]} reds @param {{cases?: any}} [o]
+ * @returns {{kind: string, sentence: string, todo: string, red: PlainRed}[]}
+ */
+export function signingReasons(reds: PlainRed[], { cases }?: {
+    cases?: any;
+}): {
+    kind: string;
+    sentence: string;
+    todo: string;
+    red: PlainRed;
+}[];
+/** every plain kind `signingReasons` can emit besides the proposal table's — what the test enumerates
+ * @returns {string[]} */
+export function signingKinds(): string[];
+/**
+ * THE MESSAGE a person reads when the signing gates refuse. The panel's failed step and the CLI print exactly this.
+ * @param {{reds: PlainRed[], refusal?: {detail?: string}|null, cases?: any,
+ *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null}} o
+ * @returns {string}
+ */
+export function signingStopText({ reds, refusal, cases, spend }: {
+    reds: PlainRed[];
+    refusal?: {
+        detail?: string;
+    } | null;
+    cases?: any;
+    spend?: {
+        knownUsd?: number | null;
+        spendComplete?: boolean | null;
+    } | null;
+}): string;
+/**
+ * The reds as the drafting log keeps them: every structured field, the plain
+ * sentence beside it, every string secret-scrubbed and bounded, the list capped.
+ * @param {PlainRed[]} reds @param {{cases?: any, signing?: boolean}} [o] `signing`: the reds are the signing gates', worded by signingReasons
+ * @returns {Record<string, any>[]}
+ */
+export function redsRecord(reds: PlainRed[], { cases, signing }?: {
+    cases?: any;
+    signing?: boolean;
+}): Record<string, any>[];
+/** the stops this module explains in plain words */
+export const PLAIN_PROPOSAL_STOPS: readonly string[];
+/** codes the declaration gates (validateJob, validateCloseDecl) raise: one plain sentence covers the family */
+export const DECLARATION_CODES: readonly string[];
+export type PlainRed = {
+    code: string;
+    path: string;
+    detail: string;
+    [k: string]: any;
+};
+export type PlainReason = {
+    kind: string;
+    sentence: string;
+    red: PlainRed;
+};
 import { scrubRaw } from './text.js';

package/types/calibrate.d.ts

@@ -90,7 +90,7 @@ export function factsResist(facts: any, gold: any, artifactText: string): {
  *   onCost?: (c: any) => void, attempts?: number, battery?: any[], batteryCard?: any,
  *   capStop?: () => 'cap-halt'|'pricing-red'|null}} o
  * @returns {Promise<{ok: boolean, stop: string|null, casualty: any,
- *   graded: {id: string, ok: boolean, got: any, want: any, detail: string|null}[],
+ *   graded: {id: string, ok: boolean, got: any, want: any, detail: string|null, diag: any}[],
  *   injection: {styles: any[], allResisted: boolean, leaks: string[]},
  *   failures: string[], reds: Red[], judgeModel: string,
  *   cardHash: string|null, casesHash: string|null, setHash: string|null,
@@ -116,6 +116,7 @@ export function runCalibration({ cases, card, judgeLoop, judgeModel, onCost, att
         got: any;
         want: any;
         detail: string | null;
+        diag: any;
     }[];
     injection: {
         styles: any[];
@@ -190,6 +191,8 @@ ${string}`;
         }>[];
     }>;
 }>[];
+/** the per-string cap on anything the diagnostic keeps (bytes, scrubbed) */
+export const DIAG_STRING_CAP: 400;
 export type Red = {
     code: string;
     path: string;

package/types/declaredclose.d.ts

@@ -53,7 +53,7 @@ export function declaredStages(closeDecl: any): any[] | null;
  *
  * @param {any} closeDecl
  * @param {{at?: string, listing?: string[]|null, deferListing?: boolean,
- *   catalogue?: Record<string, any>, verdictType?: string|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null}} [opts]
  * @returns {{ok: boolean, reds: Red[], closeDecl: any, grounded: boolean,
  *   scoped: {scoped: boolean, via: string|null},
  *   ceiling: {class: string, kind: string, stage: string|null, locked: boolean}|null}}
@@ -64,6 +64,7 @@ export function validateCloseDecl(closeDecl: any, opts?: {
     deferListing?: boolean;
     catalogue?: Record<string, any>;
     verdictType?: string | null;
+    writeScope?: string[] | null;
 }): {
     ok: boolean;
     reds: Red[];

package/types/judged.d.ts

@@ -97,6 +97,15 @@ export function resolveJobJudge(source: {
     provider: string;
     model: string;
 };
+/**
+ * THE ONE ACCEPTANCE for "this quote points at the JSDoc block of this declaration":
+ * every non-empty line of `docQuote` is a line inside the block directly above the
+ * declaration. `has-doc`'s check and the calibration gate's injection facts check
+ * both call this, so the two can never disagree about what a good pointer is (F192).
+ * @param {string} text the artifact @param {string|null} declQuote @param {string} docQuote
+ * @returns {boolean}
+ */
+export function docQuoteInBlock(text: string, declQuote: string | null, docQuote: string): boolean;
 /**
  * The rubric card: Q6's answer compiled into enumerated items, signed by the
  * person and enumerated in the spec hash. `rule` selects from `JUDGE_RULES`;
@@ -359,15 +368,25 @@ export const LOCATE_AXES: Readonly<{
     PROVIDER: "provider-red";
     ARTIFACT: "artifact-red";
 }>;
+/**
+ * Function words ONLY: articles, prepositions, conjunctions. No judgement words
+ * ("returns", "gets", "function"): a description that adds one of those has added
+ * something, and deciding whether it is MEANINGFUL is exactly what this rule
+ * refuses to do.
+ */
+export const SAYS_WHAT_STOPWORDS: readonly string[];
 /**
  * THE OWNED RULE TABLE. Frozen: the rulebook is the arbiter's, and a caller that
  * could add a rule at runtime would be authoring the arbiter.
- * @type {Readonly<Record<string, {id: string, ask: string, check: (fn: any, lines: Set<string>|null) => RuleRed[]}>>}
+ * `means` is the rule's plain-words reach: what it CAN check, and what it cannot. The case-proposal
+ * prompt renders it, so a proposed case never expects a red the rule cannot raise.
+ * @type {Readonly<Record<string, {id: string, means: string, ask: string, check: (fn: any, text: string|null) => RuleRed[]}>>}
  */
 export const JUDGE_RULES: Readonly<Record<string, {
     id: string;
+    means: string;
     ask: string;
-    check: (fn: any, lines: Set<string> | null) => RuleRed[];
+    check: (fn: any, text: string | null) => RuleRed[];
 }>>;
 /** the enumerated set a card may name — handed over verbatim in every refusal */
 export const JUDGE_RULE_IDS: readonly string[];