@nathapp/nax 0.50.2 → 0.51.0

package/src/agents/cost/pricing.ts

@@ -1,59 +0,0 @@
-/**
- * Cost rate tables for all supported model tiers and specific models.
- */
-
-import type { ModelTier } from "../../config/schema";
-import type { ModelCostRates } from "./types";
-
-/** Model tier cost rates (as of 2025-01) */
-export const COST_RATES: Record<ModelTier, ModelCostRates> = {
-  fast: {
-    // Haiku 4.5
-    inputPer1M: 0.8,
-    outputPer1M: 4.0,
-  },
-  balanced: {
-    // Sonnet 4.5
-    inputPer1M: 3.0,
-    outputPer1M: 15.0,
-  },
-  powerful: {
-    // Opus 4
-    inputPer1M: 15.0,
-    outputPer1M: 75.0,
-  },
-};
-
-/** Per-model pricing in $/1M tokens: { input, output } */
-export const MODEL_PRICING: Record<
-  string,
-  { input: number; output: number; cacheRead?: number; cacheCreation?: number }
-> = {
-  // Anthropic Claude models (short aliases)
-  sonnet: { input: 3, output: 15 },
-  haiku: { input: 0.8, output: 4.0, cacheRead: 0.1, cacheCreation: 1.0 },
-  opus: { input: 15, output: 75 },
-
-  // Anthropic Claude models (full names)
-  "claude-sonnet-4": { input: 3, output: 15 },
-  "claude-sonnet-4-5": { input: 3, output: 15 },
-  "claude-sonnet-4-6": { input: 3, output: 15 },
-  "claude-haiku": { input: 0.8, output: 4.0, cacheRead: 0.1, cacheCreation: 1.0 },
-  "claude-haiku-4-5": { input: 0.8, output: 4.0, cacheRead: 0.1, cacheCreation: 1.0 },
-  "claude-opus": { input: 15, output: 75 },
-  "claude-opus-4": { input: 15, output: 75 },
-  "claude-opus-4-6": { input: 15, output: 75 },
-
-  // OpenAI models
-  "gpt-4.1": { input: 10, output: 30 },
-  "gpt-4": { input: 30, output: 60 },
-  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
-
-  // Google Gemini
-  "gemini-2.5-pro": { input: 0.075, output: 0.3 },
-  "gemini-2-pro": { input: 0.075, output: 0.3 },
-
-  // OpenAI Codex
-  codex: { input: 0.02, output: 0.06 },
-  "code-davinci-002": { input: 0.02, output: 0.06 },
-};

package/src/agents/cost/types.ts

@@ -1,45 +0,0 @@
-/**
- * Cost tracking types — shared across all agent adapters.
- */
-
-import type { ModelTier } from "../../config/schema";
-
-export type { ModelTier };
-
-/** Cost rates per 1M tokens (USD) */
-export interface ModelCostRates {
-  inputPer1M: number;
-  outputPer1M: number;
-}
-
-/** Token usage data (camelCase — nax-internal representation) */
-export interface TokenUsage {
-  inputTokens: number;
-  outputTokens: number;
-}
-
-/** Cost estimate with confidence indicator */
-export interface CostEstimate {
-  cost: number;
-  confidence: "exact" | "estimated" | "fallback";
-}
-
-/** Token usage with confidence indicator */
-export interface TokenUsageWithConfidence {
-  inputTokens: number;
-  outputTokens: number;
-  confidence: "exact" | "estimated";
-}
-
-/**
- * Token usage from an ACP session's cumulative_token_usage field.
- * Uses snake_case to match the ACP wire format.
- */
-export interface SessionTokenUsage {
-  input_tokens: number;
-  output_tokens: number;
-  /** Cache read tokens — billed at a reduced rate */
-  cache_read_input_tokens?: number;
-  /** Cache creation tokens — billed at a higher creation rate */
-  cache_creation_input_tokens?: number;
-}

package/src/agents/gemini/adapter.ts

@@ -1,177 +0,0 @@
-/**
- * Gemini CLI Agent Adapter — implements AgentAdapter interface
- *
- * Provides uniform interface for spawning Gemini CLI processes,
- * supporting one-shot completions via 'gemini -p' and Google auth detection.
- */
-
-import type {
-  AgentAdapter,
-  AgentCapabilities,
-  AgentResult,
-  AgentRunOptions,
-  CompleteOptions,
-  DecomposeOptions,
-  DecomposeResult,
-  PlanOptions,
-  PlanResult,
-} from "../types";
-import { CompleteError } from "../types";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Injectable dependencies — follows the _deps pattern
-// Replaced in unit tests to intercept Bun.spawn/Bun.which calls.
-// ─────────────────────────────────────────────────────────────────────────────
-
-export const _geminiRunDeps = {
-  which(name: string): string | null {
-    return Bun.which(name);
-  },
-  spawn(
-    cmd: string[],
-    opts: { cwd?: string; stdout: "pipe"; stderr: "pipe" | "inherit"; env?: Record<string, string | undefined> },
-  ): {
-    stdout: ReadableStream<Uint8Array>;
-    stderr: ReadableStream<Uint8Array>;
-    exited: Promise<number>;
-    pid: number;
-    kill(signal?: number | NodeJS.Signals): void;
-  } {
-    return Bun.spawn(cmd, opts) as unknown as {
-      stdout: ReadableStream<Uint8Array>;
-      stderr: ReadableStream<Uint8Array>;
-      exited: Promise<number>;
-      pid: number;
-      kill(signal?: number | NodeJS.Signals): void;
-    };
-  },
-};
-
-export const _geminiCompleteDeps = {
-  spawn(
-    cmd: string[],
-    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
-  ): {
-    stdout: ReadableStream<Uint8Array>;
-    stderr: ReadableStream<Uint8Array>;
-    exited: Promise<number>;
-    pid: number;
-  } {
-    return Bun.spawn(cmd, opts) as unknown as {
-      stdout: ReadableStream<Uint8Array>;
-      stderr: ReadableStream<Uint8Array>;
-      exited: Promise<number>;
-      pid: number;
-    };
-  },
-};
-
-// ─────────────────────────────────────────────────────────────────────────────
-// GeminiAdapter implementation
-// ─────────────────────────────────────────────────────────────────────────────
-
-const MAX_AGENT_OUTPUT_CHARS = 5000;
-
-export class GeminiAdapter implements AgentAdapter {
-  readonly name = "gemini";
-  readonly displayName = "Gemini CLI";
-  readonly binary = "gemini";
-
-  readonly capabilities: AgentCapabilities = {
-    supportedTiers: ["fast", "balanced", "powerful"],
-    maxContextTokens: 1_000_000,
-    features: new Set<"tdd" | "review" | "refactor" | "batch">(["tdd", "review", "refactor"]),
-  };
-
-  async isInstalled(): Promise<boolean> {
-    const path = _geminiRunDeps.which("gemini");
-    if (path === null) {
-      return false;
-    }
-
-    // Check Google auth — run 'gemini' with a flag that shows auth status
-    try {
-      const proc = _geminiRunDeps.spawn(["gemini", "--version"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        return false;
-      }
-
-      const stdout = await new Response(proc.stdout).text();
-      const lowerOut = stdout.toLowerCase();
-
-      // If output explicitly says "not logged in", auth has failed
-      if (lowerOut.includes("not logged in")) {
-        return false;
-      }
-
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  buildCommand(options: AgentRunOptions): string[] {
-    return ["gemini", "-p", options.prompt];
-  }
-
-  async run(options: AgentRunOptions): Promise<AgentResult> {
-    const cmd = this.buildCommand(options);
-    const startTime = Date.now();
-
-    const proc = _geminiRunDeps.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "inherit",
-    });
-
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const durationMs = Date.now() - startTime;
-
-    return {
-      success: exitCode === 0,
-      exitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
-      rateLimited: false,
-      durationMs,
-      estimatedCost: 0,
-      pid: proc.pid,
-    };
-  }
-
-  async complete(prompt: string, _options?: CompleteOptions): Promise<string> {
-    const cmd = ["gemini", "-p", prompt];
-
-    const proc = _geminiCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
-    const exitCode = await proc.exited;
-
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const trimmed = stdout.trim();
-
-    if (exitCode !== 0) {
-      const errorDetails = stderr.trim() || trimmed;
-      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
-      throw new CompleteError(errorMessage, exitCode);
-    }
-
-    if (!trimmed) {
-      throw new CompleteError("complete() returned empty output");
-    }
-
-    return trimmed;
-  }
-
-  async plan(_options: PlanOptions): Promise<PlanResult> {
-    throw new Error("GeminiAdapter.plan() not implemented");
-  }
-
-  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
-    throw new Error("GeminiAdapter.decompose() not implemented");
-  }
-}

package/src/agents/index.ts

@@ -1,18 +0,0 @@
-export type { AgentAdapter, AgentCapabilities, AgentResult, AgentRunOptions, CompleteOptions } from "./types";
-export { CompleteError } from "./types";
-export { ClaudeCodeAdapter } from "./claude";
-export { getAllAgentNames, getAgent, getInstalledAgents, checkAgentHealth } from "./registry";
-export type { ModelCostRates, TokenUsage, CostEstimate, TokenUsageWithConfidence, SessionTokenUsage } from "./cost";
-export {
-  COST_RATES,
-  MODEL_PRICING,
-  parseTokenUsage,
-  estimateCost,
-  estimateCostFromOutput,
-  estimateCostByDuration,
-  formatCostWithConfidence,
-  estimateCostFromTokenUsage,
-} from "./cost";
-export { validateAgentForTier, validateAgentFeature, describeAgentCapabilities } from "./shared/validation";
-export type { AgentVersionInfo } from "./shared/version-detection";
-export { getAgentVersion, getAgentVersions } from "./shared/version-detection";

package/src/agents/opencode/adapter.ts

@@ -1,106 +0,0 @@
-/**
- * OpenCode Agent Adapter — implements AgentAdapter interface
- *
- * Provides uniform interface for spawning OpenCode agent processes,
- * supporting one-shot completions.
- */
-
-import type {
-  AgentAdapter,
-  AgentCapabilities,
-  AgentResult,
-  AgentRunOptions,
-  CompleteOptions,
-  DecomposeOptions,
-  DecomposeResult,
-  PlanOptions,
-  PlanResult,
-} from "../types";
-import { CompleteError } from "../types";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Injectable dependencies — matches the _deps pattern used in claude.ts
-// These are replaced in unit tests to intercept Bun.spawn calls.
-// ─────────────────────────────────────────────────────────────────────────────
-
-export const _opencodeCompleteDeps = {
-  which(name: string): string | null {
-    return Bun.which(name);
-  },
-  spawn(
-    cmd: string[],
-    opts: { stdout: "pipe"; stderr: "pipe" | "inherit" },
-  ): {
-    stdout: ReadableStream<Uint8Array>;
-    stderr: ReadableStream<Uint8Array>;
-    exited: Promise<number>;
-    pid: number;
-  } {
-    return Bun.spawn(cmd, opts) as unknown as {
-      stdout: ReadableStream<Uint8Array>;
-      stderr: ReadableStream<Uint8Array>;
-      exited: Promise<number>;
-      pid: number;
-    };
-  },
-};
-
-// ─────────────────────────────────────────────────────────────────────────────
-// OpenCodeAdapter implementation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export class OpenCodeAdapter implements AgentAdapter {
-  readonly name = "opencode";
-  readonly displayName = "OpenCode";
-  readonly binary = "opencode";
-
-  readonly capabilities: AgentCapabilities = {
-    supportedTiers: ["fast", "balanced"],
-    maxContextTokens: 8_000,
-    features: new Set<"tdd" | "review" | "refactor" | "batch">(["tdd", "refactor"]),
-  };
-
-  async isInstalled(): Promise<boolean> {
-    const path = _opencodeCompleteDeps.which("opencode");
-    return path !== null;
-  }
-
-  buildCommand(_options: AgentRunOptions): string[] {
-    throw new Error("OpenCodeAdapter.buildCommand() not implemented");
-  }
-
-  async run(_options: AgentRunOptions): Promise<AgentResult> {
-    throw new Error("OpenCodeAdapter.run() not implemented");
-  }
-
-  async complete(prompt: string, _options?: CompleteOptions): Promise<string> {
-    const cmd = ["opencode", "--prompt", prompt];
-
-    const proc = _opencodeCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
-    const exitCode = await proc.exited;
-
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const trimmed = stdout.trim();
-
-    if (exitCode !== 0) {
-      const errorDetails = stderr.trim() || trimmed;
-      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
-      throw new CompleteError(errorMessage, exitCode);
-    }
-
-    if (!trimmed) {
-      throw new CompleteError("complete() returned empty output");
-    }
-
-    return trimmed;
-  }
-
-  async plan(_options: PlanOptions): Promise<PlanResult> {
-    throw new Error("OpenCodeAdapter.plan() not implemented");
-  }
-
-  async decompose(_options: DecomposeOptions): Promise<DecomposeResult> {
-    throw new Error("OpenCodeAdapter.decompose() not implemented");
-  }
-}

package/src/agents/registry.ts

@@ -1,136 +0,0 @@
-/**
- * Agent Registry
- *
- * Discovers and manages available coding agents.
- */
-
-import type { NaxConfig } from "../config/schema";
-import { getLogger } from "../logger";
-import { AcpAgentAdapter } from "./acp/adapter";
-import { AiderAdapter } from "./aider/adapter";
-import { ClaudeCodeAdapter } from "./claude/adapter";
-import { CodexAdapter } from "./codex/adapter";
-import { GeminiAdapter } from "./gemini/adapter";
-import { OpenCodeAdapter } from "./opencode/adapter";
-import type { AgentAdapter } from "./types";
-
-/** All known agent adapters */
-export const ALL_AGENTS: AgentAdapter[] = [
-  new ClaudeCodeAdapter(),
-  new CodexAdapter(),
-  new OpenCodeAdapter(),
-  new GeminiAdapter(),
-  new AiderAdapter(),
-];
-
-/** Get all registered agent names */
-export function getAllAgentNames(): string[] {
-  return ALL_AGENTS.map((a) => a.name);
-}
-
-/** Get a specific agent by name */
-export function getAgent(name: string): AgentAdapter | undefined {
-  return ALL_AGENTS.find((a) => a.name === name);
-}
-
-/** Get all installed agents on this machine */
-export async function getInstalledAgents(): Promise<AgentAdapter[]> {
-  const results = await Promise.all(
-    ALL_AGENTS.map(async (agent) => ({
-      agent,
-      installed: await agent.isInstalled(),
-    })),
-  );
-  return results.filter((r) => r.installed).map((r) => r.agent);
-}
-
-/** Check health of all agents */
-export async function checkAgentHealth(): Promise<Array<{ name: string; displayName: string; installed: boolean }>> {
-  return Promise.all(
-    ALL_AGENTS.map(async (agent) => ({
-      name: agent.name,
-      displayName: agent.displayName,
-      installed: await agent.isInstalled(),
-    })),
-  );
-}
-
-/** Protocol-aware agent registry returned by createAgentRegistry() */
-export interface AgentRegistry {
-  /** Get a specific agent, respecting the configured protocol */
-  getAgent(name: string): AgentAdapter | undefined;
-  /** Get all installed agents */
-  getInstalledAgents(): Promise<AgentAdapter[]>;
-  /** Check health of all agents */
-  checkAgentHealth(): Promise<Array<{ name: string; displayName: string; installed: boolean }>>;
-  /** Active protocol ('acp' | 'cli') */
-  protocol: "acp" | "cli";
-}
-
-/**
- * Create a protocol-aware agent registry.
- *
- * When config.agent.protocol is 'acp', returns AcpAgentAdapter instances.
- * When 'cli' (or unset), returns legacy CLI adapters.
- * AcpAgentAdapter instances are cached per agent name for the lifetime of the registry.
- */
-export function createAgentRegistry(config: NaxConfig): AgentRegistry {
-  const protocol: "acp" | "cli" = config.agent?.protocol ?? "cli";
-  const logger = getLogger();
-  const acpCache = new Map<string, AcpAgentAdapter>();
-
-  // Log which protocol is being used at startup
-  logger?.info("agents", `Agent protocol: ${protocol}`, { protocol, hasConfig: !!config.agent });
-
-  function getAgent(name: string): AgentAdapter | undefined {
-    if (protocol === "acp") {
-      const known = ALL_AGENTS.find((a) => a.name === name);
-      if (!known) return undefined;
-      if (!acpCache.has(name)) {
-        acpCache.set(name, new AcpAgentAdapter(name));
-        logger?.debug("agents", `Created AcpAgentAdapter for ${name}`, { name, protocol });
-      }
-      return acpCache.get(name);
-    }
-    const adapter = ALL_AGENTS.find((a) => a.name === name);
-    if (adapter) {
-      logger?.debug("agents", `Using CLI adapter for ${name}: ${adapter.constructor.name}`, { name });
-    }
-    return adapter;
-  }
-
-  async function getInstalledAgents(): Promise<AgentAdapter[]> {
-    const agents =
-      protocol === "acp"
-        ? ALL_AGENTS.map((a) => {
-            if (!acpCache.has(a.name)) {
-              acpCache.set(a.name, new AcpAgentAdapter(a.name));
-            }
-            return acpCache.get(a.name) as AcpAgentAdapter;
-          })
-        : ALL_AGENTS;
-    const results = await Promise.all(agents.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
-    return results.filter((r) => r.installed).map((r) => r.agent);
-  }
-
-  async function checkAgentHealth(): Promise<Array<{ name: string; displayName: string; installed: boolean }>> {
-    const agents =
-      protocol === "acp"
-        ? ALL_AGENTS.map((a) => {
-            if (!acpCache.has(a.name)) {
-              acpCache.set(a.name, new AcpAgentAdapter(a.name));
-            }
-            return acpCache.get(a.name) as AcpAgentAdapter;
-          })
-        : ALL_AGENTS;
-    return Promise.all(
-      agents.map(async (agent) => ({
-        name: agent.name,
-        displayName: agent.displayName,
-        installed: await agent.isInstalled(),
-      })),
-    );
-  }
-
-  return { getAgent, getInstalledAgents, checkAgentHealth, protocol };
-}

package/src/agents/shared/decompose.ts

@@ -1,154 +0,0 @@
-/**
- * Claude Code Decompose Logic
- *
- * Extracted from claude.ts: decompose(), buildDecomposePrompt(),
- * parseDecomposeOutput(), validateComplexity()
- */
-
-import { COMPLEXITY_GUIDE, GROUPING_RULES, TEST_STRATEGY_GUIDE, resolveTestStrategy } from "../../config/test-strategy";
-import type { DecomposeOptions, DecomposeResult, DecomposedStory } from "../types";
-
-/**
- * Build the decompose prompt combining spec content and codebase context.
- */
-export function buildDecomposePrompt(options: DecomposeOptions): string {
-  return `You are a requirements analyst. Break down the following feature specification into user stories and classify each story's complexity.
-
-CODEBASE CONTEXT:
-${options.codebaseContext}
-
-FEATURE SPECIFICATION:
-${options.specContent}
-
-Decompose this spec into user stories. For each story, provide:
-1. id: Story ID (e.g., "US-001")
-2. title: Concise story title
-3. description: What needs to be implemented
-4. acceptanceCriteria: Array of testable criteria
-5. tags: Array of routing tags (e.g., ["security", "api"])
-6. dependencies: Array of story IDs this depends on (e.g., ["US-001"])
-7. complexity: "simple" | "medium" | "complex" | "expert"
-8. contextFiles: Array of file paths to inject into agent prompt before execution
-9. reasoning: Why this complexity level
-10. estimatedLOC: Estimated lines of code to change
-11. risks: Array of implementation risks
-12. testStrategy: "test-after" | "tdd-simple" | "three-session-tdd" | "three-session-tdd-lite"
-
-${COMPLEXITY_GUIDE}
-
-${TEST_STRATEGY_GUIDE}
-
-${GROUPING_RULES}
-
-Consider:
-1. Does infrastructure exist? (e.g., "add caching" when no cache layer exists = complex)
-2. How many files will be touched?
-3. Are there cross-cutting concerns (auth, validation, error handling)?
-4. Does it require new dependencies or architectural decisions?
-
-Respond with ONLY a JSON array (no markdown code fences):
-[{
-  "id": "US-001",
-  "title": "Story title",
-  "description": "Story description",
-  "acceptanceCriteria": ["Criterion 1", "Criterion 2"],
-  "tags": ["tag1"],
-  "dependencies": [],
-  "complexity": "medium",
-  "contextFiles": ["src/path/to/file.ts"],
-  "reasoning": "Why this complexity level",
-  "estimatedLOC": 150,
-  "risks": ["Risk 1"],
-  "testStrategy": "test-after"
-}]`;
-}
-
-/**
- * Parse decompose output from agent stdout.
- *
- * Extracts JSON array from output, handles markdown code fences,
- * and validates structure.
- */
-export function parseDecomposeOutput(output: string): DecomposedStory[] {
-  // Extract JSON from output (handles markdown code fences)
-  const jsonMatch = output.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
-  let jsonText = jsonMatch ? jsonMatch[1] : output;
-
-  // Try to find JSON array directly if no code fence
-  if (!jsonMatch) {
-    const arrayMatch = output.match(/\[[\s\S]*\]/);
-    if (arrayMatch) {
-      jsonText = arrayMatch[0];
-    }
-  }
-
-  // Parse JSON
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(jsonText.trim());
-  } catch (error) {
-    throw new Error(
-      `Failed to parse decompose output as JSON: ${(error as Error).message}\n\nOutput:\n${output.slice(0, 500)}`,
-    );
-  }
-
-  // Validate structure
-  if (!Array.isArray(parsed)) {
-    throw new Error("Decompose output is not an array");
-  }
-
-  // Map to DecomposedStory[] with validation
-  const stories: DecomposedStory[] = parsed.map((item: unknown, index: number) => {
-    // Type guard: ensure item is an object
-    if (typeof item !== "object" || item === null) {
-      throw new Error(`Story at index ${index} is not an object`);
-    }
-    const record = item as Record<string, unknown>;
-    if (!record.id || typeof record.id !== "string") {
-      throw new Error(`Story at index ${index} missing valid 'id' field`);
-    }
-    if (!record.title || typeof record.title !== "string") {
-      throw new Error(`Story ${record.id} missing valid 'title' field`);
-    }
-
-    return {
-      id: record.id,
-      title: record.title,
-      description: String(record.description || record.title),
-      acceptanceCriteria: Array.isArray(record.acceptanceCriteria)
-        ? record.acceptanceCriteria
-        : ["Implementation complete"],
-      tags: Array.isArray(record.tags) ? record.tags : [],
-      dependencies: Array.isArray(record.dependencies) ? record.dependencies : [],
-      complexity: coerceComplexity(record.complexity),
-      // contextFiles: prefer the new field; fall back to legacy relevantFiles from older LLM responses
-      contextFiles: Array.isArray(record.contextFiles)
-        ? record.contextFiles
-        : Array.isArray(record.relevantFiles)
-          ? record.relevantFiles
-          : [],
-      relevantFiles: Array.isArray(record.relevantFiles) ? record.relevantFiles : [],
-      reasoning: String(record.reasoning || "No reasoning provided"),
-      estimatedLOC: Number(record.estimatedLOC) || 0,
-      risks: Array.isArray(record.risks) ? record.risks : [],
-      testStrategy: resolveTestStrategy(typeof record.testStrategy === "string" ? record.testStrategy : undefined),
-    };
-  });
-
-  if (stories.length === 0) {
-    throw new Error("Decompose returned empty story array");
-  }
-
-  return stories;
-}
-
-/**
- * Coerce complexity value from decompose output.
- */
-export function coerceComplexity(value: unknown): "simple" | "medium" | "complex" | "expert" {
-  if (value === "simple" || value === "medium" || value === "complex" || value === "expert") {
-    return value;
-  }
-  // Default to medium if invalid
-  return "medium";
-}