bareloop 0.43.0 → 0.44.0

package/types/draftspend.d.ts

@@ -3,6 +3,8 @@
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)
@@ -58,12 +60,33 @@ export function sessionDirForRow(row: {
     home?: string;
     sessionsRoot?: string;
 }): string | null;
+/**
+ * PRD v1.106 Part 5 Q1: one answered question as the two lines the Audit's drafting table shows under its step. ONE place owns the words.
+ * @param {{question: string, answer: string, source?: string, line?: number, at?: string}} h
+ * @returns {{question: string, answer: string, source: string, line?: number, at?: string, askedText: string, saidText: string}}
+ */
+export function humanRowWords(h: {
+    question: string;
+    answer: string;
+    source?: string;
+    line?: number;
+    at?: string;
+}): {
+    question: string;
+    answer: string;
+    source: string;
+    line?: number;
+    at?: string;
+    askedText: string;
+    saidText: string;
+};
 /**
  * Fold `<dir>/draft-log.jsonl` into one record per drafting step, each with its calls. A line that cannot be parsed is
  * skipped (a torn last line must not hide the rest).
  * @param {string} dir
  * @returns {{no: number, id: string, label: string, status: 'running'|'done'|'failed', startedAt: string, endedAt: string|null, wallMs: number|null,
- *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[]}[]}
+ *   calls: {label: string, model: string|null, costUsd: number|null, unpricedRounds: number, at: string}[],
+ *   humans: ReturnType<typeof humanRowWords>[]}[]}
  */
 export function readDraftSteps(dir: string): {
     no: number;
@@ -80,6 +103,7 @@ export function readDraftSteps(dir: string): {
         unpricedRounds: number;
         at: string;
     }[];
+    humans: ReturnType<typeof humanRowWords>[];
 }[];
 /**
  * The DRAFTING PART of a run (hamr 2026-10-06, option A): the first part of the run's views, built from the session's
@@ -109,6 +133,8 @@ export const DRAFT_LOG_FILE: "draft-log.jsonl";
  *  - `step-start`  {no, id, label, at}
  *  - `step-end`    {no, status: 'done'|'failed', label, at}   (a re-opened step writes `step-reopen` {no, at} first)
  *  - `step-label`  {no, label, at}   (the step reads `label` from now on, status and times untouched: the thinking row's "the model thought anyway" / "can't change it" / "not confirmed")
+ *  - `human`       {no, source: 'confirm'|'try-3'|'look', question, answer, line?, at}: one question the person was asked and what they answered (the answer is secret-masked
+ *    before it is written; the row is written only when BOTH exist, so a question nobody answered leaves no row)
  *  - `call`        {no, step, label, model, thinking, thinkingSupport, thinkingStatus?, costUsd (null stays null), unpricedRounds, at}: one METERED model call
  *    (`thinking` = the tick's mode: off | on; `thinkingSupport` = bare-agent's lookup for the model: true | false | 'unverified';
  *    `thinkingStatus` = bare-agent's own verdict for the call's run: applied | unsupported | ignored | unknown, present only when thinkingMode was sent)

package/types/facts.d.ts

@@ -23,6 +23,14 @@ export function factClaims(part: any, results: unknown): {
     quote: string;
     values?: Record<string, string>;
 }[];
+/**
+ * One amount of a money fact in the fact's OWN signed forms, never a hardcoded sign: `symbolFirst` puts the currency sign before the amount
+ * ("$144") when the fact has one, else the unit after it ("144 US dollars"); not `symbolFirst` (a rule's bound) prefers the unit.
+ * @param {any} f a money fact @param {string|number} n @param {boolean} symbolFirst @returns {string}
+ */
+export function moneyAs(f: any, n: string | number, symbolFirst: boolean): string;
+/** @param {any} f a fact with a rule @returns {string} the rule in words, e.g. "at most 450 US dollars" */
+export function ruleWords(f: any): 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"`.
@@ -69,3 +77,10 @@ export const FACT_OPS: readonly string[];
 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[];
+/** the limits bareguard 0.24 puts on a money fact's lists (ruling #65), enforced here first so the red is ours and plain */
+export const MAX_CURRENCIES: 3;
+export const MAX_UNITS: 10;
+export const MAX_UNIT_CHARS: 100;
+export function asList(v: unknown): string[];
+export function moneyForms(f: any): string[];
+export function boundOk(shape: string, v: unknown): boolean;

package/types/factwords.d.ts

@@ -9,16 +9,35 @@ export function countExact(source: string, words: string): number;
  * @param {string} source @param {string} words @returns {number}
  */
 export function countPhrase(source: string, words: string): number;
+/**
+ * What the page-word map (src/pagemap.js) KEPT and DROPPED for one input: the sets the second proof reads. A look from the old search-and-read
+ * path has no `dropped` list, so it gives null and the label is proved against the code-made list as before.
+ * @param {{facts?: any[], dropped?: (import('./pagerules.js').Dropped & {source?: string})[]}|null|undefined} look @param {string} source
+ * @returns {{labels: Set<string>, units: Set<string>, currencies: Set<string>, words: Set<string>, dropped: Map<string, import('./pagerules.js').Dropped>}|null}
+ */
+export function keptSetOf(look: {
+    facts?: any[];
+    dropped?: (import("./pagerules.js").Dropped & {
+        source?: string;
+    })[];
+} | null | undefined, source: string): {
+    labels: Set<string>;
+    units: Set<string>;
+    currencies: Set<string>;
+    words: Set<string>;
+    dropped: Map<string, import("./pagerules.js").Dropped>;
+} | null;
 /**
  * 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
+ * @param {{part: any, text: string, line: number|string, scan?: import('./labelscan.js').LabelScan, kept?: ReturnType<typeof keptSetOf>}} o
  * @returns {{code: string, detail: string}[]}
  */
-export function checkFactWords({ part, text, line, scan }: {
+export function checkFactWords({ part, text, line, scan, kept }: {
     part: any;
     text: string;
     line: number | string;
     scan?: import("./labelscan.js").LabelScan;
+    kept?: ReturnType<typeof keptSetOf>;
 }): {
     code: string;
     detail: string;
@@ -27,9 +46,13 @@ export function checkFactWords({ part, text, line, scan }: {
  * 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
+ * @param {{facts?: any[], dropped?: any[]}|null} [look] the page-word map's report: what it kept and dropped (null = no map, the code-made list is the proof)
  * @returns {{code: string, path: string, detail: string}[]}
  */
-export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null): {
+export function checkDeclarationWords(declaration: any, texts: Record<string, string> | null, look?: {
+    facts?: any[];
+    dropped?: any[];
+} | null): {
     code: string;
     path: string;
     detail: string;

package/types/inputlook.d.ts

@@ -148,6 +148,12 @@ export function lookPrompt({ jobLines, labels, lists }: {
     labels: string[];
     lists: Record<string, string>;
 }): string;
+/**
+ * A fact the page-word map kept (src/pagerules.js `KeptFact`), as the look report carries it: a phrase fact holds its alternative
+ * phrases; any other holds its labels (the first is the primary), and a money fact its units and currencies.
+ * @param {import('./pagerules.js').KeptFact} k @param {string} source @returns {LookFact}
+ */
+export function lookFactOf(k: import("./pagerules.js").KeptFact, source: string): LookFact;
 /**
  * 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
@@ -207,6 +213,9 @@ 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 };
+/**
+ * `words` / `labels` / `unit` / `currency`: what the page-word map kept (idea A core)
+ */
 export type LookFact = {
     line: number;
     name: string;
@@ -220,6 +229,11 @@ export type LookFact = {
     rule?: any;
     aiProposal?: boolean;
     forRule?: number;
+    reading?: import("./pagerules.js").Reading;
+    words?: string[];
+    labels?: string[];
+    unit?: string[];
+    currency?: string[];
 };
 export type LookNotFound = {
     line: number;
@@ -234,5 +248,6 @@ export type LookReport = {
         text?: string;
     }[];
     notFound: LookNotFound[];
+    dropped?: import("./pagerules.js").Dropped[];
 };
 import { LABEL_SHAPES } from './labelscan.js';

package/types/kinds.d.ts

@@ -645,6 +645,11 @@ export type Ctx = {
         timeoutMs?: number;
         deadlineMs?: number;
     };
+    onRubricEvidence?: (e: {
+        step: number;
+        evidence: any[];
+        evidenceTotal?: number;
+    }) => void;
     onStage?: (row: {
         stage: string | null;
         kind: string | null;

package/types/pagedropwords.d.ts

@@ -0,0 +1,26 @@
+/** @param {Dropped} d @returns {string} the plain sentence for one drop */
+export function dropSentence(d: Dropped): string;
+/**
+ * One row per fact that lost something: the sentences (one per dropped word, then the fact's own), and whether the whole fact went.
+ * @param {Dropped[]|undefined|null} dropped
+ * @returns {{line: number, rule?: number, fact: string, full: boolean, sentences: string[]}[]}
+ */
+export function dropRows(dropped: Dropped[] | undefined | null): {
+    line: number;
+    rule?: number;
+    fact: string;
+    full: boolean;
+    sentences: string[];
+}[];
+/**
+ * A row as one Not-checked line, in the person's own words: `line N: "<the ~ rule as written, or the fact's name>" — <sentences>`.
+ * @param {{line: number, rule?: number, fact: string, sentences: string[]}} row @param {any[]|null|undefined} jobLines @param {(l: any) => string[]} rulesOf
+ * @returns {string}
+ */
+export function dropLine(row: {
+    line: number;
+    rule?: number;
+    fact: string;
+    sentences: string[];
+}, jobLines: any[] | null | undefined, rulesOf: (l: any) => string[]): string;
+export type Dropped = import("./pagerules.js").Dropped;

package/types/pagemap.d.ts

@@ -0,0 +1,154 @@
+/**
+ * What the AI is told, for ONE page input. Ported from the POC prompt: the job, the `~` rules, "a result is one item", the answer form
+ * and the shape meanings.
+ * @param {{jobLines: {n: number, text: string, rule?: string, rules?: string[]}[], label: string, text: string}} o
+ * @returns {string}
+ */
+export function mapPrompt({ jobLines, label, text }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    label: string;
+    text: string;
+}): string;
+/**
+ * Read the AI's answer: ONE JSON object of the answer form, and nothing else. No repair (hamr's ruling): text that is not JSON, JSON of
+ * another form, or a fact whose shape or lists are not of the form is a malformed answer.
+ * @param {unknown} text @returns {{ok: true, mapping: import('./pagerules.js').PageMap}|{ok: false}}
+ */
+export function parseMapAnswer(text: unknown): {
+    ok: true;
+    mapping: import("./pagerules.js").PageMap;
+} | {
+    ok: false;
+};
+/**
+ * Run the map: one call per page input.
+ * @param {{texts: Record<string, string>, inputs: {n: number, label: string}[], jobLines: {n: number, text: string, rule?: string, rules?: string[]}[],
+ *   provider?: any, maxTokens?: number, ceilingUsd?: number|null, callTimeoutMs?: number,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number, thinkingStatus?: string, raw?: string}) => void,
+ *   createLoop?: (o: {system: string, onLlmResult: any, provider: any, rates?: {in: number, out: number}}) => any,
+ *   rates?: {in: number, out: number}|null, callOptions?: Record<string, any>, sleep?: (ms: number) => Promise<void>, prove?: Function}} o
+ * @returns {Promise<{state: 'PRESENT'|'ABSENT', facts: any, reason: string|null, cause: string|null, meta: any, raw: string,
+ *   raws: ReturnType<typeof scrubRaw>[], calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
+ *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
+ */
+export function runPageMap({ texts, inputs, jobLines, provider, maxTokens, ceilingUsd, callTimeoutMs, onCall, createLoop, rates, callOptions, sleep, }: {
+    texts: Record<string, string>;
+    inputs: {
+        n: number;
+        label: string;
+    }[];
+    jobLines: {
+        n: number;
+        text: string;
+        rule?: string;
+        rules?: string[];
+    }[];
+    provider?: any;
+    maxTokens?: number;
+    ceilingUsd?: number | null;
+    callTimeoutMs?: number;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+        thinkingStatus?: string;
+        raw?: string;
+    }) => void;
+    createLoop?: (o: {
+        system: string;
+        onLlmResult: any;
+        provider: any;
+        rates?: {
+            in: number;
+            out: number;
+        };
+    }) => any;
+    rates?: {
+        in: number;
+        out: number;
+    } | null;
+    callOptions?: Record<string, any>;
+    sleep?: (ms: number) => Promise<void>;
+    prove?: Function;
+}): Promise<{
+    state: "PRESENT" | "ABSENT";
+    facts: any;
+    reason: string | null;
+    cause: string | null;
+    meta: any;
+    raw: string;
+    raws: ReturnType<typeof scrubRaw>[];
+    calls: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
+}>;
+/** @param {unknown} q a recorded question @returns {string|null} the reading a reading ask proposed, or null when it was another kind of question */
+export function readingOfQuestion(q: unknown): string | null;
+/**
+ * PRD v1.107 Part 5b ("the look reads, code asks"): the early asks CODE forces before any paid drafting, from the look's own result. Every `~` rule is
+ * one of three kinds:
+ *   - PAGE: a kept page word carries it (a kept fact with `forRule` and no `reading`): no ask.
+ *   - READING: a kept fact carries it with a `reading` (a limit the page cannot hold, e.g. "not a red-eye" -> departure time between 06:00 and 21:00).
+ *     Asked only when a bound of the reading is NOT in the words the person wrote (the same test as `rubric-fact-unmarked`, `boundInWords`); a
+ *     bound they wrote themselves is theirs and nothing is asked. `agree` writes the reading as a `~` rule in plain words (the answer text is
+ *     `reading`), so the drafter is told it and the fact signs plain.
+ *   - CAN'T CHECK: no kept fact carries it (PRD v1.106 Part 5 Q3 T2). `drop it` leaves it Not checked.
+ * One ask per rule text on a line; readings first, then can't-check asks, each in line order. The caller applies the machine's cap and the answer gate.
+ * @param {{facts?: {line: number, forRule?: number, name?: string, shape?: string, unit?: string[], currency?: string[], reading?: import('./pagerules.js').Reading}[]}|null|undefined} look
+ * @param {{n: number, text?: string, rule?: string, rules?: string[]}[]|null|undefined} jobLines
+ * @returns {LookAsk[]}
+ */
+export function askableFromLook(look: {
+    facts?: {
+        line: number;
+        forRule?: number;
+        name?: string;
+        shape?: string;
+        unit?: string[];
+        currency?: string[];
+        reading?: import("./pagerules.js").Reading;
+    }[];
+} | null | undefined, jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[] | null | undefined): LookAsk[];
+/**
+ * PRD v1.107 Part 5b: more asks than the machine's cap means the job needs a rewrite, not a questionnaire. The code-owned stop words list EVERY ask and
+ * its reading as the suggestion (no extra paid call). A secret in a rule is masked.
+ * @param {LookAsk[]} asks @returns {string}
+ */
+export function tooManyAsksText(asks: LookAsk[]): string;
+/** the label of the one paid call, as the drafting book and the progress line see it */
+export const MAP_CALL_LABEL: "page-map";
+/** the shapes the map may name; a `place` is read by code as a phrase */
+export const MAP_SHAPES: readonly string[];
+export const MAP_SYSTEM: "You map a person's job to the exact words of ONE saved web page. You never grade and never invent words: every string you return must be copied from the page text, character for character.";
+/** the plain-word stop when the answer was not readable twice (no Resume: a draft is not a run) */
+export const MAP_UNREADABLE: "The AI's answer about the page was not readable twice. Nothing was signed.";
+/** the answer that drops a `~` rule the page cannot check: the person types it (any case, a closing full stop allowed) */
+export const DROP_IT: "drop it";
+export function isDropIt(text: unknown): boolean;
+export function isAgree(text: unknown): boolean;
+/**
+ * `reading` = the plain words an `agree` writes as a `~` rule (a reading ask only)
+ */
+export type LookAsk = {
+    line: number;
+    rule: number;
+    source: "look";
+    question: string;
+    ask: "reading" | "cant-check";
+    ruleText: string;
+    reading?: string;
+};
+import { scrubRaw } from './text.js';

package/types/pagerules.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Which job line, and which `~` rule under it, a map fact carries out. The map writes `from` as "line N", "line N rule M", "rule M" or
+ * "job line"; anything else is the first job line.
+ * @param {unknown} from @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{line: number, rule?: number}}
+ */
+export function tieOf(from: unknown, jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[]): {
+    line: number;
+    rule?: number;
+};
+/**
+ * Is this a legal `reading` for a fact of this shape? Only a time or money fact carries one, with the op set and the bound types of a signed
+ * fact rule (src/facts.js): no other key, no missing bound. A malformed one makes the whole map answer malformed (no repair).
+ * @param {unknown} shape @param {unknown} r @returns {boolean}
+ */
+export function validReading(shape: unknown, r: unknown): boolean;
+/**
+ * Apply the rules to the AI's map over one saved page. Returns the kept facts and, for everything a rule removed, one `dropped` entry.
+ * The order of the rules is the POC's (apply-v3.mjs): found-on-page, then the rules that read the page. A place is read as a phrase.
+ * @param {string} text the frozen page text @param {PageMap} mapping @param {{n: number, text?: string, rule?: string, rules?: string[]}[]} jobLines
+ * @returns {{facts: KeptFact[], dropped: Dropped[]}}
+ */
+export function applyPageRules(text: string, mapping: PageMap, jobLines: {
+    n: number;
+    text?: string;
+    rule?: string;
+    rules?: string[];
+}[]): {
+    facts: KeptFact[];
+    dropped: Dropped[];
+};
+export function linesOf(text: string): string[];
+/**
+ * what a `~` rule means as a limit (PRD v1.107 Part 5b): the same shape as a signed fact rule
+ */
+export type Reading = {
+    op: string;
+    value?: string | number;
+    lo?: string | number;
+    hi?: string | number;
+};
+/**
+ * the AI's map, one fact
+ */
+export type MapFact = {
+    name: string;
+    from?: string;
+    shape: string;
+    words?: string[];
+    currency?: string[];
+    unit?: string[];
+    reading?: Reading;
+};
+export type PageMap = {
+    facts: MapFact[];
+};
+/**
+ * `words` = what the page proves: the labels of a money/number/time fact, or the alternative phrases of a phrase fact (a place is a phrase)
+ */
+export type KeptFact = {
+    line: number;
+    name: string;
+    shape: string;
+    from: string;
+    words: string[];
+    unit?: string[];
+    currency?: string[];
+    forRule?: number;
+    reading?: Reading;
+};
+/**
+ * `other` = what the drop is compared to: the first label (R1), the primary form (R1L), the fact it would have repeated (S1)
+ */
+export type Dropped = {
+    line: number;
+    rule?: number;
+    fact: string;
+    word?: string;
+    reason: string;
+    other?: string;
+};

package/types/panel/authorroutes.d.ts

@@ -33,6 +33,19 @@ export function checkHumanGuard(req: import("node:http").IncomingMessage, { toke
     ok: false;
     reason: string;
 };
+/**
+ * The one-at-a-time authoring session store (build spec: "one authoring
+ * session at a time — a second Start is refused while one is live"). A
+ * session is "live" from creation until its phase settles into a terminal
+ * one; a terminal session is kept (so its chat/hash stay readable) but no
+ * longer counts against the one-at-a-time rule.
+ */
+/**
+ * PRD v1.106 Part 5 Q2: the "fetching the page..." step is done once the run's own refetch has written `refrozenAt` (source.json, written last).
+ * Settled when the state is read, so nothing polls and the step never stays running after the fetch.
+ * @param {any} state
+ */
+export function settleFetchingStep(state: any): void;
 /**
  * Builds this file's own request handler, holding its session store in a
  * closure (one per `createPanelServer` call, exactly like `handleRequest`'s
@@ -79,7 +92,6 @@ export function createAuthorRoutes(opts: {
         workflowKey: string;
     } | null, inputs: import("../jobblock.js").JobInput[], o?: {
         headless?: boolean;
-        filesJob?: boolean;
     }) => Promise<{
         ok: true;
         session: ReturnType<typeof createSession>;
@@ -94,19 +106,6 @@ export function createAuthorRoutes(opts: {
     /** 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
- * 2026-09-28 (2nd addendum, panel money 2-decimals): a positive amount below
- * a cent reads `<$0.01`, never `$0.00` (a real cost must never read as
- * free). This is the server-side (Node, chat-text) sibling of
- * `src/panel/index.html`'s own inline `panelMoney` — the two can't share
- * code (one runs in the browser as inlined script, the other in Node), the
- * same duplication `src/replay.js`'s `money()`/`index.html`'s `money()`
- * already carry, so both apply the identical rule rather than drift.
- * @param {number} n a non-negative dollar amount
- * @returns {string}
- */
-export function panelMoney2(n: number): string;
 /**
  * THE ONLY function in this file (or anywhere in the panel) that spawns a
  * run. Refuses unless the session is `prepared` AND the hash the request
@@ -136,5 +135,9 @@ export function signRun(session: ReturnType<typeof createSession>, claimedHash:
 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.";
+export const OLD_JOB_RERUN_WORDS: "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be rerun. Use Reuse workflow on a newer run, or start a new job.";
+export const OLD_JOB_PAUSE_WORDS: "This run was made by an older bareloop. Its saved job doesn't pass today's checks, so it can't be paused from here. Use Reuse workflow on a newer run, or start a new job.";
+export { panelMoney2 };
 import { spawn as realSpawn } from 'node:child_process';
 import { createSession } from './authorsession.js';
+import { panelMoney2 } from '../panelmoney.js';

package/types/panel/runroutes.d.ts

@@ -4,12 +4,12 @@
  * recorded...`, `CHECKPOINT EXPIRED — ...`); anything else (validator reds, exit statuses, stack traces, argv) becomes ONE fixed
  * sentence naming the log. The one owner for the Resume and Accept routes.
  * @param {string} tail the log tail
- * @param {'resume'|'accept'} kind
+ * @param {'resume'|'accept'|'rerun'|'pause'} kind
  * @param {string} logFile
  * @param {(stage: string) => string|null} [questionOf] stage name to the panel's plain question (`null` = none)
  * @returns {string}
  */
-export function engineRefusalWords(tail: string, kind: "resume" | "accept", logFile: string, questionOf?: (stage: string) => string | null): string;
+export function engineRefusalWords(tail: string, kind: "resume" | "accept" | "rerun" | "pause", logFile: string, questionOf?: (stage: string) => string | null): string;
 /**
  * The run routes' handler. `getResumeContext(runid)` is the server's own reader (the same
  * `resumePlanFor` the Ended block uses, so the page never offers what this refuses):