@epoch-ai/cli 2.2.4 → 2.2.5

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

@@ -1,179 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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:")
-  })
-})