@wairon/cli 5.1.1-dev.8 → 5.1.1-dev.9

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.8";
+    WAIRON_VERSION = "5.1.1-dev.9";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -340,6 +340,85 @@ var init_yaml = __esm({
   }
 });
 
+// src/models/execution.ts
+var import_zod, WorkBreadthSchema, ReasoningDepthSchema, ExecutionProfileSchema, ModelTierSchema, EffortTierSchema, ToolClassSchema, McpAccessSchema, ExecutionBudgetSchema, BudgetTierSchema, BUDGET_TIER_DESCRIPTIONS, ExecutionConfigSchema;
+var init_execution = __esm({
+  "src/models/execution.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    WorkBreadthSchema = import_zod.z.enum(["narrow", "moderate", "wide"]);
+    ReasoningDepthSchema = import_zod.z.enum(["mechanical", "standard", "deep"]);
+    ExecutionProfileSchema = import_zod.z.object({
+      /** How much of the tree the agent must read. */
+      breadth: WorkBreadthSchema,
+      /** Whether the agent modifies files at all. Read-only agents are cheap and safe. */
+      writes: import_zod.z.boolean(),
+      /** How much judgment the work carries. */
+      reasoningDepth: ReasoningDepthSchema,
+      /**
+       * Whether this agent is a MANAGER — its job is to route work to others
+       * rather than perform it. Managers must stay thin: a manager that reads
+       * files accumulates context exactly like a main session and stops being
+       * cheaper than doing the work inline.
+       */
+      delegates: import_zod.z.boolean(),
+      /** Why the profile came out this way — surfaced in briefs and `wairon analyze`. */
+      rationale: import_zod.z.string()
+    });
+    ModelTierSchema = import_zod.z.enum(["small", "standard", "large", "frontier"]);
+    EffortTierSchema = import_zod.z.enum(["low", "medium", "high", "xhigh"]);
+    ToolClassSchema = import_zod.z.enum(["read-only", "implement", "orchestrate", "full"]);
+    McpAccessSchema = import_zod.z.enum(["none", "project", "all"]);
+    ExecutionBudgetSchema = import_zod.z.object({
+      /**
+       * Absent means "express no model choice" — the `free` tier is defined as
+       * having no quality tradeoff, and picking a model is a quality decision.
+       * Exporters must omit the field entirely rather than substituting a default.
+       */
+      modelTier: ModelTierSchema.optional(),
+      effort: EffortTierSchema.optional(),
+      /**
+       * Turn ceiling — a circuit breaker, not a target. Its purpose is to stop the
+       * runaway case: a subagent that runs hundreds of turns while accumulating
+       * context is no longer preserving the parent's context, it is a second
+       * expensive session. Hitting the ceiling returns partial output, which is
+       * the intended failure mode.
+       */
+      maxTurns: import_zod.z.number().int().positive().optional(),
+      toolClass: ToolClassSchema,
+      /**
+       * Whether this agent may spawn its own subagents. False withholds the
+       * delegation tool entirely — structural enforcement, so no instruction text
+       * has to be carried (and re-read) to achieve it.
+       */
+      allowNestedDelegation: import_zod.z.boolean(),
+      mcp: McpAccessSchema
+    });
+    BudgetTierSchema = import_zod.z.enum(["off", "free", "default", "trade", "aggressive"]);
+    BUDGET_TIER_DESCRIPTIONS = {
+      off: "No budget emitted. Generated agent files carry name and description only, as before this feature existed.",
+      free: "Structural constraints only \u2014 tool classes, MCP scoping, nested-delegation control. No model or effort selection, so no quality tradeoff of any kind.",
+      default: "Adds capability-tier selection per role and turn ceilings. Mechanical work runs on smaller models; deep reasoning keeps the large tier.",
+      trade: "Adds effort reduction on mechanical work and pushes standard work down a tier. Real but bounded quality cost; measure before adopting.",
+      aggressive: "Small tier for everything but deep reasoning, tight turn ceilings. Expect partial results and worse judgment. Opt in deliberately."
+    };
+    ExecutionConfigSchema = import_zod.z.object({
+      /**
+       * How hard to optimize. `off` preserves pre-feature output exactly, so
+       * enabling this feature can never silently change an existing project's
+       * generated files.
+       */
+      tier: BudgetTierSchema.default("off"),
+      /**
+       * Per-agent overrides, keyed by agent id. An explicit budget always wins
+       * over derivation — the tree is a good default, not an authority on how
+       * you want to spend.
+       */
+      overrides: import_zod.z.record(ExecutionBudgetSchema.partial()).default({})
+    });
+  }
+});
+
 // src/models/agent.ts
 function createAgentRecord(partial) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -357,83 +436,99 @@ function createAgentRecord(partial) {
     ...partial
   });
 }
-var import_zod, BuiltinTargetSchema, CustomTargetSchema, OutputTargetSchema, AgentStatusSchema, AgentRecordSchema, AgentTemplateSchema, AgentBriefSchema;
+var import_zod2, BuiltinTargetSchema, CustomTargetSchema, OutputTargetSchema, AgentStatusSchema, AgentRecordSchema, AgentTemplateSchema, AgentBriefSchema;
 var init_agent = __esm({
   "src/models/agent.ts"() {
     "use strict";
-    import_zod = require("zod");
-    BuiltinTargetSchema = import_zod.z.enum(["claude", "gemini", "agy", "cursor", "copilot", "codex"]);
-    CustomTargetSchema = import_zod.z.object({
-      type: import_zod.z.literal("custom"),
+    import_zod2 = require("zod");
+    init_execution();
+    BuiltinTargetSchema = import_zod2.z.enum(["claude", "gemini", "agy", "cursor", "copilot", "codex"]);
+    CustomTargetSchema = import_zod2.z.object({
+      type: import_zod2.z.literal("custom"),
       /** Human-readable label for this target, e.g. "Cursor" */
-      label: import_zod.z.string(),
+      label: import_zod2.z.string(),
       /** Root output directory relative to the project root, e.g. ".cursor/agents" */
-      outputDir: import_zod.z.string()
+      outputDir: import_zod2.z.string()
     });
-    OutputTargetSchema = import_zod.z.union([BuiltinTargetSchema, CustomTargetSchema]);
-    AgentStatusSchema = import_zod.z.enum(["active", "draft", "deprecated"]);
-    AgentRecordSchema = import_zod.z.object({
+    OutputTargetSchema = import_zod2.z.union([BuiltinTargetSchema, CustomTargetSchema]);
+    AgentStatusSchema = import_zod2.z.enum(["active", "draft", "deprecated"]);
+    AgentRecordSchema = import_zod2.z.object({
       /** Unique identifier within this project, e.g. "core-service-owner" */
-      id: import_zod.z.string().regex(/^[a-z0-9-_]+$/, "Agent id must be lowercase alphanumeric with dashes or underscores"),
+      id: import_zod2.z.string().regex(/^[a-z0-9-_]+$/, "Agent id must be lowercase alphanumeric with dashes or underscores"),
       /** Human-readable display name */
-      name: import_zod.z.string(),
+      name: import_zod2.z.string(),
       /** Short description of what this agent is responsible for */
-      description: import_zod.z.string(),
+      description: import_zod2.z.string(),
       /** Template id this agent was created from, e.g. "domain-owner" */
-      template: import_zod.z.string(),
+      template: import_zod2.z.string(),
       /** Bundle id this agent was created as part of, if applicable */
-      bundleOrigin: import_zod.z.string().optional(),
+      bundleOrigin: import_zod2.z.string().optional(),
       /**
        * The domain id this agent is responsible for (a subsystem id or a
        * free-standing domain id). Undefined = root-level agent.
        */
-      domainRoot: import_zod.z.string().optional(),
+      domainRoot: import_zod2.z.string().optional(),
       /**
        * Paths this agent owns, expressed relative to the project root.
        * e.g. ["services/core/**"]
        */
-      ownedPaths: import_zod.z.array(import_zod.z.string()).default([]),
+      ownedPaths: import_zod2.z.array(import_zod2.z.string()).default([]),
       /** Paths this agent may read but does not own */
-      readPaths: import_zod.z.array(import_zod.z.string()).default([]),
+      readPaths: import_zod2.z.array(import_zod2.z.string()).default([]),
       /** Paths this agent may write to but does not own */
-      writePaths: import_zod.z.array(import_zod.z.string()).default([]),
+      writePaths: import_zod2.z.array(import_zod2.z.string()).default([]),
       /** Classification tags, e.g. ["service", "backend", "critical"] */
-      tags: import_zod.z.array(import_zod.z.string()).default([]),
+      tags: import_zod2.z.array(import_zod2.z.string()).default([]),
       /** Ids of related agents this agent should be aware of */
-      dependencies: import_zod.z.array(import_zod.z.string()).default([]),
+      dependencies: import_zod2.z.array(import_zod2.z.string()).default([]),
       /** Rendered implementation guidance for this agent's variant-tagged components (deep variant integration); empty when none. */
-      variantGuidance: import_zod.z.string().optional(),
+      variantGuidance: import_zod2.z.string().optional(),
       /** Why this agent was created — the architectural reason for its existence */
-      creationReason: import_zod.z.string(),
+      creationReason: import_zod2.z.string(),
       status: AgentStatusSchema.default("active"),
       /** Which output targets should receive this agent's generated file */
-      targets: import_zod.z.array(OutputTargetSchema).default(["claude"]),
-      createdAt: import_zod.z.string().datetime(),
-      updatedAt: import_zod.z.string().datetime()
+      targets: import_zod2.z.array(OutputTargetSchema).default(["claude"]),
+      createdAt: import_zod2.z.string().datetime(),
+      updatedAt: import_zod2.z.string().datetime()
     });
-    AgentTemplateSchema = import_zod.z.object({
+    AgentTemplateSchema = import_zod2.z.object({
       /** Template identifier (architect, domain-owner, implementer, …) */
-      templateName: import_zod.z.string(),
+      templateName: import_zod2.z.string(),
       /** The raw instruction body with {{variable}} placeholders, before rendering */
-      instructions: import_zod.z.string()
+      instructions: import_zod2.z.string()
     });
-    AgentBriefSchema = import_zod.z.object({
+    AgentBriefSchema = import_zod2.z.object({
       /** The resolved agent's stable id (e.g. sdd_core-owner, system-architect) */
-      agentId: import_zod.z.string(),
+      agentId: import_zod2.z.string(),
       /** Human-readable display name of the agent */
-      name: import_zod.z.string(),
+      name: import_zod2.z.string(),
       /** The instruction template the brief was rendered from */
-      template: import_zod.z.string(),
+      template: import_zod2.z.string(),
       /** Domain the agent belongs to (absent = global root) */
-      domainRoot: import_zod.z.string().optional(),
+      domainRoot: import_zod2.z.string().optional(),
       /** Glob patterns of the files this agent owns — the write-scope fence */
-      ownedPaths: import_zod.z.array(import_zod.z.string()),
+      ownedPaths: import_zod2.z.array(import_zod2.z.string()),
       /** Spec paths the subagent should read first */
-      readPaths: import_zod.z.array(import_zod.z.string()).optional(),
+      readPaths: import_zod2.z.array(import_zod2.z.string()).optional(),
       /** The fully rendered instruction body — paste-ready as a subagent prompt */
-      instructions: import_zod.z.string(),
+      instructions: import_zod2.z.string(),
       /** Rendered variant guidance, also folded into instructions */
-      variantGuidance: import_zod.z.string().optional()
+      variantGuidance: import_zod2.z.string().optional(),
+      /**
+       * The resource shape of this agent's work, and the allowance it earns.
+       *
+       * Both are ABSENT unless the project has opted in with `execution.tier`,
+       * which is what keeps the brief useful to consumers that cannot act on it:
+       * an MCP client with no subagents — or a host tool that cannot express a
+       * model choice — simply never sees these fields.
+       *
+       * Where generated agent files can ENFORCE a budget through front-matter,
+       * a brief can only ADVISE: the caller spawning from this brief is the one
+       * that picks the model and tool grant. That asymmetry is deliberate, not a
+       * gap — a brief is consumed by tools wairon does not control.
+       */
+      profile: ExecutionProfileSchema.optional(),
+      budget: ExecutionBudgetSchema.optional()
     });
   }
 });
@@ -442,33 +537,33 @@ var init_agent = __esm({
 function createEmptyTopologyConfig() {
   return { schemaVersion: "1.0.0", domains: [] };
 }
-var import_zod2, DomainSchema, TopologyConfigSchema, DomainTypeSchema;
+var import_zod3, DomainSchema, TopologyConfigSchema, DomainTypeSchema;
 var init_domain = __esm({
   "src/models/domain.ts"() {
     "use strict";
-    import_zod2 = require("zod");
-    DomainSchema = import_zod2.z.object({
+    import_zod3 = require("zod");
+    DomainSchema = import_zod3.z.object({
       /** Unique identifier within the project, e.g. "billing" or "docs". */
-      id: import_zod2.z.string().regex(/^[a-z0-9-_]+$/, "Domain id must be lowercase alphanumeric with dashes or underscores"),
+      id: import_zod3.z.string().regex(/^[a-z0-9-_]+$/, "Domain id must be lowercase alphanumeric with dashes or underscores"),
       /** Optional display name. */
-      name: import_zod2.z.string().optional(),
+      name: import_zod3.z.string().optional(),
       /** Optional description of the domain's responsibility. */
-      description: import_zod2.z.string().optional(),
+      description: import_zod3.z.string().optional(),
       /**
        * The spec node this domain binds to: a subsystem id (the common case) or a
        * component id. Omitted means the domain is free-standing.
        */
-      boundTo: import_zod2.z.string().optional(),
+      boundTo: import_zod3.z.string().optional(),
       /** Glob patterns this domain owns. Derived for spec-backed, authored for free-standing. */
-      ownedPaths: import_zod2.z.array(import_zod2.z.string()).default([]),
+      ownedPaths: import_zod3.z.array(import_zod3.z.string()).default([]),
       /** Optional physical directory (e.g. a monorepo package or submodule root). */
-      path: import_zod2.z.string().optional()
+      path: import_zod3.z.string().optional()
     });
-    TopologyConfigSchema = import_zod2.z.object({
-      schemaVersion: import_zod2.z.string().default("1.0.0"),
-      domains: import_zod2.z.array(DomainSchema).default([])
+    TopologyConfigSchema = import_zod3.z.object({
+      schemaVersion: import_zod3.z.string().default("1.0.0"),
+      domains: import_zod3.z.array(DomainSchema).default([])
     });
-    DomainTypeSchema = import_zod2.z.enum([
+    DomainTypeSchema = import_zod3.z.enum([
       "git-submodule",
       // declared in .gitmodules
       "git-repo",
@@ -482,102 +577,103 @@ var init_domain = __esm({
 });
 
 // src/models/project.ts
-var import_zod3, BuiltinTargetConfigSchema, CustomTargetConfigSchema, TargetConfigSchema, NamingRuleConfigSchema, DocumentationRuleConfigSchema, ComplexityRuleConfigSchema, DesignDepthSchema, RulesConfigSchema, PathsConfigSchema, PackSelectionSchema, ProfileSelectionSubjectSchema, ProjectProfileSelectionSchema, ProjectConfigSchema;
+var import_zod4, BuiltinTargetConfigSchema, CustomTargetConfigSchema, TargetConfigSchema, NamingRuleConfigSchema, DocumentationRuleConfigSchema, ComplexityRuleConfigSchema, DesignDepthSchema, RulesConfigSchema, PathsConfigSchema, PackSelectionSchema, ProfileSelectionSubjectSchema, ProjectProfileSelectionSchema, ProjectConfigSchema;
 var init_project = __esm({
   "src/models/project.ts"() {
     "use strict";
-    import_zod3 = require("zod");
+    import_zod4 = require("zod");
     init_agent();
-    BuiltinTargetConfigSchema = import_zod3.z.object({
-      type: import_zod3.z.enum(["claude", "gemini", "agy", "cursor", "copilot", "codex"]),
+    init_execution();
+    BuiltinTargetConfigSchema = import_zod4.z.object({
+      type: import_zod4.z.enum(["claude", "gemini", "agy", "cursor", "copilot", "codex"]),
       /** Output directory for generated agent files, relative to project root */
-      outputDir: import_zod3.z.string(),
+      outputDir: import_zod4.z.string(),
       /** Whether this target is active */
-      enabled: import_zod3.z.boolean().default(true)
+      enabled: import_zod4.z.boolean().default(true)
     });
     CustomTargetConfigSchema = CustomTargetSchema.extend({
-      enabled: import_zod3.z.boolean().default(true)
+      enabled: import_zod4.z.boolean().default(true)
     });
-    TargetConfigSchema = import_zod3.z.union([BuiltinTargetConfigSchema, CustomTargetConfigSchema]);
-    NamingRuleConfigSchema = import_zod3.z.object({
+    TargetConfigSchema = import_zod4.z.union([BuiltinTargetConfigSchema, CustomTargetConfigSchema]);
+    NamingRuleConfigSchema = import_zod4.z.object({
       /** Casing style or regular expression for subsystem names/IDs */
-      subsystems: import_zod3.z.string().optional(),
+      subsystems: import_zod4.z.string().optional(),
       /** Casing style or regular expression for component names/IDs */
-      components: import_zod3.z.string().optional(),
+      components: import_zod4.z.string().optional(),
       /** Casing style or regular expression for interface names/IDs */
-      interfaces: import_zod3.z.string().optional(),
+      interfaces: import_zod4.z.string().optional(),
       /** Casing style or regular expression for general type names/IDs */
-      types: import_zod3.z.string().optional(),
+      types: import_zod4.z.string().optional(),
       /** Casing style or regular expression for entity type names/IDs */
-      entities: import_zod3.z.string().optional(),
+      entities: import_zod4.z.string().optional(),
       /** Casing style or regular expression for value-object type names/IDs */
-      valueObjects: import_zod3.z.string().optional(),
+      valueObjects: import_zod4.z.string().optional(),
       /** Casing style or regular expression for interface/implementation/type method names */
-      methods: import_zod3.z.string().optional(),
+      methods: import_zod4.z.string().optional(),
       /** Casing style or regular expression for general type fields */
-      fields: import_zod3.z.string().optional(),
+      fields: import_zod4.z.string().optional(),
       /** Casing style or regular expression for constants/enum variants */
-      constants: import_zod3.z.string().optional(),
+      constants: import_zod4.z.string().optional(),
       /** Casing style or regular expression for parameters/variables */
-      variables: import_zod3.z.string().optional(),
+      variables: import_zod4.z.string().optional(),
       /** Stereotype-specific naming rules (prefixes, suffixes, regexes) */
-      stereotypes: import_zod3.z.record(import_zod3.z.object({
-        match: import_zod3.z.enum(["id", "name", "both"]).default("both"),
-        prefix: import_zod3.z.string().optional(),
-        suffix: import_zod3.z.string().optional(),
-        regex: import_zod3.z.string().optional()
+      stereotypes: import_zod4.z.record(import_zod4.z.object({
+        match: import_zod4.z.enum(["id", "name", "both"]).default("both"),
+        prefix: import_zod4.z.string().optional(),
+        suffix: import_zod4.z.string().optional(),
+        regex: import_zod4.z.string().optional()
       })).optional()
     });
-    DocumentationRuleConfigSchema = import_zod3.z.object({
+    DocumentationRuleConfigSchema = import_zod4.z.object({
       /** Minimum character length for description fields */
-      minDescriptionLength: import_zod3.z.number().int().nonnegative().optional(),
+      minDescriptionLength: import_zod4.z.number().int().nonnegative().optional(),
       /** Force subsystem, component, interface, and type specs to have non-empty descriptions */
-      requireDescriptions: import_zod3.z.boolean().optional(),
+      requireDescriptions: import_zod4.z.boolean().optional(),
       /** Force interface and type methods to have non-empty descriptions */
-      requireMethodDescriptions: import_zod3.z.boolean().optional(),
+      requireMethodDescriptions: import_zod4.z.boolean().optional(),
       /** Force type fields to have non-empty descriptions */
-      requireFieldDescriptions: import_zod3.z.boolean().optional()
+      requireFieldDescriptions: import_zod4.z.boolean().optional()
     });
-    ComplexityRuleConfigSchema = import_zod3.z.object({
+    ComplexityRuleConfigSchema = import_zod4.z.object({
       /** Maximum number of parameters allowed on a single interface method */
-      maxMethodParams: import_zod3.z.number().int().nonnegative().optional(),
+      maxMethodParams: import_zod4.z.number().int().nonnegative().optional(),
       /** Maximum number of methods allowed on a single interface contract */
-      maxInterfaceMethods: import_zod3.z.number().int().nonnegative().optional(),
+      maxInterfaceMethods: import_zod4.z.number().int().nonnegative().optional(),
       /** Maximum number of dependencies allowed on a single component */
-      maxComponentDependencies: import_zod3.z.number().int().nonnegative().optional(),
+      maxComponentDependencies: import_zod4.z.number().int().nonnegative().optional(),
       /** Maximum number of narrative steps allowed in a single method implementation */
-      maxNarrativeSteps: import_zod3.z.number().int().nonnegative().optional(),
+      maxNarrativeSteps: import_zod4.z.number().int().nonnegative().optional(),
       /** Maximum number of direct components allowed in a single subsystem */
-      maxSubsystemComponents: import_zod3.z.number().int().nonnegative().optional(),
+      maxSubsystemComponents: import_zod4.z.number().int().nonnegative().optional(),
       /**
        * Maximum cyclomatic complexity a realized function may measure (exact AST
        * grade) while its method's narrative detail sits below `full` with no
        * narrative — above it the detail-sufficiency lint fires
        * (UNNARRATED_COMPLEXITY). Default 8 when unset.
        */
-      maxUnnarratedComplexity: import_zod3.z.number().int().nonnegative().optional()
+      maxUnnarratedComplexity: import_zod4.z.number().int().nonnegative().optional()
     });
-    DesignDepthSchema = import_zod3.z.enum(["components", "interfaces", "implementations", "narratives"]);
-    RulesConfigSchema = import_zod3.z.object({
+    DesignDepthSchema = import_zod4.z.enum(["components", "interfaces", "implementations", "narratives"]);
+    RulesConfigSchema = import_zod4.z.object({
       /**
        * Prevent two agents from declaring overlapping ownedPaths.
        * Strongly recommended: true.
        */
-      noOverlappingOwnership: import_zod3.z.boolean().default(true),
+      noOverlappingOwnership: import_zod4.z.boolean().default(true),
       /**
        * Require every non-meta agent to have at least one ownedPath.
        */
-      requireOwnedPaths: import_zod3.z.boolean().default(true),
+      requireOwnedPaths: import_zod4.z.boolean().default(true),
       /**
        * Tags that mark an agent as a meta/guardian agent — exempt from
        * requireOwnedPaths.
        */
-      metaAgentTags: import_zod3.z.array(import_zod3.z.string()).default(["meta", "guardian", "architect"]),
+      metaAgentTags: import_zod4.z.array(import_zod4.z.string()).default(["meta", "guardian", "architect"]),
       /**
        * Generated outputs should exactly reproduce from the registry.
        * Warn if generated files differ from what the registry would produce.
        */
-      enforceReproducibility: import_zod3.z.boolean().default(true),
+      enforceReproducibility: import_zod4.z.boolean().default(true),
       /**
        * Whether to generate an individual implementer agent PER COMPONENT. Off by
        * default: one subsystem-owner agent per subsystem owns its components'
@@ -587,7 +683,7 @@ var init_project = __esm({
        * emit thousands of agents — reserve it for small trees that genuinely want
        * per-component isolation.
        */
-      generateComponentImplementers: import_zod3.z.boolean().default(false),
+      generateComponentImplementers: import_zod4.z.boolean().default(false),
       /**
        * Whether `wairon generate` writes per-subsystem owner/architect agent FILES.
        * Off by default: agents are served as LIVE briefs (sdd_get_agent_brief /
@@ -595,12 +691,12 @@ var init_project = __esm({
        * same briefs. When off, generate reconciles to zero agent files — leftover
        * wairon-managed files are removed (hand-authored files never are).
        */
-      materializeAgentFiles: import_zod3.z.boolean().default(false),
+      materializeAgentFiles: import_zod4.z.boolean().default(false),
       /**
        * Severity overrides for SDD validation rules.
        * Key: rule code (e.g. CIRCULAR_DEPENDENCY), Value: error | warning | off
        */
-      sddRuleSeverity: import_zod3.z.record(import_zod3.z.enum(["error", "warning", "off"])).default({}),
+      sddRuleSeverity: import_zod4.z.record(import_zod4.z.enum(["error", "warning", "off"])).default({}),
       /** Dynamic naming conventions and stereotype suffix rules */
       naming: NamingRuleConfigSchema.optional(),
       /** Dynamic metadata documentation constraints */
@@ -610,57 +706,57 @@ var init_project = __esm({
       /** Project-default design depth (see DesignDepthSchema); subsystems may override. */
       designDepth: DesignDepthSchema.optional()
     });
-    PathsConfigSchema = import_zod3.z.object({
+    PathsConfigSchema = import_zod4.z.object({
       /** Base directory containing SDD specification files, relative to project root */
-      specsDir: import_zod3.z.string().default(".wai/specs")
+      specsDir: import_zod4.z.string().default(".wai/specs")
     });
-    PackSelectionSchema = import_zod3.z.object({
+    PackSelectionSchema = import_zod4.z.object({
       /** The pack name — the only required field. */
-      name: import_zod3.z.string().min(1),
+      name: import_zod4.z.string().min(1),
       /** Exact version pin. Omitted = the latest version installed in the store. */
-      version: import_zod3.z.string().min(1).optional(),
+      version: import_zod4.z.string().min(1).optional(),
       /** Content digest pin (`sha256-…`), verified on resolution. */
-      integrity: import_zod3.z.string().min(1).optional(),
+      integrity: import_zod4.z.string().min(1).optional(),
       /**
        * Where to obtain this pack — recorded automatically from the store's install
        * record at selection time, so a fresh machine or CI runner can fetch it
        * (`wairon pack sync`). Supports a `{version}` placeholder and `${VAR}` env
        * expansion for private URLs.
        */
-      source: import_zod3.z.string().min(1).optional(),
+      source: import_zod4.z.string().min(1).optional(),
       /**
        * Commit a copy under `.wai/packs/<name>/<version>/` and resolve from there
        * first, so the project needs no machine setup at all — the answer for private
        * packs, air-gapped CI, and repos that must be self-sufficient.
        */
-      bundle: import_zod3.z.boolean().optional()
+      bundle: import_zod4.z.boolean().optional()
     });
-    ProfileSelectionSubjectSchema = import_zod3.z.object({
-      userId: import_zod3.z.string(),
-      kind: import_zod3.z.string(),
-      issuer: import_zod3.z.string(),
-      externalSubject: import_zod3.z.string().optional(),
-      displayName: import_zod3.z.string().optional(),
-      email: import_zod3.z.string().optional()
+    ProfileSelectionSubjectSchema = import_zod4.z.object({
+      userId: import_zod4.z.string(),
+      kind: import_zod4.z.string(),
+      issuer: import_zod4.z.string(),
+      externalSubject: import_zod4.z.string().optional(),
+      displayName: import_zod4.z.string().optional(),
+      email: import_zod4.z.string().optional()
     });
-    ProjectProfileSelectionSchema = import_zod3.z.object({
+    ProjectProfileSelectionSchema = import_zod4.z.object({
       /** Selected architectural profile ids. The first resolvable one is applied as projectType. */
-      profileIds: import_zod3.z.array(import_zod3.z.string()).default([]),
+      profileIds: import_zod4.z.array(import_zod4.z.string()).default([]),
       /** Pack names the governing policy requires for this project. */
-      requiredPackNames: import_zod3.z.array(import_zod3.z.string()).default([]),
+      requiredPackNames: import_zod4.z.array(import_zod4.z.string()).default([]),
       /** Pack names applied by default unless explicitly overridden. */
-      defaultPackNames: import_zod3.z.array(import_zod3.z.string()).optional(),
+      defaultPackNames: import_zod4.z.array(import_zod4.z.string()).optional(),
       selectedBy: ProfileSelectionSubjectSchema.optional(),
-      selectedAt: import_zod3.z.string()
+      selectedAt: import_zod4.z.string()
     });
-    ProjectConfigSchema = import_zod3.z.object({
+    ProjectConfigSchema = import_zod4.z.object({
       /**
        * Schema version — used to detect incompatible config formats in future
        * CLI versions.
        */
-      schemaVersion: import_zod3.z.string().default("1.0.0"),
+      schemaVersion: import_zod4.z.string().default("1.0.0"),
       /** Human-readable project name */
-      name: import_zod3.z.string(),
+      name: import_zod4.z.string(),
       /**
        * The type/profile of the project, which configures targeted guidelines, rules,
        * templates, and validation constraints. Open string: built-ins are backend,
@@ -668,22 +764,31 @@ var init_project = __esm({
        * realtime-embedded, plc-cyclic, fullstack, system-of-systems, monorepo;
        * extension packs may register more (unknown names get UNKNOWN_PROFILE).
        */
-      projectType: import_zod3.z.string().default("backend"),
+      projectType: import_zod4.z.string().default("backend"),
       /** Optional short description of this project */
-      description: import_zod3.z.string().optional(),
+      description: import_zod4.z.string().optional(),
       /**
        * Active output targets. At least one must be enabled.
        * Configured during `wairon init` and editable afterward.
        */
-      targets: import_zod3.z.array(TargetConfigSchema).default([]),
+      targets: import_zod4.z.array(TargetConfigSchema).default([]),
       rules: RulesConfigSchema.default({}),
+      /**
+       * Execution budgets — the RESOURCE axis of the derived topology. Controls
+       * whether generated agent files carry model/effort/turn/tool constraints in
+       * addition to their authority scope.
+       *
+       * Defaults to tier `off`, so adding this feature changes no existing
+       * project's generated output until it is deliberately turned on.
+       */
+      execution: ExecutionConfigSchema.default({ tier: "off", overrides: {} }),
       /**
        * Extension packs — wairon's plugin surface. Each entry is a relative path
        * to a declarative YAML pack (custom profiles + language/platform tables)
        * or a requireable JS module id (which may also inject SddRule[] `rules`).
        * Loaded identically by CLI and MCP at validation time.
        */
-      extensions: import_zod3.z.object({
+      extensions: import_zod4.z.object({
         /**
          * The packs this project APPLIES. Two forms:
          *
@@ -697,7 +802,7 @@ var init_project = __esm({
          * A declared pack that cannot be resolved is an error, never a silent skip:
          * a project whose doctrine is absent is misconfigured, and the gate says so.
          */
-        packs: import_zod3.z.array(import_zod3.z.union([import_zod3.z.string(), PackSelectionSchema])).default([]),
+        packs: import_zod4.z.array(import_zod4.z.union([import_zod4.z.string(), PackSelectionSchema])).default([]),
         /**
          * Whether to ALSO apply every pack installed machine-wide (WAIRON_PACKS_DIR
          * or ~/.wairon/packs) to this project, without the project naming them.
@@ -711,7 +816,7 @@ var init_project = __esm({
          * packs that are installed but applied by no route, and `--fix` records them
          * as explicit selections.
          */
-        useGlobalPacks: import_zod3.z.boolean().default(false)
+        useGlobalPacks: import_zod4.z.boolean().default(false)
       }).optional(),
       paths: PathsConfigSchema.default({}),
       /**
@@ -728,20 +833,20 @@ var init_project = __esm({
        * Default: ~/.wairon/templates
        * Can also be set via WAIRON_TEMPLATES_DIR environment variable.
        */
-      globalTemplatesDir: import_zod3.z.string().optional(),
+      globalTemplatesDir: import_zod4.z.string().optional(),
       /**
        * Tracks whether the wairon usage guide has been injected into each target's
        * AI tool configuration files so the tool knows how to use wairon.
        */
-      aiGuide: import_zod3.z.object({
-        claudeGlobal: import_zod3.z.boolean().default(false),
-        claudeLocal: import_zod3.z.boolean().default(false),
-        geminiGlobal: import_zod3.z.boolean().default(false),
-        geminiLocal: import_zod3.z.boolean().default(false)
+      aiGuide: import_zod4.z.object({
+        claudeGlobal: import_zod4.z.boolean().default(false),
+        claudeLocal: import_zod4.z.boolean().default(false),
+        geminiGlobal: import_zod4.z.boolean().default(false),
+        geminiLocal: import_zod4.z.boolean().default(false)
       }).optional(),
       /** Created by wairon at init time */
-      createdAt: import_zod3.z.string().datetime(),
-      updatedAt: import_zod3.z.string().datetime()
+      createdAt: import_zod4.z.string().datetime(),
+      updatedAt: import_zod4.z.string().datetime()
     });
   }
 });
@@ -754,125 +859,125 @@ function createEmptyRegistry() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var import_zod4, RegistrySchema;
+var import_zod5, RegistrySchema;
 var init_registry = __esm({
   "src/models/registry.ts"() {
     "use strict";
-    import_zod4 = require("zod");
+    import_zod5 = require("zod");
     init_agent();
-    RegistrySchema = import_zod4.z.object({
-      schemaVersion: import_zod4.z.string().default("1.0.0"),
-      agents: import_zod4.z.array(AgentRecordSchema).default([]),
-      updatedAt: import_zod4.z.string().datetime()
+    RegistrySchema = import_zod5.z.object({
+      schemaVersion: import_zod5.z.string().default("1.0.0"),
+      agents: import_zod5.z.array(AgentRecordSchema).default([]),
+      updatedAt: import_zod5.z.string().datetime()
     });
   }
 });
 
 // src/models/template.ts
-var import_zod5, TemplateSchema;
+var import_zod6, TemplateSchema;
 var init_template = __esm({
   "src/models/template.ts"() {
     "use strict";
-    import_zod5 = require("zod");
-    TemplateSchema = import_zod5.z.object({
+    import_zod6 = require("zod");
+    TemplateSchema = import_zod6.z.object({
       /** Unique template identifier, e.g. "domain-owner" */
-      id: import_zod5.z.string(),
+      id: import_zod6.z.string(),
       /** Display name */
-      name: import_zod5.z.string(),
+      name: import_zod6.z.string(),
       /** Short description of this template's purpose */
-      description: import_zod5.z.string(),
+      description: import_zod6.z.string(),
       /**
        * Markdown instruction body for the agent.
        * Supports simple variable interpolation: {{agentName}}, {{ownedPaths}}, etc.
        */
-      instructions: import_zod5.z.string(),
+      instructions: import_zod6.z.string(),
       /** Default tags applied to agents created from this template */
-      defaultTags: import_zod5.z.array(import_zod5.z.string()).default([]),
+      defaultTags: import_zod6.z.array(import_zod6.z.string()).default([]),
       /** Whether agents from this template must have ownedPaths defined */
-      requiresOwnedPaths: import_zod5.z.boolean().default(true),
+      requiresOwnedPaths: import_zod6.z.boolean().default(true),
       /**
        * Optional YAML front-matter fields to include in generated output.
        * These are passed through to the exporter as-is.
        */
-      frontmatter: import_zod5.z.record(import_zod5.z.unknown()).optional(),
+      frontmatter: import_zod6.z.record(import_zod6.z.unknown()).optional(),
       /** Version of this template definition */
-      version: import_zod5.z.string().default("1.0.0")
+      version: import_zod6.z.string().default("1.0.0")
     });
   }
 });
 
 // src/models/specs.ts
-var import_zod6, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, ComponentSpecSchema, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, MethodSignatureSchema, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
+var import_zod7, SpecIdSchema, SpecStatusSchema, BoundaryItemSchema, RequirementItemSchema, DatabaseSpecSchema, DiagramConfigSchema, SURFACE_AUDIENCES, SurfaceAudienceSchema, SystemPublicInterfaceSchema, SystemSpecSchema, PublicInterfaceTypeSchema, PublicInterfaceSchema, TrustedLinkSchema, LintAllowSchema, LintConfigSchema, ExtDataSchema, LifecycleEntrypointSchema, SubsystemSpecSchema, ComponentTypeSchema, PATTERN_TYPES, PortalTypeSchema, DispatchBindingSchema, DurabilitySchema, PatternRefSchema, EventBindingSchema, ExternalLinkTypeSchema, ExternalLinkSchema, PortalAuthSchemeSchema, PortalAuthSchema, ComponentSpecSchema, HttpMethodSchema, TransportSchema, EndpointSchema, SEMANTIC_GUARANTEES, GuaranteeSchema, MethodParamSchema, MethodSignatureSchema, InterfaceSpecSchema, NarrativeStepTypeSchema, LoopKindSchema, SwitchCaseSchema, CatchClauseSchema, ParallelBranchSchema, NarrativeStepSchema, NarrativeDetailSchema, ConformanceTierSchema, MethodImplementationSchema, ImplementationSpecSchema, TypeKindSchema, TypeFieldSchema, TypeMethodSchema, InvariantSchema, TypeSpecSchema, SurfaceOriginSchema, SurfaceTypeDefSchema, SurfaceContractEntrySchema, SurfaceSnapshotSchema, NamedOpenApiSpecSchema, GroupSpecSchema;
 var init_specs = __esm({
   "src/models/specs.ts"() {
     "use strict";
-    import_zod6 = require("zod");
-    SpecIdSchema = import_zod6.z.string().regex(/^[a-z0-9-_]+$/, "Identifier must be lowercase alphanumeric with dashes or underscores");
-    SpecStatusSchema = import_zod6.z.enum(["draft", "design", "complete"]).default("complete");
-    BoundaryItemSchema = import_zod6.z.union([
-      import_zod6.z.string(),
-      import_zod6.z.object({
-        name: import_zod6.z.string(),
-        description: import_zod6.z.string().optional()
+    import_zod7 = require("zod");
+    SpecIdSchema = import_zod7.z.string().regex(/^[a-z0-9-_]+$/, "Identifier must be lowercase alphanumeric with dashes or underscores");
+    SpecStatusSchema = import_zod7.z.enum(["draft", "design", "complete"]).default("complete");
+    BoundaryItemSchema = import_zod7.z.union([
+      import_zod7.z.string(),
+      import_zod7.z.object({
+        name: import_zod7.z.string(),
+        description: import_zod7.z.string().optional()
       })
     ]);
-    RequirementItemSchema = import_zod6.z.union([
-      import_zod6.z.string(),
-      import_zod6.z.object({
-        description: import_zod6.z.string()
+    RequirementItemSchema = import_zod7.z.union([
+      import_zod7.z.string(),
+      import_zod7.z.object({
+        description: import_zod7.z.string()
       })
     ]);
-    DatabaseSpecSchema = import_zod6.z.object({
+    DatabaseSpecSchema = import_zod7.z.object({
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      engine: import_zod6.z.string(),
+      name: import_zod7.z.string(),
+      engine: import_zod7.z.string(),
       // e.g. "postgresql", "mysql", "sqlite", "redis"
-      description: import_zod6.z.string().optional(),
-      tables: import_zod6.z.array(SpecIdSchema).optional()
+      description: import_zod7.z.string().optional(),
+      tables: import_zod7.z.array(SpecIdSchema).optional()
     });
-    DiagramConfigSchema = import_zod6.z.object({
-      lineStyle: import_zod6.z.enum(["bezier", "straight", "taxi"]).optional(),
-      defaultView: import_zod6.z.enum(["architecture", "types", "databases"]).optional(),
-      showDatabases: import_zod6.z.boolean().optional()
+    DiagramConfigSchema = import_zod7.z.object({
+      lineStyle: import_zod7.z.enum(["bezier", "straight", "taxi"]).optional(),
+      defaultView: import_zod7.z.enum(["architecture", "types", "databases"]).optional(),
+      showDatabases: import_zod7.z.boolean().optional()
     });
     SURFACE_AUDIENCES = ["project", "department", "instance", "partner", "external"];
-    SurfaceAudienceSchema = import_zod6.z.enum(SURFACE_AUDIENCES);
-    SystemPublicInterfaceSchema = import_zod6.z.object({
+    SurfaceAudienceSchema = import_zod7.z.enum(SURFACE_AUDIENCES);
+    SystemPublicInterfaceSchema = import_zod7.z.object({
       /** Stable public interface id within the system. */
-      id: import_zod6.z.string().optional(),
-      name: import_zod6.z.string().optional(),
+      id: import_zod7.z.string().optional(),
+      name: import_zod7.z.string().optional(),
       /** Subsystem publishing the backing L1 public interface. */
-      subsystem: import_zod6.z.string().optional(),
+      subsystem: import_zod7.z.string().optional(),
       /** Portal (or compatible published component) backing this entry. */
-      component: import_zod6.z.string().optional(),
+      component: import_zod7.z.string().optional(),
       /** Optional L3 interface id backing the surface. */
-      interface: import_zod6.z.string().optional(),
+      interface: import_zod7.z.string().optional(),
       /** Surface kind: REST, GraphQL, MessageBus, RPC, or Custom. */
-      type: import_zod6.z.string().optional(),
-      details: import_zod6.z.string().optional(),
+      type: import_zod7.z.string().optional(),
+      details: import_zod7.z.string().optional(),
       /** Exposure ceiling (see SurfaceAudienceSchema). Defaults to 'instance' at projection time. */
-      audience: import_zod6.z.string().optional(),
-      authPolicy: import_zod6.z.string().optional(),
-      version: import_zod6.z.string().optional(),
-      stability: import_zod6.z.string().optional()
+      audience: import_zod7.z.string().optional(),
+      authPolicy: import_zod7.z.string().optional(),
+      version: import_zod7.z.string().optional(),
+      stability: import_zod7.z.string().optional()
     });
-    SystemSpecSchema = import_zod6.z.object({
-      schemaVersion: import_zod6.z.string().default("1.0.0"),
-      name: import_zod6.z.string(),
-      vision: import_zod6.z.string(),
-      boundaries: import_zod6.z.array(BoundaryItemSchema).default([]),
-      globalRequirements: import_zod6.z.array(RequirementItemSchema).default([]),
+    SystemSpecSchema = import_zod7.z.object({
+      schemaVersion: import_zod7.z.string().default("1.0.0"),
+      name: import_zod7.z.string(),
+      vision: import_zod7.z.string(),
+      boundaries: import_zod7.z.array(BoundaryItemSchema).default([]),
+      globalRequirements: import_zod7.z.array(RequirementItemSchema).default([]),
       /**
        * The project's gateway surface: entries intentionally exported beyond the
        * project, each backed by a subsystem-published Portal and carrying an
        * audience ceiling. Cross-PROJECT consumption may only target these.
        */
-      publicInterfaces: import_zod6.z.array(SystemPublicInterfaceSchema).optional(),
+      publicInterfaces: import_zod7.z.array(SystemPublicInterfaceSchema).optional(),
       /**
        * System-level databases. Enables database table mapping, PK/FK views,
        * and isolated ERD schemas.
        */
-      databases: import_zod6.z.array(DatabaseSpecSchema).default([]),
+      databases: import_zod7.z.array(DatabaseSpecSchema).default([]),
       /** Optional defaults for the interactive diagram canvas. */
       diagram: DiagramConfigSchema.optional(),
       /**
@@ -881,67 +986,67 @@ var init_specs = __esm({
        * validation (builtin-type vocabulary, language rule packs); free-form but
        * normalized to lowercase by the validator.
        */
-      targetLanguage: import_zod6.z.string().optional(),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      targetLanguage: import_zod7.z.string().optional(),
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    PublicInterfaceTypeSchema = import_zod6.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]);
-    PublicInterfaceSchema = import_zod6.z.object({
+    PublicInterfaceTypeSchema = import_zod7.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]);
+    PublicInterfaceSchema = import_zod7.z.object({
       type: PublicInterfaceTypeSchema,
-      details: import_zod6.z.string(),
+      details: import_zod7.z.string(),
       /** The L2 component that realizes this public interface (the subsystem's published surface). */
       component: SpecIdSchema.optional(),
       /** Optional L3 interface on that component backing this entry. */
       interface: SpecIdSchema.optional()
     });
-    TrustedLinkSchema = import_zod6.z.object({
+    TrustedLinkSchema = import_zod7.z.object({
       /** The peer subsystem id this link sanctions tight coupling with. */
       subsystem: SpecIdSchema,
       /** Why this coupling is sanctioned (e.g. "runtime dispatch latency — bus round-trip too slow"). */
-      reason: import_zod6.z.string()
+      reason: import_zod7.z.string()
     });
-    LintAllowSchema = import_zod6.z.object({
+    LintAllowSchema = import_zod7.z.object({
       /** The issue code being allowed (see `wairon rules list`). */
-      code: import_zod6.z.string(),
+      code: import_zod7.z.string(),
       /** Why this finding is acceptable here (e.g. "dispatcher — fan-out is the point"). */
-      reason: import_zod6.z.string().min(1)
+      reason: import_zod7.z.string().min(1)
     });
-    LintConfigSchema = import_zod6.z.object({
-      allow: import_zod6.z.array(LintAllowSchema).default([])
+    LintConfigSchema = import_zod7.z.object({
+      allow: import_zod7.z.array(LintAllowSchema).default([])
     });
-    ExtDataSchema = import_zod6.z.record(import_zod6.z.unknown());
-    LifecycleEntrypointSchema = import_zod6.z.object({
+    ExtDataSchema = import_zod7.z.record(import_zod7.z.unknown());
+    LifecycleEntrypointSchema = import_zod7.z.object({
       /** Which lifecycle/execution flow this roots. */
-      phase: import_zod6.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]),
+      phase: import_zod7.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]),
       /** Component id whose method the runtime invokes at this phase. */
-      component: import_zod6.z.string(),
+      component: import_zod7.z.string(),
       /** Method name on that component's interface. */
-      method: import_zod6.z.string(),
+      method: import_zod7.z.string(),
       /** What this lifecycle flow establishes or tears down. */
-      description: import_zod6.z.string().optional()
+      description: import_zod7.z.string().optional()
     });
-    SubsystemSpecSchema = import_zod6.z.object({
+    SubsystemSpecSchema = import_zod7.z.object({
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string(),
-      parentSystem: import_zod6.z.string(),
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string(),
+      parentSystem: import_zod7.z.string(),
       // References L0 System Name or file
-      publicInterfaces: import_zod6.z.array(PublicInterfaceSchema).default([]),
+      publicInterfaces: import_zod7.z.array(PublicInterfaceSchema).default([]),
       /** Declared init/shutdown flow roots (see LifecycleEntrypointSchema). */
-      lifecycle: import_zod6.z.array(LifecycleEntrypointSchema).optional(),
+      lifecycle: import_zod7.z.array(LifecycleEntrypointSchema).optional(),
       /**
        * Optional subsystem profile override (e.g. for fullstack systems). Open
        * string: built-ins are backend, frontend-reactive, frontend-controller,
        * lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs
        * may register more. Unknown names get UNKNOWN_PROFILE.
        */
-      profile: import_zod6.z.string().optional(),
-      projectPath: import_zod6.z.string().optional(),
+      profile: import_zod7.z.string().optional(),
+      projectPath: import_zod7.z.string().optional(),
       // Relative path to external project root for subsystem chaining
       /** Optional override of the system-level targetLanguage for this subsystem. */
-      targetLanguage: import_zod6.z.string().optional(),
+      targetLanguage: import_zod7.z.string().optional(),
       /** Explicitly sanctioned tight couplings with peer subsystems (see TrustedLinkSchema). */
-      trustedLinks: import_zod6.z.array(TrustedLinkSchema).default([]),
+      trustedLinks: import_zod7.z.array(TrustedLinkSchema).default([]),
       /**
        * Per-subsystem design-depth override (components | interfaces |
        * implementations | narratives): how deep THIS subsystem commits to
@@ -951,16 +1056,16 @@ var init_specs = __esm({
        * Expectation checks below the depth are gated; soundness of authored
        * content never is.
        */
-      designDepth: import_zod6.z.enum(["components", "interfaces", "implementations", "narratives"]).optional(),
+      designDepth: import_zod7.z.enum(["components", "interfaces", "implementations", "narratives"]).optional(),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional(),
       status: SpecStatusSchema.optional().default("complete"),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    ComponentTypeSchema = import_zod6.z.enum([
+    ComponentTypeSchema = import_zod7.z.enum([
       // Building blocks
       "Portal",
       "Orchestrator",
@@ -983,123 +1088,123 @@ var init_specs = __esm({
       // Switch/routing component pattern
     ]);
     PATTERN_TYPES = /* @__PURE__ */ new Set(["Repository", "Gateway", "FeatureComponent", "RouterComponent"]);
-    PortalTypeSchema = import_zod6.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]);
-    DispatchBindingSchema = import_zod6.z.object({
+    PortalTypeSchema = import_zod7.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]);
+    DispatchBindingSchema = import_zod7.z.object({
       /** Capability name exactly as dispatched at runtime (e.g. "shadow_module.get"). */
-      capability: import_zod6.z.string().min(1),
+      capability: import_zod7.z.string().min(1),
       /** Component id serving this capability (local, super::-relative, or ::-absolute). */
-      component: import_zod6.z.string(),
+      component: import_zod7.z.string(),
       /** Method name on the serving component's interface. */
-      method: import_zod6.z.string(),
+      method: import_zod7.z.string(),
       /** What this capability does. */
-      description: import_zod6.z.string().optional()
+      description: import_zod7.z.string().optional()
     });
-    DurabilitySchema = import_zod6.z.enum(["ram-projection", "durable", "read-through", "cache"]);
-    PatternRefSchema = import_zod6.z.object({
-      id: import_zod6.z.string(),
-      version: import_zod6.z.string().optional()
+    DurabilitySchema = import_zod7.z.enum(["ram-projection", "durable", "read-through", "cache"]);
+    PatternRefSchema = import_zod7.z.object({
+      id: import_zod7.z.string(),
+      version: import_zod7.z.string().optional()
     });
-    EventBindingSchema = import_zod6.z.object({
+    EventBindingSchema = import_zod7.z.object({
       /** Topic/channel name exactly as used on the bus. */
-      topic: import_zod6.z.string().min(1),
+      topic: import_zod7.z.string().min(1),
       /** Optional event name within the topic (informational in v1 — pairing is by topic). */
-      event: import_zod6.z.string().optional(),
-      description: import_zod6.z.string().optional()
+      event: import_zod7.z.string().optional(),
+      description: import_zod7.z.string().optional()
     });
-    ExternalLinkTypeSchema = import_zod6.z.enum(["implementation", "informative"]);
-    ExternalLinkSchema = import_zod6.z.object({
-      url: import_zod6.z.string(),
+    ExternalLinkTypeSchema = import_zod7.z.enum(["implementation", "informative"]);
+    ExternalLinkSchema = import_zod7.z.object({
+      url: import_zod7.z.string(),
       /** Defaults to 'informative' so an untyped link never silently satisfies the source requirement. */
       type: ExternalLinkTypeSchema.default("informative"),
-      label: import_zod6.z.string().optional()
+      label: import_zod7.z.string().optional()
     });
-    PortalAuthSchemeSchema = import_zod6.z.enum(["none", "apiKey", "bearer", "basic", "oauth2", "openIdConnect", "custom"]);
-    PortalAuthSchema = import_zod6.z.object({
+    PortalAuthSchemeSchema = import_zod7.z.enum(["none", "apiKey", "bearer", "basic", "oauth2", "openIdConnect", "custom"]);
+    PortalAuthSchema = import_zod7.z.object({
       scheme: PortalAuthSchemeSchema,
-      in: import_zod6.z.enum(["header", "query", "cookie"]).optional(),
-      name: import_zod6.z.string().optional(),
-      bearerFormat: import_zod6.z.string().optional(),
-      authorizationUrl: import_zod6.z.string().optional(),
-      tokenUrl: import_zod6.z.string().optional(),
-      refreshUrl: import_zod6.z.string().optional(),
-      scopes: import_zod6.z.array(import_zod6.z.object({ name: import_zod6.z.string(), description: import_zod6.z.string() })).optional(),
-      flow: import_zod6.z.enum(["authorizationCode", "clientCredentials", "implicit", "password"]).optional(),
-      openIdConnectUrl: import_zod6.z.string().optional(),
-      description: import_zod6.z.string().optional(),
-      example: import_zod6.z.string().optional()
+      in: import_zod7.z.enum(["header", "query", "cookie"]).optional(),
+      name: import_zod7.z.string().optional(),
+      bearerFormat: import_zod7.z.string().optional(),
+      authorizationUrl: import_zod7.z.string().optional(),
+      tokenUrl: import_zod7.z.string().optional(),
+      refreshUrl: import_zod7.z.string().optional(),
+      scopes: import_zod7.z.array(import_zod7.z.object({ name: import_zod7.z.string(), description: import_zod7.z.string() })).optional(),
+      flow: import_zod7.z.enum(["authorizationCode", "clientCredentials", "implicit", "password"]).optional(),
+      openIdConnectUrl: import_zod7.z.string().optional(),
+      description: import_zod7.z.string().optional(),
+      example: import_zod7.z.string().optional()
     });
-    ComponentSpecSchema = import_zod6.z.object({
+    ComponentSpecSchema = import_zod7.z.object({
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string(),
-      subsystem: import_zod6.z.string(),
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string(),
+      subsystem: import_zod7.z.string(),
       // References L1 Subsystem id
       componentType: ComponentTypeSchema,
       /** Member block ids privately owned by this component (patterns only; one hop). */
-      owns: import_zod6.z.array(import_zod6.z.string()).default([]),
+      owns: import_zod7.z.array(import_zod7.z.string()).default([]),
       /** Other L2 component ids this component collaborates with (facades / standalone blocks). */
-      dependsOn: import_zod6.z.array(import_zod6.z.string()).default([]),
+      dependsOn: import_zod7.z.array(import_zod7.z.string()).default([]),
       portalType: PortalTypeSchema.optional(),
-      basePath: import_zod6.z.string().optional(),
+      basePath: import_zod7.z.string().optional(),
       /** Portal-only: the API's authentication scheme (see PortalAuthSchema) — projected
        *  into the generated OpenAPI's securitySchemes/security. Portals with different auth
        *  must be separate components (one auth per portal ⇒ one OpenAPI spec per portal). */
       auth: PortalAuthSchema.optional(),
       /** Portal-only: capability → component.method dispatch table (see DispatchBindingSchema). */
-      dispatch: import_zod6.z.array(DispatchBindingSchema).optional(),
+      dispatch: import_zod7.z.array(DispatchBindingSchema).optional(),
       /** Store-only: whether held state survives restart (see DurabilitySchema). */
       durability: DurabilitySchema.optional(),
       /** Topics this component publishes to (see EventBindingSchema). */
-      emits: import_zod6.z.array(EventBindingSchema).optional(),
+      emits: import_zod7.z.array(EventBindingSchema).optional(),
       /** Topics this component consumes (see EventBindingSchema) — typical on Observers. */
-      subscribesTo: import_zod6.z.array(EventBindingSchema).optional(),
+      subscribesTo: import_zod7.z.array(EventBindingSchema).optional(),
       /** Pack-declared reusable patterns this component realizes (resolved against loaded packs; UNKNOWN_PATTERN_REF). */
-      patterns: import_zod6.z.array(PatternRefSchema).optional(),
+      patterns: import_zod7.z.array(PatternRefSchema).optional(),
       /** Optional component variant — a declared, base-anchored specialization of this component's stereotype (resolved against the variant registry; UNKNOWN_VARIANT / VARIANT_BASE_MISMATCH). */
-      variant: import_zod6.z.string().optional(),
+      variant: import_zod7.z.string().optional(),
       /** Opaque external references (see ExternalLinkSchema) — documented URLs wairon does
        *  not fetch or validate. An `implementation` link is the external source-of-record and
        *  satisfies the source requirement for a source-less implementation (suppresses
        *  MISSING_SOURCE_PATH); `informative` links are context only. */
-      externalLinks: import_zod6.z.array(ExternalLinkSchema).optional(),
+      externalLinks: import_zod7.z.array(ExternalLinkSchema).optional(),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional(),
       status: SpecStatusSchema.optional().default("complete"),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    HttpMethodSchema = import_zod6.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
-    TransportSchema = import_zod6.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]);
-    EndpointSchema = import_zod6.z.discriminatedUnion("transport", [
-      import_zod6.z.object({ transport: import_zod6.z.literal("HTTP"), method: HttpMethodSchema, path: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("gRPC"), service: import_zod6.z.string(), method: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("GraphQL"), operation: import_zod6.z.enum(["query", "mutation", "subscription"]), field: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("MessageBus"), topic: import_zod6.z.string(), event: import_zod6.z.string(), queue: import_zod6.z.string().optional(), direction: import_zod6.z.enum(["subscribe", "publish"]).default("subscribe") }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("NamedPipe"), pipe: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("IPC"), channel: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("CLI"), command: import_zod6.z.string() }),
-      import_zod6.z.object({ transport: import_zod6.z.literal("Custom"), address: import_zod6.z.string() })
+    HttpMethodSchema = import_zod7.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]);
+    TransportSchema = import_zod7.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]);
+    EndpointSchema = import_zod7.z.discriminatedUnion("transport", [
+      import_zod7.z.object({ transport: import_zod7.z.literal("HTTP"), method: HttpMethodSchema, path: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("gRPC"), service: import_zod7.z.string(), method: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("GraphQL"), operation: import_zod7.z.enum(["query", "mutation", "subscription"]), field: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("MessageBus"), topic: import_zod7.z.string(), event: import_zod7.z.string(), queue: import_zod7.z.string().optional(), direction: import_zod7.z.enum(["subscribe", "publish"]).default("subscribe") }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("NamedPipe"), pipe: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("IPC"), channel: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("CLI"), command: import_zod7.z.string() }),
+      import_zod7.z.object({ transport: import_zod7.z.literal("Custom"), address: import_zod7.z.string() })
     ]);
     SEMANTIC_GUARANTEES = ["idempotent", "atomic", "transactional", "exactly-once"];
-    GuaranteeSchema = import_zod6.z.string().min(1);
-    MethodParamSchema = import_zod6.z.object({
-      name: import_zod6.z.string(),
+    GuaranteeSchema = import_zod7.z.string().min(1);
+    MethodParamSchema = import_zod7.z.object({
+      name: import_zod7.z.string(),
       /** A primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice"). */
-      type: import_zod6.z.string(),
-      description: import_zod6.z.string().optional(),
-      optional: import_zod6.z.boolean().optional()
+      type: import_zod7.z.string(),
+      description: import_zod7.z.string().optional(),
+      optional: import_zod7.z.boolean().optional()
     });
-    MethodSignatureSchema = import_zod6.z.object({
-      name: import_zod6.z.string().regex(/^[a-zA-Z0-9_]+$/, "Method name must be alphanumeric"),
-      description: import_zod6.z.string(),
-      signature: import_zod6.z.string(),
+    MethodSignatureSchema = import_zod7.z.object({
+      name: import_zod7.z.string().regex(/^[a-zA-Z0-9_]+$/, "Method name must be alphanumeric"),
+      description: import_zod7.z.string(),
+      signature: import_zod7.z.string(),
       // e.g. "save(key: string, data: Buffer): Promise<void>"
-      returns: import_zod6.z.string(),
+      returns: import_zod7.z.string(),
       // e.g. "Promise<void>"
       /** Structured parameters (authoritative for type checking when present). */
-      params: import_zod6.z.array(MethodParamSchema).optional(),
+      params: import_zod7.z.array(MethodParamSchema).optional(),
       /** Concrete wire binding for this method when its component is a Portal (set via sdd_set_endpoints). */
       endpoint: EndpointSchema.optional(),
       /**
@@ -1108,13 +1213,13 @@ var init_specs = __esm({
        * asserts a guarantee must call a method that declares it here. Whether the guarantee is
        * actually delivered is implementation correctness (implementer tests), not a static check.
        */
-      guarantees: import_zod6.z.array(GuaranteeSchema).optional(),
+      guarantees: import_zod7.z.array(GuaranteeSchema).optional(),
       /**
        * State-effect direction of this method on its component's held state. Required on a
        * durable Store's contract methods so the durability round-trip rule can pair external
        * writes with hydration read-backs (MISSING_HYDRATION); optional elsewhere.
        */
-      effect: import_zod6.z.enum(["read", "write"]).optional(),
+      effect: import_zod7.z.enum(["read", "write"]).optional(),
       /**
        * Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph
        * (runtime timer/hook, external system, sibling subsystem). Unused-detection
@@ -1125,29 +1230,29 @@ var init_specs = __esm({
        * Prefer a `register` narrative step when the wiring is internal — the
        * registration itself is then a modeled, checkable edge.
        */
-      invokedBy: import_zod6.z.object({
-        kind: import_zod6.z.enum(["runtime", "external", "sibling-subsystem"]),
-        caller: import_zod6.z.string().optional()
+      invokedBy: import_zod7.z.object({
+        kind: import_zod7.z.enum(["runtime", "external", "sibling-subsystem"]),
+        caller: import_zod7.z.string().optional()
       }).optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional()
     });
-    InterfaceSpecSchema = import_zod6.z.object({
+    InterfaceSpecSchema = import_zod7.z.object({
       id: SpecIdSchema.regex(/^i[a-z0-9-_]+$/, 'Interface id must be prefixed with a lowercase "i"'),
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string(),
-      component: import_zod6.z.string(),
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string(),
+      component: import_zod7.z.string(),
       // References L2 Component id
-      methods: import_zod6.z.array(MethodSignatureSchema).default([]),
+      methods: import_zod7.z.array(MethodSignatureSchema).default([]),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional(),
       status: SpecStatusSchema.optional().default("complete"),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    NarrativeStepTypeSchema = import_zod6.z.enum([
+    NarrativeStepTypeSchema = import_zod7.z.enum([
       "local",
       // in-component work
       "call",
@@ -1173,27 +1278,27 @@ var init_specs = __esm({
       "throw"
       // error terminator: this path raises/propagates
     ]);
-    LoopKindSchema = import_zod6.z.enum(["forEach", "for", "while", "doWhile"]);
-    SwitchCaseSchema = import_zod6.z.object({
-      value: import_zod6.z.string(),
+    LoopKindSchema = import_zod7.z.enum(["forEach", "for", "while", "doWhile"]);
+    SwitchCaseSchema = import_zod7.z.object({
+      value: import_zod7.z.string(),
       // the matched value/case label
-      step: import_zod6.z.number().int().positive()
+      step: import_zod7.z.number().int().positive()
       // first step of this case's region
     });
-    CatchClauseSchema = import_zod6.z.object({
-      error: import_zod6.z.string(),
+    CatchClauseSchema = import_zod7.z.object({
+      error: import_zod7.z.string(),
       // error/condition caught (free text; 'any' for catch-all)
-      step: import_zod6.z.number().int().positive()
+      step: import_zod7.z.number().int().positive()
       // first step of the handler region
     });
-    ParallelBranchSchema = import_zod6.z.object({
-      step: import_zod6.z.number().int().positive(),
+    ParallelBranchSchema = import_zod7.z.object({
+      step: import_zod7.z.number().int().positive(),
       // first step of this arm's region
-      name: import_zod6.z.string().optional()
+      name: import_zod7.z.string().optional()
       // optional arm label for renderers/readers
     });
-    NarrativeStepSchema = import_zod6.z.object({
-      stepNumber: import_zod6.z.number().int().positive(),
+    NarrativeStepSchema = import_zod7.z.object({
+      stepNumber: import_zod7.z.number().int().positive(),
       /**
        * Optional symbolic anchor for this step. Authoring surfaces accept *Label
        * twins of every jump-by-number field (toLabel, onTrueLabel, …) resolved
@@ -1201,14 +1306,14 @@ var init_specs = __esm({
        * the stored numeric fields stay the single flow representation. Labels
        * persist so later deltas can reference existing steps symbolically.
        */
-      label: import_zod6.z.string().min(1).optional(),
-      description: import_zod6.z.string(),
+      label: import_zod7.z.string().min(1).optional(),
+      description: import_zod7.z.string(),
       type: NarrativeStepTypeSchema,
-      targetComponent: import_zod6.z.string().optional(),
+      targetComponent: import_zod7.z.string().optional(),
       // Required if type is 'call', 'register' or 'dispatch', references L2 Component id
-      targetMethod: import_zod6.z.string().optional(),
+      targetMethod: import_zod7.z.string().optional(),
       // Required if type is 'call' or 'register', references Method name on target interface
-      capability: import_zod6.z.string().optional(),
+      capability: import_zod7.z.string().optional(),
       // Required if type is 'dispatch': the capability routed through the target Portal's dispatch table
       /**
        * call/dispatch only: the credential this step presents to an authed callee
@@ -1221,8 +1326,8 @@ var init_specs = __esm({
        * `auth ≠ none` warns (PORTAL_AUTH_UNMET), so credential loading is never
        * overlooked.
        */
-      auth: import_zod6.z.object({ from: import_zod6.z.string(), note: import_zod6.z.string().optional() }).optional(),
-      assertsGuarantees: import_zod6.z.array(GuaranteeSchema).optional(),
+      auth: import_zod7.z.object({ from: import_zod7.z.string(), note: import_zod7.z.string().optional() }).optional(),
+      assertsGuarantees: import_zod7.z.array(GuaranteeSchema).optional(),
       /**
        * Declared entity invariants this step upholds, as "<type-id>.<invariant-id>"
        * references (type id optionally subsystem-qualified). The invariant-backing
@@ -1230,51 +1335,51 @@ var init_specs = __esm({
        * (UNKNOWN_INVARIANT_REF) and counts the step as the write-path assertion the
        * entity's write methods must carry (UNASSERTED_INVARIANT otherwise).
        */
-      assertsInvariants: import_zod6.z.array(import_zod6.z.string()).optional(),
+      assertsInvariants: import_zod7.z.array(import_zod7.z.string()).optional(),
       // --- flow config (per type; validated by the narrative-flow rule) ---------
-      condition: import_zod6.z.string().optional(),
+      condition: import_zod7.z.string().optional(),
       // branch; loop (while/doWhile)
-      onTrueStep: import_zod6.z.number().int().positive().optional(),
+      onTrueStep: import_zod7.z.number().int().positive().optional(),
       // branch (default: next step)
-      onFalseStep: import_zod6.z.number().int().positive().optional(),
+      onFalseStep: import_zod7.z.number().int().positive().optional(),
       // branch (required)
-      on: import_zod6.z.string().optional(),
+      on: import_zod7.z.string().optional(),
       // switch: the dispatched value
-      cases: import_zod6.z.array(SwitchCaseSchema).optional(),
+      cases: import_zod7.z.array(SwitchCaseSchema).optional(),
       // switch (required)
-      defaultStep: import_zod6.z.number().int().positive().optional(),
+      defaultStep: import_zod7.z.number().int().positive().optional(),
       // switch (default: next step)
       loopKind: LoopKindSchema.optional(),
       // loop (default: forEach when `over`, else while)
-      over: import_zod6.z.string().optional(),
+      over: import_zod7.z.string().optional(),
       // loop (forEach/for): iteration source
-      endStep: import_zod6.z.number().int().positive().optional(),
+      endStep: import_zod7.z.number().int().positive().optional(),
       // loop/try/parallel: last step of the body region
-      catches: import_zod6.z.array(CatchClauseSchema).optional(),
+      catches: import_zod7.z.array(CatchClauseSchema).optional(),
       // try
-      finallyStep: import_zod6.z.number().int().positive().optional(),
+      finallyStep: import_zod7.z.number().int().positive().optional(),
       // try: first step of the always-runs region
-      branches: import_zod6.z.array(ParallelBranchSchema).optional(),
+      branches: import_zod7.z.array(ParallelBranchSchema).optional(),
       // parallel (required, >= 2 arms)
-      toStep: import_zod6.z.number().int().positive().optional(),
+      toStep: import_zod7.z.number().int().positive().optional(),
       // jump (required)
       /**
        * call/dispatch only: fire-and-forget — the call is issued and this
        * narrative CONTINUES without awaiting the result (no result is consumed
        * by later steps). Language/platform packs may gate it via unsupportedFlow.
        */
-      detach: import_zod6.z.boolean().optional(),
-      outcome: import_zod6.z.string().optional(),
+      detach: import_zod7.z.boolean().optional(),
+      outcome: import_zod7.z.string().optional(),
       // return: 'success' / 'not found' / …
-      error: import_zod6.z.string().optional()
+      error: import_zod7.z.string().optional()
       // throw: the raised error
     });
-    NarrativeDetailSchema = import_zod6.z.enum(["full", "calls-only", "intent"]);
-    ConformanceTierSchema = import_zod6.z.enum(["declared", "anchored", "off"]);
-    MethodImplementationSchema = import_zod6.z.object({
-      name: import_zod6.z.string(),
+    NarrativeDetailSchema = import_zod7.z.enum(["full", "calls-only", "intent"]);
+    ConformanceTierSchema = import_zod7.z.enum(["declared", "anchored", "off"]);
+    MethodImplementationSchema = import_zod7.z.object({
+      name: import_zod7.z.string(),
       // Must match a method name in the L3 interface contract
-      narrative: import_zod6.z.array(NarrativeStepSchema).default([]),
+      narrative: import_zod7.z.array(NarrativeStepSchema).default([]),
       // Level 5 Narrative
       /** Detail level for THIS method (overrides the spec-level default). */
       detail: NarrativeDetailSchema.optional(),
@@ -1283,7 +1388,7 @@ var init_specs = __esm({
        * detail: intent. Subject to the INTENT_FLOOR check: non-trivial, and
        * failure behavior stated here or in the contract's guarantees.
        */
-      intent: import_zod6.z.string().optional(),
+      intent: import_zod7.z.string().optional(),
       /** Conformance tier for THIS method (overrides the spec-level default). */
       conformance: ConformanceTierSchema.optional(),
       /**
@@ -1291,17 +1396,17 @@ var init_specs = __esm({
        * file, when it legitimately differs from the intent-language contract
        * name — e.g. a store's `put` realized by `saveSnapshot`.
        */
-      symbol: import_zod6.z.string().optional(),
+      symbol: import_zod7.z.string().optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional()
     });
-    ImplementationSpecSchema = import_zod6.z.object({
+    ImplementationSpecSchema = import_zod7.z.object({
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string(),
-      contract: import_zod6.z.string(),
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string(),
+      contract: import_zod7.z.string(),
       // References L3 Interface id
-      sourcePath: import_zod6.z.string().optional(),
+      sourcePath: import_zod7.z.string().optional(),
       // Path to the concrete source code file (e.g. "src/storage/vfs.ts")
       /**
        * The committed integration-sim harness for this implementation (N:1
@@ -1312,7 +1417,7 @@ var init_specs = __esm({
        * simPath in a subsystem activates MISSING_INTEGRATION_SIM for that
        * subsystem's other complete non-leaf implementations.
        */
-      simPath: import_zod6.z.string().optional(),
+      simPath: import_zod7.z.string().optional(),
       /**
        * External technologies (vendor, engine, SDK, service) this implementation
        * binds to — e.g. ["mysql"], ["sendgrid"]. Declaring one makes this
@@ -1321,8 +1426,8 @@ var init_specs = __esm({
        * intent-language (VENDOR_NAME_IN_CONTRACT), and only data-layer
        * stereotypes should bind tech directly (TECH_ON_LOGIC_COMPONENT).
        */
-      technologies: import_zod6.z.array(import_zod6.z.string()).optional(),
-      methods: import_zod6.z.array(MethodImplementationSchema).default([]),
+      technologies: import_zod7.z.array(import_zod7.z.string()).optional(),
+      methods: import_zod7.z.array(MethodImplementationSchema).default([]),
       /** Spec-level narrative detail default for all methods (each may override). */
       detail: NarrativeDetailSchema.optional(),
       /** Spec-level structural-conformance tier default (each method may override). */
@@ -1332,144 +1437,144 @@ var init_specs = __esm({
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional(),
       status: SpecStatusSchema.optional().default("complete"),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    TypeKindSchema = import_zod6.z.enum(["entity", "value-object"]);
-    TypeFieldSchema = import_zod6.z.object({
-      name: import_zod6.z.string(),
-      type: import_zod6.z.string(),
+    TypeKindSchema = import_zod7.z.enum(["entity", "value-object"]);
+    TypeFieldSchema = import_zod7.z.object({
+      name: import_zod7.z.string(),
+      type: import_zod7.z.string(),
       // a primitive, or another type id (qualified across subsystems, e.g. "billing.Invoice")
-      description: import_zod6.z.string().optional(),
-      optional: import_zod6.z.boolean().default(false),
+      description: import_zod7.z.string().optional(),
+      optional: import_zod7.z.boolean().default(false),
       /**
        * Identity marker for ERD / database schema derivation:
        * - 'primary' (PK)
        * - 'unique' (UK)
        * - 'foreign' (FK)
        */
-      key: import_zod6.z.enum(["primary", "unique", "foreign"]).optional(),
+      key: import_zod7.z.enum(["primary", "unique", "foreign"]).optional(),
       /**
        * For foreign keys, the referenced type/table ID (e.g. "billing.Invoice")
        * and optionally field (e.g. "billing.Invoice.id").
        */
-      references: import_zod6.z.string().optional()
+      references: import_zod7.z.string().optional()
     });
-    TypeMethodSchema = import_zod6.z.object({
-      name: import_zod6.z.string(),
-      signature: import_zod6.z.string(),
-      returns: import_zod6.z.string(),
-      description: import_zod6.z.string().optional()
+    TypeMethodSchema = import_zod7.z.object({
+      name: import_zod7.z.string(),
+      signature: import_zod7.z.string(),
+      returns: import_zod7.z.string(),
+      description: import_zod7.z.string().optional()
     });
-    InvariantSchema = import_zod6.z.object({
+    InvariantSchema = import_zod7.z.object({
       /** Stable invariant id, unique within the entity (referenced as "<type-id>.<invariant-id>"). */
       id: SpecIdSchema,
       /** The property that must hold, stated precisely enough to test against. */
-      description: import_zod6.z.string().min(1)
+      description: import_zod7.z.string().min(1)
     });
-    TypeSpecSchema = import_zod6.z.object({
+    TypeSpecSchema = import_zod7.z.object({
       kind: TypeKindSchema,
       // discriminator — entity | value-object
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string().optional(),
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string().optional(),
       /** Owning subsystem id (entities). Omit for system-level shared value objects. */
-      subsystem: import_zod6.z.string().optional(),
+      subsystem: import_zod7.z.string().optional(),
       /** Optional logical group ID to organize this type in subfolders. */
-      group: import_zod6.z.string().optional(),
-      fields: import_zod6.z.array(TypeFieldSchema).default([]),
+      group: import_zod7.z.string().optional(),
+      fields: import_zod7.z.array(TypeFieldSchema).default([]),
       /** Pure intrinsic behaviour only — anything needing a collaborator belongs on a component. */
-      methods: import_zod6.z.array(TypeMethodSchema).default([]),
+      methods: import_zod7.z.array(TypeMethodSchema).default([]),
       /**
        * Linked Component ID if this system entity is implemented as a class Component
        * (e.g., a Store or Registry that owns this entity's lifecycle and methods).
        */
-      componentClass: import_zod6.z.string().optional(),
+      componentClass: import_zod7.z.string().optional(),
       /**
        * Declared domain invariants on this entity (see InvariantSchema). Anchored
        * through componentClass: its write-effect contract methods must each carry
        * a narrative step asserting every declared invariant.
        */
-      invariants: import_zod6.z.array(InvariantSchema).optional(),
+      invariants: import_zod7.z.array(InvariantSchema).optional(),
       /**
        * The database ID this schema belongs to (marks it as a database table schema).
        */
-      database: import_zod6.z.string().optional(),
+      database: import_zod7.z.string().optional(),
       /**
        * The database table name for this schema (e.g., "users").
        */
-      table: import_zod6.z.string().optional(),
+      table: import_zod7.z.string().optional(),
       /**
        * If this type is a database table schema, the ID of the corresponding
        * logical system entity type it maps to.
        */
-      linkedEntity: import_zod6.z.string().optional(),
+      linkedEntity: import_zod7.z.string().optional(),
       /** Per-spec lint suppressions (see LintConfigSchema). */
       lint: LintConfigSchema.optional(),
       /** Opaque pack/tool extension data (see ExtDataSchema) — preserved verbatim. */
       ext: ExtDataSchema.optional(),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
-    SurfaceOriginSchema = import_zod6.z.enum(["generated", "exchanged", "authored"]);
-    SurfaceTypeDefSchema = import_zod6.z.object({
-      id: import_zod6.z.string(),
-      name: import_zod6.z.string(),
-      kind: import_zod6.z.string().default("value-object"),
-      fields: import_zod6.z.array(import_zod6.z.object({
-        name: import_zod6.z.string(),
-        type: import_zod6.z.string(),
-        description: import_zod6.z.string().optional(),
-        optional: import_zod6.z.boolean().optional()
+    SurfaceOriginSchema = import_zod7.z.enum(["generated", "exchanged", "authored"]);
+    SurfaceTypeDefSchema = import_zod7.z.object({
+      id: import_zod7.z.string(),
+      name: import_zod7.z.string(),
+      kind: import_zod7.z.string().default("value-object"),
+      fields: import_zod7.z.array(import_zod7.z.object({
+        name: import_zod7.z.string(),
+        type: import_zod7.z.string(),
+        description: import_zod7.z.string().optional(),
+        optional: import_zod7.z.boolean().optional()
       })).default([])
     });
-    SurfaceContractEntrySchema = import_zod6.z.object({
-      id: import_zod6.z.string(),
-      name: import_zod6.z.string(),
+    SurfaceContractEntrySchema = import_zod7.z.object({
+      id: import_zod7.z.string(),
+      name: import_zod7.z.string(),
       /** Exposure level of the L0 entry (see SurfaceAudienceSchema). */
-      audience: import_zod6.z.string().default("instance"),
+      audience: import_zod7.z.string().default("instance"),
       /** Transport kind: REST, GraphQL, MessageBus, RPC, or Custom. */
-      type: import_zod6.z.string().default("Custom"),
+      type: import_zod7.z.string().default("Custom"),
       /** Local name of the backing Portal in the producing project. */
-      component: import_zod6.z.string(),
+      component: import_zod7.z.string(),
       /** Full contract methods (params, returns, guarantees, effect, endpoint). */
-      methods: import_zod6.z.array(MethodSignatureSchema).default([]),
+      methods: import_zod7.z.array(MethodSignatureSchema).default([]),
       /** The backing portal's capability dispatch table, when generic-dispatch. */
-      dispatch: import_zod6.z.array(DispatchBindingSchema).optional(),
-      details: import_zod6.z.string().default(""),
-      version: import_zod6.z.string().optional(),
-      stability: import_zod6.z.string().optional(),
+      dispatch: import_zod7.z.array(DispatchBindingSchema).optional(),
+      details: import_zod7.z.string().default(""),
+      version: import_zod7.z.string().optional(),
+      stability: import_zod7.z.string().optional(),
       /** Projected copy of the backing Portal's auth (see PortalAuthSchema) — the codec
        *  emits it as OpenAPI securitySchemes/security. */
       auth: PortalAuthSchema.optional(),
       /** The backing Portal's basePath — becomes the per-portal OpenAPI `servers` url. */
-      basePath: import_zod6.z.string().optional()
+      basePath: import_zod7.z.string().optional()
     });
-    SurfaceSnapshotSchema = import_zod6.z.object({
+    SurfaceSnapshotSchema = import_zod7.z.object({
       /** Producing project/system name — the snapshot's resolution identity. */
-      projectName: import_zod6.z.string(),
+      projectName: import_zod7.z.string(),
       origin: SurfaceOriginSchema,
       /** Producing spec tree's StateId at generation time (wairon-produced snapshots). */
-      stateId: import_zod6.z.string().optional(),
+      stateId: import_zod7.z.string().optional(),
       /** Contract version for authored/3rd-party surfaces without a StateId. */
-      version: import_zod6.z.string().optional(),
-      generatedAt: import_zod6.z.string(),
-      interfaces: import_zod6.z.array(SurfaceContractEntrySchema).default([]),
+      version: import_zod7.z.string().optional(),
+      generatedAt: import_zod7.z.string(),
+      interfaces: import_zod7.z.array(SurfaceContractEntrySchema).default([]),
       /** Transitive type closure of every exported signature — self-contained. */
-      types: import_zod6.z.array(SurfaceTypeDefSchema).default([])
+      types: import_zod7.z.array(SurfaceTypeDefSchema).default([])
     });
-    NamedOpenApiSpecSchema = import_zod6.z.object({
-      portalId: import_zod6.z.string(),
-      name: import_zod6.z.string(),
-      document: import_zod6.z.string()
+    NamedOpenApiSpecSchema = import_zod7.z.object({
+      portalId: import_zod7.z.string(),
+      name: import_zod7.z.string(),
+      document: import_zod7.z.string()
     });
-    GroupSpecSchema = import_zod6.z.object({
-      kind: import_zod6.z.literal("group"),
+    GroupSpecSchema = import_zod7.z.object({
+      kind: import_zod7.z.literal("group"),
       id: SpecIdSchema,
-      name: import_zod6.z.string(),
-      description: import_zod6.z.string().optional(),
-      createdAt: import_zod6.z.string().datetime(),
-      updatedAt: import_zod6.z.string().datetime()
+      name: import_zod7.z.string(),
+      description: import_zod7.z.string().optional(),
+      createdAt: import_zod7.z.string().datetime(),
+      updatedAt: import_zod7.z.string().datetime()
     });
   }
 });
@@ -1535,6 +1640,162 @@ var init_templates = __esm({
   }
 });
 
+// src/core/execution_profile.ts
+function isSweeping(p) {
+  return p === "**" || p === "**/*" || p.startsWith("**/");
+}
+function deriveBreadth(agent) {
+  if (agent.readPaths.some(isSweeping)) {
+    return MANAGER_TEMPLATES.has(agent.template) || READ_ONLY_TEMPLATES.has(agent.template) ? "wide" : "moderate";
+  }
+  const owned = agent.ownedPaths.length;
+  if (owned >= WIDE_PATH_COUNT) return "wide";
+  if (owned >= MODERATE_PATH_COUNT) return "moderate";
+  return "narrow";
+}
+function deriveReasoningDepth(agent) {
+  for (const tag of agent.tags) {
+    if (DEEP_STEREOTYPES.has(tag)) return "deep";
+    if (MECHANICAL_STEREOTYPES.has(tag)) return "mechanical";
+  }
+  if (MANAGER_TEMPLATES.has(agent.template)) return "deep";
+  if (agent.template === "reviewer") return "deep";
+  if (agent.template === "tester") return "standard";
+  return "standard";
+}
+function deriveWrites(agent) {
+  return !READ_ONLY_TEMPLATES.has(agent.template);
+}
+function deriveExecutionProfile(agent) {
+  const breadth = deriveBreadth(agent);
+  const reasoningDepth = deriveReasoningDepth(agent);
+  const writes = deriveWrites(agent);
+  const delegates = MANAGER_TEMPLATES.has(agent.template);
+  const because = [];
+  if (delegates) {
+    because.push(`${agent.template} routes work rather than performing it`);
+  }
+  const stereotype = agent.tags.find(
+    (t) => MECHANICAL_STEREOTYPES.has(t) || DEEP_STEREOTYPES.has(t)
+  );
+  if (stereotype) {
+    because.push(
+      MECHANICAL_STEREOTYPES.has(stereotype) ? `${stereotype} work is specified by its contract and narrative` : `${stereotype} carries decision logic`
+    );
+  }
+  because.push(
+    breadth === "wide" ? "reads broadly across the tree" : breadth === "moderate" ? `spans ${agent.ownedPaths.length} owned path(s)` : "scoped to a small owned set"
+  );
+  if (!writes) because.push("read-only");
+  return {
+    breadth,
+    writes,
+    reasoningDepth,
+    delegates,
+    rationale: because.join("; ")
+  };
+}
+var MECHANICAL_STEREOTYPES, DEEP_STEREOTYPES, MANAGER_TEMPLATES, READ_ONLY_TEMPLATES, WIDE_PATH_COUNT, MODERATE_PATH_COUNT;
+var init_execution_profile = __esm({
+  "src/core/execution_profile.ts"() {
+    "use strict";
+    MECHANICAL_STEREOTYPES = /* @__PURE__ */ new Set(["store", "index", "registry", "adapter"]);
+    DEEP_STEREOTYPES = /* @__PURE__ */ new Set(["orchestrator", "supervisor", "specialist"]);
+    MANAGER_TEMPLATES = /* @__PURE__ */ new Set(["architect", "domain-owner"]);
+    READ_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["reviewer", "guardian"]);
+    WIDE_PATH_COUNT = 12;
+    MODERATE_PATH_COUNT = 4;
+  }
+});
+
+// src/core/budget_policy.ts
+function atLeast(tier, floor) {
+  return TIER_ORDER.indexOf(tier) >= TIER_ORDER.indexOf(floor);
+}
+function baseModelTier(profile) {
+  switch (profile.reasoningDepth) {
+    case "mechanical":
+      return "small";
+    case "standard":
+      return "standard";
+    case "deep":
+      return "large";
+  }
+}
+function stepDown(tier, steps) {
+  const i = TIER_STEPS.indexOf(tier);
+  return TIER_STEPS[Math.max(0, i - steps)];
+}
+function maxTurnsFor(profile, tier) {
+  if (!atLeast(tier, "default")) return void 0;
+  const ceiling = profile.breadth === "wide" ? 60 : profile.breadth === "moderate" ? 40 : 25;
+  return atLeast(tier, "aggressive") ? Math.round(ceiling / 2) : ceiling;
+}
+function effortFor(profile, tier) {
+  if (!atLeast(tier, "trade")) return void 0;
+  if (profile.reasoningDepth === "mechanical") {
+    return atLeast(tier, "aggressive") ? "low" : "medium";
+  }
+  return void 0;
+}
+function toolClassFor(profile) {
+  return profile.writes ? "implement" : "read-only";
+}
+function mcpFor(profile, tier) {
+  if (!atLeast(tier, "free")) return "all";
+  if (profile.delegates) return "project";
+  return profile.breadth === "wide" ? "project" : "none";
+}
+function resolveBudget(profile, config, agentId) {
+  const tier = config.tier;
+  if (tier === "off") return void 0;
+  let modelTier = baseModelTier(profile);
+  if (atLeast(tier, "trade") && profile.reasoningDepth === "standard") {
+    modelTier = stepDown(modelTier, 1);
+  }
+  if (atLeast(tier, "aggressive") && profile.reasoningDepth !== "deep") {
+    modelTier = "small";
+  }
+  const budget = {
+    // At `free` no model selection is expressed at all — that tier is defined
+    // as having no quality tradeoff, and choosing a model is a quality
+    // decision. Leaving it absent is not the same as choosing a default.
+    modelTier: atLeast(tier, "default") ? modelTier : void 0,
+    effort: effortFor(profile, tier),
+    maxTurns: maxTurnsFor(profile, tier),
+    toolClass: toolClassFor(profile),
+    // Only managers may spawn. Withholding the tool from workers is what stops
+    // a worker quietly becoming a second orchestrator three levels down.
+    allowNestedDelegation: profile.delegates,
+    mcp: mcpFor(profile, tier)
+  };
+  const override = config.overrides[agentId];
+  return override ? { ...budget, ...override } : budget;
+}
+function describeBudget(profile, budget) {
+  const lines = [
+    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
+    `- **Why**: ${profile.rationale}`
+  ];
+  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
+  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
+  if (budget.maxTurns !== void 0) {
+    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
+  }
+  lines.push(`- **Tool grant**: ${budget.toolClass}`);
+  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
+  lines.push(`- **MCP access**: ${budget.mcp}`);
+  return lines;
+}
+var TIER_ORDER, TIER_STEPS;
+var init_budget_policy = __esm({
+  "src/core/budget_policy.ts"() {
+    "use strict";
+    TIER_ORDER = ["off", "free", "default", "trade", "aggressive"];
+    TIER_STEPS = ["small", "standard", "large", "frontier"];
+  }
+});
+
 // src/core/variants.ts
 function globalVariantsDir() {
   return process.env.WAIRON_VARIANTS_DIR ?? path6.join(os3.homedir(), ".wairon", "variants");
@@ -1602,27 +1863,27 @@ function loadProjectVariants() {
     return [];
   }
 }
-var fs4, os3, path6, import_zod7, VariantDefSchema;
+var fs4, os3, path6, import_zod8, VariantDefSchema;
 var init_variants = __esm({
   "src/core/variants.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
     os3 = __toESM(require("os"));
     path6 = __toESM(require("path"));
-    import_zod7 = require("zod");
+    import_zod8 = require("zod");
     init_yaml();
     init_fs();
-    VariantDefSchema = import_zod7.z.object({
+    VariantDefSchema = import_zod8.z.object({
       /** Variant id referenced by a component's `variant` (e.g. "publisher", "org/external-config-adapter"). */
-      id: import_zod7.z.string().min(1),
+      id: import_zod8.z.string().min(1),
       /** The core stereotype this variant specializes — authoritative for generic semantics (Adapter, Specialist, …). */
-      base: import_zod7.z.string().min(1),
+      base: import_zod8.z.string().min(1),
       /** How to implement a component of this variant — the recipe the implementer follows and reuses across same-variant components. */
-      guidance: import_zod7.z.string().min(1),
+      guidance: import_zod8.z.string().min(1),
       /** Optional: this variant only applies for the given target language (else it applies everywhere). */
-      target: import_zod7.z.string().optional(),
+      target: import_zod8.z.string().optional(),
       /** Optional: this variant only applies under the given architectural profile. */
-      profile: import_zod7.z.string().optional()
+      profile: import_zod8.z.string().optional()
     });
   }
 });
@@ -1977,6 +2238,9 @@ function composeAgentBrief(agentId) {
 ${guidance.trim()}
 `;
   }
+  const config = loadProjectConfig();
+  const profile = deriveExecutionProfile(record2);
+  const budget = resolveBudget(profile, config.execution, record2.id);
   return {
     agentId: record2.id,
     name: record2.name,
@@ -1985,7 +2249,9 @@ ${guidance.trim()}
     ownedPaths: record2.ownedPaths,
     readPaths: record2.readPaths,
     instructions,
-    variantGuidance: record2.variantGuidance || void 0
+    variantGuidance: record2.variantGuidance || void 0,
+    profile: budget ? profile : void 0,
+    budget
   };
 }
 var path7, fs5, projectFilesCache, UnknownAgentError;
@@ -1998,6 +2264,8 @@ var init_agent_resolver = __esm({
     init_fs();
     init_errors();
     init_templates();
+    init_execution_profile();
+    init_budget_policy();
     init_specs2();
     init_variants();
     projectFilesCache = /* @__PURE__ */ new Map();
@@ -2681,7 +2949,7 @@ function findBundledPack(projectRoot2, selection) {
   }
   return best?.dir ?? null;
 }
-var fs8, os4, path10, import_module, import_zod8, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, PACK_DIR_ENTRIES, isYamlPath;
+var fs8, os4, path10, import_module, import_zod9, ProfileDefSchema, LanguagePackDefSchema, PackSkillSchema, PackInstructionBlockSchema, PackInstructionsSchema, PatternDefSchema, AssertionSelectorSchema, assertionBase, PackAssertionSchema, DeclarativePackSchema, EXTENDABLE_BUILTIN_SKILLS, GLOBAL_PACKS_DEFAULT, PACK_DIR_ENTRIES, isYamlPath;
 var init_extensions = __esm({
   "src/core/extensions.ts"() {
     "use strict";
@@ -2689,17 +2957,17 @@ var init_extensions = __esm({
     os4 = __toESM(require("os"));
     path10 = __toESM(require("path"));
     import_module = require("module");
-    import_zod8 = require("zod");
+    import_zod9 = require("zod");
     init_yaml();
     init_fs();
     init_loader();
     init_version();
     init_project();
     init_packstore();
-    ProfileDefSchema = import_zod8.z.object({
-      family: import_zod8.z.enum(["backend-like", "frontend-like", "neutral"]).default("neutral"),
-      forbiddenStereotypes: import_zod8.z.array(import_zod8.z.object({ types: import_zod8.z.array(import_zod8.z.string()).min(1), reason: import_zod8.z.string().min(1) })).default([]),
-      discouragedStereotypes: import_zod8.z.array(import_zod8.z.object({ types: import_zod8.z.array(import_zod8.z.string()).min(1), reason: import_zod8.z.string().min(1) })).default([]),
+    ProfileDefSchema = import_zod9.z.object({
+      family: import_zod9.z.enum(["backend-like", "frontend-like", "neutral"]).default("neutral"),
+      forbiddenStereotypes: import_zod9.z.array(import_zod9.z.object({ types: import_zod9.z.array(import_zod9.z.string()).min(1), reason: import_zod9.z.string().min(1) })).default([]),
+      discouragedStereotypes: import_zod9.z.array(import_zod9.z.object({ types: import_zod9.z.array(import_zod9.z.string()).min(1), reason: import_zod9.z.string().min(1) })).default([]),
       /**
        * Edge deltas — the ALLOW half of the profile-scoped dependency matrix. An
        * entry LICENSES intra-subsystem dependsOn edges the builtin stereotype
@@ -2709,20 +2977,20 @@ var init_extensions = __esm({
        * boundary rules and pattern containment are never relaxable. The DENY
        * half is a `forbid-edge` declarative assertion.
        */
-      allowedEdges: import_zod8.z.array(import_zod8.z.object({
-        from: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
-        to: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
-        reason: import_zod8.z.string().min(1)
+      allowedEdges: import_zod9.z.array(import_zod9.z.object({
+        from: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
+        to: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
+        reason: import_zod9.z.string().min(1)
       })).default([]),
       rules: RulesConfigSchema.partial().optional()
     });
-    LanguagePackDefSchema = import_zod8.z.object({
-      unsupportedFlow: import_zod8.z.record(import_zod8.z.string()).default({}),
-      foreignBuiltins: import_zod8.z.array(import_zod8.z.string()).default([])
+    LanguagePackDefSchema = import_zod9.z.object({
+      unsupportedFlow: import_zod9.z.record(import_zod9.z.string()).default({}),
+      foreignBuiltins: import_zod9.z.array(import_zod9.z.string()).default([])
     });
-    PackSkillSchema = import_zod8.z.object({
+    PackSkillSchema = import_zod9.z.object({
       /** A NEW skill, installed namespaced as `<pack-id>-<id>`. Mutually exclusive with `extends`. */
-      id: import_zod8.z.string().min(1).optional(),
+      id: import_zod9.z.string().min(1).optional(),
       /**
        * EXTEND a builtin skill (`sdd-architect` | `sdd-narrative` | `sdd-auditor` |
        * `sdd-implement`) instead of standing beside it.
@@ -2734,86 +3002,86 @@ var init_extensions = __esm({
        * appended under `## Platform: <pack>`; the builtin stays wairon's, so an
        * upgrade still updates it.
        */
-      extends: import_zod8.z.string().min(1).optional(),
-      source: import_zod8.z.string().min(1),
-      targets: import_zod8.z.array(import_zod8.z.string()).default([])
+      extends: import_zod9.z.string().min(1).optional(),
+      source: import_zod9.z.string().min(1),
+      targets: import_zod9.z.array(import_zod9.z.string()).default([])
     }).refine((s) => s.id === void 0 !== (s.extends === void 0), {
       message: "a pack skill declares either `id` (a new skill) or `extends` (a section appended to a builtin), not both and not neither"
     });
-    PackInstructionBlockSchema = import_zod8.z.union([
+    PackInstructionBlockSchema = import_zod9.z.union([
       // Scalar shorthand: `instructions: >- …` — the common case, unscoped.
-      import_zod8.z.string().min(1).transform((text2) => ({ text: text2 })),
-      import_zod8.z.object({
-        text: import_zod8.z.string().min(1),
-        profile: import_zod8.z.array(import_zod8.z.string().min(1)).min(1).optional()
+      import_zod9.z.string().min(1).transform((text2) => ({ text: text2 })),
+      import_zod9.z.object({
+        text: import_zod9.z.string().min(1),
+        profile: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).optional()
       })
     ]);
-    PackInstructionsSchema = import_zod8.z.preprocess(
+    PackInstructionsSchema = import_zod9.z.preprocess(
       (raw) => raw === void 0 || raw === null ? [] : Array.isArray(raw) ? raw : [raw],
-      import_zod8.z.array(PackInstructionBlockSchema)
+      import_zod9.z.array(PackInstructionBlockSchema)
     );
-    PatternDefSchema = import_zod8.z.object({
-      id: import_zod8.z.string().min(1),
-      version: import_zod8.z.string().min(1),
-      description: import_zod8.z.string().optional(),
-      metadata: import_zod8.z.record(import_zod8.z.unknown()).optional()
+    PatternDefSchema = import_zod9.z.object({
+      id: import_zod9.z.string().min(1),
+      version: import_zod9.z.string().min(1),
+      description: import_zod9.z.string().optional(),
+      metadata: import_zod9.z.record(import_zod9.z.unknown()).optional()
     });
-    AssertionSelectorSchema = import_zod8.z.object({
-      componentType: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
-      profile: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
-      id: import_zod8.z.string().min(1).optional()
+    AssertionSelectorSchema = import_zod9.z.object({
+      componentType: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
+      profile: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
+      id: import_zod9.z.string().min(1).optional()
     });
     assertionBase = {
       /** Pack-local code; surfaced namespaced as <PACK_NAME>_<CODE>. */
-      code: import_zod8.z.string().min(1),
-      severity: import_zod8.z.enum(["warning", "error"]).default("warning"),
+      code: import_zod9.z.string().min(1),
+      severity: import_zod9.z.enum(["warning", "error"]).default("warning"),
       /** The doctrine, stated for the finding message. */
-      reason: import_zod8.z.string().min(1)
+      reason: import_zod9.z.string().min(1)
     };
-    PackAssertionSchema = import_zod8.z.discriminatedUnion("kind", [
-      import_zod8.z.object({
-        kind: import_zod8.z.literal("forbid-edge"),
+    PackAssertionSchema = import_zod9.z.discriminatedUnion("kind", [
+      import_zod9.z.object({
+        kind: import_zod9.z.literal("forbid-edge"),
         ...assertionBase,
         from: AssertionSelectorSchema,
         to: AssertionSelectorSchema,
-        relation: import_zod8.z.array(import_zod8.z.enum(["dependsOn", "owns"])).default(["dependsOn", "owns"])
+        relation: import_zod9.z.array(import_zod9.z.enum(["dependsOn", "owns"])).default(["dependsOn", "owns"])
       }),
-      import_zod8.z.object({
-        kind: import_zod8.z.literal("require-field"),
+      import_zod9.z.object({
+        kind: import_zod9.z.literal("require-field"),
         ...assertionBase,
         on: AssertionSelectorSchema,
-        level: import_zod8.z.enum(["component", "interface", "implementation"]).default("component"),
+        level: import_zod9.z.enum(["component", "interface", "implementation"]).default("component"),
         /** A top-level spec field name, or one `ext.*` path — nothing else is addressable. */
-        field: import_zod8.z.string().min(1),
+        field: import_zod9.z.string().min(1),
         /** Optional closed value set (string equality). */
-        values: import_zod8.z.array(import_zod8.z.string()).optional()
+        values: import_zod9.z.array(import_zod9.z.string()).optional()
       }),
-      import_zod8.z.object({
-        kind: import_zod8.z.literal("endpoint-shape"),
+      import_zod9.z.object({
+        kind: import_zod9.z.literal("endpoint-shape"),
         ...assertionBase,
         on: AssertionSelectorSchema,
         /** Optional transport allowlist. */
-        transport: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
+        transport: import_zod9.z.array(import_zod9.z.string().min(1)).optional(),
         /** Optional anchored regex over the transport's address field (path/topic/command/…). */
-        pathPattern: import_zod8.z.string().min(1).optional()
+        pathPattern: import_zod9.z.string().min(1).optional()
       })
     ]);
-    DeclarativePackSchema = import_zod8.z.object({
-      name: import_zod8.z.string().min(1),
-      version: import_zod8.z.string().optional(),
-      profiles: import_zod8.z.record(ProfileDefSchema).default({}),
-      languages: import_zod8.z.record(LanguagePackDefSchema).default({}),
-      skills: import_zod8.z.array(PackSkillSchema).default([]),
-      patterns: import_zod8.z.array(PatternDefSchema).default([]),
+    DeclarativePackSchema = import_zod9.z.object({
+      name: import_zod9.z.string().min(1),
+      version: import_zod9.z.string().optional(),
+      profiles: import_zod9.z.record(ProfileDefSchema).default({}),
+      languages: import_zod9.z.record(LanguagePackDefSchema).default({}),
+      skills: import_zod9.z.array(PackSkillSchema).default([]),
+      patterns: import_zod9.z.array(PatternDefSchema).default([]),
       /** Declarative rule assertions — instances of closed kinds, hosted-safe. */
-      assertions: import_zod8.z.array(PackAssertionSchema).default([]),
+      assertions: import_zod9.z.array(PackAssertionSchema).default([]),
       /**
        * Semantic guarantee tokens this pack adds to the builtin vocabulary
        * (SEMANTIC_GUARANTEES). Declaring a token makes it legal on L3 method
        * `guarantees` and narrative `assertsGuarantees`; referenced tokens outside
        * builtin + declared are flagged UNKNOWN_GUARANTEE by the validator.
        */
-      guarantees: import_zod8.z.array(import_zod8.z.string().min(1)).default([]),
+      guarantees: import_zod9.z.array(import_zod9.z.string().min(1)).default([]),
       /**
        * Connecting-agent guidance appended to wairon's own MCP `initialize`
        * instructions, attributed to this pack, in pack load order.
@@ -2828,7 +3096,7 @@ var init_extensions = __esm({
        * explicit in the new project's `project.yaml` where it is visible in review
        * and removable — never silent authority over projects that never mentioned it.
        */
-      applyByDefault: import_zod8.z.boolean().default(false)
+      applyByDefault: import_zod9.z.boolean().default(false)
     });
     EXTENDABLE_BUILTIN_SKILLS = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
     GLOBAL_PACKS_DEFAULT = false;
@@ -3804,12 +4072,25 @@ function getSnapshot(projectName, rootDir = getProjectRoot()) {
 function snapshotFilename(projectName) {
   return `${safeFilenamePart(projectName)}.yaml`;
 }
-function saveSnapshot(snapshot, rootDir = getProjectRoot()) {
+function writeSnapshotIfChanged(snapshot, rootDir) {
   const dir = surfacesDir(rootDir);
   fs9.mkdirSync(dir, { recursive: true });
   const p = path11.join(dir, snapshotFilename(snapshot.projectName));
-  writeYamlFile(p, SurfaceSnapshotSchema.parse(snapshot));
-  return p;
+  const next = SurfaceSnapshotSchema.parse(snapshot);
+  if (fs9.existsSync(p)) {
+    try {
+      const existing = SurfaceSnapshotSchema.parse(readYamlFile(p));
+      if (surfaceContentKey(existing) === surfaceContentKey(next)) {
+        return { path: p, changed: false };
+      }
+    } catch {
+    }
+  }
+  writeYamlFile(p, next);
+  return { path: p, changed: true };
+}
+function saveSnapshot(snapshot, rootDir = getProjectRoot()) {
+  return writeSnapshotIfChanged(snapshot, rootDir).path;
 }
 function loadSurfaceSnapshots() {
   return listSnapshots();
@@ -3894,13 +4175,16 @@ function generateChildSnapshots(rootDir = getProjectRoot()) {
     return snap;
   };
   const written = [];
+  const record2 = (r) => {
+    if (r.changed) written.push(r.path);
+  };
   for (const child of children) {
     const childDir = path11.resolve(rootDir, child.projectPath);
     if (!fs9.existsSync(childDir)) continue;
-    written.push(saveSnapshot(familySnapshot, childDir));
+    record2(writeSnapshotIfChanged(familySnapshot, childDir));
     for (const sibling of topLevel) {
       if (sibling.id === child.id) continue;
-      written.push(saveSnapshot(siblingSurface(sibling.id), childDir));
+      record2(writeSnapshotIfChanged(siblingSurface(sibling.id), childDir));
     }
   }
   return written;
@@ -17217,6 +17501,27 @@ var init_specs2 = __esm({
             `kind "system" targets the singleton L0 spec (system name "${result.name}") \u2014 pass id "system" or the system name, got "${id}". For a subsystem, use kind "subsystem".`
           );
         }
+        const deltaSchema = {
+          system: SystemSpecSchema,
+          subsystem: SubsystemSpecSchema,
+          component: ComponentSpecSchema,
+          interface: InterfaceSpecSchema,
+          implementation: ImplementationSpecSchema,
+          type: TypeSpecSchema
+        }[kind];
+        const knownKeys = new Set(Object.keys(deltaSchema.shape));
+        knownKeys.add("unset");
+        const unknownKeys = Object.keys(delta ?? {}).filter((k) => !knownKeys.has(k));
+        if (unknownKeys.length > 0) {
+          const near = (k) => {
+            const norm = k.toLowerCase().replace(/[_\-\s]/g, "");
+            const hit = [...knownKeys].find((v) => v.toLowerCase().replace(/[_\-\s]/g, "") === norm);
+            return hit ? ` (did you mean "${hit}"?)` : "";
+          };
+          throw new Error(
+            `Refusing to update ${kind} "${id}": unknown field(s) ${unknownKeys.map((k) => `"${k}"${near(k)}`).join(", ")}. An unknown key is dropped on write, so the edit would report success and change nothing. Known fields: ${[...knownKeys].sort().join(", ")}.`
+          );
+        }
         const JUMP_FIELDS = ["onTrueStep", "onFalseStep", "defaultStep", "endStep", "finallyStep", "toStep"];
         const JUMP_LIST_FIELDS = ["cases", "catches", "branches"];
         const relocateJumps = (step, shiftFrom, deltaN, captureInsertTarget = false) => {
@@ -17636,6 +17941,7 @@ function defaultProjectConfig(name, now) {
     name,
     projectType: "backend",
     targets: [{ type: "claude", outputDir: ".claude/agents", enabled: true }],
+    execution: { tier: "off", overrides: {} },
     rules: {
       noOverlappingOwnership: true,
       requireOwnedPaths: true,
@@ -20269,15 +20575,15 @@ var require_node = __commonJS({
     var slzh = function(d, b) {
       return b + 30 + b2(d, b + 26) + b2(d, b + 28);
     };
-    var zh = function(d, b, z10) {
+    var zh = function(d, b, z11) {
       var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
-      var _a2 = z64hs(d, es, efl, z10, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+      var _a2 = z64hs(d, es, efl, z11, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
       return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
     };
-    var z64hs = function(d, b, l, z10, sc, su, off) {
+    var z64hs = function(d, b, l, z11, sc, su, off) {
       var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
       var nf = nsc + nsu + noff;
-      if (z10 && nf) {
+      if (z11 && nf) {
         for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
           if (b2(d, b) == 1) {
             return [
@@ -20288,7 +20594,7 @@ var require_node = __commonJS({
             ];
           }
         }
-        if (z10 < 2)
+        if (z11 < 2)
           err(13);
       }
       return [sc, su, off, 0];
@@ -20897,18 +21203,18 @@ var require_node = __commonJS({
       if (lft) {
         var c = lft;
         var o = b4(data, e + 16);
-        var z10 = b4(data, e - 20) == 117853008;
-        if (z10) {
+        var z11 = b4(data, e - 20) == 117853008;
+        if (z11) {
           var ze = b4(data, e - 12);
-          z10 = b4(data, ze) == 101075792;
-          if (z10) {
+          z11 = b4(data, ze) == 101075792;
+          if (z11) {
             c = lft = b4(data, ze + 32);
             o = b4(data, ze + 48);
           }
         }
         var fltr = opts && opts.filter;
         var _loop_3 = function(i3) {
-          var _a2 = zh(data, o, z10), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+          var _a2 = zh(data, o, z11), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
           o = no;
           var cbl = function(e2, d) {
             if (e2) {
@@ -20963,18 +21269,18 @@ var require_node = __commonJS({
       if (!c)
         return {};
       var o = b4(data, e + 16);
-      var z10 = b4(data, e - 20) == 117853008;
-      if (z10) {
+      var z11 = b4(data, e - 20) == 117853008;
+      if (z11) {
         var ze = b4(data, e - 12);
-        z10 = b4(data, ze) == 101075792;
-        if (z10) {
+        z11 = b4(data, ze) == 101075792;
+        if (z11) {
           c = b4(data, ze + 32);
           o = b4(data, ze + 48);
         }
       }
       var fltr = opts && opts.filter;
       for (var i2 = 0; i2 < c; ++i2) {
-        var _a2 = zh(data, o, z10), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+        var _a2 = zh(data, o, z11), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
         o = no;
         if (!fltr || fltr({
           name: fn,
@@ -22419,7 +22725,8 @@ function reg(server, name, config, cb) {
     if (result.isError !== true && SPEC_WRITE_TOOLS.has(name)) listChangedEmitters.get(server)?.();
     return result;
   };
-  server.registerTool(name, config, guarded);
+  const strictConfig = config.inputSchema ? { ...config, inputSchema: import_zod10.z.object(config.inputSchema).strict() } : config;
+  server.registerTool(name, strictConfig, guarded);
 }
 function isEmptyValue(value) {
   if (value === void 0 || value === null) return true;
@@ -22522,6 +22829,16 @@ function renderAgentBriefMarkdown(brief) {
   if (brief.variantGuidance && !brief.instructions.includes(brief.variantGuidance)) {
     lines.push("", "## Variant guidance", "", brief.variantGuidance);
   }
+  if (brief.budget && brief.profile) {
+    lines.push(
+      "",
+      "## Execution budget",
+      "",
+      ...describeBudget(brief.profile, brief.budget),
+      "",
+      "Advisory \u2014 apply these when spawning. Map the capability tier onto your host tool's models; a tool that cannot express a field should ignore it rather than approximate it."
+    );
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -22602,7 +22919,7 @@ function createMcpServer(options = {}) {
     "listAgents",
     {
       description: "List all AI agents registered in this project. Returns id, name, description, domainRoot, template, tags, and status for each agent. Filter by domainId to scope to one domain.",
-      inputSchema: { domainId: import_zod9.z.string().optional() }
+      inputSchema: { domainId: import_zod10.z.string().optional() }
     },
     ({ domainId }) => {
       try {
@@ -22628,7 +22945,7 @@ function createMcpServer(options = {}) {
     "getAgent",
     {
       description: "Get full details of a specific agent by id, including ownership rules, context, and output targets.",
-      inputSchema: { id: import_zod9.z.string() }
+      inputSchema: { id: import_zod10.z.string() }
     },
     ({ id }) => {
       try {
@@ -22662,7 +22979,7 @@ function createMcpServer(options = {}) {
     {
       description: "Validate the project's agent topology. Returns errors and warnings (duplicate ids, overlapping ownership, missing paths, etc.). Supports optional subsystem scoping.",
       inputSchema: {
-        subsystem: import_zod9.z.string().optional().describe("Only validate topology for agents under the specified subsystem")
+        subsystem: import_zod10.z.string().optional().describe("Only validate topology for agents under the specified subsystem")
       }
     },
     ({ subsystem }) => {
@@ -22704,11 +23021,11 @@ function createMcpServer(options = {}) {
     }
   );
   const systemInput = {
-    name: import_zod9.z.string().describe("Overarching name of the project/system"),
-    vision: import_zod9.z.string().describe("Vision, mission, and core goals of the system"),
-    boundaries: import_zod9.z.array(import_zod9.z.union([import_zod9.z.string(), import_zod9.z.object({ name: import_zod9.z.string(), description: import_zod9.z.string().optional() })])).optional().describe("System boundary rules or scope statements (strings or name/description objects)"),
-    globalRequirements: import_zod9.z.array(import_zod9.z.union([import_zod9.z.string(), import_zod9.z.object({ description: import_zod9.z.string() })])).optional().describe("Global functional and non-functional requirements (strings or description objects)"),
-    targetLanguage: import_zod9.z.string().optional().describe('Default implementation language for the system (e.g. "typescript", "rust", "python"). Subsystems may override. Enables language-aware validation.')
+    name: import_zod10.z.string().describe("Overarching name of the project/system"),
+    vision: import_zod10.z.string().describe("Vision, mission, and core goals of the system"),
+    boundaries: import_zod10.z.array(import_zod10.z.union([import_zod10.z.string(), import_zod10.z.object({ name: import_zod10.z.string(), description: import_zod10.z.string().optional() })])).optional().describe("System boundary rules or scope statements (strings or name/description objects)"),
+    globalRequirements: import_zod10.z.array(import_zod10.z.union([import_zod10.z.string(), import_zod10.z.object({ description: import_zod10.z.string() })])).optional().describe("Global functional and non-functional requirements (strings or description objects)"),
+    targetLanguage: import_zod10.z.string().optional().describe('Default implementation language for the system (e.g. "typescript", "rust", "python"). Subsystems may override. Enables language-aware validation.')
   };
   const systemInputFields = Object.keys(systemInput);
   reg(
@@ -22749,28 +23066,28 @@ NOTICE:
     }
   );
   const subsystemInput = {
-    id: import_zod9.z.string().describe("Lowercase identifier for the subsystem"),
-    name: import_zod9.z.string().describe("Human-readable display name"),
-    description: import_zod9.z.string().describe("Purpose and details of the subsystem"),
-    publicInterfaces: import_zod9.z.array(import_zod9.z.object({
-      type: import_zod9.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
-      details: import_zod9.z.string(),
-      component: import_zod9.z.string().optional().describe("The L2 component id that realizes this interface (this subsystem's published surface)"),
-      interface: import_zod9.z.string().optional().describe("Optional L3 interface id on that component backing this entry")
+    id: import_zod10.z.string().describe("Lowercase identifier for the subsystem"),
+    name: import_zod10.z.string().describe("Human-readable display name"),
+    description: import_zod10.z.string().describe("Purpose and details of the subsystem"),
+    publicInterfaces: import_zod10.z.array(import_zod10.z.object({
+      type: import_zod10.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
+      details: import_zod10.z.string(),
+      component: import_zod10.z.string().optional().describe("The L2 component id that realizes this interface (this subsystem's published surface)"),
+      interface: import_zod10.z.string().optional().describe("Optional L3 interface id on that component backing this entry")
     })).optional().describe("Public entrypoints exposed by this subsystem, each bound to a realizing component"),
-    projectPath: import_zod9.z.string().optional().describe("Relative path to external project root for subsystem chaining"),
-    targetLanguage: import_zod9.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
-    profile: import_zod9.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
-    designDepth: import_zod9.z.enum(["components", "interfaces", "implementations", "narratives"]).optional().describe("How deep THIS subsystem commits to designing (overrides project rules.designDepth; default narratives = full depth). Expectation checks below the depth are gated \u2014 soundness of authored content always applies."),
-    trustedLinks: import_zod9.z.array(import_zod9.z.object({
-      subsystem: import_zod9.z.string().describe("Peer subsystem id"),
-      reason: import_zod9.z.string().describe('Why the coupling is sanctioned (e.g. "dispatch latency fast lane")')
+    projectPath: import_zod10.z.string().optional().describe("Relative path to external project root for subsystem chaining"),
+    targetLanguage: import_zod10.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
+    profile: import_zod10.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
+    designDepth: import_zod10.z.enum(["components", "interfaces", "implementations", "narratives"]).optional().describe("How deep THIS subsystem commits to designing (overrides project rules.designDepth; default narratives = full depth). Expectation checks below the depth are gated \u2014 soundness of authored content always applies."),
+    trustedLinks: import_zod10.z.array(import_zod10.z.object({
+      subsystem: import_zod10.z.string().describe("Peer subsystem id"),
+      reason: import_zod10.z.string().describe('Why the coupling is sanctioned (e.g. "dispatch latency fast lane")')
     })).optional().describe("Sanctioned tight couplings with peers \u2014 required to acknowledge a mutual subsystem dependency; the Adapter \u2192 published Portal shape still applies."),
-    lifecycle: import_zod9.z.array(import_zod9.z.object({
-      phase: import_zod9.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]).describe("Which lifecycle/execution flow this roots (cyclic = every scan/tick, interrupt = hardware/OS interrupt, scheduled = timer/cron)"),
-      component: import_zod9.z.string().describe("Component id whose method the runtime invokes at this phase"),
-      method: import_zod9.z.string().describe("Method name on that component's interface"),
-      description: import_zod9.z.string().optional()
+    lifecycle: import_zod10.z.array(import_zod10.z.object({
+      phase: import_zod10.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]).describe("Which lifecycle/execution flow this roots (cyclic = every scan/tick, interrupt = hardware/OS interrupt, scheduled = timer/cron)"),
+      component: import_zod10.z.string().describe("Component id whose method the runtime invokes at this phase"),
+      method: import_zod10.z.string().describe("Method name on that component's interface"),
+      description: import_zod10.z.string().optional()
     })).optional().describe("Declared execution-flow roots \u2014 reachability entrypoints alongside Portals/Observers. Only init flows feed the durable-Store hydration check (MISSING_HYDRATION); cyclic/interrupt/scheduled root non-request/response execution models (PLC scan, ISR, cron).")
   };
   const subsystemInputFields = [...Object.keys(subsystemInput), "parentSystem"];
@@ -22830,12 +23147,12 @@ NOTICE:
     {
       description: "Set (replace) an existing subsystem's publicInterfaces, binding each to the component (and optional interface) that realizes it. Use this to backfill bindings once the subsystem's components exist \u2014 cross-subsystem dependencies may only target a published public component.",
       inputSchema: {
-        subsystem: import_zod9.z.string().describe("The L1 subsystem id to update"),
-        publicInterfaces: import_zod9.z.array(import_zod9.z.object({
-          type: import_zod9.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
-          details: import_zod9.z.string(),
-          component: import_zod9.z.string().optional().describe("The L2 component id that realizes this interface"),
-          interface: import_zod9.z.string().optional().describe("Optional L3 interface id on that component")
+        subsystem: import_zod10.z.string().describe("The L1 subsystem id to update"),
+        publicInterfaces: import_zod10.z.array(import_zod10.z.object({
+          type: import_zod10.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
+          details: import_zod10.z.string(),
+          component: import_zod10.z.string().optional().describe("The L2 component id that realizes this interface"),
+          interface: import_zod10.z.string().optional().describe("Optional L3 interface id on that component")
         })).describe("The full replacement list of public interfaces for this subsystem")
       }
     },
@@ -22861,8 +23178,8 @@ NOTICE:
     {
       description: "Set (or clear) the projectPath of an L1 Subsystem for subsystem chaining. projectPath should be a relative path to the external project root directory.",
       inputSchema: {
-        subsystem: import_zod9.z.string().describe("The L1 subsystem id to update"),
-        projectPath: import_zod9.z.string().optional().describe("Relative path to external project root (or omit to clear)")
+        subsystem: import_zod10.z.string().describe("The L1 subsystem id to update"),
+        projectPath: import_zod10.z.string().optional().describe("Relative path to external project root (or omit to clear)")
       }
     },
     ({ subsystem, projectPath }) => {
@@ -22887,8 +23204,8 @@ NOTICE:
     {
       description: "Relocate an external subsystem: move its subproject directory on disk to newProjectPath and update its projectPath link in one step. Errors if the subsystem has no projectPath (not an external subproject).",
       inputSchema: {
-        subsystem: import_zod9.z.string().describe("The external L1 subsystem id to relocate"),
-        newProjectPath: import_zod9.z.string().describe("The new relative path for the subproject directory")
+        subsystem: import_zod10.z.string().describe("The external L1 subsystem id to relocate"),
+        newProjectPath: import_zod10.z.string().describe("The new relative path for the subproject directory")
       }
     },
     ({ subsystem, newProjectPath }) => {
@@ -22907,8 +23224,8 @@ NOTICE:
     {
       description: "Migrate an internal subsystem into a standalone subproject at projectPath: move its spec subtree out, mount it via projectPath, and rewrite cross-subsystem references to the new namespaced ids. Source code is not moved. Errors if the subsystem is missing or already external.",
       inputSchema: {
-        subsystem: import_zod9.z.string().describe("The internal L1 subsystem id to externalize"),
-        projectPath: import_zod9.z.string().describe("Relative destination directory for the new subproject")
+        subsystem: import_zod10.z.string().describe("The internal L1 subsystem id to externalize"),
+        projectPath: import_zod10.z.string().describe("Relative destination directory for the new subproject")
       }
     },
     ({ subsystem, projectPath }) => {
@@ -22927,7 +23244,7 @@ NOTICE:
     {
       description: "Migrate an external subsystem back into the parent tree: move its subproject spec subtree back under the parent, drop projectPath, delete the child .wai project, and rewrite references back to bare ids. Errors if the subsystem is not external or its subproject is not a single flat subsystem.",
       inputSchema: {
-        subsystem: import_zod9.z.string().describe("The external L1 subsystem id to internalize")
+        subsystem: import_zod10.z.string().describe("The external L1 subsystem id to internalize")
       }
     },
     ({ subsystem }) => {
@@ -22941,33 +23258,33 @@ NOTICE:
     }
   );
   const componentInput = {
-    id: import_zod9.z.string().describe("Lowercase identifier for the component"),
-    name: import_zod9.z.string().describe("Human-readable display name"),
-    description: import_zod9.z.string().describe("Responsibility / internal architecture details"),
-    subsystem: import_zod9.z.string().describe("The L1 subsystem ID this component belongs to"),
-    componentType: import_zod9.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Registry", "Adapter", "Observer", "Specialist", "Repository", "Gateway"]).describe("The building block, or pattern (Repository/Gateway)"),
-    owns: import_zod9.z.array(import_zod9.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
-    dependsOn: import_zod9.z.array(import_zod9.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
-    portalType: import_zod9.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
-    basePath: import_zod9.z.string().optional().describe("Portal-only: base path/prefix all the portal's endpoints mount under. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
-    dispatch: import_zod9.z.array(import_zod9.z.object({
-      capability: import_zod9.z.string().describe('Capability name exactly as dispatched at runtime (e.g. "shadow_module.get")'),
-      component: import_zod9.z.string().describe("Component id serving this capability (must also appear under dependsOn/owns)"),
-      method: import_zod9.z.string().describe("Method name on the serving component's interface"),
-      description: import_zod9.z.string().optional()
+    id: import_zod10.z.string().describe("Lowercase identifier for the component"),
+    name: import_zod10.z.string().describe("Human-readable display name"),
+    description: import_zod10.z.string().describe("Responsibility / internal architecture details"),
+    subsystem: import_zod10.z.string().describe("The L1 subsystem ID this component belongs to"),
+    componentType: import_zod10.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Registry", "Adapter", "Observer", "Specialist", "Repository", "Gateway"]).describe("The building block, or pattern (Repository/Gateway)"),
+    owns: import_zod10.z.array(import_zod10.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
+    dependsOn: import_zod10.z.array(import_zod10.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
+    portalType: import_zod10.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    basePath: import_zod10.z.string().optional().describe("Portal-only: base path/prefix all the portal's endpoints mount under. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    dispatch: import_zod10.z.array(import_zod10.z.object({
+      capability: import_zod10.z.string().describe('Capability name exactly as dispatched at runtime (e.g. "shadow_module.get")'),
+      component: import_zod10.z.string().describe("Component id serving this capability (must also appear under dependsOn/owns)"),
+      method: import_zod10.z.string().describe("Method name on the serving component's interface"),
+      description: import_zod10.z.string().optional()
     })).optional().describe("Portal-only: capability \u2192 component.method dispatch table for generic-handle portals. Gives the reachability walker real edges and is validated against target interfaces (UNSERVED_CAPABILITY)."),
-    durability: import_zod9.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
-    emits: import_zod9.z.array(import_zod9.z.object({
-      topic: import_zod9.z.string().describe("Topic/channel name exactly as used on the bus"),
-      event: import_zod9.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
-      description: import_zod9.z.string().optional()
+    durability: import_zod10.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
+    emits: import_zod10.z.array(import_zod10.z.object({
+      topic: import_zod10.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod10.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
+      description: import_zod10.z.string().optional()
     })).optional().describe("Topics this component publishes \u2014 every emitted topic needs a subscriber somewhere in the tree (UNCONSUMED_TOPIC)."),
-    subscribesTo: import_zod9.z.array(import_zod9.z.object({
-      topic: import_zod9.z.string().describe("Topic/channel name exactly as used on the bus"),
-      event: import_zod9.z.string().optional(),
-      description: import_zod9.z.string().optional()
+    subscribesTo: import_zod10.z.array(import_zod10.z.object({
+      topic: import_zod10.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod10.z.string().optional(),
+      description: import_zod10.z.string().optional()
     })).optional().describe("Topics this component consumes (typical on Observers) \u2014 every subscription needs an emitter somewhere in the tree (UNSOURCED_SUBSCRIPTION)."),
-    ext: import_zod9.z.record(import_zod9.z.unknown()).optional().describe('Opaque pack/tool extension data (namespaced keys, e.g. "mypack:priority") \u2014 preserved verbatim, never validated or interpreted by the core')
+    ext: import_zod10.z.record(import_zod10.z.unknown()).optional().describe('Opaque pack/tool extension data (namespaced keys, e.g. "mypack:priority") \u2014 preserved verbatim, never validated or interpreted by the core')
   };
   const componentInputFields = Object.keys(componentInput);
   reg(
@@ -23026,31 +23343,31 @@ NOTICE:
     }
   );
   const interfaceMethodShape = {
-    name: import_zod9.z.string(),
-    description: import_zod9.z.string(),
-    signature: import_zod9.z.string(),
-    returns: import_zod9.z.string(),
-    params: import_zod9.z.array(import_zod9.z.object({
-      name: import_zod9.z.string(),
-      type: import_zod9.z.string().describe('A primitive/builtin or a defined type id (e.g. "billing.Invoice")'),
-      description: import_zod9.z.string().optional(),
-      optional: import_zod9.z.boolean().optional()
+    name: import_zod10.z.string(),
+    description: import_zod10.z.string(),
+    signature: import_zod10.z.string(),
+    returns: import_zod10.z.string(),
+    params: import_zod10.z.array(import_zod10.z.object({
+      name: import_zod10.z.string(),
+      type: import_zod10.z.string().describe('A primitive/builtin or a defined type id (e.g. "billing.Invoice")'),
+      description: import_zod10.z.string().optional(),
+      optional: import_zod10.z.boolean().optional()
     })).optional().describe("Structured parameters \u2014 authoritative for type checking (the prose signature becomes display-only). Strongly preferred."),
-    guarantees: import_zod9.z.array(import_zod9.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
-    effect: import_zod9.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
-    invokedBy: import_zod9.z.object({
-      kind: import_zod9.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
-      caller: import_zod9.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
+    guarantees: import_zod10.z.array(import_zod10.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    effect: import_zod10.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
+    invokedBy: import_zod10.z.object({
+      kind: import_zod10.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
+      caller: import_zod10.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
     }).optional().describe("Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph. Unused-detection seeds the method as an entrypoint so reachability propagates through its narrative (unlike lint.allow); a method the internal walk already reaches is flagged stale (INVOKED_BY_REDUNDANT). Prefer a `register` narrative step when the wiring is internal."),
-    ext: import_zod9.z.record(import_zod9.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
+    ext: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
   };
   const interfaceMethodInputFields = Object.keys(interfaceMethodShape);
   const interfaceInput = {
-    id: import_zod9.z.string().describe('Lowercase identifier prefixed with "i", e.g. "istorage"'),
-    name: import_zod9.z.string().describe("Human-readable contract name"),
-    description: import_zod9.z.string().describe("Contract description and obligations"),
-    component: import_zod9.z.string().describe("The L2 component ID this interface belongs to"),
-    methods: import_zod9.z.array(import_zod9.z.object(interfaceMethodShape)).optional().describe("List of method signature contracts")
+    id: import_zod10.z.string().describe('Lowercase identifier prefixed with "i", e.g. "istorage"'),
+    name: import_zod10.z.string().describe("Human-readable contract name"),
+    description: import_zod10.z.string().describe("Contract description and obligations"),
+    component: import_zod10.z.string().describe("The L2 component ID this interface belongs to"),
+    methods: import_zod10.z.array(import_zod10.z.object(interfaceMethodShape)).optional().describe("List of method signature contracts")
   };
   const interfaceInputFields = Object.keys(interfaceInput);
   reg(
@@ -23115,24 +23432,24 @@ NOTICE:
     {
       description: "Bind concrete wire endpoints to existing L3 interface methods (required for every Portal). Pick `transport` and fill that transport's address fields. Run after sdd_define_interface.",
       inputSchema: {
-        interface: import_zod9.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
-        endpoints: import_zod9.z.array(import_zod9.z.object({
-          method: import_zod9.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
-          transport: import_zod9.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
-          httpMethod: import_zod9.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
-          path: import_zod9.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
-          service: import_zod9.z.string().optional().describe("gRPC: service name"),
-          rpcMethod: import_zod9.z.string().optional().describe("gRPC: rpc method name"),
-          operation: import_zod9.z.enum(["query", "mutation", "subscription"]).optional().describe("GraphQL: operation kind"),
-          field: import_zod9.z.string().optional().describe("GraphQL: root field name"),
-          topic: import_zod9.z.string().optional().describe("MessageBus: topic"),
-          event: import_zod9.z.string().optional().describe("MessageBus: event name"),
-          queue: import_zod9.z.string().optional().describe("MessageBus: optional queue/consumer group"),
-          direction: import_zod9.z.enum(["subscribe", "publish"]).optional().describe("MessageBus: subscribe (default) or publish"),
-          pipe: import_zod9.z.string().optional().describe('NamedPipe: pipe name, e.g. "\\\\.\\pipe\\gk-events"'),
-          channel: import_zod9.z.string().optional().describe("IPC: channel name"),
-          command: import_zod9.z.string().optional().describe("CLI: command/subcommand"),
-          address: import_zod9.z.string().optional().describe("Custom: free-form address")
+        interface: import_zod10.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
+        endpoints: import_zod10.z.array(import_zod10.z.object({
+          method: import_zod10.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
+          transport: import_zod10.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
+          httpMethod: import_zod10.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
+          path: import_zod10.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
+          service: import_zod10.z.string().optional().describe("gRPC: service name"),
+          rpcMethod: import_zod10.z.string().optional().describe("gRPC: rpc method name"),
+          operation: import_zod10.z.enum(["query", "mutation", "subscription"]).optional().describe("GraphQL: operation kind"),
+          field: import_zod10.z.string().optional().describe("GraphQL: root field name"),
+          topic: import_zod10.z.string().optional().describe("MessageBus: topic"),
+          event: import_zod10.z.string().optional().describe("MessageBus: event name"),
+          queue: import_zod10.z.string().optional().describe("MessageBus: optional queue/consumer group"),
+          direction: import_zod10.z.enum(["subscribe", "publish"]).optional().describe("MessageBus: subscribe (default) or publish"),
+          pipe: import_zod10.z.string().optional().describe('NamedPipe: pipe name, e.g. "\\\\.\\pipe\\gk-events"'),
+          channel: import_zod10.z.string().optional().describe("IPC: channel name"),
+          command: import_zod10.z.string().optional().describe("CLI: command/subcommand"),
+          address: import_zod10.z.string().optional().describe("Custom: free-form address")
         })).describe("One binding per method")
       }
     },
@@ -23181,65 +23498,65 @@ NOTICE:
       }
     }
   );
-  const stepNo = () => import_zod9.z.number().int().positive();
-  const labelRef = () => import_zod9.z.string().min(1);
-  const narrativeStepInput = import_zod9.z.object({
+  const stepNo = () => import_zod10.z.number().int().positive();
+  const labelRef = () => import_zod10.z.string().min(1);
+  const narrativeStepInput = import_zod10.z.object({
     stepNumber: stepNo().optional().describe("Defaults to the 1-based array position \u2014 jump fields reference these numbers"),
     label: labelRef().optional().describe("Optional symbolic anchor for this step (unique per narrative). Every jump-by-number field has a *Label twin resolved against these anchors at write time \u2014 prefer labels over hand-counted step numbers"),
-    description: import_zod9.z.string(),
-    type: import_zod9.z.enum(["local", "call", "dispatch", "register", "branch", "switch", "loop", "try", "parallel", "jump", "return", "throw"]),
-    targetComponent: import_zod9.z.string().optional().describe("call/register/dispatch: L2 component id (for dispatch, the Portal routed through)"),
-    targetMethod: import_zod9.z.string().optional().describe("call/register: method name on the target. A register step hands the target method to the runtime as a callback (timer, event listener, shutdown hook): reachability follows the edge, but it is never an invocation \u2014 exempt from call-graph conformance, call-cycle detection, and the durability boot walk"),
-    auth: import_zod9.z.object({ from: import_zod9.z.string(), note: import_zod9.z.string().optional() }).optional().describe("call/dispatch: the credential this step presents to an AUTHED callee Portal and WHERE it loads from (`from`). Opaque form (env:API_KEY, a config key, vault:path) = a design note wairon never resolves; modeled form `component:<id>` references the Adapter/Store that provides the secret and is validated (must resolve, be an Adapter/Store, and be wired to the presenter). Absence on a call into a Portal whose auth \u2260 none warns (PORTAL_AUTH_UNMET). The authenticated call itself should be made by an Adapter (AUTH_PRESENTER_NOT_ADAPTER)."),
-    detach: import_zod9.z.boolean().optional().describe("call/dispatch: fire-and-forget \u2014 issue the call and continue without awaiting the result (no later step consumes it)"),
-    capability: import_zod9.z.string().optional().describe("dispatch: the capability routed through the target Portal's dispatch table (validated against it \u2014 UNSERVED_CAPABILITY)"),
-    assertsGuarantees: import_zod9.z.array(import_zod9.z.string().min(1)).optional().describe("Semantic guarantees this step relies on \u2014 each must be declared in the called method's L3 guarantees (NARRATIVE_SEMANTIC_UNBACKED otherwise). Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
-    assertsInvariants: import_zod9.z.array(import_zod9.z.string()).optional().describe(`Declared entity invariants this step upholds, as "<type-id>.<invariant-id>" refs (UNKNOWN_INVARIANT_REF when unresolved); write-effect methods of the entity's componentClass must carry one per declared invariant (UNASSERTED_INVARIANT)`),
-    condition: import_zod9.z.string().optional().describe("branch / while / doWhile"),
+    description: import_zod10.z.string(),
+    type: import_zod10.z.enum(["local", "call", "dispatch", "register", "branch", "switch", "loop", "try", "parallel", "jump", "return", "throw"]),
+    targetComponent: import_zod10.z.string().optional().describe("call/register/dispatch: L2 component id (for dispatch, the Portal routed through)"),
+    targetMethod: import_zod10.z.string().optional().describe("call/register: method name on the target. A register step hands the target method to the runtime as a callback (timer, event listener, shutdown hook): reachability follows the edge, but it is never an invocation \u2014 exempt from call-graph conformance, call-cycle detection, and the durability boot walk"),
+    auth: import_zod10.z.object({ from: import_zod10.z.string(), note: import_zod10.z.string().optional() }).optional().describe("call/dispatch: the credential this step presents to an AUTHED callee Portal and WHERE it loads from (`from`). Opaque form (env:API_KEY, a config key, vault:path) = a design note wairon never resolves; modeled form `component:<id>` references the Adapter/Store that provides the secret and is validated (must resolve, be an Adapter/Store, and be wired to the presenter). Absence on a call into a Portal whose auth \u2260 none warns (PORTAL_AUTH_UNMET). The authenticated call itself should be made by an Adapter (AUTH_PRESENTER_NOT_ADAPTER)."),
+    detach: import_zod10.z.boolean().optional().describe("call/dispatch: fire-and-forget \u2014 issue the call and continue without awaiting the result (no later step consumes it)"),
+    capability: import_zod10.z.string().optional().describe("dispatch: the capability routed through the target Portal's dispatch table (validated against it \u2014 UNSERVED_CAPABILITY)"),
+    assertsGuarantees: import_zod10.z.array(import_zod10.z.string().min(1)).optional().describe("Semantic guarantees this step relies on \u2014 each must be declared in the called method's L3 guarantees (NARRATIVE_SEMANTIC_UNBACKED otherwise). Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    assertsInvariants: import_zod10.z.array(import_zod10.z.string()).optional().describe(`Declared entity invariants this step upholds, as "<type-id>.<invariant-id>" refs (UNKNOWN_INVARIANT_REF when unresolved); write-effect methods of the entity's componentClass must carry one per declared invariant (UNASSERTED_INVARIANT)`),
+    condition: import_zod10.z.string().optional().describe("branch / while / doWhile"),
     onTrueStep: stepNo().optional().describe("branch: default = next step"),
     onTrueLabel: labelRef().optional().describe("branch: symbolic alternative to onTrueStep"),
     onFalseStep: stepNo().optional().describe("branch: required (or onFalseLabel)"),
     onFalseLabel: labelRef().optional().describe("branch: symbolic alternative to onFalseStep"),
-    on: import_zod9.z.string().optional().describe("switch: the dispatched value"),
-    cases: import_zod9.z.array(import_zod9.z.object({ value: import_zod9.z.string(), step: stepNo().optional(), label: labelRef().optional() })).optional().describe("switch: required; each case targets its region by step number or label"),
+    on: import_zod10.z.string().optional().describe("switch: the dispatched value"),
+    cases: import_zod10.z.array(import_zod10.z.object({ value: import_zod10.z.string(), step: stepNo().optional(), label: labelRef().optional() })).optional().describe("switch: required; each case targets its region by step number or label"),
     defaultStep: stepNo().optional().describe("switch: default = next step"),
     defaultLabel: labelRef().optional().describe("switch: symbolic alternative to defaultStep"),
-    loopKind: import_zod9.z.enum(["forEach", "for", "while", "doWhile"]).optional().describe('loop: default forEach when "over" is set, else while'),
-    over: import_zod9.z.string().optional().describe("loop forEach/for: iteration source"),
+    loopKind: import_zod10.z.enum(["forEach", "for", "while", "doWhile"]).optional().describe('loop: default forEach when "over" is set, else while'),
+    over: import_zod10.z.string().optional().describe("loop forEach/for: iteration source"),
     endStep: stepNo().optional().describe("loop/try: last step of the body region (required, or endLabel)"),
     endLabel: labelRef().optional().describe("loop/try: symbolic alternative to endStep"),
-    catches: import_zod9.z.array(import_zod9.z.object({ error: import_zod9.z.string(), step: stepNo().optional(), label: labelRef().optional() })).optional().describe("try: handler regions, each targeted by step number or label"),
+    catches: import_zod10.z.array(import_zod10.z.object({ error: import_zod10.z.string(), step: stepNo().optional(), label: labelRef().optional() })).optional().describe("try: handler regions, each targeted by step number or label"),
     finallyStep: stepNo().optional().describe("try: first step of the always-runs region"),
     finallyLabel: labelRef().optional().describe("try: symbolic alternative to finallyStep"),
-    branches: import_zod9.z.array(import_zod9.z.object({ step: stepNo().optional(), label: labelRef().optional(), name: import_zod9.z.string().optional() })).optional().describe("parallel: >= 2 arm entries (step number or label), ascending, first = the step after the header; arms are contiguous sub-regions of body next..endStep, joining after endStep once ALL complete"),
+    branches: import_zod10.z.array(import_zod10.z.object({ step: stepNo().optional(), label: labelRef().optional(), name: import_zod10.z.string().optional() })).optional().describe("parallel: >= 2 arm entries (step number or label), ascending, first = the step after the header; arms are contiguous sub-regions of body next..endStep, joining after endStep once ALL complete"),
     toStep: stepNo().optional().describe("jump: required (break/continue/rejoin), or toLabel"),
     toLabel: labelRef().optional().describe("jump: symbolic alternative to toStep \u2014 resolves to the labeled step at write time"),
-    outcome: import_zod9.z.string().optional().describe('return: e.g. "success", "not found"'),
-    error: import_zod9.z.string().optional().describe("throw: the raised error")
+    outcome: import_zod10.z.string().optional().describe('return: e.g. "success", "not found"'),
+    error: import_zod10.z.string().optional().describe("throw: the raised error")
   });
-  const detailEnum = import_zod9.z.enum(["full", "calls-only", "intent"]);
-  const conformanceEnum = import_zod9.z.enum(["declared", "anchored", "off"]);
+  const detailEnum = import_zod10.z.enum(["full", "calls-only", "intent"]);
+  const conformanceEnum = import_zod10.z.enum(["declared", "anchored", "off"]);
   const implMethodShape = {
-    name: import_zod9.z.string(),
+    name: import_zod10.z.string(),
     detail: detailEnum.optional().describe("Detail level for this method (overrides the spec default)"),
-    intent: import_zod9.z.string().optional().describe("detail: intent \u2014 behavioral prose (what it does and how it fails); substitute for a narrative"),
+    intent: import_zod10.z.string().optional().describe("detail: intent \u2014 behavioral prose (what it does and how it fails); substitute for a narrative"),
     conformance: conformanceEnum.optional().describe("Conformance tier for this method (overrides the spec default)"),
-    symbol: import_zod9.z.string().optional().describe("Code-level name realizing this contract method in the sourcePath file, when it legitimately differs from the intent-language contract name (e.g. put realized by saveSnapshot)"),
-    ext: import_zod9.z.record(import_zod9.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim"),
-    narrative: import_zod9.z.array(narrativeStepInput).optional()
+    symbol: import_zod10.z.string().optional().describe("Code-level name realizing this contract method in the sourcePath file, when it legitimately differs from the intent-language contract name (e.g. put realized by saveSnapshot)"),
+    ext: import_zod10.z.record(import_zod10.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim"),
+    narrative: import_zod10.z.array(narrativeStepInput).optional()
   };
   const implMethodInputFields = Object.keys(implMethodShape);
   const implInput = {
-    id: import_zod9.z.string().describe('Lowercase identifier, e.g. "vfs_storage"'),
-    name: import_zod9.z.string().describe("Human-readable implementation name"),
-    description: import_zod9.z.string().describe("Implementation details"),
-    contract: import_zod9.z.string().describe("The L3 Interface contract ID this implements"),
-    sourcePath: import_zod9.z.string().optional().describe("Optional: target source code file path relative to project root"),
-    simPath: import_zod9.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
-    technologies: import_zod9.z.array(import_zod9.z.string()).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"]) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
+    id: import_zod10.z.string().describe('Lowercase identifier, e.g. "vfs_storage"'),
+    name: import_zod10.z.string().describe("Human-readable implementation name"),
+    description: import_zod10.z.string().describe("Implementation details"),
+    contract: import_zod10.z.string().describe("The L3 Interface contract ID this implements"),
+    sourcePath: import_zod10.z.string().optional().describe("Optional: target source code file path relative to project root"),
+    simPath: import_zod10.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
+    technologies: import_zod10.z.array(import_zod10.z.string()).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"]) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
     detail: detailEnum.optional().describe("Spec-level narrative detail default for all methods"),
     conformance: conformanceEnum.optional().describe("Spec-level structural-conformance tier default: declared | anchored | off (omitted = stereotype default: Portal \u2192 anchored, else declared)"),
-    methods: import_zod9.z.array(import_zod9.z.object(implMethodShape)).optional().describe("Method implementations containing L5 narratives")
+    methods: import_zod10.z.array(import_zod10.z.object(implMethodShape)).optional().describe("Method implementations containing L5 narratives")
   };
   const implInputFields = Object.keys(implInput);
   reg(
@@ -23312,29 +23629,29 @@ NOTICE:
     }
   );
   const typeInput = {
-    kind: import_zod9.z.enum(["entity", "value-object"]).describe("entity (owned by a subsystem) or value-object (often system-level shared)"),
-    id: import_zod9.z.string().describe("Lowercase identifier"),
-    name: import_zod9.z.string().describe("Human-readable name"),
-    description: import_zod9.z.string().optional(),
-    subsystem: import_zod9.z.string().optional().describe("Owning subsystem id; omit for a system-level shared value object"),
-    group: import_zod9.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
-    fields: import_zod9.z.array(import_zod9.z.object({
-      name: import_zod9.z.string(),
-      type: import_zod9.z.string(),
-      description: import_zod9.z.string().optional(),
-      optional: import_zod9.z.boolean().optional(),
-      key: import_zod9.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
-      references: import_zod9.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
+    kind: import_zod10.z.enum(["entity", "value-object"]).describe("entity (owned by a subsystem) or value-object (often system-level shared)"),
+    id: import_zod10.z.string().describe("Lowercase identifier"),
+    name: import_zod10.z.string().describe("Human-readable name"),
+    description: import_zod10.z.string().optional(),
+    subsystem: import_zod10.z.string().optional().describe("Owning subsystem id; omit for a system-level shared value object"),
+    group: import_zod10.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
+    fields: import_zod10.z.array(import_zod10.z.object({
+      name: import_zod10.z.string(),
+      type: import_zod10.z.string(),
+      description: import_zod10.z.string().optional(),
+      optional: import_zod10.z.boolean().optional(),
+      key: import_zod10.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
+      references: import_zod10.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
     })).optional().describe('Data fields (type is a primitive or a qualified type id, e.g. "billing.Invoice")'),
-    methods: import_zod9.z.array(import_zod9.z.object({ name: import_zod9.z.string(), signature: import_zod9.z.string(), returns: import_zod9.z.string(), description: import_zod9.z.string().optional() })).optional().describe("Pure intrinsic methods only"),
-    componentClass: import_zod9.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
-    invariants: import_zod9.z.array(import_zod9.z.object({
-      id: import_zod9.z.string().describe("Stable invariant id, unique within the entity"),
-      description: import_zod9.z.string().describe("The property that must hold, stated precisely")
+    methods: import_zod10.z.array(import_zod10.z.object({ name: import_zod10.z.string(), signature: import_zod10.z.string(), returns: import_zod10.z.string(), description: import_zod10.z.string().optional() })).optional().describe("Pure intrinsic methods only"),
+    componentClass: import_zod10.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
+    invariants: import_zod10.z.array(import_zod10.z.object({
+      id: import_zod10.z.string().describe("Stable invariant id, unique within the entity"),
+      description: import_zod10.z.string().describe("The property that must hold, stated precisely")
     })).optional().describe("Declared domain invariants (entities): every write-effect method of the componentClass must carry a narrative step asserting each (assertsInvariants) \u2014 declarations checked, enforcement never proven"),
-    database: import_zod9.z.string().optional().describe("Optional database id for table-schema types"),
-    table: import_zod9.z.string().optional().describe("Optional database table name for table-schema types"),
-    linkedEntity: import_zod9.z.string().optional().describe("Optional logical entity id represented by this table-schema type")
+    database: import_zod10.z.string().optional().describe("Optional database id for table-schema types"),
+    table: import_zod10.z.string().optional().describe("Optional database table name for table-schema types"),
+    linkedEntity: import_zod10.z.string().optional().describe("Optional logical entity id represented by this table-schema type")
   };
   const typeInputFields = Object.keys(typeInput);
   reg(
@@ -23405,8 +23722,8 @@ NOTICE:
     {
       description: "Validate the SDD spec tree, checking parent references, contract compatibility, narratives, and component type boundaries. Supports scoping and recursion controls.",
       inputSchema: {
-        subsystem: import_zod9.z.string().optional().describe("Only validate the specified subsystem (granular)"),
-        recursive: import_zod9.z.boolean().optional().describe("Whether to recursively validate subprojects (default: true)")
+        subsystem: import_zod10.z.string().optional().describe("Only validate the specified subsystem (granular)"),
+        recursive: import_zod10.z.boolean().optional().describe("Whether to recursively validate subprojects (default: true)")
       }
     },
     ({ subsystem, recursive }) => {
@@ -23436,8 +23753,8 @@ NOTICE:
     {
       description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back.`,
       inputSchema: {
-        kind: import_zod9.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
-        id: import_zod9.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")')
+        kind: import_zod10.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
+        id: import_zod10.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")')
       }
     },
     ({ kind, id }) => {
@@ -23481,8 +23798,8 @@ NOTICE:
     {
       description: "Delete a specification file from the spec tree and clean up any empty parent directories.",
       inputSchema: {
-        kind: import_zod9.z.enum(["subsystem", "component", "interface", "implementation", "type"]).describe("The kind of spec to delete"),
-        id: import_zod9.z.string().describe("The ID of the spec to delete")
+        kind: import_zod10.z.enum(["subsystem", "component", "interface", "implementation", "type"]).describe("The kind of spec to delete"),
+        id: import_zod10.z.string().describe("The ID of the spec to delete")
       }
     },
     ({ kind, id }) => {
@@ -23519,9 +23836,9 @@ NOTICE:
     {
       description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps.",
       inputSchema: {
-        kind: import_zod9.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project gateway surface, each entry {id, name, subsystem, component, type, details, audience: project|department|instance|partner|external}; id is informational)"),
-        id: import_zod9.z.string().describe("The ID of the spec to update (namespaced if needed)"),
-        delta: import_zod9.z.record(import_zod9.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", invariants and patterns by "id", lint.allow by "code", boundaries by "name", globalRequirements by "description". Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative; deleting a step that is a jump target is rejected until the referrers are retargeted. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, reason }] }" to silence a WARNING code on this spec only (errors always surface; stale allows are flagged).`)
+        kind: import_zod10.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project gateway surface, each entry {id, name, subsystem, component, type, details, audience: project|department|instance|partner|external}; id is informational)"),
+        id: import_zod10.z.string().describe("The ID of the spec to update (namespaced if needed)"),
+        delta: import_zod10.z.record(import_zod10.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", invariants and patterns by "id", lint.allow by "code", boundaries by "name", globalRequirements by "description". Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative; deleting a step that is a jump target is rejected until the referrers are retargeted. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, reason }] }" to silence a WARNING code on this spec only (errors always surface; stale allows are flagged).`)
       }
     },
     ({ kind, id, delta }) => {
@@ -23543,8 +23860,8 @@ NOTICE:
     {
       description: "Get the completeness status dashboard of the SDD spec tree. Supports scoping and recursion controls.",
       inputSchema: {
-        subsystem: import_zod9.z.string().optional().describe("Only show status for the specified subsystem"),
-        recursive: import_zod9.z.boolean().optional().describe("Whether to recursively load subprojects (default: true)")
+        subsystem: import_zod10.z.string().optional().describe("Only show status for the specified subsystem"),
+        recursive: import_zod10.z.boolean().optional().describe("Whether to recursively load subprojects (default: true)")
       }
     },
     ({ subsystem, recursive }) => {
@@ -23578,7 +23895,7 @@ NOTICE:
     {
       description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence \u2014 the dynamic replacement for generated per-component agent files. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
       inputSchema: {
-        agentId: import_zod9.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
+        agentId: import_zod10.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
       }
     },
     ({ agentId }) => {
@@ -23615,22 +23932,22 @@ NOTICE:
     reg(server, "sdd_host_initialize_project", {
       description: "Hosted project lifecycle (execute-primary): initialize a new hosted project into its REQUIRED owner organization unit (with an optional profile selection). Executes directly when your resolved permission is yes; when it is approval, a pending approval request is created instead.",
       inputSchema: {
-        id: import_zod9.z.string().describe("Requested project id"),
-        displayName: import_zod9.z.string().optional(),
-        description: import_zod9.z.string().optional(),
-        ownerUnitId: import_zod9.z.string().describe("REQUIRED organization unit that owns the new project (every project is placed at creation)"),
-        environment: import_zod9.z.string().optional()
+        id: import_zod10.z.string().describe("Requested project id"),
+        displayName: import_zod10.z.string().optional(),
+        description: import_zod10.z.string().optional(),
+        ownerUnitId: import_zod10.z.string().describe("REQUIRED organization unit that owns the new project (every project is placed at creation)"),
+        environment: import_zod10.z.string().optional()
       }
     }, hostedStub);
     reg(server, "sdd_host_get_approval_status", {
       description: "Hosted project lifecycle: read the status of one of your approval requests.",
-      inputSchema: { requestId: import_zod9.z.string() }
+      inputSchema: { requestId: import_zod10.z.string() }
     }, hostedStub);
     reg(server, "sdd_host_await_approval", {
       description: "Hosted project lifecycle: long-poll one of YOUR approval requests until it is decided (approved requests auto-execute, so an approval resolves as completed) or the timeout elapses. Returns the request in its current state.",
       inputSchema: {
-        requestId: import_zod9.z.string(),
-        timeoutSeconds: import_zod9.z.number().optional().describe("How long to wait server-side (clamped; 0 returns the current state immediately)")
+        requestId: import_zod10.z.string(),
+        timeoutSeconds: import_zod10.z.number().optional().describe("How long to wait server-side (clamped; 0 returns the current state immediately)")
       }
     }, hostedStub);
     reg(server, "sdd_landscape_list_reachable_projects", {
@@ -23639,7 +23956,7 @@ NOTICE:
     }, hostedStub);
     reg(server, "sdd_landscape_list_reachable_project_interfaces", {
       description: "Hosted landscape: redacted, audience-filtered public interface summaries of one reachable target project (Forbidden outside the reachable set; private by default).",
-      inputSchema: { projectId: import_zod9.z.string().describe("The reachable target project id") }
+      inputSchema: { projectId: import_zod10.z.string().describe("The reachable target project id") }
     }, hostedStub);
     reg(server, "sdd_landscape_list_visible_surfaces", {
       description: "Hosted landscape: the visibility-resolved discovery catalog for the BOUND project \u2014 every target the organization unit graph exposes to it (open-within-tenant, closed groups hidden, exposeTo grants honored), with audience distance and audience-filtered summaries. No relation required.",
@@ -23647,7 +23964,7 @@ NOTICE:
     }, hostedStub);
     reg(server, "sdd_landscape_get_project_surface", {
       description: `Hosted landscape: fetch a visible target project's CONTRACT-GRADE surface snapshot (full method contracts, dispatch tables, type closure) at your audience-distance ceiling, origin "exchanged" \u2014 save it under .wai/surfaces/ (wairon surface import) so your adapters validate against the declared contract.`,
-      inputSchema: { projectId: import_zod9.z.string().describe("The visible target project id") }
+      inputSchema: { projectId: import_zod10.z.string().describe("The visible target project id") }
     }, hostedStub);
     reg(server, "sdd_host_pack_list", {
       description: "Hosted project ops: list the BOUND project's registered extension packs (requires project:read over it).",
@@ -23656,8 +23973,8 @@ NOTICE:
     reg(server, "sdd_host_pack_install", {
       description: "Hosted project ops: install a DECLARATIVE extension pack (profiles + language/platform tables \u2014 never rule/code packs) into the BOUND project (requires project:admin over it).",
       inputSchema: {
-        name: import_zod9.z.string().describe("Pack name (letters, digits, dot, underscore, hyphen)"),
-        content: import_zod9.z.string().describe("The declarative pack YAML content")
+        name: import_zod10.z.string().describe("Pack name (letters, digits, dot, underscore, hyphen)"),
+        content: import_zod10.z.string().describe("The declarative pack YAML content")
       }
     }, hostedStub);
     reg(server, "sdd_host_policy_evaluate", {
@@ -23670,13 +23987,13 @@ NOTICE:
     }, hostedStub);
     reg(server, "sdd_host_produce", {
       description: "Hosted project ops: run a configured producer projection (Notion/Miro) of the BOUND project to the named target (requires project:admin over it).",
-      inputSchema: { target: import_zod9.z.string().describe("The configured producer target (e.g. notion, miro)") }
+      inputSchema: { target: import_zod10.z.string().describe("The configured producer target (e.g. notion, miro)") }
     }, hostedStub);
     reg(server, "sdd_host_commit_project", {
       description: "Hosted project ops: publish a DELIBERATE, .wai/-scoped commit+push of the BOUND project's specs to its bound repository (commit = local save, push = the actual backup; a clean scope publishes nothing). The data plane binds ONE project, so there is no project argument. Requires project:write over it.",
       inputSchema: {
-        subsystem: import_zod9.z.string().optional().describe("Narrow staging to .wai/specs/<subsystem>/ (a convenience \u2014 git history stays per-repo)"),
-        message: import_zod9.z.string().optional().describe("Commit message; defaults to a timestamped wairon message")
+        subsystem: import_zod10.z.string().optional().describe("Narrow staging to .wai/specs/<subsystem>/ (a convenience \u2014 git history stays per-repo)"),
+        message: import_zod10.z.string().optional().describe("Commit message; defaults to a timestamped wairon message")
       }
     }, hostedStub);
     reg(server, "sdd_host_export_tree", {
@@ -23686,8 +24003,8 @@ NOTICE:
     reg(server, "sdd_host_import_tree", {
       description: "Hosted spec-tree transfer: REPLACE the BOUND project's spec tree from a base64 .waitree archive. Requires project:admin over the project (strictly above project:write \u2014 this replaces the whole design, not one spec). Refuses an occupied destination unless replaceExisting is set, always refuses executable entries (rule/code packs install only through the trusted filesystem), and moves the previous tree aside to a backup whose path is returned.",
       inputSchema: {
-        archiveBase64: import_zod9.z.string().describe("The .waitree archive bytes, base64-encoded"),
-        replaceExisting: import_zod9.z.boolean().optional().describe("Replace a tree already present (backed up first); without it an occupied destination is refused")
+        archiveBase64: import_zod10.z.string().describe("The .waitree archive bytes, base64-encoded"),
+        replaceExisting: import_zod10.z.boolean().optional().describe("Replace a tree already present (backed up first); without it an occupied destination is refused")
       }
     }, hostedStub);
   }
@@ -23732,13 +24049,13 @@ async function startMcpServer() {
   } catch {
   }
 }
-var import_mcp, import_stdio, import_zod9, import_types3, fs20, path30, import_url, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
+var import_mcp, import_stdio, import_zod10, import_types3, fs20, path30, import_url, SERVER_BUILD_STAMP, STALE_SERVER_WARNING, SPEC_WRITE_TOOLS, listChangedEmitters, STORE_MANAGED_FIELDS, ALWAYS_CARRIED_FIELDS, SKILL_RESOURCE_MIME, AGENT_BRIEF_SCHEME;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
     import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
     import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-    import_zod9 = require("zod");
+    import_zod10 = require("zod");
     import_types3 = require("@modelcontextprotocol/sdk/types.js");
     fs20 = __toESM(require("fs"));
     path30 = __toESM(require("path"));
@@ -23758,6 +24075,7 @@ var init_server = __esm({
     init_authoring();
     init_variants();
     init_agent_resolver();
+    init_budget_policy();
     init_surfaces();
     SERVER_BUILD_STAMP = captureBuildStamp(__filename);
     STALE_SERVER_WARNING = "\n\n\u26A0 STALE SERVER: the wairon build on disk changed after this MCP server started. Restart the MCP session (e.g. /mcp reconnect) before further spec edits \u2014 writes through a stale server can silently drop fields introduced by newer schemas.";
@@ -24348,8 +24666,39 @@ var WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \
 // src/exporters/claude.ts
 var path22 = __toESM(require("path"));
 init_fs();
+var MODEL_BY_TIER = {
+  small: "haiku",
+  standard: "sonnet",
+  large: "opus",
+  frontier: "fable"
+};
+var TOOLS_BY_CLASS = {
+  "read-only": ["Read", "Grep", "Glob"],
+  implement: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
+  orchestrate: ["Agent", "SendMessage", "TodoWrite"],
+  // `full` means "inherit everything" — expressed by omitting the field.
+  full: void 0
+};
+function toolsFor(budget) {
+  const base = TOOLS_BY_CLASS[budget.toolClass];
+  if (!base) return void 0;
+  if (budget.allowNestedDelegation && !base.includes("Agent")) {
+    return [...base, "Agent"];
+  }
+  if (!budget.allowNestedDelegation) {
+    return base.filter((t) => t !== "Agent");
+  }
+  return base;
+}
+function mcpServersFor(access) {
+  return access === "none" ? "[]" : void 0;
+}
+function yamlScalar(value) {
+  return /[:#\n]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+}
 var ClaudeExporter = class {
-  constructor() {
+  constructor(options = {}) {
+    this.options = options;
     this.targetType = "claude";
   }
   outputPath(ctx) {
@@ -24358,18 +24707,22 @@ var ClaudeExporter = class {
     return path22.resolve(projectRoot2, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
-    const { agent, renderedInstructions } = ctx;
+    const { agent, renderedInstructions, budget } = ctx;
     const filePath = this.outputPath(ctx);
-    const safeDescription = agent.description.includes(":") || agent.description.includes("#") ? `"${agent.description.replace(/"/g, '\\"')}"` : agent.description;
-    const content = [
-      "---",
+    const frontmatter = [
       `name: ${agent.name}`,
-      `description: ${safeDescription}`,
-      "---",
-      "",
-      renderedInstructions,
-      ""
-    ].join("\n");
+      `description: ${yamlScalar(agent.description)}`
+    ];
+    if (budget && this.options.emitBudget) {
+      if (budget.modelTier) frontmatter.push(`model: ${MODEL_BY_TIER[budget.modelTier]}`);
+      if (budget.effort) frontmatter.push(`effort: ${budget.effort}`);
+      if (budget.maxTurns !== void 0) frontmatter.push(`maxTurns: ${budget.maxTurns}`);
+      const tools = toolsFor(budget);
+      if (tools) frontmatter.push(`tools: ${tools.join(", ")}`);
+      const servers = mcpServersFor(budget.mcp);
+      if (servers) frontmatter.push(`mcpServers: ${servers}`);
+    }
+    const content = ["---", ...frontmatter, "---", "", renderedInstructions, ""].join("\n");
     const changed = writeFileIfChanged(filePath, content);
     return { outputPath: filePath, content, unchanged: !changed };
   }
@@ -24912,12 +25265,14 @@ init_extensions();
 init_agent_resolver();
 
 // src/exporters/generate.ts
+init_execution_profile();
+init_budget_policy();
 init_fs();
 
 // src/exporters/registry.ts
 init_errors();
 var EXPORTERS = /* @__PURE__ */ new Map([
-  ["claude", new ClaudeExporter()],
+  ["claude", new ClaudeExporter({ emitBudget: true })],
   ["gemini", new GeminiExporter()],
   ["agy", new GeminiExporter()],
   ["cursor", new ClaudeExporter()],
@@ -24941,6 +25296,11 @@ function generateAgent(agent, projectConfig, options = {}) {
   const rendered = `${WAIRON_MANAGED_BANNER}
 ${composeAgentBrief(agent.id).instructions}`;
   const results = [];
+  const budget = resolveBudget(
+    deriveExecutionProfile(agent),
+    projectConfig.execution,
+    agent.id
+  );
   for (const agentTarget of agent.targets) {
     const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
     if (!targetConfig) continue;
@@ -24954,7 +25314,8 @@ ${composeAgentBrief(agent.id).instructions}`;
         template,
         renderedInstructions: rendered,
         projectRoot: projectRoot2,
-        target: targetConfig
+        target: targetConfig,
+        budget
       }));
     }
   }
@@ -25354,6 +25715,9 @@ function buildProjectConfig(name, targets, now, projectType) {
     name,
     projectType,
     targets,
+    // New projects start with budgets off — the same output a project got
+    // before execution budgets existed. Opt in with `execution.tier`.
+    execution: { tier: "off", overrides: {} },
     rules: {
       noOverlappingOwnership: true,
       requireOwnedPaths: true,
@@ -41509,10 +41873,10 @@ async function runSurface(action, options = {}) {
     case "generate-children": {
       const written = generateChildSnapshots();
       if (!written.length) {
-        logger.info("No chained child projects found \u2014 nothing to generate.");
+        logger.info("Delivered surfaces are already up to date \u2014 nothing rewritten.");
         return;
       }
-      logger.success(`Wrote the family surface into ${written.length} chained child project(s):`);
+      logger.success(`Updated ${written.length} delivered surface(s):`);
       for (const p of written) logger.info(`  ${p}`);
       return;
     }
@@ -42097,6 +42461,113 @@ function report(outcome) {
   }
 }
 
+// src/cli/index.ts
+init_budget_policy();
+
+// src/commands/execution.ts
+var import_chalk21 = __toESM(require("chalk"));
+init_logger();
+init_errors();
+init_loader();
+init_agent_resolver();
+init_execution_profile();
+init_budget_policy();
+init_execution();
+function assertInitialized() {
+  if (!isProjectInitialized()) {
+    throw new WaironError("Not a wairon project \u2014 run `wairon init` first.");
+  }
+}
+var TIER_COLOR = {
+  small: import_chalk21.default.green,
+  standard: import_chalk21.default.cyan,
+  large: import_chalk21.default.yellow,
+  frontier: import_chalk21.default.red
+};
+async function showExecution() {
+  assertInitialized();
+  const config = loadProjectConfig();
+  const tier = config.execution.tier;
+  logger.header("Execution budgets");
+  logger.info(`Tier: ${tier === "off" ? import_chalk21.default.gray(tier) : import_chalk21.default.bold(tier)}`);
+  logger.info(import_chalk21.default.gray(BUDGET_TIER_DESCRIPTIONS[tier]));
+  if (tier === "off") {
+    logger.blank();
+    logger.info("No budgets are derived. Generated agent files and briefs carry");
+    logger.info("what they carried before this feature existed.");
+    logger.info(`Enable with ${import_chalk21.default.bold("wairon execution set-tier default")}.`);
+    return;
+  }
+  const agents = resolveAgentTopology();
+  if (agents.length === 0) {
+    logger.blank();
+    logger.warn("No agents in the topology yet \u2014 nothing to budget.");
+    return;
+  }
+  logger.blank();
+  const rows = agents.map((agent) => {
+    const profile = deriveExecutionProfile(agent);
+    const budget = resolveBudget(profile, config.execution, agent.id);
+    return { agent, profile, budget };
+  });
+  const idWidth = Math.max(...rows.map((r) => r.agent.id.length));
+  for (const { agent, profile, budget } of rows) {
+    if (!budget) continue;
+    const model = budget.modelTier ? TIER_COLOR[budget.modelTier](budget.modelTier.padEnd(9)) : import_chalk21.default.gray("(inherit)");
+    const overridden = config.execution.overrides[agent.id] ? import_chalk21.default.magenta(" *override") : "";
+    logger.info(
+      `  ${agent.id.padEnd(idWidth)}  ${model} ${import_chalk21.default.gray(
+        `${budget.toolClass}, ${budget.maxTurns ?? "-"} turns, mcp:${budget.mcp}${budget.effort ? `, effort:${budget.effort}` : ""}`
+      )}${overridden}`
+    );
+    logger.info(`  ${" ".repeat(idWidth)}  ${import_chalk21.default.gray(profile.rationale)}`);
+  }
+  const overrideCount = Object.keys(config.execution.overrides).length;
+  if (overrideCount > 0) {
+    logger.blank();
+    logger.info(import_chalk21.default.magenta(`${overrideCount} per-agent override(s) in .wai/project.yaml.`));
+  }
+  const frontier = rows.filter((r) => r.budget?.modelTier === "frontier");
+  if (frontier.length > 0) {
+    logger.blank();
+    logger.warn(
+      `${frontier.length} agent(s) are pinned to the frontier tier by override: ${frontier.map((r) => r.agent.id).join(", ")}.`
+    );
+    logger.warn(
+      "Frontier is a sparring partner for questions the specs do not settle, not an owner tier. An owner that genuinely needs it usually points at a component doing too much \u2014 consider splitting it."
+    );
+  }
+}
+async function setExecutionTier(raw) {
+  assertInitialized();
+  const parsed = BudgetTierSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new WaironError(
+      `Unknown tier "${raw}" \u2014 expected one of: ${BudgetTierSchema.options.join(", ")}.`
+    );
+  }
+  const tier = parsed.data;
+  const config = loadProjectConfig();
+  const previous = config.execution.tier;
+  if (previous === tier) {
+    logger.info(`Execution tier is already ${import_chalk21.default.bold(tier)}.`);
+    return;
+  }
+  config.execution = { ...config.execution, tier };
+  saveProjectConfig(config);
+  logger.success(`Execution tier: ${import_chalk21.default.gray(previous)} \u2192 ${import_chalk21.default.bold(tier)}`);
+  logger.info(BUDGET_TIER_DESCRIPTIONS[tier]);
+  logger.blank();
+  logger.info(`Run ${import_chalk21.default.bold("wairon execution show")} to see what each agent now gets,`);
+  logger.info(`then ${import_chalk21.default.bold("wairon generate")} to write it into agent files (if materialized).`);
+  if (tier === "trade" || tier === "aggressive") {
+    logger.blank();
+    logger.warn(
+      "This tier trades quality for cost. Measure on real work before keeping it \u2014 a cheaper delegation that needs a second round trip is not cheaper."
+    );
+  }
+}
+
 // src/cli/index.ts
 cleanStaleBinary();
 var program = new import_commander.Command();
@@ -42167,7 +42638,7 @@ async function runLock2(options) {
   const childPaths = generateChildSnapshots();
   if (childPaths.length > 0) {
     logger.blank();
-    logger.success(`Regenerated the family/sibling surfaces into ${childPaths.length} chained child snapshot(s):`);
+    logger.success(`Updated ${childPaths.length} delivered surface(s) in the chained children:`);
     for (const p of childPaths) logger.info(`  ${p}`);
   }
   logger.blank();
@@ -42253,6 +42724,13 @@ async function runPack(action, arg, opts = {}) {
   else if (action === "sync") await syncPacks();
   else throw new WaironError("unknown pack action (expected init | build | install | uninstall | which | use | unuse | bundle | sync | add | list | remove)");
 }
+var executionCmd = program.command("execution").description("Execution budgets: what each agent's work is like and the model/turn/tool allowance it earns");
+executionCmd.command("show").alias("ls").description("Show the current budget tier and the derived allowance for every agent").action(async () => {
+  await showExecution();
+});
+executionCmd.command("set-tier <tier>").description("Set the aggressiveness dial: off | free | default | trade | aggressive").action(async (tier) => {
+  await setExecutionTier(tier);
+});
 var rulesCmd = program.command("rules").description("The SDD conformance rule registry (the architecture linter)");
 rulesCmd.command("list").alias("ls").description("List every conformance rule, its issue codes, default severities, and project overrides").action(async () => {
   await runRules();
@@ -42355,6 +42833,13 @@ async function runAgent(action, id) {
         logger.info("Read paths:");
         for (const p of brief.readPaths) logger.info(`  ${p}`);
       }
+      if (brief.budget && brief.profile) {
+        logger.blank();
+        logger.info("Execution budget (advisory \u2014 apply when spawning):");
+        for (const line2 of describeBudget(brief.profile, brief.budget)) {
+          logger.info(`  ${line2.replace(/^- \*\*(.+?)\*\*: /, "$1: ")}`);
+        }
+      }
       logger.blank();
       console.log(brief.instructions);
       return;