@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-HKMD33FO.js → chunk-Y55JBDO5.js}

@@ -1,24 +1,38 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   appendOutOfTurnUsageRow,
-  readEvidenceIndex,
+  readAccountabilitySummary,
   writeEvidenceIndexRowQueued
-} from "./chunk-AK5XEFVZ.js";
+} from "./chunk-JT2RFCC5.js";
 import {
-  createDispatchTraceMirror,
-  traceDatabasePath
-} from "./chunk-VKPAQYEB.js";
+  createWorkerProgressFold
+} from "./chunk-XXYSBZIQ.js";
+import {
+  truncateToWidth
+} from "./chunk-YAKGTXEV.js";
 import {
-  FAILURE_CAUSE_TAGS,
   buildEvidence,
   createCostTracker
-} from "./chunk-I66ZTYNP.js";
+} from "./chunk-NRO2BJRH.js";
+import {
+  summarizeTrustStatus
+} from "./chunk-CUSRQKPU.js";
+import {
+  createDispatchTraceMirror,
+  traceDatabasePath
+} from "./chunk-VKPAQYEB.js";
 import {
   uncachedPrefillTokens
 } from "./chunk-3DPEIQKN.js";
+import {
+  cloneRunToolBudgetEnvelope
+} from "./chunk-75W7L2E2.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-NEDJ26B5.js";
 import {
   resolveCostProvenance
-} from "./chunk-BYMNWQ7O.js";
+} from "./chunk-JSD46VO2.js";
 import {
   BusChannels
 } from "./chunk-F4EKGO4N.js";
@@ -30,104 +44,12 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// 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,
-      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,
-      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
 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) {
@@ -154,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();
@@ -192,8 +115,121 @@ 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 fleetPhases = /* @__PURE__ */ new Map();
+  let runReaders = deps;
   const notices = [];
   const providerHealth = /* @__PURE__ */ new Map();
   const pendingEvidence = /* @__PURE__ */ new Set();
@@ -218,7 +254,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]
@@ -252,12 +295,20 @@ function createObservabilityProjection(bus, deps) {
       const oldest = runs.keys().next().value;
       if (oldest === void 0) break;
       runs.delete(oldest);
+      fleetPhases.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,
@@ -269,11 +320,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);
@@ -300,6 +365,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 ?? {};
@@ -309,6 +448,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();
@@ -322,6 +462,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;
@@ -340,10 +482,46 @@ 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;
+        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) {
@@ -352,8 +530,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) => {
@@ -368,6 +548,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);
@@ -385,11 +566,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;
@@ -400,6 +604,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());
@@ -415,20 +637,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(
@@ -504,6 +712,9 @@ function createTelemetry(histogramCapacity = DEFAULT_HISTOGRAM_CAPACITY) {
 }
 
 // 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;
@@ -555,6 +766,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()
   };
 }
@@ -581,7 +797,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)
@@ -621,7 +836,7 @@ function createObservabilityBundle(context, options = {}) {
             telemetry.record("histogram", "dispatch.duration_ms", payload.durationMs);
           }
           recordDispatchCost(telemetry, cost, payload);
-          if (typeof payload.runId === "string" && payload.runId.length > 0) {
+          if (typeof payload.runId === "string" && payload.runId.length > 0 && dispatchHasEvidenceLedger(payload)) {
             trackBuild(payload.runId, false, payload.lineage?.attempt);
           }
         })
@@ -671,6 +886,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)
   };
@@ -688,6 +906,73 @@ var ObservabilityManifest = {
   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,
+      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,
+      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,
@@ -701,10 +986,8 @@ function createObservabilityDomainModule(options = {}) {
 }
 
 export {
-  readAccountabilitySummary,
-  resolveDispatchFailureStatus,
   recordBackgroundMemoryStep,
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-HKMD33FO.js.map
+//# sourceMappingURL=chunk-Y55JBDO5.js.map