bareloop 0.43.0 → 0.45.0

package/types/runlist.d.ts

@@ -48,7 +48,8 @@ export function appendRun(row: RunRow, opts?: {
     reason?: "duplicate-runid";
 };
 /**
- * @typedef {{ runid: string, type: 'settled'|'released', by: string, at: string, reason?: string, spentUsd?: number, spendComplete?: boolean, leg?: number }} RunEvent
+ * @typedef {{ runid: string, type: 'settled'|'released', by: string, at: string, reason?: string, words?: string, spentUsd?: number, spendComplete?: boolean, leg?: number }} RunEvent
+ * `words` (2026-10-19): on a `settled` with `reason: 'refused before start'`, the plain refusal the panel shows for that run (it has no spine).
  * `leg` (P5-R): which leg of the run the write-back is about; absent = leg 1 (every entry written before P5-R).
  * A resumed run is ONE row, so `settled`/`released` are per leg: a later leg's `released` gives back THAT leg's
  * claim and never removes the run.
@@ -226,6 +227,7 @@ export type RunRow = {
     leg?: number;
 };
 /**
+ * `words` (2026-10-19): on a `settled` with `reason: 'refused before start'`, the plain refusal the panel shows for that run (it has no spine).
  * `leg` (P5-R): which leg of the run the write-back is about; absent = leg 1 (every entry written before P5-R).
  * A resumed run is ONE row, so `settled`/`released` are per leg: a later leg's `released` gives back THAT leg's
  * claim and never removes the run.
@@ -241,6 +243,7 @@ export type RunEvent = {
     by: string;
     at: string;
     reason?: string;
+    words?: string;
     spentUsd?: number;
     spendComplete?: boolean;
     leg?: number;

package/types/schedulewords.d.ts

@@ -84,14 +84,16 @@ export function jobScheduleWords(f: {
 export function retryNextWords(ms: number): string;
 /**
  * RULED 2026-10-15: the sign on the head of the Audit's `schedule` section. ONE small rule (hamr may still adjust it): [▶] only while a
- * run of the job is running (as everywhere in the panel), [✗] when the SCHEDULE row is red, else [·] (on, waiting).
- * @param {{running: boolean, red: boolean}} f @returns {{sign: string}}
+ * run of the job is running (as everywhere in the panel), [✗] when the SCHEDULE row is red, else [·] (on, waiting). RULED 2026-10-18 (v1.106
+ * Part 4): the header reads `[sign] word schedule · ...`, the sign AND the word both from the one status table (src/panel/status.js), never typed here.
+ * @param {{running: boolean, red: boolean}} f @returns {{sign: string, word: string}}
  */
 export function scheduleSignFor(f: {
     running: boolean;
     red: boolean;
 }): {
     sign: string;
+    word: string;
 };
 /** Audit schedule section, the `this run` words of a run the schedule started (the head already says which schedule and from where). @param {any} rec `trigger.json` */
 export function sectionThisRunWords(rec: any): string;

package/types/source.d.ts

@@ -421,6 +421,17 @@ export function refreezeUrlInputs({ into, fetchUrl }: {
     ok: false;
     error: string;
 }>;
+/**
+ * PRD v1.106 Part 5 Q2: what `source.json` says about web inputs, read synchronously and never throwing: whether the copy has any web input
+ * (`inputs[].url`) and when the run-start refetch last finished (`refrozenAt`, written last by {@link refreezeUrlInputs}). The panel decides
+ * "fetching the page..." from this: it applies while a web input exists and no refetch has finished at or after `sinceIso`.
+ * @param {string} sourceJsonPath @param {string|null|undefined} sinceIso
+ * @returns {{ hasWeb: boolean, fetching: boolean }}
+ */
+export function webFetchState(sourceJsonPath: string, sinceIso: string | null | undefined): {
+    hasWeb: boolean;
+    fetching: boolean;
+};
 /** the per-file ceiling for a rubric input: bareguard's `cited` check searches a quote in a source only up to this size
  * (its `quoteSourceMaxBytes`); a bigger file could never be cited from, so the door refuses it at $0 */
 export const RUBRIC_INPUT_MAX_BYTES: number;

package/types/thinking.d.ts

@@ -84,6 +84,45 @@ export function thinkingRowText({ mode, support, status }: {
     support?: true | false | "unverified";
     status?: string;
 }): string;
+/**
+ * THE one decision for a worker model call (PRD v1.106 Part 1): from the phase label and attempt iteration `mkWorker` already holds,
+ * and the job's tick (`job.thinking === true`). Decided in code, never by the model.
+ *   tick on                                   -> 'on' for every call
+ *   plan (draft, redraft, replan)             -> 'on'   (the planner is the hard part of a run)
+ *   scout                                     -> 'off'
+ *   step:<id> attempt 1                       -> 'off'
+ *   step:<id> attempt >= 2                    -> 'on'
+ *   fix (close-fix)                           -> 'on'
+ * A step or fix iteration that is not a whole number >= 1 throws (operator error), as does an unknown phase — never a guess.
+ * @param {{ phase: unknown, iteration?: unknown, tick?: unknown }} o
+ * @returns {'on'|'off'}
+ */
+export function workerThinkingMode({ phase, iteration, tick }: {
+    phase: unknown;
+    iteration?: unknown;
+    tick?: unknown;
+}): "on" | "off";
+/**
+ * PRD v1.106 Part 3 — the words one worker call carries in the Audit, READ from the run's own spine, never guessed. Finds the LAST
+ * `thinking-decision` of `phase` (and `iteration`, when given) whose seq lies strictly between `lo` and `hi`, pairs it with the first
+ * `thinking-status` of the same phase and iteration after it (before the next decision), and words both through {@link thinkingRowText}
+ * (drafting's own words). `null` when the window holds no decision: a run from before the records existed shows no thinking word.
+ * @param {any[]} spine the run's spine records (each with a numeric `seq`)
+ * @param {{ phase: string, lo?: number, hi?: number, iteration?: number|null }} q
+ * @returns {string|null}
+ */
+export function thinkingWordsFrom(spine: any[], { phase, lo, hi, iteration }: {
+    phase: string;
+    lo?: number;
+    hi?: number;
+    iteration?: number | null;
+}): string | null;
+/**
+ * The Job tab's row words (PRD v1.106 Part 3): the default rule, or the job's "Thinking on" tick, but only for a run whose spine
+ * recorded a `thinking-decision`; a run from before the thinking rule reads `—`, never a guess from the job's tick (fwdloop M4d am28).
+ * @param {boolean} tick @param {boolean} recorded the run's spine holds at least one `thinking-decision` @returns {string}
+ */
+export function thinkingJobText(tick: boolean, recorded: boolean): string;
 /** The words under a greyed "Thinking on" box (the server's `thinking.canChange` decides; the page decides nothing). */
 export const THINKING_FIXED_SAY: "can't change this for this model";
 /** The enumerated operator knob a drafting call is built with: 'on' | 'off' (the tick, spelled as a word). */

package/types/userrun.d.ts

@@ -219,6 +219,10 @@ export type RunCtx = {
      * see `RunOpts.into`
      */
     into?: string | undefined;
+    /**
+     * a FRESH `--spec` run: fetch the web inputs again AFTER the run is listed (never on resume/door/decide)
+     */
+    refreeze?: boolean | undefined;
     model: string | null;
     providerKey: string | null;
     readShim: string | null;