comisai 1.0.45 → 1.0.46

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

@@ -7,18 +7,18 @@
  * the image/vision/video/voice folds used (`obs-explain-voice-fold.ts`). Houses
  * the pure reductions that turn one trajectory record's `data` into an
  * `IncidentSignals` field:
- *   - `accumulateLearningRecord` / `buildLearningSignal` — the OBS-02 (Phase 198)
+ *   - `accumulateLearningRecord` / `buildLearningSignal` — the
  *     learning outcome-signal block from `learning.outcome_observed` records.
- *   - `accumulateToolSchemaRecord` — the GBNF-02 (Phase 175) tool-schema-rejection
+ *   - `accumulateToolSchemaRecord` — the tool-schema-rejection
  *     block from `execution.tool_schema_unsupported` records.
  *
  * Every fold is content-free by construction: it reads ONLY ids / closed enums /
  * counts / booleans, dropping any off-vocabulary value (defence-in-depth — a
- * smuggled enum/body never enters the verdict surface; SEC-01 / T-175-17).
+ * smuggled enum/body never enters the verdict surface).
  *
  * @module
  */
-import { IncidentContextBudgetSchema, IncidentPromptTimeoutSchema } from "@comis/core";
+import { IncidentContextBudgetSchema, IncidentCronWakeGateSchema, IncidentPromptTimeoutSchema } from "@comis/core";
 // The content-free readers live in the sibling fields helper (one source of truth);
 // imported here so the GBNF fold reuses them rather than re-deriving (no cycle —
 // the fields helper does not import this module).
@@ -70,7 +70,7 @@ export function accumulateLearningRecord(state, data) {
         // session's meaningful result and is never clobbered by a later `unknown` (a
         // trailing no-signal turn). Only fall back to `unknown` when nothing has resolved
         // yet, so an all-unknown session still reports `unknown`. `everResolved` (NOT the
-        // last record) is what `outcomeResolved` keys on. Live VPS finding 2026-06-18.
+        // last record) is what `outcomeResolved` keys on.
         if (outcome !== "unknown") {
             state.outcome = outcome;
             state.everResolved = true;
@@ -88,7 +88,7 @@ export function accumulateLearningRecord(state, data) {
  * Fold one `skill.prompt_invoked` record's `data` into the state (mutating):
  * the invoked learned-skill `skillName` joins `skillsUsed` (deduped). IDs ONLY —
  * a non-string `skillName` is dropped (a body smuggled as a name never enters
- * the surface; SEC-01 / T-201-43). Bumps `count` (a skill-only session still
+ * the surface). Bumps `count` (a skill-only session still
  * yields a learning block).
  */
 export function accumulateSkillInvokedRecord(state, data) {
@@ -100,14 +100,14 @@ export function accumulateSkillInvokedRecord(state, data) {
 /**
  * Fold one `memory.skill_used` record's `data` into the state (mutating): the per-turn
  * attributed `usedSkillIds` join `skillsUsed` (deduped). IDS ONLY — non-string entries are
- * dropped (SEC-01; a body smuggled as an id never enters the surface).
+ * dropped (a body smuggled as an id never enters the surface).
  *
- * IMP-3 / PD-OBS-1 (package-delivery-20260628): a reuse via INLINE skill-surfacing credits the
+ * A reuse via INLINE skill-surfacing credits the
  * skill through `memory:skill_used` → `outcome_events.used_skill_ids` (the topic-match path), NOT
- * an explicit `skill.prompt_invoked` file-read — so `skillsUsed` was `[]` while `skillsPromoted>0`
- * (an internally-inconsistent explain view; the credit was visible only via a DB hand-join). With
- * `memory:skill_used` now trajectory-bridged, this surfaces the credited skill ids on `explain`.
- * Bumps `count` (a skill-only session still yields a learning block).
+ * an explicit `skill.prompt_invoked` file-read — without this fold `skillsUsed` is `[]` while
+ * `skillsPromoted>0` (an internally-inconsistent explain view; the credit is visible only via a DB
+ * hand-join). With `memory:skill_used` trajectory-bridged, this surfaces the credited skill ids on
+ * `explain`. Bumps `count` (a skill-only session still yields a learning block).
  */
 export function accumulateSkillUsedRecord(state, data) {
     state.count += 1;
@@ -120,8 +120,8 @@ export function accumulateSkillUsedRecord(state, data) {
     readAbstainSignal(state, data);
 }
 /**
- * Fold one `memory.skill_surfaced` record's `data` into the state (mutating; finding A,
- * package-delivery-20260628): record the UNCREDITED entries (the reuse near-misses — a skill that
+ * Fold one `memory.skill_surfaced` record's `data` into the state
+ * (mutating): record the UNCREDITED entries (the reuse near-misses — a skill that
  * overlapped the turn but missed the credit bar) by NAME → best `coverage` seen. So `explain` can
  * answer "why wasn't my skill reused?" (it surfaced at coverage 0.45) instead of a debugger.
  *
@@ -129,7 +129,7 @@ export function accumulateSkillUsedRecord(state, data) {
  * turns, and forcing a learning block (with outcomeResolved=false) onto sessions that had none could
  * perturb the `outcome_unresolved` verdict. Near-misses therefore surface only when a real learning
  * record (skill_used/promote/outcome) already built the block — exactly the reuse-investigation case.
- * Names/numbers only; non-string names and non-number coverage are dropped (SEC-01).
+ * Names/numbers only; non-string names and non-number coverage are dropped.
  */
 export function accumulateSkillSurfacedRecord(state, data) {
     if (!Array.isArray(data.scores))
@@ -149,8 +149,8 @@ export function accumulateSkillSurfacedRecord(state, data) {
     }
 }
 /**
- * Fold one reflection-funnel record's `data` into the state (mutating; REFLECT,
- * renamed Phase 226 from `learning.skill_synthesized` — handles BOTH `reflect.admitted`
+ * Fold one reflection-funnel record's `data` into the state (mutating —
+ * handles BOTH `reflect.admitted`
  * and `reflect.funnel`): the only signal it contributes is the BENIGN abstain flag
  * (the payload is counts + a closed admissionOutcome enum only — no body crosses).
  * Bumps `count` (a reflection-only session still yields a learning block).
@@ -161,11 +161,11 @@ export function accumulateReflectFunnelRecord(state, data) {
 }
 /**
  * Fold one `learning.skill_promoted` / `learning.skill_demoted` record's `data` into the state
- * (mutating; SURFACE-06, COUNTS ONLY). `data.count` is the number promoted/demoted this resolve;
- * bump the matching tally + `count`. OBS-4 (hindsight-reflection-20260626): with `skill.prompt_invoked`
+ * (mutating; COUNTS ONLY). `data.count` is the number promoted/demoted this resolve;
+ * bump the matching tally + `count`. With `skill.prompt_invoked`
  * (already folded into `skillsUsed`) this makes the reuse→promote chain readable on the per-session
  * learning block — `comis explain <session>` shows "used skill X → promoted N" in one call instead of
- * a trajectory + outcome_events + mental_models hand-join. A non-numeric `count` is read as 0 (SEC-01).
+ * a trajectory + outcome_events + mental_models hand-join. A non-numeric `count` is read as 0.
  */
 export function accumulateSkillTransitionRecord(state, data, direction) {
     state.count += 1;
@@ -174,7 +174,7 @@ export function accumulateSkillTransitionRecord(state, data, direction) {
         state.skillsPromoted += n;
     else {
         state.skillsDemoted += n;
-        // Finding C: collect WHICH skills demoted (names; ids only — non-string entries dropped, SEC-01).
+        // Collect WHICH skills demoted (names; ids only — non-string entries dropped).
         if (Array.isArray(data.demotedSkillNames)) {
             for (const name of data.demotedSkillNames)
                 if (typeof name === "string")
@@ -184,10 +184,10 @@ export function accumulateSkillTransitionRecord(state, data, direction) {
     readAbstainSignal(state, data);
 }
 /**
- * Fold one `learning.memory_failure_attributed` record's `data` into the state (mutating; OBS-4b,
+ * Fold one `learning.memory_failure_attributed` record's `data` into the state (mutating;
  * COUNTS ONLY). `data.count` is the number of memories that accrued a CORROBORATED failure this
  * resolve (the eviction-causation precursor — eviction needs failure_count >= floor); bump
- * `failuresAttributed` + `count`. A non-numeric `count` is read as 0 (SEC-01).
+ * `failuresAttributed` + `count`. A non-numeric `count` is read as 0.
  */
 export function accumulateMemoryFailureRecord(state, data) {
     state.count += 1;
@@ -195,11 +195,6 @@ export function accumulateMemoryFailureRecord(state, data) {
     state.failuresAttributed += n;
     readAbstainSignal(state, data);
 }
-// Phase 226 SIMPLIFY-04: accumulateSkillValidatedRecord (the sandbox-validation fold —
-// sandbox deleted in 223), accumulateUserModelRevisedRecord + accumulateMemoryGeneralizedRecord
-// (the user-rep revision + generalization folds — folded into reflection in 225) were DELETED
-// with their 0-emit events. `skillFailures` now keys on the terminal outcome only (a learned
-// procedure used in a failed/corrected trajectory).
 /**
  * Build the `IncidentSignals["learning"]` block from the fold, or `undefined`
  * when no learning record was seen (absent ⇒ omitted from the report).
@@ -207,11 +202,10 @@ export function accumulateMemoryFailureRecord(state, data) {
  * `"unknown"` (the fail-closed coverage rule — an unresolved/unknown finish is
  * the `outcome_unresolved` verdict's trigger).
  *
- * `skillFailures` (P2): the session's used skills surface as failures when the
+ * `skillFailures`: the session's used skills surface as failures when the
  * terminal outcome is `failure`/`corrected` — "a learned procedure was used in a
  * failed/corrected trajectory" (the `learned_skill_failing` verdict's trigger).
- * (The Phase-201 sandbox-validation failure path was removed in Phase 226 with the
- * 0-emit event.) Counts/ids/closed enums only — no body/script crosses the surface.
+ * Counts/ids/closed enums only — no body/script crosses the surface.
  */
 export function buildLearningSignal(state) {
     if (state.count === 0)
@@ -225,14 +219,14 @@ export function buildLearningSignal(state) {
         skillsUsed,
         skillFailures: outcomeFailed ? skillsUsed : [],
         synthesisAbstained: state.synthesisAbstained,
-        // OBS-4: additive — present only when a promote/demote fired this session (keeps schemaVersion 1).
+        // Additive — present only when a promote/demote fired this session (keeps schemaVersion 1).
         ...(state.skillsPromoted > 0 ? { skillsPromoted: state.skillsPromoted } : {}),
         ...(state.skillsDemoted > 0 ? { skillsDemoted: state.skillsDemoted } : {}),
-        // Finding C: additive — the demoted skill NAMES (which), present only when ≥1 named demote folded.
+        // Additive — the demoted skill NAMES (which), present only when ≥1 named demote folded.
         ...(state.skillsDemotedNames.size > 0 ? { skillsDemotedNames: [...state.skillsDemotedNames] } : {}),
-        // OBS-4b: additive — present only when a corroborated failure accrued this session.
+        // Additive — present only when a corroborated failure accrued this session.
         ...(state.failuresAttributed > 0 ? { failuresAttributed: state.failuresAttributed } : {}),
-        // Finding A: additive — the reuse near-misses (uncredited surfaced skills), best coverage desc.
+        // Additive — the reuse near-misses (uncredited surfaced skills), best coverage desc.
         // Present only when ≥1 near-miss was seen (and the block exists at all — count>0 from a real record).
         ...(state.skillsSurfacedButUncredited.size > 0
             ? {
@@ -244,16 +238,16 @@ export function buildLearningSignal(state) {
     };
 }
 // ---------------------------------------------------------------------------
-// GBNF-02 (Phase 175): the tool-schema-rejection fold (`execution.tool_schema_unsupported`).
+// The tool-schema-rejection fold (`execution.tool_schema_unsupported`).
 // ---------------------------------------------------------------------------
 const TOOL_SCHEMA_REASONS = ["stripped", "nothing_to_strip", "gate_closed"];
 /**
  * Build the `IncidentSignals["toolSchemaUnsupported"]` block from one
  * `execution.tool_schema_unsupported` record's `data` (LAST record wins — the
  * caller assigns it each time, so the terminal repair state explains the end).
- * Content-free (tool + keyword NAMES only — I7; string-array + exact-true reads
- * drop smuggled payload — T-175-17). The WR-05 reason is narrowed to its closed
- * vocabulary (off-vocabulary → undefined so pre-WR-05 records stay readable).
+ * Content-free (tool + keyword NAMES only; string-array + exact-true reads
+ * drop smuggled payload). The reason is narrowed to its closed
+ * vocabulary (off-vocabulary → undefined so a reason-less record stays readable).
  */
 export function accumulateToolSchemaRecord(data) {
     const reason = narrow(TOOL_SCHEMA_REASONS, data.reason);
@@ -266,11 +260,11 @@ export function accumulateToolSchemaRecord(data) {
     };
 }
 // ---------------------------------------------------------------------------
-// SPEND (WEBUI-04, 179-04): the spend kill-switch breach fold.
+// The spend kill-switch breach fold.
 // ---------------------------------------------------------------------------
 /**
- * Fold one `spend.exceeded` trajectory record (177-obs-loop WR-4
- * translateSpendPayload → `{scope, spentUsd, capUsd, estUsd}`, content-free) into
+ * Fold one `spend.exceeded` trajectory record
+ * (translateSpendPayload → `{scope, spentUsd, capUsd, estUsd}`, content-free) into
  * the `acc.spend` field. The LAST record wins (the terminal breach explains the
  * kill); the section's `totalUsd` maps from the record's `spentUsd` (the breaching
  * scope's spent total). A breach with no `scope` is defensively ignored (acc.spend
@@ -288,16 +282,16 @@ export function accumulateSpendExceeded(acc, data) {
     };
 }
 /**
- * Fold one `capability.audited` trajectory record (the per-cap audit Plan 01
- * emits at the gate chokepoint — the spawn-tree's per-node source) into the
+ * Fold one `capability.audited` trajectory record (the per-cap audit
+ * emitted at the gate chokepoint — the spawn-tree's per-node source) into the
  * lease-keyed `spawnNodesByLease` working map. Group by leaseId into ONE node per
- * lease; an in-process record (no real lease, G1) keys on its synthetic rootRunId
+ * lease; an in-process record (no real lease) keys on its synthetic rootRunId
  * (NEVER a fabricated lease-<id>). The node collects the attenuated caps it held
  * (deduped), the tool NAMES it invoked, and any CapabilityDeniedError cap (a
- * `deny` decision → denials[], TREE-02). The record is content-free by
+ * `deny` decision → denials[]). The record is content-free by
  * construction (the translator strips bodies/args); agentId rides the envelope
  * (`rec.agentId`, with the first-seen `accAgentId` fallback). budgetTokensUsed is
- * honestly omitted unless the record carries it (G3 — the live whoami is the
+ * honestly omitted unless the record carries it (the live whoami is the
  * authoritative remaining-budget surface; this is the post-mortem topology).
  *
  * Mutates the passed map (the learning-fold delegation mold); typed structurally
@@ -305,8 +299,8 @@ export function accumulateSpendExceeded(acc, data) {
  * the internal Acc (no cycle).
  */
 export function accumulateCapabilityAuditedRecord(spawnNodesByLease, data, recAgentId, accAgentId) {
-    // WR-01: group by leaseId, falling back to the synthetic rootRunId for the
-    // lease-less in-process leg (G1). A record carrying NEITHER is not a
+    // Group by leaseId, falling back to the synthetic rootRunId for the
+    // lease-less in-process leg. A record carrying NEITHER is not a
     // reconstructable node — drop it rather than folding every such record into one
     // junk leaseId:"" node (the subagent.budget_exceeded `nodeId === undefined`
     // guard precedent). In normal operation rootRunId is always present; this
@@ -335,8 +329,8 @@ export function accumulateCapabilityAuditedRecord(spawnNodesByLease, data, recAg
     if (data.decision === "deny" && cap !== undefined && !node.denials.includes(cap)) {
         node.denials.push(cap);
     }
-    // IN-02: intentional forward-scaffolding — no producer emits budgetTokensUsed on
-    // a capability.audited record today (the live `whoami` owns remaining budget, G3;
+    // Intentional forward-scaffolding — no producer emits budgetTokensUsed on
+    // a capability.audited record today (the live `whoami` owns remaining budget;
     // this fold is post-mortem topology). The optional read stays so a future
     // per-node budget producer needs no fold change; it is `undefined` until then.
     const budgetTokensUsed = asNumber(data.budgetTokensUsed);
@@ -345,13 +339,13 @@ export function accumulateCapabilityAuditedRecord(spawnNodesByLease, data, recAg
     spawnNodesByLease.set(leaseId, node);
 }
 /**
- * Fold one `graph.node_spawned` trajectory record (finding D, TREE-01) into the
+ * Fold one `graph.node_spawned` trajectory record into the
  * spawn-tree working map. A graph DAG node spawns in-process (gatedSpawn →
  * subAgentRunner.spawn), so it never crosses the socket chokepoint that emits
  * `capability.audited` — and every node shares the graph's `rootRunId`, so the
  * capability fold's `leaseId ?? rootRunId` key would collapse them all into ONE
  * node. So graph nodes get their OWN key: the stable `graphId:nodeId` identity
- * (NOT a fabricated socket lease — G1 forbids that; this is a graph-node id that
+ * (NOT a fabricated socket lease — never fabricate one; this is a graph-node id that
  * just happens to live in the `leaseId` field, the same way the in-process leg's
  * synthetic rootRunId does). The node nests under the graph root via
  * `parentLeaseId = rootRunId`. One leaf per node (spawn fires once; the
@@ -384,11 +378,83 @@ export function accumulateGraphNodeSpawnedRecord(spawnNodesByLease, data) {
         denials: [],
     });
 }
-// ---------------------------------------------------------------------------
-// Schema-validated LAST-wins folds (W3 context.budget / LAT-04 prompt_timeout).
-// ---------------------------------------------------------------------------
+const ORCHESTRATE_FAILURE_CLASSES = ["timeout", "stdout_cap", "nonzero_exit", "spawn_fail", "lease_absent"];
+/**
+ * Fold one `orchestrate.run_summary` trajectory record into the run-keyed
+ * `orchestrateRunsByRunId` working map (one skeleton per `runId`, FIRST-SEEN kept —
+ * a duplicate re-emit is idempotent). Builds the content-free run skeleton from the
+ * record's `data` (the translator forwards ids + the closed `failureClass` enum +
+ * counts + token estimates; agentId/sessionKey/stderr never cross). `outcome` is
+ * derived from `exitCode` (0 → success, else failure) — a `lease_absent` run may
+ * ride a clean exit-0 (still outcome:success). A record with NO `runId` is not a
+ * reconstructable run — dropped (the accumulateCapabilityAuditedRecord malformed→drop
+ * precedent). `savings` is carried only when BOTH `estSavedTokens` and `savedRatio`
+ * are present (a sub-threshold run has neither). `toolCalls` are NOT set here — they
+ * are joined at materialization from the per-run leaseId tally (accumulateOrchestrateToolCall).
+ *
+ * Mutates the passed map (the learning-fold delegation mold); typed structurally to
+ * avoid importing the internal Acc (no cycle).
+ */
+export function accumulateOrchestrateRunSummaryRecord(orchestrateRunsByRunId, data) {
+    const runId = asString(data.runId);
+    if (runId === undefined)
+        return; // malformed → drop (never a junk run)
+    if (orchestrateRunsByRunId.has(runId))
+        return; // first-seen kept (idempotent re-emit)
+    const exitCode = asNumber(data.exitCode) ?? 0;
+    const failureClass = narrow(ORCHESTRATE_FAILURE_CLASSES, data.failureClass);
+    const leaseId = asString(data.leaseId);
+    const estSavedTokens = asNumber(data.estSavedTokens);
+    const savedRatio = asNumber(data.savedRatio);
+    orchestrateRunsByRunId.set(runId, {
+        runId,
+        ...(leaseId !== undefined ? { leaseId } : {}),
+        outcome: exitCode === 0 ? "success" : "failure",
+        durationMs: asNumber(data.durationMs) ?? 0,
+        exitCode,
+        ...(failureClass !== undefined ? { failureClass } : {}),
+        resultRefs: {
+            count: asNumber(data.resultRefCount) ?? 0,
+            bytes: asNumber(data.resultRefBytes) ?? 0,
+        },
+        ...(estSavedTokens !== undefined && savedRatio !== undefined
+            ? { savings: { estSavedTokens, savedRatio } }
+            : {}),
+    });
+}
 /**
- * Validate one `context.budget` record (W3 — the per-call budget equation from
+ * Fold one `capability.audited` trajectory record into the per-run tool-call
+ * tally `orchestrateToolCallsByLease` — keyed by the record's `leaseId` (the
+ * daemon-minted PER-RUN child lease), then by the `${tool} ${capability} ${decision}`
+ * tuple → a `{tool,capability,decision,count}` running count. This is EXPLAIN-04:
+ * because the leaseId is per-run, a `decision:"deny"` groups under THE RUN that made
+ * the call, not the assembly. Reads the SAME records the spawn-tree fold sees (called
+ * alongside it — no duplicate event). Content-free (tool NAME + capability + the
+ * closed allow|deny decision + count only). A record with no `leaseId` (no run
+ * correlation), a missing tool/capability, or an off-vocabulary decision is dropped.
+ *
+ * Mutates the passed map (typed structurally — no Acc import, no cycle).
+ */
+export function accumulateOrchestrateToolCall(orchestrateToolCallsByLease, data) {
+    const leaseId = asString(data.leaseId);
+    if (leaseId === undefined)
+        return; // no run correlation → drop
+    const tool = asString(data.tool);
+    const capability = asString(data.capability);
+    const decision = data.decision === "allow" ? "allow" : data.decision === "deny" ? "deny" : undefined;
+    if (tool === undefined || capability === undefined || decision === undefined)
+        return;
+    const inner = orchestrateToolCallsByLease.get(leaseId) ?? new Map();
+    const key = `${tool} ${capability} ${decision}`;
+    const prev = inner.get(key);
+    if (prev !== undefined)
+        prev.count += 1;
+    else
+        inner.set(key, { tool, capability, decision, count: 1 });
+    orchestrateToolCallsByLease.set(leaseId, inner);
+}
+/**
+ * Validate one `context.budget` record (the per-call budget equation from
  * the LCD pre-flight) wholesale; return the parsed value or `undefined` (a
  * malformed/partial record is ignored — forward-compatible). The caller keeps
  * the LAST successful parse (the terminal fit check explains the end state).
@@ -398,12 +464,25 @@ export function parseContextBudgetRecord(data) {
     return parsed.success ? parsed.data : undefined;
 }
 /**
- * Validate one `execution.prompt_timeout` record (LAT-04 — the terminal
+ * Validate one `execution.prompt_timeout` record (the terminal
  * prompt-timeout attribution) wholesale; return the parsed value or `undefined`
- * (the context.budget discipline, T-177-17 — pre-extension timeoutMs-only rows
+ * (the context.budget discipline — timeoutMs-only rows
  * still parse, every other field optional). The caller keeps the LAST parse.
  */
 export function parsePromptTimeoutRecord(data) {
     const parsed = IncidentPromptTimeoutSchema.safeParse(data);
     return parsed.success ? parsed.data : undefined;
 }
+/**
+ * Validate one `scheduler.wake_gate` record (a woke fire's content-free wake-gate
+ * fact) wholesale; return the parsed value or `undefined` (a malformed/partial
+ * record is ignored — the context.budget discipline). The caller keeps the LAST
+ * successful parse (the terminal fire explains the session). Only a fire the gate
+ * WOKE writes this record — a skip opens no session, so this fold never runs for a
+ * skip. Any off-vocabulary key (the record carries `agentId`; a caller could smuggle
+ * a finding) is stripped by the bounded schema — no gate body crosses into the report.
+ */
+export function parseWakeGateRecord(data) {
+    const parsed = IncidentCronWakeGateSchema.safeParse(data);
+    return parsed.success ? parsed.data : undefined;
+}

package/node_modules/@comis/daemon/dist/api/obs-handlers/obs-explain-signals-acc.d.ts

@@ -2,15 +2,15 @@
  * The internal mutable accumulator for `toIncidentSignals` (obs-explain-signals.ts):
  * every record handler folds into this, and it is collapsed into the public
  * `IncidentSignals` at the end. Extracted to keep obs-explain-signals.ts under the
- * obs-handlers per-subdirectory file-size cap (the ORCH-OBS nodeBudgetBreaches field
+ * obs-handlers per-subdirectory file-size cap (the nodeBudgetBreaches field
  * pushed it over). Type-only; no behavior change.
  *
  * @module
  */
 import type { IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentFailure, IncidentPromptTimeout, IncidentSignals } from "@comis/core";
 import type { IncidentImageSignal, IncidentVisionSignal, IncidentVideoSignal, IncidentVoiceSignal } from "./obs-explain-signals-fields.js";
-import type { LearningFoldState } from "./obs-explain-signal-folds.js";
-/** TREE (215-03): the per-node working shape the `capability.audited` fold
+import type { LearningFoldState, OrchestrateRunFold, OrchestrateToolCallFold } from "./obs-explain-signal-folds.js";
+/** The per-node working shape the `capability.audited` fold
  *  accumulates into (one per leaseId). Materialized into
  *  `IncidentSignals["spawnTree"]` at the end of `toIncidentSignals`. */
 export type SpawnNode = NonNullable<IncidentSignals["spawnTree"]>[number];
@@ -24,10 +24,19 @@ export interface Acc {
     breakerEvents: IncidentSignals["breakerEvents"];
     offloads: IncidentSignals["offloads"];
     nodeBudgetBreaches: IncidentSignals["nodeBudgetBreaches"];
-    /** TREE (215-03): the `capability.audited` fold groups nodes by leaseId
+    /** The `capability.audited` fold groups nodes by leaseId
      *  (in-process records key on the synthetic rootRunId). Materialized into
      *  `spawnTree` at the end; absent → the section is omitted. */
     spawnNodesByLease: Map<string, SpawnNode>;
+    /** The `orchestrate.run_summary` fold groups runs by runId (first-seen kept).
+     *  Materialized (with joined toolCalls) into `orchestrate` at the end of
+     *  toIncidentSignals; absent → the section is omitted. */
+    orchestrateRunsByRunId: Map<string, OrchestrateRunFold>;
+    /** The per-run tool-call tally from `capability.audited`, keyed by the PER-RUN
+     *  child leaseId → the `${tool} ${capability} ${decision}` tuple → count. Joined
+     *  onto each run's `toolCalls` at materialization (EXPLAIN-04: the per-run leaseId
+     *  attributes a deny to THE RUN). */
+    orchestrateToolCallsByLease: Map<string, Map<string, OrchestrateToolCallFold>>;
     breakerOpenedTool?: string;
     hasDoNotRetrySignal: boolean;
     /** Tools for which a log-shape breaker "opened" event was already synthesized
@@ -37,20 +46,23 @@ export interface Acc {
     synthesizedBreakerTools: Set<string>;
     /** Per-tool: did any failure body carry a status/200/403 token? */
     misclassTokenByTool: Map<string, string>;
-    /** W3: the LAST context.budget trajectory record (the terminal fit check). */
+    /** The LAST context.budget trajectory record (the terminal fit check). */
     contextBudget?: IncidentContextBudget;
-    /** E2: the per-turn context-budget CASCADE (the progression toward `contextBudget`). Deduped on
+    /** The per-turn context-budget CASCADE (the progression toward `contextBudget`). Deduped on
      *  transition + most-recent-40 capped (see the context.budget fold). Surfaced only when ≥2 states. */
     contextBudgetHistory: IncidentContextBudgetHistoryEntry[];
-    /** LAT-04: the LAST execution.prompt_timeout record (the terminal kill
+    /** The LAST `scheduler.wake_gate` record (a woke fire's content-free wake-gate
+     *  fact). Present ONLY for a fire the gate woke — a skip opens no session. */
+    cronWakeGate?: IncidentSignals["cronWakeGate"];
+    /** The LAST execution.prompt_timeout record (the terminal kill
      *  explains the end state — a retry-path kill earlier in the session is
      *  superseded by the kill that actually ended it). */
     promptTimeout?: IncidentPromptTimeout;
-    /** GBNF-02: the LAST `execution.tool_schema_unsupported` record — the
+    /** The LAST `execution.tool_schema_unsupported` record — the
      *  strip-retry self-heal outcome (one strip-retry per session means at most
      *  a handful; the terminal repair state explains the end). */
     toolSchemaUnsupported?: IncidentSignals["toolSchemaUnsupported"];
-    /** RECALL-01: aggregated over `memory.recalled` records — how many recalls ran,
+    /** Aggregated over `memory.recalled` records — how many recalls ran,
      *  how many returned zero injected memories, and the TERMINAL recall's shape. */
     recallCount: number;
     recallZeroHits: number;
@@ -59,14 +71,14 @@ export interface Acc {
         finalCount: number;
         rerankerAvailable: boolean;
     };
-    /** PERSIST-01 (176-05): cache breaks folded per-reason from `cache.break` records
-     *  (Plan 04) — `{count, estCostUsd}` summed per closed reason. Counts + a number
+    /** Cache breaks folded per-reason from `cache.break` records
+     *  — `{count, estCostUsd}` summed per closed reason. Counts + a number
      *  ONLY (never the changed tool names — the trajectory carries only the digest). */
     cacheBreaksByReason: Map<string, {
         count: number;
         estCostUsd: number;
     }>;
-    /** SPEND (WEBUI-04, 179-04): the LAST `spend.exceeded` trajectory record's breach
+    /** The LAST `spend.exceeded` trajectory record's breach
      *  (the terminal kill explains the end state — a warn earlier in the session is
      *  superseded by the breach that actually killed it). `totalUsd` is the record's
      *  `spentUsd`; `capUsd` its ceiling. Content-free (a scope enum + two numbers). */
@@ -75,7 +87,7 @@ export interface Acc {
         totalUsd: number;
         capUsd: number;
     };
-    /** OBS-3: the per-ROOT autonomy.budget limb that tripped (from the terminal
+    /** The per-ROOT autonomy.budget limb that tripped (from the terminal
      *  `execution.aborted` record's `perRootBudget`). DISTINCT from `spend` (the
      *  priced observability.spend $-ceiling): the token / wall-clock limbs carry
      *  tokens / ms in `spent`/`cap` (NOT dollars), and the right knob is
@@ -86,7 +98,45 @@ export interface Acc {
         cap: number;
         unit: string;
     };
-    /** BUDGET-LIMB-OBS (memory-learning-stress-catalog-20260629): the terminal
+    /** The LAST `activity.turn_finalized` record — the terminal user-surface
+     *  state (strategy + effective outcome + reclassified flag). Content-free. */
+    turnFinalized?: {
+        strategy: string;
+        outcome: string;
+        errorKind?: string;
+        reason?: string;
+        reclassified: boolean;
+    };
+    /** Σ over `delivery.aborted` records: events + blocks never sent. */
+    deliveryAborts?: {
+        events: number;
+        chunksNotSent: number;
+    };
+    /** Recovery-attempt fold from `execution.recovery_attempted` records:
+     *  total + succeeded tally + per-reason counts. */
+    recoveries?: {
+        total: number;
+        succeeded: number;
+        byReason: Record<string, number>;
+    };
+    /** Σ of the session's `session.summary` records' costUsd (one record per
+     *  execution) — the trajectory-derived session cost the assembler prefers
+     *  over the last-write-wins sessionEnd rollup. Absent ⇒ no summary records. */
+    summaryCostUsd?: number;
+    /** Σ of the session's `session.summary` records' turnCount — the
+     *  trajectory-derived turn total the assembler prefers over the
+     *  last-write-wins rollup turnCount. Absent ⇒ no summary records. */
+    summaryTurnCount?: number;
+    /** Σ of the session's `model.completed` token fields — the trajectory-derived
+     *  token ledger (source of cost.totalTokens + cacheReadRatio). Absent ⇒ no
+     *  model.completed records. */
+    modelTokens?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheCreation: number;
+    };
+    /** The terminal
      *  `execution.aborted` record's `reason` (e.g. "spend_exceeded"). A HARD abort
      *  skips the clean `sessionEnd` rollup, so the assembler's metadata-derived
      *  `endReason` falls through to "unknown" and the spend-verdict (gated on
@@ -94,10 +144,10 @@ export interface Acc {
      *  abort reason as the endReason fallback. Content-free (a closed reason enum). */
     abortReason?: string;
     learning: LearningFoldState;
-    /** The image (186) / vision (187) / video (192) / voice (196) turns reconstructed
+    /** The image / vision / video / voice turns reconstructed
      *  from the session's image.* / media.vision.* / video.* / media.stt / media.tts
      *  records (folded by `applyMediaRecord`). Each is undefined until its record class
-     *  is seen. The paired *OutcomeSeq makes each fold seq-aware (IN-04 — a stale
+     *  is seen. The paired *OutcomeSeq makes each fold seq-aware (a stale
      *  lower-seq terminal never overwrites a newer one). */
     image?: IncidentImageSignal;
     imageOutcomeSeq: number;
@@ -107,10 +157,10 @@ export interface Acc {
     videoOutcomeSeq: number;
     voice?: IncidentVoiceSignal;
     voiceOutcomeSeq: number;
-    /** W8: event-shape tool.result toolCallIds already counted (dedup — the same
+    /** Event-shape tool.result toolCallIds already counted (dedup — the same
      *  call must not count twice if its result event is duplicated across sources). */
     seenToolResultCallIds: Set<string>;
-    /** OBS-4 (openclaw-usecases 2026-06-25): the distinct turn ids (envelope `traceId`,
+    /** The distinct turn ids (envelope `traceId`,
      *  one per agent turn) seen in the trajectory. The session trajectory JSONL is
      *  APPEND-ONLY across `session.reset_conversation` severs, so a single file (and the
      *  whole-session `toolStats` derived from it) can span MANY turns — counting these
@@ -118,17 +168,22 @@ export interface Acc {
      *  this-turn (the near-miss that cost a cycle: a `toolStats` count read as one turn
      *  was actually the sum across several). */
     turnTraceIds: Set<string>;
-    /** W8: agentId from the first record envelope that carries one. */
+    /** agentId from the first record envelope that carries one. */
     agentId?: string;
-    /** W8: channel identity from the session.started record's data. */
+    /** Channel identity from the session.started record's data. */
     channel?: {
         type: string;
         id: string;
     };
     sessionKey: string;
     seq: number;
-    /** DRIVE-02: the LAST `terminal.drive_promoted` reason seen (mode_detached |
+    /** The LAST `terminal.drive_promoted` reason seen (mode_detached |
      *  producing), and how many promotions fired. Folded into `terminalDrivePromoted`. */
     terminalDrivePromotedReason?: string;
     terminalDrivePromotedCount: number;
+    /** The LAST `terminal.session_evicted` reason (idle | max_sessions |
+     *  wall_clock | max_interactions) + the session lifetime at that eviction. Folded into
+     *  `terminalDriveEvicted`; `wasProducing` is derived from `terminalDrivePromotedReason`. */
+    terminalDriveEvictedReason?: string;
+    terminalDriveEvictedMs?: number;
 }