bareloop 0.41.0 → 0.42.0

package/src/labelscan.js

@@ -0,0 +1,170 @@
+// THE LABEL LIST (PART 1c, docs/product/ITEM33-BUILD.md "3. The look", "LABELS ARE PICKED, NEVER TYPED"): before the look, code scans a
+// source at $0 and lists, per shape (money, number, date, time, text), the words that sit right before a value of that shape,
+// with how often each occurs. The look and the drafter pick a label ONLY from this list (by id or exact text); a label that is not on
+// it is a $0 red naming it. ONE generic scan for every page or file - there is no per-site table here and never will be.
+//
+// How a label is found (all of it plain string work, no model):
+//   - each line is cleaned (any run of white space, U+202F / U+00A0 included, becomes one space; bracketed tags like `[ref=549]` that a
+//     page reader adds are dropped);
+//   - values are found in a fixed order of shapes: date, time, money, number, and last `text` = any other token that holds a digit
+//     (a version like 0.41.0, an id). A value is only a place to look BEFORE: bareguard reads the real value at run time;
+//   - the words before a value are the text between the previous value on the line and this one, cut to its last one or two
+//     tokens (and the whole gap when it is short); a label holds no digit;
+//   - text facts also get the words before each REPEATED capitalised phrase (an airport, a city, a name): `Leaves` before one phrase,
+//     `arrives at` before another.
+// A label is listed when it occurs at least MIN_COUNT times. Nothing here decides what a label MEANS.
+
+/** the shapes a list is made for */
+export const LABEL_SHAPES = Object.freeze(['money', 'number', 'date', 'time', 'text']);
+/** a label must occur at least this often to be listed (1: a one-page document with one total still has its label; the list is cut to the highest counts) */
+export const MIN_COUNT = 1;
+/** how many labels one shape's list holds at most (the highest counts first) */
+export const MAX_PER_SHAPE = 40;
+/** the longest label, in characters */
+const MAX_LABEL = 40;
+/** the longest whole gap taken as a label when it is short */
+const MAX_GAP_LABEL = 24;
+/** a phrase must repeat this often to be a repeated phrase */
+const MIN_PHRASE = 3;
+/** how many repeated phrases are looked behind */
+const MAX_PHRASES = 20;
+/** a line is scanned up to this many characters, and for this many values (a minified page is one huge line; the bound keeps the scan linear) */
+const MAX_LINE = 20000;
+const MAX_VALUES_PER_LINE = 400;
+/** only this much of a source is scanned (a source over it is scanned up to a line end) */
+export const SCAN_MAX_CHARS = 2_000_000;
+
+const WS = /[\s   ]+/g;
+const TAG = /\[[A-Za-z]+=[^\]\s]*\]/g;
+const MONTH = '(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:t(?:ember)?)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)';
+/** value finders in priority order: an earlier shape owns a span a later one would also match */
+const FINDERS = /** @type {[string, RegExp][]} */ ([
+  ['date', new RegExp(`\\b\\d{4}-\\d{2}-\\d{2}\\b|\\b\\d{1,2}/\\d{1,2}/\\d{2,4}\\b|\\b${MONTH}\\.? \\d{1,2}(?:, \\d{4})?\\b|\\b\\d{1,2} ${MONTH}\\.? \\d{4}\\b`, 'g')],
+  ['time', /\b\d{1,2}:\d{2}(?: ?[AaPp]\.?[Mm]\.?)?(?![\w:])/g],
+  ['money', /[$€£] ?\d[\d,]*(?:\.\d+)?|\b\d[\d,]*(?:\.\d+)? ?(?:US dollars?|dollars?|USD|euros?|EUR|pounds?|GBP)\b/g],
+  ['number', /(?<![\w.,])\d[\d,]*(?:\.\d+)?(?![\w]|\.\d)/g],
+  ['text', /[A-Za-z]*\d[\w.\-]*/g],
+]);
+const PHRASE = /\b[A-Z][a-z]+(?: [A-Z][a-z]+)+\b/g;
+
+/** @typedef {{id: string, label: string, count: number, example: string}} LabelEntry */
+/** @typedef {Record<'money'|'number'|'date'|'time'|'text', LabelEntry[]>} LabelScan */
+
+/** @param {string} t @returns {string} white space made one space, quote marks at the edges dropped, trimmed - how a label is compared */
+export function normLabel(t) {
+  return String(t ?? '').replace(WS, ' ').trim().replace(/^["'“”]+|["'“”]+$/g, '').trim();
+}
+
+/** @param {string} gap @returns {string[]} the labels a gap of text before a value offers */
+function candidates(gap) {
+  const g = normLabel(gap);
+  if (g === '') return [];
+  const tokens = g.split(' ');
+  /** @type {Set<string>} */
+  const out = new Set();
+  out.add(normLabel(tokens.at(-1) ?? ''));
+  if (tokens.length >= 2) out.add(normLabel(tokens.slice(-2).join(' ')));
+  if (g.length <= MAX_GAP_LABEL) out.add(g);
+  return [...out].filter((c) => c !== '' && c.length <= MAX_LABEL && !/\d/.test(c) && !/ref=/.test(c));
+}
+
+/**
+ * Scan one source text for the labels that sit before values, per shape.
+ * @param {string} text
+ * @returns {LabelScan}
+ */
+export function scanLabels(text) {
+  let src = String(text ?? '');
+  if (src.length > SCAN_MAX_CHARS) { const nl = src.lastIndexOf('\n', SCAN_MAX_CHARS); src = src.slice(0, nl > 0 ? nl : SCAN_MAX_CHARS); }
+  /** @type {Record<string, Map<string, {count: number, example: string}>>} */
+  const seen = Object.fromEntries(LABEL_SHAPES.map((s) => [s, new Map()]));
+  const bump = (/** @type {string} */ shape, /** @type {string} */ label, /** @type {string} */ example) => {
+    const m = seen[shape];
+    const cur = m.get(label);
+    if (cur) cur.count += 1; else m.set(label, { count: 1, example });
+  };
+  /** @type {Map<string, number>} */
+  const phraseCount = new Map();
+  /** @type {string[]} */
+  const lines = [];
+  /** @type {{line: string, at: number, phrase: string}[]} */
+  const variants = [];
+  for (const raw of src.split('\n')) {
+    const line = raw.slice(0, MAX_LINE).replace(TAG, ' ').replace(WS, ' ').trim();
+    if (line === '') continue;
+    lines.push(line);
+    for (const m of line.matchAll(PHRASE)) {
+      // a capitalised run may start with a sentence-initial word ("Leaves San Francisco ..."): the run is also read without its first word
+      const words = m[0].split(' ');
+      let off = m.index ?? 0;
+      for (let j = 0; j <= 1 && words.length - j >= 2; j += 1) {
+        const phrase = words.slice(j).join(' ');
+        phraseCount.set(phrase, (phraseCount.get(phrase) ?? 0) + 1);
+        variants.push({ line, at: off, phrase });
+        off += words[j].length + 1;
+      }
+    }
+  }
+  for (const line of lines) {
+    /** @type {{shape: string, s: number, e: number, v: string}[]} */
+    const found = [];
+    for (const [shape, re] of FINDERS) {
+      for (const m of line.matchAll(re)) {
+        const s = m.index ?? 0;
+        const e = s + m[0].length;
+        if (found.length >= MAX_VALUES_PER_LINE) break;
+        if (found.some((f) => s < f.e && e > f.s)) continue;
+        found.push({ shape, s, e, v: m[0] });
+      }
+    }
+    found.sort((a, b) => a.s - b.s);
+    let prevEnd = 0;
+    for (const f of found) {
+      for (const c of candidates(line.slice(prevEnd, f.s))) bump(f.shape, c, f.v);
+      prevEnd = f.e;
+    }
+  }
+  // the words before each REPEATED capitalised phrase (a place, a name): text facts
+  const phrases = new Set([...phraseCount].filter(([, n]) => n >= MIN_PHRASE).sort((a, b) => b[1] - a[1]).slice(0, MAX_PHRASES).map(([p]) => p));
+  for (const v of variants) {
+    if (!phrases.has(v.phrase)) continue;
+    for (const c of candidates(v.line.slice(0, v.at))) bump('text', c, v.phrase);
+  }
+  /** @type {Record<string, string>} */
+  const prefix = { money: 'm', number: 'n', date: 'd', time: 't', text: 'x' };
+  return /** @type {LabelScan} */ (Object.fromEntries(LABEL_SHAPES.map((shape) => {
+    const rows = [...seen[shape]].filter(([, v]) => v.count >= MIN_COUNT)
+      .sort((a, b) => b[1].count - a[1].count || a[0].length - b[0].length || (a[0] < b[0] ? -1 : 1))
+      .slice(0, MAX_PER_SHAPE)
+      .map(([label, v], i) => ({ id: `${prefix[shape]}${i + 1}`, label, count: v.count, example: v.example }));
+    return [shape, rows];
+  })));
+}
+
+/**
+ * Is this label on the list for this shape? Compared the way a label is read: white space of any kind is one space, quote marks at the
+ * edges are dropped. `idOrText` may be a list id (`t1`) or the exact words.
+ * @param {LabelScan} scan @param {string} shape @param {unknown} idOrText
+ * @returns {LabelEntry|null}
+ */
+export function labelOnList(scan, shape, idOrText) {
+  const rows = scan[/** @type {'money'} */ (shape)];
+  if (!rows || typeof idOrText !== 'string') return null;
+  const asId = rows.find((r) => r.id === idOrText.trim());
+  if (asId) return asId;
+  const want = normLabel(idOrText);
+  return rows.find((r) => r.label === want) ?? null;
+}
+
+/**
+ * The list as the look and the drafter are shown it, one block per shape that has any label.
+ * @param {string} inputLabel the input the list belongs to @param {LabelScan} scan
+ * @returns {string}
+ */
+export function renderLabelList(inputLabel, scan) {
+  const blocks = LABEL_SHAPES.filter((s) => scan[/** @type {'money'} */ (s)].length > 0).map((s) => {
+    const rows = scan[/** @type {'money'} */ (s)].map((r) => `  ${r.id}  ${JSON.stringify(r.label)}  x${r.count}  e.g. ${JSON.stringify(r.example)}`);
+    return `${s} (the words right before a ${s === 'text' ? 'repeated phrase or an id/version' : s}):\n${rows.join('\n')}`;
+  });
+  return `LABELS IN THE INPUT "${inputLabel}" - pick a label ONLY from this list (by its id or its exact words); a label that is not here is refused:\n\n${blocks.length ? blocks.join('\n\n') : '(no repeated label was found before a value)'}`;
+}

package/src/pagefetch.js

@@ -0,0 +1,125 @@
+// URL inputs (PART 1c, docs/product/ITEM33-BUILD.md "4. URL inputs" + live fix L1, PRD item 33 RF21/RF22): an Inputs line may be a web
+// address the person pastes (a results page). bareloop fetches it with barebrowse, READ ONLY, headless and incognito, as published:
+//
+//     page = await connect({ incognito: true, blockPrivateNetwork: true })
+//     await page.goto(url); await page.waitForNetworkIdle({ idle, timeout }); await page.snapshot({ mode: 'act' })
+//
+// L1: one-shot `browse()` snapshots at load, before the page's own scripts fill a results list (the same URL gave 77,951 / 8,801 / 719
+// chars). So we wait for the network to go quiet (bounded) before the snapshot. Generic: no site selector. The snapshot mode is the one
+// proven in step 0 ('read' and 'full' returned almost nothing from a results page). The text that comes back is the input. An empty
+// fetch is a plain-words stop, never a silent empty input. Nothing here touches a model.
+
+import { SECRET_PATTERNS } from './validate.js';
+
+/** the session options (incognito: no auth ever enters; blockPrivateNetwork: SSRF guard); ONE frozen object so a test can pin them */
+export const CONNECT_OPTIONS = Object.freeze({ incognito: true, blockPrivateNetwork: true });
+/** the snapshot options step 0 proved */
+export const SNAPSHOT_OPTIONS = Object.freeze({ mode: 'act' });
+/** the page's network must be quiet this long (ms) before we read it: long enough to span the gap between a page's first load and the
+ *  script requests that fill the results, short enough not to stretch a plain page */
+export const NETWORK_IDLE_MS = 1500;
+/** the most we wait for the network to go quiet (ms); a page that never settles (polling, streaming) is read as it stands after this */
+export const NETWORK_IDLE_TIMEOUT_MS = 20_000;
+/** the most we wait for the page to load at all (ms) */
+export const GOTO_TIMEOUT_MS = 30_000;
+/** a page that comes back with fewer characters than this (after trimming) is treated as "nothing came back" */
+export const MIN_PAGE_CHARS = 200;
+/** the page text left after the site's own header, menus and footer are taken out must hold at least this many characters, or the page is
+ *  "only site chrome" (L2: a 719-character fetch of Google's header and sign-in passed the 200-character floor) */
+export const MIN_CONTENT_CHARS = 100;
+/** the page reader's landmark roles for a site's own chrome (the ARIA names of header, menu and footer); everything under one is not the page's content */
+const CHROME_ROLES = new Set(['banner', 'navigation', 'contentinfo']);
+/** our own deadline around one whole fetch (a hung browser leaves no trace; this is the only thing that fires on the absence of an answer) */
+export const PAGE_FETCH_TIMEOUT_MS = 90_000;
+
+/** @param {unknown} v @returns {boolean} an http(s) address (the one spelling of "this Inputs value is a web address") */
+export function isWebUrl(v) {
+  return typeof v === 'string' && /^https?:\/\//i.test(v.trim());
+}
+
+/**
+ * How much of a fetched page is the page's own content: the snapshot's header lines (url, size note, hint) and every part of the tree
+ * under a banner / navigation / contentinfo landmark are taken out, the page reader's bracketed tags are removed, and what is left is
+ * counted. Generic - no site names, only the ARIA landmark roles. Text that is not a snapshot tree (a plain file) has no landmark, so it
+ * counts whole.
+ * @param {string} text @returns {number}
+ */
+export function pageContentChars(text) {
+  const lines = String(text ?? '').split('\n');
+  let skipIndent = -1;
+  let n = 0;
+  let head = true;
+  for (const raw of lines) {
+    if (head && (/^url: /.test(raw) || /^[\d,]+ chars → /.test(raw) || /^hint: /.test(raw))) continue;
+    head = false;
+    const m = /^(\s*)- ([A-Za-z_]+)\b/.exec(raw);
+    const indent = m ? m[1].length : raw.length - raw.trimStart().length;
+    if (skipIndent >= 0) {
+      if (raw.trim() === '' || indent > skipIndent) continue;
+      skipIndent = -1;
+    }
+    if (m && CHROME_ROLES.has(m[2])) { skipIndent = indent; continue; }
+    n += raw.replace(/\[[A-Za-z]+=[^\]\s]*\]/g, ' ').replace(/^\s*-\s*/, '').replace(/\s+/g, ' ').trim().length;
+  }
+  return n;
+}
+
+/**
+ * @typedef {{goto: (url: string, timeout?: number) => Promise<void>, waitForNetworkIdle: (o?: {idle?: number, timeout?: number}) => Promise<void>,
+ *   snapshot: (o?: {mode?: string}) => Promise<string>, close: () => Promise<void>}} FetchPage the part of barebrowse's page handle the fetch uses
+ */
+
+/**
+ * Fetch one page's text. `connect` is injected (a test never reaches the network); the default is barebrowse's own `connect`.
+ * @param {string} url
+ * @param {{connect?: (opts: Record<string, any>) => Promise<FetchPage>, timeoutMs?: number, idleMs?: number, idleTimeoutMs?: number, closeWaitMs?: number}} [o]
+ * @returns {Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>} `error` is plain words, without a spend line
+ */
+export async function fetchPageText(url, { connect, timeoutMs = PAGE_FETCH_TIMEOUT_MS, idleMs = NETWORK_IDLE_MS, idleTimeoutMs = NETWORK_IDLE_TIMEOUT_MS, closeWaitMs = 3000 } = {}) {
+  let u;
+  try { u = new URL(url.trim()); } catch { return { ok: false, error: `${url} is not a web address bareloop can read` }; }
+  if (u.protocol !== 'http:' && u.protocol !== 'https:') return { ok: false, error: `${url} is not an http or https address` };
+  if (u.username !== '' || u.password !== '') return { ok: false, error: 'a web address with a user name or password in it is refused - bareloop reads a page with no credentials at all' };
+  if (SECRET_PATTERNS.some((re) => re.test(u.href))) return { ok: false, error: 'the web address carries a known secret shape - secrets never enter a job' };
+  /** @type {(opts: Record<string, any>) => Promise<FetchPage>} */
+  let open;
+  if (connect) open = connect;
+  else {
+    try { open = /** @type {any} */ ((await import('barebrowse')).connect); } catch (e) { return { ok: false, error: `the page reader (barebrowse) could not be loaded: ${/** @type {Error} */ (e).message}` }; }
+  }
+  /** @type {NodeJS.Timeout|undefined} */
+  let timer;
+  /** @type {Promise<FetchPage>|undefined} */
+  let opening;
+  try {
+    opening = open({ ...CONNECT_OPTIONS });
+    const page = opening;
+    const text = await Promise.race([
+      (async () => {
+        const p = await page;
+        await p.goto(u.href, GOTO_TIMEOUT_MS);
+        // bounded: a page that never goes quiet (polling, streaming) is read as it stands - the wait is for a page that is still filling
+        try { await p.waitForNetworkIdle({ idle: idleMs, timeout: idleTimeoutMs }); } catch { /* read what is there */ }
+        return p.snapshot({ ...SNAPSHOT_OPTIONS });
+      })(),
+      new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(`no answer inside ${Math.round(timeoutMs / 1000)} seconds`)), timeoutMs); }),
+    ]);
+    if (typeof text !== 'string') return { ok: false, error: `${u.href} did not come back as text` };
+    if (/\[BOT CHALLENGE DETECTED\]/.test(text)) return { ok: false, error: `${u.href} asked for a human check (a bot challenge), so the page could not be read` };
+    const size = text.trim().length;
+    if (size < MIN_PAGE_CHARS) return { ok: false, error: `${u.href} came back with ${size === 0 ? 'no text' : `only ${size} characters of text`} (less than ${MIN_PAGE_CHARS}) - the page did not load, or holds nothing to read` };
+    if (pageContentChars(text) < MIN_CONTENT_CHARS) return { ok: false, error: `${u.href} came back with only the site's own header and menus - the page did not load its content, so there is nothing to read` };
+    return { ok: true, text, url: u.href };
+  } catch (e) {
+    return { ok: false, error: `${u.href} could not be read: ${/** @type {Error} */ (e)?.message ?? String(e)}` };
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+    // always close the browser, also when the deadline fired while it was still starting or loading
+    if (opening) {
+      /** @type {NodeJS.Timeout|undefined} */
+      let w;
+      await Promise.race([opening.then((p) => p.close()).catch(() => {}), new Promise((r) => { w = setTimeout(r, closeWaitMs); })]);
+      if (w !== undefined) clearTimeout(w);
+    }
+  }
+}

package/src/panel/authorroutes.js

@@ -22,9 +22,10 @@ import { spawn as realSpawn } from 'node:child_process';
 import { openSync } from 'node:fs';
 import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
+import { planMatchesClose } from '../rubricstep.js';
 import { createSession, validateJobCard, validateReuseCard, lockedFieldChanged, buildReuseSpec, cardFields, STEP_LABELS } from './authorsession.js';
 import { parseInputs } from '../jobblock.js';
-import { proveInputFiles } from '../source.js';
+import { proveInputFiles, looksLikeRubricInput } from '../source.js';
 import { validateJob } from '../job.js';
 import { checkMonthlyRoom, monthlyRefusalText } from '../monthly.js';
 import { ConfigError } from '../config.js';
@@ -285,7 +286,10 @@ export function createAuthorRoutes(opts) {
       // A miss is a plain 400 naming the line, shown under the card exactly like every other refused start.
       const ip = parseInputs(card.inputs);
       if (!ip.ok) { send(400, { ok: false, error: ip.error }); return true; }
-      proveInputFiles(ip.inputs).then((proof) => {
+      // Part 1a: a rubric job whose first input is a local FILE has no repo to prove inputs against; the session proves every
+      // line itself (`proveRubricInputs`), at $0, before any model call
+      const filesJob = reuse === null && card?.checkType === 'rubric' && looksLikeRubricInput(ip.inputs[0].value);
+      (filesJob ? Promise.resolve(/** @type {{ok: true}} */ ({ ok: true })) : proveInputFiles(ip.inputs)).then((proof) => {
         if (!proof.ok) { send(400, { ok: false, error: proof.error }); return; }
         if (hasLiveSession()) { send(409, { ok: false, error: 'an authoring session is already live — one at a time' }); return; }
         const session = createSession(cardFields(card), {
@@ -393,6 +397,15 @@ export function signRun(session, claimedHash, o) {
     if (e instanceof ConfigError) return { ok: false, error: `${e.message} — refusing rather than guess the monthly limit` };
     return { ok: false, error: 'could not read the signed spec to check the monthly limit — refusing to sign' };
   }
+  // PART 1a, the sign-vs-run invariant: the checks on the plan card the person saw are exactly the checks of the close about to be
+  // signed, per line. A mismatch is refused in plain words and nothing is spawned.
+  if (session.state.finalPlan) {
+    try {
+      const spec = JSON.parse(readFileSync(session.state.resolvedSpecPath, 'utf8'));
+      const m = planMatchesClose(session.state.finalPlan.checkItems, spec.closeDecl);
+      if (!m.ok) return { ok: false, error: m.error };
+    } catch { return { ok: false, error: 'could not read the signed spec to compare it with the plan you were shown — refusing to sign' }; }
+  }
   const logFile = join(session.state.outDir, 'run.log');
   // array argv, never a shell string — `--approve <hash>` is a literal
   // element, checkable byte-for-byte by a test stubbing `spawnFn`, and there

package/src/panel/authorsession.js

@@ -27,7 +27,7 @@ import {
 } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import {
-  prepareSource, proveDestination, missingDependencies, looksLikeRepoSource, nearestGitAncestor, nonRepoSourceMessage,
+  prepareSource, proveDestination, proveRubricInputs, looksLikeRubricInput, missingDependencies, looksLikeRepoSource, nearestGitAncestor, nonRepoSourceMessage,
 } from '../source.js';
 import {
   worktreePath, uncommittedCount, shortHead, removeWorktree,
@@ -50,10 +50,12 @@ import {
 import { resolveJobJudge, defaultJudgeLoop } from '../judged.js';
 import { assertThinkingMode, thinkingPlanFor, thinkingRowText } from '../thinking.js';
 import { closeJudges } from '../kinds.js';
+import { RUBRIC_LANG } from '../authoring.js';
+import { rubricGoal, reconcileRubricPlan } from '../rubricstep.js';
 import { redactSecrets } from '../validate.js';
 import { tallyCalls } from '../text.js';
 import { writeDraftSpend, appendDraftLog } from '../draftspend.js';
-import { PLAIN_PROPOSAL_STOPS, proposalStopText, signingStopText, draftStopText, redsRecord, calibrationSummary } from '../authorreadout.js';
+import { PLAIN_PROPOSAL_STOPS, proposalStopText, signingStopText, draftStopText, redsRecord, declarationRecord, calibrationSummary, tryRefusedText } from '../authorreadout.js';
 import { runNpmCi, NPM_CI_LOCKS } from '../npminstall.js';
 import {
   parseJobBlock, parseInputs, jobBlockFitsCheck, renderJobLines, renderExamples, signedJobLines,
@@ -75,6 +77,7 @@ export const STEP_LABELS = Object.freeze({
   reuse: 'reusing signed workflow',
   read: 'reading repo',
   scout: 'scouting repo',
+  look: 'looking at your input',
   listing: 'listing files',
   confirm: 'confirming plan',
   draft: 'drafting',
@@ -84,6 +87,16 @@ export const STEP_LABELS = Object.freeze({
   signed: 'signed hash',
 });
 
+/**
+ * The same steps, worded for a job on the person's own local FILES (Part 1a): there is no worktree and no repo to read.
+ * Code-owned, one table beside STEP_LABELS; a step with no entry keeps its STEP_LABELS word.
+ * @type {Readonly<Record<string, string>>}
+ */
+export const FILE_JOB_STEP_LABELS = Object.freeze({
+  copy: 'copying input files',
+  read: 'reading input files',
+});
+
 /**
  * The library's own `onPhase(name, ...)` calls (`src/authorjob.js`/`src/authorflow.js`) -> the step each one advances.
  * A phase with no entry leaves the current step as it was.
@@ -101,6 +114,8 @@ export const PHASE_STEP = Object.freeze({
   seed: 'read',
   scout: 'scout',
   'scout-done': 'scout',
+  look: 'look',
+  'look-done': 'look',
   confirm: 'confirm',
   'confirm-turn-done': 'confirm',
   listing: 'listing',
@@ -127,12 +142,13 @@ export function latestStep(steps, id) {
  * earlier line keeps its status and detail). Existing lines are never moved. Re-starting the step that is still the
  * LAST line just resumes that line.
  * @param {StepLine[]} steps @param {string} id @param {string} [detail] (absent = keep what the line has)
+ * @param {Readonly<Record<string, string>>} [labels] the label table (a file job passes its own)
  */
-export function advanceSteps(steps, id, detail) {
+export function advanceSteps(steps, id, detail, labels = STEP_LABELS) {
   for (const x of steps) if (x.status === 'running' && x.id !== id) x.status = 'done';
   const last = steps.at(-1);
   if (last && last.id === id) { last.status = 'running'; if (detail !== undefined) last.detail = detail; return; }
-  steps.push({ id, label: STEP_LABELS[id] ?? id, status: 'running', detail: detail ?? '' });
+  steps.push({ id, label: labels[id] ?? id, status: 'running', detail: detail ?? '' });
 }
 
 /** source-door refusals that come from CHECKING the copied source (the scan/freeze), not from reaching it */
@@ -327,10 +343,13 @@ export function validateJobCard(card, opts = {}) {
   if (card.thinking !== undefined && typeof card.thinking !== 'boolean') return { ok: false, error: 'Thinking on must be on or off' };
   const jb = parseJobBlock(card.jobText);
   if (!jb.ok) return { ok: false, error: jb.error };
-  const misfit = jobBlockFitsCheck(jb.lines, checkType === 'rubric');
-  if (misfit) return { ok: false, error: misfit };
   const ib = parseInputs(card.inputs);
   if (!ib.ok) return { ok: false, error: ib.error };
+  // P1=B: PASS/FAIL examples are required of a rubric job only when it holds a judged part. A rubric on the person's own
+  // local files (first input not a repo) holds none in this build; a rubric on a repo composes the judged floor.
+  const rubricFiles = checkType === 'rubric' && looksLikeRubricInput(ib.inputs[0].value);
+  const misfit = jobBlockFitsCheck(jb.lines, checkType === 'rubric', { judged: !rubricFiles });
+  if (misfit) return { ok: false, error: misfit };
   if (typeof destination !== 'string' || destination.trim() === '') return { ok: false, error: 'Destination is required' };
   if (typeof capUsd !== 'number' || !Number.isFinite(capUsd) || capUsd <= 0) {
     return { ok: false, error: '$ cap is required and must be a positive number' };
@@ -346,7 +365,7 @@ export function validateJobCard(card, opts = {}) {
  * @param {any} card the validated job card (see {@link validateJobCard})
  * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,
  *   scout?: any, generate?: Function, confirmGenerate?: Function, authorFn?: Function,
- *   prepareSigningFn?: Function, npmCiFn?: Function, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
  *   TEST SEAMS ONLY — see the note just above where each is read, below. `reuse` (Reuse workflow) is NOT a seam: the
  *   caller (`/api/author/start`) sets it only when the server's own same-job rule held.
  * @returns {any} the session object
@@ -432,10 +451,13 @@ export function createSession(card, deps = {}) {
     });
   };
 
+  /** a rubric job on local files words its copy/read steps for files (set once the card is known) */
+  let fileJob = card.checkType === 'rubric' && looksLikeRubricInput(parseInputs(card.inputs).ok ? (/** @type {any} */ (parseInputs(card.inputs))).inputs[0].value : '');
   /** @param {string} id @param {string} [detail] (absent = keep what the step has) start (or restart) a step; whatever step was running is finished */
   const stepStart = (id, detail) => {
-    advanceSteps(state.steps, id, detail);
-    state.progressLabel = STEP_LABELS[id] ?? id;
+    const labels = fileJob ? { ...STEP_LABELS, ...FILE_JOB_STEP_LABELS } : STEP_LABELS;
+    advanceSteps(state.steps, id, detail, labels);
+    state.progressLabel = labels[id] ?? id;
     logSteps();
   };
   /** @param {string} id @param {string} detail set a step's latest line's detail without changing its status */
@@ -500,6 +522,7 @@ export function createSession(card, deps = {}) {
     return true;
   };
 
+  let lastTryRefused = false;
   const onPhase = (name, data = {}) => {
     // COLLAPSED INTO THE PROGRESS INDICATOR ONLY (build item 3) — this used
     // to also `say('system', `… ${name}`)`, one jargon chat bubble per
@@ -510,10 +533,24 @@ export function createSession(card, deps = {}) {
     // person needs to read; the step-by-step detail lives in one line.
     // ONE owner of the drafting line's detail (model + cap): the drafting line is started here, by the real author phase
     if (PHASE_STEP[name]) stepStart(PHASE_STEP[name], PHASE_STEP[name] === 'draft' ? `${card.model}, $${card.capUsd.toFixed(2)} cap` : undefined);
-    // a drafting call after the first (`author-call` i >= 1, of up to `of + 1`) is a RETRY: the line says so in plain words, so a
-    // long silence on call 2 of 3 does not read as a hang. The same one line, relabelled — never a second line.
+    // WHY a try was refused: the drafting log keeps it beside the call that made it (it used to say only "retry 3 of 3"), and the
+    // progress line shows it briefly, in code's words
+    if (name === 'author-try-failed') {
+      lastTryRefused = true;
+      const no = state.steps.findLastIndex((/** @type {any} */ x) => x.id === 'draft');
+      const reason = tryRefusedText(data);
+      appendDraftLog(outDir, {
+        kind: 'try-refused', no: no === -1 ? state.steps.length - 1 : no, call: String(data.call ?? ''), reason,
+        ...(Array.isArray(data.reds) && data.reds.length ? { reds: redsRecord(data.reds) } : {}), ...declarationRecord(data.declaration), at: new Date().toISOString(),
+      });
+      stepDetail('draft', `${data.call}: refused — ${reason.length > 160 ? `${reason.slice(0, 160)}…` : reason}`);
+    }
+    // a drafting call after the first (`author-call` i >= 1, of up to `of + 1`) is relabelled in plain words, so a long silence on call 2
+    // of 3 does not read as a hang. The loop drafts again after a try that PASSED too (the drafter sees its own seed-read), so
+    // "retry" is said only when the previous try was actually refused; otherwise it is "look". The same one line, never a second one.
     if (name === 'author-call' && Number.isInteger(data.i) && data.i >= 1 && Number.isInteger(data.of)) {
-      const label = `${STEP_LABELS.draft} (retry ${data.i + 1} of ${data.of + 1})`;
+      const label = `${STEP_LABELS.draft} (${lastTryRefused ? 'retry' : 'look'} ${data.i + 1} of ${data.of + 1})`;
+      lastTryRefused = false;
       stepLabel('draft', label);
       state.progressLabel = label;
     }
@@ -644,6 +681,9 @@ export function createSession(card, deps = {}) {
     const verdictType = card.checkType === 'rubric' ? 'soft-green' : 'green';
     const into = join(outDir, 'source-seed');
     const isRepoLike = looksLikeRepoSource(SOURCE);
+    // PART 1a: a RUBRIC job whose first input is not a repo works on the person's own local FILES — every numbered input
+    // line is one file, frozen by `proveRubricInputs`; there is no repo, no language and no scout (docs/product/ITEM33-BUILD.md)
+    const RUBRIC_FILES = card.checkType === 'rubric' && !isRepoLike;
     // hamr's ruling B (2026-10-05): ONE rule for both a fresh card and a reuse card, at $0, before the copy and any model call
     const destProblem = repoDestinationProblem(card.destination, isRepoLike);
     if (destProblem !== null) { refuse(destProblem); return; }
@@ -667,10 +707,21 @@ export function createSession(card, deps = {}) {
     // fence read as a directory and refused as "not absolute" — hiding the real problem with the Source. A scope-shaped
     // (relative) Destination is therefore handed to the door only when the source is repo-like.
     const destIsDir = isAbsoluteDestination(card.destination);
-    const prep = await prepareSource({
-      source: SOURCE, into, ...(isRepoLike || destIsDir ? { destination: card.destination } : {}),
-      ...(repoRoot === null ? {} : { worktree: worktreePath(repoRoot, id) }),
-    });
+    if (RUBRIC_FILES && !destIsDir) {
+      refuse('Destination must be the full path of a folder, like /home/me/out — the finished files are delivered there. Nothing spent.');
+      return;
+    }
+    /** @type {any} */
+    let prep;
+    if (RUBRIC_FILES) {
+      const proved = await proveRubricInputs({ inputs: INPUTS, into, destination: card.destination, ...(deps.fetchUrl ? { fetchUrl: deps.fetchUrl } : {}) });
+      prep = proved.ok ? proved.prep : { stop: proved.error, code: proved.code };
+    } else {
+      prep = await prepareSource({
+        source: SOURCE, into, ...(isRepoLike || destIsDir ? { destination: card.destination } : {}),
+        ...(repoRoot === null ? {} : { worktree: worktreePath(repoRoot, id) }),
+      });
+    }
     if (repoRoot !== null && prep.stop === null && prep.manifest?.worktree) madeWorktree = { repo: repoRoot, dir: prep.manifest.worktree };
     if (abandoned) dropWorktree();
     if (prep.stop !== null) {
@@ -682,7 +733,7 @@ export function createSession(card, deps = {}) {
     stepStart('check');
 
     const IS_REPO_SOURCE = prep.manifest.kind === 'repo';
-    let LANG = 'none-detected';
+    let LANG = RUBRIC_FILES ? RUBRIC_LANG : 'none-detected';
     /** @type {any} */
     let langResult = null;
     if (IS_REPO_SOURCE) {
@@ -741,7 +792,7 @@ export function createSession(card, deps = {}) {
         state.phase = 'drafting';
       }
     }
-    if (!IS_REPO_SOURCE) {
+    if (!IS_REPO_SOURCE && !RUBRIC_FILES) {
       refuse(nonRepoSourceMessage(prep.manifest.kind));
       return;
     }
@@ -874,7 +925,9 @@ export function createSession(card, deps = {}) {
       return;
     }
 
-    const writeScope = card.destination.split(/[,\n]/).map((s) => s.trim()).filter(Boolean);
+    // a rubric job on files writes only inside the hidden tree's own `output/`; its Destination is a drop-off folder
+    // (proven above, per run), never a fence
+    const writeScope = RUBRIC_FILES ? ['output/'] : card.destination.split(/[,\n]/).map((s) => s.trim()).filter(Boolean);
     /** @type {any} the confirm turn (below) fills `goal` in once accepted —
      * declared loosely rather than typed field-by-field, since this object's
      * own shape is a `job-v1` draft `validateJob` itself is the real
@@ -909,7 +962,8 @@ export function createSession(card, deps = {}) {
     /** @type {Record<string, string>} */
     const answers = { 1: renderJobLines(jobLines) };
     if (verdictType === 'soft-green') answers[SOFTGREEN_JUDGE_EXAMPLES_KEY] = renderExamples(jobLines);
-    const required = requiredAnswersFor(verdictType);
+    // a rubric job on files holds no judged part in this build, so the PASS/FAIL examples are not required of it
+    const required = RUBRIC_FILES ? [1] : requiredAnswersFor(verdictType);
     for (const n of required) {
       if (!answers[n]) { refuse(`the ${verdictType} check type needs ${required.length} answers and one is missing (key ${n})`); return; }
     }
@@ -973,8 +1027,10 @@ export function createSession(card, deps = {}) {
       rates: draftPrice?.rates ?? null,
       draftThinking,
       onPhase, onCall,
-      ask, answerQuestions, confirmGenerate, isRepo: true, langResult,
+      ask, answerQuestions, confirmGenerate, isRepo: !RUBRIC_FILES, langResult,
       ...(deps.scout ? { scout: deps.scout } : {}),
+      // PART 1c: a test that replaces the model boundary (`generate`) must not reach the real paid look; `deps.lookFn` brings its own
+      ...(deps.lookFn !== undefined ? { lookFn: deps.lookFn } : (deps.generate ? { lookFn: null } : {})),
       ...(authorFnOverride ? { authorFn: authorFnOverride } : {}),
     });
 
@@ -1008,13 +1064,34 @@ export function createSession(card, deps = {}) {
         : draftStopText({
           stop: String(authored.stop ?? 'authoring-failed'), reds: stopReds, refusal: authored.refusal,
           spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
+          wholeJob: RUBRIC_FILES,
         }), authored.stop === 'confirm-abandoned' ? 'abandoned' : 'refused');
       return;
     }
 
-    if (authored.confirmed?.goal) draft.goal = redactSecrets(String(authored.confirmed.goal));
+    if (RUBRIC_FILES) draft.goal = redactSecrets(rubricGoal({ jobLines, files: prep.manifest.inputs, confirmedGoal: authored.confirmed?.goal ?? null, closeDecl: authored.closeDecl }));
+    else if (authored.confirmed?.goal) draft.goal = redactSecrets(String(authored.confirmed.goal));
     const spec = assembleSpec(draft, { ...authored, verdictType: /** @type {string} */ (authored.verdictType) });
+    // PART 1a (run mv5bk400): the plan the person confirmed named three checks for line 1; the composer wrote ONE stage and put
+    // "lists 3 releases" in its notes, so the card promised a check the close never ran. The card AFTER drafting is now built
+    // from the close itself, and every confirmed check no part carries out is moved to Not checked, in code, before signing.
+    if (RUBRIC_FILES) {
+      const rec = reconcileRubricPlan({
+        confirmed: authored.confirmed?.checkItems ?? [], notChecked: authored.confirmed?.notChecked ?? [], closeDecl: spec.closeDecl, jobLines,
+      });
+      state.finalPlan = { goal: String(draft.goal ?? ''), checkItems: rec.checkItems, notChecked: rec.notChecked, protections: authored.confirmed?.protections ?? [], moved: rec.moved };
+    }
     await finish(spec, authored.seedRef);
+    if (state.finalPlan && state.phase === 'prepared') {
+      // The confirm turn's plan bubble (and a try-3 "answers are in" one) is the DRAFTER's wording of the checks, written before
+      // any close existed. Once the close is signed-ready its card is the only plan the person sees: the earlier ones are
+      // dropped, so drafter prose can never sit above (and be read instead of) the code's sentences (run mv5e1ktb).
+      state.messages = state.messages.filter((/** @type {any} */ m) => m.kind !== 'plan');
+      state.messages.push({
+        ...planMessage({ checkItems: state.finalPlan.checkItems, checks: state.finalPlan.checkItems.map((/** @type {any} */ c) => c.text), notChecked: state.finalPlan.notChecked, protections: state.finalPlan.protections, questions: [] }, jobLines),
+        text: 'These are the checks the signed close will run, and what it will not check. Sign & run to accept them, or Revise to edit the boxes and draft again.',
+      });
+    }
   }
 
   // fire-and-forget — the caller (src/panel/server.js) never awaits this; it