@nathapp/nax 0.24.0 → 0.26.0

package/test/unit/pipeline/stages/routing-initial-complexity.test.ts

@@ -0,0 +1,321 @@
+/**
+ * Routing Stage — RRP-002: initialComplexity written on first classify, never overwritten
+ *
+ * AC-1: StoryRouting interface gains initialComplexity?: Complexity field
+ * AC-2: Routing stage writes initialComplexity when story.routing is first created
+ * AC-3: Escalation path never overwrites initialComplexity
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../../../../src/config/defaults";
+import type { NaxConfig } from "../../../../src/config";
+import type { PRD, UserStory } from "../../../../src/prd";
+import type { PipelineContext } from "../../../../src/pipeline/types";
+import type { StoryRouting } from "../../../../src/prd/types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeStory(overrides?: Partial<UserStory>): UserStory {
+  return {
+    id: "US-001",
+    title: "Test Story",
+    description: "Test description",
+    acceptanceCriteria: [],
+    tags: [],
+    dependencies: [],
+    status: "in-progress",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+    ...overrides,
+  };
+}
+
+function makePRD(story: UserStory): PRD {
+  return {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "feat/test",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: [story],
+  };
+}
+
+function makeConfig(): NaxConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    tdd: {
+      ...DEFAULT_CONFIG.tdd,
+      greenfieldDetection: false,
+    },
+  };
+}
+
+function makeCtx(story: UserStory, overrides?: Partial<PipelineContext>): PipelineContext & { prdPath: string } {
+  const prd = makePRD(story);
+  return {
+    config: makeConfig(),
+    prd,
+    story,
+    stories: [story],
+    routing: {
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "test",
+    },
+    workdir: "/tmp/nax-routing-initial-complexity-test",
+    hooks: { hooks: {} },
+    prdPath: "/tmp/nax-routing-initial-complexity-test/nax/prd.json",
+    ...overrides,
+  } as PipelineContext & { prdPath: string };
+}
+
+const FRESH_ROUTING_RESULT = {
+  complexity: "medium" as const,
+  modelTier: "balanced" as const,
+  testStrategy: "three-session-tdd" as const,
+  reasoning: "classified by routeStory",
+};
+
+// ---------------------------------------------------------------------------
+// AC-2: initialComplexity written on first classify (story.routing undefined)
+// ---------------------------------------------------------------------------
+
+describe("routingStage - initialComplexity set on first classification", () => {
+  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
+
+  afterEach(() => {
+    mock.restore();
+    if (origRoutingDeps) {
+      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
+      Object.assign(_routingDeps, origRoutingDeps);
+    }
+  });
+
+  test("story.routing.initialComplexity is set to classified complexity on first classify", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // initialComplexity must equal the classified complexity
+    expect(ctx.story.routing?.initialComplexity).toBe(FRESH_ROUTING_RESULT.complexity);
+  });
+
+  test("story.routing.initialComplexity matches complexity on first classify", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    const expertRouting = {
+      complexity: "expert" as const,
+      modelTier: "powerful" as const,
+      testStrategy: "three-session-tdd" as const,
+      reasoning: "complex feature",
+    };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...expertRouting }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    expect(ctx.story.routing?.initialComplexity).toBe("expert");
+    expect(ctx.story.routing?.complexity).toBe("expert");
+  });
+
+  test("initialComplexity is written to PRD passed to savePRD on first classify", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    const savedPRDs: PRD[] = [];
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock((prd: PRD) => {
+      savedPRDs.push(prd);
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    expect(savedPRDs).toHaveLength(1);
+    const savedStory = savedPRDs[0].userStories.find((s) => s.id === story.id);
+    expect(savedStory?.routing?.initialComplexity).toBe(FRESH_ROUTING_RESULT.complexity);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AC-3: Escalation path never overwrites initialComplexity
+// ---------------------------------------------------------------------------
+
+describe("routingStage - initialComplexity never overwritten after first classify", () => {
+  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
+
+  afterEach(() => {
+    mock.restore();
+    if (origRoutingDeps) {
+      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
+      Object.assign(_routingDeps, origRoutingDeps);
+    }
+  });
+
+  test("initialComplexity is preserved when story.routing already exists (escalation path)", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    // Story has routing with initialComplexity from first classify and escalated modelTier
+    const escalatedRouting: StoryRouting = {
+      complexity: "simple",
+      initialComplexity: "simple",
+      modelTier: "powerful", // escalated from "fast"
+      testStrategy: "three-session-tdd",
+      reasoning: "escalated after failure",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "expert",
+        modelTier: "powerful",
+        testStrategy: "three-session-tdd",
+        reasoning: "re-classified",
+      }),
+    );
+    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: escalatedRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // initialComplexity must remain "simple" — never overwritten by escalation
+    expect(ctx.story.routing?.initialComplexity).toBe("simple");
+  });
+
+  test("only modelTier changes during escalation, initialComplexity stays the same", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    const routingAfterFirstClassify: StoryRouting = {
+      complexity: "medium",
+      initialComplexity: "medium", // set on first classify
+      modelTier: "powerful",       // escalated tier
+      testStrategy: "three-session-tdd",
+      reasoning: "persisted from first classify, escalated",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "complex",
+        modelTier: "balanced",
+        testStrategy: "three-session-tdd",
+        reasoning: "fresh",
+      }),
+    );
+    _routingDeps.complexityToModelTier = mock(() => "balanced" as const);
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: routingAfterFirstClassify });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // initialComplexity unchanged
+    expect(ctx.story.routing?.initialComplexity).toBe("medium");
+    // modelTier uses the escalated value
+    expect(ctx.routing.modelTier).toBe("powerful");
+  });
+
+  test("initialComplexity absent on story.routing with no initialComplexity is not touched (backward compat)", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    // Legacy routing without initialComplexity (backward compat)
+    const legacyRouting: StoryRouting = {
+      complexity: "simple",
+      testStrategy: "test-after",
+      reasoning: "legacy persisted routing",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "medium",
+        modelTier: "balanced",
+        testStrategy: "three-session-tdd",
+        reasoning: "re-classified",
+      }),
+    );
+    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: legacyRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // Should not have written initialComplexity onto an existing routing object
+    expect(ctx.story.routing?.initialComplexity).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AC-1: StoryRouting interface exposes initialComplexity field
+// ---------------------------------------------------------------------------
+
+describe("StoryRouting - initialComplexity field exists on type", () => {
+  test("StoryRouting accepts initialComplexity as optional Complexity field", () => {
+    const routing: StoryRouting = {
+      complexity: "medium",
+      testStrategy: "test-after",
+      reasoning: "test",
+      initialComplexity: "medium",
+    };
+    expect(routing.initialComplexity).toBe("medium");
+  });
+
+  test("StoryRouting is valid without initialComplexity (optional field)", () => {
+    const routing: StoryRouting = {
+      complexity: "simple",
+      testStrategy: "test-after",
+      reasoning: "test",
+    };
+    expect(routing.initialComplexity).toBeUndefined();
+  });
+});

package/test/unit/pipeline/stages/routing-persistence.test.ts

@@ -0,0 +1,380 @@
+/**
+ * Routing Stage — RRP-001: Persist initial routing to prd.json on first classification
+ *
+ * AC-1, AC-2, AC-3: Tests for persistence behavior, cached routing, and escalation.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../../../../src/config/defaults";
+import type { NaxConfig } from "../../../../src/config";
+import type { PRD, UserStory } from "../../../../src/prd";
+import type { PipelineContext } from "../../../../src/pipeline/types";
+import type { StoryRouting } from "../../../../src/prd/types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeStory(overrides?: Partial<UserStory>): UserStory {
+  return {
+    id: "US-001",
+    title: "Test Story",
+    description: "Test description",
+    acceptanceCriteria: [],
+    tags: [],
+    dependencies: [],
+    status: "in-progress",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+    ...overrides,
+  };
+}
+
+function makePRD(story: UserStory): PRD {
+  return {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "feat/test",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: [story],
+  };
+}
+
+function makeConfig(): NaxConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    tdd: {
+      ...DEFAULT_CONFIG.tdd,
+      greenfieldDetection: false,
+    },
+  };
+}
+
+function makeCtx(story: UserStory, overrides?: Partial<PipelineContext>): PipelineContext & { prdPath: string } {
+  const prd = makePRD(story);
+  return {
+    config: makeConfig(),
+    prd,
+    story,
+    stories: [story],
+    routing: {
+      complexity: "simple",
+      modelTier: "fast",
+      testStrategy: "test-after",
+      reasoning: "test",
+    },
+    workdir: "/tmp/nax-routing-test",
+    hooks: { hooks: {} },
+    prdPath: "/tmp/nax-routing-test/nax/prd.json",
+    ...overrides,
+  } as PipelineContext & { prdPath: string };
+}
+
+const FRESH_ROUTING_RESULT = {
+  complexity: "medium" as const,
+  modelTier: "balanced" as const,
+  testStrategy: "three-session-tdd" as const,
+  reasoning: "classified by routeStory",
+};
+
+// ---------------------------------------------------------------------------
+// AC-1 & AC-5: savePRD is called on first classification (story.routing undefined)
+// ---------------------------------------------------------------------------
+
+describe("routingStage - first classification persists routing to prd.json", () => {
+  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
+  let savePRDCallArgs: Array<[PRD, string]>;
+
+  beforeEach(() => {
+    savePRDCallArgs = [];
+  });
+
+  afterEach(() => {
+    mock.restore();
+    // Restore original deps after each test
+    if (origRoutingDeps) {
+      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
+      Object.assign(_routingDeps, origRoutingDeps);
+    }
+  });
+
+  test("calls savePRD with updated prd when story.routing is undefined", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
+      savePRDCallArgs.push([prd, path]);
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // savePRD must have been called exactly once
+    expect(savePRDCallArgs).toHaveLength(1);
+  });
+
+  test("persists correct prdPath to savePRD on first classification", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
+      savePRDCallArgs.push([prd, path]);
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: undefined });
+    const prdPath = "/tmp/nax-routing-test/nax/prd.json";
+    const ctx = makeCtx(story, { prdPath } as Partial<PipelineContext>);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    const [, savedPath] = savePRDCallArgs[0];
+    expect(savedPath).toBe(prdPath);
+  });
+
+  test("story.routing is populated on prd after fresh classification", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock((prd: PRD, path: string) => {
+      savePRDCallArgs.push([prd, path]);
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // The story in the PRD passed to savePRD must have routing populated
+    const [savedPrd] = savePRDCallArgs[0];
+    const savedStory = savedPrd.userStories.find((s) => s.id === story.id);
+    expect(savedStory?.routing).toBeDefined();
+    expect(savedStory?.routing?.complexity).toBe(FRESH_ROUTING_RESULT.complexity);
+    expect(savedStory?.routing?.testStrategy).toBe(FRESH_ROUTING_RESULT.testStrategy);
+  });
+
+  test("ctx.story.routing is set to fresh classification result", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    _routingDeps.routeStory = mock(() => Promise.resolve({ ...FRESH_ROUTING_RESULT }));
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: undefined });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // story.routing must be populated so a crash+resume finds it
+    expect(ctx.story.routing).toBeDefined();
+    expect(ctx.story.routing?.complexity).toBe(FRESH_ROUTING_RESULT.complexity);
+    expect(ctx.story.routing?.testStrategy).toBe(FRESH_ROUTING_RESULT.testStrategy);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AC-2: No re-classification when story.routing already exists
+// ---------------------------------------------------------------------------
+
+describe("routingStage - skips savePRD when story.routing already set", () => {
+  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
+  let savePRDCallCount: number;
+
+  beforeEach(() => {
+    savePRDCallCount = 0;
+  });
+
+  afterEach(() => {
+    mock.restore();
+    if (origRoutingDeps) {
+      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
+      Object.assign(_routingDeps, origRoutingDeps);
+    }
+  });
+
+  test("does NOT call savePRD when story.routing is already populated", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    const existingRouting: StoryRouting = {
+      complexity: "simple",
+      testStrategy: "test-after",
+      reasoning: "persisted from prior run",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "medium",
+        modelTier: "balanced",
+        testStrategy: "three-session-tdd",
+        reasoning: "re-classified",
+      }),
+    );
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => {
+      savePRDCallCount++;
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: existingRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    expect(savePRDCallCount).toBe(0);
+  });
+
+  test("uses persisted complexity/testStrategy (not re-classified values) when story.routing exists", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    const existingRouting: StoryRouting = {
+      complexity: "simple",
+      testStrategy: "test-after",
+      reasoning: "persisted",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "expert",
+        modelTier: "powerful",
+        testStrategy: "three-session-tdd",
+        reasoning: "fresh",
+      }),
+    );
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: existingRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // Should use persisted values, not re-classified ones
+    expect(ctx.routing.complexity).toBe("simple");
+    expect(ctx.routing.testStrategy).toBe("test-after");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// AC-3: Escalation still overwrites modelTier/testStrategy (not protected)
+// ---------------------------------------------------------------------------
+
+describe("routingStage - escalation overwrites modelTier even after persistence", () => {
+  let origRoutingDeps: typeof import("../../../../src/pipeline/stages/routing")["_routingDeps"];
+
+  afterEach(() => {
+    mock.restore();
+    if (origRoutingDeps) {
+      const { _routingDeps } = require("../../../../src/pipeline/stages/routing");
+      Object.assign(_routingDeps, origRoutingDeps);
+    }
+  });
+
+  test("uses escalated modelTier from story.routing when explicitly set", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    // Story has routing with escalated modelTier (set by handleTierEscalation)
+    const escalatedRouting: StoryRouting = {
+      complexity: "simple",
+      modelTier: "powerful", // escalated from "fast"
+      testStrategy: "three-session-tdd",
+      reasoning: "escalated",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "simple",
+        modelTier: "fast",
+        testStrategy: "test-after",
+        reasoning: "fresh",
+      }),
+    );
+    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => Promise.resolve());
+
+    const story = makeStory({ routing: escalatedRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // escalated modelTier must take priority (BUG-032)
+    expect(ctx.routing.modelTier).toBe("powerful");
+  });
+
+  test("savePRD is NOT called during escalation (routing already persisted)", async () => {
+    const { routingStage, _routingDeps } = await import(
+      "../../../../src/pipeline/stages/routing"
+    );
+
+    origRoutingDeps = { ..._routingDeps };
+
+    let savePRDCalled = false;
+
+    const escalatedRouting: StoryRouting = {
+      complexity: "simple",
+      modelTier: "powerful",
+      testStrategy: "three-session-tdd",
+      reasoning: "escalated",
+    };
+
+    _routingDeps.routeStory = mock(() =>
+      Promise.resolve({
+        complexity: "simple",
+        modelTier: "fast",
+        testStrategy: "test-after",
+        reasoning: "fresh",
+      }),
+    );
+    _routingDeps.complexityToModelTier = mock(() => "fast" as const);
+    _routingDeps.isGreenfieldStory = mock(() => Promise.resolve(false));
+    _routingDeps.savePRD = mock(() => {
+      savePRDCalled = true;
+      return Promise.resolve();
+    });
+
+    const story = makeStory({ routing: escalatedRouting });
+    const ctx = makeCtx(story);
+
+    await routingStage.execute(ctx as Parameters<typeof routingStage.execute>[0]);
+
+    // Routing already exists — no need to re-persist
+    expect(savePRDCalled).toBe(false);
+  });
+});