@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-XTLJDC2X.js

@@ -0,0 +1,1013 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  appendOutOfTurnUsageRow,
+  readAccountabilitySummary
+} from "./chunk-W7KNI3F5.js";
+import {
+  createWorkerProgressFold
+} from "./chunk-K3W6BF5C.js";
+import {
+  buildEvidence,
+  createCostTracker
+} from "./chunk-5W4FRA5Q.js";
+import {
+  summarizeTrustStatus
+} from "./chunk-FB3KTE2J.js";
+import {
+  truncateToWidth
+} from "./chunk-V4ZKOKRB.js";
+import {
+  uncachedPrefillTokens
+} from "./chunk-QH3ZTUOA.js";
+import {
+  writeEvidenceIndexRowQueued
+} from "./chunk-XC5POIL4.js";
+import {
+  createDispatchTraceMirror,
+  traceDatabasePath
+} from "./chunk-GM4TY6VN.js";
+import {
+  cloneRunToolBudgetEnvelope
+} from "./chunk-MWMW53WW.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-2GPGAE5W.js";
+import {
+  resolveCostProvenance
+} from "./chunk-GVU4CXPJ.js";
+import {
+  BusChannels
+} from "./chunk-W5RM7YAH.js";
+import {
+  clioDataDir,
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/observability/index.ts
+init_esm_shims();
+
+// src/domains/observability/extension.ts
+init_esm_shims();
+
+// 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();
+import { performance } from "node:perf_hooks";
+
+// src/core/dispatch-outcome.ts
+init_esm_shims();
+function resolveDispatchFailureStatus(reason) {
+  if (reason === "dead" || reason === "stalled") return "dead";
+  if (reason === "interrupted" || reason === "canceled") return "aborted";
+  return "failed";
+}
+
+// src/domains/observability/projection.ts
+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 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;
+}
+var TASK_SUMMARY_MAX_WIDTH = 240;
+function finiteOrZero(value) {
+  return num(value, 0);
+}
+function parseRuntimeKind(value) {
+  if (value === "sdk" || value === "subprocess" || value === "acp-delegation") return value;
+  return "http";
+}
+function parseAgentAudience(value, fallback) {
+  if (value === "base" || value === "shadow" || value === "custom" || value === "internal") return value;
+  return fallback;
+}
+function parseRequestOrigin(value, fallback) {
+  if (value === "user" || value === "agent" || value === "internal") return value;
+  return fallback;
+}
+function parseNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parseTaskSummary(raw, fallback) {
+  return sanitizeDispatchTaskSummary(raw.task) ?? sanitizeDispatchTaskSummary(raw.taskSummary) ?? fallback;
+}
+function parsePositiveInt(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function parseGateBadge(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  if (typeof record.role !== "string" || record.role.length === 0) return void 0;
+  const cycle = parsePositiveInt(record.cycle) ?? 1;
+  return { role: record.role, cycle };
+}
+function parseEndpointCapacity(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const key = parseNonEmptyString(record.key);
+  const label = parseNonEmptyString(record.label);
+  const limit = parsePositiveInt(record.limit);
+  return key === void 0 || label === void 0 || limit === void 0 ? void 0 : { key, label, limit };
+}
+function parseCouncilBadge(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const group = parseNonEmptyString(record.group);
+  const label = parseNonEmptyString(record.label);
+  const round = parsePositiveInt(record.round);
+  if (group === void 0 || label === void 0 || round === void 0) return void 0;
+  return {
+    group,
+    label,
+    ...typeof record.color === "string" && record.color.length > 0 ? { color: record.color } : {},
+    round
+  };
+}
+function sanitizeDispatchTaskSummary(value) {
+  if (typeof value !== "string") return void 0;
+  const sanitized = sanitizeCallTargetText(value);
+  if (sanitized.length === 0) return void 0;
+  return sanitizeCallTargetText(truncateToWidth(sanitized, TASK_SUMMARY_MAX_WIDTH, "\u2026", false));
+}
+function parseRetrySnapshot(value) {
+  const attempt = parsePositiveInt(value.attempt);
+  const dueAtMs = Date.parse(value.dueAt);
+  if (attempt === void 0 || !Number.isFinite(dueAtMs)) return null;
+  return {
+    attempt,
+    dueAtMs,
+    reason: sanitizeCallTargetText(value.reason)
+  };
+}
+function readRetrySnapshot(snapshot) {
+  const retrying = /* @__PURE__ */ new Map();
+  try {
+    for (const value of snapshot.retrying) {
+      const runId = asRunId(value.runId);
+      const agentId = parseNonEmptyString(value.agentId);
+      const retry = parseRetrySnapshot(value);
+      const taskSummary = sanitizeDispatchTaskSummary(value.task);
+      if (runId && agentId && retry) {
+        retrying.set(runId, {
+          agentId,
+          ...taskSummary !== void 0 ? { taskSummary } : {},
+          retry
+        });
+      }
+    }
+  } catch {
+  }
+  return retrying;
+}
+function readRunningSnapshot(snapshot) {
+  const running = /* @__PURE__ */ new Map();
+  try {
+    for (const value of snapshot.running) {
+      const runId = asRunId(value.runId);
+      if (!runId) continue;
+      const budget = cloneRunToolBudgetEnvelope(value.budget);
+      running.set(runId, {
+        inputTokens: finiteOrZero(value.tokens.input),
+        outputTokens: finiteOrZero(value.tokens.output),
+        tokenCount: finiteOrZero(value.tokens.total),
+        costUsd: finiteOrZero(value.costUsd),
+        costProvenance: value.costProvenance ?? "unknown",
+        outcomePhase: value.outcomePhase,
+        ...budget !== void 0 ? { budget } : {}
+      });
+    }
+  } catch {
+  }
+  return running;
+}
+function createObservabilityProjection(bus, deps) {
+  const runs = /* @__PURE__ */ new Map();
+  const terminalHistory = /* @__PURE__ */ new Set();
+  const fleetPhases = /* @__PURE__ */ new Map();
+  let runReaders = deps;
+  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().map((entry) => {
+        const { progressFold, startedAtClockMs: _clock, ...summary } = entry;
+        return structuredClone({
+          ...summary,
+          status: entry.retry ? "retrying" : entry.status,
+          progress: progressFold.snapshot()
+        });
+      }),
+      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-coder:observability] projection listener crashed: ${message}`);
+      }
+    }
+  }
+  function scheduleFlush() {
+    if (flushTimer !== null) return;
+    flushTimer = setTimeout(flush, PROJECTION_FLUSH_DEBOUNCE_MS);
+    flushTimer.unref?.();
+  }
+  function markChanged() {
+    for (const [runId, summary] of runs) {
+      if (isTerminal(summary.status) && (summary.status !== "dead" || summary.finishedAtMs !== null) && !summary.retry) {
+        terminalHistory.add(runId);
+      } else {
+        terminalHistory.delete(runId);
+      }
+    }
+    while (terminalHistory.size > MAX_PROJECTION_RUNS) {
+      const oldest = terminalHistory.values().next().value;
+      if (oldest === void 0) break;
+      terminalHistory.delete(oldest);
+      runs.delete(oldest);
+      fleetPhases.delete(oldest);
+    }
+    revision += 1;
+    scheduleFlush();
+  }
+  function putRun(runId, summary) {
+    runs.set(runId, summary);
+  }
+  function emptyRun(runId, now) {
+    const phase = fleetPhases.get(runId);
+    return {
+      runId,
+      agentId: "-",
+      runtimeKind: "http",
+      progressFold: createWorkerProgressFold(),
+      startedAtClockMs: null,
+      ttftMs: null,
+      lastContextTokens: 0,
+      ...phase !== void 0 ? { phase: { ...phase } } : {},
+      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) {
+    delete summary.trust;
+    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;
+    summary.runtimeKind = parseRuntimeKind(id.runtimeKind ?? summary.runtimeKind);
+    const additions = {
+      agentAudience: parseAgentAudience(id.agentAudience, summary.agentAudience),
+      requestOrigin: parseRequestOrigin(id.requestOrigin, summary.requestOrigin),
+      node: parseNonEmptyString(id.node) ?? summary.node,
+      endpoint: parseEndpointCapacity(id.endpoint) ?? summary.endpoint,
+      gate: parseGateBadge(id.gate) ?? summary.gate,
+      council: parseCouncilBadge(id.council) ?? summary.council,
+      rerouteCount: parsePositiveInt(id.rerouteCount) ?? summary.rerouteCount,
+      contextWindow: parsePositiveInt(id.contextWindow) ?? summary.contextWindow,
+      taskSummary: parseTaskSummary(id, summary.taskSummary),
+      budget: cloneRunToolBudgetEnvelope(id.budget) ?? summary.budget
+    };
+    Object.assign(summary, Object.fromEntries(Object.entries(additions).filter(([, value]) => value !== void 0)));
+  }
+  function applyTerminalTokens(summary, payload) {
+    summary.tokens.total = num(payload.tokenCount, summary.tokens.total);
+    if (typeof payload.inputTokenCount === "number") {
+      summary.tokens.input = num(payload.inputTokenCount, summary.tokens.input) + num(payload.cacheReadTokenCount, 0);
+    }
+    summary.tokens.output = num(payload.outputTokenCount, summary.tokens.output);
+    summary.tokens.reasoning = num(payload.reasoningTokenCount, summary.tokens.reasoning);
+    summary.costUsd = num(payload.costUsd, summary.costUsd);
+    summary.costProvenance = resolveCostProvenance(payload.costProvenance, summary.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();
+  }
+  function settleFromReceipt(summary) {
+    try {
+      const facts = runReaders.readReceipt?.(summary.runId);
+      const text = facts?.trust?.artifactIntegrity.state === "verified" ? facts.text : void 0;
+      summary.progressFold.settle(typeof text === "string" && text.trim().length > 0 ? text : void 0);
+      if (facts?.trust !== void 0) summary.trust = summarizeTrustStatus(facts.trust);
+    } catch {
+      summary.progressFold.settle();
+    }
+  }
+  function applyTerminalDetail(summary, payload) {
+    const host = payload.hostVerification;
+    if (host === "verified" || host === "rejected" || host === "skipped" || host === "not_implicated")
+      summary.hostVerification = host;
+    if (payload.reason !== "retry_denied") summary.receiptId = summary.runId;
+    delete summary.retry;
+    settleFromReceipt(summary);
+  }
+  function reconcileRuns() {
+    if (!runReaders.dispatchSnapshot) return;
+    let current;
+    try {
+      current = runReaders.dispatchSnapshot();
+    } catch {
+      return;
+    }
+    if (!Array.isArray(current?.retrying) || !Array.isArray(current?.running)) return;
+    const retrying = readRetrySnapshot(current);
+    const running = readRunningSnapshot(current);
+    const now = Date.now();
+    let changed = false;
+    for (const entry of runs.values()) {
+      if (entry.retry && !retrying.has(entry.runId)) {
+        delete entry.retry;
+        changed = true;
+      }
+    }
+    for (const [runId, retry] of retrying) {
+      const existing = runs.get(runId);
+      if (existing && existing.status !== "failed" && existing.status !== "dead") continue;
+      const entry = existing ?? emptyRun(runId, now);
+      if (!existing) {
+        entry.agentId = retry.agentId;
+        entry.status = "failed";
+      }
+      entry.retry = { ...retry.retry };
+      if (entry.taskSummary === void 0 && retry.taskSummary !== void 0) entry.taskSummary = retry.taskSummary;
+      putRun(runId, entry);
+      changed = true;
+    }
+    for (const [runId, live] of running) {
+      const entry = runs.get(runId);
+      if (!entry || isTerminal(entry.status) && live.outcomePhase !== "aborting") continue;
+      entry.tokens.input = live.inputTokens;
+      entry.tokens.output = live.outputTokens;
+      entry.tokens.total = live.tokenCount;
+      entry.costUsd = live.costUsd;
+      entry.costProvenance = live.costProvenance;
+      if (live.budget !== void 0) entry.budget = live.budget;
+      if (live.outcomePhase === "aborting" && entry.status !== "completed" && entry.status !== "aborted") {
+        entry.status = "cancelling";
+        delete entry.retry;
+      }
+      changed = true;
+    }
+    if (changed) markChanged();
+  }
+  function evidenceBuildSucceeded(runId, evidence) {
+    pendingEvidence.delete(runId);
+    const summary = runs.get(runId);
+    if (summary) summary.evidence = { ...evidence, tags: [...evidence.tags] };
+    accountability = deps.readAccountability();
+    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";
+      delete summary.retry;
+      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.startedAtClockMs = performance.now();
+      delete summary.retry;
+      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 !== "cancelling") summary.status = status;
+        if (status === "dead") summary.progressFold.settle();
+        markChanged();
+        return;
+      }
+      if (type === "attempt_start") {
+        summary.failoverHops = (summary.failoverHops ?? 0) + 1;
+        const attemptRunId = asRunId(event.runId);
+        if (attemptRunId && attemptRunId !== runId) {
+          delete summary.retry;
+          markChanged();
+          return;
+        }
+        summary.status = "running";
+        summary.finishedAtMs = null;
+        summary.durationMs = null;
+        summary.progressFold.restart();
+        delete summary.retry;
+        markChanged();
+        return;
+      }
+      if (type === "agent_start") summary.startedAtClockMs = performance.now();
+      if (type === "message_update") {
+        const assistantEvent = event.assistantMessageEvent ?? {};
+        const hasDelta = ["text_delta", "thinking_delta", "toolcall_start", "toolcall_delta"].includes(
+          String(assistantEvent.type)
+        );
+        if (hasDelta && summary.ttftMs === null && summary.startedAtClockMs !== null)
+          summary.ttftMs = Math.round(performance.now() - summary.startedAtClockMs);
+      }
+      if (type === "clio_coder_write_record_downgraded") {
+        const detail = event.payload ?? {};
+        const tool = parseNonEmptyString(detail.tool);
+        const toolCallId = parseNonEmptyString(detail.toolCallId);
+        if (detail.reason === "opaque_tool_succeeded" && tool !== void 0 && toolCallId !== void 0)
+          summary.writeRecordDowngrade = {
+            reason: "opaque_tool_succeeded",
+            tool: sanitizeCallTargetText(tool),
+            toolCallId: sanitizeCallTargetText(toolCallId)
+          };
+      }
+      summary.progressFold.observe(payload.event);
+      if (type === "clio_coder_steer_received") {
+        const detail = event.payload ?? {};
+        summary.steerAcknowledgement = { receivedAtMs: now, chars: Math.max(0, Math.floor(num(detail.chars, 0))) };
+      }
+      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);
+          summary.lastContextTokens = input + output;
+        }
+      }
+      if (type === "agent_end") summary.progressFold.settle();
+      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);
+      applyTerminalDetail(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 = resolveDispatchFailureStatus(payload.reason);
+      summary.updatedAtMs = now;
+      summary.finishedAtMs = now;
+      summary.durationMs = num(payload.durationMs, Math.max(0, now - summary.startedAtMs));
+      applyTerminalTokens(summary, payload);
+      applyTerminalDetail(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.RunAborted, (raw) => {
+      const runId = asRunId(raw?.runId);
+      const summary = runId ? runs.get(runId) : void 0;
+      if (!summary) return;
+      const wasRetrying = summary.retry !== void 0;
+      delete summary.retry;
+      if (wasRetrying && raw.startedAt === null) {
+        summary.status = "aborted";
+        summary.finishedAtMs = Date.now();
+        summary.progressFold.settle();
+      } else {
+        if (isTerminal(summary.status) && !wasRetrying) return;
+        summary.status = "cancelling";
+      }
+      summary.outcomeDetail = typeof raw.reason === "string" ? raw.reason : summary.outcomeDetail ?? null;
+      summary.updatedAtMs = Date.now();
+      markChanged();
+    }),
+    bus.on(BusChannels.AccountabilityEvidenceReady, (payload) => {
+      const runId = asRunId(payload?.runId);
+      if (runId) evidenceBuildSucceeded(runId, payload);
+    }),
+    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();
+    })
+  ];
+  return {
+    snapshot: buildSnapshot,
+    bindRunReaders(readers) {
+      runReaders = readers;
+      return () => {
+        if (runReaders === readers) runReaders = deps;
+      };
+    },
+    reconcileRuns,
+    setFleetPhase(runId, phase) {
+      fleetPhases.set(runId, { ...phase });
+      while (fleetPhases.size > MAX_PROJECTION_RUNS) {
+        const oldest = fleetPhases.keys().next().value;
+        if (oldest === void 0) break;
+        fleetPhases.delete(oldest);
+      }
+      const summary = runs.get(runId);
+      if (summary) summary.phase = { ...phase };
+      markChanged();
+    },
+    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();
+    },
+    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 dispatchHasEvidenceLedger(payload) {
+  return payload.lineage !== void 0;
+}
+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,
+      ...payload.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1h: payload.cacheWrite1hTokenCount },
+      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-coder: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,
+    succeeded,
+    completionEvidenceWarning: result.findings.some(
+      (finding) => finding.tag === "completion-evidence" && finding.severity === "warn"
+    ),
+    ungroundedClaims: result.ungroundedClaims,
+    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) => {
+        context.bus.emit(BusChannels.AccountabilityEvidenceReady, { runId: 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 && dispatchHasEvidenceLedger(payload)) {
+            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, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts, label) {
+      telemetry.record("counter", "tokens.total", tokens);
+      cost.accumulate(providerId, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts, label);
+      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();
+    },
+    bindRunReaders: (readers) => projection.bindRunReaders(readers),
+    reconcileRuns: () => projection.reconcileRuns(),
+    setFleetPhase: (runId, phase) => projection.setFleetPhase(runId, phase),
+    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/background-memory-usage.ts
+init_esm_shims();
+function backgroundMemoryUsageRow(usage, options) {
+  return {
+    label: "background-memory",
+    sessionId: options.sessionId,
+    repoIdentity: options.repoIdentity,
+    timestamp: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    target: usage.targetId,
+    attributedModelId: usage.attributedModelId,
+    usage: {
+      input: usage.input,
+      output: usage.output,
+      cacheRead: usage.cacheRead,
+      cacheWrite: usage.cacheWrite,
+      ...usage.cacheWrite1h === void 0 ? {} : { cacheWrite1h: usage.cacheWrite1h },
+      reasoning: usage.reasoning,
+      totalTokens: usage.totalTokens,
+      costUsd: usage.costUsd,
+      costProvenance: usage.costProvenance
+    },
+    timing: { durationMs: usage.durationMs },
+    ...usage.backend === null ? {} : {
+      promptCache: {
+        promptTokens: usage.backend.promptTokens,
+        cachedTokens: usage.backend.cachedTokens,
+        uncachedPrefillTokens: uncachedPrefillTokens({
+          promptTokens: usage.backend.promptTokens,
+          cachedTokens: usage.backend.cachedTokens,
+          predictedTokens: 0,
+          promptMs: usage.backend.promptMs,
+          predictedMs: 0,
+          source: "llamacpp-timings"
+        }),
+        promptMs: usage.backend.promptMs,
+        source: usage.backend.source
+      }
+    }
+  };
+}
+function recordBackgroundMemoryStep(input) {
+  input.observability?.recordTokens(
+    input.usage.targetId,
+    input.usage.attributedModelId,
+    input.usage.totalTokens,
+    input.usage.costUsd,
+    {
+      input: input.usage.input,
+      output: input.usage.output,
+      cacheRead: input.usage.cacheRead,
+      cacheWrite: input.usage.cacheWrite,
+      ...input.usage.cacheWrite1h === void 0 ? {} : { cacheWrite1h: input.usage.cacheWrite1h },
+      reasoningTokens: input.usage.reasoning,
+      totalTokens: input.usage.totalTokens,
+      apiCalls: 1
+    },
+    input.usage.costProvenance,
+    void 0,
+    "background-memory"
+  );
+  const row = backgroundMemoryUsageRow(input.usage, {
+    sessionId: input.sessionId,
+    repoIdentity: input.repoIdentity,
+    ...input.now === void 0 ? {} : { now: input.now }
+  });
+  (input.appendRow ?? appendOutOfTurnUsageRow)(input.stateDir, row);
+  return row;
+}
+
+// src/domains/observability/index.ts
+var ObservabilityDomainModule = {
+  manifest: ObservabilityManifest,
+  createExtension: createObservabilityBundle
+};
+function createObservabilityDomainModule(options = {}) {
+  return {
+    manifest: ObservabilityManifest,
+    createExtension: (context) => createObservabilityBundle(context, options)
+  };
+}
+
+export {
+  recordBackgroundMemoryStep,
+  ObservabilityDomainModule,
+  createObservabilityDomainModule
+};
+//# sourceMappingURL=chunk-XTLJDC2X.js.map