@nathapp/nax 0.50.3 → 0.51.0

package/src/config/schemas.ts

@@ -1,426 +0,0 @@
-/**
- * Zod Schema Definitions
- *
- * Runtime validation schemas for nax configuration.
- */
-
-import { z } from "zod";
-
-/** Zod schema for runtime validation */
-const TokenPricingSchema = z.object({
-  inputPer1M: z.number().min(0),
-  outputPer1M: z.number().min(0),
-});
-
-const ModelDefSchema = z.object({
-  provider: z.string().min(1, "Provider must be non-empty"),
-  model: z.string().min(1, "Model must be non-empty"),
-  pricing: TokenPricingSchema.optional(),
-  env: z.record(z.string(), z.string()).optional(),
-});
-
-const ModelEntrySchema = z.union([z.string().min(1, "Model identifier must be non-empty"), ModelDefSchema]);
-
-const ModelMapSchema = z.object({
-  fast: ModelEntrySchema,
-  balanced: ModelEntrySchema,
-  powerful: ModelEntrySchema,
-});
-
-const ModelTierSchema = z.string().min(1, "Tier name must be non-empty");
-
-const TierConfigSchema = z.object({
-  tier: z.string().min(1, "Tier name must be non-empty"),
-  attempts: z.number().int().min(1).max(20, { message: "attempts must be 1-20" }),
-});
-
-const AutoModeConfigSchema = z.object({
-  enabled: z.boolean(),
-  defaultAgent: z.string().trim().min(1, "defaultAgent must be non-empty"),
-  fallbackOrder: z.array(z.string()),
-  complexityRouting: z.object({
-    simple: ModelTierSchema,
-    medium: ModelTierSchema,
-    complex: ModelTierSchema,
-    expert: ModelTierSchema,
-  }),
-  escalation: z.object({
-    enabled: z.boolean(),
-    tierOrder: z.array(TierConfigSchema).min(1, { message: "tierOrder must have at least one tier" }),
-    escalateEntireBatch: z.boolean().optional(),
-  }),
-});
-
-const RectificationConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  maxRetries: z.number().int().min(0).max(10).default(2),
-  fullSuiteTimeoutSeconds: z.number().int().min(10).max(600).default(120),
-  maxFailureSummaryChars: z.number().int().min(500).max(10000).default(2000),
-  abortOnIncreasingFailures: z.boolean().default(true),
-});
-
-const RegressionGateConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  timeoutSeconds: z.number().int().min(10).max(600).default(120),
-  acceptOnTimeout: z.boolean().default(true),
-  mode: z.enum(["deferred", "per-story", "disabled"]).default("deferred"),
-  maxRectificationAttempts: z.number().int().min(1).default(2),
-});
-
-const SmartTestRunnerConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  testFilePatterns: z.array(z.string()).default(["test/**/*.test.ts"]),
-  fallback: z.enum(["import-grep", "full-suite"]).default("import-grep"),
-});
-
-const SMART_TEST_RUNNER_DEFAULT = {
-  enabled: true,
-  testFilePatterns: ["test/**/*.test.ts"],
-  fallback: "import-grep" as const,
-};
-
-/** Coerces boolean → SmartTestRunnerConfig for backward compat */
-const smartTestRunnerFieldSchema = z
-  .preprocess((val) => {
-    if (typeof val === "boolean") {
-      return { enabled: val, testFilePatterns: ["test/**/*.test.ts"], fallback: "import-grep" };
-    }
-    return val;
-  }, SmartTestRunnerConfigSchema)
-  .default(SMART_TEST_RUNNER_DEFAULT);
-
-const ExecutionConfigSchema = z.object({
-  maxIterations: z.number().int().positive({ message: "maxIterations must be > 0" }),
-  iterationDelayMs: z.number().int().nonnegative(),
-  costLimit: z.number().positive({ message: "costLimit must be > 0" }),
-  sessionTimeoutSeconds: z.number().int().positive({ message: "sessionTimeoutSeconds must be > 0" }),
-  verificationTimeoutSeconds: z.number().int().min(1).max(3600).default(300),
-  maxStoriesPerFeature: z.number().int().positive(),
-  rectification: RectificationConfigSchema,
-  regressionGate: RegressionGateConfigSchema,
-  contextProviderTokenBudget: z
-    .number()
-    .int()
-    .positive({ message: "contextProviderTokenBudget must be > 0" })
-    .default(2000),
-  lintCommand: z.string().nullable().optional(),
-  typecheckCommand: z.string().nullable().optional(),
-  // DEPRECATED — use permissionProfile instead. Kept for backward compat.
-  dangerouslySkipPermissions: z.boolean().default(true),
-  // NEW — takes precedence over dangerouslySkipPermissions
-  permissionProfile: z.enum(["unrestricted", "safe", "scoped"]).optional(),
-  // Phase 2: per-stage permission overrides (only read when profile = "scoped")
-  permissions: z
-    .record(
-      z.string(),
-      z.object({
-        mode: z.enum(["approve-all", "approve-reads", "scoped"]),
-        allowedTools: z.array(z.string()).optional(),
-        inherit: z.string().optional(),
-      }),
-    )
-    .optional(),
-  smartTestRunner: smartTestRunnerFieldSchema,
-});
-
-const QualityConfigSchema = z.object({
-  requireTypecheck: z.boolean(),
-  requireLint: z.boolean(),
-  requireTests: z.boolean(),
-  commands: z.object({
-    typecheck: z.string().optional(),
-    lint: z.string().optional(),
-    test: z.string().optional(),
-    testScoped: z.string().optional(),
-    lintFix: z.string().optional(),
-    formatFix: z.string().optional(),
-  }),
-  forceExit: z.boolean().default(false),
-  detectOpenHandles: z.boolean().default(true),
-  detectOpenHandlesRetries: z.number().int().min(0).max(5).default(1),
-  gracePeriodMs: z.number().int().min(500).max(30000).default(5000),
-  drainTimeoutMs: z.number().int().min(0).max(10000).default(2000),
-  shell: z.string().default("/bin/sh"),
-  stripEnvVars: z
-    .array(z.string())
-    .default([
-      "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",
-    ]),
-  environmentalEscalationDivisor: z.number().min(1).max(10).default(2),
-  testing: z
-    .object({
-      /**
-       * When true (default), nax injects a hermetic test requirement into all code-writing prompts.
-       * Instructs the AI to mock all I/O boundaries (HTTP, CLI spawning, databases, etc.)
-       * and never invoke real external processes or services during test execution.
-       * Set to false only if your project requires real integration calls in tests.
-       */
-      hermetic: z.boolean().default(true),
-      /**
-       * Project-specific external boundaries the AI should watch for and mock.
-       * E.g. ["claude", "acpx", "redis", "grpc"] — any CLI tools, clients, or services
-       * the project uses that should never be called from tests.
-       */
-      externalBoundaries: z.array(z.string()).optional(),
-      /**
-       * Project-specific guidance on how to mock external dependencies.
-       * Injected verbatim into the hermetic requirement section of the prompt.
-       * E.g. "Use injectable deps for CLI spawning, ioredis-mock for Redis"
-       */
-      mockGuidance: z.string().optional(),
-    })
-    .optional(),
-});
-
-const TddConfigSchema = z.object({
-  maxRetries: z.number().int().nonnegative(),
-  autoVerifyIsolation: z.boolean(),
-  autoApproveVerifier: z.boolean(),
-  strategy: z.enum(["auto", "strict", "lite", "off"]).default("auto"),
-  sessionTiers: z
-    .object({
-      testWriter: z.string().optional(),
-      implementer: z.string().optional(),
-      verifier: z.string().optional(),
-    })
-    .optional(),
-  testWriterAllowedPaths: z.array(z.string()).optional(),
-  rollbackOnFailure: z.boolean().optional(),
-  greenfieldDetection: z.boolean().optional(),
-});
-
-const ConstitutionConfigSchema = z.object({
-  enabled: z.boolean(),
-  path: z.string().min(1, "constitution.path must be non-empty"),
-  maxTokens: z.number().int().positive({ message: "constitution.maxTokens must be > 0" }),
-  skipGlobal: z.boolean().optional(),
-});
-
-const AnalyzeConfigSchema = z.object({
-  llmEnhanced: z.boolean(),
-  model: ModelTierSchema,
-  fallbackToKeywords: z.boolean(),
-  maxCodebaseSummaryTokens: z.number().int().positive(),
-});
-
-const ReviewConfigSchema = z.object({
-  enabled: z.boolean(),
-  checks: z.array(z.enum(["typecheck", "lint", "test"])),
-  commands: z.object({
-    typecheck: z.string().optional(),
-    lint: z.string().optional(),
-    test: z.string().optional(),
-  }),
-  pluginMode: z.enum(["per-story", "deferred"]).default("per-story"),
-});
-
-const PlanConfigSchema = z.object({
-  model: ModelTierSchema,
-  outputPath: z.string().min(1, "plan.outputPath must be non-empty"),
-});
-
-export const AcceptanceConfigSchema = z.object({
-  enabled: z.boolean(),
-  maxRetries: z.number().int().nonnegative(),
-  generateTests: z.boolean(),
-  testPath: z.string().min(1, "acceptance.testPath must be non-empty"),
-  model: z.enum(["fast", "balanced", "powerful"]).default("fast"),
-  refinement: z.boolean().default(true),
-  redGate: z.boolean().default(true),
-  testStrategy: z.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
-  testFramework: z.string().min(1, "acceptance.testFramework must be non-empty").optional(),
-  timeoutMs: z.number().int().min(30000).max(3600000).default(1800000),
-});
-
-const TestCoverageConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  detail: z.enum(["names-only", "names-and-counts", "describe-blocks"]).default("names-and-counts"),
-  maxTokens: z.number().int().min(50).max(5000).default(500),
-  testDir: z.string().optional(),
-  testPattern: z.string().default("**/*.test.{ts,js,tsx,jsx}"),
-  scopeToStory: z.boolean().default(true),
-});
-
-const ContextAutoDetectConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  maxFiles: z.number().int().min(1).max(20).default(5),
-  traceImports: z.boolean().default(false),
-});
-
-const ContextConfigSchema = z.object({
-  testCoverage: TestCoverageConfigSchema,
-  autoDetect: ContextAutoDetectConfigSchema,
-  fileInjection: z.enum(["keyword", "disabled"]).default("disabled"),
-});
-
-const AdaptiveRoutingConfigSchema = z.object({
-  minSamples: z.number().int().positive({ message: "adaptive.minSamples must be > 0" }),
-  costThreshold: z.number().min(0).max(1, { message: "adaptive.costThreshold must be 0-1" }),
-  fallbackStrategy: z.enum(["keyword", "llm", "manual"]),
-});
-
-const LlmRoutingConfigSchema = z.object({
-  model: z.string().optional(),
-  fallbackToKeywords: z.boolean().optional(),
-  cacheDecisions: z.boolean().optional(),
-  mode: z.enum(["one-shot", "per-story", "hybrid"]).optional(),
-  batchMode: z.boolean().optional(), // deprecated, for backward compat
-  timeoutMs: z.number().int().positive({ message: "llm.timeoutMs must be > 0" }).optional(),
-  retries: z.number().int().min(0, { message: "llm.retries must be >= 0" }).optional(),
-  retryDelayMs: z.number().int().min(0, { message: "llm.retryDelayMs must be >= 0" }).optional(),
-});
-
-const RoutingConfigSchema = z
-  .object({
-    strategy: z.enum(["keyword", "llm", "manual", "adaptive", "custom"]),
-    customStrategyPath: z.string().optional(),
-    adaptive: AdaptiveRoutingConfigSchema.optional(),
-    llm: LlmRoutingConfigSchema.optional(),
-  })
-  .refine(
-    (data) => {
-      // If strategy is "custom", customStrategyPath is required
-      if (data.strategy === "custom" && !data.customStrategyPath) {
-        return false;
-      }
-      return true;
-    },
-    {
-      message: "routing.customStrategyPath is required when strategy is 'custom'",
-      path: ["customStrategyPath"],
-    },
-  );
-
-const OptimizerConfigSchema = z.object({
-  enabled: z.boolean(),
-  strategy: z.enum(["rule-based", "llm", "noop"]).optional(),
-});
-
-const PluginConfigEntrySchema = z.object({
-  module: z.string().min(1, "plugin.module must be non-empty"),
-  config: z.record(z.string(), z.unknown()).optional(),
-  enabled: z.boolean().default(true),
-});
-
-const HooksConfigSchema = z.object({
-  skipGlobal: z.boolean().optional(),
-  hooks: z.record(z.string(), z.unknown()),
-});
-
-const InteractionConfigSchema = z.object({
-  plugin: z.string().default("cli"),
-  config: z.record(z.string(), z.unknown()).optional(),
-  defaults: z.object({
-    timeout: z.number().int().min(1000).max(3600000).default(600000),
-    fallback: z.enum(["continue", "skip", "escalate", "abort"]).default("escalate"),
-  }),
-  triggers: z
-    .record(
-      z.string(),
-      z.union([
-        z.boolean(),
-        z.object({
-          enabled: z.boolean(),
-          fallback: z.string().optional(),
-          timeout: z.number().optional(),
-        }),
-      ]),
-    )
-    .default({}),
-});
-
-const StorySizeGateConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  maxAcCount: z.number().int().min(1).max(50).default(6),
-  maxDescriptionLength: z.number().int().min(100).max(10000).default(2000),
-  maxBulletPoints: z.number().int().min(1).max(100).default(8),
-});
-
-const AgentConfigSchema = z.object({
-  protocol: z.enum(["acp", "cli"]).default("acp"),
-  maxInteractionTurns: z.number().int().min(1).max(100).default(10),
-});
-
-const PrecheckConfigSchema = z.object({
-  storySizeGate: StorySizeGateConfigSchema,
-});
-
-export const PromptsConfigSchema = z.object({
-  overrides: z
-    .record(
-      z
-        .string()
-        .refine((key) => ["test-writer", "implementer", "verifier", "single-session", "tdd-simple"].includes(key), {
-          message: "Role must be one of: test-writer, implementer, verifier, single-session, tdd-simple",
-        }),
-      z.string().min(1, "Override path must be non-empty"),
-    )
-    .optional(),
-});
-
-const DecomposeConfigSchema = z.object({
-  trigger: z.enum(["auto", "confirm", "disabled"]).default("auto"),
-  maxAcceptanceCriteria: z.number().int().min(1).default(6),
-  maxSubstories: z.number().int().min(1).default(5),
-  maxSubstoryComplexity: z.enum(["simple", "medium", "complex", "expert"]).default("medium"),
-  maxRetries: z.number().int().min(0).default(2),
-  model: z.string().min(1).default("balanced"),
-});
-
-export const NaxConfigSchema = z
-  .object({
-    version: z.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,
-    optimizer: OptimizerConfigSchema.optional(),
-    plugins: z.array(PluginConfigEntrySchema).optional(),
-    disabledPlugins: z.array(z.string()).optional(),
-    hooks: HooksConfigSchema.optional(),
-    interaction: InteractionConfigSchema.optional(),
-    agent: AgentConfigSchema.optional(),
-    precheck: PrecheckConfigSchema.optional(),
-    prompts: PromptsConfigSchema.optional(),
-    decompose: DecomposeConfigSchema.optional(),
-  })
-  .refine((data) => data.version === 1, {
-    message: "Invalid version: expected 1",
-    path: ["version"],
-  });

package/src/config/test-strategy.ts

@@ -1,71 +0,0 @@
-/**
- * Test Strategy — Single Source of Truth
- *
- * Defines all valid test strategies, the normalizer, and shared prompt
- * fragments used by plan.ts and claude-decompose.ts.
- */
-
-import type { TestStrategy } from "./schema-types";
-
-// ─── Re-export type ───────────────────────────────────────────────────────────
-
-export type { TestStrategy };
-
-// ─── Valid values ─────────────────────────────────────────────────────────────
-
-export const VALID_TEST_STRATEGIES: readonly TestStrategy[] = [
-  "test-after",
-  "tdd-simple",
-  "three-session-tdd",
-  "three-session-tdd-lite",
-];
-
-// ─── Resolver ────────────────────────────────────────────────────────────────
-
-/**
- * Validate and normalize a test strategy string.
- * Returns a valid TestStrategy or falls back to "test-after".
- */
-export function resolveTestStrategy(raw: string | undefined): TestStrategy {
-  if (!raw) return "test-after";
-  if (VALID_TEST_STRATEGIES.includes(raw as TestStrategy)) return raw as TestStrategy;
-  // Map legacy/typo values
-  if (raw === "tdd") return "tdd-simple";
-  if (raw === "three-session") return "three-session-tdd";
-  if (raw === "tdd-lite") return "three-session-tdd-lite";
-  return "test-after"; // safe fallback
-}
-
-// ─── Prompt fragments (shared by plan.ts and claude-decompose.ts) ────────────
-
-export const COMPLEXITY_GUIDE = `## Complexity Classification Guide
-
-- simple: ≤50 LOC, single-file change, purely additive, no new dependencies → tdd-simple
-- medium: 50–200 LOC, 2–5 files, standard patterns, clear requirements → three-session-tdd-lite
-- complex: 200–500 LOC, multiple modules, new abstractions or integrations → three-session-tdd
-- expert: 500+ LOC, architectural changes, cross-cutting concerns, high risk → three-session-tdd
-
-### Security Override
-
-Security-critical functions (authentication, cryptography, tokens, sessions, credentials,
-password hashing, access control) must use three-session-tdd regardless of complexity.`;
-
-export const TEST_STRATEGY_GUIDE = `## Test Strategy Guide
-
-- tdd-simple: Simple stories (≤50 LOC). Write failing tests first, then implement to pass them — all in one session.
-- three-session-tdd-lite: Medium stories, or complex stories involving UI/CLI/integration. 3 sessions: (1) test-writer writes failing tests and may create minimal src/ stubs for imports, (2) implementer makes tests pass and may replace stubs, (3) verifier confirms correctness.
-- three-session-tdd: Complex/expert stories or security-critical code. 3 sessions with strict isolation: (1) test-writer writes failing tests — no src/ changes allowed, (2) implementer makes them pass without modifying test files, (3) verifier confirms correctness.
-- test-after: Only when explicitly configured (tddStrategy: "off"). Write tests after implementation. Not auto-assigned.`;
-
-export const GROUPING_RULES = `## Story Rules
-
-- Every story must produce code changes verifiable by tests or review.
-- NEVER create stories for analysis, planning, documentation, or migration plans.
-  Your analysis belongs in the "analysis" field, not in a story.
-- NEVER create stories whose primary purpose is writing tests, achieving coverage
-  targets, or running validation/regression suites. Each story's testStrategy
-  handles test creation as part of implementation. Testing is a built-in pipeline
-  stage, not a user story. No exceptions.
-- Combine small, related tasks into a single "simple" or "medium" story.
-  Do NOT create separate stories for every single file or function unless complex.
-- Aim for coherent units of value. Maximum recommended stories: 10-15 per feature.`;

package/src/config/types.ts

@@ -1,57 +0,0 @@
-/**
- * Configuration Type Definitions (Hub)
- *
- * Re-exports all TypeScript interfaces, type aliases, and utility functions
- * for the nax configuration system.
- */
-
-// Schema types
-export type {
-  Complexity,
-  LlmRoutingMode,
-  ModelDef,
-  ModelEntry,
-  ModelMap,
-  ModelTier,
-  RoutingStrategyName,
-  TddStrategy,
-  TestStrategy,
-  TierConfig,
-  TokenPricing,
-} from "./schema-types";
-export { resolveModel } from "./schema-types";
-
-// Runtime types
-export type {
-  AcceptanceConfig,
-  AcceptanceTestStrategy,
-  AnalyzeConfig,
-  AutoModeConfig,
-  ConstitutionConfig,
-  ContextAutoDetectConfig,
-  ContextConfig,
-  DecomposeConfig,
-  EscalationEntry,
-  ExecutionConfig,
-  HooksConfig,
-  InteractionConfig,
-  LlmRoutingConfig,
-  NaxConfig,
-  OptimizerConfig,
-  PlanConfig,
-  PluginConfigEntry,
-  PrecheckConfig,
-  PromptsConfig,
-  QualityConfig,
-  RectificationConfig,
-  RegressionGateConfig,
-  ReviewConfig,
-  RoutingConfig,
-  SmartTestRunnerConfig,
-  StorySizeGateConfig,
-  TddConfig,
-  TestCoverageConfig,
-  TestingConfig,
-  AdaptiveRoutingConfig,
-  AgentConfig,
-} from "./runtime-types";

package/src/config/validate.ts

@@ -1,103 +0,0 @@
-/**
- * Configuration Validation
- *
- * @deprecated Use NaxConfigSchema.safeParse() from schema.ts instead.
- * This module is kept for backward compatibility only.
- *
- * Validates NaxConfig structure and constraints.
- */
-
-import type { NaxConfig } from "./schema";
-
-/** Validation result */
-export interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-}
-
-/**
- * Validate NaxConfig
- *
- * Checks:
- * - version === 1
- * - maxIterations > 0
- * - costLimit > 0
- * - sessionTimeoutSeconds > 0
- * - defaultAgent is non-empty
- * - escalation.tierOrder has at least one tier with valid attempts
- */
-export function validateConfig(config: NaxConfig): ValidationResult {
-  const errors: string[] = [];
-
-  // Version check
-  if (config.version !== 1) {
-    errors.push(`Invalid version: expected 1, got ${config.version}`);
-  }
-
-  // Models mapping
-  const requiredTiers = ["fast", "balanced", "powerful"] as const;
-  if (!config.models) {
-    errors.push("models mapping is required");
-  } else {
-    for (const tier of requiredTiers) {
-      const entry = config.models[tier];
-      if (!entry) {
-        errors.push(`models.${tier} is required`);
-      } else if (typeof entry === "string") {
-        if (entry.trim() === "") {
-          errors.push(`models.${tier} must be a non-empty model identifier`);
-        }
-      } else {
-        if (!entry.provider || entry.provider.trim() === "") {
-          errors.push(`models.${tier}.provider must be non-empty`);
-        }
-        if (!entry.model || entry.model.trim() === "") {
-          errors.push(`models.${tier}.model must be non-empty`);
-        }
-      }
-    }
-  }
-
-  // Execution limits
-  if (config.execution.maxIterations <= 0) {
-    errors.push(`maxIterations must be > 0, got ${config.execution.maxIterations}`);
-  }
-
-  if (config.execution.costLimit <= 0) {
-    errors.push(`costLimit must be > 0, got ${config.execution.costLimit}`);
-  }
-
-  if (config.execution.sessionTimeoutSeconds <= 0) {
-    errors.push(`sessionTimeoutSeconds must be > 0, got ${config.execution.sessionTimeoutSeconds}`);
-  }
-
-  // Auto mode config
-  if (!config.autoMode.defaultAgent || config.autoMode.defaultAgent.trim() === "") {
-    errors.push("defaultAgent must be non-empty");
-  }
-
-  if (!config.autoMode.escalation.tierOrder || config.autoMode.escalation.tierOrder.length === 0) {
-    errors.push("escalation.tierOrder must have at least one tier");
-  } else {
-    for (const tc of config.autoMode.escalation.tierOrder) {
-      if (tc.attempts < 1 || tc.attempts > 20) {
-        errors.push(`escalation.tierOrder: tier "${tc.tier}" attempts must be 1-20, got ${tc.attempts}`);
-      }
-    }
-  }
-
-  // Validate complexityRouting values reference tiers that exist in models config
-  const configuredTiers = Object.keys(config.models);
-  const complexities = ["simple", "medium", "complex", "expert"] as const;
-  for (const complexity of complexities) {
-    const tier = config.autoMode.complexityRouting[complexity];
-    if (!configuredTiers.includes(tier)) {
-      errors.push(`complexityRouting.${complexity} must be one of: ${configuredTiers.join(", ")} (got '${tier}')`);
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
-}