@epoch-ai/cli 2.2.5 → 2.2.7

package/test/session/hard-reset.test.ts

@@ -0,0 +1,179 @@
+import { afterEach, describe, expect, mock, test } from "bun:test"
+import { Effect, Layer, ServiceMap } from "effect"
+import * as Stream from "effect/Stream"
+import path from "path"
+import fs from "fs/promises"
+
+process.env.EPOCHCLI_DB = ":memory:"
+process.env.EPOCHCLI_DISABLE_CHANNEL_DB = "true"
+
+import { Bus } from "../../src/bus"
+import { Config } from "../../src/config/config"
+import { Agent } from "../../src/agent/agent"
+import { LLM } from "../../src/session/llm"
+import { SessionCompaction } from "../../src/session/compaction"
+import { Log } from "../../src/util/log"
+import { Permission } from "../../src/permission"
+import { Plugin } from "../../src/plugin"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { Session } from "../../src/session"
+import { MessageID, PartID } from "../../src/session/schema"
+import { SessionStatus } from "../../src/session/status"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { MessageV2 } from "../../src/session/message-v2"
+import { SessionEngine } from "../../src/session/prompt/engine"
+import { InputResolver } from "../../src/session/prompt/resolver"
+import { ToolOrchestrator } from "../../src/session/prompt/orchestrator"
+import { SessionProcessor } from "../../src/session/processor"
+import { Instruction } from "../../src/session/instruction"
+import { Snapshot } from "../../src/snapshot"
+import { Todo } from "../../src/session/todo"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { MCP } from "../../src/mcp"
+import { ToolRegistry } from "../../src/tool/registry"
+import { Truncate } from "../../src/tool/truncate"
+import { AppFileSystem } from "../../src/filesystem"
+import { Git } from "../../src/git"
+import { testEffect } from "../lib/effect"
+import { NodeFileSystem, NodePath } from "@effect/platform-node"
+import { LSP } from "../../src/lsp"
+import { FileTime } from "../../src/file/time"
+import { InstanceState } from "../../src/effect/instance-state"
+
+Log.init({ print: false })
+
+function createModel(opts: { context: number; output: number; input?: number }): any {
+  return {
+    id: "test-model",
+    providerID: "test",
+    name: "Test",
+    limit: { context: opts.context, input: opts.input, output: opts.output },
+    cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+    capabilities: {
+      toolcall: true, attachment: false, reasoning: false, temperature: true, interleaved: false,
+      input: { text: true, image: false, audio: false, video: false, pdf: false },
+      output: { text: true, image: false, audio: false, video: false, pdf: false },
+    },
+    api: { id: "test-model", url: "https://example.com", npm: "@ai-sdk/openai" },
+    options: {},
+  }
+}
+
+class ProviderService extends ServiceMap.Service<ProviderService, any>()("@epochcli/Provider") {}
+
+mock.module("../../src/provider/provider", () => ({
+  Provider: {
+    getSideModel: async () => ({ providerID: "test", modelID: "test-model" }),
+    getLanguage: async () => ({
+      specificationVersion: "v3",
+      modelId: "test-side-model",
+      doGenerate: async () => ({
+        text: "NONE",
+        content: [{ type: "text", text: "NONE" }],
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 10, inputTokens: 10, outputTokens: 10 },
+      }),
+    }),
+    getModel: async () => createModel({ context: 16000, output: 4000 }),
+    Service: ProviderService,
+  },
+}))
+
+function llm() {
+  const queue: any[] = []
+  return {
+    clear() { queue.length = 0 },
+    push(stream: any) { queue.push(stream) },
+    layer: Layer.succeed(
+      LLM.Service,
+      LLM.Service.of({
+        stream: (input: any) => {
+          const item = queue.shift()
+          if (!item) return Stream.fail(new Error("Queue empty - stop test"))
+          return item.pipe(Stream.mapEffect((event: any) => Effect.succeed(event)))
+        },
+      } as any),
+    ),
+  }
+}
+
+function liveLayer(llmLayer: Layer.Layer<LLM.Service>) {
+  const bus = Bus.layer
+  const status = SessionStatus.layer.pipe(Layer.provide(bus))
+  const providers = Layer.mergeAll(
+    status, bus, Config.defaultLayer, Session.defaultLayer, Agent.defaultLayer, Plugin.defaultLayer,
+    Snapshot.defaultLayer, Instruction.defaultLayer, Permission.defaultLayer, CrossSpawnSpawner.defaultLayer,
+    AppFileSystem.defaultLayer, Git.defaultLayer, Todo.defaultLayer,
+    Layer.succeed(MCP.Service, { clients: () => Effect.succeed({}), tools: () => Effect.succeed({}) } as any),
+    Layer.succeed(ToolRegistry.Service, { resolve: () => Effect.succeed({}), list: () => Effect.succeed([]), get: () => Effect.succeed(undefined), tools: () => Effect.succeed([]) } as any),
+    Layer.succeed(Truncate.Service, { output: (text: string) => Effect.succeed({ text, truncated: false }) } as any),
+    Layer.succeed(LSP.Service, {} as any),
+    Layer.succeed(FileTime.Service, { get: () => Effect.succeed(0) } as any),
+    Layer.succeed(ProviderService, { getSideModel: () => Effect.succeed({ providerID: "test", modelID: "test-model" }), getLanguage: () => Effect.succeed({}), getModel: () => Effect.succeed(createModel({ context: 16000, output: 4000 })) } as any),
+    llmLayer, NodeFileSystem.layer, NodePath.layer,
+  )
+  let l: Layer.Layer<any, any, any> = providers
+  l = Layer.provideMerge(InputResolver.layer, l)
+  l = Layer.provideMerge(ToolOrchestrator.layer, l)
+  l = Layer.provideMerge(SessionProcessor.layer, l)
+  l = Layer.provideMerge(SessionCompaction.layer, l)
+  l = Layer.provideMerge(SessionEngine.layer, l)
+  return l
+}
+
+describe("Hard Reset Doom Loop Protection", () => {
+  const l = llm()
+  const layer = liveLayer(l.layer)
+  const { live: it } = testEffect(layer as any)
+  afterEach(() => { l.clear() })
+
+  it("triggers a Hard Reset (transition) when stall score hits 20", () =>
+    provideTmpdirInstance((tmpPath) =>
+      Effect.gen(function* () {
+        const session = yield* Session.Service
+        const engine = yield* SessionEngine.Service
+
+        const chat = yield* session.create({})
+        const parentId = MessageID.ascending()
+        yield* session.updateMessage({
+          id: parentId,
+          sessionID: chat.id,
+          role: "user",
+          time: { created: Date.now() },
+          agent: "build",
+          model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test-model") },
+        })
+
+        // Create continuity file to prevent ENOENT during transition
+        const fsNode = yield* Effect.promise(() => import("fs/promises"))
+        yield* Effect.promise(() => fsNode.writeFile(path.join(tmpPath, ".epoch-continuity.toon"), "test"))
+
+        // Simulate 3 loops of empty text in YOLO mode (10 points each, meaning 2 loops hits 20)
+        for (let i = 0; i < 3; i++) {
+          l.push(Stream.make(
+            { type: "text-start" } as any,
+            { type: "text-delta", text: "I am thinking..." } as any,
+            { type: "text-end" } as any,
+            { type: "finish-step", finishReason: "stop", usage: { totalTokens: 10 } } as any,
+          ).pipe(Stream.tap(() => Effect.sync(() => console.log("Stream", i, "consumed")))))
+        }
+
+        // Push a task_complete to gracefully exit the YOLO loop after the transition
+        l.push(Stream.make(
+          { type: "tool-call", toolCallId: "1", toolName: "task_complete", args: {} } as any,
+          { type: "finish-step", finishReason: "stop", usage: { totalTokens: 10 } } as any,
+        ).pipe(Stream.tap(() => Effect.sync(() => console.log("Task Complete Stream consumed")))))
+
+        console.log("Starting runLoop")
+        const result = yield* engine.runLoop(chat.id, true) // yolo = true
+        console.log("runLoop finished")
+
+        // Read all messages to verify transition occurred
+        const msgs = yield* MessageV2.filterByEpochEffect(chat.id)
+        const transitionParts = msgs.flatMap(m => m.parts).filter(p => p.type === "transition")
+        
+        expect(transitionParts.length).toBeGreaterThan(0)
+      }),
+    ),
+  )
+})

package/test/session/instruction.test.ts

@@ -0,0 +1,286 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import path from "path"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { Instruction } from "../../src/session/instruction"
+import type { MessageV2 } from "../../src/session/message-v2"
+import { Instance } from "../../src/project/instance"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { Global } from "../../src/global"
+import { tmpdir } from "../fixture/fixture"
+
+function loaded(filepath: string): MessageV2.WithParts[] {
+  const sessionID = SessionID.make("session-loaded-1")
+  const messageID = MessageID.make("message-loaded-1")
+
+  return [
+    {
+      info: {
+        id: messageID,
+        sessionID,
+        role: "user",
+        time: { created: 0 },
+        agent: "build",
+        model: {
+          providerID: ProviderID.make("anthropic"),
+          modelID: ModelID.make("claude-sonnet-4-20250514"),
+        },
+      },
+      parts: [
+        {
+          id: PartID.make("part-loaded-1"),
+          messageID,
+          sessionID,
+          type: "tool",
+          callID: "call-loaded-1",
+          tool: "read",
+          state: {
+            status: "completed",
+            input: {},
+            output: "done",
+            title: "Read",
+            metadata: { loaded: [filepath] },
+            time: { start: 0, end: 1 },
+          },
+        },
+      ],
+    },
+  ]
+}
+
+describe("Instruction.resolve", () => {
+  test("returns empty when AGENTS.md is at project root (already in systemPaths)", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Root Instructions")
+        await Bun.write(path.join(dir, "src", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
+
+        const results = await Instruction.resolve(
+          [],
+          path.join(tmp.path, "src", "file.ts"),
+          MessageID.make("message-test-1"),
+        )
+        expect(results).toEqual([])
+      },
+    })
+  })
+
+  test("returns AGENTS.md from subdirectory (not in systemPaths)", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
+
+        const results = await Instruction.resolve(
+          [],
+          path.join(tmp.path, "subdir", "nested", "file.ts"),
+          MessageID.make("message-test-2"),
+        )
+        expect(results.length).toBe(1)
+        expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+      },
+    })
+  })
+
+  test("doesn't reload AGENTS.md when reading it directly", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
+        const system = await Instruction.systemPaths()
+        expect(system.has(filepath)).toBe(false)
+
+        const results = await Instruction.resolve([], filepath, MessageID.make("message-test-3"))
+        expect(results).toEqual([])
+      },
+    })
+  })
+
+  test("does not reattach the same nearby instructions twice for one message", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-1")
+
+        const first = await Instruction.resolve([], filepath, id)
+        const second = await Instruction.resolve([], filepath, id)
+
+        expect(first).toHaveLength(1)
+        expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+        expect(second).toEqual([])
+      },
+    })
+  })
+
+  test("clear allows nearby instructions to be attached again for the same message", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-2")
+
+        const first = await Instruction.resolve([], filepath, id)
+        await Instruction.clear(id)
+        const second = await Instruction.resolve([], filepath, id)
+
+        expect(first).toHaveLength(1)
+        expect(second).toHaveLength(1)
+        expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+      },
+    })
+  })
+
+  test("skips instructions already reported by prior read metadata", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const agents = path.join(tmp.path, "subdir", "AGENTS.md")
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-3")
+
+        const results = await Instruction.resolve(loaded(agents), filepath, id)
+
+        expect(results).toEqual([])
+      },
+    })
+  })
+
+  test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
+})
+
+describe("Instruction.systemPaths EPOCHCLI_CONFIG_DIR", () => {
+  let originalConfigDir: string | undefined
+
+  beforeEach(() => {
+    originalConfigDir = process.env["EPOCHCLI_CONFIG_DIR"]
+  })
+
+  afterEach(() => {
+    if (originalConfigDir === undefined) {
+      delete process.env["EPOCHCLI_CONFIG_DIR"]
+    } else {
+      process.env["EPOCHCLI_CONFIG_DIR"] = originalConfigDir
+    }
+  })
+
+  test("prefers EPOCHCLI_CONFIG_DIR AGENTS.md over global when both exist", async () => {
+    await using profileTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Profile Instructions")
+      },
+    })
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    process.env["EPOCHCLI_CONFIG_DIR"] = profileTmp.path
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
+        },
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
+
+  test("falls back to global AGENTS.md when EPOCHCLI_CONFIG_DIR has no AGENTS.md", async () => {
+    await using profileTmp = await tmpdir()
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    process.env["EPOCHCLI_CONFIG_DIR"] = profileTmp.path
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+        },
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
+
+  test("uses global AGENTS.md when EPOCHCLI_CONFIG_DIR is not set", async () => {
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    delete process.env["EPOCHCLI_CONFIG_DIR"]
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: async () => {
+          const paths = await Instruction.systemPaths()
+          expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+        },
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
+})

package/test/session/llm/monitor.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "bun:test"
+import { StreamingMonitor } from "../../../src/session/llm/monitor"
+
+describe("StreamingMonitor", () => {
+  it("should not detect loops in normal text", () => {
+    const monitor = new StreamingMonitor()
+    expect(monitor.push("This is a normal sentence.")).toBe(false)
+    expect(monitor.push("It does not have any long repeating patterns.")).toBe(false)
+    expect(monitor.push("The quick brown fox jumps over the lazy dog.")).toBe(false)
+  })
+
+  it("should detect simple repeating loops", () => {
+    const monitor = new StreamingMonitor({ minMatchLength: 5, maxOccurrences: 3 })
+    const pattern = "Repeat me! "
+    expect(monitor.push(pattern)).toBe(false)
+    expect(monitor.push(pattern)).toBe(false)
+    expect(monitor.push(pattern)).toBe(true)
+    expect(monitor.getOffendingText()).toBe(pattern.trim())
+  })
+
+  it("should respect the minimum match length", () => {
+    const monitor = new StreamingMonitor({ minMatchLength: 10, maxOccurrences: 3 })
+    const shortPattern = "abc "
+    expect(monitor.push(shortPattern)).toBe(false)
+    expect(monitor.push(shortPattern)).toBe(false)
+    expect(monitor.push(shortPattern)).toBe(false)
+    expect(monitor.push(shortPattern)).toBe(false)
+
+    const longPattern = "This is a long pattern "
+    expect(monitor.push(longPattern)).toBe(false)
+    expect(monitor.push(longPattern)).toBe(false)
+    expect(monitor.push(longPattern)).toBe(true)
+  })
+
+  it("should detect loops even if they are pushed in small chunks", () => {
+    const monitor = new StreamingMonitor({ minMatchLength: 10, maxOccurrences: 3 })
+    const pattern = "Thinking about the next step... "
+    const fullText = pattern + pattern + pattern
+
+    for (let i = 0; i < fullText.length - 1; i++) {
+      expect(monitor.push(fullText[i])).toBe(false)
+    }
+    expect(monitor.push(fullText[fullText.length - 1])).toBe(true)
+  })
+
+  it("should return the longest repeating suffix as offending text", () => {
+    const monitor = new StreamingMonitor({ minMatchLength: 5, maxOccurrences: 2 })
+    const pattern = "Longer pattern that repeats"
+    monitor.push(pattern)
+    monitor.push(pattern)
+    expect(monitor.getOffendingText()).toBe(pattern)
+  })
+})

package/test/session/llm-sanitizer.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test"
+import { SanitizerMiddleware } from "../../src/session/sanitizer"
+
+describe("LLM Sanitizer Middleware Logic", () => {
+  test("strips unhelpful providerOptions from prompt messages and parts", () => {
+    const rawMessages = [
+      {
+        role: "user",
+        providerOptions: {
+          anthropic: { cacheControl: { type: "ephemeral" } },
+          openrouter: { cacheControl: { type: "ephemeral" } },
+          bedrock: { cachePoint: { type: "default" } },
+          openaiCompatible: { cache_control: { type: "ephemeral" } },
+          copilot: { copilot_cache_control: { type: "ephemeral" } },
+        },
+        content: [
+          {
+            type: "text",
+            text: "Hi",
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } },
+              openrouter: { cacheControl: { type: "ephemeral" } },
+              bedrock: { cachePoint: { type: "default" } },
+            },
+          },
+        ],
+      },
+    ]
+
+    const result = SanitizerMiddleware.stripProviderOptions(rawMessages, "anthropic")
+
+    // Message level
+    expect(result[0].providerOptions).toEqual({
+      anthropic: { cacheControl: { type: "ephemeral" } },
+    })
+
+    // Part level
+    expect(result[0].content[0].providerOptions).toEqual({
+      anthropic: { cacheControl: { type: "ephemeral" } },
+    })
+  })
+
+  test("handles azure provider by keeping both openai and azure keys", () => {
+    const rawMessages = [
+      {
+        role: "user",
+        providerOptions: {
+          openai: { cache_control: { type: "ephemeral" } },
+          azure: { cache_control: { type: "ephemeral" } },
+          anthropic: { cacheControl: { type: "ephemeral" } },
+        },
+        content: "Hello",
+      },
+    ]
+
+    const result = SanitizerMiddleware.stripProviderOptions(rawMessages, "azure", true)
+
+    expect(result[0].providerOptions).toEqual({
+      openai: { cache_control: { type: "ephemeral" } },
+      azure: { cache_control: { type: "ephemeral" } },
+    })
+    expect(result[0].providerOptions.anthropic).toBeUndefined()
+  })
+
+  test("removes providerOptions entirely if empty after stripping", () => {
+    const rawMessages = [
+      {
+        role: "user",
+        providerOptions: {
+          anthropic: { cacheControl: { type: "ephemeral" } },
+        },
+        content: [
+          {
+            type: "text",
+            text: "Hi",
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } },
+            },
+          },
+        ],
+      },
+    ]
+
+    // Target a key that is NOT present
+    const result = SanitizerMiddleware.stripProviderOptions(rawMessages, "google")
+
+    expect(result[0].providerOptions).toBeUndefined()
+    expect(result[0].content[0].providerOptions).toBeUndefined()
+  })
+})

package/test/session/llm-zones-e2e.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "bun:test"
+import * as fs from "fs"
+import * as path from "path"
+
+describe("LLM Payload Zones E2E Verification", () => {
+  it("should have correct contents in Zone 1, Zone 2, and Zone 3", () => {
+    // We are verifying against the explicit e2e test output mentioned by the user
+    const payloadPath = path.resolve(
+      __dirname,
+      "../../../../e2e_testing/results/suite_2026-04-13T23-32-46-621Z/system-prompt-hi-run-1/initial_payload.json",
+    )
+
+    // Skip if the file doesn't exist (e.g. in CI where this specific run isn't present)
+    if (!fs.existsSync(payloadPath)) {
+      console.warn("Skipping e2e payload test because payload file is missing.")
+      return
+    }
+
+    const data = JSON.parse(fs.readFileSync(payloadPath, "utf-8"))
+    const payload = data.payload
+
+    // 1. Verify Zone 1 (System Role)
+    const systemMsg = payload.find((m: any) => m.role === "system")
+    expect(systemMsg).toBeDefined()
+    // Verify it contains the Operational Facts and active agent context (Zone 1)
+    expect(systemMsg.content).toContain("Current Phase: [PLAN]")
+    expect(systemMsg.content).toContain("The environment context limit is strictly 32K tokens.")
+    expect(systemMsg.content).toContain("The codebase primary language is JavaScript/TypeScript.")
+
+    // 2. Verify Zone 2 (Assistant Role)
+    const assistantMsg = payload.find((m: any) => m.role === "assistant")
+    expect(assistantMsg).toBeDefined()
+    // Verify it contains the Behavioral Rules (Zone 2)
+    const assistantContent = assistantMsg.content[0].text
+    expect(assistantContent).toContain("=== BEHAVIORAL RULES & GENERAL CONTEXT ===")
+
+    // Verify core_interaction_pack rules ARE present
+    expect(assistantContent).toContain("Trigger: Generating code in response to a user prompt.") // comm_01
+    expect(assistantContent).toContain("Trigger: User asks a non-coding general knowledge question.") // comm_05
+    expect(assistantContent).toContain("Trigger: User implies the AI can execute, compile, or host code.") // self_01
+
+    // Verify context_mgmt_pack rules are NOT present
+    expect(assistantContent).not.toContain("Token context approaches maximum limit during a long session") // mem_02
+    expect(assistantContent).not.toContain("Session begins.") // pers_01
+
+    // Verify new_feature_pack rules are NOT present
+    expect(assistantContent).not.toContain("User asks to integrate a new file into the broader project") // epi_03
+    expect(assistantContent).not.toContain("A major feature is completed or refactored") // pers_02
+
+    // 3. Verify Zone 3 (User Role)
+    const userMsg = payload.find((m: any) => m.role === "user")
+    expect(userMsg).toBeDefined()
+    // Verify it contains the appended Project-Specific Rules (Zone 3)
+    const userContentText = userMsg.content.map((c: any) => c.text).join("")
+    expect(userContentText).toContain("Hi") // The original user message
+    expect(userContentText).toContain("ZONE 3: PROJECT-SPECIFIC RULES (Context-Aware Gaps)")
+    expect(userContentText).toContain("project_specific_pack:")
+    expect(userContentText).toContain("Adhere strictly to the detected stack conventions (Solid.js, Effect-ts")
+    expect(userContentText).toContain("Extracted from AGENTS.md:")
+  })
+})