@crewhaus/spec 0.1.8 → 0.2.0

package/dist/index.d.ts

@@ -65,6 +65,93 @@ declare const subAgentDefinitionSchema: z.ZodObject<{
     } | undefined;
     inherit_bypass?: boolean | undefined;
 }>;
+/**
+ * Item 22 — spec-declared provider failover chain, on the agent blocks of
+ * the shapes whose emitted runtime calls `runChatLoop` with a single
+ * primary model (cli, channel, managed today).
+ *
+ * `model_fallbacks` is an ordered list of model strings tried when the
+ * primary's circuit breaker is open — each entry follows the SAME
+ * model-string grammar as `agent.model` (`claude-*`, `openai/*`,
+ * `bedrock/*`, `groq/*`, …; validated like `agent.model` at parse time,
+ * with the full grammar enforced by the model-router when resolved).
+ * Cross-provider fallbacks resolve their own credentials lazily via the
+ * normal model-router path — a fallback with a missing key warns at boot
+ * and is skipped when tried, never hard-failing the run.
+ *
+ * `circuit_breaker` tunes the per-candidate breakers. Field names mirror
+ * `CircuitBreakerOptions` in `@crewhaus/circuit-breaker` exactly
+ * (failureThreshold / windowMs / cooldownMs); package defaults (5 failures
+ * / 60s window / 30s cooldown) apply per field when omitted. Declaring
+ * `circuit_breaker` WITHOUT `model_fallbacks` is valid: the primary
+ * adapter alone gets breaker-wrapped (fail-fast on a degraded provider
+ * instead of hammering it).
+ */
+declare const modelFallbacksBlock: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+declare const circuitBreakerBlock: z.ZodOptional<z.ZodObject<{
+    /** Consecutive failures inside windowMs that trip the breaker. */
+    failureThreshold: z.ZodOptional<z.ZodNumber>;
+    /** Window for counting consecutive failures (ms). */
+    windowMs: z.ZodOptional<z.ZodNumber>;
+    /** How long the breaker stays open before allowing a probe (ms). */
+    cooldownMs: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    failureThreshold?: number | undefined;
+    windowMs?: number | undefined;
+    cooldownMs?: number | undefined;
+}, {
+    failureThreshold?: number | undefined;
+    windowMs?: number | undefined;
+    cooldownMs?: number | undefined;
+}>>;
+/**
+ * Item 26 — opt-in two-tier turn-difficulty router. When present, the runtime
+ * picks a model tier PER TURN from deterministic signals (estimated context
+ * tokens, whether tools are in play, turn index, prior-turn tool_use density):
+ * the cheap `fast` model for easy turns, the `default` model for hard ones. A
+ * fast-tier turn that FAILS re-runs on `default` (misroute recovery). Both are
+ * full model-router grammar strings. `routing` tunes the escalation thresholds
+ * (all optional — sensible defaults apply). Omitted entirely → single-model
+ * behaviour, byte-identical bundles.
+ */
+declare const modelTiersBlock: z.ZodOptional<z.ZodObject<{
+    fast: z.ZodString;
+    default: z.ZodString;
+    routing: z.ZodOptional<z.ZodObject<{
+        contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+        toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+        firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+        priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        contextTokenThreshold?: number | undefined;
+        toolsToDefault?: boolean | undefined;
+        firstTurnToDefault?: boolean | undefined;
+        priorToolDensityThreshold?: number | undefined;
+    }, {
+        contextTokenThreshold?: number | undefined;
+        toolsToDefault?: boolean | undefined;
+        firstTurnToDefault?: boolean | undefined;
+        priorToolDensityThreshold?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    default: string;
+    fast: string;
+    routing?: {
+        contextTokenThreshold?: number | undefined;
+        toolsToDefault?: boolean | undefined;
+        firstTurnToDefault?: boolean | undefined;
+        priorToolDensityThreshold?: number | undefined;
+    } | undefined;
+}, {
+    default: string;
+    fast: string;
+    routing?: {
+        contextTokenThreshold?: number | undefined;
+        toolsToDefault?: boolean | undefined;
+        firstTurnToDefault?: boolean | undefined;
+        priorToolDensityThreshold?: number | undefined;
+    } | undefined;
+}>>;
 /**
  * Section 17 — optional override for the model used by
  * `compaction-autocompact` when summarising long conversations. Defaults
@@ -185,43 +272,94 @@ declare const securityBlock: z.ZodOptional<z.ZodObject<{
 declare const failureTaxonomyEntrySchema: z.ZodObject<{
     class: z.ZodString;
     pattern: z.ZodString;
-    recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+    recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
     hint: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     pattern: string;
     class: string;
-    recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+    recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
     hint?: string | undefined;
 }, {
     pattern: string;
     class: string;
-    recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+    recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
     hint?: string | undefined;
 }>;
 declare const failureTaxonomyBlock: z.ZodOptional<z.ZodArray<z.ZodObject<{
     class: z.ZodString;
     pattern: z.ZodString;
-    recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+    recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
     hint: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     pattern: string;
     class: string;
-    recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+    recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
     hint?: string | undefined;
 }, {
     pattern: string;
     class: string;
-    recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+    recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
     hint?: string | undefined;
 }>, "many">>;
+/**
+ * Item 27 — run-level spend cap with a degradation ladder. Generalizes the
+ * optimizer's `--budget-usd` to normal runs. `usd` is the dollar ceiling;
+ * when the run's accrued spend reaches it, `on_exceed` decides:
+ *   - `{ action: "stop" }`      — end the run cleanly before the next turn.
+ *   - `{ action: "degrade", model }` — re-resolve the primary model to the
+ *     cheaper `model` (one rung) and continue; a later breach on the
+ *     degraded model stops the run.
+ * The check is PRE-TURN (beside compaction), so an in-flight turn always
+ * completes. Carried on the same interactive shapes as the failover chain
+ * (cli, channel, managed). `on_exceed.model` follows the agent.model
+ * grammar. Defaults to `{ action: "stop" }` when `on_exceed` is omitted.
+ */
+declare const budgetBlock: z.ZodOptional<z.ZodObject<{
+    usd: z.ZodNumber;
+    on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+        action: z.ZodLiteral<"stop">;
+    }, "strict", z.ZodTypeAny, {
+        action: "stop";
+    }, {
+        action: "stop";
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"degrade">;
+        model: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        model: string;
+        action: "degrade";
+    }, {
+        model: string;
+        action: "degrade";
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    usd: number;
+    on_exceed: {
+        action: "stop";
+    } | {
+        model: string;
+        action: "degrade";
+    };
+}, {
+    usd: number;
+    on_exceed?: {
+        action: "stop";
+    } | {
+        model: string;
+        action: "degrade";
+    } | undefined;
+}>>;
 /**
  * Response-feedback block — declares that a harness collects human ratings on
  * agent responses (thumbs/stars/scale/comment) which `crewhaus distill` turns
  * into eval datasets + graders. Cross-cutting like security: carried on the
  * interactive shapes that consume it (cli, channel). `channelReactions` gates
  * codegen of Slack 👍/👎 → feedback in the channel target; `modality`/`storage`
- * configure the capture surfaces; `autoDistill` is a forward-looking flag for a
- * continuous flywheel. `.strict()` so a typo'd sub-key fails the build.
+ * configure the capture surfaces; `autoDistill` turns accumulated ratings into
+ * versioned `<name>-ratings` registry datasets at CLI run teardown (item 1);
+ * `exitPrompt` gates the one-keystroke REPL exit rating prompt (default on
+ * when the block is present; set `false` to keep capture surfaces without the
+ * prompt). `.strict()` so a typo'd sub-key fails the build.
  */
 declare const feedbackBlock: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -244,6 +382,7 @@ declare const feedbackBlock: z.ZodOptional<z.ZodObject<{
         location: string;
     }>>;
     autoDistill: z.ZodOptional<z.ZodBoolean>;
+    exitPrompt: z.ZodOptional<z.ZodBoolean>;
     channelReactions: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     modality: "binary" | "stars" | "scale" | "comment";
@@ -256,6 +395,7 @@ declare const feedbackBlock: z.ZodOptional<z.ZodObject<{
         location: string;
     } | undefined;
     autoDistill?: boolean | undefined;
+    exitPrompt?: boolean | undefined;
     channelReactions?: boolean | undefined;
 }, {
     enabled?: boolean | undefined;
@@ -268,15 +408,101 @@ declare const feedbackBlock: z.ZodOptional<z.ZodObject<{
         location: string;
     } | undefined;
     autoDistill?: boolean | undefined;
+    exitPrompt?: boolean | undefined;
     channelReactions?: boolean | undefined;
 }>>;
+/**
+ * Feature #53 — cross-session memory block. Its mere presence wires the
+ * Remember/Recall tools into the harness (no hand-editing). The auto-*
+ * switches layer on top: `autoCapture` summarizes the session's durable
+ * outcomes into `.crewhaus/memories/<name>.jsonl` at run teardown;
+ * `autoRecall` injects the top-`recallK` relevant memories into the system
+ * prompt at session start (mirrors project-memory auto-load). Carried on the
+ * interactive shapes that run a chat loop (cli, channel, managed, research).
+ * `.strict()` so a typo'd sub-key fails the build.
+ */
+declare const memoryBlock: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    autoCapture: z.ZodOptional<z.ZodBoolean>;
+    autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+    autoRecall: z.ZodOptional<z.ZodBoolean>;
+    recallK: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+    autoCapture?: boolean | undefined;
+    autoCaptureThreshold?: number | undefined;
+    autoRecall?: boolean | undefined;
+    recallK?: number | undefined;
+}, {
+    enabled?: boolean | undefined;
+    autoCapture?: boolean | undefined;
+    autoCaptureThreshold?: number | undefined;
+    autoRecall?: boolean | undefined;
+    recallK?: number | undefined;
+}>>;
 declare const cliSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"cli">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
         max_tokens: z.ZodOptional<z.ZodNumber>;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
         sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             description: z.ZodString;
             instructions: z.ZodString;
@@ -318,6 +544,22 @@ declare const cliSchema: z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -333,6 +575,22 @@ declare const cliSchema: z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -482,19 +740,54 @@ declare const cliSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
     feedback: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         modality: z.ZodDefault<z.ZodEnum<["binary", "stars", "scale", "comment"]>>;
@@ -516,6 +809,7 @@ declare const cliSchema: z.ZodObject<{
             location: string;
         }>>;
         autoDistill: z.ZodOptional<z.ZodBoolean>;
+        exitPrompt: z.ZodOptional<z.ZodBoolean>;
         channelReactions: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         modality: "binary" | "stars" | "scale" | "comment";
@@ -528,6 +822,7 @@ declare const cliSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }, {
         enabled?: boolean | undefined;
@@ -540,8 +835,106 @@ declare const cliSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
     cli: z.ZodOptional<z.ZodObject<{
         banner: z.ZodOptional<z.ZodObject<{
             taglineMode: z.ZodDefault<z.ZodEnum<["static", "random"]>>;
@@ -691,6 +1084,22 @@ declare const cliSchema: z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -711,6 +1120,7 @@ declare const cliSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         tui: "basic" | "rich";
         banner?: {
@@ -745,9 +1155,18 @@ declare const cliSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
     feedback?: {
         modality: "binary" | "stars" | "scale" | "comment";
         enabled?: boolean | undefined;
@@ -759,8 +1178,27 @@ declare const cliSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -803,6 +1241,22 @@ declare const cliSchema: z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -823,6 +1277,7 @@ declare const cliSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         banner?: {
             taglines: string[];
@@ -857,9 +1312,18 @@ declare const cliSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
     feedback?: {
         enabled?: boolean | undefined;
         scale?: {
@@ -871,8 +1335,27 @@ declare const cliSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -930,6 +1413,7 @@ declare const workflowStepSchema: z.ZodObject<{
 }>;
 declare const workflowSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"workflow">;
     model: z.ZodString;
     steps: z.ZodArray<z.ZodObject<{
@@ -1035,17 +1519,17 @@ declare const workflowSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1177,6 +1661,7 @@ declare const workflowSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1196,7 +1681,7 @@ declare const workflowSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -1252,6 +1737,7 @@ declare const workflowSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1271,7 +1757,7 @@ declare const workflowSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -1372,6 +1858,61 @@ declare const imessageChannelSchema: z.ZodObject<{
 declare const channelAgentSchema: z.ZodObject<{
     model: z.ZodString;
     instructions: z.ZodString;
+    model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    circuit_breaker: z.ZodOptional<z.ZodObject<{
+        /** Consecutive failures inside windowMs that trip the breaker. */
+        failureThreshold: z.ZodOptional<z.ZodNumber>;
+        /** Window for counting consecutive failures (ms). */
+        windowMs: z.ZodOptional<z.ZodNumber>;
+        /** How long the breaker stays open before allowing a probe (ms). */
+        cooldownMs: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        failureThreshold?: number | undefined;
+        windowMs?: number | undefined;
+        cooldownMs?: number | undefined;
+    }, {
+        failureThreshold?: number | undefined;
+        windowMs?: number | undefined;
+        cooldownMs?: number | undefined;
+    }>>;
+    model_tiers: z.ZodOptional<z.ZodObject<{
+        fast: z.ZodString;
+        default: z.ZodString;
+        routing: z.ZodOptional<z.ZodObject<{
+            contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+            toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+            firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+            priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        }, {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        default: string;
+        fast: string;
+        routing?: {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        } | undefined;
+    }, {
+        default: string;
+        fast: string;
+        routing?: {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        } | undefined;
+    }>>;
     tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
     sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -1415,6 +1956,22 @@ declare const channelAgentSchema: z.ZodObject<{
     instructions: string;
     model: string;
     tools?: string[] | undefined;
+    model_fallbacks?: string[] | undefined;
+    circuit_breaker?: {
+        failureThreshold?: number | undefined;
+        windowMs?: number | undefined;
+        cooldownMs?: number | undefined;
+    } | undefined;
+    model_tiers?: {
+        default: string;
+        fast: string;
+        routing?: {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        } | undefined;
+    } | undefined;
     sub_agents?: Record<string, {
         description: string;
         instructions: string;
@@ -1431,6 +1988,22 @@ declare const channelAgentSchema: z.ZodObject<{
     instructions: string;
     model: string;
     tools?: string[] | undefined;
+    model_fallbacks?: string[] | undefined;
+    circuit_breaker?: {
+        failureThreshold?: number | undefined;
+        windowMs?: number | undefined;
+        cooldownMs?: number | undefined;
+    } | undefined;
+    model_tiers?: {
+        default: string;
+        fast: string;
+        routing?: {
+            contextTokenThreshold?: number | undefined;
+            toolsToDefault?: boolean | undefined;
+            firstTurnToDefault?: boolean | undefined;
+            priorToolDensityThreshold?: number | undefined;
+        } | undefined;
+    } | undefined;
     sub_agents?: Record<string, {
         description: string;
         instructions: string;
@@ -1446,10 +2019,66 @@ declare const channelAgentSchema: z.ZodObject<{
 }>;
 declare const channelSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"channel">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
         tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
         sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -1493,6 +2122,22 @@ declare const channelSchema: z.ZodObject<{
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -1509,6 +2154,22 @@ declare const channelSchema: z.ZodObject<{
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -1770,19 +2431,54 @@ declare const channelSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
     feedback: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         modality: z.ZodDefault<z.ZodEnum<["binary", "stars", "scale", "comment"]>>;
@@ -1804,6 +2500,7 @@ declare const channelSchema: z.ZodObject<{
             location: string;
         }>>;
         autoDistill: z.ZodOptional<z.ZodBoolean>;
+        exitPrompt: z.ZodOptional<z.ZodBoolean>;
         channelReactions: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         modality: "binary" | "stars" | "scale" | "comment";
@@ -1816,6 +2513,7 @@ declare const channelSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }, {
         enabled?: boolean | undefined;
@@ -1828,8 +2526,106 @@ declare const channelSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
     heartbeat: z.ZodOptional<z.ZodObject<{
         every: z.ZodString;
         instructions: z.ZodString;
@@ -1962,12 +2758,31 @@ declare const channelSchema: z.ZodObject<{
         simulationRequired?: boolean | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
+    routing: {
+        sessionKey: "thread" | "user" | "channel";
+    };
     name: string;
     target: "channel";
     agent: {
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -2006,9 +2821,6 @@ declare const channelSchema: z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -2016,6 +2828,7 @@ declare const channelSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -2035,9 +2848,18 @@ declare const channelSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
     feedback?: {
         modality: "binary" | "stars" | "scale" | "comment";
         enabled?: boolean | undefined;
@@ -2049,8 +2871,27 @@ declare const channelSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -2095,12 +2936,31 @@ declare const channelSchema: z.ZodObject<{
         ui: boolean;
     } | undefined;
 }, {
+    routing: {
+        sessionKey: "thread" | "user" | "channel";
+    };
     name: string;
     target: "channel";
     agent: {
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -2139,9 +2999,6 @@ declare const channelSchema: z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -2149,6 +3006,7 @@ declare const channelSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -2168,9 +3026,18 @@ declare const channelSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
     feedback?: {
         enabled?: boolean | undefined;
         scale?: {
@@ -2182,8 +3049,27 @@ declare const channelSchema: z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -2274,6 +3160,7 @@ declare const graphEdgeSchema: z.ZodObject<{
 }>;
 declare const graphSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"graph">;
     model: z.ZodString;
     entry: z.ZodString;
@@ -2377,17 +3264,17 @@ declare const graphSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -2526,6 +3413,7 @@ declare const graphSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2535,7 +3423,7 @@ declare const graphSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -2594,6 +3482,7 @@ declare const graphSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2603,7 +3492,7 @@ declare const graphSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -2673,16 +3562,104 @@ declare const managedTenantSchema: z.ZodObject<{
 }>;
 declare const managedSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"managed">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
     }, "strict", z.ZodTypeAny, {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     }, {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     }>;
     tenants: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -2765,25 +3742,173 @@ declare const managedSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     name: string;
     target: "managed";
     agent: {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     };
     tenants: {
         id: string;
@@ -2799,6 +3924,7 @@ declare const managedSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2808,15 +3934,58 @@ declare const managedSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     name: string;
     target: "managed";
     agent: {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     };
     tenants: {
         id: string;
@@ -2832,6 +4001,7 @@ declare const managedSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2841,9 +4011,36 @@ declare const managedSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 declare const pipelineDocumentSchema: z.ZodObject<{
     id: z.ZodString;
@@ -2860,6 +4057,7 @@ declare const pipelineDocumentSchema: z.ZodObject<{
 }>;
 declare const pipelineSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"pipeline">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -2985,17 +4183,17 @@ declare const pipelineSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -3030,6 +4228,7 @@ declare const pipelineSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -3039,7 +4238,7 @@ declare const pipelineSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -3074,6 +4273,7 @@ declare const pipelineSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -3083,7 +4283,7 @@ declare const pipelineSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }>;
@@ -3189,6 +4389,7 @@ declare const crewRoutingSchema: z.ZodObject<{
 }>;
 declare const crewSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"crew">;
     /** Crew-wide model fallback used by any role that omits `role.model`. */
     model: z.ZodString;
@@ -3377,17 +4578,17 @@ declare const crewSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -3530,6 +4731,14 @@ declare const crewSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    routing?: {
+        kind: "match" | "llm";
+        match?: Record<string, {
+            to: string;
+            contains: string;
+        }[]> | undefined;
+    } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -3549,7 +4758,7 @@ declare const crewSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -3587,13 +4796,6 @@ declare const crewSchema: z.ZodObject<{
         maxValueUsd?: number | undefined;
         maxValueWei?: string | undefined;
     } | undefined;
-    routing?: {
-        kind: "match" | "llm";
-        match?: Record<string, {
-            to: string;
-            contains: string;
-        }[]> | undefined;
-    } | undefined;
 }, {
     model: string;
     name: string;
@@ -3623,6 +4825,14 @@ declare const crewSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    routing?: {
+        kind: "match" | "llm";
+        match?: Record<string, {
+            to: string;
+            contains: string;
+        }[]> | undefined;
+    } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -3642,7 +4852,7 @@ declare const crewSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -3680,13 +4890,6 @@ declare const crewSchema: z.ZodObject<{
         allowedContracts?: string[] | undefined;
         simulationRequired?: boolean | undefined;
     } | undefined;
-    routing?: {
-        kind: "match" | "llm";
-        match?: Record<string, {
-            to: string;
-            contains: string;
-        }[]> | undefined;
-    } | undefined;
 }>;
 declare const researchRetrieveSchema: z.ZodObject<{
     allowedOrigins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -3703,6 +4906,7 @@ declare const researchRetrieveSchema: z.ZodObject<{
 }>;
 declare const researchSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"research">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -3816,19 +5020,38 @@ declare const researchSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodLiteral<"evm">;
@@ -3963,6 +5186,7 @@ declare const researchSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -3983,9 +5207,16 @@ declare const researchSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -4037,6 +5268,7 @@ declare const researchSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -4057,9 +5289,16 @@ declare const researchSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -4124,6 +5363,7 @@ declare const batchQueueSchema: z.ZodObject<{
 }>;
 declare const batchSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"batch">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -4242,17 +5482,17 @@ declare const batchSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -4390,6 +5630,7 @@ declare const batchSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -4410,7 +5651,7 @@ declare const batchSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -4470,6 +5711,7 @@ declare const batchSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -4490,7 +5732,7 @@ declare const batchSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -4559,6 +5801,7 @@ declare const voiceTelephonySchema: z.ZodObject<{
 }>;
 declare const voiceSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"voice">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -4682,17 +5925,17 @@ declare const voiceSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -4717,6 +5960,7 @@ declare const voiceSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -4737,7 +5981,7 @@ declare const voiceSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     telephony?: {
@@ -4765,6 +6009,7 @@ declare const voiceSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -4785,7 +6030,7 @@ declare const voiceSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     telephony?: {
@@ -4822,6 +6067,7 @@ declare const browserDriverSchema: z.ZodObject<{
 }>;
 declare const browserSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"browser">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -4949,17 +6195,17 @@ declare const browserSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -4985,6 +6231,7 @@ declare const browserSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -5005,7 +6252,7 @@ declare const browserSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     groundingModel?: string | undefined;
@@ -5024,6 +6271,7 @@ declare const browserSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -5044,7 +6292,7 @@ declare const browserSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     driver?: {
@@ -5067,6 +6315,7 @@ declare const browserSchema: z.ZodObject<{
  */
 declare const evalSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"eval">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -5109,17 +6358,17 @@ declare const evalSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -5140,10 +6389,11 @@ declare const evalSchema: z.ZodObject<{
         name: string;
         opts?: Record<string, unknown> | undefined;
     }[];
+    version?: number | undefined;
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     seed?: number | undefined;
@@ -5164,10 +6414,11 @@ declare const evalSchema: z.ZodObject<{
         name: string;
         opts?: Record<string, unknown> | undefined;
     }[];
+    version?: number | undefined;
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     concurrency?: number | undefined;
@@ -5228,6 +6479,7 @@ declare const onchainTriggerSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject
 }>]>;
 declare const onchainSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"onchain">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -5483,17 +6735,17 @@ declare const onchainSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -5563,6 +6815,7 @@ declare const onchainSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -5583,7 +6836,7 @@ declare const onchainSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -5632,6 +6885,7 @@ declare const onchainSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -5652,7 +6906,7 @@ declare const onchainSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     wallets?: {
@@ -5685,6 +6939,7 @@ declare const onchainSchema: z.ZodObject<{
  */
 declare const onchainGameSchema: z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"onchain-game">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -5924,17 +7179,17 @@ declare const onchainGameSchema: z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -5994,6 +7249,7 @@ declare const onchainGameSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -6014,7 +7270,7 @@ declare const onchainGameSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -6067,6 +7323,7 @@ declare const onchainGameSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -6087,7 +7344,7 @@ declare const onchainGameSchema: z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     transaction_policy?: {
@@ -6100,11 +7357,67 @@ declare const onchainGameSchema: z.ZodObject<{
 }>;
 export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"cli">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
         max_tokens: z.ZodOptional<z.ZodNumber>;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
         sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             description: z.ZodString;
             instructions: z.ZodString;
@@ -6146,6 +7459,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -6161,6 +7490,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -6310,19 +7655,54 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
     feedback: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         modality: z.ZodDefault<z.ZodEnum<["binary", "stars", "scale", "comment"]>>;
@@ -6344,6 +7724,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         }>>;
         autoDistill: z.ZodOptional<z.ZodBoolean>;
+        exitPrompt: z.ZodOptional<z.ZodBoolean>;
         channelReactions: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         modality: "binary" | "stars" | "scale" | "comment";
@@ -6356,6 +7737,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }, {
         enabled?: boolean | undefined;
@@ -6368,8 +7750,106 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
     cli: z.ZodOptional<z.ZodObject<{
         banner: z.ZodOptional<z.ZodObject<{
             taglineMode: z.ZodDefault<z.ZodEnum<["static", "random"]>>;
@@ -6519,6 +7999,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -6539,6 +8035,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         tui: "basic" | "rich";
         banner?: {
@@ -6573,9 +8070,18 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
     feedback?: {
         modality: "binary" | "stars" | "scale" | "comment";
         enabled?: boolean | undefined;
@@ -6587,8 +8093,27 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -6631,6 +8156,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         max_tokens?: number | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -6651,6 +8192,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         banner?: {
             taglines: string[];
@@ -6685,9 +8227,18 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
     feedback?: {
         enabled?: boolean | undefined;
         scale?: {
@@ -6699,8 +8250,27 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -6738,6 +8308,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"workflow">;
     model: z.ZodString;
     steps: z.ZodArray<z.ZodObject<{
@@ -6843,17 +8414,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -6985,6 +8556,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -7004,7 +8576,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -7060,6 +8632,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -7079,7 +8652,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -7119,10 +8692,66 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"channel">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
         tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
         sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -7166,6 +8795,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -7182,6 +8827,22 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -7443,19 +9104,54 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
     feedback: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         modality: z.ZodDefault<z.ZodEnum<["binary", "stars", "scale", "comment"]>>;
@@ -7477,6 +9173,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         }>>;
         autoDistill: z.ZodOptional<z.ZodBoolean>;
+        exitPrompt: z.ZodOptional<z.ZodBoolean>;
         channelReactions: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         modality: "binary" | "stars" | "scale" | "comment";
@@ -7489,6 +9186,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }, {
         enabled?: boolean | undefined;
@@ -7501,8 +9199,106 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
     heartbeat: z.ZodOptional<z.ZodObject<{
         every: z.ZodString;
         instructions: z.ZodString;
@@ -7635,12 +9431,31 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         simulationRequired?: boolean | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
+    routing: {
+        sessionKey: "thread" | "user" | "channel";
+    };
     name: string;
     target: "channel";
     agent: {
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -7679,9 +9494,6 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -7689,6 +9501,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -7708,9 +9521,18 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
     feedback?: {
         modality: "binary" | "stars" | "scale" | "comment";
         enabled?: boolean | undefined;
@@ -7722,8 +9544,27 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -7768,12 +9609,31 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         ui: boolean;
     } | undefined;
 }, {
+    routing: {
+        sessionKey: "thread" | "user" | "channel";
+    };
     name: string;
     target: "channel";
     agent: {
         instructions: string;
         model: string;
         tools?: string[] | undefined;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
         sub_agents?: Record<string, {
             description: string;
             instructions: string;
@@ -7812,9 +9672,6 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -7822,6 +9679,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -7841,9 +9699,18 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
     feedback?: {
         enabled?: boolean | undefined;
         scale?: {
@@ -7855,8 +9722,27 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             location: string;
         } | undefined;
         autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
         channelReactions?: boolean | undefined;
     } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -7902,6 +9788,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"graph">;
     model: z.ZodString;
     entry: z.ZodString;
@@ -8005,17 +9892,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -8154,6 +10041,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8163,7 +10051,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -8222,6 +10110,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8231,7 +10120,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -8275,16 +10164,104 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     }[] | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"managed">;
     agent: z.ZodObject<{
         model: z.ZodString;
         instructions: z.ZodString;
+        model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        circuit_breaker: z.ZodOptional<z.ZodObject<{
+            /** Consecutive failures inside windowMs that trip the breaker. */
+            failureThreshold: z.ZodOptional<z.ZodNumber>;
+            /** Window for counting consecutive failures (ms). */
+            windowMs: z.ZodOptional<z.ZodNumber>;
+            /** How long the breaker stays open before allowing a probe (ms). */
+            cooldownMs: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }, {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        }>>;
+        model_tiers: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodString;
+            default: z.ZodString;
+            routing: z.ZodOptional<z.ZodObject<{
+                contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
+                toolsToDefault: z.ZodOptional<z.ZodBoolean>;
+                firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
+                priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }, {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }, {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        }>>;
     }, "strict", z.ZodTypeAny, {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     }, {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     }>;
     tenants: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -8367,25 +10344,173 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    budget: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        on_exceed: z.ZodDefault<z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+            action: z.ZodLiteral<"stop">;
+        }, "strict", z.ZodTypeAny, {
+            action: "stop";
+        }, {
+            action: "stop";
+        }>, z.ZodObject<{
+            action: z.ZodLiteral<"degrade">;
+            model: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            model: string;
+            action: "degrade";
+        }, {
+            model: string;
+            action: "degrade";
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    }, {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    }>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
+    observability: z.ZodOptional<z.ZodObject<{
+        slo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            /** Fractional error rate ceiling (unrecovered errors / model calls), e.g. 0.05. */
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            /** p95 per-turn latency ceiling, milliseconds. */
+            p95_latency_ms: z.ZodOptional<z.ZodNumber>;
+            /** p95 time-to-first-token ceiling, milliseconds. */
+            ttft_ms: z.ZodOptional<z.ZodNumber>;
+            /** Cost burn ceiling, USD per hour of wall-clock. */
+            cost_per_hour_usd: z.ZodOptional<z.ZodNumber>;
+            /** Fractional egress-block rate ceiling (egress-blocked / external calls), e.g. 0.1. */
+            egress_block_rate: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Rolling window (seconds) a breach must persist before the ladder fires.
+             * A single blip never mitigates — the monitor only acts on a SUSTAINED
+             * breach across this window. Default 300s (5 min).
+             */
+            window_seconds: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Mitigation ladder, walked in declared order on a sustained breach. Each
+             * rung is executed at most once per session. `alert` is always safe;
+             * `pause-intake` / `rollback` touch traffic + deploys so they are opt-in.
+             */
+            mitigation: z.ZodOptional<z.ZodArray<z.ZodEnum<["alert", "pause-intake", "rollback"]>, "atleastone">>;
+        }, "strict", z.ZodTypeAny, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }, {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }, {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     name: string;
     target: "managed";
     agent: {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     };
     tenants: {
         id: string;
@@ -8401,6 +10526,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8410,15 +10536,58 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        };
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     name: string;
     target: "managed";
     agent: {
         instructions: string;
         model: string;
+        model_fallbacks?: string[] | undefined;
+        circuit_breaker?: {
+            failureThreshold?: number | undefined;
+            windowMs?: number | undefined;
+            cooldownMs?: number | undefined;
+        } | undefined;
+        model_tiers?: {
+            default: string;
+            fast: string;
+            routing?: {
+                contextTokenThreshold?: number | undefined;
+                toolsToDefault?: boolean | undefined;
+                firstTurnToDefault?: boolean | undefined;
+                priorToolDensityThreshold?: number | undefined;
+            } | undefined;
+        } | undefined;
     };
     tenants: {
         id: string;
@@ -8434,6 +10603,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8443,11 +10613,39 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    budget?: {
+        usd: number;
+        on_exceed?: {
+            action: "stop";
+        } | {
+            model: string;
+            action: "degrade";
+        } | undefined;
+    } | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
+    observability?: {
+        slo?: {
+            error_rate?: number | undefined;
+            p95_latency_ms?: number | undefined;
+            ttft_ms?: number | undefined;
+            cost_per_hour_usd?: number | undefined;
+            egress_block_rate?: number | undefined;
+            window_seconds?: number | undefined;
+            mitigation?: ["alert" | "pause-intake" | "rollback", ...("alert" | "pause-intake" | "rollback")[]] | undefined;
+        } | undefined;
+    } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"pipeline">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -8573,17 +10771,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -8618,6 +10816,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8627,7 +10826,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -8662,6 +10861,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -8671,11 +10871,12 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"crew">;
     /** Crew-wide model fallback used by any role that omits `role.model`. */
     model: z.ZodString;
@@ -8864,17 +11065,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -9017,6 +11218,14 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    routing?: {
+        kind: "match" | "llm";
+        match?: Record<string, {
+            to: string;
+            contains: string;
+        }[]> | undefined;
+    } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -9036,7 +11245,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -9074,13 +11283,6 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         maxValueUsd?: number | undefined;
         maxValueWei?: string | undefined;
     } | undefined;
-    routing?: {
-        kind: "match" | "llm";
-        match?: Record<string, {
-            to: string;
-            contains: string;
-        }[]> | undefined;
-    } | undefined;
 }, {
     model: string;
     name: string;
@@ -9110,6 +11312,14 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    routing?: {
+        kind: "match" | "llm";
+        match?: Record<string, {
+            to: string;
+            contains: string;
+        }[]> | undefined;
+    } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -9129,7 +11339,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -9167,15 +11377,9 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         allowedContracts?: string[] | undefined;
         simulationRequired?: boolean | undefined;
     } | undefined;
-    routing?: {
-        kind: "match" | "llm";
-        match?: Record<string, {
-            to: string;
-            contains: string;
-        }[]> | undefined;
-    } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"research">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -9289,19 +11493,38 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
+    memory: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        autoCapture: z.ZodOptional<z.ZodBoolean>;
+        autoCaptureThreshold: z.ZodOptional<z.ZodNumber>;
+        autoRecall: z.ZodOptional<z.ZodBoolean>;
+        recallK: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    }>>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodLiteral<"evm">;
@@ -9436,6 +11659,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -9456,9 +11680,16 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -9510,6 +11741,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -9530,9 +11762,16 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
+    memory?: {
+        enabled?: boolean | undefined;
+        autoCapture?: boolean | undefined;
+        autoCaptureThreshold?: number | undefined;
+        autoRecall?: boolean | undefined;
+        recallK?: number | undefined;
+    } | undefined;
     chains?: {
         kind: "evm";
         id: string;
@@ -9577,6 +11816,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     maxDurationMs?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"batch">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -9695,17 +11935,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
     chains: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -9843,6 +12083,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -9863,7 +12104,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -9923,6 +12164,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -9943,7 +12185,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     chains?: {
@@ -9985,6 +12227,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     idempotencyWindowMs?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"voice">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -10108,17 +12351,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -10143,6 +12386,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10163,7 +12407,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     telephony?: {
@@ -10191,6 +12435,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10211,7 +12456,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     telephony?: {
@@ -10219,6 +12464,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     } | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"browser">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -10346,17 +12592,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -10382,6 +12628,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10402,7 +12649,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     groundingModel?: string | undefined;
@@ -10421,6 +12668,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10441,7 +12689,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     driver?: {
@@ -10455,6 +12703,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     groundingModel?: string | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"eval">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -10497,17 +12746,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -10528,10 +12777,11 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         name: string;
         opts?: Record<string, unknown> | undefined;
     }[];
+    version?: number | undefined;
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     seed?: number | undefined;
@@ -10552,16 +12802,18 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
         name: string;
         opts?: Record<string, unknown> | undefined;
     }[];
+    version?: number | undefined;
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     concurrency?: number | undefined;
     seed?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"onchain">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -10817,17 +13069,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -10897,6 +13149,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10917,7 +13170,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -10966,6 +13219,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -10986,7 +13240,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     wallets?: {
@@ -11012,6 +13266,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     idempotencyWindowMs?: number | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
     target: z.ZodLiteral<"onchain-game">;
     agent: z.ZodObject<{
         model: z.ZodString;
@@ -11251,17 +13506,17 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy: z.ZodOptional<z.ZodArray<z.ZodObject<{
         class: z.ZodString;
         pattern: z.ZodString;
-        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "fail"]>;
+        recovery: z.ZodEnum<["retry", "compact", "continue", "tombstone", "switch-model", "fail"]>;
         hint: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }, {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
@@ -11321,6 +13576,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -11341,7 +13597,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
 }, {
@@ -11394,6 +13650,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     tool_config?: Record<string, unknown> | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
@@ -11414,7 +13671,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     failure_taxonomy?: {
         pattern: string;
         class: string;
-        recovery: "retry" | "compact" | "continue" | "tombstone" | "fail";
+        recovery: "retry" | "compact" | "continue" | "tombstone" | "switch-model" | "fail";
         hint?: string | undefined;
     }[] | undefined;
     transaction_policy?: {
@@ -11462,8 +13719,13 @@ export type SpecEval = z.infer<typeof evalSchema>;
 export type SpecMcpServerConfig = z.infer<typeof mcpServerConfigSchema>;
 export type SpecSubAgentDefinition = z.infer<typeof subAgentDefinitionSchema>;
 export type SpecCompactionBlock = z.infer<typeof compactionBlock>;
+export type SpecModelFallbacks = z.infer<typeof modelFallbacksBlock>;
+export type SpecCircuitBreakerBlock = z.infer<typeof circuitBreakerBlock>;
+export type SpecModelTiersBlock = z.infer<typeof modelTiersBlock>;
+export type SpecBudgetBlock = z.infer<typeof budgetBlock>;
 export type SpecSecurityBlock = z.infer<typeof securityBlock>;
 export type SpecFeedbackBlock = z.infer<typeof feedbackBlock>;
+export type SpecMemoryBlock = z.infer<typeof memoryBlock>;
 export type SpecFailureTaxonomyEntry = z.infer<typeof failureTaxonomyEntrySchema>;
 export type SpecFailureTaxonomy = z.infer<typeof failureTaxonomyBlock>;
 export { SpecParseError };