muonroi-cli 1.2.0

package/src/pil/__tests__/budget.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_TOKEN_BUDGET, truncateToBudget } from "../budget";
+
+describe("truncateToBudget", () => {
+  it("allows ~4 chars per token of budget", () => {
+    const text = "a".repeat(400);
+    const result = truncateToBudget(text, 100);
+    expect(result).toBe(text);
+  });
+
+  it("truncates text exceeding budget in token-equivalent chars", () => {
+    const text = "a".repeat(500);
+    const result = truncateToBudget(text, 100);
+    expect(result.length).toBeLessThanOrEqual(404);
+  });
+
+  it("returns short text unchanged", () => {
+    expect(truncateToBudget("hello world", 100)).toBe("hello world");
+  });
+
+  it("truncates at word boundary when possible", () => {
+    const text = "word ".repeat(120);
+    const result = truncateToBudget(text, 100);
+    expect(result.endsWith("...")).toBe(true);
+    expect(result.length).toBeLessThanOrEqual(404);
+  });
+
+  it("handles empty string", () => {
+    expect(truncateToBudget("", 100)).toBe("");
+  });
+
+  it("handles budget=0 by truncating everything", () => {
+    expect(truncateToBudget("hello", 0)).toBe("...");
+  });
+
+  it("DEFAULT_TOKEN_BUDGET is 500", () => {
+    expect(DEFAULT_TOKEN_BUDGET).toBe(500);
+  });
+});

package/src/pil/__tests__/layer1-intent.test.ts

@@ -0,0 +1,243 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PipelineContext } from "../types.js";
+
+vi.mock("../../router/classifier/index.js", () => ({
+  classify: vi.fn(),
+}));
+
+vi.mock("../../ee/bridge.js", () => ({
+  classifyViaBrain: vi.fn().mockResolvedValue(null),
+}));
+
+import { classify } from "../../router/classifier/index.js";
+import { classifyViaBrain } from "../../ee/bridge.js";
+import { layer1Intent } from "../layer1-intent.js";
+
+const mockClassify = vi.mocked(classify);
+const mockClassifyViaBrain = vi.mocked(classifyViaBrain);
+
+const makeCtx = (raw = "test prompt"): PipelineContext => ({
+  raw,
+  enriched: raw,
+  taskType: null,
+  domain: null,
+  confidence: 0,
+  outputStyle: null,
+  tokenBudget: 500,
+  metrics: null,
+  layers: [],
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("layer1Intent — classifier pass", () => {
+  it("regex:refactor → refactor, confidence stored", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
+    const result = await layer1Intent(makeCtx("refactor this function"));
+    expect(result.taskType).toBe("refactor");
+    expect(result.confidence).toBe(0.85);
+    expect(result.layers[0].applied).toBe(true);
+    expect(result.layers[0].delta).toContain("taskType=refactor");
+    expect(result.layers[0].delta).toContain("conf=0.85");
+  });
+
+  it("regex:edit → generate", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:edit" });
+    const result = await layer1Intent(makeCtx("edit the file"));
+    expect(result.taskType).toBe("generate");
+  });
+
+  it("regex:install → analyze", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:install" });
+    const result = await layer1Intent(makeCtx("install the package"));
+    expect(result.taskType).toBe("analyze");
+    expect(result.layers[0].applied).toBe(true);
+  });
+
+  it("regex:run-command → analyze", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:run-command" });
+    const result = await layer1Intent(makeCtx("run bun test"));
+    expect(result.taskType).toBe("analyze");
+  });
+
+  it("tree-sitter:typescript → refactor, domain=typescript", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:typescript" });
+    const result = await layer1Intent(makeCtx("const x = 1"));
+    expect(result.taskType).toBe("refactor");
+    expect(result.domain).toBe("typescript");
+    expect(result.layers[0].delta).toContain("domain=typescript");
+  });
+
+  it("tree-sitter:python → refactor, domain=python", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:python" });
+    const result = await layer1Intent(makeCtx("def foo(): pass"));
+    expect(result.taskType).toBe("refactor");
+    expect(result.domain).toBe("python");
+  });
+
+  it("low-confidence → null taskType, applied=false", async () => {
+    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.3, reason: "low-confidence" });
+    const result = await layer1Intent(makeCtx("hello there"));
+    expect(result.taskType).toBeNull();
+    expect(result.layers[0].applied).toBe(false);
+    expect(result.layers[0].delta).toBeNull();
+  });
+
+  it("regex:search → analyze", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:search" });
+    const result = await layer1Intent(makeCtx("search for the function"));
+    expect(result.taskType).toBe("analyze");
+  });
+});
+
+describe("layer1Intent — keyword fallback (classifier returns null)", () => {
+  beforeEach(() => {
+    // Simulate classifier abstain so keyword fallback activates
+    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
+  });
+
+  it('keyword "bug" → debug', async () => {
+    const result = await layer1Intent(makeCtx("there is a bug in the login flow"));
+    expect(result.taskType).toBe("debug");
+    expect(result.confidence).toBe(0.65);
+    expect(result.layers[0].applied).toBe(true);
+  });
+
+  it('keyword "error" → debug', async () => {
+    const result = await layer1Intent(makeCtx("getting an error on line 42"));
+    expect(result.taskType).toBe("debug");
+  });
+
+  it('keyword "plan" → plan', async () => {
+    const result = await layer1Intent(makeCtx("plan the refactor approach"));
+    expect(result.taskType).toBe("plan");
+    expect(result.confidence).toBe(0.6);
+  });
+
+  it('keyword "docs" → documentation', async () => {
+    const result = await layer1Intent(makeCtx("write docs for this module"));
+    expect(result.taskType).toBe("documentation");
+    expect(result.confidence).toBe(0.6);
+  });
+
+  it('keyword "test" → analyze', async () => {
+    const result = await layer1Intent(makeCtx("write tests for the auth module"));
+    expect(result.taskType).toBe("analyze");
+  });
+
+  it("no keyword match → null (still conversational)", async () => {
+    const result = await layer1Intent(makeCtx("hello how are you"));
+    expect(result.taskType).toBeNull();
+    expect(result.layers[0].applied).toBe(false);
+  });
+});
+
+describe("layer1Intent — outputStyle detection", () => {
+  it("coding task + brain returns style → outputStyle set", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
+    mockClassifyViaBrain.mockResolvedValue("concise");
+    const result = await layer1Intent(makeCtx("refactor this function"));
+    expect(result.outputStyle).toBe("concise");
+  });
+
+  it("coding task + brain returns null → outputStyle stays null", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
+    mockClassifyViaBrain.mockResolvedValue(null);
+    const result = await layer1Intent(makeCtx("refactor this function"));
+    expect(result.outputStyle).toBeNull();
+  });
+
+  it("conversational turn (taskType=null) → outputStyle=null, no style brain call", async () => {
+    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
+    mockClassifyViaBrain.mockResolvedValue(null);
+    const result = await layer1Intent(makeCtx("hello how are you"));
+    expect(result.outputStyle).toBeNull();
+  });
+});
+
+describe("layer1Intent — EE brain bridge fallback (Pass 3)", () => {
+  beforeEach(() => {
+    mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
+    mockClassifyViaBrain.mockResolvedValue(null);
+  });
+
+  it("classifyViaBrain called when classifier and keywords both miss", async () => {
+    await layer1Intent(makeCtx("some ambiguous input without keywords"));
+    expect(mockClassifyViaBrain).toHaveBeenCalled();
+    expect(mockClassifyViaBrain).toHaveBeenCalledWith(
+      expect.stringContaining("Classify this prompt"),
+      100,
+    );
+  });
+
+  it("classifyViaBrain called with prompt containing task type and style instruction", async () => {
+    await layer1Intent(makeCtx("some ambiguous input"));
+    const [promptArg] = mockClassifyViaBrain.mock.calls[0];
+    expect(promptArg).toContain("refactor");
+    expect(promptArg).toContain("debug");
+    expect(promptArg).toContain("concise");
+    expect(promptArg).toContain("detailed");
+  });
+
+  it("classifyViaBrain called with 100ms timeout for combined detection", async () => {
+    await layer1Intent(makeCtx("some ambiguous input"));
+    expect(mockClassifyViaBrain).toHaveBeenCalledWith(expect.any(String), 100);
+  });
+
+  it("brain returns 'debug' → taskType='debug', confidence=0.55", async () => {
+    mockClassifyViaBrain.mockResolvedValue("debug");
+    const result = await layer1Intent(makeCtx("some ambiguous input"));
+    expect(result.taskType).toBe("debug");
+    expect(result.confidence).toBe(0.55);
+  });
+
+  it("brain returns null (absent/timeout) → taskType stays null", async () => {
+    mockClassifyViaBrain.mockResolvedValue(null);
+    const result = await layer1Intent(makeCtx("some ambiguous input"));
+    expect(result.taskType).toBeNull();
+  });
+
+  it("brain returns 'none' → taskType stays null", async () => {
+    mockClassifyViaBrain.mockResolvedValue("none");
+    const result = await layer1Intent(makeCtx("some ambiguous input"));
+    expect(result.taskType).toBeNull();
+  });
+
+  it("brain returns garbage → taskType stays null", async () => {
+    mockClassifyViaBrain.mockResolvedValue("I cannot classify this prompt");
+    const result = await layer1Intent(makeCtx("some ambiguous input"));
+    expect(result.taskType).toBeNull();
+  });
+
+  it("classifyViaBrain called for style detection even when classifier returns high confidence", async () => {
+    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
+    await layer1Intent(makeCtx("refactor this"));
+    expect(mockClassifyViaBrain).toHaveBeenCalledWith(
+      expect.stringContaining("concise, balanced, or detailed"),
+      50,
+    );
+  });
+
+  it("classifyViaBrain called for style detection even when keyword match found", async () => {
+    await layer1Intent(makeCtx("there is a bug here"));
+    expect(mockClassifyViaBrain).toHaveBeenCalledWith(
+      expect.stringContaining("concise, balanced, or detailed"),
+      50,
+    );
+  });
+});
+
+describe("layer1Intent — error handling", () => {
+  it("classify throws → ctx unchanged, applied=false", async () => {
+    mockClassify.mockImplementation(() => {
+      throw new Error("classify failed");
+    });
+    const ctx = makeCtx("some prompt");
+    const result = await layer1Intent(ctx);
+    expect(result.taskType).toBeNull();
+    expect(result.layers[0].applied).toBe(false);
+    expect(result.enriched).toBe(ctx.enriched);
+  });
+});

package/src/pil/__tests__/layer2-personality.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "vitest";
+import { layer2Personality } from "../layer2-personality";
+import type { PipelineContext } from "../types";
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    raw: "refactor the auth module",
+    enriched: "refactor the auth module",
+    taskType: "refactor",
+    domain: null,
+    confidence: 0.9,
+    outputStyle: "concise",
+    tokenBudget: 500,
+    metrics: null,
+    layers: [{ name: "intent-detection", applied: true, delta: "taskType=refactor" }],
+    ...overrides,
+  };
+}
+
+describe("layer2Personality", () => {
+  test("appends personality hint for concise outputStyle", async () => {
+    const result = await layer2Personality(makeCtx({ outputStyle: "concise" }));
+    expect(result.enriched).toContain("[personality:");
+    expect(result.enriched).toContain("concise");
+    const layer = result.layers.find((l) => l.name === "personality-adaptation");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(true);
+  });
+
+  test("appends personality hint for detailed outputStyle", async () => {
+    const result = await layer2Personality(makeCtx({ outputStyle: "detailed" }));
+    expect(result.enriched).toContain("detailed");
+    const layer = result.layers.find((l) => l.name === "personality-adaptation");
+    expect(layer!.applied).toBe(true);
+  });
+
+  test("applies balanced personality when outputStyle is balanced", async () => {
+    const result = await layer2Personality(makeCtx({ outputStyle: "balanced" }));
+    const layer = result.layers.find((l) => l.name === "personality-adaptation");
+    expect(layer!.applied).toBe(true);
+  });
+
+  test("defaults to balanced when outputStyle is null (never skips)", async () => {
+    const result = await layer2Personality(makeCtx({ outputStyle: null }));
+    const layer = result.layers.find((l) => l.name === "personality-adaptation");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(true);
+    expect(result.outputStyle).toBe("balanced");
+    expect(layer!.delta).toContain("source=default");
+  });
+
+  test("respects tokenBudget — hint stays within budget", async () => {
+    const result = await layer2Personality(makeCtx({ tokenBudget: 50 }));
+    const layer = result.layers.find((l) => l.name === "personality-adaptation");
+    if (layer?.delta) {
+      const charsMatch = layer.delta.match(/chars=(\d+)/);
+      if (charsMatch) {
+        const chars = parseInt(charsMatch[1], 10);
+        expect(chars).toBeLessThanOrEqual(50 * 4);
+      }
+    }
+  });
+});

package/src/pil/__tests__/layer3-ee-injection.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { layer3EeInjection } from "../layer3-ee-injection";
+import type { PipelineContext } from "../types";
+
+vi.mock("../../ee/bridge.js", () => ({
+  getEmbeddingRaw: vi.fn().mockResolvedValue(null),
+  searchCollection: vi.fn().mockResolvedValue([]),
+}));
+
+import { getEmbeddingRaw, searchCollection } from "../../ee/bridge.js";
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    raw: "debug the login flow",
+    enriched: "debug the login flow",
+    taskType: "debug",
+    domain: null,
+    confidence: 0.85,
+    outputStyle: "concise",
+    tokenBudget: 500,
+    metrics: null,
+    layers: [],
+    ...overrides,
+  };
+}
+
+describe("layer3EeInjection (bridge-based)", () => {
+  beforeEach(() => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue(null);
+    vi.mocked(searchCollection).mockResolvedValue([]);
+  });
+
+  test("Test 1: returns enriched context with hints when getEmbeddingRaw returns vector and searchCollection returns points with payload.text", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue([0.1, 0.2, 0.3]);
+    vi.mocked(searchCollection).mockResolvedValue([
+      { id: "abc1", score: 0.92, payload: { text: "Always check null before accessing .user" } },
+      { id: "def2", score: 0.88, payload: { text: "Use try-catch around DB calls" } },
+    ]);
+
+    const result = await layer3EeInjection(makeCtx());
+    expect(result.enriched).toContain("[experience:");
+    expect(result.enriched).toContain("Always check null before accessing .user");
+    const layer = result.layers.find((l) => l.name === "ee-experience-injection");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(true);
+  });
+
+  test("Test 2: returns ctx unchanged with applied=false and delta=no-embedding when getEmbeddingRaw returns null", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue(null);
+
+    const ctx = makeCtx();
+    const result = await layer3EeInjection(ctx);
+    expect(result.enriched).toBe(ctx.enriched);
+    const layer = result.layers.find((l) => l.name === "ee-experience-injection");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(false);
+    expect(layer!.delta).toContain("no-embedding");
+  });
+
+  test("Test 3: returns ctx unchanged with applied=false and delta=no-points when searchCollection returns []", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue([0.1, 0.2, 0.3]);
+    vi.mocked(searchCollection).mockResolvedValue([]);
+
+    const ctx = makeCtx();
+    const result = await layer3EeInjection(ctx);
+    expect(result.enriched).toBe(ctx.enriched);
+    const layer = result.layers.find((l) => l.name === "ee-experience-injection");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(false);
+    expect(layer!.delta).toBe("no-points");
+  });
+
+  test("Test 4: extracts text from payload.json containing solution field", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue([0.1, 0.2, 0.3]);
+    vi.mocked(searchCollection).mockResolvedValue([
+      { id: "xyz9", score: 0.75, payload: { json: JSON.stringify({ solution: "Always validate inputs at boundary" }) } },
+    ]);
+
+    const result = await layer3EeInjection(makeCtx());
+    expect(result.enriched).toContain("Always validate inputs at boundary");
+    const layer = result.layers.find((l) => l.name === "ee-experience-injection");
+    expect(layer!.applied).toBe(true);
+  });
+
+  test("Test 5: hints are truncated via truncateToBudget at 30% of tokenBudget", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue([0.1, 0.2, 0.3]);
+    const longText = "A".repeat(2000);
+    vi.mocked(searchCollection).mockResolvedValue([
+      { id: "x", score: 0.9, payload: { text: longText } },
+    ]);
+
+    const result = await layer3EeInjection(makeCtx({ tokenBudget: 100 }));
+    const layer = result.layers.find((l) => l.name === "ee-experience-injection");
+    expect(layer!.applied).toBe(true);
+    if (layer?.delta) {
+      const charsMatch = layer.delta.match(/chars=(\d+)/);
+      if (charsMatch) {
+        const chars = parseInt(charsMatch[1], 10);
+        // 30% of 100 tokens * 4 chars/token = 120 chars max; +3 for possible "..." suffix
+        expect(chars).toBeLessThanOrEqual(123);
+      }
+    }
+  });
+
+  test("Test 6: collection name is always 'experience-behavioral' regardless of taskType", async () => {
+    vi.mocked(getEmbeddingRaw).mockResolvedValue([0.1, 0.2, 0.3]);
+    vi.mocked(searchCollection).mockResolvedValue([]);
+
+    await layer3EeInjection(makeCtx({ taskType: "refactor" }));
+    expect(vi.mocked(searchCollection)).toHaveBeenCalledWith(
+      "experience-behavioral",
+      expect.any(Array),
+      expect.any(Number),
+      expect.any(Object),
+    );
+  });
+});

package/src/pil/__tests__/layer4-gsd.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { layer4Gsd } from "../layer4-gsd";
+import type { PipelineContext } from "../types";
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    raw: "implement the login feature",
+    enriched: "implement the login feature",
+    taskType: "generate",
+    domain: null,
+    confidence: 0.9,
+    outputStyle: "concise",
+    tokenBudget: 500,
+    metrics: null,
+    layers: [],
+    ...overrides,
+  };
+}
+
+describe("layer4Gsd", () => {
+  it("detects execute phase from raw prompt and appends hint", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "implement the login feature" }));
+    expect(result.enriched).toContain("[gsd:");
+    expect(result.enriched).toContain("execute");
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(true);
+    expect(layer!.delta).toContain("phase=execute");
+  });
+
+  it("uses gsdPhase from context if already set", async () => {
+    const result = await layer4Gsd(makeCtx({ gsdPhase: "plan", raw: "do something" }));
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    expect(layer!.applied).toBe(true);
+    expect(layer!.delta).toContain("phase=plan");
+  });
+
+  it("detects plan phase from keywords", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "plan the architecture" }));
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    expect(layer!.applied).toBe(true);
+    // EE bridge may route "plan the architecture" to discuss (qc-flow) or plan (keyword)
+    expect(layer!.delta).toMatch(/phase=(plan|discuss)/);
+  });
+
+  it("detects verify phase from keywords", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "test this function" }));
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    expect(layer!.applied).toBe(true);
+    // EE bridge may route "test this function" to execute (qc-lock) or verify (keyword)
+    expect(layer!.delta).toMatch(/phase=(verify|execute)/);
+  });
+
+  it("skips when no phase detected and no gsdPhase in context", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "hello there", gsdPhase: null }));
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(false);
+  });
+
+  it("respects tokenBudget", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "implement this", tokenBudget: 30 }));
+    const layer = result.layers.find((l) => l.name === "gsd-workflow-structuring");
+    if (layer?.applied && layer.delta) {
+      const charsMatch = layer.delta.match(/chars=(\d+)/);
+      if (charsMatch) {
+        expect(parseInt(charsMatch[1], 10)).toBeLessThanOrEqual(30 * 4);
+      }
+    }
+  });
+
+  it("updates gsdPhase on context when detected", async () => {
+    const result = await layer4Gsd(makeCtx({ raw: "review the pull request" }));
+    expect(result.gsdPhase).toBe("review");
+  });
+});

package/src/pil/__tests__/layer5-context.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it, vi } from "vitest";
+import type { PipelineContext } from "../types";
+
+vi.mock("../../ee/bridge.js", () => ({
+  getEmbeddingRaw: vi.fn().mockResolvedValue(null),
+  searchCollection: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    promises: {
+      ...actual.promises,
+      readFile: vi.fn().mockRejectedValue(new Error("not found")),
+      readdir: vi.fn().mockRejectedValue(new Error("not found")),
+      stat: vi.fn().mockRejectedValue(new Error("not found")),
+    },
+  };
+});
+
+import { layer5Context } from "../layer5-context";
+
+function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
+  return {
+    raw: "continue working on the auth module",
+    enriched: "continue working on the auth module",
+    taskType: "refactor",
+    domain: null,
+    confidence: 0.9,
+    outputStyle: "concise",
+    tokenBudget: 500,
+    metrics: null,
+    layers: [],
+    ...overrides,
+  };
+}
+
+describe("layer5Context", () => {
+  it("injects resume digest when available", async () => {
+    const digest = "Last session: refactored auth middleware, JWT validation working, need to add refresh token logic.";
+    const result = await layer5Context(makeCtx({ resumeDigest: digest }));
+    expect(result.enriched).toContain("[flow-context:");
+    expect(result.enriched).toContain("refactored auth middleware");
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(true);
+    expect(layer!.delta).toContain("digest=");
+  });
+
+  it("no digest, no EE, no flow → applied=false", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: null }));
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer).toBeDefined();
+    expect(layer!.applied).toBe(false);
+  });
+
+  it("no digest undefined → applied=false (with mocked EE)", async () => {
+    const result = await layer5Context(makeCtx());
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer!.applied).toBe(false);
+  });
+
+  it("empty digest → applied=false (with mocked EE)", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: "" }));
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer!.applied).toBe(false);
+  });
+
+  it("includes digest in delta when present", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: "Some digest", activeRunId: "abc123" }));
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer!.applied).toBe(true);
+    expect(layer!.delta).toContain("digest=");
+  });
+
+  it("respects tokenBudget — truncates long digest", async () => {
+    const longDigest = "Context: ".repeat(500);
+    const result = await layer5Context(makeCtx({ resumeDigest: longDigest, tokenBudget: 50 }));
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    if (layer?.delta) {
+      const charsMatch = layer.delta.match(/chars=(\d+)/);
+      if (charsMatch) {
+        expect(parseInt(charsMatch[1], 10)).toBeLessThanOrEqual(50 * 4);
+      }
+    }
+  });
+
+  it("adds stale warning when digest is older than 30 minutes", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: "Previous work on auth", digestAgeMs: 60 * 60 * 1000 }));
+    expect(result.enriched).toContain("stale");
+    const layer = result.layers.find((l) => l.name === "context-enrichment");
+    expect(layer!.delta).toContain("stale");
+  });
+
+  it("no stale warning when digest is fresh", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: "Recent work", digestAgeMs: 5 * 60 * 1000 }));
+    expect(result.enriched).not.toContain("stale");
+  });
+
+  it("no stale warning when digestAgeMs is undefined", async () => {
+    const result = await layer5Context(makeCtx({ resumeDigest: "Some work" }));
+    expect(result.enriched).not.toContain("stale");
+  });
+
+  it("preserves existing enriched content", async () => {
+    const result = await layer5Context(
+      makeCtx({
+        enriched: "already enriched prompt\n[personality: concise]",
+        resumeDigest: "Previous session work",
+      }),
+    );
+    expect(result.enriched).toContain("already enriched prompt");
+    expect(result.enriched).toContain("[flow-context:");
+  });
+});