shapeup-sdlc 3.18.2 → 4.0.0

package/kernel/probe/eval.mjs

@@ -1,405 +0,0 @@
-// 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, 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
-// branches on has to cross an `agent()`/`query()` boundary. Before this command existed, the EVAL
-// round-loop branch (`verdict = e.overall === "PASS" ? "pass" : "fail"`) trusted the DISPATCHING
-// sub-agent's own end-of-turn summary — a value composed from memory/judgment after three other
-// steps (compile, dispatch, ingest), schema-checked for SHAPE only. Nothing re-verified that
-// summary against the WorkResult `reduce ingest` had just written to disk. Measured live
-// (2026-08-19, todo-cli): `results/evaluate-r1.json`'s `verdict.overall` was `"FAIL"` (2 cited
-// bugs, `spec-evaluator` correctly failing `SC-ERR`), and the run proceeded straight to QA and
-// GATE H anyway — the exact shape `verdict = e.overall === "PASS"` allows when `e.overall` is a
-// self-report that drifted from the artifact it was supposed to summarize. This command closes
-// that gap the same way `probe t0` already closes it for the T0 ratchet: a narrow, single-purpose
-// "transcribe this JSON verbatim" query over the artifact itself, not a multi-step summary.
-//
-// WHY IT READS `results/evaluate-r<N>.json` AND NOT THE `.md` REPORT. The WorkResult is the
-// machine-checked envelope `reduce ingest` validated against `EVAL`'s schema before ever touching
-// 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, readdirSync, realpathSync } from "node:fs";
-import { join, resolve, resolve as resolvePath, sep } from "node:path";
-import { createHash } from "node:crypto";
-import { runArgs } from "../lib/argv.mjs";
-import { resultsDir, ordersDir, scopesDir, readRunId, verdictsDir, specDir } from "../lib/paths.mjs";
-import { readBoard } from "../compile.mjs";
-import { coveringAcs } from "./requirements.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 one T0 citation does not resolve, or null when the kernel can positively confirm it does.
- *
- * Re-checks the two facts a citation can lie about and the schema promises are enforced
- * (`T0Citation`: "the evaluator RECOMPUTES sha256 from disk — a handed hash is never trusted"):
- * that the bytes at `path` hash to the cited `sha256`, and that what those bytes actually say is a
- * green T0 verdict — a PASS/FAIL cannot ride on an artifact that itself recorded red. NOT checked:
- * whether `path` is one of the order's own `payload.t0_artifacts` (see the note on
- * {@link citationProblem} for why that is left to the operator rather than enforced here).
- *
- * FAILS OPEN ON "CANNOT TELL", CLOSED ON "PROVEN WRONG" — and the two are not the same fact. A read
- * that fails for a reason that says something DEFINITE about what is (or isn't) at `path` is proof,
- * same as a hash mismatch: `ENOENT` (nothing there) and `EISDIR` (a directory, never a file — T0
- * verdicts are always files, per `writeArtifact`) both mean no such artifact was ever produced, so
- * both refuse. `verify t0` writes verdict artifacts immutably and never deletes one
- * (`writeArtifact`'s `wx` flag — see kernel/verify/t0.mjs), so that absence or shape mismatch is a
- * positive fact about the citation, not a guess. Anything else a read can fail with — permission
- * denied, a symlink loop, a transient I/O error — says nothing about the citation's honesty, only
- * that THIS MACHINE could not check it just now, so it is not refused on that ground alone: the
- * fail-open discipline this repo's guards already use elsewhere for an unproven bad state.
- *
- * @param {string} cwd - Project root.
- * @param {object} citation - One `T0Citation` (`scope_id`, `path`, `sha256`). Read defensively:
- *   `reduce ingest` only reaches this after the enclosing WorkResult passed schema validation, but
- *   `probe eval` reaches it over a result file it merely `JSON.parse`s, so a malformed citation must
- *   fail this check rather than throw.
- * @returns {(string|null)} A reason phrased for an operator, or null when the file at `path` exists,
- *   hashes to the cited `sha256`, and its own `overall` reads "green".
- */
-function unresolvedCitation(cwd, citation, { round = null, runId = null, verdicts = null } = {}) {
-  const rel = typeof citation?.path === "string" ? citation.path : "";
-  if (!rel) return "names no artifact path";
-  let text;
-  try {
-    text = readFileSync(resolve(cwd, rel), "utf8");
-  } catch (e) {
-    if (e.code === "ENOENT") return `cites ${rel}, which does not exist on disk`;
-    if (e.code === "EISDIR") return `cites ${rel}, which is a directory, not a T0 verdict file`;
-    // EACCES, ELOOP, EIO, EMFILE… — this machine failing to look, not evidence against the
-    // citation, so it is not refused on that ground.
-    return null;
-  }
-  const actual = createHash("sha256").update(text).digest("hex");
-  const claimed = typeof citation.sha256 === "string" ? citation.sha256.toLowerCase() : "";
-  if (actual !== claimed) return `cites ${rel} with sha256 ${citation.sha256}, but the file on disk hashes to ${actual}`;
-  let body;
-  try { body = JSON.parse(text); }
-  catch { return `cites ${rel}, whose bytes match the hash but do not read as a T0 verdict`; }
-  if (body?.overall !== "green") return `cites ${rel}, whose own verdict is "${body?.overall ?? "unknown"}", not green`;
-  // INSIDE THIS RUN'S OWN VERDICTS DIRECTORY, resolved — asked of a file that exists, so "does not
-  // exist" and "resolves somewhere else" stay different answers. Accepted before this check: a
-  // green artifact in the source tree, one outside the project reached by `../`, one by absolute
-  // path, and a symlink in the verdicts directory pointing at a forged file. Every one hashed
-  // correctly, because a digest says the bytes are the file's and nothing about which file it
-  // should have been.
-  if (verdicts) {
-    const real = (() => { try { return realpathSync.native(resolvePath(cwd, rel)); } catch { return resolvePath(cwd, rel); } })();
-    const home = (() => { try { return realpathSync.native(verdicts); } catch { return verdicts; } })();
-    if (!real.startsWith(home.endsWith(sep) ? home : home + sep)) {
-      return `cites ${rel}, which resolves outside this run's own verdicts directory (${home}) — a verdict cites what this run's own verifier wrote, not a file the judge can reach`;
-    }
-  }
-  // THE ARTIFACT HAS TO BE THE ONE THE CITATION SAYS IT IS. A re-hash proves the bytes are the
-  // file's; it says nothing about whose verdict the file holds. A PASS citing scope alpha's green
-  // artifact while declaring scope beta, or a prior round's, or a prior run's over the same slug,
-  // passed the digest check unremarked. The citation's own required `scope_id`, the round being
-  // judged and the run's key are compared to what the artifact records about itself.
-  if (typeof citation.scope_id === "string" && body?.scope_id && body.scope_id !== citation.scope_id) {
-    return `cites ${rel} for scope "${citation.scope_id}", but the artifact records scope "${body.scope_id}"`;
-  }
-  if (round != null && typeof body?.round === "number" && body.round !== round) {
-    return `cites ${rel}, a round ${body.round} artifact, as evidence for round ${round}`;
-  }
-  if (runId && body?.run_id && body.run_id !== runId) {
-    return `cites ${rel}, an artifact of run ${body.run_id}, as evidence for run ${runId}`;
-  }
-  return null;
-}
-
-/**
- * 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.
- *
- * RESOLVES, NOT JUST PRESENT. A citation naming a path and a hash used to be taken on faith: any
- * non-empty `t0_citations[]` passed, whatever it pointed at. Measured live: a PASS citing a path
- * that does not exist on disk, and a PASS citing a real artifact whose own verdict was red, both
- * ingested clean — presence stood in for a re-hash the schema had already promised. Each citation is
- * now re-checked through {@link unresolvedCitation}.
- *
- * WHAT THIS DOES NOT CHECK: whether a citation is drawn from the order's own `payload.t0_artifacts`
- * list. That would need the compiled order, which this function's callers do not equally have —
- * `reduce ingest` holds it, but `probe eval` (and the round-loop/resume/hill readers behind it)
- * knows only (cwd, slug, round), and a scope's T0 attempt can legitimately go green again LATER than
- * whatever list was frozen at compile time (`greenVerdict` already treats "newest green" as
- * authoritative for exactly this reason — see kernel/probe/t0.mjs). Enforcing membership only where
- * the order happens to be on hand would let one channel refuse a citation the other accepts, for
- * evidence that may simply be fresher than the order — worse than leaving it unenforced.
- *
- * @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 verdict whose every
- *   citation resolves, an unscoped spec, or a block with no PASS/FAIL in it (there is no judgement
- *   to invalidate).
- */
-/**
- * Why a verdict cannot stand on its own criteria, or null when it can.
- *
- * `overall` is the judge's field, and nothing recomputed it from the criteria the judge graded: a
- * PASS over a failing criterion, or over no criterion at all, validated and ingested, and the
- * round loop branched on it. The evaluator's own first rule is that absence of evidence is a FAIL,
- * so a PASS criterion with no evidence is no evidence either. Recomputed here, on ingest and on
- * read alike: PASS means every graded criterion passed with evidence and at least one was graded;
- * FAIL means at least one graded criterion failed.
- *
- * @param {object} verdict - The WorkResult's `verdict`.
- * @returns {(string|null)} A reason phrased for an operator, or null.
- */
-export function verdictProblem(verdict) {
-  const overall = verdict?.overall;
-  if (overall !== "PASS" && overall !== "FAIL") return null;
-  const criteria = Array.isArray(verdict.criteria) ? verdict.criteria : [];
-  const fails = criteria.filter((c) => c?.verdict === "FAIL");
-  const passes = criteria.filter((c) => c?.verdict === "PASS");
-  const other = criteria.length - fails.length - passes.length;
-  if (overall === "PASS") {
-    if (criteria.length === 0) return "the PASS verdict grades no criterion at all — a PASS with no evidence is a claim";
-    if (fails.length) return `the verdict says PASS while ${fails.length} of its ${criteria.length} criteria read FAIL — overall is derived from the criteria, never declared over them`;
-    if (other) return `the verdict says PASS while ${other} of its criteria carry no PASS/FAIL verdict`;
-    const bare = passes.filter((c) => !(typeof c?.evidence === "string" && c.evidence.trim()));
-    if (bare.length) return `the PASS verdict has ${bare.length} criterion(s) marked PASS with no evidence — absence of evidence is a FAIL by the evaluator's own first rule`;
-    return null;
-  }
-  if (criteria.length === 0) return "the FAIL verdict grades no criterion at all — a FAIL must name what failed";
-  if (!fails.length) return `the verdict says FAIL while every one of its ${criteria.length} graded criteria reads PASS — a FAIL must cite the criterion it failed`;
-  return null;
-}
-
-/**
- * The Test Surface row ids the spec declares, in spec order.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @returns {string[]} Every `TS-…` id that opens a table row in a use-case file; [] with no spec tree.
- */
-export function surfaceRows(cwd, slug) {
-  const dir = join(specDir(cwd, slug), "usecases");
-  let files = [];
-  try { files = readdirSync(dir).filter((f) => /^UC-.*\.md$/.test(f)).sort(); } catch { return []; }
-  const rows = [];
-  for (const f of files) {
-    let text = "";
-    try { text = readFileSync(join(dir, f), "utf8"); } catch { continue; }
-    for (const m of text.matchAll(/^\|\s*(TS-[A-Za-z0-9_-]+)\s*\|/gm)) if (!rows.includes(m[1])) rows.push(m[1]);
-  }
-  return rows;
-}
-
-/**
- * Whether a PASS grades every Test Surface row by name.
- *
- * A PASS that grades the surface as a whole — "device rows", "local rows" — validated like any other
- * and switched off everything that reads a verdict row by row: the requirements matrix read no
- * evidence under every covered requirement, a failed row had no criterion to become a bug, and a row
- * nobody looked at passed with the rest. A row counts as graded when its id appears in a criterion's
- * text or its `traces_to`. Only a PASS is held to it: a FAIL sends the round back either way.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @param {object} verdict - The WorkResult's `verdict`.
- * @returns {(string|null)} A reason naming the rows no criterion graded, or null.
- */
-export function coverageProblem(cwd, slug, verdict) {
-  if (verdict?.overall !== "PASS") return null;
-  const rows = surfaceRows(cwd, slug);
-  if (!rows.length) return null;
-  const named = new Set();
-  for (const c of Array.isArray(verdict.criteria) ? verdict.criteria : []) {
-    const text = [c?.criterion, ...(Array.isArray(c?.traces_to) ? c.traces_to : [])].map((x) => String(x ?? "")).join(" ");
-    for (const m of text.matchAll(/\bTS-[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)*/g)) named.add(m[0]);
-  }
-  const missing = rows.filter((r) => !named.has(r));
-  if (!missing.length) return null;
-  const shown = missing.slice(0, 8).join(", ") + (missing.length > 8 ? ` and ${missing.length - 8} more` : "");
-  return `the PASS verdict grades ${rows.length - missing.length} of ${rows.length} Test Surface rows by name — ` +
-    `each row is its own criterion, its id in the criterion or its traces_to; ungraded: ${shown}`;
-}
-
-/**
- * Whether a verdict anchors any criterion to a requirement when the board says which ones it could.
- *
- * `traces_to` is copied from the `(covers: REQ-…)` clauses of the acceptance criteria a criterion
- * grades, and the requirements matrix is joined along it. Two judges on the same spec and the same
- * instruction differed: one anchored every row and the matrix read 5/5, the next anchored none and it
- * read 0/5 over the same passes. Held only to the all-empty case: which requirement a criterion
- * traces to is the judge's reading, but none at all, beside a board that covers some, is a copy
- * step skipped.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @param {object} verdict - The WorkResult's `verdict`.
- * @returns {(string|null)} A reason phrased for the judge, or null.
- */
-export function tracesProblem(cwd, slug, verdict) {
-  if (verdict?.overall !== "PASS" && verdict?.overall !== "FAIL") return null;
-  const criteria = Array.isArray(verdict.criteria) ? verdict.criteria : [];
-  if (!criteria.length) return null;
-  if (criteria.some((c) => Array.isArray(c?.traces_to) && c.traces_to.length)) return null;
-  let covered = 0;
-  try { covered = coveringAcs(readBoard(cwd, slug)).size; } catch { return null; }
-  if (!covered) return null;
-  return `the verdict anchors none of its ${criteria.length} criteria to a requirement while the board's acceptance ` +
-    `criteria cover ${covered} — copy each graded AC's (covers: REQ-…) clause into that criterion's traces_to`;
-}
-
-/**
- * A PASS that grades nothing under a dimension its order named.
- *
- * The order names the dimensions the judge grades, and GATE L4 prints them back as what "PASS"
- * covers. Measured: an order named four, the PASS graded criteria under three, and L4 still listed
- * the fourth as evaluated. A PASS must grade at least one criterion under every dimension its order
- * named; a FAIL already stops the ship, so it is not held to this.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @param {object} verdict - The WorkResult's `verdict`.
- * @param {{round:(number|null)}} [opts] - The EVAL round whose order names the set; null → no check.
- * @returns {(string|null)} Why the verdict is refused, or null.
- */
-export function dimensionsProblem(cwd, slug, verdict, { round = null } = {}) {
-  if (verdict?.overall !== "PASS" || round == null) return null;
-  const named = orderDimensions(cwd, slug, round);
-  if (!named?.length) return null;
-  const criteria = Array.isArray(verdict.criteria) ? verdict.criteria : [];
-  const graded = new Set(criteria.map((c) => c?.dimension).filter(Boolean));
-  const missing = named.filter((d) => !graded.has(d));
-  if (!missing.length) return null;
-  return `the PASS grades no criterion under ${missing.join(", ")}, which the order names — grade each named ` +
-    "dimension's criteria, or FAIL the one you cannot grade with the reason";
-}
-
-export function citationProblem(cwd, slug, verdict, { round = null } = {}) {
-  if (verdict?.overall !== "PASS" && verdict?.overall !== "FAIL") return null;
-  if (!isScoped(cwd, slug)) return null;
-  if (!Array.isArray(verdict.t0_citations) || !verdict.t0_citations.length) {
-    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)";
-  }
-  const runId = readRunId(cwd, slug);
-  const verdicts = verdictsDir(cwd, slug);
-  for (const citation of verdict.t0_citations) {
-    const reason = unresolvedCitation(cwd, citation, { round, runId, verdicts });
-    if (reason) return `the ${verdict.overall} verdict ${reason} — a T0 citation is re-hashed from disk, never taken on the handed word`;
-  }
-  return null;
-}
-
-/**
- * Read one round's EVAL verdict straight from the WorkResult `reduce ingest` wrote.
- *
- * @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), 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`);
-  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 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 = verdictProblem(v) || coverageProblem(cwd, slug, v) || tracesProblem(cwd, slug, v)
-    || dimensionsProblem(cwd, slug, v, { round }) || citationProblem(cwd, slug, v, { round });
-  if (problem) return unfit(problem, status, overall);
-  return {
-    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,
-  };
-}
-
-/**
- * The dimensions round N's evaluate order named — the set the judge was asked to grade.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @param {number} round - The EVAL round (`evaluate-r<N>.json`).
- * @returns {(string[]|null)} The order's `payload.dimensions`; null when the order or the list is absent.
- */
-export function orderDimensions(cwd, slug, round) {
-  try {
-    const o = JSON.parse(readFileSync(join(ordersDir(cwd, slug), `evaluate-r${round}.json`), "utf8"));
-    const d = o?.payload?.dimensions;
-    return Array.isArray(d) && d.every((x) => typeof x === "string") ? d : null;
-  } catch { return null; }
-}
-
-export const ARGV_SPEC = {
-  usage: "harness.mjs probe eval --slug <slug> --round N [--cwd <dir>]",
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  slug: { type: "str", required: true },
-  round: { type: "int", min: 1, required: true },
-  cwd: { type: "path" },
-};
-
-/**
- * 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 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, status, reason, bug_count, report_path } = evalVerdict(cwd, args.slug, args.round);
-  const dimensions = orderDimensions(cwd, args.slug, args.round);
-  console.log(JSON.stringify({ ok: found, overall, bug_count, report_path, round: args.round, status, reason, dimensions }));
-  process.exit(found ? 0 : 1);
-}

package/kernel/probe/hunt.mjs

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-// probe hunt — "did the QA hunt hunt anything?"
-//
-// CONTRACT. A bounded, read-only query over the hunt's WorkResult, its order and its report.
-// Prints `{ok, status, qa, charters_run, findings, reason}` on stdout; exits 0 when the hunt's
-// result is one the run may accept, 1 when it is not, and 2 on a bad argv. Writes nothing.
-//
-// WHY THIS EXISTS. A hunter that reached the app, swept the fault log and then drafted no charter
-// still returned `done`, and a `done` with no findings reads as an app with nothing wrong. The hunt
-// report's charter count says what actually happened. A `done` hunt over an app its order could
-// reach, with no charter run, is refused here and on ingest, and the run sends the hunter back once
-// — the same shape as a verdict that grades nothing by name.
-
-import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { runArgs } from "../lib/argv.mjs";
-import { resultsDir, ordersDir, qaDir } from "../lib/paths.mjs";
-
-/**
- * The number of charters a hunt report says it ran.
- *
- * @param {(string|null)} text - The hunt report's text.
- * @returns {(number|null)} The run count from its `charters: <run>/<approved>` line, or null when
- *   there is no report or no such line.
- */
-export function chartersRun(text) {
-  const m = String(text ?? "").match(/^charters:\s*(\d+)/m);
-  return m ? Number(m[1]) : null;
-}
-
-/**
- * Whether a hunt result may be accepted as it stands.
- *
- * Held to it only when the result says `done` and the order gave the hunter a way into the app
- * (`launch_cmd` or `app_url`): a hunt that returns `failed` says it could not hunt, which is honest,
- * and a hunt with no way in cannot be asked to drive anything.
- *
- * @param {object} result - The hunt WorkResult.
- * @param {object} payload - The hunt order's payload.
- * @param {(string|null)} report - The hunt report's text, or null.
- * @returns {(string|null)} A reason phrased for the hunter, or null.
- */
-export function huntProblem(result, payload, report) {
-  if (result?.status !== "done") return null;
-  if (!payload?.launch_cmd && !payload?.app_url) return null;
-  const n = chartersRun(report);
-  if (n === null) return "the hunt returned done with no hunt report carrying a `charters:` line";
-  if (n > 0) return null;
-  return "the hunt returned done over an app its order could reach, having run 0 charters — " +
-    "draft at least one charter where the EVAL left territory uncovered and hunt it, or return failed saying why the app could not be driven";
-}
-
-/**
- * Read a JSON file, or null.
- * @param {string} p - Path.
- * @returns {(object|null)} The parsed document, or null when absent or unreadable.
- */
-const readJson = (p) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return null; } };
-
-/**
- * What the hunt on disk amounts to.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @returns {{ok:boolean, status:(string|null), qa:string, charters_run:(number|null), findings:number, reason:(string|null)}}
- *   `qa` is `run` (charters ran), `not-hunted` (the hunt returned, no charter ran), or `missing`.
- */
-export function huntOutcome(cwd, slug) {
-  const result = readJson(join(resultsDir(cwd, slug), "hunt.json"));
-  if (!result) return { ok: false, status: null, qa: "missing", charters_run: null, findings: 0, reason: "no hunt result on disk" };
-  const payload = readJson(join(ordersDir(cwd, slug), "hunt.json"))?.payload || {};
-  const reportPath = join(qaDir(cwd, slug), "hunt-report.md");
-  const report = existsSync(reportPath) ? readFileSync(reportPath, "utf8") : null;
-  const n = chartersRun(report);
-  const reason = huntProblem(result, payload, report);
-  return {
-    ok: !reason,
-    status: typeof result.status === "string" ? result.status : null,
-    qa: n ? "run" : "not-hunted",
-    charters_run: n,
-    findings: Array.isArray(result.discoveries) ? result.discoveries.length : 0,
-    reason,
-  };
-}
-
-export const ARGV_SPEC = {
-  usage: "harness.mjs probe hunt --slug <slug> [--cwd <dir>]",
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  slug: { type: "str", required: true },
-  cwd: { type: "path" },
-};
-
-/**
- * Report what the hunt on disk amounts to.
- *
- * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
- * @returns {void} Exits 0 when the hunt result may be accepted, 1 when it may not.
- */
-export function cli(rawArgv) {
-  const args = runArgs(ARGV_SPEC, rawArgv);
-  const out = huntOutcome(resolve(args.cwd || process.cwd()), args.slug);
-  console.log(JSON.stringify(out));
-  process.exit(out.ok ? 0 : 1);
-}