cool-workflow 0.1.98 → 0.2.0

package/dist/{observability.js → shell/observability.js}

@@ -1,38 +1,52 @@
 "use strict";
-// Observability + Cost Accounting (v0.1.31) — DERIVED metrics, ATTESTED cost.
+// shell/observability.ts — DERIVED metrics, ATTESTED cost. `cw metrics
+// show`/`cw metrics summary`.
 //
-// BSD / Unix discipline (each non-trivial choice cites its tenet):
+// MILESTONE 11 (reporting/observability). Byte-exact port of the old
+// build's src/observability.ts — every number here is a PROJECTION of one
+// run's durable state.json (timestamps -> durations, verifier nodes ->
+// pass rate, candidates -> acceptance rate, failed workers/feedback ->
+// failure rate). No metrics database, no collector daemon. Cost is
+// ATTESTED, never fabricated: absent usage is `unreported`, never 0; a
+// rate over zero samples is `n/a`, never 0%/100%.
 //
-//  - DERIVED, NOT A TELEMETRY PIPELINE. Every number here is a PROJECTION of one
-//    run's durable `.cw/runs/<id>/state.json`: timestamps → durations, verifier
-//    nodes → pass rate, candidates → acceptance rate, failed workers/feedback →
-//    failure rate. No metrics database, no collector daemon, no hidden counter.
-//    deriveMetricsReport() is a PURE function of (run, now, policy) and NEVER
-//    mutates source records.
-//
-//  - COST IS ATTESTED, NEVER MEASURED OR FABRICATED. CW does not call the model;
-//    the host/worker does. Token usage is read from the host-attested UsageRecord
-//    on the task/worker record. Absent usage is `unreported` — never 0. Cost is
-//    `attested` only when attested usage is priced by an EXACT policy match;
-//    assumed pricing is a separate `estimated` figure; the two never conflate.
-//
-//  - MECHANISM VS POLICY. This module is MECHANISM. The pricing table is POLICY,
-//    supplied as DATA (CostPolicy) and kept out of the kernel: the same attested
-//    usage yields different cost under different policies without touching code.
-//
-//  - A COUNTER YOU CANNOT TRUST IS WORSE THAN NONE. A rate over zero samples is
-//    `n/a`, never 0%/100%. Every RateMetric carries count + total + buckets.
-//
-//  - DETERMINISTIC & REPLAYABLE. Wall-clock "now" is INJECTED (the only
-//    now-derived field is `generatedAt`); all durations come from recorded
-//    timestamps. A report over a fixed snapshot is byte-reproducible.
-//
-//  - FAIL CLOSED ON DRIFT. A fingerprinted, rebuildable per-run snapshot reports
-//    `valid|stale|absent` against current source — same ethos as the v0.1.25
-//    state-explosion summaries and the v0.1.28 registry.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// Evidence: SPEC/reporting-ux.md "cw metrics show / summary", invariant 4
+// (metrics are derived and honest), invariant 5 (freshness is fail-
+// closed), invariant 6 (metricsShow never touches state.json); plugins/
+// cool-workflow/src/observability.ts:1-822 (byte-exact source).
+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.formatMetricsSummary = exports.formatMetricsReport = exports.parseUsageFromArgs = exports.loadCostPolicy = exports.METRICS_SCHEMA_VERSION = void 0;
 exports.fingerprintMetricsSource = fingerprintMetricsSource;
@@ -42,40 +56,31 @@ exports.deriveCost = deriveCost;
 exports.deriveFailureRate = deriveFailureRate;
 exports.deriveVerifierPassRate = deriveVerifierPassRate;
 exports.deriveCandidateAcceptanceRate = deriveCandidateAcceptanceRate;
-exports.deriveMetricsReport = deriveMetricsReport;
 exports.deriveCollaborationMetrics = deriveCollaborationMetrics;
+exports.deriveMetricsReport = deriveMetricsReport;
 exports.metricsDir = metricsDir;
 exports.loadPersistedMetricsFingerprint = loadPersistedMetricsFingerprint;
 exports.showMetricsReport = showMetricsReport;
 exports.deriveMetricsSummary = deriveMetricsSummary;
-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");
-const telemetry_ledger_1 = require("./telemetry-ledger");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fs_atomic_1 = require("./fs-atomic");
+const telemetry_ledger_io_1 = require("./telemetry-ledger-io");
 exports.METRICS_SCHEMA_VERSION = 1;
-// Verifier-gate decision classes (derived, never invented).
 const VERIFIER_PASS_STATUSES = new Set(["verified", "completed", "committed"]);
 const VERIFIER_FAIL_STATUSES = new Set(["failed", "rejected", "blocked"]);
-// Candidate acceptance classes.
 const CANDIDATE_ACCEPTED_STATUSES = new Set(["selected", "verified"]);
-// ---------------------------------------------------------------------------
-// Deterministic helpers
-// ---------------------------------------------------------------------------
 function fingerprintStrings(values) {
-    const hash = node_crypto_1.default.createHash("sha256");
+    const { createHash } = require("node:crypto");
+    const hash = createHash("sha256");
     hash.update(JSON.stringify([...values].sort()));
     return `sha256:${hash.digest("hex").slice(0, 32)}`;
 }
-/** Round to a fixed precision deterministically (no locale, no float drift in
- *  the serialized form). */
 function round(value, decimals) {
     const factor = 10 ** decimals;
     return Math.round(value * factor) / factor;
 }
-/** ms between two ISO timestamps, or null if either is missing/unparseable or
- *  the result would be negative (clock skew ⇒ untrustworthy ⇒ null, not a lie). */
-function durationMs(startedAt, endedAt) {
+function durationMsBetween(startedAt, endedAt) {
     if (!startedAt || !endedAt)
         return null;
     const start = Date.parse(startedAt);
@@ -86,32 +91,21 @@ function durationMs(startedAt, endedAt) {
     return delta >= 0 ? delta : null;
 }
 function duration(startedAt, endedAt) {
-    const wallClockMs = durationMs(startedAt, endedAt);
-    return {
-        startedAt,
-        endedAt,
-        wallClockMs,
-        inFlight: !endedAt
-    };
+    return { startedAt, endedAt, wallClockMs: durationMsBetween(startedAt, endedAt), inFlight: !endedAt };
 }
-/** Build a fail-closed rate. total === 0 ⇒ `n/a` (count/rate null). */
 function rate(metric, count, total, buckets) {
-    if (total <= 0) {
+    if (total <= 0)
         return { metric, state: "n/a", count: null, total: 0, rate: null, buckets };
-    }
     return { metric, state: "ok", count, total, rate: round(count / total, 6), buckets };
 }
-// ---------------------------------------------------------------------------
-// Source fingerprint (structural, not mtime — a tampered status trips `stale`).
-// ---------------------------------------------------------------------------
+function usageKey(usage) {
+    if (!usage)
+        return "unreported";
+    return `${usage.source}:${usage.model || "-"}:${usage.inputTokens ?? "-"}:${usage.outputTokens ?? "-"}`;
+}
 function fingerprintMetricsSource(run) {
-    const parts = [
-        `id:${run.id}`,
-        `createdAt:${run.createdAt}`,
-        `updatedAt:${run.updatedAt}`,
-        `app:${run.workflow.app?.id || run.workflow.id}`
-    ];
-    for (const task of [...(run.tasks || [])].sort((a, b) => a.id.localeCompare(b.id))) {
+    const parts = [`id:${run.id}`, `createdAt:${run.createdAt}`, `updatedAt:${run.updatedAt}`, `app:${run.workflow.app?.id || run.workflow.id}`];
+    for (const task of [...run.tasks].sort((a, b) => a.id.localeCompare(b.id))) {
         parts.push(`task:${task.id}:${task.status}:${task.dispatchedAt || "-"}:${task.completedAt || "-"}:${usageKey(task.usage)}:${task.backendId || "-"}`);
     }
     for (const worker of [...(run.workers || [])].sort((a, b) => a.id.localeCompare(b.id))) {
@@ -131,40 +125,25 @@ function fingerprintMetricsSource(run) {
     }
     return fingerprintStrings(parts);
 }
-function usageKey(usage) {
-    if (!usage)
-        return "unreported";
-    return `${usage.source}:${usage.model || "-"}:${usage.inputTokens ?? "-"}:${usage.outputTokens ?? "-"}`;
-}
-// ---------------------------------------------------------------------------
-// Worker / unit helpers
-// ---------------------------------------------------------------------------
-/** A worker's recorded end timestamp, or undefined when still in-flight. */
 function workerEndAt(worker) {
-    if (worker.output?.recordedAt)
-        return worker.output.recordedAt;
+    const output = worker.output;
+    if (output?.recordedAt)
+        return output.recordedAt;
     if (["completed", "verified", "failed", "rejected"].includes(worker.status))
         return worker.updatedAt;
     return undefined;
 }
-// ---------------------------------------------------------------------------
-// Usage + cost
-// ---------------------------------------------------------------------------
-/** The work units that COULD carry attested usage: every worker that produced
- *  output, plus every completed task NOT already represented by such a worker (a
- *  worker-output-backed task's usage rides on the worker, so it is never
- *  double-counted; a task completed directly via `cw result` is its own unit
- *  even if a worker was allocated but never recorded output). */
 function usageUnits(run) {
     const units = [];
     const outputTaskIds = new Set();
     for (const worker of run.workers || []) {
         if (worker.output) {
-            outputTaskIds.add(worker.output.taskId || worker.taskId);
+            const output = worker.output;
+            outputTaskIds.add(output.taskId || worker.taskId);
             units.push({ unit: worker.id, kind: "worker", usage: worker.usage });
         }
     }
-    for (const task of run.tasks || []) {
+    for (const task of run.tasks) {
         if (task.status === "completed" && !outputTaskIds.has(task.id)) {
             units.push({ unit: task.id, kind: "task", usage: task.usage });
         }
@@ -204,16 +183,10 @@ function deriveUsageTotals(run) {
         inputTokens,
         outputTokens,
         totalTokens,
-        models: [...models].sort()
+        models: [...models].sort(),
     };
     return { totals, rows };
 }
-/** Track 1 cryptographic attestation coverage over a run's work units, plus the
- *  tamper-evident ledger state. DIFFERENT axis from UsageTotals.coverage: that
- *  counts units that merely carry a usage record; here `attested` counts units
- *  whose reported usage VERIFIED against the operator trust key. Deterministic —
- *  reads recorded `usage.attestation` and recomputes the ledger chain; no
- *  now-derived field, so it stays byte-stable for CLI<->MCP parity. */
 function deriveAttestationCoverage(run) {
     const units = usageUnits(run);
     let attested = 0;
@@ -234,12 +207,11 @@ function deriveAttestationCoverage(run) {
                 absent++;
                 break;
             default:
-                // A usage record with no verdict (operator-recorded / legacy intake).
                 unverified++;
         }
     }
     const unitCount = units.length;
-    const ledger = (0, telemetry_ledger_1.verifyTelemetryLedger)(run);
+    const ledger = (0, telemetry_ledger_io_1.verifyTelemetryLedger)(run);
     return {
         units: unitCount,
         attested,
@@ -247,36 +219,23 @@ function deriveAttestationCoverage(run) {
         absent,
         unverified,
         verifiedCoverage: unitCount > 0 ? round(attested / unitCount, 6) : null,
-        ledger: { present: ledger.present, verified: ledger.verified, records: ledger.records.length }
+        ledger: { present: ledger.present, verified: ledger.verified, records: ledger.records.length },
     };
 }
-/** Compute cost from attested usage × an optional pricing policy. The contract:
- *  attested = exact-match priced; estimated = default/fallback priced; unpriced =
- *  attested usage with no policy coverage; unreported = no attested usage. */
+function priceUsage(usage, price) {
+    const input = ((usage.inputTokens || 0) / 1_000_000) * price.inputPerMillion;
+    const output = ((usage.outputTokens || 0) / 1_000_000) * price.outputPerMillion;
+    const cacheRead = ((usage.cacheReadTokens || 0) / 1_000_000) * (price.cacheReadPerMillion || 0);
+    const cacheWrite = ((usage.cacheWriteTokens || 0) / 1_000_000) * (price.cacheWritePerMillion || 0);
+    return input + output + cacheRead + cacheWrite;
+}
 function deriveCost(rows, policy) {
     const currency = policy?.currency || "USD";
     if (rows.length === 0) {
-        return {
-            state: "unreported",
-            currency,
-            attestedUsd: null,
-            estimatedUsd: null,
-            policyId: policy?.id,
-            unpricedModels: [],
-            pricedCoverage: null,
-            notes: ["No attested usage on this run; cost is unreported, not zero."]
-        };
+        return { state: "unreported", currency, attestedUsd: null, estimatedUsd: null, policyId: policy?.id, unpricedModels: [], pricedCoverage: null, notes: ["No attested usage on this run; cost is unreported, not zero."] };
     }
     if (!policy) {
-        return {
-            state: "unpriced",
-            currency,
-            attestedUsd: null,
-            estimatedUsd: null,
-            unpricedModels: [],
-            pricedCoverage: null,
-            notes: ["Attested usage present but no pricing policy supplied; pass --pricing <path> to price it."]
-        };
+        return { state: "unpriced", currency, attestedUsd: null, estimatedUsd: null, unpricedModels: [], pricedCoverage: null, notes: ["Attested usage present but no pricing policy supplied; pass --pricing <path> to price it."] };
     }
     const byModel = new Map();
     for (const m of policy.models || [])
@@ -288,19 +247,18 @@ function deriveCost(rows, policy) {
     let usedDefault = false;
     let usedExact = false;
     const unpriced = new Set();
-    for (const row of rows) {
-        const usage = row.usage;
-        const tokens = tokenTotal(usage);
+    for (const rowUsage of rows.map((r) => r.usage)) {
+        const tokens = tokenTotal(rowUsage);
         attestedTokens += tokens;
-        const model = usage.model;
+        const model = rowUsage.model;
         const exact = model ? byModel.get(model) : undefined;
         const price = exact || policy.defaultPrice;
         if (!price) {
             if (model)
                 unpriced.add(model);
-            continue; // attested usage we cannot price under this policy
+            continue;
         }
-        const cost = priceUsage(usage, price);
+        const cost = priceUsage(rowUsage, price);
         pricedTokens += tokens;
         if (exact) {
             attestedUsd += cost;
@@ -335,26 +293,14 @@ function deriveCost(rows, policy) {
         policyId: policy.id,
         unpricedModels: [...unpriced].sort(),
         pricedCoverage: attestedTokens > 0 ? round(pricedTokens / attestedTokens, 6) : null,
-        notes
+        notes,
     };
 }
-function priceUsage(usage, price) {
-    const input = ((usage.inputTokens || 0) / 1_000_000) * price.inputPerMillion;
-    const output = ((usage.outputTokens || 0) / 1_000_000) * price.outputPerMillion;
-    const cacheRead = ((usage.cacheReadTokens || 0) / 1_000_000) * (price.cacheReadPerMillion || 0);
-    const cacheWrite = ((usage.cacheWriteTokens || 0) / 1_000_000) * (price.cacheWritePerMillion || 0);
-    return input + output + cacheRead + cacheWrite;
-}
-// ---------------------------------------------------------------------------
-// Rates (each a fail-closed RateMetric with explicit sample counts)
-// ---------------------------------------------------------------------------
 function deriveFailureRate(run) {
     const workers = run.workers || [];
     const memberships = run.multiAgent?.memberships || [];
     const feedback = run.feedback || [];
-    // Tasks not backed by a worker (a worker-backed task's outcome rides on its
-    // worker), counted only when dispatched (an attempt actually happened).
-    const tasks = (run.tasks || []).filter((t) => !t.workerId && t.dispatchedAt);
+    const tasks = run.tasks.filter((t) => !t.workerId && t.dispatchedAt);
     const workersFailed = workers.filter((w) => w.status === "failed" || w.status === "rejected").length;
     const tasksFailed = tasks.filter((t) => t.status === "failed").length;
     const membershipsFailed = memberships.filter((m) => m.status === "failed").length;
@@ -369,7 +315,7 @@ function deriveFailureRate(run) {
         memberships: memberships.length,
         membershipsFailed,
         feedback: feedback.length,
-        feedbackUnresolved
+        feedbackUnresolved,
     });
 }
 function deriveVerifierPassRate(run) {
@@ -386,7 +332,6 @@ function deriveVerifierPassRate(run) {
         else if (VERIFIER_FAIL_STATUSES.has(gate.status)) {
             decided++;
         }
-        // pending/running gates are undecided ⇒ excluded from the denominator.
     }
     return rate("verifier-pass", passed, decided, buckets);
 }
@@ -401,41 +346,56 @@ function deriveCandidateAcceptanceRate(run) {
     }
     return rate("candidate-acceptance", accepted, candidates.length, buckets);
 }
-// ---------------------------------------------------------------------------
-// Time / duration
-// ---------------------------------------------------------------------------
 function taskRows(run) {
-    return (run.tasks || [])
-        .map((task) => ({
-        id: task.id,
-        kind: "task",
-        status: task.status,
-        duration: duration(task.dispatchedAt, task.completedAt)
-    }))
+    return run.tasks
+        .map((task) => ({ id: task.id, kind: "task", status: task.status, duration: duration(task.dispatchedAt, task.completedAt) }))
         .sort((a, b) => a.id.localeCompare(b.id));
 }
 function workerRows(run) {
     return (run.workers || [])
-        .map((worker) => ({
-        id: worker.id,
-        kind: "worker",
-        status: worker.status,
-        duration: duration(worker.createdAt, workerEndAt(worker))
-    }))
+        .map((worker) => ({ id: worker.id, kind: "worker", status: worker.status, duration: duration(worker.createdAt, workerEndAt(worker)) }))
         .sort((a, b) => a.id.localeCompare(b.id));
 }
+function targetCreatedAt(run, target) {
+    if (target.kind === "candidate")
+        return (run.candidates || []).find((e) => e.id === target.id)?.createdAt;
+    if (target.kind === "commit")
+        return (run.commits || []).find((e) => e.id === target.id)?.createdAt;
+    if (target.kind === "selection")
+        return (run.candidateSelections || []).find((e) => e.id === target.id)?.selectedAt;
+    return undefined;
+}
+function deriveCollaborationMetrics(run) {
+    const collab = run.collaboration;
+    const approvalRecords = (collab?.approvals || []).filter((r) => r.decision === "approve");
+    const rejectionRecords = (collab?.approvals || []).filter((r) => r.decision === "reject");
+    const reviewers = new Set(approvalRecords.map((r) => r.actor?.id).filter((id) => id && id !== "unattributed"));
+    const samples = [];
+    for (const record of approvalRecords) {
+        const createdAt = targetCreatedAt(run, record.target);
+        const ms = durationMsBetween(createdAt, record.createdAt);
+        if (ms !== null)
+            samples.push(ms);
+    }
+    const meanMs = samples.length ? Math.round(samples.reduce((acc, ms) => acc + ms, 0) / samples.length) : null;
+    const maxMs = samples.length ? Math.max(...samples) : null;
+    return {
+        approvals: approvalRecords.length,
+        rejections: rejectionRecords.length,
+        comments: (collab?.comments || []).length,
+        handoffs: (collab?.handoffs || []).length,
+        reviewers: reviewers.size,
+        approvalRate: rate("approval", approvalRecords.length, approvalRecords.length + rejectionRecords.length, { approve: approvalRecords.length, reject: rejectionRecords.length }),
+        timeToApproval: { samples: samples.length, meanMs, maxMs },
+    };
+}
 function deriveMetricsReport(run, options) {
     const tasks = taskRows(run);
     const workers = workerRows(run);
     const activeTaskMs = tasks.reduce((acc, row) => acc + (row.duration.wallClockMs || 0), 0);
     const inFlight = tasks.filter((t) => t.duration.inFlight).length + workers.filter((w) => w.duration.inFlight).length;
-    const pendingOrRunning = (run.tasks || []).filter((t) => t.status === "pending" || t.status === "running").length;
-    const runDuration = {
-        startedAt: run.createdAt,
-        endedAt: run.updatedAt,
-        wallClockMs: durationMs(run.createdAt, run.updatedAt),
-        inFlight: pendingOrRunning > 0
-    };
+    const pendingOrRunning = run.tasks.filter((t) => t.status === "pending" || t.status === "running").length;
+    const runDuration = { startedAt: run.createdAt, endedAt: run.updatedAt, wallClockMs: durationMsBetween(run.createdAt, run.updatedAt), inFlight: pendingOrRunning > 0 };
     const { totals, rows } = deriveUsageTotals(run);
     const cost = deriveCost(rows, options.policy);
     const currentFingerprint = fingerprintMetricsSource(run);
@@ -447,39 +407,22 @@ function deriveMetricsReport(run, options) {
     else
         status = "stale";
     const backendIds = new Set();
-    for (const task of run.tasks || [])
+    for (const task of run.tasks)
         if (task.backendId)
             backendIds.add(task.backendId);
     for (const worker of run.workers || [])
         if (worker.backendId)
             backendIds.add(worker.backendId);
-    const report = {
+    return {
         schemaVersion: exports.METRICS_SCHEMA_VERSION,
         surface: "metrics",
         runId: run.id,
         generatedAt: options.now,
         sourceFingerprint: currentFingerprint,
-        freshness: {
-            status,
-            persistedFingerprint: options.persistedFingerprint,
-            currentFingerprint
-        },
-        scope: {
-            app: run.workflow.app?.id || run.workflow.id,
-            backendIds: [...backendIds].sort()
-        },
-        time: {
-            run: runDuration,
-            activeTaskMs,
-            inFlight,
-            tasks,
-            workers
-        },
-        rates: {
-            failure: deriveFailureRate(run),
-            verifierPass: deriveVerifierPassRate(run),
-            candidateAcceptance: deriveCandidateAcceptanceRate(run)
-        },
+        freshness: { status, persistedFingerprint: options.persistedFingerprint, currentFingerprint },
+        scope: { app: run.workflow.app?.id || run.workflow.id, backendIds: [...backendIds].sort() },
+        time: { run: runDuration, activeTaskMs, inFlight, tasks, workers },
+        rates: { failure: deriveFailureRate(run), verifierPass: deriveVerifierPassRate(run), candidateAcceptance: deriveCandidateAcceptanceRate(run) },
         usage: totals,
         cost,
         attestedUsage: rows,
@@ -487,94 +430,37 @@ function deriveMetricsReport(run, options) {
         collaboration: deriveCollaborationMetrics(run),
         nextAction: totals.unreportedUnits > 0 && totals.attestedUnits === 0
             ? "No attested usage yet — record host usage on result/worker intake (cw result ... --usage-input-tokens N --usage-output-tokens M --usage-model ID)."
-            : `node scripts/cw.js metrics show ${run.id} --json`
+            : `node scripts/cw.js metrics show ${run.id} --json`,
     };
-    return report;
 }
-/** v0.1.32 collaboration metrics — counts, approval rate, and time-to-approval,
- *  all from append-only records + recorded timestamps. The ONLY now-derived
- *  field anywhere in the report remains `generatedAt`; these are byte-stable. */
-function deriveCollaborationMetrics(run) {
-    const collab = run.collaboration;
-    const approvalRecords = (collab?.approvals || []).filter((record) => record.decision === "approve");
-    const rejectionRecords = (collab?.approvals || []).filter((record) => record.decision === "reject");
-    const reviewers = new Set(approvalRecords.map((record) => record.actor?.id).filter((id) => id && id !== "unattributed"));
-    const samples = [];
-    for (const record of approvalRecords) {
-        const createdAt = targetCreatedAt(run, record.target);
-        const ms = durationMs(createdAt, record.createdAt);
-        if (ms !== null)
-            samples.push(ms);
-    }
-    const meanMs = samples.length ? Math.round(samples.reduce((acc, ms) => acc + ms, 0) / samples.length) : null;
-    const maxMs = samples.length ? Math.max(...samples) : null;
-    return {
-        approvals: approvalRecords.length,
-        rejections: rejectionRecords.length,
-        comments: (collab?.comments || []).length,
-        handoffs: (collab?.handoffs || []).length,
-        reviewers: reviewers.size,
-        approvalRate: rate("approval", approvalRecords.length, approvalRecords.length + rejectionRecords.length, {
-            approve: approvalRecords.length,
-            reject: rejectionRecords.length
-        }),
-        timeToApproval: { samples: samples.length, meanMs, maxMs }
-    };
-}
-/** Recorded creation timestamp of an approval's target (for time-to-approval). */
-function targetCreatedAt(run, target) {
-    if (target.kind === "candidate")
-        return (run.candidates || []).find((entry) => entry.id === target.id)?.createdAt;
-    if (target.kind === "commit")
-        return (run.commits || []).find((entry) => entry.id === target.id)?.createdAt;
-    if (target.kind === "selection")
-        return (run.candidateSelections || []).find((entry) => entry.id === target.id)?.selectedAt;
-    return undefined;
-}
-// ---------------------------------------------------------------------------
-// Persistence — a rebuildable, fingerprinted snapshot (fail-closed freshness).
-// ---------------------------------------------------------------------------
 function metricsDir(run) {
-    return node_path_1.default.join(run.paths.runDir, "metrics");
+    return path.join(run.paths.runDir, "metrics");
 }
 function metricsReportPath(run) {
-    return node_path_1.default.join(metricsDir(run), "metrics-report.json");
+    return path.join(metricsDir(run), "metrics-report.json");
 }
-/** Read the persisted source fingerprint for this run, if any (never throws). */
 function loadPersistedMetricsFingerprint(run) {
     const file = metricsReportPath(run);
-    if (!node_fs_1.default.existsSync(file))
+    if (!fs.existsSync(file))
         return undefined;
     try {
-        const parsed = (0, state_1.readJson)(file);
-        return parsed.sourceFingerprint;
+        return (0, fs_atomic_1.readJson)(file).sourceFingerprint;
     }
     catch {
         return undefined;
     }
 }
-/** Derive + persist the per-run report. The RETURNED payload is order- and
- *  cache-independent (freshness === "valid", persistedFingerprint === itself),
- *  so `cw metrics show --json` and `cw_metrics_show` are byte-identical. The
- *  persisted file is what the cross-repo summary + Workbench read back. */
+/** Derive + persist the per-run report. The RETURNED payload is pinned to
+ *  `freshness: "valid"` (persistedFingerprint === itself) so `cw metrics
+ *  show --json` and the MCP tool are byte-identical; NEVER touches
+ *  state.json (invariant 6). */
 function showMetricsReport(run, options) {
     const live = deriveMetricsReport(run, { now: options.now, policy: options.policy });
-    const report = {
-        ...live,
-        freshness: {
-            status: "valid",
-            persistedFingerprint: live.sourceFingerprint,
-            currentFingerprint: live.sourceFingerprint
-        }
-    };
-    node_fs_1.default.mkdirSync(metricsDir(run), { recursive: true });
-    (0, state_1.writeJson)(metricsReportPath(run), report);
+    const report = { ...live, freshness: { status: "valid", persistedFingerprint: live.sourceFingerprint, currentFingerprint: live.sourceFingerprint } };
+    fs.mkdirSync(metricsDir(run), { recursive: true });
+    (0, fs_atomic_1.writeJson)(metricsReportPath(run), report);
     return report;
 }
-// ---------------------------------------------------------------------------
-// Cross-repo rollup (pool samples; sum attested usage/cost with coverage).
-// ---------------------------------------------------------------------------
-/** Pool a list of RateMetrics into one (insufficient-data when no samples). */
 function poolRates(metric, rates) {
     let count = 0;
     let total = 0;
@@ -587,7 +473,6 @@ function poolRates(metric, rates) {
     }
     return rate(metric, count, total, buckets);
 }
-/** Sum a list of UsageTotals (coverage recomputed over pooled units). */
 function poolUsage(list) {
     let units = 0;
     let attestedUnits = 0;
@@ -604,19 +489,8 @@ function poolUsage(list) {
         for (const m of u.models)
             models.add(m);
     }
-    return {
-        units,
-        attestedUnits,
-        unreportedUnits: units - attestedUnits,
-        coverage: units > 0 ? round(attestedUnits / units, 6) : null,
-        inputTokens,
-        outputTokens,
-        totalTokens,
-        models: [...models].sort()
-    };
+    return { units, attestedUnits, unreportedUnits: units - attestedUnits, coverage: units > 0 ? round(attestedUnits / units, 6) : null, inputTokens, outputTokens, totalTokens, models: [...models].sort() };
 }
-/** Sum a list of CostMetrics (attested + estimated kept separate; states merge
- *  conservatively so attested+estimated never collapses into one figure). */
 function poolCost(list) {
     const currency = list.find((c) => c.currency)?.currency || "USD";
     let attestedUsd = null;
@@ -659,41 +533,13 @@ function poolCost(list) {
     const notes = [];
     if (anyAttested && anyEstimated)
         notes.push("Totals mix exact-priced (attested) and default-priced (estimated) runs; the two USD figures are kept separate.");
-    return {
-        state,
-        currency,
-        attestedUsd,
-        estimatedUsd,
-        policyId,
-        unpricedModels: [...unpriced].sort(),
-        pricedCoverage: null,
-        notes
-    };
+    return { state, currency, attestedUsd, estimatedUsd, policyId, unpricedModels: [...unpriced].sort(), pricedCoverage: null, notes };
 }
-/** Build the cross-repo rollup from already-loaded runs. PURE over its inputs +
- *  injected `now`. `unreadableRuns` counts runs whose source could not be loaded
- *  (the caller passes the count); they are surfaced, never silently dropped. */
 function deriveMetricsSummary(inputs, options) {
     const perRun = [];
     for (const input of inputs) {
-        const report = deriveMetricsReport(input.run, {
-            now: options.now,
-            policy: options.policy,
-            persistedFingerprint: input.persistedFingerprint
-        });
-        perRun.push({
-            report,
-            ref: {
-                runId: report.runId,
-                repo: input.repo,
-                app: report.scope.app,
-                backendIds: report.scope.backendIds,
-                freshness: report.freshness.status,
-                rates: report.rates,
-                usage: report.usage,
-                cost: report.cost
-            }
-        });
+        const report = deriveMetricsReport(input.run, { now: options.now, policy: options.policy, persistedFingerprint: input.persistedFingerprint });
+        perRun.push({ report, ref: { runId: report.runId, repo: input.repo, app: report.scope.app, backendIds: report.scope.backendIds, freshness: report.freshness.status, rates: report.rates, usage: report.usage, cost: report.cost } });
     }
     perRun.sort((a, b) => a.report.runId.localeCompare(b.report.runId));
     const groupBy = (keyOf) => {
@@ -710,13 +556,9 @@ function deriveMetricsSummary(inputs, options) {
             .map(([key, reports]) => ({
             key,
             runCount: reports.length,
-            rates: {
-                failure: poolRates("failure", reports.map((r) => r.rates.failure)),
-                verifierPass: poolRates("verifier-pass", reports.map((r) => r.rates.verifierPass)),
-                candidateAcceptance: poolRates("candidate-acceptance", reports.map((r) => r.rates.candidateAcceptance))
-            },
+            rates: { failure: poolRates("failure", reports.map((r) => r.rates.failure)), verifierPass: poolRates("verifier-pass", reports.map((r) => r.rates.verifierPass)), candidateAcceptance: poolRates("candidate-acceptance", reports.map((r) => r.rates.candidateAcceptance)) },
             usage: poolUsage(reports.map((r) => r.usage)),
-            cost: poolCost(reports.map((r) => r.cost))
+            cost: poolCost(reports.map((r) => r.cost)),
         }));
     };
     const allReports = perRun.map((p) => p.report);
@@ -742,11 +584,7 @@ function deriveMetricsSummary(inputs, options) {
         generatedAt: options.now,
         runCount: perRun.length,
         unreadableRuns: options.unreadableRuns || 0,
-        rates: {
-            failure: poolRates("failure", allReports.map((r) => r.rates.failure)),
-            verifierPass: poolRates("verifier-pass", allReports.map((r) => r.rates.verifierPass)),
-            candidateAcceptance: poolRates("candidate-acceptance", allReports.map((r) => r.rates.candidateAcceptance))
-        },
+        rates: { failure: poolRates("failure", allReports.map((r) => r.rates.failure)), verifierPass: poolRates("verifier-pass", allReports.map((r) => r.rates.verifierPass)), candidateAcceptance: poolRates("candidate-acceptance", allReports.map((r) => r.rates.candidateAcceptance)) },
         usage: poolUsage(allReports.map((r) => r.usage)),
         cost: poolCost(allReports.map((r) => r.cost)),
         totalOutputBytes,
@@ -754,23 +592,12 @@ function deriveMetricsSummary(inputs, options) {
         byApp: groupBy((r) => [r.scope.app || "unknown"]),
         byBackend: groupBy((r) => (r.scope.backendIds.length ? r.scope.backendIds : ["unreported"])),
         runs: perRun.map((p) => p.ref),
-        nextAction: perRun.length === 0 ? "No indexed runs; run a workflow, then `cw metrics summary`." : "Per-run detail: cw metrics show <run-id> --json"
+        nextAction: perRun.length === 0 ? "No indexed runs; run a workflow, then `cw metrics summary`." : "Per-run detail: cw metrics show <run-id> --json",
     };
 }
-// ---------------------------------------------------------------------------
-// Intake (POLICY as DATA + host-attested usage parsing) now lives in
-// ./observability/intake.ts (god-module carve). Re-exported so importers of
-// "./observability" keep the unchanged surface.
-// ---------------------------------------------------------------------------
-var intake_1 = require("./observability/intake");
-Object.defineProperty(exports, "loadCostPolicy", { enumerable: true, get: function () { return intake_1.loadCostPolicy; } });
-Object.defineProperty(exports, "parseUsageFromArgs", { enumerable: true, get: function () { return intake_1.parseUsageFromArgs; } });
-// ---------------------------------------------------------------------------
-// Human formatters (CLI default text; --json emits the canonical payload) now
-// live in ./observability/format.ts (god-module carve, mirrors
-// run-registry/format.ts). Re-exported so importers of "./observability" keep
-// the unchanged surface.
-// ---------------------------------------------------------------------------
-var format_1 = require("./observability/format");
-Object.defineProperty(exports, "formatMetricsReport", { enumerable: true, get: function () { return format_1.formatMetricsReport; } });
-Object.defineProperty(exports, "formatMetricsSummary", { enumerable: true, get: function () { return format_1.formatMetricsSummary; } });
+var observability_intake_1 = require("./observability-intake");
+Object.defineProperty(exports, "loadCostPolicy", { enumerable: true, get: function () { return observability_intake_1.loadCostPolicy; } });
+Object.defineProperty(exports, "parseUsageFromArgs", { enumerable: true, get: function () { return observability_intake_1.parseUsageFromArgs; } });
+var observability_format_1 = require("./observability-format");
+Object.defineProperty(exports, "formatMetricsReport", { enumerable: true, get: function () { return observability_format_1.formatMetricsReport; } });
+Object.defineProperty(exports, "formatMetricsSummary", { enumerable: true, get: function () { return observability_format_1.formatMetricsSummary; } });