bareloop 0.40.0 → 0.42.0

package/src/authorflow.js

@@ -73,7 +73,7 @@
 // No spine emission here — M4 wires events.
 
 import { renderInputs } from './jobblock.js';
-import { draftCallOptions } from './providers.js';
+import { thinkingCallOptions } from './thinking.js';
 import { createRequire } from 'node:module';
 import { realpathSync } from 'node:fs';
 import { join, relative, isAbsolute } from 'node:path';
@@ -81,12 +81,16 @@ import { seedRead as runSeedReadStages, makeSeedTrees, AGGREGATES, SIGNS, MAX_TE
 import { JUDGE_RULE_IDS } from './judged.js';
 import {
   KIND_CATALOGUE, MAX_STAGES, DIRECTIONS, BASELINES,
-  GENRE_LANGUAGES, TYPES_GENRE_TEMPLATE, classGuards, genreEnv, genreOwnedEnvNames, genreInstruments,
-  validateDeclaration, envCapableKind, classMenu, VERDICT_CLASSES, LIVE_CLASSES, MENU_CLASSES,
+  GENRE_LANGUAGES, RUBRIC_LANG, DECLARABLE_LANGUAGES, TYPES_GENRE_TEMPLATE, classGuards, genreEnv, genreOwnedEnvNames, genreInstruments,
+  validateDeclaration, envCapableKind, classMenu, VERDICT_CLASSES, LIVE_CLASSES, MENU_CLASSES, catalogueForLang,
 } from './authoring.js';
 import { buildSeedListing, cleanEntry, SURVEY_CAUSES, AUTHOR_CALL_TIMEOUT_MS } from './authorscout.js';
 import { extractArtifact, priceOf, scrubRaw, tallyCalls, capStop, callCasualty } from './text.js';
 import { redactSecrets } from './validate.js';
+import { stepFileContract, inputLabelsOf, stepFileRel, readFrozenInputs, withFactBindings, settlePersonsWords } from './rubricstep.js';
+import { factShapeGuide } from './facts.js';
+import { renderLookReport, labelListsOf } from './inputlook.js';
+import { checkDeclarationWords } from './factwords.js';
 
 const require = createRequire(import.meta.url);
 const { Loop } = require('bare-agent');
@@ -632,10 +636,10 @@ export const GUARD_DESCRIPTIONS = Object.freeze({
  * 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 = null }) {
+export function confirmProtections({ verdictType, lang, writeScope = null, jobLines = null }) {
   const guards = classGuards({ verdictType, lang });
   const lines = guards.map((g) => {
     const desc = GUARD_DESCRIPTIONS[g.name];
@@ -648,6 +652,11 @@ export function confirmProtections({ verdictType, lang, writeScope = null }) {
   if (Array.isArray(writeScope) && writeScope.length > 0) {
     lines.push(`write fence — the run may only change files matching: ${writeScope.join(', ')}`);
   }
+  // PART 1a: a rubric job on local files always checks, for EVERY numbered line, that the line's file exists, is complete
+  // JSON and has text — a fact of the close's shape (`rubric-step`), not a plan of the model's, so it is listed from code
+  if (lang === RUBRIC_LANG && Array.isArray(jobLines)) {
+    for (const l of jobLines) lines.push(`line ${l.n} file — ${stepFileRel(l.n)} must exist, be complete JSON, and carry text`);
+  }
   return lines;
 }
 
@@ -801,6 +810,68 @@ export const PARAM_SCHEMAS = Object.freeze({
     items: { type: 'string' },
     description: 'the AUTHORITATIVE artifacts to judge, repository-relative, read off the listing. One paid call each.',
   },
+  step: { type: 'integer', minimum: 1, description: 'the number of the job line this stage serves; its file is output/steps/<step>.json' },
+  parts: {
+    type: 'array',
+    description: 'every constraint the person put on that job line, in their own words, each SORTED: countable (a machine counts it, or a '
+      + 'quote from a named input must back it), judged (only reading it could decide), guard (a rule about web sources), none (you cannot sort it)',
+    items: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', minLength: 1, description: 'the constraint, in the person\'s own words' },
+        class: { enum: ['countable', 'fact', 'judged', 'guard', 'none'] },
+        check: { enum: ['maxWords', 'minWords', 'maxLines', 'sections', 'sectionWords', 'cited', 'minClaims', 'maxClaims'], description: 'countable only; minClaims / maxClaims count the claims listed under the input named in source' },
+        value: { type: 'integer', minimum: 1, description: 'maxWords / minWords / maxLines: the limit the person asked for' },
+        names: { type: 'array', minItems: 1, items: { type: 'string', minLength: 1 }, description: 'sections / sectionWords: the section names' },
+        wordsPerSection: { type: 'integer', minimum: 1 },
+        source: { type: 'string', minLength: 1, description: 'cited: the label of the input a quote must come from' },
+        domains: { type: 'array', minItems: 1, items: { type: 'string', minLength: 1 }, description: 'guard only: the web domains the rule is about' },
+        covers: { type: 'array', minItems: 1, uniqueItems: true, items: { type: 'integer', minimum: 1 }, description: 'the number(s) of the CONFIRMED check(s) this part carries out' },
+        rules: { type: 'array', minItems: 1, uniqueItems: true, items: { type: 'integer', minimum: 1 }, description: 'the number(s) of the job line\'s ~ rules this part carries out (1 = the first ~ rule under the line)' },
+        facts: {
+          type: 'array',
+          minItems: 1,
+          maxItems: 10,
+          description: 'fact only: the REQUIRED FACTS every result must hold, one per thing the person asked for (from the job line AND its ~ rules)',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string', minLength: 1, description: 'what the fact is called: letters and spaces only, no digits' },
+              shape: { enum: ['money', 'number', 'date', 'time', 'phrase', 'text'], description: 'money / number / date / time may carry a rule; phrase = fixed words the quote must contain; text = words the quote holds, as it writes them' },
+              unit: { type: 'string', minLength: 1, description: 'money: the words the input writes after the amount, copied verbatim (or give currency instead)' },
+              currency: { enum: ['$', '€', '£'], description: 'money: the symbol the input writes before the amount (or give unit instead)' },
+              phrase: { type: 'string', minLength: 1, description: 'phrase only: the fixed words, copied verbatim from the input' },
+              anchor: { type: 'string', minLength: 1, description: 'a label copied VERBATIM from the input that sits right before the value (picks the right one when a result holds several)' },
+              until: { type: 'string', minLength: 1, description: 'text with an anchor: the label copied VERBATIM that ends the value' },
+              rule: {
+                type: 'object',
+                description: 'only when the person asked for a limit',
+                properties: {
+                  op: { enum: ['lt', 'lte', 'gt', 'gte', 'between'] },
+                  value: { type: ['number', 'string'], description: 'a number for number/money; a string for date (YYYY-MM-DD) / time (HH:MM)' },
+                  lo: { type: ['number', 'string'] },
+                  hi: { type: ['number', 'string'] },
+                },
+                required: ['op'],
+                additionalProperties: false,
+              },
+              aiProposal: { type: 'boolean', description: 'true when the rule\'s number is YOURS (made out of the person\'s words), not one the person wrote' },
+            },
+            required: ['name', 'shape'],
+            additionalProperties: false,
+          },
+        },
+        count: {
+          type: 'object',
+          description: 'fact only: how many results the person asked for',
+          properties: { min: { type: 'integer', minimum: 1 }, max: { type: 'integer', minimum: 1 } },
+          additionalProperties: false,
+        },
+      },
+      required: ['text', 'class'],
+      additionalProperties: false,
+    },
+  },
   ask: {
     type: 'string',
     minLength: 1,
@@ -854,10 +925,12 @@ export function schemaCoverage(catalogue = KIND_CATALOGUE) {
  * 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 = KIND_CATALOGUE, { verdictType = null, questions = false } = {}) {
+export function declarationSchema(catalogue = KIND_CATALOGUE, { verdictType = null, questions = false, kinds = null } = {}) {
   const cov = schemaCoverage(catalogue);
   if (!cov.ok) {
     throw new Error('[authorflow] the declaration schema does not cover the catalogue — '
@@ -865,7 +938,7 @@ export function declarationSchema(catalogue = KIND_CATALOGUE, { verdictType = nu
   }
   const menu = classMenu(verdictType, catalogue);
   const branches = Object.entries(catalogue)
-    .filter(([kind, spec]) => !spec.locked && menu.includes(kind))
+    .filter(([kind, spec]) => !spec.locked && menu.includes(kind) && (kinds === null || kinds.includes(kind)))
     .map(([kind, spec]) => {
       /** @type {Record<string, any>} */
       const properties = {};
@@ -910,12 +983,13 @@ export function declarationSchema(catalogue = KIND_CATALOGUE, { verdictType = nu
           type: 'object',
           properties: {
             line: { type: 'integer', minimum: 1, description: 'the number of a job line no stage checks' },
+            rule: { type: 'integer', minimum: 1, description: 'optional: the number of ONE ~ rule of that line that nothing checks (the line itself still has a stage)' },
             reason: { type: 'string', minLength: 1, description: 'why, in plain words the person can read' },
           },
           required: ['line', 'reason'],
           additionalProperties: false,
         },
-        description: 'job lines you could not turn into a stage, each with a reason — a note does not cover a line',
+        description: 'job lines (or single ~ rules of a line) you could not turn into a check, each with a reason in the person\'s words — a note does not cover a line or a rule',
       },
       ...(questions ? {
         questions: {
@@ -938,13 +1012,13 @@ export function declarationSchema(catalogue = KIND_CATALOGUE, { verdictType = nu
  * 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, { catalogue = KIND_CATALOGUE, verdictType = null, questions = false } = {}) {
+export function declarationTool(box, { catalogue = KIND_CATALOGUE, verdictType = null, questions = false, kinds = null } = {}) {
   return {
     name: DECLARATION_TOOL_NAME,
     description: 'Deliver the finished close. Call this exactly once, with the whole declaration as its arguments.',
-    parameters: declarationSchema(catalogue, { verdictType, questions }),
+    parameters: declarationSchema(catalogue, { verdictType, questions, kinds }),
     execute: async (/** @type {any} */ args) => { box.calls.push(args); return DECLARATION_ACK; },
   };
 }
@@ -1121,8 +1195,9 @@ export function writeScopeBlock(writeScope) {
  * 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) {
+export function confirmedBlock(confirmed, { numbered = false } = {}) {
   const checks = confirmed.checks ?? [];
   const protections = confirmed.protections ?? [];
   const openQuestions = confirmed.openQuestions ?? [];
@@ -1132,8 +1207,8 @@ export function confirmedBlock(confirmed) {
     + 'Compose stages for these checks and no other — a genre never adds a check the goal did not ask for, and '
     + 'neither do you:\n\n'
     + `${(confirmed.checkItems?.length
-      ? confirmed.checkItems.map((c) => `  - ${c.fromLine && c.fromLine.length ? `[line ${c.fromLine.join(', ')}] ` : ''}${c.text}`)
-      : checks.map((c) => `  - ${c}`)).join('\n') || '  (none)'}\n\n`
+      ? confirmed.checkItems.map((c, i) => `  - ${numbered ? `#${i + 1} ` : ''}${c.fromLine && c.fromLine.length ? `[line ${c.fromLine.join(', ')}] ` : ''}${c.text}`)
+      : checks.map((c, i) => `  - ${numbered ? `#${i + 1} ` : ''}${c}`)).join('\n') || '  (none)'}\n\n`
     + 'These protections are already always-on and unchanged by this plan — never compose one of these as a check:\n\n'
     + `${protections.map((p) => `  - ${p}`).join('\n') || '  (none)'}\n\n`
     + (notChecked.length
@@ -1183,14 +1258,16 @@ export function jobLineTagBlock(count) {
  * @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 = GREEN_QUESTIONS, facts, listingBlock, lang, verdictType, guards,
-  ownedEnvNames = [], mode = 'tool', catalogue = KIND_CATALOGUE, writeScope = null,
+  ownedEnvNames = [], mode = 'tool', catalogue: catalogueIn = null, writeScope = null,
   // P7: the person's numbered job lines and the inputs they pointed at. ABSENT = byte-identical prompt (every caller
   // that predates the job block). Present: the drafter is told to tag every stage it writes with the line it serves.
   jobLines = null, inputs = null,
@@ -1198,7 +1275,16 @@ export function authorPrompt({
   // turn (or ran without `ask`) — byte-identical prompt, nothing added. Present
   // only when a confirm turn actually ran and the person accepted a plan.
   confirmed = null,
+  // PART 1c: the label lists code made from the frozen inputs (src/labelscan.js `renderLabelList`); a label is picked from them
+  labelLists = null,
 }) {
+  // PART 1a: a rubric job on the person's own local files has no repository, no genre template and no tool to measure with —
+  // it gets its own brief (`rubricAuthorPrompt`), which still ends in the same declaration tool and the same guards
+  // an absent catalogue is the language's own menu (`catalogueForLang`), so a code job's prompt never lists a rubric-only kind
+  const catalogue = catalogueIn ?? catalogueForLang(lang);
+  if (lang === RUBRIC_LANG) {
+    return rubricAuthorPrompt({ answers, questions, facts, listingBlock, verdictType, guards, mode, catalogue, writeScope, jobLines, inputs, confirmed, labelLists });
+  }
   const statement = CLASS_STATEMENTS[String(verdictType)] ?? null;
   if (statement === null) {
     throw new Error(`[authorflow] the authoring prompt needs the verdict class the user picked, and "${verdictType}" `
@@ -1303,6 +1389,170 @@ measure anything.`;
   ].join('\n\n---\n\n');
 }
 
+/**
+ * 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 = 'The person declared this job SOFT-GREEN and pointed it at their own text files: the work is writing '
+  + 'about those files. This build has no judge, so every part of a job line must be one of three things. COUNTED: a limit on words, '
+  + 'sections or lines of what is written. Or a REQUIRED FACT: something the line finds, lists or looks up, each answer quoted word for '
+  + 'word from a named input and checked by its shape (money, number, date, time, phrase, text). Or BACKED BY A QUOTE: a claim that '
+  + 'must carry words copied from a named input. '
+  + 'Compose ONE rubric-step stage per numbered job line, after the mandatory guard, and name only limits the person actually '
+  + 'asked for. A part you cannot express that way is not approximated by a stage that means something else.';
+
+/**
+ * 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 = 'THE RULES FOR TURNING THE PERSON\'S WORDS INTO CHECKS (the same for every turn of this job):\n - A limit the person WROTE ("under $450") is a rule that can be checked: plan it as a limit with its number.\n'
+  + ' - A number YOU make out of their words ("not a red-eye" becomes a departure time between 06:00 and 21:00) is your proposal, marked '
+  + 'as the AI\'s proposal for the person to check; a limit on a time that you propose is a RANGE (between), never one-sided. The input does '
+  + 'not have to hold the person\'s word (it holds no "red-eye"): the limit goes on the time the input DOES hold (e.g. the one after "Departure time:"), as a '
+  + 'range marked as the AI\'s proposal.\n'
+  + ' - Names, labels and units are the INPUT\'s own words, copied exactly as the input writes them. When the input does not use the '
+  + 'person\'s word (they wrote SFO, the input says San Francisco International Airport), use the words the input uses; never invent a '
+  + 'word the input does not hold, and never add a code (like SFO) that the person did not write and the input does not hold.\n'
+  + ' - A label for a line that asks for N results (a count of N) must sit in each result, so the label list must count it N or more times '
+  + '(the x-number beside it). A label counted fewer times is on the page once or twice (a sort tab, a switch) and is refused at $0 with its count.\n'
+  + ' - The same holds for the words a "must say" (phrase) fact makes each quote say: they must be in the input at least N times for N results. Words counted fewer times (page-header words like "from San Francisco" when each result says "Leaves San Francisco International Airport") are refused at $0 with their count; pick words every result says, or drop the check.';
+
+/**
+ * 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 = 'REQUIRED FACTS — what a line that finds, lists or looks something up leaves behind\n\n'
+  + 'For such a line write ONE part of class "fact". The worker\'s file for that line holds only results, each with ONE quote copied '
+  + 'from the input and the value of every fact as the quote writes it — no free text. Code checks every value against its quote.\n'
+  + ' - The facts come from the job line itself AND from its ~ rules: "SFO to LAX" is a from fact and a to fact even with no ~ line. '
+  + 'One fact per thing the person asked for. Give every fact a shape. A rule (op, value, or between lo and hi) only where the person '
+  + 'asked for a limit.\n'
+  + ' - THE LOOK above is what a read of the inputs found: write the facts from it. Copy every label (anchor), unit and phrase EXACTLY '
+  + 'as the look gives it (the look\'s phrase facts become phrase facts with the same words), and say in "notes" when you used the input\'s '
+  + 'words instead of the person\'s. A label (anchor) is PICKED from the labels the look found in the input, never typed; one that is not '
+  + 'among them is refused at $0. What the look could not find is not checked: list it under "refused" in the person\'s words.\n'
+  + ' - When one result holds several values of one kind (leaves / arrives, subtotal / total) give the fact an anchor, the label that sits right before the value you mean.\n'
+  + ' - Set aiProposal true on a fact whose number you made out of their words.\n'
+  + RUBRIC_RULES + '\n'
+  + ' - How MANY results were asked for is a count ("3 releases": count {min: 3, max: 3}). WHICH ones ("the last", "the newest") and '
+  + 'anything else you cannot express as a shape and a rule ("the cheapest", "the best", "a good pick") is NOT CHECKED: list it in "refused" as {"line": N, "rule": the number of that ~ rule, "reason": the '
+  + 'person\'s own words}. EVERY ~ rule of a line must be carried out by a part (list its number in the part\'s "rules", 1 = the first ~ '
+  + 'rule under the line) or be listed in "refused"; a rule that is neither is refused at $0.\n'
+  + ' - A line that WRITES (a summary, a report) keeps word, section and line counts. Code ties its numbers to the facts of the lines '
+  + 'before it; you do not add that.\n'
+  + ' - A look fact that says "carries ~ rule N" is how the look carried that rule: put N in the fact part\'s "rules" and do not also list rule N in "refused".\n'
+  + ' - A ~ rule that you carry out as a fact (a limit on a time, a price, a date: "not a red-eye" is a time fact with a between rule) is carried by the '
+  + 'fact part: list its number in that part\'s "rules". It is NOT also a part of its own: on a line that lists facts, a part of class judged or none '
+  + 'is refused. A rule you cannot express as a shape and a rule goes in "refused", never into a part.\n'
+  + ' - "covers" and "rules" are fields of the PART, written once on it as a list of numbers. A fact never has a "covers" or a "rules" field.\n'
+  + ' - ONE stage per job line, holding ALL of that line\'s facts (and its other parts). Two stages for one line are refused: put a '
+  + '~ rule\'s fact (a "not a red-eye" time) on the same stage as the line\'s other facts.\n'
+  + ' - WHICH SHAPE TAKES WHICH FIELDS (a field a shape does not take is refused):\n'
+  + factShapeGuide();
+
+/**
+ * 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 = GREEN_QUESTIONS, facts, listingBlock, verdictType, guards,
+  mode = 'tool', catalogue = KIND_CATALOGUE, writeScope = null, jobLines = null, inputs = null, confirmed = null, labelLists = null,
+}) {
+  const interview = Object.entries(questions)
+    .map(([n, q]) => `Q${n}. ${q}\nA${n}. ${answers?.[n] ?? '(no answer given)'}`)
+    .join('\n\n');
+  const role = `You are composing the close for one job.
+
+The close is what decides whether a run of this job came back DONE. It runs after the work is
+finished, it is the only truth, and nothing else can overrule it. It is a list of STAGES. Each
+stage names a kind from the catalogue below and fills that kind's parameters. Stages run in the
+order you declare them.
+
+Two sources fed you this brief and neither of them is you:
+ - the person who wants the job done answered an interview, below, in their own words. They are
+   not a software engineer and did not name commands, thresholds or patterns;
+ - the person's own text files, frozen into the job. There is no code repository: the files sit
+   under input/ and the run writes only under output/.`;
+  const guardJson = guards.map((g) => ({
+    name: g.name,
+    kind: g.kind,
+    params: { ...g.params, ...Object.fromEntries(g.fill.map((f) => [f, FILL_MARKER])) },
+  }));
+  const output = mode === 'tool'
+    ? `HOW TO ANSWER
+
+Call the ${DECLARATION_TOOL_NAME} tool exactly once. Its arguments ARE the declaration: an ordered
+"stages" array, plus "notes" for anything you could not express, and "refused" for a job line no stage can check.
+Do not write the declaration as text.
+
+Stage names are unique. Every parameter name comes from the catalogue and no other. No parameter is
+left as a placeholder. You never write a number the person did not ask for.`
+    : `HOW TO ANSWER
+
+A single JSON object and nothing else: an ordered "stages" array, plus "notes" for anything you
+could not express, and "refused" for a job line no stage can check.
+
+Stage names are unique. Every parameter name comes from the catalogue and no other. No parameter is
+left as a placeholder. You never write a number the person did not ask for.`;
+  return [
+    role,
+    `WHAT THE PERSON DECLARED "DONE" TO MEAN — their answer, not yours\n\n${RUBRIC_FILES_STATEMENT}`,
+    `THE INTERVIEW — the person's own words\n\n${interview}`
+      + (inputs && inputs.length ? `\n\n${renderInputs(inputs)}` : ''),
+    ...(jobLines && jobLines.length ? [jobLineTagBlock(jobLines.length)] : []),
+    ...(writeScope && writeScope.length ? [writeScopeBlock(writeScope)] : []),
+    ...(confirmed ? [confirmedBlock(confirmed, { numbered: true }),
+      'EVERY CONFIRMED CHECK IS COMPOSED OR MOVED, NEVER DROPPED\n\nThe person saw the numbered checks above. On each countable or fact part that carries one of them out, list its number in the PART\'s "covers" (once on the part, never on a fact inside it). '
+      + 'A confirmed check that no part covers is not silently left out: it is moved to Not checked before signing, and the person is told. '
+      + 'To count "N things listed", use minClaims / maxClaims (it counts the claims listed under an input); anything else you cannot count is not composed.'] : []),
+    REQUIRED_FACTS_BRIEF,
+    `THE STEP FILES — what the worker leaves behind for each job line\n\n${stepFileContract()}\n\n`
+      + 'The rubric-step stage for job line N reads exactly that file, output/steps/N.json. It names the inputs (by label) the '
+      + 'step must cite from, and the limits on its "text".',
+    `THE FILES — the inputs the person pointed at, frozen into the job\n\n${JSON.stringify(withoutLook(facts), null, 2)}`
+      + (listingBlock ? `\n\n${listingBlock}` : ''),
+    ...(Array.isArray(labelLists) && labelLists.length ? [labelLists.join('\n\n')] : []),
+    ...(facts && facts.look ? [renderLookReport(facts.look)] : []),
+    rubricCatalogueBlock(catalogue, { verdictType }),
+    'MANDATORY GUARDS — already placed and already parameterised\n\n'
+      + 'This kind of job carries a stage the person did not ask for. It is fixed and you may not change, drop, rename, or '
+      + `re-kind it. The ONLY thing you fill in is each "${FILL_MARKER}" slot, from the interview:\n\n${JSON.stringify(guardJson, null, 2)}\n\n`
+      + 'Place it first: it is cheap, and the first red ends the judgement.',
+    output,
+  ].join('\n\n---\n\n');
+}
+
+/** the facts object without the look's report (that is its own block, written by code) @param {any} facts */
+function withoutLook(facts) {
+  if (!facts || typeof facts !== 'object' || !('look' in facts)) return facts;
+  const { look: _look, ...rest } = facts;
+  return rest;
+}
+
+/**
+ * The kind rows of the catalogue, without the command-output parser text a rubric job never needs.
+ * @param {Record<string, any>} catalogue @param {{verdictType?: string|null}} [o]
+ */
+function rubricCatalogueBlock(catalogue, { verdictType = null } = {}) {
+  const menu = classMenu(verdictType, catalogue);
+  const rows = Object.entries(catalogue).filter(([name, spec]) => menu.includes(name) && !spec.locked).map(([name, spec]) => `- ${name}\n    ${spec.shape}\n    required: ${spec.required.join(', ')}`
+    + `${spec.optional.length ? `   optional: ${spec.optional.join(', ')}` : ''}\n    asserts: ${spec.asserts}`);
+  return `THE KIND CATALOGUE — these are the only kinds that exist.
+You parameterise kinds. You never write a script, a shell fragment, or a new kind.
+
+${rows.join('\n\n')}`;
+}
+
 // ── 3. THE MEASURED BLOCKS ───────────────────────────────────────────────────
 
 /** F6, at the rendering boundary: an absent number is unknown, never 0. */
@@ -1536,7 +1786,7 @@ export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }) {
  */
 /**
  * @param {{ceilingUsd?: number|null,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void}} [o]
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void}} [o]
  *   `ceilingUsd` is the OPERATOR's ceiling; `null`/absent is UNBOUNDED.
  *   `onCall` is a REPORTING seam fired as each metered call lands — the shell's
  *   only chance to know what has been spent while the run is still alive. It is
@@ -1557,9 +1807,9 @@ export function makeCostBook({ ceilingUsd = null, onCall = () => {} } = {}) {
       const call = { label, ...priceOf(r) };
       entries.push(call);
       raws.push(scrubRaw({ label, attempt, text: r?.text, reason: r?.error ? String(r.error) : null }));
-      // bare-agent's per-run `thinkingApplied` (true | false | null) rides the REPORTING seam only — never the stored entry,
-      // so the cost report and every persisted shape stay as they were; absent when thinkingMode was not sent
-      onCall({ ...call, ...(r?.thinkingApplied === undefined ? {} : { thinkingApplied: r.thinkingApplied }) });
+      // bare-agent's per-run `thinkingStatus` ('applied' | 'unsupported' | 'ignored' | 'unknown') rides the REPORTING seam only —
+      // never the stored entry, so the cost report and every persisted shape stay as they were; absent when thinkingMode was not sent
+      onCall({ ...call, ...(r?.thinkingStatus === undefined ? {} : { thinkingStatus: r.thinkingStatus }) });
       return entries.at(-1);
     },
     /** @param {{label: string, costUsd: number|null, unpricedRounds: number}[]} calls
@@ -1599,13 +1849,13 @@ export function makeCostBook({ ceilingUsd = null, onCall = () => {} } = {}) {
  * `cacheMessages` (F18) and `maxTokens` (F30) are not optional on this stack.
  * `rates` is the customer's own price for this provider's key row (USD per 1K, `ratesFor`);
  * absent = bare-agent's built-in guess, exactly as before.
- * `draftThinking` ('on' | 'off', operator knob; default 'off') adds the drafter's per-call thinking option via `draftCallOptions`.
+ * `draftThinking` ('on' | 'off', the job's "Thinking on" tick spelled as a word; default 'off') adds the drafter's per-call thinking option via `thinkingCallOptions` (src/thinking.js, the one owner).
  * @param {any} provider @param {{system?: string, maxTokens?: number, rates?: {in: number, out: number}|null, draftThinking?: string}} [o]
  * @returns {(messages: any[], tools: any[], opts?: any) => Promise<any>}
  */
 export function makeLoopGenerate(provider, { system = AUTHOR_SYSTEM, maxTokens = AUTHOR_MAX_TOKENS, rates = null, draftThinking = 'off' } = {}) {
-  // the drafter's per-call options (src/providers.js `draftCallOptions`, one owner); a bad mode throws HERE, at construction
-  const callOptions = draftCallOptions(provider, draftThinking);
+  // the drafter's per-call options (src/thinking.js `thinkingCallOptions`, one owner); a bad mode throws HERE, at construction
+  const callOptions = thinkingCallOptions(provider, draftThinking);
   return async (/** @type {any[]} */ messages, /** @type {any[]} */ tools, /** @type {any} */ opts = {}) => {
     const loop = new Loop({ provider, system, ...(rates ? { rates } : {}) });
     const wired = tools.map((t) => ({
@@ -1784,12 +2034,12 @@ export async function askStructured({ messages, generate, mode, retries, label,
 /** THE DECLARATION CHANNEL — the one this loop has always used. Its schema is
  * CLASS-SCOPED, like the prompt's catalogue block: the two must offer one set of
  * kinds, or the composer reads about a kind it cannot call.
- * @param {{catalogue: Record<string, any>, verdictType: string, questions?: boolean}} o */
-const declarationChannel = ({ catalogue, verdictType, questions = false }) => ({
+ * @param {{catalogue: Record<string, any>, verdictType: string, questions?: boolean, kinds?: string[]|null}} o */
+const declarationChannel = ({ catalogue, verdictType, questions = false, kinds = null }) => ({
   name: DECLARATION_TOOL_NAME,
   instruction: STRUCTURE_INSTRUCTION_TOOL,
   textPath: 'declaration',
-  tool: (/** @type {{calls: any[]}} */ box) => declarationTool(box, { catalogue, verdictType, questions }),
+  tool: (/** @type {{calls: any[]}} */ box) => declarationTool(box, { catalogue, verdictType, questions, kinds }),
 });
 
 /** The declaration ask, over the shared ladder. `declaration` is `artifact`
@@ -1797,11 +2047,11 @@ const declarationChannel = ({ catalogue, verdictType, questions = false }) => ({
  * anonymous artifact, and one word for two things is how a reader loses which.
  * @param {{messages: any[], generate: Function, mode: 'tool'|'text', retries: number,
  *   label: string, book: ReturnType<typeof makeCostBook>, catalogue: Record<string, any>,
- *   verdictType: string, questions?: boolean}} o
+ *   verdictType: string, questions?: boolean, kinds?: string[]|null}} o
  */
-async function askDeclaration({ messages, generate, mode, retries, label, book, catalogue, verdictType, questions = false }) {
+async function askDeclaration({ messages, generate, mode, retries, label, book, catalogue, verdictType, questions = false, kinds = null }) {
   const r = await askStructured({
-    messages, generate, mode, retries, label, book, channel: declarationChannel({ catalogue, verdictType, questions }),
+    messages, generate, mode, retries, label, book, channel: declarationChannel({ catalogue, verdictType, questions, kinds }),
   });
   return { ...r, declaration: r.artifact };
 }
@@ -1923,6 +2173,23 @@ const confirmChannel = () => ({
  * 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 = 'THIS JOB HAS NO REPOSITORY. Its inputs are the person\'s own text files, and each numbered job line leaves ONE '
+  + 'file the run writes (output/steps/<line>.json: a "text" and, per input, quoted claims — or, for a line that finds, lists or '
+  + 'looks something up, only filled facts, each quoted from the input). In this build only three kinds of check exist: a COUNTED '
+  + 'limit on that text (words, lines, sections, words per section); a claim that must be backed by a quote copied from a named input; '
+  + 'and a REQUIRED FACT, something a line finds (a price, a date, a time, a name, a phrase) with a limit only if the person gave one '
+  + '— plan one fact check for each thing the line asks to find, including those named in the line itself ("SFO to LAX"). Plan a check '
+  + 'only for what the person asked for in those terms; '
+  + 'anything that needs reading the text to judge it (tone, quality, accuracy), any superlative ("the cheapest", "the best") and any '
+  + 'choice of WHICH ones ("the last", "the newest") goes in `notChecked`, in the person\'s own words; how MANY results were asked for is '
+  + 'a count and can be checked.\n'
+  + RUBRIC_RULES;
+
 export const CONFIRM_SYSTEM = 'You read what a NON-ENGINEER answered, plus a read-only survey or listing of their '
   + 'own repository, and draft a PLAN for a job\'s definition of done: the checks you plan to compose and one '
   + 'signed goal sentence. You never propose a check the numbered job lines (and the ~ rules written under them) did not ask for '
@@ -1974,6 +2241,9 @@ export function confirmPrompt({ answers, questions, labels = {}, facts = null, l
     lines.push('', `WORSE THAN BEFORE (a constraint the person named, repo jobs only): ${worseThanBefore}`);
   }
   lines.push('', `LANGUAGE: ${lang}`);
+  // PART 1a: a rubric job on the person's own text files. The model is told what a check CAN be here, so that anything
+  // needing judgement lands in `notChecked` instead of being promised as a check
+  if (lang === RUBRIC_LANG) lines.push('', RUBRIC_CONFIRM_NOTE);
   if (writeScope) lines.push(`WRITE SCOPE (the fence — the run may write only here): ${writeScope.join(', ')}`);
   if (protections.length > 0) {
     lines.push(
@@ -2026,7 +2296,8 @@ async function askConfirmPlan({ convo, generate, mode, book, label }) {
  *   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.
@@ -2048,6 +2319,8 @@ export async function runConfirmTurn({
   worseThanBefore: presetWorseThanBefore = '',
   // P7: the inputs the person pointed at; absent = the prompt is byte-identical
   inputs = null,
+  // PART 1a: the numbered job lines, so a rubric job's per-line file protections are listed from code
+  jobLines = null,
 }) {
   /** @typedef {null|'cap-halt'|'pricing-red'|'provider-red'|'artifact-red'|'confirm-abandoned'|'confirm-restart'} ConfirmStop */
   /** @returns {{ok: boolean, stop: ConfirmStop, rounds: number, accepted: null, reds: Red[], cost: any}} */
@@ -2073,7 +2346,7 @@ export async function runConfirmTurn({
   // the prompt below so the model can check `notChecked` against it, and
   // reused (never recomputed) after the call so the shown, prompted, and
   // recorded protections are always the exact same list.
-  const protections = confirmProtections({ verdictType, lang: resolvedLang, writeScope });
+  const protections = confirmProtections({ verdictType, lang: resolvedLang, writeScope, jobLines });
 
   // ── up to 2 paid rounds (ruling 5) ─────────────────────────────────────────
   /** @type {string|null} */
@@ -2265,7 +2538,7 @@ export async function runConfirmTurn({
  *   generate: Function, seedReadFn?: Function, closeCtx?: any,
  *   ceilingUsd?: number|null,
  *   onPhase?: (phase: string, data?: any) => void,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
  *   maxRevisions?: number, structureRetries?: number,
  *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>, writeScope?: string[]|null,
  *   priorCalls?: {label: string, costUsd: number|null, unpricedRounds: number}[]|null,
@@ -2308,12 +2581,15 @@ export async function authorClose({
   maxRevisions = MAX_REVISIONS,
   structureRetries = MAX_STRUCTURE_RETRIES,
   structuredMode = 'tool',
-  catalogue = KIND_CATALOGUE,
+  catalogue: catalogueIn = KIND_CATALOGUE,
   // P7 item 5 (fwdloop am25): OFF unless the caller can really ask the person (the panel). When on, ONLY the last of the
   // full drafting ladder (the author call plus both revisions), and only after the two before it both failed validation,
   // is offered the optional `questions` property — see `askOpen` below. Absent = byte-identical to today.
   offerQuestions = false,
 }) {
+  // PART 1a: the menu this close may draw from — a rubric job on local files sees its own two kinds, a code job never sees
+  // the rubric-only ones (`catalogueForLang`). Everything below (prompt, schema, validator, env) reads THIS one catalogue.
+  const catalogue = catalogueForLang(lang, catalogueIn);
   // TIGHTEN-ONLY: a caller may lower the ceiling, never raise it — unlimited
   // revising launders thrash as adaptation (addendum 5). The floor is zero: one
   // authoring call with no revise round is a legal ask, and a garbage value is
@@ -2431,7 +2707,7 @@ export async function authorClose({
     }], 'precheck');
   }
 
-  if (!GENRE_LANGUAGES.includes(lang)) {
+  if (!DECLARABLE_LANGUAGES.includes(lang)) {
     return refuse([{
       code: 'genre-unsupported',
       path: 'lang',
@@ -2473,9 +2749,20 @@ export async function authorClose({
   if (envProbe.reds.length) return refuse(envProbe.reds, 'precheck');
 
   // ── the grounded loop ─────────────────────────────────────────────────────
+  // PART 1c: a rubric job on files - the frozen input text the found-once check proves every word against, and the label lists code
+  // made from it (a label is PICKED from them, never typed). null = not a files job, or the freeze could not be read here.
+  /** @type {Record<string, string>|null} */
+  let inputTexts = null;
+  /** @type {string[]|null} */
+  let labelLists = null;
+  if (lang === RUBRIC_LANG && Array.isArray(inputs) && inputs.length > 0) {
+    const frozen = await readFrozenInputs(workdir, inputs.map((i) => i.label));
+    if (frozen.ok) { inputTexts = frozen.texts; labelLists = Object.values(labelListsOf(frozen.texts).lists); }
+  }
   const prompt = authorPrompt({
     answers, questions, facts, listingBlock: /** @type {string} */ (seeds.block),
     lang, verdictType, guards, ownedEnvNames, mode: structuredMode, catalogue, writeScope, confirmed, jobLines, inputs,
+    labelLists,
   });
   /** @type {any[]} */
   let messages = [{ role: 'user', content: prompt }];
@@ -2562,7 +2849,7 @@ export async function authorClose({
       // P7 item 5: a mechanism, never a wish. Only the last try of the full ladder carries the property, and only when the
       // two before it both failed (validation or the seed read; `questionLines` is set at the end of the second one, below).
       const askOpen = questionLines !== null && i === revisionCap;
-      const ask = await askDeclaration({ messages, generate, mode: structuredMode, retries: retryCap, label, book, catalogue, verdictType, questions: askOpen });
+      const ask = await askDeclaration({ messages, generate, mode: structuredMode, retries: retryCap, label, book, catalogue: catalogueIn, kinds: Object.keys(catalogue), verdictType, questions: askOpen });
       messages = ask.convo;
       /** @type {{reason: string, raw: any}[]} */
       let droppedQuestions = [];
@@ -2624,6 +2911,7 @@ export async function authorClose({
           iter.cutOff = true;
           if (nextTryMayAsk(i)) {
             questionLines = allLines.length ? allLines : null;
+            onPhase('author-try-failed', { call: label, i, of: revisionCap, reds: [scrubRed(/** @type {Red} */ (ask.red))] });
             const block = renderRejectBlock({ kind: 'artifact', reds: [/** @type {Red} */ (ask.red).detail] });
             messages = [...ask.convo, { role: 'assistant', content: '(the reply carried no text)' },
               { role: 'user', content: `${block}\n\n${structuredMode === 'tool' ? STRUCTURE_INSTRUCTION_TOOL : STRUCTURE_INSTRUCTION_TEXT}` }];
@@ -2652,7 +2940,15 @@ export async function authorClose({
       }
       previous = ask.declaration;
 
-      const v = validateDeclaration(ask.declaration, { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType, writeScope, jobLines });
+      // PART 1b: code puts the number tie on every prose step that follows a fact step, before anything is validated or signed
+      let v = validateDeclaration(withFactBindings(settlePersonsWords(ask.declaration, jobLines)), { catalogue, listing: seedFiles, guards, envOwned: ownedEnvNames, verdictType, writeScope, jobLines, inputLabels: inputLabelsOf(inputs) });
+      // PART 1c: code proves, at $0, that every label is PICKED from the input's own list and every word a fact depends on is really
+      // in the source (white-space blind, once is enough). A word that is not found is a red naming the word and the input; the
+      // drafter revises like it does for any validation red.
+      if (v.ok && lang === RUBRIC_LANG) {
+        const words = checkDeclarationWords(v.declaration, inputTexts);
+        if (words.length > 0) v = { ...v, ok: false, reds: [...v.reds, ...words], declaration: null };
+      }
       // SCRUBBED HERE, once, where the reds enter this module's records — the same
       // boundary rule `renderRejectBlock` already states, applied to the OTHER
       // channel they travel down. A validation red quotes what the model declared
@@ -2673,6 +2969,8 @@ export async function authorClose({
         // same channel and counts as a revision (addendum 5)
         measured = renderRejectBlock({ kind: 'validation', reds: vReds });
         tryFails[i] = { lines: linesNamedByReds(vReds, ask.declaration, (jobLines ?? []).map((l) => l.n)) };
+        // WHY this try was refused, for the drafting log and the progress line (the reds are already scrubbed)
+        onPhase('author-try-failed', { call: label, i, of: revisionCap, reds: vReds, declaration: ask.declaration });
       } else {
         // what gets MEASURED is what will RUN: the resolved declaration with the
         // genre's environment already injected
@@ -2703,6 +3001,16 @@ export async function authorClose({
         measuredIterations.push({ label, declaration: injected.declaration, seedRead: rows, droppedEnv: injected.dropped });
         const sf = seedReadFailure(rows, injected.declaration, guards.map((/** @type {any} */ g) => g.name), (jobLines ?? []).map((l) => l.n));
         tryFails[i] = sf.failed ? { lines: sf.lines } : null;
+        if (sf.failed) {
+          const guardNames = guards.map((/** @type {any} */ g) => g.name);
+          const stoppedNames = [...new Set(rows.filter((/** @type {any} */ r) => !guardNames.includes(r?.stage) && r?.verdict === 'instrument-stop').map((/** @type {any} */ r) => String(r.stage)))];
+          onPhase('author-try-failed', {
+            call: label, i, of: revisionCap, declaration: ask.declaration,
+            reason: stoppedNames.length
+              ? `a check could not run at the starting point (${stoppedNames.join(', ')})`
+              : 'no check was failing at the starting point, so none of them could tell a finished job from an unfinished one',
+          });
+        }
       }
 
       if (i === revisionCap) { stop = 'max-revisions'; break; }