bareloop 0.39.0 → 0.41.0

package/src/panel/authorsession.js

@@ -20,7 +20,7 @@
 // `src/panel/server.js`'s POST routes). Nothing here changes what a step
 // means or what an answer does — only where the answer comes from.
 
-import { applyConfiguredKey, judgeRatesFor, keyNameFor, modelChoiceFor, ratesFor, rowsForHome } from '../providerrows.js';
+import { judgePick, judgeRatesFor, judgeRowFor, keyValueOf, modelChoiceFor, ratesOfLine, rowsForHome } from '../providerrows.js';
 import { ConfigError } from '../config.js';
 import {
   mkdirSync, existsSync, writeFileSync, readdirSync,
@@ -42,18 +42,23 @@ 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,
 } from '../providers.js';
 import { resolveJobJudge, defaultJudgeLoop } from '../judged.js';
+import { assertThinkingMode, thinkingPlanFor, thinkingRowText } from '../thinking.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, redsRecord, calibrationSummary } from '../authorreadout.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
@@ -62,6 +67,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',
@@ -105,6 +111,8 @@ export const PHASE_STEP = Object.freeze({
   'rubric-scrubbed': 'calibrate',
 });
 
+export { thinkingRowText };
+
 /** @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) */
@@ -133,23 +141,22 @@ const SOURCE_CHECK_CODES = new Set([
   'source-file-oversize', 'source-changed-after-scan', 'source-untracked-in-repo',
 ]);
 
+/** 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 the chat shows it: ONE owner of the text (hamr, 2026-10-09: the one-blob "Plan: ...
- * Checks: ... Not checked: ..." was unreadable). Each section is a heading on its own line, its content on the next,
- * and a blank line between sections. `#NOT CHECKED:` and `#QUESTIONS:` appear only when there is something to say.
- * The CLI composes its own plan screen (src/authorrun.js) and shares no text with this one.
- * @param {{goal?: string, checks?: string[], notChecked?: string[], questions?: string[]}} p
- * @returns {string}
+ * 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 planText(p) {
-  const sections = [
-    `#PLAN:\n${JSON.stringify(p.goal ?? '')}`,
-    `#CHECKS:\n${(p.checks ?? []).join(' · ') || '(none)'}`,
-  ];
-  if ((p.notChecked ?? []).length) sections.push(`#NOT CHECKED:\n${(p.notChecked ?? []).join(' · ')}`);
-  if ((p.questions ?? []).length) sections.push(`#QUESTIONS:\n${(p.questions ?? []).join(' · ')}`);
-  sections.push('Sign & run to confirm this plan, or Revise to edit the boxes and draft again.');
-  return sections.join('\n\n');
+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 */
@@ -176,7 +183,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', 'provider', 'model', 'thinking', '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).
@@ -192,15 +210,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',
 }));
 
 /**
@@ -219,12 +237,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
@@ -234,23 +252,25 @@ 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;
-  const choice = rows && typeof card.model === 'string' ? modelChoiceFor(rows, card.model) : null;
+  const choice = rows && typeof card.model === 'string' ? modelChoiceFor(rows, { provider: card.provider, model: card.model }) : null;
   if (choice) {
     if (spec.verdictType === 'soft-green' && !spec.judge) spec.judge = resolveJobJudge(originSpec, originSpec.provider ?? choice.provider, resolveWorkerModel);
-    const entry = resolveProvider(choice.provider);
+    resolveProvider(choice.provider);
     spec.provider = choice.provider;
     if (choice.baseUrl) spec.baseUrl = choice.baseUrl; else delete spec.baseUrl;
-    if (choice.name !== entry.tiers.sonnet) spec.model = choice.name; else delete spec.model;
+    spec.model = choice.name; // a job always carries its own model
   }
   return spec;
 }
 
 /**
  * `$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]
@@ -258,8 +278,10 @@ 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 pick = judgePick(opts.rows ?? [], { provider: card.provider, model: card.model });
+  if (!pick.ok) return { ok: false, error: pick.say };
+  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' };
@@ -277,7 +299,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) {
@@ -294,19 +316,22 @@ 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 pick = judgePick(opts.rows ?? [], { provider: card.provider, model });
+  if (!pick.ok) return { ok: false, error: pick.say };
+  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 };
+  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' };
   }
@@ -321,13 +346,24 @@ 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, 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 mode ('on' | 'off'): the card's "Thinking on" tick (unticked = 'off'), signed into the job only when ticked.
+  // `deps.draftThinking` is an operator override for tests/probes; a bad value throws here, before a session exists.
+  const draftThinking = assertThinkingMode(deps.draftThinking ?? (card.thinking === true ? 'on' : '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);
@@ -422,6 +458,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;
@@ -447,8 +485,8 @@ 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') {
-      say('bot', planText(step.plan ?? {}));
-    } 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.');
   });
 
@@ -511,8 +549,22 @@ 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 — `thinkingStatus`: 'applied' | 'unsupported' | 'ignored' | 'unknown' — present only
+    // when thinkingMode was sent. The first drafting row then says what REALLY happened ("the model thought anyway", "can't change it",
+    // "not confirmed"); a row that moved to a worse word never moves back.
+    if (draftThinkingPlan !== null && call.thinkingStatus !== undefined && call.thinkingStatus !== thinkingStatusSeen
+      && !(thinkingStatusSeen !== null && thinkingStatusSeen !== 'applied' && call.thinkingStatus === 'applied')) {
+      thinkingStatusSeen = call.thinkingStatus;
+      const row = latestStep(state.steps, 'thinking');
+      if (row) {
+        row.label = thinkingRowText({ mode: draftThinkingPlan.mode, support: draftThinkingPlan.support, status: call.thinkingStatus });
+        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: draftThinkingPlan === null ? null : draftThinkingPlan.mode, thinkingSupport: draftThinkingPlan === null ? null : draftThinkingPlan.support,
+      ...(call.thinkingStatus === undefined ? {} : { thinkingStatus: call.thinkingStatus }),
       costUsd: call.costUsd ?? null, unpricedRounds: call.unpricedRounds ?? 0, at: nowIso,
     });
     try {
@@ -524,6 +576,11 @@ export function createSession(card, deps = {}) {
   };
   /** @type {string|null} */
   let draftStartedAt = null;
+  /** what the drafting calls will carry for thinking — the tick's mode and bare-agent's support answer — set once the Model resolves; null before
+   * @type {ReturnType<typeof thinkingPlanFor>|null} */
+  let draftThinkingPlan = null;
+  /** the worst-so-far `thinkingStatus` a drafting call reported (null until one did) @type {string|null} */
+  let thinkingStatusSeen = null;
   /** 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 */
@@ -549,34 +606,44 @@ export function createSession(card, deps = {}) {
 
   async function run() {
     // ── keys, at $0, before anything is prepared ────────────────────────
+    const keyRows = rowsForHome(configHome, env);
+    const pick = judgePick(keyRows, { provider: card.provider, model: card.model });
+    const modelChoice = pick.ok ? pick.choice : null;
+    // 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 {
+        draftThinkingPlan = thinkingPlanFor({ providerName: modelChoice.provider, model: modelChoice.name, baseUrl: modelChoice.baseUrl ?? null }, draftThinking);
+        state.steps.push({ id: 'thinking', label: thinkingRowText({ mode: draftThinkingPlan.mode, support: draftThinkingPlan.support }), status: 'done', detail: '' });
+        logSteps();
+      } catch { draftThinkingPlan = null; }
+    }
     stepStart('setup');
-    const keyRows = rowsForHome(configHome);
-    const modelChoice = modelChoiceFor(keyRows, card.model);
-    if (!modelChoice) { refuse(`Model "${card.model}" is not a Name in Settings > Providers. Stopped — nothing spent.`); return; }
+    if (!modelChoice) { refuse(pick.ok ? 'Pick a model. Nothing was spent.' : pick.say); return; }
     draftIdentity = { provider: modelChoice.provider, baseUrl: modelChoice.baseUrl ?? null, model: modelChoice.name };
     let providerEntry;
     try { providerEntry = resolveProvider(modelChoice.provider); } catch (e) { refuse(/** @type {Error} */ (e).message); return; }
-    // P4a item 4 — the key variable the person picked in Settings stands in for the built-in one
+    // the key is the chosen row's own variable (P8: no built-in name)
     const keyCfg = keyRows;
-    const draftEnv = applyConfiguredKey(env, modelChoice.provider, modelChoice.baseUrl, keyCfg, modelChoice.name);
-    const draftKeyName = keyNameFor(modelChoice.provider, modelChoice.baseUrl, keyCfg, modelChoice.name).name;
-    const apiKey = draftEnv[providerEntry.envKey];
+    const draftKeyName = modelChoice.envName;
+    const apiKey = keyValueOf(env, draftKeyName);
     if (!apiKey) { refuse(`${draftKeyName} not set. Stopped — nothing spent.`); return; }
     // the customer's own price on this row (USD per 1M in config.json), resolved once here at $0 and
     // handed to every model call this session makes; a bad price refuses, never falls back to the guess
-    /** @type {ReturnType<typeof ratesFor>} */
+    /** @type {import('../providerrows.js').PriceResult} */
     let draftPrice = null;
-    try { draftPrice = ratesFor(modelChoice.provider, modelChoice.baseUrl, keyCfg, modelChoice.name); } catch (e) {
-      if (!(e instanceof ConfigError)) throw e;
-      refuse(`${e.message}. Stopped — nothing spent.`);
-      return;
+    {
+      const chosenRow = keyCfg.find((r) => r.envName === modelChoice.envName);
+      const dl = chosenRow?.models.find((l) => l.model === modelChoice.name);
+      const dp = dl ? ratesOfLine(dl) : null;
+      draftPrice = dp ? { ...dp, envName: modelChoice.envName } : null;
     }
     const keyProblem = apiKeyProblem(apiKey);
     if (keyProblem) { refuse(`${draftKeyName} ${keyProblem}. Stopped — nothing spent.`); return; }
 
     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; }
@@ -586,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) {
@@ -601,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 };
@@ -724,9 +791,10 @@ export function createSession(card, deps = {}) {
       const judges = closeJudges(spec.closeDecl);
       const judge = judges ? resolveJobJudge(spec, modelChoice.provider, resolveWorkerModel) : null;
       let judgeProvider = null;
-      /** @type {ReturnType<typeof ratesFor>} */
+      /** @type {import('../providerrows.js').PriceResult} */
       let judgePrice = null;
       if (judge) {
+        const judgeRow = judgeRowFor(keyCfg, judge, modelChoice.provider, keyCfg.find((r) => r.envName === modelChoice.envName) ?? null);
         try {
           judgePrice = judgeRatesFor(judge, modelChoice.provider, modelChoice.baseUrl, draftPrice, keyCfg);
         } catch (e) {
@@ -734,22 +802,23 @@ export function createSession(card, deps = {}) {
           refuse(`${e.message} — refusing before gate 4 spends anything`);
           return;
         }
-        const judgeKeyValue = env.JUDGE_API_KEY ?? (judge.provider === modelChoice.provider ? draftEnv : applyConfiguredKey(env, judge.provider, undefined, keyCfg, judge.model))[resolveProvider(judge.provider).envKey];
+        const judgeKeyValue = env.JUDGE_API_KEY ?? (judge.provider === modelChoice.provider ? apiKey : keyValueOf(env, judgeRow?.envName));
         const judgeKeyProblem = judgeKeyValue ? apiKeyProblem(judgeKeyValue) : null;
         if (!judgeKeyValue || judgeKeyProblem) {
           refuse(`the judge key is not usable (${judgeKeyProblem ?? 'not set'}) — refusing before gate 4 spends anything`);
           return;
         }
         judgeProvider = buildRunnerProviders({
-          providerName: modelChoice.provider, apiKey, model: MODEL, tierModels: providerEntry.tiers, baseUrl: modelChoice.baseUrl,
+          providerName: modelChoice.provider, apiKey, model: MODEL, baseUrl: modelChoice.baseUrl, legacyMaxTokens: modelChoice.legacyMaxTokens,
           judgeApiKey: judgeKeyValue, judgeModel: judge.model, judgeProviderName: judge.provider,
-          judgeBaseUrl: judge.provider === modelChoice.provider ? modelChoice.baseUrl : undefined,
+          judgeBaseUrl: judge.provider === modelChoice.provider ? modelChoice.baseUrl : (judgeRow?.baseUrl.trim() || undefined),
+          judgeLegacyMaxTokens: judge.provider === modelChoice.provider ? modelChoice.legacyMaxTokens : (judgeRow?.legacyMaxTokens ?? false),
         }).judgeProvider;
       }
       const signing = await prepareSigningFn({
         spec, workdir: prep.tree, seedRef: seedRef, timeoutMs,
         shellCapUsd: spec.budgetUsd, ceilingUsd: card.capUsd, priorCalls: [...metered],
-        judgeLoop: judgeProvider ? (o) => defaultJudgeLoop({ provider: judgeProvider, system: o.system, rates: judgePrice?.rates ?? null }) : null,
+        judgeLoop: judgeProvider ? (o) => defaultJudgeLoop({ provider: judgeProvider, system: o.system, rates: judgePrice?.rates ?? null, thinking: spec.thinking === true }) : null,
         judgeModel: judge?.model ?? null,
         onJudgeCost: (c) => onCall({ label: `${c.label}:${c.id}`, costUsd: c.costUsd, unpricedRounds: c.unpricedRounds }),
       });
@@ -814,10 +883,15 @@ 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
-      ...(modelChoice.name !== providerEntry.tiers.sonnet ? { model: modelChoice.name } : {}),
+      // a job always carries its own model (P8: there is no provider default to omit it against)
+      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 } : {}),
@@ -833,18 +907,18 @@ 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; }
     }
 
     const draftJudge = (() => {
-      try { return resolveJobJudge(draft, modelChoice.provider, resolveWorkerModel); } catch { return { provider: modelChoice.provider, model: providerEntry.tiers.sonnet }; }
+      try { return resolveJobJudge(draft, modelChoice.provider, resolveWorkerModel); } catch { return { provider: modelChoice.provider, model: modelChoice.name }; }
     })();
     const { provider } = buildRunnerProviders({
-      providerName: modelChoice.provider, apiKey, model: MODEL, tierModels: providerEntry.tiers, baseUrl: modelChoice.baseUrl,
+      providerName: modelChoice.provider, apiKey, model: MODEL, baseUrl: modelChoice.baseUrl, legacyMaxTokens: modelChoice.legacyMaxTokens,
       judgeApiKey: apiKey, judgeModel: MODEL, judgeProviderName: modelChoice.provider, judgeBaseUrl: modelChoice.baseUrl,
     });
     // TEST SEAMS (see the constructor's own note): a test overrides
@@ -854,8 +928,35 @@ export function createSession(card, deps = {}) {
     // 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)
@@ -866,11 +967,13 @@ 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 } : {}),
     });
@@ -893,7 +996,19 @@ export function createSession(card, deps = {}) {
       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;
     }