@crewhaus/spec 0.1.7 → 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,42 +272,237 @@ 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` 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>;
+    modality: z.ZodDefault<z.ZodEnum<["binary", "stars", "scale", "comment"]>>;
+    scale: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        min: number;
+        max: number;
+    }, {
+        min: number;
+        max: number;
+    }>>;
+    storage: z.ZodOptional<z.ZodObject<{
+        location: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        location: string;
+    }, {
+        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";
+    enabled?: boolean | undefined;
+    scale?: {
+        min: number;
+        max: number;
+    } | undefined;
+    storage?: {
+        location: string;
+    } | undefined;
+    autoDistill?: boolean | undefined;
+    exitPrompt?: boolean | undefined;
+    channelReactions?: boolean | undefined;
+}, {
+    enabled?: boolean | undefined;
+    scale?: {
+        min: number;
+        max: number;
+    } | undefined;
+    modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+    storage?: {
+        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;
@@ -262,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;
@@ -277,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;
@@ -426,19 +740,201 @@ 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"]>>;
+        scale: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            min: number;
+            max: number;
+        }, {
+            min: number;
+            max: number;
+        }>>;
+        storage: z.ZodOptional<z.ZodObject<{
+            location: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            location: string;
+        }, {
+            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";
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            location: string;
+        } | undefined;
+        autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
+        channelReactions?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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"]>>;
@@ -588,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;
@@ -608,6 +1120,7 @@ declare const cliSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         tui: "basic" | "rich";
         banner?: {
@@ -642,9 +1155,50 @@ 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;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            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;
@@ -687,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;
@@ -707,6 +1277,7 @@ declare const cliSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         banner?: {
             taglines: string[];
@@ -741,9 +1312,50 @@ 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?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -801,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<{
@@ -906,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<{
@@ -1048,6 +1661,7 @@ declare const workflowSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1067,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?: {
@@ -1123,6 +1737,7 @@ declare const workflowSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1142,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?: {
@@ -1243,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<{
@@ -1286,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;
@@ -1302,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;
@@ -1317,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<{
@@ -1364,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;
@@ -1380,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;
@@ -1641,19 +2431,201 @@ 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"]>>;
+        scale: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            min: number;
+            max: number;
+        }, {
+            min: number;
+            max: number;
+        }>>;
+        storage: z.ZodOptional<z.ZodObject<{
+            location: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            location: string;
+        }, {
+            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";
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            location: string;
+        } | undefined;
+        autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
+        channelReactions?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -1786,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;
@@ -1830,9 +2821,6 @@ declare const channelSchema: z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -1840,6 +2828,7 @@ declare const channelSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1859,9 +2848,50 @@ 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;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            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;
@@ -1906,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;
@@ -1950,9 +2999,6 @@ declare const channelSchema: z.ZodObject<{
             cursorPath?: string | undefined;
         } | undefined;
     };
-    routing: {
-        sessionKey: "thread" | "user" | "channel";
-    };
     permissions?: {
         mode?: "default" | "plan" | "auto" | undefined;
         rules?: {
@@ -1960,6 +3006,7 @@ declare const channelSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     mcp_servers?: Record<string, {
         transport: "stdio";
         command: string;
@@ -1979,9 +3026,50 @@ 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?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -2072,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;
@@ -2175,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<{
@@ -2324,6 +3413,7 @@ declare const graphSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2333,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?: {
@@ -2392,6 +3482,7 @@ declare const graphSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2401,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?: {
@@ -2471,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;
@@ -2563,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;
@@ -2597,6 +3924,7 @@ declare const managedSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2606,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;
@@ -2630,6 +4001,7 @@ declare const managedSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2639,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;
@@ -2658,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;
@@ -2783,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, {
@@ -2828,6 +4228,7 @@ declare const pipelineSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2837,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;
 }, {
@@ -2872,6 +4273,7 @@ declare const pipelineSchema: z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     compaction?: {
         model?: string | undefined;
         curate?: boolean | undefined;
@@ -2881,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;
 }>;
@@ -2987,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;
@@ -3175,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<{
@@ -3328,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;
@@ -3347,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?: {
@@ -3383,14 +4794,7 @@ declare const crewSchema: z.ZodObject<{
         allowedContracts: string[];
         simulationRequired: boolean;
         maxValueUsd?: number | undefined;
-        maxValueWei?: string | undefined;
-    } | undefined;
-    routing?: {
-        kind: "match" | "llm";
-        match?: Record<string, {
-            to: string;
-            contains: string;
-        }[]> | undefined;
+        maxValueWei?: string | undefined;
     } | undefined;
 }, {
     model: string;
@@ -3421,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;
@@ -3440,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?: {
@@ -3478,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">>;
@@ -3501,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;
@@ -3614,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">;
@@ -3761,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";
@@ -3781,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;
@@ -3835,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";
@@ -3855,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;
@@ -3922,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;
@@ -4040,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<{
@@ -4188,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";
@@ -4208,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?: {
@@ -4268,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";
@@ -4288,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?: {
@@ -4357,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;
@@ -4480,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, {
@@ -4515,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";
@@ -4535,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?: {
@@ -4563,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";
@@ -4583,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?: {
@@ -4620,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;
@@ -4747,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, {
@@ -4783,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";
@@ -4803,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;
@@ -4822,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";
@@ -4842,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?: {
@@ -4865,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;
@@ -4907,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, {
@@ -4938,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;
@@ -4962,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;
@@ -5026,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;
@@ -5281,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, {
@@ -5361,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";
@@ -5381,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;
 }, {
@@ -5430,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";
@@ -5450,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?: {
@@ -5483,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;
@@ -5722,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, {
@@ -5792,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";
@@ -5812,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;
 }, {
@@ -5865,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";
@@ -5885,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?: {
@@ -5898,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;
@@ -5944,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;
@@ -5959,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;
@@ -6108,19 +7655,201 @@ 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"]>>;
+        scale: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            min: number;
+            max: number;
+        }, {
+            min: number;
+            max: number;
+        }>>;
+        storage: z.ZodOptional<z.ZodObject<{
+            location: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            location: string;
+        }, {
+            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";
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            location: string;
+        } | undefined;
+        autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
+        channelReactions?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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"]>>;
@@ -6270,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;
@@ -6290,6 +8035,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         tui: "basic" | "rich";
         banner?: {
@@ -6324,9 +8070,50 @@ 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;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            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;
@@ -6369,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;
@@ -6389,6 +8192,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
             pattern: string;
         }[] | undefined;
     } | undefined;
+    version?: number | undefined;
     cli?: {
         banner?: {
             taglines: string[];
@@ -6423,9 +8227,50 @@ 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?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -6463,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<{
@@ -6568,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<{
@@ -6710,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;
@@ -6729,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?: {
@@ -6785,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;
@@ -6804,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?: {
@@ -6844,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<{
@@ -6891,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;
@@ -6907,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;
@@ -7168,19 +9104,201 @@ 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"]>>;
+        scale: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            min: number;
+            max: number;
+        }, {
+            min: number;
+            max: number;
+        }>>;
+        storage: z.ZodOptional<z.ZodObject<{
+            location: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            location: string;
+        }, {
+            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";
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            location: string;
+        } | undefined;
+        autoDistill?: boolean | undefined;
+        exitPrompt?: boolean | undefined;
+        channelReactions?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -7313,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;
@@ -7357,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?: {
@@ -7367,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;
@@ -7386,9 +9521,50 @@ 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;
+        scale?: {
+            min: number;
+            max: number;
+        } | undefined;
+        storage?: {
+            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;
@@ -7433,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;
@@ -7477,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?: {
@@ -7487,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;
@@ -7506,9 +9699,50 @@ 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?: {
+            min: number;
+            max: number;
+        } | undefined;
+        modality?: "binary" | "stars" | "scale" | "comment" | undefined;
+        storage?: {
+            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;
@@ -7554,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;
@@ -7657,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<{
@@ -7806,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;
@@ -7815,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?: {
@@ -7874,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;
@@ -7883,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?: {
@@ -7927,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;
@@ -8019,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;
@@ -8053,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;
@@ -8062,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;
@@ -8086,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;
@@ -8095,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;
@@ -8225,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, {
@@ -8270,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;
@@ -8279,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;
 }, {
@@ -8314,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;
@@ -8323,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;
@@ -8516,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<{
@@ -8669,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;
@@ -8688,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?: {
@@ -8726,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;
@@ -8762,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;
@@ -8781,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?: {
@@ -8819,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;
@@ -8941,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">;
@@ -9088,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";
@@ -9108,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;
@@ -9162,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";
@@ -9182,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;
@@ -9229,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;
@@ -9347,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<{
@@ -9495,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";
@@ -9515,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?: {
@@ -9575,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";
@@ -9595,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?: {
@@ -9637,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;
@@ -9760,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, {
@@ -9795,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";
@@ -9815,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?: {
@@ -9843,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";
@@ -9863,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?: {
@@ -9871,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;
@@ -9998,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, {
@@ -10034,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";
@@ -10054,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;
@@ -10073,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";
@@ -10093,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?: {
@@ -10107,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;
@@ -10149,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, {
@@ -10180,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;
@@ -10204,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;
@@ -10469,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, {
@@ -10549,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";
@@ -10569,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;
 }, {
@@ -10618,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";
@@ -10638,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?: {
@@ -10664,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;
@@ -10903,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, {
@@ -10973,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";
@@ -10993,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;
 }, {
@@ -11046,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";
@@ -11066,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?: {
@@ -11114,7 +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 };