cool-workflow 0.1.98 → 0.2.0

package/dist/core/format/help.js

@@ -0,0 +1,314 @@
+"use strict";
+// core/format/help.ts — formatHelp, formatCommandHelp.
+//
+// Pure functions of already-loaded data. Byte-exact port of
+// src/orchestrator.ts:899-1007 in the old build (formatHelp,
+// formatCommandHelp) plus the color helpers `bold`/`dim` keyed off stdout.
+//
+// LOAD-BEARING LAYOUT (v2/PLAN.md byte-compat item 14 — do not "clean up"):
+//   - The command-line rows under "Cool Workflow" and the `cw <path...>`
+//     rows in formatCommandHelp use a 2-space indent. The CLI/MCP parity
+//     help-token checker parses ONLY 2-space lines as command tokens.
+//   - The trailing note line ("Run  cw help <command> ...") uses a
+//     DELIBERATE 4-space indent so that same 2-space parser skips it and
+//     never mistakes it for a command token.
+//
+// The header/flags/more-commands banner text stays hard-coded (it is not
+// capability-table data — see SPEC/cli-help/_root.txt). The per-verb
+// subcommand-row table (`COMMAND_HELP_ROWS`) is now a MIX: verbs whose
+// capability already has a `cli` binding in core/capability-table.ts
+// (`list`, `version`, `status`, `doctor`, `fix`, `backend`, `sandbox` as of
+// milestone 5) are dropped from the literal table below and read from the
+// capability table instead, via `cliCommandHelpRows()`; every other verb
+// stays literal here until its own milestone lands. This satisfies
+// v2/PLAN.md milestone 2's own "done when": a CLI `--help` walk and an MCP
+// `tools/list` round-trip read the SAME table rows for any capability
+// wired into both.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHelp = formatHelp;
+exports.formatCommandHelp = formatCommandHelp;
+exports.formatInfo = formatInfo;
+const capability_table_1 = require("../capability-table");
+/** src/orchestrator.ts:934-951 — the exact "More commands" token set, in
+ *  this exact order (space-joined in the source, pipe-joined for display). */
+const MORE_COMMANDS_TOKENS = [
+    "list", "search", "info", "init", "plan", "status", "next", "dispatch",
+    "result", "state", "commit", "report", "app", "sandbox", "backend",
+    "contract", "node", "feedback", "worker", "audit", "candidate", "review",
+    "loop", "schedule", "routine", "registry", "run", "queue", "clones",
+    "orphans", "history", "quickstart", "audit-run", "multi-agent", "topology",
+    "summary", "blackboard", "coordinator", "metrics", "operator", "sched",
+    "gc", "telemetry", "migration", "demo", "workbench", "approve", "reject",
+    "comment", "handoff", "ledger", "graph", "eval", "man", "version",
+    "update", "fix",
+];
+const MORE_COMMANDS_WRAP_WIDTH = 76;
+/** src/orchestrator.ts:940-951 — greedily pack pipe-joined tokens into
+ *  lines of at most `width` columns, INCLUDING the 2-space indent in the
+ *  width check (a token is never split). Returns lines WITH the 2-space
+ *  indent already applied — callers must not add another one. */
+function wrapPipeJoined(tokens, width) {
+    const lines = [];
+    let line = "  ";
+    for (const token of tokens) {
+        const sep = line.length > 2 ? "|" : "";
+        if (line.length + sep.length + token.length > width) {
+            lines.push(line);
+            line = "  ";
+        }
+        line += (line.length > 2 ? "|" : "") + token;
+    }
+    if (line.length > 2)
+        lines.push(line);
+    return lines;
+}
+/** src/orchestrator.ts:988-1007 — the per-verb subcommand rows, keyed by
+ *  the verb (`cli.path[0]` in the old registry). Verbs whose capability
+ *  now has a real `cli` binding in core/capability-table.ts (`list`,
+ *  `version`, `status`) are read from `cliCommandHelpRows()` instead (see
+ *  `formatCommandHelp` below) and are DELIBERATELY ABSENT from this
+ *  literal table — do not re-add them here, that would be exactly the
+ *  hand-sync drift this milestone's table exists to remove. Every other
+ *  verb stays literal until its own milestone lands. */
+const COMMAND_HELP_ROWS = {
+    help: [{ command: "cw help", summary: "Print the human CLI help text." }],
+    // NOTE: "ledger" is not listed here any more — ledger propose/review/
+    // verify/apply/list are now real capability-table rows (milestone 8,
+    // core/capability-table.ts) and come from cliCommandHelpRows("ledger")
+    // below, so their summary text lives in exactly one place.
+    //
+    // "clones" (and, below, "schedule"/"routine"/"sched"/"registry"/"queue"/
+    // "gc"/"orphans") STAY literal here even though milestone 10 gave each
+    // verb a real capability-table row: that row's OWN `cli.path` is the
+    // bare 1-token verb (e.g. ["clones"]) because dispatchTable only
+    // supports 1- or 2-token paths and these verbs each have MANY
+    // subcommands handled by one internal switch — so the row's `cli`
+    // binding is a dispatch/usage-error mechanism, not a per-subcommand
+    // help entry, and is marked `hiddenFromHelp` for exactly that reason
+    // (core/capability-table.ts). The per-subcommand summaries a human
+    // reads via `cw help clones` therefore still come from literal rows
+    // here, same as every other not-yet-per-subcommand-tabled verb below.
+    clones: [
+        {
+            command: "cw clones gc",
+            summary: "Reclaim cached remote-source checkouts: a TTL sweep (--older-than-days, default 30) or --all. Deletes only inside the clones cache.",
+        },
+        {
+            command: "cw clones list",
+            summary: "List the cached remote-source checkouts that --link/URL reviews populate (origin URL, kind, commit, age, bytes). Read-only.",
+        },
+    ],
+    schedule: [
+        { command: "cw schedule create", summary: "Create a scheduled CW task." },
+        { command: "cw schedule list", summary: "List scheduled CW tasks." },
+        { command: "cw schedule delete", summary: "Delete a scheduled CW task." },
+        { command: "cw schedule due", summary: "List due scheduled CW tasks." },
+        { command: "cw schedule complete", summary: "Mark a scheduled task complete." },
+        { command: "cw schedule pause", summary: "Pause a scheduled CW task." },
+        { command: "cw schedule resume", summary: "Resume a scheduled CW task." },
+        { command: "cw schedule run-now", summary: "Create an immediate scheduled-task run record." },
+        { command: "cw schedule history", summary: "List scheduled-task run history." },
+        { command: "cw schedule daemon", summary: "Tick the wall-clock scheduler once (--once) or run forever." },
+    ],
+    routine: [
+        { command: "cw routine create", summary: "Create a routine-style API/GitHub trigger." },
+        { command: "cw routine list", summary: "List routine-style triggers." },
+        { command: "cw routine delete", summary: "Delete a routine-style trigger." },
+        { command: "cw routine fire", summary: "Record an API/GitHub trigger event." },
+        { command: "cw routine events", summary: "List routine trigger events." },
+    ],
+    sched: [
+        { command: "cw sched plan", summary: "Read-only control-plane lease plan for the queue+policy+now." },
+        { command: "cw sched lease", summary: "Claim eligible queue entries as leases (concurrency-bounded)." },
+        { command: "cw sched release", summary: "Release a held lease (failed -> retry/backoff or park)." },
+        { command: "cw sched complete", summary: "Complete a held lease (terminal success)." },
+        { command: "cw sched reclaim", summary: "Reclaim expired leases (each counts a failed attempt)." },
+        { command: "cw sched reset", summary: "Reset a parked entry to ready (operator recovery)." },
+        { command: "cw sched policy", summary: "Show or set the scheduling policy (concurrency/attempts/backoff/TTL)." },
+    ],
+    registry: [
+        { command: "cw registry refresh", summary: "Recompute and persist the derived run registry index." },
+        { command: "cw registry show", summary: "Read the run registry index with valid|stale|absent freshness." },
+    ],
+    queue: [
+        { command: "cw queue add", summary: "Enqueue a pending/planned run with explicit ordering policy." },
+        { command: "cw queue list", summary: "List the durable run queue in policy order." },
+        { command: "cw queue drain", summary: "Mark the next ready queue entries drained (the host still executes)." },
+        { command: "cw queue show", summary: "Show one durable queue entry." },
+    ],
+    gc: [
+        {
+            command: "cw gc plan",
+            summary: "Dry-run plan of run reclamation (per-kind bytes + capability downgrade); frees nothing.",
+        },
+        {
+            command: "cw gc run",
+            summary: "Execute the write-ahead reclamation transaction (skeleton -> tombstone -> fsync -> free).",
+        },
+        {
+            command: "cw gc verify",
+            summary: "Re-prove a reclaimed run: skeleton-complete, tombstone chain untampered, artifacts reconstructable.",
+        },
+    ],
+    orphans: [
+        {
+            command: "cw orphans list",
+            summary: "List run directories under .cw/runs/ that the run registry cannot see (no state.json — a killed/interrupted process never wrote one), with age + bytes. Read-only.",
+        },
+        {
+            command: "cw orphans gc",
+            summary: "Reclaim orphan run directories (no state.json): an age sweep (--min-age-minutes, default 60) or --all. Deletes only inside a scanned repo's .cw/runs/, never a run the registry knows about.",
+        },
+    ],
+    run: [
+        // NOTE: neither "cw run drive" row is listed here any more. The first
+        // (read-only preview, "Preview the next agent-delegation...") is now a
+        // real capability-table row (run.drive, PARITY WIRING) with its own
+        // `cli.path`; the second (mutating "Drive a run by delegating...") is
+        // also a real capability-table row (run.drive.step, milestone 6+7)
+        // whose `helpPath` override displays it under the same "cw run drive"
+        // command column. Both come from cliCommandHelpRows("run") below, so
+        // neither is hand-duplicated here. Same for run archive/list/rerun/
+        // resume/search/show (milestone 10, core/capability-table.ts) — only
+        // the not-yet-implemented run-export family (milestone 11) stays
+        // literal here.
+        {
+            command: "cw run export",
+            summary: "Export a run to a portable archive with run-local files and digest integrity.",
+        },
+        {
+            command: "cw run import",
+            summary: "Restore a portable run archive into a target repo and verify restored file digests.",
+        },
+        {
+            command: "cw run inspect-archive",
+            summary: "Read-only integrity inspection of a portable run archive without importing it.",
+        },
+        {
+            command: "cw run restore",
+            summary: "Fail-closed restore of a portable run archive: integrity-inspect, import, and verify in one step; refuses anything that does not verify.",
+        },
+        {
+            command: "cw run verify-import",
+            summary: "Verify an imported run against its restore manifest and telemetry chain.",
+        },
+    ],
+    // NOTE: "quickstart" is not listed here any more — it is now a real
+    // capability-table row (milestone 6+7, core/capability-table.ts) and
+    // comes from cliCommandHelpRows("quickstart") below, so its summary
+    // text lives in exactly one place.
+    man: [{ command: "cw man", summary: "Show a man page from docs/ (e.g. cw man release-tooling)." }],
+    // NOTE: "demo" is not listed here any more — demo tamper/bundle are now
+    // real capability-table rows (milestone 8, core/capability-table.ts)
+    // and come from cliCommandHelpRows("demo") below.
+};
+/** src/orchestrator.ts:899-933 — the top-level `cw help` text. Color is
+ *  intentionally NOT applied here (this milestone's conformance runs pipe
+ *  stdout, so NO_COLOR/non-TTY always wins); byte content matches the
+ *  plain-text capture at SPEC/cli-help/_root.txt exactly. */
+function formatHelp() {
+    const moreCommandsLines = wrapPipeJoined(MORE_COMMANDS_TOKENS, MORE_COMMANDS_WRAP_WIDTH);
+    const lines = [
+        "Cool Workflow",
+        "",
+        '  -q "question" [-claude|-codex|-gemini|-deepseek]  Ask a question, get a report',
+        '  -q "question" --link <url>                 Review a remote repo by URL',
+        "  version                                   Show version",
+        "  update                                    Update to latest release",
+        "  doctor                                    Check setup",
+        "  fix                                       Show fix commands for setup issues",
+        "",
+        "Flags",
+        "  -q, --question TEXT    The task or question to answer",
+        "  -r, --repo PATH        Target repository path (default: .)",
+        "  -d, --dir PATH         Project folder to review (alias for --repo)",
+        "  -claude                Use Claude agent",
+        "  -codex                 Use Codex agent",
+        "  -gemini                Use Gemini (via opencode)",
+        "  -deepseek              Use DeepSeek (via opencode)",
+        "  --verbose              Show full agent narration live (default: compact)",
+        "  --full                 Verbose, plus the report printed inline at the end",
+        "  --no-color             Disable ANSI color (also honors NO_COLOR / FORCE_COLOR)",
+        "",
+        "More commands",
+        ...moreCommandsLines,
+        "",
+        "    Run  cw help <command>  for one command's subcommands and descriptions.",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** MILESTONE 2 — the capability-table projection half of
+ *  `COMMAND_HELP_ROWS`: every declared `cli` binding whose `path[0]`
+ *  matches `verb` becomes one row, `cw <path.join(" ")>` / `summary`.
+ *  Merged into `formatCommandHelp` below so a verb can have BOTH literal
+ *  rows (not-yet-migrated subcommands) and table-derived rows (migrated
+ *  ones) without duplicating data by hand. */
+function cliCommandHelpRows(verb) {
+    return (0, capability_table_1.cliCapabilities)()
+        .filter((row) => row.cli.path[0] === verb && !row.cli.hiddenFromHelp)
+        .map((row) => ({ command: `cw ${(row.cli.helpPath ?? row.cli.path).join(" ")}`, summary: row.summary }));
+}
+/** src/orchestrator.ts:988-1007 — `formatCommandHelp(verb)`. Unknown verb
+ *  gives a SOFT text (never a throw); known verb lists its registry rows,
+ *  sorted by command string, padded to the longest command column + 2
+ *  (capped at 40, per the old registry's own cap; none of the milestone-1
+ *  fixture rows exceed it). */
+function formatCommandHelp(verb, suggestCommand) {
+    const rows = [...(COMMAND_HELP_ROWS[verb] ?? []), ...cliCommandHelpRows(verb)];
+    if (rows.length === 0) {
+        const hint = suggestCommand(verb);
+        const lines = [`Unknown command: ${verb}`];
+        if (hint)
+            lines.push(`  Did you mean:  cw ${hint}`);
+        lines.push("  Try:  cw help   (list all commands)");
+        return `${lines.join("\n")}\n`;
+    }
+    const sorted = [...rows].sort((a, b) => (a.command < b.command ? -1 : a.command > b.command ? 1 : 0));
+    const longest = Math.min(40, Math.max(...sorted.map((row) => row.command.length)));
+    const lines = [`cw ${verb}`, ""];
+    for (const row of sorted) {
+        const padded = row.command.padEnd(longest, " ");
+        lines.push(`  ${padded}  ${row.summary}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** `cw info <id>` human card — MILESTONE 12. Byte-exact in spirit to
+ *  src/orchestrator.ts:899-929's `formatInfo` (color stripped, matching
+ *  this file's own `formatHelp`/`formatCommandHelp` — styling, if any, is
+ *  applied by the shell layer, never here). `data` is the `showApp`/
+ *  `showWorkflowApp` payload. */
+function formatInfo(appId, data) {
+    const inputs = (Array.isArray(data.inputs) ? data.inputs : []);
+    const phases = (Array.isArray(data.phases) ? data.phases : []);
+    const lines = [`cw info ${appId}`];
+    if (data.title)
+        lines.push(`  Title: ${data.title}`);
+    if (data.version)
+        lines.push(`  Version: ${data.version}`);
+    if (data.summary)
+        lines.push(`  Summary: ${data.summary}`);
+    if (data.author)
+        lines.push(`  Author: ${typeof data.author === "object" ? data.author.name : data.author}`);
+    if (data.compatible !== undefined)
+        lines.push(`  Compatible: ${data.compatible ? "yes" : "no"}`);
+    if (inputs.length > 0) {
+        lines.push("  Inputs:");
+        for (const one of inputs) {
+            const name = one.name || "";
+            const type = one.type || "string";
+            const required = one.required ? ", required" : "";
+            const def = one.default ? `, default: ${one.default}` : "";
+            const desc = one.description ? ` — ${one.description}` : "";
+            lines.push(`    - ${name} (${type}${required}${def})${desc}`);
+        }
+    }
+    if (Array.isArray(data.sandboxProfiles) && data.sandboxProfiles.length > 0) {
+        lines.push(`  Sandbox: ${data.sandboxProfiles.join(", ")}`);
+    }
+    const taskCount = data.taskCount || 0;
+    if (phases.length > 0) {
+        lines.push(`  Phases: ${phases.length} phase${phases.length !== 1 ? "s" : ""}, ${taskCount} task${taskCount !== 1 ? "s" : ""}`);
+    }
+    lines.push(`  Run: cw quickstart ${appId} --repo . --question "..."`);
+    return lines.join("\n");
+}

package/dist/{state-explosion/format.js → core/format/state-explosion-text.js}

@@ -1,4 +1,13 @@
 "use strict";
+// core/format/state-explosion-text.ts — formatStateExplosionReport,
+// formatCompactGraph, formatBlackboardDigest, stateExplosionReportLines.
+//
+// MILESTONE 4. Byte-exact port of the old build's
+// src/state-explosion/format.ts. CLI text only — never affects `--json`/
+// MCP payloads. Pure: a record object in, strings out.
+//
+// Evidence: SPEC/state-core.md "Human formatters (CLI text only, never
+// --json)".
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatStateExplosionReport = formatStateExplosionReport;
 exports.formatCompactGraph = formatCompactGraph;
@@ -141,7 +150,7 @@ function stateExplosionReportLines(report) {
     const lines = [
         `- Records: ${size.total}; graph nodes: ${size.graphNodes}; graph edges: ${size.graphEdges}; messages: ${size.messages}`,
         `- Compaction: ${size.compactionRecommended ? "recommended" : "not needed"}`,
-        `- Summary freshness: ${report.freshness.status}`
+        `- Summary freshness: ${report.freshness.status}`,
     ];
     for (const reason of size.reasons)
         lines.push(`  - ${reason}`);

package/dist/core/hash.js

@@ -0,0 +1,137 @@
+"use strict";
+// core/hash.ts — THE one hash/stringify module.
+//
+// Pure. No fs, no child_process, no net, no process.env, no Date.now(), no
+// Math.random(). Every input the old build fed these functions (a run id, a
+// content object, a list of strings) still comes in as a plain function
+// argument here.
+//
+// Per v2/PLAN.md's byte-compat section ("Hash dedup — three shapes, not one
+// edge case"), this file must keep THREE things separate, each with its own
+// name, never collapsed into a single flagged helper:
+//
+//   1. Three hash SPELLINGS: `sha256` (prefixed, 64 hex), `fingerprintStrings`
+//      (prefixed, 32 hex, SORTS its input), `stableHash` (prefixed, 64 hex,
+//      key-sorted JSON), plus `sha256Bytes` (bare hex, archive-only — never
+//      mix with the other three).
+//   2. Three DIVERGENT stringify-before-hash behaviors: `ledgerStableStringify`
+//      (no undefined special-casing), `telemetryStableStringify` (top-level
+//      undefined -> the string "null"), `eventHashInput` (JSON round-trip
+//      FIRST, to drop undefined-valued keys, THEN sort-and-stringify).
+//   3. One shared recursive key-sort primitive, `stableStringify`, that the
+//      three wrappers above are each built from explicitly — not a single
+//      function with a flag.
+//
+// Evidence: SPEC/ledger-trust.md "Hash form", "Handoff ledger entry",
+// "Telemetry ledger record", "Trust-audit chain"; SPEC/types-util.md
+// "Fingerprint / hash formats"; SPEC/state-core.md "Fingerprint / hash
+// formats", "Contract-migration prover invariants".
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.sha256Bytes = sha256Bytes;
+exports.fingerprintStrings = fingerprintStrings;
+exports.fingerprintRecords = fingerprintRecords;
+exports.stableHash = stableHash;
+exports.stableStringify = stableStringify;
+exports.ledgerStableStringify = ledgerStableStringify;
+exports.telemetryStableStringify = telemetryStableStringify;
+exports.eventHashInput = eventHashInput;
+const node_crypto_1 = require("node:crypto");
+// ---------------------------------------------------------------------------
+// 1. Hash spellings
+// ---------------------------------------------------------------------------
+/** Prefixed `sha256:` + all 64 hex chars. Used by both hash chains,
+ *  promptDigest, resultDigest, reportedUsageDigest, the ledger digest.
+ *  (src/execution-backend/util.ts:13-15 in the old build.) */
+function sha256(value) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(value, "utf8").digest("hex")}`;
+}
+/** BARE hex, no prefix. Archive file digests only (run-export.ts). Never mix
+ *  with the other three hash spellings in this file. */
+function sha256Bytes(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+/** Prefixed `sha256:` + only the FIRST 32 hex chars, over SORTED JSON-array
+ *  input. Sorts a COPY (`[...values].sort()`) with the JS default sort
+ *  (UTF-16 code-unit order) — never mutates the caller's array. Used by
+ *  snapshot ids, state-explosion fingerprints, evidence-reasoning
+ *  fingerprints. (src/util/fingerprint.ts:6-10.) */
+function fingerprintStrings(values) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    hash.update(JSON.stringify([...values].sort()));
+    return `sha256:${hash.digest("hex").slice(0, 32)}`;
+}
+/** Maps each record to `"<id>:<status or empty>"`, sorts, then fingerprints.
+ *  `updatedAt` is accepted in the record shape but NEVER used.
+ *  (src/util/fingerprint.ts:12-14.) */
+function fingerprintRecords(records) {
+    return fingerprintStrings(records.map((r) => `${r.id}:${r.status || ""}`).sort());
+}
+/** Prefixed `sha256:` + all 64 hex chars, over recursively KEY-SORTED JSON
+ *  (not normalized — used to prove a source snapshot was not mutated). Used
+ *  by the contract-migration prover. (src/contract-migration.ts:90-103.) */
+function stableHash(value) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(stableStringify(value)).digest("hex")}`;
+}
+// ---------------------------------------------------------------------------
+// 2/3. The one shared sort-and-stringify primitive, plus the three named,
+// independently-divergent wrapper behaviors.
+// ---------------------------------------------------------------------------
+/** Deterministic JSON with recursively sorted object keys. Never special-
+ *  cases a top-level `undefined` — `JSON.stringify(undefined)` returns
+ *  `undefined` (not a string), matching plain `JSON.stringify` behavior at
+ *  the top level. This IS the canonical primitive every wrapper below calls;
+ *  it is not itself one of the three named divergent behaviors. */
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const body = keys
+        .map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`)
+        .join(",");
+    return `{${body}}`;
+}
+/** `src/ledger.ts`'s `stableStringify` — sorts keys recursively, NO special-
+ *  casing of a top-level `undefined`. A top-level `undefined` is not a real
+ *  call site here in practice, but this must not be assumed to behave like
+ *  `telemetryStableStringify` below. Byte-identical to `stableStringify`;
+ *  kept as its own named export because the old build kept a private copy
+ *  in ledger.ts with this exact (non-)behavior, and the plan requires each
+ *  divergent behavior to stay separately named and separately tested. */
+function ledgerStableStringify(value) {
+    return stableStringify(value);
+}
+/** `src/telemetry-attestation.ts`'s `stableStringify` — sorts keys
+ *  recursively, AND maps a top-level `undefined` input to the literal
+ *  string `"null"` (via `JSON.stringify(value) ?? "null"`). Divergent from
+ *  `ledgerStableStringify` exactly at the top-level-undefined edge. */
+function telemetryStableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(telemetryStableStringify).join(",")}]`;
+    }
+    const entries = Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${telemetryStableStringify(value[key])}`);
+    return `{${entries.join(",")}}`;
+}
+/** `src/trust-audit.ts`'s `eventHash` input builder: JSON-round-trips the
+ *  value FIRST (`JSON.parse(JSON.stringify(value))`), which DROPS every key
+ *  (nested or top-level) whose value is `undefined`, and ONLY THEN runs the
+ *  sort-and-stringify step. This is a pre-pass that changes the shape being
+ *  hashed, not just a formatting rule on top of the same shape — so record-
+ *  time hashes (over an in-memory event that may carry nested `undefined`)
+ *  equal verify-time hashes (over the parsed-from-disk event, which never
+ *  had those keys to begin with). Caller is responsible for stripping the
+ *  `eventHash` field itself before calling this (this function hashes
+ *  exactly what it is given). */
+function eventHashInput(value) {
+    const roundTripped = JSON.parse(JSON.stringify(value));
+    return stableStringify(roundTripped);
+}