@epoch-ai/cli 2.2.4

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

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

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

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

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

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

@@ -0,0 +1,57 @@
+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)))
+})