bareloop 0.43.0 → 0.45.0

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/authorsession.d.ts

@@ -14,7 +14,7 @@ export function advanceSteps(steps: StepLine[], id: string, detail?: string, lab
  * The confirm turn's plan as a chat message (P7): a STRUCTURED `{role:'bot', kind:'plan', plan}` the page draws with the
  * same renderer the Job tab uses — each numbered job line, its `~` rule, its drafted checks folded; the AI's own "not
  * checked"; the always-on guards. `questions` (what the plan still asks) ride inside the plan. One owner of the shape.
- * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[]}} p the confirm turn's plan
+ * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[], signedFacts?: string[]}} p the confirm turn's plan
  * @param {{n: number, text: string, rule: string}[]|null} jobLines
  * @returns {{role: 'bot', kind: 'plan', text: string, plan: ReturnType<typeof planFromConfirm> & {goal: string, questions: string[]}}}
  */
@@ -28,6 +28,7 @@ export function planMessage(p: {
     notChecked?: string[];
     questions?: string[];
     protections?: string[];
+    signedFacts?: string[];
 }, jobLines: {
     n: number;
     text: string;
@@ -165,7 +166,7 @@ export function validateJobCard(card: any, opts?: {
  * @param {any} card the validated job card (see {@link validateJobCard})
  * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,
  *   scout?: any, generate?: Function, confirmGenerate?: Function, authorFn?: Function,
- *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fitFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
  *   TEST SEAMS ONLY — see the note just above where each is read, below. `reuse` (Reuse workflow) is NOT a seam: the
  *   caller (`/api/author/start`) sets it only when the server's own same-job rule held.
  * @returns {any} the session object
@@ -182,6 +183,7 @@ export function createSession(card: any, deps?: {
     prepareSigningFn?: Function;
     npmCiFn?: Function;
     lookFn?: Function | null;
+    fitFn?: Function | null;
     fetchUrl?: (url: string) => Promise<{
         ok: true;
         text: string;

package/types/panel/jobplan.d.ts

@@ -1,6 +1,6 @@
 /** @typedef {{name: string, cls: 'machine check'|'judge'|null}} PlanCheck */
 /** @typedef {{n: number, text: string, rule: string, rules: string[], checks: PlanCheck[], refused: string[]}} PlanLine */
-/** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
+/** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], readNotes: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
 /**
  * `machine check` for a kind a command decides, `judge` for one that needs judgement; `null` for a stage whose kind is
  * unknown (a hand-written command close has no kind: it is a command, so a machine check).
@@ -27,7 +27,8 @@ export function planFromSpec(spec: any): JobPlan;
  * The plan of the confirm turn, before anything is drafted: the person's own job lines, the model's checks under the
  * line each names, its own "not checked" words, and the real protections (code-owned) as "Always checked".
  * @param {{n: number, text: string, rule: string, rules?: string[]}[]|null|undefined} jobLines
- * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[]}} plan
+ * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[], signedFacts?: string[]}} plan
+ * `signedFacts` = the names of the facts the look signs (so an S1 copy of a signed fact reads as a note, not Not checked)
  * @returns {JobPlan}
  */
 export function planFromConfirm(jobLines: {
@@ -43,6 +44,7 @@ export function planFromConfirm(jobLines: {
     checks?: string[];
     notChecked?: string[];
     protections?: string[];
+    signedFacts?: string[];
 }): JobPlan;
 export type PlanCheck = {
     name: string;
@@ -60,6 +62,7 @@ export type JobPlan = {
     lines: PlanLine[];
     loose: PlanCheck[];
     notChecked: string[];
+    readNotes: string[];
     alwaysOn: string[];
     older: boolean;
     goal?: string;

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):

package/types/panel/server.d.ts

@@ -303,6 +303,70 @@ export function getAcceptContext(runid: string, opts?: {
     specPath: string | null;
     specHash: string | null;
 } | null;
+/**
+ * The files a run delivered: its own `destination-written` spine records (userrun.js, on a minted green only), one per path, the last record of a
+ * path winning. This is the ONLY source of a delivered path anywhere in the panel — no request ever names one.
+ * @param {any[]} records
+ * @returns {{path: string, bytes: number|null, sha256: string|null}[]}
+ */
+export function deliveredOf(records: any[]): {
+    path: string;
+    bytes: number | null;
+    sha256: string | null;
+}[];
+/**
+ * `GET /api/runs/:runid/result` — the Result tab: for each rubric job line, its words and `~` rules from the signed spec, the facts it requires
+ * (worded by {@link factSentence}), and — read from the run's own delivered step file, sha256-checked against its `destination-written`
+ * record — one row per result with each fact's cell. `passed` is read from the run's own `check-run` record; the tab never re-decides. A red run
+ * delivers nothing, so it has no rows: it carries the check's own first gap instead. `null` = no such run or no result tab for it.
+ * @param {string} runid @param {{ home?: string }} opts
+ */
+export function getRunResult(runid: string, opts?: {
+    home?: string;
+    sessionsRoot?: string;
+}): {
+    runid: string;
+    lines: any[];
+    pages: string[];
+    pageNote: string | null;
+    notChecked: string[];
+    readNotes: string[];
+    door: {
+        head: "waiting for you";
+        ask: string;
+    };
+    delivered: {
+        i: number;
+        path: string;
+        name: string;
+        bytes: number | null;
+        state: "ok" | "changed" | "gone";
+        words: string | null;
+    }[];
+    gap: {
+        line: string;
+        more: number;
+        moreText: string | null;
+    } | null;
+} | null;
+/**
+ * `GET /api/runs/:runid/download?i=<n>` — delivered file `n` (an index into the run's own `destination-written` list), or why not. The path is
+ * the record's, never the request's; the sha256 must still match the record.
+ * @param {string} runid @param {unknown} index @param {{ home?: string }} opts
+ * @returns {{ok: true, name: string, type: string, buf: Buffer}|{ok: false, code: number, error: string}}
+ */
+export function getRunDownload(runid: string, index: unknown, opts?: {
+    home?: string;
+}): {
+    ok: true;
+    name: string;
+    type: string;
+    buf: Buffer;
+} | {
+    ok: false;
+    code: number;
+    error: string;
+};
 /**
  * `GET /api/runs/:runid` — the full replay for the Run tab: steps (or
  * iterations), counters, summary-box fields. Looks `runid` up in the run
@@ -387,11 +451,12 @@ export function getRunAudit(runid: string, opts?: {
  * resolve to a real window, or the spine file is missing — the caller
  * renders 404, same posture as {@link getRunAudit}/{@link getRunJob}.
  * @param {string} runid
- * @param {{ part?: number, attempt?: number, offset?: number, limit?: number }} query
+ * @param {{ all?: boolean, part?: number, attempt?: number, offset?: number, limit?: number }} query
  * @param {{ home?: string }} [opts]
  * @returns {any|null}
  */
 export function getRunRounds(runid: string, query?: {
+    all?: boolean;
     part?: number;
     attempt?: number;
     offset?: number;
@@ -399,6 +464,78 @@ export function getRunRounds(runid: string, query?: {
 }, opts?: {
     home?: string;
 }): any | null;
+/** the Round table's check row: the sign and the plain words, ONE place (PRD v1.106 Part 5 C) @param {number} passed @param {number} failed */
+export function checkRowWords(passed: number, failed: number): {
+    sign: string;
+    text: string;
+};
+/**
+ * "71 model · 91 tool · 0 denied" — the Run summary's `calls:` row (PRD v1.106 Part 5 F). Model calls are the run's own spend records
+ * (`worker-round`, `judge-round`; the attempt-level `worker-result` echoes are not rounds and drafting is not the run's), tool and denied come
+ * from the gate-audit rows scoped to this run (the same figure `tools:` shows). No tool log saved says so, never a zero.
+ * @param {any[]} records the run's raw spine @param {{totalCalls: number, denied: number}|null} behaviour
+ * @returns {string}
+ */
+export function callsLineOf(records: any[], behaviour: {
+    totalCalls: number;
+    denied: number;
+} | null): string;
+/**
+ * "16 run · 8 passed · 8 failed (write-flight-facts tries 1-5, then tries 1-3)" — counts of what ran, never a fraction (the "checks N/M"
+ * headline stays withdrawn). Every `exit-eval` result plus every graded `outer-close` stage; the parenthesis names the steps and try ranges
+ * that failed, from the same `tries[]` the Audit reads. A run with neither says `not recorded`.
+ * @param {any[]} records the run's raw spine @param {any[]|null|undefined} parts the enriched parts
+ * @returns {string}
+ */
+export function checksLineOf(records: any[], parts: any[] | null | undefined): string;
+/**
+ * The step card's extra line (PRD v1.106 Part 5 G): "5 tries · last try: 1 check passed, 1 failed", with the cut-off try named when there is one
+ * ("4 tries (the 4th cut off before its checks ran) · last try: no checks ran"). Words for what passed and failed, never a fraction. `null`
+ * when the step has no graded try (an old spine).
+ * @param {Array<{n: number, cutOff: boolean, passed: number, failed: number, ran: number}>} tries
+ * @returns {string|null}
+ */
+export function triesLineOf(tries: Array<{
+    n: number;
+    cutOff: boolean;
+    passed: number;
+    failed: number;
+    ran: number;
+}>): string | null;
+/**
+ * "tools: read 16 · grep 22 · write 5 · denied 0" — the step's tool calls by kind, then how many the gate denied (PRD v1.106 Part 5 C). The
+ * `shell_`/`ctx_` prefixes are stripped like the rest of the page. `null` when no tool log was saved (nothing honest to count).
+ * @param {Record<string, number>|null|undefined} byTool @param {number|null|undefined} blocked
+ * @returns {string|null}
+ */
+export function toolsTallyLine(byTool: Record<string, number> | null | undefined, blocked: number | null | undefined): string | null;
+/**
+ * The try line's gap: the first failing reason, and how many more there are (PRD v1.106 Part 5 C). ONE function, beside {@link stageQuestionText}.
+ * @param {string|null|undefined} detail
+ * @returns {{ line: string, more: number }|null}
+ */
+export function gapOneLine(detail: string | null | undefined): {
+    line: string;
+    more: number;
+} | null;
+/**
+ * "from line 1 ~ under $450; not a red-eye" — the job line(s) a check serves and the `~` rules written under them (the signed `jobLines`).
+ * `null` when the stage serves no job line (a mandatory guard).
+ * @param {number[]} fromLine @param {any} spec
+ * @returns {string|null}
+ */
+export function fromLineText(fromLine: number[], spec: any): string | null;
+/**
+ * "output judged: output/steps/1.json · 2.1 KB · sha256 674b…30" — the file a try's check read (PRD v1.106 Part 5 choice 14). ONE place owns
+ * these words. `size` is bytes under 1 KB, else KB with one decimal; the hash shows its first 4 and last 2 characters.
+ * @param {{path: string|null, bytes: number|null, sha256: string|null}} o
+ * @returns {string}
+ */
+export function judgedFileLine(o: {
+    path: string | null;
+    bytes: number | null;
+    sha256: string | null;
+}): string;
 /**
  * The Signed row of the Job tab: `YYYY-MM-DD HH:MM · <first 6 of specHash>`, the time being the run's FIRST `job-start`
  * in local time (hamr, P7). `null` when either part is not on record — never a made-up stamp.
@@ -627,10 +764,11 @@ export function getStartFromImport(id: string, opts?: {
  * only `createPanelServer` below always supplies one.
  * @param {import('node:http').IncomingMessage} req
  * @param {import('node:http').ServerResponse} res
- * @param {{ home?: string, packageJsonPath?: string, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes>, runRoutes?: ReturnType<typeof createRunRoutes>, importRoutes?: ReturnType<typeof createImportRoutes>, schedules?: ReturnType<typeof createScheduleDoor> }} opts
+ * @param {{ home?: string, sessionsRoot?: string, packageJsonPath?: string, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes>, runRoutes?: ReturnType<typeof createRunRoutes>, importRoutes?: ReturnType<typeof createImportRoutes>, schedules?: ReturnType<typeof createScheduleDoor> }} opts
  */
 export function handleRequest(req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, opts: {
     home?: string;
+    sessionsRoot?: string;
     packageJsonPath?: string;
     port: number;
     token?: string;
@@ -731,11 +869,27 @@ export const RUNS_LIST_LIMITS: Readonly<{
     olderRuns: 7;
     needsYouDays: 7;
 }>;
+/** what the Result tab's open door asks, after the door's own head words */
+export const RESULT_DOOR_ASK: "the checks passed; is this what you wanted?";
+/** the two sentences for a delivered file that is no longer what the run wrote (code-owned, one spelling) */
+export const RESULT_FILE_GONE: "the saved file is gone";
+export const RESULT_FILE_CHANGED: "the saved file changed after the run";
+/** the same two states for a red run's file, which is the last one the check read (not a delivered file) */
+export const RESULT_JUDGED_GONE: "the file is gone";
+export const RESULT_JUDGED_CHANGED: "the file changed after the check";
+/** what a red run's rows are, said once above them */
+export const RESULT_JUDGED_NOTE: "a red run delivers nothing; these rows are the last file the check read";
+/** the words beside a Result-tab page link: the page is read again from the web, so it can differ from what the run read */
+export const RESULT_PAGE_MAY_CHANGE: "The page may have changed since this run.";
+/** the words after a fact whose limit the person agreed to in a Part 5b look ask */
+export const RESULT_YOU_CONFIRMED: "(you confirmed)";
 /** The default/max page size for {@link getRunRounds} — tighten-only,
  * named so a future change is a deliberate, visible edit (item 5,
  * 2026-09-25). */
 export const ROUNDS_PAGE_DEFAULT: 50;
 export const ROUNDS_PAGE_MAX: 200;
+/** the Audit step table's page size (PRD v1.106 Part 5 choice 3): rows, not rounds */
+export const STEP_ROWS_PAGE: 20;
 import { createScheduleDoor } from './schedules.js';
 import { createAuthorRoutes } from './authorroutes.js';
 import { createSettingsRoutes } from './settingsroutes.js';

package/types/panel/status.d.ts

@@ -34,6 +34,26 @@ export function partStatusFor(part: {
     sign: string;
     word: string;
 };
+/**
+ * The words one door wears: header phrase, the `last answer:` line (with the time `HH:MM` once decided) and the table rows.
+ * @param {{at: string|null, paths: string[], decision: string|null, text: string|null, decidedAt: string|null}} door
+ * @returns {{ head: string, last: string, rows: Array<{path: string|null, text: string, time: string|null}> }}
+ */
+export function doorViewOf(door: {
+    at: string | null;
+    paths: string[];
+    decision: string | null;
+    text: string | null;
+    decidedAt: string | null;
+}): {
+    head: string;
+    last: string;
+    rows: Array<{
+        path: string | null;
+        text: string;
+        time: string | null;
+    }>;
+};
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE: "goal met";
 /** @typedef {'running'|'waiting'|'passed'|'failed'|'capped'|'stopped'|'died'} StatusKey */
@@ -68,4 +88,35 @@ export const STATUS: Readonly<{
         word: "died";
     }>;
 }>;
+/**
+ * PRD v1.106 Part 5 (C, choice 9): the review door's words, ONE table. The door is the only human step bareloop has; there is no "you
+ * cancelled" (cancel is deleted). `decision` is the spine's `door-decision.decision`, or null while nothing has been decided.
+ */
+export const DOOR_WORDS: Readonly<{
+    waiting: Readonly<{
+        head: "waiting for you";
+        row: "paused for you";
+        last: "none yet";
+    }>;
+    accept: Readonly<{
+        head: "you accepted";
+        row: "you accepted";
+        last: "you accepted";
+    }>;
+    rerun: Readonly<{
+        head: "you said rerun";
+        row: "you said rerun";
+        last: "you said rerun";
+    }>;
+    pause: Readonly<{
+        head: "paused";
+        row: "paused";
+        last: "paused";
+    }>;
+}>;
+/** the marker a part wears for who did its work (PRD v1.106 Part 5 C/G): the model, or a person asked */
+export const ACTOR_MARKER: Readonly<{
+    model: "[model]";
+    human: "[human · ask]";
+}>;
 export type StatusKey = "running" | "waiting" | "passed" | "failed" | "capped" | "stopped" | "died";

package/types/panelmoney.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {number|null|undefined} n a dollar amount
+ * @returns {string}
+ */
+export function panelMoney2(n: number | null | undefined): string;

package/types/replay.d.ts

@@ -180,7 +180,26 @@ export function replayRun(spineEvents: any[], auditEvents?: any[], { runId, audi
             startTs: number | null;
             endTs: number | null;
             exitEvalDetail: string | null;
+            checks: Array<{
+                type: string;
+                pass: boolean;
+                detail: string | null;
+                name: string | null;
+            }>;
+            outputJudged: Array<{
+                path: string | null;
+                bytes: number | null;
+                sha256: string | null;
+            }>;
         }[];
+        cutOffTry: {
+            n: number;
+            iteration: any;
+            startSeq: any;
+            endSeq: any;
+            startTs: number | null;
+            endTs: number | null;
+        } | null;
         stepStartSeq: any;
         stepEndSeq: any;
         stepStartTs: number | null;
@@ -291,9 +310,10 @@ export function replayRun(spineEvents: any[], auditEvents?: any[], { runId, audi
  * @param {boolean|null} [draftSpendComplete] whether the drafting fold above was EXACT;
  *   `null`/`undefined`/`true` all read as exact (never a new enum value elsewhere) —
  *   only an explicit `false` triggers the floor wording.
+ * @param {number|null} [runUsd] the run's own spend as a number (excluding drafting), so the sum can be written
  * @returns {string}
  */
-export function moneyWithDraft(spendCore: string, draftSpentUsd: number | null, budgetUsd?: number | null, draftSpendComplete?: boolean | null): string;
+export function moneyWithDraft(spendCore: string, draftSpentUsd: number | null, budgetUsd?: number | null, draftSpendComplete?: boolean | null, runUsd?: number | null): string;
 /**
  * Render a {@link replayRun} summary as one printable page: a header block
  * (goal/shape/signed/branch/outcome/spent), a timeline (steps or iterations,

package/types/rubricstep.d.ts

@@ -35,6 +35,13 @@ export function rubricGoal({ jobLines, files, confirmedGoal, closeDecl }: {
     confirmedGoal?: string | null;
     closeDecl?: any;
 }): string;
+/**
+ * The sentence the person confirmed, out of a goal text: for a rubric brief the rest of the `CONFIRMED_GOAL_PREFIX` line,
+ * or null when the brief has none; any other goal (a code job's) comes back unchanged.
+ * @param {string} goal
+ * @returns {string|null}
+ */
+export function confirmedGoalOf(goal: string): string | null;
 /**
  * The SHAPE of a `rubric-step` stage's parameters — what a part may carry — and nothing about which class is allowed in
  * this build (that is `checkRubricParts`, which also sees the whole job). Pure, never throws.
@@ -58,6 +65,28 @@ export function buildStepSpec(params: {
     step: number;
     parts: any[];
 }, inputShas: Record<string, string>): Record<string, any>;
+/**
+ * The files one named check READS, tree-relative: a `rubric-step` stage's own step file (`output/steps/N.json`). Any other kind reads
+ * none that a try's output can be told by, so `[]`. From the signed declaration, never guessed.
+ * @param {any} closeDecl @param {string|null|undefined} checkName
+ * @returns {string[]}
+ */
+export function judgedFilesOf(closeDecl: any, checkName: string | null | undefined): string[];
+/**
+ * PRD v1.106 Part 5: what each file a try's `check-passes` checks read looked like WHEN it was judged: `{path, bytes, sha256}`. The step
+ * file is overwritten by the next try, so the spine's `output-judged` record is the only trace; the content itself is never written (hard
+ * line). A missing, non-regular or over-size file is skipped — nothing was judged there.
+ * @param {any} closeDecl @param {string} workdir @param {Array<{type?: string, name?: string}>} exits a step's declared exits
+ * @returns {Promise<Array<{path: string, bytes: number, sha256: string}>>}
+ */
+export function outputJudgedRecords(closeDecl: any, workdir: string, exits: Array<{
+    type?: string;
+    name?: string;
+}>): Promise<Array<{
+    path: string;
+    bytes: number;
+    sha256: string;
+}>>;
 /**
  * The step file's bytes as the close reads them: the parsed JSON object, or WHY there is none. A file cut off mid-write
  * parses to nothing (reason `not-json`); text cut off INSIDE an otherwise valid JSON object cannot be told from a short
@@ -101,7 +130,9 @@ export function plainStepGap(step: number, why: string, g: any, params?: any): s
  *   `inputs` maps each cited label to its frozen TEXT; its sha256 is taken here from that text, and bareguard compares it to
  *   the manifest's recorded sha via `inputShas`.
  * @param {Record<string, string>} inputShas the manifest's recorded sha256 per cited label
- * @returns {Promise<{verdict: 'green'|'red'|'stopped', gapLines: string[], fault: string|null, detail: Record<string, any>}>}
+ * @returns {Promise<{verdict: 'green'|'red'|'stopped', gapLines: string[], fault: string|null, detail: Record<string, any>,
+ *   evidence?: any[], evidenceTotal?: number}>} `evidence`/`evidenceTotal` are bareguard's `full.evidence` (what each `cited` check read), carried out
+ *   for the report-only `rubric-evidence` spine record; no verdict, gap or count above is derived from them
  */
 export function gradeStep({ params, bytes, outputBytes, inputs, factQuotes, factMissing }: {
     params: {
@@ -118,6 +149,8 @@ export function gradeStep({ params, bytes, outputBytes, inputs, factQuotes, fact
     gapLines: string[];
     fault: string | null;
     detail: Record<string, any>;
+    evidence?: any[];
+    evidenceTotal?: number;
 }>;
 /**
  * The labels of a job's numbered inputs, or null when it carries none (a caller that has no inputs in hand skips the label rule).
@@ -178,6 +211,17 @@ export function settlePersonsWords(declaration: any, jobLines: any[] | null | un
  * @param {any} declaration @returns {any}
  */
 export function withFactBindings(declaration: any): any;
+/**
+ * NO SILENT DROP (idea A core, spec 4.4): code writes the Not checked rows for what the page rules removed, before the declaration is validated.
+ *   - a dropped FACT that carries a `~` rule no part carries and no `refused` entry names -> `closeDecl.refused` gets {line, rule, reason}
+ *     (shown under that line in the person's own rule words by {@link ruleNotChecked});
+ *   - any other drop (a fact from the job line itself, a rule another fact carries, a word dropped from a fact that is still checked, so a
+ *     narrower check is still said) -> one line in `closeDecl.notes`, shown as Not checked (the AI's own reading).
+ * Never a line-level `refused` entry without `rule` (that would silence every other rule red on the line). A rule the drafter already listed
+ * itself is never listed twice, and running this twice adds nothing. Pure; the input is untouched.
+ * @param {any} declaration @param {import('./pagerules.js').Dropped[]|null|undefined} dropped @param {any[]|null|undefined} jobLines @returns {any}
+ */
+export function withDropNotes(declaration: any, dropped: import("./pagerules.js").Dropped[] | null | undefined, jobLines: any[] | null | undefined): any;
 /**
  * The ~ rules the drafter listed under Not checked (`refused` entries that name a `rule`), each as one line in the person's own
  * words: `line N: "<the rule as written>" — <the drafter's reason>` (PART 1b, RF6 / RF16).
@@ -190,6 +234,11 @@ export function ruleNotChecked(closeDecl: any, jobLines: any[] | null | undefine
  * @param {any} closeDecl @returns {string[]}
  */
 export function proseNotChecked(closeDecl: any): string[];
+/** the same items as {@link proseNotChecked} with the job line each belongs to (the stage's own `step`) @param {any} closeDecl @returns {{line: number, text: string}[]} */
+export function proseNotCheckedItems(closeDecl: any): {
+    line: number;
+    text: string;
+}[];
 /**
  * One countable part as a plain sentence, written by code from the part's signed fields (never from the model's words), so the
  * plan card and the close are one thing seen twice.
@@ -207,6 +256,11 @@ export function checksOfClose(closeDecl: any): {
     text: string;
     covers: number[];
 }[];
+/**
+ * The names of the facts a signed close checks (every fact part of every rubric-step stage). Pure.
+ * @param {any} closeDecl @returns {string[]}
+ */
+export function signedFactNames(closeDecl: any): string[];
 /**
  * Reconcile the CONFIRMED plan with the close the composer actually wrote. The plan card after drafting shows exactly
  * the close's own checks (`checksOfClose`); every confirmed check that no part carries out (no part lists its number in
@@ -269,6 +323,11 @@ export const STEP_DIR: "output/steps";
 export function stepFileRel(n: number): string;
 /** the largest step file the close reads: a bigger one is a stop, never silently truncated (bareguard's own source cap) */
 export const STEP_MAX_BYTES: number;
+/**
+ * What a rubric job's goal text is: the worker brief `rubricGoal` builds. The Job tab's "AI's summary" is only the one
+ * sentence the person confirmed, never this brief, so the first line and the confirmed-sentence prefix have ONE spelling.
+ */
+export const RUBRIC_GOAL_HEAD: "Do the job below from the input files, then write one JSON file per numbered line.";
 /** the closed set of classes a part is sorted into; `none` = "I could not sort this one" (a red, in plain words, never a guess) */
 export const PART_CLASSES: readonly string[];
 /**
@@ -279,6 +338,8 @@ export const PART_CLASSES: readonly string[];
  */
 export const COUNT_CHECKS: Readonly<Record<string, readonly string[]>>;
 export function sha256Of(b: string | Buffer): string;
+export function boundInWords(b: unknown, said: string): boolean;
+export function wordsSaidOn(jl: any): string;
 export type ShapeRed = {
     code: string;
     path: string;