@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-MWUZBSAQ.js → chunk-FSTIBAGM.js}

@@ -1,34 +1,48 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   appendOutOfTurnUsageRow,
-  readEvidenceIndex,
+  readAccountabilitySummary,
   writeEvidenceIndexRowQueued
-} from "./chunk-VA5FNYMT.js";
+} from "./chunk-HR3HPQ76.js";
 import {
-  FAILURE_CAUSE_TAGS,
-  buildEvidence,
-  createCostTracker
-} from "./chunk-AF4YM7Z4.js";
+  createWorkerProgressFold
+} from "./chunk-O2RQ7LCK.js";
+import {
+  truncateToWidth
+} from "./chunk-QRFXEO6Y.js";
 import {
   createDispatchTraceMirror,
   traceDatabasePath
-} from "./chunk-VKPAQYEB.js";
+} from "./chunk-LZBMXNLP.js";
+import {
+  buildEvidence,
+  createCostTracker
+} from "./chunk-SDWNDICN.js";
+import {
+  summarizeTrustStatus
+} from "./chunk-6CDNRHWH.js";
 import {
   uncachedPrefillTokens
-} from "./chunk-3DPEIQKN.js";
+} from "./chunk-QH3ZTUOA.js";
+import {
+  cloneRunToolBudgetEnvelope
+} from "./chunk-TZ7MFRG4.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-2GPGAE5W.js";
 import {
   resolveCostProvenance
-} from "./chunk-XPWWI35G.js";
+} from "./chunk-TEG3RYVZ.js";
 import {
   BusChannels
-} from "./chunk-F4EKGO4N.js";
+} from "./chunk-HL26ADLH.js";
 import {
   clioDataDir,
   clioStateDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/observability/index.ts
 init_esm_shims();
@@ -36,31 +50,6 @@ 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) {
@@ -87,6 +76,7 @@ function aggregateMetrics(snap) {
 
 // src/domains/observability/projection.ts
 init_esm_shims();
+import { performance } from "node:perf_hooks";
 
 // src/core/dispatch-outcome.ts
 init_esm_shims();
@@ -125,8 +115,122 @@ function makeRef(parts) {
   }
   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();
@@ -151,7 +255,14 @@ function createObservabilityProjection(bus, deps) {
       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(),
+      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]
@@ -176,21 +287,37 @@ function createObservabilityProjection(bus, deps) {
     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);
-    while (runs.size > MAX_PROJECTION_RUNS) {
-      const oldest = runs.keys().next().value;
-      if (oldest === void 0) break;
-      runs.delete(oldest);
-    }
   }
   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,
@@ -202,11 +329,25 @@ function createObservabilityProjection(bus, deps) {
     };
   }
   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;
-    if (typeof id.runtimeKind === "string" && id.runtimeKind.length > 0) summary.runtimeKind = id.runtimeKind;
+    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);
@@ -233,6 +374,80 @@ function createObservabilityProjection(bus, deps) {
     }
     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 ?? {};
@@ -242,6 +457,7 @@ function createObservabilityProjection(bus, deps) {
       const summary = runs.get(runId) ?? emptyRun(runId, now);
       applyIdentity(summary, payload);
       summary.status = "enqueued";
+      delete summary.retry;
       summary.updatedAtMs = now;
       putRun(runId, summary);
       markChanged();
@@ -255,6 +471,8 @@ function createObservabilityProjection(bus, deps) {
       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;
@@ -273,10 +491,52 @@ function createObservabilityProjection(bus, deps) {
       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;
+        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) {
@@ -285,8 +545,10 @@ function createObservabilityProjection(bus, deps) {
           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) => {
@@ -301,6 +563,7 @@ function createObservabilityProjection(bus, deps) {
       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);
@@ -318,11 +581,34 @@ function createObservabilityProjection(bus, deps) {
       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;
@@ -333,6 +619,24 @@ function createObservabilityProjection(bus, deps) {
   ];
   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());
@@ -348,20 +652,6 @@ function createObservabilityProjection(bus, deps) {
       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(
@@ -491,6 +781,11 @@ function evidenceIndexRow(runId, result, succeeded, attempt) {
     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()
   };
 }
@@ -517,7 +812,6 @@ function createObservabilityBundle(context, options = {}) {
     projection.evidenceBuildStarted(runId);
     const build = buildAndIndexEvidence(runId, succeeded, attempt, {
       onReady: (id, evidence) => {
-        projection.evidenceBuildSucceeded(id, evidence);
         context.bus.emit(BusChannels.AccountabilityEvidenceReady, { runId: id, ...evidence });
       },
       onFailed: (id, message) => projection.evidenceBuildFailed(id, message)
@@ -607,6 +901,9 @@ function createObservabilityBundle(context, options = {}) {
       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)
   };
@@ -704,10 +1001,8 @@ function createObservabilityDomainModule(options = {}) {
 }
 
 export {
-  readAccountabilitySummary,
-  resolveDispatchFailureStatus,
   recordBackgroundMemoryStep,
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-MWUZBSAQ.js.map
+//# sourceMappingURL=chunk-FSTIBAGM.js.map

package/dist/{chunk-ZTJUVLTU.js → chunk-FXFVDPWY.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/boot-trace.ts
 init_esm_shims();
@@ -27,4 +27,4 @@ export {
   formatBootTrace,
   traceBoot
 };
-//# sourceMappingURL=chunk-ZTJUVLTU.js.map
+//# sourceMappingURL=chunk-FXFVDPWY.js.map

package/dist/{chunk-XPLRXC72.js → chunk-GD55RTIW.js}

@@ -2,10 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   PI_MONO_PACKAGES,
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/lifecycle/version.ts
 init_esm_shims();
@@ -30,4 +30,4 @@ function getVersionInfo() {
 export {
   getVersionInfo
 };
-//# sourceMappingURL=chunk-XPLRXC72.js.map
+//# sourceMappingURL=chunk-GD55RTIW.js.map