bareloop 0.42.0 → 0.44.0

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

@@ -54,6 +54,18 @@ export function planMessage(p: {
 export function jobNameTaken(name: string, opts?: {
     jobsDir?: string;
 }): boolean;
+/**
+ * The next free name for a NEW workflow made from `origin` (RULED 2026-10-15, v1.101): `<base>-N`, N the next free number from 2.
+ * Base: when the origin ends in `-<digits>` AND the part before it is itself a job (in the run list or jobs/), that part (so `x-2`
+ * suggests `x-3`, never `x-2-2`); else the origin's own name. Free = not a run-list job and not {@link jobNameTaken}.
+ * @param {string} origin
+ * @param {Iterable<string>} runJobs job names in the panel's run list
+ * @param {{jobsDir?: string}} [opts] test seam for {@link jobNameTaken}
+ * @returns {string}
+ */
+export function nextFreeJobName(origin: string, runJobs: Iterable<string>, opts?: {
+    jobsDir?: string;
+}): string;
 /**
  * The repo a card names: Inputs line 1 (P7 — the Source box is gone; the first input IS the repo). `''` when the Inputs
  * box does not parse (the card validator refuses that before anything uses this).
@@ -68,13 +80,13 @@ export function cardSource(card: any): string;
  */
 export function cardFields(card: any): Record<string, any>;
 /**
- * The first LOCKED box on `card` that differs from what the signed workflow prefilled (`origin`), or `null` when
- * every locked box is untouched. Blank and absent read alike; whitespace is not compared.
+ * Did any JOB box on `card` change from what the origin run prefilled (`origin`)? Whitespace is not compared (a one-line input drops
+ * a text's newlines); an absent thinking tick reads as off.
  * @param {Record<string, any>} card the form as it was submitted
  * @param {Record<string, any>} origin the form as the server prefilled it
- * @returns {string|null} the offending field's label
+ * @returns {boolean}
  */
-export function lockedFieldChanged(card: Record<string, any>, origin: Record<string, any>): string | null;
+export function jobBoxesChanged(card: Record<string, any>, origin: Record<string, any>): boolean;
 /**
  * The spec a reuse signs: a COPY of the origin's signed spec with ONLY the open fields set from the card —
  * `writeScope` from Destination, `inputs` from the Inputs box (P7), `budgetUsd` from the $ cap, `maxWallMs` from the Time cap (absent when blank), and the
@@ -106,6 +118,18 @@ export function validateReuseCard(card: any, opts?: {
     ok: false;
     error: string;
 };
+/**
+ * THE ONE Destination check of a session start, at $0, before any session, copy or model call. The session's own pipeline, the HTTP
+ * start (`startSession`), the schedule's two clicks and a scheduled fire's `wouldAccept` all call THIS (never a copy of it), so a start
+ * that would be refused for its Destination is refused before anything is made.
+ * @param {{inputs?: unknown, destination?: unknown, checkType?: unknown}} card the Inputs text (line 1 = the source), the Destination and the check type
+ * @returns {string|null} the plain refusal, or null when the Destination is fine
+ */
+export function startDestinationProblem(card: {
+    inputs?: unknown;
+    destination?: unknown;
+    checkType?: unknown;
+}): string | null;
 /**
  * The ONE Destination rule for a REPO source (fresh card and Reuse card alike): there Destination is the write fence,
  * relative to the repo, so an absolute path is refused — at $0, before any copy or model call. A FOLDER source (or a
@@ -120,11 +144,12 @@ export function repoDestinationProblem(destination: string, isRepoLike: boolean)
  * creates a session or spends anything — never inside the async pipeline,
  * so a bad card refuses synchronously, in the same HTTP response.
  * @param {any} card
- * @param {{jobsDir?: string, rows?: readonly import('../providerrows.js').KeyRow[]}} [opts] `rows` = the Settings rows (the Model menu); jobsDir is a server-side test seam — NEVER read off the client card
+ * @param {{jobsDir?: string, allowName?: string, rows?: readonly import('../providerrows.js').KeyRow[]}} [opts] `rows` = the Settings rows (the Model menu); jobsDir is a server-side test seam — NEVER read off the client card; `allowName` = the origin job's own name on an unchanged red Reuse (it is the same job, not a collision)
  * @returns {{ok: true}|{ok: false, error: string}}
  */
 export function validateJobCard(card: any, opts?: {
     jobsDir?: string;
+    allowName?: string;
     rows?: readonly import("../providerrows.js").KeyRow[];
 }): {
     ok: true;
@@ -195,14 +220,14 @@ export const PLAN_FOOTER: "Sign & run to confirm this plan, or Revise to edit th
 /** the form's fields, in card order — what `card.json` stores, verbatim (P5 item 3) */
 export const CARD_FIELDS: readonly string[];
 /**
- * REUSE WORKFLOW (hamr 2026-10-03, replaces P5 item 3's same-job rule; Model opened 2026-10-04): a reuse card has exactly
- * FIVE open boxes — Inputs, Destination, Model, $ cap, Time cap — and every other box is the signed workflow, shown greyed and never
- * editable. The page greys them; THIS is what refuses (the server never trusts the page). Changing any locked box
- * is a different job: Clear the card, which drafts.
+ * REUSE WORKFLOW, ONE DOOR (RULED 2026-10-15, v1.101; replaces v1.88's five open boxes). Every box on the card is open. What decides
+ * the path is the CARD compared with the origin run's card, never the drafted spec: the JOB boxes are the job text (numbered lines,
+ * `~` rules, `~ PASS`/`~ FAIL`), the check type and the thinking tick. The RUN boxes (Inputs, Destination, Model, $ cap, Time cap)
+ * never decide it. A green origin with no job box changed reuses the signed plan verbatim (no drafting); anything else drafts.
  */
-export const REUSE_OPEN_FIELDS: readonly string[];
-/** every card field that is NOT open on a reuse card, in card order */
-export const REUSE_LOCKED_FIELDS: readonly string[];
+export const JOB_BOXES: readonly string[];
+/** the refusal for a plain-files rubric job whose Destination is not an absolute folder (ends with the words the session start shows) */
+export const FILES_DESTINATION_WORDS: "Destination must be the full path of a folder, like /home/me/out \u2014 the finished files are delivered there. Nothing spent.";
 export type StepLine = {
     id: string;
     label: string;

package/types/panel/runroutes.d.ts

@@ -1,3 +1,15 @@
+/**
+ * RULED 2026-10-16: the person never sees raw engine output. Of the engine's log tail, only a line it
+ * owns as a plain sentence passes through (a `Nothing spent.` / `Nothing was spent.` refusal, `DOOR REFUSED (...) — nothing was
+ * 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'|'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" | "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):
@@ -5,7 +17,11 @@
  * @param {{ port: number, token: string, env?: Record<string,string|undefined>, home?: string,
  *   spawnFn?: typeof realSpawn, bareloopBin?: string, settleMs?: number,
  *   getResumeContext: (runid: string) => ({row: any, plan: any}|null),
- *   getStopContext?: (runid: string) => ({row: any, live: boolean, spineExists: boolean}|null) }} opts
+ *   getStopContext?: (runid: string) => ({row: any, live: boolean, spineExists: boolean}|null),
+ *   getNeedsContext?: (runid: string) => ({row: any, needs: 'Accept'|'Resume'|null}|null),
+ *   getAcceptContext?: (runid: string) => ({row: any, live: boolean, waiting: boolean, specPath: string|null, specHash: string|null}|null),
+ *   stageQuestionsOfSpec?: (spec: any) => Map<string, string|null>,
+ *   acceptWaitMs?: number }} opts
  */
 export function createRunRoutes(opts: {
     port: number;
@@ -24,9 +40,24 @@ export function createRunRoutes(opts: {
         live: boolean;
         spineExists: boolean;
     } | null);
+    getNeedsContext?: (runid: string) => ({
+        row: any;
+        needs: "Accept" | "Resume" | null;
+    } | null);
+    getAcceptContext?: (runid: string) => ({
+        row: any;
+        live: boolean;
+        waiting: boolean;
+        specPath: string | null;
+        specHash: string | null;
+    } | null);
+    stageQuestionsOfSpec?: (spec: any) => Map<string, string | null>;
+    acceptWaitMs?: number;
 }): {
     handle: (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse, pathname: string, body: any) => boolean;
 };
 /** how long a resume waits for an early engine exit before reporting "started" (ms) */
 export const DEFAULT_SETTLE_MS: 6000;
+/** how long an Accept waits for the engine's answer (it re-runs the mechanical close stages) before saying it is still checking (ms) */
+export const DEFAULT_ACCEPT_WAIT_MS: number;
 import { spawn as realSpawn } from 'node:child_process';

package/types/panel/scheduler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {{ door: ReturnType<typeof import('./schedules.js').createScheduleDoor>, now?: () => number, intervalMs?: number }} opts
+ *   `intervalMs` 0 = no timer (a test drives `tick`).
+ */
+export function createScheduler(opts: {
+    door: ReturnType<typeof import("./schedules.js").createScheduleDoor>;
+    now?: () => number;
+    intervalMs?: number;
+}): {
+    tick: () => Promise<void>;
+    /** Start the real timer (idempotent). */
+    start(): void;
+    /** Stop it (idempotent). The server's close calls this. */
+    stop(): void;
+    /** whether the real timer is running (a test reads this) */
+    readonly running: boolean;
+};