bareloop 0.40.0 → 0.42.0

package/src/panel/jobplan.js

@@ -2,7 +2,7 @@
 // `renderJobPlan()` draws in two places — the drafting confirm card (the plan bubble) and the read-only Job tab. The
 // server builds it; the page only draws it (so the two places can never read the same plan two ways).
 //
-//   { lines: [{n, text, rule, checks: [{name, cls}], refused: [reason...]}],
+//   { lines: [{n, text, rule, rules: [string...], checks: [{name, cls}], refused: [reason...]}],
 //     loose: [{name, cls}],        checks that name no job line (an older caller, or a model slip)
 //     notChecked: [text...],       "the AI's own reading" — what the drafter says nothing checks
 //     alwaysOn: [text...],         the mandatory guards / protections, which serve no job line
@@ -11,9 +11,10 @@
 // `cls` is 'machine check' | 'judge' | null (null = not known yet: the confirm card's checks are the model's plan, the
 // stage kinds exist only after drafting). Pure; no file IO.
 import { KIND_CATALOGUE } from '../authoring.js';
+import { checksOfClose, proseNotChecked, lineRules } from '../rubricstep.js';
 
 /** @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 */
 
 /**
@@ -29,9 +30,19 @@ export function checkClassOfKind(kind) {
   return spec.verdictClass === 'green' ? 'machine check' : 'judge';
 }
 
+/**
+ * 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) {
+  if (Array.isArray(l?.rules)) return l.rules.filter((/** @type {unknown} */ r) => typeof r === 'string' && r);
+  return typeof l?.rule === 'string' && l.rule ? l.rule.split('; ').filter(Boolean) : [];
+}
+
 /**
  * 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
@@ -42,24 +53,34 @@ export function planFromSpec(spec) {
   let stages = [];
   if (spec && Array.isArray(spec.closeDecl?.stages)) {
     stages = spec.closeDecl.stages.filter((/** @type {any} */ s) => s && typeof s.name === 'string' && s.name)
-      .map((/** @type {any} */ s) => ({ name: s.name, cls: checkClassOfKind(s.kind), fromLine: Array.isArray(s.fromLine) && s.fromLine.length ? s.fromLine.filter(Number.isInteger) : null }));
+      .flatMap((/** @type {any} */ s) => {
+        const fromLine = Array.isArray(s.fromLine) && s.fromLine.length ? s.fromLine.filter(Number.isInteger) : null;
+        // PART 1b: a rubric-step stage is shown as the checks it RUNS — one code-worded row per fact, per count, per limit — read by
+        // the same reader (`checksOfClose`) the confirm card and the sign-time invariant use, so the Job tab cannot differ from them
+        const rows = s.kind === 'rubric-step' ? checksOfClose({ stages: [s] }) : [];
+        return rows.length > 0 ? rows.map((r) => ({ name: r.text, cls: /** @type {'machine check'} */ ('machine check'), fromLine })) : [{ name: s.name, cls: checkClassOfKind(s.kind), fromLine }];
+      });
   } else if (spec && Array.isArray(spec.close)) {
     stages = spec.close.filter((/** @type {any} */ s) => s && typeof s.name === 'string' && s.name)
       .map((/** @type {any} */ s) => ({ name: s.name, cls: /** @type {'machine check'} */ ('machine check'), fromLine: null }));
   }
-  const notes = Array.isArray(spec?.closeDecl?.notes) ? spec.closeDecl.notes.filter((/** @type {any} */ n) => typeof n === 'string' && n) : [];
+  // a prose step says what it does not check (PART 1b, RF5): the person judges the text at Accept
+  const notes = [
+    ...(Array.isArray(spec?.closeDecl?.notes) ? spec.closeDecl.notes.filter((/** @type {any} */ n) => typeof n === 'string' && n) : []),
+    ...proseNotChecked(spec?.closeDecl),
+  ];
   const jl = Array.isArray(spec?.jobLines) ? spec.jobLines.filter((/** @type {any} */ l) => l && Number.isInteger(l.n) && typeof l.text === 'string') : [];
   if (jl.length === 0) {
     return {
       lines: [{
-        n: 1, text: typeof spec?.goal === 'string' && spec.goal ? spec.goal : '(no goal recorded)', rule: '',
+        n: 1, text: typeof spec?.goal === 'string' && spec.goal ? spec.goal : '(no goal recorded)', rule: '', rules: [],
         checks: stages.map((s) => ({ name: s.name, cls: s.cls })), refused: [],
       }],
       loose: [], notChecked: notes, alwaysOn: [], older: true,
     };
   }
   /** @type {PlanLine[]} */
-  const lines = jl.map((/** @type {any} */ l) => ({ n: l.n, text: l.text, rule: typeof l.rule === 'string' ? l.rule : '', checks: [], refused: [] }));
+  const lines = jl.map((/** @type {any} */ l) => ({ n: l.n, text: l.text, rule: typeof l.rule === 'string' ? l.rule : '', rules: rulesOfLine(l), checks: [], refused: [] }));
   /** @type {PlanCheck[]} */
   const loose = [];
   /** @type {string[]} */
@@ -74,7 +95,9 @@ export function planFromSpec(spec) {
   const refused = Array.isArray(spec?.closeDecl?.refused) ? spec.closeDecl.refused : [];
   for (const r of refused) {
     const line = lines.find((l) => l.n === r?.line);
-    if (line && typeof r.reason === 'string') line.refused.push(r.reason);
+    // a refusal of ONE ~ rule (PART 1b, RF16) names the rule in the person's words, so the row reads as that rule's Not checked
+    const ruleText = line && Number.isInteger(r.rule) ? lineRules(spec.jobLines.find((/** @type {any} */ l) => l?.n === r.line))[r.rule - 1] : null;
+    if (line && typeof r.reason === 'string') line.refused.push(ruleText ? `"${ruleText}" — ${r.reason}` : r.reason);
   }
   // the model's signed goal sentence rides along: the page draws it as the "AI's summary" row (an older job shows it as line 1 instead)
   return { lines, loose, notChecked: notes, alwaysOn, older: false, ...(typeof spec?.goal === 'string' && spec.goal ? { goal: spec.goal } : {}) };
@@ -82,8 +105,8 @@ export function planFromSpec(spec) {
 
 /**
  * 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}
  */
@@ -93,7 +116,7 @@ export function planFromConfirm(jobLines, plan) {
     : (Array.isArray(plan?.checks) ? plan.checks.map((c) => ({ text: String(c), fromLine: null })) : []);
   const jl = Array.isArray(jobLines) ? jobLines : [];
   /** @type {PlanLine[]} */
-  const lines = jl.map((l) => ({ n: l.n, text: l.text, rule: l.rule, checks: [], refused: [] }));
+  const lines = jl.map((l) => ({ n: l.n, text: l.text, rule: l.rule, rules: rulesOfLine(l), checks: [], refused: [] }));
   /** @type {PlanCheck[]} */
   const loose = [];
   for (const c of items) {

package/src/panel/runroutes.js

@@ -175,6 +175,9 @@ export function createRunRoutes(opts) {
       '--wait', 'systemd-inhibit', '--why=bareloop panel resume',
       process.execPath, bareloopBin,
       'run-u', '--spec', specPath, '--resume', m[1], '--approve', specHash,
+      // an older spec that names no model runs on the Settings line the person picks at resume (hash untouched, run-u's own rule)
+      ...(typeof body?.model === 'string' && body.model !== '' ? ['--model', body.model] : []),
+      ...(typeof body?.provider === 'string' && body.provider !== '' ? ['--provider', body.provider] : []),
       // the drafting fold rides every leg of the chain (a leg that dropped it would widen the ceiling)
       ...(plan.draftSpentUsd !== null ? ['--draft-spent-usd', String(plan.draftSpentUsd), ...(plan.draftSpendComplete === false ? ['--draft-spend-incomplete'] : [])] : []),
     ];

package/src/panel/server.js

@@ -49,7 +49,8 @@ import { parseImportedRunId, safeSpinePath, spineStartedAt } from './importrun.j
 import { checkBundleDeps, resolveBundleSpec } from '../bundle.js';
 import { checkCloseByteSignature } from '../close-integrity.js';
 import { keysHome } from '../keysfile.js';
-import { rowsForHome, findRow, modelChoiceFor } from '../providerrows.js';
+import { rowsForHome, findRow, modelChoiceFor, tickedLines, endpointOf } from '../providerrows.js';
+import { SHAPES } from '../providershapes.js';
 import { resolveProvider } from '../providers.js';
 import { REUSE_LOCKED_FIELDS, REUSE_OPEN_FIELDS } from './authorsession.js';
 import { readResume, checkpointAgeGate, CHECKPOINT_OUTCOMES } from '../reuse.js';
@@ -59,6 +60,16 @@ import { planFromSpec } from './jobplan.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
+/** 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} */
+function packageVersion(file = join(HERE, '..', '..', 'package.json')) {
+  try {
+    const v = JSON.parse(readFileSync(file, 'utf8')).version;
+    return typeof v === 'string' && v.length > 0 ? v : 'unknown';
+  } catch { return 'unknown'; }
+}
+
 /** Largest POST body the panel buffers (job cards are short prose); a bigger one is refused with 413. */
 const MAX_BODY_BYTES = 1024 * 1024;
 
@@ -1809,6 +1820,7 @@ function resolveSpecForRow(row) {
  *     change any file?"
  *   - `pattern-absent-in-diff` is always the `no-suppressions` guard: "no
  *     casts or silencers added?"
+ *   - `rubric-step` (Part 1a) is one job line's output file: "line N — does its output pass the line's checks?"
  *   - `command-exit` is the genre's `suite-green` stage (the only shipped use
  *     of this kind): "does the test suite pass?"
  *   - `count-not-worse` splits three ways on its own declared
@@ -1876,6 +1888,8 @@ function stageQuestionText({
   if (kind === 'files-changed') return 'did it change any file?';
   if (kind === 'pattern-absent-in-diff') return 'no casts or silencers added?';
   if (kind === 'command-exit') return 'does the test suite pass?';
+  // Part 1a: one rubric-step stage = one job line's output file
+  if (kind === 'rubric-step') return params && Number.isInteger(params.step) ? `line ${params.step} — does its output pass the line's checks?` : null;
   if (kind !== 'count-not-worse' || !params || typeof params !== 'object') return null;
   const what = Object.hasOwn(GENRE_WHAT, String(genre)) ? GENRE_WHAT[String(genre)] : null;
   if (params.direction === 'higher-is-better' && params.baseline === 'seed') {
@@ -2374,28 +2388,38 @@ function signedSpecForRun(row, records) {
 }
 
 /**
- * The worker a signed spec ran: provider, baseUrl and model, the model falling back to the provider's default tier
- * when the spec names none (the same fallback `resolveWorkerModel` makes at run time).
+ * The worker a signed spec ran: provider, baseUrl and model ('' when an older spec names none: bareloop keeps no default).
  * @param {any} spec
  * @returns {{provider: string, baseUrl?: string, model: string}}
  */
 function workerOfSpec(spec) {
   const provider = typeof spec?.provider === 'string' ? spec.provider : '';
-  let model = typeof spec?.model === 'string' ? spec.model : '';
-  if (!model) { try { model = resolveProvider(provider).tiers.sonnet; } catch { model = ''; } }
+  const model = typeof spec?.model === 'string' ? spec.model : '';
   return { provider, ...(typeof spec?.baseUrl === 'string' && spec.baseUrl ? { baseUrl: spec.baseUrl } : {}), model };
 }
 /** @param {{provider: string, baseUrl?: string, model: string}} w @returns {string} one spelling of "the same worker" */
 const workerId = (w) => `${w.provider}\u0000${w.baseUrl ?? ''}\u0000${w.model}`;
+/**
+ * The model id a reuse card's Model box shows for a row: the spec's own model when the row has a line for it, else the
+ * row's first ticked line; `undefined` when there is no row or no such line.
+ * @param {import('../providerrows.js').KeyRow|null} row
+ * @param {string|null|undefined} specModel
+ * @returns {string|undefined}
+ */
+function rowModelOf(row, specModel) {
+  if (!row) return undefined;
+  if (specModel && row.models.some((l) => l.model === specModel)) return specModel;
+  return tickedLines([row])[0]?.line.model;
+}
 /**
  * The worker the reuse card's CURRENT Model box names: the Settings row's provider, baseUrl and Name. `null` when the
  * box is blank or names no row.
  * @param {string} model a Settings Name
- * @param {{ home?: string }} opts
+ * @param {{ home?: string, provider?: string }} opts `provider` is the key's env name the card picked
  * @returns {{provider: string, baseUrl?: string, model: string}|null}
  */
 function workerOfChoice(model, opts) {
-  const c = modelChoiceFor(rowsForHome(keysHome(opts.home)), model);
+  const c = modelChoiceFor(rowsForHome(keysHome(opts.home)), { provider: opts.provider, model });
   return c ? { provider: c.provider, ...(c.baseUrl ? { baseUrl: c.baseUrl } : {}), model: c.name } : null;
 }
 
@@ -2478,10 +2502,11 @@ 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, opts = {}) {
@@ -2507,7 +2532,7 @@ export function getStartFrom(runid, opts = {}) {
   const jobStart = records.find((r) => r && r.type === 'job-start') ?? null;
   const card = reuseCardFromSpec(spec, {
     model: typeof saved.model === 'string' && saved.model ? saved.model
-      : (findRow(rowsForHome(keysHome(opts.home)), { provider: spec.provider, baseUrl: spec.baseUrl, model: spec.model })?.name
+      : (rowModelOf(findRow(rowsForHome(keysHome(opts.home)), { provider: spec.provider, baseUrl: spec.baseUrl, model: spec.model }), spec.model)
         ?? (typeof jobStart?.model === 'string' ? jobStart.model : '')),
     source: typeof saved.source === 'string' && saved.source ? saved.source : (typeof manifest?.source === 'string' ? manifest.source : (typeof row.patient === 'string' ? row.patient : '')),
     // a card saved by P7 or later keeps the Inputs text the person typed
@@ -2515,7 +2540,7 @@ export function getStartFrom(runid, opts = {}) {
     jobName: row.job,
   });
   const key = workflowKey(spec);
-  const trackRecord = trackRecordFor(key, { ...opts, worker: workerOfChoice(opts.model ?? card.model, opts) });
+  const trackRecord = trackRecordFor(key, { ...opts, worker: workerOfChoice(opts.model ?? card.model, { ...opts, provider: opts.provider ?? card.provider }) });
   return {
     ok: true,
     origin: { runid, job: row.job },
@@ -2530,6 +2555,14 @@ export function getStartFrom(runid, opts = {}) {
     workflowKey: key,
     spec,
     specPath: signed.specPath,
+    // an older spec signed before models were required names none: the Resume card then opens its Model box (run-u takes `--model`)
+    specNamesModel: typeof spec.model === 'string' && spec.model !== '',
+    // what resolveWorker will hold a picked line to: the spec's shape, and its endpoint when it names one ('' = any endpoint)
+    specWorker: {
+      provider: String(spec.provider),
+      endpoint: typeof spec.baseUrl === 'string' && spec.baseUrl.trim() !== '' ? endpointOf(String(spec.provider), spec.baseUrl) : '',
+      label: SHAPES.find((x) => x.id === spec.provider)?.label ?? String(spec.provider),
+    },
     trackRecord,
     line: reuseLine(trackRecord),
   };
@@ -2540,7 +2573,7 @@ export function getStartFrom(runid, 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 = {}) {
@@ -2621,7 +2654,7 @@ function describeSpec(spec) {
  * 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}
@@ -2640,10 +2673,10 @@ export function getStartFromImport(id, opts = {}) {
   // the bundle's provider is no longer forced: Model is open on a reuse, so the person's chosen Settings row is the worker.
   // The card opens on the row matching the bundle's own provider when there is one, else blank (the page's menu picks).
   const rows = rowsForHome(keysHome(opts.home));
-  const named = findRow(rows, { provider: spec.provider, baseUrl: spec.baseUrl, model: spec.model })?.name ?? '';
+  const named = rowModelOf(findRow(rows, { provider: spec.provider, baseUrl: spec.baseUrl, model: spec.model }), spec.model) ?? '';
   const card = reuseCardFromSpec(spec, { model: named, source: '', jobName: row.job });
   const key = workflowKey(spec);
-  const trackRecord = trackRecordFor(key, { ...opts, worker: workerOfChoice(opts.model ?? card.model, opts) });
+  const trackRecord = trackRecordFor(key, { ...opts, worker: workerOfChoice(opts.model ?? card.model, { ...opts, provider: opts.provider ?? card.provider }) });
   return {
     ok: true,
     origin: { runid: null, job: row.job, importId: id },
@@ -2690,7 +2723,7 @@ function sendText(res, code, text) {
  * 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, res, opts) {
   /** the ONE writable route family for a path, or null — `/api/author/*` (authoring) or
@@ -2786,6 +2819,9 @@ export function handleRequest(req, res, opts) {
       return;
     }
     html = html.replace(/__BARELOOP_PANEL_PORT__/g, String(opts.port));
+    // the topbar reads `bareloop · v<version> · ...`: the version is bareloop's OWN package.json, read when the page is served
+    // and templated in exactly like the port — never written into the HTML
+    html = html.replace(/__BARELOOP_PANEL_VERSION__/g, packageVersion(opts.packageJsonPath));
     // PANEL-BUILD.md P3's human-click guard: a per-server-start token,
     // templated into the page exactly like the port — absent on every P1/P2
     // caller (no `opts.token`), which is fine: the page's own JS only reads
@@ -2867,7 +2903,7 @@ export function handleRequest(req, res, opts) {
  * @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 = {}) {
@@ -2892,7 +2928,7 @@ export function createPanelServer(opts = {}) {
     const server = createServer((req, res) => {
       try {
         handleRequest(req, res, {
-          home, port: boundPort, token, authorRoutes, settingsRoutes, runRoutes, importRoutes,
+          home, port: boundPort, token, authorRoutes, settingsRoutes, runRoutes, importRoutes, packageJsonPath: opts.packageJsonPath,
         });
       } catch (e) {
         sendText(res, 500, `internal error: ${/** @type {Error} */ (e).message}`);