cool-workflow 0.1.82 → 0.1.83

package/apps/pr-review-fix-ci/app.json

@@ -3,7 +3,7 @@
   "id": "pr-review-fix-ci",
   "title": "PR Review Fix CI",
   "summary": "Review a pull request or branch, inspect CI failures, diagnose actionable issues, optionally patch, verify, and summarize with evidence.",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/release-cut/app.json

@@ -3,7 +3,7 @@
   "id": "release-cut",
   "title": "Release Cut",
   "summary": "Prepare a release with checklist discipline: version checks, changelog, tests, packaging, release notes, and final verification.",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/apps/research-synthesis/app.json

@@ -3,7 +3,7 @@
   "id": "research-synthesis",
   "title": "Research Synthesis",
   "summary": "Split a research question into claims, investigate sources, cross-check evidence, verify claims, and synthesize a concise answer.",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "author": "COOLWHITE LLC",
   "inputs": [
     {

package/dist/capability-core.js

@@ -333,13 +333,12 @@ function queueShow(reg, id) {
 // ---- control-plane scheduling (v0.1.37) -----------------------------------
 function loadSchedulingPolicy(reg) {
     const file = reg.schedulingPolicyPath();
+    // Absent policy => conservative DEFAULT (an unconfigured backend, which §4
+    // permits). But a PRESENT-but-corrupt policy must fail closed: silently
+    // substituting defaults would schedule under settings the operator never
+    // chose while their broken file sits on disk. Let readJson's throw surface it.
     if (node_fs_1.default.existsSync(file)) {
-        try {
-            return { policy: (0, scheduling_1.normalizeSchedulingPolicy)((0, state_1.readJson)(file)), source: "file" };
-        }
-        catch {
-            /* fall through to default */
-        }
+        return { policy: (0, scheduling_1.normalizeSchedulingPolicy)((0, state_1.readJson)(file)), source: "file" };
     }
     return { policy: scheduling_1.DEFAULT_SCHEDULING_POLICY, source: "default" };
 }
@@ -400,8 +399,17 @@ function schedPolicySet(reg, args) {
     const current = loadSchedulingPolicy(reg).policy;
     const patch = {};
     for (const key of ["maxConcurrent", "maxAttempts", "leaseTtlMs", "backoffBaseMs", "backoffFactor", "backoffCapMs"]) {
-        if (args[key] !== undefined)
-            patch[key] = Number(args[key]);
+        if (args[key] === undefined)
+            continue;
+        // Fail closed on a non-numeric flag instead of letting normalizeSchedulingPolicy
+        // silently substitute the DEFAULT (which would report source:"file" + exit 0,
+        // so the operator believes they set a value they didn't). Matches the
+        // Number.isFinite guard the sibling reclaimPolicyFrom already uses.
+        const value = Number(args[key]);
+        if (!Number.isFinite(value)) {
+            throw new Error(`Invalid --${key} "${String(args[key])}": expected a number (e.g. --${key} 4)`);
+        }
+        patch[key] = value;
     }
     const policy = (0, scheduling_1.normalizeSchedulingPolicy)({ ...current, ...patch });
     (0, state_1.writeJson)(reg.schedulingPolicyPath(), policy);

package/dist/capability-registry.js

@@ -52,6 +52,14 @@ const BUILTIN_CAPABILITIES = [
         cli: { path: ["list"], jsonMode: "default" },
         mcp: { tool: "cw_list" }
     },
+    {
+        capability: "doctor",
+        summary: "Diagnose the host for setup problems (Node version, agent backend, agent binary on PATH, git, writable home/repo state) and print an actionable fix per check.",
+        entry: "runDoctor",
+        surface: "cli-only",
+        cli: { path: ["doctor"], jsonMode: "flag" },
+        reason: "Environment diagnostics are inherently local to the CLI host — Node version, $PATH, $CW_HOME/cwd writability. An MCP client diagnosing the server process's environment is not meaningful; agents already receive the same readiness facts in their typed results (e.g. status: blocked, agentConfigured). Inspired by `brew doctor`."
+    },
     {
         capability: "init",
         summary: "Scaffold a new workflow definition.",

package/dist/cli.js

@@ -21,6 +21,7 @@ const multi_agent_operator_ux_1 = require("./multi-agent-operator-ux");
 const multi_agent_eval_1 = require("./multi-agent-eval");
 const state_explosion_1 = require("./state-explosion");
 const evidence_reasoning_1 = require("./evidence-reasoning");
+const doctor_1 = require("./doctor");
 async function main() {
     const args = (0, orchestrator_1.parseArgv)(process.argv.slice(2));
     const runner = new orchestrator_1.CoolWorkflowRunner({
@@ -36,6 +37,16 @@ async function main() {
         case "list":
             printJson(runner.listWorkflows());
             return;
+        case "doctor": {
+            const report = (0, doctor_1.runDoctor)(args.options, process.env, String(args.options.cwd || process.cwd()));
+            if (wantsJson(args.options))
+                printJson(report);
+            else
+                process.stdout.write(`${(0, doctor_1.formatDoctorReport)(report)}\n`);
+            if (!report.ok)
+                process.exitCode = 1;
+            return;
+        }
         case "init": {
             const [workflowId] = args.positionals;
             if (!workflowId)
@@ -1281,7 +1292,7 @@ async function main() {
 }
 function required(value, label) {
     if (!value)
-        throw new Error(`Missing ${label}`);
+        throw new Error(`Missing ${label}. Run "cw.js help" for usage.`);
     return value;
 }
 function optionalArg(value) {

package/dist/commit.js

@@ -584,7 +584,11 @@ function readGitHead(cwd) {
         return (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd,
             encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"]
+            stdio: ["ignore", "pipe", "ignore"],
+            // Bound the call: a hung filesystem, a held .git/index.lock, or a
+            // credential-helper prompt must not block the commit path forever. A
+            // timeout throws, which the catch below maps to "no git head".
+            timeout: 5000
         }).trim();
     }
     catch {

package/dist/doctor.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+exports.formatDoctorReport = formatDoctorReport;
+// `cw doctor` — environment diagnostics, in the spirit of `brew doctor`.
+//
+// Homebrew's `doctor` turned "something is subtly wrong with your setup" into a
+// proactive, named list of problems each paired with a concrete fix. We borrow
+// that idea: instead of letting a missing agent / old Node / unwritable state
+// surface as a confusing mid-run failure, `cw doctor` probes the host up front
+// and prints WHAT is wrong and WHAT TO DO about it.
+//
+// Discipline:
+//  - READ-ONLY. Probes versions, $PATH, and the WRITABILITY of the nearest
+//    existing ancestor dir (via access(2)) — it never creates `.cw/` or $CW_HOME
+//    as a side effect, so running `doctor` changes nothing on disk.
+//  - FAIL CLOSED. Any `fail` check ⇒ `ok:false` ⇒ the CLI exits non-zero. A
+//    `warn` (e.g. no agent yet — demo/preview still work) does not fail.
+//  - TWO RENDERINGS. Human text by default; a stable `--json` payload for scripts.
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const agent_config_1 = require("./agent-config");
+/** Resolve a bare binary name against $PATH (or accept an explicit path). Returns
+ *  the resolved path, or undefined when not found. No spawning. */
+function whichBinary(bin, env) {
+    if (bin.includes("/") || bin.includes("\\")) {
+        try {
+            return node_fs_1.default.statSync(bin).isFile() ? bin : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const dirs = (env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean);
+    const exts = process.platform === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const candidate = node_path_1.default.join(dir, bin + ext);
+            try {
+                if (node_fs_1.default.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch { /* keep looking */ }
+        }
+    }
+    return undefined;
+}
+/** True when `target` could be created/written: walk up to the nearest EXISTING
+ *  ancestor and require it to be a writable DIRECTORY. (A file in the path is not
+ *  writable-as-a-dir even though access(2) W_OK on the file itself would pass.)
+ *  Does NOT create anything — a diagnostic must not have side effects. */
+function dirWritable(target) {
+    let dir = node_path_1.default.resolve(target);
+    for (;;) {
+        let stat;
+        try {
+            stat = node_fs_1.default.statSync(dir);
+        }
+        catch {
+            const parent = node_path_1.default.dirname(dir);
+            if (parent === dir)
+                return false;
+            dir = parent;
+            continue;
+        }
+        if (!stat.isDirectory())
+            return false; // an existing file blocks mkdir beneath it
+        try {
+            node_fs_1.default.accessSync(dir, node_fs_1.default.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
+    const checks = [];
+    // 1. Node runtime — the one hard prerequisite (README: v18+).
+    const major = Number((process.version.match(/^v(\d+)/) || [])[1]);
+    checks.push(Number.isFinite(major) && major >= 18
+        ? { name: "node", status: "ok", detail: `Node ${process.version} (>= 18).` }
+        : { name: "node", status: "fail", detail: `Node ${process.version} is below the required v18.`, fix: "Install Node.js 18+ (e.g. `brew install node`, or https://nodejs.org)." });
+    // 2. Agent backend — CW delegates execution; without one, real runs park.
+    const cfg = (0, agent_config_1.resolveAgentConfig)(args, env);
+    if (cfg.source === "none") {
+        checks.push({
+            name: "agent",
+            status: "warn",
+            detail: "No agent backend configured — `demo` and `--preview` work, but a real run reports status: blocked.",
+            fix: 'Pass --agent-command "claude -p", set $CW_AGENT_COMMAND, or use --agent-command builtin:claude.'
+        });
+    }
+    else {
+        const binToken = cfg.command ? String(cfg.command).split(/\s+/)[0] : undefined;
+        checks.push({
+            name: "agent",
+            status: "ok",
+            detail: `Agent configured from ${cfg.source}${binToken ? `: ${binToken}` : cfg.endpoint ? " (HTTP endpoint)" : ""}.`
+        });
+        // 2b. If it is a command agent, is the binary actually on PATH?
+        if (binToken) {
+            const resolved = whichBinary(binToken, env);
+            checks.push(resolved
+                ? { name: "agent-binary", status: "ok", detail: `Agent binary "${binToken}" found at ${resolved}.` }
+                : { name: "agent-binary", status: "warn", detail: `Configured agent binary "${binToken}" is not on $PATH.`, fix: `Install "${binToken}", or correct --agent-command / $CW_AGENT_COMMAND.` });
+        }
+    }
+    // 3. git — only needed for commit provenance (git HEAD); a warn, not a hard fail.
+    const git = (0, node_child_process_1.spawnSync)("git", ["--version"], { encoding: "utf8", timeout: 5000 });
+    checks.push(!git.error && git.status === 0
+        ? { name: "git", status: "ok", detail: (String(git.stdout || "git").trim()) + "." }
+        : { name: "git", status: "warn", detail: "git is not available — commit provenance (git HEAD) is recorded as absent.", fix: "Install git (e.g. `brew install git`) if you want commit provenance." });
+    // 4. Home registry — the cross-repo run index lives here; must be writable.
+    const home = env.CW_HOME && String(env.CW_HOME).trim()
+        ? node_path_1.default.resolve(String(env.CW_HOME))
+        : node_path_1.default.join(node_os_1.default.homedir(), ".local", "state", "cool-workflow");
+    checks.push(dirWritable(home)
+        ? { name: "home-registry", status: "ok", detail: `Home registry location is writable (${home}).` }
+        : { name: "home-registry", status: "fail", detail: `Home registry location is not writable: ${home}`, fix: "Set $CW_HOME to a writable directory, or fix the permissions." });
+    // 5. Working-dir state — per-repo runs land under <cwd>/.cw.
+    const cwState = node_path_1.default.join(node_path_1.default.resolve(cwd), ".cw");
+    checks.push(dirWritable(cwState)
+        ? { name: "repo-state", status: "ok", detail: `Run state location is writable (${cwState}).` }
+        : { name: "repo-state", status: "warn", detail: `Cannot write run state under ${cwState}.`, fix: "Run from a writable working directory, or pass --cwd PATH." });
+    const fails = checks.filter((c) => c.status === "fail").length;
+    const warns = checks.filter((c) => c.status === "warn").length;
+    const ok = fails === 0;
+    const summary = ok
+        ? warns === 0
+            ? "ready — all checks passed"
+            : `ready, with ${warns} warning${warns === 1 ? "" : "s"}`
+        : `${fails} blocking problem${fails === 1 ? "" : "s"} found`;
+    return { schemaVersion: 1, ok, checks, summary };
+}
+/** Human rendering (TTY/default). `--json` callers use the report object directly. */
+function formatDoctorReport(report) {
+    const glyph = { ok: "✓", warn: "!", fail: "✗" };
+    const lines = ["cw doctor"];
+    for (const check of report.checks) {
+        lines.push(`  ${glyph[check.status]} ${check.name}: ${check.detail}`);
+        if (check.fix && check.status !== "ok")
+            lines.push(`      fix: ${check.fix}`);
+    }
+    lines.push("");
+    lines.push(`${report.ok ? "✓" : "✗"} ${report.summary}`);
+    return lines.join("\n");
+}

package/dist/mcp-server.js

@@ -17,6 +17,11 @@ const runner = new orchestrator_1.CoolWorkflowRunner({
 });
 process.stdin.setEncoding("utf8");
 let buffer = "";
+// A single line-delimited JSON-RPC request is bounded; an un-terminated stream
+// (a peer that never sends a newline, or a slow byte dribble) must not grow the
+// long-lived server's buffer without limit until it OOMs. Cap the unconsumed
+// buffer and fail closed on a frame that exceeds it.
+const MAX_LINE_BYTES = 16 * 1024 * 1024;
 process.stdin.on("data", (chunk) => {
     buffer += chunk;
     let newlineIndex;
@@ -26,6 +31,12 @@ process.stdin.on("data", (chunk) => {
         if (line)
             handleLine(line);
     }
+    if (buffer.length > MAX_LINE_BYTES) {
+        // No newline in an over-cap buffer ⇒ a malformed or hostile frame. Reject it
+        // and drop the partial bytes rather than accumulate toward OOM.
+        buffer = "";
+        sendError(null, -32700, `Parse error: request line exceeds ${MAX_LINE_BYTES} bytes`);
+    }
 });
 function handleLine(line) {
     let message;

package/dist/orchestrator.js

@@ -821,6 +821,7 @@ function formatHelp() {
         "",
         "Commands:",
         "  list",
+        "  doctor [--json]   (check your setup: Node, agent backend, git, writable state)",
         "  init <workflow-id> [--title TEXT] [--output PATH]",
         "  quickstart [app-id] [--repo PATH] [--question TEXT] [--agent-command CMD] [--once] [--preview]",
         "  plan <workflow-id> [--repo PATH] [--question TEXT] [--invariant TEXT]",
@@ -873,6 +874,18 @@ function formatHelp() {
         "  run search|list|show|resume|archive|rerun|export|import|verify-import [run-id|archive] [--scope repo|home] [--json]",
         "  queue add|list|drain|show [queue-id] [--repo PATH] [--priority N]",
         "  history [--scope repo|home] [--app ID] [--status STATE] [--json]",
+        "  audit-run <app-id> [--repo PATH] [--question TEXT] [--agent-command CMD]",
+        "  metrics show|summary <run-id> [--scope repo|home] [--json]",
+        "  telemetry verify <run-id> [--pubkey PEM|PATH] [--json]",
+        "  gc plan|run|verify [run-id] [--json]",
+        "  sched plan|lease|release|complete|reclaim|reset|policy [--json]",
+        "  migration list|check|prove [target] [--json]",
+        "  operator status|report <run-id> [--json]",
+        "  review status|policy <run-id> [--json]",
+        "  approve|reject|comment <kind> <run-id> <target-id> [--reason TEXT]",
+        "  handoff <kind> <run-id> <target-id> [--to ROLE]",
+        "  loop --prompt TEXT [--interval-minutes N]",
+        "  demo tamper",
         "  workbench view <run-id> [--json]",
         "  workbench serve [--port N] [--scope repo|home] [--once|--json]",
         ""

package/dist/reclamation/hash.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256OfString = sha256OfString;
+exports.sha256OfFile = sha256OfFile;
+exports.dirBytes = dirBytes;
+exports.contentDigest = contentDigest;
+// Content addressing + byte measurement for run reclamation (NO `du` — in-process
+// only). Carved out of reclamation.ts (FreeBSD-audit god-module carve) so the pure
+// content-addressing leaf no longer sits inside the write-ahead reclamation
+// transaction. These are pure functions of their path/string inputs — no run
+// state, no module-level mutable state.
+//
+// BEHAVIOR-PRESERVING — pure code movement, zero logic change. reclamation.ts
+// re-exports the public symbols (sha256OfString/sha256OfFile/dirBytes) so the
+// module's surface stays byte-identical.
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const compare_1 = require("../compare");
+function sha256Hex(value) {
+    return node_crypto_1.default.createHash("sha256").update(value).digest("hex");
+}
+function sha256OfString(value) {
+    return `sha256:${sha256Hex(value)}`;
+}
+function sha256OfFile(file) {
+    return `sha256:${sha256Hex(node_fs_1.default.readFileSync(file))}`;
+}
+/** Walk a path and sum file sizes IN-PROCESS (no `du`). Returns 0 if absent. A
+ *  file returns its own size; a dir returns the recursive sum. */
+function dirBytes(p) {
+    let total = 0;
+    let stat;
+    try {
+        stat = node_fs_1.default.statSync(p);
+    }
+    catch {
+        return 0;
+    }
+    if (stat.isFile())
+        return stat.size;
+    if (!stat.isDirectory())
+        return 0;
+    for (const entry of node_fs_1.default.readdirSync(p, { withFileTypes: true })) {
+        total += dirBytes(node_path_1.default.join(p, entry.name));
+    }
+    return total;
+}
+/** Stable content digest of a path (file = its bytes; dir = digest over each
+ *  member's relative path + bytes, sorted). Lets the freed-manifest record a
+ *  single sha per freed dir. */
+function contentDigest(p) {
+    const stat = node_fs_1.default.statSync(p);
+    if (stat.isFile())
+        return sha256OfFile(p);
+    const parts = [];
+    const walk = (dir, rel) => {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => (0, compare_1.compareBytes)(a.name, b.name))) {
+            const abs = node_path_1.default.join(dir, entry.name);
+            const r = node_path_1.default.join(rel, entry.name);
+            if (entry.isDirectory())
+                walk(abs, r);
+            else
+                parts.push(`${r}:${sha256OfFile(abs)}`);
+        }
+    };
+    walk(p, "");
+    return sha256OfString(parts.join("\n"));
+}

package/dist/reclamation.js

@@ -29,10 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReclamationError = exports.ReclamationAbort = exports.SKELETON_REQUIRED_KEYS = void 0;
-exports.sha256OfString = sha256OfString;
-exports.sha256OfFile = sha256OfFile;
-exports.dirBytes = dirBytes;
+exports.dirBytes = exports.sha256OfFile = exports.sha256OfString = exports.ReclamationError = exports.ReclamationAbort = exports.SKELETON_REQUIRED_KEYS = void 0;
 exports.reclaimedLogPath = reclaimedLogPath;
 exports.loadReclamationLog = loadReclamationLog;
 exports.extractSkeleton = extractSkeleton;
@@ -49,9 +46,12 @@ exports.runReclamation = runReclamation;
 exports.reconstructArtifact = reconstructArtifact;
 exports.verifyReclamation = verifyReclamation;
 exports.dominantFailureCode = dominantFailureCode;
-const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const hash_1 = require("./reclamation/hash");
+Object.defineProperty(exports, "dirBytes", { enumerable: true, get: function () { return hash_1.dirBytes; } });
+Object.defineProperty(exports, "sha256OfFile", { enumerable: true, get: function () { return hash_1.sha256OfFile; } });
+Object.defineProperty(exports, "sha256OfString", { enumerable: true, get: function () { return hash_1.sha256OfString; } });
 const multi_agent_eval_1 = require("./multi-agent-eval");
 const node_projection_1 = require("./node-projection");
 const node_snapshot_1 = require("./node-snapshot");
@@ -95,59 +95,6 @@ class ReclamationError extends Error {
     }
 }
 exports.ReclamationError = ReclamationError;
-// ---------------------------------------------------------------------------
-// Content addressing + byte measurement (NO `du` — in-process only).
-// ---------------------------------------------------------------------------
-function sha256Hex(value) {
-    return node_crypto_1.default.createHash("sha256").update(value).digest("hex");
-}
-function sha256OfString(value) {
-    return `sha256:${sha256Hex(value)}`;
-}
-function sha256OfFile(file) {
-    return `sha256:${sha256Hex(node_fs_1.default.readFileSync(file))}`;
-}
-/** Walk a path and sum file sizes IN-PROCESS (no `du`). Returns 0 if absent. A
- *  file returns its own size; a dir returns the recursive sum. */
-function dirBytes(p) {
-    let total = 0;
-    let stat;
-    try {
-        stat = node_fs_1.default.statSync(p);
-    }
-    catch {
-        return 0;
-    }
-    if (stat.isFile())
-        return stat.size;
-    if (!stat.isDirectory())
-        return 0;
-    for (const entry of node_fs_1.default.readdirSync(p, { withFileTypes: true })) {
-        total += dirBytes(node_path_1.default.join(p, entry.name));
-    }
-    return total;
-}
-/** Stable content digest of a path (file = its bytes; dir = digest over each
- *  member's relative path + bytes, sorted). Lets the freed-manifest record a
- *  single sha per freed dir. */
-function contentDigest(p) {
-    const stat = node_fs_1.default.statSync(p);
-    if (stat.isFile())
-        return sha256OfFile(p);
-    const parts = [];
-    const walk = (dir, rel) => {
-        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => (0, compare_1.compareBytes)(a.name, b.name))) {
-            const abs = node_path_1.default.join(dir, entry.name);
-            const r = node_path_1.default.join(rel, entry.name);
-            if (entry.isDirectory())
-                walk(abs, r);
-            else
-                parts.push(`${r}:${sha256OfFile(abs)}`);
-        }
-    };
-    walk(p, "");
-    return sha256OfString(parts.join("\n"));
-}
 /** Persist a run's authoritative state.json DURABLY (atomic temp → fsync →
  *  rename). The re-point that scratch reclamation depends on MUST be persisted
  *  this way BEFORE any byte is freed — see prepareFree(). */
@@ -220,13 +167,13 @@ function digestEvidenceEntry(entry) {
         try {
             const stat = node_fs_1.default.statSync(candidatePath);
             if (stat.isFile())
-                return { ref, digest: sha256OfFile(candidatePath) };
+                return { ref, digest: (0, hash_1.sha256OfFile)(candidatePath) };
         }
         catch {
             /* fall through to locator digest */
         }
     }
-    return { ref, digest: sha256OfString(ref) };
+    return { ref, digest: (0, hash_1.sha256OfString)(ref) };
 }
 /** STEP 1: extract + seal the skeleton. Pure read over the run; never mutates. */
 function extractSkeleton(run) {
@@ -264,7 +211,7 @@ function extractSkeleton(run) {
         .map(([ref, digest]) => ({ ref, digest }))
         .sort((a, b) => (0, compare_1.compareBytes)(a.ref, b.ref));
     const eventLog = auditEventLogPath(run);
-    const auditLogDigest = node_fs_1.default.existsSync(eventLog) ? sha256OfFile(eventLog) : sha256OfString("");
+    const auditLogDigest = node_fs_1.default.existsSync(eventLog) ? (0, hash_1.sha256OfFile)(eventLog) : (0, hash_1.sha256OfString)("");
     const events = node_fs_1.default.existsSync(eventLog)
         ? node_fs_1.default
             .readFileSync(eventLog, "utf8")
@@ -284,18 +231,18 @@ function extractSkeleton(run) {
     const metricsReport = node_path_1.default.join(run.paths.runDir, "metrics", "metrics-report.json");
     const costRecord = {
         tasks: (run.tasks || []).map((task) => ({ taskId: task.id, model: task.usage?.model, source: task.usage?.source })),
-        metricsDigest: node_fs_1.default.existsSync(metricsReport) ? sha256OfFile(metricsReport) : undefined
+        metricsDigest: node_fs_1.default.existsSync(metricsReport) ? (0, hash_1.sha256OfFile)(metricsReport) : undefined
     };
     const collaboration = run.collaboration;
     const collaborationLog = {
-        digest: sha256OfString((0, multi_agent_eval_1.replayStableStringify)(collaboration || {})),
+        digest: (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)(collaboration || {})),
         approvals: collaboration?.approvals?.length || 0,
         comments: collaboration?.comments?.length || 0,
         handoffs: collaboration?.handoffs?.length || 0
     };
     // Empty (not a hash-of-empty) when state.json is absent, so the skeleton fails
     // closed — you cannot seal a run whose authoritative state is gone.
-    const stateDigest = node_fs_1.default.existsSync(run.paths.state) ? sha256OfFile(run.paths.state) : "";
+    const stateDigest = node_fs_1.default.existsSync(run.paths.state) ? (0, hash_1.sha256OfFile)(run.paths.state) : "";
     return {
         schemaVersion: 1,
         runId: run.id,
@@ -402,13 +349,13 @@ function buildReferenceGraph(run) {
  *  node-projection field set (node-projection.ts) so reconstruction matches
  *  node-snapshot.ts's body byte-for-byte — the projection can no longer drift. */
 function snapshotProjectionDigest(node) {
-    return sha256OfString((0, node_projection_1.nodeProjectionDigestInput)(node));
+    return (0, hash_1.sha256OfString)((0, node_projection_1.nodeProjectionDigestInput)(node));
 }
 /** Body digest of the RETAINED node (lives in state.json). The reconstruction
  *  verifier re-derives the projection from this retained input. Same shared field
  *  set / canonical bytes as snapshotProjectionDigest. */
 function nodeBodyDigest(node) {
-    return sha256OfString((0, node_projection_1.nodeProjectionDigestInput)(node));
+    return (0, hash_1.sha256OfString)((0, node_projection_1.nodeProjectionDigestInput)(node));
 }
 /** Build the retention plan: which paths are freeable under `policy`, of what
  *  kind, how many bytes, and the resulting capability downgrade. */
@@ -431,7 +378,7 @@ function planReclamation(run, policy = {}) {
             const resultsCopy = task?.resultPath;
             if (!resultNodeId || !resultsCopy || !node_fs_1.default.existsSync(resultsCopy))
                 continue;
-            const bytes = dirBytes(workerDir);
+            const bytes = (0, hash_1.dirBytes)(workerDir);
             if (bytes <= 0)
                 continue;
             freeable.push({
@@ -478,14 +425,14 @@ function planReclamation(run, policy = {}) {
                         continue; // source node gone → cannot reconstruct → retain
                     if (repointNodeIds.has(node.id))
                         continue; // body will be re-pointed → retain
-                    const bytes = dirBytes(snapFile);
+                    const bytes = (0, hash_1.dirBytes)(snapFile);
                     if (bytes <= 0)
                         continue;
                     const inputDigest = nodeBodyDigest(node);
                     const recipe = {
                         recipeKind: "node-snapshot-projection",
                         inputDigests: [inputDigest],
-                        inputsDigest: sha256OfString((0, multi_agent_eval_1.replayStableStringify)([inputDigest])),
+                        inputsDigest: (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)([inputDigest])),
                         expectDigest: snapshotProjectionDigest(node),
                         sourceRef: node.id
                     };
@@ -534,11 +481,11 @@ function planReclamation(run, policy = {}) {
     return { freeable, bytesToFree, byKind, capability, capabilityReason };
 }
 function policyDigestOf(policy) {
-    return sha256OfString((0, multi_agent_eval_1.replayStableStringify)(policy));
+    return (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)(policy));
 }
 /** genesis prevTombstoneHash = sha256 of the sealed skeleton. */
 function genesisPrevHash(skeleton) {
-    return sha256OfString((0, multi_agent_eval_1.replayStableStringify)(skeleton));
+    return (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)(skeleton));
 }
 /** The canonical bytes a tombstoneHash binds: freed-manifest + sealed skeleton +
  *  prevTombstoneHash + capability. Recomputed independently by `gc verify`. */
@@ -551,14 +498,14 @@ function tombstoneHashInput(t) {
         policyDigest: t.policyDigest,
         freed: t.freed.map((f) => ({ path: f.path, kind: f.kind, bytes: f.bytes, sha256: f.sha256, recipe: f.recipe || null })),
         bytesFreed: t.bytesFreed,
-        skeletonDigest: sha256OfString((0, multi_agent_eval_1.replayStableStringify)(t.skeleton)),
+        skeletonDigest: (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)(t.skeleton)),
         capability: t.capability,
         capabilityReason: t.capabilityReason,
         prevTombstoneHash: t.prevTombstoneHash
     });
 }
 function computeTombstoneHash(t) {
-    return sha256OfString(tombstoneHashInput(t));
+    return (0, hash_1.sha256OfString)(tombstoneHashInput(t));
 }
 function tombstoneId(seq) {
     // Deterministic (FreeBSD-audit L13): the chain POSITION, not a process-global
@@ -576,7 +523,7 @@ function buildTombstone(run, skeleton, plan, options = {}) {
         path: entry.path,
         kind: entry.kind,
         bytes: entry.bytes,
-        sha256: contentDigest(entry.absPath),
+        sha256: (0, hash_1.contentDigest)(entry.absPath),
         recipe: entry.recipe
     }));
     const base = {
@@ -685,7 +632,7 @@ function freeBulk(run, tombstone) {
     let freedBytes = 0;
     for (const entry of tombstone.freed) {
         const abs = node_path_1.default.join(runDir, entry.path);
-        const before = dirBytes(abs);
+        const before = (0, hash_1.dirBytes)(abs);
         node_fs_1.default.rmSync(abs, { recursive: true, force: true });
         freedBytes += before;
     }
@@ -774,15 +721,15 @@ function reconstructArtifact(run, recipe) {
     if (recipe.recipeKind === "node-snapshot-projection") {
         const node = (run.nodes || []).find((n) => n.id === recipe.sourceRef);
         if (!node) {
-            return { inputsDigest: sha256OfString("absent"), expectDigest: sha256OfString("absent") };
+            return { inputsDigest: (0, hash_1.sha256OfString)("absent"), expectDigest: (0, hash_1.sha256OfString)("absent") };
         }
         const inputDigest = nodeBodyDigest(node);
-        const inputsDigest = sha256OfString((0, multi_agent_eval_1.replayStableStringify)([inputDigest]));
+        const inputsDigest = (0, hash_1.sha256OfString)((0, multi_agent_eval_1.replayStableStringify)([inputDigest]));
         const expectDigest = snapshotProjectionDigest(node);
         return { inputsDigest, expectDigest };
     }
     // Unknown recipe kind → fail closed (digest can't match expectDigest).
-    return { inputsDigest: sha256OfString("unknown-recipe"), expectDigest: sha256OfString("unknown-recipe") };
+    return { inputsDigest: (0, hash_1.sha256OfString)("unknown-recipe"), expectDigest: (0, hash_1.sha256OfString)("unknown-recipe") };
 }
 /** Re-prove the whole reclamation chain for a run: skeleton schema-complete,
  *  tombstoneHash/prevTombstoneHash chain recomputed-and-untampered, and each