bareloop 0.41.0 → 0.42.0

package/src/authoring.js

@@ -74,6 +74,7 @@
 
 import { normalizeParser, MAX_JUDGED_PATHS, JUDGED_FLOOR_KIND } from './kinds.js';
 import { JUDGE_RULE_IDS, validateCard } from './judged.js';
+import { rubricStepShapeReds, checkRubricParts, checkRubricRules } from './rubricstep.js';
 import { isObj, isNonEmptyString, hasNestedQuantifier, globToPrefix } from './validate.js';
 
 /** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
@@ -340,6 +341,36 @@ export const KIND_CATALOGUE = Object.freeze({
       + 'Name one card line per thing you actually look for, in the order you look for them, and name the real files the '
       + 'work lands in. It is never offered to the agent as an in-run check.',
   }),
+  // PART 1a (docs/product/ITEM33-BUILD.md, "Addendum 2026-10-12"): the rubric job on LOCAL FILES. One stage per numbered job
+  // line, reading the one file that line leaves behind (output/steps/N.json). It measures nothing with a command and buys
+  // nothing: bareguard's rubric primitive grades the file against the person's own counted limits and quotes. It exists only in
+  // the text genre's menu (`catalogueForLang`) — a code job never sees it. `parts` is the person's constraints on the line,
+  // each SORTED by the drafter into a class; only `countable` parts become checks, and the validator reds the rest in plain
+  // words (`checkRubricParts`), so no signed stage carries a part this build cannot run.
+  'rubric-step': Object.freeze({
+    verdictClass: 'green',
+    required: Object.freeze(['step', 'parts']),
+    optional: Object.freeze([]),
+    pathParams: Object.freeze([]),
+    shape: 'step: integer (the job line number), parts: [{text: string, class: "countable" | "fact" | "judged" | "guard" | "none", '
+      + 'check?: "maxWords" | "minWords" | "maxLines" | "sections" | "sectionWords" | "cited" | "minClaims" | "maxClaims", value?: integer, names?: string[], '
+      + 'wordsPerSection?: integer, source?: string (an input label), domains?: string[], covers?: integer[], rules?: integer[], '
+      + 'fact parts: facts?: [{name, shape: "money"|"number"|"date"|"time"|"phrase"|"text", unit?|currency?, phrase?, anchor?, until?, '
+      + 'rule?: {op, value | lo+hi}, aiProposal?: boolean}], count?: {min?, max?}}]',
+    asserts: 'the file output/<step>.json under output/steps/ exists, is a JSON object, and its "text" is present and within the '
+      + 'limits the person asked for. Write ONE rubric-step stage per numbered job line (step = that line number, fromLine = [that line]). '
+      + 'In "parts" list each constraint the person put on that line, in their own words, and SORT it: "countable" when a machine can '
+      + 'count it (check maxWords/minWords/maxLines with value; sections with names; sectionWords with names and wordsPerSection) or '
+      + 'when claims must be backed by a quote from a named input (check cited, source = the input label), or when a number of '
+      + 'quoted claims is asked for (minClaims / maxClaims with value and source: it counts the claims listed under that input); '
+      + 'a line that FINDS, LISTS or LOOKS UP something gets ONE part of class "fact" instead (source = the input label, '
+      + 'facts = the required facts, count = how many results): its step file holds only filled facts and no free text, so '
+      + 'give such a line no word, section or claim-count parts; list in "rules" the number of every ~ rule a part carries out; '
+      + 'on every countable part that carries out a CONFIRMED check, list that check\'s number in covers (a confirmed check no part '
+      + 'covers is moved to Not checked before signing); "judged" when only reading '
+      + 'it could decide; "guard" for a rule about web sources (domains); "none" when you cannot sort it. Never turn a part you cannot '
+      + 'count or quote into a countable one by guessing a number.',
+  }),
   // LIVE at N4 slice 1, and the ONLY kind that does not measure anything: it
   // does not RUN, it PAUSES the run and hands the tree to a person (ruling 1).
   // `ask` is the whole parameter surface — no cmd, no timeoutMs, no env — so a
@@ -381,6 +412,21 @@ export const LOCKED_KINDS = Object.freeze(CATALOGUE_KINDS.filter((k) => KIND_CAT
  * that the catalogue never names is a capability nothing can reach. */
 export const CATALOGUE_LIVE_KINDS = Object.freeze(CATALOGUE_KINDS.filter((k) => !KIND_CATALOGUE[k].locked));
 
+/**
+ * The catalogue a close of this language may use. A rubric job on local files (`RUBRIC_LANG`) sees only
+ * {@link RUBRIC_LANG_KINDS}; every code language sees the whole catalogue MINUS the rubric-only kinds, so a code job's
+ * composer, schema and validator can never reach for a stage that reads step files. One filter, both directions.
+ * @param {string|null|undefined} lang
+ * @param {Record<string, KindSpec>} [catalogue]
+ * @returns {Record<string, KindSpec>}
+ */
+export function catalogueForLang(lang, catalogue = KIND_CATALOGUE) {
+  const keep = lang === RUBRIC_LANG
+    ? (/** @type {string} */ k) => RUBRIC_LANG_KINDS.includes(k)
+    : (/** @type {string} */ k) => !RUBRIC_ONLY_KINDS.includes(k);
+  return Object.freeze(Object.fromEntries(Object.entries(catalogue).filter(([k]) => keep(k))));
+}
+
 export const DIRECTIONS = Object.freeze(['lower-is-better', 'higher-is-better']);
 /** D12: the close stores the COUNTING RULE, never the number. "seed" is measured
  * at this run's own seed every run; 0 is literally zero. A frozen constant (the
@@ -516,6 +562,28 @@ export const TYPES_GENRE_TEMPLATE = `1. The STRICT form of the language's type c
 
 export const GENRE_LANGUAGES = Object.freeze(['js', 'python']);
 
+/**
+ * PART 1a: the "language" of a RUBRIC job on local text files. It is not a code language and carries no suppression
+ * battery, no environment and no instruments — it only lets such a close declare which genre-shaped guards apply to it
+ * (`classGuards`) without pretending the file is JavaScript. `GENRE_LANGUAGES` stays the code-language menu (it is what a
+ * repo job's language detection and the confirm turn offer); this is the one extra value a close may DECLARE.
+ */
+export const RUBRIC_LANG = 'text';
+/** the genre label a close over local text files carries (`closeDecl.genre`); the code languages' is `TYPES_GENRE.name`. Never the other's. */
+export const TEXT_GENRE = 'TEXT';
+/** @param {unknown} lang @returns {string} the genre a close of this language is authored under */
+export function genreForLang(lang) { return lang === RUBRIC_LANG ? TEXT_GENRE : TYPES_GENRE.name; }
+/** every `closeDecl.lang` a close may declare: the code languages plus the rubric-files one */
+export const DECLARABLE_LANGUAGES = Object.freeze([...GENRE_LANGUAGES, RUBRIC_LANG]);
+/** the kinds that exist only for a rubric job on local files — a code job's menu, schema and validator never offer them */
+export const RUBRIC_ONLY_KINDS = Object.freeze(['rubric-step']);
+/** the whole kind menu of a rubric job on local files: the one machine guard that applies to a file tree, plus its own stage */
+export const RUBRIC_LANG_KINDS = Object.freeze(['files-changed', 'rubric-step']);
+/** the rubric-files language's data, all declared-empty (never an absent field that would read as "not looked into", F59) */
+const TEXT_LANGUAGE = Object.freeze({
+  suppressions: Object.freeze([]), extensions: Object.freeze([]), env: Object.freeze([]), instruments: Object.freeze([]),
+});
+
 /**
  * The js `any` suppression pattern's regex, ONE spelling: the TYPES js battery
  * below composes it into the signed guard, and `anySuppressionWarning` keys on
@@ -733,6 +801,7 @@ export const TYPES_GENRE = Object.freeze({
 
 /** @param {string} lang */
 function language(lang) {
+  if (lang === RUBRIC_LANG) return /** @type {any} */ (TEXT_LANGUAGE);
   const l = TYPES_GENRE.languages[/** @type {'js'|'python'} */ (lang)];
   // An unknown language THROWS rather than returning an empty battery: a genre
   // we have not admitted must not read as "this genre needs no guards" (F59's
@@ -858,7 +927,15 @@ export function classGuards({ verdictType, lang }) {
       + 'admission refuses it before any battery is built; a locked class must never resolve to an empty one');
   }
   const l = language(lang);
-  const guards = battery.guards.map((g) => {
+  // PART 1a: a rubric job on local TEXT files keeps every guard a machine can render over a file tree (`changed-from-seed`:
+  // something changed, and only inside the fence) and drops only the guards COMPOSED from a code language's tool data — a
+  // suppression scan over source code has nothing to scan in a text file, and composing it from no data would be the
+  // empty-guard hazard the throw below exists for. Only the soft-green battery has a text form.
+  if (lang === RUBRIC_LANG && String(verdictType) !== 'soft-green') {
+    throw new Error(`the "${RUBRIC_LANG}" genre is the rubric-files one: it carries a battery for soft-green only, not "${verdictType}"`);
+  }
+  const batteryGuards = lang === RUBRIC_LANG ? battery.guards.filter((g) => g.compose.length === 0) : battery.guards;
+  const guards = batteryGuards.map((g) => {
     /** @type {Record<string, any>} */
     const params = structuredClone(g.params);
     for (const p of g.compose) {
@@ -1199,7 +1276,8 @@ function readPath(p, dotted) {
  * @param {{catalogue?: Record<string, KindSpec>, listing?: string[]|null,
  *   guards?: {name: string, kind: string, params: Record<string, any>, fill: string[]}[]|null,
  *   envOwned?: string[]|null, envInjected?: Record<string, string>|null, deferListing?: boolean,
- *   verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} [opts]
+ *   verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null, inputLabels?: string[]|null}} [opts]
+ *   `inputLabels` — the labels of the person's inputs (Part 1a). Present, a rubric-step `cited` part must name one of them.
  *   `jobLines` — the person's numbered job lines (P7). Present, every stage must name the line it serves and every
  *     line needs a stage or a refusal ({@link checkJobLines}); absent (every spec that predates the job block), the
  *     rule is not run.
@@ -1221,7 +1299,7 @@ function readPath(p, dotted) {
 export function validateDeclaration(declaration, opts = {}) {
   const {
     catalogue = KIND_CATALOGUE, listing = null, guards = null, envOwned = null, envInjected = null,
-    verdictType = null, writeScope = null, jobLines = null,
+    verdictType = null, writeScope = null, jobLines = null, inputLabels = null,
   } = opts;
   const deferListing = opts.deferListing === true;
   /** @type {Red[]} */
@@ -1447,6 +1525,10 @@ export function validateDeclaration(declaration, opts = {}) {
 
   if (haveGuards) checkGuards({ declaration, guards: /** @type {any[]} */ (guards), red });
   checkJobLines({ declaration, stages, jobLines, guards: haveGuards ? /** @type {any[]} */ (guards) : [], red });
+  // PART 1a (R11): the sorting rules for the rubric-step stages — plain-words reds, judged and web parts refused in this build
+  checkRubricParts(stages, { inputLabels, red });
+  // PART 1b (RF16, RF17): every ~ rule is a check or Not checked; the AI's own numbers are marked and a time range is a range
+  checkRubricRules(stages, { jobLines, refused: declaration.refused, red });
 
   const ok = reds.length === 0;
   return { ok, reds, declaration: ok ? normalizeDeclaration(declaration) : null, grounded: haveListing, scoped, ceiling };
@@ -1489,15 +1571,15 @@ function checkJobLines({ declaration, stages, jobLines, guards, red }) {
   const refused = new Set();
   if (declaration.refused !== undefined) {
     if (!Array.isArray(declaration.refused)) {
-      red('invalid-value', 'refused', 'an array of {line, reason} — the job lines no stage can check, each with a reason');
+      red('invalid-value', 'refused', 'an array of {line, rule?, reason} — the job lines (or one ~ rule of a line) no stage can check, each with a reason');
     } else {
       declaration.refused.forEach((/** @type {any} */ r, /** @type {number} */ j) => {
         const at = `refused[${j}]`;
-        if (!isObj(r) || !Number.isInteger(r.line) || r.line < 1 || !isNonEmptyString(r.reason)) {
-          red('invalid-value', at, '{line, reason}: a job line number and a plain-words reason');
+        if (!isObj(r) || !Number.isInteger(r.line) || r.line < 1 || !isNonEmptyString(r.reason) || (Object.hasOwn(r, 'rule') && !(Number.isInteger(r.rule) && r.rule >= 1))) {
+          red('invalid-value', at, '{line, rule?, reason}: a job line number, optionally the number of one of its ~ rules, and a plain-words reason');
         } else if (known !== null && !known.includes(r.line)) {
           red('invalid-value', `${at}.line`, `refused line ${r.line}, but the job has lines ${known.join(', ')} only`);
-        } else refused.add(r.line);
+        } else if (!Object.hasOwn(r, 'rule')) refused.add(r.line);
       });
     }
   }
@@ -1689,6 +1771,9 @@ function checkKind({ kind, params: p, at, red, scoped, label, populations, envOw
       if (!strArray(p.allowPrefixes)) red('invalid-value', `${at}.params.allowPrefixes`, 'a non-empty array of path prefixes');
       if (p.requireNonEmpty !== true) red('invalid-value', `${at}.params.requireNonEmpty`, 'literally true');
       break;
+    case 'rubric-step':
+      for (const r of rubricStepShapeReds(p, `${at}.params`)) red(r.code, r.path, r.detail);
+      break;
     case 'human-confirms':
       // the whole surface: the question the signer answers. It is shown to a
       // person verbatim, so an empty one is a bare "approve?" — ruling 2's

package/src/authorjob.js

@@ -100,21 +100,25 @@
 
 import { jobSpecHash, validateJob } from './job.js';
 import { seedAtHead, seedListing, seedRead as runSeedRead, makeSeedTrees, judgedStages, closeJudges } from './kinds.js';
+import { inputLabelsOf, readFrozenInputs } from './rubricstep.js';
+import { proverOf } from './factwords.js';
 // SOFTGREEN modules 4 and 5 — the compile the interview's Q6/Q7 answers land in,
 // and the gate that decides whether the ruler they describe is a ruler.
 import { proposeJudgedArtifacts, signJudgedArtifacts, foldJudgedArtifacts } from './cardauthor.js';
 import { runCalibration } from './calibrate.js';
 import { CALIBRATION_SIZE } from './judged.js';
 import {
-  GENRE_LANGUAGES, LOCKED_KINDS, TYPES_GENRE, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES,
+  GENRE_LANGUAGES, RUBRIC_LANG, DECLARABLE_LANGUAGES, genreForLang, LOCKED_KINDS, TYPES_GENRE, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES,
   UNLISTED_CLASSES, MENU_CLASSES,
 } from './authoring.js';
 import {
   QUESTION_SETS, questionsFor, requiredAnswersFor, authorClose, makeCostBook,
-  runConfirmTurn, LANGUAGE_PICK_FIELD,
+  runConfirmTurn, LANGUAGE_PICK_FIELD, normalizeQuestions,
 } from './authorflow.js';
+import { ruleQuestions } from './inputlook.js';
 import { thinkingCallOptions, assertThinkingMode } from './thinking.js';
-import { runAuthorScout, buildSeedListing, SCOUT_ATTEMPTS } from './authorscout.js';
+import { pageContentChars } from './pagefetch.js';
+import { runAuthorScout, runInputLook, buildSeedListing, SCOUT_ATTEMPTS } from './authorscout.js';
 import {
   DECLARED_GAP_PREFIX, DECLARED_GENRES, guardNames, isDeclaredClose, validateCloseDecl,
 } from './declaredclose.js';
@@ -229,14 +233,14 @@ export function refusalEvents(refusal) {
  *     makes between a locked verdict and an invalid one).
  *
  * @param {{answers: Record<string|number, any>, verdictType?: string|null,
- *   repoPath?: string|null, questions?: Record<string|number, string>|null}} o
- *   `verdictType` and `repoPath` are STRUCTURED input from the UI, never parsed
+ *   repoPath?: string|null, questions?: Record<string|number, string>|null, required?: (string|number)[]|null}} o
+ *   `required` — the answer keys that must be present; absent = the picked class's whole set. `verdictType` and `repoPath` are STRUCTURED input from the UI, never parsed
  *   out of the prose of an answer: a class is picked off a radio and a path is
  *   read off the machine, or neither exists.
  * @returns {{ok: boolean, answers: Record<string|number, string>,
  *   verdictType: string|null, repoPath: string|null, refusal: Refusal|null, reds: Red[]}}
  */
-export function runInterview({ answers, verdictType = null, repoPath = null, questions = null }) {
+export function runInterview({ answers, verdictType = null, repoPath = null, questions = null, required: requiredOverride = null }) {
   /** @type {Red[]} */
   const reds = [];
   const out = (/** @type {Partial<any>} */ over) => ({
@@ -290,7 +294,8 @@ export function runInterview({ answers, verdictType = null, repoPath = null, que
   }
 
   const set = questions ?? questionsFor(picked);
-  const required = requiredAnswersFor(picked);
+  // PART 1a: a rubric job on local files asks one question (the job lines); the caller names the keys it needs
+  const required = Array.isArray(requiredOverride) ? requiredOverride : requiredAnswersFor(picked);
 
   if (!isObj(answers)) {
     reds.push({ code: 'missing-field', path: 'answers', detail: 'the interview answers, keyed by question number' });
@@ -424,7 +429,7 @@ function composerRefusal(reds) {
  *   rates?: {in: number, out: number}|null, draftThinking?: 'on'|'off',
  *   onPhase?: (phase: string, data?: any) => void,
  *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
- *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
+ *   seedFn?: Function, scoutFn?: Function, listingFn?: Function, lookFn?: Function|null,
  *   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,
@@ -465,6 +470,9 @@ export async function authorCloseForJob({
   // callback back, and no decision in this file or below it depends on one.
   onPhase = () => {}, onCall = () => {},
   seedFn = seedAtHead, scoutFn = runAuthorScout, listingFn = buildSeedListing,
+  // PART 1c - the look at a rubric job's inputs (src/authorscout.js `runInputLook`). `null` is an explicit "no look" (a test seam, like
+  // a caller-supplied `scout`); the shipped default is the real, paid, read-only look.
+  lookFn = runInputLook,
   authorFn = authorClose, authorOpts = {},
   // SOFTGREEN modules 4+5. `signerFix` is the D5 seam: a function (or a value)
   // carrying the SIGNER's corrected artifacts back. Absent means the proposal is
@@ -504,7 +512,10 @@ export async function authorCloseForJob({
     confirmed: null,
   };
 
-  const interview = runInterview({ answers, verdictType, repoPath, questions });
+  // PART 1a: a rubric job on local files has ONE question — the numbered job lines (the judge-example answer is required only
+  // of a job that holds a judged part, and this build admits none). The prompt shows just that question.
+  if (lang === RUBRIC_LANG) questions = { 1: questionsFor('soft-green')[1] };
+  const interview = runInterview({ answers, verdictType, repoPath, questions, ...(lang === RUBRIC_LANG ? { required: [1] } : {}) });
   base.interview = interview;
   if (!interview.ok) {
     return { ...base, refusal: interview.refusal, reds: interview.reds, stop: interview.refusal ? 'refused' : 'interview-incomplete' };
@@ -530,7 +541,7 @@ export async function authorCloseForJob({
     }
   }
 
-  if (!GENRE_LANGUAGES.includes(lang)) {
+  if (!DECLARABLE_LANGUAGES.includes(lang)) {
     // THE GENRE REFUSAL, at the composer. This used to be a plain wiring red;
     // under v1.57 §2 the interview no longer asks the user to confirm a genre, so
     // this is where "we can't run this kind of job yet" actually lands — and it
@@ -588,6 +599,34 @@ export async function authorCloseForJob({
   // arrived at by accident.
   /** @type {any} */
   let survey = scout;
+  // PART 1a: a rubric job on local files has no repository to survey. PART 1c: its survey is the LOOK - a read-only, bounded, paid
+  // look at the person's frozen input text that reports which facts can be checked and with which label (picked from a code-made
+  // list). Without a look (`lookFn` null, or no model boundary) the survey is just the numbered inputs, known to code at $0.
+  if (survey == null && lang === RUBRIC_LANG) {
+    const inputList = (Array.isArray(inputs) ? inputs : []).map((i) => ({ n: i.n, label: i.label }));
+    const frozen = lookFn && provider && Array.isArray(jobLines) && jobLines.length > 0 && inputList.length > 0
+      ? await readFrozenInputs(workdir, inputList.map((i) => i.label)) : null;
+    if (frozen !== null && !frozen.ok) {
+      survey = { state: 'ABSENT', reason: `the look at your input could not start: ${frozen.why}`, cause: 'call-failed', budgetStop: null, calls: [], raws: [], facts: null };
+    } else if (frozen !== null && lookFn && !Object.values(frozen.texts).some((t) => pageContentChars(t) > 0)) {
+      // L2: an input with nothing in it (empty, or only a site's header and menus) is never looked at and never asked about - there is
+      // nothing to check a rule against. Plain words, before any model call.
+      survey = { state: 'ABSENT', reason: 'your input holds nothing to read (it is empty, or only the site\'s own header and menus) - nothing was asked and nothing was spent', cause: 'call-failed', budgetStop: null, calls: [], raws: [], facts: null };
+    } else if (frozen !== null && lookFn) {
+      onPhase('look', {});
+      const lookCallOptions = thinkingCallOptions(provider, draftThinking);
+      survey = await lookFn({
+        texts: frozen.texts, inputs: inputList, jobLines, provider, ceilingUsd, onCall, prove: proverOf(frozen.texts), ...(rates ? { rates } : {}),
+        ...(Object.keys(lookCallOptions).length ? { callOptions: lookCallOptions } : {}),
+      });
+      onPhase('look-done', { state: survey?.state ?? null, facts: survey?.facts?.look?.facts?.length ?? 0 });
+    } else {
+      survey = {
+        state: 'PRESENT', reason: null, cause: null, budgetStop: null, calls: [], raws: [],
+        facts: { rubricFiles: true, inputs: inputList },
+      };
+    }
+  }
   // `== null` and not `!survey`: this is the `??` these two lines replaced, kept
   // exactly — a caller-supplied survey is used whatever it is, and only an
   // ABSENT one is paid for.
@@ -606,6 +645,22 @@ export async function authorCloseForJob({
     onPhase('scout-done', { state: survey?.state ?? null, facts: Object.keys(survey?.facts ?? {}).length });
   }
 
+  // PART 1c, I1 (hamr 2026-10-13): the look found that the person's intent on a particular `~` rule was NOT captured (its words or
+  // meaning are not in the source) - ask about THAT rule at once, before any plan or draft is paid for. The question gate is the
+  // existing one (`answerQuestions`: answer required, no skip, the answer becomes a `~` rule on its line; `normalizeQuestions` keeps
+  // at most MAX_QUESTIONS, each on a line the look named). Everything else the look could not find asks nothing piecemeal.
+  if (answerQuestions && lang === RUBRIC_LANG && survey?.state === 'PRESENT' && Array.isArray(survey.facts?.look?.notFound) && Array.isArray(jobLines)) {
+    const candidates = ruleQuestions(survey.facts.look.notFound, jobLines);
+    const kept = normalizeQuestions(candidates, [...new Set(candidates.map((q) => q.line))]);
+    if (kept.kept.length > 0) {
+      onPhase('look-ask', { questions: kept.kept.length });
+      const updated = await answerQuestions({ questions: kept.kept, dropped: kept.dropped, confirmed: null });
+      if (updated === null) return { ...base, interview, verdictType: picked, seedRef: seed, reds: [], stop: 'confirm-abandoned', cost: null };
+      jobLines = updated.jobLines;
+      interview.answers = updated.answers;
+    }
+  }
+
   // ── THE CONFIRM TURN'S PAID HALF (PRD item 33 M3 piece 4) ──────────────────
   // Slotted between the scout and the listing: it reuses the scout's own
   // survey (ruling 4 — never a second read of the source) and needs nothing
@@ -622,7 +677,9 @@ export async function authorCloseForJob({
   let confirmPriorCalls = [];
   /** @type {any[]} */
   let confirmPriorRaws = [];
-  if (ask && isRepo && survey?.state === 'PRESENT') {
+  // PART 1a (hamr's ruling 1A): a rubric job on local files runs the SAME confirm turn a repo job does — the survey is the
+  // numbered inputs (synthetic, above), and the protections it shows come from code, never the model
+  if (ask && (isRepo || lang === RUBRIC_LANG) && survey?.state === 'PRESENT') {
     if (typeof confirmGenerate !== 'function') {
       throw new Error('[authorjob] authorCloseForJob was given `ask` for a repo job but no `confirmGenerate` — the '
         + 'confirm turn needs its OWN model boundary (bound to CONFIRM_SYSTEM), never the authoring `generate` '
@@ -645,7 +702,7 @@ export async function authorCloseForJob({
     onPhase('confirm', {});
     const confirm = await runConfirmTurn({
       verdictType: picked, answers: interview.answers, questions: questions ?? questionsFor(picked),
-      facts: survey.facts, listing: null, writeScope, isRepo, lang, worseThanBefore, inputs,
+      facts: survey.facts, listing: null, writeScope, isRepo, lang, worseThanBefore, inputs, jobLines,
       generate: confirmGenerate, book: confirmBook, ask, onPhase,
     });
     // DISTINCT from `runConfirmTurn`'s own per-round 'confirm-done' (fired once
@@ -696,7 +753,9 @@ export async function authorCloseForJob({
     answers: stageAnswers, questions: questions ?? questionsFor(picked),
     scout: survey, listing: seeds, generate, ceilingUsd, onPhase, onCall, writeScope,
     priorCalls: confirmPriorCalls, priorRaws: confirmPriorRaws, confirmed, jobLines, inputs,
-    ...(answerQuestions ? { offerQuestions: true } : {}),
+    // PART 1c: a rubric job asks nothing piecemeal on a failed try - it stops, and the person reviews the whole job (the one early
+    // ask is about a `~` rule the look could not find, above)
+    ...(answerQuestions && lang !== RUBRIC_LANG ? { offerQuestions: true } : {}),
     ...authorOpts,
   });
   // P7 item 5: the drafter, on the last try after two failed ones, asked. The person answers (required, no skip); each
@@ -752,7 +811,7 @@ export async function authorCloseForJob({
   // `prepareSigning`, which refuses there.
   /** @type {any} */
   let closeDecl = {
-    genre: GENRE,
+    genre: genreForLang(lang),
     lang,
     stages: authored.declaration.stages,
     ...(Object.keys(applied).length ? { genreEnv: { ...applied } } : {}),
@@ -770,7 +829,7 @@ export async function authorCloseForJob({
     // P7: the job lines the drafter could not turn into a stage, each with its reason — the Job tab shows them. Free
     // text the model wrote, so it rides the same redactor `notes` does.
     ...(authored.declaration.refused?.length
-      ? { refused: authored.declaration.refused.map((/** @type {any} */ r) => ({ line: r.line, reason: redactSecrets(String(r.reason)) })) }
+      ? { refused: authored.declaration.refused.map((/** @type {any} */ r) => ({ line: r.line, ...(Number.isInteger(r.rule) ? { rule: r.rule } : {}), reason: redactSecrets(String(r.reason)) })) }
       : {}),
   };
 
@@ -1301,7 +1360,7 @@ export async function prepareSigning({
   }
   // the class rides from the SPEC (PRD v1.57 §2) — gate 1a already refused a spec
   // whose class is unknown or locked, so this is the class D5's battery hangs off
-  const dv = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: spec.verdictType, writeScope: spec.writeScope, jobLines: Array.isArray(spec.jobLines) ? spec.jobLines : null });
+  const dv = validateCloseDecl(spec.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: spec.verdictType, writeScope: spec.writeScope, jobLines: Array.isArray(spec.jobLines) ? spec.jobLines : null, inputLabels: inputLabelsOf(spec.inputs) });
   // the grounded gate's reds quote BOTH untrusted sources — the declaration, and
   // the seed listing itself (the listing rule names what really sits beside an
   // invented path). The listing half is a channel gate 1a structurally cannot
@@ -1348,8 +1407,11 @@ export async function prepareSigning({
     stops: stops.map((s) => ({ stage: s.stage, gap: s.gap })),
   };
   if (stops.length) {
+    // M2: a rubric job's readout never uses the code-job wording ("install, build and test commands")
+    const rubricJob = (Array.isArray(spec.closeDecl?.stages) ? spec.closeDecl.stages : []).some((/** @type {any} */ st) => st && (st.kind === 'rubric-step' || st.kind === 'judged-floor'));
     const reds = stops.map((s) => ({
       code: 'broken-close',
+      ...(rubricJob ? { rubricJob: true } : {}),
       path: `closeDecl.stages.${s.stage}`,
       detail: s.gap.join('\n') || `stage "${s.stage}" rendered no judgment`,
     }));

package/src/authorreadout.js

@@ -313,9 +313,12 @@ export function phaseLine(phase, data = {}) {
     case 'seed': return '· reading the seed commit…';
     case 'scout': return `· scout running (up to ${data.attempts ?? '?'} attempt(s)) — a real survey over the repository…`;
     case 'scout-done': return `· scout ${data.state ?? 'unknown'} — ${data.facts ?? 0} fact(s)`;
+    case 'look': return '· looking at your input — a read-only search for the facts the job asks for…';
+    case 'look-done': return `· look ${data.state ?? 'unknown'} — ${data.facts ?? 0} fact(s) can be checked`;
     case 'listing': return '· listing the files the declaration may name…';
     case 'listing-done': return `· listing ${data.stop ? `STOPPED (${data.stop})` : `${data.files ?? 'unknown'} file(s)`}`;
     case 'author': return '· authoring the close declaration…';
+    case 'author-try-failed': return `·   ${data.call} refused — ${tryRefusedText(data)}`;
     case 'author-call': return `· ${data.call} (call ${(data.i ?? 0) + 1} of up to ${(data.of ?? 0) + 1})…`;
     case 'seed-read': return `· measuring ${data.stages ?? '?'} stage(s) at the seed — each one runs a real toolchain…`;
     case 'stage': return `·   ${data.stage} [${data.kind}] ${data.verdict} — ${ms(data.durationMs)}`;
@@ -405,6 +408,14 @@ const PLAIN_MAX_BULLETS = 8;
 const RECORD_MAX_REDS = 40;
 const RECORD_STR_MAX = 600;
 
+/** a code-written sentence that carries the person's own words (a rubric-step sorting red): scrubbed and one line, bounded wide enough to stay whole
+ * @param {unknown} s @returns {string} */
+function fullText(s) {
+  // every caller renders a drafting refusal AFTER a model call was paid; a red text written for the $0 front doors ends "Nothing spent." — false here
+  const one = redactSecrets(String(s ?? '')).replace(/\s+/g, ' ').trim().replace(/\s*Nothing spent\.$/, '');
+  return one.length > 400 ? `${one.slice(0, 400)}…` : one;
+}
+
 /** model-derived text in a person-facing line: scrubbed, one line, bounded
  * @param {unknown} s @returns {string} */
 function safeText(s) {
@@ -417,6 +428,25 @@ function safeText(s) {
  * @typedef {{kind: string, sentence: string, red: PlainRed}} PlainReason
  */
 
+/** a shape red on a rubric-step stage's own parameters (live fix B3): invalid-value / missing-field at `stages[n].params.step|parts…` */
+const isRubricShape = (/** @type {PlainRed} */ r) => (r.code === 'invalid-value' || r.code === 'missing-field') && /^stages\[\d+\]\.params\.(step|parts)\b/.test(r.path);
+
+/**
+ * The plain sentence for a shape red on a rubric-step: WHERE (stage, part, fact, field — counted from 1, the way the plan card shows
+ * them) and WHAT is wrong, in the red's own detail. Code-worded, secret-scrubbed.
+ * @param {PlainRed} r @returns {string}
+ */
+function rubricShapeSentence(r) {
+  const m = /^stages\[(\d+)\]\.params\.(.*)$/.exec(r.path);
+  const where = [`stage ${Number(m?.[1] ?? 0) + 1}`];
+  for (const seg of (m?.[2] ?? '').split('.').filter(Boolean)) {
+    const idx = /^(parts|facts)\[(\d+)\]$/.exec(seg);
+    if (idx) where.push(`${idx[1] === 'parts' ? 'part' : 'fact'} ${Number(idx[2]) + 1}`);
+    else if (seg !== 'parts' && seg !== 'facts') where.push(`field "${safeText(seg)}"`);
+  }
+  return `The model's check for a job line is not shaped right (${where.join(', ')}): ${fullText(r.detail).replace(/\.$/, '')}.`;
+}
+
 /**
  * The ONE table of plain kinds → sentence builders. A builder gets the red, the
  * name of the case it lands on (when it lands on one) and the match of the
@@ -440,6 +470,9 @@ const PLAIN_TABLE = [
     say: (r) => `Rubric line ${cardLineNo(r)} uses a rule that an earlier line already uses.` },
   { kind: 'card-line-no-text', when: (r) => r.code === 'invalid-value' && /^card item \d+: needs `text`/.test(r.detail),
     say: (r) => `Rubric line ${cardLineNo(r)} has no wording.` },
+  // Part 1b live fix B3: the rubric-step reds are whole sentences already (src/rubricstep.js); a shape red on its parameters is worded here
+  { kind: 'rubric-red', when: (r) => r.code.startsWith('rubric-'), say: (r) => fullText(r.detail) },
+  { kind: 'rubric-shape', when: isRubricShape, say: (r) => rubricShapeSentence(r) },
   { kind: 'proposal-not-object', when: (r) => r.code === 'invalid-value' && r.path === 'proposal',
     say: () => 'The model\'s answer was not a rubric plus practice cases.' },
   // ── the practice-case set as a whole ──
@@ -544,6 +577,47 @@ function spendText(spend) {
   return `${spend.spendComplete === false ? 'at least ' : ''}${moneyText(spend.knownUsd)}`;
 }
 
+/**
+ * WHY one drafting try was refused, in the code's own words: the unique `detail` of each red it raised (the same sentences
+ * `draftStopText` quotes at a stop), else the plain `reason` the loop gave (a seed-read failure raises no red). Scrubbed,
+ * one line, bounded; never empty.
+ * @param {{reds?: PlainRed[]|null, reason?: string|null}} o
+ * @returns {string}
+ */
+export function tryRefusedText({ reds = null, reason = null }) {
+  const said = [...new Set((Array.isArray(reds) ? reds : []).map((r) => fullText(r?.detail)).filter(Boolean))];
+  if (said.length === 0 && reason) said.push(fullText(reason));
+  if (said.length === 0) return 'no reason was recorded';
+  const text = said.slice(0, 3).join('; ') + (said.length > 3 ? `; …and ${said.length - 3} more` : '');
+  return text.length > 600 ? `${text.slice(0, 600)}…` : text;
+}
+
+/** the most characters of a refused declaration the drafting log keeps (a bigger one is kept as cut text, said so) */
+const DECLARATION_RECORD_MAX = 60000;
+
+/**
+ * A refused declaration as the drafting log keeps it (live fix A3), so a failed draft can be read and replayed at $0: the declaration
+ * itself, every secret masked as everywhere else (the JSON text goes through `redactSecrets`, then parses back), and bounded.
+ * @param {unknown} declaration
+ * @returns {{declaration: unknown}|{declarationText: string, declarationCut: true}|{}} nothing when there is no declaration
+ */
+export function declarationRecord(declaration) {
+  if (declaration === undefined || declaration === null) return {};
+  let text;
+  try { text = redactSecrets(JSON.stringify(declaration)); } catch { return {}; }
+  if (typeof text !== 'string') return {};
+  if (text.length > DECLARATION_RECORD_MAX) return { declarationText: text.slice(0, DECLARATION_RECORD_MAX), declarationCut: true };
+  try { return { declaration: JSON.parse(text) }; } catch { return { declarationText: text, declarationCut: true }; }
+}
+
+/** one red as a line of a stop message: a rubric red is a whole sentence already, a rubric shape red is worded by code, any other is bounded
+ * @param {any} r @returns {string} */
+function said1(r) {
+  const red = /** @type {PlainRed} */ ({ code: String(r?.code ?? ''), path: String(r?.path ?? ''), detail: String(r?.detail ?? '') });
+  if (red.code.startsWith('rubric-')) return fullText(red.detail);
+  return isRubricShape(red) ? rubricShapeSentence(red) : safeText(red.detail);
+}
+
 /** the stops this module explains in plain words */
 export const PLAIN_PROPOSAL_STOPS = Object.freeze(['proposal-invalid', 'rubric-invalid']);
 
@@ -582,10 +656,11 @@ const SCOUT_REASON_RE = /^the survey is [^(]*\((.*)\) — an absent facts/s;
 
 /**
  * @param {{stop: string, reds?: PlainRed[]|null, refusal?: {detail?: string}|null,
- *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null}} o
+ *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null, wholeJob?: boolean}} o `wholeJob` - a rubric job on the person's
+ *   own inputs (PART 1c, I1): a failed draft asks nothing piecemeal; the person reviews the whole job and submits it again
  * @returns {string}
  */
-export function draftStopText({ stop, reds = null, refusal = null, spend = null }) {
+export function draftStopText({ stop, reds = null, refusal = null, spend = null, wholeJob = false }) {
   const spent = spendText(spend);
   /** @type {Record<string, string>} */
   const heads = {
@@ -596,7 +671,7 @@ export function draftStopText({ stop, reds = null, refusal = null, spend = null
     'max-revisions': 'The AI used all its tries without a plan that passed the checks.',
     precheck: 'Drafting stopped before any call: something it needs was missing.',
     unchanged: 'Drafting stopped: the AI sent the same plan twice.',
-    'scout-absent': 'Drafting stopped: the first look at your repo did not complete.',
+    'scout-absent': 'Drafting stopped: the first look at your repo or input did not complete.',
   };
   const redList = Array.isArray(reds) ? reds : [];
   // F217: the first look at the repo failing (a dropped connection, a timeout) arrives as a `precheck` stop with a
@@ -608,7 +683,7 @@ export function draftStopText({ stop, reds = null, refusal = null, spend = null
   const said = scoutRed
     ? [SCOUT_REASON_RE.exec(String(scoutRed.detail ?? ''))?.[1]
       ?.replace(/\s+/g, ' ').trim().slice(0, 240) ?? safeText(scoutRed.detail)].map((x) => redactSecrets(x)).filter(Boolean)
-    : [...new Set(redList.map((r) => safeText(r?.detail)).filter(Boolean))];
+    : [...new Set(redList.map((r) => said1(r)).filter(Boolean))];
   if (said.length === 0 && refusal?.detail) said.push(safeText(refusal.detail));
   const lines = [`${head} Spent so far: ${spent ?? 'unknown'}.`];
   if (said.length) {
@@ -616,7 +691,9 @@ export function draftStopText({ stop, reds = null, refusal = null, spend = null
     for (const x of said.slice(0, PLAIN_MAX_BULLETS)) lines.push(` • ${x}`);
     if (said.length > PLAIN_MAX_BULLETS) lines.push(` • …and ${said.length - PLAIN_MAX_BULLETS} more.`);
   }
-  lines.push(stop === 'cap-halt' || stop === 'pricing-red' ? 'What to do: raise the cap or fix the price in Settings, then draft again.' : 'What to do: draft again.');
+  lines.push(stop === 'cap-halt' || stop === 'pricing-red'
+    ? 'What to do: raise the cap or fix the price in Settings, then draft again.'
+    : (wholeJob ? 'What to do: review the whole job - every line and its ~ rules, and the inputs - and submit it again.' : 'What to do: draft again.'));
   return lines.join('\n');
 }
 
@@ -716,6 +793,10 @@ const SIGNING_TABLE = [
     say: () => ['The judge model could not be reached or was cut off while the practice cases were graded. Nothing says the rubric is wrong.'], todo: 'try again in a few minutes' },
   { kind: 'artifact-red', when: (r) => r.code === 'artifact-red',
     say: () => ['The judge model answered with something bareloop could not read while the practice cases were graded. Nothing says the rubric is wrong.'], todo: 'try again' },
+  // M2: a rubric job's check has no install/build/test commands to blame — its own wording, never the code-job one
+  { kind: 'broken-close-rubric', when: (r) => r.code === 'broken-close' && r.rubricJob === true,
+    say: (r) => [`A check of the close (${safeText(r.path.split('.').pop() ?? '')}) could not run, so nothing it reported could be trusted.`],
+    todo: 'draft again; if it fails the same way, report the check named above' },
   { kind: 'broken-close', when: (r) => r.code === 'broken-close',
     say: (r) => [`A check of the close (${safeText(r.path.split('.').pop() ?? '')}) cannot run on this repository, so nothing it reported could be trusted.`],
     todo: 'check that the project\'s tools (its install, build and test commands) run, then try again' },
@@ -726,6 +807,9 @@ const SIGNING_TABLE = [
   { kind: 'judged-outside-fence', when: (r) => r.code === 'judged-outside-write-scope',
     say: (r) => [`The rubric check looks at ${listText(r.outside)}, but the job may only edit ${listText(r.fence)} — so the run could never fix what it finds.`],
     todo: 'draft again' },
+  // Part 1a: the rubric-step sorting reds are already whole sentences in the person's words (src/rubricstep.js `checkRubricParts`)
+  { kind: 'rubric-part', when: (r) => r.code.startsWith('rubric-'), say: (r) => [fullText(r.detail)], todo: 'draft again, or reword that line' },
+  { kind: 'rubric-shape', when: isRubricShape, say: (r) => [rubricShapeSentence(r)], todo: 'draft again, or reword that line' },
   { kind: 'declaration', when: (r) => DECLARATION_CODES.includes(r.code) && !(r.code === 'invalid-value' && r.path === 'card'),
     say: (r) => [`The close the model wrote was refused before anything ran ("${safeText(r.code)}" at ${safeText(r.path)}).`], todo: 'draft again' },
 ];