bareloop 0.41.0 → 0.42.0

package/src/panel/index.html

@@ -113,8 +113,9 @@
   .topbar > div:first-child{display:flex;align-items:baseline;gap:0;white-space:nowrap;overflow:hidden;}
   .topbar .brand{font-weight:700;font-size:17px;letter-spacing:0.06em;flex:none;}
   .topbar .brand::before{content:"■ ";}
-  .topbar .tagline{font-size:12px;color:var(--text-dim);margin-left:8px;overflow:hidden;text-overflow:ellipsis;}
-  .topbar .tagline::before{content:"· ";color:var(--text-faint);}
+  .topbar .tagline,.topbar .version{font-size:12px;color:var(--text-dim);margin-left:8px;overflow:hidden;text-overflow:ellipsis;font-weight:400;}
+  .topbar .tagline::before,.topbar .version::before{content:"· ";color:var(--text-faint);}
+  .topbar .version{flex:none;}
   @media (max-width: 600px){ .topbar .tagline{display:none;} }
   .topbar-right{display:flex;align-items:center;gap:10px;flex-wrap:wrap;}
 
@@ -590,6 +591,9 @@
   .pv-typed input{flex:1 1 160px;min-width:0;max-width:260px;min-height:28px;box-sizing:border-box;}
   .pv-typed .hint{flex:1 1 100%;margin:0;}
   .hint.bad{color:var(--red);}
+  /* a refused Start (a $0 refusal, e.g. an Inputs line) is read like the red failure line of the progress list, not like a faint hint */
+  .card-refusal:not(:empty){font-size:13px;margin-top:8px;line-height:1.4;}
+  .card-refusal:empty{display:none;}
   .field label.jf-thinking{display:flex;flex-direction:row;align-items:center;justify-content:flex-start;gap:6px;margin-top:6px;font-size:12px;text-transform:none;letter-spacing:0;}
   .field label.jf-thinking input{width:auto;min-height:0;margin:0;}
   .table-wrap{overflow-x:auto;border:1px solid var(--border-strong);background:var(--panel2);max-width:100%;}
@@ -638,6 +642,7 @@
   <header class="topbar">
     <div>
       <span class="brand">bareloop</span>
+      <span class="version" id="panel-version">v__BARELOOP_PANEL_VERSION__</span>
       <span class="tagline">automate a job, verified</span>
     </div>
     <div class="topbar-right">
@@ -726,7 +731,7 @@
                 <input id="jf-cap-time" type="text" placeholder="or blank = no wall">
               </div>
             </div>
-            <div class="hint" id="chat-card-error" data-testid="chat-card-error"></div>
+            <div class="hint bad card-refusal" id="chat-card-error" data-testid="chat-card-error" role="alert"></div>
             <div id="chat-resume-box" class="chat-resume-box" data-testid="resume-box" hidden>
               <div class="hint" id="chat-resume-spent" data-testid="resume-spent"></div>
               <div class="ended-actions"><button class="btn primary" type="button" id="chat-resume-sign" data-testid="btn-sign-resume">Sign &amp; resume</button> <button class="btn" type="button" id="chat-resume-cancel" data-testid="btn-resume-cancel">Cancel</button></div>
@@ -2488,6 +2493,19 @@
     }, 1500);
   }
 
+  // M3 (Part 1c full-run fixes): after Sign & run the new run's row is written a few seconds later (the runner starts, then
+  // appends its row), and the Runs list only re-fetches every RUNS_LIST_POLL_MS — so a run just signed showed only after a page
+  // refresh. Like a resume, a sign forces list refreshes until a run that was not listed before the click appears; bounded.
+  function afterSignRefresh(knownIds, tries){
+    refreshRunsList(true).then(function(runs){
+      var fresh = Array.isArray(runs) && runs.some(function(r){ return knownIds.indexOf(r.runid) === -1; });
+      if(!fresh && tries > 0) setTimeout(function(){ afterSignRefresh(knownIds, tries - 1); }, 1500);
+    });
+  }
+  function currentRunIds(){
+    try { return (JSON.parse(lastRunsSig || "[]") || []).map(function(r){ return r.runid; }); } catch(e){ return []; }
+  }
+
   function renderRun(detail){
     if(detail.fileMissing){
       setRunHeader("\u00B7", runName(detail.job, detail.runNo, detail.runid), "file missing");
@@ -3235,14 +3253,15 @@
   // (src/panel/jobplan.js): numbered lines with their rule, the checks under the line each serves (folded), the AI's own
   // "Not checked", the always-on guards. Only the marker is blue (--plan). Returns HTML (every text is escaped).
   function renderJobPlan(plan){
-    var h = '<div class="jp" data-testid="job-plan">' + (plan.older ? '<div class="older" data-testid="plan-older">older job \u2014 numbered lines were not saved</div>' : "") + '<div class="jp-legend"><b>\u203A</b> = the approved plan</div>' +
+    var h = '<div class="jp" data-testid="job-plan">' + (plan.older ? '<div class="older" data-testid="plan-older">older job \u2014 numbered lines were not saved</div>' : "") + '<div class="jp-legend">Done when every <b>\u203A</b> check passes</div>' +
       (plan.goal && !plan.older ? '<div class="jp-sum" data-testid="plan-goal"><span class="lbl">AI\'s summary</span>' + escapeXml(plan.goal) + "</div>" : "");
     var checkLine = function(c){
       return '<div class="fold" data-testid="plan-check"><span class="mk">\u203A</span> check \u00B7 ' + escapeXml(c.name) + (c.cls ? " \u00B7 " + escapeXml(c.cls) : "") + "</div>";
     };
     (plan.lines || []).forEach(function(l){
       h += '<div class="jl" data-testid="plan-line"><span class="num">' + escapeXml(String(l.n)) + "</span>" + escapeXml(l.text);
-      if(l.rule) h += '<div class="sub">~ ' + escapeXml(l.rule) + "</div>";
+      // one `~` row per rule (fwdloop's shape); an older plan that carries only the joined `rule` still shows it
+      (l.rules && l.rules.length ? l.rules : (l.rule ? [l.rule] : [])).forEach(function(r){ h += '<div class="sub">~ ' + escapeXml(r) + "</div>"; });
       (l.checks || []).forEach(function(c){ h += checkLine(c); });
       (l.refused || []).forEach(function(r){ h += '<div class="fold" data-testid="plan-refused"><span class="mk">\u203A</span> not checked \u00B7 ' + escapeXml(r) + "</div>"; });
       h += "</div>";
@@ -3256,7 +3275,7 @@
         items.map(function(x){ return "<li>" + escapeXml(x) + "</li>"; }).join("") + "</ul></details>";
     };
     h += fold("Not checked (the AI's own reading)", plan.notChecked, "plan-notchecked");
-    h += fold("Always on", plan.alwaysOn, "plan-alwayson");
+    h += fold("Always checked", plan.alwaysOn, "plan-alwayson");
     return h + "</div>";
   }
 
@@ -3402,7 +3421,7 @@
       pollFailStreak = 0;
       var runs = result.runs || [];
       var next = sig(runs);
-      if(next === lastRunsSig) return; // unchanged payload — never rebuild the DOM for nothing
+      if(next === lastRunsSig) return runs; // unchanged payload — never rebuild the DOM for nothing
       lastRunsSig = next;
       withScrollPreserved(["left-pane-body"], function(){
         // setItems re-runs the SAME filter/search state and view mode
@@ -3410,6 +3429,7 @@
         // bar's own state) — a poll tick never resets either.
         runsFilterBar.setItems(runs);
       });
+      return runs;
     }).catch(function(){
       pollFailStreak++;
       // Keep the last good render; a transient failure is invisible. Only a
@@ -3906,6 +3926,7 @@
     var mainHint = document.getElementById("chat-main-hint");
     var reopenBtn = document.getElementById("chat-reopen-btn");
     var mainAction = "none";
+    var knownRunIdsAtSign = null; // the run ids listed when Sign & run was pressed (M3: afterSignRefresh waits for a new one)
     var lastState = null;
     var startOk = false;
     var errEl = document.getElementById("chat-card-error");
@@ -4596,6 +4617,7 @@
         renderActions(j.state);
         if(reuseSession && !autoSigned && j.state.phase === "prepared" && j.state.specHash){
           autoSigned = true;
+          knownRunIdsAtSign = currentRunIds();
           authorPost("/api/author/" + sessionId + "/sign", {specHash: j.state.specHash}).then(function(r){
             var o = chatPostOutcome(r);
             if(o.ok){ chatActionOk(); } else { autoSigned = false; chatActionFailed(o.error); }
@@ -4604,6 +4626,7 @@
         }
         if(j.state.phase === "signed"){
           clearInterval(pollTimer);
+          afterSignRefresh(knownRunIdsAtSign || currentRunIds(), 12);
           document.getElementById("tab-runs").click();
           // hamr's ruling 2026-10-05: the run has started, so the Chat card goes back to the empty card (the one reset
           // Clear uses) — it must not keep showing a signed job that invites a rerun. The run itself is untouched.
@@ -4626,6 +4649,8 @@
       authorPost("/api/author/start", body).then(function(r){
         if(r.status !== 200 || !r.body.ok){
           errEl.textContent = (r.body && r.body.error) || "refused";
+          // the refusal is the answer to the click: bring it into view (it sits under the cap fields, above the progress list)
+          try { errEl.scrollIntoView({block: "nearest"}); } catch(e){}
           sessionLive = false;
           refreshStartEnabled();
           return;
@@ -4906,6 +4931,7 @@
       authorGet("/api/author/" + sessionId).then(function(j){
         var hash = j.state && j.state.specHash;
         if(!hash) return;
+        knownRunIdsAtSign = currentRunIds();
         authorPost("/api/author/" + sessionId + "/sign", {specHash: hash}).then(function(r){
           var o = chatPostOutcome(r);
           if(o.ok){ chatActionOk(); } else { chatActionFailed(o.error); return; }

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/server.js

@@ -60,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;
 
@@ -1810,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
@@ -1877,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') {
@@ -2710,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
@@ -2806,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
@@ -2887,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 = {}) {
@@ -2912,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}`);

package/src/planrun.js

@@ -45,6 +45,7 @@ import { defaultJudgeLoop } from './judged.js';
 export { rateSourceFields };
 import { createClock, isWallTimeout } from './clock.js';
 import { isDeclaredClose, runDeclaredStages, validateCloseDecl, closeGrade, HUMAN_PAUSE, HITL_PAUSE, HITL_DECISION_RED } from './declaredclose.js';
+import { inputLabelsOf } from './rubricstep.js';
 import {
   seedAtHead, seedListing, changedSet, GAP_TRIM_MARKER, GATE_AUDIT_FILE, ARBITER_BOOK_STORES,
   HUMAN_KIND, HUMAN_DECISIONS, normalizeHumanRuling, resolveHumanRuling,
@@ -1886,7 +1887,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
       },
       decisionReady: true,
       decision: `The close minted ${outcome} and it STANDS. What happens to the work is yours: accept it, rerun it with your own words as the gap, or pause and come back.`
-        + (held ? ' This green was rendered by the judged floor, so it has earned no reuse until you accept it.' : ''),
+        + (held ? ' This is a rubric (soft-green) job, so its green earns no reuse until you accept it, whether or not a judge ran.' : ''),
       options: [...HUMAN_DECISIONS],
       meaning: 'not a verdict — the verdict is already minted and nothing an answer does can change it; this records a disposition',
     });
@@ -2036,7 +2037,7 @@ export async function runPlan(job, { workdir, provider, nativeProvider, provider
     }
     const listed = await seedListing(workdir, s.seedRef);
     const v = listed.stop === null
-      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType, writeScope: job.writeScope, jobLines: Array.isArray(job.jobLines) ? job.jobLines : null })
+      ? validateCloseDecl(job.closeDecl, { at: 'closeDecl', listing: listed.files, verdictType: job.verdictType, writeScope: job.writeScope, jobLines: Array.isArray(job.jobLines) ? job.jobLines : null , inputLabels: inputLabelsOf(job.inputs) })
       : { ok: false, grounded: false, reds: [{ code: 'listing-unreadable', path: 'closeDecl', detail: listed.stop }] };
     emit('close-decl', {
       genre: job.closeDecl.genre,