shapeup-sdlc 3.11.0 → 3.13.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "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

@@ -69,7 +69,7 @@ Everything discovered funnels into `.shapeup/<slug>/discovery/ledger.md` (Orient
 ## Setup & Execution
 
 - Orders/results live in `.shapeup/<slug>/orders|results/`; the envelope schemas ship with the plugin runtime, not with any individual skill, so every worker validates against the same copy.
-- The plugin's run entry points need a one-time permission grant — `npx shapeup-sdlc init` writes it into `.claude/settings.json` (`permissions.allow`); without it a headless run stalls at step one. That grant is necessary, not sufficient: it covers the run's own deterministic entry points, not the generic file edits every worker skill makes constantly, or any command a worker reaches for beyond the grant's own exact shape. A truly unattended run also needs a Claude Code permission mode that covers those (`acceptEdits` at minimum) — the plugin cannot grant that on your behalf.
+- The plugin's run entry points need a one-time permission grant — `npx shapeup-sdlc init` writes it into `.claude/settings.json` (`permissions.allow`); without it a headless run stalls at step one. That grant is necessary, not sufficient: it covers the run's own deterministic entry points, not the generic file edits every worker skill makes constantly, or any command a worker reaches for beyond the grant's own exact shape. A truly unattended run also needs a Claude Code permission mode that covers those (`acceptEdits` at minimum) — the plugin cannot grant that on your behalf. Two facts about how grants reach the run's workers, both measured: a worker dispatched inside a run takes its permissions from the project's settings file, not from flags given to the launching session, so a tool the workers need belongs in `permissions.allow`; and every work order names the plugin's kernel by absolute path, because a command that spells it through a variable is refused in a headless session before any permission rule is read.
 - The grant is necessary but sits under two more layers this plugin cannot reach either. A fresh
   checkout is an **untrusted workspace**, and Claude Code discards the whole permission grant — every
   rule in it, not only this one — until the workspace is trusted; the installer detects that state and

package/SECURITY.md

@@ -58,7 +58,10 @@ test against machines you don't own.
 6. **Every hook decision is recorded.** `hooks/lib/decision.mjs` is the only exit path a hook
    has, so allow, deny, block and error each leave a row in `.shapeup/decisions.jsonl`. An
    inert hook and a permitting hook are therefore distinguishable — which matters, because
-   "exit 0, no output" is what both used to look like.
+   "exit 0, no output" is what both used to look like. A permitted Bash call's row names the
+   programs the command runs, by basename (`hdc`, `curl | jq`) — never the arguments, which is
+   where a secret, a token or a private path would be. A denied call's row keeps the first 200
+   characters of the command, as it always has, because a denial must be reviewable.
 
 If you find any of these to be false, that is a vulnerability — report it as claim #ⁿ.
 

package/hooks/safety-spine.mjs

@@ -96,6 +96,32 @@ function tokens(segment) {
     .map((t) => t.replace(/^['"]|['"]$/g, ""));
 }
 
+/**
+ * The programs a command runs — the executable of each `&&`/`;`/`|` segment, by basename, and
+ * nothing else.
+ *
+ * WHY AN ALLOW ROW NAMES THE PROGRAM. Every permitted Bash call used to be recorded with no subject,
+ * so "did this worker ever call the device tool, and was it refused?" had no answer in the ledger:
+ * a sub-agent that never tried and one whose call was stopped above this hook left the same rows.
+ * The program names answer it. Arguments are never recorded — they are where a secret, a token or a
+ * private path would be — and a basename says which tool ran without saying where it lives.
+ *
+ * @param {string} command - The raw Bash command.
+ * @returns {(string|null)} Program basenames joined by " | ", in order, duplicates kept; null when
+ *   no segment yields one.
+ */
+export function programsOf(command) {
+  if (!command || typeof command !== "string") return null;
+  const names = [];
+  for (const segment of command.split(/\s*(?:\|\||&&|;|\||\n)\s*/).filter(Boolean)) {
+    const first = commandTokens(segment)[0];
+    if (!first) continue;
+    const base = first.replace(/^["']|["']$/g, "").split("/").pop();
+    if (base && !/^[({]$/.test(base)) names.push(base.slice(0, 64));
+  }
+  return names.length ? names.join(" | ") : null;
+}
+
 /** Strip leading env assignments and privilege/no-op wrappers to find the real command. */
 function commandTokens(segment) {
   const ts = tokens(segment);
@@ -217,8 +243,9 @@ async function main() {
   const raw = await readStdin();
   let p;
   /** Fail-open, with the reason on the record (hooks/lib/decision.mjs). */
-  const defer = (reason, rule) => settle({
+  const defer = (reason, rule, subject = null) => settle({
     verdict: "allow", event: "PreToolUse", tool: p?.tool_name ?? null, cwd: p?.cwd, reason, rule,
+    ...(subject ? { subject } : {}),
   });
   try { p = JSON.parse(raw || "{}"); }
   catch (e) { settle({ verdict: "error", event: "PreToolUse", reason: `unparseable payload: ${e.message}` }); }
@@ -258,7 +285,7 @@ async function main() {
   if (p.tool_name === "Bash") {
     const command = p.tool_input?.command || "";
     const verdict = classifyCommand(command, overrides);
-    if (!verdict.deny) defer("command matched no destructive rule — inspected and permitted", "bash-clean");
+    if (!verdict.deny) defer("command matched no destructive rule — inspected and permitted", "bash-clean", programsOf(command));
     if (commandOverridden(command, overrides)) {
       // Exercised override: allowed, but never invisible.
       logPathology(metricsPath, {

package/kernel/compile.mjs

@@ -851,6 +851,13 @@ export function compileOrder({
   const order = {
     schema_version: 1,
     order_id: `${slug}/${suffix}`,
+    // WHERE THE KERNEL IS, AS A PATH A PERMISSION RULE CAN MATCH. Workers were told to run
+    // `node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" …`. In a headless session that variable is not
+    // expanded for them, and a command carrying an unexpanded variable is refused before any rule is
+    // consulted ("Contains expansion") — so every kernel query a worker's contract requires was
+    // refused, and workers reported it as "not permitted". The absolute path of this very file's
+    // kernel is known here, and quoted it matches the grant `init` writes.
+    kernel: join(HERE, "harness.mjs"),
     // THE TWO ANALYTIC FIELDS, and why they are on the ORDER rather than the result.
     //
     // `order_id` identifies a dispatch within a run and repeats across runs of the same slug, so

package/kernel/gate.mjs

@@ -364,7 +364,7 @@ export function discover({ cwd = process.cwd(), file = null, preset = null, slug
 export const ARGV_SPEC = {
   usage: "harness.mjs gate (--init | --list | --verify | --resolve <gate-id>) [--preset <name>] " +
          "[--file <path>] [--slug <slug>] [--cwd <dir>] [--out <path>] [--by <who>] " +
-         "[--auto-level <level>] [--tiny] [--no-qa] [--round <n>]",
+         "[--auto-level <level>] [--tiny] [--no-qa] [--round <n>] [--verdict <pass|fail|…>]",
   _: { arity: 0, max: 0, name: "(no positional operands)" },
   cwd: { type: "path" },
   init: { type: "flag" },
@@ -383,8 +383,32 @@ export const ARGV_SPEC = {
   // ledger row needs it to key a `GateDecision` node uniquely per crossing. Round-independent gates
   // (L0, L1a, …) simply omit it and the row carries `round: null`.
   round: { type: "int", min: 1 },
+  // The verdict the round being crossed actually reached, when there is one. A preset answers L3
+  // before any verdict exists — "loop" on a FAIL — and its note says so; recorded without the
+  // verdict, a PASS round's row read "FAIL → fix round", the opposite of what happened.
+  verdict: { type: "str" },
 };
 
+/**
+ * The note a gate row carries — the answer's own, unless the verdict it was crossed over makes that
+ * note false.
+ *
+ * L3's answers are written for a verdict that has not happened yet: `loop` means "on a FAIL, run
+ * the next round". Crossed over a PASS, nothing loops, and the preset's "FAIL → fix round" note
+ * would put a failed round on the record for a round that passed.
+ *
+ * @param {{gate:string, decision?:string, note?:string, reason?:string}} r - The resolved answer.
+ * @param {(string|null)} verdict - The round's verdict, lower-cased, or null when none was given.
+ * @returns {(string|null)} The note to record.
+ */
+export function gateNote(r, verdict) {
+  const own = r.note ?? r.reason ?? null;
+  if (r.gate === "L3" && verdict === "pass") {
+    return `verdict PASS — the "${r.decision}" answer applies only to a failed round; the run goes on to QA and GATE H`;
+  }
+  return own;
+}
+
 function out(obj, code = 0) {
   console.log(JSON.stringify(obj, null, 2));
   process.exit(code);
@@ -468,11 +492,13 @@ export function cli(rawArgv) {
     // THE ROW CARRIES THE RUN KEY. It did not, and the export stamped the current run's key onto
     // every row it found — a prior run's sign-off became this run's in the one table that answers
     // "was this ship signed off". Driven on a two-run fixture before it was fixed.
+    const verdict = args.verdict ? String(args.verdict).toLowerCase() : null;
     appendGateLedger(cwd, args.slug, {
       at: new Date().toISOString(), run_id: readRunId(cwd, args.slug),
       gate: r.gate, status: r.status, decision: r.decision ?? null,
-      source: r.source ?? found.source, note: r.note ?? r.reason ?? null,
+      source: r.source ?? found.source, note: gateNote(r, verdict),
       round: args.round ?? null,
+      ...(verdict ? { verdict } : {}),
     });
   }
   if (r.status === "ask") out({ ...r, ok: false }, 4);

package/kernel/probe/digest.mjs

@@ -33,6 +33,12 @@ const PATTERNS = [
   // ("ERROR in the build pipeline", "ERROR in test suite failed to run") is left unmatched
   // instead of handing back a fabricated file.
   { re: /^(?:ERROR|WARNING)\s+in\s+(\.{1,2}\/[^\s:]*|[^\s:]+\.[A-Za-z0-9]{1,10})\b/i, kind: "compiler-diagnostic" },
+  // A test that FAILED BY NAME, with no file:line: "FAIL TS-05-05 step 4: no text 'Bread' on screen"
+  // or jest's "FAIL src/cart.test.js". Runners that drive an app from outside it (a device flow, an
+  // end-to-end script) report a case this way and nothing else, and the line is the whole signal —
+  // dropping it handed the next attempt an empty error list over a red fixture. The name is kept as
+  // the file only when it looks like a path; an id like TS-05-05 is not one.
+  { re: /^(?:FAIL|FAILED)\s+(\S+)(?:\s+.*)?$/, kind: "named-test-failure" },
   // Generic "Error: message" line followed later by a stack — capture the message alone.
   { re: /^\s*(?:Error|TypeError|ReferenceError|AssertionError)\s*:\s*(.+)$/, kind: "error-message" },
 ];
@@ -71,8 +77,9 @@ export function digest(rawText) {
         pendingMessage = coreMessage(m[1]);
         continue; // wait for the stack frame that follows to get a file:line
       }
-      const file = m[1]?.trim();
-      const lineNo = m[2] ? Number(m[2]) : null;
+      const named = kind === "named-test-failure";
+      const file = named ? (/[\\/]|\.[A-Za-z0-9]{1,10}$/.test(m[1]) ? m[1] : null) : m[1]?.trim();
+      const lineNo = !named && m[2] ? Number(m[2]) : null;
       triples.push({
         file: file || null,
         line: lineNo,

package/kernel/probe/stats.mjs

@@ -194,7 +194,10 @@ export function ratchetReport(trials) {
       }
       if (scopeMonotone) monotone++;
     }
-    const greenAt = seq.findIndex((t) => t.score && t.score.fixtures_total > 0 && t.score.fixtures_passed === t.score.fixtures_total && t.score.regressions === 0);
+    // A score with no `regressions` field was not measured for regressions — T0 writes one only when
+    // it has a baseline to regress against — which is not the same as having some. Requiring an
+    // explicit 0 reported "no scope reached green" over a run whose every scope was green.
+    const greenAt = seq.findIndex((t) => t.score && t.score.fixtures_total > 0 && t.score.fixtures_passed === t.score.fixtures_total && (t.score.regressions ?? 0) === 0);
     if (greenAt !== -1) toGreen.push(greenAt + 1);
     per_scope.push({
       scope_id, trials: seq.length,

package/kernel/reduce/ship.mjs

@@ -280,7 +280,7 @@ export function buildReport(facts) {
     L.push("| scope | fixtures | regressions | trials | last status | delta |", "|---|---|---|---|---|---|");
     for (const s of t0) {
       const f = s.score ? `${s.score.fixtures_passed}/${s.score.fixtures_total}` : "—";
-      const r = s.score ? String(s.score.regressions) : "—";
+      const r = s.score?.regressions != null ? String(s.score.regressions) : "—";
       L.push(`| ${s.scope_id} | ${f} | ${r} | ${s.trials} | ${s.status} | ${s.delta || "—"} |`);
     }
     L.push("");

package/kernel/schemas/work-order.schema.json

@@ -1,30 +1,61 @@
 {
   "$id": "work-order.schema.json",
   "title": "WorkOrder",
-  "description": "The orchestrator → worker envelope (pure-skill architecture v1.0). Compiled by kernel/compile.mjs, validated by harness verify envelope before any worker dispatch. A worker depends only on this envelope — never on filesystem topology, run-state format, board schema, or another worker. Path: .shapeup/<slug>/orders/r<N>-a<M>.json (or <slug>/orders/<operation>.json for non-attempt work). Every record type and payload field is DEFINED CENTRALLY in domain.schema.json ($defs + x-payload-by-worker) — this file only shapes the envelope; it never re-defines a domain entity.",
+  "description": "The orchestrator \u2192 worker envelope (pure-skill architecture v1.0). Compiled by kernel/compile.mjs, validated by harness verify envelope before any worker dispatch. A worker depends only on this envelope \u2014 never on filesystem topology, run-state format, board schema, or another worker. Path: .shapeup/<slug>/orders/r<N>-a<M>.json (or <slug>/orders/<operation>.json for non-attempt work). Every record type and payload field is DEFINED CENTRALLY in domain.schema.json ($defs + x-payload-by-worker) \u2014 this file only shapes the envelope; it never re-defines a domain entity.",
   "type": "object",
-  "required": ["schema_version", "order_id", "worker", "mode", "payload"],
+  "required": [
+    "schema_version",
+    "order_id",
+    "worker",
+    "mode",
+    "payload"
+  ],
   "properties": {
-    "schema_version": { "type": "integer", "enum": [1] },
+    "schema_version": {
+      "type": "integer",
+      "enum": [
+        1
+      ]
+    },
     "order_id": {
       "type": "string",
-      "description": "\"<slug>/r<N>-a<M>\" for build attempts, \"<slug>/<operation>[-r<N>]\" otherwise. Identifies a dispatch WITHIN a run — it repeats across runs of the same slug, which is why run_id exists.",
+      "description": "\"<slug>/r<N>-a<M>\" for build attempts, \"<slug>/<operation>[-r<N>]\" otherwise. Identifies a dispatch WITHIN a run \u2014 it repeats across runs of the same slug, which is why run_id exists.",
       "pattern": "^[a-z0-9][a-z0-9-]*/[a-z0-9][A-Za-z0-9.-]*$"
     },
+    "kernel": {
+      "type": "string",
+      "description": "OPTIONAL \u2014 the absolute path of the kernel entry point (harness.mjs) of the plugin copy that compiled this order. A worker runs every kernel command as node \"<kernel>\" \u2026: a command naming a variable instead (${CLAUDE_PLUGIN_ROOT}) is refused in a headless session before any permission rule is consulted."
+    },
     "run_id": {
       "type": "string",
-      "description": "OPTIONAL (v1.8) — the run this dispatch belongs to, stamped by harness compile from the receipt (kernel/lib/paths.mjs). The join key the analysis plane groups on: order_id alone collides across runs of the same slug, so without this no record the pipeline writes can be attributed to a run. Absent when no readable receipt exists (a standalone dispatch in a workspace with no open run) — never invented, and never required, because an analytic field must not be able to block a build.",
+      "description": "OPTIONAL (v1.8) \u2014 the run this dispatch belongs to, stamped by harness compile from the receipt (kernel/lib/paths.mjs). The join key the analysis plane groups on: order_id alone collides across runs of the same slug, so without this no record the pipeline writes can be attributed to a run. Absent when no readable receipt exists (a standalone dispatch in a workspace with no open run) \u2014 never invented, and never required, because an analytic field must not be able to block a build.",
       "pattern": "^[a-z0-9][a-z0-9-]*-[0-9]{8}T[0-9]{6}Z-[0-9a-f]{8}$"
     },
     "compiled_at": {
       "type": "string",
-      "description": "OPTIONAL (v1.8) — ISO timestamp of compilation. The dispatch record's own time dimension: WorkResult carries none, and the journal's timings exist only on the workflow lane, so without this a dispatch on the prose lane is timeless."
-    },
-    "worker": { "$ref": "domain.schema.json#/$defs/WorkerName" },
-    "mode": { "type": "string", "enum": ["orchestrated", "standalone"] },
-    "operation": { "$ref": "domain.schema.json#/$defs/Operation" },
-    "interaction": { "$ref": "domain.schema.json#/$defs/Interaction" },
-    "substrate": { "$ref": "domain.schema.json#/$defs/Substrate" },
-    "payload": { "$ref": "domain.schema.json#/$defs/WorkOrderPayload" }
+      "description": "OPTIONAL (v1.8) \u2014 ISO timestamp of compilation. The dispatch record's own time dimension: WorkResult carries none, and the journal's timings exist only on the workflow lane, so without this a dispatch on the prose lane is timeless."
+    },
+    "worker": {
+      "$ref": "domain.schema.json#/$defs/WorkerName"
+    },
+    "mode": {
+      "type": "string",
+      "enum": [
+        "orchestrated",
+        "standalone"
+      ]
+    },
+    "operation": {
+      "$ref": "domain.schema.json#/$defs/Operation"
+    },
+    "interaction": {
+      "$ref": "domain.schema.json#/$defs/Interaction"
+    },
+    "substrate": {
+      "$ref": "domain.schema.json#/$defs/Substrate"
+    },
+    "payload": {
+      "$ref": "domain.schema.json#/$defs/WorkOrderPayload"
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "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/ba-pitch-analyzer/SKILL.md

@@ -20,6 +20,8 @@ same artifacts out.
 
 ## Input contract — the WorkOrder
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 Invoked as `--order <path>`. Fields you may rely on (absent = unknown; surface it, never guess):
 
 | Field | What it is |
@@ -69,10 +71,10 @@ its phase; templates live in `assets/templates/`.
 6  TASKS       atomic, ordered, executable → tasks/ (LOCAL root; the one uncommitted branch
                of the tree — regenerable, machine-local)        [references/task-generation.md]
 7  DERIVE+LINT mechanical, not yours to grade:
-               node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" reduce board --slug <slug> --write
+               node "<kernel>" reduce board --slug <slug> --write
                  (unlocks = depends_on inverse; Σ hours; critical path; appetite arithmetic —
                   overflow is a fact you REPORT for the caller's HAMMER gate, never resolve)
-               node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" verify spec --slug <slug>
+               node "<kernel>" verify spec --slug <slug>
                  (structure, wikilinks, edge symmetry — fix reds, then re-run; you never
                   self-grade with a hand-walked checklist. BREADBOARD-PLACE / BREADBOARD-UI:
                   add the screen or defer the Place; never fold it into another screen)
@@ -187,7 +189,7 @@ status flips for built work (ingest's job), scope contracts (scope-architect's),
 /ba-pitch-analyzer --order .shapeup/checkout-vnpay/orders/analyze.json
 
 # Standalone — the preamble shim compiles the order (mode: standalone, pause_gates: true):
-#   node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" compile --operation analyze --slug <slug> \
+#   node "<kernel>" compile --operation analyze --slug <slug> \
 #        --worker ba-pitch-analyzer --payload '{"pitch": "docs/pitch.md", "lens": "standard"}'
 /ba-pitch-analyzer docs/pitch.md                      # operation: analyze, lens judged
 /ba-pitch-analyzer --lens standard docs/pitch.md      # lens pinned

package/skills/scope-architect/SKILL.md

@@ -17,6 +17,8 @@ the ship report's census table.
 
 ## Input contract — the WorkOrder
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 | Field | What it is |
 |---|---|
 | `operation` | `map-scopes` — the only operation this skill has. It covers first slicing after the board exists, folding discovered items in, and re-slicing a stuck scope; the payload says which of those you are doing |
@@ -95,7 +97,7 @@ the ship report's census table.
              hill_phase: "UPHILL_UNKNOWN"                    — ALWAYS; phase is derived from
                                                                T0/T1 facts later,
                                                                never authored
-4 LINT     node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" verify spec --slug <slug>
+4 LINT     node "<kernel>" verify spec --slug <slug>
            → PA1 (directory alignment), PA2 (>~15 files), DISJOINT (undeclared overlap),
            SCOPE-ANCHOR (empty/unresolvable use_cases), TIER-DIRECTION (a task id in a
            committed contract), SCOPE-DEPS (depends_on naming a scope that isn't here).

package/skills/scope-hammer/SKILL.md

@@ -52,13 +52,15 @@ INPUT: run's finished/unfinished scopes + baseline + census sources
 
 ## GATE H0 — Census
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 **Purpose:** Gather every open item into one list before judging any of them. Never judge
 piecemeal — a partial view produces a wrong cut.
 
 ```
 H0.0  Ownership is DERIVED, never stated. Before the census says "no scope owns X" or "X is
       scope Y's", run
-        node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug <slug> [--path <p>]...
+        node "<kernel>" probe owner --slug <slug> [--path <p>]...
       and cite its row. With no --path it answers for every engine and entry call site the wiring
       map names plus the profile's entry point; `writers: []` is an unowned seam and `missing`
       lists seams the wiring names that are not on disk — owned but never written. A census that
@@ -70,7 +72,7 @@ H0.1  Unresolved scopes (breaker cases only):
         - scopes with hammer_proposals (attempt_budget exhausted) → CARRY candidates. Exhaustion
           is DERIVED, never read off `t0/verdicts/*.json` directly — a compiled order or a T0
           verdict is writable by the very scope being judged and proves nothing on its own. Run
-            node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe attempts --slug <slug> \
+            node "<kernel>" probe attempts --slug <slug> \
               --scope <scope-id> --round <n> --attempt-budget <n>
           and cite its `spent`/`tripped` fields (exit 1 = tripped) — an attempt counts only when a
           dispatch receipt AND either a leg-completion row or a WorkResult attest it, so a leg still
@@ -81,7 +83,7 @@ H0.2  QA findings (qa-edge-hunter's hunt-report.md, when present) — all `~` by
 H0.3  Discovered-task ledger entries still open (discovery/ledger.md, `[+]`/`~` unresolved).
 H0.4  Attempt-budget hammer proposals (scopes that exhausted their T0 attempts during BUILD).
 H0.4b Requirements with no PASS evidence — the pitch clauses the run never showed working. Run
-        node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe requirements --slug <slug> --format table
+        node "<kernel>" probe requirements --slug <slug> --format table
       and take its `no evidence` rows; cite the row, the same way H0.0 cites ownership. Each is a
       census item carrying its source clause (`REQ-12 ← shaping.md R12`). A `cut` row is an answer
       the PO already gave — not an item. An inconsistency row (a criterion anchored to a
@@ -200,8 +202,8 @@ with a green census could only be recorded as `ask`. Still a proposal: the file
 /scope-hammer --slug checkout-vnpay --unattended
 
 # The ownership query every census claim cites (H0.0)
-node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug checkout-vnpay --format table
-node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug checkout-vnpay --path src/pages/Cart.ets
+node "<kernel>" probe owner --slug checkout-vnpay --format table
+node "<kernel>" probe owner --slug checkout-vnpay --path src/pages/Cart.ets
 ```
 
 ### Flags

package/skills/solution-architect/SKILL.md

@@ -38,6 +38,8 @@ return as a WorkResult.
 
 ## Input contract — the WorkOrder
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 | Field | What it is |
 |---|---|
 | `operation` | `wire` (author/refresh the wiring map after `analyze`, before `map-scopes`) |
@@ -152,5 +154,5 @@ seam, or an engine with no attachment path, and why). You never touch spec docs,
 # The reachability oracle is the ORCHESTRATOR's, run advisory at L1b — not part of your craft.
 # Standalone, you MAY preview it after writing the map (it self-skips arms whose artifacts are
 # absent, and is near-vacuous pre-build since the engine code does not exist yet):
-#   node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" verify trace --slug checkout-vnpay
+#   node "<kernel>" verify trace --slug checkout-vnpay
 ```

package/skills/spec-evaluator/SKILL.md

@@ -29,6 +29,8 @@ criterion with no collected evidence is a **FAIL**, never a pass-by-assumption.
 
 ## Input contract — the WorkOrder
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 Invoked as `--order <path>`. Fields you may rely on (absent = unknown, never inferred):
 
 | Field | What it is |
@@ -83,6 +85,13 @@ Done-when statements; `_index.md` Non-Go list. Which UCs are in scope comes from
   freeze through the judge). Ugly-but-correct PASSes; pretty-but-wrong-`data-state` FAILs.
 - `[data]`: query the DB/storage, capture actual state.
 - Contract work: send real requests, compare field-by-field.
+- **A fixture that names a row is evidence for that row.** When a T0 artifact you cite, or the
+  build gate, carries output that names a Test Surface row by id — `PASS TS-05-05`, or
+  `FAIL TS-05-05 step 4: …` — grade that row on it, after reading the check that printed it: a
+  named PASS confirms only when that check asserts the row's Expect; a check weaker than its row
+  (it opens the dialog, the row says pre-filled) is not evidence for the row, and grading it PASS
+  is the generator grading itself. A named FAIL is a FAIL whose bug is that line. This is how a
+  device row is evidenced when you cannot drive the app; never a reason not to when you can.
 - No evidence collected = recorded "NO EVIDENCE" → FAILs at verdict.
 
 **VERDICT.**
@@ -217,7 +226,7 @@ bug_template). Adding one (e.g. security) = write `references/dimensions/securit
 /spec-evaluator --order .shapeup/checkout-vnpay/orders/evaluate-r2.json
 
 # Standalone — the preamble shim compiles a minimal order, then the single code path runs:
-#   node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" compile --operation evaluate --slug <slug> \
+#   node "<kernel>" compile --operation evaluate --slug <slug> \
 #        --worker spec-evaluator [--payload '{"dimensions": [...], "run_cmd": "..."}']
 /spec-evaluator --spec shapeup/checkout-vnpay/spec/ --task TASK-007
 /spec-evaluator --spec shapeup/checkout-vnpay/spec/ --feature checkout-vnpay --single-pass
@@ -225,7 +234,7 @@ bug_template). Adding one (e.g. security) = write `references/dimensions/securit
 
 Standalone keeps `--task` (per-task check, not round-gated) and `--single-pass` (feature-level)
 — the shim maps them onto the order's payload; missing run command → ask. After writing the
-WorkResult, run `node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" reduce ingest <result path>` and show its
+WorkResult, run `node "<kernel>" reduce ingest <result path>` and show its
 summary — standalone has no orchestrator to ingest for you.
 
 ---

package/skills/task-executor/SKILL.md

@@ -16,6 +16,8 @@ it does not exist for you.
 
 ## Input contract — the WorkOrder
 
+**Kernel commands.** `<kernel>` below is the absolute path in your order's `kernel` field: run every kernel command as `node "<kernel>" …`. Never spell it `${CLAUDE_PLUGIN_ROOT}` — a command carrying a variable is refused in a headless session before any permission rule is read, and the query your contract requires never runs. With no order (invoked by hand), the kernel is `kernel/harness.mjs` two directories above this skill's base directory.
+
 You are invoked as `--order <path>` pointing at a schema-valid WorkOrder. Fields you may
 rely on (anything absent = **unknown**; never invent it):
 
@@ -25,7 +27,7 @@ rely on (anything absent = **unknown**; never invent it):
 | `payload.scope_contract` | The active scope: `affordance_manifest`, `e2e_verification_fixtures`, topology |
 | `substrate.allowed` / `substrate.shared` | The ONLY globs you may write. A needed file outside them → ESCALATE, never a write (a sandbox hook blocks it anyway) |
 | `payload.decisions[]` | Adjudicated answers from prior escalations — binding precedent, apply them |
-| `payload.digested_errors[]` | `{file, line, core_message}` triples from the previous attempt's failed verification — your starting bug list |
+| `payload.digested_errors[]` | `{file, line, core_message}` triples from the previous attempt's failed verification (a test that failed by name with no file:line — `FAIL TS-05-05 step 4: …` — arrives with `file: null` and the whole line as its message) — your starting bug list |
 | `payload.trial_history[]` | Up to 8 prior attempts on this scope, oldest first, CROSSING the round boundary: `{score, status, delta, digest}`. `status: "reverted"` is a change that was tried and made things WORSE — do not re-propose it. `status: "kept"` with a still-red score is the tree you are building ON, not a failure to undo. Absent on the first attempt |
 | `payload.verify.test_cmd` | The command that verifies your work. No test_cmd → command-verifiable ACs still need *some* observable check; say what you used |
 | `payload.kb_rules_path` | Team guidelines (read if the file exists) — steering, never spec; conflict → the AC wins, note it in `deviations` |
@@ -194,8 +196,8 @@ orchestrator's `harness reduce ingest` does all of that from your envelope.
 
 # Standalone — the preamble shim compiles a minimal WorkOrder from the flags, then the
 # single code path above runs. Requires the harness scripts (plugin install):
-#   node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" compile --task TASK-003 --slug checkout-vnpay
-#   node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" compile --next --slug checkout-vnpay
+#   node "<kernel>" compile --task TASK-003 --slug checkout-vnpay
+#   node "<kernel>" compile --next --slug checkout-vnpay
 /task-executor --spec shapeup/checkout-vnpay/spec/ --task TASK-003
 /task-executor --spec shapeup/checkout-vnpay/spec/ --next
 ```
@@ -203,6 +205,6 @@ orchestrator's `harness reduce ingest` does all of that from your envelope.
 Standalone shim: derive `<slug>` from the `--spec` path (`shapeup/<slug>/spec`),
 run `harness compile` with the matching flags (mode becomes `standalone`), then proceed
 against the compiled order exactly as if dispatched. After writing the WorkResult, run
-`node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" reduce ingest <result path>` yourself and show the user its
+`node "<kernel>" reduce ingest <result path>` yourself and show the user its
 summary — standalone has no orchestrator to ingest for you. One code path inside; two entry
 points outside.

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

@@ -898,7 +898,7 @@ async function crossGate(gateId, phaseName, validDecisions, ctx) {
   // The gate ledger keys a per-round crossing (L2, L3) on gate id + round, so it needs the round
   // whenever the caller already has one to show in the block — the same value `ctx.round` carries
   // for display, threaded through rather than re-derived.
-  const roundFlag = ctx?.round != null ? ` --round ${ctx.round}` : "";
+  const roundFlag = (ctx?.round != null ? ` --round ${ctx.round}` : "") + (ctx?.verdict ? ` --verdict ${ctx.verdict}` : "");
   const g = await cmd(`gate --resolve ${gateId} --slug ${slug}${roundFlag} ${answersFlag(args.answers)}`.trim(), phaseName, `gate:${gateId}`);
   if (g.exit_code === 4) return { stop: paused(gateId, validDecisions, ctx) };
   if (g.exit_code === 5) return { stop: aborted(gateId, g.detail || `GATE ${gateId} aborted`) };