bareloop 0.41.0 → 0.43.0

package/types/panel/server.d.ts

@@ -116,7 +116,7 @@ export function legDividersFor(spineRecords: any[], parts: any[]): {
  *
  * The table (outcome → reason / next / buttons) is PANEL-BUILD.md P5 item 1. The
  * Resume button appears only when `o.resume` says the engine would accept it; "Reuse workflow"
- * (replaces P5 item 3, 2026-10-03) is offered on green rows only, and starts a NEW run.
+ * (replaces P5 item 3, 2026-10-03; one door on every ending since 2026-10-15) starts a NEW run.
  * @param {{outcome: string|null, stopReason: string|null, spentUsd: number|null, budgetUsd: number|null, lastEscalation?: any}} summary
  * @param {{died: boolean, lastThing: string|null}} death
  * @param {{resume?: {ok: boolean, why?: string}|null, destinationRefused?: string|null, moneyHalt?: boolean,
@@ -155,6 +155,28 @@ export function endedFor(summary: {
         label: string;
     }[];
 } | null;
+/**
+ * RULED 2026-10-15 (Remove from Needs you): the ONE place a run's Needs-you state is decided. `Accept` (a live door) is never removable and never ages out.
+ * A `Resume` tag leaves when the person removed it AFTER (or at) the stop it is for — a removal covers only the ending it was made on, so a later stop
+ * brings the run back — or after `needsYouDays`. `removedMs` is the newest removal that covers the current ending (or null), `expired` is true when only
+ * the age rule took a Resume run out.
+ * @param {{live: boolean, records: any[], resume: {ok?: boolean}|null|undefined, stoppedAt: string|null, nowMs: number, removedMs?: number}} f
+ * @returns {{needs: 'Accept'|'Resume'|null, removedMs: number|null, expired: boolean}}
+ */
+export function needsStateFor(f: {
+    live: boolean;
+    records: any[];
+    resume: {
+        ok?: boolean;
+    } | null | undefined;
+    stoppedAt: string | null;
+    nowMs: number;
+    removedMs?: number;
+}): {
+    needs: "Accept" | "Resume" | null;
+    removedMs: number | null;
+    expired: boolean;
+};
 /**
  * The Resume route's reader (P5 item 2): the listed row plus the resume plan, from the
  * ONE {@link resumePlanFor} the Ended block asks. `null` when the runid is not listed
@@ -184,6 +206,43 @@ export function getStopContext(runid: string, opts?: {
     live: boolean;
     spineExists: boolean;
 } | null;
+/**
+ * The Remove-from-Needs-you route's reader (RULED 2026-10-15): the listed row and the Needs-you tag the runs list shows for it right now
+ * (`summarizeRow`, the one rule). `null` when the runid is not listed.
+ * @param {string} runid
+ * @param {{ home?: string, now?: number }} [opts]
+ * @returns {{row: any, needs: 'Accept'|'Resume'|null}|null}
+ */
+export function getNeedsContext(runid: string, opts?: {
+    home?: string;
+    now?: number;
+}): {
+    row: any;
+    needs: "Accept" | "Resume" | null;
+} | null;
+/**
+ * The ONE rule for a run's Needs-you tag (P9 v2 E): `Resume` when the engine would accept a resume (the SAME `resumePlanFor` answer the Run
+ * tab's Resume card shows, already asked once per row by `endedForRow`), until the run has been stopped `needsYouDays` (exactly that old is out;
+ * no readable stop time stays in). `Accept` comes from {@link doorWaiting} (T Part 8), asked in `summarizeRow`, never here.
+ * @param {{ok?: boolean}|null|undefined} resume @param {string|null} stoppedAt @param {number} nowMs
+ * @returns {'Accept'|'Resume'|null}
+ */
+export function needsTag(resume: {
+    ok?: boolean;
+} | null | undefined, stoppedAt: string | null, nowMs: number): "Accept" | "Resume" | null;
+/**
+ * One entry per job, newest activity first: `headRunid` is the job's newest run BY TIME (never "the first row in server order"), `activityMs` the
+ * newest KNOWN time over its runs (`stoppedAt`, else `at`), `quiet` only when that time is known and older than the quiet limit. A job with a live
+ * run is never quiet; an unknown age is never guessed into quiet.
+ * @param {any[]} rows `listRuns` rows @param {number} nowMs
+ * @returns {{job: string, headRunid: string|null, quiet: boolean, activityMs: number|null}[]}
+ */
+export function summarizeJobs(rows: any[], nowMs: number): {
+    job: string;
+    headRunid: string | null;
+    quiet: boolean;
+    activityMs: number | null;
+}[];
 /**
  * `GET /api/runs` — every listed run, NEWEST FIRST BY `at` (never by file/
  * append order — a backfill scan appends rows in sorted-PATH order, which
@@ -197,12 +256,53 @@ export function getStopContext(runid: string, opts?: {
  * SAME payload by job client-side (`groupRunsByJob` in `index.html`) rather
  * than a second server-side endpoint, so the glyph/checkType mapping is
  * still computed in exactly one place.
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, now?: number }} [opts] `now` (ms) is injectable for the Needs-you age rule
  * @returns {any[]}
  */
 export function listRuns(opts?: {
     home?: string;
+    now?: number;
 }): any[];
+/**
+ * `GET /api/runs` (P9 v2 F): `{runs, jobs, limits}`. The server decides every state the left list draws — `live`, `needs`, each job's head run and
+ * quiet flag, the limits — and the page works out nothing. `scheduled` is the triggers piece (PRD v1.99, T Part 7).
+ * @param {{ home?: string, now?: number, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
+ */
+export function runsListPayload(opts?: {
+    home?: string;
+    now?: number;
+    schedules?: ReturnType<typeof createScheduleDoor>;
+}): {
+    runs: any[];
+    jobs: {
+        job: string;
+        headRunid: string | null;
+        quiet: boolean;
+        activityMs: number | null;
+    }[];
+    scheduled: any[];
+    gaveUp: any[];
+    limits: Readonly<{
+        quietDays: 30;
+        olderRuns: 7;
+        needsYouDays: 7;
+    }>;
+};
+/**
+ * T Part 8 — what the Accept route needs: the run's row, whether its runner is alive, whether it waits at its review door
+ * ({@link doorWaiting}), and the signed spec it was judged by (the file and hash `run-u --door --approve` takes).
+ * @param {string} runid @param {{ home?: string }} opts
+ * @returns {{row: any, live: boolean, waiting: boolean, specPath: string|null, specHash: string|null}|null}
+ */
+export function getAcceptContext(runid: string, opts?: {
+    home?: string;
+}): {
+    row: any;
+    live: boolean;
+    waiting: boolean;
+    specPath: string | null;
+    specHash: string | null;
+} | null;
 /**
  * `GET /api/runs/:runid` — the full replay for the Run tab: steps (or
  * iterations), counters, summary-box fields. Looks `runid` up in the run
@@ -210,11 +310,12 @@ export function listRuns(opts?: {
  * header); `null` when the runid is not in the list at all (caller renders
  * 404).
  * @param {string} runid
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
  * @returns {any|null}
  */
 export function getRunDetail(runid: string, opts?: {
     home?: string;
+    schedules?: ReturnType<typeof createScheduleDoor>;
 }): any | null;
 /**
  * `GET /api/runs/:runid/audit` — the Audit tab's rows, off the run's own
@@ -343,11 +444,12 @@ export function inputsTextFromSpec(spec: any, source: string): string;
  * from the resolved SPEC only (a) (b) (c) — a job-start record and `none()`
  * carry no close/writeScope/tools at all, so those stay `'not recorded'`.
  * @param {string} runid
- * @param {{ home?: string }} [opts]
+ * @param {{ home?: string, schedules?: ReturnType<typeof createScheduleDoor> }} [opts]
  * @returns {any|null}
  */
 export function getRunJob(runid: string, opts?: {
     home?: string;
+    schedules?: ReturnType<typeof createScheduleDoor>;
 }): any | null;
 /**
  * The track record of a WORKFLOW: every LISTED run whose signed spec (the one its latest leg ran under) has this
@@ -395,14 +497,14 @@ export function reuseLine(record: {
 } | null): string;
 /**
  * `start-from` (the route keeps its name) for one listed run: the card prefilled from the run's SIGNED job, which
- * boxes are locked and which are open, and the track record. Locked boxes carry the signed values, read by the
+ * the track record (v1.101: nothing is locked, every box is open). The job boxes carry the signed values, read by the
  * SAME readers the Job tab uses (`successFromSpec`/`guardrailsFromSpec`); the open four — Source, Destination, the
  * $ cap and the Time cap — start at what the run had. `ok:false` when the run's signed job is not on disk (nothing
  * to copy: change the job: Clear the card). `null` when the runid is not listed.
  * @param {string} runid
  * @param {{ home?: string, model?: string, provider?: string }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
  * @returns {{ok: true, origin: {runid: string, job: string}, outcome: string|null, card: Record<string, any>, from: 'signed job',
- *   locked: readonly string[], open: readonly string[], note: string|null,
+ *   note: string|null,
  *   specHash: string, workflowKey: string, spec: any, specPath: string, specNamesModel: boolean,
  *   specWorker: {provider: string, endpoint: string, label: string},
  *   trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -420,8 +522,6 @@ export function getStartFrom(runid: string, opts?: {
     outcome: string | null;
     card: Record<string, any>;
     from: "signed job";
-    locked: readonly string[];
-    open: readonly string[];
     note: string | null;
     specHash: string;
     workflowKey: string;
@@ -439,6 +539,21 @@ export function getStartFrom(runid: string, opts?: {
     ok: false;
     error: string;
 } | null;
+/**
+ * T Part 3: a job's listed runs, newest first, each with its signed spec (null when not on disk), its terminal outcome and
+ * its parsed spine. The schedule door's gate (`greenFor`) reads this; nothing here builds a run context.
+ * @param {string} job
+ * @param {{ home?: string }} [opts]
+ * @returns {{runid: string, outcome: string|null, spec: any, records: any[]}[]}
+ */
+export function jobRunsOf(job: string, opts?: {
+    home?: string;
+}): {
+    runid: string;
+    outcome: string | null;
+    spec: any;
+    records: any[];
+}[];
 /**
  * The Reuse workflow picker's list: one entry per JOB (same-job identity = `workflowKey`, the one `getStartFrom` uses)
  * that has at least one GREEN local run, newest green first. `runid` = that job's newest green run, so the page hands
@@ -469,7 +584,7 @@ export function listReuseJobs(opts?: {
  * @param {string} id
  * @param {{ home?: string, model?: string, provider?: string }} [opts] `model` as for {@link getStartFrom}
  * @returns {{ok: true, origin: {runid: null, job: string, importId: string}, card: Record<string, any>, from: 'imported job',
- *   locked: readonly string[], open: readonly string[], note: string|null, specHash: string, workflowKey: string, spec: any,
+ *   note: string|null, specHash: string, workflowKey: string, spec: any,
  *   specPath: null, trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
  */
 export function getStartFromImport(id: string, opts?: {
@@ -485,8 +600,6 @@ export function getStartFromImport(id: string, opts?: {
     };
     card: Record<string, any>;
     from: "imported job";
-    locked: readonly string[];
-    open: readonly string[];
     note: string | null;
     specHash: string;
     workflowKey: string;
@@ -514,16 +627,18 @@ 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, port: number, token?: string, authorRoutes?: ReturnType<typeof createAuthorRoutes>, settingsRoutes?: ReturnType<typeof createSettingsRoutes>, runRoutes?: ReturnType<typeof createRunRoutes>, importRoutes?: ReturnType<typeof createImportRoutes> }} opts
+ * @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
  */
 export function handleRequest(req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, opts: {
     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>;
 }): void;
 /**
  * Start the panel server. Binds `127.0.0.1` ONLY. A taken port is a LOUD,
@@ -544,8 +659,9 @@ export function handleRequest(req: import("node:http").IncomingMessage, res: imp
  * @param {{ port?: number, home?: string, env?: Record<string,string|undefined>,
  *   sessionsRoot?: string, spawnFn?: (...a: any[]) => any, bareloopBin?: string,
  *   fetchImpl?: typeof fetch, settleMs?: number, userHome?: string,
- *   openFolderSpawn?: (cmd: string, args: string[], o: object) => any, platform?: string }} [opts]
- * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, close: () => Promise<void> }>}
+ *   openFolderSpawn?: (cmd: string, args: string[], o: object) => any, platform?: string, packageJsonPath?: string,
+ *   scheduleNow?: () => number, sessionDeps?: Record<string, any>, schedulerIntervalMs?: number, acceptWaitMs?: number }} [opts] `scheduleNow`, `sessionDeps` and `schedulerIntervalMs` are TEST SEAMS (the schedule clock; createSession's stubs; the scheduler's timer, 0 = none)
+ * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, schedules: ReturnType<typeof createScheduleDoor>, scheduler: ReturnType<typeof createScheduler>, close: () => Promise<void> }>}
  */
 export function createPanelServer(opts?: {
     port?: number;
@@ -559,10 +675,17 @@ export function createPanelServer(opts?: {
     userHome?: string;
     openFolderSpawn?: (cmd: string, args: string[], o: object) => any;
     platform?: string;
+    packageJsonPath?: string;
+    scheduleNow?: () => number;
+    sessionDeps?: Record<string, any>;
+    schedulerIntervalMs?: number;
+    acceptWaitMs?: number;
 }): Promise<{
     server: import("node:http").Server;
     port: number;
     token: string;
+    schedules: ReturnType<typeof createScheduleDoor>;
+    scheduler: ReturnType<typeof createScheduler>;
     close: () => Promise<void>;
 }>;
 /**
@@ -602,13 +725,21 @@ export const DEFAULT_PORT: 4700;
  */
 export const SOFTGREEN_ADMITTED_ISO: "2026-08-18T00:00:00.000Z";
 export { DIED_MTIME_MS };
+/** The named limits of the runs list, in ONE place (P9 v2 D.13): quiet after 30 days, 7 older runs shown, a Resume tag ages out after 7 days. Sent in `GET /api/runs`; the page reads them from there. */
+export const RUNS_LIST_LIMITS: Readonly<{
+    quietDays: 30;
+    olderRuns: 7;
+    needsYouDays: 7;
+}>;
 /** 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;
+import { createScheduleDoor } from './schedules.js';
 import { createAuthorRoutes } from './authorroutes.js';
 import { createSettingsRoutes } from './settingsroutes.js';
 import { createRunRoutes } from './runroutes.js';
 import { createImportRoutes } from './importroutes.js';
+import { createScheduler } from './scheduler.js';
 import { DIED_MTIME_MS } from '../runlist.js';

package/types/planrun.d.ts

@@ -523,6 +523,8 @@ export const FORBIDDEN_WRITE_SEGMENT_PATTERN: RegExp;
 export const BOUND_REASON_MAX: 200;
 /** the recorded reason for a step attempt whose round was cut at the output cap (F122 2A b) */
 export const TRUNCATED_REASON: "output cut at the token limit (max_tokens)";
+/** the plain sentence for a replan answer cut off at its length limit (hamr 2026-10-16, run mv9gm796) */
+export const REPLAN_CUT_WORDS: "The replan answer was cut off at its length limit, so no new plan came back.";
 export type CategorizedError = Error & {
     category?: string;
     lib?: string;

package/types/providerrows.d.ts

@@ -251,8 +251,8 @@ export function judgeRowFor(rows: readonly KeyRow[], judge: {
  * the worker's own provider it calls the worker's endpoint, so a row on that endpoint with a line
  * NAMED for the judge's model prices it ({@link ratesFor}); a judge model that is absent or names
  * no line there keeps the worker's price (the worker's row, or none = the guess). A different
- * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`applyConfiguredKey`,
- * by the worker's model), so the two can come from different rows.
+ * provider resolves with no endpoint. The judge's KEY is chosen elsewhere (`judgeRowFor`:
+ * the worker's own row when the judge shares its provider), so the two can come from different rows.
  * @param {{ provider: string, model?: string|null }} judge
  * @param {string|null|undefined} workerProvider
  * @param {string|null|undefined} workerBaseUrl

package/types/reviewdoor.d.ts

@@ -4,6 +4,33 @@
  * @param {any[]} events the run's spine, parsed
  * @returns {any|null} */
 export function doorRecordOf(events: any[]): any | null;
+/**
+ * Was this run's door ACCEPTED, honoured? A `door-decision` record with `decision: 'accept'` and `honoured: true`
+ * (written by {@link answerReviewDoor}, whichever surface asked: the CLI, or the panel's Accept). Pure, off the
+ * run's spine. A refused accept (`honoured: false`) does not count.
+ * @param {any[]} events the run's spine, parsed
+ * @returns {boolean}
+ */
+export function doorAccepted(events: any[]): boolean;
+/**
+ * T D.2 — a SCHEDULED run's green is held until the person accepts it (T10): a run that carries a `trigger.json` (a scheduled
+ * start wrote it) and holds no honoured accept. One shared predicate: `getStartFrom` reads its outcome as `'green-held'` (so
+ * the Reuse start refuses it unchanged), `listReuseJobs` skips it, and the schedule gate does not count it. A hand run is never held.
+ * @param {any[]} events the run's spine, parsed @param {any} triggerRec the run's `trigger.json`, or null
+ * @returns {boolean}
+ */
+export function heldScheduled(events: any[], triggerRec: any): boolean;
+/**
+ * Is this run WAITING for the person's Accept? Its spine holds a door record, the door has not expired ({@link doorAgeGate}),
+ * and no honoured `accept` or `rerun` decision follows it (a `pause` keeps the same three doors open). One owner: the runs
+ * list's Needs-you `Accept` tag, the Run tab's Accept button and the scheduled NEXT line all read this.
+ * @param {any[]} events the run's spine, parsed
+ * @param {{now?: () => number}} [opts]
+ * @returns {boolean}
+ */
+export function doorWaiting(events: any[], opts?: {
+    now?: () => number;
+}): boolean;
 /**
  * IS THE DOOR STILL OPEN? The same 60-day TTL a hitl checkpoint keeps
  * (`PAUSE_TTL_MS`) and deliberately the same NUMBER — the door replaced `cancel`

package/types/rubricstep.d.ts

@@ -0,0 +1,286 @@
+/**
+ * The one statement of the step-file shape, in plain words. The worker's goal and the composer's prompt both carry it.
+ * @returns {string}
+ */
+export function stepFileContract(): string;
+/**
+ * What the worker is told about each line, from the close that will grade it (PART 1b item 7): a FACTS line gets its
+ * facts and its count; a TEXT line that follows a facts line is told its numbers come from that line's quotes. Written by code from
+ * the signed parts, never by a model. A line with no rubric-step stage gets nothing here.
+ * @param {any} closeDecl @returns {{line: number, text: string}[]}
+ */
+export function lineBriefs(closeDecl: any): {
+    line: number;
+    text: string;
+}[];
+/**
+ * The worker's goal for a rubric job on local files — written by code from the person's own numbered lines, never by a
+ * model. It states everything the close will judge about the FORM of the answer (the file, the keys, the quotes); what
+ * each line asks for stays in the person's own words, with its `~` rules beneath it.
+ * @param {{jobLines: {n: number, text: string, rule: string}[], files: {label: string, rel: string}[], confirmedGoal?: string|null, closeDecl?: any}} o
+ *   `confirmedGoal` — the one goal sentence the person confirmed in the confirm turn, kept as the plan line
+ *   `closeDecl` — the drafted close: with it, each line is briefed by what its stage checks (a facts line or a text line, `lineBriefs`)
+ * @returns {string}
+ */
+export function rubricGoal({ jobLines, files, confirmedGoal, closeDecl }: {
+    jobLines: {
+        n: number;
+        text: string;
+        rule: string;
+    }[];
+    files: {
+        label: string;
+        rel: string;
+    }[];
+    confirmedGoal?: string | null;
+    closeDecl?: any;
+}): string;
+/**
+ * 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.
+ * @param {unknown} p the stage's `params`
+ * @param {string} at the path prefix for reds, e.g. `stages[1].params`
+ * @returns {ShapeRed[]}
+ */
+export function rubricStepShapeReds(p: unknown, at: string): ShapeRed[];
+/** the labels of the inputs a step's `cited` parts name (each once, in order) @param {any} params @returns {string[]} */
+export function citedLabels(params: any): string[];
+/**
+ * The rubric spec for ONE step, built from its parameters and the sha256 of each input it cites (taken from the source
+ * manifest at run start — a rubric is rebuilt per run because the inputs belong to the run, not to the signed job).
+ * `happened` is bareguard's own foundational check; the `text` floor below it stops a step file whose only key is junk
+ * from passing a rubric that has no countable part.
+ * @param {{step: number, parts: any[]}} params
+ * @param {Record<string, string>} inputShas label -> sha256 hex, for every label the step cites
+ * @returns {Record<string, any>} a spec for bareguard's `createRubric`
+ */
+export function buildStepSpec(params: {
+    step: number;
+    parts: any[];
+}, inputShas: Record<string, string>): Record<string, any>;
+/**
+ * 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
+ * answer — that limit is documented, not hidden.
+ * @param {string|null} bytes the file's text, or null when it does not exist
+ * @returns {{obj: Record<string, any>, why: null}|{obj: null, why: 'missing'|'not-json'|'not-object'}}
+ */
+export function parseStepFile(bytes: string | null): {
+    obj: Record<string, any>;
+    why: null;
+} | {
+    obj: null;
+    why: "missing" | "not-json" | "not-object";
+};
+/**
+ * The step file as bareguard's rubric reads it: a flat object. `text` stays `text`; each label in `cites` becomes the field
+ * `cites:<label>` (the name a `cited` check reads its claims from). Nothing else in the file is read.
+ * @param {Record<string, any>} obj
+ * @param {string[]} [countLabels] labels whose claim COUNT a minClaims/maxClaims part reads
+ * @param {any} [factPart] the step's `fact` part: its `results` become claims (text built by code) under `cites:<source>`
+ * @returns {Record<string, any>}
+ */
+export function flattenStep(obj: Record<string, any>, countLabels?: string[], factPart?: any): Record<string, any>;
+/**
+ * One bareguard gap as a sentence the worker can act on. The numbers and names are bareguard's own measurements and the
+ * person's signed limits, never anything this module infers; a gap this table does not know falls back to bareguard's own
+ * rendering, so nothing is ever dropped.
+ * @param {number} step @param {string} why why there was no object, when there was none
+ * @param {any} g a bareguard gap
+ * @param {any} [params] the stage's parameters (a fact step words its gaps by fact)
+ * @returns {string}
+ */
+export function plainStepGap(step: number, why: string, g: any, params?: any): string;
+/**
+ * Grade ONE step: build the rubric, run it over the step file's fields, and say what happened in the close's own terms.
+ * Pure of the filesystem (the runner in src/kinds.js reads the files). `stopped` = the instrument failed (never a red).
+ * @param {{params: {step: number, parts: any[]}, bytes: string|null, outputBytes: string|null, inputs: Record<string, string>,
+ *   factQuotes?: Record<number, string[]>, factMissing?: number[]}} o
+ *   `factQuotes` maps an earlier fact line's number to the quotes its (already checked) step file holds — what a prose step's numbers are tied to
+ *   `factMissing` lists the earlier fact lines whose step file is not there (yet): a normal red, never an instrument fault
+ *   `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>}>}
+ */
+export function gradeStep({ params, bytes, outputBytes, inputs, factQuotes, factMissing }: {
+    params: {
+        step: number;
+        parts: any[];
+    };
+    bytes: string | null;
+    outputBytes: string | null;
+    inputs: Record<string, string>;
+    factQuotes?: Record<number, string[]>;
+    factMissing?: number[];
+}, inputShas: Record<string, string>): Promise<{
+    verdict: "green" | "red" | "stopped";
+    gapLines: string[];
+    fault: string | null;
+    detail: Record<string, any>;
+}>;
+/**
+ * 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).
+ * @param {unknown} inputs @returns {string[]|null}
+ */
+export function inputLabelsOf(inputs: unknown): string[] | null;
+/**
+ * R11 — the drafting-time rules for the `rubric-step` stages of a declaration, each a red in the person's plain words that
+ * names the job line and ends "Nothing spent." where nothing was. Pure; never throws. Judged parts are RED in this build
+ * (the judge arrives in the next one): the sorting is still asked for, so a part that needs the judge is named as such
+ * instead of being approximated by a count.
+ *   - a stage serves exactly the one job line it names (`step` = its only `fromLine`), and no line has two stages;
+ *   - a part with no class (`none`) cannot be counted or checked against a quote;
+ *   - a `judged` part needs the judge; a `guard` part is about web sources and the job has no web input;
+ *   - two countable parts of ONE line that no text can satisfy together (a minimum above a maximum) are a contradiction,
+ *     naming both parts and both numbers;
+ *   - a `cited` part names a label the person's inputs do not have.
+ * @param {any[]} stages the declaration's stages
+ * @param {{inputLabels?: string[]|null, red: (code: string, path: string, detail: string, extra?: object) => void}} o
+ *   `inputLabels` absent = the label rule is not run (a caller with no inputs in hand)
+ */
+export function checkRubricParts(stages: any[], { inputLabels, red }: {
+    inputLabels?: string[] | null;
+    red: (code: string, path: string, detail: string, extra?: object) => void;
+}): void;
+/** the ~ rules of one job line, one string each (`rules` when the line has the array, else the joined `rule` split on "; ") @param {any} l @returns {string[]} */
+export function lineRules(l: any): string[];
+/**
+ * PART 1b, RF16 + RF17 — the rules that need the person's own job lines. Only a close built for REQUIRED FACTS is held to them (a
+ * close with a fact part, or any part that says which `~` rules it carries out): an older Part 1a close is left as it was signed.
+ *   - every `~` rule of every job line is carried out by a part (its number in the part's `rules`), or is listed in `refused` with
+ *     its `rule` number, or its whole line is refused: a rule that is none of those was silently dropped, and that is a red;
+ *   - a number the AI made out of the person's words (a bound the person did not write) must be marked `aiProposal`, and a time
+ *     limit the AI proposes must be a range (`between`), never one-sided — "not a red-eye" must not let a 10 PM flight through.
+ * @param {any[]} stages @param {{jobLines?: any[]|null, refused?: any, red: (code: string, path: string, detail: string, extra?: object) => void}} o
+ */
+export function checkRubricRules(stages: any[], { jobLines, refused, red }: {
+    jobLines?: any[] | null;
+    refused?: any;
+    red: (code: string, path: string, detail: string, extra?: object) => void;
+}): void;
+/**
+ * PART 1c L3 - the person's own words win over the AI's reading of them, settled by CODE before anything is validated or signed:
+ *   - a limit on a fact whose bounds are all in the words the person wrote (the line, its `~` rules, an answer they gave) is the
+ *     person's, so it is NOT marked "AI's proposal" (smv710w8c3wdh: the plan called the person's own range the AI's);
+ *   - a time range the AI proposed while the person wrote ONE explicit positive time range ("between 07:00 and 23:00") on that line
+ *     is replaced by exactly that range (smv710w8c3wdh: the plan said 5:00 AM). Only when it is unambiguous: one such range in the
+ *     line's rules and one AI-proposed `between` time fact on the line; a rule with a negation ("not between ...") is never read as a range;
+ *   - a `~` rule is a check or under Not checked, never both: a `refused` entry for a rule that a part of its own line carries is dropped.
+ * Pure; returns a new declaration, the input untouched. The model is told the same in the brief; this makes it true either way.
+ * @param {any} declaration @param {any[]|null|undefined} jobLines @returns {any}
+ */
+export function settlePersonsWords(declaration: any, jobLines: any[] | null | undefined): any;
+/**
+ * PART 1b — put the number tie on every prose step. A rubric-step stage with no fact part that comes AFTER one or more fact
+ * stages gets exactly one `numbersFromFacts` part naming those lines; one the model wrote is replaced. Pure; returns a new
+ * declaration (the input is untouched). The model never writes this part: it is code's, so a draft cannot omit it.
+ * @param {any} declaration @returns {any}
+ */
+export function withFactBindings(declaration: any): 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).
+ * @param {any} closeDecl @param {any[]|null|undefined} jobLines @returns {string[]}
+ */
+export function ruleNotChecked(closeDecl: any, jobLines: any[] | null | undefined): string[];
+/**
+ * The Not-checked lines code owns for the rubric-step stages of a close: a prose step's CONTENT is judged by the person at
+ * Accept, and the card says so (PART 1b, RF5). One line per prose step (a stage with no fact part).
+ * @param {any} closeDecl @returns {string[]}
+ */
+export function proseNotChecked(closeDecl: any): 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.
+ * @param {any} part @returns {string}
+ */
+export function partSentence(part: any): string;
+/**
+ * The checks a signed close actually runs, per job line, in plain code-written sentences: one per countable part of every
+ * rubric-step stage. This is the ONE reader both the plan card and the sign-time invariant use.
+ * @param {any} closeDecl
+ * @returns {{line: number, text: string, covers: number[]}[]}
+ */
+export function checksOfClose(closeDecl: any): {
+    line: number;
+    text: string;
+    covers: number[];
+}[];
+/**
+ * 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
+ * `covers`) is moved to Not checked, in the person's words, with the reason. A check can therefore never be shown and then
+ * silently dropped (run mv5bk400: "lists 3 releases" was confirmed, then left out of the signed close without a word).
+ * @param {{confirmed: {text: string, fromLine: number[]|null}[], notChecked: string[], closeDecl: any, jobLines?: any[]|null}} o
+ *   `jobLines` — the person's numbered lines, so a ~ rule the drafter listed as Not checked reads in the person's own words
+ * @returns {{checkItems: {text: string, fromLine: number[]}[], notChecked: string[], moved: {text: string, fromLine: number[]|null}[]}}
+ */
+export function reconcileRubricPlan({ confirmed, notChecked, closeDecl, jobLines }: {
+    confirmed: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+    notChecked: string[];
+    closeDecl: any;
+    jobLines?: any[] | null;
+}): {
+    checkItems: {
+        text: string;
+        fromLine: number[];
+    }[];
+    notChecked: string[];
+    moved: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+};
+/**
+ * The sign-time invariant: the checks the person was shown (`shown`, from the plan card) are exactly the checks the signed
+ * close runs (`checksOfClose`), per line. Pure.
+ * @param {{text: string, fromLine: number[]|null}[]} shown @param {any} closeDecl
+ * @returns {{ok: true}|{ok: false, error: string}}
+ */
+export function planMatchesClose(shown: {
+    text: string;
+    fromLine: number[] | null;
+}[], closeDecl: any): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The frozen TEXT of the named inputs, read the way the runner reads them: the source door's record (`source.json`, one level
+ * above the tree) names each input's file and sha256, and a file whose bytes no longer match is not returned. Used at DRAFTING
+ * (the drafter reads the input, the early tests run on it) and at run start (the backstop). Never throws.
+ * @param {string} workdir the frozen tree @param {string[]} labels
+ * @returns {Promise<{ok: true, texts: Record<string, string>}|{ok: false, why: string}>}
+ */
+export function readFrozenInputs(workdir: string, labels: string[]): Promise<{
+    ok: true;
+    texts: Record<string, string>;
+} | {
+    ok: false;
+    why: string;
+}>;
+/** where the per-line step files live, inside the job's tree; `copyOut` delivers them with the rest of `output/` */
+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;
+/** 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[];
+/**
+ * The counted/quoted checks a `countable` part may name, with the fields each needs — read off bareguard's own rule table
+ * (`rubricVocabulary`): the names are bareguard's, so a check this build cannot run is inexpressible, not rejected late.
+ * (`max`/`min` need a numeric field the step file does not have, so they are not offered.)
+ * @type {Readonly<Record<string, readonly string[]>>}
+ */
+export const COUNT_CHECKS: Readonly<Record<string, readonly string[]>>;
+export function sha256Of(b: string | Buffer): string;
+export type ShapeRed = {
+    code: string;
+    path: string;
+    detail: string;
+};