bareloop 0.42.0 → 0.43.0

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'} 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;
 /**
  * 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;
+};

package/types/panel/schedules.d.ts

@@ -0,0 +1,412 @@
+/**
+ * When a process started, in epoch ms, from `/proc/<pid>/stat` field 22 (clock ticks since boot) and `/proc/stat` btime
+ * (whole seconds, so good to about a second). `null` where /proc cannot be read: the caller then trusts `isLiveRunner` alone.
+ * @param {number} pid
+ * @param {(path: string) => string} [read]
+ * @returns {number|null}
+ */
+export function procStartMs(pid: number, read?: (path: string) => string): number | null;
+/**
+ * Is this listed run's runner alive? `runIsAlive` (the pid is alive AND a bareloop runner) plus the PID REUSE GUARD: a
+ * pid whose process started MORE than 5 s after the row was written is a recycled pid, not that run. A resumed run's row
+ * keeps its first leg's time while its pid is the latest leg's, so the guard is skipped for it (the cmdline check stands).
+ * @param {any} row @param {number} nowMs
+ */
+export function runnerAlive(row: any, nowMs: number): boolean;
+/**
+ * @typedef {{runid: string, outcome: string|null, spec: any, records: any[]}} JobRun
+ * @typedef {{job: string, trigger: import('../trigger.js').Trigger, spec: any, specHash: string, workflowKey: string,
+ *   originRunid: string, inputsText: string, destination?: string, signedBy: string, signedAt: string}} Schedule
+ */
+/**
+ * @param {{
+ *   home?: string,
+ *   sessionsRoot?: string,
+ *   now?: () => number,
+ *   jobRuns: (job: string) => JobRun[],
+ *   startFrom: (runid: string) => any,
+ *   jobOfRun: (runid: string) => string|null,
+ *   rowsFor: () => readonly import('../providerrows.js').KeyRow[],
+ *   runRows?: () => any[],
+ *   installRetrySteps?: readonly number[], installGiveUpMs?: number,
+ *   userHome?: string,
+ * }} deps `userHome` = the folder shown as `~` in words (default the OS home). `installRetrySteps` (ms) and `installGiveUpMs` = the install-needed back-off (tests inject them). `runRows` = a test seam for the one run-list read the busy check does. `jobRuns(job)` = the job's listed runs, newest first, each with its signed spec when on disk and its terminal
+ *   outcome off the spine; `startFrom(runid)` = the panel's `getStartFrom`; `jobOfRun` = the listed run's job name.
+ */
+export function createScheduleDoor(deps: {
+    home?: string;
+    sessionsRoot?: string;
+    now?: () => number;
+    jobRuns: (job: string) => JobRun[];
+    startFrom: (runid: string) => any;
+    jobOfRun: (runid: string) => string | null;
+    rowsFor: () => readonly import("../providerrows.js").KeyRow[];
+    runRows?: () => any[];
+    installRetrySteps?: readonly number[];
+    installGiveUpMs?: number;
+    userHome?: string;
+}): {
+    /** The starter is built after the author routes (which need this door), so it is attached here. @param {ReturnType<typeof import('./schedulestart.js').createStarter>} s */
+    attachStarter(s: ReturnType<typeof import("./schedulestart.js").createStarter>): void;
+    busy: (job: string) => boolean;
+    paused: (job: string) => boolean;
+    /**
+     * RULED 2026-10-15 (v1.104): the fires that started NOTHING (busy, month used up, refused) of ALL signings of the job's schedule
+     * (the job's ledger is the job's, so every signing's rows are in it; cancelled-and-set-again rows stay). Newest first. Lines are
+     * `MM/DD HH:MM  <words>`. The caller shows the first 7 and counts them all.
+     * @param {string} job
+     * @returns {{at: number, line: string}[]}
+     */
+    skippedFor(job: string): {
+        at: number;
+        line: string;
+    }[];
+    /**
+     * One fire, in this order (T15): busy, then monthly, then wouldAccept, then the starter (which calls `beforeSpawn`, the
+     * ONE consuming row, only after every "no" is behind it). Each outcome is ONE row in ledger.jsonl, told once per
+     * `key|outcome|why` (read back from disk, so a restart does not repeat it). RULED 2026-10-14: a busy, monthly or refused
+     * fire consumes NOTHING, so the next tick tries again; a spawn error after `beforeSpawn` writes a `released` row (bounded).
+     * @param {string} job
+     * @param {{kind: 'clock', slot: number, catchUp: boolean, missed: number} | {kind: 'file', path: string, sha: string, size?: number}} cause
+     * @param {{beforeSpawn?: () => void, busy?: boolean}} [hooks] `busy` = the scheduler's one read of the run list this tick
+     * @returns {Promise<{outcome: 'busy'|'monthly-exhausted'|'refused'|'started', why?: string, told: boolean, sessionId?: string}>}
+     */
+    fire(job: string, cause: {
+        kind: "clock";
+        slot: number;
+        catchUp: boolean;
+        missed: number;
+    } | {
+        kind: "file";
+        path: string;
+        sha: string;
+        size?: number;
+    }, hooks?: {
+        beforeSpawn?: () => void;
+        busy?: boolean;
+    }): Promise<{
+        outcome: "busy" | "monthly-exhausted" | "refused" | "started";
+        why?: string;
+        told: boolean;
+        sessionId?: string;
+    }>;
+    greenFor: (job: string) => {
+        ok: true;
+        run: JobRun;
+        key: string;
+    } | {
+        ok: false;
+        say: string;
+    };
+    armFor: (job: string, schedule: Schedule, o?: {
+        baseline?: boolean;
+    }) => {
+        armed: boolean;
+        already: boolean;
+    };
+    readSchedule: (job: string) => Schedule | null;
+    ledgerOf: (job: string) => string;
+    /**
+     * A failure the scheduler met on a job (a folder that went away, a file refused), written as ONE `refused` row per
+     * `tag`, read back from disk so a restart does not repeat it (T13). Returns whether it wrote.
+     * @param {string} job @param {string} sig @param {string} tag @param {string} why
+     */
+    tellOnce(job: string, sig: string, tag: string, why: string): boolean;
+    /** Click 1. All $0 checks; signs and writes nothing; returns `{words, hash, monthlyNote}`. @param {any} body */
+    prepare(body: any): {
+        status: number;
+        body: {
+            ok: boolean;
+        };
+    } | {
+        status: number;
+        body: {
+            ok: boolean;
+            job: any;
+            words: string | null;
+            hash: string;
+            monthlyNote: string | null;
+            cancel: boolean;
+        };
+    };
+    /** Click 2, carrying the hash it was shown. $0: no drafter, no run. @param {any} body */
+    set(body: any): {
+        status: number;
+        body: {
+            ok: boolean;
+        };
+    } | {
+        status: number;
+        body: {
+            ok: boolean;
+            refused: string;
+            say: "What you were shown is not what is on the card now. Nothing was signed. Look again, then sign.";
+            job?: undefined;
+            cancelled?: undefined;
+            words?: undefined;
+        };
+    } | {
+        status: number;
+        body: {
+            ok: boolean;
+            job: any;
+            cancelled: boolean;
+            words: "Cancel schedule";
+            refused?: undefined;
+            say?: undefined;
+        };
+    } | {
+        status: number;
+        body: {
+            say?: string | undefined;
+            ok: boolean;
+            job: any;
+            words: string | null;
+            hash: string;
+            armed: boolean;
+            refused?: undefined;
+            cancelled?: undefined;
+        };
+    };
+    /** Cancel a job's schedule, never refused. @param {string} job @returns {boolean} there was one */
+    cancel(job: string): boolean;
+    /** Every job with a schedule.json: `{job, dir, schedule}`. One readdir; nothing else read when there is none. */
+    scan(): {
+        job: string;
+        dir: string;
+        schedule: Schedule;
+    }[];
+    /**
+     * What a card shows of a job's schedule, as DATA (no words): the trigger, whether it is armed under the CURRENT
+     * signing, the next slot (clock kinds), the last outcome (rows under the current signing only, never a wall-clock
+     * compare, T19), whether the job has a green run, and the refusal sentence when it has none.
+     * @param {string} job
+     */
+    read(job: string): {
+        schedule: null;
+        trigger: null;
+        armed: boolean;
+        armedAt: null;
+        nextSlotMs: null;
+        lastOutcome: null;
+        retryInMs: null;
+        gaveUp: null;
+        job: string;
+        hasGreen: boolean;
+        refusal: string | null;
+    } | {
+        schedule: Schedule;
+        trigger: import("../trigger.js").Trigger;
+        armed: boolean;
+        armedAt: number | null | undefined;
+        nextSlotMs: number | null;
+        lastOutcome: import("../triggerledger.js").LedgerRow | null;
+        retryInMs: number | null;
+        gaveUp: import("../triggerledger.js").LedgerRow | null;
+        job: string;
+        hasGreen: boolean;
+        refusal: string | null;
+    } | null;
+    stateOf: (job: string) => {
+        schedule: null;
+        trigger: null;
+        armed: boolean;
+        armedAt: null;
+        nextSlotMs: null;
+        lastOutcome: null;
+        retryInMs: null;
+        gaveUp: null;
+    } | {
+        schedule: Schedule;
+        trigger: import("../trigger.js").Trigger;
+        armed: boolean;
+        armedAt: number | null | undefined;
+        nextSlotMs: number | null;
+        lastOutcome: import("../triggerledger.js").LedgerRow | null;
+        retryInMs: number | null;
+        gaveUp: import("../triggerledger.js").LedgerRow | null;
+    };
+    userHome: string;
+    /**
+     * What the Run tab shows of a job's schedule (A.12: one read of the schedule files and the ledger; the green gate is
+     * memoised per run-list state, so a poll never re-parses every run). The SERVER decides: `scheduled` shows Cancel /
+     * modify, else `canSchedule` shows Schedule run, else no button. `fromRunid` = the green run the card opens from. `waitingRunNo` = the job's newest run when it waits
+     * for the person's Accept (the next scheduled run does NOT wait for it, T7).
+     * @param {string} job @param {{waitingRunNo?: number|null}} [o]
+     */
+    view(job: string, o?: {
+        waitingRunNo?: number | null;
+    }): {
+        fromRunid?: string | undefined;
+        scheduled: boolean;
+        canSchedule: boolean;
+        words: Readonly<{
+            byHand: "By hand";
+            cancelSchedule: "Cancel schedule";
+            cancelWords: "Cancel schedule";
+            scheduleRun: "Schedule run";
+            cancelModify: "Cancel / modify schedule";
+            signSchedule: "Sign schedule";
+            nothingChanged: "Nothing changed yet. This card only sets or adjusts the schedule; it never runs the job.";
+            confirmPrefix: "Confirm: ";
+            whenLabel: "When";
+            nowPrefix: "Now: ";
+            scheduledLabel: "SCHEDULE";
+            nextLabel: "NEXT";
+            options: Readonly<{
+                hand: "By hand";
+                daily: "Every day at HH:MM";
+                weekdays: "Weekdays at HH:MM";
+                weekly: "Every <day> at HH:MM";
+                'file-updated': "When <file> is updated";
+                'new-file': "When a new file arrives in <folder>";
+            }>;
+            gaveUpPill: "Check";
+            problemNext: "next: fix it in Cancel / modify schedule";
+            monthNext: "next: raise the limit in Settings, or it starts on the 1st";
+            acceptWaiting: "waiting for your Accept (the next run does not wait)";
+            scheduleGroup: "schedule";
+            notGreen: "This job has not had a good run yet. Run it by hand and get it right first; then you can set when it runs. A rubric job also needs your Accept once. Nothing was changed.";
+            stale: "What you were shown is not what is on the card now. Nothing was signed. Look again, then sign.";
+        }>;
+        text?: undefined;
+        next?: undefined;
+        nextRed?: undefined;
+        lastRow?: undefined;
+        problem?: undefined;
+        nextWords?: undefined;
+        accept?: undefined;
+    } | {
+        scheduled: boolean;
+        canSchedule: boolean;
+        words: Readonly<{
+            byHand: "By hand";
+            cancelSchedule: "Cancel schedule";
+            cancelWords: "Cancel schedule";
+            scheduleRun: "Schedule run";
+            cancelModify: "Cancel / modify schedule";
+            signSchedule: "Sign schedule";
+            nothingChanged: "Nothing changed yet. This card only sets or adjusts the schedule; it never runs the job.";
+            confirmPrefix: "Confirm: ";
+            whenLabel: "When";
+            nowPrefix: "Now: ";
+            scheduledLabel: "SCHEDULE";
+            nextLabel: "NEXT";
+            options: Readonly<{
+                hand: "By hand";
+                daily: "Every day at HH:MM";
+                weekdays: "Weekdays at HH:MM";
+                weekly: "Every <day> at HH:MM";
+                'file-updated': "When <file> is updated";
+                'new-file': "When a new file arrives in <folder>";
+            }>;
+            gaveUpPill: "Check";
+            problemNext: "next: fix it in Cancel / modify schedule";
+            monthNext: "next: raise the limit in Settings, or it starts on the 1st";
+            acceptWaiting: "waiting for your Accept (the next run does not wait)";
+            scheduleGroup: "schedule";
+            notGreen: "This job has not had a good run yet. Run it by hand and get it right first; then you can set when it runs. A rubric job also needs your Accept once. Nothing was changed.";
+            stale: "What you were shown is not what is on the card now. Nothing was signed. Look again, then sign.";
+        }>;
+        fromRunid: string;
+        text: string | null;
+        next: string;
+        nextRed: boolean;
+        lastRow: import("../triggerledger.js").LedgerRow | null;
+        problem: boolean;
+        nextWords: string;
+        accept: boolean;
+    } | null;
+    /**
+     * The schedule card's data for `start-from?mode=schedule`: the current schedule in the When field's own terms, the
+     * words, the refusal that disables the field (a job with no good run and no schedule), and the edit note.
+     * Cancel is never refused, so a scheduled job is never disabled here.
+     * @param {string} job
+     */
+    cardFor(job: string): {
+        scheduled: boolean;
+        trigger: import("../trigger.js").Trigger | null;
+        now: string | null;
+        refusal: string | null;
+        words: Readonly<{
+            byHand: "By hand";
+            cancelSchedule: "Cancel schedule";
+            cancelWords: "Cancel schedule";
+            scheduleRun: "Schedule run";
+            cancelModify: "Cancel / modify schedule";
+            signSchedule: "Sign schedule";
+            nothingChanged: "Nothing changed yet. This card only sets or adjusts the schedule; it never runs the job.";
+            confirmPrefix: "Confirm: ";
+            whenLabel: "When";
+            nowPrefix: "Now: ";
+            scheduledLabel: "SCHEDULE";
+            nextLabel: "NEXT";
+            options: Readonly<{
+                hand: "By hand";
+                daily: "Every day at HH:MM";
+                weekdays: "Weekdays at HH:MM";
+                weekly: "Every <day> at HH:MM";
+                'file-updated': "When <file> is updated";
+                'new-file': "When a new file arrives in <folder>";
+            }>;
+            gaveUpPill: "Check";
+            problemNext: "next: fix it in Cancel / modify schedule";
+            monthNext: "next: raise the limit in Settings, or it starts on the 1st";
+            acceptWaiting: "waiting for your Accept (the next run does not wait)";
+            scheduleGroup: "schedule";
+            notGreen: "This job has not had a good run yet. Run it by hand and get it right first; then you can set when it runs. A rubric job also needs your Accept once. Nothing was changed.";
+            stale: "What you were shown is not what is on the card now. Nothing was signed. Look again, then sign.";
+        }>;
+    };
+    /**
+     * RULED 2026-10-15: the jobs whose schedule gave up, for the runs list's Needs you section (the SERVER decides; the page works out nothing):
+     * `[{job, pill: 'Check', words, at: 'MM/DD HH:MM', runId}]`, newest give-up first. `runId` = the job's HEAD run by time. Never ages out.
+     * @param {Map<string, string|null>|Record<string, string|null>} heads
+     */
+    listGaveUp(heads: Map<string, string | null> | Record<string, string | null>): {
+        job: string;
+        pill: "Check";
+        words: string;
+        at: string;
+        runId: string | null;
+    }[];
+    /**
+     * The Scheduled section of the runs list: `[{job, at, in, words, runId}]`, soonest first; a file trigger (no clock
+     * time) after those that have one, by name. `heads` = job -> its HEAD run id by time (summarizeJobs), so the click
+     * opens the job's newest run, never "the first in server order". A job that cannot be read is absent.
+     * @param {Map<string, string|null>|Record<string, string|null>} heads
+     */
+    listScheduled(heads: Map<string, string | null> | Record<string, string | null>): {
+        job: string;
+        at: string | null;
+        in: string | null;
+        words: string | null;
+        runId: string | null;
+    }[];
+};
+/** a spawn error after the consuming row releases it at most this many times; then it stays consumed (bounded rows) */
+export const MAX_RELEASES: 3;
+/** a live pid whose process started more than this after its run row was written is a RECYCLED pid, not that run */
+export const PID_REUSE_SLACK_MS: 5000;
+/** RULED 2026-10-15: waits (ms) between consecutive `install-needed` refusals of a job: Fibonacci 1, 2, 3, 5, 8, 13, 21 minutes. A test injects its own via `deps.installRetrySteps`. */
+export const INSTALL_RETRY_STEPS_MS: readonly number[];
+/** RULED 2026-10-15: the total wait a slot or file gets. A wait that would pass it is not taken: the schedule gives up and pauses (the job waits in Needs you). */
+export const INSTALL_GIVE_UP_MS: number;
+export type JobRun = {
+    runid: string;
+    outcome: string | null;
+    spec: any;
+    records: any[];
+};
+export type Schedule = {
+    job: string;
+    trigger: import("../trigger.js").Trigger;
+    spec: any;
+    specHash: string;
+    workflowKey: string;
+    originRunid: string;
+    inputsText: string;
+    destination?: string;
+    signedBy: string;
+    signedAt: string;
+};