shapeup-sdlc 3.1.1 → 3.1.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Shape Up SDLC harness for Claude Code: shaping, intake, orient, scope-mapping, building (T0-verified, sandboxed, scope-contracted), evaluation and QA skills orchestrated by a tech-lead.",
   "author": {
     "name": "Liberty Nguyen",

package/AGENTS.md

@@ -58,7 +58,7 @@ Everything discovered funnels into `.shapeup/<slug>/discovery/ledger.md` (Orient
 - **Ledger = single source of truth** — every discovery flow writes only its own section.
 - **QA is a level-up, not a gate** — `--no-qa` skips it; circuit breaker outranks the Hunter.
 - **Role separation** — Evaluator grades, task-executor fixes, QA discovers.
-- **Hill phase is mechanical ✦** — derived only from T0/T1/seesaw artifacts, never self-reported; the evaluator cites a T0 artifact it re-hashes itself.
+- **Hill phase is mechanical ✦** — derived only from T0/T1/seesaw artifacts, never self-reported; the evaluator cites a T0 artifact it re-hashes itself, from the list its order carries. A scoped verdict citing none is refused: its round stays open and is evaluated again, never advanced.
 - **Envelope port (v1.0)** — every dispatch is WorkOrder in / WorkResult out; shared state has exactly one writer (the ingest step); malformed envelopes are hook-denied. Workers: stateless, craft-only, pipeline-blind.
 
 ## Setup & Execution

package/kernel/compile.mjs

@@ -36,10 +36,11 @@ import { readRunId } from "./lib/paths.mjs";
 // --spec-overridden directory, and the import is the convention-derived default.
 import {
   tasksDir, specDir as defaultSpecDir, roundLedger, trials, verdictsDir, ordersDir,
-  relShared, globLocal, globShared, relKnowledgeBase, resultsDir, scopesDir,
+  relShared, relLocal, globLocal, globShared, relKnowledgeBase, resultsDir, scopesDir,
 } from "./lib/paths.mjs";
-import { readContract, tasksForScope, SCOPE_CONTRACT } from "./lib/contract.mjs";
+import { readContract, readAllContracts, tasksForScope, SCOPE_CONTRACT } from "./lib/contract.mjs";
 import { writeActiveOrder } from "./probe/resume.mjs";
+import { greenVerdict } from "./probe/t0.mjs";
 // The SAME matcher the sandbox hook enforces with. "Is this cited file inside this scope's
 // substrate" has to mean exactly what the guard means, or a bug is addressed to a scope that is
 // then denied the write that fixes it.
@@ -482,6 +483,43 @@ export function scopeSubstrates(cwd, slug) {
   return out;
 }
 
+// --- the T0 artifacts the judge must cite ----------------------------------------------------
+//
+// WHY THE KERNEL DERIVES THEM. spec-evaluator treats a scoped spec whose order lists no T0 artifact
+// as NOT gradeable and returns `failed` without grading a criterion. The precondition is right —
+// its verdict must cite a T0 artifact it re-hashed itself — and nothing met it: the list was once
+// assembled by an orchestrator courier from the paths each scope reported, and was lost when the
+// orchestrator became a workflow script that passes only `{dimensions, run_cmd, round}`. Evaluators
+// that went looking on disk graded anyway; one that followed its contract refused, and the run
+// aborted at L3 over a round whose every scope was green.
+//
+// Derived here for the reason `bugs` is: this is the one line every lane compiles through, and the
+// evidence is already on disk. A caller could not rebuild the list from filenames in any case —
+// verdict files are addressed by round, attempt and trial, never by scope, so the scope lives only
+// inside each body, which is what `probe t0` reads.
+
+/**
+ * The green T0 verdict each scope contract holds for a round — an evaluate order's `t0_artifacts`.
+ *
+ * @param {string} cwd - Project root.
+ * @param {string} slug - Feature slug.
+ * @param {number} [round] - The round being evaluated. Omitted, each scope's newest green verdict
+ *   of any round — a standalone evaluation has no round.
+ * @returns {{artifacts: string[], missing: string[]}} Repo-relative verdict paths in scope-id
+ *   order, one per scope that has one; and the scopes that have none. Both empty on an unscoped spec.
+ */
+export function t0ArtifactsFor(cwd, slug, round) {
+  const artifacts = [];
+  const missing = [];
+  for (const { contract, id } of readAllContracts(scopesDir(cwd, slug))) {
+    const scopeId = contract?.scope_id || id;
+    const { green, path } = greenVerdict(cwd, slug, scopeId, round);
+    if (green) artifacts.push(relLocal(slug, "t0", "verdicts", basename(path)));
+    else missing.push(scopeId);
+  }
+  return { artifacts, missing };
+}
+
 /**
  * Assemble a WorkOrder envelope. Pure given its inputs — the CLI wrapper does the disk reads.
  * @param {object} opts - The order inputs (destructured):
@@ -743,6 +781,17 @@ export async function cli(rawArgv) {
   let payloadExtra = flag("payload") || {};
   if (specDir && !payloadExtra.spec_folder) payloadExtra.spec_folder = specDir;
   if (!payloadExtra.feature) payloadExtra.feature = slug;
+  // The judge's citations, for every lane (see t0ArtifactsFor). An explicit `--payload` list still
+  // wins, as it does for `bugs`: an operator naming the evidence outranks the derivation.
+  if (operation === "evaluate" && payloadExtra.t0_artifacts === undefined) {
+    const { artifacts, missing } = t0ArtifactsFor(cwd, slug, round);
+    if (artifacts.length) payloadExtra.t0_artifacts = artifacts;
+    // On stderr, never stdout: stdout is the order path the caller consumes.
+    if (missing.length) {
+      console.error(`compile-order: warning — no green T0 verdict${round ? ` in round ${round}` : ""} for ` +
+        `${missing.join(", ")}; the evaluator has nothing to cite for ${missing.length === 1 ? "that scope" : "those scopes"}`);
+    }
+  }
 
   const order = compileOrder({
     slug, worker, operation, round, attempt, scope, tasks, decisions, digestedErrors, trialHistory, bugs,

package/kernel/probe/eval.mjs

@@ -1,8 +1,10 @@
 // probe eval — "what did round N's EVAL WorkResult actually say?"
 //
 // CONTRACT. A bounded, read-only query over the evaluate WorkResult ingest already wrote. Prints
-// `{ok, overall, bug_count, report_path}` on stdout; exits 0 when found and readable, 1 when the
-// result is missing (nothing ran, or ingest hasn't landed yet), 2 on a bad argv. Writes nothing.
+// `{ok, overall, bug_count, report_path, round, status, reason}` on stdout; exits 0 when the round
+// holds a verdict the run may act on, 1 when it does not — nothing ran, ingest hasn't landed, the
+// evaluator refused the round, or the verdict is structurally invalid; `reason` says which — and 2
+// on a bad argv. Writes nothing.
 //
 // WHY THIS EXISTS. `shapeup-run.js` cannot read a file itself (a Workflow script has no filesystem
 // of its own — see this repo's own note on why it may not call `Date.now()`), so every fact it
@@ -23,11 +25,65 @@
 // shared state; the `.md` report is prose for a human. Reading the prose to re-derive a verdict a
 // schema already carries structurally is the paraphrase channel this repo's hooks exist to close
 // everywhere else.
+//
+// WHY "NO VERDICT" CARRIES A REASON. An evaluator that refuses a round — a structural precondition
+// it cannot meet — still writes `evaluate-r<N>.json`, with `status: failed`, no verdict, and the
+// cause as its first deviation. A bare `ok: false` reached the operator as a sub-agent that died
+// after retries, while the one sentence naming the actual cause sat in a file nobody was pointed at.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { runArgs } from "../lib/argv.mjs";
-import { resultsDir } from "../lib/paths.mjs";
+import { resultsDir, scopesDir } from "../lib/paths.mjs";
+
+/** Longest `reason` reported. A deviation is prose written by a worker and can run to paragraphs. */
+const REASON_MAX = 400;
+
+/**
+ * Bound a reason to {@link REASON_MAX} characters.
+ * @param {string} s - The reason.
+ * @returns {string} `s`, or its first REASON_MAX − 1 characters and an ellipsis.
+ */
+const clip = (s) => (s.length > REASON_MAX ? `${s.slice(0, REASON_MAX - 1)}…` : s);
+
+/**
+ * Whether a feature's spec is SCOPED — has scope contracts, the case in which every verdict must
+ * cite the T0 artifacts it re-hashed.
+ *
+ * @param {string} cwd - Project root.
+ * @param {string} slug - Feature slug.
+ * @returns {boolean} True when `scopes/` holds at least one contract (`.md`, or a legacy `.json`).
+ */
+export function isScoped(cwd, slug) {
+  try { return readdirSync(scopesDir(cwd, slug)).some((f) => /\.(md|json)$/.test(f)); }
+  catch { return false; }
+}
+
+/**
+ * Why a verdict cannot stand as its round's judgement on T0 grounds, or null when it can.
+ *
+ * A PASS or FAIL on a scoped spec that cites no T0 artifact is structurally invalid — the
+ * evaluator's own contract says so, because T0 is the machine fact a generator cannot fabricate.
+ * That rule used to live only in the contract, so a verdict citing nothing was ingested, ledgered
+ * and branched on like any other. It is checked here so the round loop, the resume derivation, the
+ * hill and ingest all refuse the same verdict for the same reason.
+ *
+ * PRESENCE, NOT HASHES. The evaluator re-hashes what it cites; a slip transcribing a digest is not
+ * evidence the verdict is wrong, and refusing a round over one would cost a whole re-evaluation.
+ *
+ * @param {string} cwd - Project root.
+ * @param {string} slug - Feature slug.
+ * @param {object} verdict - The WorkResult's `verdict` block.
+ * @returns {(string|null)} The problem, phrased for an operator; null for a cited verdict, an
+ *   unscoped spec, or a block with no PASS/FAIL in it (there is no judgement to invalidate).
+ */
+export function citationProblem(cwd, slug, verdict) {
+  if (verdict?.overall !== "PASS" && verdict?.overall !== "FAIL") return null;
+  if (Array.isArray(verdict.t0_citations) && verdict.t0_citations.length) return null;
+  if (!isScoped(cwd, slug)) return null;
+  return `the ${verdict.overall} verdict cites no T0 artifact, and a verdict on a scoped spec must ` +
+    "cite the T0 verdict it re-hashed (the order lists them under payload.t0_artifacts)";
+}
 
 /**
  * Read one round's EVAL verdict straight from the WorkResult `reduce ingest` wrote.
@@ -35,20 +91,35 @@ import { resultsDir } from "../lib/paths.mjs";
  * @param {string} cwd - Project root.
  * @param {string} slug - Feature slug.
  * @param {number} round - The EVAL round (`evaluate-r<N>.json`).
- * @returns {{found: boolean, overall: (string|null), bug_count: (number|null),
- *   report_path: (string|null)}} `found: false` when no result exists yet — a fact, not a guess.
+ * @returns {{found: boolean, overall: (string|null), status: (string|null), reason: (string|null),
+ *   bug_count: (number|null), report_path: (string|null)}} `found` is true only for a PASS/FAIL the
+ *   round may act on; otherwise `reason` says why not — a fact, not a guess.
  */
 export function evalVerdict(cwd, slug, round) {
   const path = join(resultsDir(cwd, slug), `evaluate-r${round}.json`);
-  if (!existsSync(path)) return { found: false, overall: null, bug_count: null, report_path: null };
+  const unfit = (reason, status = null, overall = null) =>
+    ({ found: false, overall, status, reason, bug_count: null, report_path: null });
+  if (!existsSync(path)) return unfit("no evaluate result for this round yet");
   let doc;
   try { doc = JSON.parse(readFileSync(path, "utf8")); }
-  catch { return { found: false, overall: null, bug_count: null, report_path: null }; }
+  catch { return unfit("the evaluate result is not readable JSON"); }
+  const status = typeof doc?.status === "string" ? doc.status : null;
   const v = doc?.verdict || {};
   const overall = v.overall === "PASS" || v.overall === "FAIL" ? v.overall : null;
+  if (!overall) {
+    // A worker that refused to grade says why in its FIRST deviation — the only channel it has.
+    const first = Array.isArray(doc?.deviations) && typeof doc.deviations[0] === "string" ? doc.deviations[0] : "";
+    return unfit(clip(first
+      ? `the evaluator returned ${status || "no status"}: ${first}`
+      : `status ${status || "unknown"} with no PASS/FAIL verdict`), status);
+  }
+  const problem = citationProblem(cwd, slug, v);
+  if (problem) return unfit(problem, status, overall);
   return {
-    found: overall !== null,
+    found: true,
     overall,
+    status,
+    reason: null,
     bug_count: Array.isArray(v.bugs) ? v.bugs.length : null,
     report_path: typeof v.report_path === "string" ? v.report_path : null,
   };
@@ -66,12 +137,12 @@ export const ARGV_SPEC = {
  * Report round N's EVAL verdict, mechanically, from the WorkResult on disk.
  *
  * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
- * @returns {void} Exits 0 when a verdict was found, 1 when none exists yet for this round.
+ * @returns {void} Exits 0 when the round holds a verdict the run may act on, 1 when it does not.
  */
 export function cli(rawArgv) {
   const args = runArgs(ARGV_SPEC, rawArgv);
   const cwd = resolve(args.cwd || process.cwd());
-  const { found, overall, bug_count, report_path } = evalVerdict(cwd, args.slug, args.round);
-  console.log(JSON.stringify({ ok: found, overall, bug_count, report_path, round: args.round }));
+  const { found, overall, status, reason, bug_count, report_path } = evalVerdict(cwd, args.slug, args.round);
+  console.log(JSON.stringify({ ok: found, overall, bug_count, report_path, round: args.round, status, reason }));
   process.exit(found ? 0 : 1);
 }

package/kernel/probe/resume.mjs

@@ -65,6 +65,7 @@ import {
   intake, harnessRun, wiringMap, projectProfile, scopesDir, resultsDir, ordersDir,
   orientDir, activeOrder, usecasesDir,
 } from "../lib/paths.mjs";
+import { evalVerdict } from "./eval.mjs";
 
 /** The run-state values `references/protocol.md` (Part 4 — State) defines. A typo'd status is a rejection,
  *  not a write — the whole point of this file is that a write nobody validates is a write nobody
@@ -405,9 +406,15 @@ export function deriveResumeState(cwd, slug) {
     // that permits the overlap is the same one that makes it invisible to the disjointness lint.
     scope_exclusions: scopeExclusions(cwd, slug, scope_files),
     pending_orders: orderFiles.filter((f) => f.endsWith(".json") && !resultFiles.includes(f)),
+    // A round is DONE when it was graded, not when its result file exists. An evaluator that
+    // refused the round — no PASS/FAIL, or a scoped verdict citing no T0 artifact — still writes
+    // `evaluate-r<N>.json`; counted, the relaunch opened round N+1 over a round nobody judged, with
+    // no bugs to route, and rebuilt every scope. Left open, it re-enters round N, skips the scopes
+    // already green there, and evaluates again.
     eval_rounds_done: resultFiles
       .filter((f) => /^evaluate-r\d+\.json$/.test(f))
-      .map((f) => Number(f.match(/\d+/)[0])),
+      .map((f) => Number(f.match(/\d+/)[0]))
+      .filter((n) => evalVerdict(cwd, slug, n).found),
   };
   return { ...facts, next_phase: nextPhase(facts) };
 }

package/kernel/probe/t0.mjs

@@ -18,13 +18,36 @@ import { join, resolve } from "node:path";
 import { runArgs } from "../lib/argv.mjs";
 import { verdictsDir } from "../lib/paths.mjs";
 
+/**
+ * Verdict filenames, newest first by their NUMERIC address.
+ *
+ * A string sort files `r1-a1-t10.json` before `r1-a1-t9.json`, and the trial ordinal is shared by
+ * every scope verified at one (round, attempt) — ten scopes on their first attempt are enough to
+ * make an older verdict read as the newest. Names that carry no address sort last.
+ *
+ * @param {string[]} names - Filenames from the verdicts directory.
+ * @returns {string[]} A new array, newest first: round, then attempt, then trial, descending.
+ */
+export function newestFirst(names) {
+  const key = (f) => {
+    const m = f.match(/^r(\d+)-a(\d+)(?:-t(\d+))?\.json$/);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [-1, -1, -1];
+  };
+  return [...names].sort((a, b) => {
+    const ka = key(a), kb = key(b);
+    for (let i = 0; i < 3; i++) if (ka[i] !== kb[i]) return kb[i] - ka[i];
+    return b.localeCompare(a);
+  });
+}
+
 /**
  * The newest green T0 verdict for one scope in one round.
  *
  * @param {string} cwd - Project root.
  * @param {string} slug - Feature slug.
  * @param {string} scopeId - Scope contract id.
- * @param {number} round - Build round.
+ * @param {number} [round] - Build round. Omitted, the newest green verdict of ANY round — what an
+ *   evaluation with no round (a standalone single pass) has to cite.
  * @returns {{green: boolean, path: (string|null)}} `path` is the artifact a later EVAL can cite.
  */
 export function greenVerdict(cwd, slug, scopeId, round) {
@@ -32,11 +55,11 @@ export function greenVerdict(cwd, slug, scopeId, round) {
   if (!existsSync(dir)) return { green: false, path: null };
   // Newest first: an attempt retried after a red one writes a higher trial ordinal at the same
   // (round, attempt) address, and the LAST verdict is the one that stands.
-  for (const f of readdirSync(dir).filter((x) => x.endsWith(".json")).sort().reverse()) {
+  for (const f of newestFirst(readdirSync(dir).filter((x) => x.endsWith(".json")))) {
     const p = join(dir, f);
     try {
       const b = JSON.parse(readFileSync(p, "utf8"));
-      if (b.scope_id === scopeId && b.round === round && b.overall === "green") return { green: true, path: p };
+      if (b.scope_id === scopeId && (round == null || b.round === round) && b.overall === "green") return { green: true, path: p };
     } catch { /* a torn artifact proves nothing; keep looking */ }
   }
   return { green: false, path: null };

package/kernel/reduce/ingest.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from "node:url";
 import { validate } from "../verify/envelope.mjs";
 import { runArgs } from "../lib/argv.mjs";
 import { tasksDir, localRoot, dispatchReceipts, legLedger, readRunId } from "../lib/paths.mjs";
+import { citationProblem } from "../probe/eval.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const RESULT_SCHEMA = JSON.parse(readFileSync(resolve(HERE, "../../skills/tech-lead/schemas/work-result.schema.json"), "utf8"));
@@ -596,6 +597,20 @@ export async function cli(rawArgv) {
     process.exit(1);
   }
 
+  // --- T0 citation gate -----------------------------------------------------------------------
+  // A PASS or FAIL on a scoped spec that cites no T0 artifact is not a judgement this run may act
+  // on (see `citationProblem`). `probe eval` refuses it to the round loop; refusing it here as well
+  // keeps the verdict ledger from recording a verdict the loop will never branch on.
+  if (result.verdict) {
+    const problem = citationProblem(cwd, String(result.order_id).split("/")[0], result.verdict);
+    if (problem) {
+      console.error(`ingest-result: result refused — ${problem}.`);
+      console.error(`  The round stays open: re-dispatch the evaluator against its order, which lists`);
+      console.error(`  the T0 artifacts to cite. Nothing was written.`);
+      process.exit(1);
+    }
+  }
+
   // Resolved for EVERY order, not only the gated ones: the attesting receipt is this leg's start,
   // and a standalone or `--no-receipt-check` ingest still deserves a truthful timing row rather
   // than one silently falling back to the order's re-writable `compiled_at`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Shape Up for coding agents \u2014 with gates the agent can't talk its way past. Harness for Claude Code.",
   "bin": {
     "shapeup-sdlc": "bin/init.mjs"

package/skills/spec-evaluator/SKILL.md

@@ -37,7 +37,7 @@ Invoked as `--order <path>`. Fields you may rely on (absent = unknown, never inf
 | `payload.feature` | Feature slug — scopes the probe and names the report |
 | `payload.dimensions[]` | The active dimension set (the caller resolved precedence). Absent → `[spec-conformance]` + the auto-enable rules below |
 | `payload.run_cmd` | How to start the running app. Absent standalone → ask; absent orchestrated → ESCALATE, do not guess |
-| `payload.t0_artifacts[]` | Per-scope T0 verdict paths for this round (scoped specs). An artifact listed but missing/red on disk, or a scoped spec with none listed → the round is NOT gradeable: return `status: failed` naming the scope — a structural precondition, not a criterion |
+| `payload.t0_artifacts[]` | Per-scope T0 verdict paths for this round (scoped specs), compiled from each scope's green verdict. An artifact listed but missing/red on disk, or a scoped spec with none listed → the round is NOT gradeable: return `status: failed` with the reason, naming the scope, as your FIRST deviation — a structural precondition, not a criterion |
 | `payload.browser` | `cli` (default, ~4x cheaper) \| `mcp` \| `none` |
 | `payload.tasks[]` | Traceability only (which UCs a task claims): NEVER a grading source — the committed UC text is the criterion, a paraphrase mismatch is a finding |
 | `substrate.allowed` | Your only write surface: `.shapeup/<slug>/evaluation/**` (the report + evidence) |

package/skills/tech-lead/references/protocol.md

@@ -465,7 +465,9 @@ Read back: the stdout JSON — {path, sha256, trial, overall, regression, score,
 ## 4. EVAL → spec-evaluator (once per round)
 ```
 compile-order --operation evaluate --slug <slug> --worker spec-evaluator --round <r>
-  --payload '{"dimensions": ["spec-conformance"], "run_cmd": "<cmd>", "t0_artifacts": [...]}'
+  --payload '{"dimensions": ["spec-conformance"], "run_cmd": "<cmd>"}'
+  t0_artifacts is compiled from each scope's green T0 verdict for round <r> — pass it only to
+  override. A scope with no green verdict is named on stderr: the judge has nothing to cite for it.
 Invoke via Agent (model: eval), ONCE, after GATE L2:
   Skill(shapeup-sdlc-plugin:spec-evaluator) --order <path>
 Effect: one feature-level pass over the running app against all AC + Done-when; writes
@@ -473,6 +475,8 @@ Effect: one feature-level pass over the running app against all AC + Done-when;
         verdicts, refuted boxes, T0 citations). It touches NO task file and NO board.
 ingest-result <results/evaluate-r<r>.json>: appends the .verdicts JSONL ledger, un-ticks the
         refuted AC boxes, sets eval_verdict frontmatter — the judge returns data, ingest writes.
+        A verdict on a scoped spec that cites no T0 artifact is refused and the round stays
+        open: re-dispatch the evaluator, do not advance the round.
 Read back: EVAL-FEATURE-<slug>.md → verdict (pass|fail) + the bug list (each bug has
         task ref, severity, file:line, expected vs actual).
 ```

package/skills/tech-lead/schemas/domain.schema.json

@@ -2512,7 +2512,7 @@
           "items": {
             "type": "integer"
           },
-          "description": "Round numbers with an evaluate-r<n>.json result — the resumed run's round counter starts one past the maximum."
+          "description": "Round numbers whose evaluate-r<n>.json holds a verdict the run may act on (PASS/FAIL, citing T0 artifacts when the spec is scoped) — the resumed run's round counter starts one past the maximum. A refused or uncited round is not done: the relaunch re-enters it."
         },
         "next_phase": {
           "type": "string",

package/skills/tech-lead/workflows/shapeup-run.js

@@ -560,6 +560,10 @@ const EVAL_VERDICT = {
     bug_count: nullable("integer"),
     report_path: nullable("string"),
     round: { type: "integer" },
+    // Why the round holds no verdict it may act on — the evaluator's own first deviation when it
+    // refused, or what is structurally wrong with the verdict it returned. Null when `ok`.
+    status: nullable("string"),
+    reason: nullable("string"),
   },
   required: ["ok", "round"],
 };
@@ -1358,14 +1362,22 @@ while (verdict !== "pass" && round <= maxRounds) {
     const e = await worker({
       skill: "spec-evaluator", operation: "evaluate", schema: EVAL, phase: "Eval", label: `eval:r${round}`,
       model: evalModel, round,
+      // No `t0_artifacts` here, deliberately: `harness compile` derives them from the round's green
+      // T0 verdicts on disk, for every lane — this script could only name paths it was told about.
       payload: { dimensions: evalDims, run_cmd: rs.run_cmd, round },
-      extra: "Evaluate the running feature against every acceptance criterion and Done-when. One feature-level pass; cite the T0 artifact you re-hash yourself.",
+      extra: "Evaluate the running feature against every acceptance criterion and Done-when. One feature-level pass; cite every artifact the order lists under t0_artifacts, re-hashing each yourself.",
     });
     if (e.__failed) return diedAt("L3", e);
     // The pass/fail branch is decided from the WorkResult on disk, not from the dispatching
     // agent's own summary of it (`e.overall`) — see EVAL_VERDICT's comment for why.
     const ev = await query(`probe eval --slug ${slug} --round ${round}`, EVAL_VERDICT, "Eval", `verdict:r${round}`);
-    if (!ev || !ev.ok || !ev.overall) return diedAt("L3", nullFail(`verdict:r${round}`));
+    if (!ev) return diedAt("L3", nullFail(`verdict:r${round}`));
+    // A round with no verdict to act on is NOT a dead worker. An evaluator that refused the round
+    // wrote a result saying why, and `probe eval` carries it as `reason`; reported as "died after
+    // retries", the one sentence naming the cause stayed in a file nobody was pointed at.
+    if (!ev.ok || !ev.overall) {
+      return diedAt("L3", { __failed: `verdict:r${round}: no verdict this round can act on — ${ev.reason || `status ${ev.status || "unknown"}`}` });
+    }
     verdict = ev.overall === "PASS" ? "pass" : "fail";
     findings = e.findings || [];
   }