bareloop 0.40.0 → 0.42.0

package/types/judged.d.ts

@@ -17,7 +17,7 @@
  *      item 31.4 a green job runs on its own key alone, and this is what lets a
  *      JUDGED one do the same.
  *
- * There is deliberately NO third fallback to `JUDGE_MODEL`. A caller that cannot
+ * There is deliberately NO third fallback to a library-pinned model. A caller that cannot
  * say which model will grade has not wired a judge, and the grading path stops
  * as a wiring gap rather than grading under an identity nobody chose — the same
  * answer an absent `judgeLoop` already gets. A silent default here would be the
@@ -79,7 +79,7 @@ export function resolveJudge({ specJudge, workerProvider, workerModel }?: {
  *
  * @param {{provider?: string, model?: string, judge?: any}} source draft or spec
  * @param {string} fallbackProviderName used only when `source.provider` is absent
- * @param {(o: {specModel?: string, flagModel?: string, defaultModel: string}) => {model: string, source: string}} resolveWorkerModelFn `resolveWorkerModel` from `./job.js`
+ * @param {(o: {specModel?: string, flagModel?: string, suppliedModel?: string}) => {model: string, source: string}} resolveWorkerModelFn `resolveWorkerModel` from `./job.js`
  * @returns {{provider: string, model: string}}
  */
 export function resolveJobJudge(source: {
@@ -89,7 +89,7 @@ export function resolveJobJudge(source: {
 }, fallbackProviderName: string, resolveWorkerModelFn: (o: {
     specModel?: string;
     flagModel?: string;
-    defaultModel: string;
+    suppliedModel?: string;
 }) => {
     model: string;
     source: string;
@@ -309,38 +309,6 @@ export function decide(facts: any, card: any, { artifactText }?: {
     firstRed: string | null;
     reason: string | null;
 };
-/**
- * THE JUDGE'S HISTORICAL PIN. Until PRD item 32 (2026-09-10) this constant WAS
- * the judge: every grading path imported it, so bareloop could run a worker on
- * any provider and still judge only on Claude.
- *
- * It is no longer read by any grading path. The judge identity is now RESOLVED
- * per job (`resolveJudge` below) and travels as data — `ctx.judgeModel` into
- * `runJudgedFloor`, an explicit argument into the calibration gate, and
- * `closeDecl.calibration.judgeModel` into the signed spec, exactly as before.
- * Keeping the export is deliberate: it is part of the public API
- * (`src/index.js`) and an adopter importing it should not break on a minor.
- * What it means now is "the judge bareloop pinned before item 32", which is
- * still the right DEFAULT for an anthropic-api job and still the only tier with
- * established injection resistance upstream (BA-20's `INJECTION_BATTERY` is
- * haiku-4.5 only).
- *
- * THE ENFORCEMENT IS UNCHANGED, and still lives in three wired places because a
- * rule with no detector is prose (F45) — only the value being compared moved
- * from this constant to the resolved identity:
- *   1. the identity is STORED with the set it graded — `foldJudgedArtifacts`
- *      writes it as `closeDecl.calibration.judgeModel`, inside the spec, so
- *      `jobSpecHash` covers it by construction. Change the judge and every
- *      signed judged spec hashes differently: the signature dies, and re-signing
- *      is what re-runs the calibration gate.
- *   2. `validateCloseDecl` REQUIRES it on any stored set — a set nobody can
- *      attribute to a judge is a floor nobody can tell apart from a moved one.
- *   3. `runJudgedFloor` refuses to grade when the stored identity is not the one
- *      about to grade, naming both. It does not degrade in either direction:
- *      grading on the new judge judges against a floor nobody calibrated, and
- *      the old judge is not on offer.
- */
-export const JUDGE_MODEL: "claude-haiku-4-5";
 /**
  * The locate call's token ceiling. The POC's two real artifacts came back well
  * inside 2000; this doubles that for headroom on a longer artifact, and the
@@ -402,13 +370,14 @@ export const JUDGE_RULE_IDS: readonly string[];
 export const CALIBRATION_SIZE: 10;
 /** the two verdicts a case may expect — `decide()`'s own closed set */
 export const CASE_VERDICTS: readonly string[];
-export function defaultJudgeLoop({ provider, system, rates }: {
+export function defaultJudgeLoop({ provider, system, rates, thinking }: {
     provider: any;
     system: string;
     rates?: {
         in: number;
         out: number;
     } | null;
+    thinking?: boolean;
 }): {
     run: (msgs: any[], tools: any[], opts?: any) => Promise<any>;
 };

package/types/keysfile.d.ts

@@ -25,19 +25,20 @@ export function parseKeysText(text: string): Record<string, string>;
  */
 export function filledKeyNames(home?: string): string[];
 /**
- * Create the keys file with the five empty preset lines when — and only when — it does not
- * exist (mode 600). An existing file is never touched.
- * @param {readonly string[]} presetNames the names to seed, in order
+ * Create the keys file with {@link KEYS_FILE_BODY} when — and only when — it does not
+ * exist (mode 600, dir 700). An existing file is never touched.
  * @param {string} [home]
  * @returns {boolean} true if it was created
  */
-export function ensureKeysFile(presetNames: readonly string[], home?: string): boolean;
+export function ensureKeysFile(home?: string): boolean;
 /**
  * @typedef {object} KeysLoad
  * @property {boolean} exists the file is there
  * @property {string[]} names the NAMES the file defines (sorted; never values)
  * @property {string|null} warning a plain-words warning (file readable by others, or
  *   unreadable), else null — a warning, never a refusal
+ * @property {boolean} [unreadable] true only when the file is there but could not be read (the Settings row then
+ *   reads "refused — see above"); absent otherwise
  * @property {Record<string,string|undefined>} env shell env with the file filling the
  *   names the shell does not set. THE ONLY place values leave this module.
  */
@@ -68,6 +69,11 @@ export function keysForDoor(deps: {
     env: Record<string, string | undefined>;
     home: string | undefined;
 };
+/**
+ * The two comment lines a fresh keys file is created with — no provider name, no preset key.
+ * Each key the person types becomes a row in Settings > Providers.
+ */
+export const KEYS_FILE_BODY: string;
 export type KeysLoad = {
     /**
      * the file is there
@@ -82,6 +88,11 @@ export type KeysLoad = {
      * unreadable), else null — a warning, never a refusal
      */
     warning: string | null;
+    /**
+     * true only when the file is there but could not be read (the Settings row then
+     * reads "refused — see above"); absent otherwise
+     */
+    unreadable?: boolean | undefined;
     /**
      * shell env with the file filling the
      * names the shell does not set. THE ONLY place values leave this module.

package/types/labelscan.d.ts

@@ -0,0 +1,38 @@
+/** @typedef {{id: string, label: string, count: number, example: string}} LabelEntry */
+/** @typedef {Record<'money'|'number'|'date'|'time'|'text', LabelEntry[]>} LabelScan */
+/** @param {string} t @returns {string} white space made one space, quote marks at the edges dropped, trimmed - how a label is compared */
+export function normLabel(t: string): string;
+/**
+ * Scan one source text for the labels that sit before values, per shape.
+ * @param {string} text
+ * @returns {LabelScan}
+ */
+export function scanLabels(text: string): LabelScan;
+/**
+ * Is this label on the list for this shape? Compared the way a label is read: white space of any kind is one space, quote marks at the
+ * edges are dropped. `idOrText` may be a list id (`t1`) or the exact words.
+ * @param {LabelScan} scan @param {string} shape @param {unknown} idOrText
+ * @returns {LabelEntry|null}
+ */
+export function labelOnList(scan: LabelScan, shape: string, idOrText: unknown): LabelEntry | null;
+/**
+ * The list as the look and the drafter are shown it, one block per shape that has any label.
+ * @param {string} inputLabel the input the list belongs to @param {LabelScan} scan
+ * @returns {string}
+ */
+export function renderLabelList(inputLabel: string, scan: LabelScan): string;
+/** the shapes a list is made for */
+export const LABEL_SHAPES: readonly string[];
+/** a label must occur at least this often to be listed (1: a one-page document with one total still has its label; the list is cut to the highest counts) */
+export const MIN_COUNT: 1;
+/** how many labels one shape's list holds at most (the highest counts first) */
+export const MAX_PER_SHAPE: 40;
+/** only this much of a source is scanned (a source over it is scanned up to a line end) */
+export const SCAN_MAX_CHARS: 2000000;
+export type LabelEntry = {
+    id: string;
+    label: string;
+    count: number;
+    example: string;
+};
+export type LabelScan = Record<"money" | "number" | "date" | "time" | "text", LabelEntry[]>;

package/types/modellist.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The key goes only in a header, in the form each shape expects.
+ * @param {string} shape an API shape id (src/providershapes.js)
+ * @param {string} key
+ * @returns {Record<string, string>}
+ */
+export function authHeaders(shape: string, key: string): Record<string, string>;
+/**
+ * The model ids a provider's list answer holds, per API shape (`data[].id` for two shapes;
+ * `models[].name` minus its `models/` prefix for the third). Sorted, de-duplicated.
+ * @param {string} shape
+ * @param {any} body
+ * @returns {string[]}
+ */
+export function idsOf(shape: string, body: any): string[];
+/**
+ * @typedef {{ ok: true, models: string[], ms: number }
+ *   | { ok: false, why: string, status: string, detail?: string }} ListResult
+ */
+/**
+ * One free GET of `<baseUrl>/models` with the key in the header only and a deadline.
+ * Failure is data, never a throw: `why` is a plain sentence, `status` a short machine word
+ * (`no-base-url`, `redirect`, `HTTP <n>`, `timeout`, `unreachable`) for callers that need it.
+ * @param {object} o
+ * @param {string} o.shape an API shape id
+ * @param {string} o.baseUrl the row's Base URL ('' = no call)
+ * @param {string} o.key the key value (header only)
+ * @param {typeof fetch} [o.fetchImpl] test seam; defaults to the global `fetch`
+ * @param {number} [o.timeoutMs]
+ * @returns {Promise<ListResult>}
+ */
+export function listModels({ shape, baseUrl, key, fetchImpl, timeoutMs }: {
+    shape: string;
+    baseUrl: string;
+    key: string;
+    fetchImpl?: typeof fetch | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<ListResult>;
+/** The default deadline for the one GET. */
+export const LIST_TIMEOUT_MS: 4000;
+export type ListResult = {
+    ok: true;
+    models: string[];
+    ms: number;
+} | {
+    ok: false;
+    why: string;
+    status: string;
+    detail?: string;
+};

package/types/monthly.d.ts

@@ -48,11 +48,11 @@ export function monthSpend(opts?: {
 };
 /**
  * The Money tab's figures: all-time and this-month spend, and per-provider breakdown
- * (rows from `rowIdFor`; a run on no known row lands under its own provider name, never
- * pooled into another row). Any leg with unknown spend makes the figure it belongs to
+ * (grouped by the matched Providers row's key variable name; a run on no row lands under its
+ * own provider name, never pooled into another row). Any leg with unknown spend makes the figure it belongs to
  * an "at least".
  * @param {{ home?: string, sessionsRoot?: string, now?: () => number, rows?: readonly import('./providerrows.js').KeyRow[] }} [opts] `rows` = the Providers rows: when given, `tokensByRow` sums each row's tokens
- * @returns {{ tokensByRow: Record<string, number>, total: {usd: number, atLeast: boolean, tokens: number}, month: {usd: number, atLeast: boolean, tokens: number},
+ * @returns {{ tokensByRow: Record<string, number>, tokensByModel: Record<string, Record<string, number>>, total: {usd: number, atLeast: boolean, tokens: number}, month: {usd: number, atLeast: boolean, tokens: number},
  *   byProvider: Record<string, {label: string, monthUsd: number, monthAtLeast: boolean, totalUsd: number, totalAtLeast: boolean, tokens: number, vouchedRounds: number, otherRounds: number, monthWallMs: number|null, monthWallAtLeast: boolean, totalWallMs: number|null, totalWallAtLeast: boolean}> }}
  */
 export function spendSummary(opts?: {
@@ -62,6 +62,7 @@ export function spendSummary(opts?: {
     rows?: readonly import("./providerrows.js").KeyRow[];
 }): {
     tokensByRow: Record<string, number>;
+    tokensByModel: Record<string, Record<string, number>>;
     total: {
         usd: number;
         atLeast: boolean;

package/types/pagefetch.d.ts

@@ -0,0 +1,71 @@
+/** @param {unknown} v @returns {boolean} an http(s) address (the one spelling of "this Inputs value is a web address") */
+export function isWebUrl(v: unknown): boolean;
+/**
+ * How much of a fetched page is the page's own content: the snapshot's header lines (url, size note, hint) and every part of the tree
+ * under a banner / navigation / contentinfo landmark are taken out, the page reader's bracketed tags are removed, and what is left is
+ * counted. Generic - no site names, only the ARIA landmark roles. Text that is not a snapshot tree (a plain file) has no landmark, so it
+ * counts whole.
+ * @param {string} text @returns {number}
+ */
+export function pageContentChars(text: string): number;
+/**
+ * @typedef {{goto: (url: string, timeout?: number) => Promise<void>, waitForNetworkIdle: (o?: {idle?: number, timeout?: number}) => Promise<void>,
+ *   snapshot: (o?: {mode?: string}) => Promise<string>, close: () => Promise<void>}} FetchPage the part of barebrowse's page handle the fetch uses
+ */
+/**
+ * Fetch one page's text. `connect` is injected (a test never reaches the network); the default is barebrowse's own `connect`.
+ * @param {string} url
+ * @param {{connect?: (opts: Record<string, any>) => Promise<FetchPage>, timeoutMs?: number, idleMs?: number, idleTimeoutMs?: number, closeWaitMs?: number}} [o]
+ * @returns {Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>} `error` is plain words, without a spend line
+ */
+export function fetchPageText(url: string, { connect, timeoutMs, idleMs, idleTimeoutMs, closeWaitMs }?: {
+    connect?: (opts: Record<string, any>) => Promise<FetchPage>;
+    timeoutMs?: number;
+    idleMs?: number;
+    idleTimeoutMs?: number;
+    closeWaitMs?: number;
+}): Promise<{
+    ok: true;
+    text: string;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** the session options (incognito: no auth ever enters; blockPrivateNetwork: SSRF guard); ONE frozen object so a test can pin them */
+export const CONNECT_OPTIONS: Readonly<{
+    incognito: true;
+    blockPrivateNetwork: true;
+}>;
+/** the snapshot options step 0 proved */
+export const SNAPSHOT_OPTIONS: Readonly<{
+    mode: "act";
+}>;
+/** the page's network must be quiet this long (ms) before we read it: long enough to span the gap between a page's first load and the
+ *  script requests that fill the results, short enough not to stretch a plain page */
+export const NETWORK_IDLE_MS: 1500;
+/** the most we wait for the network to go quiet (ms); a page that never settles (polling, streaming) is read as it stands after this */
+export const NETWORK_IDLE_TIMEOUT_MS: 20000;
+/** the most we wait for the page to load at all (ms) */
+export const GOTO_TIMEOUT_MS: 30000;
+/** a page that comes back with fewer characters than this (after trimming) is treated as "nothing came back" */
+export const MIN_PAGE_CHARS: 200;
+/** the page text left after the site's own header, menus and footer are taken out must hold at least this many characters, or the page is
+ *  "only site chrome" (L2: a 719-character fetch of Google's header and sign-in passed the 200-character floor) */
+export const MIN_CONTENT_CHARS: 100;
+/** our own deadline around one whole fetch (a hung browser leaves no trace; this is the only thing that fires on the absence of an answer) */
+export const PAGE_FETCH_TIMEOUT_MS: 90000;
+/**
+ * the part of barebrowse's page handle the fetch uses
+ */
+export type FetchPage = {
+    goto: (url: string, timeout?: number) => Promise<void>;
+    waitForNetworkIdle: (o?: {
+        idle?: number;
+        timeout?: number;
+    }) => Promise<void>;
+    snapshot: (o?: {
+        mode?: string;
+    }) => Promise<string>;
+    close: () => Promise<void>;
+};

package/types/panel/authorsession.d.ts

@@ -1,11 +1,3 @@
-/**
- * The first drafting row's words (hamr 2026-10-11) — code-owned, one owner, ALWAYS starting "thinking on" or "thinking off".
- * `sent` is what the drafting calls carry (`draftThinkingFor`); `thoughtAnyway` = a call reported `thinkingApplied === false`
- * after 'off' was sent (bare-agent saw reasoning in the reply).
- * @param {'on'|'off'|'not-switchable'|'unverified'} sent @param {boolean} [thoughtAnyway]
- * @returns {string}
- */
-export function thinkingRowText(sent: "on" | "off" | "not-switchable" | "unverified", thoughtAnyway?: boolean): string;
 /** @typedef {{id: string, label: string, status: 'running'|'done'|'failed', detail: string}} StepLine */
 /** @param {StepLine[]} steps @param {string} id the LATEST line carrying this id (the list is a time-ordered log; an id can repeat) */
 export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
@@ -15,8 +7,9 @@ export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
  * earlier line keeps its status and detail). Existing lines are never moved. Re-starting the step that is still the
  * LAST line just resumes that line.
  * @param {StepLine[]} steps @param {string} id @param {string} [detail] (absent = keep what the line has)
+ * @param {Readonly<Record<string, string>>} [labels] the label table (a file job passes its own)
  */
-export function advanceSteps(steps: StepLine[], id: string, detail?: string): void;
+export function advanceSteps(steps: StepLine[], id: string, detail?: string, labels?: Readonly<Record<string, string>>): void;
 /**
  * The confirm turn's plan as a chat message (P7): a STRUCTURED `{role:'bot', kind:'plan', plan}` the page draws with the
  * same renderer the Job tab uses — each numbered job line, its `~` rule, its drafted checks folded; the AI's own "not
@@ -147,7 +140,7 @@ export function validateJobCard(card: any, opts?: {
  * @param {any} card the validated job card (see {@link validateJobCard})
  * @param {{env?: Record<string,string|undefined>, sessionsRoot?: string, home?: string, timeoutMs?: number,
  *   scout?: any, generate?: Function, confirmGenerate?: Function, authorFn?: Function,
- *   prepareSigningFn?: Function, npmCiFn?: Function, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, lookFn?: Function|null, fetchUrl?: (url: string) => Promise<{ok: true, text: string, url: string}|{ok: false, error: string}>, draftThinking?: "on"|"off", reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
  *   TEST SEAMS ONLY — see the note just above where each is read, below. `reuse` (Reuse workflow) is NOT a seam: the
  *   caller (`/api/author/start`) sets it only when the server's own same-job rule held.
  * @returns {any} the session object
@@ -163,6 +156,15 @@ export function createSession(card: any, deps?: {
     authorFn?: Function;
     prepareSigningFn?: Function;
     npmCiFn?: Function;
+    lookFn?: Function | null;
+    fetchUrl?: (url: string) => Promise<{
+        ok: true;
+        text: string;
+        url: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
     draftThinking?: "on" | "off";
     reuse?: {
         spec: any;
@@ -176,6 +178,12 @@ export function createSession(card: any, deps?: {
  * @type {Readonly<Record<string, string>>}
  */
 export const STEP_LABELS: Readonly<Record<string, string>>;
+/**
+ * The same steps, worded for a job on the person's own local FILES (Part 1a): there is no worktree and no repo to read.
+ * Code-owned, one table beside STEP_LABELS; a step with no entry keeps its STEP_LABELS word.
+ * @type {Readonly<Record<string, string>>}
+ */
+export const FILE_JOB_STEP_LABELS: Readonly<Record<string, string>>;
 /**
  * The library's own `onPhase(name, ...)` calls (`src/authorjob.js`/`src/authorflow.js`) -> the step each one advances.
  * A phase with no entry leaves the current step as it was.
@@ -195,7 +203,6 @@ export const CARD_FIELDS: readonly string[];
 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 { nonRepoSourceMessage };
 export type StepLine = {
     id: string;
     label: string;
@@ -203,4 +210,6 @@ export type StepLine = {
     detail: string;
 };
 import { planFromConfirm } from './jobplan.js';
+import { thinkingRowText } from '../thinking.js';
 import { nonRepoSourceMessage } from '../source.js';
+export { thinkingRowText, nonRepoSourceMessage };

package/types/panel/jobplan.d.ts

@@ -1,5 +1,5 @@
 /** @typedef {{name: string, cls: 'machine check'|'judge'|null}} PlanCheck */
-/** @typedef {{n: number, text: string, rule: string, checks: PlanCheck[], refused: string[]}} PlanLine */
+/** @typedef {{n: number, text: string, rule: string, rules: string[], checks: PlanCheck[], refused: string[]}} PlanLine */
 /** @typedef {{lines: PlanLine[], loose: PlanCheck[], notChecked: string[], alwaysOn: string[], older: boolean, goal?: string}} JobPlan */
 /**
  * `machine check` for a kind a command decides, `judge` for one that needs judgement; `null` for a stage whose kind is
@@ -8,9 +8,15 @@
  * @returns {'machine check'|'judge'|null}
  */
 export function checkClassOfKind(kind: unknown): "machine check" | "judge" | null;
+/**
+ * The `~` rules of one job line, each on its own (the page draws one `~` row per rule): the line's own `rules` array when it
+ * has one (a rule may itself contain "; "), else the joined `rule` split on "; " (an older line that saved only the join).
+ * @param {any} l @returns {string[]}
+ */
+export function rulesOfLine(l: any): string[];
 /**
  * The plan of a SIGNED spec. With `jobLines`, each stage lands under EACH line its `fromLine` array names (a stage with none is
- * a mandatory guard: "Always on"), `closeDecl.refused` reasons land under their line, and `closeDecl.notes` are the
+ * a mandatory guard: "Always checked"), `closeDecl.refused` reasons land under their line, and `closeDecl.notes` are the
  * drafter's own "not checked" words. Without `jobLines` (a spec that predates the job block) the signed goal sentence is
  * line 1 and every stage name is a check under it — `older: true`.
  * @param {any} spec
@@ -19,8 +25,8 @@ export function checkClassOfKind(kind: unknown): "machine check" | "judge" | nul
 export function planFromSpec(spec: any): JobPlan;
 /**
  * The plan of the confirm turn, before anything is drafted: the person's own job lines, the model's checks under the
- * line each names, its own "not checked" words, and the real protections (code-owned) as "Always on".
- * @param {{n: number, text: string, rule: string}[]|null|undefined} jobLines
+ * line each names, its own "not checked" words, and the real protections (code-owned) as "Always checked".
+ * @param {{n: number, text: string, rule: string, rules?: string[]}[]|null|undefined} jobLines
  * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[]}} plan
  * @returns {JobPlan}
  */
@@ -28,6 +34,7 @@ export function planFromConfirm(jobLines: {
     n: number;
     text: string;
     rule: string;
+    rules?: string[];
 }[] | null | undefined, plan: {
     checkItems?: {
         text: string;
@@ -45,6 +52,7 @@ export type PlanLine = {
     n: number;
     text: string;
     rule: string;
+    rules: string[];
     checks: PlanCheck[];
     refused: string[];
 };

package/types/panel/server.d.ts

@@ -400,15 +400,17 @@ export function reuseLine(record: {
  * $ 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 }} [opts] `model` = the Model box's current Name (the estimate counts only runs on that worker); absent = the card's own Model
+ * @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,
- *   specHash: string, workflowKey: string, spec: any, specPath: string,
+ *   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}
  */
 export function getStartFrom(runid: string, opts?: {
     home?: string;
     model?: string;
+    provider?: string;
 }): {
     ok: true;
     origin: {
@@ -425,6 +427,12 @@ export function getStartFrom(runid: string, opts?: {
     workflowKey: string;
     spec: any;
     specPath: string;
+    specNamesModel: boolean;
+    specWorker: {
+        provider: string;
+        endpoint: string;
+        label: string;
+    };
     trackRecord: ReturnType<typeof trackRecordFor>;
     line: string;
 } | {
@@ -436,12 +444,13 @@ export function getStartFrom(runid: string, opts?: {
  * that has at least one GREEN local run, newest green first. `runid` = that job's newest green run, so the page hands
  * it to the existing start-from flow unchanged; `line` is `getStartFrom`'s own estimate line (never a second
  * spelling). Local runs only — an imported job keeps its Reuse button in the Import view. $0, read-only.
- * @param {{ home?: string, model?: string }} [opts] `model` passes through to the estimate line, as start-from's does
+ * @param {{ home?: string, model?: string, provider?: string }} [opts] `model` passes through to the estimate line, as start-from's does
  * @returns {{job: string, runid: string, checkType: 'deterministic'|'rubric', line: string}[]}
  */
 export function listReuseJobs(opts?: {
     home?: string;
     model?: string;
+    provider?: string;
 }): {
     job: string;
     runid: string;
@@ -458,7 +467,7 @@ export function listReuseJobs(opts?: {
  * signs it on this machine at [Sign & run]. Same card, same locked/open boxes as a run's reuse. `null` when no such
  * imported job.
  * @param {string} id
- * @param {{ home?: string, model?: string }} [opts] `model` as for {@link getStartFrom}
+ * @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,
  *   specPath: null, trackRecord: ReturnType<typeof trackRecordFor>, line: string}|{ok: false, error: string}|null}
@@ -466,6 +475,7 @@ export function listReuseJobs(opts?: {
 export function getStartFromImport(id: string, opts?: {
     home?: string;
     model?: string;
+    provider?: string;
 }): {
     ok: true;
     origin: {
@@ -504,10 +514,11 @@ 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> }} 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>;
@@ -534,7 +545,7 @@ 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]
+ *   openFolderSpawn?: (cmd: string, args: string[], o: object) => any, platform?: string, packageJsonPath?: string }} [opts]
  * @returns {Promise<{ server: import('node:http').Server, port: number, token: string, close: () => Promise<void> }>}
  */
 export function createPanelServer(opts?: {
@@ -549,6 +560,7 @@ export function createPanelServer(opts?: {
     userHome?: string;
     openFolderSpawn?: (cmd: string, args: string[], o: object) => any;
     platform?: string;
+    packageJsonPath?: string;
 }): Promise<{
     server: import("node:http").Server;
     port: number;