shapeup-sdlc 3.18.2 → 4.0.0

package/kernel/probe/t0.mjs

@@ -1,115 +0,0 @@
-// probe t0 — "has this scope already reached T0-green in this round?"
-//
-// CONTRACT. A bounded, read-only query over the verdict artifacts on disk. Prints
-// `{green, path, sha256?, round, scope_id}` on stdout; exits 0 when green, 1 when not, 2 on a bad
-// argv. Writes nothing.
-//
-// WHY IT PRINTS A DIGEST. A verdict on a scoped spec must cite a T0 artifact with the sha256 of the
-// file as it is on disk now, and the judge is asked to obtain that itself rather than accept one it
-// was handed. Some sessions have no shell hasher they may run, and a grant that covers this entry
-// point and not `shasum` is the ordinary case, not an oversight. The digest here is computed from
-// the bytes at the moment of the call, with the same reading the ingest step re-checks it against,
-// so a judge that asks for it is asking the file, not a caller. `sha256` is present only when the
-// verdict is green and readable; absent — never null — otherwise.
-//
-// WHY IT IS A SUBCOMMAND AND NOT AN INLINE SNIPPET. The control plane has no filesystem of its
-// own, so the alternative is a `node -e` blob assembled inside the workflow script. Such a blob is
-// untestable (a workflow script cannot be imported), and it is the one command shape no permission
-// rule can match — the grant covers this entry point, not arbitrary evaluated source.
-//
-// WHY IT READS ARTIFACTS AND NOT A LEDGER. It answers the question a RESUMED round asks: an
-// attempt loop that was killed mid-round must not re-do a scope whose T0 already went green, and
-// the only durable evidence of that is the verdict artifact the evaluator is required to cite.
-
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { join, resolve } from "node:path";
-import { runArgs } from "../lib/argv.mjs";
-import { verdictsDir, readRunId } from "../lib/paths.mjs";
-
-/**
- * Verdict filenames, newest first by their NUMERIC address.
- *
- * A string sort files `r1-a1-t10.json` before `r1-a1-t9.json`, and the trial ordinal is shared by
- * every scope verified at one (round, attempt) — ten scopes on their first attempt are enough to
- * make an older verdict read as the newest. Names that carry no address sort last.
- *
- * @param {string[]} names - Filenames from the verdicts directory.
- * @returns {string[]} A new array, newest first: round, then attempt, then trial, descending.
- */
-export function newestFirst(names) {
-  const key = (f) => {
-    const m = f.match(/^r(\d+)-a(\d+)(?:-t(\d+))?\.json$/);
-    return m ? [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)] : [-1, -1, -1];
-  };
-  return [...names].sort((a, b) => {
-    const ka = key(a), kb = key(b);
-    for (let i = 0; i < 3; i++) if (ka[i] !== kb[i]) return kb[i] - ka[i];
-    return b.localeCompare(a);
-  });
-}
-
-/**
- * The newest green T0 verdict for one scope in one round.
- *
- * @param {string} cwd - Project root.
- * @param {string} slug - Feature slug.
- * @param {string} scopeId - Scope contract id.
- * @param {number} [round] - Build round. Omitted, the newest green verdict of ANY round — what an
- *   evaluation with no round (a standalone single pass) has to cite.
- * @returns {{green: boolean, path: (string|null)}} `path` is the artifact a later EVAL can cite.
- */
-export function greenVerdict(cwd, slug, scopeId, round) {
-  const dir = verdictsDir(cwd, slug);
-  if (!existsSync(dir)) return { green: false, path: null };
-  // Newest first: an attempt retried after a red one writes a higher trial ordinal at the same
-  // (round, attempt) address, and the LAST verdict is the one that stands.
-  // THIS RUN'S VERDICTS. Verdicts over one slug accumulate across runs and carry the run's key; a
-  // second run used to be told its scope was green on the first run's artifact, and the round loop
-  // skipped building it. A verdict with no key at all predates the key and is kept.
-  const runId = readRunId(cwd, slug);
-  for (const f of newestFirst(readdirSync(dir).filter((x) => x.endsWith(".json")))) {
-    const p = join(dir, f);
-    try {
-      const b = JSON.parse(readFileSync(p, "utf8"));
-      if (runId && b.run_id && b.run_id !== runId) continue;
-      if (b.scope_id === scopeId && (round == null || b.round === round) && b.overall === "green") return { green: true, path: p };
-    } catch { /* a torn artifact proves nothing; keep looking */ }
-  }
-  return { green: false, path: null };
-}
-
-export const ARGV_SPEC = {
-  usage: "harness.mjs probe t0 --slug <slug> --scope <scope-id> --round N [--cwd <dir>]",
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  slug: { type: "str", required: true },
-  scope: { type: "str", required: true },
-  round: { type: "int", min: 1, required: true },
-  cwd: { type: "path" },
-};
-
-/**
- * Report whether one scope is already T0-green for one round.
- *
- * @param {string[]} rawArgv - The subcommand's own arguments (harness.mjs strips the verb words).
- * @returns {void} Exits 0 when green, 1 when not — the shape a caller can branch on without parsing.
- */
-export function cli(rawArgv) {
-  const args = runArgs(ARGV_SPEC, rawArgv);
-  const cwd = resolve(args.cwd || process.cwd());
-  const { green, path } = greenVerdict(cwd, args.slug, args.scope, args.round);
-  const sha256 = green ? digestOf(path) : null;
-  console.log(JSON.stringify({ green, path, ...(sha256 ? { sha256 } : {}), scope_id: args.scope, round: args.round }));
-  process.exit(green ? 0 : 1);
-}
-
-/**
- * The sha256 of a verdict artifact, read as `reduce ingest` re-reads it (utf8 text, then hashed) so
- * the two can never disagree about the same bytes.
- * @param {string} path - Absolute path of the verdict file.
- * @returns {(string|null)} Lowercase hex digest, or null when the file cannot be read.
- */
-function digestOf(path) {
-  try { return createHash("sha256").update(readFileSync(path, "utf8")).digest("hex"); }
-  catch { return null; }
-}

package/kernel/reduce/board.mjs

@@ -1,350 +0,0 @@
-#!/usr/bin/env node
-// Board derivation — the planner's graph math, as code a model never re-derives.
-//
-// The mechanical half of the old ba-pitch-analyzer Phase 7b + v3.3 link-field rules — pure
-// graph math a model should never re-derive (and gets wrong: hand-authored inverses drift asymmetric
-// edges came from hand-authored `unlocks`):
-//
-//   • `unlocks` = the depends_on inverse, recomputed over the WHOLE board (--write persists
-//     it into task frontmatter — run on every ingest; asymmetric edges become impossible)
-//   • Σ estimated_hours, package distribution, critical path (longest depends_on chain)
-//   • Appetite Guard arithmetic (--appetite-hours N → overflow flag; the HAMMER *pause* on
-//     overflow is an orchestrator gate, never resolved here)
-//   • board-vs-T0 drift check (a FINISHED scope whose tasks still read `ready`) when scope
-//     contracts anchor use cases the board's tasks name back — flag, never fix
-//   • board-vs-dispatch reconciliation (BOARD-UNDISPATCHED, Phase 3.5 / S6): a scope with a
-//     done-marked task but no dispatched-and-answered order anywhere for it — a cut, never
-//     dispatched scope cannot read `done` — flag, never fix
-//
-// Zero dependencies. Usage:
-//   node kernel/harness.mjs reduce board --slug <slug> [--cwd <dir>] [--write]
-//        [--appetite-hours N]
-// Prints a JSON report; exit 0 (drift/overflow are flags for the caller's gate, not errors).
-
-import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
-import { resolve, join } from "node:path";
-import { runArgs } from "../lib/argv.mjs";
-import { tasksDir, scopesDir, hillDir, ordersDir, resultsDir } from "../lib/paths.mjs";
-import { readAllContracts, splitFrontmatter, tasksForScope, SCOPE_CONTRACT } from "../lib/contract.mjs";
-
-/**
- * Read a list field from a frontmatter string, inline `[a, b]` or YAML block sequence alike.
- *
- * The SECOND instance of the same defect, in a second parser. This repo had two hand-rolled
- * frontmatter readers: `lib/contract.mjs` for the committed contracts, and this one for the board.
- * It was fixed in the first, and this one still silently dropped a block sequence — so a board
- * written as
- *   use_case_refs:
- *     - UC-01
- *   touched_files:
- *     - src/review/format.js
- * lost EVERY list field. Measured on three paid `ba-pitch-analyzer` runs: `touched_files` and
- * `use_case_refs` came back empty for all twenty tasks, `depends_on`/`unlocks` came back empty in
- * both directions so edge-symmetry passed VACUOUSLY, and the only reason it was not entirely silent
- * is that UC-ANCHOR went red. Downstream, `scope-architect` receives a board with no slicing input
- * at all.
- *
- * The fix is to stop having two parsers rather than to patch this one: `splitFrontmatter` already
- * reads both forms, so this delegates to it. A second implementation of a format is a second
- * format, and these two had already drifted.
- *
- * @param {string} fm - The frontmatter text (without the `---` fences).
- * @param {string} key - The list key to read.
- * @returns {string[]} The trimmed, unquoted, non-empty members; [] when the key is absent.
- */
-const listField = (fm, key) => {
-  const v = splitFrontmatter(`---\n${fm}\n---\n`).meta[key];
-  if (Array.isArray(v)) return v.map((x) => String(x).trim()).filter(Boolean);
-  if (v === null || v === undefined || v === "") return [];
-  return [String(v).trim()].filter(Boolean);
-};
-
-/**
- * Parse every TASK-*.md in a board directory into structured task records.
- * @param {string} tasksDir - Absolute path to the LOCAL tasks directory.
- * @returns {Array<{file:string, id:string, type:string, status:string, hours:number, pkg:string,
- *   depends_on:string[], unlocks:string[], use_case_refs:string[], scope_id:string, body:string}>} One record per
- *   task file; [] when the directory does not exist.
- */
-export function parseBoard(tasksDir) {
-  if (!existsSync(tasksDir)) return [];
-  // SORTED, because `criticalPath` breaks ties on strict `>` and therefore keeps the FIRST chain it
-  // meets among equal-hours chains. Directory order is a filesystem detail (APFS happens to return
-  // sorted; ext4's hash order does not, and neither does a rename), so an unsorted read made a
-  // derived value depend on which machine ran it. Every sibling reader in the kernel already sorts.
-  return readdirSync(tasksDir).sort()
-    .filter((f) => /^TASK-[\w.-]+\.md$/i.test(f))
-    .map((f) => {
-      const body = readFileSync(join(tasksDir, f), "utf8");
-      const fm = (body.match(/^---\r?\n([\s\S]*?)\r?\n---/) || [, ""])[1];
-      return {
-        file: join(tasksDir, f),
-        id: (fm.match(/^id:\s*(TASK-[\w.-]+)/im) || [])[1] || f.replace(/\.md$/, ""),
-        type: (fm.match(/^type:\s*(\S+)/im) || [, ""])[1],
-        status: (fm.match(/^status:\s*(\S+)/im) || [, "unknown"])[1],
-        hours: Number((fm.match(/^estimated_hours:\s*([\d.]+)/im) || [])[1]) || 0,
-        pkg: (fm.match(/^package:\s*(.+)$/im) || [, ""])[1].trim(),
-        depends_on: listField(fm, "depends_on"),
-        unlocks: listField(fm, "unlocks"),
-        use_case_refs: listField(fm, "use_case_refs"),
-        scope_id: (fm.match(/^scope_id:\s*(\S+)/im) || [, ""])[1].trim(),
-        body,
-      };
-    });
-}
-
-/**
- * Compute `unlocks` as the inverse of `depends_on` over the whole board (never hand-authored).
- * @param {Array<{id:string, depends_on:string[]}>} tasks - The parsed board.
- * @returns {Object<string,string[]>} Map of task id → sorted ids it unlocks.
- */
-export function deriveUnlocks(tasks) {
-  const unlocks = Object.fromEntries(tasks.map((t) => [t.id, []]));
-  for (const t of tasks) for (const dep of t.depends_on) if (unlocks[dep]) unlocks[dep].push(t.id);
-  for (const id of Object.keys(unlocks)) unlocks[id].sort();
-  return unlocks;
-}
-
-/**
- * Find the critical path: the depends_on chain with the greatest summed hours.
- * @param {Array<{id:string, depends_on:string[], hours:number}>} tasks - The parsed board.
- * @returns {{hours:number, chain:string[]}} The longest chain's total hours and its task ids in
- *   dependency order (cycles are guarded and contribute nothing).
- */
-export function criticalPath(tasks) {
-  const byId = Object.fromEntries(tasks.map((t) => [t.id, t]));
-  const memo = {};
-  /**
-   * Longest depends_on chain rooted at a task, by summed hours (memoized, cycle-guarded).
-   * @param {string} id - Task id to start from.
-   * @param {Set<string>} [seen=new Set()] - Ids on the current DFS path (cycle guard); callers omit it.
-   * @returns {{hours:number, chain:string[]}} The heaviest chain's total hours and its task ids in
-   *   dependency order; {hours:0, chain:[]} for an unknown id or a detected cycle.
-   */
-  const longest = (id, seen = new Set()) => {
-    if (memo[id]) return memo[id];
-    if (seen.has(id)) return { hours: 0, chain: [] }; // cycle guard — lint reports it separately
-    seen.add(id);
-    const t = byId[id];
-    if (!t) return { hours: 0, chain: [] };
-    let best = { hours: 0, chain: [] };
-    for (const dep of t.depends_on) {
-      const c = longest(dep, seen);
-      if (c.hours > best.hours) best = c;
-    }
-    return (memo[id] = { hours: best.hours + t.hours, chain: [...best.chain, id] });
-  };
-  // TIES BREAK ON CONTENT, NOT ON ARRIVAL. `>` alone keeps whichever equal-hours chain is MET
-  // FIRST, which is input order — so this function returned a different critical path for the same
-  // board depending only on how its task list happened to be ordered. Measured: two disjoint
-  // 5-hour chains, five permutations of one list, two different answers.
-  //
-  // Sorting the reader that feeds it (`parseBoard`) makes the input stable and therefore hides this
-  // on any one machine, but it leaves the ORDER-DEPENDENCE in place one call up — a caller with its
-  // own ordering, or a future second reader, re-opens it. A derived value has to be a function of
-  // the board, not of the walk that produced it, so the tie is resolved here: same hours, then the
-  // lexicographically smaller chain. Deterministic on every machine and for every caller.
-  /**
-   * Is chain `c` a better critical path than the incumbent `b`?
-   * @param {{hours:number, chain:string[]}} c - The candidate chain.
-   * @param {{hours:number, chain:string[]}} b - The incumbent best.
-   * @returns {boolean} True when `c` has more hours, or ties on hours and sorts first by chain
-   *   content — so the answer is a function of the board rather than of the iteration order.
-   */
-  const better = (c, b) => c.hours > b.hours
-    || (c.hours === b.hours && c.chain.length > 0
-        && (b.chain.length === 0 || c.chain.join("\u0000") < b.chain.join("\u0000")));
-  let best = { hours: 0, chain: [] };
-  for (const t of tasks) {
-    const c = longest(t.id);
-    if (better(c, best)) best = c;
-  }
-  return best;
-}
-
-/**
- * Flag board-vs-T0 drift: FINISHED scopes whose tasks are not yet done (flag only, never fix).
- *
- * The scope's tasks are joined through its committed `use_cases`, not read off a task-id list the
- * contract used to carry — see {@link tasksForScope}. A scope that anchors no use case contributes
- * nothing here rather than a false clean bill: "no anchor" is SCOPE-ANCHOR's finding to report.
- *
- * @param {Array<{id:string, status:string, use_case_refs?:string[]}>} tasks - The parsed board.
- * @param {Array<{scope_id:string, use_cases?:string[], finished?:boolean}>} scopes - Scope facts.
- * @returns {Array<{scope_id:string, task_id:string, status:string}>} One entry per drifting task; [] when none.
- */
-export function driftCheck(tasks, scopes) {
-  const drift = [];
-  for (const s of scopes) {
-    if (!s.finished) continue;
-    for (const t of tasksForScope(tasks, s)) {
-      if (t.status !== "done") drift.push({ scope_id: s.scope_id, task_id: t.id, status: t.status });
-    }
-  }
-  return drift;
-}
-
-/**
- * Read every dispatched-and-answered order's scope id (Phase 3.5 / S6).
- *
- * "Dispatched and answered" is filename presence in both directories, the same completion signal
- * `sandbox-guard`'s `liveOrders()` already uses — a result join on content would let a malformed
- * result count as an answer. The scope an order belongs to comes from `payload.scope_contract.
- * scope_id`, not the filename: a non-BUILD order's suffix puts the operation before the scope id
- * (`compileOrder`'s `scopedRoundSuffix`), so filename-prefix matching would miss it.
- *
- * @param {string} orders - Absolute path to the run's `orders/` directory.
- * @param {string} results - Absolute path to the run's `results/` directory.
- * @returns {Set<string>} scope_ids with at least one dispatched order answered by a same-named
- *   result file; empty when neither directory has anything to read.
- */
-function answeredScopeIds(orders, results) {
-  const answered = new Set();
-  if (!existsSync(orders)) return answered;
-  const done = new Set(existsSync(results) ? readdirSync(results) : []);
-  for (const f of readdirSync(orders)) {
-    if (!f.endsWith(".json") || !done.has(f)) continue;
-    try {
-      const sid = JSON.parse(readFileSync(join(orders, f), "utf8"))?.payload?.scope_contract?.scope_id;
-      if (sid) answered.add(sid);
-    } catch { /* an unreadable order answers nothing — spec-lint reports unreadable contracts, not this */ }
-  }
-  return answered;
-}
-
-/**
- * Flag a scope whose board tasks read done but has no dispatched-and-answered order on disk
- * (Phase 3.5 / S6) — the defect that motivated this phase: a scope cut before it was ever
- * dispatched can still read `done` on the board because nothing compared the board's rows to what
- * was actually dispatched, though both the scope contract and the order/result trail already exist
- * on disk. A sibling to {@link driftCheck} (a FINISHED scope whose tasks are NOT done) — this is
- * the opposite direction (done tasks, no dispatch trail) and both must keep running.
- *
- * @param {Array<{id:string, status:string, use_case_refs?:string[]}>} tasks - The parsed board.
- * @param {Array<{scope_id:string, use_cases?:string[]}>} scopes - Scope contracts.
- * @param {string} orders - Absolute path to the run's `orders/` directory.
- * @param {string} results - Absolute path to the run's `results/` directory.
- * @returns {Array<{rule:string, level:string, scope_id:string, detail:string}>} One finding per
- *   undispatched-but-done scope, in this codebase's `{rule, level, detail}` finding shape
- *   (`kernel/verify/spec.mjs`); [] when every done-marked scope has a dispatch trail.
- */
-export function undispatchedCheck(tasks, scopes, orders, results) {
-  const answered = answeredScopeIds(orders, results);
-  const findings = [];
-  for (const s of scopes) {
-    // Joined through the contract's committed `use_cases`, same as driftCheck — the two read the
-    // scope↔task relation from one function so they cannot disagree about which tasks a scope owns.
-    const doneTaskId = tasksForScope(tasks, s).find((t) => t.status === "done")?.id;
-    if (doneTaskId && !answered.has(s.scope_id)) {
-      findings.push({
-        rule: "BOARD-UNDISPATCHED", level: "red", scope_id: s.scope_id,
-        detail: `${doneTaskId} reads done for scope ${s.scope_id}, but no order under orders/ has a ` +
-          `matching result under results/ for this scope — a cut, never-dispatched scope cannot read done`,
-      });
-    }
-  }
-  return findings;
-}
-
-/**
- * Derive the full board report (unlocks, hours, packages, critical path, appetite overflow, drift).
- * @param {{cwd:string, slug:string, appetiteHours?:(number|null)}} opts - Working root, feature
- *   slug, and optional appetite budget (in hours) that drives the overflow flag.
- * @returns {object} The report: task_count, by_status, packages, total/keep hours, appetite
- *   overflow (or null), critical_path, unlocks + unlocks_stale, drift[], and `_tasks` (the parsed
- *   board, deleted before CLI output).
- */
-export function derive({ cwd, slug, appetiteHours = null }) {
-  const boardDir = tasksDir(cwd, slug);
-  const tasks = parseBoard(boardDir);
-  const unlocks = deriveUnlocks(tasks);
-  const keepHours = tasks.filter((t) => t.status !== "cut").reduce((a, t) => a + t.hours, 0);
-  const packages = {};
-  for (const t of tasks) packages[t.pkg || "(none)"] = (packages[t.pkg || "(none)"] || 0) + 1;
-
-  // Scope facts for the drift check: the contract (its `use_cases` carry the task join)
-  // + the committed hill shard's phase.
-  const hillRoot = hillDir(cwd, slug);
-  const scopes = readAllContracts(scopesDir(cwd, slug), SCOPE_CONTRACT).map(({ contract }) => {
-    const shard = join(hillRoot, `${contract.scope_id}.yml`);
-    const finished = existsSync(shard) && /phase:\s*FINISHED/.test(readFileSync(shard, "utf8"));
-    return { ...contract, finished };
-  });
-
-  return {
-    slug,
-    task_count: tasks.length,
-    by_status: tasks.reduce((m, t) => ((m[t.status] = (m[t.status] || 0) + 1), m), {}),
-    packages,
-    total_hours: tasks.reduce((a, t) => a + t.hours, 0),
-    keep_hours: keepHours,
-    appetite: appetiteHours === null ? null : {
-      appetite_hours: appetiteHours,
-      overflow: keepHours > appetiteHours,
-      overflow_hours: Math.max(0, keepHours - appetiteHours),
-    },
-    critical_path: criticalPath(tasks),
-    unlocks,
-    unlocks_stale: tasks.filter((t) => JSON.stringify([...t.unlocks].sort()) !== JSON.stringify(unlocks[t.id])).map((t) => t.id),
-    drift: driftCheck(tasks, scopes),
-    undispatched: undispatchedCheck(tasks, scopes, ordersDir(cwd, slug), resultsDir(cwd, slug)),
-    _tasks: tasks,
-  };
-}
-
-/**
- * Persist derived `unlocks` into task frontmatter — and give a task with NO status the one status a
- * task on a freshly written board can have.
- *
- * `unlocks` is derived, so writing it is safe by construction. `status: todo` is the other field a
- * board is written with, and it is added only where the line is absent — an existing status is never
- * touched, so a task in progress or done is never reset. A regenerated board once came back with
- * `depends_on` and neither field on every task; spec-lint failed all of them at L1b and an unattended
- * run had nobody to add a line the worker's own template already prescribes.
- *
- * @param {{_tasks:Array<object>, unlocks:Object<string,string[]>}} report - A {@link derive} report.
- * @returns {string[]} The ids of task files actually rewritten (unchanged files are skipped).
- *   Side effect: writes those task files.
- */
-export function writeUnlocks(report) {
-  const written = [];
-  for (const t of report._tasks) {
-    const want = `[${report.unlocks[t.id].join(", ")}]`;
-    const fmMatch = t.body.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!fmMatch) continue;
-    const fm = fmMatch[1];
-    let next = /^unlocks:.*$/m.test(fm) ? fm.replace(/^unlocks:.*$/m, `unlocks: ${want}`) : `${fm}\nunlocks: ${want}`;
-    if (!/^status:/m.test(next)) next = `${next}\nstatus: todo`;
-    if (next !== fm) {
-      writeFileSync(t.file, t.body.replace(fm, next));
-      written.push(t.id);
-    }
-  }
-  return written;
-}
-
-/** The typed argv contract (see `kernel/lib/argv.mjs`). */
-export const ARGV_SPEC = {
-  usage: "harness.mjs reduce board --slug <slug> [--cwd <dir>] [--write] [--appetite-hours N]",
-  _: { arity: 0, max: 0, name: "(no positional operands)" },
-  slug: { type: "str", required: true },
-  cwd: { type: "path" },
-  write: { type: "flag" },
-  "appetite-hours": { type: "num", min: 0 },
-};
-
-/**
- * Derive the task board from the scope contracts, and optionally write it.
- *
- * @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
- *   call `process.exit()` with the subcommand's documented code rather than returning.
- */
-export async function cli(rawArgv) {
-  const args = runArgs(ARGV_SPEC, rawArgv);
-  const cwd = resolve(args.cwd || process.cwd());
-  const report = derive({ cwd, slug: args.slug, appetiteHours: args.appetiteHours ?? null });
-  if (args.write) report.unlocks_written = writeUnlocks(report);
-  delete report._tasks;
-  console.log(JSON.stringify(report, null, 2));
-}