@nathapp/nax 0.50.3 → 0.51.2

package/src/cli/analyze.ts

@@ -1,352 +0,0 @@
-/**
- * Analyze Command -- Parse spec.md into prd.json via agent decompose
- *
- * Uses agent adapter's decompose() method to break spec into classified stories
- * in a single LLM call. Falls back to keyword classification if decompose fails.
- */
-
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { generateAcceptanceTests } from "../acceptance";
-import { getAgent } from "../agents/registry";
-import { scanCodebase } from "../analyze/scanner";
-import type { NaxConfig } from "../config";
-import { resolveModel } from "../config/schema";
-import { applyDecomposition } from "../decompose/apply";
-import { DecomposeBuilder } from "../decompose/builder";
-import type { DecomposeConfig as BuilderDecomposeConfig, DecomposeResult, SubStory } from "../decompose/types";
-import { getLogger } from "../logger";
-import { loadPRD, savePRD } from "../prd";
-import type { PRD, UserStory } from "../prd";
-import { routeTask } from "../routing";
-import { NAX_VERSION } from "../version";
-import {
-  applyKeywordClassification,
-  buildCodebaseContext,
-  parseUserStoriesFromSpec,
-  reclassifyExistingPRD,
-} from "./analyze-parser";
-
-export interface AnalyzeOptions {
-  featureDir: string;
-  featureName: string;
-  branchName: string;
-  config?: NaxConfig;
-  specPath?: string;
-  reclassify?: boolean;
-}
-
-/** Parse spec.md into PRD via agent decompose */
-export async function analyzeFeature(options: AnalyzeOptions): Promise<PRD> {
-  const { featureDir, featureName, branchName, config, specPath: explicitSpecPath, reclassify = false } = options;
-  const workdir = join(featureDir, "../..");
-
-  if (reclassify) {
-    return await reclassifyExistingPRD(featureDir, featureName, branchName, workdir, config);
-  }
-
-  const specPath = explicitSpecPath || join(featureDir, "spec.md");
-  if (!existsSync(specPath)) throw new Error(`spec.md not found at ${specPath}`);
-
-  const specContent = await Bun.file(specPath).text();
-  let userStories: UserStory[];
-
-  const logger = getLogger();
-  if (config?.analyze.llmEnhanced) {
-    userStories = await decomposeLLM(specContent, workdir, config, logger);
-  } else {
-    logger.info("cli", "LLM-enhanced analysis disabled, using manual parsing + keyword classification");
-    userStories = parseUserStoriesFromSpec(specContent);
-    if (userStories.length === 0) throw new Error("No user stories found in spec.md. Expected '## US-xxx' headings.");
-    userStories = applyKeywordClassification(userStories, config);
-  }
-
-  if (config && userStories.length > config.execution.maxStoriesPerFeature) {
-    logger.warn(
-      "cli",
-      `Feature has ${userStories.length} stories, exceeding recommended limit of ${config.execution.maxStoriesPerFeature}. Consider splitting.`,
-    );
-  }
-
-  const naxVersion = NAX_VERSION;
-
-  const now = new Date().toISOString();
-  const prd: PRD = {
-    project: "nax",
-    feature: featureName,
-    branchName,
-    createdAt: now,
-    updatedAt: now,
-    userStories,
-    analyzeConfig: config
-      ? {
-          naxVersion,
-          model: config.analyze.model,
-          llmEnhanced: config.analyze.llmEnhanced,
-          maxStoriesPerFeature: config.execution.maxStoriesPerFeature,
-          routingStrategy: config.analyze.llmEnhanced ? "llm" : "keyword",
-        }
-      : undefined,
-  };
-
-  // Generate acceptance tests if enabled
-  if (config?.acceptance.enabled && config.acceptance.generateTests) {
-    await generateAcceptanceTestsForFeature(specContent, featureName, featureDir, workdir, config, logger);
-  }
-
-  return prd;
-}
-
-/** Run LLM-enhanced decompose and classify stories. */
-async function decomposeLLM(
-  specContent: string,
-  workdir: string,
-  config: NaxConfig,
-  logger: ReturnType<typeof getLogger>,
-): Promise<UserStory[]> {
-  logger.info("cli", "Running agent decompose (decompose + classify in single LLM call)");
-
-  try {
-    const scan = await scanCodebase(workdir);
-    const codebaseContext = buildCodebaseContext(scan);
-    const agentName = config.autoMode.defaultAgent;
-    const adapter = getAgent(agentName);
-    if (!adapter) throw new Error(`Agent "${agentName}" not found`);
-
-    const modelTier = config.analyze.model;
-    const modelDef = resolveModel(config.models[modelTier]);
-    const result = await adapter.decompose({ specContent, workdir, codebaseContext, modelTier, modelDef, config });
-
-    logger.info("cli", "[OK] Agent decompose complete", { storiesCount: result.stories.length });
-
-    return result.stories.map((ds) => {
-      let testStrategy: import("../config").TestStrategy;
-      let routingStrategy: "llm" | "keyword";
-
-      if (ds.testStrategy) {
-        testStrategy = ds.testStrategy;
-        routingStrategy = "llm";
-      } else {
-        const routing = routeTask(ds.title, ds.description, ds.acceptanceCriteria, ds.tags, config);
-        testStrategy = routing.testStrategy;
-        routingStrategy = "keyword";
-      }
-
-      return {
-        id: ds.id,
-        title: ds.title,
-        description: ds.description,
-        acceptanceCriteria: ds.acceptanceCriteria,
-        tags: ds.tags,
-        dependencies: ds.dependencies,
-        status: "pending" as const,
-        passes: false,
-        escalations: [],
-        attempts: 0,
-        routing: {
-          complexity: ds.complexity,
-          testStrategy,
-          reasoning: ds.reasoning,
-          estimatedLOC: ds.estimatedLOC,
-          risks: ds.risks,
-          strategy: routingStrategy,
-          llmModel: routingStrategy === "llm" ? modelDef.model : undefined,
-        },
-        contextFiles: ds.contextFiles,
-      };
-    });
-  } catch (error) {
-    logger.warn("cli", "Agent decompose failed, falling back to manual story extraction", {
-      error: (error as Error).message,
-    });
-    const stories = parseUserStoriesFromSpec(specContent);
-    if (stories.length === 0) {
-      throw new Error("No user stories found in spec.md. Expected '## US-xxx' headings or agent decompose to succeed.");
-    }
-    return applyKeywordClassification(stories, config);
-  }
-}
-
-/** Generate acceptance tests for a feature. */
-async function generateAcceptanceTestsForFeature(
-  specContent: string,
-  featureName: string,
-  featureDir: string,
-  workdir: string,
-  config: NaxConfig,
-  logger: ReturnType<typeof getLogger>,
-): Promise<void> {
-  logger.info("cli", "Generating acceptance tests from spec.md");
-  try {
-    const scan = await scanCodebase(workdir);
-    const codebaseContext = buildCodebaseContext(scan);
-    const adapter = getAgent(config.autoMode.defaultAgent);
-    if (!adapter) throw new Error(`Agent "${config.autoMode.defaultAgent}" not found`);
-
-    const modelTier = config.analyze.model;
-    const modelDef = resolveModel(config.models[modelTier]);
-    const result = await generateAcceptanceTests(adapter, {
-      specContent,
-      featureName,
-      workdir,
-      codebaseContext,
-      modelTier,
-      modelDef,
-      config,
-    });
-
-    const acceptanceTestPath = join(featureDir, config.acceptance.testPath);
-    await Bun.write(acceptanceTestPath, result.testCode);
-    logger.info("cli", "[OK] Acceptance tests generated", {
-      criteriaCount: result.criteria.length,
-      testPath: acceptanceTestPath,
-    });
-  } catch (error) {
-    logger.warn("cli", "Failed to generate acceptance tests", { error: (error as Error).message });
-  }
-}
-
-// ============================================================================
-// SD-004: Story decompose CLI entry points
-// ============================================================================
-
-/** Default runDecompose implementation — replaced in tests via _decomposeCLIDeps. */
-async function runDecomposeDefault(
-  story: UserStory,
-  prd: PRD,
-  config: NaxConfig,
-  _featureDir: string,
-): Promise<DecomposeResult> {
-  const naxDecompose = config.decompose;
-  const builderConfig: BuilderDecomposeConfig = {
-    maxSubStories: naxDecompose?.maxSubstories ?? 5,
-    maxComplexity: naxDecompose?.maxSubstoryComplexity ?? "medium",
-    maxRetries: naxDecompose?.maxRetries ?? 2,
-  };
-  const agent = getAgent(config.autoMode.defaultAgent);
-  if (!agent) {
-    throw new Error(`[decompose] Agent "${config.autoMode.defaultAgent}" not found — cannot decompose`);
-  }
-  const adapter = {
-    async decompose(prompt: string): Promise<string> {
-      return agent.complete(prompt, { jsonMode: true, config });
-    },
-  };
-  return DecomposeBuilder.for(story).prd(prd).config(builderConfig).decompose(adapter);
-}
-
-/** Load PRD from featureDir and return both PRD and resolved path. */
-async function loadPRDFromDir(featureDir: string): Promise<{ prd: PRD; prdPath: string }> {
-  const prdPath = join(featureDir, "prd.json");
-  const prd = await loadPRD(prdPath);
-  return { prd, prdPath };
-}
-
-/** Build a human-readable summary of decomposed substories. */
-function buildSummaryLines(subStories: SubStory[]): string[] {
-  const lines: string[] = ["Decomposed substories:"];
-  for (const sub of subStories) {
-    lines.push(`  ${sub.id}  ${sub.title}  [${sub.complexity}]  parent: ${sub.parentStoryId}`);
-  }
-  return lines;
-}
-
-/** Default print implementation — writes lines to stdout. */
-function printSummaryDefault(lines: string[]): void {
-  for (const line of lines) {
-    process.stdout.write(`${line}\n`);
-  }
-}
-
-/**
- * Swappable dependencies for CLI decompose functions.
- * Tests override individual entries without using mock.module().
- */
-export const _decomposeCLIDeps = {
-  loadPRD: loadPRDFromDir,
-  runDecompose: runDecomposeDefault,
-  applyDecomposition,
-  savePRD,
-  printSummary: printSummaryDefault,
-};
-
-/**
- * Decompose a single story by ID via --decompose <storyId>.
- *
- * Loads the PRD, runs decomposition, applies result, and saves the updated PRD.
- * Prints a summary table of the generated substories.
- */
-export async function decomposeStory(
-  storyId: string,
-  options: { featureDir: string; config: NaxConfig },
-): Promise<void> {
-  const { featureDir, config } = options;
-  const logger = getLogger();
-
-  const { prd, prdPath } = await _decomposeCLIDeps.loadPRD(featureDir);
-
-  const story = prd.userStories.find((s) => s.id === storyId);
-  if (!story) {
-    throw new Error(`Story ${storyId} not found in PRD`);
-  }
-
-  const result = await _decomposeCLIDeps.runDecompose(story, prd, config, featureDir);
-
-  if (!result.validation.valid) {
-    logger.warn("cli", `Decompose failed for ${storyId}: ${result.validation.errors.join(", ")}`);
-    return;
-  }
-
-  _decomposeCLIDeps.applyDecomposition(prd, result);
-  await _decomposeCLIDeps.savePRD(prd, prdPath);
-
-  const lines = buildSummaryLines(result.subStories);
-  _decomposeCLIDeps.printSummary(lines);
-}
-
-/**
- * Decompose all oversized stories via --decompose-oversized.
- *
- * Iterates all stories, decomposes any that exceed config.decompose.maxAcceptanceCriteria
- * AND have complex/expert complexity. Saves the PRD once after all decompositions.
- */
-export async function decomposeOversized(options: { featureDir: string; config: NaxConfig }): Promise<void> {
-  const { featureDir, config } = options;
-  const logger = getLogger();
-
-  const { prd, prdPath } = await _decomposeCLIDeps.loadPRD(featureDir);
-
-  const threshold = config.decompose?.maxAcceptanceCriteria ?? 6;
-  const oversized = prd.userStories.filter((s) => {
-    const complexity = s.routing?.complexity;
-    return s.acceptanceCriteria.length > threshold && (complexity === "complex" || complexity === "expert");
-  });
-
-  if (oversized.length === 0) {
-    logger.info("cli", "No oversized stories found");
-    return;
-  }
-
-  const allSubStories: SubStory[] = [];
-  let anyDecomposed = false;
-
-  for (const story of oversized) {
-    const result = await _decomposeCLIDeps.runDecompose(story, prd, config, featureDir);
-    if (result.validation.valid) {
-      _decomposeCLIDeps.applyDecomposition(prd, result);
-      allSubStories.push(...result.subStories);
-      anyDecomposed = true;
-    } else {
-      logger.warn("cli", `Decompose failed for ${story.id}: ${result.validation.errors.join(", ")}`);
-    }
-  }
-
-  if (anyDecomposed) {
-    await _decomposeCLIDeps.savePRD(prd, prdPath);
-  }
-
-  if (allSubStories.length > 0) {
-    const lines = buildSummaryLines(allSubStories);
-    _decomposeCLIDeps.printSummary(lines);
-  }
-}

package/src/cli/config-descriptions.ts

@@ -1,219 +0,0 @@
-/**
- * Configuration Field Descriptions
- *
- * Human-readable descriptions for all configuration fields.
- * Extracted from config-display.ts for better maintainability.
- */
-
-export const FIELD_DESCRIPTIONS: Record<string, string> = {
-  // Top-level
-  version: "Configuration schema version",
-
-  // Models
-  models: "Model tier definitions (fast/balanced/powerful)",
-  "models.fast": "Fast model for lightweight tasks (e.g., haiku)",
-  "models.balanced": "Balanced model for general coding (e.g., sonnet)",
-  "models.powerful": "Powerful model for complex tasks (e.g., opus)",
-
-  // Auto mode
-  autoMode:
-    "Auto mode configuration for agent orchestration. Enables multi-agent routing with model tier selection per task complexity and escalation on failures.",
-  "autoMode.enabled": "Enable automatic agent selection and escalation",
-  "autoMode.defaultAgent":
-    "Default agent to use when no specific agent is requested. Examples: 'claude' (Claude Code), 'codex' (GitHub Copilot), 'opencode' (OpenCode). The agent handles the main coding tasks.",
-  "autoMode.fallbackOrder":
-    'Fallback order for agent selection when the primary agent is rate-limited, unavailable, or fails. Tries each agent in sequence until one succeeds. Example: ["claude", "codex", "opencode"] means try Claude first, then Copilot, then OpenCode.',
-  "autoMode.complexityRouting":
-    "Model tier routing rules mapped to story complexity levels. Determines which model (fast/balanced/powerful) to use based on task complexity: simple → fast, medium → balanced, complex → powerful, expert → powerful.",
-  "autoMode.complexityRouting.simple": "Model tier for simple tasks (low complexity, straightforward changes)",
-  "autoMode.complexityRouting.medium": "Model tier for medium tasks (moderate complexity, multi-file changes)",
-  "autoMode.complexityRouting.complex": "Model tier for complex tasks (high complexity, architectural decisions)",
-  "autoMode.complexityRouting.expert":
-    "Model tier for expert tasks (highest complexity, novel problems, design patterns)",
-  "autoMode.escalation":
-    "Escalation settings for failed stories. When a story fails after max attempts at current tier, escalate to the next tier in tierOrder. Enables progressive use of more powerful models.",
-  "autoMode.escalation.enabled": "Enable tier escalation on failure",
-  "autoMode.escalation.tierOrder":
-    'Ordered tier escalation chain with per-tier attempt budgets. Format: [{"tier": "fast", "attempts": 2}, {"tier": "balanced", "attempts": 2}, {"tier": "powerful", "attempts": 1}]. Allows each tier to attempt fixes before escalating to the next.',
-  "autoMode.escalation.escalateEntireBatch":
-    "When enabled, escalate all stories in a batch if one fails. When disabled, only the failing story escalates (allows parallel attempts at different tiers).",
-
-  // Routing
-  routing: "Model routing strategy configuration",
-  "routing.strategy": "Routing strategy: keyword | llm | manual | adaptive | custom",
-  "routing.customStrategyPath": "Path to custom routing strategy (if strategy=custom)",
-  "routing.adaptive": "Adaptive routing settings",
-  "routing.adaptive.minSamples": "Minimum samples before adaptive routing activates",
-  "routing.adaptive.costThreshold": "Cost threshold for strategy switching (0-1)",
-  "routing.adaptive.fallbackStrategy": "Fallback strategy if adaptive fails",
-  "routing.llm": "LLM-based routing settings",
-  "routing.llm.model": "Model tier for routing decisions",
-  "routing.llm.fallbackToKeywords": "Fall back to keyword routing on LLM failure",
-  "routing.llm.cacheDecisions": "Cache routing decisions per story ID",
-  "routing.llm.mode": "Routing mode: one-shot | per-story | hybrid",
-  "routing.llm.timeoutMs": "Timeout for LLM routing call in milliseconds",
-
-  // Execution
-  execution: "Execution limits and timeouts",
-  "execution.maxIterations": "Max iterations per feature run (auto-calculated if not set)",
-  "execution.iterationDelayMs": "Delay between iterations in milliseconds",
-  "execution.costLimit": "Max cost in USD before pausing execution",
-  "execution.sessionTimeoutSeconds": "Timeout per agent coding session in seconds",
-  "execution.verificationTimeoutSeconds": "Verification subprocess timeout in seconds",
-  "execution.maxStoriesPerFeature": "Max stories per feature (prevents memory exhaustion)",
-  "execution.contextProviderTokenBudget": "Token budget for plugin context providers",
-  "execution.lintCommand": "Lint command override (null=disabled, undefined=auto-detect)",
-  "execution.typecheckCommand": "Typecheck command override (null=disabled, undefined=auto-detect)",
-  "execution.dangerouslySkipPermissions": "Skip permissions for agent (use with caution)",
-  "execution.rectification": "Rectification loop settings (retry failed tests)",
-  "execution.rectification.enabled": "Enable rectification loop",
-  "execution.rectification.maxRetries": "Max retry attempts per story",
-  "execution.rectification.fullSuiteTimeoutSeconds": "Timeout for full test suite run in seconds",
-  "execution.rectification.maxFailureSummaryChars": "Max characters in failure summary",
-  "execution.rectification.abortOnIncreasingFailures": "Abort if failure count increases",
-  "execution.regressionGate": "Regression gate settings (full suite after scoped tests)",
-  "execution.regressionGate.enabled": "Enable full-suite regression gate",
-  "execution.regressionGate.timeoutSeconds": "Timeout for regression run in seconds",
-
-  // Quality
-  quality: "Quality gate configuration",
-  "quality.requireTypecheck": "Require typecheck to pass",
-  "quality.requireLint": "Require lint to pass",
-  "quality.requireTests": "Require tests to pass",
-  "quality.commands": "Custom quality commands",
-  "quality.commands.typecheck": "Custom typecheck command",
-  "quality.commands.lint": "Custom lint command",
-  "quality.commands.test": "Custom test command",
-  "quality.forceExit": "Append --forceExit to test command (prevents hangs)",
-  "quality.detectOpenHandles": "Append --detectOpenHandles on timeout",
-  "quality.detectOpenHandlesRetries": "Max retries with --detectOpenHandles",
-  "quality.gracePeriodMs": "Grace period in ms after SIGTERM before SIGKILL",
-  "quality.drainTimeoutMs": "Deadline in ms to drain stdout/stderr after kill",
-  "quality.shell": "Shell to use for verification commands",
-  "quality.stripEnvVars": "Environment variables to strip during verification",
-  "quality.environmentalEscalationDivisor": "Divisor for environmental failure early escalation",
-
-  // TDD
-  tdd: "Test-driven development configuration",
-  "tdd.maxRetries": "Max retries per TDD session before escalating",
-  "tdd.autoVerifyIsolation": "Auto-verify test isolation between sessions",
-  "tdd.strategy": "TDD strategy: auto | strict | lite | off",
-  "tdd.autoApproveVerifier": "Auto-approve legitimate fixes in verifier session",
-  "tdd.sessionTiers": "Per-session model tier overrides",
-  "tdd.sessionTiers.testWriter": "Model tier for test-writer session",
-  "tdd.sessionTiers.implementer": "Model tier for implementer session",
-  "tdd.sessionTiers.verifier": "Model tier for verifier session",
-  "tdd.testWriterAllowedPaths": "Glob patterns for files test-writer can modify",
-  "tdd.rollbackOnFailure": "Rollback git changes when TDD fails",
-  "tdd.greenfieldDetection": "Force test-after on projects with no test files",
-
-  // Constitution
-  constitution: "Constitution settings (core rules and constraints)",
-  "constitution.enabled": "Enable constitution loading and injection",
-  "constitution.path": "Path to constitution file (relative to nax/ directory)",
-  "constitution.maxTokens": "Maximum tokens allowed for constitution content",
-  "constitution.skipGlobal": "Skip loading global constitution",
-
-  // Analyze
-  analyze: "Feature analysis settings",
-  "analyze.llmEnhanced": "Enable LLM-enhanced analysis",
-  "analyze.model": "Model tier for decompose and classify",
-  "analyze.fallbackToKeywords": "Fall back to keyword matching on LLM failure",
-  "analyze.maxCodebaseSummaryTokens": "Max tokens for codebase summary",
-
-  // Review
-  review: "Review phase configuration",
-  "review.enabled": "Enable review phase",
-  "review.checks": "List of checks to run (typecheck, lint, test)",
-  "review.commands": "Custom commands per check",
-  "review.commands.typecheck": "Custom typecheck command for review",
-  "review.commands.lint": "Custom lint command for review",
-  "review.commands.test": "Custom test command for review",
-
-  // Plan
-  plan: "Planning phase configuration",
-  "plan.model": "Model tier for planning",
-  "plan.outputPath": "Output path for generated spec (relative to nax/)",
-
-  // Acceptance
-  acceptance: "Acceptance test configuration",
-  "acceptance.enabled": "Enable acceptance test generation and validation",
-  "acceptance.maxRetries": "Max retry loops for fix stories",
-  "acceptance.generateTests": "Generate acceptance tests during analyze",
-  "acceptance.testPath": "Path to acceptance test file (relative to feature dir)",
-  "acceptance.timeoutMs": "Timeout for acceptance test generation in milliseconds (default: 1800000 = 30 min)",
-
-  // Context
-  context: "Context injection configuration",
-  "context.fileInjection":
-    "Mode: 'disabled' (default, MCP-aware agents pull context on-demand) | 'keyword' (legacy git-grep injection for non-MCP agents). Set context.fileInjection in config.",
-  "context.testCoverage": "Test coverage context settings",
-  "context.testCoverage.enabled": "Enable test coverage context injection",
-  "context.testCoverage.detail": "Detail level: names-only | names-and-counts | describe-blocks",
-  "context.testCoverage.maxTokens": "Max tokens for test summary",
-  "context.testCoverage.testDir": "Test directory relative to workdir",
-  "context.testCoverage.testPattern": "Glob pattern for test files",
-  "context.testCoverage.scopeToStory": "Scope test coverage to story-relevant files only",
-  "context.autoDetect": "Auto-detect relevant files settings",
-  "context.autoDetect.enabled": "Enable auto-detection of relevant files",
-  "context.autoDetect.maxFiles": "Max files to auto-detect",
-  "context.autoDetect.traceImports": "Trace imports to find related files",
-
-  // Optimizer
-  optimizer: "Prompt optimizer configuration",
-  "optimizer.enabled": "Enable prompt optimizer",
-  "optimizer.strategy": "Optimization strategy: rule-based | llm | noop",
-
-  // Plugins
-  plugins: "Plugin configurations",
-
-  // Hooks
-  hooks: "Hooks configuration",
-  "hooks.skipGlobal": "Skip loading global hooks",
-
-  // Interaction
-  interaction: "Interaction plugin configuration",
-  "interaction.plugin": "Plugin to use for interactions (default: cli)",
-  "interaction.config": "Plugin-specific configuration",
-  "interaction.defaults": "Default interaction settings",
-  "interaction.defaults.timeout": "Default timeout in milliseconds",
-  "interaction.defaults.fallback": "Default fallback behavior: continue | skip | escalate | abort",
-  "interaction.triggers": "Enable/disable built-in triggers",
-
-  // Precheck
-  precheck: "Precheck configuration (run before analysis)",
-  "precheck.storySizeGate": "Story size gate settings",
-  "precheck.storySizeGate.enabled": "Enable story size gate",
-  "precheck.storySizeGate.maxAcCount": "Max acceptance criteria count before flagging",
-  "precheck.storySizeGate.maxDescriptionLength": "Max description character length before flagging",
-  "precheck.storySizeGate.maxBulletPoints": "Max bullet point count before flagging",
-
-  // Prompts
-  prompts: "Prompt template overrides (PB-003: PromptBuilder)",
-  "prompts.overrides": "Custom prompt template files for specific roles",
-  "prompts.overrides.test-writer": 'Path to custom test-writer prompt (e.g., ".nax/prompts/test-writer.md")',
-  "prompts.overrides.implementer": 'Path to custom implementer prompt (e.g., ".nax/prompts/implementer.md")',
-  "prompts.overrides.verifier": 'Path to custom verifier prompt (e.g., ".nax/prompts/verifier.md")',
-  "prompts.overrides.single-session": 'Path to custom single-session prompt (e.g., ".nax/prompts/single-session.md")',
-
-  // Decompose
-  decompose: "Story decomposition configuration (SD-003)",
-  "decompose.trigger": "Decomposition trigger mode: auto | confirm | disabled",
-  "decompose.maxAcceptanceCriteria": "Max acceptance criteria before flagging as oversized (default: 6)",
-  "decompose.maxSubstories": "Max number of substories to generate (default: 5)",
-  "decompose.maxSubstoryComplexity": "Max complexity for any generated substory (default: 'medium')",
-  "decompose.maxRetries": "Max retries on decomposition validation failure (default: 2)",
-  "decompose.model": "Model tier for decomposition LLM calls (default: 'balanced')",
-
-  // Agent protocol
-  agent: "Agent protocol configuration (ACP-003)",
-  "agent.protocol": "Protocol for agent communication: 'acp' | 'cli' (default: 'acp')",
-  "agent.maxInteractionTurns":
-    "Max turns in multi-turn interaction loop when interactionBridge is active (default: 10)",
-  // quality.testing (ENH-010) — per-package overridable
-  "quality.testing": "Hermetic test enforcement — per-package overridable (ENH-010)",
-  "quality.testing.hermetic":
-    "Inject hermetic test requirement into prompts — never call real external services in tests (default: true)",
-  "quality.testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
-  "quality.testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt",
-};

package/src/cli/config-diff.ts

@@ -1,103 +0,0 @@
-/**
- * Config Diffing
- *
- * Compare global and project configurations.
- */
-
-/**
- * Represents a single config field difference.
- */
-export interface ConfigDiff {
-  /** Dot-separated field path (e.g., "execution.maxIterations") */
-  path: string;
-  /** Value from global config */
-  globalValue: unknown;
-  /** Value from project config */
-  projectValue: unknown;
-}
-
-/**
- * Deep diff two config objects, returning only fields that differ.
- *
- * @param global - Global config (defaults + global overrides)
- * @param project - Project config (raw overrides only)
- * @param currentPath - Current path in object tree (for recursion)
- * @returns Array of differences
- */
-export function deepDiffConfigs(
-  global: Record<string, unknown>,
-  project: Record<string, unknown>,
-  currentPath: string[] = [],
-): ConfigDiff[] {
-  const diffs: ConfigDiff[] = [];
-
-  // Iterate over project config keys (we only care about what project overrides)
-  for (const key of Object.keys(project)) {
-    const projectValue = project[key];
-    const globalValue = global[key];
-    const path = [...currentPath, key];
-    const pathStr = path.join(".");
-
-    // Handle nested objects
-    if (
-      projectValue !== null &&
-      typeof projectValue === "object" &&
-      !Array.isArray(projectValue) &&
-      globalValue !== null &&
-      typeof globalValue === "object" &&
-      !Array.isArray(globalValue)
-    ) {
-      // Recurse into nested object
-      const nestedDiffs = deepDiffConfigs(
-        globalValue as Record<string, unknown>,
-        projectValue as Record<string, unknown>,
-        path,
-      );
-      diffs.push(...nestedDiffs);
-    } else {
-      // Compare primitive values or arrays
-      if (!deepEqual(projectValue, globalValue)) {
-        diffs.push({
-          path: pathStr,
-          globalValue,
-          projectValue,
-        });
-      }
-    }
-  }
-
-  return diffs;
-}
-
-/**
- * Deep equality check for two values.
- *
- * @param a - First value
- * @param b - Second value
- * @returns True if values are deeply equal
- */
-export function deepEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (a === undefined || b === undefined) return false;
-
-  // Handle arrays
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, idx) => deepEqual(val, b[idx]));
-  }
-
-  // Handle objects
-  if (typeof a === "object" && typeof b === "object") {
-    const aObj = a as Record<string, unknown>;
-    const bObj = b as Record<string, unknown>;
-    const aKeys = Object.keys(aObj);
-    const bKeys = Object.keys(bObj);
-
-    if (aKeys.length !== bKeys.length) return false;
-
-    return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
-  }
-
-  return false;
-}