bareloop 0.41.0 → 0.43.0

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 */
@@ -182,6 +198,25 @@ export function jobNameTaken(name, opts = {}) {
   } catch { return false; }
 }
 
+/**
+ * The next free name for a NEW workflow made from `origin` (RULED 2026-10-15, v1.101): `<base>-N`, N the next free number from 2.
+ * Base: when the origin ends in `-<digits>` AND the part before it is itself a job (in the run list or jobs/), that part (so `x-2`
+ * suggests `x-3`, never `x-2-2`); else the origin's own name. Free = not a run-list job and not {@link jobNameTaken}.
+ * @param {string} origin
+ * @param {Iterable<string>} runJobs job names in the panel's run list
+ * @param {{jobsDir?: string}} [opts] test seam for {@link jobNameTaken}
+ * @returns {string}
+ */
+export function nextFreeJobName(origin, runJobs, opts = {}) {
+  const used = new Set(runJobs);
+  const m = /^(.+)-\d+$/.exec(origin);
+  const base = m && (used.has(m[1]) || jobNameTaken(m[1], opts)) ? m[1] : origin;
+  for (let n = 2; ; n += 1) {
+    const name = `${base}-${n}`;
+    if (!used.has(name) && !jobNameTaken(name, opts)) return name;
+  }
+}
+
 /** the form's fields, in card order — what `card.json` stores, verbatim (P5 item 3) */
 export const CARD_FIELDS = Object.freeze(['jobName', 'checkType', 'provider', 'model', 'thinking', 'jobText', 'inputs', 'destination', 'capUsd', 'maxWallMs']);
 
@@ -209,30 +244,25 @@ export function cardFields(card) {
 }
 
 /**
- * REUSE WORKFLOW (hamr 2026-10-03, replaces P5 item 3's same-job rule; Model opened 2026-10-04): a reuse card has exactly
- * FIVE open boxes — Inputs, Destination, Model, $ cap, Time cap — and every other box is the signed workflow, shown greyed and never
- * editable. The page greys them; THIS is what refuses (the server never trusts the page). Changing any locked box
- * is a different job: Clear the card, which drafts.
+ * REUSE WORKFLOW, ONE DOOR (RULED 2026-10-15, v1.101; replaces v1.88's five open boxes). Every box on the card is open. What decides
+ * the path is the CARD compared with the origin run's card, never the drafted spec: the JOB boxes are the job text (numbered lines,
+ * `~` rules, `~ PASS`/`~ FAIL`), the check type and the thinking tick. The RUN boxes (Inputs, Destination, Model, $ cap, Time cap)
+ * never decide it. A green origin with no job box changed reuses the signed plan verbatim (no drafting); anything else drafts.
  */
-export const REUSE_OPEN_FIELDS = Object.freeze(['inputs', 'destination', 'model', 'capUsd', 'maxWallMs']);
-/** every card field that is NOT open on a reuse card, in card order */
-export const REUSE_LOCKED_FIELDS = Object.freeze(CARD_FIELDS.filter((f) => !REUSE_OPEN_FIELDS.includes(f)));
-const REUSE_LABELS = Object.freeze(/** @type {Record<string, string>} */ ({
-  jobName: 'Job name', checkType: 'Check type', jobText: 'The job',
-}));
+export const JOB_BOXES = Object.freeze(['jobText', 'checkType', 'thinking']);
 
 /**
- * The first LOCKED box on `card` that differs from what the signed workflow prefilled (`origin`), or `null` when
- * every locked box is untouched. Blank and absent read alike; whitespace is not compared.
+ * Did any JOB box on `card` change from what the origin run prefilled (`origin`)? Whitespace is not compared (a one-line input drops
+ * a text's newlines); an absent thinking tick reads as off.
  * @param {Record<string, any>} card the form as it was submitted
  * @param {Record<string, any>} origin the form as the server prefilled it
- * @returns {string|null} the offending field's label
+ * @returns {boolean}
  */
-export function lockedFieldChanged(card, origin) {
-  // whitespace is ignored: a one-line <input> drops a goal's newlines, and the signed copy never takes text from the card anyway
-  const norm = (/** @type {any} */ v) => (v === undefined || v === null ? '' : (typeof v === 'string' ? v.replace(/\s+/g, '') : v));
-  const bad = REUSE_LOCKED_FIELDS.find((f) => norm(card?.[f]) !== norm(origin?.[f]));
-  return bad === undefined ? null : (REUSE_LABELS[bad] ?? bad);
+export function jobBoxesChanged(card, origin) {
+  const text = (/** @type {any} */ v) => (typeof v === 'string' ? v.replace(/\s+/g, '') : '');
+  return text(card?.jobText) !== text(origin?.jobText)
+    || (card?.checkType === 'rubric') !== (origin?.checkType === 'rubric')
+    || (card?.thinking === true) !== (origin?.thinking === true);
 }
 
 /**
@@ -251,7 +281,9 @@ export function lockedFieldChanged(card, origin) {
  */
 export function buildReuseSpec(originSpec, card, rows) {
   const spec = JSON.parse(JSON.stringify(originSpec));
-  spec.writeScope = String(card.destination ?? '').split(/[,\n]/).map((x) => x.trim()).filter(Boolean);
+  // an ABSOLUTE Destination is a per-run output folder (a plain-files job): it is never part of the signed spec, and the spec's own
+  // fence (inside the run's tree) stays as signed. A repo job's Destination is the fence and is relative (an absolute one is refused).
+  if (!isAbsoluteDestination(String(card.destination ?? '').trim())) spec.writeScope = String(card.destination ?? '').split(/[,\n]/).map((x) => x.trim()).filter(Boolean);
   const ip = parseInputs(card.inputs);
   if (ip.ok) spec.inputs = ip.inputs; else delete spec.inputs;
   spec.budgetUsd = card.capUsd;
@@ -294,6 +326,27 @@ const isAbsoluteDestination = (destination) => /^(\/|[a-zA-Z]:[\\/])/.test(desti
 
 export { nonRepoSourceMessage };
 
+/** the refusal for a plain-files rubric job whose Destination is not an absolute folder (ends with the words the session start shows) */
+export const FILES_DESTINATION_WORDS = 'Destination must be the full path of a folder, like /home/me/out — the finished files are delivered there. Nothing spent.';
+
+/**
+ * THE ONE Destination check of a session start, at $0, before any session, copy or model call. The session's own pipeline, the HTTP
+ * start (`startSession`), the schedule's two clicks and a scheduled fire's `wouldAccept` all call THIS (never a copy of it), so a start
+ * that would be refused for its Destination is refused before anything is made.
+ * @param {{inputs?: unknown, destination?: unknown, checkType?: unknown}} card the Inputs text (line 1 = the source), the Destination and the check type
+ * @returns {string|null} the plain refusal, or null when the Destination is fine
+ */
+export function startDestinationProblem(card) {
+  const ip = parseInputs(card?.inputs);
+  const source = ip.ok ? (ip.inputs[0]?.value ?? '') : '';
+  const destination = typeof card?.destination === 'string' ? card.destination : '';
+  const isRepoLike = looksLikeRepoSource(source);
+  const repo = repoDestinationProblem(destination, isRepoLike);
+  if (repo !== null) return repo;
+  if (card?.checkType === 'rubric' && !isRepoLike && !isAbsoluteDestination(destination)) return FILES_DESTINATION_WORDS;
+  return null;
+}
+
 /**
  * The ONE Destination rule for a REPO source (fresh card and Reuse card alike): there Destination is the write fence,
  * relative to the repo, so an absolute path is refused — at $0, before any copy or model call. A FOLDER source (or a
@@ -311,14 +364,14 @@ export function repoDestinationProblem(destination, isRepoLike) {
  * creates a session or spends anything — never inside the async pipeline,
  * so a bad card refuses synchronously, in the same HTTP response.
  * @param {any} card
- * @param {{jobsDir?: string, rows?: readonly import('../providerrows.js').KeyRow[]}} [opts] `rows` = the Settings rows (the Model menu); jobsDir is a server-side test seam — NEVER read off the client card
+ * @param {{jobsDir?: string, allowName?: string, rows?: readonly import('../providerrows.js').KeyRow[]}} [opts] `rows` = the Settings rows (the Model menu); jobsDir is a server-side test seam — NEVER read off the client card; `allowName` = the origin job's own name on an unchanged red Reuse (it is the same job, not a collision)
  * @returns {{ok: true}|{ok: false, error: string}}
  */
 export function validateJobCard(card, opts = {}) {
   if (!card || typeof card !== 'object') return { ok: false, error: 'missing job card' };
   const { jobName, checkType, model, destination, capUsd } = card;
   if (!isSlug(jobName)) return { ok: false, error: 'Job name must be a kebab-case slug (letters, digits, dashes)' };
-  if (jobNameTaken(jobName, { jobsDir: opts.jobsDir })) {
+  if (jobName !== opts.allowName && jobNameTaken(jobName, { jobsDir: opts.jobsDir })) {
     return { ok: false, error: `a job named "${jobName}" already exists — P3 is new jobs only (Q4=A)` };
   }
   if (checkType !== 'deterministic' && checkType !== 'rubric') return { ok: false, error: 'Check type must be deterministic or rubric' };
@@ -327,10 +380,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 +402,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 +488,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 +559,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 +570,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,8 +718,11 @@ 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);
+    const destProblem = startDestinationProblem(card);
     if (destProblem !== null) { refuse(destProblem); return; }
 
     state.phase = 'preparing-source';
@@ -667,10 +744,17 @@ 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) }),
-    });
+    /** @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 +766,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 +825,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 +958,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
@@ -892,7 +978,6 @@ export function createSession(card, deps = {}) {
       model: modelChoice.name,
       // the "Thinking on" tick is signed ONLY when ticked (unticked writes no field: the hash stays what it would have been)
       ...(card.thinking === true && draftThinkingPlan?.support !== false ? { thinking: true } : {}),
-      cadence: { unit: 'day', every: 1 },
       budgetUsd: card.capUsd,
       ...(typeof card.maxWallMs === 'number' ? { maxWallMs: card.maxWallMs } : {}),
       writeScope,
@@ -909,7 +994,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 +1059,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 +1096,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