@nathapp/nax 0.24.0 → 0.26.0

package/test/unit/pipeline/subscribers/hooks.test.ts

@@ -11,11 +11,14 @@ describe("wireHooks", () => {
     const bus = new PipelineEventBus();
     wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
 
-    // Check subscriptions are registered
-    const events = ["run:started", "story:started", "story:completed", "story:failed", "story:paused", "run:paused", "run:completed"] as const;
-    for (const ev of events) {
+    // Single-subscriber events
+    const singleSubEvents = ["run:started", "story:started", "story:paused", "run:paused", "run:completed", "run:resumed", "run:errored"] as const;
+    for (const ev of singleSubEvents) {
       expect(bus.subscriberCount(ev)).toBe(1);
     }
+    // story:completed and story:failed each have 2: on-story-complete/fail + on-session-end
+    expect(bus.subscriberCount("story:completed")).toBe(2);
+    expect(bus.subscriberCount("story:failed")).toBe(2);
   });
 
   test("returns unsubscribe function that removes all subscriptions", () => {
@@ -24,7 +27,7 @@ describe("wireHooks", () => {
 
     unsub();
 
-    const events = ["run:started", "story:started", "story:completed"] as const;
+    const events = ["run:started", "story:started", "story:completed", "run:resumed", "run:errored"] as const;
     for (const ev of events) {
       expect(bus.subscriberCount(ev)).toBe(0);
     }
@@ -42,4 +45,40 @@ describe("wireHooks", () => {
       bus.emit({ type: "story:completed", storyId: "US-001", story: { id: "US-001" } as any, passed: true, durationMs: 100 }),
     ).not.toThrow();
   });
+
+  test("on-resume: run:resumed event triggers on-resume hook (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "run:resumed", feature: "test-feature" }),
+    ).not.toThrow();
+  });
+
+  test("on-session-end: story:completed triggers on-session-end with status passed (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "story:completed", storyId: "US-001", story: { id: "US-001" } as any, passed: true, durationMs: 100 }),
+    ).not.toThrow();
+  });
+
+  test("on-session-end: story:failed triggers on-session-end with status failed (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "story:failed", storyId: "US-001", story: { id: "US-001" } as any, reason: "test failure", countsTowardEscalation: true }),
+    ).not.toThrow();
+  });
+
+  test("on-error: run:errored event triggers on-error hook (fire-and-forget, no throw)", () => {
+    const bus = new PipelineEventBus();
+    wireHooks(bus, EMPTY_HOOKS, "/tmp", "test-feature");
+
+    expect(() =>
+      bus.emit({ type: "run:errored", reason: "SIGTERM", feature: "test-feature" }),
+    ).not.toThrow();
+  });
 });

package/test/unit/pipeline/subscribers/interaction.test.ts

@@ -1,8 +1,9 @@
 // RE-ARCH: keep
-import { describe, expect, test } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
 import { wireInteraction } from "../../../../src/pipeline/subscribers/interaction";
-import { PipelineEventBus } from "../../../../src/pipeline/event-bus";
+import { PipelineEventBus, type StoryFailedEvent } from "../../../../src/pipeline/event-bus";
 import { DEFAULT_CONFIG } from "../../../../src/config";
+import type { UserStory } from "../../../../src/prd";
 
 describe("wireInteraction", () => {
   test("no subscriptions when interactionChain is null", () => {
@@ -29,3 +30,284 @@ describe("wireInteraction", () => {
     unsub(); // should not throw
   });
 });
+
+describe("wireInteraction - max-retries trigger", () => {
+  let bus: PipelineEventBus;
+  let mockChain: any;
+  let mockLogger: any;
+  let loggedWarnings: Array<{ context: string; message: string; data: any }> = [];
+
+  beforeEach(() => {
+    bus = new PipelineEventBus();
+    mockChain = {
+      prompt: async () => ({ action: "skip" }),
+    };
+    loggedWarnings = [];
+  });
+
+  afterEach(() => {
+    bus.clear();
+  });
+
+  function createStoryFailedEvent(
+    overrides: Partial<StoryFailedEvent> = {},
+  ): StoryFailedEvent {
+    const story: UserStory = {
+      id: "US-001",
+      title: "Test Story",
+      description: "Test",
+      acceptanceCriteria: [],
+    };
+    return {
+      type: "story:failed",
+      storyId: "story-1",
+      story,
+      reason: "Test failed",
+      countsTowardEscalation: true,
+      feature: "test-feature",
+      attempts: 3,
+      ...overrides,
+    };
+  }
+
+  test("no subscription when max-retries trigger is disabled", () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: false } },
+      },
+    } as any;
+    wireInteraction(bus, mockChain, config);
+    expect(bus.subscriberCount("story:failed")).toBe(0);
+  });
+
+  test("no subscription when interactionChain is null", () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+    wireInteraction(bus, null, config);
+    expect(bus.subscriberCount("story:failed")).toBe(0);
+  });
+
+  test("fires max-retries trigger when countsTowardEscalation=true", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let triggerCalled = false;
+    mockChain.prompt = async (request: any) => {
+      triggerCalled = true;
+      expect(request.id).toContain("trigger-max-retries");
+      return { action: "skip" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+
+    // Give async handler time to execute
+    await Bun.sleep(10);
+    expect(triggerCalled).toBe(true);
+  });
+
+  test("does NOT fire max-retries trigger when countsTowardEscalation=false", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let triggerCalled = false;
+    mockChain.prompt = async () => {
+      triggerCalled = true;
+      return { action: "skip" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: false }));
+
+    await Bun.sleep(10);
+    expect(triggerCalled).toBe(false);
+  });
+
+  test("passes correct context to executeTrigger", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let capturedRequest: any;
+    mockChain.prompt = async (request: any) => {
+      capturedRequest = request;
+      return { action: "skip" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(
+      createStoryFailedEvent({
+        storyId: "story-42",
+        feature: "auth-feature",
+        attempts: 5,
+        countsTowardEscalation: true,
+      }),
+    );
+
+    await Bun.sleep(10);
+    expect(capturedRequest?.featureName).toBe("auth-feature");
+    expect(capturedRequest?.storyId).toBe("story-42");
+    // Verify the request ID contains the trigger name
+    expect(capturedRequest?.id).toContain("trigger-max-retries");
+  });
+
+  test("handles abort response with warning", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let loggedAbort = false;
+    const originalLogger = console.warn;
+    console.warn = ((context: string, message: string, data: any) => {
+      if (message === "max-retries abort requested") {
+        loggedAbort = true;
+      }
+    }) as any;
+
+    mockChain.prompt = async () => {
+      return { action: "abort" };
+    };
+
+    try {
+      wireInteraction(bus, mockChain, config);
+      bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+      await Bun.sleep(10);
+      // Note: actual logging behavior depends on getSafeLogger implementation
+    } finally {
+      console.warn = originalLogger;
+    }
+  });
+
+  test("handles skip response (default)", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let skipCalled = false;
+    mockChain.prompt = async () => {
+      skipCalled = true;
+      return { action: "skip" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+
+    await Bun.sleep(10);
+    expect(skipCalled).toBe(true);
+  });
+
+  test("handles escalate response (treated as skip)", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let escalateCalled = false;
+    mockChain.prompt = async () => {
+      escalateCalled = true;
+      return { action: "escalate" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+
+    await Bun.sleep(10);
+    expect(escalateCalled).toBe(true);
+  });
+
+  test("catches trigger execution errors gracefully", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    mockChain.prompt = async () => {
+      throw new Error("Trigger failed");
+    };
+
+    wireInteraction(bus, mockChain, config);
+    // Should not throw
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+    await Bun.sleep(10);
+  });
+
+  test("handles missing feature field", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let capturedRequest: any;
+    mockChain.prompt = async (request: any) => {
+      capturedRequest = request;
+      return { action: "skip" };
+    };
+
+    wireInteraction(bus, mockChain, config);
+    bus.emit(createStoryFailedEvent({ feature: undefined, countsTowardEscalation: true }));
+
+    await Bun.sleep(10);
+    expect(capturedRequest?.featureName).toBe("");
+  });
+
+  test("unsubscribes correctly", async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      interaction: {
+        ...DEFAULT_CONFIG.interaction,
+        triggers: { "max-retries": { enabled: true } },
+      },
+    } as any;
+
+    let triggerCalled = false;
+    mockChain.prompt = async () => {
+      triggerCalled = true;
+      return { action: "skip" };
+    };
+
+    const unsub = wireInteraction(bus, mockChain, config);
+    unsub();
+
+    bus.emit(createStoryFailedEvent({ countsTowardEscalation: true }));
+    await Bun.sleep(10);
+    expect(triggerCalled).toBe(false);
+  });
+});

package/test/unit/prd-auto-default.test.ts

@@ -257,7 +257,7 @@ describe("Router Tags Defensive Fallback (BUG-004)", () => {
 
     expect(result.complexity).toBe("simple");
     expect(result.modelTier).toBe("fast");
-    expect(result.testStrategy).toBe("three-session-tdd-lite");
+    expect(result.testStrategy).toBe("test-after");
   });
 
   test("routeTask handles null tags gracefully", () => {
@@ -271,7 +271,7 @@ describe("Router Tags Defensive Fallback (BUG-004)", () => {
 
     expect(result.complexity).toBe("simple");
     expect(result.modelTier).toBe("fast");
-    expect(result.testStrategy).toBe("three-session-tdd-lite");
+    expect(result.testStrategy).toBe("test-after");
   });
 
   test("routeTask with undefined tags does not crash on spread operation", () => {

package/test/unit/routing/content-hash.test.ts

@@ -0,0 +1,99 @@
+/**
+ * computeStoryContentHash — RRP-003
+ *
+ * AC-2: helper function computes a hash of title+description+ACs+tags
+ */
+
+import { describe, expect, test } from "bun:test";
+import { computeStoryContentHash } from "../../../src/routing";
+import type { UserStory } from "../../../src/prd/types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeStory(overrides?: Partial<UserStory>): UserStory {
+  return {
+    id: "US-001",
+    title: "Add login page",
+    description: "Users can log in with email and password",
+    acceptanceCriteria: ["Shows email field", "Shows password field", "Submits form"],
+    tags: ["auth", "ui"],
+    dependencies: [],
+    status: "pending",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// AC-2: computeStoryContentHash exists and returns a string
+// ---------------------------------------------------------------------------
+
+describe("computeStoryContentHash", () => {
+  test("returns a non-empty string", () => {
+    const story = makeStory();
+    const hash = computeStoryContentHash(story);
+    expect(typeof hash).toBe("string");
+    expect(hash.length).toBeGreaterThan(0);
+  });
+
+  test("same story content produces the same hash (deterministic)", () => {
+    const story1 = makeStory();
+    const story2 = makeStory();
+    expect(computeStoryContentHash(story1)).toBe(computeStoryContentHash(story2));
+  });
+
+  test("different title produces different hash", () => {
+    const base = makeStory();
+    const changed = makeStory({ title: "Add registration page" });
+    expect(computeStoryContentHash(base)).not.toBe(computeStoryContentHash(changed));
+  });
+
+  test("different description produces different hash", () => {
+    const base = makeStory();
+    const changed = makeStory({ description: "Users can log in via OAuth" });
+    expect(computeStoryContentHash(base)).not.toBe(computeStoryContentHash(changed));
+  });
+
+  test("different acceptanceCriteria produces different hash", () => {
+    const base = makeStory();
+    const changed = makeStory({
+      acceptanceCriteria: ["Shows email field", "Shows password field"],
+    });
+    expect(computeStoryContentHash(base)).not.toBe(computeStoryContentHash(changed));
+  });
+
+  test("different tags produces different hash", () => {
+    const base = makeStory();
+    const changed = makeStory({ tags: ["auth", "api"] });
+    expect(computeStoryContentHash(base)).not.toBe(computeStoryContentHash(changed));
+  });
+
+  test("story ID, status, and attempts do NOT affect the hash (only content fields)", () => {
+    const base = makeStory({ id: "US-001", status: "pending", attempts: 0 });
+    const differentMeta = makeStory({ id: "US-099", status: "in-progress", attempts: 3 });
+    expect(computeStoryContentHash(base)).toBe(computeStoryContentHash(differentMeta));
+  });
+
+  test("empty acceptanceCriteria and tags produce a valid hash", () => {
+    const story = makeStory({ acceptanceCriteria: [], tags: [] });
+    const hash = computeStoryContentHash(story);
+    expect(typeof hash).toBe("string");
+    expect(hash.length).toBeGreaterThan(0);
+  });
+
+  test("adding an AC changes the hash", () => {
+    const before = makeStory({ acceptanceCriteria: ["AC1", "AC2"] });
+    const after = makeStory({ acceptanceCriteria: ["AC1", "AC2", "AC3 — new"] });
+    expect(computeStoryContentHash(before)).not.toBe(computeStoryContentHash(after));
+  });
+
+  test("adding a tag changes the hash", () => {
+    const before = makeStory({ tags: ["backend"] });
+    const after = makeStory({ tags: ["backend", "security"] });
+    expect(computeStoryContentHash(before)).not.toBe(computeStoryContentHash(after));
+  });
+});

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

@@ -88,7 +88,7 @@ describe("BUG-031: keyword classifier stability across retries", () => {
 
     const result = keywordStrategy.route(story, ctx);
     expect(result!.complexity).toBe("simple");
-    expect(result!.testStrategy).toBe("three-session-tdd-lite");
+    expect(result!.testStrategy).toBe("test-after");
   });
 
   test("complexity is driven by title and tags only (not description)", () => {

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

@@ -86,8 +86,8 @@ describe("classifyComplexity", () => {
 });
 
 describe("determineTestStrategy", () => {
-  test("simple → three-session-tdd-lite", () => {
-    expect(determineTestStrategy("simple", "Fix typo", "Fix a typo", [])).toBe("three-session-tdd-lite");
+  test("simple → test-after (BUG-045)", () => {
+    expect(determineTestStrategy("simple", "Fix typo", "Fix a typo", [])).toBe("test-after");
   });
 
   test("complex → three-session-tdd", () => {
@@ -161,11 +161,11 @@ describe("determineTestStrategy", () => {
 });
 
 describe("routeTask", () => {
-  test("routes simple task to fast model with three-session-tdd-lite", () => {
+  test("routes simple task to fast model with test-after (BUG-045)", () => {
     const result = routeTask("Fix typo", "Fix a typo", ["Typo fixed"], [], DEFAULT_CONFIG);
     expect(result.complexity).toBe("simple");
     expect(result.modelTier).toBe("fast");
-    expect(result.testStrategy).toBe("three-session-tdd-lite");
+    expect(result.testStrategy).toBe("test-after");
   });
 
   test("routes security task to powerful with three-session-tdd", () => {
@@ -262,7 +262,7 @@ describe("routeTask", () => {
 
     test("default config (strategy='auto') routes simple to three-session-tdd-lite", () => {
       const simpleResult = routeTask("Fix typo", "Fix a typo", ["Typo fixed"], [], DEFAULT_CONFIG);
-      expect(simpleResult.testStrategy).toBe("three-session-tdd-lite");
+      expect(simpleResult.testStrategy).toBe("test-after");
 
       const complexResult = routeTask(
         "Auth refactor",

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

@@ -235,7 +235,7 @@ describe("keywordStrategy", () => {
     expect(decision).not.toBeNull();
     expect(decision!.complexity).toBe("simple");
     expect(decision!.modelTier).toBe("fast");
-    expect(decision!.testStrategy).toBe("three-session-tdd-lite");
+    expect(decision!.testStrategy).toBe("test-after");
   });
 
   test("classifies complex story with security keywords", () => {
@@ -352,8 +352,6 @@ describe("LLM Routing Strategy - Prompt Building", () => {
     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", () => {

package/test/unit/utils/git.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Unit tests for git utility functions (TC-003)
+ *
+ * Covers: detectMergeConflict helper
+ */
+
+import { describe, expect, test } from "bun:test";
+import { detectMergeConflict } from "../../../src/utils/git";
+
+describe("detectMergeConflict", () => {
+  test("returns true when output contains uppercase CONFLICT", () => {
+    expect(detectMergeConflict("CONFLICT (content): Merge conflict in src/foo.ts")).toBe(true);
+  });
+
+  test("returns true when output contains lowercase conflict", () => {
+    expect(detectMergeConflict("Auto-merging failed due to conflict in file")).toBe(true);
+  });
+
+  test("returns true for typical git merge CONFLICT output", () => {
+    const output = [
+      "Auto-merging src/index.ts",
+      "CONFLICT (content): Merge conflict in src/index.ts",
+      "Automatic merge failed; fix conflicts and then commit the result.",
+    ].join("\n");
+    expect(detectMergeConflict(output)).toBe(true);
+  });
+
+  test("returns true for git rebase CONFLICT output", () => {
+    const output = "CONFLICT (modify/delete): src/bar.ts deleted in HEAD";
+    expect(detectMergeConflict(output)).toBe(true);
+  });
+
+  test("returns false when output has no conflict markers", () => {
+    expect(detectMergeConflict("All changes committed successfully.")).toBe(false);
+  });
+
+  test("returns false for empty string", () => {
+    expect(detectMergeConflict("")).toBe(false);
+  });
+
+  test("returns false for unrelated git output", () => {
+    const output = "3 files changed, 10 insertions(+), 2 deletions(-)";
+    expect(detectMergeConflict(output)).toBe(false);
+  });
+
+  test("returns true when CONFLICT appears in stderr portion of combined output", () => {
+    const combined = "stdout: commit abc123\nstderr: CONFLICT detected in merge";
+    expect(detectMergeConflict(combined)).toBe(true);
+  });
+});