bareloop 0.41.0 → 0.43.0

package/types/declaredclose.d.ts

@@ -53,7 +53,8 @@ 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, jobLines?: {n: number}[]|null}} [opts]
+ *   catalogue?: Record<string, any>, verdictType?: string|null, writeScope?: string[]|null, jobLines?: {n: number}[]|null,
+ *   inputLabels?: string[]|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}}
@@ -68,6 +69,7 @@ export function validateCloseDecl(closeDecl: any, opts?: {
     jobLines?: {
         n: number;
     }[] | null;
+    inputLabels?: string[] | null;
 }): {
     ok: boolean;
     reds: Red[];
@@ -162,7 +164,7 @@ export function closeGrade(v: any): {
 /** @typedef {{code: string, path: string, detail: string, [k: string]: any}} Red */
 /** The genres a `closeDecl` may name. v1 admits exactly one (D13) — a genre
  * classifier is designed the day there is a second genre to classify. */
-export const DECLARED_GENRES: readonly "TYPES"[];
+export const DECLARED_GENRES: readonly string[];
 /**
  * The exact field set of a `closeDecl` — anything else is a smuggle channel, the
  * same rule `STAGE_FIELDS` enforces on a command stage.
@@ -185,7 +187,7 @@ export const CLOSE_DECL_FIELDS: readonly string[];
 /** what a stored calibration set carries, ENUMERATED: the frozen cases and the judge
  * tier that graded them. Both are inside the spec, so `jobSpecHash` covers both — which
  * is the whole mechanism behind "a judge-model bump forces a full recalibration"
- * (src/judged.js, `JUDGE_MODEL`): the field moves, the hash moves, the signature dies,
+ * (src/judged.js, `resolveJudge`): the field moves, the hash moves, the signature dies,
  * and the re-sign re-runs the gate. Anything else in there is a field nobody reads. */
 export const CALIBRATION_FIELDS: readonly string[];
 /**

package/types/facts.d.ts

@@ -0,0 +1,71 @@
+/** the `fact` part of a step's parameters, or null (a step has at most one) @param {any} params @returns {any|null} */
+export function factPartOf(params: any): any | null;
+/**
+ * The SHAPE of a `fact` part (what it may carry), pushed as reds in the same form `rubricStepShapeReds` uses. Whether the
+ * bareguard rubric it builds is signable is asked of bareguard itself (`checkRubricParts` builds it once at drafting).
+ * @param {any} part @param {string} w the path prefix @param {(code: string, path: string, detail: string) => void} red
+ */
+export function factShapeReds(part: any, w: string, red: (code: string, path: string, detail: string) => void): void;
+/**
+ * bareguard's `decides` list for a fact part: one decide per fact, in the fact order (so `d<j>` is the fact's own index).
+ * @param {any} part @returns {Record<string, any>[]}
+ */
+export function factDecides(part: any): Record<string, any>[];
+/**
+ * The claims bareguard reads for a fact step, built from the step file's `results`. The claim TEXT is written here, by code,
+ * from the values the worker gave (the worker writes no claim text): `name: value; name: value`. A phrase fact contributes its
+ * own signed words. A result that is not an object, or has no string quote, still becomes a claim — an empty one — so
+ * bareguard reds it by name rather than the result vanishing.
+ * @param {any} part @param {unknown} results @returns {{claim: string, quote: string, values?: Record<string, string>}[]}
+ */
+export function factClaims(part: any, results: unknown): {
+    claim: string;
+    quote: string;
+    values?: Record<string, string>;
+}[];
+/**
+ * One fact as a plain row, written by code from the signed fields:
+ * `fact · price — money, at most 450 US dollars, after "Price", quoted from "Flights"`.
+ * @param {any} f @param {string} source
+ * @returns {string}
+ */
+export function factSentence(f: any, source: string): string;
+/**
+ * One fact as the WORKER is told it (item 7): what to write for it and where in the quote it sits, in plain words, from the signed
+ * fields. A phrase fact has no value to write — the quote has to say it.
+ * @param {any} f @returns {string}
+ */
+export function factBrief(f: any): string;
+/** the "N results" row of a fact part, or null @param {any} part @returns {string|null} */
+export function countSentence(part: any): string | null;
+/**
+ * Every plan-card row a fact part carries: its facts, then its count.
+ * @param {any} part @returns {string[]}
+ */
+export function factRows(part: any): string[];
+/**
+ * One bareguard `cited` item (`#<result>:d<j>:<reason>[:<detail>]`, or `#<result>:<reason>`) as a sentence the worker can act
+ * on. The names and numbers are bareguard's measurements and the person's signed facts, never inferred here.
+ * @param {string} item @param {any} part @returns {string}
+ */
+export function plainFactItem(item: string, part: any): string;
+/**
+ * The fields each fact shape takes, in the fact part's own names (`rule` = bareguard's op/value/lo/hi; `unit`/`currency`; `phrase`
+ * = the presence decide's phrases), read off bareguard's rubric vocabulary.
+ * @returns {Record<string, string[]>} shape -> the fields it takes besides name and shape
+ */
+export function factShapeFields(): Record<string, string[]>;
+/**
+ * The lines the drafter is shown about which shape takes which fields, generated from {@link factShapeFields} (shapes with the same
+ * fields are listed together). One owner: the composer brief and the confirm note both print this.
+ * @returns {string}
+ */
+export function factShapeGuide(): string;
+/** the shapes a fact may have (bareguard's value kinds, plus `phrase` = a presence decide) */
+export const FACT_SHAPES: readonly string[];
+/** the comparison ops a rule may use (bareguard's) */
+export const FACT_OPS: readonly string[];
+/** bareguard signs at most this many decides on one `cited` check */
+export const MAX_FACTS: 10;
+/** every field a part of class `fact` may carry (the shared ones are checked by rubricStepShapeReds) */
+export const FACT_PART_FIELDS: readonly string[];

package/types/factwords.d.ts

@@ -0,0 +1,42 @@
+/**
+ * How many times exact words occur in a source, white space blind. Zero for empty words.
+ * @param {string} source the raw source text @param {string} words
+ * @returns {number}
+ */
+export function countExact(source: string, words: string): number;
+/**
+ * How many times a phrase or unit occurs as WHOLE words, case and spacing aside ("SFO" is not found inside "sfocus").
+ * @param {string} source @param {string} words @returns {number}
+ */
+export function countPhrase(source: string, words: string): number;
+/**
+ * The reds for ONE fact part against its frozen source text.
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan}} o
+ * @returns {{code: string, detail: string}[]}
+ */
+export function checkFactWords({ part, text, line, scan }: {
+    part: any;
+    text: string;
+    line: number | string;
+    scan?: import("./labelscan.js").LabelScan;
+}): {
+    code: string;
+    detail: string;
+}[];
+/**
+ * The reds for every fact part of a declaration. A fact part whose input text is not at hand is a red: a check whose words were never
+ * proved against the source is never signed.
+ * @param {any} declaration @param {Record<string, string>|null} texts label -> frozen text
+ * @returns {{code: string, path: string, detail: string}[]}
+ */
+export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null): {
+    code: string;
+    path: string;
+    detail: string;
+}[];
+/**
+ * The look's own proof hook: how often a phrase the look built is in an input.
+ * @param {Record<string, string>} texts @returns {(source: string, phrase: string) => number}
+ */
+export function proverOf(texts: Record<string, string>): (source: string, phrase: string) => number;
+export function squash(t: string): string;

package/types/inputlook.d.ts

@@ -0,0 +1,238 @@
+/**
+ * The input as the AI sees it: lines with any run of white space (U+202F included) made one space and the page reader's bracketed tags
+ * (`[ref=549]`) removed - an id that is only the page reader's, never part of a label.
+ * @param {string} text @returns {string[]}
+ */
+export function lookLines(text: string): string[];
+/**
+ * The two read-only tools: search the input text, read a slice around a hit. They are closures over in-memory text and touch nothing
+ * else - read-only BY CONSTRUCTION, not by a fence. Several inputs: the `input` argument names which (its label).
+ * @param {Record<string, string>} texts label -> frozen text
+ * @returns {{name: string, description: string, parameters: any, execute: (a: any) => Promise<any>}[]}
+ */
+export function lookReadTools(texts: Record<string, string>): {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (a: any) => Promise<any>;
+}[];
+/** the strict answer form (a JSON schema - never free prose with JSON inside) */
+export function lookReportSchema(): {
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        facts: {
+            type: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    name: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    shape: {
+                        enum: string[];
+                    };
+                    source: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                    label: {
+                        type: string;
+                        description: string;
+                    };
+                    value: {
+                        type: string;
+                        description: string;
+                    };
+                    example: {
+                        type: string;
+                        description: string;
+                    };
+                    rule: {
+                        type: string;
+                        additionalProperties: boolean;
+                        required: string[];
+                        properties: {
+                            op: {
+                                enum: string[];
+                            };
+                            value: {};
+                            lo: {};
+                            hi: {};
+                        };
+                        description: string;
+                    };
+                    aiProposal: {
+                        type: string;
+                        description: string;
+                    };
+                    forRule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                };
+            };
+        };
+        prose: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                    };
+                    text: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        notFound: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                additionalProperties: boolean;
+                required: string[];
+                properties: {
+                    line: {
+                        type: string;
+                        minimum: number;
+                    };
+                    rule: {
+                        type: string;
+                        minimum: number;
+                        description: string;
+                    };
+                    words: {
+                        type: string;
+                        description: string;
+                    };
+                    why: {
+                        type: string;
+                        minLength: number;
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * What the AI is told: the numbered job, the inputs and their label lists, and what to do.
+ * @param {{jobLines: {n: number, text: string, rule?: string, rules?: string[]}[], labels: string[], lists: Record<string, string>}} o
+ * @returns {string}
+ */
+export function lookPrompt({ jobLines, labels, lists }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    labels: string[];
+    lists: Record<string, string>;
+}): string;
+/**
+ * Turn the AI's raw report into a VERIFIED one, by code, at $0. A fact is carried only when: its shape is a real shape, its source is
+ * a real input, and its label is ON THE LIST for that input and shape (an id is resolved to its exact words). Anything else is moved
+ * to `notFound` with a plain reason naming the word - never dropped silently. `prove` is the "found in the source" test of the
+ * phrase a phrase fact builds (label + value), supplied by the caller.
+ * @param {unknown} raw
+ * @param {{scans: Record<string, import('./labelscan.js').LabelScan>, jobLines: {n: number}[], prove?: (source: string, phrase: string) => number}} o
+ * @returns {LookReport}
+ */
+export function verifyLookReport(raw: unknown, { scans, jobLines, prove }: {
+    scans: Record<string, import("./labelscan.js").LabelScan>;
+    jobLines: {
+        n: number;
+    }[];
+    prove?: (source: string, phrase: string) => number;
+}): LookReport;
+/**
+ * The look's report as the DRAFTER reads it: one block, per job line, of what can be checked (with the exact words to copy) and what
+ * could not be found. Written by code from the verified report.
+ * @param {LookReport} report @returns {string}
+ */
+export function renderLookReport(report: LookReport): string;
+/**
+ * The label scans and the rendered lists for the inputs the look will read.
+ * @param {Record<string, string>} texts
+ * @returns {{scans: Record<string, import('./labelscan.js').LabelScan>, lists: Record<string, string>}}
+ */
+export function labelListsOf(texts: Record<string, string>): {
+    scans: Record<string, import("./labelscan.js").LabelScan>;
+    lists: Record<string, string>;
+};
+/**
+ * L3: a reason the AI gave, cut only at a sentence end (never mid-sentence): whole sentences while they fit in `max` characters,
+ * and nothing at all if the first one alone does not fit. A trailing full stop is dropped (the caller closes the clause).
+ * @param {string} text @param {number} max @returns {string}
+ */
+export function wholeSentences(text: string, max: number): string;
+/**
+ * I1 (hamr, 2026-10-13, "Ruled by hamr" 2): when the look shows the person's intent on one `~` rule was NOT captured - its words or
+ * meaning are not in the source - the person is asked about THAT rule at once, named by its line and rule. Only a look entry that names
+ * a rule number counts; anything else the look could not find is not asked piecemeal (it is Not checked, or the whole job is reviewed).
+ * The wording is the code's own, never the model's. The keep-or-drop and the cap are `normalizeQuestions` (src/authorflow.js).
+ * @param {LookNotFound[]} notFound @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{line: number, question: string}[]} every candidate question (the caller applies the machine's caps)
+ */
+export function ruleQuestions(notFound: LookNotFound[], jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[]): {
+    line: number;
+    question: string;
+}[];
+/** the name of the answer tool - the one place the AI's report enters */
+export const LOOK_REPORT_TOOL: "report_look";
+/** how many hits one search returns at most, and how long a snippet or a read line is */
+export const LOOK_MAX_HITS: 40;
+export { LABEL_SHAPES };
+export type LookFact = {
+    line: number;
+    name: string;
+    shape: string;
+    source: string;
+    label?: string;
+    labelId?: string;
+    value?: string;
+    phrase?: string;
+    example: string;
+    rule?: any;
+    aiProposal?: boolean;
+    forRule?: number;
+};
+export type LookNotFound = {
+    line: number;
+    rule?: number;
+    words?: string;
+    why: string;
+};
+export type LookReport = {
+    facts: LookFact[];
+    prose: {
+        line: number;
+        text?: string;
+    }[];
+    notFound: LookNotFound[];
+};
+import { LABEL_SHAPES } from './labelscan.js';

package/types/job.d.ts

@@ -99,7 +99,8 @@ export function jobSpecHash(job: object): string;
  * share a workflow key iff they ran the same goal, checks, guardrails and close — whatever source they ran on, wherever they wrote, whatever caps they had.
  * It is NOT a signature: {@link jobSpecHash} (which covers the caps and the fence) stays what the person signs, and
  * a reuse lands on a NEW jobSpecHash with the SAME workflowKey. Same never-throws contract as `jobSpecHash`, and
- * the same resolved-`tools` form, so an omitted-`tools` spec and its spelled-out menu share a key.
+ * the same resolved-`tools` form, so an omitted-`tools` spec and its spelled-out menu share a key. A soft-green spec keys on its
+ * RESOLVED judge identity (an absent `judge` is its worker's), so pinning the default judge never changes the key.
  * @param {object} job
  * @returns {string} sha256 hex
  */
@@ -277,6 +278,12 @@ export const CONDITION_KEYS: readonly string[];
  * reuse (so what the key ignores is exactly what the person may edit, never two spellings).
  */
 export const REUSE_OPEN_SPEC_FIELDS: readonly string[];
+/**
+ * The signed spec's schedule fields: {@link workflowKey} ignores them too, so a scheduled spec keeps the workflow
+ * key of the green run it was scheduled from (else Reuse would refuse every scheduled spec). They stay inside
+ * {@link jobSpecHash}. Kept apart from {@link REUSE_OPEN_SPEC_FIELDS}, which names the Reuse boxes.
+ */
+export const SCHEDULE_SPEC_FIELDS: readonly string[];
 /**
  * The worker-identity fields {@link workflowKey} ALSO ignores (hamr 2026-10-04: Model is open on a reuse; the Name
  * chosen in Settings carries its provider and baseUrl with it). They stay inside {@link jobSpecHash}, so what the person

package/types/jobblock.d.ts

@@ -52,11 +52,18 @@ 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.
+ * PART 1a (hamr's ruling P1=B, docs/product/ITEM33-BUILD.md "Addendum 2026-10-12"): the examples are required of a rubric
+ * job ONLY when it holds a judged part. A rubric job on the person's own local files holds none in this build (its
+ * parts are counted or checked against a quote), so the caller says `judged: false` and a block without examples fits.
+ * Examples written anyway are never a red there — they simply have no judge to read them yet.
  * @param {JobLine[]} lines
  * @param {boolean} rubric
+ * @param {{judged?: boolean}} [o] `judged` (default true): does this job hold a judged part, so that it needs examples?
  * @returns {string|null} the plain red, or null when the block fits the Check type
  */
-export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean): string | null;
+export function jobBlockFitsCheck(lines: JobLine[], rubric: boolean, { judged }?: {
+    judged?: 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

package/types/labelscan.d.ts

@@ -0,0 +1,38 @@
+/** @typedef {{id: string, label: string, count: number, example: string}} LabelEntry */
+/** @typedef {Record<'money'|'number'|'date'|'time'|'text', LabelEntry[]>} LabelScan */
+/** @param {string} t @returns {string} white space made one space, quote marks at the edges dropped, trimmed - how a label is compared */
+export function normLabel(t: string): string;
+/**
+ * Scan one source text for the labels that sit before values, per shape.
+ * @param {string} text
+ * @returns {LabelScan}
+ */
+export function scanLabels(text: string): LabelScan;
+/**
+ * Is this label on the list for this shape? Compared the way a label is read: white space of any kind is one space, quote marks at the
+ * edges are dropped. `idOrText` may be a list id (`t1`) or the exact words.
+ * @param {LabelScan} scan @param {string} shape @param {unknown} idOrText
+ * @returns {LabelEntry|null}
+ */
+export function labelOnList(scan: LabelScan, shape: string, idOrText: unknown): LabelEntry | null;
+/**
+ * The list as the look and the drafter are shown it, one block per shape that has any label.
+ * @param {string} inputLabel the input the list belongs to @param {LabelScan} scan
+ * @returns {string}
+ */
+export function renderLabelList(inputLabel: string, scan: LabelScan): string;
+/** the shapes a list is made for */
+export const LABEL_SHAPES: readonly string[];
+/** a label must occur at least this often to be listed (1: a one-page document with one total still has its label; the list is cut to the highest counts) */
+export const MIN_COUNT: 1;
+/** how many labels one shape's list holds at most (the highest counts first) */
+export const MAX_PER_SHAPE: 40;
+/** only this much of a source is scanned (a source over it is scanned up to a line end) */
+export const SCAN_MAX_CHARS: 2000000;
+export type LabelEntry = {
+    id: string;
+    label: string;
+    count: number;
+    example: string;
+};
+export type LabelScan = Record<"money" | "number" | "date" | "time" | "text", LabelEntry[]>;

package/types/pagefetch.d.ts

@@ -0,0 +1,71 @@
+/** @param {unknown} v @returns {boolean} an http(s) address (the one spelling of "this Inputs value is a web address") */
+export function isWebUrl(v: unknown): boolean;
+/**
+ * How much of a fetched page is the page's own content: the snapshot's header lines (url, size note, hint) and every part of the tree
+ * under a banner / navigation / contentinfo landmark are taken out, the page reader's bracketed tags are removed, and what is left is
+ * counted. Generic - no site names, only the ARIA landmark roles. Text that is not a snapshot tree (a plain file) has no landmark, so it
+ * counts whole.
+ * @param {string} text @returns {number}
+ */
+export function pageContentChars(text: string): number;
+/**
+ * @typedef {{goto: (url: string, timeout?: number) => Promise<void>, waitForNetworkIdle: (o?: {idle?: number, timeout?: number}) => Promise<void>,
+ *   snapshot: (o?: {mode?: string}) => Promise<string>, close: () => Promise<void>}} FetchPage the part of barebrowse's page handle the fetch uses
+ */
+/**
+ * Fetch one page's text. `connect` is injected (a test never reaches the network); the default is barebrowse's own `connect`.
+ * @param {string} url
+ * @param {{connect?: (opts: Record<string, any>) => Promise<FetchPage>, timeoutMs?: number, idleMs?: number, idleTimeoutMs?: number, closeWaitMs?: number}} [o]
+ * @returns {Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>} `error` is plain words, without a spend line
+ */
+export function fetchPageText(url: string, { connect, timeoutMs, idleMs, idleTimeoutMs, closeWaitMs }?: {
+    connect?: (opts: Record<string, any>) => Promise<FetchPage>;
+    timeoutMs?: number;
+    idleMs?: number;
+    idleTimeoutMs?: number;
+    closeWaitMs?: number;
+}): Promise<{
+    ok: true;
+    text: string;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** the session options (incognito: no auth ever enters; blockPrivateNetwork: SSRF guard); ONE frozen object so a test can pin them */
+export const CONNECT_OPTIONS: Readonly<{
+    incognito: true;
+    blockPrivateNetwork: true;
+}>;
+/** the snapshot options step 0 proved */
+export const SNAPSHOT_OPTIONS: Readonly<{
+    mode: "act";
+}>;
+/** the page's network must be quiet this long (ms) before we read it: long enough to span the gap between a page's first load and the
+ *  script requests that fill the results, short enough not to stretch a plain page */
+export const NETWORK_IDLE_MS: 1500;
+/** the most we wait for the network to go quiet (ms); a page that never settles (polling, streaming) is read as it stands after this */
+export const NETWORK_IDLE_TIMEOUT_MS: 20000;
+/** the most we wait for the page to load at all (ms) */
+export const GOTO_TIMEOUT_MS: 30000;
+/** a page that comes back with fewer characters than this (after trimming) is treated as "nothing came back" */
+export const MIN_PAGE_CHARS: 200;
+/** the page text left after the site's own header, menus and footer are taken out must hold at least this many characters, or the page is
+ *  "only site chrome" (L2: a 719-character fetch of Google's header and sign-in passed the 200-character floor) */
+export const MIN_CONTENT_CHARS: 100;
+/** our own deadline around one whole fetch (a hung browser leaves no trace; this is the only thing that fires on the absence of an answer) */
+export const PAGE_FETCH_TIMEOUT_MS: 90000;
+/**
+ * the part of barebrowse's page handle the fetch uses
+ */
+export type FetchPage = {
+    goto: (url: string, timeout?: number) => Promise<void>;
+    waitForNetworkIdle: (o?: {
+        idle?: number;
+        timeout?: number;
+    }) => Promise<void>;
+    snapshot: (o?: {
+        mode?: string;
+    }) => Promise<string>;
+    close: () => Promise<void>;
+};

package/types/panel/authorroutes.d.ts

@@ -41,6 +41,9 @@ export function checkHumanGuard(req: import("node:http").IncomingMessage, { toke
  * @param {{ port: number, token: string, env?: Record<string,string|undefined>,
  *   sessionsRoot?: string, spawnFn?: typeof realSpawn, bareloopBin?: string,
  *   jobsDir?: string, fetchImpl?: typeof fetch, home?: string,
+ *   schedules?: ReturnType<typeof import('./schedules.js').createScheduleDoor>,
+ *   sessionDeps?: Record<string, any>,
+ *   runJobNames?: () => string[],
  *   startFrom?: {get: (runid: string, o?: {model?: string}) => any, getImport: (id: string, o?: {model?: string}) => any, listJobs?: (o?: {model?: string}) => any[]} }} opts
  */
 export function createAuthorRoutes(opts: {
@@ -53,6 +56,9 @@ export function createAuthorRoutes(opts: {
     jobsDir?: string;
     fetchImpl?: typeof fetch;
     home?: string;
+    schedules?: ReturnType<typeof import("./schedules.js").createScheduleDoor>;
+    sessionDeps?: Record<string, any>;
+    runJobNames?: () => string[];
     startFrom?: {
         get: (runid: string, o?: {
             model?: string;
@@ -67,6 +73,26 @@ export function createAuthorRoutes(opts: {
 }): {
     handle: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, pathname: string, body: any) => boolean;
     sessions: Map<string, any>;
+    headless: Map<string, any>;
+    startSession: (card: any, reuse: {
+        spec: any;
+        workflowKey: string;
+    } | null, inputs: import("../jobblock.js").JobInput[], o?: {
+        headless?: boolean;
+        filesJob?: boolean;
+    }) => Promise<{
+        ok: true;
+        session: ReturnType<typeof createSession>;
+    } | {
+        ok: false;
+        status: number;
+        error: string;
+    }>;
+    envNow: () => Record<string, string | undefined>;
+    spawnFn: typeof realSpawn;
+    bareloopBin: string;
+    /** a headless session the starter has removed from disk leaves its map too @param {string} id */
+    forgetHeadless: (id: string) => void;
 };
 /**
  * The panel's OWN 2-decimal money render for a chat line — hamr's ruling
@@ -89,7 +115,7 @@ export function panelMoney2(n: number): string;
  * it to sign"), and this is where it is checked, not trusted.
  * @param {ReturnType<typeof createSession>} session
  * @param {string} claimedHash
- * @param {{env: any, spawnFn: typeof realSpawn, bareloopBin: string, sessionsRoot?: string, home?: string}} o
+ * @param {{env: any, spawnFn: typeof realSpawn, bareloopBin: string, sessionsRoot?: string, home?: string, reviewDoor?: boolean, onSpawnError?: (e: Error) => void, onExit?: (code: number|null) => void}} o
  * @returns {{ok: boolean, error?: string, job?: string}}
  */
 export function signRun(session: ReturnType<typeof createSession>, claimedHash: string, o: {
@@ -98,10 +124,17 @@ export function signRun(session: ReturnType<typeof createSession>, claimedHash:
     bareloopBin: string;
     sessionsRoot?: string;
     home?: string;
+    reviewDoor?: boolean;
+    onSpawnError?: (e: Error) => void;
+    onExit?: (code: number | null) => void;
 }): {
     ok: boolean;
     error?: string;
     job?: string;
 };
+/** plain words for a run whose saved job no longer passes today's `validateJob` (RULED 2026-10-15): never the raw red codes */
+export const OLD_JOB_REUSE_WORDS: "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be reused. Start a new job instead.";
+export const OLD_JOB_RESUME_WORDS: "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be resumed. Use Reuse workflow on a newer run, or start a new job.";
+export const OLD_JOB_ACCEPT_WORDS: "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be accepted. Use Reuse workflow on a newer run, or start a new job.";
 import { spawn as realSpawn } from 'node:child_process';
 import { createSession } from './authorsession.js';