bareloop 0.39.0 → 0.40.0

package/types/authorjob.d.ts

@@ -79,26 +79,38 @@ export function refuseLockedKind(kind: string): Refusal;
  * one-genre-at-a-time law is untouched.
  *
  * @param {{answers: Record<string|number, any>, repoPath?: string|null, lang: string,
+ *   jobLines?: {n: number, text: string}[]|null, inputs?: {n: number, label: string, value: string}[]|null,
  *   verdictType?: string|null,
  *   questions?: Record<string|number, string>|null, generate?: Function, provider?: any,
  *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null, judgeModel?: string|null,
- *   rates?: {in: number, out: number}|null,
+ *   rates?: {in: number, out: number}|null, draftThinking?: 'on'|'off',
  *   onPhase?: (phase: string, data?: any) => void,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
  *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
  *   authorFn?: Function, authorOpts?: object, writeScope?: string[]|null,
  *   signerFix?: Function|any, proposeFn?: Function, compileOpts?: object,
  *   ask?: ((step: {kind: string, [k: string]: any}) => Promise<string|null>)|null,
+ *   answerQuestions?: ((o: {questions: {line: number, question: string}[], dropped: {reason: string, raw: any}[], confirmed: any}) =>
+ *     Promise<{jobLines: {n: number, text: string, rule?: string}[], answers: Record<string|number, any>}|null>)|null,
  *   confirmGenerate?: Function|null, isRepo?: boolean,
  *   langResult?: {kind: string, candidates?: string[], [k: string]: any}|null}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
  *   closeDecl: any, seedRef: string|null, authoring: any, judged: any, reds: Red[],
  *   stop: string|null, cost: any, interview: any, confirmed: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, rates, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, jobLines, inputs, generate, provider, seedRef, scout, listing, ceilingUsd, rates, draftThinking, writeScope, judgeModel, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, answerQuestions, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
+    jobLines?: {
+        n: number;
+        text: string;
+    }[] | null;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
     verdictType?: string | null;
     questions?: Record<string | number, string> | null;
     generate?: Function;
@@ -112,11 +124,13 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         in: number;
         out: number;
     } | null;
+    draftThinking?: "on" | "off";
     onPhase?: (phase: string, data?: any) => void;
     onCall?: (call: {
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
     seedFn?: Function;
     scoutFn?: Function;
@@ -131,6 +145,24 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         kind: string;
         [k: string]: any;
     }) => Promise<string | null>) | null;
+    answerQuestions?: ((o: {
+        questions: {
+            line: number;
+            question: string;
+        }[];
+        dropped: {
+            reason: string;
+            raw: any;
+        }[];
+        confirmed: any;
+    }) => Promise<{
+        jobLines: {
+            n: number;
+            text: string;
+            rule?: string;
+        }[];
+        answers: Record<string | number, any>;
+    } | null>) | null;
     confirmGenerate?: Function | null;
     isRepo?: boolean;
     langResult?: {

package/types/authorreadout.d.ts

@@ -12,7 +12,7 @@ export function declarationLines({ goal, closeDecl }: {
  * F176'S FALLBACK, SAID OUT LOUD — the revise ladder kept the NEWEST SOUND
  * declaration rather than the last one it happened to try, because "kept the
  * last accepted revision" is not the same claim as "kept the best revision"
- * (docs/logs/FINDINGS.md F176). Absent on every run where the fallback never
+ * (docs/wiki/FINDINGS.md F176). Absent on every run where the fallback never
  * fired (the overwhelming majority), which is why this returns an EMPTY list
  * rather than a "no fallback" line — a green close has nothing to say here and
  * printing it every run would be noise, not information.
@@ -216,6 +216,22 @@ export function proposalStopText({ stop, reds, cases, spend, source }: {
     } | null;
     source?: "proposal" | "signer";
 }): string;
+/**
+ * @param {{stop: string, reds?: PlainRed[]|null, refusal?: {detail?: string}|null,
+ *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null}} o
+ * @returns {string}
+ */
+export function draftStopText({ stop, reds, refusal, spend }: {
+    stop: string;
+    reds?: PlainRed[] | null;
+    refusal?: {
+        detail?: string;
+    } | null;
+    spend?: {
+        knownUsd?: number | null;
+        spendComplete?: boolean | null;
+    } | null;
+}): string;
 /**
  * Plain sentences for the reds of a refused signing, one or more per red. Card and practice-case reds reuse the
  * proposal table; an unknown code is a generic sentence that quotes the code.

package/types/authorscout.d.ts

@@ -92,15 +92,15 @@ export function defaultSurveyor({ workdir, granted, auditPath, ctx }: {
  * @param {{workdir: string, provider?: any,
  *   rounds?: number, minBytes?: number, blobMax?: number, maxTokens?: number, ctx?: boolean,
  *   attempts?: number, ceilingUsd?: number|null, callTimeoutMs?: number,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
- *   rates?: {in: number, out: number}|null,
+ *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
  * @returns {Promise<Survey & {raw: string, raws: ReturnType<typeof scrubRaw>[],
  *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
  *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
  */
-export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, createSurveyor, }: {
+export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, createSurveyor, }: {
     workdir: string;
     provider?: any;
     rounds?: number;
@@ -115,6 +115,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
     createLoop?: (o: {
         system: string;
@@ -130,6 +131,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         in: number;
         out: number;
     } | null;
+    callOptions?: Record<string, any>;
     createSurveyor?: (o: {
         workdir: string;
         granted: readonly string[];

package/types/declaredclose.d.ts

@@ -53,7 +53,7 @@ export function declaredStages(closeDecl: any): any[] | null;
  *
  * @param {any} closeDecl
  * @param {{at?: string, listing?: string[]|null, deferListing?: boolean,
- *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} [opts]
  * @returns {{ok: boolean, reds: Red[], closeDecl: any, grounded: boolean,
  *   scoped: {scoped: boolean, via: string|null},
  *   ceiling: {class: string, kind: string, stage: string|null, locked: boolean}|null}}
@@ -65,6 +65,9 @@ export function validateCloseDecl(closeDecl: any, opts?: {
     catalogue?: Record<string, any>;
     verdictType?: string | null;
     writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): {
     ok: boolean;
     reds: Red[];

package/types/draftspend.d.ts

@@ -2,7 +2,10 @@
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `call`        {no, step, label, model, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
+ *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
+ *    call's run (true | false | null), present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  * @typedef {{kind: string, no: number, at: string, [k: string]: any}} DraftEvent
  */
@@ -105,7 +108,10 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  * One line of the drafting log. `no` = the step's position in the session's progress list (a step id can repeat).
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
- *  - `call`        {no, step, label, model, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway")
+ *  - `call`        {no, step, label, model, thinking, thinkingApplied?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
+ *    (`thinking` = what was asked and sent: off | on | not-switchable | unverified; `thinkingApplied` = bare-agent's own verdict for the
+ *    call's run (true | false | null), present only when thinkingMode was sent)
  *    (no token counts: the call path does not carry them without reworking the library, so none are recorded)
  */
 export type DraftEvent = {

package/types/job.d.ts

@@ -272,7 +272,7 @@ export const PROVIDERS: readonly string[];
 export const CONDITION_KEYS: readonly string[];
 /**
  * The fields a "Reuse workflow" run may change: where the work lands (the write fence, `writeScope`, and a
- * `destination`/`source` where a spec ever carries them) and the two ceilings. Everything else in a signed spec is
+ * `destination`/`source` where a spec ever carries them), the `inputs` the person pointed at (P7: Inputs is open on a reuse) and the two ceilings. Everything else in a signed spec is
  * the WORKFLOW — goal, checks, guardrails, close (the worker model is the third kind, {@link WORKFLOW_KEY_IDENTITY_FIELDS}). ONE list, shared by {@link workflowKey} and by the panel's
  * reuse (so what the key ignores is exactly what the person may edit, never two spellings).
  */

package/types/jobblock.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Parse "The job" box. A plain line is a numbered job line (1, 2, 3...). A line starting `~` has no number and belongs
+ * to the numbered line above; consecutive `~` lines become ONE rule joined with `'; '`. A `~` line starting `PASS:` or
+ * `FAIL:` is also a judge example (kept with its line number); any other `~` line is a guardrail. Empty lines are
+ * ignored. A `~` before line 1 is a red.
+ * @param {unknown} text the box's raw text
+ * @returns {{ok: true, lines: JobLine[]}|{ok: false, error: string}}
+ */
+export function parseJobBlock(text: unknown): {
+    ok: true;
+    lines: JobLine[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse the "Inputs" box: one `label: value` per line, numbered 1, 2, 3 in the order written. Empty lines are ignored.
+ * This only checks the SHAPE — what a value must point at (line 1 an absolute repo, lines 2+ tracked files inside it)
+ * is proven by the panel at $0.
+ * @param {unknown} text
+ * @returns {{ok: true, inputs: JobInput[]}|{ok: false, error: string}}
+ */
+export function parseInputs(text: unknown): {
+    ok: true;
+    inputs: JobInput[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The person's job lines as the drafter reads them (answer 1 of the interview): each numbered line, then its rule
+ * (the `~` lines joined) indented under it. One spelling, so the number the person typed beside a line is the number a
+ * stage's `fromLine` names.
+ * @param {JobLine[]} lines
+ * @returns {string}
+ */
+export function renderJobLines(lines: JobLine[]): string;
+/**
+ * The PASS:/FAIL: examples the person wrote, each kept with its line number (answer 2 of a rubric interview — what the
+ * calibration compile reads). Empty string when there are none.
+ * @param {JobLine[]} lines
+ * @returns {string}
+ */
+export function renderExamples(lines: JobLine[]): string;
+/**
+ * The inputs as the drafter is told about them: "the person pointed at these inputs: N label path".
+ * @param {JobInput[]} inputs
+ * @returns {string}
+ */
+export function renderInputs(inputs: JobInput[]): string;
+/**
+ * The two cross-checks between a parsed job block and the Check type: a RUBRIC job needs at least one `PASS:` and one
+ * `FAIL:` example (the calibration compile reads them); a DETERMINISTIC job has no judge, so an example line would be
+ * silently dropped — a red instead.
+ * @param {JobLine[]} lines
+ * @param {boolean} rubric
+ * @returns {string|null} the plain red, or null when the block fits the Check type
+ */
+export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean): string | null;
+/**
+ * The signed `jobLines` field from parsed lines: the person's own words, `{n, text, rule, rules}` (examples stay inside the
+ * rule text, where the person wrote them). `rules` is the same `~` lines as an array, BESIDE the joined `rule` (never
+ * replacing it); it is omitted on a line with no `~` line, and an older spec lacks it entirely.
+ * @param {JobLine[]} lines
+ * @returns {{n: number, text: string, rule: string, rules?: string[]}[]}
+ */
+export function signedJobLines(lines: JobLine[]): {
+    n: number;
+    text: string;
+    rule: string;
+    rules?: string[];
+}[];
+/** @typedef {{verdict: 'PASS'|'FAIL', text: string}} JobExample a `~ PASS:` / `~ FAIL:` line (rubric only), kept with its job line */
+/** @typedef {{n: number, text: string, rule: string, rules: string[], examples: JobExample[]}} JobLine one numbered job line; `rule` = its `~` lines joined with '; ' ('' when none), `rules` = those same `~` lines one by one (so an example's own '; ' survives) */
+/** @typedef {{n: number, label: string, value: string}} JobInput one numbered `label: value` input line */
+/** the joiner for consecutive `~` lines (fwd's joinGuardrails) */
+export const RULE_JOINER: "; ";
+/**
+ * a `~ PASS:` / `~ FAIL:` line (rubric only), kept with its job line
+ */
+export type JobExample = {
+    verdict: "PASS" | "FAIL";
+    text: string;
+};
+/**
+ * one numbered job line; `rule` = its `~` lines joined with '; ' ('' when none), `rules` = those same `~` lines one by one (so an example's own '; ' survives)
+ */
+export type JobLine = {
+    n: number;
+    text: string;
+    rule: string;
+    rules: string[];
+    examples: JobExample[];
+};
+/**
+ * one numbered `label: value` input line
+ */
+export type JobInput = {
+    n: number;
+    label: string;
+    value: string;
+};

package/types/panel/authorsession.d.ts

@@ -1,3 +1,11 @@
+/**
+ * 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: "on" | "off" | "not-switchable" | "unverified", thoughtAnyway?: boolean): string;
 /** @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) */
 export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
@@ -10,19 +18,36 @@ export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
  */
 export function advanceSteps(steps: StepLine[], id: string, detail?: string): void;
 /**
- * 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: {
+export function planMessage(p: {
     goal?: string;
     checks?: string[];
+    checkItems?: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
     notChecked?: string[];
     questions?: string[];
-}): string;
+    protections?: string[];
+}, jobLines: {
+    n: number;
+    text: string;
+    rule: string;
+}[] | null): {
+    role: "bot";
+    kind: "plan";
+    text: string;
+    plan: ReturnType<typeof planFromConfirm> & {
+        goal: string;
+        questions: string[];
+    };
+};
 /**
  * `true` when `jobs/<name>.json` already exists in the repo's own jobs/ dir
  * (resolved from THIS module's own on-disk location, never `process.cwd()`,
@@ -36,6 +61,13 @@ export function planText(p: {
 export function jobNameTaken(name: string, opts?: {
     jobsDir?: string;
 }): boolean;
+/**
+ * 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: any): string;
 /**
  * Only the form's own fields, nothing else a request body might carry (`startFrom`, stray keys).
  * @param {any} card
@@ -52,12 +84,12 @@ export function cardFields(card: any): Record<string, any>;
 export function lockedFieldChanged(card: Record<string, any>, origin: Record<string, any>): string | null;
 /**
  * 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
@@ -67,7 +99,7 @@ export function lockedFieldChanged(card: Record<string, any>, origin: Record<str
 export function buildReuseSpec(originSpec: any, card: Record<string, any>, rows?: readonly import("../providerrows.js").KeyRow[]): any;
 /**
  * `$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]
@@ -86,7 +118,7 @@ export function validateReuseCard(card: any, opts?: {
  * 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: string, isRepoLike: boolean): string | null;
@@ -115,7 +147,7 @@ export function validateJobCard(card: any, 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
@@ -131,6 +163,7 @@ export function createSession(card: any, deps?: {
     authorFn?: Function;
     prepareSigningFn?: Function;
     npmCiFn?: Function;
+    draftThinking?: "on" | "off";
     reuse?: {
         spec: any;
         workflowKey: string;
@@ -149,11 +182,13 @@ export const STEP_LABELS: Readonly<Record<string, string>>;
  * @type {Readonly<Record<string, keyof typeof STEP_LABELS>>}
  */
 export const PHASE_STEP: Readonly<Record<string, keyof typeof STEP_LABELS>>;
+/** 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 form's fields, in card order — what `card.json` stores, verbatim (P5 item 3) */
 export const CARD_FIELDS: readonly string[];
 /**
  * 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.
  */
@@ -167,4 +202,5 @@ export type StepLine = {
     status: "running" | "done" | "failed";
     detail: string;
 };
+import { planFromConfirm } from './jobplan.js';
 import { nonRepoSourceMessage } from '../source.js';

package/types/panel/jobplan.d.ts

@@ -0,0 +1,58 @@
+/** @typedef {{name: string, cls: 'machine check'|'judge'|null}} PlanCheck */
+/** @typedef {{n: number, text: string, rule: string, checks: PlanCheck[], refused: string[]}} PlanLine */
+/** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
+/**
+ * `machine check` for a kind a command decides, `judge` for one that needs judgement; `null` for a stage whose kind is
+ * unknown (a hand-written command close has no kind: it is a command, so a machine check).
+ * @param {unknown} kind
+ * @returns {'machine check'|'judge'|null}
+ */
+export function checkClassOfKind(kind: unknown): "machine check" | "judge" | null;
+/**
+ * The plan of a SIGNED spec. With `jobLines`, each stage lands under EACH line its `fromLine` array names (a stage with none is
+ * a mandatory guard: "Always on"), `closeDecl.refused` reasons land under their line, and `closeDecl.notes` are the
+ * drafter's own "not checked" words. Without `jobLines` (a spec that predates the job block) the signed goal sentence is
+ * line 1 and every stage name is a check under it — `older: true`.
+ * @param {any} spec
+ * @returns {JobPlan}
+ */
+export function planFromSpec(spec: any): JobPlan;
+/**
+ * The plan of the confirm turn, before anything is drafted: the person's own job lines, the model's checks under the
+ * line each names, its own "not checked" words, and the real protections (code-owned) as "Always on".
+ * @param {{n: number, text: string, rule: string}[]|null|undefined} jobLines
+ * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[]}} plan
+ * @returns {JobPlan}
+ */
+export function planFromConfirm(jobLines: {
+    n: number;
+    text: string;
+    rule: string;
+}[] | null | undefined, plan: {
+    checkItems?: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+    checks?: string[];
+    notChecked?: string[];
+    protections?: string[];
+}): JobPlan;
+export type PlanCheck = {
+    name: string;
+    cls: "machine check" | "judge" | null;
+};
+export type PlanLine = {
+    n: number;
+    text: string;
+    rule: string;
+    checks: PlanCheck[];
+    refused: string[];
+};
+export type JobPlan = {
+    lines: PlanLine[];
+    loose: PlanCheck[];
+    notChecked: string[];
+    alwaysOn: string[];
+    older: boolean;
+    goal?: string;
+};

package/types/panel/server.d.ts

@@ -298,6 +298,26 @@ export function getRunRounds(runid: string, query?: {
 }, opts?: {
     home?: string;
 }): any | null;
+/**
+ * The Signed row of the Job tab: `YYYY-MM-DD HH:MM · <first 6 of specHash>`, the time being the run's FIRST `job-start`
+ * in local time (hamr, P7). `null` when either part is not on record — never a made-up stamp.
+ * @param {string|null|undefined} ts an ISO stamp @param {string|null|undefined} hash
+ * @returns {string|null}
+ */
+export function signedLine(ts: string | null | undefined, hash: string | null | undefined): string | null;
+/**
+ * The Job box's text for a signed spec: the person's own numbered lines (a `~` line per entry of `rules`, or — for a spec
+ * signed before `rules` existed — per '; '-split piece of `rule`), or — for
+ * an older job that saved no job lines — the signed goal sentence as the one line.
+ * @param {any} spec @returns {string}
+ */
+export function jobTextFromSpec(spec: any): string;
+/**
+ * The Inputs box's text for a signed spec: its numbered inputs, or — for an older job — `repo: <source>` from the
+ * caller's best knowledge of the source (or empty).
+ * @param {any} spec @param {string} source @returns {string}
+ */
+export function inputsTextFromSpec(spec: any, source: string): string;
 /**
  * `GET /api/runs/:runid/job` — the Job tab, filled from the first source
  * that actually resolves (item 2, 2026-09-25), in order:

package/types/planrun.d.ts

@@ -221,7 +221,7 @@ export function planPrompt(job: any, scoutBlob: string, reds: any[] | null, maxS
  *   item 27/M3 Part B), forwarded to every close invocation as
  *   `BARELOOP_CLOSE_DIR`
  * @param {number} [opts.maxStepRounds] the shell's per-step rounds ceiling (validatePlan's bound)
- * @param {boolean} [opts.scout=true] operator-only switch (docs/product/SCOUT-CONTRAST.md):
+ * @param {boolean} [opts.scout=true] operator-only switch (docs/logs/SCOUT-CONTRAST.md):
  *        `false` on a FRESH run (no `resumeSeed`) skips the survey entirely — `scoutBlob`
  *        stays `''`, no `scout-start`/`scout-result`/`scout-empty` is emitted, and a single
  *        `scout-skipped {reason:'operator-off'}` records it (a RECORD, never silence — the

package/types/providers.d.ts

@@ -1,10 +1,47 @@
 /**
- * The per-call options the rubric JUDGE's model calls carry for this provider
- * instance, from the allow-list above. Empty for any provider/model not listed.
+ * The per-call options the rubric JUDGE's model calls carry for this provider instance: `{ thinkingMode: 'off' }` when
+ * bare-agent measures the model switchable, else `{}` (F192: judge runs thinking off; a judge on a model that cannot turn it
+ * off must not throw).
  * @param {any} provider a constructed bare-agent provider
  * @returns {Record<string, any>}
  */
 export function judgeCallOptions(provider: any): Record<string, any>;
+/**
+ * Throw unless `mode` is one of {@link DRAFT_THINKING_MODES} — an operator-param guard, so a typo never silently means a mode.
+ * @param {unknown} mode
+ * @returns {'on'|'off'}
+ */
+export function assertDraftThinking(mode: unknown): "on" | "off";
+/**
+ * What the drafting calls on this provider ACTUALLY carry for thinking, for the draft log and the panel row: `'on'` (mode on,
+ * nothing sent), `'off'` (mode off and the switch is sent), `'not-switchable'` (mode off, model measured not switchable —
+ * nothing sent), `'unverified'` (mode off, model not measured by bare-agent — nothing sent). Never re-derives a model list.
+ * @param {any} provider a constructed bare-agent provider
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {'on'|'off'|'not-switchable'|'unverified'}
+ */
+export function draftThinkingSent(provider: any, mode?: unknown): "on" | "off" | "not-switchable" | "unverified";
+/**
+ * {@link draftThinkingSent} for a model the caller has only NAMED (provider shape, model id, baseUrl) — no key, no network. For
+ * the panel's first drafting row, which is shown before the key is read. Constructing the provider only makes the class and
+ * the model id available to `thinkingSupport`; it sends nothing.
+ * @param {{providerName: string, model: string, baseUrl?: string|null}} o
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {'on'|'off'|'not-switchable'|'unverified'}
+ */
+export function draftThinkingFor({ providerName, model, baseUrl }: {
+    providerName: string;
+    model: string;
+    baseUrl?: string | null;
+}, mode?: unknown): "on" | "off" | "not-switchable" | "unverified";
+/**
+ * The ONE owner of the per-call options every DRAFTING model call carries (scout, confirm, author, revise, structure retries).
+ * `{ thinkingMode: 'off' }` exactly when {@link draftThinkingSent} says `'off'`, else `{}`.
+ * @param {any} provider a constructed bare-agent provider
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {Record<string, any>}
+ */
+export function draftCallOptions(provider: any, mode?: unknown): Record<string, any>;
 /**
  * Look up a provider's table entry. Throws a NAMED error on an unrecognized
  * provider — never a silent default (the `resolveRates`-style-substring-
@@ -18,7 +55,7 @@ export function resolveProvider(providerName: string): ProviderTableEntry;
 /**
  * Report whether a resolved API key VALUE (not its presence — every call
  * site already presence-checks separately) carries a shape an HTTP header
- * value cannot: F181 (`docs/logs/FINDINGS.md`) — a two-line secret-store
+ * value cannot: F181 (`docs/wiki/FINDINGS.md`) — a two-line secret-store
  * entry put the key plus a trailing metadata line into `OPENAI_API_KEY`
  * (`"<key>\nmeta"`), the presence-only check at every door passed, and Node
  * crashed `TypeError [ERR_INVALID_CHAR]` inside its own header-encode at the
@@ -217,6 +254,13 @@ export const PROBE_STATUS: Readonly<Record<string, {
     probed: boolean;
     evidence: string;
 }>>;
+/**
+ * The drafter's THINKING knob — an enumerated OPERATOR param, never model output and never read from env inside the library.
+ * `'on'` sends nothing (the model's own thinking, byte-identical to a no-knob call); `'off'` sends `thinkingMode: 'off'` where
+ * bare-agent measures the model switchable. The DEFAULT is `'off'` (hamr 2026-10-11, decided by the frozen ON/OFF contrast,
+ * docs/logs/2026-10-10-drafter-thinking-contrast-prereg.md); `'on'` stays selectable for a later Settings checkbox.
+ */
+export const DRAFT_THINKING_MODES: readonly string[];
 export type ProviderTableEntry = {
     /**
      * the bare-agent provider class

package/types/run.d.ts

@@ -158,7 +158,7 @@
  *        frozen A0 baseline arm has to be exactly today, so a guard firing under a disabled
  *        shim would make the baseline a treatment arm. The default-flip belongs to a
  *        paid contrast nobody has approved yet (the `layerRoot` precedent, F41).
- * @param {boolean} [opts.scout=true] operator-only switch (docs/product/SCOUT-CONTRAST.md),
+ * @param {boolean} [opts.scout=true] operator-only switch (docs/logs/SCOUT-CONTRAST.md),
  *   forwarded verbatim to the plan flow: `false` on a fresh run (no `resumeSeed`) skips the
  *   read-only survey and records `scout-skipped {reason:'operator-off'}` instead — the
  *   planner drafts from `(no scout notes)`. Runner territory exactly like `readShim`: the