bareloop 0.38.0 → 0.40.0

package/src/transport.js

@@ -1,5 +1,5 @@
 // hamr's ruling, verbatim: "one retry for transport layer failure and
-// reporting with the rest end of gate." (F115, docs/logs/FINDINGS.md.)
+// reporting with the rest end of gate." (F115, docs/wiki/FINDINGS.md.)
 //
 // A transport failure is fetch THROWING — the request never produced an HTTP
 // response at all (a TLS fault mid-record, a reset socket, a DNS/network

package/src/trend.js

@@ -272,6 +272,7 @@ export function createTrend({ stageOrder = [], limit = FIX_STRIKE_LIMIT, blindCa
      * @param {{gap?: string, stage?: string|null, value?: number|null}} o either a
      *   raw gap (parsed here) or an already-read `{stage, value}` — never both
      *   spellings of the same reading in one call.
+     *   (A judged stage's value is its distinct red COUNT, supplied by the caller.)
      * @returns {{iteration: number, stage: string, value: number|null, improved: boolean,
      *   comparable: boolean, noProgress: number, limit: number, stageIndex: number}}
      */

package/src/userrun.js

@@ -111,7 +111,7 @@ const JOBS = {
     seed: '92d71a7c1253f8f2430e2d308ecfef01c826b5c2',
   },
   // Bench row G3 (the NEGATIVE row) — the planted contract contradiction
-  // (docs/product/G3-SCOPING.md). A copy of the pulselog-u patient (patients are
+  // (docs/logs/G3-SCOPING.md). A copy of the pulselog-u patient (patients are
   // always copies) with one extra commit: two test/** files that pin
   // assembleEmail's subject to two different strings, unsatisfiable together
   // inside writeScope: src/**. Not frozen, not signed, no run — BUILT ON BRANCH
@@ -153,7 +153,7 @@ const JOBS = {
   // Bench row G2 (the NEGATIVE row) — TESTGEN cold start in plan-v1. The legacy
   // steps[] config went 0-of-43 (F38); this config's rate is UNKNOWN until its
   // establishing run. Same patient/seed/grader as the l2accept battery
-  // (TESTGEN-PREREG); the spec is the cold goal. See docs/product/G2-SCOPING.md.
+  // (TESTGEN-PREREG); the spec is the cold goal. See docs/logs/G2-SCOPING.md.
   'aurora-testgen-cold': {
     spec: 'aurora-testgen-cold.json',
     workdir: '/home/hamr/PycharmProjects/bareloop-patients/aurora-soar',
@@ -445,7 +445,7 @@ async function execute(ctx) {
   const SHIM_TAIL = shimArg === null ? '' : ` --read-shim ${shimArg}`;
 
   // --scout picks whether the plan flow pays for the read-only survey at all
-  // (docs/product/SCOUT-CONTRAST.md). Runner territory exactly like --read-shim
+  // (docs/logs/SCOUT-CONTRAST.md). Runner territory exactly like --read-shim
   // and --model: the spec names no scout, so the signed hash is unaffected. An
   // unrecognised value throws at argv, before the approval gate — the same
   // param-guard class as --read-shim above, for the same reason: a silently

package/types/authorflow.d.ts

@@ -1,3 +1,40 @@
+/**
+ * Which job lines did these validation reds name? A red names a line in its text ("job line N") or through the stage it
+ * sits on (path `stages[i]…` → that stage's own `fromLine`; `refused[i]…` → that refusal's `line`). A red naming none (a
+ * missing top-level key) names no line. Sorted real line numbers.
+ * @param {Red[]} reds @param {any} declaration @param {number[]} lineNums
+ * @returns {number[]}
+ */
+export function linesNamedByReds(reds: Red[], declaration: any, lineNums: number[]): number[];
+/**
+ * The machine's keep-or-drop of the try-3 questions. Kept only when its line is one the previous try's reds named and its
+ * text is non-blank, at most {@link MAX_QUESTIONS}; every drop comes back with its reason, for the draft's log.
+ * @param {any} raw @param {number[]} failedLines
+ * @returns {{kept: {line: number, question: string}[], dropped: {reason: string, raw: any}[]}}
+ */
+export function normalizeQuestions(raw: any, failedLines: number[]): {
+    kept: {
+        line: number;
+        question: string;
+    }[];
+    dropped: {
+        reason: string;
+        raw: any;
+    }[];
+};
+/**
+ * Did this try FAIL THE SEED READ (hamr's ruling 2026-10-10, differing from fwdloop's validation-only rule)? It did when a work
+ * stage instrument-stopped, or when no work stage is red on the repo as it is — the vacuous close ("nothing in the close fails
+ * at all": it grades nothing). The mandatory guards (`guardNames`) are green at the seed by design and never count as work.
+ * The job lines it names are the `fromLine`s of the stages the seed read named (the instrument-stopped ones, else every work
+ * stage); if none of them maps to a real line, EVERY numbered job line counts.
+ * @param {any[]} rows @param {any} declaration @param {string[]} guardNames @param {number[]} lineNums
+ * @returns {{failed: boolean, lines: number[]}}
+ */
+export function seedReadFailure(rows: any[], declaration: any, guardNames: string[], lineNums: number[]): {
+    failed: boolean;
+    lines: number[];
+};
 /** @param {boolean} isRepo @returns {typeof DESTINATION_FIELD_REPO} */
 export function destinationFieldFor(isRepo: boolean): typeof DESTINATION_FIELD_REPO;
 /** The frozen question set for a picked class. Throws on a locked or unknown
@@ -69,14 +106,34 @@ export function schemaCoverage(catalogue?: Record<string, any>): {
  * THROWS on a catalogue it cannot cover: a malformed catalogue is a bareloop bug,
  * and failing loudly beats emitting a schema that quietly cannot say something
  * the validator will then demand.
+ * `questions` (P7 item 5, last drafting try only) adds the optional `questions` property; absent, the schema is byte-identical.
  * @param {Record<string, any>} [catalogue]
- * @param {{verdictType?: string|null}} [o]
+ * @param {{verdictType?: string|null, questions?: boolean}} [o]
  */
-export function declarationSchema(catalogue?: Record<string, any>, { verdictType }?: {
+export function declarationSchema(catalogue?: Record<string, any>, { verdictType, questions }?: {
     verdictType?: string | null;
+    questions?: boolean;
 }): {
     type: string;
     properties: {
+        questions?: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                    };
+                    question: {
+                        type: string;
+                        minLength: number;
+                    };
+                };
+                required: string[];
+            };
+            description: string;
+        } | undefined;
         stages: {
             type: string;
             minItems: number;
@@ -92,6 +149,16 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
                             type: string;
                             description: string;
                         };
+                        fromLine: {
+                            type: string;
+                            minItems: number;
+                            uniqueItems: boolean;
+                            items: {
+                                type: string;
+                                minimum: number;
+                            };
+                            description: string;
+                        };
                         kind: {
                             const: string;
                         };
@@ -115,6 +182,27 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
             };
             description: string;
         };
+        refused: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    reason: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            description: string;
+        };
     };
     required: string[];
     additionalProperties: boolean;
@@ -123,19 +211,38 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
  * The output channel. It records and acknowledges; it takes no action, which is
  * why handing it to a toolless authoring call does not reopen D3.
  * @param {{calls: any[]}} box
- * @param {{catalogue?: Record<string, any>, verdictType?: string|null}} [o]
+ * @param {{catalogue?: Record<string, any>, verdictType?: string|null, questions?: boolean}} [o]
  */
 export function declarationTool(box: {
     calls: any[];
-}, { catalogue, verdictType }?: {
+}, { catalogue, verdictType, questions }?: {
     catalogue?: Record<string, any>;
     verdictType?: string | null;
+    questions?: boolean;
 }): {
     name: string;
     description: string;
     parameters: {
         type: string;
         properties: {
+            questions?: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        line: {
+                            type: string;
+                            minimum: number;
+                        };
+                        question: {
+                            type: string;
+                            minLength: number;
+                        };
+                    };
+                    required: string[];
+                };
+                description: string;
+            } | undefined;
             stages: {
                 type: string;
                 minItems: number;
@@ -151,6 +258,16 @@ export function declarationTool(box: {
                                 type: string;
                                 description: string;
                             };
+                            fromLine: {
+                                type: string;
+                                minItems: number;
+                                uniqueItems: boolean;
+                                items: {
+                                    type: string;
+                                    minimum: number;
+                                };
+                                description: string;
+                            };
                             kind: {
                                 const: string;
                             };
@@ -174,6 +291,27 @@ export function declarationTool(box: {
                 };
                 description: string;
             };
+            refused: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        line: {
+                            type: string;
+                            minimum: number;
+                            description: string;
+                        };
+                        reason: {
+                            type: string;
+                            minLength: number;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
@@ -260,16 +398,27 @@ export function writeScopeBlock(writeScope: string[]): string;
  * acceptance — BINDING, never re-decided by the composer, and a DIFFERENT
  * meaning from `openQuestions` (which means "could not resolve"): the two
  * never merge.
- * @param {{checks: string[], protections: string[], openQuestions?: string[], notChecked?: string[],
+ * @param {{checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[],
  *   answeredQuestions?: string[]}} confirmed
  */
 export function confirmedBlock(confirmed: {
     checks: string[];
+    checkItems?: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
     protections: string[];
     openQuestions?: string[];
     notChecked?: string[];
     answeredQuestions?: string[];
 }): string;
+/**
+ * P7: the job-line tagging order (model-facing, registered). Rule 1 of the job block: every stage the drafter writes
+ * names the ONE numbered job line it serves, or the line is refused with a reason; the mandatory guards serve no line.
+ * The $0 validator (validateDeclaration, `jobLines`) enforces it and the revise loop feeds a miss back.
+ * @param {number} count how many numbered job lines the person wrote
+ */
+export function jobLineTagBlock(count: number): string;
 /**
  * The whole authoring prompt, as one string.
  *
@@ -292,9 +441,10 @@ export function confirmedBlock(confirmed: {
  *   guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
  *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>,
  *   writeScope?: string[]|null,
- *   confirmed?: {checks: string[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
+ *   jobLines?: {n: number}[]|null, inputs?: {n: number, label: string, value: string}[]|null,
+ *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
  */
-export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue, writeScope, confirmed, }: {
+export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue, writeScope, jobLines, inputs, confirmed, }: {
     answers: Record<string | number, string>;
     questions?: Record<string | number, string>;
     facts: any;
@@ -311,8 +461,20 @@ export function authorPrompt({ answers, questions, facts, listingBlock, lang, ve
     mode?: "tool" | "text";
     catalogue?: Record<string, any>;
     writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
     confirmed?: {
         checks: string[];
+        checkItems?: {
+            text: string;
+            fromLine: number[] | null;
+        }[];
         protections: string[];
         openQuestions?: string[];
         notChecked?: string[];
@@ -457,7 +619,7 @@ export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }: {
  */
 /**
  * @param {{ceilingUsd?: number|null,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void}} [o]
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void}} [o]
  *   `ceilingUsd` is the OPERATOR's ceiling; `null`/absent is UNBOUNDED.
  *   `onCall` is a REPORTING seam fired as each metered call lands — the shell's
  *   only chance to know what has been spent while the run is still alive. It is
@@ -473,6 +635,7 @@ export function makeCostBook({ ceilingUsd, onCall }?: {
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
 }): {
     /** @param {string} label @param {any} r a bare-agent run result @param {number} [attempt] */
@@ -537,16 +700,18 @@ export function makeCostBook({ ceilingUsd, onCall }?: {
  * `cacheMessages` (F18) and `maxTokens` (F30) are not optional on this stack.
  * `rates` is the customer's own price for this provider's key row (USD per 1K, `ratesFor`);
  * absent = bare-agent's built-in guess, exactly as before.
- * @param {any} provider @param {{system?: string, maxTokens?: number, rates?: {in: number, out: number}|null}} [o]
+ * `draftThinking` ('on' | 'off', operator knob; default 'off') adds the drafter's per-call thinking option via `draftCallOptions`.
+ * @param {any} provider @param {{system?: string, maxTokens?: number, rates?: {in: number, out: number}|null, draftThinking?: string}} [o]
  * @returns {(messages: any[], tools: any[], opts?: any) => Promise<any>}
  */
-export function makeLoopGenerate(provider: any, { system, maxTokens, rates }?: {
+export function makeLoopGenerate(provider: any, { system, maxTokens, rates, draftThinking }?: {
     system?: string;
     maxTokens?: number;
     rates?: {
         in: number;
         out: number;
     } | null;
+    draftThinking?: string;
 }): (messages: any[], tools: any[], opts?: any) => Promise<any>;
 /**
  * ONE structured ask, with the malformed-emission retry bounded on its OWN axis.
@@ -564,7 +729,7 @@ export function makeLoopGenerate(provider: any, { system, maxTokens, rates }?: {
  *   label: string, book: ReturnType<typeof makeCostBook>,
  *   channel: {name: string, instruction: string, textPath?: string, tool: (box: {calls: any[]}) => any}}} o
  * @returns {Promise<{artifact: any, attempts: number, convo: any[], raw: string,
- *   providerError: string|null, red: Red|null, budget: 'cap-halt'|'pricing-red'|null}>}
+ *   providerError: string|null, red: Red|null, budget: 'cap-halt'|'pricing-red'|null, allCutOff?: boolean}>}
  */
 export function askStructured({ messages, generate, mode, retries, label, book, channel }: {
     messages: any[];
@@ -589,7 +754,18 @@ export function askStructured({ messages, generate, mode, retries, label, book,
     providerError: string | null;
     red: Red | null;
     budget: "cap-halt" | "pricing-red" | null;
+    allCutOff?: boolean;
 }>;
+/**
+ * The confirm plan's checks as `{text, fromLine}` items. The schema asks for objects (P7: each check names the job line
+ * it is for); a bare string (a text-mode reply, an older caller) reads as a check with no line.
+ * @param {any} raw the plan's `checks`
+ * @returns {{text: string, fromLine: number[]|null}[]}
+ */
+export function normalizeChecks(raw: any): {
+    text: string;
+    fromLine: number[] | null;
+}[];
 /** The output channel. It records and acknowledges; it takes no action.
  * @param {{calls: any[]}} box */
 export function confirmTool(box: {
@@ -618,9 +794,9 @@ export function confirmTool(box: {
  * @param {{answers: Record<string|number, string>, questions: Record<string|number, string>,
  *   labels?: Record<string|number, string>, facts?: any, listing?: string|null,
  *   writeScope?: string[]|null, isRepo: boolean, lang: string, worseThanBefore?: string,
- *   fixText?: string|null, protections?: string[]}} o
+ *   fixText?: string|null, protections?: string[], inputs?: {n: number, label: string, value: string}[]|null}} o
  */
-export function confirmPrompt({ answers, questions, labels, facts, listing, writeScope, isRepo, lang, worseThanBefore, fixText, protections }: {
+export function confirmPrompt({ answers, questions, labels, facts, listing, writeScope, isRepo, lang, worseThanBefore, fixText, protections, inputs }: {
     answers: Record<string | number, string>;
     questions: Record<string | number, string>;
     labels?: Record<string | number, string>;
@@ -632,6 +808,11 @@ export function confirmPrompt({ answers, questions, labels, facts, listing, writ
     worseThanBefore?: string;
     fixText?: string | null;
     protections?: string[];
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
 }): string;
 /**
  * THE CONFIRM TURN: the $0 half (worse-than-before for a repo, a language
@@ -655,18 +836,18 @@ export function confirmPrompt({ answers, questions, labels, facts, listing, writ
  *   generate: Function, book: ReturnType<typeof makeCostBook>,
  *   ask: (step: {kind: string, [k: string]: any}) => Promise<string|null>,
  *   onPhase?: (phase: string, data?: any) => void, mode?: 'tool'|'text',
- *   worseThanBefore?: string}} o retired field (hamr's ruling 2026-09-28):
+ *   worseThanBefore?: string, inputs?: {n: number, label: string, value: string}[]|null}} o retired field (hamr's ruling 2026-09-28):
  *   `worseThanBefore` is never asked any more and defaults to `''` — a
  *   caller may still pass a string through (kept for a future, non-ask
  *   source of the same constraint), it just never comes from an ask() step.
  * @returns {Promise<{ok: boolean,
  *   stop: null|'cap-halt'|'pricing-red'|'provider-red'|'artifact-red'|'confirm-abandoned'|'confirm-restart',
  *   rounds: number,
- *   accepted: {goal: string, checks: string[], protections: string[], lang: string,
+ *   accepted: {goal: string, checks: string[], checkItems: {text: string, fromLine: number[]|null}[], protections: string[], lang: string,
  *     worseThanBefore: string, openQuestions: string[], notChecked: string[], answeredQuestions?: string[]}|null,
  *   reds: Red[], cost: any}>}
  */
-export function runConfirmTurn({ verdictType, answers, questions, labels, facts, listing, writeScope, isRepo, lang, generate, book, ask, onPhase, mode, worseThanBefore: presetWorseThanBefore, }: {
+export function runConfirmTurn({ verdictType, answers, questions, labels, facts, listing, writeScope, isRepo, lang, generate, book, ask, onPhase, mode, worseThanBefore: presetWorseThanBefore, inputs, }: {
     verdictType: string;
     answers: Record<string | number, string>;
     questions: Record<string | number, string>;
@@ -689,6 +870,11 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
     onPhase?: (phase: string, data?: any) => void;
     mode?: "tool" | "text";
     worseThanBefore?: string;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
 }): Promise<{
     ok: boolean;
     stop: null | "cap-halt" | "pricing-red" | "provider-red" | "artifact-red" | "confirm-abandoned" | "confirm-restart";
@@ -696,6 +882,10 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
     accepted: {
         goal: string;
         checks: string[];
+        checkItems: {
+            text: string;
+            fromLine: number[] | null;
+        }[];
         protections: string[];
         lang: string;
         worseThanBefore: string;
@@ -746,14 +936,16 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
  *   generate: Function, seedReadFn?: Function, closeCtx?: any,
  *   ceilingUsd?: number|null,
  *   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,
  *   maxRevisions?: number, structureRetries?: number,
  *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>, writeScope?: string[]|null,
  *   priorCalls?: {label: string, costUsd: number|null, unpricedRounds: number}[]|null,
  *   priorRaws?: any[]|null,
- *   confirmed?: {checks: string[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
+ *   jobLines?: {n: number, text: string}[]|null, inputs?: {n: number, label: string, value: string}[]|null,
+ *   offerQuestions?: boolean,
+ *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null}} o
  */
-export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, writeScope, scout, listing, priorCalls, priorRaws, confirmed, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue, }: {
+export function authorClose({ workdir, seedRef, lang, verdictType, answers, questions, writeScope, scout, listing, priorCalls, priorRaws, confirmed, jobLines, inputs, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue, offerQuestions, }: {
     workdir: string;
     seedRef: string;
     lang: string;
@@ -784,6 +976,7 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
+        thinkingApplied?: boolean | null;
     }) => void;
     maxRevisions?: number;
     structureRetries?: number;
@@ -796,8 +989,22 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
         unpricedRounds: number;
     }[] | null;
     priorRaws?: any[] | null;
+    jobLines?: {
+        n: number;
+        text: string;
+    }[] | null;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
+    offerQuestions?: boolean;
     confirmed?: {
         checks: string[];
+        checkItems?: {
+            text: string;
+            fromLine: number[] | null;
+        }[];
         protections: string[];
         openQuestions?: string[];
         notChecked?: string[];
@@ -821,6 +1028,16 @@ export const REVISE_RED_CAP: 20;
 export const AUTHOR_MAX_TOKENS: 32000;
 /** the one slot the model fills on an injected guard */
 export const FILL_MARKER: "<FILL IN>";
+/** P7 item 5 (fwdloop am24/25): the most questions the MACHINE keeps from the try-3 drafter. The drafter is never told this number. */
+export const MAX_QUESTIONS: 2;
+/**
+ * The model-visible words of the optional `questions` property — offered ONLY on the last drafting try and only after the
+ * two before it both failed validation (a mechanism, never a wish: the schema carries it on that one call and nowhere
+ * else). It lives in the property's description, so the frozen revise turn stays measurement-only. No digit and no number
+ * word anywhere in it (a test greps this): the machine, not the prompt, bounds the count.
+ */
+export const QUESTIONS_DESCRIPTION: string;
+export function isOutputCutOff(r: any): boolean;
 /**
  * THE FROZEN REVISE INSTRUCTION — gate-2 round 3's own text, byte for byte
  * (`scratch-gate2/author.mjs:63`, the turn that PASSED both arms). It is the only
@@ -889,6 +1106,15 @@ export const SOURCE_FIELD: Readonly<{
     label: "Source";
     prompt: "A local folder, subfolder or file, or one URL the machine can reach (no login, no setup).";
 }>;
+/** P7: the Inputs box's wording (replaces Source). Line 1 is the repo; lines 2+ are tracked files inside it. */
+export const INPUTS_FIELD: Readonly<{
+    id: "inputs";
+    kind: "mechanical";
+    label: "Inputs";
+    prompt: string;
+}>;
+/** P7: how to write "The job" (printed under its question by the CLI; the panel's box shows the same in its examples). */
+export const JOB_BLOCK_HELP: readonly string[];
 /** Destination's wording when Source resolved to a git repo: the answer IS the
  * signed `writeScope` fence (ITEM33-BUILD.md M3 ruling 2). */
 export const DESTINATION_FIELD_REPO: Readonly<{
@@ -907,8 +1133,11 @@ export const DESTINATION_FIELD_PLAIN: Readonly<{
     prompt: string;
 }>;
 /**
- * THE FREE-TEXT TRIO EVERY CLASS SHARES: Goal, What success looks like,
- * Guardrails — numbered contiguously from 1. This is what `answers[1..3]` are
+ * P7 (2026-10-10, docs/product/PANEL-BUILD.md): the old free-text trio (Goal, What success looks like, Guardrails) is ONE
+ * answer now — "The job", the person's numbered lines with their `~` rules (src/jobblock.js renders it). What follows
+ * is the history of the trio, kept because the numbering rule below still holds.
+ *
+ * THE FREE-TEXT SLOTS EVERY CLASS SHARES, numbered contiguously from 1. This is what `answers[1..3]` are
  * filed under for every class; soft-green appends a fourth
  * (`SOFTGREEN_QUESTIONS`) and hitl appends a different fourth
  * (`HITL_QUESTIONS`), each its own next number rather than a fixed one, so a
@@ -918,7 +1147,7 @@ export const DESTINATION_FIELD_PLAIN: Readonly<{
  * 2026-09-10 "The intake form (RULED)" ruling, `docs/product/PRD.md`) — not the
  * old worded questions ("What do you want done?", "How do you check today
  * whether it's working?", "...worse than before?"). Motivated by run `mtv8jihy`
- * (F159, `docs/logs/FINDINGS.md`): a rulebook this prompt commit did not touch
+ * (F159, `docs/wiki/FINDINGS.md`): a rulebook this prompt commit did not touch
  * still had to compile against a card built from a person's actual bar, and the
  * old wording never matched what got signed — this reshape (commit 1ac4d05)
  * trimmed the SET to three slots but left their PROSE unreconciled with the
@@ -927,9 +1156,7 @@ export const DESTINATION_FIELD_PLAIN: Readonly<{
  * `authorPrompt`'s interview block and `scripts/run-interview.mjs`.
  */
 export const GREEN_QUESTIONS: Readonly<{
-    1: "what you want to achieve";
-    2: "checks a machine can count";
-    3: "what must not happen or change";
+    1: "the job, as numbered lines — each line may carry the rules (~) the person wrote under it";
 }>;
 /**
  * The signed table's own label for each of {@link GREEN_QUESTIONS}' keys — "the
@@ -943,9 +1170,7 @@ export const GREEN_QUESTIONS: Readonly<{
  * calls `questionsFor` — additive, nothing existing breaks.
  */
 export const FIELD_LABELS: Readonly<{
-    1: "Goal";
-    2: "What success looks like";
-    3: "Guardrails";
+    1: "The job";
 }>;
 /** The soft-green quartet's own key for Judge Examples — exported so
  * `cardauthor.js` reads the SAME number this module files the answer under,
@@ -956,12 +1181,10 @@ export const SOFTGREEN_JUDGE_EXAMPLES_KEY: number;
  * you'd pass and one you'd fail, and say why."). Exported so `cardauthor.js`'s
  * prompt and this module's own `SOFTGREEN_QUESTIONS` render the identical
  * string; its label ("Judge examples") lives in `SOFTGREEN_FIELD_LABELS`. */
-export const JUDGE_EXAMPLES_QUESTION: "one pass, one fail, and why";
+export const JUDGE_EXAMPLES_QUESTION: "the PASS: and FAIL: examples the person wrote under their job lines, each with its line number";
 /** {@link FIELD_LABELS} plus Judge Examples' own label, for the soft-green set. */
 export const SOFTGREEN_FIELD_LABELS: Readonly<{
-    1: "Goal";
-    2: "What success looks like";
-    3: "Guardrails";
+    1: "The job";
 }>;
 /**
  * THE SOFTGREEN SET — the green trio plus Judge Examples. A judged close needs
@@ -973,9 +1196,7 @@ export const SOFTGREEN_FIELD_LABELS: Readonly<{
  * nothing from it.
  */
 export const SOFTGREEN_QUESTIONS: Readonly<{
-    1: "what you want to achieve";
-    2: "checks a machine can count";
-    3: "what must not happen or change";
+    1: "the job, as numbered lines — each line may carry the rules (~) the person wrote under it";
 }>;
 /**
  * THE HITL SET (N4 slice 1, kept in code only — never offered in the form or
@@ -986,9 +1207,7 @@ export const SOFTGREEN_QUESTIONS: Readonly<{
  * set's next number, not a fixed one, so a green-side trim renumbers it too.
  */
 export const HITL_QUESTIONS: Readonly<{
-    1: "what you want to achieve";
-    2: "checks a machine can count";
-    3: "what must not happen or change";
+    1: "the job, as numbered lines — each line may carry the rules (~) the person wrote under it";
 }>;
 /**
  * The three sets, all LIVE as of softgreen module 3. The locked shape stays
@@ -1039,7 +1258,7 @@ export const LANGUAGE_PICK_FIELD: Readonly<{
     prompt: "This repo has more than one supported language's manifest at the same level. Which one is this job about?";
 }>;
 /**
- * F175's open half (docs/logs/FINDINGS.md, run mu0voeo4), hamr's ruling
+ * F175's open half (docs/wiki/FINDINGS.md, run mu0voeo4), hamr's ruling
  * (2026-09-16): "Confirm" and "Type the goal yourself" may not bypass a
  * `questions` entry the model itself raised on the plan being accepted — the
  * person answers it inline, one question at a time, with NO extra model