cool-workflow 0.1.81 → 0.1.83

package/dist/multi-agent-trust.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyForRole = policyForRole;
 exports.policyForGroup = policyForGroup;
@@ -16,7 +13,7 @@ exports.summarizeMultiAgentTrust = summarizeMultiAgentTrust;
 exports.hasAcceptedJudgeRationale = hasAcceptedJudgeRationale;
 exports.sourceForActor = sourceForActor;
 exports.hashText = hashText;
-const node_crypto_1 = __importDefault(require("node:crypto"));
+const execution_backend_1 = require("./execution-backend");
 const trust_audit_1 = require("./trust-audit");
 function policyForRole(role) {
     const topologyRole = String(role.metadata?.topologyRoleId || role.title || "").toLowerCase();
@@ -294,8 +291,11 @@ function sourceForActor(actor) {
         return "runtime-derived";
     return "cw-validated";
 }
+// Delegates to the shared execution-backend sha256 (F10 dedup). Byte-identical:
+// both emit `sha256:<hex>` and Node's Hash.update(string) defaults to utf8, the
+// same encoding the shared helper passes explicitly.
 function hashText(value) {
-    return `sha256:${node_crypto_1.default.createHash("sha256").update(value).digest("hex")}`;
+    return (0, execution_backend_1.sha256)(value);
 }
 function resolvePolicy(run, input) {
     const membership = input.membershipId ? run.multiAgent?.memberships.find((entry) => entry.id === input.membershipId) : undefined;

package/dist/node-projection.js

@@ -0,0 +1,59 @@
+"use strict";
+// Canonical StateNode projection (F9 de-triplication) — the SINGLE source of
+// truth for which StateNode fields make up the derived, fingerprinted body.
+//
+// Previously this 13-field set was hand-copied in three places: node-snapshot.ts's
+// snapshotBody, reclamation.ts's snapshotProjectionDigest, and reclamation.ts's
+// rawNodeBody/nodeBodyDigest (whose comment literally said "Mirror
+// node-snapshot.ts"). Any field added in one place but not the others would drift
+// the projection — and because reclamation hashes are tombstone-chained, a drift
+// would silently break the chain. This module collapses the list to ONE export so
+// the field set can only change in one place.
+//
+// BYTE-IDENTITY [load-bearing]: the projection / digest OUTPUT here is identical to
+// the prior in-line implementations. `normalizeValue` sorts object keys, so the
+// literal field ORDER never affected the bytes — only the field SET ever mattered.
+// `replayStableStringify(value) === JSON.stringify(normalizeValue(value))` and
+// `normalizeValue` is idempotent, so the projected-body digest and the raw-body
+// digest funnel through the same canonical bytes (node-snapshot-diff-replay +
+// reclamation smokes verify this).
+//
+// Pure: no I/O, no wall-clock, no random — safe in core/state/replay logic.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawNodeProjection = rawNodeProjection;
+exports.projectNodeBody = projectNodeBody;
+exports.nodeProjectionDigestInput = nodeProjectionDigestInput;
+const multi_agent_eval_1 = require("./multi-agent-eval");
+/** The raw (un-normalized) projection input: the canonical field set, copied off
+ *  the StateNode with no scrubbing. `normalizeValue`/`replayStableStringify` apply
+ *  the timestamp/path scrubbing downstream. This is the ONE place the field list
+ *  lives — add or drop a projected field here and every consumer follows. */
+function rawNodeProjection(node) {
+    return {
+        id: node.id,
+        kind: node.kind,
+        status: node.status,
+        loopStage: node.loopStage,
+        inputs: node.inputs,
+        outputs: node.outputs,
+        artifacts: node.artifacts,
+        evidence: node.evidence,
+        errors: node.errors,
+        parents: node.parents,
+        children: node.children,
+        contractId: node.contractId,
+        metadata: node.metadata
+    };
+}
+/** The normalized, derived projected body of one StateNode — timestamps/paths
+ *  stripped via the eval normalizer, so it is byte-stable across captures of the
+ *  same logical state. This is exactly node-snapshot.ts's historical snapshotBody. */
+function projectNodeBody(node) {
+    return (0, multi_agent_eval_1.normalizeValue)(rawNodeProjection(node));
+}
+/** Stable digest input for the projected body: the canonical bytes that the
+ *  snapshot/reconstruction digests bind. `replayStableStringify` re-normalizes, so
+ *  feeding the raw projection or the already-normalized body yields identical bytes. */
+function nodeProjectionDigestInput(node) {
+    return (0, multi_agent_eval_1.replayStableStringify)(rawNodeProjection(node));
+}

package/dist/node-snapshot.js

@@ -37,7 +37,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const pipeline_runner_1 = require("./pipeline-runner");
 const state_1 = require("./state");
 const multi_agent_eval_1 = require("./multi-agent-eval");
+const node_projection_1 = require("./node-projection");
 const state_explosion_1 = require("./state-explosion");
+const validation_1 = require("./validation");
 exports.NODE_SNAPSHOT_SCHEMA_VERSION = 1;
 /** Structured fail-closed error (mirrors the PipelineContractError shape). */
 class NodeSnapshotError extends Error {
@@ -64,23 +66,11 @@ const SNAPSHOT_SECTIONS = [
     "metadata"
 ];
 /** The normalized projection of a node — timestamps/paths stripped by the eval
- *  normalizer, so it is byte-stable across captures of the same logical state. */
+ *  normalizer, so it is byte-stable across captures of the same logical state. The
+ *  canonical field set lives in node-projection.ts (shared with reclamation.ts so
+ *  the projection can never drift across the two). */
 function snapshotBody(node) {
-    return (0, multi_agent_eval_1.normalizeValue)({
-        id: node.id,
-        kind: node.kind,
-        status: node.status,
-        loopStage: node.loopStage,
-        inputs: node.inputs,
-        outputs: node.outputs,
-        artifacts: node.artifacts,
-        evidence: node.evidence,
-        errors: node.errors,
-        parents: node.parents,
-        children: node.children,
-        contractId: node.contractId,
-        metadata: node.metadata
-    });
+    return (0, node_projection_1.projectNodeBody)(node);
 }
 /** RAW fingerprint (NOT normalized): any transition (updatedAt/status) or
  *  artifact/evidence change flips it, which is how drift is detected. */
@@ -113,7 +103,7 @@ function readNodeSnapshot(run, snapshotId) {
         for (const nodeDir of node_fs_1.default.readdirSync(root)) {
             const file = node_path_1.default.join(root, nodeDir, `${snapshotId}.json`);
             if (node_fs_1.default.existsSync(file))
-                return JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+                return (0, validation_1.validateNodeSnapshot)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8")));
         }
     }
     throw new NodeSnapshotError("snapshot-not-found", `Node snapshot ${snapshotId} not found in run ${run.id}`, { freshness: "absent" });
@@ -125,7 +115,7 @@ function readNodeReplay(run, replayId) {
         for (const nodeDir of node_fs_1.default.readdirSync(root)) {
             const file = node_path_1.default.join(root, nodeDir, "replays", `${replayId}.json`);
             if (node_fs_1.default.existsSync(file))
-                return JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+                return (0, validation_1.validateNodeReplayRun)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8")));
         }
     }
     throw new NodeSnapshotError("replay-not-found", `Node replay ${replayId} not found in run ${run.id}`, { freshness: "absent" });

package/dist/orchestrator/lifecycle-operations.js

@@ -17,6 +17,7 @@ exports.commit = commit;
 // plan() receives an already-resolved workflow app record (the runner still owns
 // app loading, which is instance-stateful). Behavior is identical to the inline
 // implementations; only the location changed.
+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 state_1 = require("../state");
@@ -456,8 +457,28 @@ function renderPrompt(prompt, inputs) {
     }
     return rendered;
 }
+// Deterministic run id (replay-determinism self-audit): the wall-clock stamp is an
+// edge timestamp (recorded once and stripped on replay), but the former
+// Math.random() suffix made the run id itself non-reproducible — re-deriving the id
+// for the SAME recorded run would never match. The suffix is now a content hash of
+// the run's deterministic identity (workflowId + the recorded stamp), so the id is a
+// pure function of inputs that already live in state. Distinct plan() invocations
+// still get distinct ids because the per-millisecond stamp differs; replaying a
+// recorded run reproduces the byte-identical id. Mirrors the de-clock done for
+// worker ids in src/worker-isolation/paths.ts.
+let runIdSequence = 0;
 function createRunId(workflowId) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
-    const suffix = Math.random().toString(36).slice(2, 8);
+    // The stamp is second-resolution, so several runs of the same workflowId minted
+    // within one second would otherwise hash to the SAME id. process.pid + a monotonic
+    // counter break the tie across BOTH same-process (counter) and concurrent-process
+    // (pid) minting — deterministic-by-environment, not a PRNG, so it keeps the
+    // replay-determinism intent; the id is an edge stamp stripped on replay anyway.
+    runIdSequence += 1;
+    const suffix = node_crypto_1.default
+        .createHash("sha256")
+        .update(`${workflowId}:${stamp}:${process.pid}:${runIdSequence}`)
+        .digest("hex")
+        .slice(0, 6);
     return `${workflowId}-${stamp}-${suffix}`;
 }

package/dist/orchestrator.js

@@ -90,10 +90,24 @@ class CoolWorkflowRunner {
     pluginRoot;
     workflowsDir;
     appsDir;
-    constructor({ pluginRoot }) {
+    // F7: the directory a run is resolved against (replaces the former process.chdir
+    // bracket in capability-core). undefined => fall back to process.cwd(). The runner
+    // reads runs from disk per call (no in-memory run state), so withBaseDir hands back
+    // a cheap scoped clone instead of mutating the global process cwd.
+    baseDir;
+    constructor({ pluginRoot, baseDir }) {
         this.pluginRoot = resolvePluginRoot(pluginRoot);
         this.workflowsDir = node_path_1.default.join(this.pluginRoot, "workflows");
         this.appsDir = node_path_1.default.join(this.pluginRoot, "apps");
+        this.baseDir = baseDir ? node_path_1.default.resolve(baseDir) : undefined;
+    }
+    /** Return a runner that resolves runs against `dir` instead of process.cwd(),
+     *  WITHOUT chdir-ing the process (F7). Same instance when the dir is unchanged. */
+    withBaseDir(dir) {
+        const resolved = dir ? node_path_1.default.resolve(dir) : undefined;
+        if (resolved === this.baseDir)
+            return this;
+        return new CoolWorkflowRunner({ pluginRoot: this.pluginRoot, baseDir: resolved });
     }
     listWorkflows() {
         return this.loadWorkflowApps().map((record) => {
@@ -700,7 +714,7 @@ class CoolWorkflowRunner {
         return feedbackOps.resolveFeedback(this.loadRun(runId), feedbackId, options);
     }
     loadRun(runId) {
-        return (0, state_1.loadRunFromCwd)(runId);
+        return (0, state_1.loadRunFromCwd)(runId, this.baseDir);
     }
     loadWorkflowAppById(appId) {
         const record = this.loadWorkflowApps().find((candidate) => candidate.app.id === appId);
@@ -807,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]",
@@ -859,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,10 +46,14 @@ 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");
 const state_1 = require("./state");
 const trust_audit_1 = require("./trust-audit");
@@ -94,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(). */
@@ -219,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) {
@@ -263,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")
@@ -283,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,
@@ -397,46 +345,17 @@ function buildReferenceGraph(run) {
         add(message.id);
     return refs;
 }
+/** expectDigest of a node's deterministic projection. Re-uses the SHARED
+ *  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) {
-    // Mirror node-snapshot.ts's deterministic projection so reconstruction matches.
-    const body = (0, multi_agent_eval_1.normalizeValue)({
-        id: node.id,
-        kind: node.kind,
-        status: node.status,
-        loopStage: node.loopStage,
-        inputs: node.inputs,
-        outputs: node.outputs,
-        artifacts: node.artifacts,
-        evidence: node.evidence,
-        errors: node.errors,
-        parents: node.parents,
-        children: node.children,
-        contractId: node.contractId,
-        metadata: node.metadata
-    });
-    return sha256OfString((0, multi_agent_eval_1.replayStableStringify)(body));
+    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. */
+ *  verifier re-derives the projection from this retained input. Same shared field
+ *  set / canonical bytes as snapshotProjectionDigest. */
 function nodeBodyDigest(node) {
-    return sha256OfString((0, multi_agent_eval_1.replayStableStringify)(rawNodeBody(node)));
-}
-function rawNodeBody(node) {
-    return {
-        id: node.id,
-        kind: node.kind,
-        status: node.status,
-        loopStage: node.loopStage,
-        inputs: node.inputs,
-        outputs: node.outputs,
-        artifacts: node.artifacts,
-        evidence: node.evidence,
-        errors: node.errors,
-        parents: node.parents,
-        children: node.children,
-        contractId: node.contractId,
-        metadata: node.metadata
-    };
+    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. */
@@ -459,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({
@@ -506,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
                     };
@@ -562,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`. */
@@ -579,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
@@ -604,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 = {
@@ -713,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;
     }
@@ -802,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

package/dist/run-registry/queue.js

@@ -33,15 +33,14 @@ function queueFilePath(host) {
 }
 function loadQueue(host) {
     const file = queueFilePath(host);
+    // Absent => empty queue. A present-but-corrupt queue must FAIL CLOSED rather
+    // than read as empty: silently draining to [] would lose every queued run and
+    // let scheduling/lease ops proceed as if the store were clean. readJson throws
+    // `Invalid JSON in <file>` on a present, unparseable store; let it propagate.
     if (!node_fs_1.default.existsSync(file))
         return [];
-    try {
-        const parsed = (0, state_1.readJson)(file);
-        return Array.isArray(parsed.entries) ? parsed.entries : [];
-    }
-    catch {
-        return [];
-    }
+    const parsed = (0, state_1.readJson)(file);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
 }
 function saveQueue(host, entries) {
     (0, state_1.writeJson)(queueFilePath(host), { schemaVersion: 1, entries }, { durable: true });