bareloop 0.42.0 → 0.44.0

package/src/userrun.js

@@ -54,7 +54,8 @@ import { resolveJudge } from './judged.js';
 // path uses (never a second one) and keeps its patient the way it left it.
 import { readResume, resumeTreeGate, checkpointAgeGate, writeRunGreenRow, CHECKPOINT_OUTCOMES, PAUSE_TTL_MS } from './reuse.js';
 // PRD item 28's provider factory (src/providers.js): the WORKER provider's
-// ctor/envKey/tier-table/param-gating come from here now — one seam instead
+// ctor/param-gating come from here now (its key variable and price come from the
+// Settings row, src/providerrows.js) — one seam instead
 // of an `if (provider === …)` scattered across this script. PRD item 32.2
 // moved the JUDGE onto this SAME factory: it used to be separately pinned
 // below to a hardcoded Anthropic constructor at the judged tier because the
@@ -303,6 +304,7 @@ class ExitSignal extends Error {
  * @property {string} seed
  * @property {string} spineName
  * @property {string} [into] see `RunOpts.into`
+ * @property {boolean} [refreeze] a FRESH `--spec` run: fetch the web inputs again AFTER the run is listed (never on resume/door/decide)
  * @property {string|null} model
  * @property {string|null} providerKey
  * @property {string|null} readShim
@@ -492,7 +494,8 @@ async function execute(ctx) {
   const REGISTRY_TAIL = (ctx.registry ?? null) !== null ? ` --registry ${(ctx.registry ?? null)} --workflow ${(ctx.workflow ?? null) ?? spec.job}` : '';
 
   const WORKDIR = target.workdir;
-  const SEED = target.seed;
+  // `let`: a fresh run's refetch of its web inputs commits a NEW seed (below, after the run is listed)
+  let SEED = target.seed;
   const specHash = jobSpecHash(spec);
   // the re-invocation commands this engine prints: a bundle names its own door and hash,
   // every other caller gets today's byte-identical strings.
@@ -507,10 +510,8 @@ async function execute(ctx) {
   // and tested apart from this script. The JUDGE's model is resolved separately
   // (`resolveJudge`, below the key block): it defaults to this same resolved
   // worker model and a signed `judge` override wins over it.
-  // The provider's OWN tier table (src/providers.js) supplies the default —
-  // not the anthropic-only DEFAULT_TIER_MODELS above (that map is the
-  // `--model` FLAG's vocabulary only, sonnet/haiku, unrelated to which
-  // provider the spec names). `spec.provider` is not validateJob'd until
+  // There is no default model: a spec or flag that names none dies below with
+  // REFUSE_NAME_MODEL (the model is one ticked in Settings). `spec.provider` is not validateJob'd until
   // runJob below, so an unrecognized value dies here with the same operator-
   // facing message resolveWorkerModel's own errors use, rather than an
   // unhandled throw.
@@ -1405,8 +1406,8 @@ async function execute(ctx) {
   // token against. That made "provider-agnostic" half-true: you could run on
   // another provider only if you also held an Anthropic account.
   //
-  // The WORKER's key comes from the provider's own `envKey` (the factory's, so
-  // there is one table saying which provider reads which variable) and is
+  // The WORKER's key comes from its Settings row's own env name (`keyValueOf`, src/providerrows.js,
+  // so there is one place saying which row reads which variable) and is
   // ALWAYS required — the worker always runs.
   //
   // The JUDGE's key is required only when the close actually judges
@@ -1585,6 +1586,24 @@ async function execute(ctx) {
     err(`WARNING: could not add this run to ~/.config/bareloop/runs.jsonl (${e.message}) — the run continues; the panel's list will be missing this row.`);
   }
 
+  // RUN START REFETCH (PART 1c RF22; moved here 2026-10-19, run mvez8s54: the ~18 s barebrowse fetch ran in main() BEFORE this run was
+  // listed, so Sign & run showed nothing for 18 s). The run is listed FIRST (row above, with its pid and cap = the monthly claim), THEN
+  // fetches: the Run tab reads "fetching the page…" while source.json has no refrozenAt at or after the row. A refusal cannot be a
+  // `released` row (that unlists the run and its words); it SETTLES the claim at $0 and keeps the plain reason for the panel.
+  if (ctx.refreeze === true && ctx.into !== undefined) {
+    const fresh = await refreezeUrlInputs({ into: ctx.into, ...(deps.fetchUrl ? { fetchUrl: deps.fetchUrl } : {}) });
+    if (!fresh.ok) {
+      const words = /did not start/.test(fresh.error) ? fresh.error : `${fresh.error}. The run did not start. Nothing spent.`;
+      err(`${SELECTOR}: ${fresh.error}`);
+      if (claimedRow) {
+        try { appendRunEvent({ runid, type: 'settled', by: runid, reason: 'refused before start', words, spentUsd: 0, spendComplete: true, at: new Date().toISOString() }, { home: claimedRow.home }); } catch { /* the exit stands; the dead pid's claim is closed by the next run */ }
+        claimedRow = null; // settled, not released: a released leg-1 row is unlisted, and the person must see why
+      }
+      throw new ExitSignal(2);
+    }
+    if (fresh.refreshed.length > 0 && typeof fresh.seed === 'string' && fresh.seed) SEED = fresh.seed;
+  }
+
   const git = (/** @type {string[]} */ a) => execFileSync('git', ['-C', wd, ...a], { encoding: 'utf8' }).trim();
   if (dead) {
     // A RESUME is the OPPOSITE case from a cold launch: the halted run's edits are work
@@ -2055,7 +2074,7 @@ async function execute(ctx) {
   const legDraftSpentUsd = typeof jobStartRec?.draftSpentUsd === 'number' && jobStartRec.draftSpentUsd > 0 ? jobStartRec.draftSpentUsd : null;
   const legDraftSpendComplete = legDraftSpentUsd === null ? null : jobStartRec.draftSpendComplete !== false;
   const spendCore = je?.spentUsd == null ? 'UNKNOWN' : `${je.spendComplete === false ? '≥' : ''}$${je.spentUsd.toFixed(4)}`;
-  out(`spent     ${moneyWithDraft(spendCore, legDraftSpentUsd, spec.budgetUsd, legDraftSpendComplete)}`);
+  out(`spent     ${moneyWithDraft(spendCore, legDraftSpentUsd, spec.budgetUsd, legDraftSpendComplete, je?.spentUsd ?? null)}`);
   // FOLDED, exactly like the money line above it: on a resume the cap governs both legs
   // together, and a leg-only wall next to a folded spend is two framings on one cap with
   // no label to tell them apart (F83). The leg stays on the line beside it.
@@ -2517,6 +2536,7 @@ export async function main(argv, deps = {}) {
     /** how a "go edit the spec" hint renders — `jobs/<file>` for `--job`, the
      * spec's own path for `--spec` (it has no `jobs/` home to point at). */
     let SPEC_DESC;
+    let refreeze = false;
     let spec;
 
     if (jobArg !== null) {
@@ -2593,24 +2613,16 @@ export async function main(argv, deps = {}) {
           + 'with exactly one source-*/ sibling.');
       }
       const into = candidates[0];
-      let manifestRead = await readSourceManifest(into);
+      const manifestRead = await readSourceManifest(into);
       if (manifestRead.stop !== null) {
         die(`--spec ${specPath}: ${manifestRead.code} — ${manifestRead.stop}`);
       }
       if (!manifestRead.present || !manifestRead.manifest) {
         die(`--spec ${specPath}: ${into} carries no source.json — not a prepared copy this runner can trust`);
       }
-      // PART 1c (RF22): a FRESH run of a rubric job with web inputs fetches each address again and makes that text the run's frozen
-      // input BEFORE the worker starts (the drafting copy was only for the look). A resume / door / decision keeps the copy its
-      // first start froze. A refusal is plain words, $0.
-      if (argFlag('resume') === null && argFlag('door') === null && argFlag('decide') === null) {
-        const fresh = await refreezeUrlInputs({ into, ...(deps.fetchUrl ? { fetchUrl: deps.fetchUrl } : {}) });
-        if (!fresh.ok) die(`--spec ${specPath}: ${fresh.error}`);
-        if (fresh.refreshed.length > 0) {
-          manifestRead = await readSourceManifest(into);
-          if (manifestRead.stop !== null || !manifestRead.manifest) die(`--spec ${specPath}: the run copy's record could not be read after the fresh fetch`);
-        }
-      }
+      // PART 1c (RF22): a FRESH run with web inputs fetches each address again before the worker starts. That happens in execute(),
+      // AFTER the run is listed (`ctx.refreeze`); a resume / door / decision keeps the copy its first start froze.
+      refreeze = argFlag('resume') === null && argFlag('door') === null && argFlag('decide') === null;
       const seed = manifestRead.manifest.seed;
       if (typeof seed !== 'string' || !seed) {
         die(`--spec ${specPath}: ${into}/source.json carries no seed commit — not a prepared copy this runner can trust`);
@@ -2648,6 +2660,7 @@ export async function main(argv, deps = {}) {
       seed: target.seed,
       spineName: target.spine,
       ...(target.into === undefined ? {} : { into: target.into }),
+      ...(refreeze ? { refreeze: true } : {}),
       model: argFlag('model'),
       providerKey: argFlag('provider'),
       readShim: argFlag('read-shim'),

package/types/authorflow.d.ts

@@ -10,12 +10,16 @@ export function linesNamedByReds(reds: Red[], declaration: any, lineNums: number
  * The machine's keep-or-drop of the try-3 questions. Kept only when its line is one the previous try's reds named and its
  * text is non-blank, at most {@link MAX_QUESTIONS}; every drop comes back with its reason, for the draft's log.
  * @param {any} raw @param {number[]} failedLines
- * @returns {{kept: {line: number, question: string}[], dropped: {reason: string, raw: any}[]}}
+ * @returns {{kept: {line: number, question: string, rule?: number, source?: string, ask?: 'reading'|'cant-check', reading?: string}[], dropped: {reason: string, raw: any}[]}}
  */
 export function normalizeQuestions(raw: any, failedLines: number[]): {
     kept: {
         line: number;
         question: string;
+        rule?: number;
+        source?: string;
+        ask?: "reading" | "cant-check";
+        reading?: string;
     }[];
     dropped: {
         reason: string;
@@ -1093,8 +1097,8 @@ export const REVISE_RED_CAP: 20;
 export const AUTHOR_MAX_TOKENS: 32000;
 /** the one slot the model fills on an injected guard */
 export const FILL_MARKER: "<FILL IN>";
-/** P7 item 5 (fwdloop am24/25): the most questions the MACHINE keeps from the try-3 drafter. The drafter is never told this number. */
-export const MAX_QUESTIONS: 2;
+/** P7 item 5 (fwdloop am24/25): the most questions the MACHINE keeps from the try-3 drafter. The drafter is never told this number. PRD v1.107 Part 5b: three (hamr's ruling), shared with the code-forced early asks. */
+export const MAX_QUESTIONS: 3;
 /**
  * The model-visible words of the optional `questions` property — offered ONLY on the last drafting try and only after the
  * two before it both failed validation (a mechanism, never a wish: the schema carries it on that one call and nowhere
@@ -1680,12 +1684,44 @@ export const PARAM_SCHEMAS: Readonly<{
                                 description: string;
                             };
                             unit: {
-                                type: string;
-                                minLength: number;
+                                anyOf: ({
+                                    type: string;
+                                    minLength: number;
+                                    minItems?: undefined;
+                                    maxItems?: undefined;
+                                    uniqueItems?: undefined;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    minItems: number;
+                                    maxItems: number;
+                                    uniqueItems: boolean;
+                                    items: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    minLength?: undefined;
+                                })[];
                                 description: string;
                             };
                             currency: {
-                                enum: string[];
+                                anyOf: ({
+                                    enum: string[];
+                                    type?: undefined;
+                                    minItems?: undefined;
+                                    maxItems?: undefined;
+                                    uniqueItems?: undefined;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    minItems: number;
+                                    maxItems: number;
+                                    uniqueItems: boolean;
+                                    items: {
+                                        enum: string[];
+                                    };
+                                    enum?: undefined;
+                                })[];
                                 description: string;
                             };
                             phrase: {

package/types/authorjob.d.ts

@@ -91,8 +91,8 @@ export function refuseLockedKind(kind: string): Refusal;
  *   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,
+ *   answerQuestions?: ((o: {questions: {line: number, question: string, rule?: number, source?: string, ask?: string, reading?: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
+ *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>, left?: {line: number, rule: number}[]}|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,
@@ -151,6 +151,10 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         questions: {
             line: number;
             question: string;
+            rule?: number;
+            source?: string;
+            ask?: string;
+            reading?: string;
         }[];
         dropped: {
             reason: string;
@@ -164,6 +168,10 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
             rule?: string;
         }[];
         answers: Record<string | number, any>;
+        left?: {
+            line: number;
+            rule: number;
+        }[];
     } | null>) | null;
     confirmGenerate?: Function | null;
     isRepo?: boolean;

package/types/declaredclose.d.ts

@@ -118,6 +118,7 @@ export function guardNames(closeDecl: any, verdictType: string): string[];
  *   judgeLoop?: ((o: {system: string}) => any)|null,
  *   judgeModel?: string|null,
  *   onJudgeCost?: ((c: any) => void)|null,
+ *   onRubricEvidence?: ((e: any) => void)|null,
  *   callBounds?: (() => {timeoutMs?: number, deadlineMs?: number})|null}} [opts]
  * @returns {Promise<any>}
  */
@@ -138,6 +139,7 @@ export function runDeclaredStages(stages: any[], redact?: (s: string) => string,
     }) => any) | null;
     judgeModel?: string | null;
     onJudgeCost?: ((c: any) => void) | null;
+    onRubricEvidence?: ((e: any) => void) | null;
     callBounds?: (() => {
         timeoutMs?: number;
         deadlineMs?: number;
@@ -187,7 +189,7 @@ export const CLOSE_DECL_FIELDS: readonly string[];
 /** what a stored calibration set carries, ENUMERATED: the frozen cases and the judge
  * tier that graded them. Both are inside the spec, so `jobSpecHash` covers both — which
  * is the whole mechanism behind "a judge-model bump forces a full recalibration"
- * (src/judged.js, `JUDGE_MODEL`): the field moves, the hash moves, the signature dies,
+ * (src/judged.js, `resolveJudge`): the field moves, the hash moves, the signature dies,
  * and the re-sign re-runs the gate. Anything else in there is a field nobody reads. */
 export const CALIBRATION_FIELDS: readonly string[];
 /**

package/types/draftspend.d.ts

@@ -3,6 +3,8 @@
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
@@ -58,12 +60,33 @@ export function sessionDirForRow(row: {
     home?: string;
     sessionsRoot?: string;
 }): string | null;
+/**
+ * PRD v1.106 Part 5 Q1: one answered question as the two lines the Audit's drafting table shows under its step. ONE place owns the words.
+ * @param {{question: string, answer: string, source?: string, line?: number, at?: string}} h
+ * @returns {{question: string, answer: string, source: string, line?: number, at?: string, askedText: string, saidText: string}}
+ */
+export function humanRowWords(h: {
+    question: string;
+    answer: string;
+    source?: string;
+    line?: number;
+    at?: string;
+}): {
+    question: string;
+    answer: string;
+    source: string;
+    line?: number;
+    at?: string;
+    askedText: string;
+    saidText: string;
+};
 /**
  * Fold `<dir>/draft-log.jsonl` into one record per drafting step, each with its calls. A line that cannot be parsed is
  * skipped (a torn last line must not hide the rest).
  * @param {string} dir
  * @returns {{no: number, id: string, label: string, status: 'running'|'done'|'failed', startedAt: string, endedAt: string|null, wallMs: number|null,
- *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[]}[]}
+ *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[],
+ *   humans: ReturnType<typeof humanRowWords>[]}[]}
  */
 export function readDraftSteps(dir: string): {
     no: number;
@@ -80,6 +103,7 @@ export function readDraftSteps(dir: string): {
         unpricedRounds: number;
         at: string;
     }[];
+    humans: ReturnType<typeof humanRowWords>[];
 }[];
 /**
  * The DRAFTING PART of a run (hamr 2026-10-06, option A): the first part of the run's views, built from the session's
@@ -109,6 +133,8 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)

package/types/facts.d.ts

@@ -23,6 +23,14 @@ export function factClaims(part: any, results: unknown): {
     quote: string;
     values?: Record<string, string>;
 }[];
+/**
+ * One amount of a money fact in the fact's OWN signed forms, never a hardcoded sign: `symbolFirst` puts the currency sign before the amount
+ * ("$144") when the fact has one, else the unit after it ("144 US dollars"); not `symbolFirst` (a rule's bound) prefers the unit.
+ * @param {any} f a money fact @param {string|number} n @param {boolean} symbolFirst @returns {string}
+ */
+export function moneyAs(f: any, n: string | number, symbolFirst: boolean): string;
+/** @param {any} f a fact with a rule @returns {string} the rule in words, e.g. "at most 450 US dollars" */
+export function ruleWords(f: any): string;
 /**
  * One fact as a plain row, written by code from the signed fields:
  * `fact · price — money, at most 450 US dollars, after "Price", quoted from "Flights"`.
@@ -69,3 +77,10 @@ export const FACT_OPS: readonly string[];
 export const MAX_FACTS: 10;
 /** every field a part of class `fact` may carry (the shared ones are checked by rubricStepShapeReds) */
 export const FACT_PART_FIELDS: readonly string[];
+/** the limits bareguard 0.24 puts on a money fact's lists (ruling #65), enforced here first so the red is ours and plain */
+export const MAX_CURRENCIES: 3;
+export const MAX_UNITS: 10;
+export const MAX_UNIT_CHARS: 100;
+export function asList(v: unknown): string[];
+export function moneyForms(f: any): string[];
+export function boundOk(shape: string, v: unknown): boolean;

package/types/factwords.d.ts

@@ -9,16 +9,35 @@ export function countExact(source: string, words: string): number;
  * @param {string} source @param {string} words @returns {number}
  */
 export function countPhrase(source: string, words: string): number;
+/**
+ * What the page-word map (src/pagemap.js) KEPT and DROPPED for one input: the sets the second proof reads. A look from the old search-and-read
+ * path has no `dropped` list, so it gives null and the label is proved against the code-made list as before.
+ * @param {{facts?: any[], dropped?: (import('./pagerules.js').Dropped & {source?: string})[]}|null|undefined} look @param {string} source
+ * @returns {{labels: Set<string>, units: Set<string>, currencies: Set<string>, words: Set<string>, dropped: Map<string, import('./pagerules.js').Dropped>}|null}
+ */
+export function keptSetOf(look: {
+    facts?: any[];
+    dropped?: (import("./pagerules.js").Dropped & {
+        source?: string;
+    })[];
+} | null | undefined, source: string): {
+    labels: Set<string>;
+    units: Set<string>;
+    currencies: Set<string>;
+    words: Set<string>;
+    dropped: Map<string, import("./pagerules.js").Dropped>;
+} | null;
 /**
  * The reds for ONE fact part against its frozen source text.
- * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan}} o
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan, kept?: ReturnType<typeof keptSetOf>}} o
  * @returns {{code: string, detail: string}[]}
  */
-export function checkFactWords({ part, text, line, scan }: {
+export function checkFactWords({ part, text, line, scan, kept }: {
     part: any;
     text: string;
     line: number | string;
     scan?: import("./labelscan.js").LabelScan;
+    kept?: ReturnType<typeof keptSetOf>;
 }): {
     code: string;
     detail: string;
@@ -27,9 +46,13 @@ export function checkFactWords({ part, text, line, scan }: {
  * The reds for every fact part of a declaration. A fact part whose input text is not at hand is a red: a check whose words were never
  * proved against the source is never signed.
  * @param {any} declaration @param {Record<string, string>|null} texts label -> frozen text
+ * @param {{facts?: any[], dropped?: any[]}|null} [look] the page-word map's report: what it kept and dropped (null = no map, the code-made list is the proof)
  * @returns {{code: string, path: string, detail: string}[]}
  */
-export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null): {
+export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null, look?: {
+    facts?: any[];
+    dropped?: any[];
+} | null): {
     code: string;
     path: string;
     detail: string;

package/types/inputlook.d.ts

@@ -148,6 +148,12 @@ export function lookPrompt({ jobLines, labels, lists }: {
     labels: string[];
     lists: Record<string, string>;
 }): string;
+/**
+ * A fact the page-word map kept (src/pagerules.js `KeptFact`), as the look report carries it: a phrase fact holds its alternative
+ * phrases; any other holds its labels (the first is the primary), and a money fact its units and currencies.
+ * @param {import('./pagerules.js').KeptFact} k @param {string} source @returns {LookFact}
+ */
+export function lookFactOf(k: import("./pagerules.js").KeptFact, source: string): LookFact;
 /**
  * Turn the AI's raw report into a VERIFIED one, by code, at $0. A fact is carried only when: its shape is a real shape, its source is
  * a real input, and its label is ON THE LIST for that input and shape (an id is resolved to its exact words). Anything else is moved
@@ -207,6 +213,9 @@ export const LOOK_REPORT_TOOL: "report_look";
 /** how many hits one search returns at most, and how long a snippet or a read line is */
 export const LOOK_MAX_HITS: 40;
 export { LABEL_SHAPES };
+/**
+ * `words` / `labels` / `unit` / `currency`: what the page-word map kept (idea A core)
+ */
 export type LookFact = {
     line: number;
     name: string;
@@ -220,6 +229,11 @@ export type LookFact = {
     rule?: any;
     aiProposal?: boolean;
     forRule?: number;
+    reading?: import("./pagerules.js").Reading;
+    words?: string[];
+    labels?: string[];
+    unit?: string[];
+    currency?: string[];
 };
 export type LookNotFound = {
     line: number;
@@ -234,5 +248,6 @@ export type LookReport = {
         text?: string;
     }[];
     notFound: LookNotFound[];
+    dropped?: import("./pagerules.js").Dropped[];
 };
 import { LABEL_SHAPES } from './labelscan.js';

package/types/job.d.ts

@@ -99,7 +99,8 @@ export function jobSpecHash(job: object): string;
  * share a workflow key iff they ran the same goal, checks, guardrails and close — whatever source they ran on, wherever they wrote, whatever caps they had.
  * It is NOT a signature: {@link jobSpecHash} (which covers the caps and the fence) stays what the person signs, and
  * a reuse lands on a NEW jobSpecHash with the SAME workflowKey. Same never-throws contract as `jobSpecHash`, and
- * the same resolved-`tools` form, so an omitted-`tools` spec and its spelled-out menu share a key.
+ * the same resolved-`tools` form, so an omitted-`tools` spec and its spelled-out menu share a key. A soft-green spec keys on its
+ * RESOLVED judge identity (an absent `judge` is its worker's), so pinning the default judge never changes the key.
  * @param {object} job
  * @returns {string} sha256 hex
  */
@@ -277,6 +278,12 @@ export const CONDITION_KEYS: readonly string[];
  * reuse (so what the key ignores is exactly what the person may edit, never two spellings).
  */
 export const REUSE_OPEN_SPEC_FIELDS: readonly string[];
+/**
+ * The signed spec's schedule fields: {@link workflowKey} ignores them too, so a scheduled spec keeps the workflow
+ * key of the green run it was scheduled from (else Reuse would refuse every scheduled spec). They stay inside
+ * {@link jobSpecHash}. Kept apart from {@link REUSE_OPEN_SPEC_FIELDS}, which names the Reuse boxes.
+ */
+export const SCHEDULE_SPEC_FIELDS: readonly string[];
 /**
  * The worker-identity fields {@link workflowKey} ALSO ignores (hamr 2026-10-04: Model is open on a reuse; the Name
  * chosen in Settings carries its provider and baseUrl with it). They stay inside {@link jobSpecHash}, so what the person

package/types/kinds.d.ts

@@ -645,6 +645,11 @@ export type Ctx = {
         timeoutMs?: number;
         deadlineMs?: number;
     };
+    onRubricEvidence?: (e: {
+        step: number;
+        evidence: any[];
+        evidenceTotal?: number;
+    }) => void;
     onStage?: (row: {
         stage: string | null;
         kind: string | null;

package/types/pagedropwords.d.ts

@@ -0,0 +1,26 @@
+/** @param {Dropped} d @returns {string} the plain sentence for one drop */
+export function dropSentence(d: Dropped): string;
+/**
+ * One row per fact that lost something: the sentences (one per dropped word, then the fact's own), and whether the whole fact went.
+ * @param {Dropped[]|undefined|null} dropped
+ * @returns {{line: number, rule?: number, fact: string, full: boolean, sentences: string[]}[]}
+ */
+export function dropRows(dropped: Dropped[] | undefined | null): {
+    line: number;
+    rule?: number;
+    fact: string;
+    full: boolean;
+    sentences: string[];
+}[];
+/**
+ * A row as one Not-checked line, in the person's own words: `line N: "<the ~ rule as written, or the fact's name>" — <sentences>`.
+ * @param {{line: number, rule?: number, fact: string, sentences: string[]}} row @param {any[]|null|undefined} jobLines @param {(l: any) => string[]} rulesOf
+ * @returns {string}
+ */
+export function dropLine(row: {
+    line: number;
+    rule?: number;
+    fact: string;
+    sentences: string[];
+}, jobLines: any[] | null | undefined, rulesOf: (l: any) => string[]): string;
+export type Dropped = import("./pagerules.js").Dropped;