bareloop 0.38.0 → 0.40.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,12 @@ 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, 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`).
@@ -283,6 +306,10 @@ export function validateDeclaration(declaration: any, opts?: {
     envInjected?: Record<string, string> | null;
     deferListing?: boolean;
     verdictType?: string | null;
+    writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): {
     ok: boolean;
     reds: Red[];
@@ -455,6 +482,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

@@ -79,26 +79,38 @@ export function refuseLockedKind(kind: string): Refusal;
  * 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,
  *   closeDecl: any, seedRef: string|null, authoring: any, judged: any, reds: Red[],
  *   stop: string|null, cost: any, interview: any, confirmed: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, rates, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, jobLines, inputs, generate, provider, seedRef, scout, listing, ceilingUsd, rates, draftThinking, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, answerQuestions, }: {
     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;
@@ -112,11 +124,13 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         in: number;
         out: number;
     } | null;
+    draftThinking?: "on" | "off";
     onPhase?: (phase: string, data?: any) => void;
     onCall?: (call: {
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
     seedFn?: Function;
     scoutFn?: Function;
@@ -131,6 +145,24 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         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?: {
@@ -185,6 +217,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 +246,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

@@ -12,7 +12,7 @@ export function declarationLines({ goal, closeDecl }: {
  * F176'S FALLBACK, SAID OUT LOUD — the revise ladder kept the NEWEST SOUND
  * declaration rather than the last one it happened to try, because "kept the
  * last accepted revision" is not the same claim as "kept the best revision"
- * (docs/logs/FINDINGS.md F176). Absent on every run where the fallback never
+ * (docs/wiki/FINDINGS.md F176). Absent on every run where the fallback never
  * fired (the overwhelming majority), which is why this returns an EMPTY list
  * rather than a "no fallback" line — a green close has nothing to say here and
  * printing it every run would be noise, not information.
@@ -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,112 @@ 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;
+/**
+ * @param {{stop: string, reds?: PlainRed[]|null, refusal?: {detail?: string}|null,
+ *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null}} o
+ * @returns {string}
+ */
+export function draftStopText({ stop, reds, refusal, spend }: {
+    stop: string;
+    reds?: PlainRed[] | null;
+    refusal?: {
+        detail?: string;
+    } | null;
+    spend?: {
+        knownUsd?: number | null;
+        spendComplete?: boolean | null;
+    } | null;
+}): 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/authorscout.d.ts

@@ -92,15 +92,15 @@ export function defaultSurveyor({ workdir, granted, auditPath, ctx }: {
  * @param {{workdir: string, provider?: any,
  *   rounds?: number, minBytes?: number, blobMax?: number, maxTokens?: number, ctx?: boolean,
  *   attempts?: number, ceilingUsd?: number|null, callTimeoutMs?: number,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
- *   rates?: {in: number, out: number}|null,
+ *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
  * @returns {Promise<Survey & {raw: string, raws: ReturnType<typeof scrubRaw>[],
  *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
  *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
  */
-export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, createSurveyor, }: {
+export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, createSurveyor, }: {
     workdir: string;
     provider?: any;
     rounds?: number;
@@ -115,6 +115,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
     createLoop?: (o: {
         system: string;
@@ -130,6 +131,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         in: number;
         out: number;
     } | null;
+    callOptions?: Record<string, any>;
     createSurveyor?: (o: {
         workdir: string;
         granted: readonly string[];

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, jobLines?: {n: number}[]|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,10 @@ export function validateCloseDecl(closeDecl: any, opts?: {
     deferListing?: boolean;
     catalogue?: Record<string, any>;
     verdictType?: string | null;
+    writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): {
     ok: boolean;
     reds: Red[];

package/types/draftspend.d.ts

@@ -2,7 +2,10 @@
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `call`        {no, step, label, model, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
+ *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
+ *    call's run (true | false | null), present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  * @typedef {{kind: string, no: number, at: string, [k: string]: any}} DraftEvent
  */
@@ -105,7 +108,10 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `call`        {no, step, label, model, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
+ *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
+ *    call's run (true | false | null), present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  */
 export type DraftEvent = {

package/types/job.d.ts

@@ -272,7 +272,7 @@ export const PROVIDERS: readonly string[];
 export const CONDITION_KEYS: readonly string[];
 /**
  * The fields a "Reuse workflow" run may change: where the work lands (the write fence, `writeScope`, and a
- * `destination`/`source` where a spec ever carries them) and the two ceilings. Everything else in a signed spec is
+ * `destination`/`source` where a spec ever carries them), the `inputs` the person pointed at (P7: Inputs is open on a reuse) and the two ceilings. Everything else in a signed spec is
  * the WORKFLOW — goal, checks, guardrails, close (the worker model is the third kind, {@link WORKFLOW_KEY_IDENTITY_FIELDS}). ONE list, shared by {@link workflowKey} and by the panel's
  * reuse (so what the key ignores is exactly what the person may edit, never two spellings).
  */

package/types/jobblock.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Parse "The job" box. A plain line is a numbered job line (1, 2, 3...). A line starting `~` has no number and belongs
+ * to the numbered line above; consecutive `~` lines become ONE rule joined with `'; '`. A `~` line starting `PASS:` or
+ * `FAIL:` is also a judge example (kept with its line number); any other `~` line is a guardrail. Empty lines are
+ * ignored. A `~` before line 1 is a red.
+ * @param {unknown} text the box's raw text
+ * @returns {{ok: true, lines: JobLine[]}|{ok: false, error: string}}
+ */
+export function parseJobBlock(text: unknown): {
+    ok: true;
+    lines: JobLine[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse the "Inputs" box: one `label: value` per line, numbered 1, 2, 3 in the order written. Empty lines are ignored.
+ * This only checks the SHAPE — what a value must point at (line 1 an absolute repo, lines 2+ tracked files inside it)
+ * is proven by the panel at $0.
+ * @param {unknown} text
+ * @returns {{ok: true, inputs: JobInput[]}|{ok: false, error: string}}
+ */
+export function parseInputs(text: unknown): {
+    ok: true;
+    inputs: JobInput[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The person's job lines as the drafter reads them (answer 1 of the interview): each numbered line, then its rule
+ * (the `~` lines joined) indented under it. One spelling, so the number the person typed beside a line is the number a
+ * stage's `fromLine` names.
+ * @param {JobLine[]} lines
+ * @returns {string}
+ */
+export function renderJobLines(lines: JobLine[]): string;
+/**
+ * The PASS:/FAIL: examples the person wrote, each kept with its line number (answer 2 of a rubric interview — what the
+ * calibration compile reads). Empty string when there are none.
+ * @param {JobLine[]} lines
+ * @returns {string}
+ */
+export function renderExamples(lines: JobLine[]): string;
+/**
+ * The inputs as the drafter is told about them: "the person pointed at these inputs: N label path".
+ * @param {JobInput[]} inputs
+ * @returns {string}
+ */
+export function renderInputs(inputs: JobInput[]): string;
+/**
+ * The two cross-checks between a parsed job block and the Check type: a RUBRIC job needs at least one `PASS:` and one
+ * `FAIL:` example (the calibration compile reads them); a DETERMINISTIC job has no judge, so an example line would be
+ * silently dropped — a red instead.
+ * @param {JobLine[]} lines
+ * @param {boolean} rubric
+ * @returns {string|null} the plain red, or null when the block fits the Check type
+ */
+export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean): string | null;
+/**
+ * The signed `jobLines` field from parsed lines: the person's own words, `{n, text, rule, rules}` (examples stay inside the
+ * rule text, where the person wrote them). `rules` is the same `~` lines as an array, BESIDE the joined `rule` (never
+ * replacing it); it is omitted on a line with no `~` line, and an older spec lacks it entirely.
+ * @param {JobLine[]} lines
+ * @returns {{n: number, text: string, rule: string, rules?: string[]}[]}
+ */
+export function signedJobLines(lines: JobLine[]): {
+    n: number;
+    text: string;
+    rule: string;
+    rules?: string[];
+}[];
+/** @typedef {{verdict: 'PASS'|'FAIL', text: string}} JobExample a `~ PASS:` / `~ FAIL:` line (rubric only), kept with its job line */
+/** @typedef {{n: number, text: string, rule: string, rules: string[], examples: JobExample[]}} JobLine one numbered job line; `rule` = its `~` lines joined with '; ' ('' when none), `rules` = those same `~` lines one by one (so an example's own '; ' survives) */
+/** @typedef {{n: number, label: string, value: string}} JobInput one numbered `label: value` input line */
+/** the joiner for consecutive `~` lines (fwd's joinGuardrails) */
+export const RULE_JOINER: "; ";
+/**
+ * a `~ PASS:` / `~ FAIL:` line (rubric only), kept with its job line
+ */
+export type JobExample = {
+    verdict: "PASS" | "FAIL";
+    text: string;
+};
+/**
+ * one numbered job line; `rule` = its `~` lines joined with '; ' ('' when none), `rules` = those same `~` lines one by one (so an example's own '; ' survives)
+ */
+export type JobLine = {
+    n: number;
+    text: string;
+    rule: string;
+    rules: string[];
+    examples: JobExample[];
+};
+/**
+ * one numbered `label: value` input line
+ */
+export type JobInput = {
+    n: number;
+    label: string;
+    value: string;
+};

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