shapeup-sdlc 3.0.0 → 3.0.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "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/kernel/probe/stats.mjs

@@ -23,7 +23,6 @@ import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
 import { validate } from "../verify/envelope.mjs";
 import { runArgs } from "../lib/argv.mjs";
-import { collectRun } from "../report/export.mjs";
 import { localDir, decisions as decisionsPath, metricsDir as metricsDirPath, SHARED } from "../lib/paths.mjs";
 
 /**
@@ -284,79 +283,6 @@ export function readDecisions(cwd) {
   } catch { return []; }
 }
 
-/**
- * Project run economics for every run in the checkout — measurement-table row 4.
- *
- * WHY IT LIVES HERE and reads the run trace rather than the metrics shards: the same reason
- * `--ratchet` reads `trials.jsonl` and `--hooks` reads `decisions.jsonl`. A harvest row is written
- * once at SHIP S.6 and carries counts, never durations or cost — so a run that never shipped, which
- * is exactly the run whose cost you want to see, has no harvest row at all. The journal has one row
- * per agent call from the first dispatch onwards.
- *
- * FACTS ONLY, unchanged: sums, counts and durations over rows that already exist. Nothing here is
- * divided by an expectation or compared to a target, because that would be a grade.
- *
- * @param {string} cwd - Project root.
- * @param {(string|null)} [slug=null] - Restrict to one feature slug.
- * @returns {object} `{runs, per_run[]}` — one economics block per run, newest last, each tagged
- *   with its run_id and slug.
- */
-export function economicsReport(cwd, slug = null) {
-  const root = localDir(cwd);
-  if (!existsSync(root)) return { runs: 0, per_run: [] };
-  let slugs;
-  try { slugs = slug ? [slug] : readdirSync(root); } catch { return { runs: 0, per_run: [] }; }
-  const per_run = [];
-  for (const s of slugs.sort()) {
-    let collected = null;
-    try { collected = collectRun(cwd, s); } catch { collected = null; }
-    if (!collected) continue; // no receipt ⇒ not a run, which is not an error
-    per_run.push({ run_id: collected.run_id, slug: s, ...collected.economics });
-  }
-  return { runs: per_run.length, per_run };
-}
-
-/**
- * Format a dollar figure, keeping "no cost row was recorded" visibly different from "$0.0000".
- * @param {(number|null|undefined)} v - A cost in USD, or null when nothing recorded one.
- * @returns {string} e.g. `$1.2000`, or `—` when the value is absent.
- */
-function money(v) {
-  return v === null || v === undefined ? "—" : `$${v.toFixed(4)}`;
-}
-
-/**
- * Render the economics report as text.
- * @param {object} r - Output of {@link economicsReport}.
- * @returns {string} The multi-line report.
- */
-function renderEconomics(r) {
-  const lines = [`economics: ${r.runs} run(s) with a receipt`];
-  if (!r.runs) {
-    lines.push("", "(no run trace in this checkout — this reads the run's own records, so it is empty");
-    lines.push(" until a run opens, and stays readable after one ends until the trace is cleaned.)");
-    return lines.join("\n");
-  }
-  for (const e of r.per_run) {
-    lines.push("", `  ${e.run_id ?? e.slug}`,
-      `    agent calls           ${e.agent_calls}   (${e.retried_calls} retried, ${e.failed_calls} failed, ${e.killed_calls} killed)`,
-      `    cost                  ${money(e.cost_usd)}   attributed ${money(e.cost_attributed_usd)} · unattributed ${money(e.cost_unattributed_usd)}`,
-      `    wall clock            ${e.wall_ms_total === null ? "—" : `${Math.round(e.wall_ms_total / 1000)}s`}`,
-      `    to first write        ${e.calls_to_first_write ?? "—"} call(s)` +
-        `${e.seconds_to_first_write === null ? "" : ` · ${e.seconds_to_first_write}s`}`,
-      `    dispatches            ${e.dispatches}   (${e.dispatches_answered} answered, ${e.dispatches_costed} costed)`);
-    for (const m of e.by_model) {
-      lines.push(`      ${String(m.model).padEnd(22)}${String(m.calls).padStart(3)} call(s)  ${money(m.cost_usd)}`);
-    }
-    // The gap is named, never left as a quiet shortfall in the total.
-    if (e.dispatches_costed < e.dispatches) {
-      lines.push(`    ⓘ ${e.dispatches - e.dispatches_costed} dispatch(es) carry no cost row — the journal exists only on the`,
-        "      workflow lane, so a prose-lane or --tiny dispatch has no agent call to join to.");
-    }
-  }
-  return lines.join("\n");
-}
-
 /**
  * Render a StatsReport as a human-readable fixed-width table.
  * @param {object} report - A validated StatsReport (see {@link aggregate}).
@@ -395,7 +321,7 @@ function renderTable(report) {
 /** The typed argv contract (see `./lib/argv.mjs`). */
 export const ARGV_SPEC = {
   usage: "harness.mjs probe stats [--cwd <dir>] [--metrics-dir <dir>] [--slug <slug>] [--format json|table] " +
-         "[--ratchet] [--hooks] [--economics]",
+         "[--ratchet] [--hooks]",
   _: { arity: 0, max: 0, name: "(no positional operands)" },
   cwd: { type: "path" },
   "metrics-dir": { type: "path" },
@@ -403,7 +329,6 @@ export const ARGV_SPEC = {
   format: { type: "enum", values: ["json", "table"], default: "json" },
   ratchet: { type: "flag" },
   hooks: { type: "flag" },
-  economics: { type: "flag" },
 };
 
 /**
@@ -461,7 +386,7 @@ function renderHooks(r) {
 }
 
 /**
- * Aggregate the metric shards, or report the ratchet, hook and economics ledgers.
+ * Aggregate the metric shards, or report the ratchet and hook ledgers.
  *
  * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
  * @returns {(Promise<void>|void)} Settles when the subcommand has written its output; most paths
@@ -475,16 +400,14 @@ export async function cli(rawArgv) {
 
   // The two exit measurements are separate modes: each reads a different ledger, and neither is a
   // StatsReport (which is schema-locked to the harvest shards).
-  if (args.ratchet || args.hooks || args.economics) {
+  if (args.ratchet || args.hooks) {
     const out = {};
     if (args.ratchet) out.ratchet = ratchetReport(readAllTrials(cwd, args.slug ?? null));
     if (args.hooks) out.hooks = hooksReport(readDecisions(cwd));
-    if (args.economics) out.economics = economicsReport(cwd, args.slug ?? null);
     if (format === "table") {
       const parts = [];
       if (out.ratchet) parts.push(renderRatchet(out.ratchet));
       if (out.hooks) parts.push(renderHooks(out.hooks));
-      if (out.economics) parts.push(renderEconomics(out.economics));
       console.log(parts.join("\n\n"));
     } else {
       console.log(JSON.stringify(out, null, 2));

package/kernel/report/export.mjs

@@ -3,9 +3,9 @@
 //
 // WHY THIS EXISTS (from the storage design, not from a preference for tooling).
 //
-// Every record this exports already exists. Orders, results, journal rows, trial rows, T0
-// verdicts, criterion verdicts and hook decisions are all written during a normal run, all as
-// JSON, all schema-registered. They live in `.shapeup/<slug>/` — the LOCAL tier, which ADR-0001
+// Every record this exports already exists. Orders, results, trial rows, T0 verdicts, criterion
+// verdicts and hook decisions are all written during a normal run, all as JSON, all
+// schema-registered. They live in `.shapeup/<slug>/` — the LOCAL tier, which ADR-0001
 // defines as gitignored, machine-local and REGENERABLE. That definition is correct for run state
 // and fatal for measurement: the trial-row contract says it out loud — a measurement left there
 // "answers the question exactly once and then deletes itself".
@@ -46,10 +46,10 @@ import { join, resolve } from "node:path";
 import { runArgs } from "../lib/argv.mjs";
 import { splitFrontmatter } from "../lib/contract.mjs";
 import { runIdFromReceipt, readReceipt } from "../lib/paths.mjs";
-import { TABLES, runRow, agentCallRow, dispatchFacts, economics } from "./facts.mjs";
+import { TABLES, runRow, dispatchFacts } from "./facts.mjs";
 import {
   localDir, activeScope, receipt as receiptPath, harnessRun, ordersDir, resultsDir,
-  workflowRunDir, trials as trialsPath, verdictsDir, evaluationDir, decisions as decisionsPath,
+  trials as trialsPath, verdictsDir, evaluationDir, decisions as decisionsPath,
   exportsDir, exportRunDir,
 } from "../lib/paths.mjs";
 
@@ -174,8 +174,8 @@ function criterionRows(dir, runId, t) {
  *
  * @param {string} cwd - Project root.
  * @param {string} slug - The feature slug whose run to export.
- * @returns {(object|null)} `{run_id, slug, tables:{…}, economics, defects}` — or null when the
- *   slug has no readable receipt, which is the definition of "not a run".
+ * @returns {(object|null)} `{run_id, slug, tables:{…}, defects}` — or null when the slug has no
+ *   readable receipt, which is the definition of "not a run".
  */
 export function collectRun(cwd, slug) {
   const t = tally();
@@ -188,10 +188,8 @@ export function collectRun(cwd, slug) {
 
   const orders = readJsonDir(ordersDir(cwd, slug), t);
   const results = readJsonDir(resultsDir(cwd, slug), t);
-  const journal = readJsonl(join(workflowRunDir(cwd, slug), "journal.jsonl"), t);
 
-  const { dispatch, ac_result, discovery, file_touched } = dispatchFacts({ orders, results, journal, runId });
-  const agent_call = journal.map((j) => agentCallRow(j, runId));
+  const { dispatch, ac_result, discovery, file_touched } = dispatchFacts({ orders, results, runId });
   const run = runRow({ receipt: rec, ledger, runId });
 
   // Hook decisions are checkout-wide, so they are FILTERED to this run rather than read from a
@@ -205,13 +203,12 @@ export function collectRun(cwd, slug) {
     slug,
     tables: {
       run: run ? [run] : [],
-      dispatch, ac_result, discovery, file_touched, agent_call,
+      dispatch, ac_result, discovery, file_touched,
       trial: readJsonl(trialsPath(cwd, slug), t).map((r) => ({ ...r, run_id: r.run_id ?? runId ?? null })),
       t0_verdict: readJsonDir(verdictsDir(cwd, slug), t).map((a) => t0Row(a, runId)),
       criterion_verdict: criterionRows(evaluationDir(cwd, slug), runId, t),
       hook_decision,
     },
-    economics: economics({ agent_call, dispatch, run }),
     defects: { records_skipped: t.skipped },
   };
 }
@@ -246,7 +243,6 @@ export function writeRun(collected, outDir, format = "jsonl") {
     // The defect count is a first-class manifest field, not a log line. A short table with no
     // record of why is indistinguishable from a short run.
     records_skipped: collected.defects.records_skipped,
-    economics: collected.economics,
   };
   writeFileSync(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
   return manifest;

package/kernel/report/facts.mjs

@@ -2,45 +2,31 @@
 //
 // WHY THIS FILE EXISTS.
 //
-// The pipeline already writes JSON at every boundary — an order in, a result out, a journal row
-// per agent call, a decision row per hook evaluation, a trial row per T0 run. What it never had
-// was a way to READ them together. Each record answers a question about itself; none of them
-// answers "what did this run do, and what did it cost", because that question needs a join and
-// nothing on disk was joinable (see `mintRunId` in `lib/paths.mjs` for why).
+// The pipeline already writes JSON at every boundary — an order in, a result out, a decision row
+// per hook evaluation, a trial row per T0 run. What it never had was a way to READ them together.
+// Each record answers a question about itself; none of them answers "what did this run do",
+// because that question needs a join and nothing on disk was joinable (see `mintRunId` in
+// `lib/paths.mjs` for why).
 //
 // This module is the projection half. It takes parsed records and returns flat rows — a star
 // schema whose grain is the DISPATCH, which is the finest unit the harness actually plans in:
-// one compiled order, one worker, one result. Everything else either rolls up to it
-// (`agent_call`, via the join below) or hangs off it as a child table (`ac_result`,
-// `discovery`, `file_touched`).
+// one compiled order, one worker, one result. Everything else hangs off it as a child table
+// (`ac_result`, `discovery`, `file_touched`).
 //
-// TWO RULES, INHERITED, AND NEITHER IS STYLISTIC.
+// FACTS ONLY — the rule ``harness probe stats`` states in its own header. Every field below is a
+// count, a duration, a copied enum or an id. No field here is a score, a rate of quality, or a
+// judgement, because a computed grade in the read plane is a second judge behind spec-evaluator
+// and the architecture forbids one. `n_ac_fail` is a fact; "AC health" is not.
 //
-//   1. FACTS ONLY — the rule ``harness probe stats`` states in its own header. Every field below is a count,
-//      a duration, a copied enum or an id. No field here is a score, a rate of quality, or a
-//      judgement, because a computed grade in the read plane is a second judge behind
-//      spec-evaluator and the architecture forbids one. `n_ac_fail` is a fact; "AC health" is not.
-//
-//   2. NEVER FABRICATE A JOIN. The agent-call join (below) is real but partial, so every dispatch
-//      row carries `agent_join` naming HOW it was joined — or `null` when it wasn't. An analyst
-//      summing `cost_usd` must be able to see what share of dispatches had no cost row at all,
-//      because the alternative is a total that silently under-reports and looks authoritative.
-//      This is the same defect shape as `allow` with no receipt: an absent value and a zero value
-//      must not share a signature.
-//
-// THE AGENT-CALL JOIN, stated exactly. `journal.jsonl` is the only record carrying `cost_usd` and
-// wall-clock, and its rows name no order — the launcher is generic and never parsed the prompt it
-// was given. But the workflow's dispatch prompt asks the worker for a `result_path`, and that path
-// is `<run root>/results/<stem>.json`, whose stem is the order id's suffix. So a journal row whose
-// returned object carries `result_path` joins to exactly one order, deterministically, with no
-// heuristics. Rows without it — the mechanical `set-active-order` couriers, a failed dispatch that
-// returned nothing — join to no order and are counted as unattributed rather than dropped.
+// A dispatch with no matching result is not dropped: `answered: false` says so, because an absent
+// value and a zero value must not share a signature. This module carries no cost or wall-clock
+// instrumentation — there is no run-scoped record of either to project.
 
 /** Every fact table this module can produce, in dependency order. Exported so the writer, the
  * manifest and the tests enumerate one list instead of three. */
 export const TABLES = [
   "run", "dispatch", "ac_result", "discovery", "file_touched",
-  "agent_call", "trial", "t0_verdict", "criterion_verdict", "hook_decision",
+  "trial", "t0_verdict", "criterion_verdict", "hook_decision",
 ];
 
 /** Coerce anything to a finite number, or null. Keeps `0` and rejects `NaN`/`""`/undefined. */
@@ -84,18 +70,6 @@ export function parseOrderStem(orderId) {
   return { scope_id: null, round: null, attempt: null };
 }
 
-/**
- * The order stem a journal row refers to, via the `result_path` its schema'd reply carries.
- * @param {object} row - One `journal.jsonl` row.
- * @returns {(string|null)} The stem, or null when the row named no result path.
- */
-export function journalOrderStem(row) {
-  const p = row?.result?.result_path;
-  if (typeof p !== "string" || !p) return null;
-  const base = p.split(/[/\\]/).pop() || "";
-  return base.replace(/\.json$/i, "") || null;
-}
-
 /**
  * Project the run dimension — one row, the thing every fact table's `run_id` points at.
  * @param {object} o - Sources (destructured):
@@ -132,35 +106,6 @@ export function runRow({ receipt, ledger = null, runId = null }) {
   };
 }
 
-/**
- * Project one agent-call row from a journal row.
- * @param {object} row - One `journal.jsonl` row.
- * @param {(string|null)} runId - The run key to stamp when the row itself carries none.
- * @returns {object} A flat `agent_call` fact row.
- */
-export function agentCallRow(row, runId = null) {
-  const sessions = Array.isArray(row?.sessions) ? row.sessions : [];
-  return {
-    run_id: row?.run_id ?? runId ?? null,
-    seq: num(row?.seq),
-    phase: row?.phase ?? null,
-    label: row?.label ?? null,
-    model: row?.model ?? null,
-    permission_mode: row?.permission_mode ?? null,
-    started_at: row?.started_at ?? null,
-    wall_ms: num(row?.wall_ms),
-    // The launcher retries a schema-invalid reply once, so `attempts` > 1 is a fact about the
-    // WORKER's compliance and is kept distinct from `ok`, which is about the final outcome.
-    attempts: num(row?.attempts),
-    ok: typeof row?.ok === "boolean" ? row.ok : null,
-    cost_usd: sumOrNull(sessions.map((s) => s?.cost_usd)),
-    sessions: sessions.length,
-    errored: sessions.some((s) => s?.is_error === true),
-    killed: sessions.some((s) => s?.killed === true),
-    order_stem: journalOrderStem(row),
-  };
-}
-
 /**
  * Project the dispatch fact table and its three child tables.
  *
@@ -170,24 +115,14 @@ export function agentCallRow(row, runId = null) {
  * @param {object} o - Sources (destructured):
  * @param {Array<object>} o.orders - Parsed WorkOrders.
  * @param {Array<object>} [o.results] - Parsed WorkResults; joined on `order_id`.
- * @param {Array<object>} [o.journal] - Parsed journal rows; joined on the result-path stem.
  * @param {(string|null)} [o.runId] - Run key for orders that carry none (pre-v1.8 traces).
  * @returns {{dispatch:Array<object>, ac_result:Array<object>, discovery:Array<object>,
  *   file_touched:Array<object>}} The fact table and its children, each row already carrying
  *   `run_id` + `order_id` so every table stands alone in the warehouse.
  */
-export function dispatchFacts({ orders, results = [], journal = [], runId = null }) {
+export function dispatchFacts({ orders, results = [], runId = null }) {
   const byOrderId = new Map();
   for (const r of results) if (r?.order_id) byOrderId.set(r.order_id, r);
-  const byStem = new Map();
-  for (const j of journal) {
-    const stem = journalOrderStem(j);
-    // Last write wins: a dispatch retried after a failure legitimately produces two journal rows
-    // for one order, and the one that finished it is the one whose cost the dispatch carries. The
-    // discarded row is NOT lost — it remains its own `agent_call` row, so the retry is still
-    // visible and the two totals differ by exactly the retries.
-    if (stem) byStem.set(stem, j);
-  }
 
   const dispatch = [], ac_result = [], discovery = [], file_touched = [];
 
@@ -198,8 +133,6 @@ export function dispatchFacts({ orders, results = [], journal = [], runId = null
     const stem = orderStem(id);
     const { scope_id, round, attempt } = parseOrderStem(id);
     const result = byOrderId.get(id) || null;
-    const call = stem ? byStem.get(stem) || null : null;
-    const agent = call ? agentCallRow(call, rid) : null;
     const taskResults = Array.isArray(result?.task_results) ? result.task_results : [];
     const discoveries = Array.isArray(result?.discoveries) ? result.discoveries : [];
     const filesTouched = Array.isArray(result?.files_touched) ? result.files_touched : [];
@@ -270,78 +203,7 @@ export function dispatchFacts({ orders, results = [], journal = [], runId = null
       verdict_overall: result?.verdict?.overall ?? null,
       assumptions: Array.isArray(result?.assumptions) ? result.assumptions.length : 0,
       deviations: Array.isArray(result?.deviations) ? result.deviations.length : 0,
-      // The agent-call leg. Present only where the join held; `agent_join` says which.
-      agent_seq: agent?.seq ?? null,
-      model: agent?.model ?? null,
-      wall_ms: agent?.wall_ms ?? null,
-      cost_usd: agent?.cost_usd ?? null,
-      agent_attempts: agent?.attempts ?? null,
-      agent_ok: agent?.ok ?? null,
-      agent_join: agent ? "result_path" : null,
     });
   }
   return { dispatch, ac_result, discovery, file_touched };
 }
-
-/**
- * The run-economics projection — measurement-table row 4, computed from records the harness
- * already writes.
- *
- * Every field is a count, a sum or a duration over recorded rows. Nothing here is normalised
- * against a baseline, because no baseline dataset exists: this reports what a run cost, never
- * whether that was good, which would be a grade.
- *
- * @param {object} o - Sources (destructured):
- * @param {Array<object>} o.agent_call - Rows from {@link agentCallRow}.
- * @param {Array<object>} [o.dispatch] - Rows from {@link dispatchFacts}; supplies the first write.
- * @param {(object|null)} [o.run] - The run row; supplies `started_at` for the latency measures.
- * @returns {object} `{agent_calls, cost_usd, cost_attributed_usd, cost_unattributed_usd,
- *   wall_ms_total, calls_to_first_write, seconds_to_first_write, by_model[], retried_calls,
- *   failed_calls, dispatches, dispatches_answered, dispatches_costed}` — with nulls, never zeros,
- *   wherever the underlying record was absent.
- */
-export function economics({ agent_call, dispatch = [], run = null }) {
-  const calls = Array.isArray(agent_call) ? agent_call : [];
-  const wroteBy = new Set(dispatch.filter((d) => (d.files_touched || 0) > 0).map((d) => d.stem));
-
-  // "Turns to first write" — the harness's own definition of the metric the design doc names but
-  // has never had an instrument for. Measured in AGENT CALLS, because a call is the unit that
-  // costs money; the seconds figure is reported beside it so a run that is slow and a run that is
-  // chatty stay distinguishable.
-  const ordered = [...calls].sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
-  const firstWriteIdx = ordered.findIndex((c) => c.order_stem && wroteBy.has(c.order_stem));
-  const firstWrite = firstWriteIdx === -1 ? null : ordered[firstWriteIdx];
-  const startMs = run?.started_at ? Date.parse(run.started_at) : NaN;
-  const firstMs = firstWrite?.started_at ? Date.parse(firstWrite.started_at) : NaN;
-
-  const byModel = new Map();
-  for (const c of calls) {
-    const k = c.model || "(unnamed)";
-    const m = byModel.get(k) || { model: k, calls: 0, cost_usd: null, wall_ms: null };
-    m.calls++;
-    if (num(c.cost_usd) !== null) m.cost_usd = (m.cost_usd ?? 0) + c.cost_usd;
-    if (num(c.wall_ms) !== null) m.wall_ms = (m.wall_ms ?? 0) + c.wall_ms;
-    byModel.set(k, m);
-  }
-
-  const costed = new Set(dispatch.filter((d) => num(d.cost_usd) !== null).map((d) => d.order_id));
-  return {
-    agent_calls: calls.length,
-    cost_usd: sumOrNull(calls.map((c) => c.cost_usd)),
-    // The unattributed share is reported, never hidden: it is what the dispatch table's cost
-    // column is MISSING, and an analyst who cannot see it will read a partial total as a full one.
-    cost_attributed_usd: sumOrNull(calls.filter((c) => c.order_stem).map((c) => c.cost_usd)),
-    cost_unattributed_usd: sumOrNull(calls.filter((c) => !c.order_stem).map((c) => c.cost_usd)),
-    wall_ms_total: sumOrNull(calls.map((c) => c.wall_ms)),
-    calls_to_first_write: firstWriteIdx === -1 ? null : firstWriteIdx + 1,
-    seconds_to_first_write: Number.isFinite(startMs) && Number.isFinite(firstMs)
-      ? Math.round((firstMs - startMs) / 1000) : null,
-    retried_calls: calls.filter((c) => (c.attempts ?? 0) > 1).length,
-    failed_calls: calls.filter((c) => c.ok === false).length,
-    killed_calls: calls.filter((c) => c.killed).length,
-    dispatches: dispatch.length,
-    dispatches_answered: dispatch.filter((d) => d.answered).length,
-    dispatches_costed: costed.size,
-    by_model: [...byModel.values()].sort((a, b) => a.model.localeCompare(b.model)),
-  };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "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/tech-lead/references/gates.md

@@ -436,17 +436,19 @@ S.6  Harvest one signal row → append to `.shapeup/metrics/<machine-id>.jsonl`
 S.7  Export the run's records → one keyed dataset, before the trace is superseded.
        node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" report export --slug <slug>
      Same argument as S.6, applied to the records the harvest row does NOT carry: orders,
-     results, the agent-call journal, T0 verdicts, trial rows, criterion verdicts and this
-     run's hook decisions all live in the LOCAL tier, which is regenerable and gets wiped.
+     results, T0 verdicts, trial rows, criterion verdicts and this run's hook decisions all
+     live in the LOCAL tier, which is regenerable and gets wiped.
      The export freezes them as fact tables under `.shapeup/exports/<run_id>/` (JSONL, one
      object per line), keyed by run id so a second run of the same feature is a second
      dataset rather than an overwrite. `--out <dir>` sends it somewhere durable instead.
      It is READ-ONLY: it writes nothing into the trace, so it may be re-run at any time.
-     WHY IT IS NOT A HARVEST FIELD. Run economics — cost, wall clock, turns-to-first-write —
-     is DERIVED from this dataset (`harness probe stats --economics`), never copied into the metrics
-     shard, because that row's contract rejects clock fields on purpose (see
-     protocol.md "Rejected fields"). Preserving the trace keeps the figures available
-     without putting a velocity number in the signal feed.
+     NOT COST/WALL-CLOCK. This harness carries no run-economics record — the design once
+     called for one derived from a per-agent-call journal, but nothing in the pipeline ever
+     wrote that journal, so the derivation and its reporting command were removed rather than
+     left presenting nulls as measurements. Even a real cost record would not belong in the
+     harvest row's schema either way — that row's contract rejects clock fields on purpose
+     (see protocol.md "Rejected fields"), because a signal feed that carried a duration would
+     become a velocity feed on the next person who read it.
 ```
 
 ---

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

@@ -816,10 +816,10 @@ fixtures run in isolation and do not consume it.
   drives both toward 0 — measured from the build trace, no manual grading.
 - **Rejected fields:** `time_spent` / velocity (no clock; Shape Up forbids counting hours
   — `round_count` is the legitimate effort proxy) and `run_quality_score` (second judge).
-  This rejection is **unchanged** by the run-economics measurement (`harness probe stats
-  --economics`): cost and wall-clock are properties of a machine run, derived on demand
-  from the exported trace, and they deliberately do not enter this row. A signal feed that
-  carried a duration would become a velocity feed on the next person who read it.
+  Even a real cost or wall-clock record would not belong here: a signal feed that carried a
+  duration would become a velocity feed on the next person who read it. This harness does not
+  currently carry one — the design called for one derived from a per-agent-call journal, but
+  nothing in the pipeline ever writes it, so there is no such record to reject or admit.
 
 ### Row template
 ```json

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

@@ -992,6 +992,20 @@ if (!rs.has_spec_tree) {
 // ---- WIRE + GATE L1a.5 ------------------------------------------------------------------------
 phase("Wire");
 if (!rs.has_wiring_map) {
+  // FAIL FAST, at the orchestrator: `rs` already carries has_project_profile from the resume
+  // snapshot taken before ORIENT — the SAME fact solution-architect would have to discover for
+  // itself. Dispatching without it spends a full worker turn only for the worker to hit its own
+  // documented rule ("profile absent ⇒ ESCALATE, do not invent an entry point" — solution-
+  // architect/SKILL.md) and escalate; an escalation writes no wiring-map.md, so `has_wiring_map`
+  // stays false and every relaunch re-dispatches and re-escalates identically. The orchestrator
+  // holds the state a gate needs; it should not hand the check to the LLM it is about to pay for.
+  if (!rs.has_project_profile) {
+    return withWarnings(aborted("WIRE",
+      `missing SHARED project-profile.md at ${rs.project_profile_path} — GATE L0 writes it ` +
+      `({schema_version:1, archetype, entry_point}; references/gates.md GATE L0 §PROFILE) before ` +
+      `this workflow launches. WIRE cannot resolve an entry_call_site without an entry_point to ` +
+      `resolve against. Write the profile, then relaunch.`));
+  }
   log(`WIRE — dispatching (slug ${slug})`);
   const w = await worker({
     skill: "solution-architect", operation: "wire", schema: PHASE_OK, phase: "Wire", label: "wire",