saeeol 1.2.9 → 1.3.1

package/test/server/httpapi-cors.test.ts

@@ -0,0 +1,89 @@
+import { NodeHttpServer, NodeServices } from "@effect/platform-node"
+import { Flag } from "@saeeol/core/flag/flag"
+import { describe, expect } from "bun:test"
+import { Config, Effect, Layer } from "effect"
+import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
+import * as Socket from "effect/unstable/socket/Socket"
+import { Server } from "../../src/server/server"
+import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
+import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
+import { resetDatabase } from "../fixture/db"
+import { testEffect } from "../lib/effect"
+
+const testStateLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const original = {
+      SAEEOL_EXPERIMENTAL_HTTPAPI: Flag.SAEEOL_EXPERIMENTAL_HTTPAPI,
+      SAEEOL_SERVER_PASSWORD: Flag.SAEEOL_SERVER_PASSWORD,
+    }
+    Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
+    Flag.SAEEOL_SERVER_PASSWORD = "secret"
+    yield* Effect.promise(() => resetDatabase())
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(async () => {
+        Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original.SAEEOL_EXPERIMENTAL_HTTPAPI
+        Flag.SAEEOL_SERVER_PASSWORD = original.SAEEOL_SERVER_PASSWORD
+        await resetDatabase()
+      }),
+    )
+  }),
+)
+
+const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
+  ExperimentalHttpApiServer.routes,
+  { disableListenLog: true, disableLogger: true },
+)
+
+const it = testEffect(
+  Layer.mergeAll(
+    testStateLayer,
+    servedRoutes.pipe(
+      Layer.provide(Socket.layerWebSocketConstructorGlobal),
+      Layer.provideMerge(NodeHttpServer.layerTest),
+      Layer.provideMerge(NodeServices.layer),
+    ),
+  ),
+)
+
+describe("HttpApi CORS", () => {
+  it.live("allows browser preflight requests without credentials", () =>
+    Effect.gen(function* () {
+      const response = yield* HttpClientRequest.options(InstancePaths.path).pipe(
+        HttpClientRequest.setHeaders({
+          origin: "http://localhost:3000",
+          "access-control-request-method": "GET",
+          "access-control-request-headers": "authorization",
+        }),
+        HttpClient.execute,
+      )
+
+      expect(response.status).toBe(204)
+      expect(response.headers["access-control-allow-origin"]).toBe("http://localhost:3000")
+      expect(response.headers["access-control-allow-headers"]).toBe("authorization")
+    }),
+  )
+
+  it.live("uses custom CORS origins passed to the server", () =>
+    Effect.gen(function* () {
+      const listener = yield* Effect.acquireRelease(
+        Effect.promise(() => Server.listen({ hostname: "127.0.0.1", port: 0, cors: ["https://custom.example"] })),
+        (listener) => Effect.promise(() => listener.stop(true)),
+      )
+
+      const response = yield* Effect.promise(() =>
+        fetch(new URL(InstancePaths.path, listener.url), {
+          method: "OPTIONS",
+          headers: {
+            origin: "https://custom.example",
+            "access-control-request-method": "GET",
+            "access-control-request-headers": "authorization",
+          },
+        }),
+      )
+
+      expect(response.status).toBe(204)
+      expect(response.headers.get("access-control-allow-origin")).toBe("https://custom.example")
+      expect(response.headers.get("access-control-allow-headers")).toBe("authorization")
+    }),
+  )
+})

package/test/server/httpapi-event.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Flag } from "@saeeol/core/flag/flag"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { EventPaths } from "../../src/server/routes/instance/httpapi/event"
+import * as Log from "@saeeol/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
+
+function app(experimental = true) {
+  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
+  return experimental ? Server.Default().app : Server.Legacy().app
+}
+
+async function readFirstChunk(response: Response) {
+  if (!response.body) throw new Error("missing response body")
+  const reader = response.body.getReader()
+  const result = await Promise.race([
+    reader.read(),
+    new Promise<never>((_, reject) => setTimeout(() => reject(new Error("timed out waiting for event")), 5_000)),
+  ])
+  await reader.cancel()
+  return new TextDecoder().decode(result.value)
+}
+
+afterEach(async () => {
+  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
+  await disposeAllInstances()
+  await resetDatabase()
+})
+
+describe("event HttpApi bridge", () => {
+  test("serves event stream through experimental Effect route", async () => {
+    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
+    const response = await app().request(EventPaths.event, { headers: { "x-saeeol-directory": tmp.path } })
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get("content-type")).toContain("text/event-stream")
+    expect(response.headers.get("cache-control")).toBe("no-cache, no-transform")
+    expect(response.headers.get("x-accel-buffering")).toBe("no")
+    expect(response.headers.get("x-content-type-options")).toBe("nosniff")
+    expect(await readFirstChunk(response)).toContain('data: {"type":"server.connected","properties":{}}\n\n')
+  })
+
+  test("matches legacy first event frame", async () => {
+    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
+    const headers = { "x-saeeol-directory": tmp.path }
+    const legacy = await app(false).request(EventPaths.event, { headers })
+    const effect = await app(true).request(EventPaths.event, { headers })
+
+    expect(await readFirstChunk(effect)).toBe(await readFirstChunk(legacy))
+  })
+})

package/test/server/httpapi-experimental.test.ts

@@ -0,0 +1,219 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { Flag } from "@saeeol/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { ExperimentalPaths } from "../../src/server/routes/instance/httpapi/groups/experimental"
+import { Session } from "@/session/session"
+import { Database } from "@/storage/db"
+import * as Log from "@saeeol/core/util/log"
+import { Worktree } from "../../src/worktree"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
+const testWorktreeMutations = process.platform === "win32" ? test.skip : test
+
+function app() {
+  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
+  return Server.Default().app
+}
+
+function runSession<A, E>(fx: Effect.Effect<A, E, Session.Service>) {
+  return Effect.runPromise(fx.pipe(Effect.provide(Session.defaultLayer)))
+}
+
+function createSession(input?: Session.CreateInput) {
+  return runSession(Session.Service.use((svc) => svc.create(input)))
+}
+
+async function waitReady(directory: string) {
+  return await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", onEvent)
+      reject(new Error("timed out waiting for worktree.ready"))
+    }, 10_000)
+
+    function onEvent(event: { directory?: string; payload: { type?: string } }) {
+      if (event.payload.type !== Worktree.Event.Ready.type || event.directory !== directory) return
+      clearTimeout(timer)
+      GlobalBus.off("event", onEvent)
+      resolve()
+    }
+
+    GlobalBus.on("event", onEvent)
+  })
+}
+
+afterEach(async () => {
+  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
+  await disposeAllInstances()
+  await resetDatabase()
+})
+
+describe("experimental HttpApi", () => {
+  // The /experimental/tool handler 500s via the bridge (InstanceState/AsyncLocalStorage leak).
+  // Bridge is gated behind SAEEOL_EXPERIMENTAL_HTTPAPI, not enabled in any production client.
+  test.skip("serves read-only experimental endpoints through Hono bridge", async () => {
+    await using tmp = await tmpdir({
+      config: {
+        formatter: false,
+        lsp: false,
+        mcp: {
+          demo: {
+            type: "local",
+            command: ["echo", "demo"],
+            enabled: false,
+          },
+        },
+      },
+    })
+
+    const headers = { "x-saeeol-directory": tmp.path }
+    const [consoleState, consoleOrgs, toolList, toolIDs, worktrees, resources] = await Promise.all([
+      app().request(ExperimentalPaths.console, { headers }),
+      app().request(ExperimentalPaths.consoleOrgs, { headers }),
+      app().request(`${ExperimentalPaths.tool}?provider=saeeol&model=gpt-5`, { headers }),
+      app().request(ExperimentalPaths.toolIDs, { headers }),
+      app().request(ExperimentalPaths.worktree, { headers }),
+      app().request(ExperimentalPaths.resource, { headers }),
+    ])
+
+    expect(consoleState.status).toBe(200)
+    expect(await consoleState.json()).toEqual({
+      consoleManagedProviders: [],
+      switchableOrgCount: 0,
+    })
+
+    expect(consoleOrgs.status).toBe(200)
+    expect(await consoleOrgs.json()).toEqual({ orgs: [] })
+
+    expect(toolList.status).toBe(200)
+    expect(await toolList.json()).toContainEqual(
+      expect.objectContaining({
+        id: "bash",
+        description: expect.any(String),
+        parameters: expect.any(Object),
+      }),
+    )
+
+    expect(toolIDs.status).toBe(200)
+    expect(await toolIDs.json()).toContain("bash")
+
+    expect(worktrees.status).toBe(200)
+    expect(await worktrees.json()).toEqual([])
+
+    expect(resources.status).toBe(200)
+    expect(await resources.json()).toEqual({})
+  })
+
+  test("serves Console org switch through Hono bridge", async () => {
+    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
+    Database.Client()
+      .$client.prepare(
+        "INSERT INTO account (id, email, url, access_token, refresh_token, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?)",
+      )
+      .run(
+        "account-test",
+        "test@example.com",
+        "https://console.example.com",
+        "access",
+        "refresh",
+        Date.now(),
+        Date.now(),
+      )
+
+    const switched = await app().request(ExperimentalPaths.consoleSwitch, {
+      method: "POST",
+      headers: { "x-saeeol-directory": tmp.path, "content-type": "application/json" },
+      body: JSON.stringify({ accountID: "account-test", orgID: "org-test" }),
+    })
+
+    expect(switched.status).toBe(200)
+    expect(await switched.json()).toBe(true)
+  })
+
+  test("serves global session list through Hono bridge", async () => {
+    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
+
+    const first = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => createSession({ title: "page-one" }),
+    })
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    const second = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => createSession({ title: "page-two" }),
+    })
+
+    const headers = { "x-saeeol-directory": tmp.path }
+    const page = await app().request(
+      `${ExperimentalPaths.session}?${new URLSearchParams({ directory: tmp.path, limit: "1" })}`,
+      { headers },
+    )
+    expect(page.status).toBe(200)
+    expect(page.headers.get("x-next-cursor")).toBeTruthy()
+
+    const body = (await page.json()) as Session.GlobalInfo[]
+    expect(body.map((session) => session.id)).toEqual([second.id])
+    expect(body[0].project?.id).toBe(second.projectID)
+
+    const next = await app().request(
+      `${ExperimentalPaths.session}?${new URLSearchParams({
+        directory: tmp.path,
+        limit: "10",
+        cursor: body[0].time.updated.toString(),
+      })}`,
+      { headers },
+    )
+    expect(next.status).toBe(200)
+    expect(((await next.json()) as Session.GlobalInfo[]).map((session) => session.id)).toContain(first.id)
+  })
+
+  testWorktreeMutations("serves worktree mutations through Hono bridge", async () => {
+    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
+
+    const headers = { "x-saeeol-directory": tmp.path, "content-type": "application/json" }
+    const created = await app().request(ExperimentalPaths.worktree, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ name: "api-test" }),
+    })
+
+    expect(created.status).toBe(200)
+    const info = (await created.json()) as Worktree.Info
+    expect(info).toMatchObject({ name: "api-test", branch: "saeeol/api-test" })
+    await waitReady(info.directory)
+
+    const listed = await app().request(ExperimentalPaths.worktree, { headers })
+    expect(listed.status).toBe(200)
+    expect(await listed.json()).toContain(info.directory)
+
+    if (process.platform !== "win32") {
+      const reset = await app().request(ExperimentalPaths.worktreeReset, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ directory: info.directory }),
+      })
+
+      expect(reset.status).toBe(200)
+      expect(await reset.json()).toBe(true)
+    }
+
+    const removed = await app().request(ExperimentalPaths.worktree, {
+      method: "DELETE",
+      headers,
+      body: JSON.stringify({ directory: info.directory }),
+    })
+
+    expect(removed.status).toBe(200)
+    expect(await removed.json()).toBe(true)
+
+    const afterRemove = await app().request(ExperimentalPaths.worktree, { headers })
+    expect(afterRemove.status).toBe(200)
+    expect(await afterRemove.json()).toEqual([])
+  })
+})

package/test/server/httpapi-file.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Context } from "effect"
+import path from "path"
+import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
+import { FilePaths } from "../../src/server/routes/instance/httpapi/groups/file"
+import { Instance } from "../../src/project/instance"
+import * as Log from "@saeeol/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const context = Context.empty() as Context.Context<unknown>
+
+function request(route: string, directory: string, query?: Record<string, string>) {
+  const url = new URL(`http://localhost${route}`)
+  for (const [key, value] of Object.entries(query ?? {})) {
+    url.searchParams.set(key, value)
+  }
+  return ExperimentalHttpApiServer.webHandler().handler(
+    new Request(url, {
+      headers: {
+        "x-saeeol-directory": directory,
+      },
+    }),
+    context,
+  )
+}
+
+afterEach(async () => {
+  await disposeAllInstances()
+  await resetDatabase()
+})
+
+describe("file HttpApi", () => {
+  test("serves read endpoints", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Bun.write(path.join(tmp.path, "hello.txt"), "hello")
+
+    const [list, content, status] = await Promise.all([
+      request(FilePaths.list, tmp.path, { path: "." }),
+      request(FilePaths.content, tmp.path, { path: "hello.txt" }),
+      request(FilePaths.status, tmp.path),
+    ])
+
+    expect(list.status).toBe(200)
+    expect(await list.json()).toContainEqual(
+      expect.objectContaining({ name: "hello.txt", path: "hello.txt", type: "file" }),
+    )
+
+    expect(content.status).toBe(200)
+    expect(await content.json()).toMatchObject({ type: "text", content: "hello" })
+
+    expect(status.status).toBe(200)
+    expect(await status.json()).toContainEqual({ path: "hello.txt", added: 1, removed: 0, status: "added" })
+  })
+  // Other platforms pass; bridge is gated behind SAEEOL_EXPERIMENTAL_HTTPAPI and not enabled in production.
+  // Tracked in SAEEOL/saeeol#9831.
+  const searchTest = process.platform === "win32" ? test.skip : test
+  searchTest("serves search endpoints", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Bun.write(path.join(tmp.path, "hello.txt"), "needle")
+
+    const [text, files, symbols] = await Promise.all([
+      request(FilePaths.findText, tmp.path, { pattern: "needle" }),
+      request(FilePaths.findFile, tmp.path, { query: "hello", type: "file" }),
+      request(FilePaths.findSymbol, tmp.path, { query: "hello" }),
+    ])
+
+    expect(text.status).toBe(200)
+    expect(await text.json()).toContainEqual(expect.objectContaining({ line_number: 1 }))
+
+    expect(files.status).toBe(200)
+    expect(await files.json()).toContain("hello.txt")
+
+    expect(symbols.status).toBe(200)
+    expect(await symbols.json()).toEqual([])
+  })
+})

package/test/server/httpapi-instance-context.test.ts

@@ -0,0 +1,237 @@
+import { NodeHttpServer, NodeServices } from "@effect/platform-node"
+import { Flag } from "@saeeol/core/flag/flag"
+import { GlobalBus } from "@/bus/global"
+import { describe, expect } from "bun:test"
+import { Effect, Fiber, Layer } from "effect"
+import { HttpClient, HttpClientRequest, HttpRouter, HttpServerResponse } from "effect/unstable/http"
+import * as Socket from "effect/unstable/socket/Socket"
+import { mkdir } from "node:fs/promises"
+import path from "node:path"
+import { registerAdapter } from "../../src/control-plane/adapters"
+import type { WorkspaceAdapter } from "../../src/control-plane/types"
+import { Workspace } from "../../src/control-plane/workspace"
+import { InstanceRef, WorkspaceRef } from "../../src/effect/instance-ref"
+import { InstanceBootstrap } from "../../src/project/bootstrap"
+import { Instance } from "../../src/project/instance"
+import { InstanceStore } from "../../src/project/instance-store"
+import { Project } from "../../src/project/project"
+import { disposeMiddleware, markInstanceForDisposal } from "../../src/server/routes/instance/httpapi/lifecycle"
+import { instanceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/instance-context"
+import { workspaceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const testStateLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const originalWorkspaces = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES
+    yield* Effect.promise(() => resetDatabase())
+    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(async () => {
+        Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = originalWorkspaces
+        await disposeAllInstances()
+        await resetDatabase()
+      }),
+    )
+  }),
+)
+
+const it = testEffect(
+  Layer.mergeAll(
+    testStateLayer,
+    NodeHttpServer.layerTest,
+    NodeServices.layer,
+    InstanceBootstrap.defaultLayer,
+    InstanceStore.defaultLayer,
+    Project.defaultLayer,
+    Workspace.defaultLayer,
+  ),
+)
+
+const instanceContextTestLayer = instanceRouterMiddleware
+  .combine(workspaceRouterMiddleware)
+  .layer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal))
+
+const localAdapter = (directory: string): WorkspaceAdapter => ({
+  name: "Local Test",
+  description: "Create a local test workspace",
+  configure: (info) => ({ ...info, name: "local-test", directory }),
+  create: async () => {
+    await mkdir(directory, { recursive: true })
+  },
+  async remove() {},
+  target: () => ({ type: "local" as const, directory }),
+})
+
+const createLocalWorkspace = (input: { projectID: Project.Info["id"]; type: string; directory: string }) =>
+  Effect.acquireRelease(
+    Effect.gen(function* () {
+      registerAdapter(input.projectID, input.type, localAdapter(input.directory))
+      const workspace = yield* Workspace.Service
+      return yield* workspace.create({
+        type: input.type,
+        branch: null,
+        extra: null,
+        projectID: input.projectID,
+      })
+    }),
+    (info) => Workspace.Service.use((workspace) => workspace.remove(info.id)).pipe(Effect.ignore),
+  )
+
+const probeInstanceContext = Effect.gen(function* () {
+  const instance = yield* InstanceRef
+  const workspaceID = yield* WorkspaceRef
+  return yield* HttpServerResponse.json({
+    directory: instance?.directory,
+    worktree: instance?.worktree,
+    projectID: instance?.project.id,
+    workspaceID,
+  })
+})
+
+const serveProbe = (probePath: HttpRouter.PathInput = "/probe") =>
+  HttpRouter.add("GET", probePath, probeInstanceContext).pipe(
+    Layer.provide(instanceContextTestLayer),
+    HttpRouter.serve,
+    Layer.build,
+  )
+
+const waitDisposedEvent = Effect.promise(
+  () =>
+    new Promise<{ directory?: string; workspace?: string }>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        GlobalBus.off("event", onEvent)
+        reject(new Error("timed out waiting for instance disposal"))
+      }, 10_000)
+
+      function onEvent(event: { directory?: string; workspace?: string; payload: { type?: string } }) {
+        if (event.payload.type !== "server.instance.disposed") return
+        clearTimeout(timer)
+        GlobalBus.off("event", onEvent)
+        resolve({ directory: event.directory, workspace: event.workspace })
+      }
+
+      GlobalBus.on("event", onEvent)
+    }),
+)
+
+const serveDisposeProbe = () =>
+  HttpRouter.serve(
+    HttpRouter.add(
+      "POST",
+      "/dispose-probe",
+      Effect.gen(function* () {
+        const instance = yield* InstanceRef
+        if (!instance) return HttpServerResponse.empty({ status: 500 })
+        yield* markInstanceForDisposal(instance)
+        return yield* HttpServerResponse.json(true)
+      }),
+    ).pipe(Layer.provide(instanceContextTestLayer)),
+    { middleware: disposeMiddleware, disableListenLog: true, disableLogger: true },
+  ).pipe(Layer.build)
+
+describe("HttpApi instance context middleware", () => {
+  it.live("provides instance context from the routed directory", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const project = yield* Project.use.fromDirectory(dir)
+      yield* serveProbe()
+
+      const response = yield* HttpClient.get(`/probe?directory=${encodeURIComponent(dir)}`)
+
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toEqual({
+        directory: dir,
+        worktree: dir,
+        projectID: project.project.id,
+      })
+    }),
+  )
+
+  it.live("falls back to the raw directory when URI decoding fails", () =>
+    Effect.gen(function* () {
+      yield* serveProbe()
+
+      const response = yield* HttpClient.get("/probe?directory=%25E0%25A4%25A")
+
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toMatchObject({
+        directory: path.join(process.cwd(), "%E0%A4%A"),
+      })
+    }),
+  )
+
+  it.live("provides selected workspace id on control-plane routes", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const project = yield* Project.use.fromDirectory(dir)
+      const workspaceDir = path.join(dir, ".workspace-local")
+      const workspace = yield* createLocalWorkspace({
+        projectID: project.project.id,
+        type: "instance-context-workspace-ref",
+        directory: workspaceDir,
+      })
+      yield* serveProbe("/session")
+
+      const response = yield* HttpClientRequest.get(`/session?workspace=${workspace.id}`).pipe(
+        HttpClientRequest.setHeader("x-saeeol-directory", dir),
+        HttpClient.execute,
+      )
+
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toMatchObject({
+        directory: dir,
+        workspaceID: workspace.id,
+      })
+    }),
+  )
+
+  it.live("uses workspace routing output instead of raw directory hints", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const project = yield* Project.use.fromDirectory(dir)
+      const workspaceDir = path.join(dir, ".workspace-local")
+      const workspace = yield* createLocalWorkspace({
+        projectID: project.project.id,
+        type: "instance-context-routing-output",
+        directory: workspaceDir,
+      })
+      yield* serveProbe()
+
+      const response = yield* HttpClientRequest.get(`/probe?workspace=${workspace.id}`).pipe(
+        HttpClientRequest.setHeader("x-saeeol-directory", dir),
+        HttpClient.execute,
+      )
+
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toMatchObject({
+        directory: workspaceDir,
+        workspaceID: workspace.id,
+      })
+    }),
+  )
+
+  it.live("preserves selected workspace id on instance disposal events", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+      const project = yield* Project.use.fromDirectory(dir)
+      const workspaceDir = path.join(dir, ".workspace-local")
+      const workspace = yield* createLocalWorkspace({
+        projectID: project.project.id,
+        type: "instance-context-dispose-event",
+        directory: workspaceDir,
+      })
+      yield* serveDisposeProbe()
+      const disposed = yield* waitDisposedEvent.pipe(Effect.forkScoped)
+
+      const response = yield* HttpClientRequest.post(`/dispose-probe?workspace=${workspace.id}`).pipe(
+        HttpClient.execute,
+      )
+
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toBe(true)
+      expect(yield* Fiber.join(disposed)).toEqual({ directory: workspaceDir, workspace: workspace.id })
+    }),
+  )
+})