@epoch-ai/cli 2.2.4 → 2.2.5

package/test/session/prompt/builder.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect } from "bun:test"
-import { PromptBuilder, type ZoneStructuredPayload } from "../../../src/session/prompt/builder"
-
-describe("PromptBuilder", () => {
-  it("should correctly assemble all three zones", () => {
-    const payload: ZoneStructuredPayload = {
-      zone1_critical_rules: ["Fact 1", "Fact 2"],
-      zone2_context_files: ["Rule Pack A", "Tool Schemas"],
-      zone3_active_cursor: ["Fact 1 Repeated", "Cursor at line 10"],
-      zone4_guidelines: ["Guideline 1"],
-    }
-
-    const result = PromptBuilder.build(payload)
-
-    expect(result).toContain("=== ZONE 1: IMMEDIATE CONTEXT & PERSISTENCE ===")
-    expect(result).toContain("Fact 1\n\nFact 2")
-
-    expect(result).toContain("=== ZONE 2: BEHAVIORAL RULES & GENERAL CONTEXT ===")
-    expect(result).toContain("Rule Pack A\n\nTool Schemas")
-
-    expect(result).toContain("=== ZONE 3: PROJECT-SPECIFIC RULES & CURSOR CONTEXT ===")
-    expect(result).toContain("Fact 1 Repeated\n\nCursor at line 10")
-  })
-
-  it("should handle empty zones gracefully", () => {
-    const payload: ZoneStructuredPayload = {
-      zone1_critical_rules: ["Fact 1"],
-      zone2_context_files: [],
-      zone3_active_cursor: ["Cursor at line 10"],
-      zone4_guidelines: [],
-    }
-
-    const result = PromptBuilder.build(payload)
-
-    expect(result).toContain("=== ZONE 1: IMMEDIATE CONTEXT & PERSISTENCE ===")
-    expect(result).toContain("Fact 1")
-
-    expect(result).not.toContain("=== ZONE 2: BEHAVIORAL RULES & GENERAL CONTEXT ===")
-
-    expect(result).toContain("=== ZONE 3: PROJECT-SPECIFIC RULES & CURSOR CONTEXT ===")
-    expect(result).toContain("Cursor at line 10")
-  })
-
-  it("should filter out empty strings within zones", () => {
-    const payload: ZoneStructuredPayload = {
-      zone1_critical_rules: ["Fact 1", "", "Fact 2"],
-      zone2_context_files: ["", "Rule Pack A"],
-      zone3_active_cursor: [""],
-      zone4_guidelines: [],
-    }
-
-    const result = PromptBuilder.build(payload)
-
-    expect(result).toContain("Fact 1\n\nFact 2")
-    expect(result).toContain("Rule Pack A")
-    expect(result).not.toContain("=== ZONE 3: PROJECT-SPECIFIC RULES & CURSOR CONTEXT ===")
-  })
-
-  it("should return an empty string if all zones are empty", () => {
-    const payload: ZoneStructuredPayload = {
-      zone1_critical_rules: [],
-      zone2_context_files: [""],
-      zone3_active_cursor: [],
-      zone4_guidelines: [],
-    }
-
-    const result = PromptBuilder.build(payload)
-
-    expect(result).toBe("")
-  })
-})

package/test/session/prompt/engine-loop.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { SessionEngine } from "../../../src/session/prompt/engine"
-import { Session } from "../../../src/session"
-import { Agent } from "../../../src/agent/agent"
-import { Provider } from "../../../src/provider/provider"
-import { Bus } from "../../../src/bus"
-import { Plugin } from "../../../src/plugin"
-import { SessionStatus } from "../../../src/session/status"
-import { SessionCompaction } from "../../../src/session/compaction"
-import { SessionProcessor } from "../../../src/session/processor"
-import { Instruction } from "../../../src/session/instruction"
-import { InputResolver } from "../../../src/session/prompt/resolver"
-import { ToolOrchestrator } from "../../../src/session/prompt/orchestrator"
-import { AppFileSystem } from "../../../src/filesystem"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { InstanceRef } from "@/effect/instance-ref"
-import { testEffect } from "../../lib/effect"
-import { SessionID } from "../../../src/session/schema"
-
-const mockDeps = Layer.mergeAll(
-  Layer.succeed(Bus.Service, Bus.Service.of({ publish: () => Effect.void } as any)),
-  Layer.succeed(
-    Session.Service,
-    Session.Service.of({
-      get: () => Effect.succeed({} as any),
-      updateMessage: () => Effect.void,
-      updatePart: () => Effect.void,
-    } as any),
-  ),
-  Layer.succeed(
-    Agent.Service,
-    Agent.Service.of({
-      get: () => Effect.succeed(undefined),
-      list: () => Effect.succeed([]),
-    } as any),
-  ),
-  Layer.succeed(Provider.Service, Provider.Service.of({} as any)),
-  Layer.succeed(
-    Plugin.Service,
-    Plugin.Service.of({ trigger: (name: string, payload: any, state: any) => Effect.succeed(state) } as any),
-  ),
-  Layer.succeed(ChildProcessSpawner, ChildProcessSpawner.of({} as any)),
-  Layer.succeed(SessionStatus.Service, SessionStatus.Service.of({ set: () => Effect.void } as any)),
-  Layer.succeed(SessionCompaction.Service, SessionCompaction.Service.of({} as any)),
-  Layer.succeed(SessionProcessor.Service, SessionProcessor.Service.of({} as any)),
-  Layer.succeed(Instruction.Service, Instruction.Service.of({} as any)),
-  Layer.succeed(AppFileSystem.Service, AppFileSystem.Service.of({} as any)),
-  Layer.succeed(
-    InputResolver.Service,
-    InputResolver.Service.of({
-      lastModel: () => Effect.succeed({ providerID: "p", modelID: "m" }),
-    } as any),
-  ),
-  Layer.succeed(ToolOrchestrator.Service, ToolOrchestrator.Service.of({} as any)),
-)
-
-const { effect: it } = testEffect(SessionEngine.layer.pipe(Layer.provideMerge(mockDeps)) as any)
-
-const testContext = { worktree: "/tmp", directory: "/tmp", project: { directory: "/tmp" } as any }
-
-describe("SessionEngine", () => {
-  it("shellImpl - fails when agent not found", () =>
-    Effect.gen(function* () {
-      const engine = yield* SessionEngine.Service
-      const sessionID = SessionID.descending()
-
-      const task = engine.shellImpl(
-        {
-          sessionID,
-          command: "echo 1",
-          agent: "non-existent",
-        },
-        new AbortController().signal,
-      )
-
-      const result = yield* Effect.exit(task)
-      expect(result._tag).toBe("Failure")
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-})

package/test/session/prompt/orchestrator.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { ToolOrchestrator } from "../../../src/session/prompt/orchestrator"
-import { AppFileSystem } from "../../../src/filesystem"
-import { Session } from "../../../src/session"
-import { Agent } from "../../../src/agent/agent"
-import { Provider } from "../../../src/provider/provider"
-import { Bus } from "../../../src/bus"
-import { Plugin } from "../../../src/plugin"
-import { MCP } from "../../../src/mcp"
-import { LSP } from "../../../src/lsp"
-import { FileTime } from "../../../src/file/time"
-import { ToolRegistry } from "../../../src/tool/registry"
-import { Truncate } from "../../../src/tool/truncate"
-import { Permission } from "../../../src/permission"
-import { InputResolver } from "../../../src/session/prompt/resolver"
-import { Todo } from "../../../src/session/todo"
-import { InstanceRef } from "@/effect/instance-ref"
-import { testEffect } from "../../lib/effect"
-import { SessionID, MessageID } from "../../../src/session/schema"
-
-const mockFsys = Layer.succeed(AppFileSystem.Service, AppFileSystem.Service.of({} as any))
-const mockBus = Layer.succeed(Bus.Service, Bus.Service.of({ publish: () => Effect.void } as any))
-const mockSessions = Layer.succeed(Session.Service, Session.Service.of({ updatePart: () => Effect.void } as any))
-const mockAgents = Layer.succeed(Agent.Service, Agent.Service.of({} as any))
-const mockPlugin = Layer.succeed(
-  Plugin.Service,
-  Plugin.Service.of({ trigger: (name: string, payload: any, state: any) => Effect.succeed(state) } as any),
-)
-const mockMcp = Layer.succeed(MCP.Service, MCP.Service.of({ tools: () => Effect.succeed({}) } as any))
-const mockRegistry = Layer.succeed(
-  ToolRegistry.Service,
-  ToolRegistry.Service.of({ tools: () => Effect.succeed([]) } as any),
-)
-const mockTruncate = Layer.succeed(Truncate.Service, Truncate.Service.of({} as any))
-const mockPermission = Layer.succeed(
-  Permission.Service,
-  Permission.Service.of({ ask: () => Effect.succeed(true) } as any),
-)
-const mockResolver = Layer.succeed(InputResolver.Service, InputResolver.Service.of({} as any))
-
-const mockTodo = Layer.succeed(
-  Todo.Service,
-  Todo.Service.of({
-    update: () => Effect.void,
-    get: () => Effect.succeed([]),
-    syncWithFile: () => Effect.void,
-  }),
-)
-
-const mockDeps = Layer.mergeAll(
-  mockFsys,
-  mockBus,
-  mockSessions,
-  mockAgents,
-  mockPlugin,
-  mockMcp,
-  mockRegistry,
-  mockTruncate,
-  mockPermission,
-  mockResolver,
-  mockTodo,
-)
-
-const { effect: it } = testEffect(ToolOrchestrator.layer.pipe(Layer.provideMerge(mockDeps)))
-
-const testContext = { worktree: "/tmp", directory: "/tmp", project: { directory: "/tmp" } as any }
-
-describe("ToolOrchestrator", () => {
-  it("createStructuredOutputTool - returns a tool with correct schema", () =>
-    Effect.gen(function* () {
-      const orchestrator = yield* ToolOrchestrator.Service
-      let success = false
-      const tool = orchestrator.createStructuredOutputTool({
-        schema: { type: "object", properties: { result: { type: "string" } } },
-        onSuccess: (args: any) => {
-          if (args.result === "done") success = true
-        },
-      })
-
-      expect(tool.description).toContain("structured format")
-      if (tool.execute) {
-        // @ts-ignore
-        yield* Effect.promise(() =>
-          tool.execute!(
-            { result: "done" },
-            { abortSignal: new AbortController().signal, toolCallId: "1", messages: [] },
-          ),
-        )
-      }
-      expect(success).toBe(true)
-    }))
-
-  it("resolveTools - returns tools from registry", () =>
-    Effect.gen(function* () {
-      const orchestrator = yield* ToolOrchestrator.Service
-      const tools = yield* orchestrator.resolveTools({
-        agent: { name: "build", tools: [], permission: [] } as any,
-        model: { providerID: "openai", modelID: "gpt-4", api: { id: "gpt-4" } } as any,
-        session: { id: SessionID.descending() } as any,
-        processor: { message: { id: MessageID.ascending() }, partFromToolCall: () => undefined } as any,
-        bypassAgentCheck: true,
-        messages: [],
-      })
-
-      expect(tools).toBeDefined()
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-})

package/test/session/prompt/resolver.test.ts

@@ -1,211 +0,0 @@
-import { describe, expect, beforeAll, afterAll } from "bun:test"
-import { Effect, Layer, Scope } from "effect"
-import { Session } from "../../../src/session"
-import { Instance } from "../../../src/project/instance"
-import { InputResolver } from "../../../src/session/prompt/resolver"
-import { AppFileSystem } from "../../../src/filesystem"
-import { Agent } from "../../../src/agent/agent"
-import { Provider } from "../../../src/provider/provider"
-import { Bus } from "../../../src/bus"
-import { Plugin } from "../../../src/plugin"
-import { MCP } from "../../../src/mcp"
-import { LSP } from "../../../src/lsp"
-import { FileTime } from "../../../src/file/time"
-import { ToolRegistry } from "../../../src/tool/registry"
-import { Instruction } from "../../../src/session/instruction"
-import { InstanceRef } from "@/effect/instance-ref"
-import { testEffect } from "../../lib/effect"
-import { SessionID, MessageID } from "../../../src/session/schema"
-import { ProviderID, ModelID } from "../../../src/provider/schema"
-import { Flag } from "../../../src/flag/flag"
-import { InstanceState } from "../../../src/effect/instance-state"
-
-const mockFsys = Layer.succeed(
-  AppFileSystem.Service,
-  AppFileSystem.Service.of({
-    stat: (path: string) =>
-      path.includes("exists.ts")
-        ? Effect.succeed({ type: "File", size: 100, mtime: 0 } as any)
-        : Effect.fail(new Error("Not found")),
-    existsSafe: (path: string) => Effect.succeed(path.includes("plan.md")),
-    readFileString: () => Effect.succeed(""),
-    writeFileString: () => Effect.succeed(undefined),
-    ensureDir: () => Effect.succeed(undefined),
-  } as any),
-)
-
-const mockAgents = Layer.succeed(
-  Agent.Service,
-  Agent.Service.of({
-    get: (name: string) =>
-      ["coder", "build", "plan"].includes(name) ? Effect.succeed({ name } as any) : Effect.succeed(undefined),
-    list: () => Effect.succeed([]),
-    defaultAgent: () => Effect.succeed("build"),
-  } as any),
-)
-
-const mockSessions = Layer.succeed(
-  Session.Service,
-  Session.Service.of({
-    get: () => Effect.succeed({ id: "session-1", title: "New Session" } as any),
-    updatePart: (part: any) => Effect.succeed(part as any),
-    updateMessage: () => Effect.void,
-    setTitle: () => Effect.void,
-    touch: () => Effect.void,
-    setPermission: () => Effect.void,
-  } as any),
-)
-
-const mockBus = Layer.succeed(Bus.Service, Bus.Service.of({ publish: () => Effect.void } as any))
-const mockProvider = Layer.succeed(
-  Provider.Service,
-  Provider.Service.of({ getModel: () => Effect.succeed({} as any) } as any),
-)
-const mockPlugin = Layer.succeed(
-  Plugin.Service,
-  Plugin.Service.of({ trigger: (name: string, payload: any, state: any) => Effect.succeed(state) } as any),
-)
-const mockMcp = Layer.succeed(MCP.Service, MCP.Service.of({ tools: () => Effect.succeed({}) } as any))
-const mockLsp = Layer.succeed(LSP.Service, LSP.Service.of({ tools: () => Effect.succeed({}) } as any))
-const mockFileTime = Layer.succeed(FileTime.Service, FileTime.Service.of({} as any))
-const mockRegistry = Layer.succeed(
-  ToolRegistry.Service,
-  ToolRegistry.Service.of({ tools: () => Effect.succeed([]) } as any),
-)
-const mockInstruction = Layer.succeed(
-  Instruction.Service,
-  Instruction.Service.of({
-    clear: () => Effect.void,
-  } as any),
-)
-
-const mockDeps = Layer.mergeAll(
-  mockFsys,
-  mockAgents,
-  mockSessions,
-  mockBus,
-  mockProvider,
-  mockPlugin,
-  mockMcp,
-  mockLsp,
-  mockFileTime,
-  mockRegistry,
-  mockInstruction,
-)
-
-const testEnv = InputResolver.layer.pipe(Layer.provideMerge(mockDeps))
-
-const { effect: it } = testEffect(testEnv)
-
-const testContext = { worktree: "/tmp", directory: "/tmp", project: { directory: "/tmp" } as any }
-
-describe("InputResolver", () => {
-  let originalPlanMode: boolean
-  let originalSessionPlan: any
-
-  beforeAll(() => {
-    originalPlanMode = Flag.EPOCHCLI_EXPERIMENTAL_PLAN_MODE
-    // @ts-ignore
-    Flag.EPOCHCLI_EXPERIMENTAL_PLAN_MODE = true
-    originalSessionPlan = Session.plan
-    // @ts-ignore
-    Session.plan = () => "/tmp/plan.md"
-  })
-
-  afterAll(() => {
-    // @ts-ignore
-    Flag.EPOCHCLI_EXPERIMENTAL_PLAN_MODE = originalPlanMode
-    // @ts-ignore
-    Session.plan = originalSessionPlan
-  })
-
-  it("resolvePromptParts - resolves existing file", () =>
-    Effect.gen(function* () {
-      const resolver = yield* InputResolver.Service
-      const parts = yield* resolver.resolvePromptParts("check @exists.ts")
-
-      expect(parts).toHaveLength(2)
-      expect(parts[0]).toEqual({ type: "text", text: "check @exists.ts" })
-      expect(parts[1].type).toBe("file")
-      if (parts[1].type === "file") {
-        expect(parts[1].filename).toBe("exists.ts")
-      }
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-
-  it("resolvePromptParts - falls back to agent if file not found", () =>
-    Effect.gen(function* () {
-      const resolver = yield* InputResolver.Service
-      const parts = yield* resolver.resolvePromptParts("ask @coder")
-
-      expect(parts).toHaveLength(2)
-      expect(parts[0]).toEqual({ type: "text", text: "ask @coder" })
-      expect(parts[1]).toEqual({ type: "agent", name: "coder" })
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-
-  it("insertReminders - injects plan reminder in plan mode", () =>
-    Effect.gen(function* () {
-      const resolver = yield* InputResolver.Service
-      const sessionID = SessionID.descending()
-      const messageID = MessageID.ascending()
-      const messages = [
-        {
-          info: { role: "user", id: messageID, sessionID },
-          parts: [{ type: "text", text: "hi" }],
-        },
-      ] as any
-
-      const result = yield* resolver.insertReminders({
-        messages,
-        agent: { name: "plan" } as any,
-        session: { id: sessionID, slug: "test", time: { created: Date.now() } } as any,
-      })
-
-      const userMsg = result.find((m: any) => m.info.role === "user")
-      expect(userMsg!.parts.some((p: any) => p.synthetic && p.text.includes("Plan mode is active"))).toBe(true)
-    }).pipe(Effect.provideService(InstanceRef, testContext as any)))
-
-  it("insertReminders - does not inject plan reminder in build mode", () =>
-    Effect.gen(function* () {
-      const resolver = yield* InputResolver.Service
-      const sessionID = SessionID.descending()
-      const messageID = MessageID.ascending()
-      const messages = [
-        {
-          info: { role: "assistant", id: MessageID.ascending(), sessionID, agent: "plan" },
-          parts: [{ type: "text", text: "Here is the plan" }],
-        },
-        {
-          info: { role: "user", id: messageID, sessionID },
-          parts: [{ type: "text", text: "looks good, go" }],
-        },
-      ] as any
-
-      const result = yield* resolver.insertReminders({
-        messages,
-        agent: { name: "build" } as any,
-        session: { id: sessionID, slug: "test", time: { created: Date.now() } } as any,
-      })
-
-      const userMsg = result.find((m: any) => m.info.role === "user" && m.info.id === messageID)
-      expect(userMsg!.parts.some((p: any) => p.synthetic && p.text.includes("Plan mode is active"))).toBe(false)
-      expect(userMsg!.parts.some((p: any) => p.synthetic && p.text.includes("plan file exists"))).toBe(true)
-    }).pipe(Effect.provideService(InstanceRef, testContext as any)))
-
-  it("createUserMessage - creates a user message with parts", () =>
-    Effect.gen(function* () {
-      const resolver = yield* InputResolver.Service
-      const sessionID = SessionID.descending()
-
-      const result = yield* resolver.createUserMessage({
-        sessionID,
-        parts: [{ type: "text", text: "hello" }],
-        agent: "build",
-        model: { providerID: ProviderID.make("openai"), modelID: ModelID.make("gpt-4") },
-      })
-
-      expect(result.info.role).toBe("user")
-      expect(result.info.sessionID).toBe(sessionID)
-      expect(result.parts).toHaveLength(1)
-      expect(result.parts[0].type).toBe("text")
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-})

package/test/session/prompt/router.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it, mock } from "bun:test"
-import { RuleRouter } from "../../../src/session/prompt/router"
-
-describe("RuleRouter", () => {
-  describe("classify (Heuristics)", () => {
-    it("should supply core_interaction_pack when intent is ambiguous", () => {
-      const packs = RuleRouter.classify("Hi")
-      expect(packs).toEqual(["core_interaction_pack"])
-    })
-
-    it("should supply new_feature_pack when intent indicates creation", () => {
-      const packs = RuleRouter.classify("create a new user profile component")
-      expect(packs).toContain("new_feature_pack")
-      expect(packs).toContain("core_interaction_pack")
-    })
-
-    it("should supply context_mgmt_pack when intent indicates summarization", () => {
-      const packs = RuleRouter.classify("summarize what we have done so far")
-      expect(packs).toContain("context_mgmt_pack")
-      expect(packs).toContain("core_interaction_pack")
-    })
-
-    it("should supply debugging_pack when intent indicates an error", () => {
-      const packs = RuleRouter.classify("fix this bug and stack trace")
-      expect(packs).toContain("debugging_pack")
-      expect(packs).toContain("core_interaction_pack")
-    })
-  })
-
-  describe("identifyRulePacks (Clerk Model)", () => {
-    it("should supply core_interaction_pack when intent is ambiguous", async () => {
-      const mockModel = {
-        specificationVersion: "v3",
-        provider: "mock",
-        modelId: "mock",
-        doGenerate: async () => ({
-          text: "none",
-          finishReason: "stop",
-          usage: { promptTokens: 10, completionTokens: 10, inputTokens: { total: 10 }, outputTokens: { total: 10 } },
-          content: [{ type: "text", text: "none" }],
-        }),
-      } as any
-
-      const packs = await RuleRouter.identifyRulePacks("Hi", mockModel)
-      expect(packs).toEqual(["core_interaction_pack"])
-    })
-
-    it("should supply new_feature_pack when the model identifies new_feature", async () => {
-      const mockModel = {
-        specificationVersion: "v3",
-        provider: "mock",
-        modelId: "mock",
-        doGenerate: async () => ({
-          text: "new_feature",
-          finishReason: "stop",
-          usage: { promptTokens: 10, completionTokens: 10, inputTokens: { total: 10 }, outputTokens: { total: 10 } },
-          content: [{ type: "text", text: "new_feature" }],
-        }),
-      } as any
-
-      const packs = await RuleRouter.identifyRulePacks("create a new user profile component", mockModel)
-      expect(packs).toContain("new_feature_pack")
-      expect(packs).toContain("core_interaction_pack")
-    })
-
-    it("should supply context_mgmt_pack when the model identifies context_mgmt", async () => {
-      const mockModel = {
-        specificationVersion: "v3",
-        provider: "mock",
-        modelId: "mock",
-        doGenerate: async () => ({
-          text: "context_mgmt",
-          finishReason: "stop",
-          usage: { promptTokens: 10, completionTokens: 10, inputTokens: { total: 10 }, outputTokens: { total: 10 } },
-          content: [{ type: "text", text: "context_mgmt" }],
-        }),
-      } as any
-
-      const packs = await RuleRouter.identifyRulePacks("forget previous rules and summarize", mockModel)
-      expect(packs).toContain("context_mgmt_pack")
-      expect(packs).toContain("core_interaction_pack")
-    })
-  })
-})

package/test/session/prompt/state.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { SessionState } from "../../../src/session/prompt/state"
-import { SessionStatus } from "../../../src/session/status"
-import { Bus } from "../../../src/bus"
-import { testEffect } from "../../lib/effect"
-import { SessionID, MessageID } from "../../../src/session/schema"
-import { Session } from "../../../src/session"
-import { InstanceRef } from "@/effect/instance-ref"
-
-const mockStatus = Layer.succeed(
-  SessionStatus.Service,
-  SessionStatus.Service.of({
-    set: () => Effect.void,
-    get: () => Effect.succeed({ type: "idle" } as any),
-  } as any),
-)
-
-const mockBus = Layer.succeed(Bus.Service, Bus.Service.of({ publish: () => Effect.void } as any))
-
-const mockDeps = Layer.mergeAll(mockStatus, mockBus, Session.defaultLayer)
-
-const { effect: it } = testEffect(SessionState.layer.pipe(Layer.provideMerge(mockDeps)))
-
-const testContext = { worktree: "/tmp", directory: "/tmp", project: { directory: "/tmp" } as any }
-
-describe("SessionState", () => {
-  it("getRunner - returns new runner and caches it", () =>
-    Effect.gen(function* () {
-      const state = yield* SessionState.Service
-      const sessionID = SessionID.descending()
-
-      const runner1 = yield* state.getRunner(sessionID)
-      const runner2 = yield* state.getRunner(sessionID)
-
-      expect(runner1).toBeDefined()
-      expect(runner1).toBe(runner2)
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-
-  it("assertNotBusy - succeeds when idle", () =>
-    Effect.gen(function* () {
-      const state = yield* SessionState.Service
-      const sessionID = SessionID.descending()
-
-      yield* state.assertNotBusy(sessionID)
-      // Success if no throw
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-
-  it("cancel - ignores if no runner", () =>
-    Effect.gen(function* () {
-      const state = yield* SessionState.Service
-      const sessionID = SessionID.descending()
-
-      yield* state.cancel(sessionID)
-      // Should resolve cleanly
-    }).pipe(Effect.provideService(InstanceRef, testContext)))
-})