@nathapp/nax 0.57.1-canary.1 → 0.57.2

package/dist/nax.js

@@ -17829,261 +17829,6 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// src/config/defaults.ts
-var DEFAULT_CONFIG;
-var init_defaults = __esm(() => {
-  DEFAULT_CONFIG = {
-    version: 1,
-    models: {
-      claude: {
-        fast: "haiku",
-        balanced: "sonnet",
-        powerful: "opus"
-      }
-    },
-    autoMode: {
-      enabled: true,
-      defaultAgent: "claude",
-      fallbackOrder: ["claude"],
-      complexityRouting: {
-        simple: "fast",
-        medium: "balanced",
-        complex: "powerful",
-        expert: "powerful"
-      },
-      escalation: {
-        enabled: true,
-        tierOrder: [
-          { tier: "fast", attempts: 5 },
-          { tier: "balanced", attempts: 3 },
-          { tier: "powerful", attempts: 2 }
-        ],
-        escalateEntireBatch: true
-      }
-    },
-    routing: {
-      strategy: "keyword",
-      llm: {
-        model: "fast",
-        fallbackToKeywords: true,
-        cacheDecisions: true,
-        mode: "hybrid",
-        timeoutMs: 30000
-      }
-    },
-    execution: {
-      maxIterations: 10,
-      iterationDelayMs: 2000,
-      costLimit: 30,
-      sessionTimeoutSeconds: 3600,
-      verificationTimeoutSeconds: 600,
-      maxStoriesPerFeature: 500,
-      rectification: {
-        enabled: true,
-        maxRetries: 2,
-        fullSuiteTimeoutSeconds: 300,
-        maxFailureSummaryChars: 2000,
-        abortOnIncreasingFailures: true,
-        escalateOnExhaustion: true,
-        rethinkAtAttempt: 2,
-        urgencyAtAttempt: 3
-      },
-      regressionGate: {
-        enabled: true,
-        timeoutSeconds: 300,
-        acceptOnTimeout: true,
-        maxRectificationAttempts: 2
-      },
-      contextProviderTokenBudget: 2000,
-      smartTestRunner: true
-    },
-    quality: {
-      requireTypecheck: true,
-      requireLint: true,
-      requireTests: true,
-      commands: {},
-      forceExit: false,
-      detectOpenHandles: true,
-      detectOpenHandlesRetries: 1,
-      gracePeriodMs: 5000,
-      drainTimeoutMs: 2000,
-      shell: "/bin/sh",
-      stripEnvVars: [
-        "CLAUDECODE",
-        "REPL_ID",
-        "AGENT",
-        "GITLAB_ACCESS_TOKEN",
-        "GITHUB_TOKEN",
-        "GITHUB_ACCESS_TOKEN",
-        "GH_TOKEN",
-        "CI_GIT_TOKEN",
-        "CI_JOB_TOKEN",
-        "BITBUCKET_ACCESS_TOKEN",
-        "NPM_TOKEN",
-        "NPM_AUTH_TOKEN",
-        "YARN_NPM_AUTH_TOKEN",
-        "ANTHROPIC_API_KEY",
-        "OPENAI_API_KEY",
-        "GEMINI_API_KEY",
-        "COHERE_API_KEY",
-        "AWS_ACCESS_KEY_ID",
-        "AWS_SECRET_ACCESS_KEY",
-        "AWS_SESSION_TOKEN",
-        "GOOGLE_APPLICATION_CREDENTIALS",
-        "GCLOUD_SERVICE_KEY",
-        "AZURE_CLIENT_SECRET",
-        "AZURE_TENANT_ID",
-        "TELEGRAM_BOT_TOKEN",
-        "SLACK_TOKEN",
-        "SLACK_WEBHOOK_URL",
-        "SENTRY_AUTH_TOKEN",
-        "DATADOG_API_KEY"
-      ],
-      testing: {
-        hermetic: true
-      }
-    },
-    tdd: {
-      maxRetries: 2,
-      autoVerifyIsolation: true,
-      autoApproveVerifier: true,
-      strategy: "auto",
-      sessionTiers: {
-        testWriter: "balanced",
-        verifier: "fast"
-      },
-      testWriterAllowedPaths: ["src/index.ts", "src/**/index.ts"],
-      rollbackOnFailure: true,
-      greenfieldDetection: true
-    },
-    constitution: {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000
-    },
-    analyze: {
-      llmEnhanced: true,
-      model: "balanced",
-      fallbackToKeywords: true,
-      maxCodebaseSummaryTokens: 5000
-    },
-    review: {
-      enabled: true,
-      checks: ["typecheck", "lint"],
-      commands: {},
-      pluginMode: "per-story",
-      semantic: {
-        modelTier: "balanced",
-        rules: [],
-        timeoutMs: 600000,
-        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
-      }
-    },
-    plan: {
-      model: "balanced",
-      outputPath: "spec.md"
-    },
-    acceptance: {
-      enabled: true,
-      maxRetries: 2,
-      generateTests: true,
-      testPath: ".nax-acceptance.test.ts",
-      model: "fast",
-      refinement: true,
-      redGate: true,
-      timeoutMs: 1800000,
-      fix: {
-        diagnoseModel: "fast",
-        fixModel: "balanced",
-        strategy: "diagnose-first",
-        maxRetries: 2
-      }
-    },
-    context: {
-      fileInjection: "disabled",
-      testCoverage: {
-        enabled: true,
-        detail: "names-and-counts",
-        maxTokens: 500,
-        testPattern: "**/*.test.{ts,js,tsx,jsx}",
-        scopeToStory: true
-      },
-      autoDetect: {
-        enabled: true,
-        maxFiles: 5,
-        traceImports: false
-      }
-    },
-    interaction: {
-      plugin: "cli",
-      config: {},
-      defaults: {
-        timeout: 600000,
-        fallback: "escalate"
-      },
-      triggers: {
-        "security-review": true,
-        "cost-warning": true
-      }
-    },
-    precheck: {
-      storySizeGate: {
-        enabled: true,
-        maxAcCount: 10,
-        maxDescriptionLength: 3000,
-        maxBulletPoints: 12,
-        action: "block",
-        maxReplanAttempts: 3
-      }
-    },
-    prompts: {},
-    agent: {
-      protocol: "acp"
-    },
-    debate: {
-      enabled: false,
-      agents: 3,
-      stages: {
-        plan: {
-          enabled: true,
-          resolver: { type: "synthesis" },
-          sessionMode: "stateful",
-          rounds: 3,
-          timeoutSeconds: 600
-        },
-        review: {
-          enabled: true,
-          resolver: { type: "majority-fail-closed" },
-          sessionMode: "one-shot",
-          rounds: 2,
-          timeoutSeconds: 600
-        },
-        acceptance: {
-          enabled: false,
-          resolver: { type: "majority-fail-closed" },
-          sessionMode: "one-shot",
-          rounds: 1,
-          timeoutSeconds: 600
-        },
-        rectification: {
-          enabled: false,
-          resolver: { type: "synthesis" },
-          sessionMode: "one-shot",
-          rounds: 1,
-          timeoutSeconds: 600
-        },
-        escalation: {
-          enabled: false,
-          resolver: { type: "majority-fail-closed" },
-          sessionMode: "one-shot",
-          rounds: 1,
-          timeoutSeconds: 600
-        }
-      }
-    }
-  };
-});
-
 // src/config/schemas.ts
 function isLegacyFlatModels(val) {
   if (typeof val !== "object" || val === null)
@@ -18112,7 +17857,6 @@ var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, PerAgentModelMapSchema
 })), DebateConfigSchema, NaxConfigSchema;
 var init_schemas3 = __esm(() => {
   init_zod();
-  init_defaults();
   TokenPricingSchema = exports_external.object({
     inputPer1M: exports_external.number().min(0),
     outputPer1M: exports_external.number().min(0)
@@ -18127,8 +17871,7 @@ var init_schemas3 = __esm(() => {
   PerAgentModelMapSchema = exports_external.record(exports_external.string().min(1), exports_external.record(exports_external.string().min(1), ModelEntrySchema));
   ModelMapSchema = exports_external.preprocess((val) => {
     if (isLegacyFlatModels(val)) {
-      const defaultAgent = DEFAULT_CONFIG.autoMode.defaultAgent;
-      return { [defaultAgent]: val };
+      return { claude: val };
     }
     return val;
   }, PerAgentModelMapSchema);
@@ -18220,6 +17963,19 @@ var init_schemas3 = __esm(() => {
       formatFix: exports_external.string().optional(),
       build: exports_external.string().optional()
     }),
+    autofix: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      maxAttempts: exports_external.number().int().min(1).default(3),
+      maxTotalAttempts: exports_external.number().int().min(1).default(12),
+      rethinkAtAttempt: exports_external.number().int().min(1).default(2),
+      urgencyAtAttempt: exports_external.number().int().min(1).default(3)
+    }).default({
+      enabled: true,
+      maxAttempts: 3,
+      maxTotalAttempts: 12,
+      rethinkAtAttempt: 2,
+      urgencyAtAttempt: 3
+    }),
     forceExit: exports_external.boolean().default(false),
     detectOpenHandles: exports_external.boolean().default(true),
     detectOpenHandlesRetries: exports_external.number().int().min(0).max(5).default(1),
@@ -18313,10 +18069,10 @@ var init_schemas3 = __esm(() => {
     timeoutSeconds: exports_external.number().int().positive().default(600)
   });
   AcceptanceFixConfigSchema = exports_external.object({
-    diagnoseModel: exports_external.string().min(1, "acceptance.fix.diagnoseModel must be non-empty"),
-    fixModel: exports_external.string().min(1, "acceptance.fix.fixModel must be non-empty"),
-    strategy: exports_external.enum(["diagnose-first", "implement-only"]),
-    maxRetries: exports_external.number().int().nonnegative()
+    diagnoseModel: exports_external.string().min(1, "acceptance.fix.diagnoseModel must be non-empty").default("fast"),
+    fixModel: exports_external.string().min(1, "acceptance.fix.fixModel must be non-empty").default("balanced"),
+    strategy: exports_external.enum(["diagnose-first", "implement-only"]).default("diagnose-first"),
+    maxRetries: exports_external.number().int().nonnegative().default(2)
   });
   AcceptanceConfigSchema = exports_external.object({
     enabled: exports_external.boolean(),
@@ -18436,6 +18192,7 @@ var init_schemas3 = __esm(() => {
   DebateConfigSchema = exports_external.preprocess(toObject, exports_external.object({
     enabled: exports_external.boolean().default(false),
     agents: exports_external.number().int().min(2).default(3),
+    maxConcurrentDebaters: exports_external.number().int().min(1).max(10).default(2),
     stages: exports_external.preprocess(toObject, exports_external.object({
       plan: DebateStageConfigSchema({ enabled: true, resolverType: "synthesis", sessionMode: "stateful", rounds: 3 }),
       review: DebateStageConfigSchema({
@@ -18465,36 +18222,289 @@ var init_schemas3 = __esm(() => {
     }))
   }));
   NaxConfigSchema = exports_external.object({
-    version: exports_external.number(),
-    models: ModelMapSchema,
-    autoMode: AutoModeConfigSchema,
-    routing: RoutingConfigSchema,
-    execution: ExecutionConfigSchema,
-    quality: QualityConfigSchema,
-    tdd: TddConfigSchema,
-    constitution: ConstitutionConfigSchema,
-    analyze: AnalyzeConfigSchema,
-    review: ReviewConfigSchema,
-    plan: PlanConfigSchema,
-    acceptance: AcceptanceConfigSchema,
-    context: ContextConfigSchema,
+    version: exports_external.number().default(1),
+    models: ModelMapSchema.default({
+      claude: {
+        fast: "haiku",
+        balanced: "sonnet",
+        powerful: "opus"
+      }
+    }),
+    autoMode: AutoModeConfigSchema.default({
+      enabled: true,
+      defaultAgent: "claude",
+      fallbackOrder: ["claude"],
+      complexityRouting: {
+        simple: "fast",
+        medium: "balanced",
+        complex: "powerful",
+        expert: "powerful"
+      },
+      escalation: {
+        enabled: true,
+        tierOrder: [
+          { tier: "fast", attempts: 5 },
+          { tier: "balanced", attempts: 3 },
+          { tier: "powerful", attempts: 2 }
+        ],
+        escalateEntireBatch: true
+      }
+    }),
+    routing: RoutingConfigSchema.default({
+      strategy: "keyword",
+      llm: {
+        model: "fast",
+        fallbackToKeywords: true,
+        cacheDecisions: true,
+        mode: "hybrid",
+        timeoutMs: 30000
+      }
+    }),
+    execution: ExecutionConfigSchema.default({
+      maxIterations: 10,
+      iterationDelayMs: 2000,
+      costLimit: 30,
+      sessionTimeoutSeconds: 3600,
+      verificationTimeoutSeconds: 600,
+      maxStoriesPerFeature: 500,
+      rectification: {
+        enabled: true,
+        maxRetries: 2,
+        fullSuiteTimeoutSeconds: 300,
+        maxFailureSummaryChars: 2000,
+        abortOnIncreasingFailures: true,
+        escalateOnExhaustion: true,
+        rethinkAtAttempt: 2,
+        urgencyAtAttempt: 3
+      },
+      regressionGate: {
+        enabled: true,
+        timeoutSeconds: 300,
+        acceptOnTimeout: true,
+        mode: "deferred",
+        maxRectificationAttempts: 3
+      },
+      contextProviderTokenBudget: 2000,
+      lintCommand: null,
+      typecheckCommand: null,
+      dangerouslySkipPermissions: true,
+      permissionProfile: "unrestricted",
+      smartTestRunner: true
+    }),
+    quality: QualityConfigSchema.default({
+      requireTypecheck: true,
+      requireLint: true,
+      requireTests: true,
+      commands: {},
+      autofix: {
+        enabled: true,
+        maxAttempts: 3,
+        maxTotalAttempts: 12,
+        rethinkAtAttempt: 2,
+        urgencyAtAttempt: 3
+      },
+      forceExit: false,
+      detectOpenHandles: true,
+      detectOpenHandlesRetries: 1,
+      gracePeriodMs: 5000,
+      drainTimeoutMs: 2000,
+      shell: "/bin/sh",
+      stripEnvVars: [
+        "CLAUDECODE",
+        "REPL_ID",
+        "AGENT",
+        "GITLAB_ACCESS_TOKEN",
+        "GITHUB_TOKEN",
+        "GITHUB_ACCESS_TOKEN",
+        "GH_TOKEN",
+        "CI_GIT_TOKEN",
+        "CI_JOB_TOKEN",
+        "BITBUCKET_ACCESS_TOKEN",
+        "NPM_TOKEN",
+        "NPM_AUTH_TOKEN",
+        "YARN_NPM_AUTH_TOKEN",
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "GEMINI_API_KEY",
+        "COHERE_API_KEY",
+        "AWS_ACCESS_KEY_ID",
+        "AWS_SECRET_ACCESS_KEY",
+        "AWS_SESSION_TOKEN",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+        "GCLOUD_SERVICE_KEY",
+        "AZURE_CLIENT_SECRET",
+        "AZURE_TENANT_ID",
+        "TELEGRAM_BOT_TOKEN",
+        "SLACK_TOKEN",
+        "SLACK_WEBHOOK_URL",
+        "SENTRY_AUTH_TOKEN",
+        "DATADOG_API_KEY"
+      ],
+      testing: {
+        hermetic: true
+      }
+    }),
+    tdd: TddConfigSchema.default({
+      maxRetries: 2,
+      autoVerifyIsolation: true,
+      autoApproveVerifier: true,
+      strategy: "auto",
+      sessionTiers: {
+        testWriter: "balanced",
+        verifier: "fast"
+      },
+      testWriterAllowedPaths: ["src/index.ts", "src/**/index.ts"],
+      rollbackOnFailure: true,
+      greenfieldDetection: true
+    }),
+    constitution: ConstitutionConfigSchema.default({
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000
+    }),
+    analyze: AnalyzeConfigSchema.default({
+      llmEnhanced: true,
+      model: "balanced",
+      fallbackToKeywords: true,
+      maxCodebaseSummaryTokens: 5000
+    }),
+    review: ReviewConfigSchema.default({
+      enabled: true,
+      checks: ["typecheck", "lint"],
+      commands: {},
+      pluginMode: "per-story",
+      semantic: {
+        modelTier: "balanced",
+        rules: [],
+        timeoutMs: 600000,
+        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
+      }
+    }),
+    plan: PlanConfigSchema.default({
+      model: "balanced",
+      outputPath: "spec.md",
+      timeoutSeconds: 600
+    }),
+    acceptance: AcceptanceConfigSchema.default({
+      enabled: true,
+      maxRetries: 2,
+      generateTests: true,
+      testPath: ".nax-acceptance.test.ts",
+      model: "fast",
+      refinement: true,
+      redGate: true,
+      timeoutMs: 1800000,
+      fix: {
+        diagnoseModel: "fast",
+        fixModel: "balanced",
+        strategy: "diagnose-first",
+        maxRetries: 2
+      }
+    }),
+    context: ContextConfigSchema.default({
+      fileInjection: "disabled",
+      testCoverage: {
+        enabled: true,
+        detail: "names-and-counts",
+        maxTokens: 500,
+        testPattern: "**/*.test.{ts,js,tsx,jsx}",
+        scopeToStory: true
+      },
+      autoDetect: {
+        enabled: true,
+        maxFiles: 5,
+        traceImports: false
+      }
+    }),
     optimizer: OptimizerConfigSchema.optional(),
     plugins: exports_external.array(PluginConfigEntrySchema).optional(),
     disabledPlugins: exports_external.array(exports_external.string()).optional(),
     hooks: HooksConfigSchema.optional(),
-    interaction: InteractionConfigSchema.optional(),
-    agent: AgentConfigSchema.optional(),
-    precheck: PrecheckConfigSchema.optional(),
+    interaction: InteractionConfigSchema.optional().default({
+      plugin: "cli",
+      config: {},
+      defaults: {
+        timeout: 600000,
+        fallback: "escalate"
+      },
+      triggers: {
+        "security-review": true,
+        "cost-warning": true
+      }
+    }),
+    agent: AgentConfigSchema.optional().default({
+      protocol: "acp",
+      maxInteractionTurns: 10
+    }),
+    precheck: PrecheckConfigSchema.optional().default({
+      storySizeGate: {
+        enabled: true,
+        maxAcCount: 10,
+        maxDescriptionLength: 3000,
+        maxBulletPoints: 12,
+        action: "block",
+        maxReplanAttempts: 3
+      }
+    }),
     prompts: PromptsConfigSchema.optional(),
     generate: GenerateConfigSchema.optional(),
     project: ProjectProfileSchema.optional(),
-    debate: DebateConfigSchema.optional().default(() => DEFAULT_CONFIG.debate)
+    debate: DebateConfigSchema.optional().default(() => ({
+      enabled: false,
+      agents: 3,
+      maxConcurrentDebaters: 2,
+      stages: {
+        plan: {
+          enabled: true,
+          resolver: { type: "synthesis" },
+          sessionMode: "stateful",
+          rounds: 3,
+          timeoutSeconds: 600
+        },
+        review: {
+          enabled: true,
+          resolver: { type: "majority-fail-closed" },
+          sessionMode: "one-shot",
+          rounds: 2,
+          timeoutSeconds: 600
+        },
+        acceptance: {
+          enabled: false,
+          resolver: { type: "majority-fail-closed" },
+          sessionMode: "one-shot",
+          rounds: 1,
+          timeoutSeconds: 600
+        },
+        rectification: {
+          enabled: false,
+          resolver: { type: "synthesis" },
+          sessionMode: "one-shot",
+          rounds: 1,
+          timeoutSeconds: 600
+        },
+        escalation: {
+          enabled: false,
+          resolver: { type: "majority-fail-closed" },
+          sessionMode: "one-shot",
+          rounds: 1,
+          timeoutSeconds: 600
+        }
+      }
+    })),
+    profile: exports_external.string().default("default")
   }).refine((data) => data.version === 1, {
     message: "Invalid version: expected 1",
     path: ["version"]
   });
 });
 
+// src/config/defaults.ts
+var DEFAULT_CONFIG;
+var init_defaults = __esm(() => {
+  init_schemas3();
+  DEFAULT_CONFIG = NaxConfigSchema.parse({});
+});
+
 // src/config/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
@@ -20687,26 +20697,179 @@ var init_path_security = () => {};
 import { homedir as homedir2 } from "os";
 import { join as join3, resolve as resolve2 } from "path";
 function globalConfigDir() {
+  const override = process.env[GLOBAL_CONFIG_DIR_ENV];
+  if (override)
+    return override;
   return join3(homedir2(), ".nax");
 }
-var PROJECT_NAX_DIR = ".nax";
+function projectConfigDir(projectRoot) {
+  return join3(resolve2(projectRoot), PROJECT_NAX_DIR);
+}
+var GLOBAL_CONFIG_DIR_ENV = "NAX_GLOBAL_CONFIG_DIR", PROJECT_NAX_DIR = ".nax";
 var init_paths = () => {};
 
+// src/config/dotenv.ts
+function parseDotenv(content) {
+  if (!content)
+    return {};
+  const result = {};
+  for (const rawLine of content.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const stripped = line.startsWith("export ") ? line.slice(7).trim() : line;
+    const eqIndex = stripped.indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = stripped.slice(0, eqIndex).trim();
+    let value = stripped.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function resolveEnvVars(config2, env2) {
+  if (typeof config2 === "string") {
+    return resolveString(config2, env2);
+  }
+  if (Array.isArray(config2)) {
+    return config2.map((item) => resolveEnvVars(item, env2));
+  }
+  if (config2 !== null && typeof config2 === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(config2)) {
+      result[key] = resolveEnvVars(value, env2);
+    }
+    return result;
+  }
+  return config2;
+}
+function resolveString(str, env2) {
+  return str.replace(/\$\$([A-Za-z_][A-Za-z0-9_]*)/g, `${DOUBLE_DOLLAR_PLACEHOLDER}$1`).replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, varName) => {
+    if (!(varName in env2)) {
+      throw new Error(`Environment variable $${varName} (${varName}) is not defined`);
+    }
+    return env2[varName];
+  }).replace(new RegExp(`${DOUBLE_DOLLAR_PLACEHOLDER}([A-Za-z_][A-Za-z0-9_]*)`, "g"), "$$$1");
+}
+var DOUBLE_DOLLAR_PLACEHOLDER = "__DOLLAR_ESCAPE__";
+
+// src/config/profile.ts
+import { readdirSync } from "fs";
+import { join as join4 } from "path";
+async function loadProfile(profileName, projectRoot) {
+  const globalPath = join4(globalConfigDir(), "profiles", `${profileName}.json`);
+  const projectPath = join4(projectConfigDir(projectRoot), "profiles", `${profileName}.json`);
+  const globalFile = Bun.file(globalPath);
+  const projectFile = Bun.file(projectPath);
+  const [globalExists, projectExists] = await Promise.all([globalFile.exists(), projectFile.exists()]);
+  if (!globalExists && !projectExists) {
+    const available = await listAvailableProfileNames(projectRoot);
+    const availableList = available.length > 0 ? available.join(", ") : "(none)";
+    throw new Error(`Profile "${profileName}" not found. Available: ${availableList}`);
+  }
+  let base = {};
+  if (globalExists) {
+    base = await globalFile.json();
+  }
+  if (projectExists) {
+    const projectData = await projectFile.json();
+    base = deepMergeConfig(base, projectData);
+  }
+  return base;
+}
+async function loadProfileEnv(profileName, projectRoot) {
+  const globalPath = join4(globalConfigDir(), "profiles", `${profileName}.env`);
+  const projectPath = join4(projectConfigDir(projectRoot), "profiles", `${profileName}.env`);
+  const globalFile = Bun.file(globalPath);
+  const projectFile = Bun.file(projectPath);
+  const [globalExists, projectExists] = await Promise.all([globalFile.exists(), projectFile.exists()]);
+  if (!globalExists && !projectExists) {
+    return {};
+  }
+  let merged = {};
+  if (globalExists) {
+    const globalContent = await globalFile.text();
+    merged = { ...merged, ...parseDotenv(globalContent) };
+  }
+  if (projectExists) {
+    const projectContent = await projectFile.text();
+    merged = { ...merged, ...parseDotenv(projectContent) };
+  }
+  return merged;
+}
+async function resolveProfileName(cliOptions, env2, projectRoot) {
+  if (cliOptions.profile) {
+    return cliOptions.profile;
+  }
+  if (env2.NAX_PROFILE) {
+    return env2.NAX_PROFILE;
+  }
+  const projectConfigPath = join4(projectConfigDir(projectRoot), "config.json");
+  const projectConfigFile = Bun.file(projectConfigPath);
+  if (await projectConfigFile.exists()) {
+    const config2 = await projectConfigFile.json();
+    if (typeof config2.profile === "string" && config2.profile && config2.profile !== "default") {
+      return config2.profile;
+    }
+  }
+  const globalConfigPath = join4(globalConfigDir(), "config.json");
+  const globalConfigFile = Bun.file(globalConfigPath);
+  if (await globalConfigFile.exists()) {
+    const config2 = await globalConfigFile.json();
+    if (typeof config2.profile === "string" && config2.profile && config2.profile !== "default") {
+      return config2.profile;
+    }
+  }
+  return "default";
+}
+async function listAvailableProfileNames(projectRoot) {
+  const entries = await listProfiles(projectRoot);
+  const names = [...new Set(entries.map((e) => e.name))].sort();
+  return names;
+}
+async function listProfiles(projectRoot) {
+  const globalProfilesDir = join4(globalConfigDir(), "profiles");
+  const projectProfilesDir = join4(projectConfigDir(projectRoot), "profiles");
+  const entries = [];
+  for (const dir of [globalProfilesDir, projectProfilesDir]) {
+    let files;
+    try {
+      files = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const file3 of files) {
+      if (file3.endsWith(".json")) {
+        const name = file3.replace(/\.json$/, "");
+        entries.push({ name, path: join4(dir, file3) });
+      }
+    }
+  }
+  return entries;
+}
+var init_profile = __esm(() => {
+  init_paths();
+});
+
 // src/config/loader.ts
 import { existsSync as existsSync4 } from "fs";
-import { basename, dirname, join as join4, resolve as resolve3 } from "path";
+import { basename, dirname, join as join5, resolve as resolve3 } from "path";
 function globalConfigPath() {
-  return join4(globalConfigDir(), "config.json");
+  return join5(globalConfigDir(), "config.json");
 }
 function findProjectDir(startDir = process.cwd()) {
   let dir = resolve3(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const candidate = join4(dir, PROJECT_NAX_DIR);
-    if (existsSync4(join4(candidate, "config.json"))) {
+    const candidate = join5(dir, PROJECT_NAX_DIR);
+    if (existsSync4(join5(candidate, "config.json"))) {
       return candidate;
     }
-    const parent = join4(dir, "..");
+    const parent = join5(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -20749,22 +20912,36 @@ function applyBatchModeCompat(conf) {
 }
 async function loadConfig(startDir, cliOverrides) {
   let rawConfig = structuredClone(DEFAULT_CONFIG);
+  const projDir = startDir ? basename(startDir) === PROJECT_NAX_DIR ? startDir : findProjectDir(startDir) : findProjectDir();
+  const projectRoot = startDir ? basename(startDir) === PROJECT_NAX_DIR ? dirname(startDir) : startDir : process.cwd();
+  const profileName = await resolveProfileName(cliOverrides ?? {}, process.env, projectRoot);
   const globalConfRaw = await loadJsonFile(globalConfigPath(), "config");
   if (globalConfRaw) {
-    const globalConf = applyBatchModeCompat(applyRemovedStrategyCompat(globalConfRaw));
+    const { profile: _gProfile, ...globalConfStripped } = globalConfRaw;
+    const globalConf = applyBatchModeCompat(applyRemovedStrategyCompat(globalConfStripped));
     rawConfig = deepMergeConfig(rawConfig, globalConf);
   }
-  const projDir = startDir ? basename(startDir) === PROJECT_NAX_DIR ? startDir : findProjectDir(startDir) : findProjectDir();
   if (projDir) {
-    const projConf = await loadJsonFile(join4(projDir, "config.json"), "config");
+    const projConf = await loadJsonFile(join5(projDir, "config.json"), "config");
     if (projConf) {
-      const resolvedProjConf = applyBatchModeCompat(applyRemovedStrategyCompat(projConf));
+      const { profile: _pProfile, ...projConfStripped } = projConf;
+      const resolvedProjConf = applyBatchModeCompat(applyRemovedStrategyCompat(projConfStripped));
       rawConfig = deepMergeConfig(rawConfig, resolvedProjConf);
     }
   }
+  if (profileName !== "default") {
+    const profileData = await loadProfile(profileName, projectRoot);
+    rawConfig = deepMergeConfig(rawConfig, profileData);
+    await loadProfileEnv(profileName, projectRoot);
+  }
   if (cliOverrides) {
     rawConfig = deepMergeConfig(rawConfig, cliOverrides);
   }
+  rawConfig.profile = profileName;
+  const hasMergedConfigs = globalConfRaw || projDir !== null || cliOverrides !== undefined || profileName !== "default";
+  if (!hasMergedConfigs) {
+    return structuredClone(DEFAULT_CONFIG);
+  }
   const result = NaxConfigSchema.safeParse(rawConfig);
   if (!result.success) {
     const errors3 = result.error.issues.map((err) => {
@@ -20786,7 +20963,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir) {
     return rootConfig;
   }
   const repoRoot = dirname(rootNaxDir);
-  const packageConfigPath = join4(repoRoot, PROJECT_NAX_DIR, "mono", packageDir, "config.json");
+  const packageConfigPath = join5(repoRoot, PROJECT_NAX_DIR, "mono", packageDir, "config.json");
   const packageOverride = await loadJsonFile(packageConfigPath, "config");
   if (!packageOverride) {
     logger.debug("config", "Per-package config not found \u2014 falling back to root config", {
@@ -20803,6 +20980,7 @@ var init_loader = __esm(() => {
   init_json_file();
   init_path_security();
   init_paths();
+  init_profile();
   init_schema();
 });
 // src/config/index.ts
@@ -20811,6 +20989,7 @@ var init_config = __esm(() => {
   init_loader();
   init_path_security();
   init_paths();
+  init_profile();
 });
 
 // src/utils/errors.ts
@@ -20996,7 +21175,7 @@ __export(exports_generator, {
   acceptanceTestFilename: () => acceptanceTestFilename,
   _generatorPRDDeps: () => _generatorPRDDeps
 });
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function skeletonImportLine(testFramework) {
   if (!testFramework)
     return `import { describe, test, expect } from "bun:test";`;
@@ -21092,7 +21271,7 @@ Rules:
 - Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
 - **Prefer behavioral tests** \u2014 import functions and call them rather than reading source files. For example, to verify "getPostRunActions() returns empty array", import PluginRegistry and call getPostRunActions(), don't grep the source file for the method name.
 - **File output (REQUIRED)**: Write the acceptance test file DIRECTLY to the path shown below. Do NOT output the test code in your response. After writing the file, reply with a brief confirmation.
-- **Path anchor (CRITICAL)**: Write the test file to this exact path: \`${join5(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile(options.language, options.config?.acceptance?.testPath))}\`. Import from package sources using relative paths like \`../../../src/...\` (3 levels up from \`.nax/features/<name>/\` to the package root).`;
+- **Path anchor (CRITICAL)**: Write the test file to this exact path: \`${join6(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile(options.language, options.config?.acceptance?.testPath))}\`. Import from package sources using relative paths like \`../../../src/...\` (3 levels up from \`.nax/features/<name>/\` to the package root).`;
   const prompt = basePrompt;
   logger.info("acceptance", "Generating tests from PRD refined criteria", { count: refinedCriteria.length });
   const completeResult = await (options.adapter ?? _generatorPRDDeps.adapter).complete(prompt, {
@@ -21111,7 +21290,7 @@ Rules:
     outputPreview: rawOutput.slice(0, 300)
   });
   if (!testCode) {
-    const targetPath = join5(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile(options.language, options.config?.acceptance?.testPath));
+    const targetPath = join6(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile(options.language, options.config?.acceptance?.testPath));
     let recoveryFailed = false;
     logger.debug("acceptance", "BUG-076 recovery: checking for agent-written file", { targetPath });
     try {
@@ -21166,7 +21345,7 @@ Rules:
     testable: c.testable,
     storyId: c.storyId
   })), null, 2);
-  await _generatorPRDDeps.writeFile(join5(options.featureDir, "acceptance-refined.json"), refinedJsonContent);
+  await _generatorPRDDeps.writeFile(join6(options.featureDir, "acceptance-refined.json"), refinedJsonContent);
   return { testCode, criteria };
 }
 function parseAcceptanceCriteria(specContent) {
@@ -22163,7 +22342,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.57.1-canary.1",
+    version: "0.57.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22242,8 +22421,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("814ed29f"))
-        return "814ed29f";
+      if (/^[0-9a-f]{6,10}$/.test("2ffb62ec"))
+        return "2ffb62ec";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22390,6 +22569,27 @@ var init_prd = __esm(() => {
   PRD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 });
 
+// src/debate/concurrency.ts
+async function allSettledBounded(tasks, limit) {
+  if (tasks.length === 0)
+    return [];
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < tasks.length) {
+      const i = nextIndex++;
+      try {
+        results[i] = { status: "fulfilled", value: await tasks[i]() };
+      } catch (reason) {
+        results[i] = { status: "rejected", reason };
+      }
+    }
+  }
+  const concurrency = Math.max(1, Math.min(limit, tasks.length));
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  return results;
+}
+
 // src/debate/prompts.ts
 function buildCritiquePrompt(taskPrompt, allProposals, debaterIndex) {
   const othersProposals = allProposals.filter((_, i) => i !== debaterIndex);
@@ -22496,7 +22696,7 @@ var DEFAULT_FALLBACK_AGENT = "claude";
 var init_resolvers = () => {};
 
 // src/debate/session.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function resolveDebaterModel(debater, config2) {
   const tier = debater.model ?? "fast";
   if (!config2?.models)
@@ -22661,7 +22861,10 @@ class DebateSession {
       stage: this.stage,
       debaters: resolved.map((r) => r.debater.agent)
     });
-    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }, debaterIdx) => this.runStatefulTurn(adapter, debater, prompt, `debate-${this.stage}-${debaterIdx}`, config2.rounds > 1)));
+    const cfg = this.config;
+    const debate = cfg?.debate;
+    const concurrencyLimit = debate?.maxConcurrentDebaters ?? 2;
+    const proposalSettled = await allSettledBounded(resolved.map(({ debater, adapter }, debaterIdx) => () => this.runStatefulTurn(adapter, debater, prompt, `debate-${this.stage}-${debaterIdx}`, config2.rounds > 1)), concurrencyLimit);
     const successfulProposals = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
     for (const r of proposalSettled) {
       if (r.status === "fulfilled") {
@@ -22741,7 +22944,7 @@ class DebateSession {
     let critiqueOutputs = [];
     if (config2.rounds > 1) {
       const proposalOutputs2 = successfulProposals.map((s) => s.output);
-      const critiqueSettled = await Promise.allSettled(successfulProposals.map((proposal, successfulIdx) => this.runStatefulTurn(proposal.adapter, proposal.debater, buildCritiquePrompt(prompt, proposalOutputs2, successfulIdx), proposal.roleKey ?? `debate-${this.stage}-${successfulIdx}`, false)));
+      const critiqueSettled = await allSettledBounded(successfulProposals.map((proposal, successfulIdx) => () => this.runStatefulTurn(proposal.adapter, proposal.debater, buildCritiquePrompt(prompt, proposalOutputs2, successfulIdx), proposal.roleKey ?? `debate-${this.stage}-${successfulIdx}`, false)), concurrencyLimit);
       for (const r of critiqueSettled) {
         if (r.status === "fulfilled") {
           totalCostUsd += r.value.cost;
@@ -22791,14 +22994,17 @@ class DebateSession {
       stage: this.stage,
       debaters: resolved.map((r) => r.debater.agent)
     });
-    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }) => runComplete(adapter, prompt, {
+    const cfg = this.config;
+    const debate = cfg?.debate;
+    const concurrencyLimit = debate?.maxConcurrentDebaters ?? 2;
+    const proposalSettled = await allSettledBounded(resolved.map(({ debater, adapter }, i) => () => runComplete(adapter, prompt, {
       model: resolveDebaterModel(debater, this.config),
       featureName: this.stage,
       config: this.config,
       storyId: this.storyId,
-      sessionRole: "debate-proposal",
+      sessionRole: `debate-proposal-${i}`,
       timeoutMs: this.timeoutMs
-    }, modelTierFromDebater(debater)).then((result) => ({ debater, adapter, output: result.output, cost: result.costUsd }))));
+    }, modelTierFromDebater(debater)).then((result) => ({ debater, adapter, output: result.output, cost: result.costUsd }))), concurrencyLimit);
     const successful = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
     for (const r of proposalSettled) {
       if (r.status === "fulfilled") {
@@ -22877,14 +23083,14 @@ class DebateSession {
     let critiqueOutputs = [];
     if (config2.rounds > 1) {
       const proposalOutputs2 = successful.map((p) => p.output);
-      const critiqueSettled = await Promise.allSettled(successful.map(({ debater, adapter }, i) => runComplete(adapter, buildCritiquePrompt(prompt, proposalOutputs2, i), {
+      const critiqueSettled = await allSettledBounded(successful.map(({ debater, adapter }, i) => () => runComplete(adapter, buildCritiquePrompt(prompt, proposalOutputs2, i), {
         model: resolveDebaterModel(debater, this.config),
         featureName: this.stage,
         config: this.config,
         storyId: this.storyId,
-        sessionRole: "debate-critique",
+        sessionRole: `debate-critique-${i}`,
         timeoutMs: this.timeoutMs
-      }, modelTierFromDebater(debater))));
+      }, modelTierFromDebater(debater))), concurrencyLimit);
       for (const r of critiqueSettled) {
         if (r.status === "fulfilled") {
           totalCostUsd += r.value.costUsd;
@@ -22934,8 +23140,11 @@ class DebateSession {
       stage: this.stage,
       debaters: resolved.map((r) => r.debater.agent)
     });
-    const planSettled = await Promise.allSettled(resolved.map(async ({ debater, adapter }, i) => {
-      const tempOutputPath = join11(opts.outputDir, `prd-debate-${i}.json`);
+    const cfg = this.config;
+    const debate = cfg?.debate;
+    const concurrencyLimit = debate?.maxConcurrentDebaters ?? 2;
+    const settled = await allSettledBounded(resolved.map(({ debater, adapter }, i) => async () => {
+      const tempOutputPath = join12(opts.outputDir, `prd-debate-${i}.json`);
       const debaterPrompt = `${basePrompt}
 
 Write the PRD JSON directly to this file path: ${tempOutputPath}
@@ -22950,12 +23159,28 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
         dangerouslySkipPermissions: opts.dangerouslySkipPermissions,
         maxInteractionTurns: opts.maxInteractionTurns,
         featureName: opts.feature,
-        sessionRole: "plan"
+        storyId: this.storyId,
+        sessionRole: `plan-${i}`
       });
       const output = await _debateSessionDeps.readFile(tempOutputPath);
       return { debater, adapter, output, cost: 0 };
-    }));
-    const successful = planSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    }), concurrencyLimit);
+    const successful = [];
+    for (let i = 0;i < settled.length; i++) {
+      const res = settled[i];
+      if (res.status === "fulfilled") {
+        successful.push(res.value);
+      } else {
+        const { debater } = resolved[i];
+        logger?.warn("debate", "debate:debater-failed", {
+          storyId: this.storyId,
+          stage: this.stage,
+          debaterIndex: i,
+          agent: debater.agent,
+          error: res.reason instanceof Error ? res.reason.message : String(res.reason)
+        });
+      }
+    }
     for (let i = 0;i < successful.length; i++) {
       logger?.info("debate", "debate:proposal", {
         storyId: this.storyId,
@@ -25881,59 +26106,6 @@ ${stderr}`;
   };
 });
 
-// src/agents/claude/index.ts
-var init_claude = __esm(() => {
-  init_adapter3();
-  init_execution();
-});
-
-// src/agents/shared/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-function validateAgentFeature(agent, feature) {
-  return agent.capabilities.features.has(feature);
-}
-function describeAgentCapabilities(agent) {
-  const tiers = agent.capabilities.supportedTiers.join(",");
-  const features = Array.from(agent.capabilities.features).join(",");
-  const maxTokens = agent.capabilities.maxContextTokens;
-  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
-}
-
-// src/agents/index.ts
-var exports_agents = {};
-__export(exports_agents, {
-  validateAgentForTier: () => validateAgentForTier,
-  validateAgentFeature: () => validateAgentFeature,
-  parseTokenUsage: () => parseTokenUsage,
-  getInstalledAgents: () => getInstalledAgents,
-  getAllAgentNames: () => getAllAgentNames,
-  getAgentVersions: () => getAgentVersions,
-  getAgentVersion: () => getAgentVersion,
-  getAgent: () => getAgent,
-  formatCostWithConfidence: () => formatCostWithConfidence,
-  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
-  estimateCostFromOutput: () => estimateCostFromOutput,
-  estimateCostByDuration: () => estimateCostByDuration,
-  estimateCost: () => estimateCost,
-  describeAgentCapabilities: () => describeAgentCapabilities,
-  checkAgentHealth: () => checkAgentHealth,
-  MODEL_PRICING: () => MODEL_PRICING,
-  CompleteError: () => CompleteError,
-  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
-  COST_RATES: () => COST_RATES,
-  AllAgentsUnavailableError: () => AllAgentsUnavailableError
-});
-var init_agents = __esm(() => {
-  init_types2();
-  init_claude();
-  init_registry();
-  init_cost();
-  init_version_detection();
-  init_errors();
-});
-
 // src/pipeline/stages/acceptance-setup.ts
 var exports_acceptance_setup = {};
 __export(exports_acceptance_setup, {
@@ -26077,7 +26249,6 @@ ${stderr}` };
       }
       if (shouldGenerate) {
         totalCriteria = allCriteria.length;
-        const { getAgent: getAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
         const agent = (ctx.agentGetFn ?? _acceptanceSetupDeps.getAgent)(ctx.config.autoMode.defaultAgent);
         let allRefinedCriteria;
         if (ctx.config.acceptance.refinement) {
@@ -26105,7 +26276,7 @@ ${stderr}` };
         testableCount = allRefinedCriteria.filter((r) => r.testable).length;
         for (const [workdir, group] of workdirGroups) {
           const packageDir = workdir ? path5.join(ctx.workdir, workdir) : ctx.workdir;
-          const testPath = path5.join(packageDir, resolveAcceptanceTestFile(language, testPathConfig));
+          const testPath = path5.join(packageDir, ".nax", "features", featureName, resolveAcceptanceTestFile(language, testPathConfig));
           const groupStoryIds = new Set(group.stories.map((s) => s.id));
           const groupRefined = allRefinedCriteria.filter((r) => groupStoryIds.has(r.storyId));
           const result = await _acceptanceSetupDeps.generate(group.stories, groupRefined, {
@@ -26162,6 +26333,59 @@ ${stderr}` };
   };
 });
 
+// src/agents/claude/index.ts
+var init_claude = __esm(() => {
+  init_adapter3();
+  init_execution();
+});
+
+// src/agents/shared/validation.ts
+function validateAgentForTier(agent, tier) {
+  return agent.capabilities.supportedTiers.includes(tier);
+}
+function validateAgentFeature(agent, feature) {
+  return agent.capabilities.features.has(feature);
+}
+function describeAgentCapabilities(agent) {
+  const tiers = agent.capabilities.supportedTiers.join(",");
+  const features = Array.from(agent.capabilities.features).join(",");
+  const maxTokens = agent.capabilities.maxContextTokens;
+  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
+}
+
+// src/agents/index.ts
+var exports_agents = {};
+__export(exports_agents, {
+  validateAgentForTier: () => validateAgentForTier,
+  validateAgentFeature: () => validateAgentFeature,
+  parseTokenUsage: () => parseTokenUsage,
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgentVersions: () => getAgentVersions,
+  getAgentVersion: () => getAgentVersion,
+  getAgent: () => getAgent,
+  formatCostWithConfidence: () => formatCostWithConfidence,
+  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
+  estimateCostFromOutput: () => estimateCostFromOutput,
+  estimateCostByDuration: () => estimateCostByDuration,
+  estimateCost: () => estimateCost,
+  describeAgentCapabilities: () => describeAgentCapabilities,
+  checkAgentHealth: () => checkAgentHealth,
+  MODEL_PRICING: () => MODEL_PRICING,
+  CompleteError: () => CompleteError,
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  COST_RATES: () => COST_RATES,
+  AllAgentsUnavailableError: () => AllAgentsUnavailableError
+});
+var init_agents = __esm(() => {
+  init_types2();
+  init_claude();
+  init_registry();
+  init_cost();
+  init_version_detection();
+  init_errors();
+});
+
 // src/quality/runner.ts
 var {spawn: spawn2 } = globalThis.Bun;
 async function runQualityCommand(opts) {
@@ -26251,6 +26475,59 @@ var init_quality = __esm(() => {
   init_runner2();
 });
 
+// src/verification/shared-rectification-loop.ts
+function resolveLogData(data, state) {
+  if (!data) {
+    return;
+  }
+  return typeof data === "function" ? data(state) : data;
+}
+function buildProgressivePromptPreamble(opts) {
+  const rethinkAt = Math.min(opts.rethinkAtAttempt ?? 2, opts.maxAttempts);
+  const urgencyAt = Math.min(opts.urgencyAtAttempt ?? 3, opts.maxAttempts);
+  const shouldRethink = opts.attempt >= rethinkAt;
+  const shouldUrgency = opts.attempt >= urgencyAt;
+  if (!shouldRethink && !shouldUrgency) {
+    return "";
+  }
+  if (shouldUrgency) {
+    opts.logger?.info(opts.stage, "Progressive prompt escalation: urgency + rethink injected", {
+      attempt: opts.attempt,
+      rethinkAtAttempt: rethinkAt,
+      urgencyAtAttempt: urgencyAt,
+      maxAttempts: opts.maxAttempts
+    });
+  } else {
+    opts.logger?.info(opts.stage, "Progressive prompt escalation: rethink injected", {
+      attempt: opts.attempt,
+      rethinkAtAttempt: rethinkAt,
+      maxAttempts: opts.maxAttempts
+    });
+  }
+  const urgencySection = shouldUrgency ? opts.urgencySection : "";
+  const rethinkSection = shouldRethink ? opts.rethinkSection : "";
+  return `${urgencySection}${rethinkSection}`;
+}
+async function runSharedRectificationLoop(opts) {
+  opts.logger?.info(opts.stage, opts.startMessage, resolveLogData(opts.startData, opts.state));
+  while (opts.canContinue(opts.state)) {
+    opts.state.attempt++;
+    opts.logger?.info(opts.stage, opts.attemptMessage(opts.state.attempt, opts.maxAttempts, opts.state), resolveLogData(opts.attemptData, opts.state));
+    const prompt = await opts.buildPrompt(opts.state.attempt, opts.state);
+    await opts.runAttempt(opts.state.attempt, prompt, opts.state);
+    const passed = await opts.checkResult(opts.state.attempt, opts.state);
+    if (passed) {
+      return true;
+    }
+    await opts.onAttemptFailure?.(opts.state.attempt, opts.state);
+  }
+  await opts.onLoopEnd?.(opts.state);
+  if (opts.state.attempt >= opts.maxAttempts) {
+    return await opts.onExhausted?.(opts.state) ?? false;
+  }
+  return false;
+}
+
 // src/pipeline/event-bus.ts
 class PipelineEventBus {
   subscribers = new Map;
@@ -26702,6 +26979,16 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
   const needsTruncation = rawDiff.length > DIFF_CAP_BYTES;
   const stat = needsTruncation ? await collectDiffStat(workdir, effectiveRef) : undefined;
   const diff = truncateDiff(rawDiff, stat);
+  if (!diff) {
+    return {
+      check: "semantic",
+      success: true,
+      command: "",
+      exitCode: 0,
+      output: "skipped: no production code changes",
+      durationMs: Date.now() - startTime
+    };
+  }
   const agent = modelResolver(semanticConfig.modelTier);
   if (!agent) {
     logger?.warn("semantic", "No agent available for semantic review \u2014 skipping", {
@@ -27196,7 +27483,7 @@ __export(exports_review, {
   reviewStage: () => reviewStage,
   _reviewDeps: () => _reviewDeps
 });
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var reviewStage, _reviewDeps;
 var init_review = __esm(() => {
   init_agents();
@@ -27210,7 +27497,7 @@ var init_review = __esm(() => {
       const logger = getLogger();
       const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       logger.info("review", "Running review phase", { storyId: ctx.story.id });
-      const effectiveWorkdir = ctx.story.workdir ? join17(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const effectiveWorkdir = ctx.story.workdir ? join18(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       const agentResolver = ctx.agentGetFn ?? getAgent;
       const agentName = effectiveConfig.autoMode?.defaultAgent;
       const modelResolver = (_tier) => agentName ? agentResolver(agentName) ?? null : null;
@@ -27262,7 +27549,7 @@ var init_review = __esm(() => {
 });
 
 // src/pipeline/stages/autofix.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function recheckReview(ctx) {
   const { reviewStage: reviewStage2 } = await Promise.resolve().then(() => (init_review(), exports_review));
   if (!reviewStage2.enabled(ctx))
@@ -27295,11 +27582,38 @@ Fix ALL errors listed above. Do NOT change test files or test behavior.
 Do NOT add new features \u2014 only fix the quality check errors.
 Commit your fixes when done.${scopeConstraint}`;
 }
+function buildAutofixEscalationPreamble(attempt, maxAttempts, rethinkAtAttempt, urgencyAtAttempt) {
+  return buildProgressivePromptPreamble({
+    attempt,
+    maxAttempts,
+    rethinkAtAttempt,
+    urgencyAtAttempt,
+    stage: "autofix",
+    logger: getLogger(),
+    urgencySection: `## Final Autofix Attempt Before Escalation
+
+This is attempt ${attempt}. If the review still fails after this, autofix will escalate instead of retrying.
+A different approach is required. Do not repeat the same fix.
+
+`,
+    rethinkSection: `## Previous Attempt Did Not Fix the Failures
+
+Your previous fix attempt (attempt ${attempt}) did not resolve the quality errors. Rethink your approach.
+
+- Do not repeat the same edit pattern.
+- Re-read the failing diagnostics carefully.
+- Try a fundamentally different fix strategy if the earlier one did not work.
+
+`
+  });
+}
 async function runAgentRectification(ctx) {
   const logger = getLogger();
   const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
   const maxPerCycle = effectiveConfig.quality.autofix?.maxAttempts ?? 2;
   const maxTotal = effectiveConfig.quality.autofix?.maxTotalAttempts ?? 10;
+  const rethinkAtAttempt = effectiveConfig.quality.autofix?.rethinkAtAttempt ?? 2;
+  const urgencyAtAttempt = effectiveConfig.quality.autofix?.urgencyAtAttempt ?? 3;
   const consumed = ctx.autofixAttempt ?? 0;
   const failedChecks = collectFailedChecks(ctx);
   if (failedChecks.length === 0) {
@@ -27316,56 +27630,90 @@ async function runAgentRectification(ctx) {
   }
   const remainingBudget = maxTotal - consumed;
   const maxAttempts = Math.min(maxPerCycle, remainingBudget);
-  logger.info("autofix", "Starting agent rectification for review failures", {
+  const agentGetFn = ctx.agentGetFn ?? _autofixDeps.getAgent;
+  const loopState = {
+    attempt: 0,
+    failedChecks
+  };
+  return runSharedRectificationLoop({
+    stage: "autofix",
     storyId: ctx.story.id,
-    failedChecks: failedChecks.map((c) => c.check),
     maxAttempts,
-    totalUsed: consumed,
-    maxTotalAttempts: maxTotal
-  });
-  const agentGetFn = ctx.agentGetFn ?? _autofixDeps.getAgent;
-  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-    ctx.autofixAttempt = consumed + attempt;
-    logger.info("autofix", `Agent rectification attempt ${ctx.autofixAttempt}/${maxTotal}`, { storyId: ctx.story.id });
-    const agent = agentGetFn(ctx.config.autoMode.defaultAgent);
-    if (!agent) {
-      logger.error("autofix", "Agent not found \u2014 cannot run agent rectification", { storyId: ctx.story.id });
-      return false;
-    }
-    const prompt = buildReviewRectificationPrompt(failedChecks, ctx.story);
-    const modelTier = ctx.story.routing?.modelTier ?? ctx.config.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
-    const modelDef = resolveModelForAgent(ctx.config.models, ctx.routing.agent ?? ctx.config.autoMode.defaultAgent, modelTier, ctx.config.autoMode.defaultAgent);
-    const rectificationWorkdir = ctx.story.workdir ? join18(ctx.workdir, ctx.story.workdir) : ctx.workdir;
-    await agent.run({
-      prompt,
-      workdir: rectificationWorkdir,
-      modelTier,
-      modelDef,
-      timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
-      dangerouslySkipPermissions: resolvePermissions(ctx.config, "rectification").skipPermissions,
-      pipelineStage: "rectification",
-      config: ctx.config,
-      maxInteractionTurns: ctx.config.agent?.maxInteractionTurns,
+    state: loopState,
+    logger,
+    startMessage: "Starting agent rectification for review failures",
+    startData: {
       storyId: ctx.story.id,
-      sessionRole: "implementer"
-    });
-    const passed = await _autofixDeps.recheckReview(ctx);
-    if (passed) {
-      logger.info("autofix", `[OK] Agent rectification succeeded on attempt ${attempt}`, {
+      failedChecks: failedChecks.map((check2) => check2.check),
+      maxAttempts,
+      totalUsed: consumed,
+      maxTotalAttempts: maxTotal
+    },
+    attemptMessage: (attempt) => `Agent rectification attempt ${consumed + attempt}/${maxTotal}`,
+    attemptData: { storyId: ctx.story.id },
+    canContinue: (state) => state.failedChecks.length > 0 && state.attempt < maxAttempts,
+    buildPrompt: (attempt, state) => {
+      let prompt = buildReviewRectificationPrompt(state.failedChecks, ctx.story);
+      const escalationPreamble = buildAutofixEscalationPreamble(attempt, maxAttempts, rethinkAtAttempt, urgencyAtAttempt);
+      if (escalationPreamble) {
+        prompt = `${escalationPreamble}${prompt}`;
+      }
+      return prompt;
+    },
+    runAttempt: async (attempt, prompt) => {
+      ctx.autofixAttempt = consumed + attempt;
+      const agent = agentGetFn(ctx.config.autoMode.defaultAgent);
+      if (!agent) {
+        logger.error("autofix", "Agent not found \u2014 cannot run agent rectification", { storyId: ctx.story.id });
+        throw new Error("AUTOFIX_AGENT_NOT_FOUND");
+      }
+      const modelTier = ctx.story.routing?.modelTier ?? ctx.config.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
+      const modelDef = resolveModelForAgent(ctx.config.models, ctx.routing.agent ?? ctx.config.autoMode.defaultAgent, modelTier, ctx.config.autoMode.defaultAgent);
+      const rectificationWorkdir = ctx.story.workdir ? join19(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      await agent.run({
+        prompt,
+        workdir: rectificationWorkdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
+        dangerouslySkipPermissions: resolvePermissions(ctx.config, "rectification").skipPermissions,
+        pipelineStage: "rectification",
+        config: ctx.config,
+        maxInteractionTurns: ctx.config.agent?.maxInteractionTurns,
+        storyId: ctx.story.id,
+        sessionRole: "implementer"
+      });
+    },
+    checkResult: async (attempt, state) => {
+      const passed = await _autofixDeps.recheckReview(ctx);
+      if (passed) {
+        logger.info("autofix", `[OK] Agent rectification succeeded on attempt ${attempt}`, {
+          storyId: ctx.story.id
+        });
+        return true;
+      }
+      const updatedFailed = collectFailedChecks(ctx);
+      if (updatedFailed.length > 0) {
+        state.failedChecks.splice(0, state.failedChecks.length, ...updatedFailed);
+      }
+      return false;
+    },
+    onAttemptFailure: (attempt) => {
+      logger.warn("autofix", `Agent rectification still failing after attempt ${attempt}`, {
         storyId: ctx.story.id
       });
-      return true;
+    },
+    onLoopEnd: (state) => {
+      if (state.attempt >= maxAttempts) {
+        logger.warn("autofix", "Agent rectification exhausted", { storyId: ctx.story.id });
+      }
     }
-    const updatedFailed = collectFailedChecks(ctx);
-    if (updatedFailed.length > 0) {
-      failedChecks.splice(0, failedChecks.length, ...updatedFailed);
+  }).catch((error48) => {
+    if (error48 instanceof Error && error48.message === "AUTOFIX_AGENT_NOT_FOUND") {
+      return false;
     }
-    logger.warn("autofix", `Agent rectification still failing after attempt ${attempt}`, {
-      storyId: ctx.story.id
-    });
-  }
-  logger.warn("autofix", "Agent rectification exhausted", { storyId: ctx.story.id });
-  return false;
+    throw error48;
+  });
 }
 var autofixStage, _autofixDeps;
 var init_autofix = __esm(() => {
@@ -27399,7 +27747,7 @@ var init_autofix = __esm(() => {
       const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       const lintFixCmd = effectiveConfig.quality.commands.lintFix;
       const formatFixCmd = effectiveConfig.quality.commands.formatFix;
-      const effectiveWorkdir = ctx.story.workdir ? join18(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const effectiveWorkdir = ctx.story.workdir ? join19(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       const failedCheckNames = new Set((reviewResult.checks ?? []).filter((c) => !c.success).map((c) => c.check));
       const hasLintFailure = failedCheckNames.has("lint");
       logger.info("autofix", "Starting autofix", {
@@ -27483,10 +27831,10 @@ var init_autofix = __esm(() => {
 
 // src/execution/progress.ts
 import { appendFile as appendFile2, mkdir } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir(featureDir, { recursive: true });
-  const progressPath = join19(featureDir, "progress.txt");
+  const progressPath = join20(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -27569,7 +27917,7 @@ function estimateTokens(text) {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync19 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -27591,7 +27939,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join20(globalConfigDir(), config2.path);
+    const globalPath = join21(globalConfigDir(), config2.path);
     if (existsSync19(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -27601,7 +27949,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join20(projectDir, config2.path);
+  const projectPath = join21(projectDir, config2.path);
   if (existsSync19(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -28629,7 +28977,7 @@ var init_helpers = __esm(() => {
 });
 
 // src/pipeline/stages/context.ts
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var contextStage;
 var init_context2 = __esm(() => {
   init_helpers();
@@ -28639,7 +28987,7 @@ var init_context2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const packageWorkdir = ctx.story.workdir ? join21(ctx.workdir, ctx.story.workdir) : undefined;
+      const packageWorkdir = ctx.story.workdir ? join22(ctx.workdir, ctx.story.workdir) : undefined;
       const result = await buildStoryContextFull(ctx.prd, ctx.story, ctx.config, packageWorkdir);
       if (result) {
         ctx.contextMarkdown = result.markdown;
@@ -28773,14 +29121,14 @@ var init_isolation = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 async function scanForTestFiles(dir, testPattern, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join22(dir, entry.name);
+      const fullPath = join23(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -29135,13 +29483,13 @@ function parseTestOutput(output, exitCode) {
 
 // src/verification/runners.ts
 import { existsSync as existsSync20 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file3 of expectedFiles) {
-    if (!existsSync20(join23(workingDirectory, file3)))
+    if (!existsSync20(join24(workingDirectory, file3)))
       missingFiles.push(file3);
   }
   if (missingFiles.length > 0) {
@@ -29245,27 +29593,14 @@ function shouldRetryRectification(state, config2) {
   return true;
 }
 function buildEscalationPreamble(attempt, config2) {
-  const logger = getSafeLogger();
-  const rethinkAt = Math.min(config2.rethinkAtAttempt ?? 2, config2.maxRetries);
-  const urgencyAt = Math.min(config2.urgencyAtAttempt ?? 3, config2.maxRetries);
-  if (attempt < rethinkAt)
-    return "";
-  const isUrgent = attempt >= urgencyAt;
-  if (isUrgent) {
-    logger?.info("rectification", "Progressive prompt escalation: urgency + rethink injected", {
-      attempt,
-      urgencyAtAttempt: urgencyAt,
-      rethinkAtAttempt: rethinkAt,
-      maxRetries: config2.maxRetries
-    });
-  } else {
-    logger?.info("rectification", "Progressive prompt escalation: rethink injected", {
-      attempt,
-      rethinkAtAttempt: rethinkAt,
-      maxRetries: config2.maxRetries
-    });
-  }
-  const rethinkSection = `## \u26A0\uFE0F Previous Attempt Did Not Fix the Failures
+  return buildProgressivePromptPreamble({
+    attempt,
+    maxAttempts: config2.maxRetries,
+    rethinkAtAttempt: config2.rethinkAtAttempt,
+    urgencyAtAttempt: config2.urgencyAtAttempt,
+    stage: "rectification",
+    logger: getSafeLogger(),
+    rethinkSection: `## \u26A0\uFE0F Previous Attempt Did Not Fix the Failures
 
 Your previous fix attempt (attempt ${attempt}) did not resolve all failures. **Step back and reconsider your approach.**
 
@@ -29274,14 +29609,14 @@ Your previous fix attempt (attempt ${attempt}) did not resolve all failures. **S
 - Re-read the story context and test failures carefully before making changes.
 - Consider: are there missing edge cases, incorrect assumptions, or a design flaw in the implementation?
 
-`;
-  const urgencySection = isUrgent ? `## \uD83D\uDEA8 Final Rectification Attempt Before Model Escalation
+`,
+    urgencySection: `## \uD83D\uDEA8 Final Rectification Attempt Before Model Escalation
 
 This is attempt ${attempt} \u2014 if the tests still fail after this, the task will escalate to a stronger model tier.
 A **completely different approach** is required. Do not repeat what you have already tried.
 
-` : "";
-  return `${urgencySection}${rethinkSection}`;
+`
+  });
 }
 function createRectificationPrompt(failures, story, config2, attempt) {
   const maxChars = config2?.maxFailureSummaryChars ?? 2000;
@@ -29541,77 +29876,112 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
     storyId: story.id,
     sessionName: rectificationSessionName
   });
-  while (_rectificationGateDeps.shouldRetryRectification(rectificationState, rectificationConfig)) {
-    rectificationState.attempt++;
-    const isLastAttempt = rectificationState.attempt >= rectificationConfig.maxRetries;
-    logger.info("tdd", `-> Implementer rectification attempt ${rectificationState.attempt}/${rectificationConfig.maxRetries}`, { storyId: story.id, currentFailures: rectificationState.currentFailures });
-    const rectificationPrompt = buildImplementerRectificationPrompt(testSummary.failures, story, contextMarkdown, rectificationConfig);
-    const rectifyBeforeRef = await captureGitRef(workdir) ?? "HEAD";
-    const rectifyResult = await agent.run({
-      prompt: rectificationPrompt,
-      workdir,
-      modelTier: implementerTier,
-      modelDef: resolveModelForAgent(config2.models, story.routing?.agent ?? config2.autoMode.defaultAgent, implementerTier, config2.autoMode.defaultAgent),
-      timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-      dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
-      pipelineStage: "rectification",
-      config: config2,
-      maxInteractionTurns: config2.agent?.maxInteractionTurns,
-      featureName,
+  const loopState = {
+    ...rectificationState,
+    isolationPassed: true
+  };
+  const fixed = await runSharedRectificationLoop({
+    stage: "tdd",
+    storyId: story.id,
+    maxAttempts: rectificationConfig.maxRetries,
+    state: loopState,
+    logger,
+    startMessage: "Full suite gate detected regressions",
+    startData: {
       storyId: story.id,
-      sessionRole: "implementer",
-      acpSessionName: rectificationSessionName,
-      keepSessionOpen: !isLastAttempt
-    });
-    if (!rectifyResult.success && rectifyResult.pid) {
-      await cleanupProcessTree(rectifyResult.pid);
-    }
-    if (rectifyResult.success) {
-      logger.info("tdd", "Rectification agent session complete", {
-        storyId: story.id,
-        attempt: rectificationState.attempt,
-        cost: rectifyResult.estimatedCost
-      });
-    } else {
-      logger.warn("tdd", "Rectification agent session failed", {
+      failedTests: testSummary.failed,
+      passedTests: testSummary.passed
+    },
+    attemptMessage: (attempt) => `-> Implementer rectification attempt ${attempt}/${rectificationConfig.maxRetries}`,
+    attemptData: (state) => ({
+      storyId: story.id,
+      currentFailures: state.currentFailures
+    }),
+    canContinue: (state) => state.isolationPassed && _rectificationGateDeps.shouldRetryRectification(state, rectificationConfig),
+    buildPrompt: () => buildImplementerRectificationPrompt(testSummary.failures, story, contextMarkdown, rectificationConfig),
+    runAttempt: async (attempt, rectificationPrompt) => {
+      const isLastAttempt = attempt >= rectificationConfig.maxRetries;
+      const rectifyBeforeRef = await captureGitRef(workdir) ?? "HEAD";
+      const rectifyResult = await agent.run({
+        prompt: rectificationPrompt,
+        workdir,
+        modelTier: implementerTier,
+        modelDef: resolveModelForAgent(config2.models, story.routing?.agent ?? config2.autoMode.defaultAgent, implementerTier, config2.autoMode.defaultAgent),
+        timeoutSeconds: config2.execution.sessionTimeoutSeconds,
+        dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
+        pipelineStage: "rectification",
+        config: config2,
+        maxInteractionTurns: config2.agent?.maxInteractionTurns,
+        featureName,
         storyId: story.id,
-        attempt: rectificationState.attempt,
-        exitCode: rectifyResult.exitCode
+        sessionRole: "implementer",
+        acpSessionName: rectificationSessionName,
+        keepSessionOpen: !isLastAttempt
       });
-    }
-    await autoCommitIfDirty(workdir, "tdd", "rectification", story.id);
-    const rectifyIsolation = lite ? undefined : await verifyImplementerIsolation(workdir, rectifyBeforeRef);
-    if (rectifyIsolation && !rectifyIsolation.passed) {
-      logger.error("tdd", "Rectification violated isolation", {
-        storyId: story.id,
-        attempt: rectificationState.attempt,
-        violations: rectifyIsolation.violations
+      if (!rectifyResult.success && rectifyResult.pid) {
+        await cleanupProcessTree(rectifyResult.pid);
+      }
+      if (rectifyResult.success) {
+        logger.info("tdd", "Rectification agent session complete", {
+          storyId: story.id,
+          attempt,
+          cost: rectifyResult.estimatedCost
+        });
+      } else {
+        logger.warn("tdd", "Rectification agent session failed", {
+          storyId: story.id,
+          attempt,
+          exitCode: rectifyResult.exitCode
+        });
+      }
+      await autoCommitIfDirty(workdir, "tdd", "rectification", story.id);
+      const rectifyIsolation = lite ? undefined : await verifyImplementerIsolation(workdir, rectifyBeforeRef);
+      if (rectifyIsolation && !rectifyIsolation.passed) {
+        loopState.isolationPassed = false;
+        logger.error("tdd", "Rectification violated isolation", {
+          storyId: story.id,
+          attempt,
+          violations: rectifyIsolation.violations
+        });
+      }
+    },
+    checkResult: async (attempt, state) => {
+      if (!state.isolationPassed) {
+        return false;
+      }
+      const retryFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
+        cwd: workdir
       });
-      break;
-    }
-    const retryFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
-      cwd: workdir
-    });
-    const retrySuitePassed = retryFullSuite.success && retryFullSuite.exitCode === 0;
-    if (retrySuitePassed) {
-      logger.info("tdd", "Full suite gate passed after rectification!", {
+      const retrySuitePassed = retryFullSuite.success && retryFullSuite.exitCode === 0;
+      if (retrySuitePassed) {
+        logger.info("tdd", "Full suite gate passed after rectification!", {
+          storyId: story.id,
+          attempt
+        });
+        return true;
+      }
+      if (retryFullSuite.output) {
+        const newTestSummary = _rectificationGateDeps.parseBunTestOutput(retryFullSuite.output);
+        state.currentFailures = newTestSummary.failed;
+        testSummary.failures = newTestSummary.failures;
+        testSummary.failed = newTestSummary.failed;
+        testSummary.passed = newTestSummary.passed;
+      }
+      return false;
+    },
+    onAttemptFailure: (attempt, state) => {
+      if (!state.isolationPassed) {
+        return;
+      }
+      logger.warn("tdd", "Full suite still failing after rectification attempt", {
         storyId: story.id,
-        attempt: rectificationState.attempt
+        attempt,
+        remainingFailures: state.currentFailures
       });
-      return true;
     }
-    if (retryFullSuite.output) {
-      const newTestSummary = _rectificationGateDeps.parseBunTestOutput(retryFullSuite.output);
-      rectificationState.currentFailures = newTestSummary.failed;
-      testSummary.failures = newTestSummary.failures;
-      testSummary.failed = newTestSummary.failed;
-      testSummary.passed = newTestSummary.passed;
-    }
-    logger.warn("tdd", "Full suite still failing after rectification attempt", {
-      storyId: story.id,
-      attempt: rectificationState.attempt,
-      remainingFailures: rectificationState.currentFailures
-    });
+  });
+  if (fixed) {
+    return true;
   }
   const finalFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
     cwd: workdir
@@ -30035,13 +30405,13 @@ var exports_loader = {};
 __export(exports_loader, {
   loadOverride: () => loadOverride
 });
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join24(workdir, overridePath);
+  const absolutePath = join25(workdir, overridePath);
   const file3 = Bun.file(absolutePath);
   if (!await file3.exists()) {
     return null;
@@ -30900,11 +31270,11 @@ var init_tdd = __esm(() => {
 
 // src/pipeline/stages/execution.ts
 import { existsSync as existsSync21 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function resolveStoryWorkdir(repoRoot, storyWorkdir) {
   if (!storyWorkdir)
     return repoRoot;
-  const resolved = join25(repoRoot, storyWorkdir);
+  const resolved = join26(repoRoot, storyWorkdir);
   if (!existsSync21(resolved)) {
     throw new Error(`[execution] story.workdir "${storyWorkdir}" does not exist at "${resolved}"`);
   }
@@ -31609,167 +31979,202 @@ async function runRectificationLoop2(opts) {
     currentFailures: testSummary.failed,
     lastExitCode: 1
   };
-  logger?.info("rectification", `Starting ${label} loop`, {
+  return runSharedRectificationLoop({
+    stage: "rectification",
     storyId: story.id,
-    initialFailures: rectificationState.initialFailures,
-    maxRetries: rectificationConfig.maxRetries
-  });
-  while (shouldRetryRectification(rectificationState, rectificationConfig)) {
-    rectificationState.attempt++;
-    logger?.info("rectification", `${label} attempt ${rectificationState.attempt}/${rectificationConfig.maxRetries}`, {
+    maxAttempts: rectificationConfig.maxRetries,
+    state: rectificationState,
+    logger,
+    startMessage: `Starting ${label} loop`,
+    startData: {
+      storyId: story.id,
+      initialFailures: rectificationState.initialFailures,
+      maxRetries: rectificationConfig.maxRetries
+    },
+    attemptMessage: (attempt) => `${label} attempt ${attempt}/${rectificationConfig.maxRetries}`,
+    attemptData: () => ({
       storyId: story.id,
       currentFailures: rectificationState.currentFailures
-    });
-    let diagnosisPrefix = null;
-    const debateStageConfig = config2.debate?.stages?.rectification;
-    if (debateStageConfig?.enabled) {
-      const failureSummary = formatFailureSummary(testSummary.failures);
-      const diagnosisPrompt = `Analyze the following test failures and identify the root cause:
+    }),
+    canContinue: (state) => shouldRetryRectification(state, rectificationConfig),
+    buildPrompt: async (attempt) => {
+      let diagnosisPrefix = null;
+      const debateStageConfig = config2.debate?.stages?.rectification;
+      if (debateStageConfig?.enabled) {
+        const failureSummary = formatFailureSummary(testSummary.failures);
+        const diagnosisPrompt = `Analyze the following test failures and identify the root cause:
 
 ${failureSummary}`;
-      try {
-        const debateResult = await _rectificationDeps.runDebate(story.id, debateStageConfig, diagnosisPrompt, config2);
-        if (debateResult.totalCostUsd > 0 && story.routing) {
-          story.routing.estimatedCost = (story.routing.estimatedCost ?? 0) + debateResult.totalCostUsd;
-        }
-        if (debateResult.output !== null) {
-          diagnosisPrefix = `## Root Cause Analysis
+        try {
+          const debateResult = await _rectificationDeps.runDebate(story.id, debateStageConfig, diagnosisPrompt, config2);
+          if (debateResult.totalCostUsd > 0 && story.routing) {
+            story.routing.estimatedCost = (story.routing.estimatedCost ?? 0) + debateResult.totalCostUsd;
+          }
+          if (debateResult.output !== null) {
+            diagnosisPrefix = `## Root Cause Analysis
 
 ${debateResult.output}`;
-        } else {
-          logger?.info("rectification", "debate diagnosis fallback \u2014 all debaters failed", {
+          } else {
+            logger?.info("rectification", "debate diagnosis fallback \u2014 all debaters failed", {
+              storyId: story.id,
+              attempt,
+              event: "fallback"
+            });
+          }
+        } catch (_error) {
+          logger?.info("rectification", "debate diagnosis fallback \u2014 debate threw error", {
             storyId: story.id,
-            attempt: rectificationState.attempt,
+            attempt,
             event: "fallback"
           });
         }
-      } catch (err) {
-        logger?.info("rectification", "debate diagnosis fallback \u2014 debate threw error", {
-          storyId: story.id,
-          attempt: rectificationState.attempt,
-          event: "fallback"
-        });
       }
-    }
-    let rectificationPrompt = createRectificationPrompt(testSummary.failures, story, rectificationConfig, rectificationState.attempt);
-    if (diagnosisPrefix)
-      rectificationPrompt = `${diagnosisPrefix}
+      let rectificationPrompt = createRectificationPrompt(testSummary.failures, story, rectificationConfig, attempt);
+      if (diagnosisPrefix) {
+        rectificationPrompt = `${diagnosisPrefix}
 
 ${rectificationPrompt}`;
-    if (promptPrefix)
-      rectificationPrompt = `${promptPrefix}
+      }
+      if (promptPrefix) {
+        rectificationPrompt = `${promptPrefix}
 
 ${rectificationPrompt}`;
-    const agent = agentGetFn ? agentGetFn(config2.autoMode.defaultAgent) : _rectificationDeps.getAgent(config2.autoMode.defaultAgent, config2);
-    if (!agent) {
-      logger?.error("rectification", "Agent not found, cannot retry");
-      break;
-    }
-    const complexity = story.routing?.complexity ?? "medium";
-    const modelTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
-    const modelDef = resolveModelForAgent(config2.models, story.routing?.agent ?? config2.autoMode.defaultAgent, modelTier, config2.autoMode.defaultAgent);
-    const agentResult = await agent.run({
-      prompt: rectificationPrompt,
-      workdir,
-      modelTier,
-      modelDef,
-      timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-      dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
-      pipelineStage: "rectification",
-      config: config2,
-      maxInteractionTurns: config2.agent?.maxInteractionTurns,
-      featureName,
-      storyId: story.id,
-      sessionRole: "implementer"
-    });
-    if (agentResult.success) {
-      logger?.info("rectification", `Agent ${label} session complete`, {
+      }
+      return rectificationPrompt;
+    },
+    runAttempt: async (attempt, rectificationPrompt) => {
+      const agent = agentGetFn ? agentGetFn(config2.autoMode.defaultAgent) : _rectificationDeps.getAgent(config2.autoMode.defaultAgent, config2);
+      if (!agent) {
+        logger?.error("rectification", "Agent not found, cannot retry");
+        throw new Error("RECTIFICATION_AGENT_NOT_FOUND");
+      }
+      const complexity = story.routing?.complexity ?? "medium";
+      const modelTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
+      const modelDef = resolveModelForAgent(config2.models, story.routing?.agent ?? config2.autoMode.defaultAgent, modelTier, config2.autoMode.defaultAgent);
+      const agentResult = await agent.run({
+        prompt: rectificationPrompt,
+        workdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds: config2.execution.sessionTimeoutSeconds,
+        dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
+        pipelineStage: "rectification",
+        config: config2,
+        maxInteractionTurns: config2.agent?.maxInteractionTurns,
+        featureName,
         storyId: story.id,
-        attempt: rectificationState.attempt,
-        cost: agentResult.estimatedCost
+        sessionRole: "implementer"
       });
-    } else {
-      logger?.warn("rectification", `Agent ${label} session failed`, {
-        storyId: story.id,
-        attempt: rectificationState.attempt,
-        exitCode: agentResult.exitCode
+      if (agentResult.success) {
+        logger?.info("rectification", `Agent ${label} session complete`, {
+          storyId: story.id,
+          attempt,
+          cost: agentResult.estimatedCost
+        });
+      } else {
+        logger?.warn("rectification", `Agent ${label} session failed`, {
+          storyId: story.id,
+          attempt,
+          exitCode: agentResult.exitCode
+        });
+      }
+    },
+    checkResult: async (attempt, state) => {
+      const retryVerification = await _rectificationDeps.runVerification({
+        workdir,
+        expectedFiles: getExpectedFiles(story),
+        command: testCommand,
+        timeoutSeconds,
+        forceExit: config2.quality.forceExit,
+        detectOpenHandles: config2.quality.detectOpenHandles,
+        detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
+        timeoutRetryCount: 0,
+        gracePeriodMs: config2.quality.gracePeriodMs,
+        drainTimeoutMs: config2.quality.drainTimeoutMs,
+        shell: config2.quality.shell,
+        stripEnvVars: config2.quality.stripEnvVars
       });
-    }
-    const retryVerification = await _rectificationDeps.runVerification({
-      workdir,
-      expectedFiles: getExpectedFiles(story),
-      command: testCommand,
-      timeoutSeconds,
-      forceExit: config2.quality.forceExit,
-      detectOpenHandles: config2.quality.detectOpenHandles,
-      detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
-      timeoutRetryCount: 0,
-      gracePeriodMs: config2.quality.gracePeriodMs,
-      drainTimeoutMs: config2.quality.drainTimeoutMs,
-      shell: config2.quality.shell,
-      stripEnvVars: config2.quality.stripEnvVars
-    });
-    if (retryVerification.success) {
-      logger?.info("rectification", `[OK] ${label} succeeded!`, {
+      if (retryVerification.success) {
+        logger?.info("rectification", `[OK] ${label} succeeded!`, {
+          storyId: story.id,
+          attempt,
+          initialFailures: state.initialFailures
+        });
+        return true;
+      }
+      if (retryVerification.output) {
+        const newTestSummary = parseBunTestOutput(retryVerification.output);
+        state.currentFailures = newTestSummary.failed;
+        state.lastExitCode = retryVerification.status === "SUCCESS" ? 0 : 1;
+        testSummary.failures = newTestSummary.failures;
+        testSummary.failed = newTestSummary.failed;
+        testSummary.passed = newTestSummary.passed;
+        if (newTestSummary.failed === 0) {
+          state.lastExitCode = 0;
+          logger?.info("rectification", `[OK] ${label} succeeded after parsing retry output`, {
+            storyId: story.id,
+            attempt,
+            initialFailures: state.initialFailures
+          });
+          return true;
+        }
+      }
+      return false;
+    },
+    onAttemptFailure: (attempt, state) => {
+      const failingTests = testSummary.failures.slice(0, 10).map((failure) => failure.testName);
+      const logData = {
         storyId: story.id,
-        attempt: rectificationState.attempt,
-        initialFailures: rectificationState.initialFailures
-      });
-      return true;
-    }
-    if (retryVerification.output) {
-      const newTestSummary = parseBunTestOutput(retryVerification.output);
-      rectificationState.currentFailures = newTestSummary.failed;
-      rectificationState.lastExitCode = retryVerification.status === "SUCCESS" ? 0 : 1;
-      testSummary.failures = newTestSummary.failures;
-      testSummary.failed = newTestSummary.failed;
-      testSummary.passed = newTestSummary.passed;
-    }
-    const failingTests = testSummary.failures.slice(0, 10).map((f) => f.testName);
-    const logData = {
-      storyId: story.id,
-      attempt: rectificationState.attempt,
-      remainingFailures: rectificationState.currentFailures,
-      failingTests
-    };
-    if (testSummary.failures.length > 10 || testSummary.failures.length === 0 && testSummary.failed > 0) {
-      logData.totalFailingTests = testSummary.failed;
-    }
-    logger?.warn("rectification", `${label} still failing after attempt`, logData);
-  }
-  if (rectificationState.attempt >= rectificationConfig.maxRetries) {
-    logger?.warn("rectification", `${label} exhausted max retries`, {
-      storyId: story.id,
-      attempts: rectificationState.attempt,
-      remainingFailures: rectificationState.currentFailures
-    });
-  } else if (rectificationState.currentFailures > rectificationState.initialFailures) {
-    logger?.warn("rectification", `${label} aborted due to further regression`, {
-      storyId: story.id,
-      initialFailures: rectificationState.initialFailures,
-      currentFailures: rectificationState.currentFailures
-    });
-  }
-  const shouldEscalate = rectificationConfig.escalateOnExhaustion !== false && config2.autoMode?.escalation?.enabled === true && rectificationState.attempt >= rectificationConfig.maxRetries && rectificationState.currentFailures > 0;
-  if (shouldEscalate) {
-    const complexity = story.routing?.complexity ?? "medium";
-    const currentTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
-    const tierOrder = config2.autoMode.escalation.tierOrder;
-    const escalationResult = _rectificationDeps.escalateTier(currentTier, tierOrder);
-    const escalatedTier = escalationResult?.tier ?? null;
-    const escalatedAgent = escalationResult?.agent;
-    if (escalatedTier !== null) {
+        attempt,
+        remainingFailures: state.currentFailures,
+        failingTests
+      };
+      if (testSummary.failures.length > 10 || testSummary.failures.length === 0 && testSummary.failed > 0) {
+        logData.totalFailingTests = testSummary.failed;
+      }
+      logger?.warn("rectification", `${label} still failing after attempt`, logData);
+    },
+    onLoopEnd: (state) => {
+      if (state.attempt >= rectificationConfig.maxRetries) {
+        logger?.warn("rectification", `${label} exhausted max retries`, {
+          storyId: story.id,
+          attempts: state.attempt,
+          remainingFailures: state.currentFailures
+        });
+      } else if (state.currentFailures > state.initialFailures) {
+        logger?.warn("rectification", `${label} aborted due to further regression`, {
+          storyId: story.id,
+          initialFailures: state.initialFailures,
+          currentFailures: state.currentFailures
+        });
+      }
+    },
+    onExhausted: async (state) => {
+      const shouldEscalate = rectificationConfig.escalateOnExhaustion !== false && config2.autoMode?.escalation?.enabled === true && state.currentFailures > 0;
+      if (!shouldEscalate) {
+        return false;
+      }
+      const complexity = story.routing?.complexity ?? "medium";
+      const currentTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
+      const tierOrder = config2.autoMode.escalation.tierOrder;
+      const escalationResult = _rectificationDeps.escalateTier(currentTier, tierOrder);
+      const escalatedTier = escalationResult?.tier ?? null;
+      const escalatedAgent = escalationResult?.agent;
+      if (escalatedTier === null) {
+        return false;
+      }
       const agentName = escalatedAgent ?? story.routing?.agent ?? config2.autoMode.defaultAgent;
       const agent = agentGetFn ? agentGetFn(agentName) : _rectificationDeps.getAgent(agentName, config2);
       if (!agent) {
         return false;
       }
       const escalatedModelDef = resolveModelForAgent(config2.models, agentName, escalatedTier, config2.autoMode.defaultAgent);
-      let escalationPrompt = createEscalatedRectificationPrompt(testSummary.failures, story, rectificationState.attempt, currentTier, escalatedTier, rectificationConfig);
-      if (promptPrefix)
+      let escalationPrompt = createEscalatedRectificationPrompt(testSummary.failures, story, state.attempt, currentTier, escalatedTier, rectificationConfig);
+      if (promptPrefix) {
         escalationPrompt = `${promptPrefix}
 
 ${escalationPrompt}`;
+      }
       const escalationRunResult = await agent.run({
         prompt: escalationPrompt,
         workdir,
@@ -31812,9 +32217,14 @@ ${escalationPrompt}`;
         return true;
       }
       logger?.warn("rectification", "escalated rectification also failed", { storyId: story.id, escalatedTier });
+      return false;
     }
-  }
-  return false;
+  }).catch((error48) => {
+    if (error48 instanceof Error && error48.message === "RECTIFICATION_AGENT_NOT_FOUND") {
+      return false;
+    }
+    throw error48;
+  });
 }
 var _rectificationDeps;
 var init_rectification_loop = __esm(() => {
@@ -32475,7 +32885,7 @@ var init_regression2 = __esm(() => {
 });
 
 // src/pipeline/stages/routing.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var routingStage, _routingDeps;
 var init_routing2 = __esm(() => {
   init_registry();
@@ -32512,7 +32922,7 @@ var init_routing2 = __esm(() => {
       }
       const greenfieldDetectionEnabled = effectiveConfig.tdd.greenfieldDetection ?? true;
       if (greenfieldDetectionEnabled && routing.testStrategy.startsWith("three-session-tdd")) {
-        const greenfieldScanDir = ctx.story.workdir ? join26(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+        const greenfieldScanDir = ctx.story.workdir ? join27(ctx.workdir, ctx.story.workdir) : ctx.workdir;
         const isGreenfield = await _routingDeps.isGreenfieldStory(ctx.story, greenfieldScanDir);
         if (isGreenfield) {
           logger.info("routing", "Greenfield detected \u2014 forcing test-after strategy", {
@@ -32564,7 +32974,7 @@ var init_crash_detector = __esm(() => {
 });
 
 // src/pipeline/stages/verify.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function coerceSmartTestRunner(val) {
   if (val === undefined || val === true)
     return DEFAULT_SMART_RUNNER_CONFIG2;
@@ -32580,7 +32990,7 @@ function buildScopedCommand2(testFiles, baseCommand, testScopedTemplate) {
 }
 async function readPackageName(dir) {
   try {
-    const content = await Bun.file(join27(dir, "package.json")).json();
+    const content = await Bun.file(join28(dir, "package.json")).json();
     return typeof content.name === "string" ? content.name : null;
   } catch {
     return null;
@@ -32625,7 +33035,7 @@ var init_verify = __esm(() => {
         return { action: "continue" };
       }
       logger.info("verify", "Running verification", { storyId: ctx.story.id });
-      const effectiveWorkdir = ctx.story.workdir ? join27(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const effectiveWorkdir = ctx.story.workdir ? join28(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       let effectiveCommand = testCommand;
       let isFullSuite = true;
       const smartRunnerConfig = coerceSmartTestRunner(effectiveConfig.execution.smartTestRunner);
@@ -32843,7 +33253,7 @@ __export(exports_init_context, {
 });
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename3, join as join31 } from "path";
+import { basename as basename3, join as join32 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -32871,7 +33281,7 @@ async function findFiles(dir, maxFiles = 200) {
   return [];
 }
 async function readPackageManifest(projectRoot) {
-  const packageJsonPath = join31(projectRoot, "package.json");
+  const packageJsonPath = join32(projectRoot, "package.json");
   if (!existsSync24(packageJsonPath)) {
     return null;
   }
@@ -32889,7 +33299,7 @@ async function readPackageManifest(projectRoot) {
   }
 }
 async function readReadmeSnippet(projectRoot) {
-  const readmePath = join31(projectRoot, "README.md");
+  const readmePath = join32(projectRoot, "README.md");
   if (!existsSync24(readmePath)) {
     return null;
   }
@@ -32907,7 +33317,7 @@ 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 path12 = join31(projectRoot, candidate);
+    const path12 = join32(projectRoot, candidate);
     if (existsSync24(path12)) {
       found.push(candidate);
     }
@@ -32918,7 +33328,7 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path12 = join31(projectRoot, candidate);
+    const path12 = join32(projectRoot, candidate);
     if (existsSync24(path12)) {
       found.push(candidate);
     }
@@ -33079,8 +33489,8 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const naxDir = join31(repoRoot, ".nax", "mono", packagePath);
-  const contextPath = join31(naxDir, "context.md");
+  const naxDir = join32(repoRoot, ".nax", "mono", packagePath);
+  const contextPath = join32(naxDir, "context.md");
   if (existsSync24(contextPath) && !force) {
     logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
     return;
@@ -33094,8 +33504,8 @@ async function initPackage(repoRoot, packagePath, force = false) {
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join31(projectRoot, ".nax");
-  const contextPath = join31(naxDir, "context.md");
+  const naxDir = join32(projectRoot, ".nax");
+  const contextPath = join32(naxDir, "context.md");
   if (existsSync24(contextPath) && !options.force) {
     logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
     return;
@@ -33125,7 +33535,7 @@ var init_init_context = __esm(() => {
 
 // src/utils/path-security.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join32, normalize as normalize2, resolve as resolve5 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join33, normalize as normalize2, resolve as resolve5 } from "path";
 function safeRealpathForComparison(p) {
   try {
     return realpathSync3(p);
@@ -33134,7 +33544,7 @@ function safeRealpathForComparison(p) {
     if (parent === p)
       return normalize2(p);
     const resolvedParent = safeRealpathForComparison(parent);
-    return join32(resolvedParent, p.split("/").pop() ?? "");
+    return join33(resolvedParent, p.split("/").pop() ?? "");
   }
 }
 function validateModulePath(modulePath, allowedRoots) {
@@ -33152,7 +33562,7 @@ function validateModulePath(modulePath, allowedRoots) {
   } else {
     for (let i = 0;i < allowedRoots.length; i++) {
       const originalRoot = resolve5(allowedRoots[i]);
-      const absoluteInput = resolve5(join32(originalRoot, modulePath));
+      const absoluteInput = resolve5(join33(originalRoot, modulePath));
       const resolved = safeRealpathForComparison(absoluteInput);
       const resolvedRoot = resolvedRoots[i];
       if (resolved.startsWith(`${resolvedRoot}/`) || resolved === resolvedRoot) {
@@ -33688,19 +34098,19 @@ var init_loader4 = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join46 } from "path";
+import { join as join48 } from "path";
 async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join46(projectDir, "hooks.json");
+  const projectPath = join48(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join46(globalDir, "hooks.json");
+    const globalPath = join48(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -34239,7 +34649,7 @@ async function diagnoseAcceptanceFailure(agent, options) {
       reasoning: "diagnosis failed \u2014 falling back to source fix",
       confidence: 0
     };
-  } catch (err) {
+  } catch {
     return {
       verdict: "source_bug",
       reasoning: "diagnosis failed \u2014 falling back to source fix",
@@ -34349,11 +34759,12 @@ var init_fix_executor = __esm(() => {
 var exports_acceptance_loop = {};
 __export(exports_acceptance_loop, {
   runAcceptanceLoop: () => runAcceptanceLoop,
+  regenerateAcceptanceTest: () => regenerateAcceptanceTest,
   isTestLevelFailure: () => isTestLevelFailure,
   isStubTestFile: () => isStubTestFile,
   _acceptanceLoopDeps: () => _acceptanceLoopDeps
 });
-import path14, { join as join47 } from "path";
+import path14, { join as join49 } from "path";
 function isStubTestFile(content) {
   return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
 }
@@ -34424,7 +34835,7 @@ async function executeFixStory(ctx, story, prd, iterations) {
     agent: ctx.config.autoMode.defaultAgent,
     iteration: iterations
   }), ctx.workdir);
-  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join47(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
+  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join49(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const fixContext = {
     config: ctx.config,
     effectiveConfig: fixEffectiveConfig,
@@ -35111,6 +35522,8 @@ async function handleRunCompletion(options) {
     totalStories: finalCounts.total,
     passedStories: finalCounts.passed,
     failedStories: finalCounts.failed,
+    skippedStories: finalCounts.skipped,
+    pausedStories: finalCounts.paused,
     durationMs,
     totalCost
   });
@@ -35237,12 +35650,12 @@ var init_headless_formatter = __esm(() => {
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename6, join as join48 } from "path";
+import { basename as basename6, join as join50 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename6(workdir);
-  const eventsDir = join48(homedir5(), ".nax", "events", project);
-  const eventsFile = join48(eventsDir, "events.jsonl");
+  const eventsDir = join50(homedir5(), ".nax", "events", project);
+  const eventsFile = join50(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -35423,12 +35836,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir4, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename7, join as join49 } from "path";
+import { basename as basename7, join as join51 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename7(workdir);
-  const runDir = join49(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join49(runDir, "meta.json");
+  const runDir = join51(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join51(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -35438,8 +35851,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join49(workdir, ".nax", "features", feature, "status.json"),
-          eventsDir: join49(workdir, ".nax", "features", feature, "runs"),
+          statusPath: join51(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join51(workdir, ".nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -35562,8 +35975,8 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
               storySummary: {
                 completed: ev.passedStories,
                 failed: ev.failedStories,
-                skipped: 0,
-                paused: 0
+                skipped: ev.skippedStories,
+                paused: ev.pausedStories
               }
             });
           } catch (err) {
@@ -36091,7 +36504,7 @@ var init_pipeline_result_handler = __esm(() => {
 });
 
 // src/execution/iteration-runner.ts
-import { join as join50 } from "path";
+import { join as join52 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const logger = getSafeLogger();
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
@@ -36126,7 +36539,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     }
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join50(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join52(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const pipelineContext = {
     config: ctx.config,
     effectiveConfig,
@@ -36385,13 +36798,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync32, symlinkSync } from "fs";
 import { mkdir as mkdir5 } from "fs/promises";
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join51(projectRoot, ".git", "info");
-    const excludePath = join51(infoDir, "exclude");
+    const infoDir = join53(projectRoot, ".git", "info");
+    const excludePath = join53(infoDir, "exclude");
     try {
       await mkdir5(infoDir, { recursive: true });
       let existing = "";
@@ -36418,7 +36831,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join51(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join53(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -36459,9 +36872,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join51(projectRoot, "node_modules");
+    const nodeModulesSource = join53(projectRoot, "node_modules");
     if (existsSync32(nodeModulesSource)) {
-      const nodeModulesTarget = join51(worktreePath, "node_modules");
+      const nodeModulesTarget = join53(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -36469,9 +36882,9 @@ ${missing.join(`
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join51(projectRoot, ".env");
+    const envSource = join53(projectRoot, ".env");
     if (existsSync32(envSource)) {
-      const envTarget = join51(worktreePath, ".env");
+      const envTarget = join53(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -36482,7 +36895,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join51(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join53(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -37057,6 +37470,12 @@ async function executeUnified(ctx, initialPrd) {
   wireInteraction(pipelineEventBus, ctx.interactionChain, ctx.config);
   wireEventsWriter(pipelineEventBus, ctx.feature, ctx.runId, ctx.workdir);
   wireRegistry(pipelineEventBus, ctx.feature, ctx.runId, ctx.workdir);
+  pipelineEventBus.emit({
+    type: "run:started",
+    feature: ctx.feature,
+    totalStories: initialPrd.userStories.length,
+    workdir: ctx.workdir
+  });
   const buildResult2 = (exitReason) => ({
     prd,
     iterations,
@@ -37401,16 +37820,16 @@ var init_unified_executor = __esm(() => {
 });
 
 // src/project/detector.ts
-import { join as join52 } from "path";
+import { join as join54 } from "path";
 async function detectLanguage(workdir, pkg) {
   const deps = _detectorDeps;
-  if (await deps.fileExists(join52(workdir, "go.mod")))
+  if (await deps.fileExists(join54(workdir, "go.mod")))
     return "go";
-  if (await deps.fileExists(join52(workdir, "Cargo.toml")))
+  if (await deps.fileExists(join54(workdir, "Cargo.toml")))
     return "rust";
-  if (await deps.fileExists(join52(workdir, "pyproject.toml")))
+  if (await deps.fileExists(join54(workdir, "pyproject.toml")))
     return "python";
-  if (await deps.fileExists(join52(workdir, "requirements.txt")))
+  if (await deps.fileExists(join54(workdir, "requirements.txt")))
     return "python";
   if (pkg != null) {
     const allDeps = {
@@ -37470,18 +37889,18 @@ async function detectLintTool(workdir, language) {
   if (language === "python")
     return "ruff";
   const deps = _detectorDeps;
-  if (await deps.fileExists(join52(workdir, "biome.json")))
+  if (await deps.fileExists(join54(workdir, "biome.json")))
     return "biome";
-  if (await deps.fileExists(join52(workdir, ".eslintrc")))
+  if (await deps.fileExists(join54(workdir, ".eslintrc")))
     return "eslint";
-  if (await deps.fileExists(join52(workdir, ".eslintrc.js")))
+  if (await deps.fileExists(join54(workdir, ".eslintrc.js")))
     return "eslint";
-  if (await deps.fileExists(join52(workdir, ".eslintrc.json")))
+  if (await deps.fileExists(join54(workdir, ".eslintrc.json")))
     return "eslint";
   return;
 }
 async function detectProjectProfile(workdir, existing) {
-  const pkg = await _detectorDeps.readJson(join52(workdir, "package.json"));
+  const pkg = await _detectorDeps.readJson(join54(workdir, "package.json"));
   const language = existing.language !== undefined ? existing.language : await detectLanguage(workdir, pkg);
   const type = existing.type !== undefined ? existing.type : detectType(pkg);
   const testFramework = existing.testFramework !== undefined ? existing.testFramework : await detectTestFramework(workdir, language, pkg);
@@ -37574,7 +37993,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join53 } from "path";
+import { join as join55 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -37648,7 +38067,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join53(featureDir, "status.json");
+    const featureStatusPath = join55(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -37764,7 +38183,7 @@ var exports_precheck_runner = {};
 __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
-import { mkdirSync as mkdirSync4 } from "fs";
+import { mkdirSync as mkdirSync5 } from "fs";
 import path17 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
@@ -37779,7 +38198,7 @@ async function runPrecheckValidation(ctx) {
     format: "human"
   });
   if (ctx.logFilePath) {
-    mkdirSync4(path17.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync5(path17.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -37859,7 +38278,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join54 } from "path";
+import { join as join56 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -37877,7 +38296,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join54(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join56(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -37987,7 +38406,6 @@ async function setupRun(options) {
     prdPath,
     workdir,
     config: config2,
-    hooks,
     feature,
     dryRun,
     statusFile,
@@ -38093,7 +38511,6 @@ async function setupRun(options) {
       naxVersion: NAX_VERSION,
       naxCommit: NAX_COMMIT
     });
-    await fireHook(hooks, "on-start", hookCtx(feature), workdir);
     const { initializeRun: initializeRun2 } = await Promise.resolve().then(() => (init_run_initialization(), exports_run_initialization));
     const initResult = await initializeRun2({
       config: config2,
@@ -38121,7 +38538,6 @@ async function setupRun(options) {
 var _runSetupDeps;
 var init_run_setup = __esm(() => {
   init_errors();
-  init_hooks();
   init_interaction();
   init_logger2();
   init_event_bus();
@@ -38171,24 +38587,26 @@ async function cleanupRun(options) {
   const logger = getSafeLogger();
   const { runId, startTime, totalCost, storiesCompleted, prd, pluginRegistry, workdir, interactionChain } = options;
   const durationMs = Date.now() - startTime;
-  const finalCounts = countStories(prd);
-  const reporters = pluginRegistry.getReporters();
-  for (const reporter of reporters) {
-    if (reporter.onRunEnd) {
-      try {
-        await reporter.onRunEnd({
-          runId,
-          totalDurationMs: durationMs,
-          totalCost,
-          storySummary: {
-            completed: storiesCompleted,
-            failed: finalCounts.failed,
-            skipped: finalCounts.skipped,
-            paused: finalCounts.paused
-          }
-        });
-      } catch (error48) {
-        logger?.warn("plugins", `Reporter '${reporter.name}' onRunEnd failed`, { error: error48 });
+  if (!options.runCompleted) {
+    const finalCounts = countStories(prd);
+    const reporters = pluginRegistry.getReporters();
+    for (const reporter of reporters) {
+      if (reporter.onRunEnd) {
+        try {
+          await reporter.onRunEnd({
+            runId,
+            totalDurationMs: durationMs,
+            totalCost,
+            storySummary: {
+              completed: storiesCompleted,
+              failed: finalCounts.failed,
+              skipped: finalCounts.skipped,
+              paused: finalCounts.paused
+            }
+          });
+        } catch (error48) {
+          logger?.warn("plugins", `Reporter '${reporter.name}' onRunEnd failed`, { error: error48 });
+        }
       }
     }
   }
@@ -69085,9 +69503,9 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync34, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -69109,14 +69527,14 @@ var {
 init_acceptance();
 init_registry();
 import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/analyze/scanner.ts
-import { existsSync as existsSync5, readdirSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
 async function scanCodebase(workdir) {
-  const srcPath = join6(workdir, "src");
-  const packageJsonPath = join6(workdir, "package.json");
+  const srcPath = join7(workdir, "src");
+  const packageJsonPath = join7(workdir, "package.json");
   const fileTree = existsSync5(srcPath) ? await generateFileTree(srcPath, 3) : "No src/ directory";
   let dependencies = {};
   let devDependencies = {};
@@ -69141,7 +69559,7 @@ async function generateFileTree(dir, maxDepth, currentDepth = 0, prefix = "") {
   }
   const entries = [];
   try {
-    const dirEntries = readdirSync(dir, { withFileTypes: true });
+    const dirEntries = readdirSync2(dir, { withFileTypes: true });
     dirEntries.sort((a, b) => {
       if (a.isDirectory() && !b.isDirectory())
         return -1;
@@ -69157,7 +69575,7 @@ async function generateFileTree(dir, maxDepth, currentDepth = 0, prefix = "") {
       const isDir = dirent.isDirectory();
       entries.push(`${prefix}${connector}${dirent.name}${isDir ? "/" : ""}`);
       if (isDir) {
-        const subtree = await generateFileTree(join6(dir, dirent.name), maxDepth, currentDepth + 1, prefix + childPrefix);
+        const subtree = await generateFileTree(join7(dir, dirent.name), maxDepth, currentDepth + 1, prefix + childPrefix);
         if (subtree) {
           entries.push(subtree);
         }
@@ -69181,16 +69599,16 @@ function detectTestPatterns(workdir, dependencies, devDependencies) {
   } else {
     patterns.push("Test framework: likely bun:test (no framework dependency)");
   }
-  if (existsSync5(join6(workdir, "test"))) {
+  if (existsSync5(join7(workdir, "test"))) {
     patterns.push("Test directory: test/");
   }
-  if (existsSync5(join6(workdir, "__tests__"))) {
+  if (existsSync5(join7(workdir, "__tests__"))) {
     patterns.push("Test directory: __tests__/");
   }
-  if (existsSync5(join6(workdir, "tests"))) {
+  if (existsSync5(join7(workdir, "tests"))) {
     patterns.push("Test directory: tests/");
   }
-  const hasTestFiles = existsSync5(join6(workdir, "test")) || existsSync5(join6(workdir, "src"));
+  const hasTestFiles = existsSync5(join7(workdir, "test")) || existsSync5(join7(workdir, "src"));
   if (hasTestFiles) {
     patterns.push("Test files: *.test.ts, *.spec.ts");
   }
@@ -69206,7 +69624,7 @@ init_version();
 // src/cli/analyze-parser.ts
 init_registry();
 import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 init_config();
 init_logger2();
 init_prd();
@@ -69336,7 +69754,7 @@ function estimateLOCFromComplexity(complexity) {
   }
 }
 async function reclassifyExistingPRD(featureDir, featureName, branchName, workdir, config2) {
-  const prdPath = join7(featureDir, "prd.json");
+  const prdPath = join8(featureDir, "prd.json");
   if (!existsSync7(prdPath)) {
     throw new Error(`prd.json not found at ${prdPath}. Run analyze without --reclassify first.`);
   }
@@ -69437,11 +69855,11 @@ function reclassifyWithKeywords(story, config2) {
 // src/cli/analyze.ts
 async function analyzeFeature(options) {
   const { featureDir, featureName, branchName, config: config2, specPath: explicitSpecPath, reclassify = false } = options;
-  const workdir = join8(featureDir, "../..");
+  const workdir = join9(featureDir, "../..");
   if (reclassify) {
     return await reclassifyExistingPRD(featureDir, featureName, branchName, workdir, config2);
   }
-  const specPath = explicitSpecPath || join8(featureDir, "spec.md");
+  const specPath = explicitSpecPath || join9(featureDir, "spec.md");
   if (!existsSync8(specPath))
     throw new Error(`spec.md not found at ${specPath}`);
   const specContent = await Bun.file(specPath).text();
@@ -69558,7 +69976,7 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
       modelDef,
       config: config2
     });
-    const acceptanceTestPath = join8(featureDir, config2.acceptance.testPath);
+    const acceptanceTestPath = join9(featureDir, config2.acceptance.testPath);
     await Bun.write(acceptanceTestPath, result.testCode);
     logger.info("cli", "[OK] Acceptance tests generated", {
       criteriaCount: result.criteria.length,
@@ -69571,18 +69989,18 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
 // src/cli/plan.ts
 init_registry();
 import { existsSync as existsSync15 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { createInterface as createInterface2 } from "readline";
 init_test_strategy();
 
 // src/context/generator.ts
 init_path_security();
 import { existsSync as existsSync10, readFileSync } from "fs";
-import { join as join10, relative } from "path";
+import { join as join11, relative } from "path";
 
 // src/context/injector.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var NOTABLE_NODE_DEPS = [
   "@nestjs",
   "express",
@@ -69612,7 +70030,7 @@ var NOTABLE_NODE_DEPS = [
   "ioredis"
 ];
 async function detectNode(workdir) {
-  const pkgPath = join9(workdir, "package.json");
+  const pkgPath = join10(workdir, "package.json");
   if (!existsSync9(pkgPath))
     return null;
   try {
@@ -69629,7 +70047,7 @@ async function detectNode(workdir) {
   }
 }
 async function detectGo(workdir) {
-  const goMod = join9(workdir, "go.mod");
+  const goMod = join10(workdir, "go.mod");
   if (!existsSync9(goMod))
     return null;
   try {
@@ -69653,7 +70071,7 @@ async function detectGo(workdir) {
   }
 }
 async function detectRust(workdir) {
-  const cargoPath = join9(workdir, "Cargo.toml");
+  const cargoPath = join10(workdir, "Cargo.toml");
   if (!existsSync9(cargoPath))
     return null;
   try {
@@ -69669,8 +70087,8 @@ async function detectRust(workdir) {
   }
 }
 async function detectPython(workdir) {
-  const pyproject = join9(workdir, "pyproject.toml");
-  const requirements = join9(workdir, "requirements.txt");
+  const pyproject = join10(workdir, "pyproject.toml");
+  const requirements = join10(workdir, "requirements.txt");
   if (!existsSync9(pyproject) && !existsSync9(requirements))
     return null;
   try {
@@ -69689,7 +70107,7 @@ async function detectPython(workdir) {
   }
 }
 async function detectPhp(workdir) {
-  const composerPath = join9(workdir, "composer.json");
+  const composerPath = join10(workdir, "composer.json");
   if (!existsSync9(composerPath))
     return null;
   try {
@@ -69702,7 +70120,7 @@ async function detectPhp(workdir) {
   }
 }
 async function detectRuby(workdir) {
-  const gemfile = join9(workdir, "Gemfile");
+  const gemfile = join10(workdir, "Gemfile");
   if (!existsSync9(gemfile))
     return null;
   try {
@@ -69714,9 +70132,9 @@ async function detectRuby(workdir) {
   }
 }
 async function detectJvm(workdir) {
-  const pom = join9(workdir, "pom.xml");
-  const gradle = join9(workdir, "build.gradle");
-  const gradleKts = join9(workdir, "build.gradle.kts");
+  const pom = join10(workdir, "pom.xml");
+  const gradle = join10(workdir, "build.gradle");
+  const gradleKts = join10(workdir, "build.gradle.kts");
   if (!existsSync9(pom) && !existsSync9(gradle) && !existsSync9(gradleKts))
     return null;
   try {
@@ -69724,7 +70142,7 @@ async function detectJvm(workdir) {
       const content2 = await Bun.file(pom).text();
       const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync9(join9(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      const lang2 = existsSync9(join10(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
       return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
     }
     const gradleFile = existsSync9(gradleKts) ? gradleKts : gradle;
@@ -69951,7 +70369,7 @@ async function generateFor(agent, options, config2) {
   try {
     const context = await loadContextContent(options, config2);
     const content = generator.generate(context);
-    const outputPath = join10(options.outputDir, generator.outputFile);
+    const outputPath = join11(options.outputDir, generator.outputFile);
     validateFilePath(outputPath, options.outputDir);
     if (!options.dryRun) {
       await _generatorDeps.writeFile(outputPath, content);
@@ -69969,7 +70387,7 @@ async function generateAll(options, config2, agentFilter) {
   for (const [agentKey, generator] of entries) {
     try {
       const content = generator.generate(context);
-      const outputPath = join10(options.outputDir, generator.outputFile);
+      const outputPath = join11(options.outputDir, generator.outputFile);
       validateFilePath(outputPath, options.outputDir);
       if (!options.dryRun) {
         await _generatorDeps.writeFile(outputPath, content);
@@ -69989,7 +70407,7 @@ async function discoverPackages(repoRoot) {
     const glob = new Bun.Glob(pattern);
     for await (const match of glob.scan({ cwd: repoRoot, dot: true })) {
       const pkgRelative = match.replace(/^\.nax\/mono\//, "").replace(/\/context\.md$/, "");
-      const pkgAbsolute = join10(repoRoot, pkgRelative);
+      const pkgAbsolute = join11(repoRoot, pkgRelative);
       if (!seen.has(pkgAbsolute)) {
         seen.add(pkgAbsolute);
         packages.push(pkgAbsolute);
@@ -70021,7 +70439,7 @@ async function discoverWorkspacePackages(repoRoot) {
       }
     }
   }
-  const turboPath = join10(repoRoot, "turbo.json");
+  const turboPath = join11(repoRoot, "turbo.json");
   if (_generatorDeps.existsSync(turboPath)) {
     try {
       const turbo = JSON.parse(_generatorDeps.readFileSync(turboPath, "utf-8"));
@@ -70030,7 +70448,7 @@ async function discoverWorkspacePackages(repoRoot) {
       }
     } catch {}
   }
-  const pkgPath = join10(repoRoot, "package.json");
+  const pkgPath = join11(repoRoot, "package.json");
   if (_generatorDeps.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(_generatorDeps.readFileSync(pkgPath, "utf-8"));
@@ -70040,7 +70458,7 @@ async function discoverWorkspacePackages(repoRoot) {
         await resolveGlobs(patterns);
     } catch {}
   }
-  const pnpmPath = join10(repoRoot, "pnpm-workspace.yaml");
+  const pnpmPath = join11(repoRoot, "pnpm-workspace.yaml");
   if (_generatorDeps.existsSync(pnpmPath)) {
     try {
       const raw = _generatorDeps.readFileSync(pnpmPath, "utf-8");
@@ -70068,7 +70486,7 @@ async function discoverWorkspacePackages(repoRoot) {
 async function generateForPackage(packageDir, config2, dryRun = false, repoRoot) {
   const resolvedRepoRoot = repoRoot ?? packageDir;
   const relativePkgPath = relative(resolvedRepoRoot, packageDir);
-  const contextPath = join10(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
+  const contextPath = join11(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
   if (!_generatorDeps.existsSync(contextPath)) {
     return [
       {
@@ -70300,7 +70718,7 @@ var _planDeps = {
   writeFile: (path, content) => Bun.write(path, content).then(() => {}),
   scanCodebase: (workdir) => scanCodebase(workdir),
   getAgent: (name, cfg) => cfg ? createAgentRegistry(cfg).getAgent(name) : getAgent(name),
-  readPackageJson: (workdir) => Bun.file(join12(workdir, "package.json")).json().catch(() => null),
+  readPackageJson: (workdir) => Bun.file(join13(workdir, "package.json")).json().catch(() => null),
   spawnSync: (cmd, opts) => {
     const result = Bun.spawnSync(cmd, opts ? { cwd: opts.cwd } : {});
     return { stdout: result.stdout, exitCode: result.exitCode };
@@ -70320,7 +70738,7 @@ var _planDeps = {
   planDecompose: (workdir, config2, opts) => planDecomposeCommand(workdir, config2, opts)
 };
 async function planCommand(workdir, config2, options) {
-  const naxDir = join12(workdir, ".nax");
+  const naxDir = join13(workdir, ".nax");
   if (!existsSync15(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
@@ -70336,13 +70754,13 @@ async function planCommand(workdir, config2, options) {
   const codebaseContext = buildCodebaseContext2(scan);
   const relativePackages = discoveredPackages.map((p) => p.startsWith("/") ? p.replace(`${workdir}/`, "") : p);
   const packageDetails = relativePackages.length > 0 ? await Promise.all(relativePackages.map(async (rel) => {
-    const pkgJson = await _planDeps.readPackageJsonAt(join12(workdir, rel, "package.json"));
+    const pkgJson = await _planDeps.readPackageJsonAt(join13(workdir, rel, "package.json"));
     return buildPackageSummary(rel, pkgJson);
   })) : [];
   const projectName = detectProjectName(workdir, pkg);
   const branchName = options.branch ?? `feat/${options.feature}`;
-  const outputDir = join12(naxDir, "features", options.feature);
-  const outputPath = join12(outputDir, "prd.json");
+  const outputDir = join13(naxDir, "features", options.feature);
+  const outputPath = join13(outputDir, "prd.json");
   await _planDeps.mkdirp(outputDir);
   const agentName = config2?.autoMode?.defaultAgent ?? "claude";
   const timeoutSeconds = config2?.plan?.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS2;
@@ -70777,7 +71195,7 @@ Return JSON with this exact structure (no markdown, no explanation \u2014 JSON o
 }`;
 }
 async function planDecomposeCommand(workdir, config2, options) {
-  const prdPath = join12(workdir, ".nax", "features", options.feature, "prd.json");
+  const prdPath = join13(workdir, ".nax", "features", options.feature, "prd.json");
   if (!_planDeps.existsSync(prdPath)) {
     throw new NaxError(`PRD not found: ${prdPath}`, "PRD_NOT_FOUND", {
       stage: "decompose",
@@ -70807,6 +71225,15 @@ async function planDecomposeCommand(workdir, config2, options) {
   const adapter = _planDeps.getAgent(agentName, config2);
   if (!adapter)
     throw new Error(`[decompose] No agent adapter found for '${agentName}'`);
+  let decomposeModel;
+  try {
+    const planTier = config2?.plan?.model ?? "balanced";
+    const { resolveModelForAgent: resolveModelForAgent2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+    if (config2?.models) {
+      const defaultAgent = config2.autoMode?.defaultAgent ?? "claude";
+      decomposeModel = resolveModelForAgent2(config2.models, defaultAgent, planTier, defaultAgent).model;
+    }
+  } catch {}
   const stages = config2?.debate?.stages;
   const debateEnabled = config2?.debate?.enabled && stages?.decompose?.enabled;
   let rawResponse;
@@ -70828,6 +71255,7 @@ async function planDecomposeCommand(workdir, config2, options) {
       rawResponse = debateResult.output;
     } else {
       const completeResult = await adapter.complete(prompt, {
+        model: decomposeModel,
         jsonMode: true,
         workdir,
         sessionRole: "decompose",
@@ -70839,6 +71267,7 @@ async function planDecomposeCommand(workdir, config2, options) {
     }
   } else {
     const completeResult = await adapter.complete(prompt, {
+      model: decomposeModel,
       jsonMode: true,
       workdir,
       sessionRole: "decompose",
@@ -71068,14 +71497,14 @@ async function displayModelEfficiency(workdir) {
 }
 // src/cli/status-features.ts
 init_source();
-import { existsSync as existsSync17, readdirSync as readdirSync3 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync4 } from "fs";
+import { join as join16 } from "path";
 
 // src/commands/common.ts
 init_path_security();
 init_errors();
-import { existsSync as existsSync16, readdirSync as readdirSync2, realpathSync as realpathSync2 } from "fs";
-import { join as join13, resolve as resolve4 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync3, realpathSync as realpathSync2 } from "fs";
+import { join as join14, resolve as resolve4 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -71083,12 +71512,12 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync2(resolve4(dir));
-    naxDir = join13(projectRoot, ".nax");
+    naxDir = join14(projectRoot, ".nax");
     if (!existsSync16(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
-    configPath = join13(naxDir, "config.json");
+    configPath = join14(naxDir, "config.json");
     if (!existsSync16(configPath)) {
       throw new NaxError(`.nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
@@ -71096,24 +71525,24 @@ Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join13(process.cwd(), ".nax");
+      const cwdNaxDir = join14(process.cwd(), ".nax");
       if (existsSync16(cwdNaxDir)) {
-        const cwdConfigPath = join13(cwdNaxDir, "config.json");
+        const cwdConfigPath = join14(cwdNaxDir, "config.json");
         throw new NaxError(`.nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join13(projectRoot, ".nax");
-    configPath = join13(naxDir, "config.json");
+    naxDir = join14(projectRoot, ".nax");
+    configPath = join14(naxDir, "config.json");
   }
   let featureDir;
   if (feature) {
-    const featuresDir = join13(naxDir, "features");
-    featureDir = join13(featuresDir, feature);
+    const featuresDir = join14(naxDir, "features");
+    featureDir = join14(featuresDir, feature);
     if (!existsSync16(featureDir)) {
-      const availableFeatures = existsSync16(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+      const availableFeatures = existsSync16(featuresDir) ? readdirSync3(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
       const availableMsg = availableFeatures.length > 0 ? `
 
 Available features:
@@ -71138,12 +71567,12 @@ function findProjectRoot(startDir) {
   let current = resolve4(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join13(current, ".nax");
-    const configPath = join13(naxDir, "config.json");
+    const naxDir = join14(current, ".nax");
+    const configPath = join14(naxDir, "config.json");
     if (existsSync16(configPath)) {
       return realpathSync2(current);
     }
-    const parent = join13(current, "..");
+    const parent = join14(current, "..");
     if (parent === current) {
       break;
     }
@@ -71165,7 +71594,7 @@ function isPidAlive(pid) {
   }
 }
 async function loadStatusFile(featureDir) {
-  const statusPath = join15(featureDir, "status.json");
+  const statusPath = join16(featureDir, "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -71177,7 +71606,7 @@ async function loadStatusFile(featureDir) {
   }
 }
 async function loadProjectStatusFile(projectDir) {
-  const statusPath = join15(projectDir, ".nax", "status.json");
+  const statusPath = join16(projectDir, ".nax", "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -71189,7 +71618,7 @@ async function loadProjectStatusFile(projectDir) {
   }
 }
 async function getFeatureSummary(featureName, featureDir) {
-  const prdPath = join15(featureDir, "prd.json");
+  const prdPath = join16(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     return {
       name: featureName,
@@ -71232,9 +71661,9 @@ async function getFeatureSummary(featureName, featureDir) {
       };
     }
   }
-  const runsDir = join15(featureDir, "runs");
+  const runsDir = join16(featureDir, "runs");
   if (existsSync17(runsDir)) {
-    const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
+    const runs = readdirSync4(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
     if (runs.length > 0) {
       const latestRun = runs[0].replace(".jsonl", "");
       summary.lastRun = latestRun;
@@ -71243,12 +71672,12 @@ async function getFeatureSummary(featureName, featureDir) {
   return summary;
 }
 async function displayAllFeatures(projectDir) {
-  const featuresDir = join15(projectDir, ".nax", "features");
+  const featuresDir = join16(projectDir, ".nax", "features");
   if (!existsSync17(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
   }
-  const features = readdirSync3(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const features = readdirSync4(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   if (features.length === 0) {
     console.log(source_default.dim("No features found."));
     return;
@@ -71284,7 +71713,7 @@ async function displayAllFeatures(projectDir) {
       console.log();
     }
   }
-  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join15(featuresDir, name))));
+  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join16(featuresDir, name))));
   console.log(source_default.bold(`\uD83D\uDCCA Features
 `));
   const header = `  ${"Feature".padEnd(25)} ${"Done".padEnd(6)} ${"Failed".padEnd(8)} ${"Pending".padEnd(9)} ${"Last Run".padEnd(22)} ${"Cost".padEnd(10)} Status`;
@@ -71310,7 +71739,7 @@ async function displayAllFeatures(projectDir) {
   console.log();
 }
 async function displayFeatureDetails(featureName, featureDir) {
-  const prdPath = join15(featureDir, "prd.json");
+  const prdPath = join16(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     console.log(source_default.bold(`
 \uD83D\uDCCA ${featureName}
@@ -71431,8 +71860,8 @@ async function displayFeatureStatus(options = {}) {
 // src/cli/runs.ts
 init_errors();
 init_logger2();
-import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync5 } from "fs";
+import { join as join17 } from "path";
 async function parseRunLog(logPath) {
   const logger = getLogger();
   try {
@@ -71448,19 +71877,19 @@ async function parseRunLog(logPath) {
 async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
-  const runsDir = join16(workdir, ".nax", "features", feature, "runs");
+  const runsDir = join17(workdir, ".nax", "features", feature, "runs");
   if (!existsSync18(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
   }
-  const files = readdirSync4(runsDir).filter((f) => f.endsWith(".jsonl"));
+  const files = readdirSync5(runsDir).filter((f) => f.endsWith(".jsonl"));
   if (files.length === 0) {
     logger.info("cli", "No runs found for feature", { feature });
     return;
   }
   logger.info("cli", `Runs for ${feature}`, { count: files.length });
   for (const file3 of files.sort().reverse()) {
-    const logPath = join16(runsDir, file3);
+    const logPath = join17(runsDir, file3);
     const entries = await parseRunLog(logPath);
     const startEvent = entries.find((e) => e.message === "run.start");
     const completeEvent = entries.find((e) => e.message === "run.complete");
@@ -71486,7 +71915,7 @@ async function runsListCommand(options) {
 async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
-  const logPath = join16(workdir, ".nax", "features", feature, "runs", `${runId}.jsonl`);
+  const logPath = join17(workdir, ".nax", "features", feature, "runs", `${runId}.jsonl`);
   if (!existsSync18(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
@@ -71525,7 +71954,7 @@ async function runsShowCommand(options) {
 // src/cli/prompts-main.ts
 init_logger2();
 import { existsSync as existsSync22, mkdirSync as mkdirSync2 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/pipeline/index.ts
 init_runner();
@@ -71600,7 +72029,7 @@ function buildFrontmatter(story, ctx, role) {
 
 // src/cli/prompts-tdd.ts
 init_prompts2();
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     PromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -71619,7 +72048,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join28(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join29(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -71635,7 +72064,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join28(outputDir, `${story.id}.context.md`);
+    const contextFile = join29(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -71649,12 +72078,12 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join29(workdir, ".nax");
+  const naxDir = join30(workdir, ".nax");
   if (!existsSync22(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join29(naxDir, "features", feature);
-  const prdPath = join29(featureDir, "prd.json");
+  const featureDir = join30(naxDir, "features", feature);
+  const prdPath = join30(featureDir, "prd.json");
   if (!existsSync22(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
@@ -71715,10 +72144,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join29(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join30(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join29(outputDir, `${story.id}.context.md`);
+        const contextFile = join30(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -71745,7 +72174,7 @@ ${"=".repeat(80)}`);
 }
 // src/cli/prompts-init.ts
 import { existsSync as existsSync23, mkdirSync as mkdirSync3 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
   { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -71769,9 +72198,9 @@ var TEMPLATE_HEADER = `<!--
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join30(workdir, ".nax", "templates");
+  const templatesDir = join31(workdir, ".nax", "templates");
   mkdirSync3(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync23(join30(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync23(join31(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -71779,7 +72208,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join30(templatesDir, template.file);
+    const filePath = join31(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -71795,7 +72224,7 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join30(workdir, "nax.config.json");
+  const configPath = join31(workdir, "nax.config.json");
   if (!existsSync23(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
@@ -71960,8 +72389,8 @@ function pad(str, width) {
 init_config();
 init_logger2();
 init_prd();
-import { existsSync as existsSync25, readdirSync as readdirSync5 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync6 } from "fs";
+import { join as join36 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, prd, status) {
@@ -72160,7 +72589,7 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join35(workdir, ".nax", "status.json");
+  const statusPath = join36(workdir, ".nax", "status.json");
   if (!existsSync25(statusPath))
     return null;
   try {
@@ -72188,7 +72617,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join35(workdir, "nax.lock"));
+  const lockFile = Bun.file(join36(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -72206,8 +72635,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join35(naxSubdir, "..") : null;
-  if (!projectDir && existsSync25(join35(workdir, ".nax"))) {
+  let projectDir = naxSubdir ? join36(naxSubdir, "..") : null;
+  if (!projectDir && existsSync25(join36(workdir, ".nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -72218,18 +72647,18 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join35(projectDir, ".nax", "features");
+      const featuresDir = join36(projectDir, ".nax", "features");
       if (!existsSync25(featuresDir))
         throw new Error("No features found in project");
-      const features = readdirSync5(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      const features = readdirSync6(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (features.length === 0)
         throw new Error("No features found");
       feature = features[0];
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join35(projectDir, ".nax", "features", feature);
-  const prdPath = join35(featureDir, "prd.json");
+  const featureDir = join36(projectDir, ".nax", "features", feature);
+  const prdPath = join36(featureDir, "prd.json");
   if (!existsSync25(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
@@ -72272,7 +72701,7 @@ init_interaction();
 init_source();
 init_loader();
 import { existsSync as existsSync26 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -72315,7 +72744,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join36(workdir, options.package);
+    const packageDir = join37(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -72335,8 +72764,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join36(workdir, options.context) : join36(workdir, ".nax/context.md");
-  const outputDir = options.output ? join36(workdir, options.output) : workdir;
+  const contextPath = options.context ? join37(workdir, options.context) : join37(workdir, ".nax/context.md");
+  const outputDir = options.output ? join37(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync26(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -72441,7 +72870,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader();
 import { existsSync as existsSync28 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -72679,7 +73108,7 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader();
 import { existsSync as existsSync27 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 async function loadConfigFile(path14) {
   if (!existsSync27(path14))
     return null;
@@ -72701,7 +73130,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join37(projectDir, "config.json");
+  const projectPath = join38(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -72761,7 +73190,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join38(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join39(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -72831,6 +73260,26 @@ function displayConfigWithDescriptions(obj, path14, sources, indent = 0) {
       }
     }
   }
+  if (indent === 0 && !entries.find(([k]) => k === "prompts")) {
+    console.log("# prompts: Prompt template overrides (PB-003: PromptBuilder)");
+    const description = FIELD_DESCRIPTIONS["prompts.overrides"];
+    if (description) {
+      console.log(`# prompts.overrides: ${description}`);
+    }
+    const roles = ["test-writer", "implementer", "verifier", "single-session"];
+    console.log("overrides:");
+    for (const role of roles) {
+      const roleDesc = FIELD_DESCRIPTIONS[`prompts.overrides.${role}`];
+      if (roleDesc) {
+        console.log(`  # ${roleDesc}`);
+        const match = roleDesc.match(/e\.g\., "([^"]+)"/);
+        if (match) {
+          console.log(`  # ${role}: "${match[1]}"`);
+        }
+      }
+    }
+    console.log();
+  }
 }
 function formatValue(value) {
   if (value === null)
@@ -72885,6 +73334,107 @@ function formatValueForTable(value) {
   }
   return String(value);
 }
+// src/cli/config-profile.ts
+init_paths();
+init_profile();
+import { mkdirSync as mkdirSync4 } from "fs";
+import { readdirSync as readdirSync7 } from "fs";
+import { join as join40 } from "path";
+var _profileCLIDeps = {
+  env: process.env
+};
+var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
+var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
+async function profileListCommand(startDir) {
+  const globalProfilesDir = join40(globalConfigDir(), "profiles");
+  const projectProfilesDir = join40(projectConfigDir(startDir), "profiles");
+  const globalProfiles = scanProfileDir(globalProfilesDir);
+  const projectProfiles = scanProfileDir(projectProfilesDir);
+  const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
+  const lines = [];
+  lines.push("global:");
+  if (globalProfiles.length === 0) {
+    lines.push("  (none)");
+  } else {
+    for (const name of globalProfiles) {
+      const marker = name === activeProfile ? "* " : "  ";
+      lines.push(`${marker}${name}`);
+    }
+  }
+  if (projectProfiles.length > 0) {
+    lines.push("project:");
+    for (const name of projectProfiles) {
+      const marker = name === activeProfile ? "* " : "  ";
+      lines.push(`${marker}${name}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function scanProfileDir(dir) {
+  try {
+    return readdirSync7(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+  } catch {
+    return [];
+  }
+}
+async function profileShowCommand(profileName, startDir, opts) {
+  const rawProfile = await loadProfile(profileName, startDir);
+  const envVars = await loadProfileEnv(profileName, startDir);
+  if (opts.unmask) {
+    const resolved = resolveEnvVars(rawProfile, envVars);
+    const warning = "WARNING: Sensitive values are displayed in plaintext.";
+    return `${warning}
+${JSON.stringify(resolved, null, 2)}`;
+  }
+  const masked = maskProfileValues(rawProfile);
+  return JSON.stringify(masked, null, 2);
+}
+function maskProfileValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEY_PATTERN.test(key)) {
+      result[key] = "***";
+    } else if (typeof value === "string" && VAR_PATTERN.test(value)) {
+      result[key] = "***";
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = maskProfileValues(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function profileUseCommand(profileName, startDir) {
+  const configPath = join40(projectConfigDir(startDir), "config.json");
+  const configFile = Bun.file(configPath);
+  let existing = {};
+  if (await configFile.exists()) {
+    existing = await configFile.json();
+  }
+  if (profileName === "default") {
+    const { profile: _removed, ...rest } = existing;
+    await Bun.write(configPath, JSON.stringify(rest, null, 2));
+    return "Profile reset to default.";
+  }
+  const updated = { ...existing, profile: profileName };
+  await Bun.write(configPath, JSON.stringify(updated, null, 2));
+  return `Now using profile: ${profileName}`;
+}
+async function profileCurrentCommand(startDir) {
+  return resolveProfileName({}, _profileCLIDeps.env, startDir);
+}
+async function profileCreateCommand(profileName, startDir) {
+  const profilesDir = join40(projectConfigDir(startDir), "profiles");
+  const profilePath = join40(profilesDir, `${profileName}.json`);
+  const profileFile = Bun.file(profilePath);
+  if (await profileFile.exists()) {
+    throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
+  }
+  mkdirSync4(profilesDir, { recursive: true });
+  await Bun.write(profilePath, "{}");
+  return profilePath;
+}
 // src/cli/agents.ts
 init_registry();
 init_version_detection();
@@ -72941,24 +73491,24 @@ async function diagnose(options) {
 
 // src/commands/logs.ts
 import { existsSync as existsSync30 } from "fs";
-import { join as join42 } from "path";
+import { join as join44 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
-import { readdirSync as readdirSync7 } from "fs";
-import { join as join41 } from "path";
+import { readdirSync as readdirSync9 } from "fs";
+import { join as join43 } from "path";
 
 // src/commands/logs-reader.ts
-import { existsSync as existsSync29, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync8 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
-import { join as join40 } from "path";
+import { join as join42 } from "path";
 
 // src/utils/paths.ts
 import { homedir as homedir4 } from "os";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join39(homedir4(), ".nax", "runs");
+  return process.env.NAX_RUNS_DIR ?? join41(homedir4(), ".nax", "runs");
 }
 
 // src/commands/logs-reader.ts
@@ -72975,7 +73525,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join40(runsDir, entry, "meta.json");
+    const metaPath = join42(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -72991,20 +73541,20 @@ async function resolveRunFileFromRegistry(runId) {
     console.log(`Log directory unavailable for run: ${runId}`);
     return null;
   }
-  const files = readdirSync6(matched.eventsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync8(matched.eventsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     console.log(`No log files found for run: ${runId}`);
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join40(matched.eventsDir, specificFile ?? files[0]);
+  return join42(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
-  const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync8(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join40(runsDir, files[0]);
+  return join42(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -73078,7 +73628,7 @@ var LOG_LEVEL_PRIORITY2 = {
   error: 3
 };
 async function displayRunsList(runsDir) {
-  const files = readdirSync7(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync9(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     console.log(source_default.dim("No runs found"));
     return;
@@ -73089,7 +73639,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file3 of files) {
-    const filePath = join41(runsDir, file3);
+    const filePath = join43(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -73203,7 +73753,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join42(resolved.projectDir, ".nax");
+  const naxDir = join44(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -73211,8 +73761,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join42(naxDir, "features", featureName);
-  const runsDir = join42(featureDir, "runs");
+  const featureDir = join44(naxDir, "features", featureName);
+  const runsDir = join44(featureDir, "runs");
   if (!existsSync30(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -73237,7 +73787,7 @@ init_config();
 init_prd();
 init_precheck();
 import { existsSync as existsSync31 } from "fs";
-import { join as join43 } from "path";
+import { join as join45 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -73259,9 +73809,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join43(resolved.projectDir, ".nax");
-  const featureDir = join43(naxDir, "features", featureName);
-  const prdPath = join43(featureDir, "prd.json");
+  const naxDir = join45(resolved.projectDir, ".nax");
+  const featureDir = join45(naxDir, "features", featureName);
+  const prdPath = join45(featureDir, "prd.json");
   if (!existsSync31(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -73283,7 +73833,7 @@ async function precheckCommand(options) {
 // src/commands/runs.ts
 init_source();
 import { readdir as readdir4 } from "fs/promises";
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -73338,7 +73888,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join44(runsDir, entry, "meta.json");
+    const metaPath = join46(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -73415,7 +73965,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join45 } from "path";
+import { join as join47 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -73430,7 +73980,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join45(workdir, "nax.lock");
+  const lockPath = join47(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -73637,21 +74187,6 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
   options.statusWriter.setRunStatus("running");
   options.statusWriter.setCurrentStory(null);
   await options.statusWriter.update(totalCost, iterations);
-  const reporters = pluginRegistry.getReporters();
-  for (const reporter of reporters) {
-    if (reporter.onRunStart) {
-      try {
-        await reporter.onRunStart({
-          runId: options.runId,
-          feature: options.feature,
-          totalStories: prd.userStories.length,
-          startTime: options.startedAt
-        });
-      } catch (error48) {
-        logger?.warn("plugins", `Reporter '${reporter.name}' onRunStart failed`, { error: error48 });
-      }
-    }
-  }
   logger?.info("execution", `Starting ${options.feature}`, {
     totalStories: prd.userStories.length,
     doneStories: prd.userStories.filter((s) => s.status === "passed").length,
@@ -73765,6 +74300,7 @@ async function run(options) {
   let iterations = 0;
   let storiesCompleted = 0;
   let totalCost = 0;
+  let runCompleted = false;
   const allStoryMetrics = [];
   const logger = getSafeLogger();
   const registry2 = createAgentRegistry(config2);
@@ -73857,6 +74393,7 @@ async function run(options) {
       agentGetFn
     });
     const { durationMs } = completionResult;
+    runCompleted = true;
     return {
       success: isComplete(prd),
       iterations,
@@ -73892,7 +74429,8 @@ async function run(options) {
       feature,
       prdPath,
       branch,
-      version: NAX_VERSION
+      version: NAX_VERSION,
+      runCompleted
     });
     logger2?.debug("execution", "Runner finally \u2014 cleanupRun done, run() returning");
   }
@@ -81253,15 +81791,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join56(workdir, ".nax");
+  const naxDir = join58(workdir, ".nax");
   if (existsSync34(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync5(join56(naxDir, "features"), { recursive: true });
-  mkdirSync5(join56(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join56(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join56(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync6(join58(naxDir, "features"), { recursive: true });
+  mkdirSync6(join58(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join58(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join58(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -81269,12 +81807,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join56(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join58(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join56(naxDir, "context.md"), `# Project Context
+  await Bun.write(join58(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -81359,7 +81897,7 @@ Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cu
   console.log(source_default.dim(`
 Next: nax features create <name>`));
 });
-program2.command("run").description("Run the orchestration loop for a feature").requiredOption("-f, --feature <name>", "Feature name").option("-a, --agent <name>", "Force a specific agent").option("-m, --max-iterations <n>", "Max iterations", "20").option("--dry-run", "Show plan without executing", false).option("--no-context", "Disable context builder (skip file context in prompts)").option("--no-batch", "Disable story batching (execute all stories individually)").option("--parallel <n>", "Max parallel sessions (0=auto, omit=sequential)").option("--plan", "Run plan phase first before execution", false).option("--from <spec-path>", "Path to spec file (required when --plan is used)").option("--one-shot", "Skip interactive planning Q&A, use single LLM call (ACP only)", false).option("--force", "Force overwrite existing prd.json when using --plan", false).option("--headless", "Force headless mode (disable TUI, use pipe mode)", false).option("--verbose", "Enable verbose logging (debug level)", false).option("--quiet", "Quiet mode (warnings and errors only)", false).option("--silent", "Silent mode (errors only)", false).option("--json", "JSON mode (raw JSONL output to stdout)", false).option("-d, --dir <path>", "Working directory", process.cwd()).option("--skip-precheck", "Skip precheck validations (advanced users only)", false).action(async (options) => {
+program2.command("run").description("Run the orchestration loop for a feature").requiredOption("-f, --feature <name>", "Feature name").option("-a, --agent <name>", "Force a specific agent").option("-m, --max-iterations <n>", "Max iterations", "20").option("--dry-run", "Show plan without executing", false).option("--no-context", "Disable context builder (skip file context in prompts)").option("--no-batch", "Disable story batching (execute all stories individually)").option("--parallel <n>", "Max parallel sessions (0=auto, omit=sequential)").option("--plan", "Run plan phase first before execution", false).option("--from <spec-path>", "Path to spec file (required when --plan is used)").option("--one-shot", "Skip interactive planning Q&A, use single LLM call (ACP only)", false).option("--force", "Force overwrite existing prd.json when using --plan", false).option("--headless", "Force headless mode (disable TUI, use pipe mode)", false).option("--verbose", "Enable verbose logging (debug level)", false).option("--quiet", "Quiet mode (warnings and errors only)", false).option("--silent", "Silent mode (errors only)", false).option("--json", "JSON mode (raw JSONL output to stdout)", false).option("-d, --dir <path>", "Working directory", process.cwd()).option("--skip-precheck", "Skip precheck validations (advanced users only)", false).option("--profile <name>", "Profile to use (overrides config.json profile)").action(async (options) => {
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -81395,13 +81933,17 @@ program2.command("run").description("Run the orchestration loop for a feature").
     formatterMode = "quiet";
   }
   const naxDir = findProjectDir(workdir);
-  const config2 = await loadConfig(naxDir ?? undefined);
+  const cliOverrides = {};
+  if (options.profile) {
+    cliOverrides.profile = options.profile;
+  }
+  const config2 = await loadConfig(naxDir ?? undefined, cliOverrides);
   if (!naxDir) {
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", options.feature);
-  const prdPath = join56(featureDir, "prd.json");
+  const featureDir = join58(naxDir, "features", options.feature);
+  const prdPath = join58(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync34(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -81423,10 +81965,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join56(featureDir, "plan");
-      mkdirSync5(planLogDir, { recursive: true });
+      const planLogDir = join58(featureDir, "plan");
+      mkdirSync6(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join56(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join58(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -81470,10 +82012,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join56(featureDir, "runs");
-  mkdirSync5(runsDir, { recursive: true });
+  const runsDir = join58(featureDir, "runs");
+  mkdirSync6(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join56(runsDir, `${runId}.jsonl`);
+  const logFilePath = join58(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -81489,7 +82031,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join56(homedir8(), ".nax");
+  const globalNaxDir = join58(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -81512,7 +82054,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join56(workdir, ".nax", "status.json");
+  const statusFilePath = join58(workdir, ".nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -81538,7 +82080,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join56(runsDir, "latest.jsonl");
+  const latestSymlink = join58(runsDir, "latest.jsonl");
   try {
     if (existsSync34(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -81576,9 +82118,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", name);
-  mkdirSync5(featureDir, { recursive: true });
-  await Bun.write(join56(featureDir, "spec.md"), `# Feature: ${name}
+  const featureDir = join58(naxDir, "features", name);
+  mkdirSync6(featureDir, { recursive: true });
+  await Bun.write(join58(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -81611,7 +82153,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join56(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join58(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -81637,13 +82179,13 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join56(naxDir, "features");
+  const featuresDir = join58(naxDir, "features");
   if (!existsSync34(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
-  const { readdirSync: readdirSync8 } = await import("fs");
-  const entries = readdirSync8(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const { readdirSync: readdirSync10 } = await import("fs");
+  const entries = readdirSync10(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   if (entries.length === 0) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -81652,7 +82194,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join56(featuresDir, name, "prd.json");
+    const prdPath = join58(featuresDir, name, "prd.json");
     if (existsSync34(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -81663,7 +82205,7 @@ Features:
   }
   console.log();
 });
-program2.command("plan [description]").description("Generate prd.json from a spec file via LLM one-shot call (replaces deprecated 'nax analyze')").option("--from <spec-path>", "Path to spec file (required unless --decompose is used)").requiredOption("-f, --feature <name>", "Feature name (required)").option("--auto", "Run in one-shot LLM mode (alias: --one-shot)", false).option("--one-shot", "Run in one-shot LLM mode (alias: --auto)", false).option("-b, --branch <branch>", "Override default branch name").option("-d, --dir <path>", "Project directory", process.cwd()).option("--decompose <storyId>", "Decompose an existing story into sub-stories").action(async (description, options) => {
+program2.command("plan [description]").description("Generate prd.json from a spec file via LLM one-shot call (replaces deprecated 'nax analyze')").option("--from <spec-path>", "Path to spec file (required unless --decompose is used)").requiredOption("-f, --feature <name>", "Feature name (required)").option("--auto", "Run in one-shot LLM mode (alias: --one-shot)", false).option("--one-shot", "Run in one-shot LLM mode (alias: --auto)", false).option("-b, --branch <branch>", "Override default branch name").option("-d, --dir <path>", "Project directory", process.cwd()).option("--decompose <storyId>", "Decompose an existing story into sub-stories").option("--profile <name>", "Profile to use (overrides config.json profile)").action(async (description, options) => {
   if (description) {
     console.error(source_default.red(`Error: Positional args removed in plan v2.
 
@@ -81682,11 +82224,15 @@ Use: nax plan -f <feature> --from <spec>`));
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const config2 = await loadConfig(workdir);
-  const featureLogDir = join56(naxDir, "features", options.feature, "plan");
-  mkdirSync5(featureLogDir, { recursive: true });
+  const cliOverrides = {};
+  if (options.profile) {
+    cliOverrides.profile = options.profile;
+  }
+  const config2 = await loadConfig(workdir, cliOverrides);
+  const featureLogDir = join58(naxDir, "features", options.feature, "plan");
+  mkdirSync6(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join56(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join58(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {
@@ -81737,7 +82283,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", options.feature);
+  const featureDir = join58(naxDir, "features", options.feature);
   if (!existsSync34(featureDir)) {
     console.error(source_default.red(`Feature "${options.feature}" not found.`));
     process.exit(1);
@@ -81753,7 +82299,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
       specPath: options.from,
       reclassify: options.reclassify
     });
-    const prdPath = join56(featureDir, "prd.json");
+    const prdPath = join58(featureDir, "prd.json");
     await Bun.write(prdPath, JSON.stringify(prd, null, 2));
     const c = countStories(prd);
     console.log(source_default.green(`
@@ -81786,7 +82332,7 @@ program2.command("agents").description("List available coding agents with status
     process.exit(1);
   }
 });
-program2.command("config").description("Display effective merged configuration").option("-d, --dir <path>", "Project directory", process.cwd()).option("--explain", "Show detailed field descriptions", false).option("--diff", "Show only fields where project overrides global", false).action(async (options) => {
+var configCmd = program2.command("config").description("Display effective merged configuration").option("-d, --dir <path>", "Project directory", process.cwd()).option("--explain", "Show detailed field descriptions", false).option("--diff", "Show only fields where project overrides global", false).action(async (options) => {
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -81803,6 +82349,52 @@ program2.command("config").description("Display effective merged configuration")
     process.exit(1);
   }
 });
+var configProfileCmd = configCmd.command("profile").description("Manage config profiles");
+configProfileCmd.command("list").description("List all available profiles grouped by scope").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
+  try {
+    const output = await profileListCommand(options.dir);
+    console.log(output);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+configProfileCmd.command("show <name>").description("Show resolved profile JSON").option("-d, --dir <path>", "Project directory", process.cwd()).option("--unmask", "Show raw values including secrets", false).action(async (name, options) => {
+  try {
+    const output = await profileShowCommand(name, options.dir, { unmask: options.unmask });
+    console.log(output);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+configProfileCmd.command("use <name>").description("Set the active profile (use 'default' to clear)").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (name, options) => {
+  try {
+    const msg = await profileUseCommand(name, options.dir);
+    console.log(msg);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+configProfileCmd.command("current").description("Show the currently active profile name").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
+  try {
+    const name = await profileCurrentCommand(options.dir);
+    console.log(name);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+configProfileCmd.command("create <name>").description("Create a new empty profile").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (name, options) => {
+  try {
+    const path19 = await profileCreateCommand(name, options.dir);
+    console.log(`Created profile at: ${path19}`);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+});
 program2.command("status").description("Show current run status").option("-f, --feature <name>", "Feature name").option("-d, --dir <path>", "Project directory", process.cwd()).option("--cost", "Show cost metrics across all runs", false).option("--last", "Show last run metrics (requires --cost)", false).option("--model", "Show per-model efficiency (requires --cost)", false).action(async (options) => {
   let workdir;
   try {