bareloop 0.38.0 → 0.39.0

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[];

package/types/panel/authorsession.d.ts

@@ -9,6 +9,20 @@ export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
  * @param {StepLine[]} steps @param {string} id @param {string} [detail] (absent = keep what the line has)
  */
 export function advanceSteps(steps: StepLine[], id: string, detail?: string): void;
+/**
+ * The confirm turn's plan as the chat shows it: ONE owner of the text (hamr, 2026-10-09: the one-blob "Plan: ...
+ * Checks: ... Not checked: ..." was unreadable). Each section is a heading on its own line, its content on the next,
+ * and a blank line between sections. `#NOT CHECKED:` and `#QUESTIONS:` appear only when there is something to say.
+ * The CLI composes its own plan screen (src/authorrun.js) and shares no text with this one.
+ * @param {{goal?: string, checks?: string[], notChecked?: string[], questions?: string[]}} p
+ * @returns {string}
+ */
+export function planText(p: {
+    goal?: string;
+    checks?: string[];
+    notChecked?: string[];
+    questions?: string[];
+}): string;
 /**
  * `true` when `jobs/<name>.json` already exists in the repo's own jobs/ dir
  * (resolved from THIS module's own on-disk location, never `process.cwd()`,
@@ -96,7 +110,7 @@ export function validateJobCard(card: any, opts?: {
 /**
  * ONE session's engine — created already RUNNING (the caller awaits nothing;
  * the pipeline drives itself, reporting through `state`). `state.pendingAsk`
- * is the ONE thing a person answers next; `answer()`/`send()`/`revise()`/
+ * is the ONE thing a person answers next; `answer()`/`send()`/
  * `signPrepare()` are the only ways in.
  * @param {any} card the validated job card (see {@link validateJobCard})
  * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,

package/types/providers.d.ts

@@ -1,3 +1,10 @@
+/**
+ * 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: any): Record<string, any>;
 /**
  * Look up a provider's table entry. Throws a NAMED error on an unrecognized
  * provider — never a silent default (the `resolveRates`-style-substring-

package/types/trend.d.ts

@@ -54,6 +54,7 @@ export function createTrend({ stageOrder, limit, blindCap, seed, directions }?:
      * @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}}
      */