bareloop 0.38.0 → 0.40.0

package/src/panel/authorroutes.js

@@ -13,7 +13,7 @@
 // The SIGN route additionally requires the EXACT `specHash` from that
 // session's own `signing.json` (never trusted from the request body alone
 // without that check) — a mismatch, a missing gate, or a session not yet
-// `prepared` all refuse. No other route in this file (start/send/revise/
+// `prepared` all refuse. No other route in this file (start/send/
 // sign-prepare) can reach the sign path — `signRun` is the only function
 // here that ever calls `spawnFn`.
 
@@ -23,6 +23,8 @@ import { openSync } from 'node:fs';
 import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { createSession, validateJobCard, validateReuseCard, lockedFieldChanged, buildReuseSpec, cardFields, STEP_LABELS } from './authorsession.js';
+import { parseInputs } from '../jobblock.js';
+import { proveInputFiles } from '../source.js';
 import { validateJob } from '../job.js';
 import { checkMonthlyRoom, monthlyRefusalText } from '../monthly.js';
 import { ConfigError } from '../config.js';
@@ -274,15 +276,23 @@ export function createAuthorRoutes(opts) {
         const v = validateJobCard(card, { jobsDir: opts.jobsDir, rows });
         if (!v.ok) { send(400, { ok: false, error: v.error }); return true; }
       }
-      const session = createSession(cardFields(card), {
-        env: envNow(), sessionsRoot: opts.sessionsRoot, ...(opts.home !== undefined ? { home: opts.home } : {}), ...(reuse ? { reuse } : {}),
-      });
-      sessions.set(session.id, session);
-      send(200, { ok: true, sessionId: session.id, reuse: reuse !== null, state: session.state });
+      // P7: the Inputs are proven at $0 before a session (so before any token): line 1 the repo, lines 2+ tracked files inside it.
+      // 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) => {
+        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), {
+          env: envNow(), sessionsRoot: opts.sessionsRoot, ...(opts.home !== undefined ? { home: opts.home } : {}), ...(reuse ? { reuse } : {}),
+        });
+        sessions.set(session.id, session);
+        send(200, { ok: true, sessionId: session.id, reuse: reuse !== null, state: session.state });
+      }).catch((e) => { send(500, { ok: false, error: `could not check the inputs: ${/** @type {Error} */ (e)?.message ?? e}` }); });
       return true;
     }
 
-    const m = /^\/api\/author\/([A-Za-z0-9]+)(\/(send|revise|sign-prepare|sign|check-deps|abandon))?$/.exec(pathname);
+    const m = /^\/api\/author\/([A-Za-z0-9]+)(\/(send|sign-prepare|sign|check-deps|abandon))?$/.exec(pathname);
     if (!m) { send(404, { ok: false, error: 'not found' }); return true; }
     const session = sessions.get(m[1]);
     if (!session) { send(404, { ok: false, error: 'no such session' }); return true; }
@@ -300,10 +310,6 @@ export function createAuthorRoutes(opts) {
       send(r.ok ? 200 : 400, { ...r, state: session.state });
       return true;
     }
-    if (sub === 'revise') {
-      session.revise(String(body?.text ?? '')).then((r) => send(r.ok ? 200 : 400, { ...r, state: session.state }));
-      return true;
-    }
     if (sub === 'abandon') {
       const r = session.abandon();
       send(r.ok ? 200 : 400, { ...r, state: session.state });

package/src/panel/authorsession.js

@@ -42,17 +42,22 @@ import {
 import { prepareSigning } from '../authorjob.js';
 import { checkCloseByteSignature } from '../close-integrity.js';
 import {
-  questionsFor, requiredAnswersFor, makeLoopGenerate, CONFIRM_SYSTEM,
+  questionsFor, requiredAnswersFor, makeLoopGenerate, CONFIRM_SYSTEM, SOFTGREEN_JUDGE_EXAMPLES_KEY,
 } from '../authorflow.js';
 import {
-  resolveProvider, buildRunnerProviders, apiKeyProblem,
+  resolveProvider, buildRunnerProviders, apiKeyProblem, assertDraftThinking, draftThinkingFor,
 } from '../providers.js';
 import { resolveJobJudge, defaultJudgeLoop } from '../judged.js';
 import { closeJudges } from '../kinds.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 { runNpmCi, NPM_CI_LOCKS } from '../npminstall.js';
+import {
+  parseJobBlock, parseInputs, jobBlockFitsCheck, renderJobLines, renderExamples, signedJobLines,
+} from '../jobblock.js';
+import { planFromConfirm } from './jobplan.js';
 
 /**
  * THE PROGRESS LIST's one table (hamr 2026-10-04, "one place showing all"): every pipeline step the left Chat panel
@@ -61,6 +66,7 @@ import { runNpmCi, NPM_CI_LOCKS } from '../npminstall.js';
  * @type {Readonly<Record<string, string>>}
  */
 export const STEP_LABELS = Object.freeze({
+  thinking: 'thinking',
   setup: 'checking setup',
   copy: 'making worktree',
   check: 'checking source',
@@ -104,6 +110,20 @@ export const PHASE_STEP = Object.freeze({
   'rubric-scrubbed': 'calibrate',
 });
 
+/**
+ * The first drafting row's words (hamr 2026-10-11) — code-owned, one owner, ALWAYS starting "thinking on" or "thinking off".
+ * `sent` is what the drafting calls carry (`draftThinkingFor`); `thoughtAnyway` = a call reported `thinkingApplied === false`
+ * after 'off' was sent (bare-agent saw reasoning in the reply).
+ * @param {'on'|'off'|'not-switchable'|'unverified'} sent @param {boolean} [thoughtAnyway]
+ * @returns {string}
+ */
+export function thinkingRowText(sent, thoughtAnyway = false) {
+  if (sent === 'off') return thoughtAnyway ? 'thinking on (the model thought anyway)' : 'thinking off';
+  if (sent === 'on') return 'thinking on';
+  if (sent === 'not-switchable') return "thinking on (this model can't turn it off)";
+  return 'thinking on (not verified for this model)';
+}
+
 /** @typedef {{id: string, label: string, status: 'running'|'done'|'failed', detail: string}} StepLine */
 
 /** @param {StepLine[]} steps @param {string} id the LATEST line carrying this id (the list is a time-ordered log; an id can repeat) */
@@ -132,13 +152,23 @@ const SOURCE_CHECK_CODES = new Set([
   'source-file-oversize', 'source-changed-after-scan', 'source-untracked-in-repo',
 ]);
 
-/** the confirm turn's own fixed round cap (`src/authorflow.js`'s
- * `runConfirmTurn`: `for (let round = 1; round <= 2; round += 1)`) — named
- * here, once, rather than re-guessed at every `onPhase('confirm-round')`
- * below. Not itself exported from the library as a named constant (it is
- * the loop bound the confirm turn's own doc calls "D3" / "ruling 5"); this is
- * this file's one place that would need editing if that cap ever changed. */
-const CONFIRM_ROUND_CAP = 2;
+/** the line under the plan bubble, in plain words (the bubble itself is drawn by the page's one `renderJobPlan`) */
+export const PLAN_FOOTER = 'Sign & run to confirm this plan, or Revise to edit the boxes and draft again.';
+
+/**
+ * The confirm turn's plan as a chat message (P7): a STRUCTURED `{role:'bot', kind:'plan', plan}` the page draws with the
+ * same renderer the Job tab uses — each numbered job line, its `~` rule, its drafted checks folded; the AI's own "not
+ * checked"; the always-on guards. `questions` (what the plan still asks) ride inside the plan. One owner of the shape.
+ * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[]}} p the confirm turn's plan
+ * @param {{n: number, text: string, rule: string}[]|null} jobLines
+ * @returns {{role: 'bot', kind: 'plan', text: string, plan: ReturnType<typeof planFromConfirm> & {goal: string, questions: string[]}}}
+ */
+export function planMessage(p, jobLines) {
+  return {
+    role: 'bot', kind: 'plan', text: PLAN_FOOTER,
+    plan: { ...planFromConfirm(jobLines, p), goal: String(p.goal ?? ''), questions: [...(p.questions ?? [])] },
+  };
+}
 
 /** @param {string} name @returns {boolean} kebab-case slug, same rule `job.js`'s `SLUG_RE` enforces */
 function isSlug(name) {
@@ -164,7 +194,18 @@ export function jobNameTaken(name, opts = {}) {
 }
 
 /** the form's fields, in card order — what `card.json` stores, verbatim (P5 item 3) */
-export const CARD_FIELDS = Object.freeze(['jobName', 'checkType', 'model', 'goal', 'source', 'destination', 'success', 'guardrails', 'judgeExamples', 'capUsd', 'maxWallMs']);
+export const CARD_FIELDS = Object.freeze(['jobName', 'checkType', 'model', 'jobText', 'inputs', 'destination', 'capUsd', 'maxWallMs']);
+
+/**
+ * The repo a card names: Inputs line 1 (P7 — the Source box is gone; the first input IS the repo). `''` when the Inputs
+ * box does not parse (the card validator refuses that before anything uses this).
+ * @param {any} card
+ * @returns {string}
+ */
+export function cardSource(card) {
+  const p = parseInputs(card?.inputs);
+  return p.ok ? p.inputs[0].value : '';
+}
 
 /**
  * Only the form's own fields, nothing else a request body might carry (`startFrom`, stray keys).
@@ -180,15 +221,15 @@ 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 — Source, Destination, Model, $ cap, Time cap — and every other box is the signed workflow, shown greyed and never
+ * 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.
  */
-export const REUSE_OPEN_FIELDS = Object.freeze(['source', 'destination', 'model', 'capUsd', 'maxWallMs']);
+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', goal: 'Goal', success: 'Success', guardrails: 'Guardrails', judgeExamples: 'Judge examples',
+  jobName: 'Job name', checkType: 'Check type', jobText: 'The job',
 }));
 
 /**
@@ -207,12 +248,12 @@ export function lockedFieldChanged(card, origin) {
 
 /**
  * The spec a reuse signs: a COPY of the origin's signed spec with ONLY the open fields set from the card —
- * `writeScope` from Destination, `budgetUsd` from the $ cap, `maxWallMs` from the Time cap (absent when blank), and the
+ * `writeScope` from Destination, `inputs` from the Inputs box (P7), `budgetUsd` from the $ cap, `maxWallMs` from the Time cap (absent when blank), and the
  * worker (`provider`/`baseUrl`/`model`) from the Model Name chosen in Settings > Providers, spelled exactly as normal
  * authoring spells it (`baseUrl` only when the row has one; `model` only when the Name is not the provider's default
  * tier). A RUBRIC (soft-green) origin with no explicit `judge` first has its judge pinned to the ORIGIN's resolved judge
  * identity — the judge must not change because the worker did (`resolveJobJudge`, the one spelling); an explicit
- * `judge` is kept; a deterministic job has no judge to move. Source is not in a spec (it lives beside the run). The copy
+ * `judge` is kept; a deterministic job has no judge to move. The repo (Inputs line 1) is in a spec only as `inputs`. The copy
  * hashes to a NEW `jobSpecHash` and the SAME `workflowKey` — the caller checks the second after building.
  * @param {any} originSpec
  * @param {Record<string, any>} card
@@ -222,6 +263,8 @@ 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);
+  const ip = parseInputs(card.inputs);
+  if (ip.ok) spec.inputs = ip.inputs; else delete spec.inputs;
   spec.budgetUsd = card.capUsd;
   if (typeof card.maxWallMs === 'number' && Number.isFinite(card.maxWallMs) && card.maxWallMs > 0) spec.maxWallMs = card.maxWallMs;
   else delete spec.maxWallMs;
@@ -238,7 +281,7 @@ export function buildReuseSpec(originSpec, card, rows) {
 
 /**
  * `$0` validation for a REUSE start: the signed job carries the goal, checks and guardrails, so those boxes are not
- * required here — only what the new session itself needs: a Source, a Destination, a Model that is a Settings Name,
+ * required here — only what the new session itself needs: Inputs, a Destination, a Model that is a Settings Name,
  * and the cap. (The spec built from the open boxes is validated by the route with `validateJob`.)
  * @param {any} card
  * @param {{rows?: readonly import('../providerrows.js').KeyRow[]}} [opts]
@@ -247,7 +290,8 @@ export function buildReuseSpec(originSpec, card, rows) {
 export function validateReuseCard(card, opts = {}) {
   if (!card || typeof card !== 'object') return { ok: false, error: 'missing job card' };
   if (!modelChoiceFor(opts.rows ?? [], card.model)) return { ok: false, error: 'Model must be one of the Names in Settings > Providers' };
-  if (typeof card.source !== 'string' || card.source.trim() === '') return { ok: false, error: 'Source is required' };
+  const ip = parseInputs(card.inputs);
+  if (!ip.ok) return { ok: false, error: ip.error };
   if (typeof card.destination !== 'string' || card.destination.trim() === '') return { ok: false, error: 'Destination is required' };
   if (typeof card.capUsd !== 'number' || !Number.isFinite(card.capUsd) || card.capUsd <= 0) {
     return { ok: false, error: '$ cap is required and must be a positive number' };
@@ -265,7 +309,7 @@ export { nonRepoSourceMessage };
  * relative to the repo, so an absolute path is refused — at $0, before any copy or model call. A FOLDER source (or a
  * source that does not peek as a repo) keeps today's behaviour: its Destination is an absolute output directory.
  * @param {string} destination
- * @param {boolean} isRepoLike `looksLikeRepoSource(card.source)`
+ * @param {boolean} isRepoLike `looksLikeRepoSource(cardSource(card))`
  * @returns {string|null} the plain refusal, or null when the Destination is fine
  */
 export function repoDestinationProblem(destination, isRepoLike) {
@@ -282,19 +326,20 @@ export function repoDestinationProblem(destination, isRepoLike) {
  */
 export function validateJobCard(card, opts = {}) {
   if (!card || typeof card !== 'object') return { ok: false, error: 'missing job card' };
-  const { jobName, checkType, model, goal, source, destination, success, guardrails, capUsd } = 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 })) {
     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' };
   if (!modelChoiceFor(opts.rows ?? [], model)) return { ok: false, error: 'Model must be one of the Names in Settings > Providers' };
-  for (const [field, label] of [[goal, 'Goal'], [source, 'Source'], [destination, 'Destination'], [success, 'Success'], [guardrails, 'Guardrails']]) {
-    if (typeof field !== 'string' || field.trim() === '') return { ok: false, error: `${label} is required` };
-  }
-  if (checkType === 'rubric' && (typeof card.judgeExamples !== 'string' || card.judgeExamples.trim() === '')) {
-    return { ok: false, error: 'Judge examples is required for a rubric (soft-green) check type' };
-  }
+  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 };
+  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' };
   }
@@ -304,25 +349,36 @@ export function validateJobCard(card, opts = {}) {
 /**
  * ONE session's engine — created already RUNNING (the caller awaits nothing;
  * the pipeline drives itself, reporting through `state`). `state.pendingAsk`
- * is the ONE thing a person answers next; `answer()`/`send()`/`revise()`/
+ * is the ONE thing a person answers next; `answer()`/`send()`/
  * `signPrepare()` are the only ways in.
  * @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, reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, 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
  */
 export function createSession(card, deps = {}) {
   const env = deps.env ?? process.env;
+  // The drafter's THINKING knob ('on' | 'off'): an explicit operator option, never read from env and not in the panel UI. A bad
+  // value throws here, before a session exists. Default 'off' (hamr ruling 2026-10-11, after the paid ON/OFF contrast).
+  const draftThinking = assertDraftThinking(deps.draftThinking ?? 'off');
+  // P7: the person's own words, parsed ONCE by the one parser (src/jobblock.js). The card validator refused a malformed
+  // block before a session exists; a reuse card's job text is the origin's and is not drafted from.
+  const jobParsed = parseJobBlock(card.jobText);
+  const jobLines = jobParsed.ok ? jobParsed.lines : [];
+  const inputsParsed = parseInputs(card.inputs);
+  const INPUTS = inputsParsed.ok ? inputsParsed.inputs : [];
+  /** the repo — Inputs line 1 */
+  const SOURCE = INPUTS[0]?.value ?? '';
   const sessionsRoot = deps.sessionsRoot ?? join(process.env.HOME ?? '/tmp', '.config', 'bareloop', 'panel-sessions');
   // config.json lives beside the sessions dir (~/.config/bareloop) unless a home is injected
   const configHome = deps.home ?? dirname(sessionsRoot);
   const timeoutMs = deps.timeoutMs ?? 300_000;
   // TEST SEAMS ONLY (never set by `src/panel/authorroutes.js`'s real caller):
   // override the declaration composer and/or `prepareSigning` itself so a
-  // test can drive the REAL confirm turn / ask() channel / revise-round /
+  // test can drive the REAL confirm turn / ask() channel /
   // hash-matching machinery this file owns, without also re-running (and
   // re-proving) `authorClose`'s own composer ladder or `prepareSigning`'s own
   // gates — both already have their own test suites. Absent, both default to
@@ -342,7 +398,6 @@ export function createSession(card, deps = {}) {
     messages: /** @type {{role: string, text: string}[]} */ ([]),
     pendingAsk: /** @type {any} */ (null),
     cost: /** @type {any} */ (null),
-    revisesLeft: CONFIRM_ROUND_CAP,
     specHash: /** @type {string|null} */ (null),
     resolvedSpecPath: /** @type {string|null} */ (null),
     error: /** @type {string|null} */ (null),
@@ -411,6 +466,8 @@ export function createSession(card, deps = {}) {
 
   /** @param {'bot'|'you'|'system'} role @param {string} text */
   const say = (role, text) => { state.messages.push({ role, text }); };
+  /** a structured message (the plan bubble): the page draws it, the thread keeps it as data */
+  const sayPlan = (/** @type {any} */ plan) => { state.messages.push(planMessage(plan, jobLines)); };
 
   /** @type {((value: string|null) => void)|null} */
   let resolvePending = null;
@@ -436,15 +493,9 @@ export function createSession(card, deps = {}) {
     resolvePending = resolveFn;
     if (step.kind === 'language') say('bot', `${step.field?.prompt ?? 'Which language is this job about?'} (${(step.candidates ?? []).join(', ')})`);
     else if (step.kind === 'menu') {
-      const p = step.plan ?? {};
-      const lines = [`Plan: ${JSON.stringify(p.goal ?? '')}`, `Checks: ${(p.checks ?? []).join(' · ') || '(none)'}`];
-      if ((p.notChecked ?? []).length) lines.push(`Not checked: ${p.notChecked.join(' · ')}`);
-      if ((p.questions ?? []).length) lines.push(`Questions: ${p.questions.join(' · ')}`);
-      lines.push('Sign & run to confirm this plan, or Revise to describe a change.');
-      say('bot', lines.join('\n'));
-    } else if (step.kind === 'answer') say('bot', `A question the plan raised (${step.index} of ${step.total}): ${step.question}`);
+      sayPlan(step.plan ?? {});
+    } else if (step.kind === 'answer') say('bot', `A question the plan raised (${step.index} of ${step.total})${Number.isInteger(step.line) ? `, about job line ${step.line}` : ''}: ${step.question}`);
     else if (step.kind === 'goal') say('bot', 'Type the goal sentence yourself.');
-    else if (step.kind === 'fix') say('bot', 'What should change?');
   });
 
   /** @param {string|null} value @returns {boolean} */
@@ -457,21 +508,7 @@ export function createSession(card, deps = {}) {
     return true;
   };
 
-  /** @param {'menu'|'fix'|'answer'|'language'|'goal'} kind @param {number} timeoutMsInner */
-  const waitForPendingKind = async (kind, timeoutMsInner = 2000) => {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMsInner) {
-      if (state.pendingAsk?.kind === kind) return true;
-      // eslint-disable-next-line no-await-in-loop
-      await new Promise((r) => { setTimeout(r, 10); });
-    }
-    return state.pendingAsk?.kind === kind;
-  };
-
   const onPhase = (name, data = {}) => {
-    if (name === 'confirm-round' && typeof data.round === 'number') {
-      state.revisesLeft = Math.max(0, CONFIRM_ROUND_CAP - (data.round - 1));
-    }
     // COLLAPSED INTO THE PROGRESS INDICATOR ONLY (build item 3) — this used
     // to also `say('system', `… ${name}`)`, one jargon chat bubble per
     // library phase (`… confirm-turn-done`, `… seed-read`, …), read back to
@@ -520,8 +557,16 @@ export function createSession(card, deps = {}) {
     // the call's label, the drafting model, its cost (null stays null: unpriced is never $0). One owner: this onCall.
     const runningNo = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
     const callNo = runningNo === -1 ? state.steps.length - 1 : runningNo;
+    // bare-agent's own verdict on the call's run (true | false | null), present only when thinkingMode was sent. 'off' sent but
+    // reasoning seen (false) turns the first drafting row into "thinking on (the model thought anyway)" and stays so.
+    if (draftThinkingLogged === 'off' && call.thinkingApplied === false && !thoughtAnyway) {
+      thoughtAnyway = true;
+      const row = latestStep(state.steps, 'thinking');
+      if (row) { row.label = thinkingRowText('off', true); appendDraftLog(outDir, { kind: 'step-label', no: state.steps.indexOf(row), label: row.label, at: new Date().toISOString() }); }
+    }
     appendDraftLog(outDir, {
       kind: 'call', no: callNo, step: state.steps[callNo]?.id ?? null, label: call.label, model: draftIdentity?.model ?? null,
+      thinking: draftThinkingLogged, ...(call.thinkingApplied === undefined ? {} : { thinkingApplied: call.thinkingApplied }),
       costUsd: call.costUsd ?? null, unpricedRounds: call.unpricedRounds ?? 0, at: nowIso,
     });
     try {
@@ -533,6 +578,10 @@ export function createSession(card, deps = {}) {
   };
   /** @type {string|null} */
   let draftStartedAt = null;
+  /** what the drafting calls really carry for thinking ('on' | 'off' | 'not-switchable' | 'unverified'), set once the Model Name resolves; null before @type {string|null} */
+  let draftThinkingLogged = null;
+  /** a drafting call reported thinkingApplied === false after 'off' was sent */
+  let thoughtAnyway = false;
   /** P6 item 1: the worktree this session made in the person's repo (null until made, and again once removed) @type {{repo: string, dir: string}|null} */
   let madeWorktree = null;
   /** a session that ends WITHOUT ever running (refused, errored, abandoned) takes its worktree with it; a signed one keeps it for the run */
@@ -558,9 +607,18 @@ export function createSession(card, deps = {}) {
 
   async function run() {
     // ── keys, at $0, before anything is prepared ────────────────────────
-    stepStart('setup');
     const keyRows = rowsForHome(configHome);
     const modelChoice = modelChoiceFor(keyRows, card.model);
+    // hamr 2026-10-11: the FIRST drafting row says whether the drafter thinks, before any other line ("checking setup" follows).
+    // A Reuse session drafts nothing, so it has no row. A provider shape that cannot be built is refused below, in words.
+    if (modelChoice && deps.reuse === undefined) {
+      try {
+        draftThinkingLogged = draftThinkingFor({ providerName: modelChoice.provider, model: modelChoice.name, baseUrl: modelChoice.baseUrl ?? null }, draftThinking);
+        state.steps.push({ id: 'thinking', label: thinkingRowText(/** @type {any} */ (draftThinkingLogged)), status: 'done', detail: '' });
+        logSteps();
+      } catch { draftThinkingLogged = null; }
+    }
+    stepStart('setup');
     if (!modelChoice) { refuse(`Model "${card.model}" is not a Name in Settings > Providers. Stopped — nothing spent.`); return; }
     draftIdentity = { provider: modelChoice.provider, baseUrl: modelChoice.baseUrl ?? null, model: modelChoice.name };
     let providerEntry;
@@ -585,7 +643,7 @@ export function createSession(card, deps = {}) {
 
     const verdictType = card.checkType === 'rubric' ? 'soft-green' : 'green';
     const into = join(outDir, 'source-seed');
-    const isRepoLike = looksLikeRepoSource(card.source);
+    const isRepoLike = looksLikeRepoSource(SOURCE);
     // 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; }
@@ -595,7 +653,7 @@ export function createSession(card, deps = {}) {
     // P6 item 1 (hamr 2026-10-05, Q1 = A / Q3 = A): a REPO source gets a worktree in the person's own repo, made now at
     // drafting start — `.bareloop/wt/<session id>` at their current commit. Edits they have not committed are not in it,
     // and the progress line says so (a notice, never a refusal).
-    const repoRoot = isRepoLike ? nearestGitAncestor(resolve(card.source))?.dir ?? null : null;
+    const repoRoot = isRepoLike ? nearestGitAncestor(resolve(SOURCE))?.dir ?? null : null;
     if (repoRoot !== null) {
       const dirty = uncommittedCount(repoRoot);
       if (dirty > 0) {
@@ -610,7 +668,7 @@ export function createSession(card, deps = {}) {
     // (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: card.source, into, ...(isRepoLike || destIsDir ? { destination: card.destination } : {}),
+      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 };
@@ -764,9 +822,28 @@ export function createSession(card, deps = {}) {
       });
       const signingFile = join(outDir, 'signing.json');
       writeFileSync(signingFile, `${JSON.stringify(signing, null, 2)}\n`);
+      // The `calibrating` line is the rubric phase the person watched; its ✓ was set long before the gate graded
+      // anything. Once the gate has a result, the line says THAT, on its own line (hamr, 2026-10-09).
+      const calSum = calibrationSummary(signing.gates?.calibration);
+      const calStep = latestStep(state.steps, 'calibrate');
+      if (calSum && calStep) {
+        calStep.status = calSum.ok ? 'done' : 'failed';
+        calStep.detail = calSum.note;
+        logSteps();
+      }
 
       if (!signing.ok) {
-        refuse(`signing gates failed — ${signing.reds.map((r) => r.code).join(', ') || 'no work red at seed'}`);
+        // plain words for the person (src/authorreadout.js, the one owner the CLI prints too); the full reds go into
+        // the drafting log on the failed step, so the cause survives the session
+        const runningNo = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
+        appendDraftLog(outDir, {
+          kind: 'step-reds', no: runningNo === -1 ? state.steps.length - 1 : runningNo, stop: 'signing-gates-failed',
+          reds: redsRecord(signing.reds ?? [], { signing: true }), at: new Date().toISOString(),
+        });
+        refuse(signingStopText({
+          reds: signing.reds ?? [], refusal: signing.refusal,
+          spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
+        }));
         return;
       }
       state.specHash = signing.specHash;
@@ -804,6 +881,9 @@ export function createSession(card, deps = {}) {
       schema: 'job-v1',
       job: card.jobName,
       description: `${card.jobName} — authored through the bareloop panel (${verdictType}, ${LANG})`,
+      // P7: the person's own words, signed beside the model's goal sentence
+      jobLines: signedJobLines(jobLines),
+      inputs: INPUTS,
       provider: modelChoice.provider,
       ...(modelChoice.baseUrl ? { baseUrl: modelChoice.baseUrl } : {}),
       // the Name is the model id: signed into the spec only when it is not the provider's own default
@@ -823,8 +903,8 @@ export function createSession(card, deps = {}) {
     }
 
     /** @type {Record<string, string>} */
-    const answers = { 1: card.goal, 2: card.success, 3: card.guardrails };
-    if (verdictType === 'soft-green') answers[4] = card.judgeExamples;
+    const answers = { 1: renderJobLines(jobLines) };
+    if (verdictType === 'soft-green') answers[SOFTGREEN_JUDGE_EXAMPLES_KEY] = renderExamples(jobLines);
     const required = 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; }
@@ -840,12 +920,39 @@ export function createSession(card, deps = {}) {
     // TEST SEAMS (see the constructor's own note): a test overrides
     // `generate`/`confirmGenerate` directly (bypassing this real, constructed
     // `provider` for the model boundary) and/or `scout` (bypassing the real
-    // paid scout) so it can drive the REAL confirm turn/ask()/revise/hash
+    // paid scout) so it can drive the REAL confirm turn/ask()/hash
     // machinery below with a deterministic fake, never a live provider call.
     // no NEW model call starts after an abandon; a call already in flight books its usage via onCall and is discarded
     const noCallAfterAbandon = (fn) => (...a) => { if (abandoned) throw new Error('abandoned — no new model call'); return fn(...a); };
-    const generate = noCallAfterAbandon(deps.generate ?? makeLoopGenerate(provider, { rates: draftPrice?.rates ?? null }));
-    const confirmGenerate = noCallAfterAbandon(deps.confirmGenerate ?? makeLoopGenerate(provider, { system: CONFIRM_SYSTEM, rates: draftPrice?.rates ?? null }));
+    const generate = noCallAfterAbandon(deps.generate ?? makeLoopGenerate(provider, { rates: draftPrice?.rates ?? null, draftThinking }));
+    const confirmGenerate = noCallAfterAbandon(deps.confirmGenerate ?? makeLoopGenerate(provider, { system: CONFIRM_SYSTEM, rates: draftPrice?.rates ?? null, draftThinking }));
+
+    // P7 item 5 (fwdloop am24/25): the last drafting try, after two failed ones, may ask. Each question comes through the same
+    // ask path as every other (the chat box + Send); the answer is REQUIRED (a blank one asks again, there is no skip) and is
+    // added WORD FOR WORD as a `~` rule on the job line it names — never rewritten. The lines are mutated in place, so the
+    // signed `jobLines`, the answers text and the plan card all read the same words.
+    const answerQuestions = async (/** @type {{questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}} */ o) => {
+      if (o.dropped.length) appendDraftLog(outDir, { kind: 'questions-dropped', no: Math.max(0, state.steps.length - 1), dropped: o.dropped, at: new Date().toISOString() });
+      const total = o.questions.length;
+      for (let k = 0; k < total; k += 1) {
+        const q = o.questions[k];
+        let text = '';
+        for (;;) {
+          const a = await ask({ kind: 'answer', index: k + 1, total, question: q.question, line: q.line });
+          if (a === null) return null;
+          // one `~` line is one line: the person's own words, newlines folded to spaces, nothing else touched
+          text = String(a).replace(/\s*\n\s*/g, ' ').trim();
+          if (text) break;
+          say('bot', 'An answer is needed here — there is no skip. Type it in the box below and press Send.');
+        }
+        const line = jobLines.find((l) => l.n === q.line);
+        if (line) { line.rule = line.rule ? `${line.rule}; ${text}` : text; line.rules.push(text); }
+      }
+      draft.jobLines = signedJobLines(jobLines);
+      answers[1] = renderJobLines(jobLines);
+      state.messages.push({ ...planMessage(o.confirmed ?? {}, jobLines), text: 'Your answers are in as ~ rules on those job lines. Drafting again.' });
+      return { jobLines, answers };
+    };
 
     state.phase = 'drafting';
     // no early "drafting" line: the real author phase (PHASE_STEP) starts it, carrying draftDetail (see onPhase)
@@ -856,17 +963,48 @@ export function createSession(card, deps = {}) {
       judgeModel: draftJudge.model,
       answers, verdictType, repoPath: prep.tree, lang: LANG,
       questions: questionsFor(verdictType),
+      jobLines, inputs: INPUTS,
       writeScope, provider, generate,
       ceilingUsd: card.capUsd,
       rates: draftPrice?.rates ?? null,
+      draftThinking,
       onPhase, onCall,
-      ask, confirmGenerate, isRepo: true, langResult,
+      ask, answerQuestions, confirmGenerate, isRepo: true, langResult,
       ...(deps.scout ? { scout: deps.scout } : {}),
       ...(authorFnOverride ? { authorFn: authorFnOverride } : {}),
     });
 
+    if (!authored.ok && PLAIN_PROPOSAL_STOPS.includes(String(authored.stop))) {
+      // a refused rubric proposal: the person gets the reason in plain words (src/authorreadout.js, the one owner the
+      // CLI prints too), and the full reds go into the drafting log on the failed step so the cause survives the session
+      const cases = authored.judged?.signed?.cases ?? authored.judged?.proposal?.proposal?.cases ?? null;
+      const reds = authored.reds ?? [];
+      const runningNo = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
+      appendDraftLog(outDir, {
+        kind: 'step-reds', no: runningNo === -1 ? state.steps.length - 1 : runningNo, stop: authored.stop,
+        reds: redsRecord(reds, { cases }), at: new Date().toISOString(),
+      });
+      refuse(proposalStopText({
+        stop: String(authored.stop), reds, cases,
+        spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
+        source: authored.judged?.source === 'signer' ? 'signer' : 'proposal',
+      }));
+      return;
+    }
     if (!authored.ok) {
-      refuse(`Stopped: ${authored.stop ?? 'authoring-failed'}${authored.refusal ? ` — ${authored.refusal.detail}` : ''}`, authored.stop === 'confirm-abandoned' ? 'abandoned' : 'refused');
+      // ITEM 6 (P7): every drafting stop says WHY in plain words (the reds travel into the drafting log beside it) — the bare
+      // "Stopped: provider-red" of live session smv2bzdqmp0f8 carried a code and no reason.
+      const stopReds = authored.reds ?? [];
+      if (stopReds.length) {
+        const no = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
+        appendDraftLog(outDir, { kind: 'step-reds', no: no === -1 ? state.steps.length - 1 : no, stop: authored.stop ?? 'authoring-failed', reds: redsRecord(stopReds), at: new Date().toISOString() });
+      }
+      refuse(authored.stop === 'confirm-abandoned' || authored.stop === 'confirm-restart'
+        ? `Stopped: ${authored.stop}${authored.refusal ? ` — ${authored.refusal.detail}` : ''}`
+        : draftStopText({
+          stop: String(authored.stop ?? 'authoring-failed'), reds: stopReds, refusal: authored.refusal,
+          spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
+        }), authored.stop === 'confirm-abandoned' ? 'abandoned' : 'refused');
       return;
     }
 
@@ -888,7 +1026,7 @@ export function createSession(card, deps = {}) {
     /** @param {string} text */
     send: (text) => {
       if (!state.pendingAsk) return { ok: false, error: 'nothing is being asked right now' };
-      if (state.pendingAsk.kind === 'menu') return { ok: false, error: 'use Sign & run or Revise for a plan, never Send — the chat can never sign or pick a plan action' };
+      if (state.pendingAsk.kind === 'menu') return { ok: false, error: 'use Sign & run for a plan, never Send — the chat can never sign or pick a plan action' };
       if (state.pendingAsk.kind === 'install-needed') return { ok: false, error: 'install the packages, then click Check again — nothing to send here' };
       say('you', text);
       answer(text);
@@ -917,17 +1055,6 @@ export function createSession(card, deps = {}) {
       r();
       return { ok: true };
     },
-    /** @param {string} text */
-    revise: async (text) => {
-      if (!state.pendingAsk || state.pendingAsk.kind !== 'menu') return { ok: false, error: 'no plan is waiting for a Revise right now' };
-      if (state.revisesLeft <= 0) return { ok: false, error: 'no revises left (D3: max 2 rounds)' };
-      answer('fix');
-      const reached = await waitForPendingKind('fix', 3000);
-      if (!reached) return { ok: false, error: 'the confirm turn did not ask for a fix in time' };
-      say('you', text);
-      answer(text);
-      return { ok: true };
-    },
     /** click 1 — the confirm pick. Never signs on its own. */
     signPrepare: () => {
       if (!state.pendingAsk || state.pendingAsk.kind !== 'menu') return { ok: false, error: 'no plan is waiting for a decision right now' };