@nathapp/nax 0.34.0 → 0.35.0

package/src/config/types.ts

@@ -7,7 +7,7 @@
 
 export type Complexity = "simple" | "medium" | "complex" | "expert";
 export type TestStrategy = "test-after" | "tdd-simple" | "three-session-tdd" | "three-session-tdd-lite";
-export type TddStrategy = "auto" | "strict" | "lite" | "off";
+export type TddStrategy = "auto" | "strict" | "lite" | "simple" | "off";
 
 export interface EscalationEntry {
   from: string;
@@ -125,6 +125,8 @@ export interface ExecutionConfig {
   /** Enable smart test runner to scope test runs to changed files (default: true).
    * Accepts boolean for backward compat or a SmartTestRunnerConfig object. */
   smartTestRunner?: boolean | SmartTestRunnerConfig;
+  /** Configured agent binary: claude, codex, opencode, gemini, aider (default: claude) */
+  agent?: string;
 }
 
 /** Quality gate config */

package/src/interaction/init.ts

@@ -41,18 +41,20 @@ function createInteractionPlugin(pluginName: string): InteractionPlugin {
 export async function initInteractionChain(config: NaxConfig, headless: boolean): Promise<InteractionChain | null> {
   const logger = getSafeLogger();
 
-  // If headless mode, skip interaction system
-  if (headless) {
-    logger?.debug("interaction", "Headless mode - skipping interaction system");
-    return null;
-  }
-
   // If no interaction config, skip
   if (!config.interaction) {
     logger?.debug("interaction", "No interaction config - skipping interaction system");
     return null;
   }
 
+  // In headless mode, skip CLI plugin only — it requires stdin (TTY).
+  // Telegram and Webhook plugins work via HTTP and don't need a TTY.
+  const pluginName = config.interaction.plugin;
+  if (headless && pluginName === "cli") {
+    logger?.debug("interaction", "Headless mode with CLI plugin - skipping interaction system (stdin unavailable)");
+    return null;
+  }
+
   // Create chain
   const chain = new InteractionChain({
     defaultTimeout: config.interaction.defaults.timeout,
@@ -60,7 +62,6 @@ export async function initInteractionChain(config: NaxConfig, headless: boolean)
   });
 
   // Create and register plugin
-  const pluginName = config.interaction.plugin;
   try {
     const plugin = createInteractionPlugin(pluginName);
     chain.register(plugin, 100);

package/src/interaction/plugins/auto.ts

@@ -6,6 +6,7 @@
  */
 
 import { z } from "zod";
+import type { AgentAdapter } from "../../agents/types";
 import type { NaxConfig } from "../../config";
 import { resolveModel } from "../../config";
 import type { InteractionPlugin, InteractionRequest, InteractionResponse } from "../types";
@@ -40,9 +41,12 @@ interface DecisionResponse {
 
 /**
  * Module-level deps for testability (_deps pattern).
- * Override callLlm in tests to avoid spawning the claude CLI.
+ * Override adapter in tests to mock adapter.complete() without spawning the claude CLI.
+ *
+ * For backward compatibility, also supports _deps.callLlm (deprecated).
  */
 export const _deps = {
+  adapter: null as AgentAdapter | null,
   callLlm: null as ((request: InteractionRequest) => Promise<DecisionResponse>) | null,
 };
 
@@ -71,7 +75,7 @@ export class AutoInteractionPlugin implements InteractionPlugin {
     // No-op — in-process plugin
   }
 
-  async receive(requestId: string, timeout = 60000): Promise<InteractionResponse> {
+  async receive(_requestId: string, _timeout = 60000): Promise<InteractionResponse> {
     // For auto plugin, we need to fetch the request from somewhere
     // In practice, the chain should pass the request to us
     // For now, throw an error since we need the full request
@@ -88,8 +92,23 @@ export class AutoInteractionPlugin implements InteractionPlugin {
     }
 
     try {
-      const callFn = _deps.callLlm ?? this.callLlm.bind(this);
-      const decision = await callFn(request);
+      // Use deprecated callLlm if provided (backward compatibility)
+      if (_deps.callLlm) {
+        const decision = await _deps.callLlm(request);
+        if (decision.confidence < (this.config.confidenceThreshold ?? 0.7)) {
+          return undefined;
+        }
+        return {
+          requestId: request.id,
+          action: decision.action,
+          value: decision.value,
+          respondedBy: "auto-ai",
+          respondedAt: Date.now(),
+        };
+      }
+
+      // Use new adapter-based path
+      const decision = await this.callLlm(request);
 
       // Check confidence threshold
       if (decision.confidence < (this.config.confidenceThreshold ?? 0.7)) {
@@ -114,34 +133,31 @@ export class AutoInteractionPlugin implements InteractionPlugin {
    */
   private async callLlm(request: InteractionRequest): Promise<DecisionResponse> {
     const prompt = this.buildPrompt(request);
-    const modelTier = this.config.model ?? "fast";
 
-    if (!this.config.naxConfig) {
-      throw new Error("Auto plugin requires naxConfig in init()");
+    // Get adapter from dependency injection or throw
+    const adapter = _deps.adapter;
+    if (!adapter) {
+      throw new Error("Auto plugin requires adapter to be injected via _deps.adapter");
     }
 
-    const modelEntry = this.config.naxConfig.models[modelTier];
-    if (!modelEntry) {
-      throw new Error(`Model tier "${modelTier}" not found in config.models`);
+    // Resolve model option if naxConfig is available
+    let modelArg: string | undefined;
+    if (this.config.naxConfig) {
+      const modelTier = this.config.model ?? "fast";
+      const modelEntry = this.config.naxConfig.models[modelTier];
+      if (!modelEntry) {
+        throw new Error(`Model tier "${modelTier}" not found in config.models`);
+      }
+      const modelDef = resolveModel(modelEntry);
+      modelArg = modelDef.model;
     }
 
-    const modelDef = resolveModel(modelEntry);
-    const modelArg = modelDef.model;
-
-    // Spawn claude CLI
-    const proc = Bun.spawn(["claude", "-p", prompt, "--model", modelArg], {
-      stdout: "pipe",
-      stderr: "pipe",
+    // Use adapter.complete() for one-shot LLM call
+    const output = await adapter.complete(prompt, {
+      ...(modelArg && { model: modelArg }),
+      jsonMode: true,
     });
 
-    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`claude CLI failed with exit code ${exitCode}: ${stderr}`);
-    }
-
-    const output = stdout.trim();
     return this.parseResponse(output);
   }
 

package/src/pipeline/stages/routing.ts

@@ -90,7 +90,10 @@ export const routingStage: PipelineStage = {
       routing = await _routingDeps.routeStory(ctx.story, { config: ctx.config }, ctx.workdir, ctx.plugins);
       // Override with cached values only when they are actually set
       if (ctx.story.routing?.complexity) routing.complexity = ctx.story.routing.complexity;
-      if (ctx.story.routing?.testStrategy) routing.testStrategy = ctx.story.routing.testStrategy;
+      // BUG-062: Only honor stored testStrategy for legacy/manual routing (no contentHash).
+      // When contentHash exists, the LLM strategy layer already recomputes testStrategy
+      // fresh via determineTestStrategy() — don't clobber it with the stale PRD value.
+      if (!hasContentHash && ctx.story.routing?.testStrategy) routing.testStrategy = ctx.story.routing.testStrategy;
       // BUG-032: Use escalated modelTier if explicitly set (by handleTierEscalation),
       // otherwise derive from complexity + current config
       if (ctx.story.routing?.modelTier) {

package/src/plugins/index.ts

@@ -9,6 +9,7 @@ export type {
   PluginType,
   PluginExtensions,
   PluginConfigEntry,
+  PluginLogger,
   IReviewPlugin,
   ReviewCheckResult,
   IContextProvider,
@@ -29,3 +30,4 @@ export type {
 export { validatePlugin } from "./validator";
 export { loadPlugins } from "./loader";
 export { PluginRegistry } from "./registry";
+export { createPluginLogger } from "./plugin-logger";

package/src/plugins/loader.ts

@@ -11,6 +11,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getSafeLogger as _getSafeLoggerFromModule } from "../logger";
 import { validateModulePath } from "../utils/path-security";
+import { createPluginLogger } from "./plugin-logger";
 import { PluginRegistry } from "./registry";
 import type { NaxPlugin, PluginConfigEntry } from "./types";
 import { validatePlugin } from "./validator";
@@ -272,10 +273,11 @@ async function loadAndValidatePlugin(
       return null;
     }
 
-    // Call setup() if defined
+    // Call setup() if defined — pass plugin-scoped logger
     if (validated.setup) {
       try {
-        await validated.setup(config);
+        const pluginLogger = createPluginLogger(validated.name);
+        await validated.setup(config, pluginLogger);
       } catch (error) {
         const logger = getSafeLogger();
         logger?.error("plugins", `Plugin '${validated.name}' setup failed`, { error });

package/src/plugins/plugin-logger.ts

@@ -0,0 +1,41 @@
+/**
+ * Plugin Logger Factory
+ *
+ * Creates write-only, stage-prefixed loggers for plugins.
+ * Each logger auto-tags entries with `plugin:<name>` so plugin
+ * output is filterable and cannot impersonate core stages.
+ *
+ * @module plugins/plugin-logger
+ */
+
+import { getSafeLogger } from "../logger";
+import type { PluginLogger } from "./types";
+
+/**
+ * Create a PluginLogger scoped to a plugin name.
+ *
+ * The returned logger delegates to the global nax Logger with
+ * `plugin:<pluginName>` as the stage. If the global logger is
+ * not initialized (e.g., during tests), calls are silently dropped.
+ *
+ * @param pluginName - Plugin name used as stage prefix
+ * @returns PluginLogger instance
+ */
+export function createPluginLogger(pluginName: string): PluginLogger {
+  const stage = `plugin:${pluginName}`;
+
+  return {
+    error(message: string, data?: Record<string, unknown>): void {
+      getSafeLogger()?.error(stage, message, data);
+    },
+    warn(message: string, data?: Record<string, unknown>): void {
+      getSafeLogger()?.warn(stage, message, data);
+    },
+    info(message: string, data?: Record<string, unknown>): void {
+      getSafeLogger()?.info(stage, message, data);
+    },
+    debug(message: string, data?: Record<string, unknown>): void {
+      getSafeLogger()?.debug(stage, message, data);
+    },
+  };
+}

package/src/plugins/types.ts

@@ -61,8 +61,9 @@ export interface NaxPlugin {
    * validating config, establishing connections, etc.
    *
    * @param config - Plugin-specific config from nax config.json
+   * @param logger - Write-only logger scoped to this plugin (stage auto-prefixed as `plugin:<name>`)
    */
-  setup?(config: Record<string, unknown>): Promise<void>;
+  setup?(config: Record<string, unknown>, logger: PluginLogger): Promise<void>;
 
   /**
    * Called when the nax run ends (success or failure).
@@ -333,6 +334,54 @@ export interface IReporter {
   onRunEnd?(event: RunEndEvent): Promise<void>;
 }
 
+// ============================================================================
+// Plugin Logger
+// ============================================================================
+
+/**
+ * Write-only, level-gated logger provided to plugins via setup().
+ *
+ * All log entries are auto-prefixed with `plugin:<name>` as the stage,
+ * so plugins cannot impersonate core nax stages. The interface is
+ * intentionally minimal — plugins only need to emit messages, not
+ * configure log levels or access log files.
+ *
+ * @example
+ * ```ts
+ * let log: PluginLogger;
+ *
+ * const myPlugin: NaxPlugin = {
+ *   name: "my-plugin",
+ *   version: "1.0.0",
+ *   provides: ["reviewer"],
+ *   async setup(config, logger) {
+ *     log = logger;
+ *     log.info("Initialized with config", { keys: Object.keys(config) });
+ *   },
+ *   extensions: {
+ *     reviewer: {
+ *       name: "my-check",
+ *       description: "Custom check",
+ *       async check(workdir, changedFiles) {
+ *         log.debug("Scanning files", { count: changedFiles.length });
+ *         // ...
+ *       }
+ *     }
+ *   }
+ * };
+ * ```
+ */
+export interface PluginLogger {
+  /** Log an error message */
+  error(message: string, data?: Record<string, unknown>): void;
+  /** Log a warning message */
+  warn(message: string, data?: Record<string, unknown>): void;
+  /** Log an informational message */
+  info(message: string, data?: Record<string, unknown>): void;
+  /** Log a debug message */
+  debug(message: string, data?: Record<string, unknown>): void;
+}
+
 // ============================================================================
 // Plugin Config
 // ============================================================================

package/src/precheck/checks-blockers.ts

@@ -162,10 +162,15 @@ export async function checkPRDValid(prd: PRD): Promise<Check> {
   };
 }
 
+/** Dependency injection for testability */
+export const _deps = {
+  spawn: Bun.spawn,
+};
+
 /** Check if Claude CLI is available. Uses: claude --version */
 export async function checkClaudeCLI(): Promise<Check> {
   try {
-    const proc = Bun.spawn(["claude", "--version"], {
+    const proc = _deps.spawn(["claude", "--version"], {
       stdout: "pipe",
       stderr: "pipe",
     });
@@ -192,6 +197,37 @@ export async function checkClaudeCLI(): Promise<Check> {
   }
 }
 
+/** Check if configured agent binary is available. Reads agent from config, defaults to 'claude'.
+ * Supports: claude, codex, opencode, gemini, aider */
+export async function checkAgentCLI(config: NaxConfig): Promise<Check> {
+  const agent = config.execution?.agent || "claude";
+
+  try {
+    const proc = _deps.spawn([agent, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const exitCode = await proc.exited;
+    const passed = exitCode === 0;
+
+    return {
+      name: "agent-cli-available",
+      tier: "blocker",
+      passed,
+      message: passed ? `${agent} CLI is available` : `${agent} CLI not found. Install the ${agent} binary.`,
+    };
+  } catch {
+    // Bun.spawn throws ENOENT when the binary is not found in PATH.
+    return {
+      name: "agent-cli-available",
+      tier: "blocker",
+      passed: false,
+      message: `${agent} CLI not found in PATH. Install the ${agent} binary.`,
+    };
+  }
+}
+
 /** Check if dependencies are installed (language-aware). Detects: node_modules, target, venv, vendor */
 export async function checkDependenciesInstalled(workdir: string): Promise<Check> {
   const depPaths = [

package/src/precheck/checks.ts

@@ -13,6 +13,7 @@ export {
   checkStaleLock,
   checkPRDValid,
   checkClaudeCLI,
+  checkAgentCLI,
   checkDependenciesInstalled,
   checkTestCommand,
   checkLintCommand,

package/src/precheck/index.ts

@@ -9,7 +9,7 @@
 import type { NaxConfig } from "../config";
 import type { PRD } from "../prd/types";
 import {
-  checkClaudeCLI,
+  checkAgentCLI,
   checkClaudeMdExists,
   checkDependenciesInstalled,
   checkDiskSpace,
@@ -105,7 +105,7 @@ export async function runPrecheck(
     () => checkWorkingTreeClean(workdir),
     () => checkStaleLock(workdir),
     () => checkPRDValid(prd),
-    () => checkClaudeCLI(),
+    () => checkAgentCLI(config),
     () => checkDependenciesInstalled(workdir),
     () => checkTestCommand(config),
     () => checkLintCommand(config),

package/src/routing/router.ts

@@ -181,6 +181,7 @@ export function determineTestStrategy(
   // Explicit overrides — ignore all heuristics
   if (tddStrategy === "strict") return "three-session-tdd";
   if (tddStrategy === "lite") return "three-session-tdd-lite";
+  if (tddStrategy === "simple") return "tdd-simple";
   if (tddStrategy === "off") return "test-after";
 
   // auto mode: apply heuristics

package/src/routing/strategies/llm.ts

@@ -5,10 +5,12 @@
  * Falls back to keyword strategy on failure. Supports batch mode for efficiency.
  */
 
+import type { AgentAdapter } from "../../agents/types";
 import type { NaxConfig } from "../../config";
 import { resolveModel } from "../../config";
 import { getLogger } from "../../logger";
 import type { UserStory } from "../../prd/types";
+import { determineTestStrategy } from "../router";
 import type { RoutingContext, RoutingDecision, RoutingStrategy } from "../strategy";
 import { keywordStrategy } from "./keyword";
 import { buildBatchPrompt, buildRoutingPrompt, parseBatchResponse, parseRoutingResponse } from "./llm-prompts";
@@ -41,6 +43,11 @@ export function clearCacheForStory(storyId: string): void {
   cachedDecisions.delete(storyId);
 }
 
+/** Inject a cache entry directly (test helper only) */
+export function injectCacheEntry(storyId: string, decision: RoutingDecision): void {
+  cachedDecisions.set(storyId, decision);
+}
+
 /** Evict oldest entry when cache is full (LRU) */
 function evictOldest(): void {
   const firstKey = cachedDecisions.keys().next().value;
@@ -59,22 +66,31 @@ export interface PipedProc {
 
 /**
  * Swappable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
+ * Includes spawn for backward compatibility with BUG-039 tests, and adapter for new AA-003.
  */
 export const _deps = {
   spawn: (cmd: string[], opts: { stdout: "pipe"; stderr: "pipe" }): PipedProc =>
     Bun.spawn(cmd, opts) as unknown as PipedProc,
+  adapter: undefined as AgentAdapter | undefined,
 };
 
 /**
- * Call LLM via claude CLI with timeout.
+ * Call LLM via adapter.complete() with timeout.
  *
+ * @param adapter - Agent adapter to use for completion
  * @param modelTier - Model tier to use for routing call
  * @param prompt - Prompt to send to LLM
  * @param config - nax configuration
  * @returns LLM response text
- * @throws Error on timeout or spawn failure
+ * @throws Error on timeout or completion failure
  */
-async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig, timeoutMs: number): Promise<string> {
+async function callLlmOnce(
+  adapter: AgentAdapter,
+  modelTier: string,
+  prompt: string,
+  config: NaxConfig,
+  timeoutMs: number,
+): Promise<string> {
   // Resolve model tier to actual model identifier
   const modelEntry = config.models[modelTier];
   if (!modelEntry) {
@@ -84,12 +100,6 @@ async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig,
   const modelDef = resolveModel(modelEntry);
   const modelArg = modelDef.model;
 
-  // Spawn claude CLI with timeout
-  const proc = _deps.spawn(["claude", "-p", prompt, "--model", modelArg], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
   // Race between completion and timeout, ensuring cleanup on either path
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
 
@@ -101,16 +111,7 @@ async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig,
   // Prevent unhandled rejection if timer fires between race resolution and clearTimeout
   timeoutPromise.catch(() => {});
 
-  const outputPromise = (async () => {
-    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`claude CLI failed with exit code ${exitCode}: ${stderr}`);
-    }
-
-    return stdout.trim();
-  })();
+  const outputPromise = adapter.complete(prompt, { model: modelArg });
 
   try {
     const result = await Promise.race([outputPromise, timeoutPromise]);
@@ -118,30 +119,23 @@ async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig,
     return result;
   } catch (err) {
     clearTimeout(timeoutId);
-    // Silence the floating outputPromise BEFORE killing the process.
-    // proc.kill() causes piped streams to error → Response.text() rejects →
-    // outputPromise rejects. The .catch() must be attached first to prevent
-    // an unhandled rejection that crashes nax via crash-recovery.
+    // Silence the floating outputPromise to prevent unhandled rejection
     outputPromise.catch(() => {});
-    proc.kill();
-    // DO NOT call proc.stdout.cancel() / proc.stderr.cancel() here.
-    // The streams are locked by Response.text() readers. Per Web Streams spec,
-    // cancel() on a locked stream returns a rejected Promise (not a sync throw),
-    // which becomes an unhandled rejection. Let proc.kill() handle cleanup.
     throw err;
   }
 }
 
 /**
- * Call LLM via claude CLI with timeout and retry (BUG-033).
+ * Call LLM via adapter.complete() with timeout and retry (BUG-033).
  *
+ * @param adapter - Agent adapter to use for completion
  * @param modelTier - Model tier to use for routing call
  * @param prompt - Prompt to send to LLM
  * @param config - nax configuration
  * @returns LLM response text
  * @throws Error after all retries exhausted
  */
-async function callLlm(modelTier: string, prompt: string, config: NaxConfig): Promise<string> {
+async function callLlm(adapter: AgentAdapter, modelTier: string, prompt: string, config: NaxConfig): Promise<string> {
   const llmConfig = config.routing.llm;
   const timeoutMs = llmConfig?.timeoutMs ?? 30000;
   const maxRetries = llmConfig?.retries ?? 1;
@@ -151,7 +145,7 @@ async function callLlm(modelTier: string, prompt: string, config: NaxConfig): Pr
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      return await callLlmOnce(modelTier, prompt, config, timeoutMs);
+      return await callLlmOnce(adapter, modelTier, prompt, config, timeoutMs);
     } catch (err) {
       lastError = err as Error;
       if (attempt < maxRetries) {
@@ -189,11 +183,17 @@ export async function routeBatch(stories: UserStory[], context: RoutingContext):
     throw new Error("LLM routing config not found");
   }
 
+  // Resolve adapter from context or _deps
+  const adapter = context.adapter ?? _deps.adapter;
+  if (!adapter) {
+    throw new Error("No agent adapter available for batch routing (AA-003)");
+  }
+
   const modelTier = llmConfig.model ?? "fast";
   const prompt = buildBatchPrompt(stories, config);
 
   try {
-    const output = await callLlm(modelTier, prompt, config);
+    const output = await callLlm(adapter, modelTier, prompt, config);
     const decisions = parseBatchResponse(output, stories, config);
 
     // Populate cache (PERF-1 fix: evict oldest if full)
@@ -217,7 +217,7 @@ export async function routeBatch(stories: UserStory[], context: RoutingContext):
  *
  * This strategy:
  * - Checks cache first (if enabled)
- * - Calls LLM with story context to classify complexity
+ * - Calls LLM with story context to classify complexity (via adapter.complete())
  * - Parses structured JSON response
  * - Maps complexity to model tier and test strategy
  * - Falls back to null (keyword fallback) on any failure
@@ -241,14 +241,25 @@ export const llmStrategy: RoutingStrategy = {
       if (!cached) {
         throw new Error(`Cached decision not found for story: ${story.id}`);
       }
+      // Recompute testStrategy from complexity — cache is authoritative on complexity/modelTier
+      // only. testStrategy must always reflect the current determineTestStrategy() rules
+      // (e.g. TS-001: simple → tdd-simple) even if the cache was populated under older rules.
+      const tddStrategy = config.tdd?.strategy ?? "auto";
+      const freshTestStrategy = determineTestStrategy(
+        cached.complexity,
+        story.title,
+        story.description,
+        story.tags,
+        tddStrategy,
+      );
       const logger = getLogger();
       logger.debug("routing", "LLM cache hit", {
         storyId: story.id,
         complexity: cached.complexity,
         modelTier: cached.modelTier,
-        testStrategy: cached.testStrategy,
+        testStrategy: freshTestStrategy,
       });
-      return cached;
+      return { ...cached, testStrategy: freshTestStrategy };
     }
 
     // One-shot mode: cache miss -> keyword fallback without new LLM call
@@ -261,9 +272,15 @@ export const llmStrategy: RoutingStrategy = {
     }
 
     try {
+      // Resolve adapter from context or _deps (AA-003)
+      const adapter = context.adapter ?? _deps.adapter;
+      if (!adapter) {
+        throw new Error("No agent adapter available for LLM routing (AA-003)");
+      }
+
       const modelTier = llmConfig.model ?? "fast";
       const prompt = buildRoutingPrompt(story, config);
-      const output = await callLlm(modelTier, prompt, config);
+      const output = await callLlm(adapter, modelTier, prompt, config);
       const decision = parseRoutingResponse(output, story, config);
 
       // Cache decision (PERF-1 fix: evict oldest if full)

package/src/routing/strategy.ts

@@ -5,6 +5,7 @@
  * Strategies can return null to delegate to the next strategy in the chain.
  */
 
+import type { AgentAdapter } from "../agents/types";
 import type { Complexity, ModelTier, NaxConfig, TestStrategy } from "../config";
 import type { UserStory } from "../prd/types";
 
@@ -45,6 +46,8 @@ export interface RoutingContext {
   codebaseContext?: string;
   /** Optional historical metrics (v0.5 Phase 1) */
   metrics?: AggregateMetrics;
+  /** Optional agent adapter for LLM-based routing (AA-003) */
+  adapter?: AgentAdapter;
 }
 
 /** Routing decision returned by strategies */