bareloop 0.46.0 → 0.47.0

package/types/learn.d.ts

@@ -193,7 +193,7 @@ export function foldCards(cards: Card[]): Card[][];
  * @typedef {object} Ledger
  * @property {1} version
  * @property {Row[]} rows
- * @property {Pending[]} pending     rubric cards held until a human Accept (NOT counted, NOT readable)
+ * @property {Pending[]} pending     holds written by v0.46.x for rubric runs, released by the human Accept (NOT counted, NOT readable); new runs never write one
  * @property {Card[]} suspect        CHECK-SUSPECT cards, listed, newest last
  * @property {Record<string, {at: string, noise: string|null, cards: number, suspect: number, thin: number}>} health  per run (idempotent by run id)
  */
@@ -208,8 +208,9 @@ export function lessonOf(c: Card): string;
  * Fold ONE run's cards into the ledger. Pure: returns a new ledger.
  *
  * +1 per RUN per row: the run's own cards are folded into lessons first, and a row whose `runIds` already holds the
- * run id is never counted twice (a resumed run, one id, never double counts). A matching lesson replaces the row's
- * sample, bumps the model count and appends the run id (a row last seen 56+ days ago counts +1 and is read again);
+ * run id is never counted twice (a resumed run, one id, never double counts) but IS refreshed: the resumed leg's card
+ * replaces the sample, lesson, key, lastSeen, hash and place (a leg-1 NEVER FIXED row becomes the leg-2 FIXED one). A
+ * matching lesson replaces the row's sample, bumps the model count and appends the run id (a row last seen 56+ days ago counts +1 and is read again);
  * otherwise it opens a new row at count 1. NEVER FIXED cards count like FIXED ones (RULING 3). A workflow row of
  * another signed hash is never matched here: the new version opens its own rows. Nothing is ever deleted or stamped.
  * @param {Ledger} ledger
@@ -234,8 +235,8 @@ export function countLedger(ledger: Ledger, { runid, cards, workflow, place, spe
  */
 export function climb(rows: Row[]): Row[];
 /**
- * A rubric run's cards are HELD, not counted, until a human Accept (the existing quarantine is the rule). Replaces
- * an earlier hold for the same run id (a resumed run re-derives its cards). Pure.
+ * Hold a run's cards until a human Accept. NO LONGER CALLED for new runs (v1.112: a rubric run's lessons count at run
+ * end); kept so a hold already in a ledger file still has a writer for tests and a reader in {@link releasePending}. Pure.
  * @param {Ledger} ledger
  * @param {{runid: string, cards: Card[], workflow: string, place: string|null, specHash: string|null, at: string}} o
  * @param {Date} now @returns {Ledger}
@@ -249,7 +250,7 @@ export function holdPending(ledger: Ledger, { runid, cards, workflow, place, spe
     at: string;
 }, now: Date): Ledger;
 /**
- * The human Accept releases a held rubric run: its cards count now (trust `rubric`). Only forward, only here. A hold
+ * The human Accept releases an OLD hold (written by v0.46.x; new runs write none): its cards count now (trust `rubric`). Only forward, only here. A hold
  * older than 60 days is dropped uncounted. Idempotent (no hold = nothing to do; run ids stop a double count).
  * @param {Ledger} ledger @param {string} runid @param {Date} now
  * @returns {{ledger: Ledger, released: number}}
@@ -510,7 +511,7 @@ export type Ledger = {
     version: 1;
     rows: Row[];
     /**
-     * rubric cards held until a human Accept (NOT counted, NOT readable)
+     * holds written by v0.46.x for rubric runs, released by the human Accept (NOT counted, NOT readable); new runs never write one
      */
     pending: Pending[];
     /**

package/types/learnstore.d.ts

@@ -22,9 +22,8 @@ export function readLedger(home?: string): {
  */
 export function writeLedger(ledger: import("./learn.js").Ledger, home?: string): string;
 /**
- * Fold ONE finished run into the ledger on disk: a deterministic job's cards COUNT now; a rubric job's cards are HELD
- * until a human Accept (they are written to `pending`, never counted, never readable). The run's health line is recorded
- * either way. Never throws on a bad ledger file: it reports `problem` and writes nothing.
+ * Fold ONE finished run into the ledger on disk: every run's cards COUNT now, rubric jobs too (trust kept on new rows;
+ * v1.112). `held` is always 0 (kept in the shape for callers). The run's health line is recorded. Never throws on a bad ledger file: it reports `problem` and writes nothing.
  * @param {{home?: string, runid: string, build: import('./learn.js').CardBuild, workflow: string, place: string|null, specHash: string|null, trust: 'deterministic'|'rubric', at: string, now?: Date}} o
  * @returns {{wrote: boolean, counted: number, held: number, problem: string|null}}
  */
@@ -45,7 +44,7 @@ export function foldRunIntoLedger({ home, runid, build, workflow, place, specHas
     problem: string | null;
 };
 /**
- * The human Accept at the review door: release the run's held rubric cards so they count (only forward, only here).
+ * The human Accept at the review door: release a hold an older version wrote for the run so it counts (new runs write none; only forward, only here).
  * @param {{home?: string, runid: string, now?: Date}} o
  * @returns {{released: number, problem: string|null}}
  */
@@ -66,7 +65,7 @@ export function releaseRun({ home, runid, now }: {
 export function learningHintsOn(home?: string): boolean;
 /**
  * THE RUN-END TALLY ($0, code only, no model): turn the finished run's whole record into cards and fold them into the
- * ledger (a rubric job's are held until Accept). Called once from the one engine's run-end block (src/userrun.js
+ * ledger (a rubric job's count too, trust kept). Called once from the one engine's run-end block (src/userrun.js
  * `execute`, shared by the panel, the CLI and the bundle runner), inside its own try/catch: it is a record, never a verdict,
  * and can never change a run's outcome, exit code or spend. It runs whether the hints setting is on or off.
  * @param {{home?: string, runid: string, events: any[], auditFiles?: string[], spec: any, specHash: string|null, workdir: string|null, trust: 'deterministic'|'rubric', now?: Date}} o

package/types/opener.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {string} target a folder path or a URL
+ * @param {{ platform?: string, spawnFn?: ((cmd: string, args: string[], o: object) => any)|null, underTest?: boolean }} [opts]
+ *   `spawnFn: null` = no opener at all (resolves false); undefined = the real spawn, unless `underTest`, which spawns nothing
+ *   unless a test injected one
+ * @returns {Promise<boolean>} true once the opener process has started
+ */
+export function openInOs(target: string, opts?: {
+    platform?: string;
+    spawnFn?: ((cmd: string, args: string[], o: object) => any) | null;
+    underTest?: boolean;
+}): Promise<boolean>;

package/types/panel/authorroutes.d.ts

@@ -87,6 +87,7 @@ 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>;
+    openDrafts: () => number;
     startSession: (card: any, reuse: {
         spec: any;
         workflowKey: string;

package/types/panel/server.d.ts

@@ -1,3 +1,7 @@
+/** bareloop's own version, from its package.json (read each time the page is served); 'unknown' if it cannot be read, never a guess
+ * @param {string} [file] test seam: another package.json
+ * @returns {string} */
+export function packageVersion(file?: string): string;
 /**
  * `[✓]`/`[✗]`/`[■]`/`[▶]` — the ONLY vocabulary a result is ever rendered in
  * (auto-memory `ui-verdict-words.md`: never the words green/red/soft-green
@@ -288,6 +292,20 @@ export function runsListPayload(opts?: {
         needsYouDays: 7;
     }>;
 };
+/**
+ * The runs list as the panel builds it, for a caller with no panel running (the launcher header): the same `runsListPayload` over a
+ * schedule door built read-only (no scheduler, no timer), so Needs you = the rows tagged `needs` + the schedules that gave up, ONE owner.
+ * @param {{ home?: string, now?: number, env?: Record<string, string|undefined> }} [opts]
+ * @returns {{ runs: any[], gaveUp: any[] }}
+ */
+export function runsListForCount(opts?: {
+    home?: string;
+    now?: number;
+    env?: Record<string, string | undefined>;
+}): {
+    runs: any[];
+    gaveUp: any[];
+};
 /**
  * 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).
@@ -778,6 +796,12 @@ export function handleRequest(req: import("node:http").IncomingMessage, res: imp
     importRoutes?: ReturnType<typeof createImportRoutes>;
     schedules?: ReturnType<typeof createScheduleDoor>;
 }): void;
+/**
+ * The ONE spelling of the panel's own address (the launcher prints and opens it too).
+ * @param {number} boundPort
+ * @returns {string}
+ */
+export function panelUrl(boundPort: number): string;
 /**
  * Start the panel server. Binds `127.0.0.1` ONLY. A taken port is a LOUD,
  * non-zero-exit failure — this never falls back to another port (see file

package/types/panel/status.d.ts

@@ -1,3 +1,11 @@
+/**
+ * ONE spelling of "this run's outcome is a green that can be reused" (the Reuse picker, the Reuse start/prefill, the Ended block's
+ * next line). hamr 2026-10-15: an `already-green` (fixed before any work) counts. `satisfied` is a close verdict, never a run outcome.
+ * The SCHEDULE gate (schedules.js greenFor) deliberately stays on a real `green` only (T3).
+ * @param {string|null|undefined} outcome
+ * @returns {boolean}
+ */
+export function isReusableGreen(outcome: string | null | undefined): boolean;
 /**
  * The status of one run.
  * @param {{outcome: string|null|undefined, died?: boolean, category?: string|null, moneyHalt?: boolean}} o

package/types/stagewords.d.ts

@@ -8,21 +8,6 @@
  * question.
  * @param {any} params @returns {string|null} */
 export function cmdKey(params: any): string | null;
-export function stageQuestionText({ kind, params, genre, suiteCmdKeys, }: {
-    kind: any;
-    params: any;
-    genre: any;
-    suiteCmdKeys: any;
-}): string | null;
-/**
- * Stage name to its plain question, off a signed spec's `closeDecl.stages` — the one pass that gathers every
- * `command-exit` stage's cmd+args FIRST (so the failing-test-count half of `suite-green`'s pair can be told from a
- * genuine typecheck stage) and then asks {@link stageQuestionText} per stage. `null` for a stage with no honest
- * question; an empty map for a spec with no declared stages.
- * @param {any} spec
- * @returns {Map<string, string|null>}
- */
-export function stageQuestionsByName(spec: any): Map<string, string | null>;
 /**
  * THE PLAIN-QUESTION OWNER (plain-checks build, 2026-09-28, hamr's ruling:
  * the "checks N/M" headline is WITHDRAWN — "confusing, reads like 6 failed
@@ -85,6 +70,22 @@ export function stageQuestionsByName(spec: any): Map<string, string | null>;
  * @param {{kind: string|null, params: any, genre: string|null, suiteCmdKeys: Set<string>}} o
  * @returns {string|null}
  */
+export function stageQuestionText({ kind, params, genre, suiteCmdKeys, }: {
+    kind: string | null;
+    params: any;
+    genre: string | null;
+    suiteCmdKeys: Set<string>;
+}): string | null;
+/**
+ * Stage name to its plain question, off a signed spec's `closeDecl.stages` — the one pass that gathers every
+ * `command-exit` stage's cmd+args FIRST (so the failing-test-count half of `suite-green`'s pair can be told from a
+ * genuine typecheck stage) and then asks {@link stageQuestionText} per stage. `null` for a stage with no honest
+ * question; an empty map for a spec with no declared stages.
+ * @param {any} spec
+ * @returns {Map<string, string|null>}
+ */
+export function stageQuestionsByName(spec: any): Map<string, string | null>;
+/** the genre-owned noun for the count a TYPES-genre typecheck stage measures (see {@link stageQuestionText}) */
 export const GENRE_WHAT: Readonly<{
     TYPES: "type errors";
 }>;

package/types/tty-colour.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @typedef {object} Paint
+ * @property {boolean} on
+ * @property {(s: string) => string} grey @property {(s: string) => string} green @property {(s: string) => string} yellow
+ * @property {(s: string) => string} red @property {(s: string) => string} cyan @property {(s: string) => string} boldCyan
+ */
+/**
+ * Colour is on only for a terminal: the stream says it is a TTY, `NO_COLOR` is empty/unset, and `TERM` is not `dumb`.
+ * @param {{isTTY?: boolean}|undefined} stream the output stream (process.stdout)
+ * @param {Record<string, string|undefined>} [env]
+ * @returns {Paint}
+ */
+export function makePaint(stream: {
+    isTTY?: boolean;
+} | undefined, env?: Record<string, string | undefined>): Paint;
+export namespace PLAIN {
+    let on: boolean;
+    let grey: (s: string) => string;
+    let green: (s: string) => string;
+    let yellow: (s: string) => string;
+    let red: (s: string) => string;
+    let cyan: (s: string) => string;
+    let boldCyan: (s: string) => string;
+}
+export type Paint = {
+    on: boolean;
+    grey: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    cyan: (s: string) => string;
+    boldCyan: (s: string) => string;
+};