comisai 1.0.45 → 1.0.46

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-signals.js

@@ -1,26 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * `toIncidentSignals` — the X3 dual-shape normalizer.
+ * `toIncidentSignals` — the dual-shape normalizer.
  *
  * Collapses two on-disk telemetry record shapes into one `IncidentSignals` view
- * the assembler (Plan 03) + heuristic registry (Plan 05) consume: the LOG shape
- * (raw Pino lines, PRE Phase-150 — no `traceSchema`, keyed on `msg`, detail from
+ * the assembler + heuristic registry consume: the LOG shape (raw Pino lines —
+ * no `traceSchema`, keyed on `msg`, detail from
  * `errorText`/`httpStatus`/`errorKind`) and the EVENT shape (structured
- * trajectory events, POST Phase-151 — `traceSchema:"comis-trajectory"`, keyed on
+ * trajectory events — `traceSchema:"comis-trajectory"`, keyed on
  * `type`, detail from `data`).
  *
  * SECURITY (depth-independent): raw bodies are NEVER inlined — `errorPreview` is
  * the ReDoS-pre-bounded `sanitizeLogString(...).slice(0, MAX_ERROR_PREVIEW)` and
  * the full body is captured only by `resultDigest = fingerprint(...)`; an offload
- * `diskPath` is relativized (the absolute host path is never emitted). The 678
+ * `diskPath` is relativized (the absolute host path is never emitted). The
  * misclassification signal derives from LOG EVIDENCE ONLY (zero
- * `classifiedFailureBy` reads — the field is absent in that fixture).
+ * `classifiedFailureBy` reads — the field is absent in the log shape).
  *
  * @module
  */
 import { fingerprint } from "@comis/core";
 import { asString, asNumber, relativizeDiskPath, previewAndDigest, applyMediaRecord, } from "./obs-explain-signals-fields.js";
-import { accumulateLearningRecord, accumulateSkillInvokedRecord, accumulateSkillUsedRecord, accumulateSkillSurfacedRecord, accumulateReflectFunnelRecord, accumulateSkillTransitionRecord, accumulateMemoryFailureRecord, accumulateToolSchemaRecord, buildLearningSignal, emptyLearningFold, accumulateSpendExceeded, accumulateCapabilityAuditedRecord, accumulateGraphNodeSpawnedRecord, parseContextBudgetRecord, parsePromptTimeoutRecord, } from "./obs-explain-signal-folds.js";
+import { accumulateLearningRecord, accumulateSkillInvokedRecord, accumulateSkillUsedRecord, accumulateSkillSurfacedRecord, accumulateReflectFunnelRecord, accumulateSkillTransitionRecord, accumulateMemoryFailureRecord, accumulateToolSchemaRecord, buildLearningSignal, emptyLearningFold, accumulateSpendExceeded, accumulateCapabilityAuditedRecord, accumulateGraphNodeSpawnedRecord, accumulateOrchestrateRunSummaryRecord, accumulateOrchestrateToolCall, parseContextBudgetRecord, parsePromptTimeoutRecord, parseWakeGateRecord, } from "./obs-explain-signal-folds.js";
 // ---------------------------------------------------------------------------
 // Tunable thresholds (module-top constants per the naming contract).
 // ---------------------------------------------------------------------------
@@ -28,7 +28,7 @@ import { accumulateLearningRecord, accumulateSkillInvokedRecord, accumulateSkill
  * heuristic misclassification signal to fire. */
 const MISCLASS_N = 2;
 /** Minimum same-tool failures for a breaker/repeated-failure signal. Used by
- * the heuristic registry (Plan 05); surfaced here for one source of truth. */
+ * the heuristic registry; surfaced here for one source of truth. */
 export const BREAKER_N = 5;
 /** Token literals the misclassification heuristic looks for in a failure body. */
 const MISCLASS_TOKEN_RE = /"?status"?\s*:?\s*(200|403)|\b(200|403)\b|status/i;
@@ -72,12 +72,12 @@ function handleLogRecord(acc, rec) {
         if (errorText && DO_NOT_RETRY_RE.test(errorText)) {
             acc.hasDoNotRetrySignal = true;
             // The breaker's offending tool is this line's toolName (log-shape proxy
-            // for a tool.breaker_opened event, which does not exist pre-151).
+            // for a tool.breaker_opened event, which the log shape never carries).
             acc.breakerOpenedTool ??= tool;
             // Synthesize a breaker "opened" timeline entry from the log evidence so a
-            // pre-151 log-only session still has a non-empty breakerTimeline (the X3
-            // 678 must-have). Dedup per tool — the breaker opens once even though the
-            // fixture carries multiple "DO NOT retry" lines.
+            // log-only session still has a non-empty breakerTimeline. Dedup per
+            // tool — the breaker opens once even though the
+            // stream carries multiple "DO NOT retry" lines.
             if (!acc.synthesizedBreakerTools.has(tool)) {
                 acc.synthesizedBreakerTools.add(tool);
                 acc.breakerEvents.push({ seq: acc.seq++, event: "opened", toolName: tool });
@@ -114,7 +114,7 @@ function handleEventRecord(acc, rec) {
     const tool = asString(data.toolName);
     switch (type) {
         case "session.started": {
-            // W8: channel identity rides the session.started data (channelType/channelId).
+            // Channel identity rides the session.started data (channelType/channelId).
             const channelType = asString(data.channelType);
             const channelId = asString(data.channelId);
             if (acc.channel === undefined && (channelType !== undefined || channelId !== undefined)) {
@@ -123,7 +123,7 @@ function handleEventRecord(acc, rec) {
             return;
         }
         case "terminal.drive_promoted": {
-            // DRIVE-02: a coding-CLI/terminal drive backgrounded at the inline→detached
+            // A coding-CLI/terminal drive backgrounded at the inline→detached
             // boundary (bridged from terminal:drive_promoted). Count promotions; keep the
             // LAST reason (mode_detached | producing) for the terminal-drive verdict.
             const reason = asString(data.reason);
@@ -132,10 +132,20 @@ function handleEventRecord(acc, rec) {
             acc.terminalDrivePromotedCount += 1;
             return;
         }
+        case "terminal.session_evicted": {
+            // The reaper evicted a durable drive (bridged from terminal:session_evicted).
+            // Keep the LAST reason (idle | max_sessions | wall_clock | max_interactions) + the
+            // session's total lifetime at eviction for the terminal_drive_evicted verdict.
+            const reason = asString(data.reason);
+            if (reason !== undefined)
+                acc.terminalDriveEvictedReason = reason;
+            acc.terminalDriveEvictedMs = asNumber(data.durationMs) ?? acc.terminalDriveEvictedMs;
+            return;
+        }
         case "tool.result": {
             if (!tool)
                 return;
-            // W8: dedupe by toolCallId — the live ctx_search counted twice when its
+            // Dedupe by toolCallId — the live ctx_search counted twice when its
             // result appeared in more than one telemetry source.
             const toolCallId = asString(data.toolCallId);
             if (toolCallId !== undefined) {
@@ -156,7 +166,7 @@ function handleEventRecord(acc, rec) {
             // (translate-payload.ts), NOT `errorText` — reading the wrong field left
             // `errorPreview` empty so `comis explain` showed no reason (forcing a daemon-log
             // grep). Prefer `errorMessage`; keep `errorText` as a defensive fallback for any
-            // other producer shape. (hermes-usecases obs-loop 2026-06-25.)
+            // other producer shape.
             const errorText = asString(data.errorMessage) ?? asString(data.errorText);
             const { errorPreview, resultBytes } = previewAndDigest(errorText);
             const httpStatus = asNumber(data.httpStatus);
@@ -170,8 +180,8 @@ function handleEventRecord(acc, rec) {
                 ...(asString(data.matchedToken) !== undefined
                     ? { matchedToken: asString(data.matchedToken) }
                     : {}),
-                // #4 (self-grade visibility): the failure-detector sub-rule that flipped the
-                // call — "self_grade" (the #1 {graded:true,outcome} envelope, a clean DOMAIN
+                // Self-grade visibility: the failure-detector sub-rule that flipped the
+                // call — "self_grade" (the {graded:true,outcome} envelope, a clean DOMAIN
                 // task-failure) vs an error-token rule. Lets `explain.failures` distinguish an
                 // honest task-failure from a transport error. Content-free (a closed rule label).
                 ...(asString(data.matchedRule) !== undefined
@@ -181,6 +191,11 @@ function handleEventRecord(acc, rec) {
                 resultDigest: asString(data.resultDigest) ?? fingerprint(errorText ?? ""),
                 resultBytes,
                 errorPreview,
+                // The bounded+redacted arguments the failed call was invoked with
+                // (already sanitized at the emit) — "what did the failed call attempt?"
+                ...(data.argsPreview !== null && typeof data.argsPreview === "object" && !Array.isArray(data.argsPreview)
+                    ? { argsPreview: data.argsPreview }
+                    : {}),
             });
             return;
         }
@@ -205,7 +220,7 @@ function handleEventRecord(acc, rec) {
             return;
         }
         case "subagent.budget_exceeded": {
-            // ORCH-OBS (BUDGET-03): a per-node token-budget breach. The trajectory record
+            // A per-node token-budget breach. The trajectory record
             // carries the per-incident view (nodeId + capSource + the two token numbers)
             // the IncidentReport surfaces so a breach is diagnosable from the report alone —
             // WHICH knob bound the node, not just "a node failed". Content-free by
@@ -226,26 +241,37 @@ function handleEventRecord(acc, rec) {
             });
             return;
         }
-        // TREE-01/02 (215): the per-cap audit record (Plan 01) → the spawn-tree's
+        // The per-cap audit record → the spawn-tree's
         // per-node source. Delegated to a fold helper (the accumulateSpendExceeded
         // mold) for the obs-handlers/* subdir cap — see its docstring for the full
         // group-by-leaseId / content-free contract.
         case "graph.node_spawned":
-            // Finding D (TREE-01): a graph DAG node is a spawn-tree leaf too (it never
+            // A graph DAG node is a spawn-tree leaf too (it never
             // crosses the socket chokepoint that emits capability.audited).
             accumulateGraphNodeSpawnedRecord(acc.spawnNodesByLease, data);
             return;
         case "capability.audited":
             accumulateCapabilityAuditedRecord(acc.spawnNodesByLease, data, rec.agentId, acc.agentId);
+            // ALSO tally the run's tool calls keyed by the PER-RUN child leaseId. The
+            // same record feeds the spawn-tree node (benign — a run appears in both
+            // sections) AND the orchestrate section's per-run toolCalls; the per-run
+            // leaseId groups a deny under THE RUN (EXPLAIN-04), not the assembly.
+            accumulateOrchestrateToolCall(acc.orchestrateToolCallsByLease, data);
+            return;
+        // The per-run orchestrate summary → the run skeleton (grouped by runId,
+        // first-seen kept). Its toolCalls are joined from the leaseId tally at
+        // materialization below. Content-free fold (see obs-explain-signal-folds.ts).
+        case "orchestrate.run_summary":
+            accumulateOrchestrateRunSummaryRecord(acc.orchestrateRunsByRunId, data);
             return;
-        // W3 budget equation (LCD pre-flight) + LAT-04 prompt-timeout attribution —
+        // The budget equation (LCD pre-flight) + prompt-timeout attribution —
         // schema-validated LAST-wins folds delegated to helpers (subdir cap). An
         // undefined parse leaves acc.* unchanged (malformed/partial ignored, fwd-compat).
         case "context.budget": {
             const b = parseContextBudgetRecord(data);
             if (b !== undefined) {
-                acc.contextBudget = b; // W3 terminal fit-check (LAST wins) — unchanged.
-                // E2: also record the per-turn CASCADE. Dedup on transition (the window is fixed per session
+                acc.contextBudget = b; // The terminal fit-check (LAST wins).
+                // Also record the per-turn CASCADE. Dedup on transition (the window is fixed per session
                 // + S is ~fixed, so push only when assembled-input/eviction/verdict MOVES) so a stable
                 // multi-turn session adds nothing; cap to the most-recent 40 (the tightening toward an
                 // exhaustion is at the tail). Surfaced only when ≥2 states (see the assemble guard).
@@ -274,6 +300,15 @@ function handleEventRecord(acc, rec) {
                 acc.promptTimeout = t;
             return;
         }
+        // A woke fire's content-free wake-gate fact (only a fire the gate WOKE runs the
+        // model in a session, so only it writes this record). LAST wins — the terminal
+        // fire explains the session. Malformed/partial → unchanged (fwd-compat).
+        case "scheduler.wake_gate": {
+            const w = parseWakeGateRecord(data);
+            if (w !== undefined)
+                acc.cronWakeGate = w;
+            return;
+        }
         case "tool.result_offloaded": {
             if (!tool)
                 return;
@@ -283,13 +318,13 @@ function handleEventRecord(acc, rec) {
                 originalChars: asNumber(data.originalChars) ?? 0,
                 // The translator writes the relative pointer as `diskPathRel` — NOT
                 // `diskPath` (the raw Pino LOG-shape field; reading it here silently
-                // yielded "<offloaded>" for every post-151 event-shape session).
+                // yielded "<offloaded>" for every event-shape session).
                 pointer: relativizeDiskPath(asString(data.diskPathRel)),
             });
             return;
         }
         case "memory.recalled": {
-            // RECALL-01: aggregate the per-recall outcome. finalCount === 0 is a recall
+            // Aggregate the per-recall outcome. finalCount === 0 is a recall
             // MISS (no memories injected); the LAST recall is the terminal state. Counts
             // only — the bridged record never carries query text or memory bodies.
             acc.recallCount += 1;
@@ -304,11 +339,11 @@ function handleEventRecord(acc, rec) {
             return;
         }
         case "cache.break": {
-            // PERSIST-01 (176-05): fold the cache-break per reason → {count, estCostUsd}.
-            // The bridged record (Plan 04 + 176-05) carries a closed `reason`, `tokenDrop`,
+            // Fold the cache-break per reason → {count, estCostUsd}.
+            // The bridged record carries a closed `reason`, `tokenDrop`,
             // and a COMPUTED `estCostUsd` (the directly-lost cache-read saving) — counts +
             // a number ONLY, never the changed tool names (only the changed-dims digest
-            // crosses the trajectory boundary, I3). A blank/missing reason folds to "unknown".
+            // crosses the trajectory boundary). A blank/missing reason folds to "unknown".
             const reason = asString(data.reason) ?? "unknown";
             const estCostUsd = asNumber(data.estCostUsd) ?? 0;
             const prev = acc.cacheBreaksByReason.get(reason) ?? { count: 0, estCostUsd: 0 };
@@ -318,17 +353,86 @@ function handleEventRecord(acc, rec) {
             });
             return;
         }
-        // SPEND (WEBUI-04, 179-04): the spend kill-switch breach (LAST wins) — delegated to a fold helper (learning-fold mold) for the subdir cap.
+        case "activity.turn_finalized": {
+            // The terminal user-surface state (LAST wins — the final turn's
+            // finalize explains what the chat shows now). Closed labels only.
+            const strategy = asString(data.strategy);
+            const outcome = asString(data.outcome);
+            if (strategy !== undefined && outcome !== undefined) {
+                acc.turnFinalized = {
+                    strategy,
+                    outcome,
+                    ...(asString(data.errorKind) !== undefined ? { errorKind: asString(data.errorKind) } : {}),
+                    ...(asString(data.reason) !== undefined ? { reason: asString(data.reason) } : {}),
+                    reclassified: data.reclassified === true,
+                };
+            }
+            return;
+        }
+        case "delivery.aborted": {
+            // Blocks an abort left unsent — the "reply never reached the user"
+            // ledger (no delivery.dispatched fires for these).
+            const total = asNumber(data.totalChunks) ?? 0;
+            const delivered = asNumber(data.chunksDelivered) ?? 0;
+            const prev = acc.deliveryAborts ?? { events: 0, chunksNotSent: 0 };
+            acc.deliveryAborts = {
+                events: prev.events + 1,
+                chunksNotSent: prev.chunksNotSent + Math.max(0, total - delivered),
+            };
+            return;
+        }
+        case "execution.recovery_attempted": {
+            // Fold the model re-entry recoveries (silent_retry / lkw_fallback /
+            // continuation_nudge) → counts by reason + a succeeded tally.
+            const reason = asString(data.reason) ?? "unknown";
+            const prev = acc.recoveries ?? { total: 0, succeeded: 0, byReason: {} };
+            prev.total += 1;
+            if (data.succeeded === true)
+                prev.succeeded += 1;
+            // eslint-disable-next-line security/detect-object-injection -- reason is a closed enum from the recovery emitter
+            prev.byReason[reason] = (prev.byReason[reason] ?? 0) + 1;
+            acc.recoveries = prev;
+            return;
+        }
+        case "session.summary": {
+            // One summary record per EXECUTION, each carrying that execution's own
+            // costUsd — Σ them for the session cost. The sessionEnd rollup is
+            // overwritten per execution (last write wins), so it holds only the
+            // FINAL execution's cost; the assembler prefers this ledger sum.
+            const c = asNumber(data.costUsd);
+            if (c !== undefined)
+                acc.summaryCostUsd = (acc.summaryCostUsd ?? 0) + c;
+            // Σ the per-execution turn counts — the sessionEnd rollup's turnCount is
+            // last-write-wins (the final execution's only), so a multi-execution
+            // session under-reported (the incident's 11-turn session showed 1).
+            const t = asNumber(data.turnCount);
+            if (t !== undefined)
+                acc.summaryTurnCount = (acc.summaryTurnCount ?? 0) + t;
+            return;
+        }
+        case "model.completed": {
+            // The per-LLM-call token ledger: Σ the four token fields across the
+            // session's completions. Source of cost.totalTokens and cacheReadRatio
+            // (no rollup writer ever populates a cache ratio).
+            const t = acc.modelTokens ?? { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+            t.input += asNumber(data.inputTokens) ?? 0;
+            t.output += asNumber(data.outputTokens) ?? 0;
+            t.cacheRead += asNumber(data.cacheReadTokens) ?? 0;
+            t.cacheCreation += asNumber(data.cacheCreationTokens) ?? 0;
+            acc.modelTokens = t;
+            return;
+        }
+        // The spend kill-switch breach (LAST wins) — delegated to a fold helper (learning-fold mold) for the subdir cap.
         case "spend.exceeded":
             accumulateSpendExceeded(acc, data);
             return;
-        // OBS-3: the terminal `execution.aborted` record carries the per-ROOT
+        // The terminal `execution.aborted` record carries the per-ROOT
         // autonomy.budget limb + numbers when a per-root meter (not the priced
         // observability.spend ceiling) tripped. Capture it (LAST wins) so the spend
         // verdict names `autonomy.budget.<limb>` + the numbers in their unit, instead
         // of an operator grepping the "Per-root … budget exceeded" daemon-log line.
         case "execution.aborted": {
-            // BUDGET-LIMB-OBS: capture the abort `reason` (LAST wins) — the assembler
+            // Capture the abort `reason` (LAST wins) — the assembler
             // uses it as the `endReason` fallback when a hard abort skipped the clean
             // sessionEnd rollup, so the spend-verdict can fire + name the limb.
             const reason = asString(data.reason);
@@ -345,23 +449,21 @@ function handleEventRecord(acc, rec) {
             }
             return;
         }
-        // OBS-02 / REFLECT (Phase 226): fold learning-family records → the learning block —
-        // outcome (198) / skill invocation (201) / the reflection funnel (reflect.admitted +
-        // reflect.funnel, renamed Phase 226); ids/counts only (SEC-01). The 3 vestigial dispatch
-        // cases (sandbox-validation + user-rep-revision + generalization) were DELETED with their
-        // 0-emit events.
+        // Fold learning-family records → the learning block —
+        // outcome / skill invocation / the reflection funnel (reflect.admitted +
+        // reflect.funnel); ids/counts only, never content.
         case "learning.outcome_observed":
             accumulateLearningRecord(acc.learning, data);
             return;
         case "skill.prompt_invoked":
             accumulateSkillInvokedRecord(acc.learning, data);
             return;
-        // IMP-3 / PD-OBS-1: inline-surfaced reuse credit (memory:skill_used → used_skill_ids) — surfaces
-        // the credited skill ids on explain.skillsUsed (was DB-only, invisible to a one-call explain).
+        // Inline-surfaced reuse credit (memory:skill_used → used_skill_ids) — surfaces
+        // the credited skill ids on explain.skillsUsed (otherwise DB-only, invisible to a one-call explain).
         case "memory.skill_used":
             accumulateSkillUsedRecord(acc.learning, data);
             return;
-        // Finding A: the topic-match reuse census — folds the UNCREDITED near-misses (surfaced skills
+        // The topic-match reuse census — folds the UNCREDITED near-misses (surfaced skills
         // that overlapped the turn but missed the bar) into explain.learning.skillsSurfacedButUncredited.
         case "memory.skill_surfaced":
             accumulateSkillSurfacedRecord(acc.learning, data);
@@ -372,7 +474,7 @@ function handleEventRecord(acc, rec) {
             // counts only); bump count so a reflection-only session still yields a learning block.
             accumulateReflectFunnelRecord(acc.learning, data);
             return;
-        // OBS-4 (hindsight-reflection-20260626): the reuse→promote chain. With skill.prompt_invoked
+        // The reuse→promote chain. With skill.prompt_invoked
         // (skillsUsed) this surfaces "used skill X → promoted N" on the per-session learning block.
         case "learning.skill_promoted":
             accumulateSkillTransitionRecord(acc.learning, data, "promoted");
@@ -380,19 +482,19 @@ function handleEventRecord(acc, rec) {
         case "learning.skill_demoted":
             accumulateSkillTransitionRecord(acc.learning, data, "demoted");
             return;
-        // OBS-4b: the corroborated-failure accrual (eviction-causation precursor) → the learning block.
+        // The corroborated-failure accrual (eviction-causation precursor) → the learning block.
         case "learning.memory_failure_attributed":
             accumulateMemoryFailureRecord(acc.learning, data);
             return;
         case "execution.tool_schema_unsupported":
-            // GBNF-02 (175): the strip-retry self-heal record (LAST wins — terminal
+            // The strip-retry self-heal record (LAST wins — terminal
             // repair state). Content-free fold (see obs-explain-signal-folds.ts).
             acc.toolSchemaUnsupported = accumulateToolSchemaRecord(data);
             return;
-        // 186/187/192/196: image.* + media.vision.* + video.* + media.stt.*/media.tts.*
-        // lifecycles → applyMediaRecord folds each into its reconstructed turn (seq-aware
-        // IN-04). The explicit media.stt.*/media.tts.* arms are LOAD-BEARING — without
-        // them the default: below silently DROPS voice records (Pitfall 2).
+        // image.* + media.vision.* + video.* + media.stt.*/media.tts.*
+        // lifecycles → applyMediaRecord folds each into its reconstructed turn
+        // (seq-aware). The explicit media.stt.*/media.tts.* arms are LOAD-BEARING —
+        // without them the default: below silently DROPS voice records.
         case "image.requested":
         case "image.generated":
         case "image.delivered":
@@ -425,7 +527,7 @@ function handleEventRecord(acc, rec) {
  * Normalize a heterogeneous record stream (raw log lines AND/OR structured
  * trajectory events) into one `IncidentSignals` view.
  *
- * The 678 `hasMisclassificationSignal` derivation uses log evidence only:
+ * The `hasMisclassificationSignal` derivation uses log evidence only:
  * a tool with BOTH ≥1 success and ≥`MISCLASS_N` failures whose failure body
  * carried a status/200/403 token. No `classifiedFailureBy` is consulted.
  */
@@ -437,6 +539,8 @@ export function toIncidentSignals(records) {
         offloads: [],
         nodeBudgetBreaches: [],
         spawnNodesByLease: new Map(),
+        orchestrateRunsByRunId: new Map(),
+        orchestrateToolCallsByLease: new Map(),
         hasDoNotRetrySignal: false,
         synthesizedBreakerTools: new Set(),
         misclassTokenByTool: new Map(),
@@ -449,7 +553,7 @@ export function toIncidentSignals(records) {
         learning: emptyLearningFold(),
         sessionKey: "",
         seq: 0,
-        // IN-04: -1 so the FIRST real terminal record always sets outcome (seeds do not).
+        // -1 so the FIRST real terminal record always sets outcome (seeds do not).
         imageOutcomeSeq: -1,
         visionOutcomeSeq: -1,
         videoOutcomeSeq: -1,
@@ -457,14 +561,14 @@ export function toIncidentSignals(records) {
         terminalDrivePromotedCount: 0,
     };
     for (const rec of records) {
-        // W8: envelope agentId (first seen) — the metadata rollup often lacks it.
+        // Envelope agentId (first seen) — the metadata rollup often lacks it.
         if (acc.agentId === undefined) {
             const envelopeAgentId = asString(rec.agentId);
             if (envelopeAgentId !== undefined && envelopeAgentId.length > 0)
                 acc.agentId = envelopeAgentId;
         }
         if (rec.traceSchema === "comis-trajectory") {
-            // OBS-4: count distinct turns (envelope traceId, one per agent turn) so the
+            // Count distinct turns (envelope traceId, one per agent turn) so the
             // report can flag whole-session toolStats as cumulative-across-N-turns (the
             // trajectory JSONL is append-only across reset_conversation severs).
             const tid = asString(rec.traceId);
@@ -473,7 +577,7 @@ export function toIncidentSignals(records) {
             handleEventRecord(acc, rec);
         }
         else if (rec.traceSchema === "comis-cache-trace") {
-            // W8: cache-layer telemetry — NOT tool evidence. Its tool:before/tool:after
+            // Cache-layer telemetry — NOT tool evidence. Its tool:before/tool:after
             // stage records carry toolName + success and previously fell into the
             // log-shape handler, double-counting every tool call (live ctx_search ok:2
             // for one call). Skipped until a dedicated cache-stage handler exists.
@@ -525,7 +629,7 @@ export function toIncidentSignals(records) {
             break;
         }
     }
-    const learning = buildLearningSignal(acc.learning); // OBS-02 (198): undefined ⇒ omitted below
+    const learning = buildLearningSignal(acc.learning); // undefined ⇒ omitted below
     return {
         sessionKey: acc.sessionKey,
         toolStats,
@@ -533,11 +637,25 @@ export function toIncidentSignals(records) {
         breakerEvents: acc.breakerEvents,
         offloads: acc.offloads,
         nodeBudgetBreaches: acc.nodeBudgetBreaches,
-        // TREE (215-03): materialize the lease-keyed spawn nodes → array (first-seen
+        // Materialize the lease-keyed spawn nodes → array (first-seen
         // order); present ONLY when ≥1 capability.audited record (the presence-conditional mold).
         ...(acc.spawnNodesByLease.size > 0
             ? { spawnTree: [...acc.spawnNodesByLease.values()] }
             : {}),
+        // Materialize the run skeletons → array (first-seen order), JOINing each run's
+        // toolCalls from the per-run leaseId tally (EXPLAIN-04: a deny is attributed to
+        // the run via its child leaseId). Present ONLY when ≥1 orchestrate.run_summary
+        // record (the presence-conditional spawnTree mold).
+        ...(acc.orchestrateRunsByRunId.size > 0
+            ? {
+                orchestrate: [...acc.orchestrateRunsByRunId.values()].map((run) => ({
+                    ...run,
+                    toolCalls: run.leaseId !== undefined
+                        ? [...(acc.orchestrateToolCallsByLease.get(run.leaseId)?.values() ?? [])]
+                        : [],
+                })),
+            }
+            : {}),
         ...(acc.breakerOpenedTool !== undefined ? { breakerOpenedTool: acc.breakerOpenedTool } : {}),
         hasDoNotRetrySignal: acc.hasDoNotRetrySignal,
         ...(mostFailedTool !== undefined ? { mostFailedTool } : {}),
@@ -546,9 +664,12 @@ export function toIncidentSignals(records) {
         ...(misclassifiedTool !== undefined ? { misclassifiedTool } : {}),
         ...(misclassifiedToken !== undefined ? { misclassifiedToken } : {}),
         ...(acc.contextBudget !== undefined ? { contextBudget: acc.contextBudget } : {}),
-        // E2: surface the cascade ONLY when ≥2 distinct budget states occurred (a single state adds
+        // Surface the cascade ONLY when ≥2 distinct budget states occurred (a single state adds
         // nothing over `contextBudget`; the dedup already collapsed a stable session to ≤1).
         ...(acc.contextBudgetHistory.length >= 2 ? { contextBudgetHistory: acc.contextBudgetHistory } : {}),
+        // A woke fire's wake-gate fact (absent when the trajectory carries no
+        // scheduler.wake_gate record — a non-gate session or a skip, which opens none).
+        ...(acc.cronWakeGate !== undefined ? { cronWakeGate: acc.cronWakeGate } : {}),
         ...(acc.promptTimeout !== undefined ? { promptTimeout: acc.promptTimeout } : {}),
         ...(acc.toolSchemaUnsupported !== undefined
             ? { toolSchemaUnsupported: acc.toolSchemaUnsupported }
@@ -564,7 +685,7 @@ export function toIncidentSignals(records) {
                 },
             }
             : {}),
-        // PERSIST-01 (176-05): collapse the per-reason cache-break fold → a bounded,
+        // Collapse the per-reason cache-break fold → a bounded,
         // deterministically-ordered array (count desc, then reason asc — the fleet
         // degradedByCause ordering). Present ONLY when the session had ≥1 cache break
         // (undefined, never [], when none). estCostUsd rounded to cents-precision to
@@ -580,20 +701,26 @@ export function toIncidentSignals(records) {
                     .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason)),
             }
             : {}),
-        // SPEND (WEBUI-04, 179-04): the terminal spend-kill breach (undefined when not spend-killed — never {}); the verdict stays amount-free, this carries the numbers.
+        // The terminal spend-kill breach (undefined when not spend-killed — never {}); the verdict stays amount-free, this carries the numbers.
         ...(acc.spend !== undefined ? { spend: acc.spend } : {}),
-        // OBS-3: the per-ROOT autonomy.budget limb that tripped (token/wall-clock/$),
+        // The per-ROOT autonomy.budget limb that tripped (token/wall-clock/$),
         // with its numbers in their unit — lets the spend verdict name the exact knob.
         ...(acc.perRootBudget !== undefined ? { perRootBudget: acc.perRootBudget } : {}),
+        ...(acc.summaryCostUsd !== undefined ? { summaryCostUsd: acc.summaryCostUsd } : {}),
+        ...(acc.summaryTurnCount !== undefined ? { summaryTurnCount: acc.summaryTurnCount } : {}),
+        ...(acc.modelTokens !== undefined ? { modelTokens: acc.modelTokens } : {}),
+        ...(acc.turnFinalized !== undefined ? { turnFinalized: acc.turnFinalized } : {}),
+        ...(acc.deliveryAborts !== undefined ? { deliveryAborts: acc.deliveryAborts } : {}),
+        ...(acc.recoveries !== undefined ? { recoveries: acc.recoveries } : {}),
         ...(acc.abortReason !== undefined ? { abortReason: acc.abortReason } : {}),
-        // OBS-4: surface the turn span ONLY when >1 — it flags the whole-session toolStats
+        // Surface the turn span ONLY when >1 — it flags the whole-session toolStats
         // as cumulative across N turns (the trajectory is append-only across severs), so a
         // reader does not misread a multi-turn count as this-turn. Absent for a 1-turn session.
         ...(acc.turnTraceIds.size > 1 ? { turnCount: acc.turnTraceIds.size } : {}),
         ...(learning !== undefined ? { learning } : {}),
         ...(acc.agentId !== undefined ? { agentId: acc.agentId } : {}),
         ...(acc.channel !== undefined ? { channel: acc.channel } : {}),
-        // DRIVE-02: surface the backgrounding ONLY when ≥1 promotion fired (undefined,
+        // Surface the backgrounding ONLY when ≥1 promotion fired (undefined,
         // never {}, when no drive backgrounded) — lets the terminal-drive verdict cite it.
         ...(acc.terminalDrivePromotedCount > 0
             ? {
@@ -603,7 +730,22 @@ export function toIncidentSignals(records) {
                 },
             }
             : {}),
-        // 186/187/192/196: surface the reconstructed image/vision/video/voice turns (presence-conditional; voice = the OBS-02 oracle, keyless costUsd:0 visible).
+        // Surface a reaper eviction ONLY when one fired (undefined, never {}, when
+        // no drive was evicted). `wasProducing` is DERIVED from the already-folded
+        // drive_promoted reason (zero new events) — the acute canary (a drive
+        // that had been producing when the reaper idle-killed it). Lets the
+        // terminal_drive_evicted verdict distinguish a cut-short producing drive from an
+        // expected idle-out of a never-producing one.
+        ...(acc.terminalDriveEvictedReason !== undefined
+            ? {
+                terminalDriveEvicted: {
+                    reason: acc.terminalDriveEvictedReason,
+                    idleMs: acc.terminalDriveEvictedMs ?? 0,
+                    wasProducing: acc.terminalDrivePromotedReason === "producing",
+                },
+            }
+            : {}),
+        // Surface the reconstructed image/vision/video/voice turns (presence-conditional; keyless voice costUsd:0 stays visible).
         ...(acc.image !== undefined ? { image: acc.image } : {}),
         ...(acc.vision !== undefined ? { vision: acc.vision } : {}),
         ...(acc.video !== undefined ? { videoGenerated: acc.video } : {}),

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-spend-verdict.d.ts

@@ -1,34 +1,33 @@
 /**
- * WR-4 (177-obs-loop): the NAMED terminal SPEND root-cause verdict spliced into
+ * The NAMED terminal SPEND root-cause verdict spliced into
  * the `obs-explain-heuristics` registry — `spend_exceeded`.
  *
  * Extracted into this sibling (the `obs-explain-learning-verdicts.ts` discipline)
  * to keep `obs-explain-heuristics.ts` under the 500-line `obs-handlers/*` subdir
  * cap. PURE: no LLM, no I/O, no globals — same signals ⇒ same verdict forever
- * (the Glass Box determinism invariant).
+ * (the report-determinism invariant).
  *
- * Ordering contract (registry position #2 — LIVE v2.28 260621): the dollars
+ * Ordering contract (registry position #2): the dollars
  * kill-switch is an ADMINISTRATIVE pre-emption that aborts at admission, causally
  * INDEPENDENT of tool failures (a failed tool returns ~0 bytes / ~$0 and cannot
  * drive cumulative spend). It is therefore NOT a downstream terminal label like
  * context_exhausted / output_starved / prompt_timeout (which a runaway tool CAN
  * cause) — it out-ranks the breaker/dependency/timeout/degradation heuristics and
- * sits directly below the single X3-frozen content_heuristic_misclassification
- * verdict (the one specific Comis-defect indicator). It was originally spliced
- * into the terminal band below every tool-failure cause; a live VPS incident
- * proved that masked the kill-switch behind chronic breaker noise — a spend-killed
- * session root-caused to breaker_opened_repeated_failure while the operator's
- * turns were all blocked by the ceiling. Before the verdict existed at all a
- * spend-killed session root-caused to NOTHING (the security-review WR-4 finding);
- * both gaps directly violated this milestone's thesis + CLAUDE.md's troubleshooting
- * feedback loop ("verdict ranked chronic noise over the acute event").
+ * sits directly below the single fixture-frozen content_heuristic_misclassification
+ * verdict (the one specific Comis-defect indicator). Splicing it any lower —
+ * into the terminal band below the tool-failure causes — masks the kill-switch
+ * behind chronic breaker noise: a spend-killed
+ * session would root-cause to breaker_opened_repeated_failure while the operator's
+ * turns were all blocked by the ceiling (and without the verdict at all a
+ * spend-killed session root-causes to NOTHING). The acute administrative event
+ * must out-rank the chronic noise.
  *
  * Keys on the metadata-derived endReason (END_REASON_MAP spend_exceeded →
- * "spend_exceeded", WR-2). The frozen 678/503 fixtures carry no endReason
+ * "spend_exceeded"). The frozen 678/503 fixtures carry no endReason
  * "spend_exceeded" ⇒ cannot regress them. The detail NAMES the config key family
- * the operator turns (the §2.7 "name the knob" doctrine); the exact breached
+ * the operator turns (the "name the exact knob" doctrine); the exact breached
  * scope + per-scope $ amounts live on the content-free spend.exceeded trajectory
- * record (WR-4), pointed to by the suggested step. The return type is structurally
+ * record, pointed to by the suggested step. The return type is structurally
  * identical to the registry's `RootCause` (no cross-module type import ⇒ no cycle).
  *
  * @module