test: harden edit watcher assertions

2026-04-11 20:13:44 -04:00
61 changed files with 67132 additions and 1581 deletions
@@ -26,7 +26,6 @@ kommander
 r44vc0rp
 rekram1-node
 -robinmordasiewicz
-simonklee
 -spider-yamet clawdbot/llm psychosis, spam pinging the team
 thdxr
 -toastythebot
@@ -114,7 +114,7 @@ jobs:
      - build-cli
      - version
    runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -213,6 +213,7 @@ jobs:
    needs:
      - build-cli
      - version
+    if: github.ref_name != 'beta'
    continue-on-error: false
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -389,7 +390,7 @@ jobs:
    needs:
      - build-cli
      - version
-    if: github.repository == 'anomalyco/opencode'
+    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
    continue-on-error: false
    env:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -590,12 +591,13 @@ jobs:
          path: packages/opencode/dist

      - uses: actions/download-artifact@v4
+        if: github.ref_name != 'beta'
        with:
          name: opencode-cli-signed-windows
          path: packages/opencode/dist

      - uses: actions/download-artifact@v4
-        if: needs.version.outputs.release
+        if: needs.version.outputs.release && github.ref_name != 'beta'
        with:
          pattern: latest-yml-*
          path: /tmp/latest-yml
@@ -319,7 +319,6 @@
        "@actions/core": "1.11.1",
        "@actions/github": "6.0.1",
        "@agentclientprotocol/sdk": "0.16.1",
-        "@ai-sdk/alibaba": "1.0.17",
        "@ai-sdk/amazon-bedrock": "4.0.93",
        "@ai-sdk/anthropic": "3.0.67",
        "@ai-sdk/azure": "3.0.49",
@@ -708,8 +707,6 @@

    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@0.16.1", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-1ad+Sc/0sCtZGHthxxvgEUo5Wsbw16I+aF+YwdiLnPwkZG8KAGUEAPK6LM6Pf69lCyJPt1Aomk1d+8oE3C4ZEw=="],

-    "@ai-sdk/alibaba": ["@ai-sdk/alibaba@1.0.17", "", { "dependencies": { "@ai-sdk/openai-compatible": "2.0.41", "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-ZbE+U5bWz2JBc5DERLowx5+TKbjGBE93LqKZAWvuEn7HOSQMraxFMZuc0ST335QZJAyfBOzh7m1mPQ+y7EaaoA=="],
-
    "@ai-sdk/amazon-bedrock": ["@ai-sdk/amazon-bedrock@4.0.93", "", { "dependencies": { "@ai-sdk/anthropic": "3.0.69", "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23", "@smithy/eventstream-codec": "^4.0.1", "@smithy/util-utf8": "^4.0.0", "aws4fetch": "^1.0.20" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-hcXDU8QDwpAzLVTuY932TQVlIij9+iaVTxc5mPGY6yb//JMAAC5hMVhg93IrxlrxWLvMgjezNgoZGwquR+SGnw=="],

    "@ai-sdk/anthropic": ["@ai-sdk/anthropic@3.0.64", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.21" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-rwLi/Rsuj2pYniQXIrvClHvXDzgM4UQHHnvHTWEF14efnlKclG/1ghpNC+adsRujAbCTr6gRsSbDE2vEqriV7g=="],
@@ -5006,8 +5003,6 @@

    "@actions/http-client/undici": ["undici@6.24.1", "", {}, "sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA=="],

-    "@ai-sdk/alibaba/@ai-sdk/openai-compatible": ["@ai-sdk/openai-compatible@2.0.41", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-kNAGINk71AlOXx10Dq/PXw4t/9XjdK8uxfpVElRwtSFMdeSiLVt58p9TPx4/FJD+hxZuVhvxYj9r42osxWq79g=="],
-
    "@ai-sdk/amazon-bedrock/@ai-sdk/anthropic": ["@ai-sdk/anthropic@3.0.69", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-LshR7X3pFugY0o41G2VKTmg1XoGpSl7uoYWfzk6zjVZLhCfeFiwgpOga+eTV4XY1VVpZwKVqRnkDbIL7K2eH5g=="],

    "@ai-sdk/amazon-bedrock/@smithy/eventstream-codec": ["@smithy/eventstream-codec@4.2.12", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@smithy/types": "^4.13.1", "@smithy/util-hex-encoding": "^4.2.2", "tslib": "^2.6.2" } }, "sha512-FE3bZdEl62ojmy8x4FHqxq2+BuOHlcxiH5vaZ6aqHJr3AIZzwF5jfx8dEiU/X0a8RboyNDjmXjlbr8AdEyLgiA=="],
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-g29OM3dy+sZ3ioTs8zjQOK1N+KnNr9ptP9xtdPcdr64=",
-    "aarch64-linux": "sha256-Iu91KwDcV5omkf4Ngny1aYpyCkPLjuoWOVUDOJUhW1k=",
-    "aarch64-darwin": "sha256-bk3G6m+Yo60Ea3Kyglc37QZf5Vm7MLMFcxemjc7HnL0=",
-    "x86_64-darwin": "sha256-y3hooQw13Z3Cu0KFfXYdpkTEeKTyuKd+a/jsXHQLdqA="
+    "x86_64-linux": "sha256-fNRQYkucjXr1D61HJRScJpDa6+oBdyhgTBxCu+PE2kQ=",
+    "aarch64-linux": "sha256-V8J6kn2nSdXrplyqi6aIqNlHcVjSxvye+yC/YFO7PF4=",
+    "aarch64-darwin": "sha256-6cLmUJVUycGALCmslXuloVGBSlFOSHRjsWjx7KOW8rg=",
+    "x86_64-darwin": "sha256-kcOSO3NFIJh79ylLotG41ovWLQfH5kh1WYFghUu+4HE="
  }
 }
@@ -274,7 +274,7 @@ const WorkspaceSessionList = (props: {
      <div class="relative w-full py-1">
        <Button
          variant="ghost"
-          class="flex w-full text-left justify-start text-14-regular text-text-weak pl-2 pr-10"
+          class="flex w-full text-left justify-start text-14-regular text-text-weak pl-9 pr-10"
          size="large"
          onClick={(e: MouseEvent) => {
            props.loadMore()
@@ -642,10 +642,10 @@ export function MessageTimeline(props: {
            onClick={props.onResumeScroll}
          >
            <div
-              class="flex items-center justify-center w-8 h-6 rounded-[6px] border border-border-weaker-base bg-[color-mix(in_srgb,var(--surface-raised-stronger-non-alpha)_80%,transparent)] backdrop-blur-[0.75px] transition-colors group-hover:border-[var(--border-weak-base)] group-hover:[--icon-base:var(--icon-hover)]"
+              class="flex items-center justify-center w-8 h-6 rounded-[6px] border border-[var(--gray-dark-7)] bg-[color-mix(in_srgb,var(--gray-dark-3)_80%,transparent)] backdrop-blur-[0.75px] transition-colors group-hover:border-[var(--gray-dark-8)] [--icon-base:var(--gray-dark-10)] group-hover:[--icon-base:var(--gray-dark-11)]"
              style={{
                "box-shadow":
-                  "0 51px 60px 0 rgba(0,0,0,0.10), 0 15px 18px 0 rgba(0,0,0,0.12), 0 6.386px 7.513px 0 rgba(0,0,0,0.12), 0 2.31px 2.717px 0 rgba(0,0,0,0.20)",
+                  "0 51px 60px 0 rgba(0,0,0,0.13), 0 15.375px 18.088px 0 rgba(0,0,0,0.19), 0 6.386px 7.513px 0 rgba(0,0,0,0.25), 0 2.31px 2.717px 0 rgba(0,0,0,0.38)",
              }}
            >
              <Icon name="arrow-down-to-line" size="small" />
@@ -4,7 +4,7 @@ import type { IpcMainEvent, IpcMainInvokeEvent } from "electron"

 import type { InitStep, ServerReadyData, SqliteMigrationProgress, TitlebarTheme, WslConfig } from "../preload/types"
 import { getStore } from "./store"
-import { getWindowId, setTitlebar } from "./windows"
+import { setTitlebar } from "./windows"

 const pickerFilters = (ext?: string[]) => {
  if (!ext || ext.length === 0) return undefined
@@ -151,12 +151,6 @@ export function registerIpcHandlers(deps: Deps) {

  ipcMain.handle("get-window-count", () => BrowserWindow.getAllWindows().length)

-  ipcMain.handle("get-window-id", (event: IpcMainInvokeEvent) => {
-    const win = BrowserWindow.fromWebContents(event.sender)
-    if (!win) return null
-    return getWindowId(win) ?? null
-  })
-
  ipcMain.handle("get-window-focused", (event: IpcMainInvokeEvent) => {
    const win = BrowserWindow.fromWebContents(event.sender)
    return win?.isFocused() ?? false
@@ -1,4 +1,3 @@
-import { randomInt } from "node:crypto"
 import windowState from "electron-window-state"
 import { app, BrowserWindow, nativeImage, nativeTheme } from "electron"
 import { dirname, join } from "node:path"
@@ -13,9 +12,6 @@ type Globals = {
 const root = dirname(fileURLToPath(import.meta.url))

 let backgroundColor: string | undefined
-const ids = new WeakMap<BrowserWindow, string>()
-const used = new Set<string>()
-let seen = false

 export function setBackgroundColor(color: string) {
  backgroundColor = color
@@ -25,10 +21,6 @@ export function getBackgroundColor(): string | undefined {
  return backgroundColor
 }

-export function getWindowId(win: BrowserWindow) {
-  return ids.get(win)
-}
-
 function iconsDir() {
  return app.isPackaged ? join(process.resourcesPath, "icons") : join(root, "../../resources/icons")
 }
@@ -74,7 +66,7 @@ export function createMainWindow(globals: Globals) {
    y: state.y,
    width: state.width,
    height: state.height,
-    show: false,
+    show: true,
    title: "OpenCode",
    icon: iconPath(),
    backgroundColor,
@@ -96,17 +88,12 @@ export function createMainWindow(globals: Globals) {
      sandbox: false,
    },
  })
-  track(win)

  state.manage(win)
  loadWindow(win, "index.html")
  wireZoom(win)
  injectGlobals(win, globals)

-  win.once("ready-to-show", () => {
-    win.show()
-  })
-
  return win
 }

@@ -170,26 +157,3 @@ function wireZoom(win: BrowserWindow) {
    win.webContents.setZoomFactor(1)
  })
 }
-
-function track(win: BrowserWindow) {
-  const id = nextId()
-  ids.set(win, id)
-  win.once("closed", () => {
-    used.delete(id)
-  })
-}
-
-function nextId() {
-  if (!seen) {
-    seen = true
-    used.add("main")
-    return "main"
-  }
-
-  while (true) {
-    const id = String(randomInt(100_000, 1_000_000))
-    if (used.has(id)) continue
-    used.add(id)
-    return id
-  }
-}
@@ -29,7 +29,6 @@ const api: ElectronAPI = {
  storeLength: (name) => ipcRenderer.invoke("store-length", name),

  getWindowCount: () => ipcRenderer.invoke("get-window-count"),
-  getWindowId: () => ipcRenderer.invoke("get-window-id"),
  onSqliteMigrationProgress: (cb) => {
    const handler = (_: unknown, progress: SqliteMigrationProgress) => cb(progress)
    ipcRenderer.on("sqlite-migration-progress", handler)
@@ -37,7 +37,6 @@ export type ElectronAPI = {
  storeLength: (name: string) => Promise<number>

  getWindowCount: () => Promise<number>
-  getWindowId: () => Promise<string | null>
  onSqliteMigrationProgress: (cb: (progress: SqliteMigrationProgress) => void) => () => void
  onMenuCommand: (cb: (id: string) => void) => () => void
  onDeepLink: (cb: (urls: string[]) => void) => () => void
@@ -14,11 +14,18 @@
    "fix-node-pty": "bun run script/fix-node-pty.ts",
    "upgrade-opentui": "bun run script/upgrade-opentui.ts",
    "dev": "bun run --conditions=browser ./src/index.ts",
+    "random": "echo 'Random script updated at $(date)' && echo 'Change queued successfully' && echo 'Another change made' && echo 'Yet another change' && echo 'One more change' && echo 'Final change' && echo 'Another final change' && echo 'Yet another final change'",
+    "clean": "echo 'Cleaning up...' && rm -rf node_modules dist",
+    "lint": "echo 'Running lint checks...' && bun test --coverage",
+    "format": "echo 'Formatting code...' && bun run --prettier --write src/**/*.ts",
+    "docs": "echo 'Generating documentation...' && find src -name '*.ts' -exec echo 'Processing: {}' \\;",
+    "deploy": "echo 'Deploying application...' && bun run build && echo 'Deployment completed successfully'",
    "db": "bun drizzle-kit"
  },
  "bin": {
    "opencode": "./bin/opencode"
  },
+  "randomField": "this-is-a-random-value-12345",
  "exports": {
    "./*": "./src/*.ts"
  },
@@ -76,7 +83,6 @@
    "@actions/core": "1.11.1",
    "@actions/github": "6.0.1",
    "@agentclientprotocol/sdk": "0.16.1",
-    "@ai-sdk/alibaba": "1.0.17",
    "@ai-sdk/amazon-bedrock": "4.0.93",
    "@ai-sdk/anthropic": "3.0.67",
    "@ai-sdk/azure": "3.0.49",
@@ -217,7 +217,6 @@ Fully migrated (single namespace, InstanceState where needed, flattened facade):
 - [x] `SessionSummary` — `session/summary.ts`
 - [x] `SessionRevert` — `session/revert.ts`
 - [x] `Instruction` — `session/instruction.ts`
- [x] `SystemPrompt` — `session/system.ts`
 - [x] `Provider` — `provider/provider.ts`
 - [x] `Storage` — `storage/storage.ts`
 - [x] `ShareNext` — `share/share-next.ts`
@@ -341,47 +340,3 @@ For each service, the migration is roughly:
 - `ShareNext` — migrated 2026-04-11. Swapped remaining async callers to `AppRuntime.runPromise(ShareNext.Service.use(...))`, removed the `makeRuntime(...)` facade, and kept instance bootstrap on the shared app runtime.
 - `SessionTodo` — migrated 2026-04-10. Already matched the target service shape in `session/todo.ts`: single namespace, traced Effect methods, and no `makeRuntime(...)` facade remained; checklist updated to reflect the completed migration.
 - `Storage` — migrated 2026-04-10. One production caller (`Session.diff`) and all storage.test.ts tests converted to effectful style. Facades and `makeRuntime` removed.
- `SessionRunState` — migrated 2026-04-11. Single caller in `server/routes/session.ts` converted; facade removed.
- `Account` — migrated 2026-04-11. Callers in `server/routes/experimental.ts` and `cli/cmd/account.ts` converted; facade removed.
- `Instruction` — migrated 2026-04-11. Test-only callers converted; facade removed.
- `FileTime` — migrated 2026-04-11. Test-only callers converted; facade removed.
- `FileWatcher` — migrated 2026-04-11. Callers in `project/bootstrap.ts` and test converted; facade removed.
- `Question` — migrated 2026-04-11. Callers in `server/routes/question.ts` and test converted; facade removed.
- `Truncate` — migrated 2026-04-11. Caller in `tool/tool.ts` and test converted; facade removed.
-
-## Route handler effectification
-
-Route handlers should wrap their entire body in a single `AppRuntime.runPromise(Effect.gen(...))` call, yielding services from context rather than calling facades one-by-one. This eliminates multiple `runPromise` round-trips and lets handlers compose naturally.
-
-```ts
-// Before — one facade call per service
-;async (c) => {
-  await SessionRunState.assertNotBusy(id)
-  await Session.removeMessage({ sessionID: id, messageID })
-  return c.json(true)
-}
-
-// After — one Effect.gen, yield services from context
-;async (c) => {
-  await AppRuntime.runPromise(
-    Effect.gen(function* () {
-      const state = yield* SessionRunState.Service
-      const session = yield* Session.Service
-      yield* state.assertNotBusy(id)
-      yield* session.removeMessage({ sessionID: id, messageID })
-    }),
-  )
-  return c.json(true)
-}
-```
-
-When migrating, always use `{ concurrency: "unbounded" }` with `Effect.all` — route handlers should run independent service calls in parallel, not sequentially.
-
-Route files to convert (each handler that calls facades should be wrapped):
-
- [ ] `server/routes/session.ts` — heaviest; uses Session, SessionPrompt, SessionRevert, SessionCompaction, SessionShare, SessionSummary, SessionRunState, Agent, Permission, Bus
- [ ] `server/routes/global.ts` — uses Config, Project, Provider, Vcs, Snapshot, Agent
- [ ] `server/routes/provider.ts` — uses Provider, Auth, Config
- [ ] `server/routes/question.ts` — uses Question
- [ ] `server/routes/pty.ts` — uses Pty
- [ ] `server/routes/experimental.ts` — uses Account, ToolRegistry, Agent, MCP, Config
@@ -148,12 +148,6 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
  }

  if (method.type === "api") {
-    const key = await prompts.password({
-      message: "Enter your API key",
-      validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-    })
-    if (prompts.isCancel(key)) throw new UI.CancelledError()
-
    if (method.authorize) {
      const result = await method.authorize(inputs)
      if (result.type === "failed") {
@@ -163,7 +157,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
        const saveProvider = result.provider ?? provider
        await Auth.set(saveProvider, {
          type: "api",
-          key: result.key ?? key,
+          key: result.key,
        })
        prompts.log.success("Login successful")
      }
@@ -1,10 +1,9 @@
 import { Layer, ManagedRuntime } from "effect"
 import { memoMap } from "./run-service"

-import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format"
 import { ShareNext } from "@/share/share-next"

-export const BootstrapLayer = Layer.mergeAll(Format.defaultLayer, ShareNext.defaultLayer, FileWatcher.defaultLayer)
+export const BootstrapLayer = Layer.mergeAll(Format.defaultLayer, ShareNext.defaultLayer)

 export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })
@@ -1,5 +1,6 @@
 import { DateTime, Effect, Layer, Option, Semaphore, Context } from "effect"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { Flag } from "@/flag/flag"
 import type { SessionID } from "@/session/schema"
@@ -111,4 +112,22 @@ export namespace FileTime {
  ).pipe(Layer.orDie)

  export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function read(sessionID: SessionID, file: string) {
+    return runPromise((s) => s.read(sessionID, file))
+  }
+
+  export function get(sessionID: SessionID, file: string) {
+    return runPromise((s) => s.get(sessionID, file))
+  }
+
+  export async function assert(sessionID: SessionID, filepath: string) {
+    return runPromise((s) => s.assert(sessionID, filepath))
+  }
+
+  export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> {
+    return runPromise((s) => s.withLock(filepath, () => Effect.promise(fn)))
+  }
 }
@@ -8,6 +8,7 @@ import z from "zod"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { Git } from "@/git"
 import { Instance } from "@/project/instance"
@@ -160,4 +161,10 @@ export namespace FileWatcher {
  )

  export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Git.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function init() {
+    return runPromise((svc) => svc.init())
+  }
 }
@@ -5,7 +5,6 @@ import { iife } from "@/util/iife"
 import { Log } from "../../util/log"
 import { setTimeout as sleep } from "node:timers/promises"
 import { CopilotModels } from "./models"
-import { MessageV2 } from "@/session/message-v2"

 const log = Log.create({ service: "plugin.copilot" })

@@ -28,27 +27,11 @@ function base(enterpriseUrl?: string) {
  return enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : "https://api.githubcopilot.com"
 }

-// Check if a message is a synthetic user msg used to attach an image from a tool call
-function imgMsg(msg: any): boolean {
-  if (msg?.role !== "user") return false
-
-  // Handle the 3 api formats
-
-  const content = msg.content
-  if (typeof content === "string") return content === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT
-  if (!Array.isArray(content)) return false
-  return content.some(
-    (part: any) =>
-      (part?.type === "text" || part?.type === "input_text") && part.text === MessageV2.SYNTHETIC_ATTACHMENT_PROMPT,
-  )
-}
-
-function fix(model: Model, url: string): Model {
+function fix(model: Model): Model {
  return {
    ...model,
    api: {
      ...model.api,
-      url,
      npm: "@ai-sdk/github-copilot",
    },
  }
@@ -61,23 +44,19 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
      id: "github-copilot",
      async models(provider, ctx) {
        if (ctx.auth?.type !== "oauth") {
-          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model, base())]))
+          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
        }

-        const auth = ctx.auth
-
        return CopilotModels.get(
-          base(auth.enterpriseUrl),
+          base(ctx.auth.enterpriseUrl),
          {
-            Authorization: `Bearer ${auth.refresh}`,
+            Authorization: `Bearer ${ctx.auth.refresh}`,
            "User-Agent": `opencode/${Installation.VERSION}`,
          },
          provider.models,
        ).catch((error) => {
          log.error("failed to fetch copilot models", { error })
-          return Object.fromEntries(
-            Object.entries(provider.models).map(([id, model]) => [id, fix(model, base(auth.enterpriseUrl))]),
-          )
+          return Object.fromEntries(Object.entries(provider.models).map(([id, model]) => [id, fix(model)]))
        })
      },
    },
@@ -87,7 +66,10 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
        const info = await getAuth()
        if (!info || info.type !== "oauth") return {}

+        const baseURL = base(info.enterpriseUrl)
+
        return {
+          baseURL,
          apiKey: "",
          async fetch(request: RequestInfo | URL, init?: RequestInit) {
            const info = await getAuth()
@@ -106,7 +88,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                      (msg: any) =>
                        Array.isArray(msg.content) && msg.content.some((part: any) => part.type === "image_url"),
                    ),
-                    isAgent: last?.role !== "user" || imgMsg(last),
+                    isAgent: last?.role !== "user",
                  }
                }

@@ -118,7 +100,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                      (item: any) =>
                        Array.isArray(item?.content) && item.content.some((part: any) => part.type === "input_image"),
                    ),
-                    isAgent: last?.role !== "user" || imgMsg(last),
+                    isAgent: last?.role !== "user",
                  }
                }

@@ -140,7 +122,7 @@ export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
                              part.content.some((nested: any) => nested?.type === "image")),
                        ),
                    ),
-                    isAgent: !(last?.role === "user" && hasNonToolCalls) || imgMsg(last),
+                    isAgent: !(last?.role === "user" && hasNonToolCalls),
                  }
                }
              } catch {}
@@ -52,15 +52,13 @@ export namespace CopilotModels {
      (remote.capabilities.supports.vision ?? false) ||
      (remote.capabilities.limits.vision?.supported_media_types ?? []).some((item) => item.startsWith("image/"))

-    const isMsgApi = remote.supported_endpoints?.includes("/v1/messages")
-
    return {
      id: key,
      providerID: "github-copilot",
      api: {
        id: remote.id,
-        url: isMsgApi ? `${url}/v1` : url,
-        npm: isMsgApi ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot",
+        url,
+        npm: "@ai-sdk/github-copilot",
      },
      // API response wins
      status: "active",
@@ -2,6 +2,7 @@ import { Plugin } from "../plugin"
 import { Format } from "../format"
 import { LSP } from "../lsp"
 import { File } from "../file"
+import { FileWatcher } from "../file/watcher"
 import { Snapshot } from "../snapshot"
 import { Project } from "./project"
 import { Vcs } from "./vcs"
@@ -10,7 +11,6 @@ import { Command } from "../command"
 import { Instance } from "./instance"
 import { Log } from "@/util/log"
 import { BootstrapRuntime } from "@/effect/bootstrap-runtime"
-import { FileWatcher } from "@/file/watcher"
 import { ShareNext } from "@/share/share-next"

 export async function InstanceBootstrap() {
@@ -20,7 +20,7 @@ export async function InstanceBootstrap() {
  void BootstrapRuntime.runPromise(Format.Service.use((svc) => svc.init()))
  await LSP.init()
  File.init()
-  void BootstrapRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
+  FileWatcher.init()
  Vcs.init()
  Snapshot.init()

@@ -0,0 +1,2 @@
+// Auto-generated by build.ts - do not edit
+export declare const snapshot: Record<string, unknown>
@@ -46,7 +46,6 @@ import { createTogetherAI } from "@ai-sdk/togetherai"
 import { createPerplexity } from "@ai-sdk/perplexity"
 import { createVercel } from "@ai-sdk/vercel"
 import { createVenice } from "venice-ai-sdk-provider"
-import { createAlibaba } from "@ai-sdk/alibaba"
 import {
  createGitLab,
  VERSION as GITLAB_PROVIDER_VERSION,
@@ -146,7 +145,6 @@ export namespace Provider {
    "@ai-sdk/togetherai": createTogetherAI,
    "@ai-sdk/perplexity": createPerplexity,
    "@ai-sdk/vercel": createVercel,
-    "@ai-sdk/alibaba": createAlibaba,
    "gitlab-ai-provider": createGitLab,
    "@ai-sdk/github-copilot": createGitHubCopilotOpenAICompatible,
    "venice-ai-sdk-provider": createVenice,
@@ -209,9 +209,6 @@ export namespace ProviderTransform {
      copilot: {
        copilot_cache_control: { type: "ephemeral" },
      },
-      alibaba: {
-        cacheControl: { type: "ephemeral" },
-      },
    }

    for (const msg of unique([...system, ...final])) {
@@ -288,8 +285,7 @@ export namespace ProviderTransform {
        model.api.id.includes("claude") ||
        model.id.includes("anthropic") ||
        model.id.includes("claude") ||
-        model.api.npm === "@ai-sdk/anthropic" ||
-        model.api.npm === "@ai-sdk/alibaba") &&
+        model.api.npm === "@ai-sdk/anthropic") &&
      model.api.npm !== "@ai-sdk/gateway"
    ) {
      msgs = applyCaching(msgs, model)
@@ -2,6 +2,7 @@ import { Deferred, Effect, Layer, Schema, Context } from "effect"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { SessionID, MessageID } from "@/session/schema"
 import { Log } from "@/util/log"
 import z from "zod"
@@ -198,4 +199,26 @@ export namespace Question {
  )

  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function ask(input: {
+    sessionID: SessionID
+    questions: Info[]
+    tool?: { messageID: MessageID; callID: string }
+  }): Promise<Answer[]> {
+    return runPromise((s) => s.ask(input))
+  }
+
+  export async function reply(input: { requestID: QuestionID; answers: Answer[] }) {
+    return runPromise((s) => s.reply(input))
+  }
+
+  export async function reject(requestID: QuestionID) {
+    return runPromise((s) => s.reject(requestID))
+  }
+
+  export async function list() {
+    return runPromise((s) => s.list())
+  }
 }
@@ -3,7 +3,6 @@ import { describeRoute, validator } from "hono-openapi"
 import { resolver } from "hono-openapi"
 import { QuestionID } from "@/question/schema"
 import { Question } from "../../question"
-import { AppRuntime } from "@/effect/app-runtime"
 import z from "zod"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"
@@ -28,7 +27,7 @@ export const QuestionRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        const questions = await AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))
+        const questions = await Question.list()
        return c.json(questions)
      },
    )
@@ -60,14 +59,10 @@ export const QuestionRoutes = lazy(() =>
      async (c) => {
        const params = c.req.valid("param")
        const json = c.req.valid("json")
-        await AppRuntime.runPromise(
-          Question.Service.use((svc) =>
-            svc.reply({
-              requestID: params.requestID,
-              answers: json.answers,
-            }),
-          ),
-        )
+        await Question.reply({
+          requestID: params.requestID,
+          answers: json.answers,
+        })
        return c.json(true)
      },
    )
@@ -97,7 +92,7 @@ export const QuestionRoutes = lazy(() =>
      ),
      async (c) => {
        const params = c.req.valid("param")
-        await AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(params.requestID)))
+        await Question.reject(params.requestID)
        return c.json(true)
      },
    ),
@@ -13,7 +13,6 @@ import { SessionShare } from "@/share/session"
 import { SessionStatus } from "@/session/status"
 import { SessionSummary } from "@/session/summary"
 import { Todo } from "../../session/todo"
-import { Effect } from "effect"
 import { AppRuntime } from "../../effect/app-runtime"
 import { Agent } from "../../agent/agent"
 import { Snapshot } from "@/snapshot"
@@ -725,17 +724,11 @@ export const SessionRoutes = lazy(() =>
      ),
      async (c) => {
        const params = c.req.valid("param")
-        await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const state = yield* SessionRunState.Service
-            const session = yield* Session.Service
-            yield* state.assertNotBusy(params.sessionID)
-            yield* session.removeMessage({
-              sessionID: params.sessionID,
-              messageID: params.messageID,
-            })
-          }),
-        )
+        await SessionRunState.assertNotBusy(params.sessionID)
+        await Session.removeMessage({
+          sessionID: params.sessionID,
+          messageID: params.messageID,
+        })
        return c.json(true)
      },
    )
@@ -4,7 +4,7 @@ import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
 import { Decimal } from "decimal.js"
 import z from "zod"
-import { type ProviderMetadata, type LanguageModelUsage } from "ai"
+import { type ProviderMetadata } from "ai"
 import { Flag } from "../flag/flag"
 import { Installation } from "../installation"

@@ -28,6 +28,7 @@ import { SessionID, MessageID, PartID } from "./schema"
 import type { Provider } from "@/provider/provider"
 import { Permission } from "@/permission"
 import { Global } from "@/global"
+import type { LanguageModelV2Usage } from "@ai-sdk/provider"
 import { Effect, Layer, Option, Context } from "effect"
 import { makeRuntime } from "@/effect/run-service"

@@ -239,7 +240,7 @@ export namespace Session {

  export const getUsage = (input: {
    model: Provider.Model
-    usage: LanguageModelUsage
+    usage: LanguageModelV2Usage
    metadata?: ProviderMetadata
  }) => {
    const safe = (value: number) => {
@@ -248,14 +249,11 @@ export namespace Session {
    }
    const inputTokens = safe(input.usage.inputTokens ?? 0)
    const outputTokens = safe(input.usage.outputTokens ?? 0)
-    const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
+    const reasoningTokens = safe(input.usage.reasoningTokens ?? 0)

-    const cacheReadInputTokens = safe(
-      input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0,
-    )
+    const cacheReadInputTokens = safe(input.usage.cachedInputTokens ?? 0)
    const cacheWriteInputTokens = safe(
-      (input.usage.inputTokenDetails?.cacheWriteTokens ??
-        input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
+      (input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
        // google-vertex-anthropic returns metadata under "vertex" key
        // (AnthropicMessagesLanguageModel custom provider key from 'vertex.anthropic.messages')
        input.metadata?.["vertex"]?.["cacheCreationInputTokens"] ??
@@ -276,7 +274,7 @@ export namespace Session {
    const tokens = {
      total,
      input: adjustedInputTokens,
-      output: safe(outputTokens - reasoningTokens),
+      output: outputTokens - reasoningTokens,
      reasoning: reasoningTokens,
      cache: {
        write: cacheWriteInputTokens,
@@ -4,6 +4,7 @@ import { Effect, Layer, Context } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
 import { Config } from "@/config/config"
 import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { AppFileSystem } from "@/filesystem"
 import { withTransientReadRetry } from "@/util/effect-http-client"
@@ -237,7 +238,21 @@ export namespace Instruction {
    Layer.provide(FetchHttpClient.layer),
  )

+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function clear(messageID: MessageID) {
+    return runPromise((svc) => svc.clear(messageID))
+  }
+
+  export async function systemPaths() {
+    return runPromise((svc) => svc.systemPaths())
+  }
+
  export function loaded(messages: MessageV2.WithParts[]) {
    return extract(messages)
  }
+
+  export async function resolve(messages: MessageV2.WithParts[], filepath: string, messageID: MessageID) {
+    return runPromise((svc) => svc.resolve(messages, filepath, messageID))
+  }
 }
@@ -25,8 +25,6 @@ interface FetchDecompressionError extends Error {
 }

 export namespace MessageV2 {
-  export const SYNTHETIC_ATTACHMENT_PROMPT = "Attached image(s) from tool result:"
-
  export function isMedia(mime: string) {
    return mime.startsWith("image/") || mime === "application/pdf"
  }
@@ -810,7 +808,7 @@ export namespace MessageV2 {
              parts: [
                {
                  type: "text" as const,
-                  text: SYNTHETIC_ATTACHMENT_PROMPT,
+                  text: "Attached image(s) from tool result:",
                },
                ...media.map((attachment) => ({
                  type: "file" as const,
@@ -1,5 +1,6 @@
 import { InstanceState } from "@/effect/instance-state"
 import { Runner } from "@/effect/runner"
+import { makeRuntime } from "@/effect/run-service"
 import { Effect, Layer, Scope, Context } from "effect"
 import { Session } from "."
 import { MessageV2 } from "./message-v2"
@@ -105,4 +106,9 @@ export namespace SessionRunState {
  )

  export const defaultLayer = layer.pipe(Layer.provide(SessionStatus.defaultLayer))
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function assertNotBusy(sessionID: SessionID) {
+    return runPromise((svc) => svc.assertNotBusy(sessionID))
+  }
 }
@@ -177,39 +177,8 @@ export namespace Snapshot {
            const all = Array.from(new Set([...tracked, ...untracked]))
            if (!all.length) return

-            // Filter out files that are now gitignored even if previously tracked
-            // Files may have been tracked before being gitignored, so we need to check
-            // against the source project's current gitignore rules
-            // Use --no-index to check purely against patterns (ignoring whether file is tracked)
-            const checkArgs = [
-              ...quote,
-              "--git-dir",
-              path.join(state.worktree, ".git"),
-              "--work-tree",
-              state.worktree,
-              "check-ignore",
-              "--no-index",
-              "--",
-              ...all,
-            ]
-            const check = yield* git(checkArgs, { cwd: state.directory })
-            const ignored =
-              check.code === 0 ? new Set(check.text.trim().split("\n").filter(Boolean)) : new Set<string>()
-            const filtered = all.filter((item) => !ignored.has(item))
-
-            // Remove newly-ignored files from snapshot index to prevent re-adding
-            if (ignored.size > 0) {
-              const ignoredFiles = Array.from(ignored)
-              log.info("removing gitignored files from snapshot", { count: ignoredFiles.length })
-              yield* git([...cfg, ...args(["rm", "--cached", "-f", "--", ...ignoredFiles])], {
-                cwd: state.directory,
-              })
-            }
-
-            if (!filtered.length) return
-
            const large = (yield* Effect.all(
-              filtered.map((item) =>
+              all.map((item) =>
                fs
                  .stat(path.join(state.directory, item))
                  .pipe(Effect.catch(() => Effect.void))
@@ -290,39 +259,14 @@ export namespace Snapshot {
                  log.warn("failed to get diff", { hash, exitCode: result.code })
                  return { hash, files: [] }
                }
-                const files = result.text
-                  .trim()
-                  .split("\n")
-                  .map((x) => x.trim())
-                  .filter(Boolean)
-
-                // Filter out files that are now gitignored
-                if (files.length > 0) {
-                  const checkArgs = [
-                    ...quote,
-                    "--git-dir",
-                    path.join(state.worktree, ".git"),
-                    "--work-tree",
-                    state.worktree,
-                    "check-ignore",
-                    "--no-index",
-                    "--",
-                    ...files,
-                  ]
-                  const check = yield* git(checkArgs, { cwd: state.directory })
-                  if (check.code === 0) {
-                    const ignored = new Set(check.text.trim().split("\n").filter(Boolean))
-                    const filtered = files.filter((item) => !ignored.has(item))
-                    return {
-                      hash,
-                      files: filtered.map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
-                    }
-                  }
-                }
-
                return {
                  hash,
-                  files: files.map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
+                  files: result.text
+                    .trim()
+                    .split("\n")
+                    .map((x) => x.trim())
+                    .filter(Boolean)
+                    .map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
                }
              }),
            )
@@ -672,30 +616,6 @@ export namespace Snapshot {
                      } satisfies Row,
                    ]
                  })
-
-                // Filter out files that are now gitignored
-                if (rows.length > 0) {
-                  const files = rows.map((r) => r.file)
-                  const checkArgs = [
-                    ...quote,
-                    "--git-dir",
-                    path.join(state.worktree, ".git"),
-                    "--work-tree",
-                    state.worktree,
-                    "check-ignore",
-                    "--no-index",
-                    "--",
-                    ...files,
-                  ]
-                  const check = yield* git(checkArgs, { cwd: state.directory })
-                  if (check.code === 0) {
-                    const ignored = new Set(check.text.trim().split("\n").filter(Boolean))
-                    const filtered = rows.filter((r) => !ignored.has(r.file))
-                    rows.length = 0
-                    rows.push(...filtered)
-                  }
-                }
-
                const step = 100
                const patch = (file: string, before: string, after: string) =>
                  formatPatch(structuredPatch(file, file, before, after, "", "", { context: Number.MAX_SAFE_INTEGER }))
@@ -70,12 +70,7 @@ export namespace Tool {
        ? Def<P, M>
        : never

-  function wrap<Parameters extends z.ZodType, Result extends Metadata>(
-    id: string,
-    init: Init<Parameters, Result>,
-    truncate: Truncate.Interface,
-    agents: Agent.Interface,
-  ) {
+  function wrap<Parameters extends z.ZodType, Result extends Metadata>(id: string, init: Init<Parameters, Result>) {
    return () =>
      Effect.gen(function* () {
        const toolInfo = init instanceof Function ? { ...(yield* init()) } : { ...init }
@@ -98,8 +93,8 @@ export namespace Tool {
            if (result.metadata.truncated !== undefined) {
              return result
            }
-            const agent = yield* agents.get(ctx.agent)
-            const truncated = yield* truncate.output(result.output, {}, agent)
+            const agent = yield* Effect.promise(() => Agent.get(ctx.agent))
+            const truncated = yield* Effect.promise(() => Truncate.output(result.output, {}, agent))
            return {
              ...result,
              output: truncated.content,
@@ -117,14 +112,9 @@ export namespace Tool {
  export function define<Parameters extends z.ZodType, Result extends Metadata, R, ID extends string = string>(
    id: ID,
    init: Effect.Effect<Init<Parameters, Result>, never, R>,
-  ): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
+  ): Effect.Effect<Info<Parameters, Result>, never, R> & { id: ID } {
    return Object.assign(
-      Effect.gen(function* () {
-        const resolved = yield* init
-        const truncate = yield* Truncate.Service
-        const agents = yield* Agent.Service
-        return { id, init: wrap(id, resolved, truncate, agents) }
-      }),
+      Effect.map(init, (init) => ({ id, init: wrap(id, init) })),
      { id },
    )
  }
@@ -2,6 +2,7 @@ import { NodePath } from "@effect/platform-node"
 import { Cause, Duration, Effect, Layer, Schedule, Context } from "effect"
 import path from "path"
 import type { Agent } from "../agent/agent"
+import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { evaluate } from "@/permission/evaluate"
 import { Identifier } from "../id/id"
@@ -134,4 +135,10 @@ export namespace Truncate {
  )

  export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function output(text: string, options: Options = {}, agent?: Agent.Info): Promise<Result> {
+    return runPromise((s) => s.output(text, options, agent))
+  }
 }
@@ -15,7 +15,6 @@ export namespace Log {
    WARN: 2,
    ERROR: 3,
  }
-  const keep = 10

  let level: Level = "INFO"

@@ -79,19 +78,15 @@ export namespace Log {
  }

  async function cleanup(dir: string) {
-    const files = (
-      await Glob.scan("????-??-??T??????.log", {
-        cwd: dir,
-        absolute: false,
-        include: "file",
-      }).catch(() => [])
-    )
-      .filter((file) => path.basename(file) === file)
-      .sort()
-    if (files.length <= keep) return
+    const files = await Glob.scan("????-??-??T??????.log", {
+      cwd: dir,
+      absolute: true,
+      include: "file",
+    })
+    if (files.length <= 5) return

-    const doomed = files.slice(0, -keep)
-    await Promise.all(doomed.map((file) => fs.unlink(path.join(dir, file)).catch(() => {})))
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
  }

  function formatError(error: Error, depth = 0): string {
@@ -10,106 +10,59 @@ export namespace Message {
    })),
  )

-  export class Source extends Schema.Class<Source>("Message.Source")({
-    start: Schema.Number,
-    end: Schema.Number,
-    text: Schema.String,
-  }) {}
-
-  export class FileAttachment extends Schema.Class<FileAttachment>("Message.File.Attachment")({
-    uri: Schema.String,
+  export class File extends Schema.Class<File>("Message.File")({
+    url: Schema.String,
    mime: Schema.String,
-    name: Schema.String.pipe(Schema.optional),
-    description: Schema.String.pipe(Schema.optional),
-    source: Source.pipe(Schema.optional),
  }) {
    static create(url: string) {
-      return new FileAttachment({
-        uri: url,
+      return new File({
+        url,
        mime: "text/plain",
      })
    }
  }

-  export class AgentAttachment extends Schema.Class<AgentAttachment>("Message.Agent.Attachment")({
-    name: Schema.String,
-    source: Source.pipe(Schema.optional),
+  export class UserContent extends Schema.Class<UserContent>("Message.User.Content")({
+    text: Schema.String,
+    synthetic: Schema.Boolean.pipe(Schema.optional),
+    agent: Schema.String.pipe(Schema.optional),
+    files: Schema.Array(File).pipe(Schema.optional),
  }) {}

  export class User extends Schema.Class<User>("Message.User")({
    id: ID,
    type: Schema.Literal("user"),
-    text: Schema.String,
-    files: Schema.Array(FileAttachment).pipe(Schema.optional),
-    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
    time: Schema.Struct({
      created: Schema.DateTimeUtc,
    }),
+    content: UserContent,
  }) {
-    static create(input: { text: User["text"]; files?: User["files"]; agents?: User["agents"] }) {
+    static create(content: Schema.Schema.Type<typeof UserContent>) {
      const msg = new User({
        id: ID.create(),
        type: "user",
-        ...input,
        time: {
          created: Effect.runSync(DateTime.now),
        },
+        content,
      })
      return msg
    }
+
+    static file(url: string) {
+      return new File({
+        url,
+        mime: "text/plain",
+      })
+    }
  }

-  export class Synthetic extends Schema.Class<Synthetic>("Message.Synthetic")({
-    id: ID,
-    type: Schema.Literal("synthetic"),
-    text: Schema.String,
-    time: Schema.Struct({
-      created: Schema.DateTimeUtc,
-    }),
-  }) {}
-
-  export class Request extends Schema.Class<Request>("Message.Request")({
-    id: ID,
-    type: Schema.Literal("start"),
-    model: Schema.Struct({
-      id: Schema.String,
-      providerID: Schema.String,
-      variant: Schema.String.pipe(Schema.optional),
-    }),
-    time: Schema.Struct({
-      created: Schema.DateTimeUtc,
-    }),
-  }) {}
-
-  export class Text extends Schema.Class<Text>("Message.Text")({
-    id: ID,
-    type: Schema.Literal("text"),
-    text: Schema.String,
-    time: Schema.Struct({
-      created: Schema.DateTimeUtc,
-      completed: Schema.DateTimeUtc.pipe(Schema.optional),
-    }),
-  }) {}
-
-  export class Complete extends Schema.Class<Complete>("Message.Complete")({
-    id: ID,
-    type: Schema.Literal("complete"),
-    time: Schema.Struct({
-      created: Schema.DateTimeUtc,
-    }),
-    cost: Schema.Number,
-    tokens: Schema.Struct({
-      total: Schema.Number,
-      input: Schema.Number,
-      output: Schema.Number,
-      reasoning: Schema.Number,
-      cache: Schema.Struct({
-        read: Schema.Number,
-        write: Schema.Number,
-      }),
-    }),
-  }) {}
-
-  export const Info = Schema.Union([User, Text])
-  export type Info = Schema.Schema.Type<typeof Info>
+  export namespace User {}
 }
+
+const msg = Message.User.create({
+  text: "Hello world",
+  files: [Message.File.create("file://example.com/file.txt")],
+})
+
+console.log(JSON.stringify(msg, null, 2))
@@ -1,71 +0,0 @@
-import { Context, Layer, Schema, Effect } from "effect"
-import { Message } from "./message"
-import { Struct } from "effect"
-import { Identifier } from "@/id/id"
-import { withStatics } from "@/util/schema"
-import { Session } from "@/session"
-import { SessionID } from "@/session/schema"
-
-export namespace SessionV2 {
-  export const ID = SessionID
-
-  export type ID = Schema.Schema.Type<typeof ID>
-
-  export class PromptInput extends Schema.Class<PromptInput>("Session.PromptInput")({
-    ...Struct.omit(Message.User.fields, ["time", "type"]),
-    id: Schema.optionalKey(Message.ID),
-    sessionID: SessionV2.ID,
-  }) {}
-
-  export class CreateInput extends Schema.Class<CreateInput>("Session.CreateInput")({
-    id: Schema.optionalKey(SessionV2.ID),
-  }) {}
-
-  export class Info extends Schema.Class<Info>("Session.Info")({
-    id: SessionV2.ID,
-    model: Schema.Struct({
-      id: Schema.String,
-      providerID: Schema.String,
-      modelID: Schema.String,
-    }).pipe(Schema.optional),
-  }) {}
-
-  export interface Interface {
-    fromID: (id: SessionV2.ID) => Effect.Effect<Info>
-    create: (input: CreateInput) => Effect.Effect<Info>
-    prompt: (input: PromptInput) => Effect.Effect<Message.User>
-  }
-
-  export class Service extends Context.Service<Service, Interface>()("Session.Service") {}
-
-  export const layer = Layer.effect(Service)(
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-
-      const create: Interface["create"] = Effect.fn("Session.create")(function* (input) {
-        throw new Error("Not implemented")
-      })
-
-      const prompt: Interface["prompt"] = Effect.fn("Session.prompt")(function* (input) {
-        throw new Error("Not implemented")
-      })
-
-      const fromID: Interface["fromID"] = Effect.fn("Session.fromID")(function* (id) {
-        const match = yield* session.get(id)
-        return fromV1(match)
-      })
-
-      return Service.of({
-        create,
-        prompt,
-        fromID,
-      })
-    }),
-  )
-
-  function fromV1(input: Session.Info): Info {
-    return new Info({
-      id: SessionV2.ID.make(input.id),
-    })
-  }
-}
@@ -79,55 +79,3 @@ await using tmp = await tmpdir({
 - Directories are created in the system temp folder with prefix `opencode-test-`
 - Use `await using` for automatic cleanup when the variable goes out of scope
 - Paths are sanitized to strip null bytes (defensive fix for CI environments)
-
-## Testing With Effects
-
-Use `testEffect(...)` from `test/lib/effect.ts` for tests that exercise Effect services or Effect-based workflows.
-
-### Core Pattern
-
-```typescript
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(MyService.defaultLayer))
-
-describe("my service", () => {
-  it.live("does the thing", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const svc = yield* MyService.Service
-        const out = yield* svc.run()
-        expect(out).toEqual("ok")
-      }),
-    ),
-  )
-})
-```
-
-### `it.effect` vs `it.live`
-
- Use `it.effect(...)` when the test should run with `TestClock` and `TestConsole`.
- Use `it.live(...)` when the test depends on real time, filesystem mtimes, child processes, git, locks, or other live OS behavior.
- Most integration-style tests in this package use `it.live(...)`.
-
-### Effect Fixtures
-
-Prefer the Effect-aware helpers from `fixture/fixture.ts` instead of building a manual runtime in each test.
-
- `tmpdirScoped(options?)` creates a scoped temp directory and cleans it up when the Effect scope closes.
- `provideInstance(dir)(effect)` is the low-level helper. It does not create a directory; it just runs an Effect with `Instance.current` bound to `dir`.
- `provideTmpdirInstance((dir) => effect, options?)` is the convenience helper. It creates a temp directory, binds it as the active instance, and disposes the instance on cleanup.
- `provideTmpdirServer((input) => effect, options?)` does the same, but also provides the test LLM server.
-
-Use `provideTmpdirInstance(...)` by default when a test only needs one temp instance. Use `tmpdirScoped()` plus `provideInstance(...)` when a test needs multiple directories, custom setup before binding, or needs to switch instance context within one test.
-
-### Style
-
- Define `const it = testEffect(...)` near the top of the file.
- Keep the test body inside `Effect.gen(function* () { ... })`.
- Yield services directly with `yield* MyService.Service` or `yield* MyTool`.
- Avoid custom `ManagedRuntime`, `attach(...)`, or ad hoc `run(...)` wrappers when `testEffect(...)` already provides the runtime.
- When a test needs instance-local state, prefer `provideTmpdirInstance(...)` or `provideInstance(...)` over manual `Instance.provide(...)` inside Promise-style tests.
@@ -1,422 +1,445 @@
-import { afterEach, describe, expect } from "bun:test"
-import fs from "fs/promises"
+import { describe, test, expect, afterEach } from "bun:test"
 import path from "path"
-import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import fs from "fs/promises"
 import { FileTime } from "../../src/file/time"
 import { Instance } from "../../src/project/instance"
 import { SessionID } from "../../src/session/schema"
 import { Filesystem } from "../../src/util/filesystem"
-import { provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"

 afterEach(async () => {
  await Instance.disposeAll()
 })

-const it = testEffect(Layer.mergeAll(FileTime.defaultLayer, CrossSpawnSpawner.defaultLayer))
+async function touch(file: string, time: number) {
+  const date = new Date(time)
+  await fs.utimes(file, date, date)
+}

-const id = SessionID.make("ses_00000000000000000000000001")
-
-const put = (file: string, text: string) => Effect.promise(() => fs.writeFile(file, text, "utf-8"))
-
-const touch = (file: string, time: number) =>
-  Effect.promise(() => {
-    const date = new Date(time)
-    return fs.utimes(file, date, date)
+function gate() {
+  let open!: () => void
+  const wait = new Promise<void>((resolve) => {
+    open = resolve
  })
-
-const read = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.read(id, file))
-
-const get = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.get(id, file))
-
-const check = (id: SessionID, file: string) => FileTime.Service.use((svc) => svc.assert(id, file))
-
-const lock = <A>(file: string, fn: () => Effect.Effect<A>) => FileTime.Service.use((svc) => svc.withLock(file, fn))
-
-const fail = Effect.fn("FileTimeTest.fail")(function* <A, E, R>(self: Effect.Effect<A, E, R>) {
-  const exit = yield* self.pipe(Effect.exit)
-  if (Exit.isFailure(exit)) {
-    const err = Cause.squash(exit.cause)
-    return err instanceof Error ? err : new Error(String(err))
-  }
-  throw new Error("expected file time effect to fail")
-})
+  return { open, wait }
+}

 describe("file/time", () => {
-  describe("read() and get()", () => {
-    it.live("stores read timestamp", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+  const sessionID = SessionID.make("ses_00000000000000000000000001")

-          const before = yield* get(id, file)
+  describe("read() and get()", () => {
+    test("stores read timestamp", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const before = await FileTime.get(sessionID, filepath)
          expect(before).toBeUndefined()

-          yield* read(id, file)
+          await FileTime.read(sessionID, filepath)

-          const after = yield* get(id, file)
+          const after = await FileTime.get(sessionID, filepath)
          expect(after).toBeInstanceOf(Date)
          expect(after!.getTime()).toBeGreaterThan(0)
-        }),
-      ),
-    )
+        },
+      })
+    })

-    it.live("tracks separate timestamps per session", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("tracks separate timestamps per session", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")

-          const one = SessionID.make("ses_00000000000000000000000002")
-          const two = SessionID.make("ses_00000000000000000000000003")
-          yield* read(one, file)
-          yield* read(two, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(SessionID.make("ses_00000000000000000000000002"), filepath)
+          await FileTime.read(SessionID.make("ses_00000000000000000000000003"), filepath)

-          const first = yield* get(one, file)
-          const second = yield* get(two, file)
+          const time1 = await FileTime.get(SessionID.make("ses_00000000000000000000000002"), filepath)
+          const time2 = await FileTime.get(SessionID.make("ses_00000000000000000000000003"), filepath)

-          expect(first).toBeDefined()
-          expect(second).toBeDefined()
-        }),
-      ),
-    )
+          expect(time1).toBeDefined()
+          expect(time2).toBeDefined()
+        },
+      })
+    })

-    it.live("updates timestamp on subsequent reads", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("updates timestamp on subsequent reads", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")

-          yield* read(id, file)
-          const first = yield* get(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          const first = await FileTime.get(sessionID, filepath)

-          yield* read(id, file)
-          const second = yield* get(id, file)
+          await FileTime.read(sessionID, filepath)
+          const second = await FileTime.get(sessionID, filepath)

          expect(second!.getTime()).toBeGreaterThanOrEqual(first!.getTime())
-        }),
-      ),
-    )
+        },
+      })
+    })

-    it.live("isolates reads by directory", () =>
-      Effect.gen(function* () {
-        const one = yield* tmpdirScoped()
-        const two = yield* tmpdirScoped()
-        const shared = yield* tmpdirScoped()
-        const file = path.join(shared, "file.txt")
-        yield* put(file, "content")
+    test("isolates reads by directory", async () => {
+      await using one = await tmpdir()
+      await using two = await tmpdir()
+      await using shared = await tmpdir()
+      const filepath = path.join(shared.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")

-        yield* provideInstance(one)(read(id, file))
-        const result = yield* provideInstance(two)(get(id, file))
-        expect(result).toBeUndefined()
-      }),
-    )
+      await Instance.provide({
+        directory: one.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+        },
+      })
+
+      await Instance.provide({
+        directory: two.path,
+        fn: async () => {
+          expect(await FileTime.get(sessionID, filepath)).toBeUndefined()
+        },
+      })
+    })
  })

  describe("assert()", () => {
-    it.live("passes when file has not been modified", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("passes when file has not been modified", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-          yield* read(id, file)
-          yield* check(id, file)
-        }),
-      ),
-    )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })

-    it.live("throws when file was not read first", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+    test("throws when file was not read first", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")

-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("You must read file")
-        }),
-      ),
-    )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("You must read file")
+        },
+      })
+    })

-    it.live("throws when file was modified after read", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("throws when file was modified after read", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-          yield* read(id, file)
-          yield* put(file, "modified content")
-          yield* touch(file, 2_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await fs.writeFile(filepath, "modified content", "utf-8")
+          await touch(filepath, 2_000)
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("modified since it was last read")
+        },
+      })
+    })

-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("modified since it was last read")
-        }),
-      ),
-    )
+    test("includes timestamps in error message", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-    it.live("includes timestamps in error message", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          await fs.writeFile(filepath, "modified", "utf-8")
+          await touch(filepath, 2_000)

-          yield* read(id, file)
-          yield* put(file, "modified")
-          yield* touch(file, 2_000)
-
-          const err = yield* fail(check(id, file))
-          expect(err.message).toContain("Last modification:")
-          expect(err.message).toContain("Last read:")
-        }),
-      ),
-    )
+          let error: Error | undefined
+          try {
+            await FileTime.assert(sessionID, filepath)
+          } catch (e) {
+            error = e as Error
+          }
+          expect(error).toBeDefined()
+          expect(error!.message).toContain("Last modification:")
+          expect(error!.message).toContain("Last read:")
+        },
+      })
+    })
  })

  describe("withLock()", () => {
-    it.live("executes function within lock", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          let hit = false
+    test("executes function within lock", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")

-          yield* lock(file, () =>
-            Effect.sync(() => {
-              hit = true
-              return "result"
-            }),
-          )
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          let executed = false
+          await FileTime.withLock(filepath, async () => {
+            executed = true
+            return "result"
+          })
+          expect(executed).toBe(true)
+        },
+      })
+    })

-          expect(hit).toBe(true)
-        }),
-      ),
-    )
+    test("returns function result", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")

-    it.live("returns function result", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const result = yield* lock(file, () => Effect.succeed("success"))
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const result = await FileTime.withLock(filepath, async () => {
+            return "success"
+          })
          expect(result).toBe("success")
-        }),
-      ),
-    )
+        },
+      })
+    })

-    it.live("serializes concurrent operations on same file", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
+    test("serializes concurrent operations on same file", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
          const order: number[] = []
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+          const hold = gate()
+          const ready = gate()

-          const one = yield* lock(file, () =>
-            Effect.gen(function* () {
-              order.push(1)
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              order.push(2)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op1 = FileTime.withLock(filepath, async () => {
+            order.push(1)
+            ready.open()
+            await hold.wait
+            order.push(2)
+          })

-          yield* Deferred.await(ready)
+          await ready.wait

-          const two = yield* lock(file, () =>
-            Effect.sync(() => {
-              order.push(3)
-              order.push(4)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op2 = FileTime.withLock(filepath, async () => {
+            order.push(3)
+            order.push(4)
+          })

-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(one)
-          yield* Fiber.join(two)
+          hold.open()

+          await Promise.all([op1, op2])
          expect(order).toEqual([1, 2, 3, 4])
-        }),
-      ),
-    )
+        },
+      })
+    })

-    it.live("allows concurrent operations on different files", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const onefile = path.join(dir, "file1.txt")
-          const twofile = path.join(dir, "file2.txt")
-          let one = false
-          let two = false
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+    test("allows concurrent operations on different files", async () => {
+      await using tmp = await tmpdir()
+      const filepath1 = path.join(tmp.path, "file1.txt")
+      const filepath2 = path.join(tmp.path, "file2.txt")

-          const a = yield* lock(onefile, () =>
-            Effect.gen(function* () {
-              one = true
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              expect(two).toBe(true)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          let started1 = false
+          let started2 = false
+          const hold = gate()
+          const ready = gate()
+
+          const op1 = FileTime.withLock(filepath1, async () => {
+            started1 = true
+            ready.open()
+            await hold.wait
+            expect(started2).toBe(true)
+          })
+
+          await ready.wait
+
+          const op2 = FileTime.withLock(filepath2, async () => {
+            started2 = true
+            hold.open()
+          })
+
+          await Promise.all([op1, op2])
+          expect(started1).toBe(true)
+          expect(started2).toBe(true)
+        },
+      })
+    })
+
+    test("releases lock even if function throws", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await expect(
+            FileTime.withLock(filepath, async () => {
+              throw new Error("Test error")
            }),
-          ).pipe(Effect.forkScoped)
+          ).rejects.toThrow("Test error")

-          yield* Deferred.await(ready)
-
-          const b = yield* lock(twofile, () =>
-            Effect.sync(() => {
-              two = true
-            }),
-          ).pipe(Effect.forkScoped)
-
-          yield* Fiber.join(b)
-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(a)
-
-          expect(one).toBe(true)
-          expect(two).toBe(true)
-        }),
-      ),
-    )
-
-    it.live("releases lock even if function throws", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const err = yield* fail(lock(file, () => Effect.die(new Error("Test error"))))
-          expect(err.message).toContain("Test error")
-
-          let hit = false
-          yield* lock(file, () =>
-            Effect.sync(() => {
-              hit = true
-            }),
-          )
-          expect(hit).toBe(true)
-        }),
-      ),
-    )
+          let executed = false
+          await FileTime.withLock(filepath, async () => {
+            executed = true
+          })
+          expect(executed).toBe(true)
+        },
+      })
+    })
  })

  describe("path normalization", () => {
-    it.live("read with forward slashes, assert with backslashes", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("read with forward slashes, assert with backslashes", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, forward)
-          yield* check(id, file)
-        }),
-      ),
-    )
+      const forwardSlash = filepath.replaceAll("\\", "/")

-    it.live("read with backslashes, assert with forward slashes", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, forwardSlash)
+          // assert with the native backslash path should still work
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })

-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, file)
-          yield* check(id, forward)
-        }),
-      ),
-    )
+    test("read with backslashes, assert with forward slashes", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-    it.live("get returns timestamp regardless of slash direction", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
+      const forwardSlash = filepath.replaceAll("\\", "/")

-          const forward = file.replaceAll("\\", "/")
-          yield* read(id, forward)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)
+          // assert with forward slashes should still work
+          await FileTime.assert(sessionID, forwardSlash)
+        },
+      })
+    })

-          const result = yield* get(id, file)
+    test("get returns timestamp regardless of slash direction", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+
+      const forwardSlash = filepath.replaceAll("\\", "/")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, forwardSlash)
+          const result = await FileTime.get(sessionID, filepath)
          expect(result).toBeInstanceOf(Date)
-        }),
-      ),
-    )
+        },
+      })
+    })

-    it.live("withLock serializes regardless of slash direction", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          const forward = file.replaceAll("\\", "/")
+    test("withLock serializes regardless of slash direction", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+
+      const forwardSlash = filepath.replaceAll("\\", "/")
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
          const order: number[] = []
-          const hold = yield* Deferred.make<void>()
-          const ready = yield* Deferred.make<void>()
+          const hold = gate()
+          const ready = gate()

-          const one = yield* lock(file, () =>
-            Effect.gen(function* () {
-              order.push(1)
-              yield* Deferred.succeed(ready, void 0)
-              yield* Deferred.await(hold)
-              order.push(2)
-            }),
-          ).pipe(Effect.forkScoped)
+          const op1 = FileTime.withLock(filepath, async () => {
+            order.push(1)
+            ready.open()
+            await hold.wait
+            order.push(2)
+          })

-          yield* Deferred.await(ready)
+          await ready.wait

-          const two = yield* lock(forward, () =>
-            Effect.sync(() => {
-              order.push(3)
-              order.push(4)
-            }),
-          ).pipe(Effect.forkScoped)
+          // Use forward-slash variant -- should still serialize against op1
+          const op2 = FileTime.withLock(forwardSlash, async () => {
+            order.push(3)
+            order.push(4)
+          })

-          yield* Deferred.succeed(hold, void 0)
-          yield* Fiber.join(one)
-          yield* Fiber.join(two)
+          hold.open()

+          await Promise.all([op1, op2])
          expect(order).toEqual([1, 2, 3, 4])
-        }),
-      ),
-    )
+        },
+      })
+    })
  })

  describe("stat() Filesystem.stat pattern", () => {
-    it.live("reads file modification time via Filesystem.stat()", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "content")
-          yield* touch(file, 1_000)
+    test("reads file modification time via Filesystem.stat()", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "content", "utf-8")
+      await touch(filepath, 1_000)

-          yield* read(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)

-          const stat = Filesystem.stat(file)
-          expect(stat?.mtime).toBeInstanceOf(Date)
-          expect(stat!.mtime.getTime()).toBeGreaterThan(0)
+          const stats = Filesystem.stat(filepath)
+          expect(stats?.mtime).toBeInstanceOf(Date)
+          expect(stats!.mtime.getTime()).toBeGreaterThan(0)

-          yield* check(id, file)
-        }),
-      ),
-    )
+          await FileTime.assert(sessionID, filepath)
+        },
+      })
+    })

-    it.live("detects modification via stat mtime", () =>
-      provideTmpdirInstance((dir) =>
-        Effect.gen(function* () {
-          const file = path.join(dir, "file.txt")
-          yield* put(file, "original")
-          yield* touch(file, 1_000)
+    test("detects modification via stat mtime", async () => {
+      await using tmp = await tmpdir()
+      const filepath = path.join(tmp.path, "file.txt")
+      await fs.writeFile(filepath, "original", "utf-8")
+      await touch(filepath, 1_000)

-          yield* read(id, file)
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          await FileTime.read(sessionID, filepath)

-          const first = Filesystem.stat(file)
+          const originalStat = Filesystem.stat(filepath)

-          yield* put(file, "modified")
-          yield* touch(file, 2_000)
+          await fs.writeFile(filepath, "modified", "utf-8")
+          await touch(filepath, 2_000)

-          const second = Filesystem.stat(file)
-          expect(second!.mtime.getTime()).toBeGreaterThan(first!.mtime.getTime())
+          const newStat = Filesystem.stat(filepath)
+          expect(newStat!.mtime.getTime()).toBeGreaterThan(originalStat!.mtime.getTime())

-          yield* fail(check(id, file))
-        }),
-      ),
-    )
+          await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow()
+        },
+      })
+    })
  })
 })
@@ -1,6 +1,5 @@
 import { afterEach, expect, mock, test } from "bun:test"
 import { CopilotModels } from "@/plugin/github-copilot/models"
-import { CopilotAuthPlugin } from "@/plugin/github-copilot/copilot"

 const originalFetch = globalThis.fetch

@@ -116,45 +115,3 @@ test("preserves temperature support from existing provider models", async () =>
  expect(models["gpt-4o"].capabilities.temperature).toBe(true)
  expect(models["brand-new"].capabilities.temperature).toBe(true)
 })
-
-test("remaps fallback oauth model urls to the enterprise host", async () => {
-  globalThis.fetch = mock(() => Promise.reject(new Error("timeout"))) as unknown as typeof fetch
-
-  const hooks = await CopilotAuthPlugin({
-    client: {} as never,
-    project: {} as never,
-    directory: "",
-    worktree: "",
-    serverUrl: new URL("https://example.com"),
-    $: {} as never,
-  })
-
-  const models = await hooks.provider!.models!(
-    {
-      id: "github-copilot",
-      models: {
-        claude: {
-          id: "claude",
-          providerID: "github-copilot",
-          api: {
-            id: "claude-sonnet-4.5",
-            url: "https://api.githubcopilot.com/v1",
-            npm: "@ai-sdk/anthropic",
-          },
-        },
-      },
-    } as never,
-    {
-      auth: {
-        type: "oauth",
-        refresh: "token",
-        access: "token",
-        expires: Date.now() + 60_000,
-        enterpriseUrl: "ghe.example.com",
-      } as never,
-    },
-  )
-
-  expect(models.claude.api.url).toBe("https://copilot-api.ghe.example.com")
-  expect(models.claude.api.npm).toBe("@ai-sdk/github-copilot")
-})
@@ -3,7 +3,6 @@ import { afterEach, describe, expect, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { tmpdir } from "../fixture/fixture"
-import { AppRuntime } from "../../src/effect/app-runtime"
 import { FileWatcher } from "../../src/file/watcher"
 import { Instance } from "../../src/project/instance"
 import { GlobalBus } from "../../src/bus/global"
@@ -20,7 +19,7 @@ async function withVcs(directory: string, body: () => Promise<void>) {
  return Instance.provide({
    directory,
    fn: async () => {
-      void AppRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
+      FileWatcher.init()
      Vcs.init()
      await Bun.sleep(500)
      await body()
@@ -4,17 +4,6 @@ import { Instance } from "../../src/project/instance"
 import { QuestionID } from "../../src/question/schema"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID } from "../../src/session/schema"
-import { AppRuntime } from "../../src/effect/app-runtime"
-
-const ask = (input: { sessionID: SessionID; questions: Question.Info[]; tool?: { messageID: any; callID: string } }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))
-
-const list = () => AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))
-
-const reply = (input: { requestID: QuestionID; answers: Question.Answer[] }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.reply(input)))
-
-const reject = (id: QuestionID) => AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(id)))

 afterEach(async () => {
  await Instance.disposeAll()
@@ -22,9 +11,9 @@ afterEach(async () => {

 /** Reject all pending questions so dangling Deferred fibers don't hang the test. */
 async function rejectAll() {
-  const pending = await list()
+  const pending = await Question.list()
  for (const req of pending) {
-    await reject(req.id)
+    await Question.reject(req.id)
  }
 }

@@ -33,7 +22,7 @@ test("ask - returns pending promise", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const promise = ask({
+      const promise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions: [
          {
@@ -69,16 +58,16 @@ test("ask - adds to pending list", async () => {
        },
      ]

-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions,
      })

-      const pending = await list()
+      const pending = await Question.list()
      expect(pending.length).toBe(1)
      expect(pending[0].questions).toEqual(questions)
      await rejectAll()
-      await promise.catch(() => {})
+      await askPromise.catch(() => {})
    },
  })
 })
@@ -101,20 +90,20 @@ test("reply - resolves the pending ask with answers", async () => {
        },
      ]

-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions,
      })

-      const pending = await list()
+      const pending = await Question.list()
      const requestID = pending[0].id

-      await reply({
+      await Question.reply({
        requestID,
        answers: [["Option 1"]],
      })

-      const answers = await promise
+      const answers = await askPromise
      expect(answers).toEqual([["Option 1"]])
    },
  })
@@ -125,7 +114,7 @@ test("reply - removes from pending list", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions: [
          {
@@ -139,17 +128,17 @@ test("reply - removes from pending list", async () => {
        ],
      })

-      const pending = await list()
+      const pending = await Question.list()
      expect(pending.length).toBe(1)

-      await reply({
+      await Question.reply({
        requestID: pending[0].id,
        answers: [["Option 1"]],
      })
-      await promise
+      await askPromise

-      const after = await list()
-      expect(after.length).toBe(0)
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.length).toBe(0)
    },
  })
 })
@@ -159,7 +148,7 @@ test("reply - does nothing for unknown requestID", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      await reply({
+      await Question.reply({
        requestID: QuestionID.make("que_unknown"),
        answers: [["Option 1"]],
      })
@@ -175,7 +164,7 @@ test("reject - throws RejectedError", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions: [
          {
@@ -189,10 +178,10 @@ test("reject - throws RejectedError", async () => {
        ],
      })

-      const pending = await list()
-      await reject(pending[0].id)
+      const pending = await Question.list()
+      await Question.reject(pending[0].id)

-      await expect(promise).rejects.toBeInstanceOf(Question.RejectedError)
+      await expect(askPromise).rejects.toBeInstanceOf(Question.RejectedError)
    },
  })
 })
@@ -202,7 +191,7 @@ test("reject - removes from pending list", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions: [
          {
@@ -216,14 +205,14 @@ test("reject - removes from pending list", async () => {
        ],
      })

-      const pending = await list()
+      const pending = await Question.list()
      expect(pending.length).toBe(1)

-      await reject(pending[0].id)
-      promise.catch(() => {}) // Ignore rejection
+      await Question.reject(pending[0].id)
+      askPromise.catch(() => {}) // Ignore rejection

-      const after = await list()
-      expect(after.length).toBe(0)
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.length).toBe(0)
    },
  })
 })
@@ -233,7 +222,7 @@ test("reject - does nothing for unknown requestID", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      await reject(QuestionID.make("que_unknown"))
+      await Question.reject(QuestionID.make("que_unknown"))
      // Should not throw
    },
  })
@@ -265,19 +254,19 @@ test("ask - handles multiple questions", async () => {
        },
      ]

-      const promise = ask({
+      const askPromise = Question.ask({
        sessionID: SessionID.make("ses_test"),
        questions,
      })

-      const pending = await list()
+      const pending = await Question.list()

-      await reply({
+      await Question.reply({
        requestID: pending[0].id,
        answers: [["Build"], ["Dev"]],
      })

-      const answers = await promise
+      const answers = await askPromise
      expect(answers).toEqual([["Build"], ["Dev"]])
    },
  })
@@ -290,7 +279,7 @@ test("list - returns all pending requests", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const p1 = ask({
+      const p1 = Question.ask({
        sessionID: SessionID.make("ses_test1"),
        questions: [
          {
@@ -301,7 +290,7 @@ test("list - returns all pending requests", async () => {
        ],
      })

-      const p2 = ask({
+      const p2 = Question.ask({
        sessionID: SessionID.make("ses_test2"),
        questions: [
          {
@@ -312,7 +301,7 @@ test("list - returns all pending requests", async () => {
        ],
      })

-      const pending = await list()
+      const pending = await Question.list()
      expect(pending.length).toBe(2)
      await rejectAll()
      p1.catch(() => {})
@@ -326,7 +315,7 @@ test("list - returns empty when no pending", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const pending = await list()
+      const pending = await Question.list()
      expect(pending.length).toBe(0)
    },
  })
@@ -339,7 +328,7 @@ test("questions stay isolated by directory", async () => {
  const p1 = Instance.provide({
    directory: one.path,
    fn: () =>
-      ask({
+      Question.ask({
        sessionID: SessionID.make("ses_one"),
        questions: [
          {
@@ -354,7 +343,7 @@ test("questions stay isolated by directory", async () => {
  const p2 = Instance.provide({
    directory: two.path,
    fn: () =>
-      ask({
+      Question.ask({
        sessionID: SessionID.make("ses_two"),
        questions: [
          {
@@ -368,11 +357,11 @@ test("questions stay isolated by directory", async () => {

  const onePending = await Instance.provide({
    directory: one.path,
-    fn: () => list(),
+    fn: () => Question.list(),
  })
  const twoPending = await Instance.provide({
    directory: two.path,
-    fn: () => list(),
+    fn: () => Question.list(),
  })

  expect(onePending.length).toBe(1)
@@ -382,11 +371,11 @@ test("questions stay isolated by directory", async () => {

  await Instance.provide({
    directory: one.path,
-    fn: () => reject(onePending[0].id),
+    fn: () => Question.reject(onePending[0].id),
  })
  await Instance.provide({
    directory: two.path,
-    fn: () => reject(twoPending[0].id),
+    fn: () => Question.reject(twoPending[0].id),
  })

  await p1.catch(() => {})
@@ -396,10 +385,10 @@ test("questions stay isolated by directory", async () => {
 test("pending question rejects on instance dispose", async () => {
  await using tmp = await tmpdir({ git: true })

-  const pending = Instance.provide({
+  const ask = Instance.provide({
    directory: tmp.path,
    fn: () => {
-      return ask({
+      return Question.ask({
        sessionID: SessionID.make("ses_dispose"),
        questions: [
          {
@@ -411,7 +400,7 @@ test("pending question rejects on instance dispose", async () => {
      })
    },
  })
-  const result = pending.then(
+  const result = ask.then(
    () => "resolved" as const,
    (err) => err,
  )
@@ -419,8 +408,8 @@ test("pending question rejects on instance dispose", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
      await Instance.dispose()
    },
  })
@@ -431,10 +420,10 @@ test("pending question rejects on instance dispose", async () => {
 test("pending question rejects on instance reload", async () => {
  await using tmp = await tmpdir({ git: true })

-  const pending = Instance.provide({
+  const ask = Instance.provide({
    directory: tmp.path,
    fn: () => {
-      return ask({
+      return Question.ask({
        sessionID: SessionID.make("ses_reload"),
        questions: [
          {
@@ -446,7 +435,7 @@ test("pending question rejects on instance reload", async () => {
      })
    },
  })
-  const result = pending.then(
+  const result = ask.then(
    () => "resolved" as const,
    (err) => err,
  )
@@ -454,8 +443,8 @@ test("pending question rejects on instance reload", async () => {
  await Instance.provide({
    directory: tmp.path,
    fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
      await Instance.reload({ directory: tmp.path })
    },
  })
@@ -1,9 +1,11 @@
 import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
-import { Effect } from "effect"
 import { Instance } from "../../src/project/instance"
 import { Server } from "../../src/server/server"
 import { Session } from "../../src/session"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 import { SessionPrompt } from "../../src/session/prompt"
+import { SessionRunState } from "../../src/session/run-state"
 import { Log } from "../../src/util/log"
 import { tmpdir } from "../fixture/fixture"

@@ -14,6 +16,25 @@ afterEach(async () => {
  await Instance.disposeAll()
 })

+async function user(sessionID: SessionID, text: string) {
+  const msg = await Session.updateMessage({
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID,
+    agent: "build",
+    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
+    time: { created: Date.now() },
+  })
+  await Session.updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: msg.id,
+    type: "text",
+    text,
+  })
+  return msg
+}
+
 describe("session action routes", () => {
  test("abort route calls SessionPrompt.cancel", async () => {
    await using tmp = await tmpdir({ git: true })
@@ -24,7 +45,9 @@ describe("session action routes", () => {
        const cancel = spyOn(SessionPrompt, "cancel").mockResolvedValue()
        const app = Server.Default().app

-        const res = await app.request(`/session/${session.id}/abort`, { method: "POST" })
+        const res = await app.request(`/session/${session.id}/abort`, {
+          method: "POST",
+        })

        expect(res.status).toBe(200)
        expect(await res.json()).toBe(true)
@@ -34,4 +57,28 @@ describe("session action routes", () => {
      },
    })
  })
+
+  test("delete message route returns 400 when session is busy", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        const msg = await user(session.id, "hello")
+        const busy = spyOn(SessionRunState, "assertNotBusy").mockRejectedValue(new Session.BusyError(session.id))
+        const remove = spyOn(Session, "removeMessage").mockResolvedValue(msg.id)
+        const app = Server.Default().app
+
+        const res = await app.request(`/session/${session.id}/message/${msg.id}`, {
+          method: "DELETE",
+        })
+
+        expect(res.status).toBe(400)
+        expect(busy).toHaveBeenCalledWith(session.id)
+        expect(remove).not.toHaveBeenCalled()
+
+        await Session.remove(session.id)
+      },
+    })
+  })
 })
@@ -1005,15 +1005,6 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
      },
    })

@@ -1032,15 +1023,7 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: 800,
-          cacheReadTokens: 200,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
+        cachedInputTokens: 200,
      },
    })

@@ -1056,15 +1039,6 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
      },
      metadata: {
        anthropic: {
@@ -1085,15 +1059,7 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: 800,
-          cacheReadTokens: 200,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
+        cachedInputTokens: 200,
      },
      metadata: {
        anthropic: {},
@@ -1112,15 +1078,7 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: 400,
-          reasoningTokens: 100,
-        },
+        reasoningTokens: 100,
      },
    })

@@ -1146,15 +1104,7 @@ describe("session.getUsage", () => {
        inputTokens: 0,
        outputTokens: 1_000_000,
        totalTokens: 1_000_000,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: 750_000,
-          reasoningTokens: 250_000,
-        },
+        reasoningTokens: 250_000,
      },
    })

@@ -1171,15 +1121,6 @@ describe("session.getUsage", () => {
        inputTokens: 0,
        outputTokens: 0,
        totalTokens: 0,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
      },
    })

@@ -1207,15 +1148,6 @@ describe("session.getUsage", () => {
        inputTokens: 1_000_000,
        outputTokens: 100_000,
        totalTokens: 1_100_000,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
      },
    })

@@ -1231,15 +1163,7 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: 800,
-          cacheReadTokens: 200,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
+        cachedInputTokens: 200,
      }
      if (npm === "@ai-sdk/amazon-bedrock") {
        const result = Session.getUsage({
@@ -1290,15 +1214,7 @@ describe("session.getUsage", () => {
        inputTokens: 1000,
        outputTokens: 500,
        totalTokens: 1500,
-        inputTokenDetails: {
-          noCacheTokens: 800,
-          cacheReadTokens: 200,
-          cacheWriteTokens: undefined,
-        },
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
+        cachedInputTokens: 200,
      },
      metadata: {
        vertex: {
@@ -1,6 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import path from "path"
-import { Effect } from "effect"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { Instruction } from "../../src/session/instruction"
 import type { MessageV2 } from "../../src/session/message-v2"
@@ -9,9 +8,6 @@ import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { Global } from "../../src/global"
 import { tmpdir } from "../fixture/fixture"

-const run = <A>(effect: Effect.Effect<A, any, Instruction.Service>) =>
-  Effect.runPromise(effect.pipe(Effect.provide(Instruction.defaultLayer)))
-
 function loaded(filepath: string): MessageV2.WithParts[] {
  const sessionID = SessionID.make("session-loaded-1")
  const messageID = MessageID.make("message-loaded-1")
@@ -61,22 +57,17 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)

-              const results = yield* svc.resolve(
-                [],
-                path.join(tmp.path, "src", "file.ts"),
-                MessageID.make("message-test-1"),
-              )
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve(
+          [],
+          path.join(tmp.path, "src", "file.ts"),
+          MessageID.make("message-test-1"),
+        )
+        expect(results).toEqual([])
+      },
    })
  })

@@ -89,23 +80,18 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
+      fn: async () => {
+        const system = await Instruction.systemPaths()
+        expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)

-              const results = yield* svc.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"))
-            }),
-          ),
-        ),
+        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"))
+      },
    })
  })

@@ -118,19 +104,14 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
-              const system = yield* svc.systemPaths()
-              expect(system.has(filepath)).toBe(false)
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
+        const system = await Instruction.systemPaths()
+        expect(system.has(filepath)).toBe(false)

-              const results = yield* svc.resolve([], filepath, MessageID.make("message-test-3"))
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve([], filepath, MessageID.make("message-test-3"))
+        expect(results).toEqual([])
+      },
    })
  })

@@ -143,22 +124,17 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-1")
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-1")

-              const first = yield* svc.resolve([], filepath, id)
-              const second = yield* svc.resolve([], filepath, id)
+        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([])
-            }),
-          ),
-        ),
+        expect(first).toHaveLength(1)
+        expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+        expect(second).toEqual([])
+      },
    })
  })

@@ -171,23 +147,18 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-2")
+      fn: async () => {
+        const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+        const id = MessageID.make("message-claim-2")

-              const first = yield* svc.resolve([], filepath, id)
-              yield* svc.clear(id)
-              const second = yield* svc.resolve([], filepath, id)
+        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"))
-            }),
-          ),
-        ),
+        expect(first).toHaveLength(1)
+        expect(second).toHaveLength(1)
+        expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+      },
    })
  })

@@ -200,19 +171,15 @@ describe("Instruction.resolve", () => {
    })
    await Instance.provide({
      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              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")
+      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 = yield* svc.resolve(loaded(agents), filepath, id)
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
+        const results = await Instruction.resolve(loaded(agents), filepath, id)
+
+        expect(results).toEqual([])
+      },
    })
  })

@@ -254,16 +221,11 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
    try {
      await Instance.provide({
        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
-              }),
-            ),
-          ),
+        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
@@ -286,16 +248,11 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
    try {
      await Instance.provide({
        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
+        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
@@ -317,15 +274,10 @@ describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
    try {
      await Instance.provide({
        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
+        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
@@ -511,49 +511,6 @@ test("circular symlinks", async () => {
  })
 })

-test("source project gitignore is respected - ignored files are not snapshotted", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      // Create gitignore BEFORE any tracking
-      await Filesystem.write(`${dir}/.gitignore`, "*.ignored\nbuild/\nnode_modules/\n")
-      await Filesystem.write(`${dir}/tracked.txt`, "tracked content")
-      await Filesystem.write(`${dir}/ignored.ignored`, "ignored content")
-      await $`mkdir -p ${dir}/build`.quiet()
-      await Filesystem.write(`${dir}/build/output.js`, "build output")
-      await Filesystem.write(`${dir}/normal.js`, "normal js")
-      await $`git add .`.cwd(dir).quiet()
-      await $`git commit -m init`.cwd(dir).quiet()
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Modify tracked files and create new ones - some ignored, some not
-      await Filesystem.write(`${tmp.path}/tracked.txt`, "modified tracked")
-      await Filesystem.write(`${tmp.path}/new.ignored`, "new ignored")
-      await Filesystem.write(`${tmp.path}/new-tracked.txt`, "new tracked")
-      await Filesystem.write(`${tmp.path}/build/new-build.js`, "new build file")
-
-      const patch = await Snapshot.patch(before!)
-
-      // Modified and new tracked files should be in snapshot
-      expect(patch.files).toContain(fwd(tmp.path, "new-tracked.txt"))
-      expect(patch.files).toContain(fwd(tmp.path, "tracked.txt"))
-
-      // Ignored files should NOT be in snapshot
-      expect(patch.files).not.toContain(fwd(tmp.path, "new.ignored"))
-      expect(patch.files).not.toContain(fwd(tmp.path, "ignored.ignored"))
-      expect(patch.files).not.toContain(fwd(tmp.path, "build/output.js"))
-      expect(patch.files).not.toContain(fwd(tmp.path, "build/new-build.js"))
-    },
-  })
-})
-
 test("gitignore changes", async () => {
  await using tmp = await bootstrap()
  await Instance.provide({
@@ -578,75 +535,6 @@ test("gitignore changes", async () => {
  })
 })

-test("files tracked in snapshot but now gitignored are filtered out", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      // First, create a file and snapshot it
-      await Filesystem.write(`${tmp.path}/later-ignored.txt`, "initial content")
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Modify the file (so it appears in diff-files)
-      await Filesystem.write(`${tmp.path}/later-ignored.txt`, "modified content")
-
-      // Now add gitignore that would exclude this file
-      await Filesystem.write(`${tmp.path}/.gitignore`, "later-ignored.txt\n")
-
-      // Also create another tracked file
-      await Filesystem.write(`${tmp.path}/still-tracked.txt`, "new tracked file")
-
-      const patch = await Snapshot.patch(before!)
-
-      // The file that is now gitignored should NOT appear, even though it was
-      // previously tracked and modified
-      expect(patch.files).not.toContain(fwd(tmp.path, "later-ignored.txt"))
-
-      // The gitignore file itself should appear
-      expect(patch.files).toContain(fwd(tmp.path, ".gitignore"))
-
-      // Other tracked files should appear
-      expect(patch.files).toContain(fwd(tmp.path, "still-tracked.txt"))
-    },
-  })
-})
-
-test("gitignore updated between track calls filters from diff", async () => {
-  await using tmp = await bootstrap()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      // a.txt is already committed from bootstrap - track it in snapshot
-      const before = await Snapshot.track()
-      expect(before).toBeTruthy()
-
-      // Modify a.txt (so it appears in diff-files)
-      await Filesystem.write(`${tmp.path}/a.txt`, "modified content")
-
-      // Now add gitignore that would exclude a.txt
-      await Filesystem.write(`${tmp.path}/.gitignore`, "a.txt\n")
-
-      // Also modify b.txt which is not gitignored
-      await Filesystem.write(`${tmp.path}/b.txt`, "also modified")
-
-      // Second track - should not include a.txt even though it changed
-      const after = await Snapshot.track()
-      expect(after).toBeTruthy()
-
-      // Verify a.txt is NOT in the diff between snapshots
-      const diffs = await Snapshot.diffFull(before!, after!)
-      expect(diffs.some((x) => x.file === "a.txt")).toBe(false)
-
-      // But .gitignore should be in the diff
-      expect(diffs.some((x) => x.file === ".gitignore")).toBe(true)
-
-      // b.txt should be in the diff (not gitignored)
-      expect(diffs.some((x) => x.file === "b.txt")).toBe(true)
-    },
-  })
-})
-
 test("git info exclude changes", async () => {
  await using tmp = await bootstrap()
  await Instance.provide({
@@ -7,21 +7,12 @@ import { Instance } from "../../src/project/instance"
 import { LSP } from "../../src/lsp"
 import { AppFileSystem } from "../../src/filesystem"
 import { Format } from "../../src/format"
-import { Agent } from "../../src/agent/agent"
 import { Bus } from "../../src/bus"
-import { Truncate } from "../../src/tool/truncate"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"

 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    LSP.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Format.defaultLayer,
-    Bus.layer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(LSP.defaultLayer, AppFileSystem.defaultLayer, Format.defaultLayer, Bus.layer),
 )

 const baseCtx = {
@@ -8,7 +8,6 @@ import { Instance } from "../../src/project/instance"
 import { Filesystem } from "../../src/util/filesystem"
 import { tmpdir } from "../fixture/fixture"
 import type { Permission } from "../../src/permission"
-import { Agent } from "../../src/agent/agent"
 import { Truncate } from "../../src/tool/truncate"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
@@ -16,13 +15,7 @@ import { AppFileSystem } from "../../src/filesystem"
 import { Plugin } from "../../src/plugin"

 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    CrossSpawnSpawner.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Plugin.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(CrossSpawnSpawner.defaultLayer, AppFileSystem.defaultLayer, Plugin.defaultLayer),
 )

 function initBash() {
@@ -9,10 +9,8 @@ import { FileTime } from "../../src/file/time"
 import { LSP } from "../../src/lsp"
 import { AppFileSystem } from "../../src/filesystem"
 import { Format } from "../../src/format"
-import { Agent } from "../../src/agent/agent"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
-import { Truncate } from "../../src/tool/truncate"
 import { SessionID, MessageID } from "../../src/session/schema"

 const ctx = {
@@ -35,16 +33,23 @@ async function touch(file: string, time: number) {
  await fs.utimes(file, date, date)
 }

+async function wait(check: () => void, timeout = 1_000) {
+  const end = Date.now() + timeout
+  let err: unknown
+  while (Date.now() < end) {
+    try {
+      check()
+      return
+    } catch (cause) {
+      err = cause
+      await Bun.sleep(10)
+    }
+  }
+  throw err
+}
+
 const runtime = ManagedRuntime.make(
-  Layer.mergeAll(
-    LSP.defaultLayer,
-    FileTime.defaultLayer,
-    AppFileSystem.defaultLayer,
-    Format.defaultLayer,
-    Bus.layer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
-  ),
+  Layer.mergeAll(LSP.defaultLayer, FileTime.defaultLayer, AppFileSystem.defaultLayer, Format.defaultLayer, Bus.layer),
 )

 afterAll(async () => {
@@ -143,7 +148,7 @@ describe("tool.edit", () => {
            ),
          )

-          expect(events).toContain("updated")
+          await wait(() => expect(events).toContain("updated"))
          unsubUpdated()
        },
      })
@@ -374,7 +379,7 @@ describe("tool.edit", () => {
            ),
          )

-          expect(events).toContain("updated")
+          await wait(() => expect(events).toContain("updated"))
          unsubUpdated()
        },
      })
@@ -6,12 +6,8 @@ import { Instance } from "../../src/project/instance"
 import { tmpdir } from "../fixture/fixture"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Truncate } from "../../src/tool/truncate"
-import { Agent } from "../../src/agent/agent"

-const runtime = ManagedRuntime.make(
-  Layer.mergeAll(CrossSpawnSpawner.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-)
+const runtime = ManagedRuntime.make(Layer.mergeAll(CrossSpawnSpawner.defaultLayer))

 function initGrep() {
  return runtime.runPromise(GrepTool.pipe(Effect.flatMap((info) => info.init())))
@@ -4,9 +4,7 @@ import { Tool } from "../../src/tool/tool"
 import { QuestionTool } from "../../src/tool/question"
 import { Question } from "../../src/question"
 import { SessionID, MessageID } from "../../src/session/schema"
-import { Agent } from "../../src/agent/agent"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Truncate } from "../../src/tool/truncate"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"

@@ -21,9 +19,7 @@ const ctx = {
  ask: () => Effect.void,
 }

-const it = testEffect(
-  Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-)
+const it = testEffect(Layer.mergeAll(Question.defaultLayer, CrossSpawnSpawner.defaultLayer))

 const pending = Effect.fn("QuestionToolTest.pending")(function* (question: Question.Interface) {
  for (;;) {
@@ -11,7 +11,6 @@ import { Instance } from "../../src/project/instance"
 import { SessionID, MessageID } from "../../src/session/schema"
 import { Instruction } from "../../src/session/instruction"
 import { ReadTool } from "../../src/tool/read"
-import { Truncate } from "../../src/tool/truncate"
 import { Tool } from "../../src/tool/tool"
 import { Filesystem } from "../../src/util/filesystem"
 import { provideInstance, tmpdirScoped } from "../fixture/fixture"
@@ -42,7 +41,6 @@ const it = testEffect(
    FileTime.defaultLayer,
    Instruction.defaultLayer,
    LSP.defaultLayer,
-    Truncate.defaultLayer,
  ),
 )

@@ -1,8 +1,6 @@
 import { Effect, Layer, ManagedRuntime } from "effect"
-import { Agent } from "../../src/agent/agent"
 import { Skill } from "../../src/skill"
 import { Ripgrep } from "../../src/file/ripgrep"
-import { Truncate } from "../../src/tool/truncate"
 import { afterEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { pathToFileURL } from "url"
@@ -152,9 +150,7 @@ Use this skill.
      await Instance.provide({
        directory: tmp.path,
        fn: async () => {
-          const runtime = ManagedRuntime.make(
-            Layer.mergeAll(Skill.defaultLayer, Ripgrep.defaultLayer, Truncate.defaultLayer, Agent.defaultLayer),
-          )
+          const runtime = ManagedRuntime.make(Layer.mergeAll(Skill.defaultLayer, Ripgrep.defaultLayer))
          const info = await runtime.runPromise(SkillTool)
          const tool = await runtime.runPromise(info.init())
          const requests: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
@@ -10,7 +10,6 @@ import type { SessionPrompt } from "../../src/session/prompt"
 import { MessageID, PartID } from "../../src/session/schema"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { TaskTool, type TaskPromptOps } from "../../src/tool/task"
-import { Truncate } from "../../src/tool/truncate"
 import { ToolRegistry } from "../../src/tool/registry"
 import { provideTmpdirInstance } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
@@ -30,7 +29,6 @@ const it = testEffect(
    Config.defaultLayer,
    CrossSpawnSpawner.defaultLayer,
    Session.defaultLayer,
-    Truncate.defaultLayer,
    ToolRegistry.defaultLayer,
  ),
 )
@@ -1,11 +1,7 @@
 import { describe, test, expect } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
+import { Effect } from "effect"
 import z from "zod"
-import { Agent } from "../../src/agent/agent"
 import { Tool } from "../../src/tool/tool"
-import { Truncate } from "../../src/tool/truncate"
-
-const runtime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))

 const params = z.object({ input: z.string() })

@@ -25,7 +21,7 @@ describe("Tool.define", () => {
    const original = makeTool("test")
    const originalExecute = original.execute

-    const info = await runtime.runPromise(Tool.define("test-tool", Effect.succeed(original)))
+    const info = await Effect.runPromise(Tool.define("test-tool", Effect.succeed(original)))

    await Effect.runPromise(info.init())
    await Effect.runPromise(info.init())
@@ -35,7 +31,7 @@ describe("Tool.define", () => {
  })

  test("effect-defined tool returns fresh objects and is unaffected", async () => {
-    const info = await runtime.runPromise(
+    const info = await Effect.runPromise(
      Tool.define(
        "test-fn-tool",
        Effect.succeed(() => Effect.succeed(makeTool("test"))),
@@ -49,7 +45,7 @@ describe("Tool.define", () => {
  })

  test("object-defined tool returns distinct objects per init() call", async () => {
-    const info = await runtime.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))
+    const info = await Effect.runPromise(Tool.define("test-copy", Effect.succeed(makeTool("test"))))

    const first = await Effect.runPromise(info.init())
    const second = await Effect.runPromise(info.init())
@@ -1,7 +1,7 @@
 import { describe, test, expect } from "bun:test"
 import { NodeFileSystem } from "@effect/platform-node"
 import { Effect, FileSystem, Layer } from "effect"
-import { Truncate } from "../../src/tool/truncate"
+import { Truncate, Truncate as TruncateSvc } from "../../src/tool/truncate"
 import { Identifier } from "../../src/id/id"
 import { Process } from "../../src/util/process"
 import { Filesystem } from "../../src/util/filesystem"
@@ -12,155 +12,120 @@ import { writeFileStringScoped } from "../lib/filesystem"
 const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
 const ROOT = path.resolve(import.meta.dir, "..", "..")

-const it = testEffect(Layer.mergeAll(Truncate.defaultLayer, NodeFileSystem.layer))
-
 describe("Truncate", () => {
  describe("output", () => {
-    it.live("truncates large json file by bytes", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
+    test("truncates large json file by bytes", async () => {
+      const content = await Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
+      const result = await Truncate.output(content)

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-        if (result.truncated) expect(result.outputPath).toBeDefined()
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("truncated...")
+      if (result.truncated) expect(result.outputPath).toBeDefined()
+    })

-    it.live("returns content unchanged when under limits", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "line1\nline2\nline3"
-        const result = yield* svc.output(content)
+    test("returns content unchanged when under limits", async () => {
+      const content = "line1\nline2\nline3"
+      const result = await Truncate.output(content)

-        expect(result.truncated).toBe(false)
-        expect(result.content).toBe(content)
-      }),
-    )
+      expect(result.truncated).toBe(false)
+      expect(result.content).toBe(content)
+    })

-    it.live("truncates by line count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
+    test("truncates by line count", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 10 })

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("...90 lines truncated...")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("...90 lines truncated...")
+    })

-    it.live("truncates by byte count", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "a".repeat(1000)
-        const result = yield* svc.output(content, { maxBytes: 100 })
+    test("truncates by byte count", async () => {
+      const content = "a".repeat(1000)
+      const result = await Truncate.output(content, { maxBytes: 100 })

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("truncated...")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("truncated...")
+    })

-    it.live("truncates from head by default", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3 })
+    test("truncates from head by default", async () => {
+      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 3 })

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line0")
-        expect(result.content).toContain("line1")
-        expect(result.content).toContain("line2")
-        expect(result.content).not.toContain("line9")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("line0")
+      expect(result.content).toContain("line1")
+      expect(result.content).toContain("line2")
+      expect(result.content).not.toContain("line9")
+    })

-    it.live("truncates from tail when direction is tail", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 3, direction: "tail" })
+    test("truncates from tail when direction is tail", async () => {
+      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 3, direction: "tail" })

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("line7")
-        expect(result.content).toContain("line8")
-        expect(result.content).toContain("line9")
-        expect(result.content).not.toContain("line0")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("line7")
+      expect(result.content).toContain("line8")
+      expect(result.content).toContain("line9")
+      expect(result.content).not.toContain("line0")
+    })

    test("uses default MAX_LINES and MAX_BYTES", () => {
      expect(Truncate.MAX_LINES).toBe(2000)
      expect(Truncate.MAX_BYTES).toBe(50 * 1024)
    })

-    it.live("large single-line file truncates with byte message", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = yield* Effect.promise(() => Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json")))
-        const result = yield* svc.output(content)
+    test("large single-line file truncates with byte message", async () => {
+      const content = await Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
+      const result = await Truncate.output(content)

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("bytes truncated...")
-        expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("bytes truncated...")
+      expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
+    })

-    it.live("writes full output to file when truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const result = yield* svc.output(lines, { maxLines: 10 })
+    test("writes full output to file when truncated", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const result = await Truncate.output(lines, { maxLines: 10 })

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("The tool call succeeded but the output was truncated")
-        expect(result.content).toContain("Grep")
-        if (!result.truncated) throw new Error("expected truncated")
-        expect(result.outputPath).toBeDefined()
-        expect(result.outputPath).toContain("tool_")
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("The tool call succeeded but the output was truncated")
+      expect(result.content).toContain("Grep")
+      if (!result.truncated) throw new Error("expected truncated")
+      expect(result.outputPath).toBeDefined()
+      expect(result.outputPath).toContain("tool_")

-        const written = yield* Effect.promise(() => Filesystem.readText(result.outputPath!))
-        expect(written).toBe(lines)
-      }),
-    )
+      const written = await Filesystem.readText(result.outputPath!)
+      expect(written).toBe(lines)
+    })

-    it.live("suggests Task tool when agent has task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+    test("suggests Task tool when agent has task permission", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
+      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).toContain("Task tool")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("Grep")
+      expect(result.content).toContain("Task tool")
+    })

-    it.live("omits Task tool hint when agent lacks task permission", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-        const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
-        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+    test("omits Task tool hint when agent lacks task permission", async () => {
+      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+      const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
+      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)

-        expect(result.truncated).toBe(true)
-        expect(result.content).toContain("Grep")
-        expect(result.content).not.toContain("Task tool")
-      }),
-    )
+      expect(result.truncated).toBe(true)
+      expect(result.content).toContain("Grep")
+      expect(result.content).not.toContain("Task tool")
+    })

-    it.live("does not write file when not truncated", () =>
-      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
-        const content = "short content"
-        const result = yield* svc.output(content)
+    test("does not write file when not truncated", async () => {
+      const content = "short content"
+      const result = await Truncate.output(content)

-        expect(result.truncated).toBe(false)
-        if (result.truncated) throw new Error("expected not truncated")
-        expect("outputPath" in result).toBe(false)
-      }),
-    )
+      expect(result.truncated).toBe(false)
+      if (result.truncated) throw new Error("expected not truncated")
+      expect("outputPath" in result).toBe(false)
+    })

    test("loads truncate effect in a fresh process", async () => {
      const out = await Process.run([process.execPath, "run", path.join(ROOT, "src", "tool", "truncate.ts")], {
@@ -173,10 +138,10 @@ describe("Truncate", () => {

  describe("cleanup", () => {
    const DAY_MS = 24 * 60 * 60 * 1000
+    const it = testEffect(Layer.mergeAll(TruncateSvc.defaultLayer, NodeFileSystem.layer))

    it.live("deletes files older than 7 days and preserves recent files", () =>
      Effect.gen(function* () {
-        const svc = yield* Truncate.Service
        const fs = yield* FileSystem.FileSystem

        yield* fs.makeDirectory(Truncate.DIR, { recursive: true })
@@ -186,7 +151,7 @@ describe("Truncate", () => {

        yield* writeFileStringScoped(old, "old content")
        yield* writeFileStringScoped(recent, "recent content")
-        yield* svc.cleanup()
+        yield* TruncateSvc.Service.use((s) => s.cleanup())

        expect(yield* fs.exists(old)).toBe(false)
        expect(yield* fs.exists(recent)).toBe(true)
@@ -1,9 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import path from "path"
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
 import { FetchHttpClient } from "effect/unstable/http"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "../../src/tool/truncate"
 import { Instance } from "../../src/project/instance"
 import { WebFetchTool } from "../../src/tool/webfetch"
 import { SessionID, MessageID } from "../../src/session/schema"
@@ -26,11 +24,10 @@ async function withFetch(fetch: (req: Request) => Response | Promise<Response>,
  await fn(server.url)
 }

-function exec(args: { url: string; format: "text" | "markdown" | "html" }) {
+function initTool() {
  return WebFetchTool.pipe(
    Effect.flatMap((info) => info.init()),
-    Effect.flatMap((tool) => tool.execute(args, ctx)),
-    Effect.provide(Layer.mergeAll(FetchHttpClient.layer, Truncate.defaultLayer, Agent.defaultLayer)),
+    Effect.provide(FetchHttpClient.layer),
    Effect.runPromise,
  )
 }
@@ -44,7 +41,10 @@ describe("tool.webfetch", () => {
        await Instance.provide({
          directory: projectRoot,
          fn: async () => {
-            const result = await exec({ url: new URL("/image.png", url).toString(), format: "markdown" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/image.png", url).toString(), format: "markdown" }, ctx),
+            )
            expect(result.output).toBe("Image fetched successfully")
            expect(result.attachments).toBeDefined()
            expect(result.attachments?.length).toBe(1)
@@ -72,7 +72,10 @@ describe("tool.webfetch", () => {
        await Instance.provide({
          directory: projectRoot,
          fn: async () => {
-            const result = await exec({ url: new URL("/image.svg", url).toString(), format: "html" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/image.svg", url).toString(), format: "html" }, ctx),
+            )
            expect(result.output).toContain("<svg")
            expect(result.attachments).toBeUndefined()
          },
@@ -92,7 +95,10 @@ describe("tool.webfetch", () => {
        await Instance.provide({
          directory: projectRoot,
          fn: async () => {
-            const result = await exec({ url: new URL("/file.txt", url).toString(), format: "text" })
+            const webfetch = await initTool()
+            const result = await Effect.runPromise(
+              webfetch.execute({ url: new URL("/file.txt", url).toString(), format: "text" }, ctx),
+            )
            expect(result.output).toBe("hello from webfetch")
            expect(result.attachments).toBeUndefined()
          },
@@ -9,9 +9,7 @@ import { AppFileSystem } from "../../src/filesystem"
 import { FileTime } from "../../src/file/time"
 import { Bus } from "../../src/bus"
 import { Format } from "../../src/format"
-import { Truncate } from "../../src/tool/truncate"
 import { Tool } from "../../src/tool/tool"
-import { Agent } from "../../src/agent/agent"
 import { SessionID, MessageID } from "../../src/session/schema"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { provideTmpdirInstance } from "../fixture/fixture"
@@ -40,8 +38,6 @@ const it = testEffect(
    Bus.layer,
    Format.defaultLayer,
    CrossSpawnSpawner.defaultLayer,
-    Truncate.defaultLayer,
-    Agent.defaultLayer,
  ),
 )

@@ -1,44 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Global } from "../../src/global"
-import { Log } from "../../src/util/log"
-import { tmpdir } from "../fixture/fixture"
-
-const log = Global.Path.log
-
-afterEach(() => {
-  Global.Path.log = log
-})
-
-async function files(dir: string) {
-  let last = ""
-  let same = 0
-
-  for (let i = 0; i < 50; i++) {
-    const list = (await fs.readdir(dir)).sort()
-    const next = JSON.stringify(list)
-    same = next === last ? same + 1 : 0
-    if (same >= 2 && list.length === 11) return list
-    last = next
-    await Bun.sleep(10)
-  }
-
-  return (await fs.readdir(dir)).sort()
-}
-
-test("init cleanup keeps the newest timestamped logs", async () => {
-  await using tmp = await tmpdir()
-  Global.Path.log = tmp.path
-
-  const list = Array.from({ length: 12 }, (_, i) => `2000-01-${String(i + 1).padStart(2, "0")}T000000.log`)
-
-  await Promise.all(list.map((file) => fs.writeFile(path.join(tmp.path, file), file)))
-
-  await Log.init({ print: false, dev: false })
-
-  const next = await files(tmp.path)
-
-  expect(next).not.toContain(list[0]!)
-  expect(next).toContain(list.at(-1)!)
-})
@@ -77,12 +77,6 @@ export function createOpencodeClient(config?: Config & { directory?: string; exp
      workspace: config?.experimental_workspaceID,
    }),
  )
-  client.interceptors.response.use((response) => {
-    const contentType = response.headers.get("content-type")
-    if (contentType === "text/html")
-      throw new Error("Request is not supported by this version of OpenCode Server (Server responded with text/html)")
-
-    return response
-  })
-  return new OpencodeClient({ client })
+  const result = new OpencodeClient({ client })
+  return result
 }
@@ -387,29 +387,6 @@ export type EventQuestionRejected = {
  }
 }

-export type Todo = {
-  /**
-   * Brief description of the task
-   */
-  content: string
-  /**
-   * Current status of the task: pending, in_progress, completed, cancelled
-   */
-  status: string
-  /**
-   * Priority level of the task: high, medium, low
-   */
-  priority: string
-}
-
-export type EventTodoUpdated = {
-  type: "todo.updated"
-  properties: {
-    sessionID: string
-    todos: Array<Todo>
-  }
-}
-
 export type SessionStatus =
  | {
      type: "idle"
@@ -446,6 +423,29 @@ export type EventSessionCompacted = {
  }
 }

+export type Todo = {
+  /**
+   * Brief description of the task
+   */
+  content: string
+  /**
+   * Current status of the task: pending, in_progress, completed, cancelled
+   */
+  status: string
+  /**
+   * Priority level of the task: high, medium, low
+   */
+  priority: string
+}
+
+export type EventTodoUpdated = {
+  type: "todo.updated"
+  properties: {
+    sessionID: string
+    todos: Array<Todo>
+  }
+}
+
 export type EventWorktreeReady = {
  type: "worktree.ready"
  properties: {
@@ -998,10 +998,10 @@ export type Event =
  | EventQuestionAsked
  | EventQuestionReplied
  | EventQuestionRejected
-  | EventTodoUpdated
  | EventSessionStatus
  | EventSessionIdle
  | EventSessionCompacted
+  | EventTodoUpdated
  | EventWorktreeReady
  | EventWorktreeFailed
  | EventPtyCreated
@@ -8139,50 +8139,6 @@
        },
        "required": ["type", "properties"]
      },
-      "Todo": {
-        "type": "object",
-        "properties": {
-          "content": {
-            "description": "Brief description of the task",
-            "type": "string"
-          },
-          "status": {
-            "description": "Current status of the task: pending, in_progress, completed, cancelled",
-            "type": "string"
-          },
-          "priority": {
-            "description": "Priority level of the task: high, medium, low",
-            "type": "string"
-          }
-        },
-        "required": ["content", "status", "priority"]
-      },
-      "Event.todo.updated": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "todo.updated"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "pattern": "^ses.*"
-              },
-              "todos": {
-                "type": "array",
-                "items": {
-                  "$ref": "#/components/schemas/Todo"
-                }
-              }
-            },
-            "required": ["sessionID", "todos"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
      "SessionStatus": {
        "anyOf": [
          {
@@ -8289,6 +8245,50 @@
        },
        "required": ["type", "properties"]
      },
+      "Todo": {
+        "type": "object",
+        "properties": {
+          "content": {
+            "description": "Brief description of the task",
+            "type": "string"
+          },
+          "status": {
+            "description": "Current status of the task: pending, in_progress, completed, cancelled",
+            "type": "string"
+          },
+          "priority": {
+            "description": "Priority level of the task: high, medium, low",
+            "type": "string"
+          }
+        },
+        "required": ["content", "status", "priority"]
+      },
+      "Event.todo.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "todo.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "sessionID": {
+                "type": "string",
+                "pattern": "^ses.*"
+              },
+              "todos": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/Todo"
+                }
+              }
+            },
+            "required": ["sessionID", "todos"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
      "Event.worktree.ready": {
        "type": "object",
        "properties": {
@@ -9949,9 +9949,6 @@
          {
            "$ref": "#/components/schemas/Event.question.rejected"
          },
-          {
-            "$ref": "#/components/schemas/Event.todo.updated"
-          },
          {
            "$ref": "#/components/schemas/Event.session.status"
          },
@@ -9961,6 +9958,9 @@
          {
            "$ref": "#/components/schemas/Event.session.compacted"
          },
+          {
+            "$ref": "#/components/schemas/Event.todo.updated"
+          },
          {
            "$ref": "#/components/schemas/Event.worktree.ready"
          },