bareloop 0.39.0 → 0.41.0

package/src/panel/jobplan.js

@@ -0,0 +1,107 @@
+// The job plan MODEL (P7, docs/product/PANEL-BUILD.md "The job" block): ONE owner of the structure the page's single
+// `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...]}],
+//     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
+//     older: boolean }             an older job: the numbered lines were not saved
+//
+// `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';
+
+/** @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) {
+  if (typeof kind !== 'string') return null;
+  const spec = Object.hasOwn(KIND_CATALOGUE, kind) ? KIND_CATALOGUE[kind] : null;
+  if (!spec) return null;
+  return spec.verdictClass === 'green' ? 'machine check' : 'judge';
+}
+
+/**
+ * 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) {
+  /** @type {{name: string, cls: 'machine check'|'judge'|null, fromLine: number[]|null}[]} */
+  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 }));
+  } 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) : [];
+  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: '',
+        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: [] }));
+  /** @type {PlanCheck[]} */
+  const loose = [];
+  /** @type {string[]} */
+  const alwaysOn = [];
+  for (const s of stages) {
+    if (s.fromLine === null) { alwaysOn.push(s.name); continue; }
+    // a check that serves several job lines is shown under EACH line it serves (no new element: the same check line, repeated)
+    const served = lines.filter((l) => /** @type {number[]} */ (s.fromLine).includes(l.n));
+    for (const line of served) line.checks.push({ name: s.name, cls: s.cls });
+    if (served.length === 0) loose.push({ name: s.name, cls: s.cls });
+  }
+  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);
+  }
+  // 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 } : {}) };
+}
+
+/**
+ * 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, plan) {
+  const items = Array.isArray(plan?.checkItems) && plan.checkItems.length
+    ? plan.checkItems
+    : (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: [] }));
+  /** @type {PlanCheck[]} */
+  const loose = [];
+  for (const c of items) {
+    const served = lines.filter((l) => Array.isArray(c.fromLine) && c.fromLine.includes(l.n));
+    for (const line of served) line.checks.push({ name: c.text, cls: null });
+    if (served.length === 0) loose.push({ name: c.text, cls: null });
+  }
+  return {
+    lines, loose, notChecked: [...(plan?.notChecked ?? [])], alwaysOn: [...(plan?.protections ?? [])], older: false,
+  };
+}

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

@@ -36,7 +36,7 @@ import {
   replayOne, parseJsonl, resolveSiblings, isSidecarByName,
 } from '../replayio.js';
 import { summarizeForAllLine, auditWindowsOf } from '../replay.js';
-import { legsOf, legsWallMs, stopFilePath } from '../legs.js';
+import { legsOf, legsWallMs, stopFilePath, capKindOf } from '../legs.js';
 import { chainSpend } from '../ledger.js';
 import { runBehaviour } from '../behaviour.js';
 import { SPEND_RECORD_TYPES, floorsFromRecords } from '../ledger.js';
@@ -49,12 +49,14 @@ 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';
 import { statusFor, partStatusFor, GOAL_MET_LINE } from './status.js';
 import { createSettingsRoutes } from './settingsroutes.js';
+import { planFromSpec } from './jobplan.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -479,7 +481,7 @@ function endedBase(summary, death, o) {
   if (outcome === 'escalated') {
     const strikes = esc?.spend?.strikes;
     const limit = esc?.spend?.strikeLimit;
-    if (cat === 'cap-halt' && o.moneyHalt) {
+    if (capKindOf({ outcome, category: cat, moneyHalt: o.moneyHalt }) === 'money') {
       const money = typeof summary.spentUsd === 'number' && typeof summary.budgetUsd === 'number'
         ? ` (${panelMoney2(summary.spentUsd)} of ${panelMoney2(summary.budgetUsd)})` : '';
       return {
@@ -494,7 +496,7 @@ function endedBase(summary, death, o) {
         actions: [],
       };
     }
-    if (cat === 'wall-halt') {
+    if (capKindOf({ outcome, category: cat, moneyHalt: o.moneyHalt }) === 'time') {
       return { reason: 'Time cap reached.', next: CHANGE, line: 'time cap', actions: [] };
     }
     if (cat === 'provider-red') {
@@ -2098,6 +2100,42 @@ function toolsFromSpec(spec) {
   return names ? names.join(' · ') : 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, hash) {
+  const t = typeof ts === 'string' ? new Date(ts) : null;
+  if (!t || Number.isNaN(t.getTime()) || typeof hash !== 'string' || hash.length < 6) return null;
+  const p2 = (/** @type {number} */ n) => String(n).padStart(2, '0');
+  return `${t.getFullYear()}-${p2(t.getMonth() + 1)}-${p2(t.getDate())} ${p2(t.getHours())}:${p2(t.getMinutes())} · ${hash.slice(0, 6)}`;
+}
+
+/**
+ * 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) {
+  if (Array.isArray(spec?.jobLines) && spec.jobLines.length) {
+    return spec.jobLines.map((/** @type {any} */ l) => [String(l.text), ...(Array.isArray(l.rules) ? l.rules.map((r) => `~ ${r}`) : l.rule ? String(l.rule).split('; ').map((r) => `~ ${r}`) : [])].join('\n')).join('\n');
+  }
+  return typeof spec?.goal === 'string' ? spec.goal : '';
+}
+
+/**
+ * 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, source) {
+  if (Array.isArray(spec?.inputs) && spec.inputs.length) return spec.inputs.map((/** @type {any} */ i) => `${i.label}: ${i.value}`).join('\n');
+  return source ? `repo: ${source}` : '';
+}
+
 /**
  * `<src/panel>/../../jobs` — the repo's `jobs/` directory of signed specs,
  * resolved from the bareloop PACKAGE ROOT (this module's own on-disk
@@ -2180,8 +2218,20 @@ export function getRunJob(runid, opts = {}) {
       : (typeof jobStart?.model === 'string' ? jobStart.model : null),
   );
 
+  // the Signed row: the run's FIRST job-start, local time (P7)
+  let firstStart = null;
+  if (existsSync(row.spine)) {
+    try { firstStart = parseJsonl(row.spine).records.find((r) => r && typeof r === 'object' && r.type === 'job-start') ?? null; } catch { firstStart = null; }
+  }
   /** @param {any} spec @param {boolean} resolved @param {string} resolvedFrom @param {string|null} note */
   const fromSpec = (spec, resolved, resolvedFrom, note) => ({
+    // P7: the same plan model the chat's plan bubble is drawn from (src/panel/jobplan.js), read from the SIGNED spec
+    plan: planFromSpec(spec),
+    jobLines: Array.isArray(spec.jobLines) ? spec.jobLines : null,
+    inputs: Array.isArray(spec.inputs) && spec.inputs.length ? spec.inputs : [{ n: 1, label: 'repo', value: sourceDisplay() }],
+    signedAt: typeof firstStart?.ts === 'string' ? firstStart.ts : null,
+    specHash: typeof jobStart?.specHash === 'string' ? jobStart.specHash : null,
+    signed: signedLine(firstStart?.ts, typeof jobStart?.specHash === 'string' ? jobStart.specHash : null),
     runid,
     job: typeof spec.job === 'string' ? spec.job : row.job,
     resolved,
@@ -2202,6 +2252,7 @@ export function getRunJob(runid, opts = {}) {
     note,
   });
   const none = () => ({
+    plan: null, jobLines: null, inputs: [{ n: 1, label: 'repo', value: sourceDisplay() }], signedAt: null, specHash: null, signed: null,
     runid,
     job: row.job,
     resolved: false,
@@ -2263,6 +2314,10 @@ export function getRunJob(runid, opts = {}) {
   // (d) the run's own job-start record — narrower, unsigned.
   if (jobStart) {
     return {
+      plan: null, jobLines: null, inputs: [{ n: 1, label: 'repo', value: sourceDisplay() }],
+      signedAt: typeof jobStart.ts === 'string' ? jobStart.ts : null,
+      specHash: typeof jobStart.specHash === 'string' ? jobStart.specHash : null,
+      signed: signedLine(jobStart.ts, jobStart.specHash),
       runid,
       job: typeof jobStart.job === 'string' ? jobStart.job : row.job,
       resolved: false,
@@ -2320,28 +2375,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;
 }
 
@@ -2424,10 +2489,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 = {}) {
@@ -2453,14 +2519,15 @@ 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 : '')),
-    judgeExamples: typeof saved.judgeExamples === 'string' ? saved.judgeExamples : '',
+    // a card saved by P7 or later keeps the Inputs text the person typed
+    inputs: typeof saved.inputs === 'string' && saved.inputs ? saved.inputs : '',
     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 },
@@ -2470,11 +2537,19 @@ export function getStartFrom(runid, opts = {}) {
     from: 'signed job',
     locked: REUSE_LOCKED_FIELDS,
     open: REUSE_OPEN_FIELDS,
-    note: card.checkType === 'rubric' && card.judgeExamples === '' ? 'judge examples were not saved for this run' : null,
+    note: Array.isArray(spec.jobLines) && spec.jobLines.length ? null : 'older job — numbered lines were not saved',
     specHash: signed.specHash,
     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),
   };
@@ -2485,7 +2560,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 = {}) {
@@ -2518,7 +2593,7 @@ export function listReuseJobs(opts = {}) {
  * The reuse card for a signed spec: locked boxes from the spec through the Job tab's own readers, open boxes from
  * the spec's own fence and caps (Source and the saved text from the caller — a spec carries neither).
  * @param {any} spec
- * @param {{model: string, source: string, judgeExamples: string, jobName: string}} extra
+ * @param {{model: string, source: string, inputs?: string, jobName: string}} extra `inputs` = the Inputs text the person saved (else built from the spec's inputs, else `repo: <source>`)
  * @returns {Record<string, any>}
  */
 function reuseCardFromSpec(spec, extra) {
@@ -2527,12 +2602,9 @@ function reuseCardFromSpec(spec, extra) {
     jobName: typeof spec.job === 'string' && spec.job ? spec.job : extra.jobName,
     checkType: spec.verdictType === 'soft-green' ? 'rubric' : 'deterministic',
     model: typeof spec.model === 'string' && spec.model && !extra.model ? spec.model : extra.model,
-    goal: typeof spec.goal === 'string' ? spec.goal : '',
-    source: extra.source,
+    jobText: jobTextFromSpec(spec),
+    inputs: extra.inputs || inputsTextFromSpec(spec, extra.source),
     destination: writeScope.join(', '),
-    success: successFromSpec(spec) ?? '',
-    guardrails: guardrailsFromSpec(spec) ?? '',
-    judgeExamples: extra.judgeExamples,
     capUsd: typeof spec.budgetUsd === 'number' ? spec.budgetUsd : null,
     maxWallMs: typeof spec.maxWallMs === 'number' ? spec.maxWallMs : undefined,
   };
@@ -2542,7 +2614,7 @@ function reuseCardFromSpec(spec, extra) {
  * P5 item 4 — the facts of a spec for an IMPORTED job's view, read by the SAME readers the Job tab uses for a run
  * (so an imported job and a run read alike): check type, goal, success checks, guardrails, model, caps.
  * @param {any} spec
- * @returns {{checkType: string, goal: string, success: string, guardrails: string, model: string, budgetUsd: number|null, maxWallMs: number|null}}
+ * @returns {{checkType: string, goal: string, success: string, guardrails: string, plan: ReturnType<typeof planFromSpec>, inputs: any[]|null, model: string, budgetUsd: number|null, maxWallMs: number|null}}
  */
 function describeSpec(spec) {
   const nr = (/** @type {string|null} */ v) => (typeof v === 'string' && v.length > 0 ? v : 'not recorded');
@@ -2551,6 +2623,8 @@ function describeSpec(spec) {
     goal: nr(typeof spec.goal === 'string' ? spec.goal : null),
     success: nr(successFromSpec(spec)),
     guardrails: nr(guardrailsFromSpec(spec)),
+    plan: planFromSpec(spec),
+    inputs: Array.isArray(spec.inputs) && spec.inputs.length ? spec.inputs : null,
     model: nr(typeof spec.model === 'string' ? spec.model : null),
     budgetUsd: typeof spec.budgetUsd === 'number' ? spec.budgetUsd : null,
     maxWallMs: typeof spec.maxWallMs === 'number' ? spec.maxWallMs : null,
@@ -2567,7 +2641,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}
@@ -2586,10 +2660,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 card = reuseCardFromSpec(spec, { model: named, source: '', judgeExamples: '', jobName: row.job });
+  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 },