bareloop 0.39.0 → 0.41.0

package/types/panel/authorsession.d.ts

@@ -10,19 +10,36 @@ export function latestStep(steps: StepLine[], id: string): StepLine | undefined;
  */
 export function advanceSteps(steps: StepLine[], id: string, detail?: string): void;
 /**
- * The confirm turn's plan as the chat shows it: ONE owner of the text (hamr, 2026-10-09: the one-blob "Plan: ...
- * Checks: ... Not checked: ..." was unreadable). Each section is a heading on its own line, its content on the next,
- * and a blank line between sections. `#NOT CHECKED:` and `#QUESTIONS:` appear only when there is something to say.
- * The CLI composes its own plan screen (src/authorrun.js) and shares no text with this one.
- * @param {{goal?: string, checks?: string[], notChecked?: string[], questions?: string[]}} p
- * @returns {string}
+ * 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
+ * checked"; the always-on guards. `questions` (what the plan still asks) ride inside the plan. One owner of the shape.
+ * @param {{goal?: string, checks?: string[], checkItems?: {text: string, fromLine: number[]|null}[], notChecked?: string[], questions?: string[], protections?: string[]}} p the confirm turn's plan
+ * @param {{n: number, text: string, rule: string}[]|null} jobLines
+ * @returns {{role: 'bot', kind: 'plan', text: string, plan: ReturnType<typeof planFromConfirm> & {goal: string, questions: string[]}}}
  */
-export function planText(p: {
+export function planMessage(p: {
     goal?: string;
     checks?: string[];
+    checkItems?: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
     notChecked?: string[];
     questions?: string[];
-}): string;
+    protections?: string[];
+}, jobLines: {
+    n: number;
+    text: string;
+    rule: string;
+}[] | null): {
+    role: "bot";
+    kind: "plan";
+    text: string;
+    plan: ReturnType<typeof planFromConfirm> & {
+        goal: string;
+        questions: string[];
+    };
+};
 /**
  * `true` when `jobs/<name>.json` already exists in the repo's own jobs/ dir
  * (resolved from THIS module's own on-disk location, never `process.cwd()`,
@@ -36,6 +53,13 @@ export function planText(p: {
 export function jobNameTaken(name: string, opts?: {
     jobsDir?: string;
 }): boolean;
+/**
+ * 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).
+ * @param {any} card
+ * @returns {string}
+ */
+export function cardSource(card: any): string;
 /**
  * Only the form's own fields, nothing else a request body might carry (`startFrom`, stray keys).
  * @param {any} card
@@ -52,12 +76,12 @@ export function cardFields(card: any): Record<string, any>;
 export function lockedFieldChanged(card: Record<string, any>, origin: Record<string, any>): string | null;
 /**
  * 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, `budgetUsd` from the $ cap, `maxWallMs` from the Time cap (absent when blank), and the
+ * `writeScope` from Destination, `inputs` from the Inputs box (P7), `budgetUsd` from the $ cap, `maxWallMs` from the Time cap (absent when blank), and the
  * worker (`provider`/`baseUrl`/`model`) from the Model Name chosen in Settings > Providers, spelled exactly as normal
  * authoring spells it (`baseUrl` only when the row has one; `model` only when the Name is not the provider's default
  * tier). A RUBRIC (soft-green) origin with no explicit `judge` first has its judge pinned to the ORIGIN's resolved judge
  * identity — the judge must not change because the worker did (`resolveJobJudge`, the one spelling); an explicit
- * `judge` is kept; a deterministic job has no judge to move. Source is not in a spec (it lives beside the run). The copy
+ * `judge` is kept; a deterministic job has no judge to move. The repo (Inputs line 1) is in a spec only as `inputs`. The copy
  * hashes to a NEW `jobSpecHash` and the SAME `workflowKey` — the caller checks the second after building.
  * @param {any} originSpec
  * @param {Record<string, any>} card
@@ -67,7 +91,7 @@ export function lockedFieldChanged(card: Record<string, any>, origin: Record<str
 export function buildReuseSpec(originSpec: any, card: Record<string, any>, rows?: readonly import("../providerrows.js").KeyRow[]): any;
 /**
  * `$0` validation for a REUSE start: the signed job carries the goal, checks and guardrails, so those boxes are not
- * required here — only what the new session itself needs: a Source, a Destination, a Model that is a Settings Name,
+ * required here — only what the new session itself needs: Inputs, a Destination, a Model that is a Settings Name,
  * and the cap. (The spec built from the open boxes is validated by the route with `validateJob`.)
  * @param {any} card
  * @param {{rows?: readonly import('../providerrows.js').KeyRow[]}} [opts]
@@ -86,7 +110,7 @@ export function validateReuseCard(card: any, opts?: {
  * relative to the repo, so an absolute path is refused — at $0, before any copy or model call. A FOLDER source (or a
  * source that does not peek as a repo) keeps today's behaviour: its Destination is an absolute output directory.
  * @param {string} destination
- * @param {boolean} isRepoLike `looksLikeRepoSource(card.source)`
+ * @param {boolean} isRepoLike `looksLikeRepoSource(cardSource(card))`
  * @returns {string|null} the plain refusal, or null when the Destination is fine
  */
 export function repoDestinationProblem(destination: string, isRepoLike: boolean): string | null;
@@ -115,7 +139,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, reuse?: {spec: any, workflowKey: string}}} [deps] `scout`..`prepareSigningFn` are
+ *   prepareSigningFn?: Function, npmCiFn?: Function, 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
@@ -131,6 +155,7 @@ export function createSession(card: any, deps?: {
     authorFn?: Function;
     prepareSigningFn?: Function;
     npmCiFn?: Function;
+    draftThinking?: "on" | "off";
     reuse?: {
         spec: any;
         workflowKey: string;
@@ -149,22 +174,26 @@ export const STEP_LABELS: Readonly<Record<string, string>>;
  * @type {Readonly<Record<string, keyof typeof STEP_LABELS>>}
  */
 export const PHASE_STEP: Readonly<Record<string, keyof typeof STEP_LABELS>>;
+/** the line under the plan bubble, in plain words (the bubble itself is drawn by the page's one `renderJobPlan`) */
+export const PLAN_FOOTER: "Sign & run to confirm this plan, or Revise to edit the boxes and draft again.";
 /** 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 — Source, Destination, Model, $ cap, Time cap — and every other box is the signed workflow, shown greyed and never
+ * 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.
  */
 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;
     status: "running" | "done" | "failed";
     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

@@ -0,0 +1,58 @@
+/** @typedef {{name: string, cls: 'machine check'|'judge'|null}} PlanCheck */
+/** @typedef {{n: number, text: string, rule: 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
+ * unknown (a hand-written command close has no kind: it is a command, so a machine check).
+ * @param {unknown} kind
+ * @returns {'machine check'|'judge'|null}
+ */
+export function checkClassOfKind(kind: unknown): "machine check" | "judge" | null;
+/**
+ * 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
+ * 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
+ * @returns {JobPlan}
+ */
+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
+ * @param {{checkItems?: {text: string, fromLine: number[]|null}[], checks?: string[], notChecked?: string[], protections?: string[]}} plan
+ * @returns {JobPlan}
+ */
+export function planFromConfirm(jobLines: {
+    n: number;
+    text: string;
+    rule: string;
+}[] | null | undefined, plan: {
+    checkItems?: {
+        text: string;
+        fromLine: number[] | null;
+    }[];
+    checks?: string[];
+    notChecked?: string[];
+    protections?: string[];
+}): JobPlan;
+export type PlanCheck = {
+    name: string;
+    cls: "machine check" | "judge" | null;
+};
+export type PlanLine = {
+    n: number;
+    text: string;
+    rule: string;
+    checks: PlanCheck[];
+    refused: string[];
+};
+export type JobPlan = {
+    lines: PlanLine[];
+    loose: PlanCheck[];
+    notChecked: string[];
+    alwaysOn: string[];
+    older: boolean;
+    goal?: string;
+};

package/types/panel/server.d.ts

@@ -298,6 +298,26 @@ export function getRunRounds(runid: string, query?: {
 }, opts?: {
     home?: string;
 }): any | null;
+/**
+ * The Signed row of the Job tab: `YYYY-MM-DD HH:MM · <first 6 of specHash>`, the time being the run's FIRST `job-start`
+ * in local time (hamr, P7). `null` when either part is not on record — never a made-up stamp.
+ * @param {string|null|undefined} ts an ISO stamp @param {string|null|undefined} hash
+ * @returns {string|null}
+ */
+export function signedLine(ts: string | null | undefined, hash: string | null | undefined): string | null;
+/**
+ * The Job box's text for a signed spec: the person's own numbered lines (a `~` line per entry of `rules`, or — for a spec
+ * signed before `rules` existed — per '; '-split piece of `rule`), or — for
+ * an older job that saved no job lines — the signed goal sentence as the one line.
+ * @param {any} spec @returns {string}
+ */
+export function jobTextFromSpec(spec: any): string;
+/**
+ * The Inputs box's text for a signed spec: its numbered inputs, or — for an older job — `repo: <source>` from the
+ * caller's best knowledge of the source (or empty).
+ * @param {any} spec @param {string} source @returns {string}
+ */
+export function inputsTextFromSpec(spec: any, source: string): string;
 /**
  * `GET /api/runs/:runid/job` — the Job tab, filled from the first source
  * that actually resolves (item 2, 2026-09-25), in order:
@@ -380,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: {
@@ -405,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;
 } | {
@@ -416,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;
@@ -438,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}
@@ -446,6 +475,7 @@ export function listReuseJobs(opts?: {
 export function getStartFromImport(id: string, opts?: {
     home?: string;
     model?: string;
+    provider?: string;
 }): {
     ok: true;
     origin: {

package/types/planrun.d.ts

@@ -221,7 +221,7 @@ export function planPrompt(job: any, scoutBlob: string, reds: any[] | null, maxS
  *   item 27/M3 Part B), forwarded to every close invocation as
  *   `BARELOOP_CLOSE_DIR`
  * @param {number} [opts.maxStepRounds] the shell's per-step rounds ceiling (validatePlan's bound)
- * @param {boolean} [opts.scout=true] operator-only switch (docs/product/SCOUT-CONTRAST.md):
+ * @param {boolean} [opts.scout=true] operator-only switch (docs/logs/SCOUT-CONTRAST.md):
  *        `false` on a FRESH run (no `resumeSeed`) skips the survey entirely — `scoutBlob`
  *        stays `''`, no `scout-start`/`scout-result`/`scout-empty` is emitted, and a single
  *        `scout-skipped {reason:'operator-off'}` records it (a RECORD, never silence — the