bareloop 0.41.0 → 0.42.0

package/src/source.js

@@ -23,14 +23,16 @@
 // on rather than catch.
 
 import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
 import { existsSync, lstatSync, readFileSync } from 'node:fs';
-import { mkdir, readdir, readFile, writeFile, lstat, stat, chmod, access, copyFile, cp, open, rm, realpath, readlink, symlink, constants as fsConstants } from 'node:fs/promises';
+import { mkdir, mkdtemp, readdir, readFile, writeFile, lstat, stat, chmod, access, copyFile, cp, open, rm, realpath, readlink, symlink, constants as fsConstants } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep, basename, isAbsolute } from 'node:path';
 import { git } from './kinds.js';
 import { addWorktree, hideBareloopDir } from './worktree.js';
 import { MAX_BUFFER } from './kinds.js';
 import { PROVIDER_TIMEOUT_MS } from './clock.js';
 import { scanSecrets, SECRET_PATTERNS, SECRET_PATTERN_NAMES } from './validate.js';
+import { fetchPageText, isWebUrl } from './pagefetch.js';
 
 /** @typedef {{stop: string, code: string}} SourceRefusal a named, non-throwing stop */
 
@@ -1223,3 +1225,166 @@ export async function proveInputFiles(inputs) {
   }
   return { ok: true, repo, root };
 }
+
+/** the per-file ceiling for a rubric input: bareguard's `cited` check searches a quote in a source only up to this size
+ * (its `quoteSourceMaxBytes`); a bigger file could never be cited from, so the door refuses it at $0 */
+export const RUBRIC_INPUT_MAX_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Does this source manifest belong to a rubric job on local files (`proveRubricInputs` wrote it)? One spelling for both
+ * doors (the panel session and the CLI author run): a non-repo source that froze numbered, labelled input files.
+ * @param {Record<string, any>|null|undefined} manifest
+ * @returns {boolean}
+ */
+export function isRubricFilesManifest(manifest) {
+  return !!manifest && manifest.kind !== 'repo' && Array.isArray(manifest.inputs) && manifest.inputs.length > 0;
+}
+
+/**
+ * PART 1a (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-12"): the front door for a RUBRIC job whose inputs are the
+ * person's own LOCAL FILES, not a repo. Each numbered `label: /absolute/file` line is proven at $0 and frozen into the
+ * same hidden-git tree a plain folder gets (`prepareSource`, which also refuses a secret shape, an environment file
+ * and a symlink), under `input/`; the manifest then also records `inputs: [{label, rel, sha256}]` — the bytes the
+ * rubric's `cited` check will search a quote in, hashed once, here. A line that is a web address is fetched ONCE with
+ * barebrowse (PART 1c, read only) and its text frozen under `input/` like a file (the manifest row also records its `url`,
+ * so run start can fetch it again); a `search:` line is a named refusal (a later build); so is a relative path, a missing file, a folder, a file over
+ * {@link RUBRIC_INPUT_MAX_BYTES}, and text that is not valid UTF-8. Every refusal is plain words naming the line and
+ * ends "Nothing spent." — nothing here touches a model.
+ * @param {{inputs: {n: number, label: string, value: string}[], into: string, destination?: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `fetchUrl` - how a web address is read (default barebrowse via `fetchPageText`; a test injects a stub, never the network)
+ * @returns {Promise<{ok: true, prep: {stop: null, into: string, tree: string, manifestPath: string, manifest: Record<string, any>}}|{ok: false, error: string, code: string}>}
+ */
+export async function proveRubricInputs({ inputs, into, destination, fetchUrl = (u) => fetchPageText(u) }) {
+  /** @param {string} code @param {number} n @param {string} msg @returns {{ok: false, error: string, code: string}} */
+  const bad = (code, n, msg) => ({ ok: false, code, error: `line ${n}: ${msg} Nothing spent.` });
+  if (!Array.isArray(inputs) || inputs.length === 0) return { ok: false, code: 'inputs-missing', error: 'Inputs is required. Nothing spent.' };
+  /** @type {Set<string>} */
+  const labels = new Set();
+  /** @type {{label: string, name: string, buf: Buffer, url?: string}[]} */
+  const staged = [];
+  /** @type {Set<string>} */
+  const names = new Set();
+  const utf8 = new TextDecoder('utf-8', { fatal: true });
+  for (const inp of inputs) {
+    const { n, label, value } = inp;
+    if (/^search$/i.test(label) || (/^[a-z][a-z0-9+.-]*:\/\//i.test(value) && !isWebUrl(value))) {
+      return bad('web-input', n, 'a search, or an address that is not http or https, is not an input yet.');
+    }
+    if (labels.has(label.toLowerCase())) return bad('label-repeat', n, `the label "${label}" is already used by an earlier line.`);
+    labels.add(label.toLowerCase());
+    if (isWebUrl(value)) {
+      const got = await fetchUrl(value.trim());
+      if (!got.ok) return bad('input-url-unreadable', n, `${got.error.replace(/[.\s]+$/, '')}.`);
+      const pageBuf = Buffer.from(got.text, 'utf8');
+      const leak = secretPatternNames(got.text);
+      if (leak.length) return bad('input-url-secret', n, `the page at ${got.url} carries a known secret shape (${leak.join(', ')}) - refused, secrets never enter a job.`);
+      const stem = label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'page';
+      const pageName = names.has(`${stem}.txt`) ? `${n}-${stem}.txt` : `${stem}.txt`;
+      names.add(pageName);
+      staged.push({ label, name: pageName, buf: pageBuf, url: got.url });
+      continue;
+    }
+    if (!isAbsolute(value)) return bad('input-not-absolute', n, `${value} must be the full path of a file, like /home/me/notes.md.`);
+    const abs = resolve(value);
+    let ls;
+    try { ls = await lstat(abs); } catch { return bad('input-missing', n, `${abs} does not exist.`); }
+    if (ls.isSymbolicLink()) return bad('input-symlink', n, `${abs} is a symlink — refused, never followed.`);
+    if (!ls.isFile()) return bad('input-not-file', n, `${abs} is not a file — each input line is one file.`);
+    const base = basename(abs);
+    if (ENV_FILE.test(base)) return bad('input-env-file', n, `${abs} is an environment file — refused by name, whatever it contains.`);
+    if (ls.size > RUBRIC_INPUT_MAX_BYTES) return bad('input-oversize', n, `${abs} is over the ${RUBRIC_INPUT_MAX_BYTES / (1024 * 1024)} MiB limit for a quoted input.`);
+    const buf = await readFile(abs);
+    try { utf8.decode(buf); } catch { return bad('input-not-utf8', n, `${abs} is not UTF-8 text — text files only for now.`); }
+    if (hasNulByte(buf)) return bad('input-not-text', n, `${abs} is not a text file — text files only for now.`);
+    // two files with one name keep the line number in front, so neither overwrites the other under input/
+    const name = names.has(base) ? `${n}-${base}` : base;
+    names.add(name);
+    staged.push({ label, name, buf });
+  }
+  const stage = await mkdtemp(join(tmpdir(), 'bareloop-rubric-inputs-'));
+  try {
+    for (const f of staged) await writeFile(join(stage, f.name), f.buf);
+    const prep = await prepareSource({ source: stage, into, ...(destination === undefined ? {} : { destination }) });
+    if (prep.stop !== null) return { ok: false, code: prep.code, error: prep.stop };
+    // `source` names the person's own first file, never the scratch staging folder that was already removed
+    const manifest = {
+      ...prep.manifest,
+      source: isWebUrl(inputs[0].value) ? inputs[0].value.trim() : resolve(inputs[0].value),
+      inputs: staged.map((f) => ({ label: f.label, rel: `input/${f.name}`, sha256: sha256Hex(f.buf), ...(f.url === undefined ? {} : { url: f.url }) })),
+    };
+    await writeFile(prep.manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return { ok: true, prep: { ...prep, manifest } };
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Is this Inputs value a path to an existing regular FILE on this machine (not a repo folder, not a web address, not a
+ * missing path)? The $0 peek that tells a rubric job on local files from a rubric job on a repo before a session exists;
+ * `proveRubricInputs` makes the authoritative, line-by-line proof.
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeLocalFile(value) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value) || !isAbsolute(value)) return false;
+  try { return lstatSync(resolve(value)).isFile(); } catch { return false; }
+}
+
+/**
+ * Is this Inputs value one a rubric job can work on without a repo: a regular FILE on this machine, or a web address (PART 1c)?
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function looksLikeRubricInput(value) {
+  return isWebUrl(value) || looksLikeLocalFile(value);
+}
+
+/**
+ * RUN START for a rubric job with web inputs (PART 1c, RF22): fetch every web input AGAIN and make that text the run's frozen input
+ * BEFORE the worker starts. The drafting copy was only for the look (prices change); the close grades, and the worker reads, THIS
+ * copy. It is written into the prepared tree, committed as the new seed (so the page is never read as a worker write), and
+ * `source.json` is rewritten (new sha256 per input, new seed, `draftSha256` keeps what the look saw). Nothing but the text of a
+ * recorded web address is ever refetched; a job with only file inputs returns at once and changes nothing.
+ * @param {{into: string, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>}} o `into` - the prepared copy (source.json + tree/)
+ * @returns {Promise<{ok: true, refreshed: string[], seed: string|null}|{ok: false, error: string}>}
+ */
+export async function refreezeUrlInputs({ into, fetchUrl = (u) => fetchPageText(u) }) {
+  const read = await readSourceManifest(into);
+  if (read.stop !== null) return { ok: false, error: read.stop };
+  if (!read.present || !read.manifest) return { ok: true, refreshed: [], seed: null };
+  const manifest = read.manifest;
+  const rows = Array.isArray(manifest.inputs) ? manifest.inputs.filter((/** @type {any} */ r) => r && typeof r.url === 'string' && r.url !== '') : [];
+  if (rows.length === 0) return { ok: true, refreshed: [], seed: null };
+  const tree = join(resolve(into), 'tree');
+  /** @type {{row: any, buf: Buffer}[]} */
+  const fresh = [];
+  for (const row of rows) {
+    const got = await fetchUrl(row.url);
+    if (!got.ok) return { ok: false, error: `Input "${row.label}": ${got.error}. The run did not start. Nothing spent.` };
+    const leak = secretPatternNames(got.text);
+    if (leak.length) return { ok: false, error: `Input "${row.label}": the page at ${got.url} carries a known secret shape (${leak.join(', ')}) - refused, secrets never enter a job. The run did not start. Nothing spent.` };
+    fresh.push({ row, buf: Buffer.from(got.text, 'utf8') });
+  }
+  for (const f of fresh) await writeFile(join(tree, f.row.rel), f.buf);
+  const add = await git(tree, [...NO_HOOKS, 'add', '-A', '-f']);
+  if (!add.ok) return { ok: false, error: `the fresh page copy could not be staged: ${add.err}. The run did not start. Nothing spent.` };
+  const commit = await git(tree, [...GIT_IDENTITY, ...NO_HOOKS, 'commit', '-q', '--allow-empty', '-m', 'bareloop: run start - fresh copy of the web inputs']);
+  if (!commit.ok) return { ok: false, error: `the fresh page copy could not be committed: ${commit.err}. The run did not start. Nothing spent.` };
+  const head = await git(tree, ['rev-parse', 'HEAD']);
+  if (!head.ok) return { ok: false, error: `git rev-parse HEAD failed in ${tree}: ${head.err}. The run did not start. Nothing spent.` };
+  const seed = head.out.trim();
+  const byLabel = new Map(fresh.map((f) => [f.row.label, f.buf]));
+  const inputs = manifest.inputs.map((/** @type {any} */ r) => {
+    const buf = byLabel.get(r.label);
+    return buf === undefined || typeof r.url !== 'string' ? r : { ...r, draftSha256: r.draftSha256 ?? r.sha256, sha256: sha256Hex(buf) };
+  });
+  const files = Array.isArray(manifest.files) ? manifest.files.map((/** @type {any} */ m) => {
+    const hit = inputs.find((/** @type {any} */ r) => typeof r.url === 'string' && r.rel === `input/${m.path}`);
+    if (!hit) return m;
+    const buf = byLabel.get(hit.label);
+    return buf === undefined ? m : { ...m, bytes: buf.length, sha256: sha256Hex(buf) };
+  }) : manifest.files;
+  const next = { ...manifest, inputs, files, seed, refrozenAt: new Date().toISOString() };
+  await writeFile(join(resolve(into), 'source.json'), `${JSON.stringify(next, null, 2)}\n`);
+  return { ok: true, refreshed: rows.map((/** @type {any} */ r) => r.label), seed };
+}

package/src/u-readout.js

@@ -202,7 +202,7 @@ export function reviewDoorPackage({ door, diff }) {
   const out = [];
   out.push(`REVIEW DOOR — this run's close minted ${String(d.outcome ?? 'a verdict')} and it STANDS. Nothing you do here changes it.`);
   if (held) {
-    out.push('  held     this green was rendered by the judged floor, so it has earned NO reuse and NO learning credit until you accept it');
+    out.push('  held     this is a rubric (soft-green) job, so its green earns NO reuse and NO learning credit until you accept it, whether or not a judge ran');
   }
   // the body: what the machine judged, what moved, and the lines themselves —
   // rendered by the SAME code the pause screen uses, off the same record shape.

package/src/userrun.js

@@ -42,7 +42,7 @@ import { makeSpine } from './spine.js';
 // signed into the job spec — a job is a repeatable SHAPE, the source/
 // destination a per-run value, exactly like `bareloop run <bundle> --repo
 // <path>` varies the repo without touching the bundle's signature).
-import { readSourceManifest, frontDoorFromManifest, proveDestination, copyOut } from './source.js';
+import { readSourceManifest, frontDoorFromManifest, proveDestination, copyOut, refreezeUrlInputs } from './source.js';
 import { scanSecrets, redactSecrets } from './validate.js';
 import { runBehaviour, formatBehaviour } from './behaviour.js';
 // the three doors' SEMANTICS live in the library; this script surfaces them
@@ -235,6 +235,7 @@ class ExitSignal extends Error {
  * @property {any} [provider] the TEST SEAM: supplying this skips the real-key
  *   check entirely, the same shape `src/cli.js`'s `main(argv, deps)` uses.
  * @property {(tier: string) => any} [providerFor]
+ * @property {(url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>} [fetchUrl] PART 1c - a test seam: how a web input is read at run start (production: barebrowse)
  * @property {any} [judgeProvider]
  * @property {string} [runlistHome] F196 — a test seam for `appendRun`'s
  *   (src/runlist.js) `home` override, the same shape `deps.provider` already
@@ -2592,13 +2593,24 @@ export async function main(argv, deps = {}) {
           + 'with exactly one source-*/ sibling.');
       }
       const into = candidates[0];
-      const manifestRead = await readSourceManifest(into);
+      let 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`);
+        }
+      }
       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`);

package/types/authorflow.d.ts

@@ -63,13 +63,16 @@ export function labelsFor(verdictType: string): Record<string | number, string>;
  * close — one source, never a second hand-typed list — rendered through the
  * frozen line in {@link GUARD_DESCRIPTIONS}, plus the write fence (a real,
  * signed fence — {@link writeScopeBlock}'s own subject) when one is set.
- * @param {{verdictType: string, lang: string, writeScope?: string[]|null}} o
+ * @param {{verdictType: string, lang: string, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} o
  * @returns {string[]}
  */
-export function confirmProtections({ verdictType, lang, writeScope }: {
+export function confirmProtections({ verdictType, lang, writeScope, jobLines }: {
     verdictType: string;
     lang: string;
     writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): string[];
 /**
  * The mechanical seam between the catalogue and the schema, read BOTH ways: a
@@ -107,12 +110,15 @@ export function schemaCoverage(catalogue?: Record<string, any>): {
  * and failing loudly beats emitting a schema that quietly cannot say something
  * the validator will then demand.
  * `questions` (P7 item 5, last drafting try only) adds the optional `questions` property; absent, the schema is byte-identical.
+ * `kinds` (Part 1a) narrows the branches to the kinds a language may use (`catalogueForLang`) WITHOUT narrowing the coverage check,
+ * which stays over the whole catalogue; null (the default) = no narrowing.
  * @param {Record<string, any>} [catalogue]
- * @param {{verdictType?: string|null, questions?: boolean}} [o]
+ * @param {{verdictType?: string|null, questions?: boolean, kinds?: string[]|null}} [o]
  */
-export function declarationSchema(catalogue?: Record<string, any>, { verdictType, questions }?: {
+export function declarationSchema(catalogue?: Record<string, any>, { verdictType, questions, kinds }?: {
     verdictType?: string | null;
     questions?: boolean;
+    kinds?: string[] | null;
 }): {
     type: string;
     properties: {
@@ -192,6 +198,11 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
                         minimum: number;
                         description: string;
                     };
+                    rule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
                     reason: {
                         type: string;
                         minLength: number;
@@ -211,14 +222,15 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
  * The output channel. It records and acknowledges; it takes no action, which is
  * why handing it to a toolless authoring call does not reopen D3.
  * @param {{calls: any[]}} box
- * @param {{catalogue?: Record<string, any>, verdictType?: string|null, questions?: boolean}} [o]
+ * @param {{catalogue?: Record<string, any>, verdictType?: string|null, questions?: boolean, kinds?: string[]|null}} [o]
  */
 export function declarationTool(box: {
     calls: any[];
-}, { catalogue, verdictType, questions }?: {
+}, { catalogue, verdictType, questions, kinds }?: {
     catalogue?: Record<string, any>;
     verdictType?: string | null;
     questions?: boolean;
+    kinds?: string[] | null;
 }): {
     name: string;
     description: string;
@@ -301,6 +313,11 @@ export function declarationTool(box: {
                             minimum: number;
                             description: string;
                         };
+                        rule: {
+                            type: string;
+                            minimum: number;
+                            description: string;
+                        };
                         reason: {
                             type: string;
                             minLength: number;
@@ -400,6 +417,7 @@ export function writeScopeBlock(writeScope: string[]): string;
  * never merge.
  * @param {{checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[],
  *   answeredQuestions?: string[]}} confirmed
+ * @param {{numbered?: boolean}} [o] `numbered` (a rubric job on files): each confirmed check carries its `#n`, which a part cites in `covers`
  */
 export function confirmedBlock(confirmed: {
     checks: string[];
@@ -411,6 +429,8 @@ export function confirmedBlock(confirmed: {
     openQuestions?: string[];
     notChecked?: string[];
     answeredQuestions?: string[];
+}, { numbered }?: {
+    numbered?: boolean;
 }): string;
 /**
  * P7: the job-line tagging order (model-facing, registered). Rule 1 of the job block: every stage the drafter writes
@@ -439,12 +459,14 @@ export function jobLineTagBlock(count: number): string;
  * @param {{answers: Record<string|number, string>, questions?: Record<string|number, string>,
  *   facts: any, listingBlock: string, lang: string, verdictType: string,
  *   guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
- *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>,
+ *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>|null,
  *   writeScope?: string[]|null,
  *   jobLines?: {n: number}[]|null, inputs?: {n: number, label: string, value: string}[]|null,
- *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
+ *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null,
+ *   labelLists?: string[]|null,
+ * }} o
  */
-export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue, writeScope, jobLines, inputs, confirmed, }: {
+export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue: catalogueIn, writeScope, jobLines, inputs, confirmed, labelLists, }: {
     answers: Record<string | number, string>;
     questions?: Record<string | number, string>;
     facts: any;
@@ -459,7 +481,7 @@ export function authorPrompt({ answers, questions, facts, listingBlock, lang, ve
     }[];
     ownedEnvNames?: string[];
     mode?: "tool" | "text";
-    catalogue?: Record<string, any>;
+    catalogue?: Record<string, any> | null;
     writeScope?: string[] | null;
     jobLines?: {
         n: number;
@@ -480,6 +502,45 @@ export function authorPrompt({ answers, questions, facts, listingBlock, lang, ve
         notChecked?: string[];
         answeredQuestions?: string[];
     } | null;
+    labelLists?: string[] | null;
+}): string;
+/**
+ * The composer prompt for a rubric job on local files (Part 1a, docs/product/ITEM33-BUILD.md). There is no repository
+ * and no survey: the facts are the numbered inputs and the listing is the frozen tree (input/ files, output/). It states
+ * the step-file contract the worker is also told ({@link stepFileContract}), so the stage and the file cannot drift.
+ * @param {{answers: Record<string|number, string>, questions?: Record<string|number, string>, facts: any, listingBlock: string,
+ *   verdictType: string, guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
+ *   mode?: 'tool'|'text', catalogue?: Record<string, any>, writeScope?: string[]|null,
+ *   jobLines?: {n: number}[]|null, inputs?: {n: number, label: string, value: string}[]|null, confirmed?: any,
+ *   labelLists?: string[]|null,
+ * }} o
+ * @returns {string}
+ */
+export function rubricAuthorPrompt({ answers, questions, facts, listingBlock, verdictType, guards, mode, catalogue, writeScope, jobLines, inputs, confirmed, labelLists, }: {
+    answers: Record<string | number, string>;
+    questions?: Record<string | number, string>;
+    facts: any;
+    listingBlock: string;
+    verdictType: string;
+    guards: {
+        name: string;
+        kind: string;
+        params: Record<string, any>;
+        fill: string[];
+    }[];
+    mode?: "tool" | "text";
+    catalogue?: Record<string, any>;
+    writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
+    confirmed?: any;
+    labelLists?: string[] | null;
 }): string;
 /**
  * The seed read, as the model sees it: mechanical labels, no editorial. Per-stage
@@ -836,7 +897,8 @@ export function confirmPrompt({ answers, questions, labels, facts, listing, writ
  *   generate: Function, book: ReturnType<typeof makeCostBook>,
  *   ask: (step: {kind: string, [k: string]: any}) => Promise<string|null>,
  *   onPhase?: (phase: string, data?: any) => void, mode?: 'tool'|'text',
- *   worseThanBefore?: string, inputs?: {n: number, label: string, value: string}[]|null}} o retired field (hamr's ruling 2026-09-28):
+ *   worseThanBefore?: string, inputs?: {n: number, label: string, value: string}[]|null,
+ *   jobLines?: {n: number}[]|null}} o retired field (hamr's ruling 2026-09-28):
  *   `worseThanBefore` is never asked any more and defaults to `''` — a
  *   caller may still pass a string through (kept for a future, non-ask
  *   source of the same constraint), it just never comes from an ask() step.
@@ -847,7 +909,7 @@ export function confirmPrompt({ answers, questions, labels, facts, listing, writ
  *     worseThanBefore: string, openQuestions: string[], notChecked: string[], answeredQuestions?: string[]}|null,
  *   reds: Red[], cost: any}>}
  */
-export function runConfirmTurn({ verdictType, answers, questions, labels, facts, listing, writeScope, isRepo, lang, generate, book, ask, onPhase, mode, worseThanBefore: presetWorseThanBefore, inputs, }: {
+export function runConfirmTurn({ verdictType, answers, questions, labels, facts, listing, writeScope, isRepo, lang, generate, book, ask, onPhase, mode, worseThanBefore: presetWorseThanBefore, inputs, jobLines, }: {
     verdictType: string;
     answers: Record<string | number, string>;
     questions: Record<string | number, string>;
@@ -875,6 +937,9 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
         label: string;
         value: string;
     }[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): Promise<{
     ok: boolean;
     stop: null | "cap-halt" | "pricing-red" | "provider-red" | "artifact-red" | "confirm-abandoned" | "confirm-restart";
@@ -945,7 +1010,7 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
  *   offerQuestions?: boolean,
  *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
  */
-export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, writeScope, scout, listing, priorCalls, priorRaws, confirmed, jobLines, inputs, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue, offerQuestions, }: {
+export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, writeScope, scout, listing, priorCalls, priorRaws, confirmed, jobLines, inputs, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue: catalogueIn, offerQuestions, }: {
     workdir: string;
     seedRef: string;
     lang: string;
@@ -1522,12 +1587,195 @@ export const PARAM_SCHEMAS: Readonly<{
         };
         description: string;
     };
+    step: {
+        type: string;
+        minimum: number;
+        description: string;
+    };
+    parts: {
+        type: string;
+        description: string;
+        items: {
+            type: string;
+            properties: {
+                text: {
+                    type: string;
+                    minLength: number;
+                    description: string;
+                };
+                class: {
+                    enum: string[];
+                };
+                check: {
+                    enum: string[];
+                    description: string;
+                };
+                value: {
+                    type: string;
+                    minimum: number;
+                    description: string;
+                };
+                names: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    description: string;
+                };
+                wordsPerSection: {
+                    type: string;
+                    minimum: number;
+                };
+                source: {
+                    type: string;
+                    minLength: number;
+                    description: string;
+                };
+                domains: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    description: string;
+                };
+                covers: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    items: {
+                        type: string;
+                        minimum: number;
+                    };
+                    description: string;
+                };
+                rules: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    items: {
+                        type: string;
+                        minimum: number;
+                    };
+                    description: string;
+                };
+                facts: {
+                    type: string;
+                    minItems: number;
+                    maxItems: number;
+                    description: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            name: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            shape: {
+                                enum: string[];
+                                description: string;
+                            };
+                            unit: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            currency: {
+                                enum: string[];
+                                description: string;
+                            };
+                            phrase: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            anchor: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            until: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            rule: {
+                                type: string;
+                                description: string;
+                                properties: {
+                                    op: {
+                                        enum: string[];
+                                    };
+                                    value: {
+                                        type: string[];
+                                        description: string;
+                                    };
+                                    lo: {
+                                        type: string[];
+                                    };
+                                    hi: {
+                                        type: string[];
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            aiProposal: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                count: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        min: {
+                            type: string;
+                            minimum: number;
+                        };
+                        max: {
+                            type: string;
+                            minimum: number;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
     ask: {
         type: string;
         minLength: number;
         description: string;
     };
 }>;
+/**
+ * What a rubric job on local files means by DONE — the class statement of the text genre (Part 1a). It is stated as an order
+ * about KINDS: every part of a job line is counted or checked against a quote, because nothing in this build judges.
+ */
+export const RUBRIC_FILES_STATEMENT: string;
+/**
+ * THE RUBRIC RULES, in one place (live fix B1): what the confirm step and the drafter are both told about turning the person's words
+ * into checks. The confirm note ({@link RUBRIC_CONFIRM_NOTE}) and the composer brief ({@link REQUIRED_FACTS_BRIEF}) interpolate THIS
+ * constant, so the two cannot drift (in smv6k6l8dxkzs the confirm step planned a limit the drafter then could not carry, and the
+ * drafter added an airport code the person never wrote). Field-neutral: neither turn needs the other's field names.
+ */
+export const RUBRIC_RULES: string;
+/**
+ * REQUIRED FACTS, as the composer is told them (PART 1b, PRD item 33 RF1–RF17). The shape of the fact part is in the catalogue and the
+ * schema; this is the judgement the schema cannot carry: what becomes a fact, where its words come from, and what is Not checked.
+ */
+export const REQUIRED_FACTS_BRIEF: string;
 export const CONFIRM_TOOL_NAME: "confirm_plan";
 /** Acknowledgement text the confirm tool's `execute` returns — mirrors
  * {@link DECLARATION_ACK}'s role: an output channel that records and
@@ -1545,6 +1793,12 @@ export const CONFIRM_STRUCTURE_INSTRUCTION: string;
  * an ORDER to the model itself, the same register {@link AUTHOR_SYSTEM} and
  * {@link CLASS_STATEMENTS} already use, rather than a code matcher over prose.
  */
+/**
+ * What the confirm turn tells the model about a rubric job on local text files (model-facing, registered). There is no
+ * repository and no judge: a check is a limit a machine counts (words, lines, sections), or a claim a quote from a named
+ * input must back. Everything else the person asked for is named in `notChecked`, in their words.
+ */
+export const RUBRIC_CONFIRM_NOTE: string;
 export const CONFIRM_SYSTEM: string;
 export type Red = {
     code: string;