bareloop 0.40.0 → 0.42.0

package/types/authorflow.d.ts

@@ -63,13 +63,16 @@ export function labelsFor(verdictType: string): Record<string | number, string>;
  * close — one source, never a second hand-typed list — rendered through the
  * frozen line in {@link GUARD_DESCRIPTIONS}, plus the write fence (a real,
  * signed fence — {@link writeScopeBlock}'s own subject) when one is set.
- * @param {{verdictType: string, lang: string, writeScope?: string[]|null}} o
+ * @param {{verdictType: string, lang: string, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} o
  * @returns {string[]}
  */
-export function confirmProtections({ verdictType, lang, writeScope }: {
+export function confirmProtections({ verdictType, lang, writeScope, jobLines }: {
     verdictType: string;
     lang: string;
     writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): string[];
 /**
  * The mechanical seam between the catalogue and the schema, read BOTH ways: a
@@ -107,12 +110,15 @@ export function schemaCoverage(catalogue?: Record<string, any>): {
  * 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.
+ * `kinds` (Part 1a) narrows the branches to the kinds a language may use (`catalogueForLang`) WITHOUT narrowing the coverage check,
+ * which stays over the whole catalogue; null (the default) = no narrowing.
  * @param {Record<string, any>} [catalogue]
- * @param {{verdictType?: string|null, questions?: boolean}} [o]
+ * @param {{verdictType?: string|null, questions?: boolean, kinds?: string[]|null}} [o]
  */
-export function declarationSchema(catalogue?: Record<string, any>, { verdictType, questions }?: {
+export function declarationSchema(catalogue?: Record<string, any>, { verdictType, questions, kinds }?: {
     verdictType?: string | null;
     questions?: boolean;
+    kinds?: string[] | null;
 }): {
     type: string;
     properties: {
@@ -192,6 +198,11 @@ export function declarationSchema(catalogue?: Record<string, any>, { verdictType
                         minimum: number;
                         description: string;
                     };
+                    rule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
                     reason: {
                         type: string;
                         minLength: number;
@@ -211,14 +222,15 @@ 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, questions?: boolean}} [o]
+ * @param {{catalogue?: Record<string, any>, verdictType?: string|null, questions?: boolean, kinds?: string[]|null}} [o]
  */
 export function declarationTool(box: {
     calls: any[];
-}, { catalogue, verdictType, questions }?: {
+}, { catalogue, verdictType, questions, kinds }?: {
     catalogue?: Record<string, any>;
     verdictType?: string | null;
     questions?: boolean;
+    kinds?: string[] | null;
 }): {
     name: string;
     description: string;
@@ -301,6 +313,11 @@ export function declarationTool(box: {
                             minimum: number;
                             description: string;
                         };
+                        rule: {
+                            type: string;
+                            minimum: number;
+                            description: string;
+                        };
                         reason: {
                             type: string;
                             minLength: number;
@@ -400,6 +417,7 @@ export function writeScopeBlock(writeScope: string[]): string;
  * never merge.
  * @param {{checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[],
  *   answeredQuestions?: string[]}} confirmed
+ * @param {{numbered?: boolean}} [o] `numbered` (a rubric job on files): each confirmed check carries its `#n`, which a part cites in `covers`
  */
 export function confirmedBlock(confirmed: {
     checks: string[];
@@ -411,6 +429,8 @@ export function confirmedBlock(confirmed: {
     openQuestions?: string[];
     notChecked?: string[];
     answeredQuestions?: string[];
+}, { numbered }?: {
+    numbered?: boolean;
 }): string;
 /**
  * P7: the job-line tagging order (model-facing, registered). Rule 1 of the job block: every stage the drafter writes
@@ -439,12 +459,14 @@ export function jobLineTagBlock(count: number): string;
  * @param {{answers: Record<string|number, string>, questions?: Record<string|number, string>,
  *   facts: any, listingBlock: string, lang: string, verdictType: string,
  *   guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
- *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>,
+ *   ownedEnvNames?: string[], mode?: 'tool'|'text', catalogue?: Record<string, any>|null,
  *   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[], answeredQuestions?: string[]}|null}} o
+ *   confirmed?: {checks: string[], checkItems?: {text: string, fromLine: number[]|null}[], protections: string[], openQuestions?: string[], notChecked?: string[], answeredQuestions?: string[]}|null,
+ *   labelLists?: string[]|null,
+ * }} o
  */
-export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue, writeScope, jobLines, inputs, confirmed, }: {
+export function authorPrompt({ answers, questions, facts, listingBlock, lang, verdictType, guards, ownedEnvNames, mode, catalogue: catalogueIn, writeScope, jobLines, inputs, confirmed, labelLists, }: {
     answers: Record<string | number, string>;
     questions?: Record<string | number, string>;
     facts: any;
@@ -459,7 +481,7 @@ export function authorPrompt({ answers, questions, facts, listingBlock, lang, ve
     }[];
     ownedEnvNames?: string[];
     mode?: "tool" | "text";
-    catalogue?: Record<string, any>;
+    catalogue?: Record<string, any> | null;
     writeScope?: string[] | null;
     jobLines?: {
         n: number;
@@ -480,6 +502,45 @@ export function authorPrompt({ answers, questions, facts, listingBlock, lang, ve
         notChecked?: string[];
         answeredQuestions?: string[];
     } | null;
+    labelLists?: string[] | null;
+}): string;
+/**
+ * The composer prompt for a rubric job on local files (Part 1a, docs/product/ITEM33-BUILD.md). There is no repository
+ * and no survey: the facts are the numbered inputs and the listing is the frozen tree (input/ files, output/). It states
+ * the step-file contract the worker is also told ({@link stepFileContract}), so the stage and the file cannot drift.
+ * @param {{answers: Record<string|number, string>, questions?: Record<string|number, string>, facts: any, listingBlock: string,
+ *   verdictType: string, guards: {name: string, kind: string, params: Record<string, any>, fill: string[]}[],
+ *   mode?: 'tool'|'text', catalogue?: Record<string, any>, writeScope?: string[]|null,
+ *   jobLines?: {n: number}[]|null, inputs?: {n: number, label: string, value: string}[]|null, confirmed?: any,
+ *   labelLists?: string[]|null,
+ * }} o
+ * @returns {string}
+ */
+export function rubricAuthorPrompt({ answers, questions, facts, listingBlock, verdictType, guards, mode, catalogue, writeScope, jobLines, inputs, confirmed, labelLists, }: {
+    answers: Record<string | number, string>;
+    questions?: Record<string | number, string>;
+    facts: any;
+    listingBlock: string;
+    verdictType: string;
+    guards: {
+        name: string;
+        kind: string;
+        params: Record<string, any>;
+        fill: string[];
+    }[];
+    mode?: "tool" | "text";
+    catalogue?: Record<string, any>;
+    writeScope?: string[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
+    inputs?: {
+        n: number;
+        label: string;
+        value: string;
+    }[] | null;
+    confirmed?: any;
+    labelLists?: string[] | null;
 }): string;
 /**
  * The seed read, as the model sees it: mechanical labels, no editorial. Per-stage
@@ -619,7 +680,7 @@ export function resolveSourcePrefixes({ workdir, sourcePaths, seedFiles }: {
  */
 /**
  * @param {{ceilingUsd?: number|null,
- *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingApplied?: boolean|null}) => void}} [o]
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => 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
@@ -635,7 +696,7 @@ export function makeCostBook({ ceilingUsd, onCall }?: {
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
-        thinkingApplied?: boolean | null;
+        thinkingStatus?: string;
     }) => void;
 }): {
     /** @param {string} label @param {any} r a bare-agent run result @param {number} [attempt] */
@@ -700,7 +761,7 @@ 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.
- * `draftThinking` ('on' | 'off', operator knob; default 'off') adds the drafter's per-call thinking option via `draftCallOptions`.
+ * `draftThinking` ('on' | 'off', the job's "Thinking on" tick spelled as a word; default 'off') adds the drafter's per-call thinking option via `thinkingCallOptions` (src/thinking.js, the one owner).
  * @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>}
  */
@@ -836,7 +897,8 @@ 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, inputs?: {n: number, label: string, value: string}[]|null}} o retired field (hamr's ruling 2026-09-28):
+ *   worseThanBefore?: string, inputs?: {n: number, label: string, value: string}[]|null,
+ *   jobLines?: {n: number}[]|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.
@@ -847,7 +909,7 @@ export function confirmPrompt({ answers, questions, labels, facts, listing, writ
  *     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, inputs, }: {
+export function runConfirmTurn({ verdictType, answers, questions, labels, facts, listing, writeScope, isRepo, lang, generate, book, ask, onPhase, mode, worseThanBefore: presetWorseThanBefore, inputs, jobLines, }: {
     verdictType: string;
     answers: Record<string | number, string>;
     questions: Record<string | number, string>;
@@ -875,6 +937,9 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
         label: string;
         value: string;
     }[] | null;
+    jobLines?: {
+        n: number;
+    }[] | null;
 }): Promise<{
     ok: boolean;
     stop: null | "cap-halt" | "pricing-red" | "provider-red" | "artifact-red" | "confirm-abandoned" | "confirm-restart";
@@ -936,7 +1001,7 @@ 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, thinkingApplied?: boolean|null}) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
  *   maxRevisions?: number, structureRetries?: number,
  *   structuredMode?: 'tool'|'text', catalogue?: Record<string, any>, writeScope?: string[]|null,
  *   priorCalls?: {label: string, costUsd: number|null, unpricedRounds: number}[]|null,
@@ -945,7 +1010,7 @@ export function runConfirmTurn({ verdictType, answers, questions, labels, facts,
  *   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, jobLines, inputs, generate, seedReadFn, closeCtx, ceilingUsd, onPhase, onCall, maxRevisions, structureRetries, structuredMode, catalogue, offerQuestions, }: {
+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: catalogueIn, offerQuestions, }: {
     workdir: string;
     seedRef: string;
     lang: string;
@@ -976,7 +1041,7 @@ export function authorClose({ workdir, seedRef, lang, verdictType, answers, ques
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
-        thinkingApplied?: boolean | null;
+        thinkingStatus?: string;
     }) => void;
     maxRevisions?: number;
     structureRetries?: number;
@@ -1522,12 +1587,195 @@ export const PARAM_SCHEMAS: Readonly<{
         };
         description: string;
     };
+    step: {
+        type: string;
+        minimum: number;
+        description: string;
+    };
+    parts: {
+        type: string;
+        description: string;
+        items: {
+            type: string;
+            properties: {
+                text: {
+                    type: string;
+                    minLength: number;
+                    description: string;
+                };
+                class: {
+                    enum: string[];
+                };
+                check: {
+                    enum: string[];
+                    description: string;
+                };
+                value: {
+                    type: string;
+                    minimum: number;
+                    description: string;
+                };
+                names: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    description: string;
+                };
+                wordsPerSection: {
+                    type: string;
+                    minimum: number;
+                };
+                source: {
+                    type: string;
+                    minLength: number;
+                    description: string;
+                };
+                domains: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    description: string;
+                };
+                covers: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    items: {
+                        type: string;
+                        minimum: number;
+                    };
+                    description: string;
+                };
+                rules: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    items: {
+                        type: string;
+                        minimum: number;
+                    };
+                    description: string;
+                };
+                facts: {
+                    type: string;
+                    minItems: number;
+                    maxItems: number;
+                    description: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            name: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            shape: {
+                                enum: string[];
+                                description: string;
+                            };
+                            unit: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            currency: {
+                                enum: string[];
+                                description: string;
+                            };
+                            phrase: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            anchor: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            until: {
+                                type: string;
+                                minLength: number;
+                                description: string;
+                            };
+                            rule: {
+                                type: string;
+                                description: string;
+                                properties: {
+                                    op: {
+                                        enum: string[];
+                                    };
+                                    value: {
+                                        type: string[];
+                                        description: string;
+                                    };
+                                    lo: {
+                                        type: string[];
+                                    };
+                                    hi: {
+                                        type: string[];
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            aiProposal: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                count: {
+                    type: string;
+                    description: string;
+                    properties: {
+                        min: {
+                            type: string;
+                            minimum: number;
+                        };
+                        max: {
+                            type: string;
+                            minimum: number;
+                        };
+                    };
+                    additionalProperties: boolean;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
     ask: {
         type: string;
         minLength: number;
         description: string;
     };
 }>;
+/**
+ * What a rubric job on local files means by DONE — the class statement of the text genre (Part 1a). It is stated as an order
+ * about KINDS: every part of a job line is counted or checked against a quote, because nothing in this build judges.
+ */
+export const RUBRIC_FILES_STATEMENT: string;
+/**
+ * THE RUBRIC RULES, in one place (live fix B1): what the confirm step and the drafter are both told about turning the person's words
+ * into checks. The confirm note ({@link RUBRIC_CONFIRM_NOTE}) and the composer brief ({@link REQUIRED_FACTS_BRIEF}) interpolate THIS
+ * constant, so the two cannot drift (in smv6k6l8dxkzs the confirm step planned a limit the drafter then could not carry, and the
+ * drafter added an airport code the person never wrote). Field-neutral: neither turn needs the other's field names.
+ */
+export const RUBRIC_RULES: string;
+/**
+ * REQUIRED FACTS, as the composer is told them (PART 1b, PRD item 33 RF1–RF17). The shape of the fact part is in the catalogue and the
+ * schema; this is the judgement the schema cannot carry: what becomes a fact, where its words come from, and what is Not checked.
+ */
+export const REQUIRED_FACTS_BRIEF: string;
 export const CONFIRM_TOOL_NAME: "confirm_plan";
 /** Acknowledgement text the confirm tool's `execute` returns — mirrors
  * {@link DECLARATION_ACK}'s role: an output channel that records and
@@ -1545,6 +1793,12 @@ export const CONFIRM_STRUCTURE_INSTRUCTION: string;
  * an ORDER to the model itself, the same register {@link AUTHOR_SYSTEM} and
  * {@link CLASS_STATEMENTS} already use, rather than a code matcher over prose.
  */
+/**
+ * What the confirm turn tells the model about a rubric job on local text files (model-facing, registered). There is no
+ * repository and no judge: a check is a limit a machine counts (words, lines, sections), or a claim a quote from a named
+ * input must back. Everything else the person asked for is named in `notChecked`, in their words.
+ */
+export const RUBRIC_CONFIRM_NOTE: string;
 export const CONFIRM_SYSTEM: string;
 export type Red = {
     code: string;

package/types/authoring.d.ts

@@ -64,6 +64,15 @@ export function classMenu(verdictType: string | null, catalogue?: Record<string,
  * @param {string} kind @param {Record<string, KindSpec>} [catalogue]
  */
 export function envCapableKind(kind: string, catalogue?: Record<string, KindSpec>): boolean;
+/**
+ * The catalogue a close of this language may use. A rubric job on local files (`RUBRIC_LANG`) sees only
+ * {@link RUBRIC_LANG_KINDS}; every code language sees the whole catalogue MINUS the rubric-only kinds, so a code job's
+ * composer, schema and validator can never reach for a stage that reads step files. One filter, both directions.
+ * @param {string|null|undefined} lang
+ * @param {Record<string, KindSpec>} [catalogue]
+ * @returns {Record<string, KindSpec>}
+ */
+export function catalogueForLang(lang: string | null | undefined, catalogue?: Record<string, KindSpec>): Record<string, KindSpec>;
 /**
  * The floor's decision for one declared `cmd`, as a reason or null.
  *
@@ -80,6 +89,8 @@ export function envCapableKind(kind: string, catalogue?: Record<string, KindSpec
  * @param {string} cmd @returns {string|null}
  */
 export function deniedCommandReason(cmd: string): string | null;
+/** @param {unknown} lang @returns {string} the genre a close of this language is authored under */
+export function genreForLang(lang: unknown): string;
 /**
  * The warning line for a job whose ACTUAL stages carry the js `any` pattern, else
  * ''. Derived from the stages' patterns (never goal prose), so a job without the
@@ -274,7 +285,8 @@ export function judgedOutsideFence(paths: unknown, writeScope: string[] | null |
  * @param {{catalogue?: Record<string, KindSpec>, listing?: string[]|null,
  *   guards?: {name: string, kind: string, params: Record<string, any>, fill: string[]}[]|null,
  *   envOwned?: string[]|null, envInjected?: Record<string, string>|null, deferListing?: boolean,
- *   verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null}} [opts]
+ *   verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null, inputLabels?: string[]|null}} [opts]
+ *   `inputLabels` — the labels of the person's inputs (Part 1a). Present, a rubric-step `cited` part must name one of them.
  *   `jobLines` — the person's numbered job lines (P7). Present, every stage must name the line it serves and every
  *     line needs a stage or a refusal ({@link checkJobLines}); absent (every spec that predates the job block), the
  *     rule is not run.
@@ -310,6 +322,7 @@ export function validateDeclaration(declaration: any, opts?: {
     jobLines?: {
         n: number;
     }[] | null;
+    inputLabels?: string[] | null;
 }): {
     ok: boolean;
     reds: Red[];
@@ -482,6 +495,21 @@ export const DENIED_COMMANDS: readonly string[];
  */
 export const TYPES_GENRE_TEMPLATE: "1. The STRICT form of the language's type checker is used only when a confirmed check \u2014 or,\n   absent a confirm turn, the goal and interview answers \u2014 asks for strict typing; otherwise the\n   checker runs at whatever strictness the repo's own scripts already use.\n2. Tools are invoked so their binaries actually resolve \u2014 through the project's own package\n   runner or language module runner, never a bare binary name.\n3. The WORK stages \u2014 typecheck (error count IN the target scope, baseline 0, lower-is-better),\n   typecheck-outside (error count OUTSIDE the target scope, baseline measured at seed, a\n   ceiling \u2014 required whenever a typecheck stage is scoped to a subset of the tree), tests-kept\n   (a floor on tests that actually EXECUTED, baseline at seed, higher-is-better; a skipped or\n   deselected test did not run and must not count), and suite-green (the suite exits clean AND\n   reports zero failing tests \u2014 two assertions) \u2014 are composed ONLY for the checks a confirmed\n   plan asked for (or, absent a confirm turn, the goal and interview answers). The GUARDS \u2014\n   changed-from-seed and no-suppressions \u2014 are composed always, first-red-wins:\n   changed-from-seed before every WORK stage, no-suppressions last.\n4. One population per stage \u2014 two structurally different counts never share a stage.\n5. The checker must judge the PATIENT's own tree: if imports could resolve to an installed or\n   editable copy elsewhere, the environment is set so they resolve inside the patient.\n6. A number the tool did not report is unknown, never zero.";
 export const GENRE_LANGUAGES: readonly string[];
+/**
+ * PART 1a: the "language" of a RUBRIC job on local text files. It is not a code language and carries no suppression
+ * battery, no environment and no instruments — it only lets such a close declare which genre-shaped guards apply to it
+ * (`classGuards`) without pretending the file is JavaScript. `GENRE_LANGUAGES` stays the code-language menu (it is what a
+ * repo job's language detection and the confirm turn offer); this is the one extra value a close may DECLARE.
+ */
+export const RUBRIC_LANG: "text";
+/** the genre label a close over local text files carries (`closeDecl.genre`); the code languages' is `TYPES_GENRE.name`. Never the other's. */
+export const TEXT_GENRE: "TEXT";
+/** every `closeDecl.lang` a close may declare: the code languages plus the rubric-files one */
+export const DECLARABLE_LANGUAGES: readonly string[];
+/** the kinds that exist only for a rubric job on local files — a code job's menu, schema and validator never offer them */
+export const RUBRIC_ONLY_KINDS: readonly string[];
+/** the whole kind menu of a rubric job on local files: the one machine guard that applies to a file tree, plus its own stage */
+export const RUBRIC_LANG_KINDS: readonly string[];
 /** The worker-facing line that rides with the js `any` guard (run mv13ery3). */
 export const ANY_SUPPRESSION_WARNING: string;
 /**

package/types/authorjob.d.ts

@@ -30,18 +30,19 @@ export function refusalEvents(refusal: Refusal): {
  *     makes between a locked verdict and an invalid one).
  *
  * @param {{answers: Record<string|number, any>, verdictType?: string|null,
- *   repoPath?: string|null, questions?: Record<string|number, string>|null}} o
- *   `verdictType` and `repoPath` are STRUCTURED input from the UI, never parsed
+ *   repoPath?: string|null, questions?: Record<string|number, string>|null, required?: (string|number)[]|null}} o
+ *   `required` — the answer keys that must be present; absent = the picked class's whole set. `verdictType` and `repoPath` are STRUCTURED input from the UI, never parsed
  *   out of the prose of an answer: a class is picked off a radio and a path is
  *   read off the machine, or neither exists.
  * @returns {{ok: boolean, answers: Record<string|number, string>,
  *   verdictType: string|null, repoPath: string|null, refusal: Refusal|null, reds: Red[]}}
  */
-export function runInterview({ answers, verdictType, repoPath, questions }: {
+export function runInterview({ answers, verdictType, repoPath, questions, required: requiredOverride }: {
     answers: Record<string | number, any>;
     verdictType?: string | null;
     repoPath?: string | null;
     questions?: Record<string | number, string> | null;
+    required?: (string | number)[] | null;
 }): {
     ok: boolean;
     answers: Record<string | number, string>;
@@ -85,8 +86,8 @@ export function refuseLockedKind(kind: string): Refusal;
  *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null, judgeModel?: string|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, thinkingApplied?: boolean|null}) => void,
- *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string}) => void,
+ *   seedFn?: Function, scoutFn?: Function, listingFn?: Function, lookFn?: Function|null,
  *   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,
@@ -98,7 +99,7 @@ export function refuseLockedKind(kind: string): Refusal;
  *   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, 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, }: {
+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, lookFn, authorFn, authorOpts, signerFix, proposeFn, compileOpts, ask, confirmGenerate, isRepo, langResult, answerQuestions, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
@@ -130,11 +131,12 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
         label: string;
         costUsd: number | null;
         unpricedRounds: number;
-        thinkingApplied?: boolean | null;
+        thinkingStatus?: string;
     }) => void;
     seedFn?: Function;
     scoutFn?: Function;
     listingFn?: Function;
+    lookFn?: Function | null;
     authorFn?: Function;
     authorOpts?: object;
     writeScope?: string[] | null;

package/types/authorreadout.d.ts

@@ -199,6 +199,29 @@ export function plainKinds(): string[];
 export function plainReasons(reds: PlainRed[], { cases }?: {
     cases?: any;
 }): PlainReason[];
+/**
+ * WHY one drafting try was refused, in the code's own words: the unique `detail` of each red it raised (the same sentences
+ * `draftStopText` quotes at a stop), else the plain `reason` the loop gave (a seed-read failure raises no red). Scrubbed,
+ * one line, bounded; never empty.
+ * @param {{reds?: PlainRed[]|null, reason?: string|null}} o
+ * @returns {string}
+ */
+export function tryRefusedText({ reds, reason }: {
+    reds?: PlainRed[] | null;
+    reason?: string | null;
+}): string;
+/**
+ * A refused declaration as the drafting log keeps it (live fix A3), so a failed draft can be read and replayed at $0: the declaration
+ * itself, every secret masked as everywhere else (the JSON text goes through `redactSecrets`, then parses back), and bounded.
+ * @param {unknown} declaration
+ * @returns {{declaration: unknown}|{declarationText: string, declarationCut: true}|{}} nothing when there is no declaration
+ */
+export function declarationRecord(declaration: unknown): {
+    declaration: unknown;
+} | {
+    declarationText: string;
+    declarationCut: true;
+} | {};
 /**
  * THE MESSAGE a person reads when the rubric proposal was refused. Both doors
  * (the panel's failed step and the CLI) print exactly this.
@@ -218,10 +241,11 @@ export function proposalStopText({ stop, reds, cases, spend, source }: {
 }): string;
 /**
  * @param {{stop: string, reds?: PlainRed[]|null, refusal?: {detail?: string}|null,
- *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null}} o
+ *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null, wholeJob?: boolean}} o `wholeJob` - a rubric job on the person's
+ *   own inputs (PART 1c, I1): a failed draft asks nothing piecemeal; the person reviews the whole job and submits it again
  * @returns {string}
  */
-export function draftStopText({ stop, reds, refusal, spend }: {
+export function draftStopText({ stop, reds, refusal, spend, wholeJob }: {
     stop: string;
     reds?: PlainRed[] | null;
     refusal?: {
@@ -231,6 +255,7 @@ export function draftStopText({ stop, reds, refusal, spend }: {
         knownUsd?: number | null;
         spendComplete?: boolean | null;
     } | null;
+    wholeJob?: boolean;
 }): string;
 /**
  * Plain sentences for the reds of a refused signing, one or more per red. Card and practice-case reds reuse the