@nathapp/nax 0.20.0 → 0.22.0

package/test/unit/routing-strategies.test.ts

@@ -0,0 +1,442 @@
+// RE-ARCH: keep
+/**
+ * Routing Tests
+ *
+ * Consolidated test suite for routing system including:
+ * - Core routing logic (classifyComplexity, determineTestStrategy, routeTask)
+ * - Routing strategies (keyword, llm, manual, adaptive)
+ * - Strategy chain execution
+ * - Async support and chain delegation
+ */
+
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../../src/config";
+import type { NaxConfig } from "../../src/config";
+import { escalateTier } from "../../src/execution/runner";
+import type { AggregateMetrics } from "../../src/metrics/types";
+import type { UserStory } from "../../src/prd/types";
+import { classifyComplexity, determineTestStrategy, routeTask } from "../../src/routing";
+import { buildStrategyChain } from "../../src/routing/builder";
+import { StrategyChain } from "../../src/routing/chain";
+import { keywordStrategy, llmStrategy, manualStrategy } from "../../src/routing/strategies";
+import { adaptiveStrategy } from "../../src/routing/strategies/adaptive";
+import {
+  buildBatchPrompt,
+  buildRoutingPrompt,
+  clearCache,
+  clearCacheForStory,
+  getCacheSize,
+  llmStrategy as llmStrategyFull,
+  parseRoutingResponse,
+  routeBatch,
+  stripCodeFences,
+  validateRoutingDecision,
+} from "../../src/routing/strategies/llm";
+import type { RoutingContext, RoutingDecision, RoutingStrategy } from "../../src/routing/strategy";
+
+
+const simpleStory: UserStory = {
+  id: "US-001",
+  title: "Fix typo in README",
+  description: "Correct spelling mistake",
+  acceptanceCriteria: ["Update README.md with correct spelling"],
+  tags: ["docs"],
+  dependencies: [],
+  status: "pending",
+  passes: false,
+};
+
+const complexStory: UserStory = {
+  id: "US-002",
+  title: "Add JWT authentication",
+  description: "Implement JWT authentication with refresh tokens",
+  acceptanceCriteria: ["Secure token storage", "Token refresh endpoint", "Expiry handling", "Logout functionality"],
+  tags: ["security", "auth"],
+  dependencies: [],
+  status: "pending",
+  passes: false,
+};
+
+const testContext: RoutingContext = {
+  config: DEFAULT_CONFIG,
+};
+
+describe("StrategyChain", () => {
+  test("uses first strategy that returns non-null", async () => {
+    const alwaysNullStrategy: RoutingStrategy = {
+      name: "always-null",
+      route: () => null,
+    };
+
+    const alwaysReturnStrategy: RoutingStrategy = {
+      name: "always-return",
+      route: () => ({
+        complexity: "simple",
+        modelTier: "fast",
+        testStrategy: "test-after",
+        reasoning: "Always return strategy",
+      }),
+    };
+
+    const chain = new StrategyChain([alwaysNullStrategy, alwaysReturnStrategy]);
+
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test story",
+      description: "Test",
+      acceptanceCriteria: [],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = await chain.route(story, context);
+
+    expect(decision.reasoning).toBe("Always return strategy");
+  });
+
+  test("throws error if all strategies return null", async () => {
+    const alwaysNullStrategy: RoutingStrategy = {
+      name: "always-null",
+      route: () => null,
+    };
+
+    const chain = new StrategyChain([alwaysNullStrategy]);
+
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test story",
+      description: "Test",
+      acceptanceCriteria: [],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+
+    await expect(chain.route(story, context)).rejects.toThrow("No routing strategy returned a decision");
+  });
+
+  test("getStrategyNames returns strategy names", () => {
+    const chain = new StrategyChain([keywordStrategy, llmStrategy]);
+    expect(chain.getStrategyNames()).toEqual(["keyword", "llm"]);
+  });
+
+  describe("async support", () => {
+    test("handles async strategy that returns decision", async () => {
+      const asyncStrategy: RoutingStrategy = {
+        name: "async-test",
+        route: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return {
+            complexity: "medium",
+            modelTier: "balanced",
+            testStrategy: "test-after",
+            reasoning: "Async strategy result",
+          };
+        },
+      };
+
+      const chain = new StrategyChain([asyncStrategy]);
+
+      const story: UserStory = {
+        id: "US-001",
+        title: "Test async story",
+        description: "Test async routing",
+        acceptanceCriteria: [],
+        tags: [],
+        dependencies: [],
+        status: "pending",
+        passes: false,
+        escalations: [],
+        attempts: 0,
+      };
+
+      const context: RoutingContext = { config: DEFAULT_CONFIG };
+      const decision = await chain.route(story, context);
+
+      expect(decision.reasoning).toBe("Async strategy result");
+      expect(decision.complexity).toBe("medium");
+      expect(decision.modelTier).toBe("balanced");
+    });
+
+    test("handles mixed sync and async strategies", async () => {
+      const syncStrategy: RoutingStrategy = {
+        name: "sync-first",
+        route: () => null,
+      };
+
+      const asyncStrategy: RoutingStrategy = {
+        name: "async-second",
+        route: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return {
+            complexity: "complex",
+            modelTier: "powerful",
+            testStrategy: "three-session-tdd",
+            reasoning: "Mixed chain result",
+          };
+        },
+      };
+
+      const chain = new StrategyChain([syncStrategy, asyncStrategy]);
+
+      const story: UserStory = {
+        id: "US-003",
+        title: "Test mixed",
+        description: "Test mixed sync/async",
+        acceptanceCriteria: [],
+        tags: [],
+        dependencies: [],
+        status: "pending",
+        passes: false,
+        escalations: [],
+        attempts: 0,
+      };
+
+      const context: RoutingContext = { config: DEFAULT_CONFIG };
+      const decision = await chain.route(story, context);
+
+      expect(decision.reasoning).toBe("Mixed chain result");
+      expect(decision.testStrategy).toBe("three-session-tdd");
+    });
+  });
+});
+
+describe("keywordStrategy", () => {
+  test("classifies simple story correctly", () => {
+    const story: UserStory = {
+      id: "US-001",
+      title: "Update button color",
+      description: "Change button to blue",
+      acceptanceCriteria: ["Button is blue"],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = keywordStrategy.route(story, context);
+
+    expect(decision).not.toBeNull();
+    expect(decision!.complexity).toBe("simple");
+    expect(decision!.modelTier).toBe("fast");
+    expect(decision!.testStrategy).toBe("three-session-tdd-lite");
+  });
+
+  test("classifies complex story with security keywords", () => {
+    const story: UserStory = {
+      id: "US-002",
+      title: "Add JWT authentication",
+      description: "Implement JWT auth with refresh tokens",
+      acceptanceCriteria: ["Token storage", "Refresh logic", "Expiry"],
+      tags: ["security", "auth"],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = keywordStrategy.route(story, context);
+
+    expect(decision).not.toBeNull();
+    expect(decision!.complexity).toBe("complex");
+    expect(decision!.modelTier).toBe("powerful");
+    expect(decision!.testStrategy).toBe("three-session-tdd");
+    expect(decision!.reasoning).toContain("security-critical");
+  });
+
+  test("uses three-session-tdd for public API", () => {
+    const story: UserStory = {
+      id: "US-005",
+      title: "Add public API endpoint",
+      description: "Create external API for consumers",
+      acceptanceCriteria: ["Endpoint returns JSON"],
+      tags: ["public api"],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = keywordStrategy.route(story, context);
+
+    expect(decision).not.toBeNull();
+    expect(decision!.testStrategy).toBe("three-session-tdd");
+    expect(decision!.reasoning).toContain("public-api");
+  });
+});
+
+describe("manualStrategy", () => {
+  test("returns decision from story.routing metadata", () => {
+    const story: UserStory = {
+      id: "US-006",
+      title: "Manual override test",
+      description: "Story with manual routing",
+      acceptanceCriteria: [],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+      routing: {
+        complexity: "expert",
+        modelTier: "powerful",
+        testStrategy: "three-session-tdd",
+        reasoning: "Manual override for critical task",
+      },
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = manualStrategy.route(story, context);
+
+    expect(decision).not.toBeNull();
+    expect(decision!.complexity).toBe("expert");
+    expect(decision!.modelTier).toBe("powerful");
+    expect(decision!.testStrategy).toBe("three-session-tdd");
+    expect(decision!.reasoning).toBe("Manual override for critical task");
+  });
+
+  test("returns null when no routing metadata", () => {
+    const story: UserStory = {
+      id: "US-007",
+      title: "No manual routing",
+      description: "Story without routing metadata",
+      acceptanceCriteria: [],
+      tags: [],
+      dependencies: [],
+      status: "pending",
+      passes: false,
+      escalations: [],
+      attempts: 0,
+    };
+
+    const configWithoutLlm = { ...DEFAULT_CONFIG, routing: { ...DEFAULT_CONFIG.routing, llm: undefined } };
+    const context: RoutingContext = { config: configWithoutLlm };
+    const decision = manualStrategy.route(story, context);
+
+    expect(decision).toBeNull();
+  });
+});
+
+describe("LLM Routing Strategy - Prompt Building", () => {
+  test("buildRoutingPrompt formats story correctly", () => {
+    const prompt = buildRoutingPrompt(simpleStory, DEFAULT_CONFIG);
+
+    expect(prompt).toContain("Title: Fix typo in README");
+    expect(prompt).toContain("Description: Correct spelling mistake");
+    expect(prompt).toContain("1. Update README.md with correct spelling");
+    expect(prompt).toContain("Tags: docs");
+    expect(prompt).toContain("fast: Simple changes");
+    expect(prompt).toContain("balanced: Standard features");
+    expect(prompt).toContain("powerful: Complex architecture");
+    expect(prompt).toContain("test-after: Write implementation first");
+    expect(prompt).toContain("three-session-tdd: Separate test-writer");
+  });
+
+  test("buildBatchPrompt formats multiple stories", () => {
+    const stories = [simpleStory, complexStory];
+    const prompt = buildBatchPrompt(stories, DEFAULT_CONFIG);
+
+    expect(prompt).toContain("1. US-001: Fix typo in README");
+    expect(prompt).toContain("2. US-002: Add JWT authentication");
+    expect(prompt).toContain("Tags: docs");
+    expect(prompt).toContain("Tags: security, auth");
+    expect(prompt).toContain('{"id":"US-001"');
+  });
+});
+
+describe("LLM Routing Strategy - Response Parsing", () => {
+  test("parseRoutingResponse handles valid JSON", () => {
+    const output =
+      '{"complexity":"simple","modelTier":"fast","testStrategy":"test-after","reasoning":"Simple documentation fix"}';
+    const decision = parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG);
+
+    expect(decision.complexity).toBe("simple");
+    expect(decision.modelTier).toBe("fast");
+    expect(decision.testStrategy).toBe("test-after");
+    expect(decision.reasoning).toBe("Simple documentation fix");
+  });
+
+  test("parseRoutingResponse strips markdown code blocks", () => {
+    const output =
+      '```json\n{"complexity":"complex","modelTier":"powerful","testStrategy":"three-session-tdd","reasoning":"Security-critical"}\n```';
+    const decision = parseRoutingResponse(output, complexStory, DEFAULT_CONFIG);
+
+    expect(decision.complexity).toBe("complex");
+    expect(decision.modelTier).toBe("powerful");
+    expect(decision.testStrategy).toBe("three-session-tdd");
+  });
+
+  test("parseRoutingResponse throws on invalid JSON", () => {
+    const output = "This is not JSON";
+    expect(() => parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG)).toThrow();
+  });
+
+  test("parseRoutingResponse throws on missing fields", () => {
+    const output = '{"complexity":"simple","modelTier":"fast"}';
+    expect(() => parseRoutingResponse(output, simpleStory, DEFAULT_CONFIG)).toThrow("Missing required fields");
+  });
+});
+
+describe("stripCodeFences", () => {
+  test("returns plain JSON unchanged", () => {
+    const input = '{"complexity":"simple"}';
+    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
+  });
+
+  test("strips ```json ... ``` fences", () => {
+    const input = '```json\n{"complexity":"simple"}\n```';
+    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
+  });
+
+  test("strips leading 'json' keyword (no backticks)", () => {
+    const input = 'json\n{"complexity":"simple"}';
+    expect(stripCodeFences(input)).toBe('{"complexity":"simple"}');
+  });
+});
+
+describe("validateRoutingDecision", () => {
+  test("returns valid decision for correct input", () => {
+    const input = { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "trivial" };
+    const result = validateRoutingDecision(input, DEFAULT_CONFIG);
+    expect(result).toEqual({
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "trivial",
+    });
+  });
+
+  test("throws on missing complexity", () => {
+    const input = { modelTier: "fast", testStrategy: "test-after", reasoning: "test" };
+    expect(() => validateRoutingDecision(input, DEFAULT_CONFIG)).toThrow("Missing required fields");
+  });
+
+  test("throws on invalid complexity value", () => {
+    const input = { complexity: "mega", modelTier: "fast", testStrategy: "test-after", reasoning: "test" };
+    expect(() => validateRoutingDecision(input, DEFAULT_CONFIG)).toThrow("Invalid complexity: mega");
+  });
+});

package/test/unit/storyid-events.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * BUG-020: Verify storyId is present in JSONL event logger calls.
  *

package/test/{ui → unit/ui}/tui-controls.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * TUI Controls Tests
  *
@@ -9,13 +10,13 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { render } from "ink-testing-library";
 import { createElement } from "react";
-import type { UserStory } from "../../src/prd/types";
-import { CostOverlay } from "../../src/tui/components/CostOverlay";
-import { HelpOverlay } from "../../src/tui/components/HelpOverlay";
-import type { KeyboardAction } from "../../src/tui/hooks/useKeyboard";
-import { PanelFocus } from "../../src/tui/types";
-import type { StoryDisplayState } from "../../src/tui/types";
-import { writeQueueCommand } from "../../src/utils/queue-writer";
+import type { UserStory } from "../../../src/prd/types";
+import { CostOverlay } from "../../../src/tui/components/CostOverlay";
+import { HelpOverlay } from "../../../src/tui/components/HelpOverlay";
+import type { KeyboardAction } from "../../../src/tui/hooks/useKeyboard";
+import { PanelFocus } from "../../../src/tui/types";
+import type { StoryDisplayState } from "../../../src/tui/types";
+import { writeQueueCommand } from "../../../src/utils/queue-writer";
 
 // Helper to create mock stories
 function createMockStory(id: string, status: StoryDisplayState["status"], cost = 0.01): StoryDisplayState {

package/test/{ui → unit/ui}/tui-cost-and-pty.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * TUI Cost Accumulation and PTY Line Length Tests
  *
@@ -5,9 +6,9 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { PipelineEventEmitter } from "../../src/pipeline/events";
-import type { StageResult } from "../../src/pipeline/types";
-import type { UserStory } from "../../src/prd/types";
+import { PipelineEventEmitter } from "../../../src/pipeline/events";
+import type { StageResult } from "../../../src/pipeline/types";
+import type { UserStory } from "../../../src/prd/types";
 
 // ── Test Fixtures ────────────────────────────────────
 

package/test/{ui → unit/ui}/tui-layout.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * TUI Layout Tests
  *
@@ -8,10 +9,10 @@
 import { describe, expect, test } from "bun:test";
 import { render } from "ink-testing-library";
 import { createElement } from "react";
-import type { UserStory } from "../../src/prd/types";
-import { StoriesPanel } from "../../src/tui/components/StoriesPanel";
-import { COMPACT_MAX_VISIBLE_STORIES, MAX_VISIBLE_STORIES, MIN_TERMINAL_WIDTH } from "../../src/tui/hooks/useLayout";
-import type { StoryDisplayState } from "../../src/tui/types";
+import type { UserStory } from "../../../src/prd/types";
+import { StoriesPanel } from "../../../src/tui/components/StoriesPanel";
+import { COMPACT_MAX_VISIBLE_STORIES, MAX_VISIBLE_STORIES, MIN_TERMINAL_WIDTH } from "../../../src/tui/hooks/useLayout";
+import type { StoryDisplayState } from "../../../src/tui/types";
 
 // Helper to create mock stories
 function createMockStory(id: string, status: StoryDisplayState["status"]): StoryDisplayState {

package/test/{ui → unit/ui}/tui-stories.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * TUI Stories Panel Tests
  *
@@ -8,10 +9,10 @@
 import { describe, expect, test } from "bun:test";
 import { render } from "ink-testing-library";
 import { createElement } from "react";
-import type { UserStory } from "../../src/prd/types";
-import { StatusBar } from "../../src/tui/components/StatusBar";
-import { StoriesPanel } from "../../src/tui/components/StoriesPanel";
-import type { StoryDisplayState } from "../../src/tui/types";
+import type { UserStory } from "../../../src/prd/types";
+import { StatusBar } from "../../../src/tui/components/StatusBar";
+import { StoriesPanel } from "../../../src/tui/components/StoriesPanel";
+import type { StoryDisplayState } from "../../../src/tui/types";
 
 // Helper to create mock stories
 function createMockStory(id: string, status: StoryDisplayState["status"]): StoryDisplayState {

package/test/unit/{isolation.test.ts → unit-isolation.test.ts}

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/tdd/isolation.ts
  *

package/test/unit/{helpers.test.ts → utils-helpers.test.ts}

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/execution/helpers.ts
  *

package/test/unit/verdict.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Tests for src/tdd/verdict.ts
  *

package/test/unit/verification/orchestrator-types.test.ts

@@ -0,0 +1,54 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import {
+  makeSkippedResult,
+  makePassResult,
+  makeFailResult,
+  type VerifyResult,
+} from "../../../src/verification/orchestrator-types";
+
+describe("makeSkippedResult", () => {
+  test("returns SKIPPED success result", () => {
+    const r = makeSkippedResult("US-001", "scoped");
+    expect(r.success).toBe(true);
+    expect(r.status).toBe("SKIPPED");
+    expect(r.storyId).toBe("US-001");
+    expect(r.strategy).toBe("scoped");
+    expect(r.countsTowardEscalation).toBe(false);
+    expect(r.failures).toEqual([]);
+  });
+});
+
+describe("makePassResult", () => {
+  test("returns PASS success result", () => {
+    const r = makePassResult("US-002", "regression", { passCount: 42, durationMs: 1234 });
+    expect(r.success).toBe(true);
+    expect(r.status).toBe("PASS");
+    expect(r.passCount).toBe(42);
+    expect(r.failCount).toBe(0);
+    expect(r.totalCount).toBe(42);
+    expect(r.durationMs).toBe(1234);
+    expect(r.countsTowardEscalation).toBe(false);
+  });
+});
+
+describe("makeFailResult", () => {
+  test("returns failure result with correct totals", () => {
+    const r = makeFailResult("US-003", "scoped", "TEST_FAILURE", {
+      passCount: 10,
+      failCount: 3,
+      durationMs: 5000,
+    });
+    expect(r.success).toBe(false);
+    expect(r.status).toBe("TEST_FAILURE");
+    expect(r.passCount).toBe(10);
+    expect(r.failCount).toBe(3);
+    expect(r.totalCount).toBe(13);
+    expect(r.countsTowardEscalation).toBe(true);
+  });
+
+  test("timeout does not count toward escalation by default when overridden", () => {
+    const r = makeFailResult("US-004", "scoped", "TIMEOUT", { countsTowardEscalation: false });
+    expect(r.countsTowardEscalation).toBe(false);
+  });
+});

package/test/unit/verification/orchestrator.test.ts

@@ -0,0 +1,66 @@
+// RE-ARCH: keep
+import { describe, expect, test } from "bun:test";
+import { VerificationOrchestrator } from "../../../src/verification/orchestrator";
+import type { IVerificationStrategy, VerifyContext, VerifyResult } from "../../../src/verification/orchestrator-types";
+import { makePassResult, makeSkippedResult } from "../../../src/verification/orchestrator-types";
+
+function makeCtx(): VerifyContext {
+  return {
+    workdir: "/tmp",
+    testCommand: "bun test",
+    timeoutSeconds: 60,
+    storyId: "US-001",
+  };
+}
+
+function makeStubStrategy(name: "scoped" | "regression" | "deferred-regression" | "acceptance", result: VerifyResult): IVerificationStrategy {
+  return {
+    name,
+    execute: async () => result,
+  };
+}
+
+describe("VerificationOrchestrator", () => {
+  test("delegates to scoped strategy", async () => {
+    const expected = makePassResult("US-001", "scoped");
+    const orch = new VerificationOrchestrator({
+      scoped: makeStubStrategy("scoped", expected),
+    });
+    const result = await orch.verifyScoped(makeCtx());
+    expect(result).toBe(expected);
+  });
+
+  test("delegates to regression strategy", async () => {
+    const expected = makePassResult("US-001", "regression");
+    const orch = new VerificationOrchestrator({
+      regression: makeStubStrategy("regression", expected),
+    });
+    const result = await orch.verifyRegression(makeCtx());
+    expect(result).toBe(expected);
+  });
+
+  test("delegates to deferred-regression strategy", async () => {
+    const expected = makeSkippedResult("US-001", "deferred-regression");
+    const orch = new VerificationOrchestrator({
+      "deferred-regression": makeStubStrategy("deferred-regression", expected),
+    });
+    const result = await orch.verifyDeferredRegression(makeCtx());
+    expect(result).toBe(expected);
+  });
+
+  test("delegates to acceptance strategy", async () => {
+    const expected = makeSkippedResult("US-001", "acceptance");
+    const orch = new VerificationOrchestrator({
+      acceptance: makeStubStrategy("acceptance", expected),
+    });
+    const result = await orch.verifyAcceptance(makeCtx());
+    expect(result).toBe(expected);
+  });
+
+  test("returns SKIPPED for unknown strategy", async () => {
+    const orch = new VerificationOrchestrator();
+    const result = await orch.verify(makeCtx(), "scoped");
+    // scoped strategy exists, just confirm it runs
+    expect(result.storyId).toBe("US-001");
+  });
+});

package/test/unit/verification/smart-runner-config.test.ts

@@ -1,3 +1,4 @@
+// RE-ARCH: keep
 /**
  * Smart Test Runner — Config Coercion Tests
  *