@nathapp/nax 0.69.9 → 0.70.0-canary.1

package/dist/nax.js

@@ -16705,7 +16705,8 @@ var init_schemas_model = __esm(() => {
   ConfiguredModelSchema = exports_external.union([ModelTierSchema, ConfiguredModelObjectSchema]);
   TierConfigSchema = exports_external.object({
     tier: exports_external.string().min(1, "Tier name must be non-empty"),
-    attempts: exports_external.number().int().min(1).max(20, { message: "attempts must be 1-20" })
+    attempts: exports_external.number().int().min(1).max(20, { message: "attempts must be 1-20" }),
+    agent: exports_external.string().min(1, { message: "agent must be non-empty" }).optional()
   });
 });
 
@@ -17000,7 +17001,7 @@ var init_schemas_execution = __esm(() => {
 });
 
 // src/config/schemas-infra.ts
-var PlanConfigSchema, AcceptanceFixConfigSchema, AcceptanceConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PromptAuditConfigSchema, AgentFallbackConfigSchema, DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG, AgentIdleWatchdogConfigSchema, AgentAcpConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, CuratorThresholdsSchema, CuratorConfigSchema;
+var PlanConfigSchema, AcceptanceFixConfigSchema, AcceptanceConfigSchema, LlmRoutingConfigSchema, AgentRoutingProfileSchema, AgentRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PromptAuditConfigSchema, AgentFallbackConfigSchema, DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG, AgentIdleWatchdogConfigSchema, AgentAcpConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, CuratorThresholdsSchema, CuratorConfigSchema;
 var init_schemas_infra = __esm(() => {
   init_zod();
   init_schemas_model();
@@ -17054,9 +17055,57 @@ var init_schemas_infra = __esm(() => {
     retries: exports_external.number().int().min(0, { message: "llm.retries must be >= 0" }).optional(),
     retryDelayMs: exports_external.number().int().min(0, { message: "llm.retryDelayMs must be >= 0" }).optional()
   });
+  AgentRoutingProfileSchema = exports_external.object({
+    id: exports_external.string().min(1),
+    target: exports_external.object({
+      agent: exports_external.string().min(1),
+      model: ModelTierSchema
+    }),
+    strengths: exports_external.array(exports_external.string().min(1)).min(1),
+    weaknesses: exports_external.array(exports_external.string().min(1)).optional(),
+    costTier: exports_external.enum(["low", "medium", "high"]).optional(),
+    affinity: exports_external.object({
+      taskTypes: exports_external.array(exports_external.string().min(1)).optional(),
+      domains: exports_external.array(exports_external.string().min(1)).optional()
+    }).optional()
+  });
+  AgentRoutingConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    strategy: exports_external.enum(["off", "llm"]).default("off"),
+    default: exports_external.string().optional(),
+    profiles: exports_external.array(AgentRoutingProfileSchema).default([])
+  }).superRefine((cfg, ctx) => {
+    const ids = cfg.profiles.map((p) => p.id);
+    const seen = new Set;
+    for (const [i, id] of ids.entries()) {
+      if (seen.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["profiles", i, "id"],
+          message: `Duplicate profile id "${id}"`
+        });
+      }
+      seen.add(id);
+    }
+    if (cfg.default !== undefined && !ids.includes(cfg.default)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["default"],
+        message: `Default profile "${cfg.default}" is not in the profiles list`
+      });
+    }
+    if (cfg.strategy === "llm" && cfg.profiles.length === 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["strategy"],
+        message: 'strategy "llm" requires at least one profile in routing.agents.profiles'
+      });
+    }
+  });
   RoutingConfigSchema = exports_external.object({
     strategy: exports_external.enum(["keyword", "llm"]),
-    llm: LlmRoutingConfigSchema.optional()
+    llm: LlmRoutingConfigSchema.optional(),
+    agents: AgentRoutingConfigSchema.default({ enabled: true, strategy: "off", profiles: [] })
   });
   OptimizerConfigSchema = exports_external.object({
     enabled: exports_external.boolean(),
@@ -17313,7 +17362,8 @@ var init_schemas3 = __esm(() => {
         cacheDecisions: true,
         mode: "hybrid",
         timeoutMs: 30000
-      }
+      },
+      agents: { enabled: true, strategy: "off", profiles: [] }
     }),
     execution: ExecutionConfigSchema.default({
       maxIterations: 10,
@@ -17618,6 +17668,48 @@ var init_schemas3 = __esm(() => {
   }).refine((data) => data.version === 1, {
     message: "Invalid version: expected 1",
     path: ["version"]
+  }).superRefine((data, ctx) => {
+    const tierOrder = data.autoMode?.escalation?.tierOrder ?? [];
+    const knownAgents = Object.keys(data.models ?? {});
+    for (const [i, rung] of tierOrder.entries()) {
+      if (rung.agent === undefined)
+        continue;
+      if (!knownAgents.includes(rung.agent)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["autoMode", "escalation", "tierOrder", i, "agent"],
+          message: `Agent "${rung.agent}" is not defined in config.models (known: ${knownAgents.join(", ")})`
+        });
+      } else {
+        const agentTiers = data.models?.[rung.agent] ?? {};
+        if (!(rung.tier in agentTiers)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["autoMode", "escalation", "tierOrder", i, "tier"],
+            message: `Tier "${rung.tier}" is not defined for agent "${rung.agent}" in config.models`
+          });
+        }
+      }
+    }
+    const profiles = data.routing.agents?.profiles ?? [];
+    for (const [pi, profile] of profiles.entries()) {
+      const { agent: pAgent, model: pModel } = profile.target;
+      const hasMatchingRung = tierOrder.some((r) => r.tier === pModel && r.agent === pAgent);
+      if (!hasMatchingRung) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["routing", "agents", "profiles", pi, "target"],
+          message: `Profile "${profile.id}" target (${pAgent}@${pModel}) has no matching rung in autoMode.escalation.tierOrder \u2014 escalation from this profile has no defined path. To fix: agent-qualify the ladder by adding a rung { "tier": "${pModel}", "agent": "${pAgent}", "attempts": <n> } (and an agent on every other rung) to autoMode.escalation.tierOrder.`
+        });
+      }
+      if (!knownAgents.includes(pAgent)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["routing", "agents", "profiles", pi, "target", "agent"],
+          message: `Profile "${profile.id}" target agent "${pAgent}" is not defined in config.models`
+        });
+      }
+    }
   });
 });
 
@@ -19140,7 +19232,7 @@ var reviewConfigSelector, planConfigSelector, decomposeConfigSelector, rectifyCo
 var init_selectors = __esm(() => {
   reviewConfigSelector = pickSelector("review", "review", "debate", "models", "execution", "project", "quality", "agent");
   planConfigSelector = pickSelector("plan", "plan", "debate", "agent", "project");
-  decomposeConfigSelector = pickSelector("decompose", "plan", "agent");
+  decomposeConfigSelector = pickSelector("decompose", "plan", "agent", "routing");
   rectifyConfigSelector = pickSelector("rectify", "execution");
   acceptanceConfigSelector = pickSelector("acceptance", "acceptance");
   acceptanceFixConfigSelector = pickSelector("acceptance-fix", "acceptance", "execution");
@@ -19452,6 +19544,7 @@ __export(exports_config, {
   acceptanceFixConfigSelector: () => acceptanceFixConfigSelector,
   acceptanceConfigSelector: () => acceptanceConfigSelector,
   VALID_TEST_STRATEGIES: () => VALID_TEST_STRATEGIES,
+  TierConfigSchema: () => TierConfigSchema,
   TddConfigSchema: () => TddConfigSchema,
   THREE_SESSION_STRATEGIES: () => THREE_SESSION_STRATEGIES,
   TEST_STRATEGY_GUIDE: () => TEST_STRATEGY_GUIDE,
@@ -19467,12 +19560,15 @@ __export(exports_config, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   ConfiguredModelSchema: () => ConfiguredModelSchema,
   COMPLEXITY_GUIDE: () => COMPLEXITY_GUIDE,
+  AgentRoutingProfileSchema: () => AgentRoutingProfileSchema,
+  AgentRoutingConfigSchema: () => AgentRoutingConfigSchema,
   AcceptanceConfigSchema: () => AcceptanceConfigSchema,
   AC_QUALITY_RULES: () => AC_QUALITY_RULES
 });
 var init_config = __esm(() => {
   init_schema();
   init_schemas_model();
+  init_schemas_infra();
   init_schemas_debate();
   init_schemas_execution();
   init_loader();
@@ -22826,8 +22922,12 @@ async function _detectLanguageImpl(workdir, pkg) {
     };
     if ("typescript" in allDeps)
       return "typescript";
+    if (await deps.fileExists(join5(workdir, "tsconfig.json")))
+      return "typescript";
     return "javascript";
   }
+  if (await deps.fileExists(join5(workdir, "tsconfig.json")))
+    return "typescript";
   return;
 }
 function detectType(pkg) {
@@ -29883,6 +29983,73 @@ var init_builder = __esm(() => {
   };
 });
 
+// src/context/greenfield.ts
+async function gitLsFiles2(workdir) {
+  try {
+    const proc = _greenfieldDeps.spawn(["git", "ls-files"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0)
+      return null;
+    const output = await new Response(proc.stdout).text();
+    return output.split(`
+`).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+async function hasTestFiles(workdir, patterns) {
+  const files = await gitLsFiles2(workdir);
+  if (files !== null) {
+    return files.some((f) => isTestFileByPatterns(f, patterns));
+  }
+  for (const pattern of patterns) {
+    const g = new Bun.Glob(pattern);
+    for await (const path3 of g.scan({ cwd: workdir, onlyFiles: true })) {
+      if (!path3.split("/").some((seg) => IGNORE_DIRS.has(seg))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function isGreenfieldStory(_story, workdir, patterns) {
+  try {
+    return !await hasTestFiles(workdir, patterns ?? DEFAULT_TEST_FILE_PATTERNS);
+  } catch {
+    return false;
+  }
+}
+var _greenfieldDeps, IGNORE_DIRS;
+var init_greenfield = __esm(() => {
+  init_test_runners();
+  _greenfieldDeps = {
+    spawn: Bun.spawn
+  };
+  IGNORE_DIRS = new Set([
+    "node_modules",
+    "dist",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "coverage",
+    "vendor",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".eggs",
+    "target",
+    ".gradle",
+    "out",
+    "tmp",
+    "temp",
+    ".git"
+  ]);
+});
+
 // src/context/index.ts
 var init_context = __esm(() => {
   init_feature_resolver();
@@ -29892,6 +30059,7 @@ var init_context = __esm(() => {
   init_engine();
   init_test_scanner();
   init_auto_detect();
+  init_greenfield();
 });
 
 // src/prompts/core/section-accumulator.ts
@@ -34830,36 +34998,40 @@ ${outputFormat}`,
 
 // src/agents/shared/decompose.ts
 function parseDecomposeOutput(output) {
-  const jsonMatch = output.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
-  let jsonText = jsonMatch ? jsonMatch[1] : output;
-  if (!jsonMatch) {
-    const arrayMatch = output.match(/\[[\s\S]*\]/);
-    if (arrayMatch) {
-      jsonText = arrayMatch[0];
-    }
-  }
   let parsed;
   try {
-    parsed = JSON.parse(jsonText.trim());
+    parsed = parseLLMJson(output);
   } catch (error48) {
-    throw new Error(`Failed to parse decompose output as JSON: ${error48.message}
-
-Output:
-${output.slice(0, 500)}`);
+    throw new NaxError("Failed to parse decompose output as JSON", "DECOMPOSE_PARSE_FAILED", {
+      stage: "decompose",
+      outputSnippet: output.slice(0, 500),
+      cause: error48
+    });
   }
   if (!Array.isArray(parsed)) {
-    throw new Error("Decompose output is not an array");
+    throw new NaxError("Decompose output is not an array", "DECOMPOSE_PARSE_FAILED", {
+      stage: "decompose"
+    });
   }
   const stories = parsed.map((item, index) => {
     if (typeof item !== "object" || item === null) {
-      throw new Error(`Story at index ${index} is not an object`);
+      throw new NaxError(`Story at index ${index} is not an object`, "DECOMPOSE_PARSE_FAILED", {
+        stage: "decompose",
+        index
+      });
     }
     const record2 = item;
     if (!record2.id || typeof record2.id !== "string") {
-      throw new Error(`Story at index ${index} missing valid 'id' field`);
+      throw new NaxError(`Story at index ${index} missing valid 'id' field`, "DECOMPOSE_PARSE_FAILED", {
+        stage: "decompose",
+        index
+      });
     }
     if (!record2.title || typeof record2.title !== "string") {
-      throw new Error(`Story ${record2.id} missing valid 'title' field`);
+      throw new NaxError(`Story ${record2.id} missing valid 'title' field`, "DECOMPOSE_PARSE_FAILED", {
+        stage: "decompose",
+        storyId: record2.id
+      });
     }
     return {
       id: record2.id,
@@ -34874,11 +35046,14 @@ ${output.slice(0, 500)}`);
       reasoning: String(record2.reasoning || "No reasoning provided"),
       estimatedLOC: Number(record2.estimatedLOC) || 0,
       risks: Array.isArray(record2.risks) ? record2.risks : [],
-      testStrategy: resolveTestStrategy(typeof record2.testStrategy === "string" ? record2.testStrategy : undefined)
+      testStrategy: resolveTestStrategy(typeof record2.testStrategy === "string" ? record2.testStrategy : undefined),
+      agentProfileId: typeof record2.agentProfileId === "string" && record2.agentProfileId.length > 0 ? record2.agentProfileId : undefined
     };
   });
   if (stories.length === 0) {
-    throw new Error("Decompose returned empty story array");
+    throw new NaxError("Decompose returned empty story array", "DECOMPOSE_PARSE_FAILED", {
+      stage: "decompose"
+    });
   }
   return stories;
 }
@@ -34889,7 +35064,8 @@ function coerceComplexity(value) {
   return "medium";
 }
 var init_decompose = __esm(() => {
-  init_test_strategy();
+  init_config();
+  init_errors();
 });
 
 // src/agents/shared/decompose-prompt.ts
@@ -34928,10 +35104,10 @@ function buildPlanModePromptSync(input) {
 `);
     builder = builder.inputData("Sibling Stories", siblingsSummary);
   }
-  return builder.jsonSchema(DECOMPOSE_PLAN_SCHEMA).build();
+  return builder.agentProfiles(input.profiles ?? []).jsonSchema(DECOMPOSE_PLAN_SCHEMA).build();
 }
 function buildSpecModePromptSync(input) {
-  return OneShotPromptBuilder.for("decomposer").instructions(SPEC_DECOMPOSE_INSTRUCTIONS).inputData("Codebase Context", input.codebaseContext).inputData("Feature Specification", input.specContent).jsonSchema(DECOMPOSE_SPEC_SCHEMA).build();
+  return OneShotPromptBuilder.for("decomposer").instructions(SPEC_DECOMPOSE_INSTRUCTIONS).inputData("Codebase Context", input.codebaseContext).inputData("Feature Specification", input.specContent).agentProfiles(input.profiles ?? []).jsonSchema(DECOMPOSE_SPEC_SCHEMA).build();
 }
 async function buildPlanModePrompt(options) {
   const targetStory = options.targetStory;
@@ -34944,10 +35120,10 @@ async function buildPlanModePrompt(options) {
 `);
     builder = builder.inputData("Sibling Stories", siblingsSummary);
   }
-  return builder.jsonSchema(DECOMPOSE_PLAN_SCHEMA).build();
+  return builder.agentProfiles(options.profiles ?? []).jsonSchema(DECOMPOSE_PLAN_SCHEMA).build();
 }
 async function buildSpecModePrompt(options) {
-  return OneShotPromptBuilder.for("decomposer").instructions(SPEC_DECOMPOSE_INSTRUCTIONS).inputData("Codebase Context", options.codebaseContext).inputData("Feature Specification", options.specContent).jsonSchema(DECOMPOSE_SPEC_SCHEMA).build();
+  return OneShotPromptBuilder.for("decomposer").instructions(SPEC_DECOMPOSE_INSTRUCTIONS).inputData("Codebase Context", options.codebaseContext).inputData("Feature Specification", options.specContent).agentProfiles(options.profiles ?? []).jsonSchema(DECOMPOSE_SPEC_SCHEMA).build();
 }
 var DECOMPOSE_SPEC_SCHEMA, DECOMPOSE_PLAN_SCHEMA, SPEC_DECOMPOSE_INSTRUCTIONS;
 var init_decompose_prompt = __esm(() => {
@@ -34969,7 +35145,8 @@ var init_decompose_prompt = __esm(() => {
         reasoning: "Why this complexity level",
         estimatedLOC: 150,
         risks: ["Risk 1"],
-        testStrategy: "test-after"
+        testStrategy: "test-after",
+        agentProfileId: ""
       }
     ]
   };
@@ -34989,7 +35166,8 @@ var init_decompose_prompt = __esm(() => {
         reasoning: "Why this complexity",
         estimatedLOC: 0,
         risks: [],
-        testStrategy: "no-test | tdd-simple | three-session-tdd-lite | three-session-tdd | test-after"
+        testStrategy: "no-test | tdd-simple | three-session-tdd-lite | three-session-tdd | test-after",
+        agentProfileId: ""
       }
     ]
   };
@@ -35009,6 +35187,7 @@ For each story, provide:
 11. risks: Array of implementation risks
 12. testStrategy: "no-test" | "test-after" | "tdd-simple" | "three-session-tdd" | "three-session-tdd-lite"
 13. noTestJustification: string (REQUIRED when testStrategy is "no-test" \u2014 explain why tests are unnecessary)
+14. agentProfileId: (optional) profile id from the Agent Profiles table \u2014 assign the best-matching profile for each story; omit if no profiles are listed or none fits well
 
 ${COMPLEXITY_GUIDE}
 
@@ -35024,11 +35203,15 @@ Consider:
 });
 
 // src/operations/decompose.ts
-var decomposeOp;
+var _decomposeOpDeps, decomposeOp;
 var init_decompose2 = __esm(() => {
   init_decompose();
   init_decompose_prompt();
   init_config();
+  init_logger2();
+  _decomposeOpDeps = {
+    getSafeLogger
+  };
   decomposeOp = {
     kind: "complete",
     name: "decompose",
@@ -35037,21 +35220,62 @@ var init_decompose2 = __esm(() => {
     config: decomposeConfigSelector,
     model: (_input, ctx) => ctx.config.plan.model,
     timeoutMs: (_input, ctx) => (ctx.config.plan.decomposeTimeoutSeconds ?? ctx.config.plan.timeoutSeconds ?? 600) * 1000,
-    build(input, _ctx) {
+    build(input, ctx) {
+      const agentRouting = ctx.config.routing?.agents;
+      const profiles = agentRouting?.enabled === true ? agentRouting.profiles ?? [] : [];
       const prompt = buildDecomposePromptSync({
         specContent: input.specContent,
         codebaseContext: input.codebaseContext,
         targetStory: input.targetStory,
         siblings: input.siblings,
-        maxAcCount: input.maxAcCount
+        maxAcCount: input.maxAcCount,
+        profiles
       });
       return {
         role: { id: "role", content: "", overridable: false },
         task: { id: "task", content: prompt, overridable: false }
       };
     },
-    parse(output, _input, _ctx) {
-      return parseDecomposeOutput(output);
+    parse(output, _input, ctx) {
+      const stories = parseDecomposeOutput(output);
+      const agentRouting = ctx.config.routing?.agents;
+      if (agentRouting?.enabled !== true) {
+        return stories;
+      }
+      const profiles = agentRouting.profiles ?? [];
+      if (profiles.length === 0) {
+        return stories;
+      }
+      const defaultProfile = agentRouting.default ? profiles.find((p) => p.id === agentRouting.default) : undefined;
+      return stories.map((story) => {
+        if (story.agentProfileId) {
+          const profile = profiles.find((p) => p.id === story.agentProfileId);
+          if (profile) {
+            return {
+              ...story,
+              routing: {
+                ...story.routing,
+                agent: profile.target.agent,
+                agentProfileId: profile.id,
+                profileModelTier: profile.target.model
+              }
+            };
+          }
+          _decomposeOpDeps.getSafeLogger()?.warn("decompose", `Story ${story.id} selected unknown agent profile "${story.agentProfileId}" \u2014 falling back to ${defaultProfile ? `default profile "${defaultProfile.id}"` : "no profile"}`, { storyId: story.id, agentProfileId: story.agentProfileId });
+        }
+        if (defaultProfile) {
+          return {
+            ...story,
+            routing: {
+              ...story.routing,
+              agent: defaultProfile.target.agent,
+              agentProfileId: defaultProfile.id,
+              profileModelTier: defaultProfile.target.model
+            }
+          };
+        }
+        return story;
+      });
     }
   };
 });
@@ -35467,6 +35691,7 @@ __export(exports_routing, {
   resolveRouting: () => resolveRouting,
   determineTestStrategy: () => determineTestStrategy,
   complexityToModelTier: () => complexityToModelTier,
+  clearCache: () => clearCache,
   classifyComplexity: () => classifyComplexity,
   _tryLlmBatchRouteDeps: () => _tryLlmBatchRouteDeps,
   ROUTING_INSTRUCTIONS: () => ROUTING_INSTRUCTIONS
@@ -35568,6 +35793,22 @@ ${BATCH_ROUTING_SCHEMA_INLINE}`;
 
 // src/acceptance/test-path.ts
 import path3 from "path";
+async function _readPackageTestPath(workdir, relativeDir) {
+  if (!relativeDir)
+    return;
+  if (path3.isAbsolute(relativeDir) || relativeDir.split(path3.sep).includes(".."))
+    return;
+  const cfgPath = path3.join(workdir, ".nax", "mono", relativeDir, "config.json");
+  const file3 = Bun.file(cfgPath);
+  if (!await file3.exists())
+    return;
+  try {
+    const cfg = JSON.parse(await file3.text());
+    return cfg?.acceptance?.testPath;
+  } catch {
+    return;
+  }
+}
 function acceptanceTestFilename(language) {
   switch (language?.toLowerCase()) {
     case "go":
@@ -35617,10 +35858,12 @@ async function groupStoriesByPackage(prd, workdir, featureName, testPathConfig,
   }
   return Promise.all(Array.from(groupMap.entries()).map(async ([wd, { stories, criteria }]) => {
     const packageDir = wd ? path3.join(workdir, wd) : workdir;
+    const pkgTestPath = await _groupDeps.readPackageTestPath(workdir, wd);
     const detectedLang = await _groupDeps.detectLanguage(packageDir);
     const resolvedLang = detectedLang ?? language;
-    const testPath = resolveAcceptancePackageFeatureTestPath(packageDir, featureName, testPathConfig, resolvedLang);
-    return { testPath, packageDir, stories, criteria };
+    const resolvedTestPathConfig = pkgTestPath ?? testPathConfig;
+    const testPath = resolveAcceptancePackageFeatureTestPath(packageDir, featureName, resolvedTestPathConfig, resolvedLang);
+    return { testPath, packageDir, stories, criteria, language: resolvedLang };
   }));
 }
 function suggestedTestFilename(language) {
@@ -35668,7 +35911,8 @@ var _groupDeps;
 var init_test_path = __esm(() => {
   init_detector();
   _groupDeps = {
-    detectLanguage
+    detectLanguage,
+    readPackageTestPath: _readPackageTestPath
   };
 });
 
@@ -38419,73 +38663,6 @@ var init_plan_critic_llm = __esm(() => {
   };
 });
 
-// src/context/greenfield.ts
-async function gitLsFiles2(workdir) {
-  try {
-    const proc = _greenfieldDeps.spawn(["git", "ls-files"], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0)
-      return null;
-    const output = await new Response(proc.stdout).text();
-    return output.split(`
-`).filter(Boolean);
-  } catch {
-    return null;
-  }
-}
-async function hasTestFiles(workdir, patterns) {
-  const files = await gitLsFiles2(workdir);
-  if (files !== null) {
-    return files.some((f) => isTestFileByPatterns(f, patterns));
-  }
-  for (const pattern of patterns) {
-    const g = new Bun.Glob(pattern);
-    for await (const path5 of g.scan({ cwd: workdir, onlyFiles: true })) {
-      if (!path5.split("/").some((seg) => IGNORE_DIRS.has(seg))) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-async function isGreenfieldStory(_story, workdir, patterns) {
-  try {
-    return !await hasTestFiles(workdir, patterns ?? DEFAULT_TEST_FILE_PATTERNS);
-  } catch {
-    return false;
-  }
-}
-var _greenfieldDeps, IGNORE_DIRS;
-var init_greenfield = __esm(() => {
-  init_test_runners();
-  _greenfieldDeps = {
-    spawn: Bun.spawn
-  };
-  IGNORE_DIRS = new Set([
-    "node_modules",
-    "dist",
-    ".next",
-    ".nuxt",
-    ".cache",
-    "coverage",
-    "vendor",
-    "__pycache__",
-    ".venv",
-    "venv",
-    ".eggs",
-    "target",
-    ".gradle",
-    "out",
-    "tmp",
-    "temp",
-    ".git"
-  ]);
-});
-
 // src/operations/greenfield-gate.ts
 var greenfieldGateConfigSelector, greenfieldGateOp;
 var init_greenfield_gate = __esm(() => {
@@ -42856,9 +43033,59 @@ ${body}`
     this.acc.add(jsonSchemaSection(schema));
     return this;
   }
+  agentProfiles(profiles) {
+    const cards = OneShotPromptBuilder.agentCapabilityCards(profiles);
+    if (cards.length === 0)
+      return this;
+    this.acc.add({
+      id: "agent-profiles",
+      overridable: false,
+      content: `${cards}
+
+${OneShotPromptBuilder.agentProfileInstruction()}`
+    });
+    return this;
+  }
   build() {
     return this.acc.join();
   }
+  static agentProfileInstruction() {
+    return [
+      "When agent profiles are listed above, pick exactly ONE profile id per story and set it on the `agentProfileId` field. Apply these steps in order:",
+      "1. Eliminate any profile whose weaknesses conflict with the story.",
+      "2. Keep profiles whose strengths or affinity cover the story's main job (task type + primary domain).",
+      "3. If more than one remains, choose the LOWEST cost profile.",
+      "4. If none clearly fit, omit `agentProfileId` entirely \u2014 never invent a profile id."
+    ].join(`
+`);
+  }
+  static agentCapabilityCards(profiles) {
+    if (profiles.length === 0)
+      return "";
+    const header = [
+      "## Agent Profiles",
+      "",
+      "| ID | Agent | Tier | Strengths | Weaknesses | Affinity | Cost |",
+      "|---|---|---|---|---|---|---|"
+    ];
+    const rows = profiles.map((p) => {
+      const esc2 = OneShotPromptBuilder.escapeCell;
+      const id = esc2(p.id);
+      const agent = esc2(p.target.agent);
+      const model = esc2(p.target.model);
+      const strengths = p.strengths.map(esc2).join(", ");
+      const weaknesses = p.weaknesses?.length ? p.weaknesses.map(esc2).join("; ") : "\u2014";
+      const affinityParts = [...p.affinity?.taskTypes ?? [], ...p.affinity?.domains ?? []];
+      const affinity = affinityParts.length ? affinityParts.map(esc2).join(", ") : "\u2014";
+      const cost = esc2(p.costTier ?? "\u2014");
+      return `| ${id} | ${agent} | ${model} | ${strengths} | ${weaknesses} | ${affinity} | ${cost} |`;
+    });
+    return [...header, ...rows].join(`
+`);
+  }
+  static escapeCell(value) {
+    return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+  }
 }
 var init_one_shot_builder = __esm(() => {
   init_core3();
@@ -51554,10 +51781,9 @@ function mapDecomposedStoriesToUserStories(stories, parentStoryId, parentWorkdir
       });
     }
     if (!story.contextFiles || story.contextFiles.length === 0) {
-      throw new NaxError(`Entry ${entryIndex} (${story.id}) has empty contextFiles`, "DECOMPOSE_VALIDATION_FAILED", {
-        stage: "decompose-mapper",
-        entryIndex,
+      getSafeLogger()?.warn("decompose-mapper", `Entry ${entryIndex} (${story.id}) has empty contextFiles \u2014 continuing`, {
         storyId: story.id,
+        entryIndex,
         parentStoryId
       });
     }
@@ -51579,13 +51805,17 @@ function mapDecomposedStoriesToUserStories(stories, parentStoryId, parentWorkdir
         complexity: story.complexity,
         testStrategy: story.testStrategy ?? "test-after",
         reasoning: story.reasoning,
-        modelTier: "balanced"
+        modelTier: story.routing?.profileModelTier ?? "balanced",
+        ...story.routing?.agent !== undefined && { agent: story.routing.agent },
+        ...story.routing?.agentProfileId !== undefined && { agentProfileId: story.routing.agentProfileId },
+        ...story.routing?.profileModelTier !== undefined && { profileModelTier: story.routing.profileModelTier }
       }
     };
   });
 }
 var init_decompose_mapper = __esm(() => {
   init_errors();
+  init_logger2();
 });
 
 // src/cli/plan-decompose.ts
@@ -51627,8 +51857,12 @@ async function planDecomposeCommand(workdir, config2, options) {
   const rt = createPlanRuntime(config2, workdir, options.feature);
   const agentManager = rt.agentManager;
   const adapterForCapCheck = agentManager.getAgent(agentName);
-  if (!adapterForCapCheck)
-    throw new Error(`[decompose] No agent adapter found for '${agentName}'`);
+  if (!adapterForCapCheck) {
+    throw new NaxError(`No agent adapter found for '${agentName}'`, "AGENT_NOT_FOUND", {
+      stage: "decompose",
+      agentName
+    });
+  }
   const timeoutSeconds = config2?.plan?.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS2;
   const maxAcCount = config2?.precheck?.storySizeGate?.maxAcCount ?? Number.POSITIVE_INFINITY;
   const maxReplanAttempts = config2?.precheck?.storySizeGate?.maxReplanAttempts ?? 3;
@@ -51640,6 +51874,8 @@ async function planDecomposeCommand(workdir, config2, options) {
     for (let attempt = 0;attempt < maxReplanAttempts; attempt++) {
       if (attempt === 0 && debateDecompEnabled) {
         const decomposeStageConfig = debateStages.decompose;
+        const agentRoutingForDebate = config2.routing?.agents;
+        const profilesForDebate = agentRoutingForDebate?.enabled === true ? agentRoutingForDebate.profiles ?? [] : [];
         const prompt = await buildDecomposePromptAsync({
           specContent: "",
           codebaseContext,
@@ -51648,7 +51884,8 @@ async function planDecomposeCommand(workdir, config2, options) {
           siblings,
           featureName: options.feature,
           storyId: options.storyId,
-          maxAcCount: config2?.precheck?.storySizeGate?.maxAcCount
+          maxAcCount: config2?.precheck?.storySizeGate?.maxAcCount,
+          profiles: profilesForDebate
         });
         const decompCallCtx = {
           runtime: rt,
@@ -51721,7 +51958,11 @@ ${repairHint}` : codebaseContext;
     ...subStoriesWithParent,
     ...updatedStories.slice(originalIndex + 1)
   ];
-  const updatedPrd = { ...prd, userStories: finalStories };
+  const updatedPrd = {
+    ...prd,
+    userStories: finalStories,
+    routingProfile: config2.profile ?? "default"
+  };
   await _planDeps.writeFile(prdPath, JSON.stringify(updatedPrd, null, 2));
   return () => {};
 }
@@ -52658,6 +52899,103 @@ var init_semantic_verdict = __esm(() => {
 });
 
 // src/acceptance/hardening.ts
+import path10 from "path";
+async function processPackageGroup(ctx, packageDir, groupStories, language, result) {
+  const logger = getSafeLogger();
+  const groupRefined = [];
+  for (const story of groupStories) {
+    const callCtx = {
+      runtime: ctx.runtime,
+      packageView: ctx.runtime.packages.resolve(packageDir),
+      packageDir,
+      storyId: story.id,
+      featureName: ctx.prd.feature,
+      agentName: ctx.agentManager.getDefault()
+    };
+    const refined = await _hardeningDeps.callOp(callCtx, acceptanceRefineOp, {
+      criteria: story.suggestedCriteria ?? [],
+      codebaseContext: "",
+      storyId: story.id,
+      testStrategy: ctx.config.acceptance?.testStrategy,
+      testFramework: ctx.config.acceptance?.testFramework,
+      storyTitle: story.title,
+      storyDescription: story.description
+    });
+    groupRefined.push(...refined);
+  }
+  const suggestedTestPath = resolveSuggestedPackageFeatureTestPath(packageDir, ctx.prd.feature, ctx.config.acceptance?.suggestedTestPath, language);
+  const criteriaList = groupRefined.map((c, i) => `AC-${i + 1}: ${c.refined}`).join(`
+`);
+  const frameworkOverrideLine = ctx.config.acceptance?.testFramework ? `
+[FRAMEWORK OVERRIDE: Use ${ctx.config.acceptance.testFramework} as the test framework regardless of what you detect.]` : "";
+  const genCallCtx = {
+    runtime: ctx.runtime,
+    packageView: ctx.runtime.packages.resolve(packageDir),
+    packageDir,
+    storyId: groupStories[0]?.id,
+    featureName: ctx.prd.feature,
+    agentName: ctx.agentManager.getDefault()
+  };
+  const genResult = await _hardeningDeps.callOp(genCallCtx, acceptanceGenerateOp, {
+    featureName: ctx.prd.feature,
+    criteriaList,
+    frameworkOverrideLine,
+    targetTestFilePath: suggestedTestPath
+  });
+  let testCode = genResult.testCode;
+  if (!testCode) {
+    const skeletonCriteria = groupRefined.map((c, i) => ({
+      id: `AC-${i + 1}`,
+      text: c.refined,
+      lineNumber: i + 1
+    }));
+    testCode = generateSkeletonTests(ctx.prd.feature, skeletonCriteria, ctx.config.acceptance?.testFramework, language);
+    logger?.warn("acceptance", "Hardening generate op returned no test code \u2014 using skeleton", {
+      storyIds: groupStories.map((s) => s.id),
+      storiesProcessed: groupStories.length
+    });
+  }
+  await _hardeningDeps.writeFile(suggestedTestPath, testCode);
+  const testCmd = buildAcceptanceRunCommand(suggestedTestPath, ctx.config.project?.testFramework, ctx.config.acceptance?.command, packageDir);
+  const proc = _hardeningDeps.spawn(testCmd, { cwd: packageDir, stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}
+${stderr}`;
+  const failedACs = parseTestFailures(output);
+  const failedSet = new Set(failedACs.map((ac) => ac.toUpperCase()));
+  const refinedByStory = new Map;
+  for (const r of groupRefined) {
+    const list = refinedByStory.get(r.storyId) ?? [];
+    list.push(r);
+    refinedByStory.set(r.storyId, list);
+  }
+  let acIndex = 0;
+  for (const story of groupStories) {
+    const storyRefined = refinedByStory.get(story.id) ?? [];
+    const toPromote = [];
+    const toDiscard = [];
+    for (const refined of storyRefined) {
+      acIndex++;
+      const acId = `AC-${acIndex}`;
+      if (refined.testable === false || failedSet.has(acId) || exitCode !== 0 && failedACs.length === 0) {
+        toDiscard.push(refined.original);
+      } else {
+        toPromote.push(refined.original);
+      }
+    }
+    if (toPromote.length > 0) {
+      const existingACs = new Set(story.acceptanceCriteria);
+      story.acceptanceCriteria = [...story.acceptanceCriteria, ...toPromote.filter((ac) => !existingACs.has(ac))];
+      result.promoted.push(...toPromote);
+    }
+    result.discarded.push(...toDiscard);
+    story.suggestedCriteria = toDiscard.length > 0 ? toDiscard : undefined;
+  }
+}
 async function runHardeningPass(ctx) {
   const logger = getSafeLogger();
   const result = { promoted: [], discarded: [] };
@@ -52670,105 +53008,17 @@ async function runHardeningPass(ctx) {
     totalSuggestedACs: storiesWithSuggested.reduce((n, s) => n + (s.suggestedCriteria?.length ?? 0), 0)
   });
   try {
-    const allRefined = [];
+    const packageGroups = new Map;
     for (const story of storiesWithSuggested) {
-      const criteria = story.suggestedCriteria ?? [];
-      const callCtx = {
-        runtime: ctx.runtime,
-        packageView: ctx.runtime.packages.resolve(ctx.workdir),
-        packageDir: ctx.workdir,
-        storyId: story.id,
-        featureName: ctx.prd.feature,
-        agentName: ctx.agentManager.getDefault()
-      };
-      const refined = await _hardeningDeps.callOp(callCtx, acceptanceRefineOp, {
-        criteria,
-        codebaseContext: "",
-        storyId: story.id,
-        testStrategy: ctx.config.acceptance?.testStrategy,
-        testFramework: ctx.config.acceptance?.testFramework,
-        storyTitle: story.title,
-        storyDescription: story.description
-      });
-      allRefined.push(...refined);
-    }
-    const language = ctx.config.project?.language;
-    const suggestedTestPath = resolveSuggestedPackageFeatureTestPath(ctx.workdir, ctx.prd.feature, ctx.config.acceptance?.suggestedTestPath, language);
-    const criteriaList = allRefined.map((c, i) => `AC-${i + 1}: ${c.refined}`).join(`
-`);
-    const frameworkOverrideLine = ctx.config.acceptance?.testFramework ? `
-[FRAMEWORK OVERRIDE: Use ${ctx.config.acceptance.testFramework} as the test framework regardless of what you detect.]` : "";
-    const genCallCtx = {
-      runtime: ctx.runtime,
-      packageView: ctx.runtime.packages.resolve(ctx.workdir),
-      packageDir: ctx.workdir,
-      storyId: storiesWithSuggested[0]?.id,
-      featureName: ctx.prd.feature,
-      agentName: ctx.agentManager.getDefault()
-    };
-    const genResult = await _hardeningDeps.callOp(genCallCtx, acceptanceGenerateOp, {
-      featureName: ctx.prd.feature,
-      criteriaList,
-      frameworkOverrideLine,
-      targetTestFilePath: suggestedTestPath
-    });
-    let testCode = genResult.testCode;
-    if (!testCode) {
-      const skeletonCriteria = allRefined.map((c, i) => ({
-        id: `AC-${i + 1}`,
-        text: c.refined,
-        lineNumber: i + 1
-      }));
-      testCode = generateSkeletonTests(ctx.prd.feature, skeletonCriteria, ctx.config.acceptance?.testFramework, language);
-      logger?.warn("acceptance", "Hardening generate op returned no test code \u2014 using skeleton", {
-        storyIds: storiesWithSuggested.map((s) => s.id),
-        storiesProcessed: storiesWithSuggested.length
-      });
+      const wd = story.workdir ?? "";
+      if (!packageGroups.has(wd))
+        packageGroups.set(wd, []);
+      packageGroups.get(wd)?.push(story);
     }
-    await _hardeningDeps.writeFile(suggestedTestPath, testCode);
-    const testCmd = buildAcceptanceRunCommand(suggestedTestPath, ctx.config.project?.testFramework, ctx.config.acceptance?.command, ctx.workdir);
-    const proc = _hardeningDeps.spawn(testCmd, {
-      cwd: ctx.workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [exitCode, stdout, stderr] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text()
-    ]);
-    const output = `${stdout}
-${stderr}`;
-    const failedACs = parseTestFailures(output);
-    const failedSet = new Set(failedACs.map((ac) => ac.toUpperCase()));
-    const refinedByStory = new Map;
-    for (const r of allRefined) {
-      const list = refinedByStory.get(r.storyId) ?? [];
-      list.push(r);
-      refinedByStory.set(r.storyId, list);
-    }
-    let acIndex = 0;
-    for (const story of storiesWithSuggested) {
-      const storyRefined = refinedByStory.get(story.id) ?? [];
-      const toPromote = [];
-      const toDiscard = [];
-      for (const refinedCriterion of storyRefined) {
-        acIndex++;
-        const acId = `AC-${acIndex}`;
-        const nonTestable = refinedCriterion.testable === false;
-        if (nonTestable || failedSet.has(acId) || exitCode !== 0 && failedACs.length === 0) {
-          toDiscard.push(refinedCriterion.original);
-        } else {
-          toPromote.push(refinedCriterion.original);
-        }
-      }
-      if (toPromote.length > 0) {
-        const existingACs = new Set(story.acceptanceCriteria);
-        story.acceptanceCriteria = [...story.acceptanceCriteria, ...toPromote.filter((ac) => !existingACs.has(ac))];
-        result.promoted.push(...toPromote);
-      }
-      result.discarded.push(...toDiscard);
-      story.suggestedCriteria = toDiscard.length > 0 ? toDiscard : undefined;
+    for (const [wd, groupStories] of packageGroups.entries()) {
+      const packageDir = wd ? path10.join(ctx.workdir, wd) : ctx.workdir;
+      const detectedLang = await _hardeningDeps.detectLanguage(packageDir);
+      await processPackageGroup(ctx, packageDir, groupStories, detectedLang ?? ctx.config.project?.language, result);
     }
     if (result.promoted.length > 0) {
       await _hardeningDeps.savePRD(ctx.prd, ctx.prdPath);
@@ -52793,6 +53043,7 @@ var init_hardening = __esm(() => {
   init_logger2();
   init_operations();
   init_prd();
+  init_detector();
   init_ac_parser();
   init_generator();
   init_test_path();
@@ -52802,7 +53053,8 @@ var init_hardening = __esm(() => {
     spawn: Bun.spawn,
     writeFile: async (p, c) => {
       await Bun.write(p, c);
-    }
+    },
+    detectLanguage
   };
 });
 
@@ -53056,7 +53308,7 @@ __export(exports_acceptance_setup, {
   acceptanceSetupStage: () => acceptanceSetupStage,
   _acceptanceSetupDeps: () => _acceptanceSetupDeps
 });
-import path10 from "path";
+import path11 from "path";
 function computeACFingerprint(criteria) {
   const sorted = [...criteria].sort().join(`
 `);
@@ -53129,7 +53381,7 @@ var init_acceptance_setup = __esm(() => {
     },
     autoCommitIfDirty,
     loadGroupConfig: async (projectDir, relativeWorkdir) => {
-      return loadConfigForWorkdir(path10.join(projectDir, ".nax", "config.json"), relativeWorkdir || undefined);
+      return loadConfigForWorkdir(path11.join(projectDir, ".nax", "config.json"), relativeWorkdir || undefined);
     },
     runTest: async (_testPath, _workdir, _cmd) => {
       const cmd = _cmd;
@@ -53173,7 +53425,7 @@ ${stderr}` };
       }
       const language = ctx.config.project?.language;
       const testPathConfig = ctx.config.acceptance.testPath;
-      const metaPath = path10.join(ctx.featureDir, "acceptance-meta.json");
+      const metaPath = path11.join(ctx.featureDir, "acceptance-meta.json");
       const allCriteria = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-") && s.status !== "decomposed").flatMap((s) => s.acceptanceCriteria);
       const featureName = ctx.prd.feature ?? ctx.prd.featureName;
       const groups = await groupStoriesByPackage(ctx.prd, ctx.workdir, featureName, testPathConfig, language);
@@ -53272,7 +53524,7 @@ ${stderr}` };
               text: c.refined,
               lineNumber: i + 1
             }));
-            const skeletonCode = generateSkeletonTests(featureName, skeletonCriteria, ctx.config.acceptance.testFramework, language);
+            const skeletonCode = generateSkeletonTests(featureName, skeletonCriteria, ctx.config.acceptance.testFramework, group.language);
             await _acceptanceSetupDeps.writeFile(testPath, skeletonCode);
             getSafeLogger()?.warn("acceptance-setup", "agent did not produce test content; using skeleton", {
               storyId: groupStoryId,
@@ -53288,7 +53540,7 @@ ${stderr}` };
             testable: c.testable,
             storyId: c.storyId
           })), null, 2);
-          await _acceptanceSetupDeps.writeFile(path10.join(ctx.featureDir, "acceptance-refined.json"), refinedJsonContent);
+          await _acceptanceSetupDeps.writeFile(path11.join(ctx.featureDir, "acceptance-refined.json"), refinedJsonContent);
         }
         const fingerprint2 = computeACFingerprint(allCriteria);
         await _acceptanceSetupDeps.writeMeta(metaPath, {
@@ -53302,7 +53554,7 @@ ${stderr}` };
       }
       const acceptanceTestPaths = [];
       for (const g of groups) {
-        const relativeWorkdir = path10.relative(ctx.projectDir, g.packageDir);
+        const relativeWorkdir = path11.relative(ctx.projectDir, g.packageDir);
         let groupConfig = ctx.config;
         if (relativeWorkdir && relativeWorkdir !== ".") {
           try {
@@ -53871,7 +54123,7 @@ var init_story_context = __esm(() => {
 
 // src/execution/lock.ts
 import { unlink as unlink2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 function getSafeLogger3() {
   try {
     return getLogger();
@@ -53888,7 +54140,7 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(workdir) {
-  const lockPath = path11.join(workdir, "nax.lock");
+  const lockPath = path12.join(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   try {
     const exists = await lockFile.exists();
@@ -53940,7 +54192,7 @@ async function acquireLock(workdir) {
   }
 }
 async function releaseLock(workdir) {
-  const lockPath = path11.join(workdir, "nax.lock");
+  const lockPath = path12.join(workdir, "nax.lock");
   try {
     await unlink2(lockPath);
   } catch (error48) {
@@ -55500,6 +55752,16 @@ var init_plan_inputs = __esm(() => {
 });
 
 // src/pipeline/stages/execution-helpers.ts
+function resolveExecutionAgent(opts) {
+  const { routedAgent, defaultAgent, getAgent } = opts;
+  if (routedAgent !== undefined) {
+    const routed = getAgent(routedAgent);
+    if (routed)
+      return { agentName: routedAgent, agent: routed, degraded: false };
+    return { agentName: defaultAgent, agent: getAgent(defaultAgent), degraded: true };
+  }
+  return { agentName: defaultAgent, agent: getAgent(defaultAgent), degraded: false };
+}
 function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason, failureDetail) {
   const buildReason = (category) => {
     const trimmedDetail = failureDetail?.trim();
@@ -55998,6 +56260,7 @@ var init_execution = __esm(() => {
   init_logger2();
   init_git();
   init_execution_helpers();
+  init_execution_helpers();
   RUNTIME_CRASH_CODES = new Set(["CALL_OP_NO_OUTPUT", "CALL_OP_MAX_RETRIES"]);
   executionStage = {
     name: "execution",
@@ -56005,9 +56268,21 @@ var init_execution = __esm(() => {
     async execute(ctx) {
       const logger = getLogger();
       const defaultAgent = ctx.agentManager?.getDefault() ?? "claude";
-      const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(defaultAgent);
+      const resolved = resolveExecutionAgent({
+        routedAgent: ctx.routing.agent,
+        defaultAgent,
+        getAgent: ctx.agentGetFn ?? _executionDeps.getAgent
+      });
+      if (resolved.degraded) {
+        logger.warn("execution", "Routed agent unavailable \u2014 degrading to default agent", {
+          storyId: ctx.story.id,
+          routedAgent: ctx.routing.agent,
+          defaultAgent
+        });
+      }
+      const agent = resolved.agent;
       if (!agent)
-        return { action: "fail", reason: `Agent "${defaultAgent}" not found` };
+        return { action: "fail", reason: `Agent "${resolved.agentName}" not found` };
       let effectiveTier = ctx.routing.modelTier;
       if (!_executionDeps.validateAgentForTier(agent, ctx.routing.modelTier)) {
         effectiveTier = agent.capabilities.supportedTiers[0] ?? ctx.routing.modelTier;
@@ -56031,7 +56306,7 @@ var init_execution = __esm(() => {
         runtime: ctx.runtime,
         packageView,
         packageDir: ctx.workdir,
-        agentName: ctx.routing.agent ?? defaultAgent,
+        agentName: resolved.agentName,
         storyId: ctx.story.id,
         featureName: ctx.prd.feature,
         story: ctx.story,
@@ -56449,7 +56724,7 @@ function parseQueueFile(content) {
 var init_queue = () => {};
 
 // src/execution/queue-handler.ts
-import path12 from "path";
+import path13 from "path";
 function getSafeLogger4() {
   try {
     return getLogger();
@@ -56458,8 +56733,8 @@ function getSafeLogger4() {
   }
 }
 async function readQueueFile(workdir) {
-  const queuePath = path12.join(workdir, ".queue.txt");
-  const processingPath = path12.join(workdir, ".queue.txt.processing");
+  const queuePath = path13.join(workdir, ".queue.txt");
+  const processingPath = path13.join(workdir, ".queue.txt.processing");
   const logger = getSafeLogger4();
   try {
     const file3 = Bun.file(queuePath);
@@ -56484,7 +56759,7 @@ async function readQueueFile(workdir) {
   }
 }
 async function clearQueueFile(workdir) {
-  const processingPath = path12.join(workdir, ".queue.txt.processing");
+  const processingPath = path13.join(workdir, ".queue.txt.processing");
   const logger = getSafeLogger4();
   try {
     const file3 = Bun.file(processingPath);
@@ -56562,13 +56837,12 @@ var init_queue_check = __esm(() => {
 // src/pipeline/stages/routing.ts
 var routingStage, _routingDeps;
 var init_routing2 = __esm(() => {
-  init_test_runners();
-  init_paths3();
-  init_greenfield();
+  init_context();
   init_logger2();
   init_prd();
   init_routing();
-  init_llm();
+  init_test_runners();
+  init_paths3();
   routingStage = {
     name: "routing",
     enabled: () => true,
@@ -56580,26 +56854,35 @@ var init_routing2 = __esm(() => {
       const decision = await _routingDeps.resolveRouting(ctx.story, ctx.config, ctx.plugins, ctx);
       const TIER_RANK = { fast: 0, balanced: 1, powerful: 2 };
       const derivedTier = decision.modelTier;
+      const profileTier = ctx.story.routing?.profileModelTier;
+      const candidateTier = profileTier ?? derivedTier;
+      const candidateRank = TIER_RANK[candidateTier];
       const previousTier = ctx.story.routing?.modelTier;
       const previousRank = previousTier !== undefined ? TIER_RANK[previousTier] : undefined;
-      const derivedRank = TIER_RANK[derivedTier];
-      if (previousTier !== undefined && previousRank === undefined) {
+      const hasEscalationRecords = (ctx.story.escalations?.length ?? 0) > 0;
+      if (previousTier !== undefined && previousRank === undefined && !hasEscalationRecords) {
         logger?.warn("routing", "Ignoring unknown previousTier \u2014 not escalating", {
           storyId: ctx.story.id,
           previousTier,
-          derivedTier
+          candidateTier
         });
       }
-      const isEscalated = previousTier !== undefined && previousRank !== undefined && derivedRank !== undefined && previousRank > derivedRank;
-      const modelTier = isEscalated ? previousTier : derivedTier;
-      const routing = { ...decision, modelTier, agent: ctx.story.routing?.agent };
+      const isEscalated = previousTier !== undefined && (previousRank !== undefined && candidateRank !== undefined ? previousRank > candidateRank : hasEscalationRecords);
+      const modelTier = isEscalated ? previousTier : candidateTier;
+      const routing = { ...decision, modelTier, agent: ctx.story.routing?.agent ?? decision.agent };
+      const neverEscalated = !hasEscalationRecords;
+      const initialAgent = ctx.story.routing?.initialAgent ?? (neverEscalated ? routing.agent : undefined);
+      const initialProfileId = ctx.story.routing?.initialProfileId ?? (neverEscalated ? ctx.story.routing?.agentProfileId : undefined);
       ctx.story.routing = {
         ...ctx.story.routing ?? {},
         complexity: routing.complexity,
         initialComplexity: ctx.story.routing?.initialComplexity ?? routing.complexity,
         testStrategy: routing.testStrategy,
         reasoning: routing.reasoning ?? "",
-        modelTier: routing.modelTier
+        modelTier: routing.modelTier,
+        ...routing.agent !== undefined && { agent: routing.agent },
+        ...initialAgent !== undefined && { initialAgent },
+        ...initialProfileId !== undefined && { initialProfileId }
       };
       if (ctx.prdPath) {
         await _routingDeps.savePRD(ctx.prd, ctx.prdPath);
@@ -56629,13 +56912,13 @@ var init_routing2 = __esm(() => {
       }
       ctx.routing = routing;
       logger.debug("routing", "Task classified", {
+        storyId: ctx.story.id,
         complexity: ctx.routing.complexity,
         modelTier: ctx.routing.modelTier,
-        testStrategy: ctx.routing.testStrategy,
-        storyId: ctx.story.id
+        testStrategy: ctx.routing.testStrategy
       });
       if (ctx.stories.length === 1) {
-        logger.debug("routing", "Routing reasoning", { reasoning: ctx.routing.reasoning, storyId: ctx.story.id });
+        logger.debug("routing", "Routing reasoning", { storyId: ctx.story.id, reasoning: ctx.routing.reasoning });
       }
       return { action: "continue" };
     }
@@ -56707,6 +56990,7 @@ var init_pipeline = __esm(() => {
   init_runner4();
   init_events();
   init_stages();
+  init_execution_helpers();
   init_event_bus();
 });
 
@@ -57113,11 +57397,11 @@ __export(exports_init_context, {
   _initContextDeps: () => _initContextDeps
 });
 import { basename as basename9, join as join52 } from "path";
-async function bunFileExists(path13) {
-  return Bun.file(path13).exists();
+async function bunFileExists(path14) {
+  return Bun.file(path14).exists();
 }
-async function bunMkdirp(path13) {
-  const proc = Bun.spawn(["mkdir", "-p", path13]);
+async function bunMkdirp(path14) {
+  const proc = Bun.spawn(["mkdir", "-p", path14]);
   await proc.exited;
 }
 async function findFiles(dir, maxFiles = 200) {
@@ -57183,8 +57467,8 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join52(projectRoot, candidate);
-    if (await bunFileExists(path13)) {
+    const path14 = join52(projectRoot, candidate);
+    if (await bunFileExists(path14)) {
       found.push(candidate);
     }
   }
@@ -57194,8 +57478,8 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join52(projectRoot, candidate);
-    if (await bunFileExists(path13)) {
+    const path14 = join52(projectRoot, candidate);
+    if (await bunFileExists(path14)) {
       found.push(candidate);
     }
   }
@@ -57981,10 +58265,10 @@ var init_setup_analyze = __esm(() => {
   init_workspace();
   CANONICAL_SCRIPTS = ["build", "test", "lint", "type-check", "lint:fix"];
   _analyzeRepoDeps = {
-    fileExists: async (path13) => Bun.file(path13).exists(),
-    readJson: async (path13) => {
+    fileExists: async (path14) => Bun.file(path14).exists(),
+    readJson: async (path14) => {
       try {
-        const f = Bun.file(path13);
+        const f = Bun.file(path14);
         if (!await f.exists())
           return null;
         return JSON.parse(await f.text());
@@ -58039,9 +58323,9 @@ async function fillScripts(workdir, analysis) {
 var TYPE_CHECK_KEY = "type-check", TYPE_CHECK_SCRIPT = "tsc --noEmit -p tsconfig.json", TYPE_CHECK_TURBO_PASSTHROUGH = "turbo run type-check", _fillScriptsDeps;
 var init_setup_fill = __esm(() => {
   _fillScriptsDeps = {
-    readJson: async (path13) => {
+    readJson: async (path14) => {
       try {
-        const f = Bun.file(path13);
+        const f = Bun.file(path14);
         if (!await f.exists())
           return null;
         return JSON.parse(await f.text());
@@ -58049,8 +58333,8 @@ var init_setup_fill = __esm(() => {
         return null;
       }
     },
-    writeFile: async (path13, content) => {
-      await Bun.write(path13, content);
+    writeFile: async (path14, content) => {
+      await Bun.write(path14, content);
     }
   };
 });
@@ -58171,10 +58455,10 @@ var init_setup = __esm(() => {
     },
     generateSetupPlan: (ctx, analysis) => generateSetupPlan(ctx, analysis),
     runGate: (workdir, config2) => runSetupGate(workdir, config2),
-    fileExists: (path13) => Bun.file(path13).exists(),
-    writeFile: (path13, content) => Bun.write(path13, content).then(() => {}),
-    mkdir: async (path13) => {
-      const proc = Bun.spawn(["mkdir", "-p", path13]);
+    fileExists: (path14) => Bun.file(path14).exists(),
+    writeFile: (path14, content) => Bun.write(path14, content).then(() => {}),
+    mkdir: async (path14) => {
+      const proc = Bun.spawn(["mkdir", "-p", path14]);
       await proc.exited;
     },
     stdout: (msg) => {
@@ -58189,7 +58473,7 @@ var init_setup = __esm(() => {
 });
 
 // src/plugins/builtin/curator/collect.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function now() {
   return new Date().toISOString();
 }
@@ -58239,7 +58523,7 @@ function tokenCount(story) {
 }
 async function collectFromMetrics(context) {
   const observations = [];
-  const metricsPath = path13.join(context.outputDir, "metrics.json");
+  const metricsPath = path14.join(context.outputDir, "metrics.json");
   try {
     const data = await readJsonFile(metricsPath);
     const runs = Array.isArray(data) ? data : [data];
@@ -58289,11 +58573,11 @@ function findingMessage(finding) {
 }
 async function collectFromReviewAudit(context) {
   const observations = [];
-  const auditDir = path13.join(context.outputDir, "review-audit");
+  const auditDir = path14.join(context.outputDir, "review-audit");
   try {
     const glob = new Bun.Glob("**/*.json");
     for await (const file3 of glob.scan({ cwd: auditDir, absolute: false })) {
-      const fullPath = path13.join(auditDir, file3);
+      const fullPath = path14.join(auditDir, file3);
       try {
         const audit = asRecord3(await readJsonFile(fullPath));
         if (!audit)
@@ -58333,11 +58617,11 @@ async function collectFromReviewAudit(context) {
 }
 async function collectFromContextManifests(context) {
   const observations = [];
-  const featuresDir = path13.join(context.workdir, ".nax", "features");
+  const featuresDir = path14.join(context.workdir, ".nax", "features");
   try {
     const glob = new Bun.Glob("*/stories/*/context-manifest-*.json");
     for await (const file3 of glob.scan({ cwd: featuresDir, absolute: false })) {
-      const fullPath = path13.join(featuresDir, file3);
+      const fullPath = path14.join(featuresDir, file3);
       try {
         const parts = file3.split("/");
         const featureId = parts[0] ?? context.feature;
@@ -58890,10 +59174,10 @@ function renderProposals(proposals, runId, observationCount) {
 
 // src/plugins/builtin/curator/rollup.ts
 import { appendFile as appendFile3, mkdir as mkdir9, writeFile } from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 async function appendToRollup(observations, rollupPath) {
   try {
-    const dir = path14.dirname(rollupPath);
+    const dir = path15.dirname(rollupPath);
     await mkdir9(dir, { recursive: true });
     if (observations.length === 0) {
       const f = Bun.file(rollupPath);
@@ -58912,7 +59196,7 @@ var init_rollup = () => {};
 
 // src/plugins/builtin/curator/index.ts
 import { mkdir as mkdir10 } from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 function getCuratorEnabled(context) {
   const cfg = context.config;
   if (!cfg)
@@ -58985,7 +59269,7 @@ var init_curator = __esm(() => {
         const observations = await collectObservations(curatorContext);
         if (context.outputDir) {
           const { observationsPath, rollupPath } = resolveCuratorOutputs(curatorContext);
-          const runDir = path15.dirname(observationsPath);
+          const runDir = path16.dirname(observationsPath);
           await mkdir10(runDir, { recursive: true });
           await Bun.write(observationsPath, observations.map((o) => JSON.stringify(o)).join(`
 `) + (observations.length > 0 ? `
@@ -58993,7 +59277,7 @@ var init_curator = __esm(() => {
           const thresholds = getCuratorThresholds(context);
           const proposals = runHeuristics(observations, thresholds);
           const markdown = renderProposals(proposals, context.runId, observations.length);
-          const proposalsMdPath = path15.join(runDir, "curator-proposals.md");
+          const proposalsMdPath = path16.join(runDir, "curator-proposals.md");
           await Bun.write(proposalsMdPath, markdown);
           await appendToRollup(observations, rollupPath);
         }
@@ -59363,14 +59647,14 @@ var init_validator = __esm(() => {
 
 // src/plugins/loader.ts
 import * as fs from "fs/promises";
-import * as path16 from "path";
+import * as path17 from "path";
 function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename11 = path16.basename(pluginPath);
+  const basename11 = path17.basename(pluginPath);
   if (basename11 === "index.ts" || basename11 === "index.js" || basename11 === "index.mjs") {
-    return path16.basename(path16.dirname(pluginPath));
+    return path17.basename(path17.dirname(pluginPath));
   }
   return basename11.replace(/\.(ts|js|mjs)$/, "");
 }
@@ -59456,7 +59740,7 @@ async function discoverPlugins(dir, isTestFileFn) {
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isFile()) {
         if (isPluginFile(entry.name, isTestFileFn)) {
           discovered.push({ path: fullPath });
@@ -59464,7 +59748,7 @@ async function discoverPlugins(dir, isTestFileFn) {
       } else if (entry.isDirectory()) {
         const indexPaths = ["index.ts", "index.js", "index.mjs"];
         for (const indexFile of indexPaths) {
-          const indexPath = path16.join(fullPath, indexFile);
+          const indexPath = path17.join(fullPath, indexFile);
           try {
             await fs.access(indexPath);
             discovered.push({ path: indexPath });
@@ -59489,13 +59773,13 @@ function isPluginFile(filename, isTestFileFn) {
   return !FALLBACK_TEST_FILE_RE.test(filename);
 }
 function resolveModulePath(modulePath, projectRoot) {
-  if (path16.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
+  if (path17.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
     return modulePath;
   }
   if (projectRoot) {
-    return path16.resolve(projectRoot, modulePath);
+    return path17.resolve(projectRoot, modulePath);
   }
-  return path16.resolve(modulePath);
+  return path17.resolve(modulePath);
 }
 async function loadAndValidatePlugin(initialModulePath, config2, allowedRoots = [], originalPath) {
   let attemptedPath = initialModulePath;
@@ -59811,7 +60095,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.69.9",
+    version: "0.70.0-canary.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -59906,8 +60190,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("03eecdb1"))
-        return "03eecdb1";
+      if (/^[0-9a-f]{6,10}$/.test("f895b7d3"))
+        return "f895b7d3";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -60293,7 +60577,7 @@ async function readSourceFileContent(filePath, workdir) {
 var MAX_SOURCE_FILES = 5, MAX_FILE_LINES2 = 500;
 
 // src/execution/lifecycle/acceptance-helpers.ts
-import path18 from "path";
+import path19 from "path";
 function isStubTestFile(content) {
   return isStubTestContent(content);
 }
@@ -60312,7 +60596,7 @@ function isTestLevelFailure(failedACs, totalACs, semanticVerdicts) {
 async function loadSpecContent(featureDir) {
   if (!featureDir)
     return "";
-  const specPath = path18.join(featureDir, "spec.md");
+  const specPath = path19.join(featureDir, "spec.md");
   const specFile = Bun.file(specPath);
   return await specFile.exists() ? await specFile.text() : "";
 }
@@ -60332,7 +60616,7 @@ async function loadAcceptanceTestContent2(featureDir, testPaths, configuredTestP
   }
   if (!configuredTestPath)
     return [];
-  const resolvedPath = path18.join(featureDir, configuredTestPath);
+  const resolvedPath = path19.join(featureDir, configuredTestPath);
   const testFile = Bun.file(resolvedPath);
   const content = await testFile.exists() ? await testFile.text() : "";
   return [{ content, path: resolvedPath }];
@@ -60349,7 +60633,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const { unlink: unlink3 } = await import("fs/promises");
   await unlink3(testPath);
   if (acceptanceContext.featureDir) {
-    const metaPath = path18.join(acceptanceContext.featureDir, "acceptance-meta.json");
+    const metaPath = path19.join(acceptanceContext.featureDir, "acceptance-meta.json");
     try {
       await unlink3(metaPath);
     } catch {}
@@ -60363,7 +60647,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
       const changedFilesRaw = diffOutput.split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
       const repoRoot = acceptanceContext.projectDir ?? workdir;
-      const packageDir = acceptanceContext.story.workdir && acceptanceContext.projectDir ? path18.join(acceptanceContext.projectDir, acceptanceContext.story.workdir) : undefined;
+      const packageDir = acceptanceContext.story.workdir && acceptanceContext.projectDir ? path19.join(acceptanceContext.projectDir, acceptanceContext.story.workdir) : undefined;
       const ignoreMatchers = acceptanceContext.naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
       const changedFiles = filterNaxInternalPaths(changedFilesRaw, ignoreMatchers);
       const MAX_BYTES = 51200;
@@ -60372,7 +60656,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
       for (const file3 of changedFiles) {
         if (totalBytes >= MAX_BYTES)
           break;
-        const filePath = path18.join(workdir, file3);
+        const filePath = path19.join(workdir, file3);
         try {
           const fileContent = await _regenerateDeps.readFile(filePath);
           const remaining = MAX_BYTES - totalBytes;
@@ -60831,9 +61115,9 @@ var init_scratch_purge = __esm(() => {
         return [];
       }
     },
-    fileExists: (path19) => Bun.file(path19).exists(),
-    readFile: (path19) => Bun.file(path19).text(),
-    remove: (path19) => rm(path19, { recursive: true, force: true }),
+    fileExists: (path20) => Bun.file(path20).exists(),
+    readFile: (path20) => Bun.file(path20).text(),
+    remove: (path20) => rm(path20, { recursive: true, force: true }),
     move: async (src, dest) => {
       await mkdir12(dirname12(dest), { recursive: true });
       await rename(src, dest);
@@ -62537,17 +62821,12 @@ var init_merge = __esm(() => {
 });
 
 // src/execution/escalation/escalation.ts
-function escalateTier(currentTier, tierOrder) {
-  const getName = (t) => t.tier ?? t.name ?? null;
-  const currentIndex = tierOrder.findIndex((t) => getName(t) === currentTier);
-  if (currentIndex === -1 || currentIndex === tierOrder.length - 1) {
+function escalateTier(currentRung, tierOrder) {
+  const i = currentRung.agent !== undefined ? tierOrder.findIndex((t) => t.tier === currentRung.tier && t.agent === currentRung.agent) : tierOrder.findIndex((t) => t.tier === currentRung.tier);
+  if (i === -1 || i === tierOrder.length - 1)
     return null;
-  }
-  const next = tierOrder[currentIndex + 1];
-  const nextName = getName(next);
-  if (!nextName)
-    return null;
-  return { tier: nextName, agent: next.agent };
+  const next = tierOrder[i + 1];
+  return { tier: next.tier, agent: next.agent };
 }
 function calculateMaxIterations(tierOrder) {
   return tierOrder.reduce((sum, t) => sum + t.attempts, 0);
@@ -62610,9 +62889,9 @@ var _quoteIntegrityDeps, CONTEXT_LINES = 3;
 var init_quote_integrity = __esm(() => {
   init_logger2();
   _quoteIntegrityDeps = {
-    readFile: async (path20) => {
+    readFile: async (path21) => {
       try {
-        return await Bun.file(path20).text();
+        return await Bun.file(path21).text();
       } catch {
         return null;
       }
@@ -62767,7 +63046,10 @@ async function handleTierEscalation(ctx) {
     });
     return { outcome: "retry-same", prdDirty: false, prd: ctx.prd };
   }
-  const escalationResult = escalateTier(ctx.routing.modelTier, ctx.config.autoMode.escalation.tierOrder);
+  const escalationTierOrder = ctx.config.autoMode.escalation.tierOrder;
+  const hasAgentRungs = escalationTierOrder.some((r) => r.agent !== undefined);
+  const currentRung = hasAgentRungs ? { tier: ctx.routing.modelTier, agent: ctx.story.routing?.agent } : { tier: ctx.routing.modelTier };
+  const escalationResult = escalateTier(currentRung, escalationTierOrder);
   const nextAgent = escalationResult?.agent;
   const escalateWholeBatch = ctx.config.autoMode.escalation.escalateEntireBatch ?? true;
   const storiesToEscalate = ctx.isBatchExecution && escalateWholeBatch ? ctx.storiesToExecute : [ctx.story];
@@ -62875,7 +63157,8 @@ var init_tier_escalation = __esm(() => {
   init_quote_integrity();
   init_tier_outcome();
   _tierEscalationDeps = {
-    savePRD
+    savePRD,
+    getSafeLogger
   };
 });
 
@@ -62889,7 +63172,7 @@ var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
   rectifyConflictedStory: () => rectifyConflictedStory
 });
-import path20 from "path";
+import path21 from "path";
 async function closeStaleAcpSession(worktreePath, sessionName) {
   const logger = getSafeLogger();
   try {
@@ -62916,7 +63199,7 @@ async function rectifyConflictedStory(options) {
       await worktreeManager.remove(workdir, storyId);
     } catch {}
     await worktreeManager.create(workdir, storyId);
-    const worktreePath = path20.join(workdir, ".nax-wt", storyId);
+    const worktreePath = path21.join(workdir, ".nax-wt", storyId);
     const { formatSessionName: formatSessionName2 } = await Promise.resolve().then(() => (init_naming(), exports_naming));
     const staleSessionName = formatSessionName2({
       workdir: worktreePath,
@@ -63599,7 +63882,7 @@ __export(exports_parallel_batch, {
   runParallelBatch: () => runParallelBatch,
   _parallelBatchDeps: () => _parallelBatchDeps
 });
-import path21 from "path";
+import path22 from "path";
 async function runParallelBatch(options) {
   const { stories, ctx, prd } = options;
   const { workdir, config: config2, maxConcurrency, pipelineContext, eventEmitter, agentGetFn, hooks, pluginRegistry } = ctx;
@@ -63618,9 +63901,9 @@ async function runParallelBatch(options) {
       });
       throw error48;
     }
-    worktreePaths.set(story.id, path21.join(workdir, ".nax-wt", story.id));
+    worktreePaths.set(story.id, path22.join(workdir, ".nax-wt", story.id));
   }
-  const rootConfigPath = path21.join(workdir, ".nax", "config.json");
+  const rootConfigPath = path22.join(workdir, ".nax", "config.json");
   const profileOverride = config2.profile && config2.profile !== "default" ? { profile: config2.profile } : undefined;
   const storyEffectiveConfigs = new Map;
   const configResults = await Promise.allSettled(stories.filter((story) => story.workdir).map(async (story) => {
@@ -64537,7 +64820,7 @@ __export(exports_migrate, {
 });
 import { existsSync as existsSync33 } from "fs";
 import { mkdir as mkdir16, readdir as readdir5, rename as rename3 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync33(naxDir))
     return [];
@@ -64550,17 +64833,17 @@ async function detectGeneratedContent(naxDir) {
   }
   for (const entry of entries) {
     if (GENERATED_NAMES.has(entry)) {
-      candidates.push({ name: entry, srcPath: path22.join(naxDir, entry) });
+      candidates.push({ name: entry, srcPath: path23.join(naxDir, entry) });
     }
   }
-  const featuresDir = path22.join(naxDir, "features");
+  const featuresDir = path23.join(naxDir, "features");
   if (existsSync33(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir5(featuresDir);
     } catch {}
     for (const fid of featureDirs) {
-      const featureDir = path22.join(featuresDir, fid);
+      const featureDir = path23.join(featuresDir, fid);
       let subEntries = [];
       try {
         subEntries = await readdir5(featureDir);
@@ -64570,12 +64853,12 @@ async function detectGeneratedContent(naxDir) {
       for (const sub of subEntries) {
         if (GENERATED_FEATURE_SUBNAMES.has(sub)) {
           candidates.push({
-            name: path22.join("features", fid, sub),
-            srcPath: path22.join(featureDir, sub)
+            name: path23.join("features", fid, sub),
+            srcPath: path23.join(featureDir, sub)
           });
         }
         if (sub === "stories") {
-          const storiesDir = path22.join(featureDir, "stories");
+          const storiesDir = path23.join(featureDir, "stories");
           let storyDirs = [];
           try {
             storyDirs = await readdir5(storiesDir);
@@ -64583,7 +64866,7 @@ async function detectGeneratedContent(naxDir) {
             continue;
           }
           for (const sid of storyDirs) {
-            const storyDir = path22.join(storiesDir, sid);
+            const storyDir = path23.join(storiesDir, sid);
             let storyEntries = [];
             try {
               storyEntries = await readdir5(storyDir);
@@ -64593,8 +64876,8 @@ async function detectGeneratedContent(naxDir) {
             for (const se of storyEntries) {
               if (se.startsWith("context-manifest-") && se.endsWith(".json")) {
                 candidates.push({
-                  name: path22.join("features", fid, "stories", sid, se),
-                  srcPath: path22.join(storyDir, se)
+                  name: path23.join("features", fid, "stories", sid, se),
+                  srcPath: path23.join(storyDir, se)
                 });
               }
             }
@@ -64615,15 +64898,15 @@ async function migrateCommand(options) {
         name: options.reclaim
       });
     }
-    const src = path22.join(globalConfigDir(), options.reclaim);
+    const src = path23.join(globalConfigDir(), options.reclaim);
     if (!existsSync33(src)) {
       throw new NaxError(`Nothing to reclaim: ~/.nax/${options.reclaim} does not exist`, "MIGRATE_RECLAIM_NOT_FOUND", {
         stage: "migrate",
         name: options.reclaim
       });
     }
-    const archiveBase = path22.join(globalConfigDir(), "_archive");
-    const archiveDest = path22.join(archiveBase, `${options.reclaim}-${Date.now()}`);
+    const archiveBase = path23.join(globalConfigDir(), "_archive");
+    const archiveDest = path23.join(archiveBase, `${options.reclaim}-${Date.now()}`);
     await mkdir16(archiveBase, { recursive: true });
     await rename3(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
@@ -64660,8 +64943,8 @@ async function migrateCommand(options) {
     logger.info("migrate", `Merged: identity for "${options.merge}" updated`, { storyId: "_migrate" });
     return;
   }
-  const naxDir = path22.join(options.workdir, ".nax");
-  const configPath = path22.join(naxDir, "config.json");
+  const naxDir = path23.join(options.workdir, ".nax");
+  const configPath = path23.join(naxDir, "config.json");
   if (!existsSync33(configPath)) {
     throw new NaxError("No .nax/config.json found \u2014 run nax init first", "MIGRATE_NO_CONFIG", {
       stage: "migrate",
@@ -64677,7 +64960,7 @@ async function migrateCommand(options) {
       cause: e
     });
   }
-  const projectKey = config2.name?.trim() || path22.basename(options.workdir);
+  const projectKey = config2.name?.trim() || path23.basename(options.workdir);
   const destBase = projectOutputDir(projectKey, config2.outputDir);
   const candidates = await detectGeneratedContent(naxDir);
   if (candidates.length === 0) {
@@ -64686,7 +64969,7 @@ async function migrateCommand(options) {
   }
   if (options.dryRun) {
     for (const c of candidates) {
-      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path22.join(destBase, c.name)}`, {
+      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path23.join(destBase, c.name)}`, {
         storyId: "_migrate"
       });
     }
@@ -64695,8 +64978,8 @@ async function migrateCommand(options) {
   await mkdir16(destBase, { recursive: true });
   let moved = 0;
   for (const candidate of candidates) {
-    const dest = path22.join(destBase, candidate.name);
-    await mkdir16(path22.dirname(dest), { recursive: true });
+    const dest = path23.join(destBase, candidate.name);
+    await mkdir16(path23.dirname(dest), { recursive: true });
     if (existsSync33(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
@@ -64726,7 +65009,7 @@ async function migrateCommand(options) {
     moved++;
     logger.info("migrate", `Moved: ${candidate.name}`, { storyId: "_migrate" });
   }
-  await Bun.write(path22.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
+  await Bun.write(path23.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
   logger.info("migrate", `Migration complete: ${moved} entries moved`, {
     storyId: "_migrate",
     destBase
@@ -64843,7 +65126,7 @@ __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
 import { mkdirSync as mkdirSync6 } from "fs";
-import path23 from "path";
+import path24 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
   if (process.env.NAX_PRECHECK !== "1") {
@@ -64858,7 +65141,7 @@ async function runPrecheckValidation(ctx) {
     silent: true
   });
   if (ctx.logFilePath) {
-    mkdirSync6(path23.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync6(path24.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -65155,11 +65438,33 @@ var init_paused_story_prompts = __esm(() => {
 // src/execution/lifecycle/run-setup.ts
 var exports_run_setup = {};
 __export(exports_run_setup, {
+  warnProfileMismatch: () => warnProfileMismatch,
   warnFallbackMisconfiguration: () => warnFallbackMisconfiguration,
   setupRun: () => setupRun,
   _runSetupDeps: () => _runSetupDeps
 });
-import path24 from "path";
+import path25 from "path";
+function warnProfileMismatch(prd, config2, logger) {
+  const profiles = config2.routing?.agents?.profiles ?? [];
+  const profileIds = new Set(profiles.map((p) => p.id));
+  if (prd.routingProfile !== undefined) {
+    const current = config2.profile ?? "default";
+    if (prd.routingProfile !== current) {
+      logger?.warn("prd", `PRD was planned with config profile "${prd.routingProfile}" but this run resolved profile "${current}" \u2014 the escalation ladder and agent profiles may differ from what plan assumed. Re-run with --profile ${prd.routingProfile} to match.`, { storyId: "prd", plannedProfile: prd.routingProfile, currentProfile: current });
+    }
+  }
+  const knownAgents = new Set(Object.keys(config2.models ?? {}));
+  for (const story of prd.userStories) {
+    const profileId = story.routing?.agentProfileId;
+    if (profileId && !profileIds.has(profileId)) {
+      logger?.warn("setup", `Story ${story.id} was planned with profile ${profileId} which no longer exists in config \u2014 routing.agent assignment retained`, { storyId: story.id, agentProfileId: profileId });
+    }
+    const storyAgent = story.routing?.agent;
+    if (storyAgent && !knownAgents.has(storyAgent)) {
+      logger?.warn("setup", `Story ${story.id} routes to agent "${storyAgent}" which is not defined in config.models \u2014 execution will degrade to the default agent`, { storyId: story.id, agent: storyAgent });
+    }
+  }
+}
 function warnFallbackMisconfiguration(config2, agentGetFn, logger) {
   if (!agentGetFn)
     return;
@@ -65173,6 +65478,7 @@ function warnFallbackMisconfiguration(config2, agentGetFn, logger) {
         continue;
       if (!agentGetFn(candidate)) {
         logger?.warn("fallback", "Fallback candidate not available \u2014 will be skipped if triggered", {
+          storyId: "_setup",
           primaryAgent,
           candidate
         });
@@ -65258,7 +65564,7 @@ async function setupRun(options) {
   statusWriter.setPrd(prd);
   {
     const { detectGeneratedContent: detectGeneratedContent2, migrateCommand: migrateCommand2 } = await Promise.resolve().then(() => (init_migrate(), exports_migrate));
-    const naxDir = path24.join(workdir, ".nax");
+    const naxDir = path25.join(workdir, ".nax");
     const candidates = await detectGeneratedContent2(naxDir).catch(() => []);
     if (candidates.length > 0) {
       logger?.info("setup", "Found generated content under .nax/ \u2014 migrating to output dir", {
@@ -65285,7 +65591,7 @@ async function setupRun(options) {
         remoteUrl = new TextDecoder().decode(gitResult.stdout).trim() || null;
       }
     } catch {}
-    const projectKey = config2.name?.trim() || path24.basename(workdir);
+    const projectKey = config2.name?.trim() || path25.basename(workdir);
     await claimProjectIdentity2(projectKey, workdir, remoteUrl).catch((err) => {
       if (err instanceof NaxError && err.code === "RUN_NAME_COLLISION") {
         throw err;
@@ -65340,8 +65646,8 @@ async function setupRun(options) {
       explicit: Object.fromEntries(explicitFields.map((f) => [f, existingProjectConfig[f]])),
       detected: Object.fromEntries(autodetectedFields.map((f) => [f, detectedProfile[f]]))
     });
-    const globalPluginsDir = path24.join(globalConfigDir(), "plugins");
-    const projectPluginsDir = path24.join(workdir, ".nax", "plugins");
+    const globalPluginsDir = path25.join(globalConfigDir(), "plugins");
+    const projectPluginsDir = path25.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
@@ -65370,6 +65676,7 @@ async function setupRun(options) {
     });
     prd = initResult.prd;
     statusWriter.setPrd(prd);
+    warnProfileMismatch(prd, config2, logger);
     let counts = initResult.storyCounts;
     if (counts.paused > 0 && interactionChain !== null) {
       const { promptForPausedStories: promptForPausedStories2 } = await Promise.resolve().then(() => (init_paused_story_prompts(), exports_paused_story_prompts));
@@ -66832,11 +67139,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
         fiber = fiber.next, id--;
       return fiber;
     }
-    function copyWithSetImpl(obj, path25, index, value) {
-      if (index >= path25.length)
+    function copyWithSetImpl(obj, path26, index, value) {
+      if (index >= path26.length)
         return value;
-      var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      updated[key] = copyWithSetImpl(obj[key], path25, index + 1, value);
+      var key = path26[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path26, index + 1, value);
       return updated;
     }
     function copyWithRename(obj, oldPath, newPath) {
@@ -66856,11 +67163,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
       return updated;
     }
-    function copyWithDeleteImpl(obj, path25, index) {
-      var key = path25[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      if (index + 1 === path25.length)
+    function copyWithDeleteImpl(obj, path26, index) {
+      var key = path26[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      if (index + 1 === path26.length)
         return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-      updated[key] = copyWithDeleteImpl(obj[key], path25, index + 1);
+      updated[key] = copyWithDeleteImpl(obj[key], path26, index + 1);
       return updated;
     }
     function shouldSuspendImpl() {
@@ -76883,29 +77190,29 @@ Check the top-level render call using <` + componentName2 + ">.");
     var didWarnAboutNestedUpdates = false;
     var didWarnAboutFindNodeInStrictMode = {};
     var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
-    overrideHookState = function(fiber, id, path25, value) {
+    overrideHookState = function(fiber, id, path26, value) {
       id = findHook(fiber, id);
-      id !== null && (path25 = copyWithSetImpl(id.memoizedState, path25, 0, value), id.memoizedState = path25, id.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2));
+      id !== null && (path26 = copyWithSetImpl(id.memoizedState, path26, 0, value), id.memoizedState = path26, id.baseState = path26, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path26 = enqueueConcurrentRenderForLane(fiber, 2), path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2));
     };
-    overrideHookStateDeletePath = function(fiber, id, path25) {
+    overrideHookStateDeletePath = function(fiber, id, path26) {
       id = findHook(fiber, id);
-      id !== null && (path25 = copyWithDeleteImpl(id.memoizedState, path25, 0), id.memoizedState = path25, id.baseState = path25, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path25 = enqueueConcurrentRenderForLane(fiber, 2), path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2));
+      id !== null && (path26 = copyWithDeleteImpl(id.memoizedState, path26, 0), id.memoizedState = path26, id.baseState = path26, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path26 = enqueueConcurrentRenderForLane(fiber, 2), path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2));
     };
     overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
       id = findHook(fiber, id);
       id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
     };
-    overrideProps = function(fiber, path25, value) {
-      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path25, 0, value);
+    overrideProps = function(fiber, path26, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path26, 0, value);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path25 = enqueueConcurrentRenderForLane(fiber, 2);
-      path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
+      path26 = enqueueConcurrentRenderForLane(fiber, 2);
+      path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2);
     };
-    overridePropsDeletePath = function(fiber, path25) {
-      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path25, 0);
+    overridePropsDeletePath = function(fiber, path26) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path26, 0);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path25 = enqueueConcurrentRenderForLane(fiber, 2);
-      path25 !== null && scheduleUpdateOnFiber(path25, fiber, 2);
+      path26 = enqueueConcurrentRenderForLane(fiber, 2);
+      path26 !== null && scheduleUpdateOnFiber(path26, fiber, 2);
     };
     overridePropsRenamePath = function(fiber, oldPath, newPath) {
       fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -80960,8 +81267,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return false;
         }
-        function utils_getInObject(object2, path25) {
-          return path25.reduce(function(reduced, attr) {
+        function utils_getInObject(object2, path26) {
+          return path26.reduce(function(reduced, attr) {
             if (reduced) {
               if (utils_hasOwnProperty.call(reduced, attr)) {
                 return reduced[attr];
@@ -80973,11 +81280,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }, object2);
         }
-        function deletePathInObject(object2, path25) {
-          var length = path25.length;
-          var last2 = path25[length - 1];
+        function deletePathInObject(object2, path26) {
+          var length = path26.length;
+          var last2 = path26[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path25.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path26.slice(0, length - 1));
             if (parent) {
               if (src_isArray(parent)) {
                 parent.splice(last2, 1);
@@ -81003,11 +81310,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
           }
         }
-        function utils_setInObject(object2, path25, value) {
-          var length = path25.length;
-          var last2 = path25[length - 1];
+        function utils_setInObject(object2, path26, value) {
+          var length = path26.length;
+          var last2 = path26[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path25.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path26.slice(0, length - 1));
             if (parent) {
               parent[last2] = value;
             }
@@ -81538,8 +81845,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           unserializable: Symbol("unserializable")
         };
         var LEVEL_THRESHOLD = 2;
-        function createDehydrated(type, inspectable, data, cleaned, path25) {
-          cleaned.push(path25);
+        function createDehydrated(type, inspectable, data, cleaned, path26) {
+          cleaned.push(path26);
           var dehydrated = {
             inspectable,
             type,
@@ -81557,13 +81864,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return dehydrated;
         }
-        function dehydrate(data, cleaned, unserializable, path25, isPathAllowed) {
+        function dehydrate(data, cleaned, unserializable, path26, isPathAllowed) {
           var level = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
           var type = getDataType(data);
           var isPathAllowedCheck;
           switch (type) {
             case "html_element":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81572,7 +81879,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "function":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81581,14 +81888,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "string":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (isPathAllowedCheck) {
                 return data;
               } else {
                 return data.length <= 500 ? data : data.slice(0, 500) + "...";
               }
             case "bigint":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81597,7 +81904,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "symbol":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81606,9 +81913,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "react_element": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 return {
                   inspectable: true,
                   preview_short: formatDataForPreview(data, false),
@@ -81625,19 +81932,19 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: getDisplayNameForReactElement(data) || "Unknown"
               };
-              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path25.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path26.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if (data.$$typeof === REACT_LEGACY_ELEMENT_TYPE) {
-                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path25.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path26.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
-              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path25.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path25);
+              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path26.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path26);
               return unserializableValue;
             }
             case "react_lazy": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               var payload = data._payload;
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 var inspectable = payload !== null && hydration_typeof(payload) === "object" && (payload._status === 1 || payload._status === 2 || payload.status === "fulfilled" || payload.status === "rejected");
                 return {
                   inspectable,
@@ -81654,13 +81961,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: "lazy()"
               };
-              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path25.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path25);
+              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path26.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path26);
               return _unserializableValue;
             }
             case "array_buffer":
             case "data_view":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81670,21 +81977,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "array":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var arr = [];
               for (var i = 0;i < data.length; i++) {
-                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path25.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path26.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               return arr;
             case "html_all_collection":
             case "typed_array":
             case "iterator":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               } else {
                 var _unserializableValue2 = {
                   unserializable: true,
@@ -81696,13 +82003,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   name: typeof data.constructor !== "function" || typeof data.constructor.name !== "string" || data.constructor.name === "Object" ? "" : data.constructor.name
                 };
                 Array.from(data).forEach(function(item, i2) {
-                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path25.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path26.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
-                unserializable.push(path25);
+                unserializable.push(path26);
                 return _unserializableValue2;
               }
             case "opaque_iterator":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81711,7 +82018,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "date":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81720,7 +82027,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "regexp":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -81729,9 +82036,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "thenable":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path25);
+                cleaned.push(path26);
                 return {
                   inspectable: data.status === "fulfilled" || data.status === "rejected",
                   preview_short: formatDataForPreview(data, false),
@@ -81752,8 +82059,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "fulfilled Thenable"
                   };
-                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path25.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path25);
+                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path26.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path26);
                   return _unserializableValue3;
                 }
                 case "rejected": {
@@ -81764,12 +82071,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "rejected Thenable"
                   };
-                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path25.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path25);
+                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path26.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path26);
                   return _unserializableValue4;
                 }
                 default:
-                  cleaned.push(path25);
+                  cleaned.push(path26);
                   return {
                     inspectable: false,
                     preview_short: formatDataForPreview(data, false),
@@ -81779,21 +82086,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   };
               }
             case "object":
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               } else {
                 var object2 = {};
                 getAllEnumerableKeys(data).forEach(function(key) {
                   var name = key.toString();
-                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path25.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path26.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
                 return object2;
               }
             case "class_instance": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var value = {
                 unserializable: true,
@@ -81805,15 +82112,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               };
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path25.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path26.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path25);
+              unserializable.push(path26);
               return value;
             }
             case "error": {
-              isPathAllowedCheck = isPathAllowed(path25);
+              isPathAllowedCheck = isPathAllowed(path26);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path25);
+                return createDehydrated(type, true, data, cleaned, path26);
               }
               var _value = {
                 unserializable: true,
@@ -81823,22 +82130,22 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: data.name
               };
-              _value.message = dehydrate(data.message, cleaned, unserializable, path25.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              _value.stack = dehydrate(data.stack, cleaned, unserializable, path25.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.message = dehydrate(data.message, cleaned, unserializable, path26.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.stack = dehydrate(data.stack, cleaned, unserializable, path26.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if ("cause" in data) {
-                _value.cause = dehydrate(data.cause, cleaned, unserializable, path25.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value.cause = dehydrate(data.cause, cleaned, unserializable, path26.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path25.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path26.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path25);
+              unserializable.push(path26);
               return _value;
             }
             case "infinity":
             case "nan":
             case "undefined":
-              cleaned.push(path25);
+              cleaned.push(path26);
               return {
                 type
               };
@@ -81846,10 +82153,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               return data;
           }
         }
-        function dehydrateKey(parent, key, cleaned, unserializable, path25, isPathAllowed) {
+        function dehydrateKey(parent, key, cleaned, unserializable, path26, isPathAllowed) {
           var level = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
           try {
-            return dehydrate(parent[key], cleaned, unserializable, path25, isPathAllowed, level);
+            return dehydrate(parent[key], cleaned, unserializable, path26, isPathAllowed, level);
           } catch (error48) {
             var preview = "";
             if (hydration_typeof(error48) === "object" && error48 !== null && typeof error48.stack === "string") {
@@ -81857,7 +82164,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             } else if (typeof error48 === "string") {
               preview = error48;
             }
-            cleaned.push(path25);
+            cleaned.push(path26);
             return {
               inspectable: false,
               preview_short: "[Exception]",
@@ -81867,8 +82174,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
         }
-        function fillInPath(object2, data, path25, value) {
-          var target = getInObject(object2, path25);
+        function fillInPath(object2, data, path26, value) {
+          var target = getInObject(object2, path26);
           if (target != null) {
             if (!target[meta3.unserializable]) {
               delete target[meta3.inspectable];
@@ -81883,9 +82190,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           if (value !== null && data.unserializable.length > 0) {
             var unserializablePath = data.unserializable[0];
-            var isMatch2 = unserializablePath.length === path25.length;
-            for (var i = 0;i < path25.length; i++) {
-              if (path25[i] !== unserializablePath[i]) {
+            var isMatch2 = unserializablePath.length === path26.length;
+            for (var i = 0;i < path26.length; i++) {
+              if (path26[i] !== unserializablePath[i]) {
                 isMatch2 = false;
                 break;
               }
@@ -81894,13 +82201,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               upgradeUnserializable(value, value);
             }
           }
-          setInObject(object2, path25, value);
+          setInObject(object2, path26, value);
         }
         function hydrate(object2, cleaned, unserializable) {
-          cleaned.forEach(function(path25) {
-            var length = path25.length;
-            var last2 = path25[length - 1];
-            var parent = getInObject(object2, path25.slice(0, length - 1));
+          cleaned.forEach(function(path26) {
+            var length = path26.length;
+            var last2 = path26[length - 1];
+            var parent = getInObject(object2, path26.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -81926,10 +82233,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               parent[last2] = replaced;
             }
           });
-          unserializable.forEach(function(path25) {
-            var length = path25.length;
-            var last2 = path25[length - 1];
-            var parent = getInObject(object2, path25.slice(0, length - 1));
+          unserializable.forEach(function(path26) {
+            var length = path26.length;
+            var last2 = path26[length - 1];
+            var parent = getInObject(object2, path26.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -82050,11 +82357,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return gte2(version2, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
         }
         function cleanForBridge(data, isPathAllowed) {
-          var path25 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+          var path26 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
           if (data !== null) {
             var cleanedPaths = [];
             var unserializablePaths = [];
-            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path25, isPathAllowed);
+            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path26, isPathAllowed);
             return {
               data: cleanedData,
               cleaned: cleanedPaths,
@@ -82064,18 +82371,18 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }
         }
-        function copyWithDelete(obj, path25) {
+        function copyWithDelete(obj, path26) {
           var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-          var key = path25[index];
+          var key = path26[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          if (index + 1 === path25.length) {
+          if (index + 1 === path26.length) {
             if (shared_isArray(updated)) {
               updated.splice(key, 1);
             } else {
               delete updated[key];
             }
           } else {
-            updated[key] = copyWithDelete(obj[key], path25, index + 1);
+            updated[key] = copyWithDelete(obj[key], path26, index + 1);
           }
           return updated;
         }
@@ -82096,14 +82403,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return updated;
         }
-        function copyWithSet(obj, path25, value) {
+        function copyWithSet(obj, path26, value) {
           var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-          if (index >= path25.length) {
+          if (index >= path26.length) {
             return value;
           }
-          var key = path25[index];
+          var key = path26[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          updated[key] = copyWithSet(obj[key], path25, value, index + 1);
+          updated[key] = copyWithSet(obj[key], path26, value, index + 1);
           return updated;
         }
         function getEffectDurations(root) {
@@ -83431,12 +83738,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             bridge_defineProperty(_this, "overrideValueAtPath", function(_ref) {
-              var { id, path: path25, rendererID, type, value } = _ref;
+              var { id, path: path26, rendererID, type, value } = _ref;
               switch (type) {
                 case "context":
                   _this.send("overrideContext", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -83445,7 +83752,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "hooks":
                   _this.send("overrideHookState", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -83454,7 +83761,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "props":
                   _this.send("overrideProps", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -83463,7 +83770,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "state":
                   _this.send("overrideState", {
                     id,
-                    path: path25,
+                    path: path26,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -83797,12 +84104,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "copyElementPath", function(_ref5) {
-              var { id, path: path25, rendererID } = _ref5;
+              var { id, path: path26, rendererID } = _ref5;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                var value = renderer.getSerializedElementValueByPath(id, path25);
+                var value = renderer.getSerializedElementValueByPath(id, path26);
                 if (value != null) {
                   _this._bridge.send("saveToClipboard", value);
                 } else {
@@ -83811,12 +84118,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "deletePath", function(_ref6) {
-              var { hookID, id, path: path25, rendererID, type } = _ref6;
+              var { hookID, id, path: path26, rendererID, type } = _ref6;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.deletePath(type, id, hookID, path25);
+                renderer.deletePath(type, id, hookID, path26);
               }
             });
             agent_defineProperty(_this, "getBackendVersion", function() {
@@ -83853,12 +84160,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "inspectElement", function(_ref9) {
-              var { forceFullData, id, path: path25, rendererID, requestID } = _ref9;
+              var { forceFullData, id, path: path26, rendererID, requestID } = _ref9;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path25, forceFullData));
+                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path26, forceFullData));
                 if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
                   _this._persistedSelection = null;
                   _this._persistedSelectionMatch = null;
@@ -83892,15 +84199,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
               for (var rendererID in _this._rendererInterfaces) {
                 var renderer = _this._rendererInterfaces[rendererID];
-                var path25 = null;
+                var path26 = null;
                 if (suspendedByPathIndex !== null && rendererPath !== null) {
                   var suspendedByPathRendererIndex = suspendedByPathIndex - suspendedByOffset;
                   var rendererHasRequestedSuspendedByPath = renderer.getElementAttributeByPath(id, ["suspendedBy", suspendedByPathRendererIndex]) !== undefined;
                   if (rendererHasRequestedSuspendedByPath) {
-                    path25 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
+                    path26 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
                   }
                 }
-                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path25, forceFullData);
+                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path26, forceFullData);
                 switch (inspectedRootsPayload.type) {
                   case "hydrated-path":
                     inspectedRootsPayload.path[1] += suspendedByOffset;
@@ -83994,20 +84301,20 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideValueAtPath", function(_ref15) {
-              var { hookID, id, path: path25, rendererID, type, value } = _ref15;
+              var { hookID, id, path: path26, rendererID, type, value } = _ref15;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.overrideValueAtPath(type, id, hookID, path25, value);
+                renderer.overrideValueAtPath(type, id, hookID, path26, value);
               }
             });
             agent_defineProperty(_this, "overrideContext", function(_ref16) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref16;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref16;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "context",
                   value
@@ -84015,11 +84322,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideHookState", function(_ref17) {
-              var { id, hookID, path: path25, rendererID, wasForwarded, value } = _ref17;
+              var { id, hookID, path: path26, rendererID, wasForwarded, value } = _ref17;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "hooks",
                   value
@@ -84027,11 +84334,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideProps", function(_ref18) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref18;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref18;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "props",
                   value
@@ -84039,11 +84346,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideState", function(_ref19) {
-              var { id, path: path25, rendererID, wasForwarded, value } = _ref19;
+              var { id, path: path26, rendererID, wasForwarded, value } = _ref19;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path25,
+                  path: path26,
                   rendererID,
                   type: "state",
                   value
@@ -84110,12 +84417,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               _this._bridge.send("stopInspectingHost", selected);
             });
             agent_defineProperty(_this, "storeAsGlobal", function(_ref23) {
-              var { count, id, path: path25, rendererID } = _ref23;
+              var { count, id, path: path26, rendererID } = _ref23;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.storeAsGlobal(id, path25, count);
+                renderer.storeAsGlobal(id, path26, count);
               }
             });
             agent_defineProperty(_this, "updateHookSettings", function(settings) {
@@ -84132,12 +84439,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 var rendererID = +rendererIDString;
                 var renderer = _this._rendererInterfaces[rendererID];
                 if (_this._lastSelectedRendererID === rendererID) {
-                  var path25 = renderer.getPathForElement(_this._lastSelectedElementID);
-                  if (path25 !== null) {
-                    renderer.setTrackedPath(path25);
+                  var path26 = renderer.getPathForElement(_this._lastSelectedElementID);
+                  if (path26 !== null) {
+                    renderer.setTrackedPath(path26);
                     _this._persistedSelection = {
                       rendererID,
-                      path: path25
+                      path: path26
                     };
                   }
                 }
@@ -84212,11 +84519,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               var rendererID = _this._lastSelectedRendererID;
               var id = _this._lastSelectedElementID;
               var renderer = _this._rendererInterfaces[rendererID];
-              var path25 = renderer != null ? renderer.getPathForElement(id) : null;
-              if (path25 !== null) {
+              var path26 = renderer != null ? renderer.getPathForElement(id) : null;
+              if (path26 !== null) {
                 storage_sessionStorageSetItem(SESSION_STORAGE_LAST_SELECTION_KEY, JSON.stringify({
                   rendererID,
-                  path: path25
+                  path: path26
                 }));
               } else {
                 storage_sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);
@@ -84939,7 +85246,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             hasElementWithId: function hasElementWithId() {
               return false;
             },
-            inspectElement: function inspectElement(requestID, id, path25) {
+            inspectElement: function inspectElement(requestID, id, path26) {
               return {
                 id,
                 responseID: requestID,
@@ -90209,9 +90516,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
             return null;
           }
-          function getElementAttributeByPath(id, path25) {
+          function getElementAttributeByPath(id, path26) {
             if (isMostRecentlyInspectedElement(id)) {
-              return utils_getInObject(mostRecentlyInspectedElement, path25);
+              return utils_getInObject(mostRecentlyInspectedElement, path26);
             }
             return;
           }
@@ -90914,9 +91221,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           function isMostRecentlyInspectedElementCurrent(id) {
             return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
           }
-          function mergeInspectedPaths(path25) {
+          function mergeInspectedPaths(path26) {
             var current = currentlyInspectedPaths;
-            path25.forEach(function(key) {
+            path26.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -90924,21 +91231,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             });
           }
           function createIsPathAllowed(key, secondaryCategory) {
-            return function isPathAllowed(path25) {
+            return function isPathAllowed(path26) {
               switch (secondaryCategory) {
                 case "hooks":
-                  if (path25.length === 1) {
+                  if (path26.length === 1) {
                     return true;
                   }
-                  if (path25[path25.length - 2] === "hookSource" && path25[path25.length - 1] === "fileName") {
+                  if (path26[path26.length - 2] === "hookSource" && path26[path26.length - 1] === "fileName") {
                     return true;
                   }
-                  if (path25[path25.length - 1] === "subHooks" || path25[path25.length - 2] === "subHooks") {
+                  if (path26[path26.length - 1] === "subHooks" || path26[path26.length - 2] === "subHooks") {
                     return true;
                   }
                   break;
                 case "suspendedBy":
-                  if (path25.length < 5) {
+                  if (path26.length < 5) {
                     return true;
                   }
                   break;
@@ -90949,8 +91256,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path25.length; i++) {
-                current = current[path25[i]];
+              for (var i = 0;i < path26.length; i++) {
+                current = current[path26[i]];
                 if (!current) {
                   return false;
                 }
@@ -91004,38 +91311,38 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 break;
             }
           }
-          function storeAsGlobal(id, path25, count) {
+          function storeAsGlobal(id, path26, count) {
             if (isMostRecentlyInspectedElement(id)) {
-              var value = utils_getInObject(mostRecentlyInspectedElement, path25);
+              var value = utils_getInObject(mostRecentlyInspectedElement, path26);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path25) {
+          function getSerializedElementValueByPath(id, path26) {
             if (isMostRecentlyInspectedElement(id)) {
-              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path25);
+              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path26);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path25, forceFullData) {
-            if (path25 !== null) {
-              mergeInspectedPaths(path25);
+          function inspectElement(requestID, id, path26, forceFullData) {
+            if (path26 !== null) {
+              mergeInspectedPaths(path26);
             }
             if (isMostRecentlyInspectedElement(id) && !forceFullData) {
               if (!hasElementUpdatedSinceLastInspected) {
-                if (path25 !== null) {
+                if (path26 !== null) {
                   var secondaryCategory = null;
-                  if (path25[0] === "hooks" || path25[0] === "suspendedBy") {
-                    secondaryCategory = path25[0];
+                  if (path26[0] === "hooks" || path26[0] === "suspendedBy") {
+                    secondaryCategory = path26[0];
                   }
                   return {
                     id,
                     responseID: requestID,
                     type: "hydrated-path",
-                    path: path25,
-                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path25), createIsPathAllowed(null, secondaryCategory), path25)
+                    path: path26,
+                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path26), createIsPathAllowed(null, secondaryCategory), path26)
                   };
                 } else {
                   return {
@@ -91231,7 +91538,7 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function deletePath(type, id, hookID, path25) {
+          function deletePath(type, id, hookID, path26) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -91245,11 +91552,11 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path25 = path25.slice(1);
+                  path26 = path26.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path25.length === 0) {} else {
-                        deletePathInObject(instance2.context, path25);
+                      if (path26.length === 0) {} else {
+                        deletePathInObject(instance2.context, path26);
                       }
                       instance2.forceUpdate();
                       break;
@@ -91259,21 +91566,21 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookStateDeletePath === "function") {
-                    overrideHookStateDeletePath(fiber, hookID, path25);
+                    overrideHookStateDeletePath(fiber, hookID, path26);
                   }
                   break;
                 case "props":
                   if (instance2 === null) {
                     if (typeof overridePropsDeletePath === "function") {
-                      overridePropsDeletePath(fiber, path25);
+                      overridePropsDeletePath(fiber, path26);
                     }
                   } else {
-                    fiber.pendingProps = copyWithDelete(instance2.props, path25);
+                    fiber.pendingProps = copyWithDelete(instance2.props, path26);
                     instance2.forceUpdate();
                   }
                   break;
                 case "state":
-                  deletePathInObject(instance2.state, path25);
+                  deletePathInObject(instance2.state, path26);
                   instance2.forceUpdate();
                   break;
               }
@@ -91328,7 +91635,7 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path25, value) {
+          function overrideValueAtPath(type, id, hookID, path26, value) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -91342,13 +91649,13 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path25 = path25.slice(1);
+                  path26 = path26.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path25.length === 0) {
+                      if (path26.length === 0) {
                         instance2.context = value;
                       } else {
-                        utils_setInObject(instance2.context, path25, value);
+                        utils_setInObject(instance2.context, path26, value);
                       }
                       instance2.forceUpdate();
                       break;
@@ -91358,18 +91665,18 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookState === "function") {
-                    overrideHookState(fiber, hookID, path25, value);
+                    overrideHookState(fiber, hookID, path26, value);
                   }
                   break;
                 case "props":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      fiber.pendingProps = copyWithSet(instance2.props, path25, value);
+                      fiber.pendingProps = copyWithSet(instance2.props, path26, value);
                       instance2.forceUpdate();
                       break;
                     default:
                       if (typeof overrideProps === "function") {
-                        overrideProps(fiber, path25, value);
+                        overrideProps(fiber, path26, value);
                       }
                       break;
                   }
@@ -91377,7 +91684,7 @@ The error thrown in the component is:
                 case "state":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      utils_setInObject(instance2.state, path25, value);
+                      utils_setInObject(instance2.state, path26, value);
                       instance2.forceUpdate();
                       break;
                   }
@@ -91663,14 +91970,14 @@ The error thrown in the component is:
           var trackedPathMatchInstance = null;
           var trackedPathMatchDepth = -1;
           var mightBeOnTrackedPath = false;
-          function setTrackedPath(path25) {
-            if (path25 === null) {
+          function setTrackedPath(path26) {
+            if (path26 === null) {
               trackedPathMatchFiber = null;
               trackedPathMatchInstance = null;
               trackedPathMatchDepth = -1;
               mightBeOnTrackedPath = false;
             }
-            trackedPath = path25;
+            trackedPath = path26;
           }
           function updateTrackedPathStateBeforeMount(fiber, fiberInstance) {
             if (trackedPath === null || !mightBeOnTrackedPath) {
@@ -92434,9 +92741,9 @@ The error thrown in the component is:
           }
           var currentlyInspectedElementID = null;
           var currentlyInspectedPaths = {};
-          function mergeInspectedPaths(path25) {
+          function mergeInspectedPaths(path26) {
             var current = currentlyInspectedPaths;
-            path25.forEach(function(key) {
+            path26.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -92444,13 +92751,13 @@ The error thrown in the component is:
             });
           }
           function createIsPathAllowed(key) {
-            return function isPathAllowed(path25) {
+            return function isPathAllowed(path26) {
               var current = currentlyInspectedPaths[key];
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path25.length; i++) {
-                current = current[path25[i]];
+              for (var i = 0;i < path26.length; i++) {
+                current = current[path26[i]];
                 if (!current) {
                   return false;
                 }
@@ -92500,24 +92807,24 @@ The error thrown in the component is:
                 break;
             }
           }
-          function storeAsGlobal(id, path25, count) {
+          function storeAsGlobal(id, path26, count) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var value = utils_getInObject(inspectedElement, path25);
+              var value = utils_getInObject(inspectedElement, path26);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path25) {
+          function getSerializedElementValueByPath(id, path26) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var valueToCopy = utils_getInObject(inspectedElement, path25);
+              var valueToCopy = utils_getInObject(inspectedElement, path26);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path25, forceFullData) {
+          function inspectElement(requestID, id, path26, forceFullData) {
             if (forceFullData || currentlyInspectedElementID !== id) {
               currentlyInspectedElementID = id;
               currentlyInspectedPaths = {};
@@ -92530,8 +92837,8 @@ The error thrown in the component is:
                 type: "not-found"
               };
             }
-            if (path25 !== null) {
-              mergeInspectedPaths(path25);
+            if (path26 !== null) {
+              mergeInspectedPaths(path26);
             }
             updateSelectedElement(id);
             inspectedElement.context = cleanForBridge(inspectedElement.context, createIsPathAllowed("context"));
@@ -92734,10 +93041,10 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function getElementAttributeByPath(id, path25) {
+          function getElementAttributeByPath(id, path26) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              return utils_getInObject(inspectedElement, path25);
+              return utils_getInObject(inspectedElement, path26);
             }
             return;
           }
@@ -92754,14 +93061,14 @@ The error thrown in the component is:
             }
             return element.type;
           }
-          function deletePath(type, id, hookID, path25) {
+          function deletePath(type, id, hookID, path26) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    deletePathInObject(publicInstance.context, path25);
+                    deletePathInObject(publicInstance.context, path26);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -92769,12 +93076,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithDelete(element.props, path25)
+                      props: copyWithDelete(element.props, path26)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    deletePathInObject(publicInstance.state, path25);
+                    deletePathInObject(publicInstance.state, path26);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -92808,14 +93115,14 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path25, value) {
+          function overrideValueAtPath(type, id, hookID, path26, value) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    utils_setInObject(publicInstance.context, path25, value);
+                    utils_setInObject(publicInstance.context, path26, value);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -92823,12 +93130,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithSet(element.props, path25, value)
+                      props: copyWithSet(element.props, path26, value)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    utils_setInObject(publicInstance.state, path25, value);
+                    utils_setInObject(publicInstance.state, path26, value);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -92869,7 +93176,7 @@ The error thrown in the component is:
             return [];
           }
           function setTraceUpdatesEnabled(enabled) {}
-          function setTrackedPath(path25) {}
+          function setTrackedPath(path26) {}
           function getOwnersList(id) {
             return null;
           }
@@ -96178,10 +96485,10 @@ init_setup();
 // src/cli/plugins.ts
 init_paths();
 init_loader4();
-import * as path17 from "path";
+import * as path18 from "path";
 async function pluginsListCommand(config2, workdir, overrideGlobalPluginsDir) {
-  const globalPluginsDir = overrideGlobalPluginsDir ?? path17.join(globalConfigDir(), "plugins");
-  const projectPluginsDir = path17.join(workdir, ".nax", "plugins");
+  const globalPluginsDir = overrideGlobalPluginsDir ?? path18.join(globalConfigDir(), "plugins");
+  const projectPluginsDir = path18.join(workdir, ".nax", "plugins");
   const configPlugins = config2.plugins || [];
   const registry2 = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
   const plugins = registry2.plugins;
@@ -96231,10 +96538,10 @@ function formatSource(type, sourcePath) {
     return `built-in (${sourcePath})`;
   }
   if (type === "global") {
-    return `global (${path17.basename(sourcePath)})`;
+    return `global (${path18.basename(sourcePath)})`;
   }
   if (type === "project") {
-    return `project (${path17.basename(sourcePath)})`;
+    return `project (${path18.basename(sourcePath)})`;
   }
   return `config (${sourcePath})`;
 }
@@ -96626,10 +96933,10 @@ function deepDiffConfigs(global2, project, currentPath = []) {
   for (const key of Object.keys(project)) {
     const projectValue = project[key];
     const globalValue = global2[key];
-    const path18 = [...currentPath, key];
-    const pathStr = path18.join(".");
+    const path19 = [...currentPath, key];
+    const pathStr = path19.join(".");
     if (projectValue !== null && typeof projectValue === "object" && !Array.isArray(projectValue) && globalValue !== null && typeof globalValue === "object" && !Array.isArray(globalValue)) {
-      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path18);
+      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path19);
       diffs.push(...nestedDiffs);
     } else {
       if (!deepEqual(projectValue, globalValue)) {
@@ -96672,11 +96979,11 @@ init_defaults();
 init_loader();
 import { existsSync as existsSync25 } from "fs";
 import { join as join63 } from "path";
-async function loadConfigFile(path18) {
-  if (!existsSync25(path18))
+async function loadConfigFile(path19) {
+  if (!existsSync25(path19))
     return null;
   try {
-    return await Bun.file(path18).json();
+    return await Bun.file(path19).json();
   } catch {
     return null;
   }
@@ -96723,10 +97030,10 @@ async function configCommand(config2, options = {}) {
     console.log(`${"Field".padEnd(40)}${"Project Value".padEnd(20)}Global Value`);
     console.log("\u2500".repeat(80));
     for (const diff2 of diffs) {
-      const path18 = diff2.path.padEnd(40);
+      const path19 = diff2.path.padEnd(40);
       const projectVal = formatValueForTable(diff2.projectValue);
       const globalVal = formatValueForTable(diff2.globalValue);
-      console.log(`${path18}${projectVal.padEnd(20)}${globalVal}`);
+      console.log(`${path19}${projectVal.padEnd(20)}${globalVal}`);
       const description = FIELD_DESCRIPTIONS[diff2.path];
       if (description) {
         console.log(`${"".padEnd(40)}\u21B3 ${description}`);
@@ -96759,26 +97066,26 @@ function determineConfigSources() {
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
-function fileExists(path18) {
-  return existsSync26(path18);
+function fileExists(path19) {
+  return existsSync26(path19);
 }
-function displayConfigWithDescriptions(obj, path18, sources, indent = 0) {
+function displayConfigWithDescriptions(obj, path19, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
-  const pathStr = path18.join(".");
+  const pathStr = path19.join(".");
   if (obj === null || obj === undefined || typeof obj !== "object" || Array.isArray(obj)) {
     const description = FIELD_DESCRIPTIONS[pathStr];
     const value = formatValue(obj);
     if (description) {
       console.log(`${indentStr}# ${description}`);
     }
-    const key = path18[path18.length - 1] || "";
+    const key = path19[path19.length - 1] || "";
     console.log(`${indentStr}${key}: ${value}`);
     console.log();
     return;
   }
   const entries = Object.entries(obj);
   const objAsRecord = obj;
-  const isPromptsSection = path18.join(".") === "prompts";
+  const isPromptsSection = path19.join(".") === "prompts";
   if (isPromptsSection && !objAsRecord.overrides) {
     const description = FIELD_DESCRIPTIONS["prompts.overrides"];
     if (description) {
@@ -96801,7 +97108,7 @@ function displayConfigWithDescriptions(obj, path18, sources, indent = 0) {
   }
   for (let i = 0;i < entries.length; i++) {
     const [key, value] = entries[i];
-    const currentPath = [...path18, key];
+    const currentPath = [...path19, key];
     const currentPathStr = currentPath.join(".");
     const description = FIELD_DESCRIPTIONS[currentPathStr];
     if (description) {
@@ -97113,11 +97420,11 @@ init_errors();
 import { mkdir as mkdir11 } from "fs/promises";
 import { basename as basename12, join as join66 } from "path";
 var _rulesCLIDeps = {
-  readFile: async (path18) => Bun.file(path18).text(),
-  writeFile: async (path18, content) => {
-    await Bun.write(path18, content);
+  readFile: async (path19) => Bun.file(path19).text(),
+  writeFile: async (path19, content) => {
+    await Bun.write(path19, content);
   },
-  fileExists: async (path18) => Bun.file(path18).exists(),
+  fileExists: async (path19) => Bun.file(path19).exists(),
   globInDir: (dir) => {
     try {
       return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join66(dir, f));
@@ -97125,8 +97432,8 @@ var _rulesCLIDeps = {
       return [];
     }
   },
-  mkdir: async (path18) => {
-    await mkdir11(path18, { recursive: true });
+  mkdir: async (path19) => {
+    await mkdir11(path19, { recursive: true });
   },
   globCanonicalRuleFiles: (workdir) => {
     try {
@@ -97290,6 +97597,35 @@ async function rulesLintCommand(options) {
   const scopeLabel = roots.length === 1 ? "repo root" : `${roots.length} rule roots`;
   console.log(`[OK] Canonical rules lint passed (${totalRuleFiles} file(s) across ${scopeLabel}).`);
 }
+// src/cli/resolve-run-profile.ts
+init_config();
+init_logger2();
+async function resolveRunProfileOverride(opts) {
+  if (opts.cliProfile)
+    return opts.cliProfile;
+  if (opts.envProfile)
+    return;
+  const readJson = opts._readJson ?? (async (path19) => {
+    const file3 = Bun.file(path19);
+    if (!await file3.exists())
+      return;
+    return file3.json();
+  });
+  try {
+    const prd = await readJson(opts.prdPath);
+    if (prd && typeof prd.routingProfile === "string" && prd.routingProfile.length > 0) {
+      const name = prd.routingProfile;
+      if (name === "default")
+        return name;
+      const listNames = opts._listProfileNames ?? (async () => (await listProfiles(opts.projectRoot)).map((p) => p.name));
+      const available = await listNames();
+      if (available.includes(name))
+        return name;
+      getSafeLogger()?.warn("run", `PRD was planned with config profile "${name}" but no such profile exists \u2014 continuing with current config resolution`, { storyId: "prd", plannedProfile: name });
+    }
+  } catch {}
+  return;
+}
 // src/commands/detect.ts
 init_source();
 init_config();
@@ -97305,14 +97641,14 @@ function resolveEffective(detected, configPatterns) {
     return "detected";
   return "none";
 }
-async function loadRawConfig(path18) {
-  const f = Bun.file(path18);
+async function loadRawConfig(path19) {
+  const f = Bun.file(path19);
   if (!await f.exists())
     return {};
   return JSON.parse(await f.text());
 }
-async function writeRawConfig(path18, data) {
-  await Bun.write(path18, `${JSON.stringify(data, null, 2)}
+async function writeRawConfig(path19, data) {
+  await Bun.write(path19, `${JSON.stringify(data, null, 2)}
 `);
 }
 function deepSet(obj, keyPath, value) {
@@ -98020,7 +98356,7 @@ init_prd();
 init_git();
 init_crash_recovery();
 init_story_context();
-import path19 from "path";
+import path20 from "path";
 var _runnerCompletionDeps = {
   async runAcceptanceLoop(ctx) {
     const { runAcceptanceLoop: runAcceptanceLoop2 } = await Promise.resolve().then(() => (init_acceptance_loop(), exports_acceptance_loop));
@@ -98051,11 +98387,11 @@ async function runCompletionPhase(options) {
       options.statusWriter.setPostRunPhase("acceptance", { status: "running" });
       pipelineEventBus.emit({ type: "postrun:phase:started", phase: "acceptance" });
       const acceptanceTestPaths = options.featureDir ? await Promise.all((await groupStoriesByPackage(options.prd, options.workdir, options.feature, options.config.acceptance.testPath, options.config.project?.language)).map(async (g) => {
-        const relativeWorkdir = path19.relative(options.workdir, g.packageDir);
+        const relativeWorkdir = path20.relative(options.workdir, g.packageDir);
         let groupConfig = options.config;
         if (relativeWorkdir && relativeWorkdir !== ".") {
           try {
-            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path19.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
+            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path20.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
           } catch (error48) {
             logger?.warn("execution", "Falling back to root config for package acceptance settings", {
               packageDir: g.packageDir,
@@ -103302,8 +103638,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
-var cleanupPath = (path25) => {
-  return path25?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path26) => {
+  return path26?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -106574,8 +106910,14 @@ program2.command("run").description("Run the orchestration loop for a feature").
   }
   const naxDir = findProjectDir(workdir);
   const cliOverrides = {};
-  if (options.profile) {
-    cliOverrides.profile = options.profile;
+  const profileOverride = naxDir ? await resolveRunProfileOverride({
+    prdPath: join87(naxDir, "features", options.feature, "prd.json"),
+    projectRoot: workdir,
+    cliProfile: options.profile,
+    envProfile: process.env.NAX_PROFILE
+  }) : options.profile;
+  if (profileOverride) {
+    cliOverrides.profile = profileOverride;
   }
   const config2 = await loadConfig(naxDir ?? undefined, cliOverrides);
   if (!naxDir) {
@@ -107009,8 +107351,8 @@ configProfileCmd.command("current").description("Show the currently active profi
 });
 configProfileCmd.command("create <name>").description("Create a new empty profile").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (name, options) => {
   try {
-    const path25 = await profileCreateCommand(name, options.dir);
-    console.log(`Created profile at: ${path25}`);
+    const path26 = await profileCreateCommand(name, options.dir);
+    console.log(`Created profile at: ${path26}`);
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
     process.exit(1);