cool-workflow 0.1.98 → 0.2.0

package/dist/{state-migrations.js → core/state/migrations.js}

@@ -1,15 +1,57 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// core/state/migrations.ts — RUN_STATE_MIGRATIONS, findMigrationPath (BFS),
+// migrateRunState, reverseRunState, normalizeRunState.
+//
+// MILESTONE 3. Byte-exact port of the old build's src/state-migrations.ts.
+// Pure: no fs, no clock reads except `new Date(0)` (a fixed epoch
+// constant, not a real clock read) — statePath-derived `runDir`/`cwd`
+// defaults are path math over a string the caller already has, never a
+// real filesystem read.
+//
+// Evidence: SPEC/state-core.md "src/state-migrations.ts — run-state
+// migration", "Migration pipeline (migrateRunState)", "Normalization
+// defaults" (v2/PLAN.md byte-compat item 4).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RUN_STATE_MIGRATIONS = void 0;
 exports.findMigrationPath = findMigrationPath;
 exports.migrateRunState = migrateRunState;
 exports.reverseRunState = reverseRunState;
-const node_path_1 = __importDefault(require("node:path"));
-const version_1 = require("./version");
-const run_state_schema_1 = require("./run-state-schema");
+const path = __importStar(require("node:path"));
+const version_1 = require("../version");
+const schema_1 = require("./schema");
 exports.RUN_STATE_MIGRATIONS = [
     {
         from: version_1.LEGACY_RUN_STATE_SCHEMA_VERSION,
@@ -19,22 +61,23 @@ exports.RUN_STATE_MIGRATIONS = [
             setDefault(state, "schemaVersion", version_1.CURRENT_RUN_STATE_SCHEMA_VERSION, context, "legacy run state did not declare schemaVersion");
         },
         reverse(state, context) {
-            // Reverse: remove schemaVersion to return to legacy format.
-            // Only removes if the value equals CURRENT_RUN_STATE_SCHEMA_VERSION (fail-closed).
             if (state.schemaVersion === version_1.CURRENT_RUN_STATE_SCHEMA_VERSION) {
                 delete state.schemaVersion;
-                context.changes.push({ path: "schemaVersion", before: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION, after: undefined, reason: "reverse: legacy run state unmarks schemaVersion" });
+                context.changes.push({
+                    path: "schemaVersion",
+                    before: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION,
+                    after: undefined,
+                    reason: "reverse: legacy run state unmarks schemaVersion",
+                });
             }
-        }
-    }
+        },
+    },
 ];
-// BSD discipline: mechanism — BFS shortest-path resolver over a directed graph of
-// migration steps. Forward edges use `from -> to`; reverse edges use `to -> from`
-// when a step has a `reverse()` function. Fail-closed: no path → named refusal.
+/** BFS shortest path over forward edges (`from -> to`) plus reverse edges
+ *  (`to -> from`, only when the step has a `reverse()`). */
 function findMigrationPath(steps, fromVersion, toVersion) {
     if (fromVersion === toVersion)
         return { reachable: true, path: [] };
-    // Build adjacency: for each step, record forward (from->to) and optional reverse (to->from)
     const forward = new Map();
     const reverse = new Map();
     for (const step of steps) {
@@ -52,7 +95,6 @@ function findMigrationPath(steps, fromVersion, toVersion) {
     visited.add(fromVersion);
     while (queue.length > 0) {
         const current = queue.shift();
-        // Try forward moves
         const fwd = forward.get(current.version) || [];
         for (const move of fwd) {
             const next = move.edge.to;
@@ -63,10 +105,9 @@ function findMigrationPath(steps, fromVersion, toVersion) {
                 queue.push({ version: next, path: [...current.path, { edge: move.edge, reverse: false }] });
             }
         }
-        // Try reverse moves (only when reverse() is defined on the step)
         const rev = reverse.get(current.version) || [];
         for (const move of rev) {
-            const next = move.edge.from; // reverse direction
+            const next = move.edge.from;
             if (next === toVersion)
                 return { reachable: true, path: [...current.path, { edge: move.edge, reverse: true }] };
             if (!visited.has(next)) {
@@ -83,15 +124,12 @@ function migrateRunState(input, options = {}) {
         statePath: options.statePath,
         detectedSchemaVersion: detectSchemaVersion(input),
         currentSchemaVersion: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION,
-        supportedSchemaVersions: {
-            min: version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION,
-            max: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION
-        },
+        supportedSchemaVersions: { min: version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION, max: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION },
         dryRun: Boolean(options.dryRun),
         writeRequired: false,
         changes: [],
         warnings: [],
-        errors: []
+        errors: [],
     };
     if (!isRecord(input)) {
         report.status = "unsupported";
@@ -117,12 +155,10 @@ function migrateRunState(input, options = {}) {
         return { run: state, report };
     }
     for (const step of resolved.path) {
-        if (step.reverse) {
+        if (step.reverse)
             step.edge.reverse(state, context);
-        }
-        else {
+        else
             step.edge.migrate(state, context);
-        }
     }
     normalizeRunState(state, context);
     validateMigratedRunState(state, report);
@@ -137,25 +173,18 @@ function migrateRunState(input, options = {}) {
         report.status = "current";
     return { run: state, report };
 }
-// BSD discipline: mechanism — reverse migration along the DAG graph. The caller
-// supplies a target version; the graph resolver finds a path (which may include
-// forward steps AND reverse steps). Fail-closed: no path => named refusal.
-// POLICY (kept out of the kernel): whether to reverse, and to which version.
 function reverseRunState(input, targetSchemaVersion, options = {}) {
     const report = {
         status: "current",
         statePath: options.statePath,
         detectedSchemaVersion: detectSchemaVersion(input),
         currentSchemaVersion: targetSchemaVersion,
-        supportedSchemaVersions: {
-            min: version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION,
-            max: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION
-        },
+        supportedSchemaVersions: { min: version_1.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION, max: version_1.CURRENT_RUN_STATE_SCHEMA_VERSION },
         dryRun: Boolean(options.dryRun),
         writeRequired: false,
         changes: [],
         warnings: [],
-        errors: []
+        errors: [],
     };
     if (!isRecord(input)) {
         report.status = "unsupported";
@@ -180,16 +209,12 @@ function reverseRunState(input, targetSchemaVersion, options = {}) {
         report.errors.push(resolved.error || `No reverse path from schemaVersion ${report.detectedSchemaVersion} to ${targetSchemaVersion}.`);
         return { run: state, report };
     }
-    // Apply each step along the path; reverse=true calls edge.reverse(), false calls edge.migrate()
     for (const step of resolved.path) {
-        if (step.reverse) {
+        if (step.reverse)
             step.edge.reverse(state, context);
-        }
-        else {
+        else
             step.edge.migrate(state, context);
-        }
     }
-    // warn on destructive changes (reverse steps that mutate or remove data)
     for (const change of report.changes) {
         if (change.after === undefined && change.before !== undefined) {
             report.warnings.push(`Destructive reverse change at ${change.path}: removed ${JSON.stringify(change.before)}`);
@@ -206,14 +231,19 @@ function reverseRunState(input, targetSchemaVersion, options = {}) {
         report.status = "current";
     return { run: state, report };
 }
+/** Fill in every WorkflowRun default, each recorded as a StateMigrationChange.
+ *  Pinned defaults (v2/PLAN.md byte-compat item 4): epoch-0 ISO timestamps,
+ *  cwd = three dirs above the run dir else process.cwd(), workflow.limits =
+ *  { maxAgents: 8, maxConcurrentAgents: 4 }, loopStage = "interpret" (any
+ *  unknown value overwritten). */
 function normalizeRunState(state, context) {
-    const runDir = context.statePath ? node_path_1.default.dirname(context.statePath) : undefined;
-    const id = stringValue(state.id) || (runDir ? node_path_1.default.basename(runDir) : "unknown-run");
+    const runDir = context.statePath ? path.dirname(context.statePath) : undefined;
+    const id = stringValue(state.id) || (runDir ? path.basename(runDir) : "unknown-run");
     const now = new Date(0).toISOString();
     setDefault(state, "id", id, context, "run id is required");
     setDefault(state, "createdAt", stringValue(state.updatedAt) || now, context, "createdAt is required");
     setDefault(state, "updatedAt", stringValue(state.createdAt) || now, context, "updatedAt is required");
-    setDefault(state, "cwd", runDir ? node_path_1.default.resolve(runDir, "..", "..", "..") : process.cwd(), context, "cwd is required");
+    setDefault(state, "cwd", runDir ? path.resolve(runDir, "..", "..", "..") : process.cwd(), context, "cwd is required");
     setDefault(state, "inputs", {}, context, "inputs must be present");
     setDefault(state, "loopStage", "interpret", context, "loopStage is required");
     if (!isLoopStage(state.loopStage))
@@ -224,23 +254,23 @@ function normalizeRunState(state, context) {
     setDefault(workflow, "summary", "", context, "workflow.summary is required", "workflow.summary");
     setDefault(workflow, "limits", { maxAgents: 8, maxConcurrentAgents: 4 }, context, "workflow.limits is required", "workflow.limits");
     const paths = ensureRecord(state, "paths", context, "run paths are required");
-    const baseRunDir = stringValue(paths.runDir) || runDir || node_path_1.default.join(String(state.cwd), ".cw", "runs", id);
+    const baseRunDir = stringValue(paths.runDir) || runDir || path.join(String(state.cwd), ".cw", "runs", id);
     setDefault(paths, "runDir", baseRunDir, context, "paths.runDir is required", "paths.runDir");
-    setDefault(paths, "state", node_path_1.default.join(baseRunDir, "state.json"), context, "paths.state is required", "paths.state");
-    setDefault(paths, "report", node_path_1.default.join(baseRunDir, "report.md"), context, "paths.report is required", "paths.report");
-    setDefault(paths, "tasksDir", node_path_1.default.join(baseRunDir, "tasks"), context, "paths.tasksDir is required", "paths.tasksDir");
-    setDefault(paths, "resultsDir", node_path_1.default.join(baseRunDir, "results"), context, "paths.resultsDir is required", "paths.resultsDir");
-    setDefault(paths, "dispatchesDir", node_path_1.default.join(baseRunDir, "dispatches"), context, "paths.dispatchesDir is required", "paths.dispatchesDir");
-    setDefault(paths, "artifactsDir", node_path_1.default.join(baseRunDir, "artifacts"), context, "paths.artifactsDir is required", "paths.artifactsDir");
-    setDefault(paths, "commitsDir", node_path_1.default.join(baseRunDir, "commits"), context, "paths.commitsDir is required", "paths.commitsDir");
-    setDefault(paths, "stateNodesDir", node_path_1.default.join(baseRunDir, "nodes"), context, "paths.stateNodesDir is required", "paths.stateNodesDir");
-    setDefault(paths, "feedbackDir", node_path_1.default.join(baseRunDir, "feedback"), context, "paths.feedbackDir is required", "paths.feedbackDir");
-    setDefault(paths, "auditDir", node_path_1.default.join(baseRunDir, "audit"), context, "paths.auditDir is required", "paths.auditDir");
-    setDefault(paths, "workersDir", node_path_1.default.join(baseRunDir, "workers"), context, "paths.workersDir is required", "paths.workersDir");
-    setDefault(paths, "candidatesDir", node_path_1.default.join(baseRunDir, "candidates"), context, "paths.candidatesDir is required", "paths.candidatesDir");
-    setDefault(paths, "multiAgentDir", node_path_1.default.join(baseRunDir, "multi-agent"), context, "paths.multiAgentDir is required", "paths.multiAgentDir");
-    setDefault(paths, "blackboardDir", node_path_1.default.join(baseRunDir, "blackboard"), context, "paths.blackboardDir is required", "paths.blackboardDir");
-    setDefault(paths, "topologiesDir", node_path_1.default.join(baseRunDir, "topologies"), context, "paths.topologiesDir is required", "paths.topologiesDir");
+    setDefault(paths, "state", path.join(baseRunDir, "state.json"), context, "paths.state is required", "paths.state");
+    setDefault(paths, "report", path.join(baseRunDir, "report.md"), context, "paths.report is required", "paths.report");
+    setDefault(paths, "tasksDir", path.join(baseRunDir, "tasks"), context, "paths.tasksDir is required", "paths.tasksDir");
+    setDefault(paths, "resultsDir", path.join(baseRunDir, "results"), context, "paths.resultsDir is required", "paths.resultsDir");
+    setDefault(paths, "dispatchesDir", path.join(baseRunDir, "dispatches"), context, "paths.dispatchesDir is required", "paths.dispatchesDir");
+    setDefault(paths, "artifactsDir", path.join(baseRunDir, "artifacts"), context, "paths.artifactsDir is required", "paths.artifactsDir");
+    setDefault(paths, "commitsDir", path.join(baseRunDir, "commits"), context, "paths.commitsDir is required", "paths.commitsDir");
+    setDefault(paths, "stateNodesDir", path.join(baseRunDir, "nodes"), context, "paths.stateNodesDir is required", "paths.stateNodesDir");
+    setDefault(paths, "feedbackDir", path.join(baseRunDir, "feedback"), context, "paths.feedbackDir is required", "paths.feedbackDir");
+    setDefault(paths, "auditDir", path.join(baseRunDir, "audit"), context, "paths.auditDir is required", "paths.auditDir");
+    setDefault(paths, "workersDir", path.join(baseRunDir, "workers"), context, "paths.workersDir is required", "paths.workersDir");
+    setDefault(paths, "candidatesDir", path.join(baseRunDir, "candidates"), context, "paths.candidatesDir is required", "paths.candidatesDir");
+    setDefault(paths, "multiAgentDir", path.join(baseRunDir, "multi-agent"), context, "paths.multiAgentDir is required", "paths.multiAgentDir");
+    setDefault(paths, "blackboardDir", path.join(baseRunDir, "blackboard"), context, "paths.blackboardDir is required", "paths.blackboardDir");
+    setDefault(paths, "topologiesDir", path.join(baseRunDir, "topologies"), context, "paths.topologiesDir is required", "paths.topologiesDir");
     ensureArray(state, "tasks", context);
     ensureArray(state, "dispatches", context);
     ensureArray(state, "commits", context);
@@ -252,9 +282,9 @@ function normalizeRunState(state, context) {
             context.errors.push("audit must be an object when present.");
         setValue(state, "audit", {
             schemaVersion: 1,
-            eventLogPath: node_path_1.default.join(String(paths.auditDir), "events.jsonl"),
-            summaryPath: node_path_1.default.join(String(paths.auditDir), "summary.json"),
-            indexPath: node_path_1.default.join(String(paths.auditDir), "index.json")
+            eventLogPath: path.join(String(paths.auditDir), "events.jsonl"),
+            summaryPath: path.join(String(paths.auditDir), "summary.json"),
+            indexPath: path.join(String(paths.auditDir), "index.json"),
         }, context, "audit metadata is required");
     }
     ensureArray(state, "workers", context);
@@ -264,15 +294,7 @@ function normalizeRunState(state, context) {
     if (!isRecord(state.multiAgent)) {
         if (state.multiAgent !== undefined)
             context.errors.push("multiAgent must be an object when present.");
-        setValue(state, "multiAgent", {
-            schemaVersion: 1,
-            runs: [],
-            roles: [],
-            groups: [],
-            memberships: [],
-            fanouts: [],
-            fanins: []
-        }, context, "multiAgent state is required");
+        setValue(state, "multiAgent", { schemaVersion: 1, runs: [], roles: [], groups: [], memberships: [], fanouts: [], fanins: [] }, context, "multiAgent state is required");
     }
     else {
         const multiAgent = state.multiAgent;
@@ -288,16 +310,7 @@ function normalizeRunState(state, context) {
     if (!isRecord(state.blackboard)) {
         if (state.blackboard !== undefined)
             context.errors.push("blackboard must be an object when present.");
-        setValue(state, "blackboard", {
-            schemaVersion: 1,
-            boards: [],
-            topics: [],
-            messages: [],
-            contexts: [],
-            artifacts: [],
-            snapshots: [],
-            decisions: []
-        }, context, "blackboard state is required");
+        setValue(state, "blackboard", { schemaVersion: 1, boards: [], topics: [], messages: [], contexts: [], artifacts: [], snapshots: [], decisions: [] }, context, "blackboard state is required");
     }
     else {
         const blackboard = state.blackboard;
@@ -313,10 +326,7 @@ function normalizeRunState(state, context) {
     if (!isRecord(state.topologies)) {
         if (state.topologies !== undefined)
             context.errors.push("topologies must be an object when present.");
-        setValue(state, "topologies", {
-            schemaVersion: 1,
-            runs: []
-        }, context, "topologies state is required");
+        setValue(state, "topologies", { schemaVersion: 1, runs: [] }, context, "topologies state is required");
     }
     else {
         const topologies = state.topologies;
@@ -327,9 +337,6 @@ function normalizeRunState(state, context) {
             setValue(topologies, "runs", [], context, "topologies.runs must be an array", "topologies.runs");
         }
     }
-    // Team Collaboration (v0.1.32) is purely additive: pre-v0.1.32 runs carry no
-    // `collaboration` and load unchanged (absent => no approvals, no review gate).
-    // When present, normalize its append-only arrays so a partial object is honest.
     if (state.collaboration !== undefined) {
         if (!isRecord(state.collaboration)) {
             context.errors.push("collaboration must be an object when present.");
@@ -355,18 +362,18 @@ function normalizeRunState(state, context) {
     }
 }
 function validateMigratedRunState(state, report) {
-    for (const key of run_state_schema_1.REQUIRED_TOP_LEVEL_KEYS) {
+    for (const key of schema_1.REQUIRED_TOP_LEVEL_KEYS) {
         if (!(key in state))
             report.errors.push(`Missing required run-state field: ${key}.`);
     }
     if (state.schemaVersion !== version_1.CURRENT_RUN_STATE_SCHEMA_VERSION) {
         report.errors.push(`Expected schemaVersion ${version_1.CURRENT_RUN_STATE_SCHEMA_VERSION}; found ${String(state.schemaVersion)}.`);
     }
-    for (const key of run_state_schema_1.REQUIRED_RECORD_KEYS) {
+    for (const key of schema_1.REQUIRED_RECORD_KEYS) {
         if (key in state && !isRecord(state[key]))
             report.errors.push(`${key} must be an object.`);
     }
-    for (const key of run_state_schema_1.REQUIRED_ARRAY_KEYS) {
+    for (const key of schema_1.REQUIRED_ARRAY_KEYS) {
         if (!Array.isArray(state[key]))
             report.errors.push(`${key} must be an array.`);
     }
@@ -429,7 +436,7 @@ function derivePhases(tasks) {
         id: slugify(name),
         name,
         status: tasksForPhaseCompleted(tasks, taskIds) ? "completed" : "pending",
-        taskIds
+        taskIds,
     }));
 }
 function tasksForPhaseCompleted(tasks, taskIds) {
@@ -439,11 +446,11 @@ function tasksForPhaseCompleted(tasks, taskIds) {
     });
 }
 function titleize(value) {
-    return value
+    return (value
         .split(/[-_\s]+/g)
         .filter(Boolean)
         .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
-        .join(" ") || "Workflow";
+        .join(" ") || "Workflow");
 }
 function slugify(value) {
     const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");

package/dist/core/state/node-projection.js

@@ -0,0 +1,95 @@
+"use strict";
+// core/state/node-projection.ts — the canonical StateNode projection.
+//
+// MILESTONE 3. Byte-exact port of the old build's src/node-projection.ts
+// PLUS the `normalizeValue`/`replayStableStringify` pair it depends on
+// (src/multi-agent-eval/normalize.ts:9-45). This is the SINGLE source of
+// truth for the 13-field projected-node shape; node-snapshot.ts and (in a
+// later milestone) reclamation.ts's tombstone chain both read from here so
+// the field set can only change in one place.
+//
+// BYTE-IDENTITY [load-bearing]: `normalizeValue` sorts object keys, so field
+// ORDER never affects the bytes — only the field SET matters.
+// `replayStableStringify(value) === JSON.stringify(normalizeValue(value))`.
+//
+// Pure: no I/O, no wall-clock, no random.
+//
+// Evidence: SPEC/state-core.md "src/node-projection.ts — the canonical node
+// projection", "normalizeValue ... drops the keys createdAt, updatedAt,
+// recordedAt, selectedAt, replayedAt, generatedAt ...".
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeValue = normalizeValue;
+exports.replayStableStringify = replayStableStringify;
+exports.rawNodeProjection = rawNodeProjection;
+exports.projectNodeBody = projectNodeBody;
+exports.nodeProjectionDigestInput = nodeProjectionDigestInput;
+const SCRUBBED_TIMESTAMP_KEYS = new Set(["createdAt", "updatedAt", "recordedAt", "selectedAt", "replayedAt", "generatedAt"]);
+/** Recursively sorts object keys, drops timestamp-shaped keys, and scrubs
+ *  timestamp/tmp-path substrings out of every string value (so a snapshot
+ *  body captured at two different wall-clock times, in two different tmp
+ *  dirs, is byte-identical). Ported literally from the old build's
+ *  src/multi-agent-eval/normalize.ts — this is the ONE normalizer every
+ *  node snapshot/replay/diff/eval-line path shares. */
+function normalizeValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeValue);
+    if (!value || typeof value !== "object") {
+        if (typeof value === "string")
+            return normalizeString(value);
+        return value;
+    }
+    const record = value;
+    const normalized = {};
+    for (const key of Object.keys(record).sort()) {
+        if (SCRUBBED_TIMESTAMP_KEYS.has(key))
+            continue;
+        if (key.endsWith("Path") || key === "path" || key === "cwd" || key === "runDir" || key.endsWith("Dir")) {
+            normalized[key] = normalizeString(String(record[key]));
+        }
+        else {
+            normalized[key] = normalizeValue(record[key]);
+        }
+    }
+    return normalized;
+}
+function normalizeString(value) {
+    return value
+        .replace(/[0-9]{8}T[0-9]{6}Z/g, "<timestamp>")
+        .replace(/[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9:.]+Z/g, "<timestamp>")
+        .replace(/\/[^"\s]+\/\.cw\/runs\/[^"\s/]+/g, "<run-dir>")
+        .replace(/\/[^"\s]+\/\.cw\/evals\/[^"\s/]+/g, "<eval-dir>")
+        .replace(/\/var\/folders\/[^"\s]+|\/tmp\/[^"\s]+|\/private\/tmp\/[^"\s]+/g, "<tmp>");
+}
+/** Deterministic bytes over a normalized value. */
+function replayStableStringify(value) {
+    return JSON.stringify(normalizeValue(value));
+}
+/** The ONE place that lists the 13 projected fields (no `createdAt`/
+ *  `updatedAt`/`schemaVersion`). 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,
+    };
+}
+/** `normalizeValue(rawNodeProjection(node))` — the `NodeSnapshotBody`. */
+function projectNodeBody(node) {
+    return normalizeValue(rawNodeProjection(node));
+}
+/** `replayStableStringify(rawNodeProjection(node))` — shared with a later
+ *  milestone's reclamation tombstone chain so it cannot drift. */
+function nodeProjectionDigestInput(node) {
+    return replayStableStringify(rawNodeProjection(node));
+}