@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-WVO7V2QY.js

@@ -0,0 +1,797 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readEvidenceIndex,
+  writeEvidenceIndexRowQueued
+} from "./chunk-HC4CLZ2Y.js";
+import {
+  createDispatchTraceMirror,
+  traceDatabasePath
+} from "./chunk-HFSBBKSQ.js";
+import {
+  FAILURE_CAUSE_TAGS,
+  buildEvidence
+} from "./chunk-6EJV5X2W.js";
+import {
+  normalizeCostProvenance
+} from "./chunk-LZSJBIVT.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
+import {
+  BusChannels
+} from "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/observability/cost.ts
+init_esm_shims();
+function emptyCostAggregate() {
+  return { knownUsd: 0, hasEstimated: false, hasUnknown: false, allKnownFree: false, calls: 0 };
+}
+function costWasMeasured(cost) {
+  return cost !== null && cost !== void 0 && cost.calls > 0;
+}
+function accumulateCostAmount(aggregate, amount, first) {
+  return {
+    knownUsd: aggregate.knownUsd + (amount.provenance === "unknown" ? 0 : amount.usd),
+    hasEstimated: aggregate.hasEstimated || amount.provenance === "estimated",
+    hasUnknown: aggregate.hasUnknown || amount.provenance === "unknown",
+    allKnownFree: amount.provenance === "known_free" && (first || aggregate.allKnownFree),
+    calls: aggregate.calls + 1
+  };
+}
+function aggregateCostAmounts(amounts) {
+  return amounts.reduce(
+    (aggregate, amount, index) => accumulateCostAmount(aggregate, amount, index === 0),
+    emptyCostAggregate()
+  );
+}
+function formatUsdAmount(value) {
+  if (!Number.isFinite(value) || value <= 0) return "$0.00";
+  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
+}
+function formatCostAggregate(cost) {
+  if (!costWasMeasured(cost)) return null;
+  if (cost.allKnownFree) return "$0.00 local";
+  if (cost.hasUnknown) return cost.knownUsd > 0 ? `${formatUsdAmount(cost.knownUsd)} +?` : null;
+  if (cost.hasEstimated) return `~${formatUsdAmount(cost.knownUsd)} est`;
+  return formatUsdAmount(cost.knownUsd);
+}
+var COST_NOT_MEASURED = "not measured";
+function costAggregateForAmount(usd, provenance) {
+  return aggregateCostAmounts([{ usd, provenance: normalizeCostProvenance(provenance) }]);
+}
+function emptyBreakdown() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoningTokens: 0, totalTokens: 0 };
+}
+function createCostTracker() {
+  const log = [];
+  let total = 0;
+  const totals = emptyBreakdown();
+  return {
+    accumulate(providerId, modelId, tokens, usd, breakdown, costProvenance) {
+      const resolvedUsd = usd ?? 0;
+      const provenance = normalizeCostProvenance(costProvenance);
+      const input = breakdown?.input ?? 0;
+      const output = breakdown?.output ?? 0;
+      const cacheRead = breakdown?.cacheRead ?? 0;
+      const cacheWrite = breakdown?.cacheWrite ?? 0;
+      const reasoningTokens = breakdown?.reasoningTokens ?? 0;
+      const apiCalls = breakdown?.apiCalls;
+      log.push({
+        providerId,
+        modelId,
+        tokens,
+        usd: resolvedUsd,
+        provenance,
+        input,
+        output,
+        cacheRead,
+        cacheWrite,
+        reasoningTokens,
+        ...apiCalls !== void 0 ? { apiCalls } : {}
+      });
+      total += resolvedUsd;
+      totals.input += input;
+      totals.output += output;
+      totals.cacheRead += cacheRead;
+      totals.cacheWrite += cacheWrite;
+      totals.reasoningTokens += reasoningTokens;
+      totals.totalTokens += tokens;
+      return resolvedUsd;
+    },
+    sessionTotal() {
+      return total;
+    },
+    sessionCost() {
+      return aggregateCostAmounts(log.map((entry) => ({ usd: entry.usd, provenance: entry.provenance })));
+    },
+    sessionTokens() {
+      return { ...totals };
+    },
+    entries() {
+      return log;
+    },
+    reset() {
+      log.length = 0;
+      total = 0;
+      totals.input = 0;
+      totals.output = 0;
+      totals.cacheRead = 0;
+      totals.cacheWrite = 0;
+      totals.reasoningTokens = 0;
+      totals.totalTokens = 0;
+    }
+  };
+}
+
+// src/domains/observability/index.ts
+init_esm_shims();
+
+// src/domains/observability/extension.ts
+init_esm_shims();
+
+// src/domains/observability/accountability.ts
+init_esm_shims();
+function summarizeEvidenceIndex(rows) {
+  const totalRuns = rows.length;
+  let firstPassRuns = 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.firstPassSuccess) firstPassRuns += 1;
+    for (const tag of row.tags) {
+      if (!FAILURE_CAUSE_TAGS.has(tag)) continue;
+      counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    }
+  }
+  const failureCauses = [...counts.entries()].map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count !== a.count ? b.count - a.count : a.tag.localeCompare(b.tag));
+  return {
+    totalRuns,
+    firstPassRuns,
+    firstPassRate: totalRuns === 0 ? 0 : firstPassRuns / totalRuns,
+    failureCauses
+  };
+}
+function readAccountabilitySummary(stateDir) {
+  return summarizeEvidenceIndex(readEvidenceIndex(stateDir));
+}
+
+// src/domains/observability/metrics.ts
+init_esm_shims();
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.floor(p / 100 * sorted.length));
+  return sorted[idx] ?? 0;
+}
+function aggregateMetrics(snap) {
+  const histograms = {};
+  for (const [name, values] of Object.entries(snap.histograms)) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const count = sorted.length;
+    const avg = count > 0 ? sorted.reduce((s, v) => s + v, 0) / count : 0;
+    histograms[name] = { count, avg, p50: percentile(sorted, 50), p95: percentile(sorted, 95) };
+  }
+  return {
+    dispatchesCompleted: snap.counters["dispatch.completed"] ?? 0,
+    dispatchesFailed: snap.counters["dispatch.failed"] ?? 0,
+    safetyClassifications: snap.counters["safety.classified"] ?? 0,
+    totalTokens: snap.counters["tokens.total"] ?? 0,
+    histograms
+  };
+}
+
+// src/domains/observability/projection.ts
+init_esm_shims();
+var MAX_PROJECTION_RUNS = 50;
+var MAX_PROJECTION_NOTICES = 100;
+var PROJECTION_FLUSH_DEBOUNCE_MS = 16;
+function str(value, fallback) {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asRunId(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "aborted" || status === "dead";
+}
+function resolveHeartbeat(status) {
+  if (status === "alive") return "running";
+  if (status === "stale") return "stale";
+  if (status === "dead") return "dead";
+  return null;
+}
+function resolveFailedStatus(reason) {
+  if (reason === "dead" || reason === "stalled") return "dead";
+  if (reason === "interrupted" || reason === "canceled") return "aborted";
+  return "failed";
+}
+function normalizeLevel(value) {
+  return value === "error" || value === "warning" || value === "info" ? value : "info";
+}
+function makeRef(parts) {
+  const ref = {};
+  for (const [key, value] of Object.entries(parts)) {
+    if (typeof value === "string" && value.length > 0) ref[key] = value;
+  }
+  return Object.keys(ref).length > 0 ? ref : void 0;
+}
+function createObservabilityProjection(bus, deps) {
+  const runs = /* @__PURE__ */ new Map();
+  const notices = [];
+  const providerHealth = /* @__PURE__ */ new Map();
+  const pendingEvidence = /* @__PURE__ */ new Set();
+  let accountability = deps.readAccountability();
+  let revision = 0;
+  let noticeSeq = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let flushTimer = null;
+  function buildSnapshot() {
+    const providerHealthRecord = {};
+    for (const [id, status] of providerHealth) providerHealthRecord[id] = status;
+    return {
+      revision,
+      generatedAt: Date.now(),
+      session: {
+        costUsd: deps.sessionCost(),
+        cost: deps.sessionCostSummary(),
+        tokens: deps.sessionTokens(),
+        latestThroughput: deps.latestThroughput()
+      },
+      metrics: deps.metrics(),
+      accountability,
+      // Newest-first: Map preserves first-seen (enqueue) order, so reversing
+      // surfaces the most recently started runs at the head of the list.
+      runs: [...runs.values()].reverse(),
+      providerHealth: providerHealthRecord,
+      notices: [...notices],
+      pendingEvidenceBuildRunIds: [...pendingEvidence]
+    };
+  }
+  function flush() {
+    flushTimer = null;
+    if (listeners.size === 0) return;
+    const snapshot = buildSnapshot();
+    for (const listener of [...listeners]) {
+      try {
+        listener(snapshot);
+      } catch (error) {
+        const message = error instanceof Error ? error.stack ?? error.message : String(error);
+        console.error(`[clio:observability] projection listener crashed: ${message}`);
+      }
+    }
+  }
+  function scheduleFlush() {
+    if (flushTimer !== null) return;
+    flushTimer = setTimeout(flush, PROJECTION_FLUSH_DEBOUNCE_MS);
+    flushTimer.unref?.();
+  }
+  function markChanged() {
+    revision += 1;
+    scheduleFlush();
+  }
+  function putRun(runId, summary) {
+    runs.set(runId, summary);
+    while (runs.size > MAX_PROJECTION_RUNS) {
+      const oldest = runs.keys().next().value;
+      if (oldest === void 0) break;
+      runs.delete(oldest);
+    }
+  }
+  function emptyRun(runId, now) {
+    return {
+      runId,
+      agentId: "-",
+      status: "enqueued",
+      startedAtMs: now,
+      updatedAtMs: now,
+      finishedAtMs: null,
+      durationMs: null,
+      tokens: { input: 0, output: 0, reasoning: 0, total: 0 },
+      costUsd: 0,
+      costProvenance: "unknown"
+    };
+  }
+  function applyIdentity(summary, id) {
+    if (typeof id.agentId === "string" && id.agentId.length > 0) summary.agentId = id.agentId;
+    if (typeof id.targetId === "string" && id.targetId.length > 0) summary.targetId = id.targetId;
+    if (typeof id.wireModelId === "string" && id.wireModelId.length > 0) summary.modelId = id.wireModelId;
+    if (typeof id.runtimeId === "string" && id.runtimeId.length > 0) summary.runtimeId = id.runtimeId;
+    if (typeof id.runtimeKind === "string" && id.runtimeKind.length > 0) summary.runtimeKind = id.runtimeKind;
+  }
+  function applyTerminalTokens(summary, payload) {
+    if (typeof payload.tokenCount === "number") summary.tokens.total = payload.tokenCount;
+    if (typeof payload.inputTokenCount === "number") {
+      summary.tokens.input = payload.inputTokenCount + num(payload.cacheReadTokenCount, 0);
+    }
+    if (typeof payload.outputTokenCount === "number") summary.tokens.output = payload.outputTokenCount;
+    if (typeof payload.reasoningTokenCount === "number") summary.tokens.reasoning = payload.reasoningTokenCount;
+    if (typeof payload.costUsd === "number") summary.costUsd = payload.costUsd;
+    if (payload.costProvenance === "known" || payload.costProvenance === "known_free" || payload.costProvenance === "estimated" || payload.costProvenance === "unknown") {
+      summary.costProvenance = payload.costProvenance;
+    }
+  }
+  function pushNotice(kind, level, message, ref) {
+    const notice = {
+      id: `n${noticeSeq++}`,
+      at: Date.now(),
+      kind,
+      level,
+      message,
+      ...ref ? { ref } : {}
+    };
+    notices.push(notice);
+    if (notices.length > MAX_PROJECTION_NOTICES) {
+      notices.splice(0, notices.length - MAX_PROJECTION_NOTICES);
+    }
+    markChanged();
+  }
+  const unsubscribes = [
+    bus.on(BusChannels.DispatchEnqueued, (raw) => {
+      const payload = raw ?? {};
+      const runId = asRunId(payload.runId);
+      if (!runId) return;
+      const now = Date.now();
+      const summary = runs.get(runId) ?? emptyRun(runId, now);
+      applyIdentity(summary, payload);
+      summary.status = "enqueued";
+      summary.updatedAtMs = now;
+      putRun(runId, summary);
+      markChanged();
+    }),
+    bus.on(BusChannels.DispatchStarted, (raw) => {
+      const payload = raw ?? {};
+      const runId = asRunId(payload.runId);
+      if (!runId) return;
+      const now = Date.now();
+      const summary = runs.get(runId) ?? emptyRun(runId, now);
+      applyIdentity(summary, payload);
+      summary.status = "running";
+      summary.startedAtMs = now;
+      summary.updatedAtMs = now;
+      summary.finishedAtMs = null;
+      summary.durationMs = null;
+      putRun(runId, summary);
+      markChanged();
+    }),
+    bus.on(BusChannels.DispatchProgress, (raw) => {
+      const payload = raw ?? {};
+      const runId = asRunId(payload.runId);
+      if (!runId) return;
+      const summary = runs.get(runId);
+      if (!summary) return;
+      const now = Date.now();
+      summary.updatedAtMs = now;
+      const event = payload.event ?? {};
+      const type = typeof event.type === "string" ? event.type : "";
+      if (type === "heartbeat_status") {
+        const status = resolveHeartbeat(event.status);
+        if (status && !isTerminal(summary.status)) summary.status = status;
+        markChanged();
+        return;
+      }
+      if (type === "message_end" && !isTerminal(summary.status)) {
+        const message = event.message ?? {};
+        if (message.role === "assistant" && message.usage) {
+          const input = num(message.usage.input, 0) + num(message.usage.cacheRead, 0);
+          const output = num(message.usage.output, 0);
+          summary.tokens.input += input;
+          summary.tokens.output += output;
+          summary.tokens.total += input + output + num(message.usage.cacheWrite, 0);
+        }
+      }
+      markChanged();
+    }),
+    bus.on(BusChannels.DispatchCompleted, (raw) => {
+      const payload = raw ?? {};
+      const runId = asRunId(payload.runId);
+      if (!runId) return;
+      const now = Date.now();
+      const summary = runs.get(runId) ?? emptyRun(runId, now);
+      applyIdentity(summary, payload);
+      summary.status = "completed";
+      summary.updatedAtMs = now;
+      summary.finishedAtMs = now;
+      summary.durationMs = num(payload.durationMs, Math.max(0, now - summary.startedAtMs));
+      applyTerminalTokens(summary, payload);
+      summary.outcome = str(payload.outcome, "succeeded");
+      summary.outcomeDetail = typeof payload.outcomeDetail === "string" ? payload.outcomeDetail : null;
+      putRun(runId, summary);
+      markChanged();
+    }),
+    bus.on(BusChannels.DispatchFailed, (raw) => {
+      const payload = raw ?? {};
+      const runId = asRunId(payload.runId);
+      if (!runId) return;
+      const now = Date.now();
+      const summary = runs.get(runId) ?? emptyRun(runId, now);
+      applyIdentity(summary, payload);
+      summary.status = resolveFailedStatus(payload.reason);
+      summary.updatedAtMs = now;
+      summary.finishedAtMs = now;
+      summary.durationMs = num(payload.durationMs, Math.max(0, now - summary.startedAtMs));
+      applyTerminalTokens(summary, payload);
+      summary.outcome = str(payload.outcome, str(payload.reason, "failed"));
+      summary.outcomeDetail = typeof payload.outcomeDetail === "string" ? payload.outcomeDetail : null;
+      putRun(runId, summary);
+      markChanged();
+    }),
+    bus.on(BusChannels.ProviderHealth, (raw) => {
+      const payload = raw ?? {};
+      if (typeof payload.id !== "string" || payload.id.length === 0) return;
+      if (payload.status === null || typeof payload.status !== "object") return;
+      providerHealth.set(payload.id, payload.status);
+      markChanged();
+    }),
+    bus.on(BusChannels.RuntimeNotice, (raw) => {
+      const payload = raw ?? {};
+      pushNotice(
+        "runtime",
+        normalizeLevel(payload.level),
+        str(payload.message, "runtime notice"),
+        makeRef({ targetId: payload.targetId, modelId: payload.model })
+      );
+    }),
+    bus.on(BusChannels.MiddlewareHookFailed, (raw) => {
+      const payload = raw ?? {};
+      const kind = payload.kind;
+      if (kind === "budget_exceeded" && payload.steadyStateWarn !== true) return;
+      const hook = str(payload.hook, "hook");
+      const message = typeof payload.message === "string" && payload.message.length > 0 ? payload.message : kind === "budget_exceeded" ? `middleware hook ${hook} exceeded ${num(payload.budgetMs, 0)}ms budget` : `middleware hook ${hook} failed`;
+      pushNotice("middleware", kind === "budget_exceeded" ? "warning" : "error", message);
+    }),
+    bus.on(BusChannels.SafetyBlocked, (raw) => {
+      const payload = raw ?? {};
+      const tool = str(payload.tool, "tool");
+      const rejection = payload.rejection ?? {};
+      const short = str(rejection.short, `${str(payload.actionClass, "action")} blocked`);
+      pushNotice("safety", "warning", `${tool}: ${short}`, makeRef({ tool: payload.tool }));
+    }),
+    bus.on(BusChannels.LoopBlocked, (raw) => {
+      const payload = raw ?? {};
+      const tool = str(payload.tool, "tool");
+      pushNotice(
+        "loop",
+        payload.interrupted === true ? "error" : "warning",
+        `loop guard blocked repeated ${tool} (${num(payload.repeatCount, 0)}x)`,
+        makeRef({ tool: payload.tool })
+      );
+    }),
+    bus.on(BusChannels.ToolBudgetExceeded, (raw) => {
+      const payload = raw ?? {};
+      const tool = str(payload.tool, "tool");
+      pushNotice(
+        "tool-budget",
+        payload.interrupted === true ? "error" : "warning",
+        `tool-call budget reached on ${tool} (${num(payload.callsThisTurn, 0)} calls)`,
+        makeRef({ tool: payload.tool })
+      );
+    }),
+    bus.on(BusChannels.ContextPruned, (raw) => {
+      const payload = raw ?? {};
+      const reclaimed = Math.max(0, num(payload.tokensBefore, 0) - num(payload.tokensAfter, 0));
+      pushNotice("context", "info", `context pruned ${reclaimed} tokens (${str(payload.stage, "prune")})`);
+    }),
+    bus.on(BusChannels.BudgetAlert, (raw) => {
+      const payload = raw ?? {};
+      const over = payload.level === "over";
+      pushNotice(
+        "budget",
+        over ? "error" : "warning",
+        `session cost $${num(payload.currentUsd, 0).toFixed(2)} ${over ? "over" : "at"} $${num(payload.ceilingUsd, 0).toFixed(2)} ceiling`
+      );
+    })
+  ];
+  return {
+    snapshot: buildSnapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(buildSnapshot());
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    refresh() {
+      markChanged();
+    },
+    evidenceBuildStarted(runId) {
+      if (typeof runId !== "string" || runId.length === 0) return;
+      pendingEvidence.add(runId);
+      markChanged();
+    },
+    evidenceBuildSucceeded(runId, evidence) {
+      pendingEvidence.delete(runId);
+      const summary = runs.get(runId);
+      if (summary) {
+        summary.evidence = {
+          evidenceId: evidence.evidenceId,
+          firstPassSuccess: evidence.firstPassSuccess,
+          findingCount: evidence.findingCount,
+          tags: [...evidence.tags]
+        };
+      }
+      accountability = deps.readAccountability();
+      markChanged();
+    },
+    evidenceBuildFailed(runId, message) {
+      pendingEvidence.delete(runId);
+      pushNotice(
+        "evidence",
+        "warning",
+        message.length > 0 ? message : `evidence build failed for ${runId}`,
+        makeRef({ runId })
+      );
+    },
+    stop() {
+      for (const off of unsubscribes) off();
+      unsubscribes.length = 0;
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      listeners.clear();
+    }
+  };
+}
+
+// src/domains/observability/telemetry.ts
+init_esm_shims();
+var DEFAULT_HISTOGRAM_CAPACITY = 256;
+var BoundedSamples = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  capacity;
+  buffer = [];
+  writeIndex = 0;
+  push(value) {
+    if (this.buffer.length < this.capacity) {
+      this.buffer.push(value);
+      return;
+    }
+    this.buffer[this.writeIndex] = value;
+    this.writeIndex = (this.writeIndex + 1) % this.capacity;
+  }
+  values() {
+    return [...this.buffer];
+  }
+};
+function createTelemetry(histogramCapacity = DEFAULT_HISTOGRAM_CAPACITY) {
+  const capacity = Math.max(1, Math.floor(histogramCapacity));
+  const counters = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  return {
+    record(kind, name, value) {
+      if (kind === "counter") {
+        counters.set(name, (counters.get(name) ?? 0) + value);
+        return;
+      }
+      let bucket = histograms.get(name);
+      if (!bucket) {
+        bucket = new BoundedSamples(capacity);
+        histograms.set(name, bucket);
+      }
+      bucket.push(value);
+    },
+    snapshot() {
+      const c = {};
+      for (const [k, v] of counters) c[k] = v;
+      const h = {};
+      for (const [k, v] of histograms) h[k] = v.values();
+      return { counters: c, histograms: h };
+    },
+    reset() {
+      counters.clear();
+      histograms.clear();
+    }
+  };
+}
+
+// src/domains/observability/extension.ts
+function recordDispatchCost(telemetry, cost, payload) {
+  if (!payload.targetId || !payload.wireModelId || typeof payload.tokenCount !== "number") {
+    return;
+  }
+  telemetry.record("counter", "tokens.total", payload.tokenCount);
+  cost.accumulate(
+    payload.targetId,
+    payload.wireModelId,
+    payload.tokenCount,
+    payload.costUsd,
+    {
+      input: payload.inputTokenCount ?? 0,
+      output: payload.outputTokenCount ?? 0,
+      cacheRead: payload.cacheReadTokenCount ?? 0,
+      cacheWrite: payload.cacheWriteTokenCount ?? 0,
+      reasoningTokens: payload.reasoningTokenCount ?? 0,
+      totalTokens: payload.tokenCount
+    },
+    payload.costProvenance
+  );
+}
+async function buildAndIndexEvidence(runId, succeeded, attempt, hooks) {
+  try {
+    const dataDir = clioDataDir();
+    const stateDir = clioStateDir();
+    const result = await buildEvidence({ dataDir, stateDir, runId });
+    const row = evidenceIndexRow(runId, result, succeeded, attempt);
+    await writeEvidenceIndexRowQueued(stateDir, row);
+    hooks.onReady(runId, {
+      evidenceId: row.evidenceId,
+      firstPassSuccess: row.firstPassSuccess,
+      findingCount: row.findingCount,
+      tags: row.tags
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[clio:evidence] auto-build failed for run ${runId}: ${message}
+`);
+    hooks.onFailed(runId, message);
+  }
+}
+function evidenceIndexRow(runId, result, succeeded, attempt) {
+  const tags = result.overview.tags;
+  const hasNoValidationTag = tags.includes("no-validation") || result.findings.some((finding) => finding.tag === "no-validation");
+  const firstPassSuccess = succeeded && attempt === 0 && !hasNoValidationTag;
+  return {
+    runId,
+    evidenceId: result.evidenceId,
+    tags: [...tags],
+    firstPassSuccess,
+    findingCount: result.findings.length,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createObservabilityBundle(context, options = {}) {
+  const telemetry = createTelemetry();
+  const cost = createCostTracker();
+  const trace = options.dispatchTrace === false ? { enqueue: () => {
+  }, enqueueSessionTurn: () => {
+  }, flush: async () => {
+  }, close: async () => {
+  } } : createDispatchTraceMirror(traceDatabasePath(clioStateDir()));
+  const unsubscribes = [];
+  let latestThroughput = null;
+  const projection = createObservabilityProjection(context.bus, {
+    metrics: () => aggregateMetrics(telemetry.snapshot()),
+    sessionCost: () => cost.sessionTotal(),
+    sessionCostSummary: () => cost.sessionCost(),
+    sessionTokens: () => cost.sessionTokens(),
+    latestThroughput: () => latestThroughput,
+    readAccountability: () => readAccountabilitySummary(clioStateDir())
+  });
+  const pendingBuilds = /* @__PURE__ */ new Set();
+  const trackBuild = (runId, succeeded, attempt) => {
+    projection.evidenceBuildStarted(runId);
+    const build = buildAndIndexEvidence(runId, succeeded, attempt, {
+      onReady: (id, evidence) => projection.evidenceBuildSucceeded(id, evidence),
+      onFailed: (id, message) => projection.evidenceBuildFailed(id, message)
+    });
+    pendingBuilds.add(build);
+    void build.finally(() => pendingBuilds.delete(build));
+  };
+  const extension = {
+    async start() {
+      for (const channel of [
+        BusChannels.DispatchEnqueued,
+        BusChannels.DispatchStarted,
+        BusChannels.DispatchProgress,
+        BusChannels.DispatchCompleted,
+        BusChannels.DispatchFailed
+      ]) {
+        unsubscribes.push(context.bus.on(channel, (payload) => trace.enqueue(channel, payload)));
+      }
+      unsubscribes.push(
+        context.bus.on(BusChannels.DispatchCompleted, (raw) => {
+          const payload = raw ?? {};
+          telemetry.record("counter", "dispatch.completed", 1);
+          if (typeof payload.durationMs === "number") {
+            telemetry.record("histogram", "dispatch.duration_ms", payload.durationMs);
+          }
+          recordDispatchCost(telemetry, cost, payload);
+          if (typeof payload.runId === "string" && payload.runId.length > 0) {
+            trackBuild(payload.runId, true, payload.lineage?.attempt);
+          }
+        })
+      );
+      unsubscribes.push(
+        context.bus.on(BusChannels.DispatchFailed, (raw) => {
+          const payload = raw ?? {};
+          telemetry.record("counter", "dispatch.failed", 1);
+          if (typeof payload.durationMs === "number") {
+            telemetry.record("histogram", "dispatch.duration_ms", payload.durationMs);
+          }
+          recordDispatchCost(telemetry, cost, payload);
+          if (typeof payload.runId === "string" && payload.runId.length > 0) {
+            trackBuild(payload.runId, false, payload.lineage?.attempt);
+          }
+        })
+      );
+      unsubscribes.push(
+        context.bus.on(BusChannels.SafetyClassified, () => {
+          telemetry.record("counter", "safety.classified", 1);
+          projection.refresh();
+        })
+      );
+    },
+    async stop() {
+      for (const off of unsubscribes) off();
+      unsubscribes.length = 0;
+      projection.stop();
+      await trace.close();
+      if (pendingBuilds.size > 0) {
+        await Promise.allSettled([...pendingBuilds]);
+      }
+    }
+  };
+  const contract = {
+    telemetry: () => telemetry.snapshot(),
+    metrics: () => aggregateMetrics(telemetry.snapshot()),
+    sessionCost: () => cost.sessionTotal(),
+    sessionCostSummary: () => cost.sessionCost(),
+    sessionTokens: () => cost.sessionTokens(),
+    costEntries: () => cost.entries(),
+    accountability: () => readAccountabilitySummary(clioStateDir()),
+    latestTokenThroughput: () => latestThroughput,
+    resetSession() {
+      cost.reset();
+      latestThroughput = null;
+      projection.refresh();
+    },
+    recordTokens(providerId, modelId, tokens, costUsd, breakdown, costProvenance) {
+      telemetry.record("counter", "tokens.total", tokens);
+      cost.accumulate(providerId, modelId, tokens, costUsd, breakdown, costProvenance);
+      projection.refresh();
+    },
+    recordSessionTurn(sessionTurn) {
+      trace.enqueueSessionTurn(sessionTurn);
+    },
+    recordTokenThroughput(snapshot) {
+      latestThroughput = snapshot;
+      telemetry.record("histogram", "tokens.output_per_second", snapshot.tokensPerSecond);
+      telemetry.record("histogram", "tokens.ttft_ms", snapshot.ttftMs ?? 0);
+      projection.refresh();
+    },
+    snapshot: () => projection.snapshot(),
+    subscribe: (listener) => projection.subscribe(listener)
+  };
+  return { extension, contract };
+}
+
+// src/domains/observability/manifest.ts
+init_esm_shims();
+var ObservabilityManifest = {
+  // observability listens to dispatch + safety bus channels but never reads
+  // their contracts. Keeping dispatch out of dependsOn lets scheduling sit
+  // between observability and dispatch (scheduling -> observability, dispatch
+  // -> scheduling) without a topological cycle.
+  name: "observability",
+  dependsOn: ["providers", "session"]
+};
+
+// src/domains/observability/index.ts
+var ObservabilityDomainModule = {
+  manifest: ObservabilityManifest,
+  createExtension: createObservabilityBundle
+};
+function createObservabilityDomainModule(options = {}) {
+  return {
+    manifest: ObservabilityManifest,
+    createExtension: (context) => createObservabilityBundle(context, options)
+  };
+}
+
+export {
+  readAccountabilitySummary,
+  aggregateCostAmounts,
+  formatCostAggregate,
+  COST_NOT_MEASURED,
+  costAggregateForAmount,
+  ObservabilityDomainModule,
+  createObservabilityDomainModule
+};
+//# sourceMappingURL=chunk-WVO7V2QY.js.map