comisai 1.0.45 → 1.0.46

package/node_modules/@comis/core/dist/api-contracts/incident-report.d.ts

@@ -1,7 +1,7 @@
 /**
- * The `obs.explain` contract: the §6.3 `IncidentReport` wire schema + shape
- * types + the `ObsExplainContract` itself (Phase 153 centerpiece). Extracted
- * from `observability.ts` to keep that module under the file-size cap.
+ * The `obs.explain` contract: the `IncidentReport` wire schema + shape
+ * types + the `ObsExplainContract` itself. Extracted from `observability.ts`
+ * to keep that module under the file-size cap.
  *
  * Barrel-only: external consumers import these from `"@comis/core"`. The
  * `observability.ts` barrel re-exports them (and the `OBSERVABILITY_CONTRACTS`
@@ -13,26 +13,26 @@
  * @module
  */
 import { z } from "zod";
-import { IncidentContextBudgetSchema, IncidentPromptTimeoutSchema, SpawnTreeNodeSchema } from "./incident-report-sections.js";
-import type { IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentPromptTimeout, SpawnTreeNode } from "./incident-report-sections.js";
+import { IncidentContextBudgetSchema, IncidentCronWakeGateSchema, IncidentPromptTimeoutSchema, SpawnTreeNodeSchema, OrchestrateRunSchema } from "./incident-report-sections.js";
+import type { IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentCronWakeGate, IncidentPromptTimeout, SpawnTreeNode, OrchestrateRun } from "./incident-report-sections.js";
 /**
- * The §6.3 `IncidentReport` wire shape (the `obs.explain` response).
+ * The `IncidentReport` wire shape (the `obs.explain` response).
  *
  * A self-contained, redaction-safe post-mortem for a single agent session:
  * outcome, cost, timing, per-tool stats, normalized failures (newest-first),
  * the circuit-breaker timeline, large-result offloads, a one-paragraph
- * summary, a deterministic `likelyRootCause` (heuristic registry, Plan 05),
- * report-level next steps, and an honest `truncations[]` ledger (Plan 04
+ * summary, a deterministic `likelyRootCause` (heuristic registry),
+ * report-level next steps, and an honest `truncations[]` ledger (the
  * bounding pass records what it dropped).
  *
  * Field bounding (≤200-char `errorPreview`, digest-only `resultDigest`, the
- * 6 KB summary budget) is ENFORCED by the Plan-04 bounding pass — this schema
+ * 6 KB summary budget) is ENFORCED by the bounding pass — this schema
  * only declares the shape. `suggestedNextSteps` appears BOTH inside
  * `likelyRootCause` (matching the heuristic `RootCause` 1:1) and at the report
  * root (report-level guidance); both are required-or-default.
  */
-export { IncidentContextBudgetSchema, IncidentPromptTimeoutSchema, SpawnTreeNodeSchema, };
-export type { IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentPromptTimeout, SpawnTreeNode };
+export { IncidentContextBudgetSchema, IncidentCronWakeGateSchema, IncidentPromptTimeoutSchema, SpawnTreeNodeSchema, OrchestrateRunSchema, };
+export type { IncidentContextBudget, IncidentContextBudgetHistoryEntry, IncidentCronWakeGate, IncidentPromptTimeout, SpawnTreeNode, OrchestrateRun };
 export declare const IncidentReportSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     sessionKey: z.ZodString;
@@ -115,6 +115,40 @@ export declare const IncidentReportSchema: z.ZodObject<{
         denials: z.ZodArray<z.ZodString>;
         budgetTokensUsed: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
+    orchestrate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        leaseId: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodEnum<{
+            success: "success";
+            failure: "failure";
+        }>;
+        durationMs: z.ZodNumber;
+        exitCode: z.ZodNumber;
+        failureClass: z.ZodOptional<z.ZodEnum<{
+            timeout: "timeout";
+            stdout_cap: "stdout_cap";
+            nonzero_exit: "nonzero_exit";
+            spawn_fail: "spawn_fail";
+            lease_absent: "lease_absent";
+        }>>;
+        toolCalls: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            capability: z.ZodString;
+            decision: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        resultRefs: z.ZodObject<{
+            count: z.ZodNumber;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>;
+        savings: z.ZodOptional<z.ZodObject<{
+            estSavedTokens: z.ZodNumber;
+            savedRatio: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     contextBudget: z.ZodOptional<z.ZodObject<{
         windowTokens: z.ZodNumber;
         rawContextWindowTokens: z.ZodNumber;
@@ -137,6 +171,13 @@ export declare const IncidentReportSchema: z.ZodObject<{
             exhausted: "exhausted";
         }>;
     }, z.core.$strip>>;
+    cronWakeGate: z.ZodOptional<z.ZodObject<{
+        jobId: z.ZodString;
+        wake: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+        toolCalls: z.ZodNumber;
+        estTurnsSaved: z.ZodNumber;
+    }, z.core.$strip>>;
     contextBudgetHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
         windowTokens: z.ZodNumber;
         assembledInputTokens: z.ZodNumber;
@@ -263,6 +304,22 @@ export declare const IncidentReportSchema: z.ZodObject<{
         cap: z.ZodNumber;
         unit: z.ZodString;
     }, z.core.$strip>>;
+    activityFinalize: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodString;
+        outcome: z.ZodString;
+        errorKind: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        reclassified: z.ZodBoolean;
+    }, z.core.$strip>>;
+    recoveries: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        byReason: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    deliverySkipped: z.ZodOptional<z.ZodObject<{
+        events: z.ZodNumber;
+        chunksNotSent: z.ZodNumber;
+    }, z.core.$strip>>;
     turnCount: z.ZodOptional<z.ZodNumber>;
     summary: z.ZodString;
     likelyRootCause: z.ZodNullable<z.ZodObject<{
@@ -305,332 +362,13 @@ export declare const IncidentReportSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-/** The §6.3 IncidentReport (the `obs.explain` response). Inferred from the Zod schema. */
+/** The IncidentReport (the `obs.explain` response). Inferred from the Zod schema. */
 export type IncidentReport = z.infer<typeof IncidentReportSchema>;
-/**
- * A single normalized failure entry the assembler emits (and the bounding
- * pass trims). Mirrors `IncidentReport.failures[]` so the normalizer output
- * maps 1:1 onto the wire shape.
- */
-export interface IncidentFailure {
-    seq: number;
-    toolName: string;
-    classifiedFailureBy: string;
-    transportOk: boolean;
-    httpStatus?: number;
-    errorKind: string;
-    matchedToken?: string;
-    /** #4: the failure-detector sub-rule ("self_grade" = a clean domain task-failure
-     *  via the #1 self-grade envelope, vs an error-token rule) — surfaced on
-     *  `explain.failures` so an honest task-failure is distinguishable from a transport error. */
-    matchedRule?: string;
-    resultDigest: string;
-    resultBytes: number;
-    errorPreview: string;
-}
-/**
- * The normalizer output (`toIncidentSignals`) that Plans 02/03/05 consume.
- *
- * One shared contract for the heuristic registry's predicates: raw per-tool
- * stats + normalized failures/breaker/offload arrays, plus the derived
- * booleans/strings the deterministic `RootCause` rules key on (breaker-opened
- * tool, "DO NOT retry" signal, most-failed tool, the content-heuristic
- * misclassification signal + offending tool/token). Derived from the heuristic
- * predicates in 153-PATTERNS.md ("678 / 503 heuristic derivation").
- */
-export interface IncidentSignals {
-    sessionKey: string;
-    /** W8: agentId from the trajectory record envelopes (first seen). Fallback for
-     *  reports whose metadata rollup carries no agentId. */
-    agentId?: string;
-    /** W8: channel identity from the session.started trajectory record. Fallback for
-     *  reports whose metadata rollup carries no channel. */
-    channel?: {
-        type: string;
-        id: string;
-    };
-    toolStats: Record<string, {
-        ok: number;
-        failed: number;
-        topErrorKind?: string;
-    }>;
-    /** DRIVE-02: set when a terminal/coding-CLI drive was promoted to a backgrounded
-     *  drive-owner during the session — folded from `terminal.drive_promoted` trajectory
-     *  records (bridged from the `terminal:drive_promoted` event, previously daemon-log-only).
-     *  `reason` is the promotion enum (`mode_detached` | `producing`), last-wins; `count` is
-     *  how many fired. Lets the terminal-drive verdict cite the backgrounding. Absent (never
-     *  `{}`) when no drive backgrounded. */
-    terminalDrivePromoted?: {
-        reason: string;
-        count: number;
-    };
-    failures: IncidentFailure[];
-    breakerEvents: Array<{
-        seq: number;
-        event: "opened" | "reset";
-        toolName: string;
-        consecutiveFailures?: number;
-    }>;
-    offloads: Array<{
-        seq: number;
-        toolName: string;
-        originalChars: number;
-        pointer: string;
-    }>;
-    /** ORCH-OBS: per-node token-budget breaches (BUDGET-03) folded from
-     *  `subagent.budget_exceeded` trajectory records — the per-incident view (capSource
-     *  + the two token numbers) the IncidentReport surfaces. */
-    nodeBudgetBreaches: Array<{
-        seq: number;
-        nodeId: string;
-        capSource: "node" | "operator-default" | "inherit-share" | "unknown";
-        tokenBudget: number;
-        tokensUsed: number;
-    }>;
-    /** TREE-01/02 (215): the spawn-tree nodes folded from `capability.audited`
-     *  records — one node per `leaseId` (in-process records group under their
-     *  synthetic `rootRunId`). Optional (the `recall`/`spend` presence-conditional
-     *  mold): absent when the trajectory carried no `capability.audited` records, so
-     *  the assembler omits the report section. Node shape: {@link SpawnTreeNode}. */
-    spawnTree?: SpawnTreeNode[];
-    breakerOpenedTool?: string;
-    hasDoNotRetrySignal: boolean;
-    mostFailedTool?: string;
-    repeatedFailureCount: Record<string, number>;
-    hasMisclassificationSignal: boolean;
-    misclassifiedTool?: string;
-    misclassifiedToken?: string;
-    /** GBNF-02: derived from `execution.tool_schema_unsupported` trajectory records
-     *  (last record wins — one strip-retry per session means at most a handful).
-     *  Content-free by construction: tool + keyword NAMES only. `reason`
-     *  (175-REVIEW WR-05) discriminates the handler branch so gate-closed and
-     *  nothing-to-strip terminals stay distinguishable in the verdict; optional
-     *  because pre-WR-05 trajectory records on disk lack it. */
-    toolSchemaUnsupported?: {
-        toolNames: string[];
-        strippedKeywords: string[];
-        retried: boolean;
-        succeeded: boolean;
-        reason?: "stripped" | "nothing_to_strip" | "gate_closed";
-    };
-    /**
-     * The mapped terminal `endReason` (the NAMED degradation cause — QT2/QT3 Glass
-     * Box degradation detectors). Metadata-derived (NOT from the trajectory record
-     * stream — `toIncidentSignals` omits it), so the handler threads
-     * `report.outcome.endReason` onto the signals before running the registry. The
-     * two lowest-priority heuristics (`context_exhausted` / `output_starved`) key
-     * on it — they explain the TERMINAL state, so a tool-failure cause out-ranks
-     * them. Absent ⇒ those rules do not fire (a clean session names no cause).
-     */
-    endReason?: string;
-    /**
-     * BUDGET-LIMB-OBS: the terminal `execution.aborted` record's `reason` (e.g.
-     * "spend_exceeded"), captured by `toIncidentSignals` from the trajectory. UNLIKE
-     * `endReason` (metadata-derived), this IS in the record stream — so when a HARD
-     * abort skipped the clean `sessionEnd` rollup (leaving metadata's endReason
-     * absent), the assembler uses it as the `endReason` fallback. Without it a
-     * per-root budget abort surfaced endReason:"unknown" + a null spend-verdict
-     * despite the trajectory carrying the limb (memory-learning-stress-catalog-20260629).
-     */
-    abortReason?: string;
-    /**
-     * RECALL-01: the report's authoritative `outcome.degraded` flag (derived by the
-     * assembler from the closed HARD_FAILURE/DEGRADED end-reason sets), threaded by
-     * the handler alongside `endReason`. Lets the `recall_miss` heuristic gate on
-     * genuine degradation instead of re-deriving it from endReason strings (a
-     * zero-hit recall on a healthy turn is benign and must never name a cause).
-     * Absent ⇒ the rule does not fire.
-     */
-    degraded?: boolean;
-    /**
-     * W3: the terminal per-call budget equation from the trajectory's
-     * `context.budget` records (last wins). Lets the `context_exhausted`
-     * heuristic produce a numbers-backed verdict naming the cap knob and the
-     * tool-schema share instead of the generic speculation.
-     */
-    contextBudget?: IncidentContextBudget;
-    /** E2: the per-turn context-budget cascade toward the terminal `contextBudget` (≥2 distinct states;
-     *  deduped on transition, most-recent-40 capped). The assembler folds it onto IncidentReport. */
-    contextBudgetHistory?: IncidentContextBudgetHistoryEntry[];
-    /**
-     * LAT-04 (177): the LAST `execution.prompt_timeout` trajectory record (the
-     * terminal kill explains the end state). Lets the `prompt_timeout` heuristic
-     * produce a numbers-backed verdict naming the binding knob (stall) or
-     * `stallCeilingMultiplier` (makespan) instead of falling through to NO
-     * verdict. Absent ⇒ pre-extension session (the rule degrades to a generic
-     * knob suggestion when `endReason` is "timeout").
-     */
-    promptTimeout?: IncidentPromptTimeout;
-    /**
-     * RECALL-01: memory-recall outcome aggregated over the session's
-     * `memory.recalled` trajectory records. Lets the `recall_miss` heuristic name a
-     * zero-hit recall on a degraded session (the #1 blind spot). Counts/booleans
-     * only. Absent ⇒ no recall records in the trajectory (omitted from the report).
-     */
-    recall?: {
-        recalls: number;
-        zeroHits: number;
-        lastLanes: number;
-        lastFinalCount: number;
-        rerankerAvailable: boolean;
-    };
-    /**
-     * PERSIST-01 (176-05): cache breaks folded per-reason from the session's
-     * `cache.break` trajectory records (Plan 04). Bounded + deterministically
-     * ordered (count desc, reason asc). Counts + a closed reason label + a summed
-     * est-$ ONLY (never the changed tool names). Absent ⇒ no cache breaks in the
-     * trajectory (omitted from the report — the `recall?` presence-conditional mold).
-     */
-    cacheBreaks?: Array<{
-        reason: string;
-        count: number;
-        estCostUsd: number;
-    }>;
-    /**
-     * SPEND (WEBUI-04 / 179-04): the spend kill-switch breach folded from the
-     * session's terminal `spend.exceeded` trajectory record (last wins). `totalUsd`
-     * is the breaching scope's spent total (the record's `spentUsd`); `capUsd` is its
-     * ceiling. Content-free (a scope enum + two numbers). Absent ⇒ the session was
-     * not spend-killed (omitted from the report — the `cacheBreaks?` presence mold).
-     */
-    spend?: {
-        scope: string;
-        totalUsd: number;
-        capUsd: number;
-    };
-    /**
-     * OBS-3 (openclaw-usecases 2026-06-25): the per-ROOT `autonomy.budget` limb that
-     * tripped, folded from the terminal `execution.aborted` record's `perRootBudget`
-     * (last wins). DISTINCT from `spend` (the priced `observability.spend` ceiling):
-     * `spent`/`cap` are tokens / ms / USD per `unit`, and the knob is
-     * `autonomy.budget.<limb>`. Lets the spend verdict name the exact limb. Absent ⇒
-     * not a per-root spend-abort.
-     */
-    perRootBudget?: {
-        limb: string;
-        spent: number;
-        cap: number;
-        unit: string;
-    };
-    /**
-     * OBS-4 (openclaw-usecases 2026-06-25): the number of DISTINCT turns (envelope
-     * `traceId`, one per agent turn) the trajectory spans. The session trajectory JSONL
-     * is append-only across `session.reset_conversation` severs, so the whole-session
-     * `toolStats` can be the SUM across many turns — surfacing this (only when >1) flags
-     * the counts as cumulative so a reader does not misread a multi-turn count as
-     * this-turn. Absent for a single-turn session.
-     */
-    turnCount?: number;
-    /**
-     * OBS-03/OBS-04 (Phase 186): the image-generation turn reconstructed from the
-     * session's `image.*` trajectory records (the terminal image.generated /
-     * image.failed record wins; `delivered` set when image.delivered fired). The
-     * cost (`costUsd`) rides HERE so `comis explain` shows it from the trajectory
-     * (Route a) — NOT `cost.costUsd` (the executor `sessionEnd`, a different path —
-     * Pitfall 2). Content-free. Absent ⇒ no image records in the trajectory.
-     */
-    image?: {
-        provider: string;
-        model?: string;
-        costUsd?: number;
-        outcome: "ok" | "failed";
-        errorKind?: string;
-        delivered: boolean;
-        /** WR-02 (186): false on a persist-failed-but-delivered generation (degraded
-         *  delivery, still outcome:"ok", still charged). Absent ⇒ persisted. */
-        persisted?: boolean;
-    };
-    /**
-     * VIS-04 (Phase 187): the VISION turn reconstructed from the session's
-     * `media.vision.*` trajectory records (the terminal media.vision.completed /
-     * media.vision.failed record wins). The cost (`costUsd`) rides HERE so `comis
-     * explain` shows it from the trajectory (Route a) — NOT `cost.costUsd`
-     * (Pitfall 2). The `path` is VIS-03's "which tier served". Content-free.
-     * Absent ⇒ no media.vision.* records in the trajectory.
-     */
-    vision?: {
-        provider: string;
-        mainProvider?: string;
-        model?: string;
-        costUsd?: number;
-        path?: "main-vision" | "registry" | "gemini-video" | "unavailable";
-        outcome: "ok" | "failed";
-        errorKind?: string;
-    };
-    /**
-     * OBS-03/OBS-04 (Phase 192): the VIDEO-generation turn reconstructed from the
-     * session's `video.*` trajectory records (the terminal `video.generated` /
-     * `video.failed` record wins; `delivered` set when `video.delivered` fired,
-     * `jobId` carried from `video.submitted`). The cost rides HERE so `comis
-     * explain` shows it from the trajectory (Route a — NOT `cost.costUsd`,
-     * Pitfall 2). A background-completed job's later completion stitches to its
-     * originating turn via `traceId`/`jobId` on one `sessionKey` (the offline
-     * assembler is the binding oracle). Content-free. Absent ⇒ no `video.*`
-     * records in the trajectory.
-     */
-    videoGenerated?: {
-        provider: string;
-        model?: string;
-        jobId?: string;
-        costUsd?: number;
-        estimatedCostUsd?: number;
-        durationSecs?: number;
-        outcome: "ok" | "failed";
-        errorKind?: string;
-        delivered: boolean;
-    };
-    /**
-     * OBS-02/OBS-05 (Phase 196): the VOICE turn reconstructed from the session's
-     * `media.stt.*` / `media.tts.*` trajectory records (the terminal completed/
-     * failed record wins). Wholly in-turn (the daemon voice RPC handlers
-     * direct-emit). The cost rides HERE (Route a — NOT `cost.costUsd`, Pitfall 2):
-     * `0` explicit on keyless (OBS-05 "free" visible), absent on keyed (no per-call
-     * source — FLAG 4). `source` is the OBS-03 selection rung. Content-free. Absent
-     * ⇒ no `media.stt.*`/`media.tts.*` records in the trajectory.
-     */
-    voice?: {
-        provider: string;
-        keyless: boolean;
-        model?: string;
-        durationMs?: number;
-        costUsd?: number;
-        source?: "explicit" | "keyless-local" | "follow-main-key" | "fallback";
-        outcome: "ok" | "failed";
-        errorKind?: string;
-    };
-    /**
-     * OBS-02 (Phase 198): the outcome-signal telemetry reconstructed from the
-     * session's `learning.outcome_observed` trajectory records (counts/ids/closed
-     * enums ONLY — the bridged record carries no body/alpha/recalled-ids; SEC-01).
-     * `outcomeResolved` is false ⇒ the learning shadow observed this finished
-     * trajectory but no signal tier produced a resolvable outcome (the
-     * `outcome_unresolved` verdict keys on exactly this — distinct from an explicit
-     * `unknown` outcome, which IS a resolution). `skillsUsed`/`skillFailures` are
-     * EMPTY in P0 (skill-use attribution lands Phase 201); `synthesisAbstained` is
-     * false in P0 (synthesis is Phase 201). Absent ⇒ no learning records in the
-     * trajectory (omitted from the report — the signal is per-agent default-OFF).
-     * (The Phase-203 `userModelRevised`/`memoriesGeneralized` counts were removed in
-     * Phase 226 with their 0-emit events.)
-     */
-    learning?: {
-        outcomeResolved: boolean;
-        outcome?: "success" | "failure" | "corrected" | "unknown";
-        sources: Array<"tool" | "pipeline" | "correction" | "judge" | "reaction" | "explicit">;
-        skillsUsed: string[];
-        skillFailures: string[];
-        synthesisAbstained: boolean;
-        /** OBS-4: count of candidate skills promoted to active this session (`learning.skill_promoted`). */
-        skillsPromoted?: number;
-        /** OBS-4: count of skills demoted this session (`learning.skill_demoted`). */
-        skillsDemoted?: number;
-        /** OBS-4b: memories that accrued a corroborated failure this session (`learning.memory_failure_attributed`) — eviction precursor. */
-        failuresAttributed?: number;
-    };
-}
+export type { IncidentFailure, IncidentSignals } from "./incident-report-signals.js";
 /**
  * Assemble a redaction-safe post-mortem for a single agent session.
  *
- * Accepts ONE of `sessionKey`, `traceId`, or `rootRunId` (FLEET-05; the
+ * Accepts ONE of `sessionKey`, `traceId`, or `rootRunId` (the
  * `.refine` rejects none-of-three). A `traceId` is canonicalized to its
  * sessionKey, and a `rootRunId` (an autonomy run) is canonicalized to the
  * run's sessionKey, so there is one assembler path. `depth` selects the
@@ -728,6 +466,40 @@ export declare const ObsExplainContract: import("./types.js").ApiContract<z.ZodO
         denials: z.ZodArray<z.ZodString>;
         budgetTokensUsed: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
+    orchestrate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        leaseId: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodEnum<{
+            success: "success";
+            failure: "failure";
+        }>;
+        durationMs: z.ZodNumber;
+        exitCode: z.ZodNumber;
+        failureClass: z.ZodOptional<z.ZodEnum<{
+            timeout: "timeout";
+            stdout_cap: "stdout_cap";
+            nonzero_exit: "nonzero_exit";
+            spawn_fail: "spawn_fail";
+            lease_absent: "lease_absent";
+        }>>;
+        toolCalls: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            capability: z.ZodString;
+            decision: z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+            }>;
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+        resultRefs: z.ZodObject<{
+            count: z.ZodNumber;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>;
+        savings: z.ZodOptional<z.ZodObject<{
+            estSavedTokens: z.ZodNumber;
+            savedRatio: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     contextBudget: z.ZodOptional<z.ZodObject<{
         windowTokens: z.ZodNumber;
         rawContextWindowTokens: z.ZodNumber;
@@ -750,6 +522,13 @@ export declare const ObsExplainContract: import("./types.js").ApiContract<z.ZodO
             exhausted: "exhausted";
         }>;
     }, z.core.$strip>>;
+    cronWakeGate: z.ZodOptional<z.ZodObject<{
+        jobId: z.ZodString;
+        wake: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+        toolCalls: z.ZodNumber;
+        estTurnsSaved: z.ZodNumber;
+    }, z.core.$strip>>;
     contextBudgetHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
         windowTokens: z.ZodNumber;
         assembledInputTokens: z.ZodNumber;
@@ -876,6 +655,22 @@ export declare const ObsExplainContract: import("./types.js").ApiContract<z.ZodO
         cap: z.ZodNumber;
         unit: z.ZodString;
     }, z.core.$strip>>;
+    activityFinalize: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodString;
+        outcome: z.ZodString;
+        errorKind: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        reclassified: z.ZodBoolean;
+    }, z.core.$strip>>;
+    recoveries: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        byReason: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    deliverySkipped: z.ZodOptional<z.ZodObject<{
+        events: z.ZodNumber;
+        chunksNotSent: z.ZodNumber;
+    }, z.core.$strip>>;
     turnCount: z.ZodOptional<z.ZodNumber>;
     summary: z.ZodString;
     likelyRootCause: z.ZodNullable<z.ZodObject<{