@nathapp/nax 0.45.0 → 0.46.1

package/src/agents/cost/calculate.ts

@@ -0,0 +1,154 @@
+/**
+ * Cost calculation functions for all agent adapters.
+ */
+
+import type { ModelTier } from "../../config/schema";
+import { parseTokenUsage } from "./parse";
+import { COST_RATES, MODEL_PRICING } from "./pricing";
+import type { CostEstimate, ModelCostRates, SessionTokenUsage } from "./types";
+
+/**
+ * Estimate cost in USD based on token usage and model tier.
+ *
+ * @param modelTier - Model tier (fast/balanced/powerful)
+ * @param inputTokens - Number of input tokens consumed
+ * @param outputTokens - Number of output tokens generated
+ * @param customRates - Optional custom rates (overrides tier defaults)
+ * @returns Total cost in USD
+ *
+ * @example
+ * ```ts
+ * const cost = estimateCost("balanced", 10000, 5000);
+ * // Sonnet 4.5: (10000/1M * $3.00) + (5000/1M * $15.00) = $0.105
+ * ```
+ */
+export function estimateCost(
+  modelTier: ModelTier,
+  inputTokens: number,
+  outputTokens: number,
+  customRates?: ModelCostRates,
+): number {
+  const rates = customRates ?? COST_RATES[modelTier];
+  const inputCost = (inputTokens / 1_000_000) * rates.inputPer1M;
+  const outputCost = (outputTokens / 1_000_000) * rates.outputPer1M;
+  return inputCost + outputCost;
+}
+
+/**
+ * Estimate cost from agent output by parsing token usage.
+ *
+ * Attempts to extract token counts from stdout/stderr, then calculates cost.
+ * Returns null if tokens cannot be parsed.
+ *
+ * @param modelTier - Model tier for cost calculation
+ * @param output - Agent stdout + stderr combined
+ * @returns Cost estimate with confidence indicator, or null if unparseable
+ */
+export function estimateCostFromOutput(modelTier: ModelTier, output: string): CostEstimate | null {
+  const usage = parseTokenUsage(output);
+  if (!usage) {
+    return null;
+  }
+  const cost = estimateCost(modelTier, usage.inputTokens, usage.outputTokens);
+  return {
+    cost,
+    confidence: usage.confidence,
+  };
+}
+
+/**
+ * Fallback cost estimation based on runtime duration.
+ *
+ * Used when token usage cannot be parsed from agent output.
+ * Provides conservative estimates using per-minute rates.
+ *
+ * @param modelTier - Model tier for cost calculation
+ * @param durationMs - Agent runtime in milliseconds
+ * @returns Cost estimate with 'fallback' confidence
+ *
+ * @example
+ * ```ts
+ * const estimate = estimateCostByDuration("balanced", 120000); // 2 minutes
+ * // { cost: 0.10, confidence: 'fallback' }
+ * // Sonnet: 2 min * $0.05/min = $0.10
+ * ```
+ */
+export function estimateCostByDuration(modelTier: ModelTier, durationMs: number): CostEstimate {
+  const costPerMinute: Record<ModelTier, number> = {
+    fast: 0.01,
+    balanced: 0.05,
+    powerful: 0.15,
+  };
+  const minutes = durationMs / 60000;
+  const cost = minutes * costPerMinute[modelTier];
+  return {
+    cost,
+    confidence: "fallback",
+  };
+}
+
+/**
+ * Format cost estimate with confidence indicator for display.
+ *
+ * @param estimate - Cost estimate with confidence level
+ * @returns Formatted cost string with confidence indicator
+ *
+ * @example
+ * ```ts
+ * formatCostWithConfidence({ cost: 0.12, confidence: 'exact' });
+ * // "$0.12"
+ *
+ * formatCostWithConfidence({ cost: 0.15, confidence: 'estimated' });
+ * // "~$0.15"
+ *
+ * formatCostWithConfidence({ cost: 0.05, confidence: 'fallback' });
+ * // "~$0.05 (duration-based)"
+ * ```
+ */
+export function formatCostWithConfidence(estimate: CostEstimate): string {
+  const formattedCost = `$${estimate.cost.toFixed(2)}`;
+
+  switch (estimate.confidence) {
+    case "exact":
+      return formattedCost;
+    case "estimated":
+      return `~${formattedCost}`;
+    case "fallback":
+      return `~${formattedCost} (duration-based)`;
+  }
+}
+
+/**
+ * Calculate USD cost from ACP session token counts using per-model pricing.
+ *
+ * @param usage - Token counts from cumulative_token_usage
+ * @param model - Model identifier (e.g., 'claude-sonnet-4', 'claude-haiku-4-5')
+ * @returns Estimated cost in USD
+ */
+export function estimateCostFromTokenUsage(usage: SessionTokenUsage, model: string): number {
+  const pricing = MODEL_PRICING[model];
+
+  if (!pricing) {
+    // Fallback: use average rate for unknown models
+    const fallbackInputRate = 3 / 1_000_000;
+    const fallbackOutputRate = 15 / 1_000_000;
+    const inputCost = (usage.input_tokens ?? 0) * fallbackInputRate;
+    const outputCost = (usage.output_tokens ?? 0) * fallbackOutputRate;
+    const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * (0.5 / 1_000_000);
+    const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * (2 / 1_000_000);
+    return inputCost + outputCost + cacheReadCost + cacheCreationCost;
+  }
+
+  // Convert $/1M rates to $/token
+  const inputRate = pricing.input / 1_000_000;
+  const outputRate = pricing.output / 1_000_000;
+  const cacheReadRate = (pricing.cacheRead ?? pricing.input * 0.1) / 1_000_000;
+  const cacheCreationRate = (pricing.cacheCreation ?? pricing.input * 0.33) / 1_000_000;
+
+  const inputCost = (usage.input_tokens ?? 0) * inputRate;
+  const outputCost = (usage.output_tokens ?? 0) * outputRate;
+  const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * cacheReadRate;
+  const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * cacheCreationRate;
+
+  return inputCost + outputCost + cacheReadCost + cacheCreationCost;
+}

package/src/agents/cost/index.ts

@@ -0,0 +1,10 @@
+export type { ModelCostRates, TokenUsage, CostEstimate, TokenUsageWithConfidence, SessionTokenUsage } from "./types";
+export { COST_RATES, MODEL_PRICING } from "./pricing";
+export { parseTokenUsage } from "./parse";
+export {
+  estimateCost,
+  estimateCostFromOutput,
+  estimateCostByDuration,
+  formatCostWithConfidence,
+  estimateCostFromTokenUsage,
+} from "./calculate";

package/src/agents/cost/parse.ts

@@ -0,0 +1,97 @@
+/**
+ * Token usage parsing from raw agent output strings.
+ */
+
+import type { TokenUsageWithConfidence } from "./types";
+
+/**
+ * Parse Claude Code output for token usage.
+ *
+ * Supports multiple formats with varying confidence levels:
+ * - JSON structured output → "exact" confidence
+ * - Markdown/plain text patterns → "estimated" confidence
+ *
+ * Uses specific regex patterns to reduce false positives.
+ *
+ * @param output - Agent stdout + stderr combined
+ * @returns Token usage with confidence indicator, or null if tokens cannot be parsed
+ *
+ * @example
+ * ```ts
+ * // JSON format (exact)
+ * const usage1 = parseTokenUsage('{"usage": {"input_tokens": 1234, "output_tokens": 5678}}');
+ * // { inputTokens: 1234, outputTokens: 5678, confidence: 'exact' }
+ *
+ * // Markdown format (estimated)
+ * const usage2 = parseTokenUsage('Input tokens: 1234\nOutput tokens: 5678');
+ * // { inputTokens: 1234, outputTokens: 5678, confidence: 'estimated' }
+ *
+ * // Unparseable
+ * const usage3 = parseTokenUsage('No token data here');
+ * // null
+ * ```
+ */
+export function parseTokenUsage(output: string): TokenUsageWithConfidence | null {
+  // Try JSON format first (most reliable) - confidence: exact
+  try {
+    const jsonMatch = output.match(
+      /\{[^}]*"usage"\s*:\s*\{[^}]*"input_tokens"\s*:\s*(\d+)[^}]*"output_tokens"\s*:\s*(\d+)[^}]*\}[^}]*\}/,
+    );
+    if (jsonMatch) {
+      return {
+        inputTokens: Number.parseInt(jsonMatch[1], 10),
+        outputTokens: Number.parseInt(jsonMatch[2], 10),
+        confidence: "exact",
+      };
+    }
+
+    // Try parsing as full JSON object
+    const lines = output.split("\n");
+    for (const line of lines) {
+      if (line.trim().startsWith("{")) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.usage?.input_tokens && parsed.usage?.output_tokens) {
+            return {
+              inputTokens: parsed.usage.input_tokens,
+              outputTokens: parsed.usage.output_tokens,
+              confidence: "exact",
+            };
+          }
+        } catch {
+          // Not valid JSON, continue
+        }
+      }
+    }
+  } catch {
+    // JSON parsing failed, try regex patterns
+  }
+
+  // Try specific markdown-style patterns (more specific to reduce false positives)
+  // Match "Input tokens: 1234" or "input_tokens: 1234" or "INPUT TOKENS: 1234"
+  // Use word boundary at start, require colon or space after keyword, then digits
+  // confidence: estimated (regex-based)
+  const inputMatch = output.match(/\b(?:input|input_tokens)\s*:\s*(\d{2,})|(?:input)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
+  const outputMatch = output.match(
+    /\b(?:output|output_tokens)\s*:\s*(\d{2,})|(?:output)\s+(?:tokens?)\s*:\s*(\d{2,})/i,
+  );
+
+  if (inputMatch && outputMatch) {
+    // Extract token counts (may be in capture group 1 or 2)
+    const inputTokens = Number.parseInt(inputMatch[1] || inputMatch[2], 10);
+    const outputTokens = Number.parseInt(outputMatch[1] || outputMatch[2], 10);
+
+    // Sanity check: reject if tokens seem unreasonably large (> 1M each)
+    if (inputTokens > 1_000_000 || outputTokens > 1_000_000) {
+      return null;
+    }
+
+    return {
+      inputTokens,
+      outputTokens,
+      confidence: "estimated",
+    };
+  }
+
+  return null;
+}

package/src/agents/cost/pricing.ts

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +1,45 @@
+/**
+ * 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/index.ts

@@ -2,15 +2,17 @@ export type { AgentAdapter, AgentCapabilities, AgentResult, AgentRunOptions, Com
 export { CompleteError } from "./types";
 export { ClaudeCodeAdapter } from "./claude";
 export { getAllAgentNames, getAgent, getInstalledAgents, checkAgentHealth } from "./registry";
-export type { ModelCostRates, TokenUsage, CostEstimate, TokenUsageWithConfidence } from "./cost";
+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 "./validation";
-export type { AgentVersionInfo } from "./version-detection";
-export { getAgentVersion, getAgentVersions } from "./version-detection";
+export { validateAgentForTier, validateAgentFeature, describeAgentCapabilities } from "./shared/validation";
+export type { AgentVersionInfo } from "./shared/version-detection";
+export { getAgentVersion, getAgentVersions } from "./shared/version-detection";

package/src/agents/registry.ts

@@ -7,11 +7,11 @@
 import type { NaxConfig } from "../config/schema";
 import { getLogger } from "../logger";
 import { AcpAgentAdapter } from "./acp/adapter";
-import { AiderAdapter } from "./adapters/aider";
-import { CodexAdapter } from "./adapters/codex";
-import { GeminiAdapter } from "./adapters/gemini";
-import { OpenCodeAdapter } from "./adapters/opencode";
-import { ClaudeCodeAdapter } from "./claude";
+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 */

package/src/agents/{claude-decompose.ts → shared/decompose.ts}

@@ -5,8 +5,8 @@
  * parseDecomposeOutput(), validateComplexity()
  */
 
-import { COMPLEXITY_GUIDE, GROUPING_RULES, TEST_STRATEGY_GUIDE, resolveTestStrategy } from "../config/test-strategy";
-import type { DecomposeOptions, DecomposeResult, DecomposedStory } from "./types";
+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.

package/src/agents/{model-resolution.ts → shared/model-resolution.ts}

@@ -7,8 +7,8 @@
  * Implementation placeholder — logic to be filled in by the implementer.
  */
 
-import { resolveModel } from "../config/schema";
-import type { ModelDef, NaxConfig } from "../config/schema";
+import { resolveModel } from "../../config/schema";
+import type { ModelDef, NaxConfig } from "../../config/schema";
 
 /**
  * Resolve the balanced model definition from config, with optional adapter default fallback.

package/src/agents/{types-extended.ts → shared/types-extended.ts}

@@ -5,7 +5,7 @@
  * Separated from core types to keep each file under 400 lines.
  */
 
-import type { ModelDef, ModelTier, NaxConfig } from "../config/schema";
+import type { ModelDef, ModelTier, NaxConfig } from "../../config/schema";
 
 /**
  * Configuration options for running an agent in plan mode.
@@ -56,7 +56,7 @@ export interface PlanOptions {
    */
   onAcpSessionCreated?: (sessionName: string) => Promise<void> | void;
   /** PID registry for tracking spawned agent processes — cleanup on crash/SIGTERM */
-  pidRegistry?: import("../execution/pid-registry").PidRegistry;
+  pidRegistry?: import("../../execution/pid-registry").PidRegistry;
 }
 
 /**
@@ -117,7 +117,7 @@ export interface DecomposedStory {
   /** Implementation risks */
   risks: string[];
   /** Test strategy recommendation from LLM */
-  testStrategy?: import("../config/test-strategy").TestStrategy;
+  testStrategy?: import("../../config/test-strategy").TestStrategy;
 }
 
 /**
@@ -161,4 +161,4 @@ export interface InteractiveRunOptions extends AgentRunOptions {
 }
 
 // Re-import for the extends clause
-import type { AgentRunOptions } from "./types";
+import type { AgentRunOptions } from "../types";

package/src/agents/{validation.ts → shared/validation.ts}

@@ -4,8 +4,8 @@
  * Runtime validation for agent capabilities and tier compatibility.
  */
 
-import type { ModelTier } from "../config/schema";
-import type { AgentAdapter } from "./types";
+import type { ModelTier } from "../../config/schema";
+import type { AgentAdapter } from "../types";
 
 /**
  * Check if an agent supports a given model tier.

package/src/agents/{version-detection.ts → shared/version-detection.ts}

@@ -5,8 +5,8 @@
  * by running `<agent> --version` and parsing the output.
  */
 
-import { getInstalledAgents } from "./registry";
-import type { AgentAdapter } from "./types";
+import { getInstalledAgents } from "../registry";
+import type { AgentAdapter } from "../types";
 
 /**
  * Information about an installed agent including its version
@@ -90,7 +90,7 @@ export async function getAgentVersions(): Promise<AgentVersionInfo[]> {
   const agentsByName = new Map(agents.map((a) => [a.name, a]));
 
   // Import ALL_AGENTS to include non-installed ones
-  const { ALL_AGENTS } = await import("./registry");
+  const { ALL_AGENTS } = await import("../registry");
 
   const versions = await Promise.all(
     ALL_AGENTS.map(async (agent: AgentAdapter): Promise<AgentVersionInfo> => {

package/src/agents/types.ts

@@ -8,6 +8,7 @@
 
 import type { NaxConfig } from "../config";
 import type { ModelDef, ModelTier } from "../config/schema";
+import type { TokenUsage } from "./cost";
 
 // Re-export extended types for backward compatibility
 export type {
@@ -18,7 +19,7 @@ export type {
   DecomposedStory,
   PtyHandle,
   InteractiveRunOptions,
-} from "./types-extended";
+} from "./shared/types-extended";
 
 /**
  * Agent execution result returned after running a coding agent.
@@ -38,6 +39,8 @@ export interface AgentResult {
   durationMs: number;
   /** Estimated cost for this run (USD) */
   estimatedCost: number;
+  /** Token usage for this run (when available) */
+  tokenUsage?: TokenUsage;
   /** Process ID of the spawned agent (for cleanup on failure) */
   pid?: number;
 }
@@ -165,10 +168,12 @@ export interface AgentAdapter {
   buildCommand(options: AgentRunOptions): string[];
 
   /** Run the agent in plan mode to generate a feature specification. */
-  plan(options: import("./types-extended").PlanOptions): Promise<import("./types-extended").PlanResult>;
+  plan(options: import("./shared/types-extended").PlanOptions): Promise<import("./shared/types-extended").PlanResult>;
 
   /** Run the agent in decompose mode to break spec into classified stories. */
-  decompose(options: import("./types-extended").DecomposeOptions): Promise<import("./types-extended").DecomposeResult>;
+  decompose(
+    options: import("./shared/types-extended").DecomposeOptions,
+  ): Promise<import("./shared/types-extended").DecomposeResult>;
 
   /**
    * Run a one-shot LLM call and return the plain text response.
@@ -181,5 +186,7 @@ export interface AgentAdapter {
    * This method is optional — only implemented by agents that support
    * interactive terminal sessions (e.g., Claude Code).
    */
-  runInteractive?(options: import("./types-extended").InteractiveRunOptions): import("./types-extended").PtyHandle;
+  runInteractive?(
+    options: import("./shared/types-extended").InteractiveRunOptions,
+  ): import("./shared/types-extended").PtyHandle;
 }

package/src/cli/agents.ts

@@ -5,7 +5,7 @@
  */
 
 import { ALL_AGENTS } from "../agents/registry";
-import { getAgentVersion } from "../agents/version-detection";
+import { getAgentVersion } from "../agents/shared/version-detection";
 import type { NaxConfig } from "../config/schema";
 
 /**

package/src/cli/init.ts

@@ -33,7 +33,21 @@ export interface InitProjectOptions {
 /**
  * Gitignore entries added by nax init
  */
-const NAX_GITIGNORE_ENTRIES = [".nax-verifier-verdict.json", "nax.lock", "nax/**/runs/", "nax/metrics.json"];
+const NAX_GITIGNORE_ENTRIES = [
+  ".nax-verifier-verdict.json",
+  "nax.lock",
+  "nax/**/runs/",
+  "nax/metrics.json",
+  "nax/features/*/status.json",
+  "nax/features/*/plan/",
+  "nax/features/*/acp-sessions.json",
+  "nax/features/*/interactions/",
+  "nax/features/*/progress.txt",
+  "nax/features/*/acceptance-refined.json",
+  ".nax-pids",
+  ".nax-wt/",
+  "~/",
+];
 
 /**
  * Add nax-specific entries to .gitignore if not already present.

package/src/pipeline/stages/acceptance-setup.ts

@@ -106,6 +106,7 @@ export const acceptanceSetupStage: PipelineStage = {
       const result = await _acceptanceSetupDeps.generate(ctx.prd.userStories, refinedCriteria, {
         featureName: ctx.prd.feature,
         workdir: ctx.workdir,
+        featureDir: ctx.featureDir,
         codebaseContext: "",
         modelTier: ctx.config.acceptance.model ?? "fast",
         modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),

package/src/pipeline/stages/acceptance.ts

@@ -27,6 +27,7 @@
 import path from "node:path";
 import { getLogger } from "../../logger";
 import { countStories } from "../../prd";
+import { logTestOutput } from "../../utils/log-test-output";
 import type { PipelineContext, PipelineStage, StageResult } from "../types";
 
 /**
@@ -163,10 +164,8 @@ export const acceptanceStage: PipelineStage = {
 
     // Non-zero exit but no AC failures parsed at all — test crashed (syntax error, import failure, etc.)
     if (failedACs.length === 0 && exitCode !== 0) {
-      logger.error("acceptance", "Tests errored with no AC failures parsed", {
-        exitCode,
-        output,
-      });
+      logger.error("acceptance", "Tests errored with no AC failures parsed", { exitCode });
+      logTestOutput(logger, "acceptance", output);
 
       ctx.acceptanceFailures = {
         failedACs: ["AC-ERROR"],
@@ -190,10 +189,8 @@ export const acceptanceStage: PipelineStage = {
         });
       }
 
-      logger.error("acceptance", "Acceptance tests failed", {
-        failedACs: actualFailures,
-        output,
-      });
+      logger.error("acceptance", "Acceptance tests failed", { failedACs: actualFailures });
+      logTestOutput(logger, "acceptance", output);
 
       // Store failed ACs and test output in context for fix generation
       ctx.acceptanceFailures = {

package/src/pipeline/stages/regression.ts

@@ -14,6 +14,7 @@
  */
 
 import { getLogger } from "../../logger";
+import { logTestOutput } from "../../utils/log-test-output";
 import { verificationOrchestrator } from "../../verification/orchestrator";
 import type { VerifyContext } from "../../verification/orchestrator-types";
 import { pipelineEventBus } from "../event-bus";
@@ -71,6 +72,7 @@ export const regressionStage: PipelineStage = {
       storyId: ctx.story.id,
       failCount: result.failCount,
     });
+    logTestOutput(logger, "regression", result.rawOutput, { storyId: ctx.story.id });
 
     pipelineEventBus.emit({
       type: "regression:detected",

package/src/pipeline/stages/verify.ts

@@ -11,6 +11,7 @@
 
 import type { SmartTestRunnerConfig } from "../../config/types";
 import { getLogger } from "../../logger";
+import { logTestOutput } from "../../utils/log-test-output";
 import { detectRuntimeCrash } from "../../verification/crash-detector";
 import type { VerifyStatus } from "../../verification/orchestrator-types";
 import { regression } from "../../verification/runners";
@@ -173,16 +174,10 @@ export const verifyStage: PipelineStage = {
         });
       }
 
-      // Log first few lines of output for context
-      // BUG-037: Changed from .slice(0, 10) to .slice(-20) to show failures, not prechecks
-      if (result.output && result.status !== "TIMEOUT") {
-        const outputLines = result.output.split("\n").slice(-20);
-        if (outputLines.length > 0) {
-          logger.debug("verify", "Test output preview", {
-            storyId: ctx.story.id,
-            output: outputLines.join("\n"),
-          });
-        }
+      // Log tail of output at debug level for context (ENH-001)
+      // BUG-037: Use .slice(-20) to show failures, not prechecks
+      if (result.status !== "TIMEOUT") {
+        logTestOutput(logger, "verify", result.output, { storyId: ctx.story.id });
       }
 
       return {