refactor(file): drop redundant gen wrappers

Co-authored-by: Kit Langton <kit.langton@gmail.com>

packages/opencode/AGENTS.md

@@ -13,7 +13,7 @@
 
 Use these rules when writing or migrating Effect code.
 
-See `specs/effect-migration.md` for the compact pattern reference and examples.
+See `specs/effect/migration.md` for the compact pattern reference and examples.
 
 ## Core
 
@@ -51,7 +51,7 @@ See `specs/effect-migration.md` for the compact pattern reference and examples.
 
 ## Effect.cached for deduplication
 
-Use `Effect.cached` when multiple concurrent callers should share a single in-flight computation rather than storing `Fiber | undefined` or `Promise | undefined` manually. See `specs/effect-migration.md` for the full pattern.
+Use `Effect.cached` when multiple concurrent callers should share a single in-flight computation rather than storing `Fiber | undefined` or `Promise | undefined` manually. See `specs/effect/migration.md` for the full pattern.
 
 ## Instance.bind — ALS for native callbacks
 

packages/opencode/script/seed-e2e.ts

@@ -1,3 +1,5 @@
+import { AppRuntime } from "@/effect/app-runtime"
+
 const dir = process.env.OPENCODE_E2E_PROJECT_DIR ?? process.cwd()
 const title = process.env.OPENCODE_E2E_SESSION_TITLE ?? "E2E Session"
 const text = process.env.OPENCODE_E2E_MESSAGE ?? "Seeded for UI e2e"
@@ -16,14 +18,20 @@ const seed = async () => {
   const { Project } = await import("../src/project/project")
   const { ModelID, ProviderID } = await import("../src/provider/schema")
   const { ToolRegistry } = await import("../src/tool/registry")
+  const { Effect } = await import("effect")
 
   try {
     await Instance.provide({
       directory: dir,
-      init: InstanceBootstrap,
+      init: () => AppRuntime.runPromise(InstanceBootstrap),
       fn: async () => {
         await Config.waitForDependencies()
-        await ToolRegistry.ids()
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const registry = yield* ToolRegistry.Service
+            yield* registry.ids()
+          }),
+        )
 
         const session = await Session.create({ title })
         const messageID = MessageID.ascending()
@@ -54,6 +62,7 @@ const seed = async () => {
     })
   } finally {
     await Instance.disposeAll().catch(() => {})
+    await AppRuntime.dispose().catch(() => {})
   }
 }
 

packages/opencode/specs/effect/http-api.md

@@ -0,0 +1,137 @@
+# HttpApi migration
+
+Practical notes for an eventual migration of `packages/opencode` server routes from the current Hono handlers to Effect `HttpApi`, either as a full replacement or as a parallel surface.
+
+## Goal
+
+Use Effect `HttpApi` where it gives us a better typed contract for:
+
+- route definition
+- request decoding and validation
+- typed success and error responses
+- OpenAPI generation
+- handler composition inside Effect
+
+This should be treated as a later-stage HTTP boundary migration, not a prerequisite for ongoing service, route-handler, or schema work.
+
+## Core model
+
+`HttpApi` is definition-first.
+
+- `HttpApi` is the root API
+- `HttpApiGroup` groups related endpoints
+- `HttpApiEndpoint` defines a single route and its request / response schemas
+- handlers are implemented separately from the contract
+
+This is a better fit once route inputs and outputs are already moving toward Effect Schema-first models.
+
+## Why it is relevant here
+
+The current route-effectification work is already pushing handlers toward:
+
+- one `AppRuntime.runPromise(Effect.gen(...))` body
+- yielding services from context
+- using typed Effect errors instead of Promise wrappers
+
+That work is a good prerequisite for `HttpApi`. Once the handler body is already a composed Effect, the remaining migration is mostly about replacing the Hono route declaration and validator layer.
+
+## What HttpApi gives us
+
+### Contracts
+
+Request params, query, payload, success payloads, and typed error payloads are declared in one place using Effect Schema.
+
+### Validation and decoding
+
+Incoming data is decoded through Effect Schema instead of hand-maintained Zod validators per route.
+
+### OpenAPI
+
+`HttpApi` can derive OpenAPI from the API definition, which overlaps with the current `describeRoute(...)` and `resolver(...)` pattern.
+
+### Typed errors
+
+`Schema.TaggedErrorClass` maps naturally to endpoint error contracts.
+
+## Likely fit for opencode
+
+Best fit first:
+
+- JSON request / response endpoints
+- route groups that already mostly delegate into services
+- endpoints whose request and response models can be defined with Effect Schema
+
+Harder / later fit:
+
+- SSE endpoints
+- websocket endpoints
+- streaming handlers
+- routes with heavy Hono-specific middleware assumptions
+
+## Current blockers and gaps
+
+### Schema split
+
+Many route boundaries still use Zod-first validators. That does not block all experimentation, but full `HttpApi` adoption is easier after the domain and boundary types are more consistently Schema-first with `.zod` compatibility only where needed.
+
+### Mixed handler styles
+
+Many current `server/instance/*.ts` handlers still call async facades directly. Migrating those to composed `Effect.gen(...)` handlers is the low-risk step to do first.
+
+### Non-JSON routes
+
+The server currently includes SSE, websocket, and streaming-style endpoints. Those should not be the first `HttpApi` targets.
+
+### Existing Hono integration
+
+The current server composition, middleware, and docs flow are Hono-centered today. That suggests a parallel or incremental adoption plan is safer than a flag day rewrite.
+
+## Recommended strategy
+
+### 1. Finish the prerequisites first
+
+- continue route-handler effectification in `server/instance/*.ts`
+- continue schema migration toward Effect Schema-first DTOs and errors
+- keep removing service facades
+
+### 2. Start with one parallel group
+
+Introduce one small `HttpApi` group for plain JSON endpoints only. Good initial candidates are the least stateful endpoints in:
+
+- `server/instance/question.ts`
+- `server/instance/provider.ts`
+- `server/instance/permission.ts`
+
+Avoid `session.ts`, SSE, websocket, and TUI-facing routes first.
+
+### 3. Reuse existing services
+
+Do not re-architect business logic during the HTTP migration. `HttpApi` handlers should call the same Effect services already used by the Hono handlers.
+
+### 4. Run in parallel before replacing
+
+Prefer mounting an experimental `HttpApi` surface alongside the existing Hono routes first. That lowers migration risk and lets us compare:
+
+- handler ergonomics
+- OpenAPI output
+- auth and middleware integration
+- test ergonomics
+
+### 5. Migrate JSON route groups gradually
+
+If the parallel slice works well, migrate additional JSON route groups one at a time. Leave streaming-style endpoints on Hono until there is a clear reason to move them.
+
+## Proposed first steps
+
+- [ ] add one small spike that defines an `HttpApi` group for a simple JSON route set
+- [ ] use Effect Schema request / response types for that slice
+- [ ] keep the underlying service calls identical to the current handlers
+- [ ] compare generated OpenAPI against the current Hono/OpenAPI setup
+- [ ] document how auth, instance lookup, and error mapping would compose in the new stack
+- [ ] decide after the spike whether `HttpApi` should stay parallel, replace only some groups, or become the long-term default
+
+## Rule of thumb
+
+Do not start with the hardest route file.
+
+If `HttpApi` is adopted here, it should arrive after the handler body is already Effect-native and after the relevant request / response models have moved to Effect Schema.

packages/opencode/specs/effect/migration.md

@@ -178,7 +178,9 @@ That is fine for leaf files like `schema.ts`. Keep the service surface in the ow
 
 ## Migration checklist
 
-Fully migrated (single namespace, InstanceState where needed, flattened facade):
+Service-shape migrated (single namespace, traced methods, `InstanceState` where needed).
+
+This checklist is only about the service shape migration. Many of these services still keep `makeRuntime(...)` plus async facade exports; that facade-removal phase is tracked separately in [Destroying the facades](#destroying-the-facades).
 
 - [x] `Account` — `account/index.ts`
 - [x] `Agent` — `agent/agent.ts`
@@ -221,59 +223,16 @@ Fully migrated (single namespace, InstanceState where needed, flattened facade):
 - [x] `Provider` — `provider/provider.ts`
 - [x] `Storage` — `storage/storage.ts`
 - [x] `ShareNext` — `share/share-next.ts`
-
-Still open:
-
 - [x] `SessionTodo` — `session/todo.ts`
-- [ ] `SyncEvent` — `sync/index.ts`
-- [ ] `Workspace` — `control-plane/workspace.ts`
 
-## Tool interface → Effect
+Still open at the service-shape level:
 
-`Tool.Def.execute` and `Tool.Info.init` already return `Effect` on this branch. Tool definitions should now stay Effect-native all the way through initialization instead of using Promise-returning init callbacks. Tools can still use lazy init callbacks when they need instance-bound state at init time, but those callbacks should return `Effect`, not `Promise`. Remaining work is:
+- [ ] `SyncEvent` — `sync/index.ts` (deferred pending sync with James)
+- [ ] `Workspace` — `control-plane/workspace.ts` (deferred pending sync with James)
 
-1. Migrate each tool body to return Effects
-2. Keep `Tool.define()` inputs Effect-native
-3. Update remaining callers to `yield*` tool initialization instead of `await`ing
+## Tool migration
 
-### Tool migration details
-
-With `Tool.Info.init()` now effectful, use this transitional pattern for migrated tools that still need Promise-based boundaries internally:
-
-- `Tool.defineEffect(...)` should `yield*` the services the tool depends on and close over them in the returned tool definition.
-- Keep the bridge at the Promise boundary only inside the tool body when required by external APIs. Do not return Promise-based init callbacks from `Tool.define()`.
-- If a tool starts requiring new services, wire them into `ToolRegistry.defaultLayer` so production callers resolve the same dependencies as tests.
-
-Tool tests should use the existing Effect helpers in `packages/opencode/test/lib/effect.ts`:
-
-- Use `testEffect(...)` / `it.live(...)` instead of creating fake local wrappers around effectful tools.
-- Yield the real tool export, then initialize it: `const info = yield* ReadTool`, `const tool = yield* info.init()`.
-- Run tests inside a real instance with `provideTmpdirInstance(...)` or `provideInstance(tmpdirScoped(...))` so instance-scoped services resolve exactly as they do in production.
-
-This keeps migrated tool tests aligned with the production service graph today, and makes the eventual `Tool.Info` → `Effect` cleanup mostly mechanical later.
-
-Individual tools, ordered by value:
-
-- [ ] `apply_patch.ts` — HIGH: multi-step orchestration, error accumulation, Bus events
-- [ ] `bash.ts` — HIGH: shell orchestration, quoting, timeout handling, output capture
-- [x] `read.ts` — HIGH: streaming I/O, readline, binary detection → FileSystem + Stream
-- [ ] `edit.ts` — HIGH: multi-step diff/format/publish pipeline, FileWatcher lock
-- [ ] `grep.ts` — MEDIUM: spawns ripgrep → ChildProcessSpawner, timeout handling
-- [ ] `write.ts` — MEDIUM: permission checks, diagnostics polling, Bus events
-- [ ] `codesearch.ts` — MEDIUM: HTTP + SSE + manual timeout → HttpClient + Effect.timeout
-- [ ] `webfetch.ts` — MEDIUM: fetch with UA retry, size limits → HttpClient
-- [ ] `websearch.ts` — MEDIUM: MCP over HTTP → HttpClient
-- [ ] `batch.ts` — MEDIUM: parallel execution, per-call error recovery → Effect.all
-- [ ] `task.ts` — MEDIUM: task state management
-- [ ] `ls.ts` — MEDIUM: bounded directory listing over ripgrep-backed traversal
-- [ ] `multiedit.ts` — MEDIUM: sequential edit orchestration over `edit.ts`
-- [ ] `glob.ts` — LOW: simple async generator
-- [ ] `lsp.ts` — LOW: dispatch switch over LSP operations
-- [ ] `question.ts` — LOW: prompt wrapper
-- [ ] `skill.ts` — LOW: skill tool adapter
-- [ ] `todo.ts` — LOW: todo persistence wrapper
-- [ ] `invalid.ts` — LOW: invalid-tool fallback
-- [ ] `plan.ts` — LOW: plan file operations
+Tool-specific migration guidance and checklist live in `tools.md`.
 
 ## Effect service adoption in already-migrated code
 
@@ -281,27 +240,19 @@ Some already-effectified areas still use raw `Filesystem.*` or `Process.spawn` i
 
 ### `Filesystem.*` → `AppFileSystem.Service` (yield in layer)
 
-- [ ] `file/index.ts` — 1 remaining `Filesystem.readText()` call in untracked diff handling
-- [ ] `config/config.ts` — 5 remaining `Filesystem.*` calls in `installDependencies()`
-- [ ] `provider/provider.ts` — 1 remaining `Filesystem.readJson()` call for recent model state
+- [x] `config/config.ts` — `installDependencies()` now uses `AppFileSystem`
+- [x] `provider/provider.ts` — recent model state now reads via `AppFileSystem.Service`
 
 ### `Process.spawn` → `ChildProcessSpawner` (yield in layer)
 
-- [ ] `format/formatter.ts` — 2 remaining `Process.spawn()` checks (`air`, `uv`)
+- [x] `format/formatter.ts` — direct `Process.spawn()` checks removed (`air`, `uv`)
 - [ ] `lsp/server.ts` — multiple `Process.spawn()` installs/download helpers
 
 ## Filesystem consolidation
 
-`util/filesystem.ts` (raw fs wrapper) is currently imported by **34 files**. The effectified `AppFileSystem` service (`filesystem/index.ts`) is currently imported by **15 files**. As services and tools are effectified, they should switch from `Filesystem.*` to yielding `AppFileSystem.Service` — this happens naturally during each migration, not as a separate effort.
+`util/filesystem.ts` is still used widely across `src/`, and raw `fs` / `fs/promises` imports still exist in multiple tooling and infrastructure files. As services and tools are effectified, they should switch from `Filesystem.*` to yielding `AppFileSystem.Service` where possible — this should happen naturally during each migration, not as a separate sweep.
 
-Similarly, **21 files** still import raw `fs` or `fs/promises` directly. These should migrate to `AppFileSystem` or `Filesystem.*` as they're touched.
-
-Current raw fs users that will convert during tool migration:
-
-- `tool/read.ts` — fs.createReadStream, readline
-- `tool/apply_patch.ts` — fs/promises
-- `file/ripgrep.ts` — fs/promises
-- `patch/index.ts` — fs, fs/promises
+Tool-specific filesystem cleanup notes live in `tools.md`.
 
 ## Primitives & utilities
 
@@ -312,7 +263,9 @@ Current raw fs users that will convert during tool migration:
 
 ## Destroying the facades
 
-Every service currently exports async facade functions at the bottom of its namespace — `export async function read(...) { return runPromise(...) }` — backed by a per-service `makeRuntime`. These exist because cyclic imports used to force each service to build its own independent runtime. Now that the layer DAG is acyclic and `AppRuntime` (`src/effect/app-runtime.ts`) composes everything into one `ManagedRuntime`, we're removing them.
+This phase is still broadly open. As of 2026-04-11 there are still 31 `makeRuntime(...)` call sites under `src/`, and many service namespaces still export async facade helpers like `export async function read(...) { return runPromise(...) }`.
+
+These facades exist because cyclic imports used to force each service to build its own independent runtime. Now that the layer DAG is acyclic and `AppRuntime` (`src/effect/app-runtime.ts`) composes everything into one `ManagedRuntime`, we're removing them.
 
 ### Process
 
@@ -341,47 +294,14 @@ 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.
+- `SessionRunState` — migrated 2026-04-11. Single caller in `server/instance/session.ts` converted; facade removed.
+- `Account` — migrated 2026-04-11. Callers in `server/instance/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.
+- `Question` — migrated 2026-04-11. Callers in `server/instance/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
+Route-handler migration guidance and checklist live in `routes.md`.

packages/opencode/specs/effect/routes.md

@@ -0,0 +1,66 @@
+# Route handler effectification
+
+Practical reference for converting server route handlers in `packages/opencode` to a single `AppRuntime.runPromise(Effect.gen(...))` body.
+
+## Goal
+
+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)
+}
+```
+
+## Rules
+
+- Wrap the whole handler body in one `AppRuntime.runPromise(Effect.gen(...))` call when the handler is service-heavy.
+- Yield services from context instead of calling async facades repeatedly.
+- When independent service calls can run in parallel, use `Effect.all(..., { concurrency: "unbounded" })`.
+- Prefer one composed Effect body over multiple separate `runPromise(...)` calls in the same handler.
+
+## Current route files
+
+Current instance route files live under `src/server/instance`, not `server/routes`.
+
+The main migration targets are:
+
+- [ ] `server/instance/session.ts` — heaviest; still has many direct facade calls for Session, SessionPrompt, SessionRevert, SessionCompaction, SessionShare, SessionSummary, Agent, Bus
+- [ ] `server/instance/global.ts` — still has direct facade calls for Config and instance lifecycle actions
+- [ ] `server/instance/provider.ts` — still has direct facade calls for Config and Provider
+- [ ] `server/instance/question.ts` — partially converted; still worth tracking here until it consistently uses the composed style
+- [ ] `server/instance/pty.ts` — still calls Pty facades directly
+- [ ] `server/instance/experimental.ts` — mixed state; some handlers are already composed, others still use facades
+
+Additional route files that still participate in the migration:
+
+- [ ] `server/instance/index.ts` — Vcs, Agent, Skill, LSP, Format
+- [ ] `server/instance/file.ts` — Ripgrep, File, LSP
+- [ ] `server/instance/mcp.ts` — MCP facade-heavy
+- [ ] `server/instance/permission.ts` — Permission
+- [ ] `server/instance/workspace.ts` — Workspace
+- [ ] `server/instance/tui.ts` — Bus and Session
+- [ ] `server/instance/middleware.ts` — Session and Workspace lookups
+
+## Notes
+
+- Some handlers already use `AppRuntime.runPromise(Effect.gen(...))` in isolated places. Keep pushing those files toward one consistent style.
+- Route conversion is closely tied to facade removal. As services lose `makeRuntime`-backed async exports, route handlers should switch to yielding the service directly.

packages/opencode/specs/effect/schema.md

@@ -0,0 +1,99 @@
+# Schema migration
+
+Practical reference for migrating data types in `packages/opencode` from Zod-first definitions to Effect Schema with Zod compatibility shims.
+
+## Goal
+
+Use Effect Schema as the source of truth for domain models, IDs, inputs, outputs, and typed errors.
+
+Keep Zod available at existing HTTP, tool, and compatibility boundaries by exposing a `.zod` field derived from the Effect schema.
+
+## Preferred shapes
+
+### Data objects
+
+Use `Schema.Class` for structured data.
+
+```ts
+export class Info extends Schema.Class<Info>("Foo.Info")({
+  id: FooID,
+  name: Schema.String,
+  enabled: Schema.Boolean,
+}) {
+  static readonly zod = zod(Info)
+}
+```
+
+If the class cannot reference itself cleanly during initialization, use the existing two-step pattern:
+
+```ts
+const _Info = Schema.Struct({
+  id: FooID,
+  name: Schema.String,
+})
+
+export const Info = Object.assign(_Info, {
+  zod: zod(_Info),
+})
+```
+
+### Errors
+
+Use `Schema.TaggedErrorClass` for domain errors.
+
+```ts
+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("FooNotFoundError", {
+  id: FooID,
+}) {}
+```
+
+### IDs and branded leaf types
+
+Keep branded/schema-backed IDs as Effect schemas and expose `static readonly zod` for compatibility when callers still expect Zod.
+
+## Compatibility rule
+
+During migration, route validators, tool parameters, and any existing Zod-based boundary should consume the derived `.zod` schema instead of maintaining a second hand-written Zod schema.
+
+The default should be:
+
+- Effect Schema owns the type
+- `.zod` exists only as a compatibility surface
+- new domain models should not start Zod-first unless there is a concrete boundary-specific need
+
+## When Zod can stay
+
+It is fine to keep a Zod-native schema temporarily when:
+
+- the type is only used at an HTTP or tool boundary
+- the validator depends on Zod-only transforms or behavior not yet covered by `zod()`
+- the migration would force unrelated churn across a large call graph
+
+When this happens, prefer leaving a short note or TODO rather than silently creating a parallel schema source of truth.
+
+## Ordering
+
+Migrate in this order:
+
+1. Shared leaf models and `schema.ts` files
+2. Exported `Info`, `Input`, `Output`, and DTO types
+3. Tagged domain errors
+4. Service-local internal models
+5. Route and tool boundary validators that can switch to `.zod`
+
+This keeps shared types canonical first and makes boundary updates mostly mechanical.
+
+## Checklist
+
+- [ ] Shared `schema.ts` leaf models are Effect Schema-first
+- [ ] Exported `Info` / `Input` / `Output` types use `Schema.Class` where appropriate
+- [ ] Domain errors use `Schema.TaggedErrorClass`
+- [ ] Migrated types expose `.zod` for back compatibility
+- [ ] Route and tool validators consume derived `.zod` instead of duplicate Zod definitions
+- [ ] New domain models default to Effect Schema first
+
+## Notes
+
+- Use `@/util/effect-zod` for all Schema -> Zod conversion.
+- Prefer one canonical schema definition. Avoid maintaining parallel Zod and Effect definitions for the same domain type.
+- Keep the migration incremental. Converting the domain model first is more valuable than converting every boundary in the same change.

packages/opencode/specs/effect/tools.md

@@ -0,0 +1,96 @@
+# Tool migration
+
+Practical reference for the current tool-migration state in `packages/opencode`.
+
+## Status
+
+`Tool.Def.execute` and `Tool.Info.init` already return `Effect` on this branch, and the built-in tool surface is now largely on the target shape.
+
+The current exported tools in `src/tool` all use `Tool.define(...)` with Effect-based initialization, and nearly all of them already build their tool body with `Effect.gen(...)` and `Effect.fn(...)`.
+
+So the remaining work is no longer "convert tools to Effect at all". The remaining work is mostly:
+
+1. remove Promise and raw platform bridges inside individual tool bodies
+2. swap tool internals to Effect-native services like `AppFileSystem`, `HttpClient`, and `ChildProcessSpawner`
+3. keep tests and callers aligned with `yield* info.init()` and real service graphs
+
+## Current shape
+
+`Tool.define(...)` is already the Effect-native helper here.
+
+- `init` is an `Effect`
+- `info.init()` returns an `Effect`
+- `execute(...)` returns an `Effect`
+
+That means a tool does not need a separate `Tool.defineEffect(...)` helper to count as migrated. A tool is effectively migrated when its init and execute path stay Effect-native, even if some internals still bridge to Promise-based or raw APIs.
+
+## Tests
+
+Tool tests should use the existing Effect helpers in `packages/opencode/test/lib/effect.ts`:
+
+- Use `testEffect(...)` / `it.live(...)` instead of creating fake local wrappers around effectful tools.
+- Yield the real tool export, then initialize it: `const info = yield* ReadTool`, `const tool = yield* info.init()`.
+- Run tests inside a real instance with `provideTmpdirInstance(...)` or `provideInstance(tmpdirScoped(...))` so instance-scoped services resolve exactly as they do in production.
+
+This keeps tool tests aligned with the production service graph and makes follow-up cleanup mostly mechanical.
+
+## Exported tools
+
+These exported tool definitions already exist in `src/tool` and are on the current Effect-native `Tool.define(...)` path:
+
+- [x] `apply_patch.ts`
+- [x] `bash.ts`
+- [x] `codesearch.ts`
+- [x] `edit.ts`
+- [x] `glob.ts`
+- [x] `grep.ts`
+- [x] `invalid.ts`
+- [x] `ls.ts`
+- [x] `lsp.ts`
+- [x] `multiedit.ts`
+- [x] `plan.ts`
+- [x] `question.ts`
+- [x] `read.ts`
+- [x] `skill.ts`
+- [x] `task.ts`
+- [x] `todo.ts`
+- [x] `webfetch.ts`
+- [x] `websearch.ts`
+- [x] `write.ts`
+
+Notes:
+
+- `batch.ts` is no longer a current tool file and should not be tracked here.
+- `truncate.ts` is an Effect service used by tools, not a tool definition itself.
+- `mcp-exa.ts`, `external-directory.ts`, and `schema.ts` are support modules, not standalone tool definitions.
+
+## Follow-up cleanup
+
+Most exported tools are already on the intended Effect-native shape. The remaining cleanup is narrower than the old checklist implied.
+
+Current spot cleanups worth tracking:
+
+- [ ] `read.ts` — still bridges to Node stream / `readline` helpers and Promise-based binary detection
+- [ ] `bash.ts` — already uses Effect child-process primitives; only keep tracking shell-specific platform bridges and parser/loading details as they come up
+- [ ] `webfetch.ts` — already uses `HttpClient`; remaining work is limited to smaller boundary helpers like HTML text extraction
+- [ ] `file/ripgrep.ts` — adjacent to tool migration; still has raw fs/process usage that affects `grep.ts` and `ls.ts`
+- [ ] `patch/index.ts` — adjacent to tool migration; still has raw fs usage behind patch application
+
+Notable items that are already effectively on the target path and do not need separate migration bullets right now:
+
+- `apply_patch.ts`
+- `grep.ts`
+- `write.ts`
+- `codesearch.ts`
+- `websearch.ts`
+- `ls.ts`
+- `multiedit.ts`
+- `edit.ts`
+
+## Filesystem notes
+
+Current raw fs users that still appear relevant here:
+
+- `tool/read.ts` — `fs.createReadStream`, `readline`
+- `file/ripgrep.ts` — `fs/promises`
+- `patch/index.ts` — `fs`, `fs/promises`

packages/opencode/src/auth/index.ts

@@ -1,6 +1,5 @@
 import path from "path"
 import { Effect, Layer, Record, Result, Schema, Context } from "effect"
-import { makeRuntime } from "@/effect/run-service"
 import { zod } from "@/util/effect-zod"
 import { Global } from "../global"
 import { AppFileSystem } from "../filesystem"
@@ -89,22 +88,4 @@ export namespace Auth {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function get(providerID: string) {
-    return runPromise((service) => service.get(providerID))
-  }
-
-  export async function all(): Promise<Record<string, Info>> {
-    return runPromise((service) => service.all())
-  }
-
-  export async function set(key: string, info: Info) {
-    return runPromise((service) => service.set(key, info))
-  }
-
-  export async function remove(key: string) {
-    return runPromise((service) => service.remove(key))
-  }
 }

packages/opencode/src/cli/bootstrap.ts

@@ -1,10 +1,11 @@
+import { AppRuntime } from "@/effect/app-runtime"
 import { InstanceBootstrap } from "../project/bootstrap"
 import { Instance } from "../project/instance"
 
 export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
   return Instance.provide({
     directory,
-    init: InstanceBootstrap,
+    init: () => AppRuntime.runPromise(InstanceBootstrap),
     fn: async () => {
       try {
         const result = await cb()

packages/opencode/src/cli/cmd/debug/agent.ts

@@ -12,6 +12,7 @@ import { Permission } from "../../../permission"
 import { iife } from "../../../util/iife"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
+import { AppRuntime } from "@/effect/app-runtime"
 
 export const AgentCommand = cmd({
   command: "agent <name>",
@@ -71,11 +72,17 @@ export const AgentCommand = cmd({
 })
 
 async function getAvailableTools(agent: Agent.Info) {
-  const model = agent.model ?? (await Provider.defaultModel())
-  return ToolRegistry.tools({
-    ...model,
-    agent,
-  })
+  return AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const provider = yield* Provider.Service
+      const registry = yield* ToolRegistry.Service
+      const model = agent.model ?? (yield* provider.defaultModel())
+      return yield* registry.tools({
+        ...model,
+        agent,
+      })
+    }),
+  )
 }
 
 async function resolveTools(agent: Agent.Info, availableTools: Awaited<ReturnType<typeof getAvailableTools>>) {
@@ -118,7 +125,14 @@ function parseToolParams(input?: string) {
 async function createToolContext(agent: Agent.Info) {
   const session = await Session.create({ title: `Debug tool run (${agent.name})` })
   const messageID = MessageID.ascending()
-  const model = agent.model ?? (await Provider.defaultModel())
+  const model =
+    agent.model ??
+    (await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const provider = yield* Provider.Service
+        return yield* provider.defaultModel()
+      }),
+    ))
   const now = Date.now()
   const message: MessageV2.Assistant = {
     id: messageID,

packages/opencode/src/cli/cmd/debug/file.ts

@@ -1,4 +1,6 @@
 import { EOL } from "os"
+import { Effect } from "effect"
+import { AppRuntime } from "@/effect/app-runtime"
 import { File } from "../../../file"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
@@ -15,7 +17,7 @@ const FileSearchCommand = cmd({
     }),
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
-      const results = await File.search({ query: args.query })
+      const results = await AppRuntime.runPromise(File.Service.use((svc) => svc.search({ query: args.query })))
       process.stdout.write(results.join(EOL) + EOL)
     })
   },
@@ -32,7 +34,7 @@ const FileReadCommand = cmd({
     }),
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
-      const content = await File.read(args.path)
+      const content = await AppRuntime.runPromise(File.Service.use((svc) => svc.read(args.path)))
       process.stdout.write(JSON.stringify(content, null, 2) + EOL)
     })
   },
@@ -44,7 +46,7 @@ const FileStatusCommand = cmd({
   builder: (yargs) => yargs,
   async handler() {
     await bootstrap(process.cwd(), async () => {
-      const status = await File.status()
+      const status = await AppRuntime.runPromise(File.Service.use((svc) => svc.status()))
       process.stdout.write(JSON.stringify(status, null, 2) + EOL)
     })
   },
@@ -61,7 +63,7 @@ const FileListCommand = cmd({
     }),
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
-      const files = await File.list(args.path)
+      const files = await AppRuntime.runPromise(File.Service.use((svc) => svc.list(args.path)))
       process.stdout.write(JSON.stringify(files, null, 2) + EOL)
     })
   },

packages/opencode/src/cli/cmd/debug/lsp.ts

@@ -1,4 +1,6 @@
 import { LSP } from "../../../lsp"
+import { AppRuntime } from "../../../effect/app-runtime"
+import { Effect } from "effect"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
 import { Log } from "../../../util/log"
@@ -19,9 +21,16 @@ const DiagnosticsCommand = cmd({
   builder: (yargs) => yargs.positional("file", { type: "string", demandOption: true }),
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
-      await LSP.touchFile(args.file, true)
-      await sleep(1000)
-      process.stdout.write(JSON.stringify(await LSP.diagnostics(), null, 2) + EOL)
+      const out = await AppRuntime.runPromise(
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            yield* lsp.touchFile(args.file, true)
+            yield* Effect.sleep(1000)
+            return yield* lsp.diagnostics()
+          }),
+        ),
+      )
+      process.stdout.write(JSON.stringify(out, null, 2) + EOL)
     })
   },
 })
@@ -33,7 +42,7 @@ export const SymbolsCommand = cmd({
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
       using _ = Log.Default.time("symbols")
-      const results = await LSP.workspaceSymbol(args.query)
+      const results = await AppRuntime.runPromise(LSP.Service.use((lsp) => lsp.workspaceSymbol(args.query)))
       process.stdout.write(JSON.stringify(results, null, 2) + EOL)
     })
   },
@@ -46,7 +55,7 @@ export const DocumentSymbolsCommand = cmd({
   async handler(args) {
     await bootstrap(process.cwd(), async () => {
       using _ = Log.Default.time("document-symbols")
-      const results = await LSP.documentSymbol(args.uri)
+      const results = await AppRuntime.runPromise(LSP.Service.use((lsp) => lsp.documentSymbol(args.uri)))
       process.stdout.write(JSON.stringify(results, null, 2) + EOL)
     })
   },

packages/opencode/src/cli/cmd/debug/ripgrep.ts

@@ -1,4 +1,5 @@
 import { EOL } from "os"
+import { AppRuntime } from "../../../effect/app-runtime"
 import { Ripgrep } from "../../../file/ripgrep"
 import { Instance } from "../../../project/instance"
 import { bootstrap } from "../../bootstrap"
@@ -76,12 +77,18 @@ const SearchCommand = cmd({
         description: "Limit number of results",
       }),
   async handler(args) {
-    const results = await Ripgrep.search({
-      cwd: process.cwd(),
-      pattern: args.pattern,
-      glob: args.glob as string[] | undefined,
-      limit: args.limit,
+    await bootstrap(process.cwd(), async () => {
+      const results = await AppRuntime.runPromise(
+        Ripgrep.Service.use((svc) =>
+          svc.search({
+            cwd: Instance.directory,
+            pattern: args.pattern,
+            glob: args.glob as string[] | undefined,
+            limit: args.limit,
+          }),
+        ),
+      )
+      process.stdout.write(JSON.stringify(results.items, null, 2) + EOL)
     })
-    process.stdout.write(JSON.stringify(results, null, 2) + EOL)
   },
 })

packages/opencode/src/cli/cmd/debug/skill.ts

@@ -1,4 +1,6 @@
 import { EOL } from "os"
+import { Effect } from "effect"
+import { AppRuntime } from "@/effect/app-runtime"
 import { Skill } from "../../../skill"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
@@ -9,7 +11,12 @@ export const SkillCommand = cmd({
   builder: (yargs) => yargs,
   async handler() {
     await bootstrap(process.cwd(), async () => {
-      const skills = await Skill.all()
+      const skills = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const skill = yield* Skill.Service
+          return yield* skill.all()
+        }),
+      )
       process.stdout.write(JSON.stringify(skills, null, 2) + EOL)
     })
   },

packages/opencode/src/cli/cmd/models.ts

@@ -6,6 +6,8 @@ import { ModelsDev } from "../../provider/models"
 import { cmd } from "./cmd"
 import { UI } from "../ui"
 import { EOL } from "os"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Effect } from "effect"
 
 export const ModelsCommand = cmd({
   command: "models [provider]",
@@ -35,43 +37,51 @@ export const ModelsCommand = cmd({
     await Instance.provide({
       directory: process.cwd(),
       async fn() {
-        const providers = await Provider.list()
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const svc = yield* Provider.Service
+            const providers = yield* svc.list()
 
-        function printModels(providerID: ProviderID, verbose?: boolean) {
-          const provider = providers[providerID]
-          const sortedModels = Object.entries(provider.models).sort(([a], [b]) => a.localeCompare(b))
-          for (const [modelID, model] of sortedModels) {
-            process.stdout.write(`${providerID}/${modelID}`)
-            process.stdout.write(EOL)
-            if (verbose) {
-              process.stdout.write(JSON.stringify(model, null, 2))
-              process.stdout.write(EOL)
+            const print = (providerID: ProviderID, verbose?: boolean) => {
+              const provider = providers[providerID]
+              const sorted = Object.entries(provider.models).sort(([a], [b]) => a.localeCompare(b))
+              for (const [modelID, model] of sorted) {
+                process.stdout.write(`${providerID}/${modelID}`)
+                process.stdout.write(EOL)
+                if (verbose) {
+                  process.stdout.write(JSON.stringify(model, null, 2))
+                  process.stdout.write(EOL)
+                }
+              }
             }
-          }
-        }
 
-        if (args.provider) {
-          const provider = providers[ProviderID.make(args.provider)]
-          if (!provider) {
-            UI.error(`Provider not found: ${args.provider}`)
-            return
-          }
+            if (args.provider) {
+              const providerID = ProviderID.make(args.provider)
+              const provider = providers[providerID]
+              if (!provider) {
+                yield* Effect.sync(() => UI.error(`Provider not found: ${args.provider}`))
+                return
+              }
 
-          printModels(ProviderID.make(args.provider), args.verbose)
-          return
-        }
+              yield* Effect.sync(() => print(providerID, args.verbose))
+              return
+            }
 
-        const providerIDs = Object.keys(providers).sort((a, b) => {
-          const aIsOpencode = a.startsWith("opencode")
-          const bIsOpencode = b.startsWith("opencode")
-          if (aIsOpencode && !bIsOpencode) return -1
-          if (!aIsOpencode && bIsOpencode) return 1
-          return a.localeCompare(b)
-        })
+            const ids = Object.keys(providers).sort((a, b) => {
+              const aIsOpencode = a.startsWith("opencode")
+              const bIsOpencode = b.startsWith("opencode")
+              if (aIsOpencode && !bIsOpencode) return -1
+              if (!aIsOpencode && bIsOpencode) return 1
+              return a.localeCompare(b)
+            })
 
-        for (const providerID of providerIDs) {
-          printModels(ProviderID.make(providerID), args.verbose)
-        }
+            yield* Effect.sync(() => {
+              for (const providerID of ids) {
+                print(ProviderID.make(providerID), args.verbose)
+              }
+            })
+          }),
+        )
       },
     })
   },

packages/opencode/src/cli/cmd/providers.ts

@@ -1,4 +1,5 @@
 import { Auth } from "../../auth"
+import { AppRuntime } from "../../effect/app-runtime"
 import { cmd } from "./cmd"
 import * as prompts from "@clack/prompts"
 import { UI } from "../ui"
@@ -13,9 +14,18 @@ import { Instance } from "../../project/instance"
 import type { Hooks } from "@opencode-ai/plugin"
 import { Process } from "../../util/process"
 import { text } from "node:stream/consumers"
+import { Effect } from "effect"
 
 type PluginAuth = NonNullable<Hooks["auth"]>
 
+const put = (key: string, info: Auth.Info) =>
+  AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const auth = yield* Auth.Service
+      yield* auth.set(key, info)
+    }),
+  )
+
 async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string, methodName?: string): Promise<boolean> {
   let index = 0
   if (methodName) {
@@ -93,7 +103,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
         const saveProvider = result.provider ?? provider
         if ("refresh" in result) {
           const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
-          await Auth.set(saveProvider, {
+          await put(saveProvider, {
             type: "oauth",
             refresh,
             access,
@@ -102,7 +112,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
           })
         }
         if ("key" in result) {
-          await Auth.set(saveProvider, {
+          await put(saveProvider, {
             type: "api",
             key: result.key,
           })
@@ -125,7 +135,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
         const saveProvider = result.provider ?? provider
         if ("refresh" in result) {
           const { type: _, provider: __, refresh, access, expires, ...extraFields } = result
-          await Auth.set(saveProvider, {
+          await put(saveProvider, {
             type: "oauth",
             refresh,
             access,
@@ -134,7 +144,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
           })
         }
         if ("key" in result) {
-          await Auth.set(saveProvider, {
+          await put(saveProvider, {
             type: "api",
             key: result.key,
           })
@@ -161,7 +171,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
       }
       if (result.type === "success") {
         const saveProvider = result.provider ?? provider
-        await Auth.set(saveProvider, {
+        await put(saveProvider, {
           type: "api",
           key: result.key ?? key,
         })
@@ -221,7 +231,12 @@ export const ProvidersListCommand = cmd({
     const homedir = os.homedir()
     const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
     prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
-    const results = Object.entries(await Auth.all())
+    const results = await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        return Object.entries(yield* auth.all())
+      }),
+    )
     const database = await ModelsDev.get()
 
     for (const [providerID, result] of results) {
@@ -300,7 +315,7 @@ export const ProvidersLoginCommand = cmd({
             prompts.outro("Done")
             return
           }
-          await Auth.set(url, {
+          await put(url, {
             type: "wellknown",
             key: wellknown.auth.env,
             token: token.trim(),
@@ -447,7 +462,7 @@ export const ProvidersLoginCommand = cmd({
           validate: (x) => (x && x.length > 0 ? undefined : "Required"),
         })
         if (prompts.isCancel(key)) throw new UI.CancelledError()
-        await Auth.set(provider, {
+        await put(provider, {
           type: "api",
           key,
         })
@@ -463,22 +478,33 @@ export const ProvidersLogoutCommand = cmd({
   describe: "log out from a configured provider",
   async handler(_args) {
     UI.empty()
-    const credentials = await Auth.all().then((x) => Object.entries(x))
+    const credentials: Array<[string, Auth.Info]> = await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        return Object.entries(yield* auth.all())
+      }),
+    )
     prompts.intro("Remove credential")
     if (credentials.length === 0) {
       prompts.log.error("No credentials found")
       return
     }
     const database = await ModelsDev.get()
-    const providerID = await prompts.select({
+    const selected = await prompts.select({
       message: "Select provider",
       options: credentials.map(([key, value]) => ({
         label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
         value: key,
       })),
     })
-    if (prompts.isCancel(providerID)) throw new UI.CancelledError()
-    await Auth.remove(providerID)
+    if (prompts.isCancel(selected)) throw new UI.CancelledError()
+    const providerID = selected as string
+    await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.remove(providerID)
+      }),
+    )
     prompts.outro("Logout successful")
   },
 })

packages/opencode/src/cli/cmd/run.ts

@@ -1,16 +1,3 @@
-// CLI entry point for `opencode run`.
-//
-// Handles three modes:
-//   1. Non-interactive (default): sends a single prompt, streams events to
-//      stdout, and exits when the session goes idle.
-//   2. Interactive local (`--interactive`): boots the split-footer direct mode
-//      with an in-process server (no external HTTP).
-//   3. Interactive attach (`--interactive --attach`): connects to a running
-//      opencode server and runs interactive mode against it.
-//
-// Also supports `--command` for slash-command execution, `--format json` for
-// raw event streaming, `--continue` / `--session` for session resumption,
-// and `--fork` for forking before continuing.
 import type { Argv } from "yargs"
 import path from "path"
 import { pathToFileURL } from "url"
@@ -21,26 +8,39 @@ import { bootstrap } from "../bootstrap"
 import { EOL } from "os"
 import { Filesystem } from "../../util/filesystem"
 import { createOpencodeClient, type OpencodeClient, type ToolPart } from "@opencode-ai/sdk/v2"
+import { Server } from "../../server/server"
+import { Provider } from "../../provider/provider"
+import { Agent } from "../../agent/agent"
 import { Permission } from "../../permission"
-import type { RunDemo } from "./run/types"
+import { Tool } from "../../tool/tool"
+import { GlobTool } from "../../tool/glob"
+import { GrepTool } from "../../tool/grep"
+import { ListTool } from "../../tool/ls"
+import { ReadTool } from "../../tool/read"
+import { WebFetchTool } from "../../tool/webfetch"
+import { EditTool } from "../../tool/edit"
+import { WriteTool } from "../../tool/write"
+import { CodeSearchTool } from "../../tool/codesearch"
+import { WebSearchTool } from "../../tool/websearch"
+import { TaskTool } from "../../tool/task"
+import { SkillTool } from "../../tool/skill"
+import { BashTool } from "../../tool/bash"
+import { TodoWriteTool } from "../../tool/todo"
+import { Locale } from "../../util/locale"
 
-const runtimeTask = import("./run/runtime")
-type ModelInput = Parameters<OpencodeClient["session"]["prompt"]>[0]["model"]
-
-function pick(value: string | undefined): ModelInput | undefined {
-  if (!value) return undefined
-  const [providerID, ...rest] = value.split("/")
-  return {
-    providerID,
-    modelID: rest.join("/"),
-  } as ModelInput
+type ToolProps<T> = {
+  input: Tool.InferParameters<T>
+  metadata: Tool.InferMetadata<T>
+  part: ToolPart
 }
 
-type FilePart = {
-  type: "file"
-  url: string
-  filename: string
-  mime: string
+function props<T>(part: ToolPart): ToolProps<T> {
+  const state = part.state
+  return {
+    input: state.input as Tool.InferParameters<T>,
+    metadata: ("metadata" in state ? state.metadata : {}) as Tool.InferMetadata<T>,
+    part,
+  }
 }
 
 type Inline = {
@@ -49,12 +49,6 @@ type Inline = {
   description?: string
 }
 
-type SessionInfo = {
-  id: string
-  title?: string
-  directory?: string
-}
-
 function inline(info: Inline) {
   const suffix = info.description ? UI.Style.TEXT_DIM + ` ${info.description}` + UI.Style.TEXT_NORMAL : ""
   UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title + suffix)
@@ -68,22 +62,160 @@ function block(info: Inline, output?: string) {
   UI.empty()
 }
 
-async function tool(part: ToolPart) {
-  try {
-    const { toolInlineInfo } = await import("./run/tool")
-    const next = toolInlineInfo(part)
-    if (next.mode === "block") {
-      block(next, next.body)
-      return
-    }
+function fallback(part: ToolPart) {
+  const state = part.state
+  const input = "input" in state ? state.input : undefined
+  const title =
+    ("title" in state && state.title ? state.title : undefined) ||
+    (input && typeof input === "object" && Object.keys(input).length > 0 ? JSON.stringify(input) : "Unknown")
+  inline({
+    icon: "⚙",
+    title: `${part.tool} ${title}`,
+  })
+}
 
-    inline(next)
-  } catch {
-    inline({
-      icon: "⚙",
-      title: part.tool,
-    })
-  }
+function glob(info: ToolProps<typeof GlobTool>) {
+  const root = info.input.path ?? ""
+  const title = `Glob "${info.input.pattern}"`
+  const suffix = root ? `in ${normalizePath(root)}` : ""
+  const num = info.metadata.count
+  const description =
+    num === undefined ? suffix : `${suffix}${suffix ? " · " : ""}${num} ${num === 1 ? "match" : "matches"}`
+  inline({
+    icon: "✱",
+    title,
+    ...(description && { description }),
+  })
+}
+
+function grep(info: ToolProps<typeof GrepTool>) {
+  const root = info.input.path ?? ""
+  const title = `Grep "${info.input.pattern}"`
+  const suffix = root ? `in ${normalizePath(root)}` : ""
+  const num = info.metadata.matches
+  const description =
+    num === undefined ? suffix : `${suffix}${suffix ? " · " : ""}${num} ${num === 1 ? "match" : "matches"}`
+  inline({
+    icon: "✱",
+    title,
+    ...(description && { description }),
+  })
+}
+
+function list(info: ToolProps<typeof ListTool>) {
+  const dir = info.input.path ? normalizePath(info.input.path) : ""
+  inline({
+    icon: "→",
+    title: dir ? `List ${dir}` : "List",
+  })
+}
+
+function read(info: ToolProps<typeof ReadTool>) {
+  const file = normalizePath(info.input.filePath)
+  const pairs = Object.entries(info.input).filter(([key, value]) => {
+    if (key === "filePath") return false
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+  })
+  const description = pairs.length ? `[${pairs.map(([key, value]) => `${key}=${value}`).join(", ")}]` : undefined
+  inline({
+    icon: "→",
+    title: `Read ${file}`,
+    ...(description && { description }),
+  })
+}
+
+function write(info: ToolProps<typeof WriteTool>) {
+  block(
+    {
+      icon: "←",
+      title: `Write ${normalizePath(info.input.filePath)}`,
+    },
+    info.part.state.status === "completed" ? info.part.state.output : undefined,
+  )
+}
+
+function webfetch(info: ToolProps<typeof WebFetchTool>) {
+  inline({
+    icon: "%",
+    title: `WebFetch ${info.input.url}`,
+  })
+}
+
+function edit(info: ToolProps<typeof EditTool>) {
+  const title = normalizePath(info.input.filePath)
+  const diff = info.metadata.diff
+  block(
+    {
+      icon: "←",
+      title: `Edit ${title}`,
+    },
+    diff,
+  )
+}
+
+function codesearch(info: ToolProps<typeof CodeSearchTool>) {
+  inline({
+    icon: "◇",
+    title: `Exa Code Search "${info.input.query}"`,
+  })
+}
+
+function websearch(info: ToolProps<typeof WebSearchTool>) {
+  inline({
+    icon: "◈",
+    title: `Exa Web Search "${info.input.query}"`,
+  })
+}
+
+function task(info: ToolProps<typeof TaskTool>) {
+  const input = info.part.state.input
+  const status = info.part.state.status
+  const subagent =
+    typeof input.subagent_type === "string" && input.subagent_type.trim().length > 0 ? input.subagent_type : "unknown"
+  const agent = Locale.titlecase(subagent)
+  const desc =
+    typeof input.description === "string" && input.description.trim().length > 0 ? input.description : undefined
+  const icon = status === "error" ? "✗" : status === "running" ? "•" : "✓"
+  const name = desc ?? `${agent} Task`
+  inline({
+    icon,
+    title: name,
+    description: desc ? `${agent} Agent` : undefined,
+  })
+}
+
+function skill(info: ToolProps<typeof SkillTool>) {
+  inline({
+    icon: "→",
+    title: `Skill "${info.input.name}"`,
+  })
+}
+
+function bash(info: ToolProps<typeof BashTool>) {
+  const output = info.part.state.status === "completed" ? info.part.state.output?.trim() : undefined
+  block(
+    {
+      icon: "$",
+      title: `${info.input.command}`,
+    },
+    output,
+  )
+}
+
+function todo(info: ToolProps<typeof TodoWriteTool>) {
+  block(
+    {
+      icon: "#",
+      title: "Todos",
+    },
+    info.input.todos.map((item) => `${item.status === "completed" ? "[x]" : "[ ]"} ${item.content}`).join("\n"),
+  )
+}
+
+function normalizePath(input?: string) {
+  if (!input) return ""
+  if (path.isAbsolute(input)) return path.relative(process.cwd(), input) || "."
+  return input
 }
 
 export const RunCommand = cmd({
@@ -168,11 +300,6 @@ export const RunCommand = cmd({
       .option("thinking", {
         type: "boolean",
         describe: "show thinking blocks",
-      })
-      .option("interactive", {
-        alias: ["i"],
-        type: "boolean",
-        describe: "run in direct interactive split-footer mode",
         default: false,
       })
       .option("dangerously-skip-permissions", {
@@ -180,89 +307,30 @@ export const RunCommand = cmd({
         describe: "auto-approve permissions that are not explicitly denied (dangerous!)",
         default: false,
       })
-      .option("demo", {
-        type: "string",
-        choices: ["on", "permission", "question", "mix", "text"],
-        describe: "enable direct interactive demo slash commands",
-      })
-      .option("demo-text", {
-        type: "string",
-        describe: "text used with --demo text",
-      })
   },
   handler: async (args) => {
-    const rawMessage = [...args.message, ...(args["--"] || [])].join(" ")
-    const thinking = args.interactive ? (args.thinking ?? true) : (args.thinking ?? false)
-
     let message = [...args.message, ...(args["--"] || [])]
       .map((arg) => (arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg))
       .join(" ")
 
-    if (args.interactive && args.command) {
-      UI.error("--interactive cannot be used with --command")
-      process.exit(1)
-    }
-
-    if (args.demo && !args.interactive) {
-      UI.error("--demo requires --interactive")
-      process.exit(1)
-    }
-
-    if (args.demoText && args.demo !== "text") {
-      UI.error("--demo-text requires --demo text")
-      process.exit(1)
-    }
-
-    if (args.interactive && args.format === "json") {
-      UI.error("--interactive cannot be used with --format json")
-      process.exit(1)
-    }
-
-    if (args.interactive && !process.stdin.isTTY) {
-      UI.error("--interactive requires a TTY")
-      process.exit(1)
-    }
-
-    if (args.interactive && !process.stdout.isTTY) {
-      UI.error("--interactive requires a TTY stdout")
-      process.exit(1)
-    }
-
-    const root = Filesystem.resolve(process.env.PWD ?? process.cwd())
     const directory = (() => {
-      if (!args.dir) return args.attach ? undefined : root
+      if (!args.dir) return undefined
       if (args.attach) return args.dir
-
       try {
-        process.chdir(path.isAbsolute(args.dir) ? args.dir : path.join(root, args.dir))
+        process.chdir(args.dir)
         return process.cwd()
       } catch {
         UI.error("Failed to change directory to " + args.dir)
         process.exit(1)
       }
     })()
-    const attachHeaders = (() => {
-      if (!args.attach) return undefined
-      const password = args.password ?? process.env.OPENCODE_SERVER_PASSWORD
-      if (!password) return undefined
-      const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
-      const auth = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-      return { Authorization: auth }
-    })()
-    const attachSDK = (dir?: string) => {
-      return createOpencodeClient({
-        baseUrl: args.attach!,
-        directory: dir,
-        headers: attachHeaders,
-      })
-    }
 
-    const files: FilePart[] = []
+    const files: { type: "file"; url: string; filename: string; mime: string }[] = []
     if (args.file) {
       const list = Array.isArray(args.file) ? args.file : [args.file]
 
       for (const filePath of list) {
-        const resolvedPath = path.resolve(args.attach ? root : (directory ?? root), filePath)
+        const resolvedPath = path.resolve(process.cwd(), filePath)
         if (!(await Filesystem.exists(resolvedPath))) {
           UI.error(`File not found: ${filePath}`)
           process.exit(1)
@@ -281,7 +349,7 @@ export const RunCommand = cmd({
 
     if (!process.stdin.isTTY) message += "\n" + (await Bun.stdin.text())
 
-    if (message.trim().length === 0 && !args.command && !args.interactive) {
+    if (message.trim().length === 0 && !args.command) {
       UI.error("You must provide a message or a command")
       process.exit(1)
     }
@@ -291,25 +359,23 @@ export const RunCommand = cmd({
       process.exit(1)
     }
 
-    const rules: Permission.Ruleset = args.interactive
-      ? []
-      : [
-          {
-            permission: "question",
-            action: "deny",
-            pattern: "*",
-          },
-          {
-            permission: "plan_enter",
-            action: "deny",
-            pattern: "*",
-          },
-          {
-            permission: "plan_exit",
-            action: "deny",
-            pattern: "*",
-          },
-        ]
+    const rules: Permission.Ruleset = [
+      {
+        permission: "question",
+        action: "deny",
+        pattern: "*",
+      },
+      {
+        permission: "plan_enter",
+        action: "deny",
+        pattern: "*",
+      },
+      {
+        permission: "plan_exit",
+        action: "deny",
+        pattern: "*",
+      },
+    ]
 
     function title() {
       if (args.title === undefined) return
@@ -317,83 +383,19 @@ export const RunCommand = cmd({
       return message.slice(0, 50) + (message.length > 50 ? "..." : "")
     }
 
-    async function session(sdk: OpencodeClient): Promise<SessionInfo | undefined> {
-      if (args.session) {
-        const current = await sdk.session
-          .get({
-            sessionID: args.session,
-          })
-          .catch(() => undefined)
+    async function session(sdk: OpencodeClient) {
+      const baseID = args.continue ? (await sdk.session.list()).data?.find((s) => !s.parentID)?.id : args.session
 
-        if (!current?.data) {
-          UI.error("Session not found")
-          process.exit(1)
-        }
-
-        if (args.fork) {
-          const forked = await sdk.session.fork({
-            sessionID: args.session,
-          })
-          const id = forked.data?.id
-          if (!id) {
-            return
-          }
-
-          return {
-            id,
-            title: forked.data?.title ?? current.data.title,
-            directory: forked.data?.directory ?? current.data.directory,
-          }
-        }
-
-        return {
-          id: current.data.id,
-          title: current.data.title,
-          directory: current.data.directory,
-        }
+      if (baseID && args.fork) {
+        const forked = await sdk.session.fork({ sessionID: baseID })
+        return forked.data?.id
       }
 
-      const base = args.continue ? (await sdk.session.list()).data?.find((item) => !item.parentID) : undefined
-
-      if (base && args.fork) {
-        const forked = await sdk.session.fork({
-          sessionID: base.id,
-        })
-        const id = forked.data?.id
-        if (!id) {
-          return
-        }
-
-        return {
-          id,
-          title: forked.data?.title ?? base.title,
-          directory: forked.data?.directory ?? base.directory,
-        }
-      }
-
-      if (base) {
-        return {
-          id: base.id,
-          title: base.title,
-          directory: base.directory,
-        }
-      }
+      if (baseID) return baseID
 
       const name = title()
-      const result = await sdk.session.create({
-        title: name,
-        permission: rules,
-      })
-      const id = result.data?.id
-      if (!id) {
-        return
-      }
-
-      return {
-        id,
-        title: result.data?.title ?? name,
-        directory: result.data?.directory,
-      }
+      const result = await sdk.session.create({ title: name, permission: rules })
+      return result.data?.id
     }
 
     async function share(sdk: OpencodeClient, sessionID: string) {
@@ -411,122 +413,45 @@ export const RunCommand = cmd({
       }
     }
 
-    async function current(sdk: OpencodeClient): Promise<string> {
-      if (!args.attach) {
-        return directory ?? root
-      }
-
-      const next = await sdk.path
-        .get()
-        .then((x) => x.data?.directory)
-        .catch(() => undefined)
-      if (next) {
-        return next
-      }
-
-      UI.error("Failed to resolve remote directory")
-      process.exit(1)
-    }
-
-    async function localAgent() {
-      if (!args.agent) return undefined
-
-      const entry = await (await import("../../agent/agent")).Agent.get(args.agent)
-      if (!entry) {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL,
-          `agent "${args.agent}" not found. Falling back to default agent`,
-        )
-        return undefined
-      }
-      if (entry.mode === "subagent") {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL,
-          `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`,
-        )
-        return undefined
-      }
-      return args.agent
-    }
-
-    async function attachAgent(sdk: OpencodeClient) {
-      if (!args.agent) return undefined
-
-      const modes = await sdk.app
-        .agents(undefined, { throwOnError: true })
-        .then((x) => x.data ?? [])
-        .catch(() => undefined)
-
-      if (!modes) {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL,
-          `failed to list agents from ${args.attach}. Falling back to default agent`,
-        )
-        return undefined
-      }
-
-      const agent = modes.find((a) => a.name === args.agent)
-      if (!agent) {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL,
-          `agent "${args.agent}" not found. Falling back to default agent`,
-        )
-        return undefined
-      }
-
-      if (agent.mode === "subagent") {
-        UI.println(
-          UI.Style.TEXT_WARNING_BOLD + "!",
-          UI.Style.TEXT_NORMAL,
-          `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`,
-        )
-        return undefined
-      }
-
-      return args.agent
-    }
-
-    async function pickAgent(sdk: OpencodeClient) {
-      if (!args.agent) return undefined
-      if (args.attach) {
-        return attachAgent(sdk)
-      }
-
-      return localAgent()
-    }
-
     async function execute(sdk: OpencodeClient) {
+      function tool(part: ToolPart) {
+        try {
+          if (part.tool === "bash") return bash(props<typeof BashTool>(part))
+          if (part.tool === "glob") return glob(props<typeof GlobTool>(part))
+          if (part.tool === "grep") return grep(props<typeof GrepTool>(part))
+          if (part.tool === "list") return list(props<typeof ListTool>(part))
+          if (part.tool === "read") return read(props<typeof ReadTool>(part))
+          if (part.tool === "write") return write(props<typeof WriteTool>(part))
+          if (part.tool === "webfetch") return webfetch(props<typeof WebFetchTool>(part))
+          if (part.tool === "edit") return edit(props<typeof EditTool>(part))
+          if (part.tool === "codesearch") return codesearch(props<typeof CodeSearchTool>(part))
+          if (part.tool === "websearch") return websearch(props<typeof WebSearchTool>(part))
+          if (part.tool === "task") return task(props<typeof TaskTool>(part))
+          if (part.tool === "todowrite") return todo(props<typeof TodoWriteTool>(part))
+          if (part.tool === "skill") return skill(props<typeof SkillTool>(part))
+          return fallback(part)
+        } catch {
+          return fallback(part)
+        }
+      }
+
       function emit(type: string, data: Record<string, unknown>) {
         if (args.format === "json") {
-          process.stdout.write(
-            JSON.stringify({
-              type,
-              timestamp: Date.now(),
-              sessionID,
-              ...data,
-            }) + EOL,
-          )
+          process.stdout.write(JSON.stringify({ type, timestamp: Date.now(), sessionID, ...data }) + EOL)
           return true
         }
         return false
       }
 
-      // Consume one subscribed event stream for the active session and mirror it
-      // to stdout/UI. `client` is passed explicitly because attach mode may
-      // rebind the SDK to the session's directory after the subscription is
-      // created, and replies issued from inside the loop must use that client.
-      async function loop(client: OpencodeClient, events: Awaited<ReturnType<typeof sdk.event.subscribe>>) {
+      const events = await sdk.event.subscribe()
+      let error: string | undefined
+
+      async function loop() {
         const toggles = new Map<string, boolean>()
-        let error: string | undefined
 
         for await (const event of events.stream) {
           if (
             event.type === "message.updated" &&
-            event.properties.sessionID === sessionID &&
             event.properties.info.role === "assistant" &&
             args.format !== "json" &&
             toggles.get("start") !== true
@@ -544,7 +469,7 @@ export const RunCommand = cmd({
             if (part.type === "tool" && (part.state.status === "completed" || part.state.status === "error")) {
               if (emit("tool_use", { part })) continue
               if (part.state.status === "completed") {
-                await tool(part)
+                tool(part)
                 continue
               }
               inline({
@@ -561,7 +486,7 @@ export const RunCommand = cmd({
               args.format !== "json"
             ) {
               if (toggles.get(part.id) === true) continue
-              await tool(part)
+              task(props<typeof TaskTool>(part))
               toggles.set(part.id, true)
             }
 
@@ -626,7 +551,7 @@ export const RunCommand = cmd({
             if (permission.sessionID !== sessionID) continue
 
             if (args["dangerously-skip-permissions"]) {
-              await client.permission.reply({
+              await sdk.permission.reply({
                 requestID: permission.id,
                 reply: "once",
               })
@@ -636,7 +561,7 @@ export const RunCommand = cmd({
                 UI.Style.TEXT_NORMAL +
                   `permission requested: ${permission.permission} (${permission.patterns.join(", ")}); auto-rejecting`,
               )
-              await client.permission.reply({
+              await sdk.permission.reply({
                 requestID: permission.id,
                 reply: "reject",
               })
@@ -645,112 +570,119 @@ export const RunCommand = cmd({
         }
       }
 
-      const sess = await session(sdk)
-      if (!sess?.id) {
+      // Validate agent if specified
+      const agent = await (async () => {
+        if (!args.agent) return undefined
+
+        // When attaching, validate against the running server instead of local Instance state.
+        if (args.attach) {
+          const modes = await sdk.app
+            .agents(undefined, { throwOnError: true })
+            .then((x) => x.data ?? [])
+            .catch(() => undefined)
+
+          if (!modes) {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `failed to list agents from ${args.attach}. Falling back to default agent`,
+            )
+            return undefined
+          }
+
+          const agent = modes.find((a) => a.name === args.agent)
+          if (!agent) {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `agent "${args.agent}" not found. Falling back to default agent`,
+            )
+            return undefined
+          }
+
+          if (agent.mode === "subagent") {
+            UI.println(
+              UI.Style.TEXT_WARNING_BOLD + "!",
+              UI.Style.TEXT_NORMAL,
+              `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`,
+            )
+            return undefined
+          }
+
+          return args.agent
+        }
+
+        const entry = await Agent.get(args.agent)
+        if (!entry) {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" not found. Falling back to default agent`,
+          )
+          return undefined
+        }
+        if (entry.mode === "subagent") {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`,
+          )
+          return undefined
+        }
+        return args.agent
+      })()
+
+      const sessionID = await session(sdk)
+      if (!sessionID) {
         UI.error("Session not found")
         process.exit(1)
       }
-      const cwd = args.attach ? (directory ?? sess.directory ?? (await current(sdk))) : (directory ?? root)
-      const client = args.attach ? attachSDK(cwd) : sdk
+      await share(sdk, sessionID)
 
-      // Validate agent if specified
-      const agent = await pickAgent(client)
+      loop().catch((e) => {
+        console.error(e)
+        process.exit(1)
+      })
 
-      const sessionID = sess.id
-      await share(client, sessionID)
-
-      if (!args.interactive) {
-        const events = await client.event.subscribe()
-        loop(client, events).catch((e) => {
-          console.error(e)
-          process.exit(1)
+      if (args.command) {
+        await sdk.session.command({
+          sessionID,
+          agent,
+          model: args.model,
+          command: args.command,
+          arguments: message,
+          variant: args.variant,
         })
-
-        if (args.command) {
-          await client.session.command({
-            sessionID,
-            agent,
-            model: args.model,
-            command: args.command,
-            arguments: message,
-            variant: args.variant,
-          })
-          return
-        }
-
-        const model = pick(args.model)
-        await client.session.prompt({
+      } else {
+        const model = args.model ? Provider.parseModel(args.model) : undefined
+        await sdk.session.prompt({
           sessionID,
           agent,
           model,
           variant: args.variant,
           parts: [...files, { type: "text", text: message }],
         })
-        return
       }
-
-      const model = pick(args.model)
-      const { runInteractiveMode } = await runtimeTask
-      await runInteractiveMode({
-        sdk: client,
-        directory: cwd,
-        sessionID,
-        sessionTitle: sess.title,
-        resume: Boolean(args.session) && !args.fork,
-        agent,
-        model,
-        variant: args.variant,
-        files,
-        initialInput: rawMessage.trim().length > 0 ? rawMessage : undefined,
-        thinking,
-        demo: args.demo as RunDemo | undefined,
-        demoText: args.demoText,
-      })
-      return
-    }
-
-    if (args.interactive && !args.attach && !args.session && !args.continue) {
-      const model = pick(args.model)
-      const { runInteractiveLocalMode } = await runtimeTask
-      const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
-        const { Server } = await import("../../server/server")
-        const request = new Request(input, init)
-        return Server.Default().app.fetch(request)
-      }) as typeof globalThis.fetch
-
-      return await runInteractiveLocalMode({
-        directory: directory ?? root,
-        fetch: fetchFn,
-        resolveAgent: localAgent,
-        session,
-        share,
-        agent: args.agent,
-        model,
-        variant: args.variant,
-        files,
-        initialInput: rawMessage.trim().length > 0 ? rawMessage : undefined,
-        thinking,
-        demo: args.demo as RunDemo | undefined,
-        demoText: args.demoText,
-      })
     }
 
     if (args.attach) {
-      const sdk = attachSDK(directory)
+      const headers = (() => {
+        const password = args.password ?? process.env.OPENCODE_SERVER_PASSWORD
+        if (!password) return undefined
+        const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
+        const auth = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
+        return { Authorization: auth }
+      })()
+      const sdk = createOpencodeClient({ baseUrl: args.attach, directory, headers })
       return await execute(sdk)
     }
 
-    await bootstrap(directory ?? root, async () => {
+    await bootstrap(process.cwd(), async () => {
       const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
-        const { Server } = await import("../../server/server")
         const request = new Request(input, init)
         return Server.Default().app.fetch(request)
       }) as typeof globalThis.fetch
-      const sdk = createOpencodeClient({
-        baseUrl: "http://opencode.internal",
-        fetch: fetchFn,
-        directory,
-      })
+      const sdk = createOpencodeClient({ baseUrl: "http://opencode.internal", fetch: fetchFn })
       await execute(sdk)
     })
   },

packages/opencode/src/cli/cmd/run/footer.permission.tsx

@@ -1,487 +0,0 @@
-// Permission UI body for the direct-mode footer.
-//
-// Renders inside the footer when the reducer pushes a FooterView of type
-// "permission". Uses a three-stage state machine (permission.shared.ts):
-//
-//   permission → shows the request with Allow once / Always / Reject buttons
-//   always     → confirmation step before granting permanent access
-//   reject     → text field for the rejection message
-//
-// Keyboard: left/right to select, enter to confirm, esc to reject.
-// The diff view (when available) uses the same diff component as scrollback
-// tool snapshots.
-/** @jsxImportSource @opentui/solid */
-import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
-import { For, Match, Show, Switch, createEffect, createMemo, createSignal } from "solid-js"
-import type { PermissionRequest } from "@opencode-ai/sdk/v2"
-import {
-  createPermissionBodyState,
-  permissionAlwaysLines,
-  permissionCancel,
-  permissionEscape,
-  permissionHover,
-  permissionInfo,
-  permissionLabel,
-  permissionOptions,
-  permissionReject,
-  permissionRun,
-  permissionShift,
-  type PermissionOption,
-} from "./permission.shared"
-import { toolDiffView, toolFiletype } from "./tool"
-import { transparent, type RunBlockTheme, type RunFooterTheme } from "./theme"
-import type { PermissionReply, RunDiffStyle } from "./types"
-
-type RejectArea = {
-  isDestroyed: boolean
-  plainText: string
-  cursorOffset: number
-  setText(text: string): void
-  focus(): void
-}
-
-function buttons(
-  list: PermissionOption[],
-  selected: PermissionOption,
-  theme: RunFooterTheme,
-  disabled: boolean,
-  onHover: (option: PermissionOption) => void,
-  onSelect: (option: PermissionOption) => void,
-) {
-  return (
-    <box flexDirection="row" gap={1} flexShrink={0} paddingBottom={1}>
-      <For each={list}>
-        {(option) => (
-          <box
-            paddingLeft={1}
-            paddingRight={1}
-            backgroundColor={option === selected ? theme.highlight : transparent}
-            onMouseOver={() => {
-              if (!disabled) onHover(option)
-            }}
-            onMouseUp={() => {
-              if (!disabled) onSelect(option)
-            }}
-          >
-            <text fg={option === selected ? theme.surface : theme.muted}>{permissionLabel(option)}</text>
-          </box>
-        )}
-      </For>
-    </box>
-  )
-}
-
-function RejectField(props: {
-  theme: RunFooterTheme
-  text: string
-  disabled: boolean
-  onChange: (text: string) => void
-  onConfirm: () => void
-  onCancel: () => void
-}) {
-  let area: RejectArea | undefined
-
-  createEffect(() => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    if (area.plainText !== props.text) {
-      area.setText(props.text)
-      area.cursorOffset = props.text.length
-    }
-
-    queueMicrotask(() => {
-      if (!area || area.isDestroyed || props.disabled) {
-        return
-      }
-      area.focus()
-    })
-  })
-
-  return (
-    <textarea
-      id="run-direct-footer-permission-reject"
-      width="100%"
-      minHeight={1}
-      maxHeight={3}
-      paddingBottom={1}
-      wrapMode="word"
-      placeholder="Tell OpenCode what to do differently"
-      placeholderColor={props.theme.muted}
-      textColor={props.theme.text}
-      focusedTextColor={props.theme.text}
-      backgroundColor={props.theme.surface}
-      focusedBackgroundColor={props.theme.surface}
-      cursorColor={props.theme.text}
-      focused={!props.disabled}
-      onContentChange={() => {
-        if (!area || area.isDestroyed) {
-          return
-        }
-        props.onChange(area.plainText)
-      }}
-      onKeyDown={(event) => {
-        if (event.name === "escape") {
-          event.preventDefault()
-          props.onCancel()
-          return
-        }
-
-        if (event.name === "return" && !event.meta && !event.ctrl && !event.shift) {
-          event.preventDefault()
-          props.onConfirm()
-        }
-      }}
-      ref={(item) => {
-        area = item as RejectArea
-      }}
-    />
-  )
-}
-
-export function RunPermissionBody(props: {
-  request: PermissionRequest
-  theme: RunFooterTheme
-  block: RunBlockTheme
-  diffStyle?: RunDiffStyle
-  onReply: (input: PermissionReply) => void | Promise<void>
-}) {
-  const dims = useTerminalDimensions()
-  const [state, setState] = createSignal(createPermissionBodyState(props.request.id))
-  const info = createMemo(() => permissionInfo(props.request))
-  const ft = createMemo(() => toolFiletype(info().file))
-  const view = createMemo(() => toolDiffView(dims().width, props.diffStyle))
-  const narrow = createMemo(() => dims().width < 80)
-  const opts = createMemo(() => permissionOptions(state().stage))
-  const busy = createMemo(() => state().submitting)
-  const title = createMemo(() => {
-    if (state().stage === "always") {
-      return "Always allow"
-    }
-
-    if (state().stage === "reject") {
-      return "Reject permission"
-    }
-
-    return "Permission required"
-  })
-
-  createEffect(() => {
-    const id = props.request.id
-    if (state().requestID === id) {
-      return
-    }
-
-    setState(createPermissionBodyState(id))
-  })
-
-  const shift = (dir: -1 | 1) => {
-    setState((prev) => permissionShift(prev, dir))
-  }
-
-  const submit = async (next: PermissionReply) => {
-    setState((prev) => ({
-      ...prev,
-      submitting: true,
-    }))
-
-    try {
-      await props.onReply(next)
-    } catch {
-      setState((prev) => ({
-        ...prev,
-        submitting: false,
-      }))
-    }
-  }
-
-  const run = (option: PermissionOption) => {
-    const cur = state()
-    const next = permissionRun(cur, props.request.id, option)
-    if (next.state !== cur) {
-      setState(next.state)
-    }
-
-    if (!next.reply) {
-      return
-    }
-
-    void submit(next.reply)
-  }
-
-  const reject = () => {
-    const next = permissionReject(state(), props.request.id)
-    if (!next) {
-      return
-    }
-
-    void submit(next)
-  }
-
-  const cancelReject = () => {
-    setState((prev) => permissionCancel(prev))
-  }
-
-  useKeyboard((event) => {
-    const cur = state()
-    if (cur.stage === "reject") {
-      return
-    }
-
-    if (cur.submitting) {
-      if (["left", "right", "h", "l", "tab", "return", "escape"].includes(event.name)) {
-        event.preventDefault()
-      }
-      return
-    }
-
-    if (event.name === "tab") {
-      shift(event.shift ? -1 : 1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "left" || event.name === "h") {
-      shift(-1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "right" || event.name === "l") {
-      shift(1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "return") {
-      run(state().selected)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name !== "escape") {
-      return
-    }
-
-    setState((prev) => permissionEscape(prev))
-    event.preventDefault()
-  })
-
-  return (
-    <box id="run-direct-footer-permission-body" width="100%" height="100%" flexDirection="column">
-      <box
-        id="run-direct-footer-permission-head"
-        flexDirection="column"
-        gap={1}
-        paddingLeft={1}
-        paddingRight={2}
-        paddingTop={1}
-        paddingBottom={1}
-        flexShrink={0}
-      >
-        <box flexDirection="row" gap={1} paddingLeft={1}>
-          <text fg={state().stage === "reject" ? props.theme.error : props.theme.warning}>△</text>
-          <text fg={props.theme.text}>{title()}</text>
-        </box>
-        <Switch>
-          <Match when={state().stage === "permission"}>
-            <box flexDirection="row" gap={1} paddingLeft={2}>
-              <text fg={props.theme.muted} flexShrink={0}>
-                {info().icon}
-              </text>
-              <text fg={props.theme.text} wrapMode="word">
-                {info().title}
-              </text>
-            </box>
-          </Match>
-          <Match when={state().stage === "reject"}>
-            <box paddingLeft={1}>
-              <text fg={props.theme.muted}>Tell OpenCode what to do differently</text>
-            </box>
-          </Match>
-        </Switch>
-      </box>
-
-      <Show
-        when={state().stage !== "reject"}
-        fallback={
-          <box width="100%" flexGrow={1} flexShrink={1} justifyContent="flex-end">
-            <box
-              id="run-direct-footer-permission-reject-bar"
-              flexDirection={narrow() ? "column" : "row"}
-              flexShrink={0}
-              backgroundColor={props.theme.line}
-              paddingTop={1}
-              paddingLeft={2}
-              paddingRight={3}
-              paddingBottom={1}
-              justifyContent={narrow() ? "flex-start" : "space-between"}
-              alignItems={narrow() ? "flex-start" : "center"}
-              gap={1}
-            >
-              <box width={narrow() ? "100%" : undefined} flexGrow={1} flexShrink={1}>
-                <RejectField
-                  theme={props.theme}
-                  text={state().message}
-                  disabled={busy()}
-                  onChange={(text) => {
-                    setState((prev) => ({
-                      ...prev,
-                      message: text,
-                    }))
-                  }}
-                  onConfirm={reject}
-                  onCancel={cancelReject}
-                />
-              </box>
-              <Show
-                when={!busy()}
-                fallback={
-                  <text fg={props.theme.muted} wrapMode="word" flexShrink={0}>
-                    Waiting for permission event...
-                  </text>
-                }
-              >
-                <box flexDirection="row" gap={2} flexShrink={0} paddingBottom={1}>
-                  <text fg={props.theme.text}>
-                    enter <span style={{ fg: props.theme.muted }}>confirm</span>
-                  </text>
-                  <text fg={props.theme.text}>
-                    esc <span style={{ fg: props.theme.muted }}>cancel</span>
-                  </text>
-                </box>
-              </Show>
-            </box>
-          </box>
-        }
-      >
-        <box width="100%" flexGrow={1} flexShrink={1} paddingLeft={1} paddingRight={3} paddingBottom={1}>
-          <Switch>
-            <Match when={state().stage === "permission"}>
-              <scrollbox
-                width="100%"
-                height="100%"
-                verticalScrollbarOptions={{
-                  trackOptions: {
-                    backgroundColor: props.theme.surface,
-                    foregroundColor: props.theme.line,
-                  },
-                }}
-              >
-                <box width="100%" flexDirection="column" gap={1}>
-                  <Show
-                    when={info().diff}
-                    fallback={
-                      <box width="100%" flexDirection="column" gap={1} paddingLeft={1}>
-                        <For each={info().lines}>
-                          {(line) => (
-                            <text fg={props.theme.text} wrapMode="word">
-                              {line}
-                            </text>
-                          )}
-                        </For>
-                      </box>
-                    }
-                  >
-                    <diff
-                      diff={info().diff!}
-                      view={view()}
-                      filetype={ft()}
-                      syntaxStyle={props.block.syntax}
-                      showLineNumbers={true}
-                      width="100%"
-                      wrapMode="word"
-                      fg={props.theme.text}
-                      addedBg={props.block.diffAddedBg}
-                      removedBg={props.block.diffRemovedBg}
-                      contextBg={props.block.diffContextBg}
-                      addedSignColor={props.block.diffHighlightAdded}
-                      removedSignColor={props.block.diffHighlightRemoved}
-                      lineNumberFg={props.block.diffLineNumber}
-                      lineNumberBg={props.block.diffContextBg}
-                      addedLineNumberBg={props.block.diffAddedLineNumberBg}
-                      removedLineNumberBg={props.block.diffRemovedLineNumberBg}
-                    />
-                  </Show>
-                  <Show when={!info().diff && info().lines.length === 0}>
-                    <box paddingLeft={1}>
-                      <text fg={props.theme.muted}>No diff provided</text>
-                    </box>
-                  </Show>
-                </box>
-              </scrollbox>
-            </Match>
-            <Match when={true}>
-              <scrollbox
-                width="100%"
-                height="100%"
-                verticalScrollbarOptions={{
-                  trackOptions: {
-                    backgroundColor: props.theme.surface,
-                    foregroundColor: props.theme.line,
-                  },
-                }}
-              >
-                <box width="100%" flexDirection="column" gap={1} paddingLeft={1}>
-                  <For each={permissionAlwaysLines(props.request)}>
-                    {(line) => (
-                      <text fg={props.theme.text} wrapMode="word">
-                        {line}
-                      </text>
-                    )}
-                  </For>
-                </box>
-              </scrollbox>
-            </Match>
-          </Switch>
-        </box>
-
-        <box
-          id="run-direct-footer-permission-actions"
-          flexDirection={narrow() ? "column" : "row"}
-          flexShrink={0}
-          backgroundColor={props.theme.pane}
-          gap={1}
-          paddingTop={1}
-          paddingLeft={2}
-          paddingRight={3}
-          paddingBottom={1}
-          justifyContent={narrow() ? "flex-start" : "space-between"}
-          alignItems={narrow() ? "flex-start" : "center"}
-        >
-          {buttons(
-            opts(),
-            state().selected,
-            props.theme,
-            busy(),
-            (option) => {
-              setState((prev) => permissionHover(prev, option))
-            },
-            run,
-          )}
-          <Show
-            when={!busy()}
-            fallback={
-              <text fg={props.theme.muted} wrapMode="word" flexShrink={0}>
-                Waiting for permission event...
-              </text>
-            }
-          >
-            <box flexDirection="row" gap={2} flexShrink={0} paddingBottom={1}>
-              <text fg={props.theme.text}>
-                {"⇆"} <span style={{ fg: props.theme.muted }}>select</span>
-              </text>
-              <text fg={props.theme.text}>
-                enter <span style={{ fg: props.theme.muted }}>confirm</span>
-              </text>
-              <text fg={props.theme.text}>
-                esc <span style={{ fg: props.theme.muted }}>{state().stage === "always" ? "cancel" : "reject"}</span>
-              </text>
-            </box>
-          </Show>
-        </box>
-      </Show>
-    </box>
-  )
-}

packages/opencode/src/cli/cmd/run/footer.prompt.tsx

@@ -1,977 +0,0 @@
-// Prompt textarea component and its state machine for direct interactive mode.
-//
-// createPromptState() wires keybinds, history navigation, leader-key sequences,
-// and direct-mode `@` autocomplete for files, subagents, and MCP resources.
-// It produces a PromptState that RunPromptBody renders as an OpenTUI textarea,
-// while RunPromptAutocomplete renders a fixed-height suggestion list below it.
-/** @jsxImportSource @opentui/solid */
-import { pathToFileURL } from "bun"
-import { StyledText, bg, fg, type KeyBinding, type KeyEvent, type TextareaRenderable } from "@opentui/core"
-import { useKeyboard } from "@opentui/solid"
-import fuzzysort from "fuzzysort"
-import path from "path"
-import {
-  Index,
-  Show,
-  createEffect,
-  createMemo,
-  createResource,
-  createSignal,
-  onCleanup,
-  onMount,
-  type Accessor,
-} from "solid-js"
-import { Locale } from "../../../util/locale"
-import {
-  createPromptHistory,
-  isExitCommand,
-  movePromptHistory,
-  promptCycle,
-  promptHit,
-  promptInfo,
-  promptKeys,
-  pushPromptHistory,
-} from "./prompt.shared"
-import type { FooterKeybinds, FooterState, RunAgent, RunPrompt, RunPromptPart, RunResource } from "./types"
-import type { RunFooterTheme } from "./theme"
-
-const LEADER_TIMEOUT_MS = 2000
-const AUTOCOMPLETE_ROWS = 6
-
-const EMPTY_BORDER = {
-  topLeft: "",
-  bottomLeft: "",
-  vertical: "",
-  topRight: "",
-  bottomRight: "",
-  horizontal: " ",
-  bottomT: "",
-  topT: "",
-  cross: "",
-  leftT: "",
-  rightT: "",
-}
-
-export const TEXTAREA_MIN_ROWS = 1
-export const TEXTAREA_MAX_ROWS = 6
-export const PROMPT_MAX_ROWS = TEXTAREA_MAX_ROWS + AUTOCOMPLETE_ROWS - 1
-
-export const HINT_BREAKPOINTS = {
-  send: 50,
-  newline: 66,
-  history: 80,
-  variant: 95,
-}
-
-type Mention = Extract<RunPromptPart, { type: "file" | "agent" }>
-
-type Auto = {
-  display: string
-  value: string
-  part: Mention
-  description?: string
-  directory?: boolean
-}
-
-type PromptInput = {
-  directory: string
-  findFiles: (query: string) => Promise<string[]>
-  agents: Accessor<RunAgent[]>
-  resources: Accessor<RunResource[]>
-  keybinds: FooterKeybinds
-  state: Accessor<FooterState>
-  view: Accessor<string>
-  prompt: Accessor<boolean>
-  width: Accessor<number>
-  theme: Accessor<RunFooterTheme>
-  history?: RunPrompt[]
-  onSubmit: (input: RunPrompt) => boolean | Promise<boolean>
-  onCycle: () => void
-  onInterrupt: () => boolean
-  onExitRequest?: () => boolean
-  onExit: () => void
-  onRows: (rows: number) => void
-  onStatus: (text: string) => void
-}
-
-export type PromptState = {
-  placeholder: Accessor<StyledText | string>
-  bindings: Accessor<KeyBinding[]>
-  visible: Accessor<boolean>
-  options: Accessor<Auto[]>
-  selected: Accessor<number>
-  onSubmit: () => void
-  onKeyDown: (event: KeyEvent) => void
-  onContentChange: () => void
-  bind: (area?: TextareaRenderable) => void
-}
-
-function clamp(rows: number): number {
-  return Math.max(TEXTAREA_MIN_ROWS, Math.min(TEXTAREA_MAX_ROWS, rows))
-}
-
-function clonePrompt(prompt: RunPrompt): RunPrompt {
-  return {
-    text: prompt.text,
-    parts: structuredClone(prompt.parts),
-  }
-}
-
-function removeLineRange(input: string) {
-  const hash = input.lastIndexOf("#")
-  return hash === -1 ? input : input.slice(0, hash)
-}
-
-function extractLineRange(input: string) {
-  const hash = input.lastIndexOf("#")
-  if (hash === -1) {
-    return { base: input }
-  }
-
-  const base = input.slice(0, hash)
-  const line = input.slice(hash + 1)
-  const match = line.match(/^(\d+)(?:-(\d*))?$/)
-  if (!match) {
-    return { base }
-  }
-
-  const start = Number(match[1])
-  const end = match[2] && start < Number(match[2]) ? Number(match[2]) : undefined
-  return { base, line: { start, end } }
-}
-
-export function hintFlags(width: number) {
-  return {
-    send: width >= HINT_BREAKPOINTS.send,
-    newline: width >= HINT_BREAKPOINTS.newline,
-    history: width >= HINT_BREAKPOINTS.history,
-    variant: width >= HINT_BREAKPOINTS.variant,
-  }
-}
-
-export function RunPromptBody(props: {
-  theme: () => RunFooterTheme
-  placeholder: () => StyledText | string
-  bindings: () => KeyBinding[]
-  onSubmit: () => void
-  onKeyDown: (event: KeyEvent) => void
-  onContentChange: () => void
-  bind: (area?: TextareaRenderable) => void
-}) {
-  let area: TextareaRenderable | undefined
-
-  onMount(() => {
-    props.bind(area)
-  })
-
-  onCleanup(() => {
-    props.bind(undefined)
-  })
-
-  return (
-    <box id="run-direct-footer-prompt" width="100%">
-      <box id="run-direct-footer-input-shell" paddingTop={1} paddingLeft={2} paddingRight={2}>
-        <textarea
-          id="run-direct-footer-composer"
-          width="100%"
-          minHeight={TEXTAREA_MIN_ROWS}
-          maxHeight={TEXTAREA_MAX_ROWS}
-          wrapMode="word"
-          placeholder={props.placeholder()}
-          placeholderColor={props.theme().muted}
-          textColor={props.theme().text}
-          focusedTextColor={props.theme().text}
-          backgroundColor={props.theme().surface}
-          focusedBackgroundColor={props.theme().surface}
-          cursorColor={props.theme().text}
-          keyBindings={props.bindings()}
-          onSubmit={props.onSubmit}
-          onKeyDown={props.onKeyDown}
-          onContentChange={props.onContentChange}
-          ref={(next) => {
-            area = next
-          }}
-        />
-      </box>
-    </box>
-  )
-}
-
-export function RunPromptAutocomplete(props: {
-  theme: () => RunFooterTheme
-  options: () => Auto[]
-  selected: () => number
-}) {
-  return (
-    <box
-      id="run-direct-footer-complete"
-      width="100%"
-      height={AUTOCOMPLETE_ROWS}
-      border={["left"]}
-      borderColor={props.theme().border}
-      customBorderChars={{
-        ...EMPTY_BORDER,
-        vertical: "┃",
-      }}
-    >
-      <box
-        id="run-direct-footer-complete-fill"
-        width="100%"
-        height={AUTOCOMPLETE_ROWS}
-        flexDirection="column"
-        backgroundColor={props.theme().pane}
-      >
-        <Index
-          each={props.options()}
-          fallback={
-            <box paddingLeft={1} paddingRight={1}>
-              <text fg={props.theme().muted}>No matching items</text>
-            </box>
-          }
-        >
-          {(item, index) => (
-            <box
-              paddingLeft={1}
-              paddingRight={1}
-              flexDirection="row"
-              gap={1}
-              backgroundColor={index === props.selected() ? props.theme().highlight : undefined}
-            >
-              <text
-                fg={index === props.selected() ? props.theme().surface : props.theme().text}
-                wrapMode="none"
-                truncate
-              >
-                {item().display}
-              </text>
-              <Show when={item().description}>
-                <text
-                  fg={index === props.selected() ? props.theme().surface : props.theme().muted}
-                  wrapMode="none"
-                  truncate
-                >
-                  {item().description}
-                </text>
-              </Show>
-            </box>
-          )}
-        </Index>
-      </box>
-    </box>
-  )
-}
-
-export function createPromptState(input: PromptInput): PromptState {
-  const keys = createMemo(() => promptKeys(input.keybinds))
-  const bindings = createMemo(() => keys().bindings)
-  const placeholder = createMemo(() => {
-    if (!input.state().first) {
-      return ""
-    }
-
-    return new StyledText([
-      bg(input.theme().surface)(fg(input.theme().muted)('Ask anything... "Fix a TODO in the codebase"')),
-    ])
-  })
-
-  let history = createPromptHistory(input.history)
-  let draft: RunPrompt = { text: "", parts: [] }
-  let stash: RunPrompt = { text: "", parts: [] }
-  let area: TextareaRenderable | undefined
-  let leader = false
-  let timeout: NodeJS.Timeout | undefined
-  let tick = false
-  let prev = input.view()
-  let type = 0
-  let parts: Mention[] = []
-  let marks = new Map<number, number>()
-
-  const [visible, setVisible] = createSignal(false)
-  const [at, setAt] = createSignal(0)
-  const [selected, setSelected] = createSignal(0)
-  const [query, setQuery] = createSignal("")
-
-  const width = createMemo(() => Math.max(20, input.width() - 8))
-  const agents = createMemo<Auto[]>(() => {
-    return input
-      .agents()
-      .filter((item) => !item.hidden && item.mode !== "primary")
-      .map((item) => ({
-        display: "@" + item.name,
-        value: item.name,
-        part: {
-          type: "agent",
-          name: item.name,
-          source: {
-            start: 0,
-            end: 0,
-            value: "",
-          },
-        },
-      }))
-  })
-  const resources = createMemo<Auto[]>(() => {
-    return input.resources().map((item) => ({
-      display: Locale.truncateMiddle(`@${item.name} (${item.uri})`, width()),
-      value: item.name,
-      description: item.description,
-      part: {
-        type: "file",
-        mime: item.mimeType ?? "text/plain",
-        filename: item.name,
-        url: item.uri,
-        source: {
-          type: "resource",
-          clientName: item.client,
-          uri: item.uri,
-          text: {
-            start: 0,
-            end: 0,
-            value: "",
-          },
-        },
-      },
-    }))
-  })
-  const [files] = createResource(
-    query,
-    async (value) => {
-      if (!visible()) {
-        return []
-      }
-
-      const next = extractLineRange(value)
-      const list = await input.findFiles(next.base)
-      return list
-        .sort((a, b) => {
-          const dir = Number(b.endsWith("/")) - Number(a.endsWith("/"))
-          if (dir !== 0) {
-            return dir
-          }
-
-          const depth = a.split("/").length - b.split("/").length
-          if (depth !== 0) {
-            return depth
-          }
-
-          return a.localeCompare(b)
-        })
-        .map((item): Auto => {
-          const url = pathToFileURL(path.resolve(input.directory, item))
-          let filename = item
-          if (next.line && !item.endsWith("/")) {
-            filename = `${item}#${next.line.start}${next.line.end ? `-${next.line.end}` : ""}`
-            url.searchParams.set("start", String(next.line.start))
-            if (next.line.end !== undefined) {
-              url.searchParams.set("end", String(next.line.end))
-            }
-          }
-
-          return {
-            display: Locale.truncateMiddle("@" + filename, width()),
-            value: filename,
-            directory: item.endsWith("/"),
-            part: {
-              type: "file",
-              mime: item.endsWith("/") ? "application/x-directory" : "text/plain",
-              filename,
-              url: url.href,
-              source: {
-                type: "file",
-                path: item,
-                text: {
-                  start: 0,
-                  end: 0,
-                  value: "",
-                },
-              },
-            },
-          }
-        })
-    },
-    { initialValue: [] as Auto[] },
-  )
-  const options = createMemo(() => {
-    const mixed = [...agents(), ...files(), ...resources()]
-    if (!query()) {
-      return mixed.slice(0, AUTOCOMPLETE_ROWS)
-    }
-
-    return fuzzysort
-      .go(removeLineRange(query()), mixed, {
-        keys: [(item) => (item.value || item.display).trimEnd(), "description"],
-        limit: AUTOCOMPLETE_ROWS,
-      })
-      .map((item) => item.obj)
-  })
-  const popup = createMemo(() => {
-    return visible() ? AUTOCOMPLETE_ROWS - 1 : 0
-  })
-
-  const clear = () => {
-    leader = false
-    if (!timeout) {
-      return
-    }
-
-    clearTimeout(timeout)
-    timeout = undefined
-  }
-
-  const arm = () => {
-    clear()
-    leader = true
-    timeout = setTimeout(() => {
-      clear()
-    }, LEADER_TIMEOUT_MS)
-  }
-
-  const hide = () => {
-    setVisible(false)
-    setQuery("")
-    setSelected(0)
-  }
-
-  const syncRows = () => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    input.onRows(clamp(area.virtualLineCount || 1) + popup())
-  }
-
-  const scheduleRows = () => {
-    if (tick) {
-      return
-    }
-
-    tick = true
-    queueMicrotask(() => {
-      tick = false
-      syncRows()
-    })
-  }
-
-  const syncParts = () => {
-    if (!area || area.isDestroyed || type === 0) {
-      return
-    }
-
-    const next: Mention[] = []
-    const map = new Map<number, number>()
-    for (const item of area.extmarks.getAllForTypeId(type)) {
-      const idx = marks.get(item.id)
-      if (idx === undefined) {
-        continue
-      }
-
-      const part = parts[idx]
-      if (!part) {
-        continue
-      }
-
-      const text = area.plainText.slice(item.start, item.end)
-      const prev =
-        part.type === "agent"
-          ? (part.source?.value ?? "@" + part.name)
-          : (part.source?.text.value ?? "@" + (part.filename ?? ""))
-      if (text !== prev) {
-        continue
-      }
-
-      const copy = structuredClone(part)
-      if (copy.type === "agent") {
-        copy.source = {
-          start: item.start,
-          end: item.end,
-          value: text,
-        }
-      }
-      if (copy.type === "file" && copy.source?.text) {
-        copy.source.text.start = item.start
-        copy.source.text.end = item.end
-        copy.source.text.value = text
-      }
-
-      map.set(item.id, next.length)
-      next.push(copy)
-    }
-
-    const stale = map.size !== marks.size
-    parts = next
-    marks = map
-    if (stale) {
-      restoreParts(next)
-    }
-  }
-
-  const clearParts = () => {
-    if (area && !area.isDestroyed) {
-      area.extmarks.clear()
-    }
-    parts = []
-    marks = new Map()
-  }
-
-  const restoreParts = (value: RunPromptPart[]) => {
-    clearParts()
-    parts = value
-      .filter((item): item is Mention => item.type === "file" || item.type === "agent")
-      .map((item) => structuredClone(item))
-    if (!area || area.isDestroyed || type === 0) {
-      return
-    }
-
-    const box = area
-    parts.forEach((item, idx) => {
-      const start = item.type === "agent" ? item.source?.start : item.source?.text.start
-      const end = item.type === "agent" ? item.source?.end : item.source?.text.end
-      if (start === undefined || end === undefined) {
-        return
-      }
-
-      const id = box.extmarks.create({
-        start,
-        end,
-        virtual: true,
-        typeId: type,
-      })
-      marks.set(id, idx)
-    })
-  }
-
-  const restore = (value: RunPrompt, cursor = value.text.length) => {
-    draft = clonePrompt(value)
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    hide()
-    area.setText(value.text)
-    restoreParts(value.parts)
-    area.cursorOffset = Math.min(cursor, area.plainText.length)
-    scheduleRows()
-    area.focus()
-  }
-
-  const refresh = () => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    const cursor = area.cursorOffset
-    const text = area.plainText
-    if (visible()) {
-      if (cursor <= at() || /\s/.test(text.slice(at(), cursor))) {
-        hide()
-        return
-      }
-
-      setQuery(text.slice(at() + 1, cursor))
-      return
-    }
-
-    if (cursor === 0) {
-      return
-    }
-
-    const head = text.slice(0, cursor)
-    const idx = head.lastIndexOf("@")
-    if (idx === -1) {
-      return
-    }
-
-    const before = idx === 0 ? undefined : head[idx - 1]
-    const tail = head.slice(idx)
-    if ((before === undefined || /\s/.test(before)) && !/\s/.test(tail)) {
-      setAt(idx)
-      setSelected(0)
-      setVisible(true)
-      setQuery(head.slice(idx + 1))
-    }
-  }
-
-  const bind = (next?: TextareaRenderable) => {
-    if (area === next) {
-      return
-    }
-
-    if (area && !area.isDestroyed) {
-      area.off("line-info-change", scheduleRows)
-    }
-
-    area = next
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    if (type === 0) {
-      type = area.extmarks.registerType("run-direct-prompt-part")
-    }
-    area.on("line-info-change", scheduleRows)
-    queueMicrotask(() => {
-      if (!area || area.isDestroyed || !input.prompt()) {
-        return
-      }
-
-      restore(draft)
-      refresh()
-    })
-  }
-
-  const syncDraft = () => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    syncParts()
-    draft = {
-      text: area.plainText,
-      parts: structuredClone(parts),
-    }
-  }
-
-  const push = (value: RunPrompt) => {
-    history = pushPromptHistory(history, value)
-  }
-
-  const move = (dir: -1 | 1, event: KeyEvent) => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    if (history.index === null && dir === -1) {
-      stash = clonePrompt(draft)
-    }
-
-    const next = movePromptHistory(history, dir, area.plainText, area.cursorOffset)
-    if (!next.apply || next.text === undefined || next.cursor === undefined) {
-      return
-    }
-
-    history = next.state
-    const value =
-      next.state.index === null ? stash : (next.state.items[next.state.index] ?? { text: next.text, parts: [] })
-    restore(value, next.cursor)
-    event.preventDefault()
-  }
-
-  const cycle = (event: KeyEvent): boolean => {
-    const next = promptCycle(leader, promptInfo(event), keys().leaders, keys().cycles)
-    if (!next.consume) {
-      return false
-    }
-
-    if (next.clear) {
-      clear()
-    }
-
-    if (next.arm) {
-      arm()
-    }
-
-    if (next.cycle) {
-      input.onCycle()
-    }
-
-    event.preventDefault()
-    return true
-  }
-
-  const select = (item?: Auto) => {
-    const next = item ?? options()[selected()]
-    if (!next || !area || area.isDestroyed) {
-      return
-    }
-
-    const cursor = area.cursorOffset
-    const tail = area.plainText.at(cursor)
-    const append = "@" + next.value + (tail === " " ? "" : " ")
-    area.cursorOffset = at()
-    const start = area.logicalCursor
-    area.cursorOffset = cursor
-    const end = area.logicalCursor
-    area.deleteRange(start.row, start.col, end.row, end.col)
-    area.insertText(append)
-
-    const text = "@" + next.value
-    const startOffset = at()
-    const endOffset = startOffset + Bun.stringWidth(text)
-    const part = structuredClone(next.part)
-    if (part.type === "agent") {
-      part.source = {
-        start: startOffset,
-        end: endOffset,
-        value: text,
-      }
-    }
-    if (part.type === "file" && part.source?.text) {
-      part.source.text.start = startOffset
-      part.source.text.end = endOffset
-      part.source.text.value = text
-    }
-
-    if (part.type === "file") {
-      const prev = parts.findIndex((item) => item.type === "file" && item.url === part.url)
-      if (prev !== -1) {
-        const mark = [...marks.entries()].find((item) => item[1] === prev)?.[0]
-        if (mark !== undefined) {
-          area.extmarks.delete(mark)
-        }
-        parts = parts.filter((_, idx) => idx !== prev)
-        marks = new Map(
-          [...marks.entries()]
-            .filter((item) => item[0] !== mark)
-            .map((item) => [item[0], item[1] > prev ? item[1] - 1 : item[1]]),
-        )
-      }
-    }
-
-    const id = area.extmarks.create({
-      start: startOffset,
-      end: endOffset,
-      virtual: true,
-      typeId: type,
-    })
-    marks.set(id, parts.length)
-    parts.push(part)
-    hide()
-    syncDraft()
-    scheduleRows()
-    area.focus()
-  }
-
-  const expand = () => {
-    const next = options()[selected()]
-    if (!next?.directory || !area || area.isDestroyed) {
-      return
-    }
-
-    const cursor = area.cursorOffset
-    area.cursorOffset = at()
-    const start = area.logicalCursor
-    area.cursorOffset = cursor
-    const end = area.logicalCursor
-    area.deleteRange(start.row, start.col, end.row, end.col)
-    area.insertText("@" + next.value)
-    syncDraft()
-    refresh()
-  }
-
-  const onKeyDown = (event: KeyEvent) => {
-    if (visible()) {
-      const name = event.name.toLowerCase()
-      const ctrl = event.ctrl && !event.meta && !event.shift
-      if (name === "up" || (ctrl && name === "p")) {
-        event.preventDefault()
-        if (options().length > 0) {
-          setSelected((selected() - 1 + options().length) % options().length)
-        }
-        return
-      }
-
-      if (name === "down" || (ctrl && name === "n")) {
-        event.preventDefault()
-        if (options().length > 0) {
-          setSelected((selected() + 1) % options().length)
-        }
-        return
-      }
-
-      if (name === "escape") {
-        event.preventDefault()
-        hide()
-        return
-      }
-
-      if (name === "return") {
-        event.preventDefault()
-        select()
-        return
-      }
-
-      if (name === "tab") {
-        event.preventDefault()
-        if (options()[selected()]?.directory) {
-          expand()
-          return
-        }
-
-        select()
-        return
-      }
-    }
-
-    if (event.ctrl && event.name === "c") {
-      const handled = input.onExitRequest ? input.onExitRequest() : (input.onExit(), true)
-      if (handled) {
-        event.preventDefault()
-      }
-      return
-    }
-
-    const key = promptInfo(event)
-    if (promptHit(keys().interrupts, key)) {
-      if (input.onInterrupt()) {
-        event.preventDefault()
-        return
-      }
-    }
-
-    if (cycle(event)) {
-      return
-    }
-
-    const up = promptHit(keys().previous, key)
-    const down = promptHit(keys().next, key)
-    if (!up && !down) {
-      return
-    }
-
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    const dir = up ? -1 : 1
-    if ((dir === -1 && area.cursorOffset === 0) || (dir === 1 && area.cursorOffset === area.plainText.length)) {
-      move(dir, event)
-      return
-    }
-
-    if (dir === -1 && area.visualCursor.visualRow === 0) {
-      area.cursorOffset = 0
-    }
-
-    const end =
-      typeof area.height === "number" && Number.isFinite(area.height) && area.height > 0
-        ? area.height - 1
-        : Math.max(0, area.virtualLineCount - 1)
-    if (dir === 1 && area.visualCursor.visualRow === end) {
-      area.cursorOffset = area.plainText.length
-    }
-  }
-
-  useKeyboard((event) => {
-    if (input.prompt()) {
-      return
-    }
-
-    if (event.ctrl && event.name === "c") {
-      const handled = input.onExitRequest ? input.onExitRequest() : (input.onExit(), true)
-      if (handled) {
-        event.preventDefault()
-      }
-    }
-  })
-
-  const onSubmit = () => {
-    if (!area || area.isDestroyed) {
-      return
-    }
-
-    if (visible()) {
-      select()
-      return
-    }
-
-    syncDraft()
-    const next = clonePrompt(draft)
-    if (!next.text.trim()) {
-      input.onStatus(input.state().phase === "running" ? "waiting for current response" : "empty prompt ignored")
-      return
-    }
-
-    if (isExitCommand(next.text)) {
-      input.onExit()
-      return
-    }
-
-    area.setText("")
-    clearParts()
-    hide()
-    draft = { text: "", parts: [] }
-    scheduleRows()
-    area.focus()
-    queueMicrotask(async () => {
-      if (await input.onSubmit(next)) {
-        push(next)
-        return
-      }
-
-      restore(next)
-    })
-  }
-
-  onCleanup(() => {
-    clear()
-    if (area && !area.isDestroyed) {
-      area.off("line-info-change", scheduleRows)
-    }
-  })
-
-  createEffect(() => {
-    input.width()
-    popup()
-    if (input.prompt()) {
-      scheduleRows()
-    }
-  })
-
-  createEffect(() => {
-    query()
-    setSelected(0)
-  })
-
-  createEffect(() => {
-    input.state().phase
-    if (!input.prompt() || !area || area.isDestroyed || input.state().phase !== "idle") {
-      return
-    }
-
-    queueMicrotask(() => {
-      if (!area || area.isDestroyed) {
-        return
-      }
-
-      area.focus()
-    })
-  })
-
-  createEffect(() => {
-    const kind = input.view()
-    if (kind === prev) {
-      return
-    }
-
-    if (prev === "prompt") {
-      syncDraft()
-    }
-
-    clear()
-    hide()
-    prev = kind
-    if (kind !== "prompt") {
-      return
-    }
-
-    queueMicrotask(() => {
-      restore(draft)
-    })
-  })
-
-  return {
-    placeholder,
-    bindings,
-    visible,
-    options,
-    selected,
-    onSubmit,
-    onKeyDown,
-    onContentChange: () => {
-      syncDraft()
-      refresh()
-      scheduleRows()
-    },
-    bind,
-  }
-}

packages/opencode/src/cli/cmd/run/footer.question.tsx

@@ -1,596 +0,0 @@
-// Question UI body for the direct-mode footer.
-//
-// Renders inside the footer when the reducer pushes a FooterView of type
-// "question". Supports single-question and multi-question flows:
-//
-//   Single question: options list with up/down selection, digit shortcuts,
-//   and optional custom text input.
-//
-//   Multi-question: tabbed interface where each question is a tab, plus a
-//   final "Confirm" tab that shows all answers for review. Tab/shift-tab
-//   or left/right to navigate between questions.
-//
-// All state logic lives in question.shared.ts as a pure state machine.
-// This component just renders it and dispatches keyboard events.
-/** @jsxImportSource @opentui/solid */
-import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
-import { For, Show, createEffect, createMemo, createSignal } from "solid-js"
-import type { QuestionRequest } from "@opencode-ai/sdk/v2"
-import {
-  createQuestionBodyState,
-  questionConfirm,
-  questionCustom,
-  questionInfo,
-  questionInput,
-  questionMove,
-  questionOther,
-  questionPicked,
-  questionReject,
-  questionSave,
-  questionSelect,
-  questionSetEditing,
-  questionSetSelected,
-  questionSetSubmitting,
-  questionSetTab,
-  questionSingle,
-  questionStoreCustom,
-  questionSubmit,
-  questionSync,
-  questionTabs,
-  questionTotal,
-} from "./question.shared"
-import type { RunFooterTheme } from "./theme"
-import type { QuestionReject, QuestionReply } from "./types"
-
-type Area = {
-  isDestroyed: boolean
-  plainText: string
-  cursorOffset: number
-  setText(text: string): void
-  focus(): void
-}
-
-export function RunQuestionBody(props: {
-  request: QuestionRequest
-  theme: RunFooterTheme
-  onReply: (input: QuestionReply) => void | Promise<void>
-  onReject: (input: QuestionReject) => void | Promise<void>
-}) {
-  const dims = useTerminalDimensions()
-  const [state, setState] = createSignal(createQuestionBodyState(props.request.id))
-  const single = createMemo(() => questionSingle(props.request))
-  const confirm = createMemo(() => questionConfirm(props.request, state()))
-  const info = createMemo(() => questionInfo(props.request, state()))
-  const input = createMemo(() => questionInput(state()))
-  const other = createMemo(() => questionOther(props.request, state()))
-  const picked = createMemo(() => questionPicked(state()))
-  const disabled = createMemo(() => state().submitting)
-  const narrow = createMemo(() => dims().width < 80)
-  const verb = createMemo(() => {
-    if (confirm()) {
-      return "submit"
-    }
-
-    if (info()?.multiple) {
-      return "toggle"
-    }
-
-    if (single()) {
-      return "submit"
-    }
-
-    return "confirm"
-  })
-  let area: Area | undefined
-
-  createEffect(() => {
-    setState((prev) => questionSync(prev, props.request.id))
-  })
-
-  const setTab = (tab: number) => {
-    setState((prev) => questionSetTab(prev, tab))
-  }
-
-  const move = (dir: -1 | 1) => {
-    setState((prev) => questionMove(prev, props.request, dir))
-  }
-
-  const beginReply = async (input: QuestionReply) => {
-    setState((prev) => questionSetSubmitting(prev, true))
-
-    try {
-      await props.onReply(input)
-    } catch {
-      setState((prev) => questionSetSubmitting(prev, false))
-    }
-  }
-
-  const beginReject = async (input: QuestionReject) => {
-    setState((prev) => questionSetSubmitting(prev, true))
-
-    try {
-      await props.onReject(input)
-    } catch {
-      setState((prev) => questionSetSubmitting(prev, false))
-    }
-  }
-
-  const saveCustom = () => {
-    const cur = state()
-    const next = questionSave(cur, props.request)
-    if (next.state !== cur) {
-      setState(next.state)
-    }
-
-    if (!next.reply) {
-      return
-    }
-
-    void beginReply(next.reply)
-  }
-
-  const choose = (selected: number) => {
-    const base = state()
-    const cur = questionSetSelected(base, selected)
-    const next = questionSelect(cur, props.request)
-    if (next.state !== base) {
-      setState(next.state)
-    }
-
-    if (!next.reply) {
-      return
-    }
-
-    void beginReply(next.reply)
-  }
-
-  const mark = (selected: number) => {
-    setState((prev) => questionSetSelected(prev, selected))
-  }
-
-  const select = () => {
-    const cur = state()
-    const next = questionSelect(cur, props.request)
-    if (next.state !== cur) {
-      setState(next.state)
-    }
-
-    if (!next.reply) {
-      return
-    }
-
-    void beginReply(next.reply)
-  }
-
-  const submit = () => {
-    void beginReply(questionSubmit(props.request, state()))
-  }
-
-  const reject = () => {
-    void beginReject(questionReject(props.request))
-  }
-
-  useKeyboard((event) => {
-    const cur = state()
-    if (cur.submitting) {
-      event.preventDefault()
-      return
-    }
-
-    if (cur.editing) {
-      if (event.name === "escape") {
-        setState((prev) => questionSetEditing(prev, false))
-        event.preventDefault()
-        return
-      }
-
-      if (event.name === "return" && !event.shift && !event.ctrl && !event.meta) {
-        saveCustom()
-        event.preventDefault()
-      }
-      return
-    }
-
-    if (!single() && (event.name === "left" || event.name === "h")) {
-      setTab((cur.tab - 1 + questionTabs(props.request)) % questionTabs(props.request))
-      event.preventDefault()
-      return
-    }
-
-    if (!single() && (event.name === "right" || event.name === "l")) {
-      setTab((cur.tab + 1) % questionTabs(props.request))
-      event.preventDefault()
-      return
-    }
-
-    if (!single() && event.name === "tab") {
-      const dir = event.shift ? -1 : 1
-      setTab((cur.tab + dir + questionTabs(props.request)) % questionTabs(props.request))
-      event.preventDefault()
-      return
-    }
-
-    if (questionConfirm(props.request, cur)) {
-      if (event.name === "return") {
-        submit()
-        event.preventDefault()
-        return
-      }
-
-      if (event.name === "escape") {
-        reject()
-        event.preventDefault()
-      }
-      return
-    }
-
-    const total = questionTotal(props.request, cur)
-    const max = Math.min(total, 9)
-    const digit = Number(event.name)
-    if (!Number.isNaN(digit) && digit >= 1 && digit <= max) {
-      choose(digit - 1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "up" || event.name === "k") {
-      move(-1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "down" || event.name === "j") {
-      move(1)
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "return") {
-      select()
-      event.preventDefault()
-      return
-    }
-
-    if (event.name === "escape") {
-      reject()
-      event.preventDefault()
-    }
-  })
-
-  createEffect(() => {
-    if (!state().editing || !area || area.isDestroyed) {
-      return
-    }
-
-    if (area.plainText !== input()) {
-      area.setText(input())
-      area.cursorOffset = input().length
-    }
-
-    queueMicrotask(() => {
-      if (!area || area.isDestroyed || !state().editing) {
-        return
-      }
-
-      area.focus()
-      area.cursorOffset = area.plainText.length
-    })
-  })
-
-  return (
-    <box id="run-direct-footer-question-body" width="100%" height="100%" flexDirection="column">
-      <box
-        id="run-direct-footer-question-panel"
-        flexDirection="column"
-        gap={1}
-        paddingLeft={1}
-        paddingRight={3}
-        paddingTop={1}
-        marginBottom={1}
-        flexGrow={1}
-        flexShrink={1}
-        backgroundColor={props.theme.surface}
-      >
-        <Show when={!single()}>
-          <box id="run-direct-footer-question-tabs"
-            flexDirection="row"
-            gap={1}
-            paddingLeft={1}
-            flexShrink={0}
-          >
-            <For each={props.request.questions}>
-              {(item, index) => {
-                const active = () => state().tab === index()
-                const answered = () => (state().answers[index()]?.length ?? 0) > 0
-                return (
-                  <box
-                    id={`run-direct-footer-question-tab-${index()}`}
-                    paddingLeft={1}
-                    paddingRight={1}
-                    backgroundColor={active() ? props.theme.highlight : props.theme.surface}
-                    onMouseUp={() => {
-                      if (!disabled()) setTab(index())
-                    }}
-                  >
-                    <text fg={active() ? props.theme.surface : answered() ? props.theme.text : props.theme.muted}>
-                      {item.header}
-                    </text>
-                  </box>
-                )
-              }}
-            </For>
-            <box
-              id="run-direct-footer-question-tab-confirm"
-              paddingLeft={1}
-              paddingRight={1}
-              backgroundColor={confirm() ? props.theme.highlight : props.theme.surface}
-              onMouseUp={() => {
-                if (!disabled()) setTab(props.request.questions.length)
-              }}
-            >
-              <text fg={confirm() ? props.theme.surface : props.theme.muted}>Confirm</text>
-            </box>
-          </box>
-        </Show>
-
-        <Show
-          when={!confirm()}
-          fallback={
-            <box width="100%" flexGrow={1} flexShrink={1} paddingLeft={1}>
-              <scrollbox
-                width="100%"
-                height="100%"
-                verticalScrollbarOptions={{
-                  trackOptions: {
-                    backgroundColor: props.theme.surface,
-                    foregroundColor: props.theme.line,
-                  },
-                }}
-              >
-                <box width="100%" flexDirection="column" gap={1}>
-                  <box paddingLeft={1}>
-                    <text fg={props.theme.text}>Review</text>
-                  </box>
-                  <For each={props.request.questions}>
-                    {(item, index) => {
-                      const value = () => state().answers[index()]?.join(", ") ?? ""
-                      const answered = () => Boolean(value())
-                      return (
-                        <box paddingLeft={1}>
-                          <text wrapMode="word">
-                            <span style={{ fg: props.theme.muted }}>{item.header}:</span>{" "}
-                            <span style={{ fg: answered() ? props.theme.text : props.theme.error }}>
-                              {answered() ? value() : "(not answered)"}
-                            </span>
-                          </text>
-                        </box>
-                      )
-                    }}
-                  </For>
-                </box>
-              </scrollbox>
-            </box>
-          }
-        >
-          <box width="100%" flexGrow={1} flexShrink={1} paddingLeft={1} gap={1}>
-            <box>
-              <text fg={props.theme.text} wrapMode="word">
-                {info()?.question}
-                {info()?.multiple ? " (select all that apply)" : ""}
-              </text>
-            </box>
-
-            <box flexGrow={1} flexShrink={1}>
-              <scrollbox
-                width="100%"
-                height="100%"
-                verticalScrollbarOptions={{
-                  trackOptions: {
-                    backgroundColor: props.theme.surface,
-                    foregroundColor: props.theme.line,
-                  },
-                }}
-              >
-                <box width="100%" flexDirection="column">
-                  <For each={info()?.options ?? []}>
-                    {(item, index) => {
-                      const active = () => state().selected === index()
-                      const hit = () => state().answers[state().tab]?.includes(item.label) ?? false
-                      return (
-                        <box
-                          id={`run-direct-footer-question-option-${index()}`}
-                          flexDirection="column"
-                          gap={0}
-                          onMouseOver={() => {
-                            if (!disabled()) {
-                              mark(index())
-                            }
-                          }}
-                          onMouseDown={() => {
-                            if (!disabled()) {
-                              mark(index())
-                            }
-                          }}
-                          onMouseUp={() => {
-                            if (!disabled()) {
-                              choose(index())
-                            }
-                          }}
-                        >
-                          <box flexDirection="row">
-                            <box backgroundColor={active() ? props.theme.line : undefined} paddingRight={1}>
-                              <text fg={active() ? props.theme.highlight : props.theme.muted}>{`${index() + 1}.`}</text>
-                            </box>
-                            <box backgroundColor={active() ? props.theme.line : undefined}>
-                              <text
-                                fg={active() ? props.theme.highlight : hit() ? props.theme.success : props.theme.text}
-                              >
-                                {info()?.multiple ? `[${hit() ? "✓" : " "}] ${item.label}` : item.label}
-                              </text>
-                            </box>
-                            <Show when={!info()?.multiple}>
-                              <text fg={props.theme.success}>{hit() ? "✓" : ""}</text>
-                            </Show>
-                          </box>
-                          <box paddingLeft={3}>
-                            <text fg={props.theme.muted} wrapMode="word">
-                              {item.description}
-                            </text>
-                          </box>
-                        </box>
-                      )
-                    }}
-                  </For>
-
-                  <Show when={questionCustom(props.request, state())}>
-                    <box
-                      id="run-direct-footer-question-option-custom"
-                      flexDirection="column"
-                      gap={0}
-                      onMouseOver={() => {
-                        if (!disabled()) {
-                          mark(info()?.options.length ?? 0)
-                        }
-                      }}
-                      onMouseDown={() => {
-                        if (!disabled()) {
-                          mark(info()?.options.length ?? 0)
-                        }
-                      }}
-                      onMouseUp={() => {
-                        if (!disabled()) {
-                          choose(info()?.options.length ?? 0)
-                        }
-                      }}
-                    >
-                      <box flexDirection="row">
-                        <box backgroundColor={other() ? props.theme.line : undefined} paddingRight={1}>
-                          <text
-                            fg={other() ? props.theme.highlight : props.theme.muted}
-                          >{`${(info()?.options.length ?? 0) + 1}.`}</text>
-                        </box>
-                        <box backgroundColor={other() ? props.theme.line : undefined}>
-                          <text
-                            fg={other() ? props.theme.highlight : picked() ? props.theme.success : props.theme.text}
-                          >
-                            {info()?.multiple
-                              ? `[${picked() ? "✓" : " "}] Type your own answer`
-                              : "Type your own answer"}
-                          </text>
-                        </box>
-                        <Show when={!info()?.multiple}>
-                          <text fg={props.theme.success}>{picked() ? "✓" : ""}</text>
-                        </Show>
-                      </box>
-                      <Show
-                        when={state().editing}
-                        fallback={
-                          <Show when={input()}>
-                            <box paddingLeft={3}>
-                              <text fg={props.theme.muted} wrapMode="word">
-                                {input()}
-                              </text>
-                            </box>
-                          </Show>
-                        }
-                      >
-                        <box paddingLeft={3}>
-                          <textarea
-                            id="run-direct-footer-question-custom"
-                            width="100%"
-                            minHeight={1}
-                            maxHeight={4}
-                            wrapMode="word"
-                            placeholder="Type your own answer"
-                            placeholderColor={props.theme.muted}
-                            textColor={props.theme.text}
-                            focusedTextColor={props.theme.text}
-                            backgroundColor={props.theme.surface}
-                            focusedBackgroundColor={props.theme.surface}
-                            cursorColor={props.theme.text}
-                            focused={!disabled()}
-                            onContentChange={() => {
-                              if (!area || area.isDestroyed || disabled()) {
-                                return
-                              }
-
-                              const text = area.plainText
-                              setState((prev) => questionStoreCustom(prev, prev.tab, text))
-                            }}
-                            ref={(item) => {
-                              area = item as Area
-                            }}
-                          />
-                        </box>
-                      </Show>
-                    </box>
-                  </Show>
-                </box>
-              </scrollbox>
-            </box>
-          </box>
-        </Show>
-      </box>
-
-      <box
-        id="run-direct-footer-question-actions"
-        flexDirection={narrow() ? "column" : "row"}
-        flexShrink={0}
-        gap={1}
-        paddingLeft={2}
-        paddingRight={3}
-        paddingBottom={1}
-        justifyContent={narrow() ? "flex-start" : "space-between"}
-        alignItems={narrow() ? "flex-start" : "center"}
-      >
-        <Show
-          when={!disabled()}
-          fallback={
-            <text fg={props.theme.muted} wrapMode="word">
-              Waiting for question event...
-            </text>
-          }
-        >
-          <box
-            flexDirection={narrow() ? "column" : "row"}
-            gap={narrow() ? 1 : 2}
-            flexShrink={0}
-            paddingBottom={1}
-            width={narrow() ? "100%" : undefined}
-          >
-            <Show
-              when={!state().editing}
-              fallback={
-                <>
-                  <text fg={props.theme.text}>
-                    enter <span style={{ fg: props.theme.muted }}>save</span>
-                  </text>
-                  <text fg={props.theme.text}>
-                    esc <span style={{ fg: props.theme.muted }}>cancel</span>
-                  </text>
-                </>
-              }
-            >
-              <Show when={!single()}>
-                <text fg={props.theme.text}>
-                  {"⇆"} <span style={{ fg: props.theme.muted }}>tab</span>
-                </text>
-              </Show>
-              <Show when={!confirm()}>
-                <text fg={props.theme.text}>
-                  {"↑↓"} <span style={{ fg: props.theme.muted }}>select</span>
-                </text>
-              </Show>
-              <text fg={props.theme.text}>
-                enter <span style={{ fg: props.theme.muted }}>{verb()}</span>
-              </text>
-              <text fg={props.theme.text}>
-                esc <span style={{ fg: props.theme.muted }}>dismiss</span>
-              </text>
-            </Show>
-          </box>
-        </Show>
-      </box>
-    </box>
-  )
-}

packages/opencode/src/cli/cmd/run/footer.ts

@@ -1,636 +0,0 @@
-// RunFooter -- the mutable control surface for direct interactive mode.
-//
-// In the split-footer architecture, scrollback is immutable (append-only)
-// and the footer is the only region that can repaint. RunFooter owns both
-// sides of that boundary:
-//
-//   Scrollback: append() queues StreamCommit entries and flush() writes them
-//   to the renderer via writeToScrollback(). Commits coalesce in a microtask
-//   queue -- consecutive progress chunks for the same part merge into one
-//   write to avoid excessive scrollback snapshots.
-//
-//   Footer: event() updates the SolidJS signal-backed FooterState, which
-//   drives the reactive footer view (prompt, status, permission, question).
-//   present() swaps the active footer view and resizes the footer region.
-//
-// Lifecycle:
-//   - close() flushes pending commits and notifies listeners (the prompt
-//     queue uses this to know when to stop).
-//   - destroy() does the same plus tears down event listeners and clears
-//     internal state.
-//   - The renderer's DESTROY event triggers destroy() so the footer
-//     doesn't outlive the renderer.
-//
-// Interrupt and exit use a two-press pattern: first press shows a hint,
-// second press within 5 seconds actually fires the action.
-import { CliRenderEvents, type CliRenderer } from "@opentui/core"
-import { render } from "@opentui/solid"
-import { createComponent, createSignal, type Accessor, type Setter } from "solid-js"
-import { PROMPT_MAX_ROWS, TEXTAREA_MIN_ROWS } from "./footer.prompt"
-import { printableBinding } from "./prompt.shared"
-import { RunFooterView } from "./footer.view"
-import { normalizeEntry } from "./scrollback.format"
-import { entryWriter } from "./scrollback"
-import { spacerWriter } from "./scrollback.writer"
-import { toolView } from "./tool"
-import type { RunTheme } from "./theme"
-import type {
-  RunAgent,
-  FooterApi,
-  FooterEvent,
-  FooterKeybinds,
-  FooterPatch,
-  RunPrompt,
-  RunResource,
-  FooterState,
-  FooterView,
-  PermissionReply,
-  QuestionReject,
-  QuestionReply,
-  RunDiffStyle,
-  StreamCommit,
-} from "./types"
-
-type CycleResult = {
-  modelLabel?: string
-  status?: string
-}
-
-type RunFooterOptions = {
-  directory: string
-  findFiles: (query: string) => Promise<string[]>
-  agents: RunAgent[]
-  resources: RunResource[]
-  agentLabel: string
-  modelLabel: string
-  first: boolean
-  history?: RunPrompt[]
-  theme: RunTheme
-  keybinds: FooterKeybinds
-  diffStyle: RunDiffStyle
-  onPermissionReply: (input: PermissionReply) => void | Promise<void>
-  onQuestionReply: (input: QuestionReply) => void | Promise<void>
-  onQuestionReject: (input: QuestionReject) => void | Promise<void>
-  onCycleVariant?: () => CycleResult | void
-  onInterrupt?: () => void
-  onExit?: () => void
-}
-
-const PERMISSION_ROWS = 12
-const QUESTION_ROWS = 14
-
-export class RunFooter implements FooterApi {
-  private closed = false
-  private destroyed = false
-  private prompts = new Set<(input: RunPrompt) => void>()
-  private closes = new Set<() => void>()
-  // Most recent visible scrollback commit.
-  private tail: StreamCommit | undefined
-  // The entry splash is already in scrollback before footer output starts.
-  private wrote = true
-  // Microtask-coalesced commit queue. Flushed on next microtask or on close/destroy.
-  private queue: StreamCommit[] = []
-  private pending = false
-  // Fixed portion of footer height above the textarea.
-  private base: number
-  private rows = TEXTAREA_MIN_ROWS
-  private state: Accessor<FooterState>
-  private setState: Setter<FooterState>
-  private view: Accessor<FooterView>
-  private setView: Setter<FooterView>
-  private interruptTimeout: NodeJS.Timeout | undefined
-  private exitTimeout: NodeJS.Timeout | undefined
-  private interruptHint: string
-
-  constructor(
-    private renderer: CliRenderer,
-    private options: RunFooterOptions,
-  ) {
-    const [state, setState] = createSignal<FooterState>({
-      phase: "idle",
-      status: "",
-      queue: 0,
-      model: options.modelLabel,
-      duration: "",
-      usage: "",
-      first: options.first,
-      interrupt: 0,
-      exit: 0,
-    })
-    this.state = state
-    this.setState = setState
-    const [view, setView] = createSignal<FooterView>({ type: "prompt" })
-    this.view = view
-    this.setView = setView
-    this.base = Math.max(1, renderer.footerHeight - TEXTAREA_MIN_ROWS)
-    this.interruptHint = printableBinding(options.keybinds.interrupt, options.keybinds.leader) || "esc"
-
-    this.renderer.on(CliRenderEvents.DESTROY, this.handleDestroy)
-
-    void render(
-      () =>
-        createComponent(RunFooterView, {
-          directory: options.directory,
-          state: this.state,
-          view: this.view,
-          findFiles: options.findFiles,
-          agents: () => options.agents,
-          resources: () => options.resources,
-          theme: options.theme.footer,
-          block: options.theme.block,
-          diffStyle: options.diffStyle,
-          keybinds: options.keybinds,
-          history: options.history,
-          agent: options.agentLabel,
-          onSubmit: this.handlePrompt,
-          onPermissionReply: this.handlePermissionReply,
-          onQuestionReply: this.handleQuestionReply,
-          onQuestionReject: this.handleQuestionReject,
-          onCycle: this.handleCycle,
-          onInterrupt: this.handleInterrupt,
-          onExitRequest: this.handleExit,
-          onExit: () => this.close(),
-          onRows: this.syncRows,
-          onStatus: this.setStatus,
-        }),
-      this.renderer as unknown as Parameters<typeof render>[1],
-    ).catch(() => {
-      if (!this.destroyed && !this.renderer.isDestroyed) {
-        this.close()
-      }
-    })
-  }
-
-  public get isClosed(): boolean {
-    return this.closed || this.destroyed || this.renderer.isDestroyed
-  }
-
-  public onPrompt(fn: (input: RunPrompt) => void): () => void {
-    this.prompts.add(fn)
-    return () => {
-      this.prompts.delete(fn)
-    }
-  }
-
-  public onClose(fn: () => void): () => void {
-    if (this.isClosed) {
-      fn()
-      return () => {}
-    }
-
-    this.closes.add(fn)
-    return () => {
-      this.closes.delete(fn)
-    }
-  }
-
-  public event(next: FooterEvent): void {
-    if (next.type === "queue") {
-      this.patch({ queue: next.queue })
-      return
-    }
-
-    if (next.type === "first") {
-      this.patch({ first: next.first })
-      return
-    }
-
-    if (next.type === "model") {
-      this.patch({ model: next.model })
-      return
-    }
-
-    if (next.type === "turn.send") {
-      this.patch({
-        phase: "running",
-        status: "sending prompt",
-        queue: next.queue,
-      })
-      return
-    }
-
-    if (next.type === "turn.wait") {
-      this.patch({
-        phase: "running",
-        status: "waiting for assistant",
-      })
-      return
-    }
-
-    if (next.type === "turn.idle") {
-      this.patch({
-        phase: "idle",
-        status: "",
-        queue: next.queue,
-      })
-      return
-    }
-
-    if (next.type === "turn.duration") {
-      this.patch({ duration: next.duration })
-      return
-    }
-
-    if (next.type === "stream.patch") {
-      if (typeof next.patch.status === "string" && next.patch.phase === undefined) {
-        this.patch({ phase: "running", ...next.patch })
-        return
-      }
-
-      this.patch(next.patch)
-      return
-    }
-
-    this.present(next.view)
-  }
-
-  private patch(next: FooterPatch): void {
-    if (this.destroyed || this.renderer.isDestroyed) {
-      return
-    }
-
-    const prev = this.state()
-    const state = {
-      phase: next.phase ?? prev.phase,
-      status: typeof next.status === "string" ? next.status : prev.status,
-      queue: typeof next.queue === "number" ? Math.max(0, next.queue) : prev.queue,
-      model: typeof next.model === "string" ? next.model : prev.model,
-      duration: typeof next.duration === "string" ? next.duration : prev.duration,
-      usage: typeof next.usage === "string" ? next.usage : prev.usage,
-      first: typeof next.first === "boolean" ? next.first : prev.first,
-      interrupt:
-        typeof next.interrupt === "number" && Number.isFinite(next.interrupt)
-          ? Math.max(0, Math.floor(next.interrupt))
-          : prev.interrupt,
-      exit:
-        typeof next.exit === "number" && Number.isFinite(next.exit) ? Math.max(0, Math.floor(next.exit)) : prev.exit,
-    }
-
-    if (state.phase === "idle") {
-      state.interrupt = 0
-    }
-
-    this.setState(state)
-
-    if (prev.phase === "running" && state.phase === "idle") {
-      this.flush()
-    }
-  }
-
-  private present(view: FooterView): void {
-    if (this.destroyed || this.renderer.isDestroyed) {
-      return
-    }
-
-    this.setView(view)
-    this.applyHeight()
-  }
-
-  // Queues a scrollback commit. Consecutive progress chunks for the same
-  // part coalesce by appending text, reducing the number of renderer writes.
-  // Actual flush happens on the next microtask, so a burst of events from
-  // one reducer pass becomes a single scrollback write.
-  public append(commit: StreamCommit): void {
-    if (this.destroyed || this.renderer.isDestroyed) {
-      return
-    }
-
-    if (!normalizeEntry(commit)) {
-      return
-    }
-
-    const last = this.queue.at(-1)
-    if (
-      last &&
-      last.phase === "progress" &&
-      commit.phase === "progress" &&
-      last.kind === commit.kind &&
-      last.source === commit.source &&
-      last.partID === commit.partID &&
-      last.tool === commit.tool
-    ) {
-      last.text += commit.text
-    } else {
-      this.queue.push(commit)
-    }
-
-    if (this.pending) {
-      return
-    }
-
-    this.pending = true
-    queueMicrotask(() => {
-      this.pending = false
-      this.flush()
-    })
-  }
-
-  public idle(): Promise<void> {
-    if (this.destroyed || this.renderer.isDestroyed) {
-      return Promise.resolve()
-    }
-
-    return this.renderer.idle().catch(() => {})
-  }
-
-  public close(): void {
-    if (this.closed) {
-      return
-    }
-
-    this.flush()
-    this.notifyClose()
-  }
-
-  public requestExit(): boolean {
-    return this.handleExit()
-  }
-
-  public destroy(): void {
-    if (this.destroyed) {
-      return
-    }
-
-    this.flush()
-    this.destroyed = true
-    this.notifyClose()
-    this.clearInterruptTimer()
-    this.clearExitTimer()
-    this.renderer.off(CliRenderEvents.DESTROY, this.handleDestroy)
-    this.prompts.clear()
-    this.closes.clear()
-    this.tail = undefined
-    this.wrote = false
-  }
-
-  private notifyClose(): void {
-    if (this.closed) {
-      return
-    }
-
-    this.closed = true
-    for (const fn of [...this.closes]) {
-      fn()
-    }
-  }
-
-  private setStatus = (status: string): void => {
-    this.patch({ status })
-  }
-
-  // Resizes the footer to fit the current view. Permission and question views
-  // get fixed extra rows; the prompt view scales with textarea line count.
-  private applyHeight(): void {
-    const type = this.view().type
-    const height =
-      type === "permission"
-        ? this.base + PERMISSION_ROWS
-        : type === "question"
-          ? this.base + QUESTION_ROWS
-          : Math.max(this.base + TEXTAREA_MIN_ROWS, Math.min(this.base + PROMPT_MAX_ROWS, this.base + this.rows))
-
-    if (height !== this.renderer.footerHeight) {
-      this.renderer.footerHeight = height
-    }
-  }
-
-  private syncRows = (value: number): void => {
-    if (this.destroyed || this.renderer.isDestroyed) {
-      return
-    }
-
-    const rows = Math.max(TEXTAREA_MIN_ROWS, Math.min(PROMPT_MAX_ROWS, value))
-    if (rows === this.rows) {
-      return
-    }
-
-    this.rows = rows
-    if (this.view().type === "prompt") {
-      this.applyHeight()
-    }
-  }
-
-  private handlePrompt = (input: RunPrompt): boolean => {
-    if (this.isClosed) {
-      return false
-    }
-
-    if (this.state().first) {
-      this.patch({ first: false })
-    }
-
-    if (this.prompts.size === 0) {
-      this.patch({ status: "input queue unavailable" })
-      return false
-    }
-
-    for (const fn of [...this.prompts]) {
-      fn(input)
-    }
-
-    return true
-  }
-
-  private handlePermissionReply = async (input: PermissionReply): Promise<void> => {
-    if (this.isClosed) {
-      return
-    }
-
-    await this.options.onPermissionReply(input)
-  }
-
-  private handleQuestionReply = async (input: QuestionReply): Promise<void> => {
-    if (this.isClosed) {
-      return
-    }
-
-    await this.options.onQuestionReply(input)
-  }
-
-  private handleQuestionReject = async (input: QuestionReject): Promise<void> => {
-    if (this.isClosed) {
-      return
-    }
-
-    await this.options.onQuestionReject(input)
-  }
-
-  private handleCycle = (): void => {
-    const result = this.options.onCycleVariant?.()
-    if (!result) {
-      this.patch({ status: "no variants available" })
-      return
-    }
-
-    const patch: FooterPatch = {
-      status: result.status ?? "variant updated",
-    }
-
-    if (result.modelLabel) {
-      patch.model = result.modelLabel
-    }
-
-    this.patch(patch)
-  }
-
-  private clearInterruptTimer(): void {
-    if (!this.interruptTimeout) {
-      return
-    }
-
-    clearTimeout(this.interruptTimeout)
-    this.interruptTimeout = undefined
-  }
-
-  private armInterruptTimer(): void {
-    this.clearInterruptTimer()
-    this.interruptTimeout = setTimeout(() => {
-      this.interruptTimeout = undefined
-      if (this.destroyed || this.renderer.isDestroyed || this.state().phase !== "running") {
-        return
-      }
-
-      this.patch({ interrupt: 0 })
-    }, 5000)
-  }
-
-  private clearExitTimer(): void {
-    if (!this.exitTimeout) {
-      return
-    }
-
-    clearTimeout(this.exitTimeout)
-    this.exitTimeout = undefined
-  }
-
-  private armExitTimer(): void {
-    this.clearExitTimer()
-    this.exitTimeout = setTimeout(() => {
-      this.exitTimeout = undefined
-      if (this.destroyed || this.renderer.isDestroyed || this.isClosed) {
-        return
-      }
-
-      this.patch({ exit: 0 })
-    }, 5000)
-  }
-
-  // Two-press interrupt: first press shows a hint ("esc again to interrupt"),
-  // second press within 5 seconds fires onInterrupt. The timer resets the
-  // counter if the user doesn't follow through.
-  private handleInterrupt = (): boolean => {
-    if (this.isClosed || this.state().phase !== "running") {
-      return false
-    }
-
-    const next = this.state().interrupt + 1
-    this.patch({ interrupt: next })
-
-    if (next < 2) {
-      this.armInterruptTimer()
-      this.patch({ status: `${this.interruptHint} again to interrupt` })
-      return true
-    }
-
-    this.clearInterruptTimer()
-    this.patch({ interrupt: 0, status: "interrupting" })
-    this.options.onInterrupt?.()
-    return true
-  }
-
-  private handleExit = (): boolean => {
-    if (this.isClosed) {
-      return true
-    }
-
-    this.clearInterruptTimer()
-    const next = this.state().exit + 1
-    this.patch({ exit: next, interrupt: 0 })
-
-    if (next < 2) {
-      this.armExitTimer()
-      this.patch({ status: "Press Ctrl-c again to exit" })
-      return true
-    }
-
-    this.clearExitTimer()
-    this.patch({ exit: 0, status: "exiting" })
-    this.close()
-    this.options.onExit?.()
-    return true
-  }
-
-  private handleDestroy = (): void => {
-    if (this.destroyed) {
-      return
-    }
-
-    this.flush()
-    this.destroyed = true
-    this.notifyClose()
-    this.clearInterruptTimer()
-    this.clearExitTimer()
-    this.renderer.off(CliRenderEvents.DESTROY, this.handleDestroy)
-    this.prompts.clear()
-    this.closes.clear()
-    this.tail = undefined
-    this.wrote = false
-  }
-
-  // Drains the commit queue to scrollback. Visible commits start a new block
-  // whenever their block key changes, and new blocks get a single spacer.
-  private flush(): void {
-    if (this.destroyed || this.renderer.isDestroyed || this.queue.length === 0) {
-      this.queue.length = 0
-      return
-    }
-
-    for (const item of this.queue.splice(0)) {
-      const same = sameGroup(this.tail, item)
-      if (this.wrote && !same) {
-        this.renderer.writeToScrollback(spacerWriter())
-      }
-
-      this.renderer.writeToScrollback(entryWriter(item, this.options.theme, { diffStyle: this.options.diffStyle }))
-      this.wrote = true
-      this.tail = item
-    }
-  }
-}
-
-function snap(commit: StreamCommit): boolean {
-  const tool = commit.tool ?? commit.part?.tool
-  return (
-    commit.kind === "tool" &&
-    commit.phase === "final" &&
-    (commit.toolState ?? commit.part?.state.status) === "completed" &&
-    typeof tool === "string" &&
-    Boolean(toolView(tool).snap)
-  )
-}
-
-function groupKey(commit: StreamCommit): string | undefined {
-  if (!commit.partID) {
-    return
-  }
-
-  if (snap(commit)) {
-    return `tool:${commit.partID}:final`
-  }
-
-  return `${commit.kind}:${commit.partID}`
-}
-
-function sameGroup(a: StreamCommit | undefined, b: StreamCommit): boolean {
-  if (!a) {
-    return false
-  }
-
-  const left = groupKey(a)
-  const right = groupKey(b)
-  if (left && right && left === right) {
-    return true
-  }
-
-  return a.kind === "tool" && a.phase === "start" && b.kind === "tool" && b.phase === "start"
-}

packages/opencode/src/cli/cmd/run/footer.view.tsx

@@ -1,335 +0,0 @@
-// Top-level footer layout for direct interactive mode.
-//
-// Renders the footer region as a vertical stack:
-//   1. Spacer row (visual separation from scrollback)
-//   2. Composer frame with left-border accent -- swaps between prompt,
-//      permission, and question bodies via Switch/Match
-//   3. Meta row showing agent name and model label
-//   4. Bottom border + status row (spinner, interrupt hint, duration, usage)
-//
-// All state comes from the parent RunFooter through SolidJS signals.
-// The view itself is stateless except for derived memos.
-/** @jsxImportSource @opentui/solid */
-import { useTerminalDimensions } from "@opentui/solid"
-import { Match, Show, Switch, createMemo } from "solid-js"
-import "opentui-spinner/solid"
-import { createColors, createFrames } from "../tui/ui/spinner"
-import { RunPromptAutocomplete, RunPromptBody, createPromptState, hintFlags } from "./footer.prompt"
-import { RunPermissionBody } from "./footer.permission"
-import { RunQuestionBody } from "./footer.question"
-import { printableBinding } from "./prompt.shared"
-import type {
-  FooterKeybinds,
-  RunAgent,
-  RunPrompt,
-  RunResource,
-  FooterState,
-  FooterView,
-  PermissionReply,
-  QuestionReject,
-  QuestionReply,
-  RunDiffStyle,
-} from "./types"
-import { RUN_THEME_FALLBACK, type RunBlockTheme, type RunFooterTheme } from "./theme"
-
-const EMPTY_BORDER = {
-  topLeft: "",
-  bottomLeft: "",
-  vertical: "",
-  topRight: "",
-  bottomRight: "",
-  horizontal: " ",
-  bottomT: "",
-  topT: "",
-  cross: "",
-  leftT: "",
-  rightT: "",
-}
-
-type RunFooterViewProps = {
-  directory: string
-  findFiles: (query: string) => Promise<string[]>
-  agents: () => RunAgent[]
-  resources: () => RunResource[]
-  state: () => FooterState
-  view?: () => FooterView
-  theme?: RunFooterTheme
-  block?: RunBlockTheme
-  diffStyle?: RunDiffStyle
-  keybinds: FooterKeybinds
-  history?: RunPrompt[]
-  agent: string
-  onSubmit: (input: RunPrompt) => boolean
-  onPermissionReply: (input: PermissionReply) => void | Promise<void>
-  onQuestionReply: (input: QuestionReply) => void | Promise<void>
-  onQuestionReject: (input: QuestionReject) => void | Promise<void>
-  onCycle: () => void
-  onInterrupt: () => boolean
-  onExitRequest?: () => boolean
-  onExit: () => void
-  onRows: (rows: number) => void
-  onStatus: (text: string) => void
-}
-
-export { TEXTAREA_MIN_ROWS, TEXTAREA_MAX_ROWS } from "./footer.prompt"
-
-export function RunFooterView(props: RunFooterViewProps) {
-  const term = useTerminalDimensions()
-  const active = createMemo<FooterView>(() => props.view?.() ?? { type: "prompt" })
-  const prompt = createMemo(() => active().type === "prompt")
-  const variant = createMemo(() => printableBinding(props.keybinds.variantCycle, props.keybinds.leader))
-  const interrupt = createMemo(() => printableBinding(props.keybinds.interrupt, props.keybinds.leader))
-  const hints = createMemo(() => hintFlags(term().width))
-  const busy = createMemo(() => props.state().phase === "running")
-  const armed = createMemo(() => props.state().interrupt > 0)
-  const exiting = createMemo(() => props.state().exit > 0)
-  const queue = createMemo(() => props.state().queue)
-  const duration = createMemo(() => props.state().duration)
-  const usage = createMemo(() => props.state().usage)
-  const interruptKey = createMemo(() => interrupt() || "/exit")
-  const theme = createMemo(() => props.theme ?? RUN_THEME_FALLBACK.footer)
-  const block = createMemo(() => props.block ?? RUN_THEME_FALLBACK.block)
-  const spin = createMemo(() => {
-    return {
-      frames: createFrames({
-        color: theme().highlight,
-        style: "blocks",
-        inactiveFactor: 0.6,
-        minAlpha: 0.3,
-      }),
-      color: createColors({
-        color: theme().highlight,
-        style: "blocks",
-        inactiveFactor: 0.6,
-        minAlpha: 0.3,
-      }),
-    }
-  })
-  const permission = createMemo<Extract<FooterView, { type: "permission" }> | undefined>(() => {
-    const view = active()
-    return view.type === "permission" ? view : undefined
-  })
-  const question = createMemo<Extract<FooterView, { type: "question" }> | undefined>(() => {
-    const view = active()
-    return view.type === "question" ? view : undefined
-  })
-  const composer = createPromptState({
-    directory: props.directory,
-    findFiles: props.findFiles,
-    agents: props.agents,
-    resources: props.resources,
-    keybinds: props.keybinds,
-    state: props.state,
-    view: () => active().type,
-    prompt,
-    width: () => term().width,
-    theme,
-    history: props.history,
-    onSubmit: props.onSubmit,
-    onCycle: props.onCycle,
-    onInterrupt: props.onInterrupt,
-    onExitRequest: props.onExitRequest,
-    onExit: props.onExit,
-    onRows: props.onRows,
-    onStatus: props.onStatus,
-  })
-  const menu = createMemo(() => active().type === "prompt" && composer.visible())
-
-  return (
-    <box
-      id="run-direct-footer-shell"
-      width="100%"
-      height="100%"
-      border={false}
-      backgroundColor="transparent"
-      flexDirection="column"
-      gap={0}
-      padding={0}
-    >
-      <box id="run-direct-footer-top-spacer" width="100%" height={1} flexShrink={0} backgroundColor="transparent" />
-
-      <box
-        id="run-direct-footer-composer-frame"
-        width="100%"
-        flexShrink={0}
-        border={["left"]}
-        borderColor={theme().highlight}
-        customBorderChars={{
-          ...EMPTY_BORDER,
-          vertical: "┃",
-          bottomLeft: "╹",
-        }}
-      >
-        <box
-          id="run-direct-footer-composer-area"
-          width="100%"
-          flexGrow={1}
-          paddingLeft={0}
-          paddingRight={0}
-          paddingTop={0}
-          flexDirection="column"
-          backgroundColor={theme().surface}
-          gap={0}
-        >
-          <box id="run-direct-footer-body" width="100%" flexGrow={1} flexShrink={1} flexDirection="column">
-            <Switch>
-              <Match when={active().type === "prompt"}>
-                <RunPromptBody
-                  theme={theme}
-                  placeholder={composer.placeholder}
-                  bindings={composer.bindings}
-                  onSubmit={composer.onSubmit}
-                  onKeyDown={composer.onKeyDown}
-                  onContentChange={composer.onContentChange}
-                  bind={composer.bind}
-                />
-              </Match>
-              <Match when={active().type === "permission"}>
-                <RunPermissionBody
-                  request={permission()!.request}
-                  theme={theme()}
-                  block={block()}
-                  diffStyle={props.diffStyle}
-                  onReply={props.onPermissionReply}
-                />
-              </Match>
-              <Match when={active().type === "question"}>
-                <RunQuestionBody
-                  request={question()!.request}
-                  theme={theme()}
-                  onReply={props.onQuestionReply}
-                  onReject={props.onQuestionReject}
-                />
-              </Match>
-            </Switch>
-          </box>
-
-          <box
-            id="run-direct-footer-meta-row"
-            width="100%"
-            flexDirection="row"
-            gap={1}
-            paddingLeft={2}
-            flexShrink={0}
-            paddingTop={1}
-          >
-            <text id="run-direct-footer-agent" fg={theme().highlight} wrapMode="none" truncate flexShrink={0}>
-              {props.agent}
-            </text>
-            <text id="run-direct-footer-model" fg={theme().text} wrapMode="none" truncate flexGrow={1} flexShrink={1}>
-              {props.state().model}
-            </text>
-          </box>
-        </box>
-      </box>
-
-      <box
-        id="run-direct-footer-line-6"
-        width="100%"
-        height={1}
-        border={["left"]}
-        borderColor={theme().highlight}
-        backgroundColor="transparent"
-        customBorderChars={{
-          ...EMPTY_BORDER,
-          vertical: "╹",
-        }}
-        flexShrink={0}
-      >
-        <box
-          id="run-direct-footer-line-6-fill"
-          width="100%"
-          height={1}
-          border={["bottom"]}
-          borderColor={theme().surface}
-          backgroundColor={menu() ? theme().shade : "transparent"}
-          customBorderChars={{
-            ...EMPTY_BORDER,
-            horizontal: "▀",
-          }}
-        />
-      </box>
-
-      <Show
-        when={menu()}
-        fallback={
-          <box
-            id="run-direct-footer-row"
-            width="100%"
-            height={1}
-            flexDirection="row"
-            justifyContent="space-between"
-            gap={1}
-            flexShrink={0}
-          >
-            <Show when={busy() || exiting()}>
-              <box id="run-direct-footer-hint-left" flexDirection="row" gap={1} flexShrink={0}>
-                <Show when={exiting()}>
-                  <text id="run-direct-footer-hint-exit" fg={theme().highlight} wrapMode="none" truncate marginLeft={1}>
-                    Press Ctrl-c again to exit
-                  </text>
-                </Show>
-
-                <Show when={busy() && !exiting()}>
-                  <box id="run-direct-footer-status-spinner" marginLeft={1} flexShrink={0}>
-                    <spinner color={spin().color} frames={spin().frames} interval={40} />
-                  </box>
-
-                  <text
-                    id="run-direct-footer-hint-interrupt"
-                    fg={armed() ? theme().highlight : theme().text}
-                    wrapMode="none"
-                    truncate
-                  >
-                    {interruptKey()}{" "}
-                    <span style={{ fg: armed() ? theme().highlight : theme().muted }}>
-                      {armed() ? "again to interrupt" : "interrupt"}
-                    </span>
-                  </text>
-                </Show>
-              </box>
-            </Show>
-
-            <Show when={!busy() && !exiting() && duration().length > 0}>
-              <box id="run-direct-footer-duration" flexDirection="row" gap={2} flexShrink={0} marginLeft={1}>
-                <text id="run-direct-footer-duration-mark" fg={theme().muted} wrapMode="none" truncate>
-                  ▣
-                </text>
-                <box id="run-direct-footer-duration-tail" flexDirection="row" gap={1} flexShrink={0}>
-                  <text id="run-direct-footer-duration-dot" fg={theme().muted} wrapMode="none" truncate>
-                    ·
-                  </text>
-                  <text id="run-direct-footer-duration-value" fg={theme().muted} wrapMode="none" truncate>
-                    {duration()}
-                  </text>
-                </box>
-              </box>
-            </Show>
-
-            <box id="run-direct-footer-spacer" flexGrow={1} flexShrink={1} backgroundColor="transparent" />
-
-            <box id="run-direct-footer-hint-group" flexDirection="row" gap={2} flexShrink={0} justifyContent="flex-end">
-              <Show when={queue() > 0}>
-                <text id="run-direct-footer-queue" fg={theme().muted} wrapMode="none" truncate>
-                  {queue()} queued
-                </text>
-              </Show>
-              <Show when={usage().length > 0}>
-                <text id="run-direct-footer-usage" fg={theme().muted} wrapMode="none" truncate>
-                  {usage()}
-                </text>
-              </Show>
-              <Show when={variant().length > 0 && hints().variant}>
-                <text id="run-direct-footer-hint-variant" fg={theme().muted} wrapMode="none" truncate>
-                  {variant()} variant
-                </text>
-              </Show>
-            </box>
-          </box>
-        }
-      >
-        <RunPromptAutocomplete theme={theme} options={composer.options} selected={composer.selected} />
-      </Show>
-    </box>
-  )
-}

packages/opencode/src/cli/cmd/run/permission.shared.ts

@@ -1,256 +0,0 @@
-// Pure state machine for the permission UI.
-//
-// Lives outside the JSX component so it can be tested independently. The
-// machine has three stages:
-//
-//   permission → initial view with Allow once / Always / Reject options
-//   always     → confirmation step (Confirm / Cancel)
-//   reject     → text input for rejection message
-//
-// permissionRun() is the main transition: given the current state and the
-// selected option, it returns a new state and optionally a PermissionReply
-// to send to the SDK. The component calls this on enter/click.
-//
-// permissionInfo() extracts display info (icon, title, lines, diff) from
-// the request, delegating to tool.ts for tool-specific formatting.
-import type { PermissionRequest } from "@opencode-ai/sdk/v2"
-import type { PermissionReply } from "./types"
-import { toolPath, toolPermissionInfo } from "./tool"
-
-type Dict = Record<string, unknown>
-
-export type PermissionStage = "permission" | "always" | "reject"
-export type PermissionOption = "once" | "always" | "reject" | "confirm" | "cancel"
-
-export type PermissionBodyState = {
-  requestID: string
-  stage: PermissionStage
-  selected: PermissionOption
-  message: string
-  submitting: boolean
-}
-
-export type PermissionInfo = {
-  icon: string
-  title: string
-  lines: string[]
-  diff?: string
-  file?: string
-}
-
-export type PermissionStep = {
-  state: PermissionBodyState
-  reply?: PermissionReply
-}
-
-function dict(v: unknown): Dict {
-  if (!v || typeof v !== "object" || Array.isArray(v)) {
-    return {}
-  }
-
-  return v as Dict
-}
-
-function text(v: unknown): string {
-  return typeof v === "string" ? v : ""
-}
-
-function data(request: PermissionRequest): Dict {
-  const meta = dict(request.metadata)
-  return {
-    ...meta,
-    ...dict(meta.input),
-  }
-}
-
-function patterns(request: PermissionRequest): string[] {
-  return request.patterns.filter((item): item is string => typeof item === "string")
-}
-
-export function createPermissionBodyState(requestID: string): PermissionBodyState {
-  return {
-    requestID,
-    stage: "permission",
-    selected: "once",
-    message: "",
-    submitting: false,
-  }
-}
-
-export function permissionOptions(stage: PermissionStage): PermissionOption[] {
-  if (stage === "permission") {
-    return ["once", "always", "reject"]
-  }
-
-  if (stage === "always") {
-    return ["confirm", "cancel"]
-  }
-
-  return []
-}
-
-export function permissionInfo(request: PermissionRequest): PermissionInfo {
-  const pats = patterns(request)
-  const input = data(request)
-  const info = toolPermissionInfo(request.permission, input, dict(request.metadata), pats)
-  if (info) {
-    return info
-  }
-
-  if (request.permission === "external_directory") {
-    const meta = dict(request.metadata)
-    const raw = text(meta.parentDir) || text(meta.filepath) || pats[0] || ""
-    const dir = raw.includes("*") ? raw.slice(0, raw.indexOf("*")).replace(/[\\/]+$/, "") : raw
-    return {
-      icon: "←",
-      title: `Access external directory ${toolPath(dir, { home: true })}`,
-      lines: pats.map((item) => `- ${item}`),
-    }
-  }
-
-  if (request.permission === "doom_loop") {
-    return {
-      icon: "⟳",
-      title: "Continue after repeated failures",
-      lines: ["This keeps the session running despite repeated failures."],
-    }
-  }
-
-  return {
-    icon: "⚙",
-    title: `Call tool ${request.permission}`,
-    lines: [`Tool: ${request.permission}`],
-  }
-}
-
-export function permissionAlwaysLines(request: PermissionRequest): string[] {
-  if (request.always.length === 1 && request.always[0] === "*") {
-    return [`This will allow ${request.permission} until OpenCode is restarted.`]
-  }
-
-  return [
-    "This will allow the following patterns until OpenCode is restarted.",
-    ...request.always.map((item) => `- ${item}`),
-  ]
-}
-
-export function permissionLabel(option: PermissionOption): string {
-  if (option === "once") return "Allow once"
-  if (option === "always") return "Allow always"
-  if (option === "reject") return "Reject"
-  if (option === "confirm") return "Confirm"
-  return "Cancel"
-}
-
-export function permissionReply(requestID: string, reply: PermissionReply["reply"], message?: string): PermissionReply {
-  return {
-    requestID,
-    reply,
-    ...(message && message.trim() ? { message: message.trim() } : {}),
-  }
-}
-
-export function permissionShift(state: PermissionBodyState, dir: -1 | 1): PermissionBodyState {
-  const list = permissionOptions(state.stage)
-  if (list.length === 0) {
-    return state
-  }
-
-  const idx = Math.max(0, list.indexOf(state.selected))
-  const selected = list[(idx + dir + list.length) % list.length]
-  return {
-    ...state,
-    selected,
-  }
-}
-
-export function permissionHover(state: PermissionBodyState, option: PermissionOption): PermissionBodyState {
-  return {
-    ...state,
-    selected: option,
-  }
-}
-
-export function permissionRun(state: PermissionBodyState, requestID: string, option: PermissionOption): PermissionStep {
-  if (state.submitting) {
-    return { state }
-  }
-
-  if (state.stage === "permission") {
-    if (option === "always") {
-      return {
-        state: {
-          ...state,
-          stage: "always",
-          selected: "confirm",
-        },
-      }
-    }
-
-    if (option === "reject") {
-      return {
-        state: {
-          ...state,
-          stage: "reject",
-          selected: "reject",
-        },
-      }
-    }
-
-    return {
-      state,
-      reply: permissionReply(requestID, "once"),
-    }
-  }
-
-  if (state.stage !== "always") {
-    return { state }
-  }
-
-  if (option === "cancel") {
-    return {
-      state: {
-        ...state,
-        stage: "permission",
-        selected: "always",
-      },
-    }
-  }
-
-  return {
-    state,
-    reply: permissionReply(requestID, "always"),
-  }
-}
-
-export function permissionReject(state: PermissionBodyState, requestID: string): PermissionReply | undefined {
-  if (state.submitting) {
-    return
-  }
-
-  return permissionReply(requestID, "reject", state.message)
-}
-
-export function permissionCancel(state: PermissionBodyState): PermissionBodyState {
-  return {
-    ...state,
-    stage: "permission",
-    selected: "reject",
-  }
-}
-
-export function permissionEscape(state: PermissionBodyState): PermissionBodyState {
-  if (state.stage === "always") {
-    return {
-      ...state,
-      stage: "permission",
-      selected: "always",
-    }
-  }
-
-  return {
-    ...state,
-    stage: "reject",
-    selected: "reject",
-  }
-}

packages/opencode/src/cli/cmd/run/prompt.shared.ts

@@ -1,271 +0,0 @@
-// Pure state machine for the prompt input.
-//
-// Handles keybind parsing, history ring navigation, and the leader-key
-// sequence for variant cycling. All functions are pure -- they take state
-// in and return new state out, with no side effects.
-//
-// The history ring (PromptHistoryState) stores past prompts and tracks
-// the current browse position. When the user arrows up at cursor offset 0,
-// the current draft is saved and history begins. Arrowing past the end
-// restores the draft.
-//
-// The leader-key cycle (promptCycle) uses a two-step pattern: first press
-// arms the leader, second press within the timeout fires the action.
-import type { KeyBinding } from "@opentui/core"
-import { Keybind } from "../../../util/keybind"
-import type { FooterKeybinds, RunPrompt } from "./types"
-
-const HISTORY_LIMIT = 200
-
-export type PromptHistoryState = {
-  items: RunPrompt[]
-  index: number | null
-  draft: string
-}
-
-export type PromptKeys = {
-  leaders: Keybind.Info[]
-  cycles: Keybind.Info[]
-  interrupts: Keybind.Info[]
-  previous: Keybind.Info[]
-  next: Keybind.Info[]
-  bindings: KeyBinding[]
-}
-
-export type PromptCycle = {
-  arm: boolean
-  clear: boolean
-  cycle: boolean
-  consume: boolean
-}
-
-export type PromptMove = {
-  state: PromptHistoryState
-  text?: string
-  cursor?: number
-  apply: boolean
-}
-
-function copy(prompt: RunPrompt): RunPrompt {
-  return {
-    text: prompt.text,
-    parts: structuredClone(prompt.parts),
-  }
-}
-
-function same(a: RunPrompt, b: RunPrompt): boolean {
-  return a.text === b.text && JSON.stringify(a.parts) === JSON.stringify(b.parts)
-}
-
-function mapInputBindings(binding: string, action: "submit" | "newline"): KeyBinding[] {
-  return Keybind.parse(binding).map((item) => ({
-    name: item.name,
-    ctrl: item.ctrl || undefined,
-    meta: item.meta || undefined,
-    shift: item.shift || undefined,
-    super: item.super || undefined,
-    action,
-  }))
-}
-
-function textareaBindings(keybinds: FooterKeybinds): KeyBinding[] {
-  return [
-    { name: "return", action: "submit" },
-    { name: "return", meta: true, action: "newline" },
-    ...mapInputBindings(keybinds.inputSubmit, "submit"),
-    ...mapInputBindings(keybinds.inputNewline, "newline"),
-  ]
-}
-
-export function promptKeys(keybinds: FooterKeybinds): PromptKeys {
-  return {
-    leaders: Keybind.parse(keybinds.leader),
-    cycles: Keybind.parse(keybinds.variantCycle),
-    interrupts: Keybind.parse(keybinds.interrupt),
-    previous: Keybind.parse(keybinds.historyPrevious),
-    next: Keybind.parse(keybinds.historyNext),
-    bindings: textareaBindings(keybinds),
-  }
-}
-
-export function printableBinding(binding: string, leader: string): string {
-  const first = Keybind.parse(binding).at(0)
-  if (!first) {
-    return ""
-  }
-
-  let text = Keybind.toString(first)
-  const lead = Keybind.parse(leader).at(0)
-  if (lead) {
-    text = text.replace("<leader>", Keybind.toString(lead))
-  }
-
-  return text.replace(/escape/g, "esc")
-}
-
-export function isExitCommand(input: string): boolean {
-  const text = input.trim().toLowerCase()
-  return text === "/exit" || text === "/quit"
-}
-
-export function promptInfo(event: {
-  name: string
-  ctrl?: boolean
-  meta?: boolean
-  shift?: boolean
-  super?: boolean
-}): Keybind.Info {
-  return {
-    name: event.name === " " ? "space" : event.name,
-    ctrl: !!event.ctrl,
-    meta: !!event.meta,
-    shift: !!event.shift,
-    super: !!event.super,
-    leader: false,
-  }
-}
-
-export function promptHit(bindings: Keybind.Info[], event: Keybind.Info): boolean {
-  return bindings.some((item) => Keybind.match(item, event))
-}
-
-export function promptCycle(
-  armed: boolean,
-  event: Keybind.Info,
-  leaders: Keybind.Info[],
-  cycles: Keybind.Info[],
-): PromptCycle {
-  if (!armed && promptHit(leaders, event)) {
-    return {
-      arm: true,
-      clear: false,
-      cycle: false,
-      consume: true,
-    }
-  }
-
-  if (armed) {
-    return {
-      arm: false,
-      clear: true,
-      cycle: promptHit(cycles, { ...event, leader: true }),
-      consume: true,
-    }
-  }
-
-  if (!promptHit(cycles, event)) {
-    return {
-      arm: false,
-      clear: false,
-      cycle: false,
-      consume: false,
-    }
-  }
-
-  return {
-    arm: false,
-    clear: false,
-    cycle: true,
-    consume: true,
-  }
-}
-
-export function createPromptHistory(items?: RunPrompt[]): PromptHistoryState {
-  const list = (items ?? []).filter((item) => item.text.trim().length > 0).map(copy)
-  const next: RunPrompt[] = []
-  for (const item of list) {
-    if (next.length > 0 && same(next[next.length - 1], item)) {
-      continue
-    }
-
-    next.push(item)
-  }
-
-  return {
-    items: next.slice(-HISTORY_LIMIT),
-    index: null,
-    draft: "",
-  }
-}
-
-export function pushPromptHistory(state: PromptHistoryState, prompt: RunPrompt): PromptHistoryState {
-  if (!prompt.text.trim()) {
-    return state
-  }
-
-  const next = copy(prompt)
-  if (state.items[state.items.length - 1] && same(state.items[state.items.length - 1], next)) {
-    return {
-      ...state,
-      index: null,
-      draft: "",
-    }
-  }
-
-  const items = [...state.items, next].slice(-HISTORY_LIMIT)
-  return {
-    ...state,
-    items,
-    index: null,
-    draft: "",
-  }
-}
-
-export function movePromptHistory(state: PromptHistoryState, dir: -1 | 1, text: string, cursor: number): PromptMove {
-  if (state.items.length === 0) {
-    return { state, apply: false }
-  }
-
-  if (dir === -1 && cursor !== 0) {
-    return { state, apply: false }
-  }
-
-  if (dir === 1 && cursor !== text.length) {
-    return { state, apply: false }
-  }
-
-  if (state.index === null) {
-    if (dir === 1) {
-      return { state, apply: false }
-    }
-
-    const idx = state.items.length - 1
-    return {
-      state: {
-        ...state,
-        index: idx,
-        draft: text,
-      },
-      text: state.items[idx].text,
-      cursor: 0,
-      apply: true,
-    }
-  }
-
-  const idx = state.index + dir
-  if (idx < 0) {
-    return { state, apply: false }
-  }
-
-  if (idx >= state.items.length) {
-    return {
-      state: {
-        ...state,
-        index: null,
-      },
-      text: state.draft,
-      cursor: state.draft.length,
-      apply: true,
-    }
-  }
-
-  return {
-    state: {
-      ...state,
-      index: idx,
-    },
-    text: state.items[idx].text,
-    cursor: dir === -1 ? 0 : state.items[idx].text.length,
-    apply: true,
-  }
-}

packages/opencode/src/cli/cmd/run/question.shared.ts

@@ -1,340 +0,0 @@
-// Pure state machine for the question UI.
-//
-// Supports both single-question and multi-question flows. Single questions
-// submit immediately on selection. Multi-question flows use tabs and a
-// final confirmation step.
-//
-// State transitions:
-//   questionSelect  → picks an option (single: submits, multi: toggles/advances)
-//   questionSave    → saves custom text input
-//   questionMove    → arrow key navigation through options
-//   questionSetTab  → tab navigation between questions
-//   questionSubmit  → builds the final QuestionReply with all answers
-//
-// Custom answers: if a question has custom=true, an extra "Type your own
-// answer" option appears. Selecting it enters editing mode with a text field.
-import type { QuestionInfo, QuestionRequest } from "@opencode-ai/sdk/v2"
-import type { QuestionReject, QuestionReply } from "./types"
-
-export type QuestionBodyState = {
-  requestID: string
-  tab: number
-  answers: string[][]
-  custom: string[]
-  selected: number
-  editing: boolean
-  submitting: boolean
-}
-
-export type QuestionStep = {
-  state: QuestionBodyState
-  reply?: QuestionReply
-}
-
-export function createQuestionBodyState(requestID: string): QuestionBodyState {
-  return {
-    requestID,
-    tab: 0,
-    answers: [],
-    custom: [],
-    selected: 0,
-    editing: false,
-    submitting: false,
-  }
-}
-
-export function questionSync(state: QuestionBodyState, requestID: string): QuestionBodyState {
-  if (state.requestID === requestID) {
-    return state
-  }
-
-  return createQuestionBodyState(requestID)
-}
-
-export function questionSingle(request: QuestionRequest): boolean {
-  return request.questions.length === 1 && request.questions[0]?.multiple !== true
-}
-
-export function questionTabs(request: QuestionRequest): number {
-  return questionSingle(request) ? 1 : request.questions.length + 1
-}
-
-export function questionConfirm(request: QuestionRequest, state: QuestionBodyState): boolean {
-  return !questionSingle(request) && state.tab === request.questions.length
-}
-
-export function questionInfo(request: QuestionRequest, state: QuestionBodyState): QuestionInfo | undefined {
-  return request.questions[state.tab]
-}
-
-export function questionCustom(request: QuestionRequest, state: QuestionBodyState): boolean {
-  return questionInfo(request, state)?.custom !== false
-}
-
-export function questionInput(state: QuestionBodyState): string {
-  return state.custom[state.tab] ?? ""
-}
-
-export function questionPicked(state: QuestionBodyState): boolean {
-  const value = questionInput(state)
-  if (!value) {
-    return false
-  }
-
-  return state.answers[state.tab]?.includes(value) ?? false
-}
-
-export function questionOther(request: QuestionRequest, state: QuestionBodyState): boolean {
-  const info = questionInfo(request, state)
-  if (!info || info.custom === false) {
-    return false
-  }
-
-  return state.selected === info.options.length
-}
-
-export function questionTotal(request: QuestionRequest, state: QuestionBodyState): number {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return 0
-  }
-
-  return info.options.length + (questionCustom(request, state) ? 1 : 0)
-}
-
-export function questionAnswers(state: QuestionBodyState, count: number): string[][] {
-  return Array.from({ length: count }, (_, idx) => state.answers[idx] ?? [])
-}
-
-export function questionSetTab(state: QuestionBodyState, tab: number): QuestionBodyState {
-  return {
-    ...state,
-    tab,
-    selected: 0,
-    editing: false,
-  }
-}
-
-export function questionSetSelected(state: QuestionBodyState, selected: number): QuestionBodyState {
-  return {
-    ...state,
-    selected,
-  }
-}
-
-export function questionSetEditing(state: QuestionBodyState, editing: boolean): QuestionBodyState {
-  return {
-    ...state,
-    editing,
-  }
-}
-
-export function questionSetSubmitting(state: QuestionBodyState, submitting: boolean): QuestionBodyState {
-  return {
-    ...state,
-    submitting,
-  }
-}
-
-function storeAnswers(state: QuestionBodyState, tab: number, list: string[]): QuestionBodyState {
-  const answers = [...state.answers]
-  answers[tab] = list
-  return {
-    ...state,
-    answers,
-  }
-}
-
-export function questionStoreCustom(state: QuestionBodyState, tab: number, text: string): QuestionBodyState {
-  const custom = [...state.custom]
-  custom[tab] = text
-  return {
-    ...state,
-    custom,
-  }
-}
-
-function questionPick(
-  state: QuestionBodyState,
-  request: QuestionRequest,
-  answer: string,
-  custom = false,
-): QuestionStep {
-  const answers = [...state.answers]
-  answers[state.tab] = [answer]
-  let next: QuestionBodyState = {
-    ...state,
-    answers,
-    editing: false,
-  }
-
-  if (custom) {
-    const list = [...state.custom]
-    list[state.tab] = answer
-    next = {
-      ...next,
-      custom: list,
-    }
-  }
-
-  if (questionSingle(request)) {
-    return {
-      state: next,
-      reply: {
-        requestID: request.id,
-        answers: [[answer]],
-      },
-    }
-  }
-
-  return {
-    state: questionSetTab(next, state.tab + 1),
-  }
-}
-
-function questionToggle(state: QuestionBodyState, answer: string): QuestionBodyState {
-  const list = [...(state.answers[state.tab] ?? [])]
-  const idx = list.indexOf(answer)
-  if (idx === -1) {
-    list.push(answer)
-  } else {
-    list.splice(idx, 1)
-  }
-
-  return storeAnswers(state, state.tab, list)
-}
-
-export function questionMove(state: QuestionBodyState, request: QuestionRequest, dir: -1 | 1): QuestionBodyState {
-  const total = questionTotal(request, state)
-  if (total === 0) {
-    return state
-  }
-
-  return {
-    ...state,
-    selected: (state.selected + dir + total) % total,
-  }
-}
-
-export function questionSelect(state: QuestionBodyState, request: QuestionRequest): QuestionStep {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return { state }
-  }
-
-  if (questionOther(request, state)) {
-    if (!info.multiple) {
-      return {
-        state: questionSetEditing(state, true),
-      }
-    }
-
-    const value = questionInput(state)
-    if (value && questionPicked(state)) {
-      return {
-        state: questionToggle(state, value),
-      }
-    }
-
-    return {
-      state: questionSetEditing(state, true),
-    }
-  }
-
-  const option = info.options[state.selected]
-  if (!option) {
-    return { state }
-  }
-
-  if (info.multiple) {
-    return {
-      state: questionToggle(state, option.label),
-    }
-  }
-
-  return questionPick(state, request, option.label)
-}
-
-export function questionSave(state: QuestionBodyState, request: QuestionRequest): QuestionStep {
-  const info = questionInfo(request, state)
-  if (!info) {
-    return { state }
-  }
-
-  const value = questionInput(state).trim()
-  const prev = state.custom[state.tab]
-  if (!value) {
-    if (!prev) {
-      return {
-        state: questionSetEditing(state, false),
-      }
-    }
-
-    const next = questionStoreCustom(state, state.tab, "")
-    return {
-      state: questionSetEditing(
-        storeAnswers(
-          next,
-          state.tab,
-          (state.answers[state.tab] ?? []).filter((item) => item !== prev),
-        ),
-        false,
-      ),
-    }
-  }
-
-  if (info.multiple) {
-    const answers = [...(state.answers[state.tab] ?? [])]
-    if (prev) {
-      const idx = answers.indexOf(prev)
-      if (idx !== -1) {
-        answers.splice(idx, 1)
-      }
-    }
-
-    if (!answers.includes(value)) {
-      answers.push(value)
-    }
-
-    const next = questionStoreCustom(state, state.tab, value)
-    return {
-      state: questionSetEditing(storeAnswers(next, state.tab, answers), false),
-    }
-  }
-
-  return questionPick(state, request, value, true)
-}
-
-export function questionSubmit(request: QuestionRequest, state: QuestionBodyState): QuestionReply {
-  return {
-    requestID: request.id,
-    answers: questionAnswers(state, request.questions.length),
-  }
-}
-
-export function questionReject(request: QuestionRequest): QuestionReject {
-  return {
-    requestID: request.id,
-  }
-}
-
-export function questionHint(request: QuestionRequest, state: QuestionBodyState): string {
-  if (state.submitting) {
-    return "Waiting for question event..."
-  }
-
-  if (questionConfirm(request, state)) {
-    return "enter submit   esc dismiss"
-  }
-
-  if (state.editing) {
-    return "enter save   esc cancel"
-  }
-
-  const info = questionInfo(request, state)
-  if (questionSingle(request)) {
-    return `↑↓ select   enter ${info?.multiple ? "toggle" : "submit"}   esc dismiss`
-  }
-
-  return `⇆ tab   ↑↓ select   enter ${info?.multiple ? "toggle" : "confirm"}   esc dismiss`
-}

packages/opencode/src/cli/cmd/run/runtime.boot.ts

@@ -1,140 +0,0 @@
-// Boot-time resolution for direct interactive mode.
-//
-// These functions run concurrently at startup to gather everything the runtime
-// needs before the first frame: keybinds from TUI config, diff display style,
-// model variant list with context limits, and session history for the prompt
-// history ring. All are async because they read config or hit the SDK, but
-// none block each other.
-import { TuiConfig } from "../../../config/tui"
-import { resolveSession, sessionHistory } from "./session.shared"
-import type { FooterKeybinds, RunDiffStyle, RunInput, RunPrompt } from "./types"
-import { pickVariant } from "./variant.shared"
-
-const DEFAULT_KEYBINDS: FooterKeybinds = {
-  leader: "ctrl+x",
-  variantCycle: "ctrl+t,<leader>t",
-  interrupt: "escape",
-  historyPrevious: "up",
-  historyNext: "down",
-  inputSubmit: "return",
-  inputNewline: "shift+return,ctrl+return,alt+return,ctrl+j",
-}
-
-export type ModelInfo = {
-  variants: string[]
-  limits: Record<string, number>
-}
-
-export type SessionInfo = {
-  first: boolean
-  history: RunPrompt[]
-  variant: string | undefined
-}
-
-function modelKey(provider: string, model: string): string {
-  return `${provider}/${model}`
-}
-
-// Fetches available variants and context limits for every provider/model pair.
-export async function resolveModelInfo(sdk: RunInput["sdk"], model: RunInput["model"]): Promise<ModelInfo> {
-  try {
-    const response = await sdk.provider.list()
-    const providers = response.data?.all ?? []
-    const limits: Record<string, number> = {}
-
-    for (const provider of providers) {
-      for (const [modelID, info] of Object.entries(provider.models ?? {})) {
-        const limit = info?.limit?.context
-        if (typeof limit === "number" && limit > 0) {
-          limits[modelKey(provider.id, modelID)] = limit
-        }
-      }
-    }
-
-    if (!model) {
-      return {
-        variants: [],
-        limits,
-      }
-    }
-
-    const provider = providers.find((item) => item.id === model.providerID)
-    const modelInfo = provider?.models?.[model.modelID]
-    return {
-      variants: Object.keys(modelInfo?.variants ?? {}),
-      limits,
-    }
-  } catch {
-    return {
-      variants: [],
-      limits: {},
-    }
-  }
-}
-
-// Fetches session messages to determine if this is the first turn and build prompt history.
-export async function resolveSessionInfo(
-  sdk: RunInput["sdk"],
-  sessionID: string,
-  model: RunInput["model"],
-): Promise<SessionInfo> {
-  try {
-    const session = await resolveSession(sdk, sessionID)
-    return {
-      first: session.first,
-      history: sessionHistory(session),
-      variant: pickVariant(model, session),
-    }
-  } catch {
-    return {
-      first: true,
-      history: [],
-      variant: undefined,
-    }
-  }
-}
-
-// Reads keybind overrides from TUI config and merges them with defaults.
-// Always ensures <leader>t is present in the variant cycle binding.
-export async function resolveFooterKeybinds(): Promise<FooterKeybinds> {
-  try {
-    const config = await TuiConfig.get()
-    const configuredLeader = config.keybinds?.leader?.trim() || DEFAULT_KEYBINDS.leader
-    const configuredVariantCycle = config.keybinds?.variant_cycle?.trim() || "ctrl+t"
-    const configuredInterrupt = config.keybinds?.session_interrupt?.trim() || DEFAULT_KEYBINDS.interrupt
-    const configuredHistoryPrevious = config.keybinds?.history_previous?.trim() || DEFAULT_KEYBINDS.historyPrevious
-    const configuredHistoryNext = config.keybinds?.history_next?.trim() || DEFAULT_KEYBINDS.historyNext
-    const configuredSubmit = config.keybinds?.input_submit?.trim() || DEFAULT_KEYBINDS.inputSubmit
-    const configuredNewline = config.keybinds?.input_newline?.trim() || DEFAULT_KEYBINDS.inputNewline
-
-    const variantBindings = configuredVariantCycle
-      .split(",")
-      .map((item) => item.trim())
-      .filter((item) => item.length > 0)
-
-    if (!variantBindings.some((binding) => binding.toLowerCase() === "<leader>t")) {
-      variantBindings.push("<leader>t")
-    }
-
-    return {
-      leader: configuredLeader,
-      variantCycle: variantBindings.join(","),
-      interrupt: configuredInterrupt,
-      historyPrevious: configuredHistoryPrevious,
-      historyNext: configuredHistoryNext,
-      inputSubmit: configuredSubmit,
-      inputNewline: configuredNewline,
-    }
-  } catch {
-    return DEFAULT_KEYBINDS
-  }
-}
-
-export async function resolveDiffStyle(): Promise<RunDiffStyle> {
-  try {
-    const config = await TuiConfig.get()
-    return config.diff_style ?? "auto"
-  } catch {
-    return "auto"
-  }
-}

packages/opencode/src/cli/cmd/run/runtime.lifecycle.ts

@@ -1,259 +0,0 @@
-// Lifecycle management for the split-footer renderer.
-//
-// Creates the OpenTUI CliRenderer in split-footer mode, resolves the theme
-// from the terminal palette, writes the entry splash to scrollback, and
-// constructs the RunFooter. Returns a Lifecycle handle whose close() writes
-// the exit splash and tears everything down in the right order:
-// footer.close → footer.destroy → renderer shutdown.
-//
-// Also wires SIGINT so Ctrl-c during a turn triggers the two-press exit
-// sequence through RunFooter.requestExit().
-import { createCliRenderer, type CliRenderer, type ScrollbackWriter } from "@opentui/core"
-import { Locale } from "../../../util/locale"
-import { entrySplash, exitSplash, splashMeta } from "./splash"
-import { resolveRunTheme } from "./theme"
-import type {
-  FooterApi,
-  FooterKeybinds,
-  PermissionReply,
-  QuestionReject,
-  QuestionReply,
-  RunAgent,
-  RunDiffStyle,
-  RunInput,
-  RunPrompt,
-  RunResource,
-} from "./types"
-import { formatModelLabel } from "./variant.shared"
-
-const FOOTER_HEIGHT = 7
-const DEFAULT_TITLE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
-
-type SplashState = {
-  entry: boolean
-  exit: boolean
-}
-
-type CycleResult = {
-  modelLabel?: string
-  status?: string
-}
-
-type FooterLabels = {
-  agentLabel: string
-  modelLabel: string
-}
-
-export type LifecycleInput = {
-  directory: string
-  findFiles: (query: string) => Promise<string[]>
-  agents: RunAgent[]
-  resources: RunResource[]
-  sessionID: string
-  sessionTitle?: string
-  first: boolean
-  history: RunPrompt[]
-  agent: string | undefined
-  model: RunInput["model"]
-  variant: string | undefined
-  keybinds: FooterKeybinds
-  diffStyle: RunDiffStyle
-  onPermissionReply: (input: PermissionReply) => void | Promise<void>
-  onQuestionReply: (input: QuestionReply) => void | Promise<void>
-  onQuestionReject: (input: QuestionReject) => void | Promise<void>
-  onCycleVariant?: () => CycleResult | void
-  onInterrupt?: () => void
-}
-
-export type Lifecycle = {
-  footer: FooterApi
-  close(input: { showExit: boolean; sessionTitle?: string }): Promise<void>
-}
-
-// Gracefully tears down the renderer. Order matters: switch external output
-// back to passthrough before leaving split-footer mode, so pending stdout
-// doesn't get captured into the now-dead scrollback pipeline.
-function shutdown(renderer: CliRenderer): void {
-  if (renderer.isDestroyed) {
-    return
-  }
-
-  if (renderer.externalOutputMode === "capture-stdout") {
-    renderer.externalOutputMode = "passthrough"
-  }
-
-  if (renderer.screenMode === "split-footer") {
-    renderer.screenMode = "main-screen"
-  }
-
-  if (!renderer.isDestroyed) {
-    renderer.destroy()
-  }
-}
-
-function splashTitle(title: string | undefined, history: RunPrompt[]): string | undefined {
-  if (title && !DEFAULT_TITLE.test(title)) {
-    return title
-  }
-
-  const next = history.find((item) => item.text.trim().length > 0)
-  return next?.text ?? title
-}
-
-function splashSession(title: string | undefined, history: RunPrompt[]): boolean {
-  if (title && !DEFAULT_TITLE.test(title)) {
-    return true
-  }
-
-  return !!history.find((item) => item.text.trim().length > 0)
-}
-
-function footerLabels(input: Pick<RunInput, "agent" | "model" | "variant">): FooterLabels {
-  const agentLabel = Locale.titlecase(input.agent ?? "build")
-
-  if (!input.model) {
-    return {
-      agentLabel,
-      modelLabel: "Model default",
-    }
-  }
-
-  return {
-    agentLabel,
-    modelLabel: formatModelLabel(input.model, input.variant),
-  }
-}
-
-function queueSplash(
-  renderer: Pick<CliRenderer, "writeToScrollback" | "requestRender">,
-  state: SplashState,
-  phase: keyof SplashState,
-  write: ScrollbackWriter | undefined,
-): boolean {
-  if (state[phase]) {
-    return false
-  }
-
-  if (!write) {
-    return false
-  }
-
-  state[phase] = true
-  renderer.writeToScrollback(write)
-  renderer.requestRender()
-  return true
-}
-
-// Boots the split-footer renderer and constructs the RunFooter.
-//
-// The renderer starts in split-footer mode with captured stdout so that
-// scrollback commits and footer repaints happen in the same frame. After
-// the entry splash, RunFooter takes over the footer region.
-export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lifecycle> {
-  const renderer = await createCliRenderer({
-    targetFps: 30,
-    maxFps: 60,
-    useMouse: false,
-    autoFocus: false,
-    openConsoleOnError: false,
-    exitOnCtrlC: false,
-    useKittyKeyboard: { events: process.platform === "win32" },
-    screenMode: "split-footer",
-    footerHeight: FOOTER_HEIGHT,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-    clearOnShutdown: false,
-  })
-  let theme = await resolveRunTheme(renderer)
-  renderer.setBackgroundColor(theme.background)
-  const state: SplashState = {
-    entry: false,
-    exit: false,
-  }
-  const showSession = splashSession(input.sessionTitle, input.history)
-  const meta = splashMeta({
-    title: splashTitle(input.sessionTitle, input.history),
-    session_id: input.sessionID,
-  })
-  queueSplash(
-    renderer,
-    state,
-    "entry",
-    entrySplash({
-      ...meta,
-      theme: theme.entry,
-      background: theme.background,
-      showSession,
-    }),
-  )
-  await renderer.idle().catch(() => {})
-
-  const { RunFooter } = await import("./footer")
-
-  const labels = footerLabels({
-    agent: input.agent,
-    model: input.model,
-    variant: input.variant,
-  })
-  const footer = new RunFooter(renderer, {
-    directory: input.directory,
-    findFiles: input.findFiles,
-    agents: input.agents,
-    resources: input.resources,
-    ...labels,
-    first: input.first,
-    history: input.history,
-    theme,
-    keybinds: input.keybinds,
-    diffStyle: input.diffStyle,
-    onPermissionReply: input.onPermissionReply,
-    onQuestionReply: input.onQuestionReply,
-    onQuestionReject: input.onQuestionReject,
-    onCycleVariant: input.onCycleVariant,
-    onInterrupt: input.onInterrupt,
-  })
-
-  const sigint = () => {
-    footer.requestExit()
-  }
-  process.on("SIGINT", sigint)
-
-  let closed = false
-  const close = async (next: { showExit: boolean; sessionTitle?: string }) => {
-    if (closed) {
-      return
-    }
-
-    closed = true
-    process.off("SIGINT", sigint)
-
-    try {
-      const show = renderer.isDestroyed ? false : next.showExit
-      if (!renderer.isDestroyed && show) {
-        queueSplash(
-          renderer,
-          state,
-          "exit",
-          exitSplash({
-            ...splashMeta({
-              title: splashTitle(next.sessionTitle ?? input.sessionTitle, input.history),
-              session_id: input.sessionID,
-            }),
-            theme: theme.entry,
-            background: theme.background,
-          }),
-        )
-        await renderer.idle().catch(() => {})
-      }
-    } finally {
-      footer.close()
-      footer.destroy()
-      shutdown(renderer)
-    }
-  }
-
-  return {
-    footer,
-    close,
-  }
-}

packages/opencode/src/cli/cmd/run/runtime.queue.ts

@@ -1,213 +0,0 @@
-// Serial prompt queue for direct interactive mode.
-//
-// Prompts arrive from the footer (user types and hits enter) and queue up
-// here. The queue drains one turn at a time: it appends the user row to
-// scrollback, calls input.run() to execute the turn through the stream
-// transport, and waits for completion before starting the next prompt.
-//
-// The queue also handles /exit and /quit commands, empty-prompt rejection,
-// and tracks per-turn wall-clock duration for the footer status line.
-//
-// Resolves when the footer closes and all in-flight work finishes.
-import { Locale } from "../../../util/locale"
-import { isExitCommand } from "./prompt.shared"
-import type { FooterApi, FooterEvent, RunPrompt } from "./types"
-
-type Trace = {
-  write(type: string, data?: unknown): void
-}
-
-export type QueueInput = {
-  footer: FooterApi
-  initialInput?: string
-  trace?: Trace
-  onPrompt?: () => void
-  run: (prompt: RunPrompt, signal: AbortSignal) => Promise<void>
-}
-
-// Runs the prompt queue until the footer closes.
-//
-// Subscribes to footer prompt events, queues them, and drains one at a
-// time through input.run(). If the user submits multiple prompts while
-// a turn is running, they queue up and execute in order. The footer shows
-// the queue depth so the user knows how many are pending.
-export async function runPromptQueue(input: QueueInput): Promise<void> {
-  const q: RunPrompt[] = []
-  let busy = false
-  let closed = input.footer.isClosed
-  let ctrl: AbortController | undefined
-  let stop: (() => void) | undefined
-  let err: unknown
-  let hasErr = false
-  let done: (() => void) | undefined
-  const wait = new Promise<void>((resolve) => {
-    done = resolve
-  })
-  const until = new Promise<void>((resolve) => {
-    stop = resolve
-  })
-
-  const fail = (error: unknown) => {
-    err = error
-    hasErr = true
-    done?.()
-    done = undefined
-  }
-
-  const finish = () => {
-    if (!closed || busy) {
-      return
-    }
-
-    done?.()
-    done = undefined
-  }
-
-  const emit = (next: FooterEvent, row: Record<string, unknown>) => {
-    input.trace?.write("ui.patch", row)
-    input.footer.event(next)
-  }
-
-  const pump = async () => {
-    if (busy || closed) {
-      return
-    }
-
-    busy = true
-
-    try {
-      while (!closed && q.length > 0) {
-        const prompt = q.shift()
-        if (!prompt) {
-          continue
-        }
-
-        emit(
-          {
-            type: "turn.send",
-            queue: q.length,
-          },
-          {
-            phase: "running",
-            status: "sending prompt",
-            queue: q.length,
-          },
-        )
-        const start = Date.now()
-        const next = new AbortController()
-        ctrl = next
-        try {
-          const task = input.run(prompt, next.signal).then(
-            () => ({ type: "done" as const }),
-            (error) => ({ type: "error" as const, error }),
-          )
-          await input.footer.idle()
-          const commit = { kind: "user", text: prompt.text, phase: "start", source: "system" } as const
-          input.trace?.write("ui.commit", commit)
-          input.footer.append(commit)
-          const out = await Promise.race([task, until.then(() => ({ type: "closed" as const }))])
-          if (out.type === "closed") {
-            next.abort()
-            break
-          }
-
-          if (out.type === "error") {
-            throw out.error
-          }
-        } finally {
-          if (ctrl === next) {
-            ctrl = undefined
-          }
-          const duration = Locale.duration(Math.max(0, Date.now() - start))
-          emit(
-            {
-              type: "turn.duration",
-              duration,
-            },
-            {
-              duration,
-            },
-          )
-        }
-      }
-    } finally {
-      busy = false
-      emit(
-        {
-          type: "turn.idle",
-          queue: q.length,
-        },
-        {
-          phase: "idle",
-          status: "",
-          queue: q.length,
-        },
-      )
-      finish()
-    }
-  }
-
-  const push = (prompt: RunPrompt) => {
-    if (!prompt.text.trim() || closed) {
-      return
-    }
-
-    if (isExitCommand(prompt.text)) {
-      input.footer.close()
-      return
-    }
-
-    input.onPrompt?.()
-    q.push(prompt)
-    emit(
-      {
-        type: "queue",
-        queue: q.length,
-      },
-      {
-        queue: q.length,
-      },
-    )
-    emit(
-      {
-        type: "first",
-        first: false,
-      },
-      {
-        first: false,
-      },
-    )
-    void pump().catch(fail)
-  }
-
-  const offPrompt = input.footer.onPrompt((prompt) => {
-    push(prompt)
-  })
-  const offClose = input.footer.onClose(() => {
-    closed = true
-    q.length = 0
-    ctrl?.abort()
-    stop?.()
-    finish()
-  })
-
-  try {
-    if (closed) {
-      return
-    }
-
-    push({ text: input.initialInput ?? "", parts: [] })
-    await pump()
-
-    if (!closed) {
-      await wait
-    }
-
-    if (hasErr) {
-      throw err
-    }
-  } finally {
-    offPrompt()
-    offClose()
-  }
-}

packages/opencode/src/cli/cmd/run/runtime.ts

@@ -1,324 +0,0 @@
-// Top-level orchestrator for `run --interactive`.
-//
-// Wires the boot sequence, lifecycle (renderer + footer), stream transport,
-// and prompt queue together into a single session loop. Two entry points:
-//
-//   runInteractiveMode     -- used when an SDK client already exists (attach mode)
-//   runInteractiveLocalMode -- used for local in-process mode (no server)
-//
-// Both delegate to runInteractiveRuntime, which:
-//   1. resolves keybinds, diff style, model info, and session history,
-//   2. creates the split-footer lifecycle (renderer + RunFooter),
-//   3. starts the stream transport (SDK event subscription),
-//   4. runs the prompt queue until the footer closes.
-import { createOpencodeClient } from "@opencode-ai/sdk/v2"
-import { createRunDemo } from "./demo"
-import { resolveDiffStyle, resolveFooterKeybinds, resolveModelInfo, resolveSessionInfo } from "./runtime.boot"
-import { createRuntimeLifecycle } from "./runtime.lifecycle"
-import { trace } from "./trace"
-import { cycleVariant, formatModelLabel, resolveSavedVariant, resolveVariant, saveVariant } from "./variant.shared"
-import type { RunInput } from "./types"
-
-/** @internal Exported for testing */
-export { pickVariant, resolveVariant } from "./variant.shared"
-
-/** @internal Exported for testing */
-export { runPromptQueue } from "./runtime.queue"
-
-type BootContext = Pick<RunInput, "sdk" | "directory" | "sessionID" | "sessionTitle" | "agent" | "model" | "variant">
-
-type RunRuntimeInput = {
-  boot: () => Promise<BootContext>
-  afterPaint?: (ctx: BootContext) => Promise<void> | void
-  files: RunInput["files"]
-  initialInput?: string
-  thinking: boolean
-  demo?: RunInput["demo"]
-  demoText?: RunInput["demoText"]
-}
-
-type RunLocalInput = {
-  directory: string
-  fetch: typeof globalThis.fetch
-  resolveAgent: () => Promise<string | undefined>
-  session: (sdk: RunInput["sdk"]) => Promise<{ id: string; title?: string } | undefined>
-  share: (sdk: RunInput["sdk"], sessionID: string) => Promise<void>
-  agent: RunInput["agent"]
-  model: RunInput["model"]
-  variant: RunInput["variant"]
-  files: RunInput["files"]
-  initialInput?: string
-  thinking: boolean
-  demo?: RunInput["demo"]
-  demoText?: RunInput["demoText"]
-}
-
-// Core runtime loop. Boot resolves the SDK context, then we set up the
-// lifecycle (renderer + footer), wire the stream transport for SDK events,
-// and feed prompts through the queue until the user exits.
-//
-// Files only attach on the first prompt turn -- after that, includeFiles
-// flips to false so subsequent turns don't re-send attachments.
-async function runInteractiveRuntime(input: RunRuntimeInput): Promise<void> {
-  const log = trace()
-  const keybindTask = resolveFooterKeybinds()
-  const diffTask = resolveDiffStyle()
-  const ctx = await input.boot()
-  const modelTask = resolveModelInfo(ctx.sdk, ctx.model)
-  const sessionTask = resolveSessionInfo(ctx.sdk, ctx.sessionID, ctx.model)
-  const savedTask = resolveSavedVariant(ctx.model)
-  const agentsTask = ctx.sdk.app
-    .agents({ directory: ctx.directory })
-    .then((x) => x.data ?? [])
-    .catch(() => [])
-  const resourcesTask = ctx.sdk.experimental.resource
-    .list({ directory: ctx.directory })
-    .then((x) => Object.values(x.data ?? {}))
-    .catch(() => [])
-  let variants: string[] = []
-  let limits: Record<string, number> = {}
-  let aborting = false
-  let shown = false
-  let demo: ReturnType<typeof createRunDemo> | undefined
-  const [keybinds, diffStyle, session, savedVariant, agents, resources] = await Promise.all([
-    keybindTask,
-    diffTask,
-    sessionTask,
-    savedTask,
-    agentsTask,
-    resourcesTask,
-  ])
-  shown = !session.first
-  let activeVariant = resolveVariant(ctx.variant, session.variant, savedVariant, variants)
-
-  const shell = await createRuntimeLifecycle({
-    directory: ctx.directory,
-    findFiles: (query) =>
-      ctx.sdk.find
-        .files({ query, directory: ctx.directory })
-        .then((x) => x.data ?? [])
-        .catch(() => []),
-    agents,
-    resources,
-    sessionID: ctx.sessionID,
-    sessionTitle: ctx.sessionTitle,
-    first: session.first,
-    history: session.history,
-    agent: ctx.agent,
-    model: ctx.model,
-    variant: activeVariant,
-    keybinds,
-    diffStyle,
-    onPermissionReply: async (next) => {
-      if (demo?.permission(next)) {
-        return
-      }
-
-      log?.write("send.permission.reply", next)
-      await ctx.sdk.permission.reply(next)
-    },
-    onQuestionReply: async (next) => {
-      if (demo?.questionReply(next)) {
-        return
-      }
-
-      await ctx.sdk.question.reply(next)
-    },
-    onQuestionReject: async (next) => {
-      if (demo?.questionReject(next)) {
-        return
-      }
-
-      await ctx.sdk.question.reject(next)
-    },
-    onCycleVariant: () => {
-      if (!ctx.model || variants.length === 0) {
-        return {
-          status: "no variants available",
-        }
-      }
-
-      activeVariant = cycleVariant(activeVariant, variants)
-      saveVariant(ctx.model, activeVariant)
-      return {
-        status: activeVariant ? `variant ${activeVariant}` : "variant default",
-        modelLabel: formatModelLabel(ctx.model, activeVariant),
-      }
-    },
-    onInterrupt: () => {
-      if (aborting) {
-        return
-      }
-
-      aborting = true
-      void ctx.sdk.session
-        .abort({
-          sessionID: ctx.sessionID,
-        })
-        .catch(() => {})
-        .finally(() => {
-          aborting = false
-        })
-    },
-  })
-  const footer = shell.footer
-
-  if (input.demo) {
-    demo = createRunDemo({
-      mode: input.demo,
-      text: input.demoText,
-      footer,
-      sessionID: ctx.sessionID,
-      thinking: input.thinking,
-      limits: () => limits,
-    })
-  }
-
-  if (input.afterPaint) {
-    void Promise.resolve(input.afterPaint(ctx)).catch(() => {})
-  }
-
-  void modelTask.then((info) => {
-    variants = info.variants
-    limits = info.limits
-
-    const next = resolveVariant(ctx.variant, session.variant, savedVariant, variants)
-    if (next === activeVariant) {
-      return
-    }
-
-    activeVariant = next
-    if (!ctx.model || footer.isClosed) {
-      return
-    }
-
-    footer.event({
-      type: "model",
-      model: formatModelLabel(ctx.model, activeVariant),
-    })
-  })
-
-  try {
-    const mod = await import("./stream.transport")
-    let includeFiles = true
-    const stream = await mod.createSessionTransport({
-      sdk: ctx.sdk,
-      sessionID: ctx.sessionID,
-      thinking: input.thinking,
-      limits: () => limits,
-      footer,
-      trace: log,
-    })
-
-    try {
-      if (demo) {
-        await demo.start()
-      }
-
-      const queue = await import("./runtime.queue")
-      await queue.runPromptQueue({
-        footer,
-        initialInput: input.initialInput,
-        trace: log,
-        onPrompt: () => {
-          shown = true
-        },
-        run: async (prompt, signal) => {
-          if (demo && (await demo.prompt(prompt, signal))) {
-            return
-          }
-
-          try {
-            await stream.runPromptTurn({
-              agent: ctx.agent,
-              model: ctx.model,
-              variant: activeVariant,
-              prompt,
-              files: input.files,
-              includeFiles,
-              signal,
-            })
-            includeFiles = false
-          } catch (error) {
-            if (signal.aborted || footer.isClosed) {
-              return
-            }
-            footer.append({ kind: "error", text: mod.formatUnknownError(error), phase: "start", source: "system" })
-          }
-        },
-      })
-    } finally {
-      await stream.close()
-    }
-  } finally {
-    const title = shown
-      ? await ctx.sdk.session
-          .get({
-            sessionID: ctx.sessionID,
-          })
-          .then((x) => x.data?.title)
-          .catch(() => undefined)
-      : undefined
-
-    await shell.close({
-      showExit: shown,
-      sessionTitle: title,
-    })
-  }
-}
-
-// Local in-process mode. Creates an SDK client backed by a direct fetch to
-// the in-process server, so no external HTTP server is needed.
-export async function runInteractiveLocalMode(input: RunLocalInput): Promise<void> {
-  const sdk = createOpencodeClient({
-    baseUrl: "http://opencode.internal",
-    fetch: input.fetch,
-    directory: input.directory,
-  })
-
-  return runInteractiveRuntime({
-    files: input.files,
-    initialInput: input.initialInput,
-    thinking: input.thinking,
-    demo: input.demo,
-    demoText: input.demoText,
-    afterPaint: (ctx) => input.share(ctx.sdk, ctx.sessionID),
-    boot: async () => {
-      const agent = await input.resolveAgent()
-      const session = await input.session(sdk)
-      if (!session?.id) {
-        throw new Error("Session not found")
-      }
-
-      return {
-        sdk,
-        directory: input.directory,
-        sessionID: session.id,
-        sessionTitle: session.title,
-        agent,
-        model: input.model,
-        variant: input.variant,
-      }
-    },
-  })
-}
-
-// Attach mode. Uses the caller-provided SDK client directly.
-export async function runInteractiveMode(input: RunInput): Promise<void> {
-  return runInteractiveRuntime({
-    files: input.files,
-    initialInput: input.initialInput,
-    thinking: input.thinking,
-    demo: input.demo,
-    demoText: input.demoText,
-    boot: async () => ({
-      sdk: input.sdk,
-      directory: input.directory,
-      sessionID: input.sessionID,
-      sessionTitle: input.sessionTitle,
-      agent: input.agent,
-      model: input.model,
-      variant: input.variant,
-    }),
-  })
-}

packages/opencode/src/cli/cmd/run/scrollback.format.ts

@@ -1,92 +0,0 @@
-// Text normalization for scrollback entries.
-//
-// Transforms a StreamCommit into the final text that will be appended to
-// terminal scrollback. Each entry kind has its own formatting:
-//
-//   user       → prefixed with "› "
-//   assistant  → raw text (progress), empty (start/final unless interrupted)
-//   reasoning  → raw text with [REDACTED] stripped
-//   tool       → delegated to tool.ts for per-tool scrollback formatting
-//   error/system → raw trimmed text
-//
-// Returns an empty string when the commit should produce no visible output
-// (e.g., assistant start events, empty final events).
-import { toolFrame, toolScroll, toolView } from "./tool"
-import type { StreamCommit } from "./types"
-
-export function clean(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
-}
-
-function toolText(commit: StreamCommit, raw: string): string {
-  const ctx = toolFrame(commit, raw)
-  const view = toolView(ctx.name)
-
-  if (commit.phase === "progress" && !view.output) {
-    return ""
-  }
-
-  if (commit.phase === "final") {
-    if (ctx.status === "error") {
-      return toolScroll("final", ctx)
-    }
-
-    if (!view.final) {
-      return ""
-    }
-
-    if (ctx.status && ctx.status !== "completed") {
-      return ctx.raw.trim()
-    }
-  }
-
-  return toolScroll(commit.phase, ctx)
-}
-
-export function normalizeEntry(commit: StreamCommit): string {
-  const raw = clean(commit.text)
-
-  if (commit.kind === "user") {
-    if (!raw.trim()) {
-      return ""
-    }
-
-    const lead = raw.match(/^\n+/)?.[0] ?? ""
-    const body = lead ? raw.slice(lead.length) : raw
-    return `${lead}› ${body}`
-  }
-
-  if (commit.kind === "tool") {
-    return toolText(commit, raw)
-  }
-
-  if (commit.kind === "assistant") {
-    if (commit.phase === "start") {
-      return ""
-    }
-
-    if (commit.phase === "final") {
-      return commit.interrupted ? "assistant interrupted" : ""
-    }
-
-    return raw
-  }
-
-  if (commit.kind === "reasoning") {
-    if (commit.phase === "start") {
-      return ""
-    }
-
-    if (commit.phase === "final") {
-      return commit.interrupted ? "reasoning interrupted" : ""
-    }
-
-    return raw.replace(/\[REDACTED\]/g, "")
-  }
-
-  if (commit.phase === "start" || commit.phase === "final") {
-    return raw.trim()
-  }
-
-  return raw
-}

packages/opencode/src/cli/cmd/run/scrollback.tsx

@@ -1,26 +0,0 @@
-// Entry writer routing for scrollback commits.
-//
-// Decides whether a commit should render as plain text or as a rich snapshot
-// (code block, diff view, task card, etc.). Completed tool parts whose tool
-// rule has a "snap" mode get routed to snapEntryWriter, which produces a
-// structured JSX snapshot. Everything else goes through textEntryWriter.
-import type { ScrollbackWriter } from "@opentui/core"
-import { toolView } from "./tool"
-import { snapEntryWriter, textEntryWriter } from "./scrollback.writer"
-import { RUN_THEME_FALLBACK, type RunTheme } from "./theme"
-import type { ScrollbackOptions, StreamCommit } from "./types"
-
-export function entryWriter(
-  commit: StreamCommit,
-  theme: RunTheme = RUN_THEME_FALLBACK,
-  opts: ScrollbackOptions = {},
-): ScrollbackWriter {
-  const state = commit.toolState ?? commit.part?.state.status
-  if (commit.kind === "tool" && commit.phase === "final" && state === "completed") {
-    if (toolView(commit.tool).snap) {
-      return snapEntryWriter(commit, theme, opts)
-    }
-  }
-
-  return textEntryWriter(commit, theme.entry)
-}

packages/opencode/src/cli/cmd/run/scrollback.writer.tsx

@@ -1,641 +0,0 @@
-// JSX-based scrollback snapshot writers for rich tool output.
-//
-// When a tool commit has a "snap" mode (code, diff, task, todo, question),
-// snapEntryWriter renders it as a structured JSX tree that OpenTUI converts
-// into a ScrollbackSnapshot. These snapshots support syntax highlighting,
-// unified/split diffs, line numbers, and LSP diagnostics.
-//
-// The writers use OpenTUI's createScrollbackWriter to produce snapshots.
-// OpenTUI measures and reflows them when the terminal resizes. The fit()
-// helper measures actual rendered width so narrow content doesn't claim
-// the full terminal width.
-//
-// Plain text entries (textEntryWriter) also go through here -- they just
-// produce a simple <text> element with the right color and attributes.
-/** @jsxImportSource @opentui/solid */
-
-import {
-  SyntaxStyle,
-  TextAttributes,
-  type ColorInput,
-  type ScrollbackRenderContext,
-  type ScrollbackSnapshot,
-  type ScrollbackWriter,
-} from "@opentui/core"
-import { createScrollbackWriter, type JSX } from "@opentui/solid"
-import { For, Show } from "solid-js"
-import { Filesystem } from "../../../util/filesystem"
-import { toolDiffView, toolFiletype, toolFrame, toolSnapshot } from "./tool"
-import { clean, normalizeEntry } from "./scrollback.format"
-import { RUN_THEME_FALLBACK, type RunEntryTheme, type RunTheme } from "./theme"
-import type { ScrollbackOptions, StreamCommit } from "./types"
-
-type ToolDict = Record<string, unknown>
-
-function dict(v: unknown): ToolDict {
-  if (!v || typeof v !== "object") {
-    return {}
-  }
-
-  return v as ToolDict
-}
-
-function text(v: unknown): string {
-  return typeof v === "string" ? v : ""
-}
-
-function arr(v: unknown): unknown[] {
-  return Array.isArray(v) ? v : []
-}
-
-function num(v: unknown): number | undefined {
-  if (typeof v !== "number" || !Number.isFinite(v)) {
-    return
-  }
-
-  return v
-}
-
-function diagnostics(meta: ToolDict, file: string): string[] {
-  const all = dict(meta.diagnostics)
-  const key = Filesystem.normalizePath(file)
-  const list = arr(all[key]).map(dict)
-  return list
-    .filter((item) => item.severity === 1)
-    .slice(0, 3)
-    .map((item) => {
-      const range = dict(item.range)
-      const start = dict(range.start)
-      const line = num(start.line)
-      const char = num(start.character)
-      const msg = text(item.message)
-      if (line === undefined || char === undefined) {
-        return `Error ${msg}`.trim()
-      }
-
-      return `Error [${line + 1}:${char + 1}] ${msg}`.trim()
-    })
-}
-
-type Flags = {
-  startOnNewLine: boolean
-  trailingNewline: boolean
-}
-
-type Paint = {
-  fg: ColorInput
-  attrs?: number
-}
-
-type CodeInput = {
-  title: string
-  content: string
-  filetype?: string
-  diagnostics: string[]
-}
-
-type DiffInput = {
-  title: string
-  diff?: string
-  filetype?: string
-  deletions?: number
-  diagnostics: string[]
-}
-
-type TaskInput = {
-  title: string
-  rows: string[]
-  tail: string
-}
-
-type TodoInput = {
-  items: Array<{
-    status: string
-    content: string
-  }>
-  tail: string
-}
-
-type QuestionInput = {
-  items: Array<{
-    question: string
-    answer: string
-  }>
-  tail: string
-}
-
-type Measure = {
-  widthColsMax: number
-}
-
-type MeasureNode = {
-  textBufferView?: {
-    measureForDimensions(width: number, height: number): Measure | null
-  }
-  getChildren?: () => unknown[]
-}
-
-let bare: SyntaxStyle | undefined
-
-function syntax(style?: SyntaxStyle): SyntaxStyle {
-  if (style) {
-    return style
-  }
-
-  bare ??= SyntaxStyle.fromTheme([])
-  return bare
-}
-
-function failed(commit: StreamCommit): boolean {
-  return commit.kind === "tool" && (commit.toolState === "error" || commit.part?.state.status === "error")
-}
-
-function look(commit: StreamCommit, theme: RunEntryTheme): Paint {
-  if (commit.kind === "user") {
-    return {
-      fg: theme.user.body,
-      attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (failed(commit)) {
-    return {
-      fg: theme.error.body,
-      attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (commit.phase === "final") {
-    return {
-      fg: theme.system.body,
-      attrs: TextAttributes.DIM,
-    }
-  }
-
-  if (commit.kind === "tool" && commit.phase === "start") {
-    return {
-      fg: theme.tool.start ?? theme.tool.body,
-    }
-  }
-
-  if (commit.kind === "assistant") {
-    return { fg: theme.assistant.body }
-  }
-
-  if (commit.kind === "reasoning") {
-    return {
-      fg: theme.reasoning.body,
-      attrs: TextAttributes.DIM,
-    }
-  }
-
-  if (commit.kind === "error") {
-    return {
-      fg: theme.error.body,
-      attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (commit.kind === "tool") {
-    return { fg: theme.tool.body }
-  }
-
-  return { fg: theme.system.body }
-}
-
-function cols(ctx: ScrollbackRenderContext): number {
-  return Math.max(1, Math.trunc(ctx.width))
-}
-
-function leaf(node: unknown): MeasureNode | undefined {
-  if (!node || typeof node !== "object") {
-    return
-  }
-
-  const next = node as MeasureNode
-  if (next.textBufferView) {
-    return next
-  }
-
-  const list = next.getChildren?.() ?? []
-  for (const child of list) {
-    const out = leaf(child)
-    if (out) {
-      return out
-    }
-  }
-}
-
-function fit(snapshot: ScrollbackSnapshot, ctx: ScrollbackRenderContext) {
-  const node = leaf(snapshot.root)
-  const width = cols(ctx)
-  const box = node?.textBufferView?.measureForDimensions(width, Math.max(1, snapshot.height ?? 1))
-  const rowColumns = Math.max(1, Math.min(width, box?.widthColsMax ?? 0))
-
-  snapshot.width = width
-  snapshot.rowColumns = rowColumns
-  return snapshot
-}
-
-function full(node: () => JSX.Element, ctx: ScrollbackRenderContext, flags: Flags) {
-  return createScrollbackWriter(node, {
-    width: cols(ctx),
-    rowColumns: cols(ctx),
-    startOnNewLine: flags.startOnNewLine,
-    trailingNewline: flags.trailingNewline,
-  })(ctx)
-}
-
-function TextEntry(props: { body: string; fg: ColorInput; attrs?: number }) {
-  return (
-    <text width="100%" wrapMode="word" fg={props.fg} attributes={props.attrs}>
-      {props.body}
-    </text>
-  )
-}
-
-function thinking(body: string) {
-  const mark = "Thinking: "
-  if (body.startsWith(mark)) {
-    return {
-      head: mark,
-      tail: body.slice(mark.length),
-    }
-  }
-
-  return {
-    tail: body,
-  }
-}
-
-function ReasoningEntry(props: { body: string; theme: RunEntryTheme }) {
-  const part = thinking(props.body)
-  return (
-    <text
-      width="100%"
-      wrapMode="word"
-      fg={props.theme.reasoning.body}
-      attributes={TextAttributes.DIM | TextAttributes.ITALIC}
-    >
-      <Show when={part.head}>{part.head}</Show>
-      {part.tail}
-    </text>
-  )
-}
-
-function Diagnostics(props: { theme: RunTheme; lines: string[] }) {
-  return (
-    <Show when={props.lines.length > 0}>
-      <box>
-        <For each={props.lines}>{(line) => <text fg={props.theme.entry.error.body}>{line}</text>}</For>
-      </box>
-    </Show>
-  )
-}
-
-function BlockTool(props: { theme: RunTheme; title: string; children: JSX.Element }) {
-  return (
-    <box flexDirection="column" gap={1}>
-      <text fg={props.theme.block.muted} attributes={TextAttributes.DIM}>
-        {props.title}
-      </text>
-      {props.children}
-    </box>
-  )
-}
-
-function CodeTool(props: { theme: RunTheme; data: CodeInput }) {
-  return (
-    <BlockTool theme={props.theme} title={props.data.title}>
-      <line_number fg={props.theme.block.muted} minWidth={3} paddingRight={1}>
-        <code
-          conceal={false}
-          fg={props.theme.block.text}
-          filetype={props.data.filetype}
-          syntaxStyle={syntax(props.theme.block.syntax)}
-          content={props.data.content}
-          drawUnstyledText={true}
-          wrapMode="word"
-        />
-      </line_number>
-      <Diagnostics theme={props.theme} lines={props.data.diagnostics} />
-    </BlockTool>
-  )
-}
-
-function DiffTool(props: { theme: RunTheme; data: DiffInput; view: "unified" | "split" }) {
-  return (
-    <BlockTool theme={props.theme} title={props.data.title}>
-      <Show
-        when={props.data.diff?.trim()}
-        fallback={
-          <text fg={props.theme.block.diffRemoved}>
-            -{props.data.deletions ?? 0} line{props.data.deletions === 1 ? "" : "s"}
-          </text>
-        }
-      >
-        <box>
-          <diff
-            diff={props.data.diff ?? ""}
-            view={props.view}
-            filetype={props.data.filetype}
-            syntaxStyle={syntax(props.theme.block.syntax)}
-            showLineNumbers={true}
-            width="100%"
-            wrapMode="word"
-            fg={props.theme.block.text}
-            addedBg={props.theme.block.diffAddedBg}
-            removedBg={props.theme.block.diffRemovedBg}
-            contextBg={props.theme.block.diffContextBg}
-            addedSignColor={props.theme.block.diffHighlightAdded}
-            removedSignColor={props.theme.block.diffHighlightRemoved}
-            lineNumberFg={props.theme.block.diffLineNumber}
-            lineNumberBg={props.theme.block.diffContextBg}
-            addedLineNumberBg={props.theme.block.diffAddedLineNumberBg}
-            removedLineNumberBg={props.theme.block.diffRemovedLineNumberBg}
-          />
-        </box>
-      </Show>
-      <Diagnostics theme={props.theme} lines={props.data.diagnostics} />
-    </BlockTool>
-  )
-}
-
-function TaskTool(props: { theme: RunTheme; data: TaskInput }) {
-  return (
-    <BlockTool theme={props.theme} title={props.data.title}>
-      <box>
-        <For each={props.data.rows}>{(line) => <text fg={props.theme.block.text}>{line}</text>}</For>
-      </box>
-      <text fg={props.theme.block.muted} attributes={TextAttributes.DIM}>
-        {props.data.tail}
-      </text>
-    </BlockTool>
-  )
-}
-
-function todoMark(status: string): string {
-  if (status === "completed") {
-    return "[x]"
-  }
-  if (status === "in_progress") {
-    return "[>]"
-  }
-  if (status === "cancelled") {
-    return "[-]"
-  }
-  return "[ ]"
-}
-
-function TodoTool(props: { theme: RunTheme; data: TodoInput }) {
-  return (
-    <BlockTool theme={props.theme} title="# Todos">
-      <box>
-        <For each={props.data.items}>
-          {(item) => (
-            <text fg={props.theme.block.text}>
-              {todoMark(item.status)} {item.content}
-            </text>
-          )}
-        </For>
-      </box>
-      <text fg={props.theme.block.muted} attributes={TextAttributes.DIM}>
-        {props.data.tail}
-      </text>
-    </BlockTool>
-  )
-}
-
-function QuestionTool(props: { theme: RunTheme; data: QuestionInput }) {
-  return (
-    <BlockTool theme={props.theme} title="# Questions">
-      <text fg={props.theme.block.muted} attributes={TextAttributes.DIM}>
-        {props.data.tail}
-      </text>
-      <box gap={1}>
-        <For each={props.data.items}>
-          {(item) => (
-            <box flexDirection="column">
-              <text fg={props.theme.block.muted}>{item.question}</text>
-              <text fg={props.theme.block.text}>{item.answer}</text>
-            </box>
-          )}
-        </For>
-      </box>
-    </BlockTool>
-  )
-}
-
-function textWriter(body: string, commit: StreamCommit, theme: RunEntryTheme, flags: Flags): ScrollbackWriter {
-  const style = look(commit, theme)
-  return (ctx) =>
-    fit(
-      createScrollbackWriter(() => <TextEntry body={body} fg={style.fg} attrs={style.attrs} />, {
-        width: cols(ctx),
-        startOnNewLine: flags.startOnNewLine,
-        trailingNewline: flags.trailingNewline,
-      })(ctx),
-      ctx,
-    )
-}
-
-function reasoningWriter(body: string, theme: RunEntryTheme, flags: Flags): ScrollbackWriter {
-  return (ctx) =>
-    fit(
-      createScrollbackWriter(() => <ReasoningEntry body={body} theme={theme} />, {
-        width: cols(ctx),
-        startOnNewLine: flags.startOnNewLine,
-        trailingNewline: flags.trailingNewline,
-      })(ctx),
-      ctx,
-    )
-}
-
-function blankWriter(): ScrollbackWriter {
-  return (ctx) =>
-    createScrollbackWriter(() => <text width="100%" />, {
-      width: cols(ctx),
-      startOnNewLine: true,
-      trailingNewline: true,
-    })(ctx)
-}
-
-function textBlockWriter(body: string, theme: RunEntryTheme): ScrollbackWriter {
-  return (ctx) =>
-    full(() => <TextEntry body={body.endsWith("\n") ? body : `${body}\n`} fg={theme.system.body} />, ctx, {
-      startOnNewLine: true,
-      trailingNewline: false,
-    })
-}
-
-function codeWriter(data: CodeInput, theme: RunTheme, flags: Flags): ScrollbackWriter {
-  return (ctx) => full(() => <CodeTool theme={theme} data={data} />, ctx, flags)
-}
-
-function diffWriter(list: DiffInput[], theme: RunTheme, flags: Flags, view: "unified" | "split"): ScrollbackWriter {
-  return (ctx) =>
-    full(
-      () => (
-        <box flexDirection="column" gap={1}>
-          <For each={list}>{(data) => <DiffTool theme={theme} data={data} view={view} />}</For>
-        </box>
-      ),
-      ctx,
-      flags,
-    )
-}
-
-function taskWriter(data: TaskInput, theme: RunTheme, flags: Flags): ScrollbackWriter {
-  return (ctx) => full(() => <TaskTool theme={theme} data={data} />, ctx, flags)
-}
-
-function todoWriter(data: TodoInput, theme: RunTheme, flags: Flags): ScrollbackWriter {
-  return (ctx) => full(() => <TodoTool theme={theme} data={data} />, ctx, flags)
-}
-
-function questionWriter(data: QuestionInput, theme: RunTheme, flags: Flags): ScrollbackWriter {
-  return (ctx) => full(() => <QuestionTool theme={theme} data={data} />, ctx, flags)
-}
-
-function flags(commit: StreamCommit): Flags {
-  if (commit.kind === "user") {
-    return {
-      startOnNewLine: true,
-      trailingNewline: false,
-    }
-  }
-
-  if (commit.kind === "tool") {
-    if (commit.phase === "progress") {
-      return {
-        startOnNewLine: false,
-        trailingNewline: false,
-      }
-    }
-
-    return {
-      startOnNewLine: true,
-      trailingNewline: true,
-    }
-  }
-
-  if (commit.kind === "assistant" || commit.kind === "reasoning") {
-    if (commit.phase === "progress") {
-      return {
-        startOnNewLine: false,
-        trailingNewline: false,
-      }
-    }
-
-    return {
-      startOnNewLine: true,
-      trailingNewline: true,
-    }
-  }
-
-  return {
-    startOnNewLine: true,
-    trailingNewline: true,
-  }
-}
-
-export function textEntryWriter(commit: StreamCommit, theme: RunEntryTheme): ScrollbackWriter {
-  const body = normalizeEntry(commit)
-  const snap = flags(commit)
-  if (commit.kind === "reasoning") {
-    return reasoningWriter(body, theme, snap)
-  }
-
-  return textWriter(body, commit, theme, snap)
-}
-
-export function snapEntryWriter(commit: StreamCommit, theme: RunTheme, opts: ScrollbackOptions): ScrollbackWriter {
-  const snap = toolSnapshot(commit, clean(commit.text))
-  if (!snap) {
-    return textEntryWriter(commit, theme.entry)
-  }
-
-  const info = toolFrame(commit, clean(commit.text))
-  const style = flags(commit)
-
-  if (snap.kind === "code") {
-    return codeWriter(
-      {
-        title: snap.title,
-        content: snap.content,
-        filetype: toolFiletype(snap.file),
-        diagnostics: diagnostics(info.meta, snap.file ?? ""),
-      },
-      theme,
-      style,
-    )
-  }
-
-  if (snap.kind === "diff") {
-    if (snap.items.length === 0) {
-      return textEntryWriter(commit, theme.entry)
-    }
-
-    const list = snap.items
-      .map((item) => {
-        if (!item.diff.trim()) {
-          return
-        }
-
-        return {
-          title: item.title,
-          diff: item.diff,
-          filetype: toolFiletype(item.file),
-          deletions: item.deletions,
-          diagnostics: diagnostics(info.meta, item.file ?? ""),
-        }
-      })
-      .filter((item): item is NonNullable<typeof item> => Boolean(item))
-
-    if (list.length === 0) {
-      return textEntryWriter(commit, theme.entry)
-    }
-
-    return (ctx) => diffWriter(list, theme, style, toolDiffView(ctx.width, opts.diffStyle))(ctx)
-  }
-
-  if (snap.kind === "task") {
-    return taskWriter(
-      {
-        title: snap.title,
-        rows: snap.rows,
-        tail: snap.tail,
-      },
-      theme,
-      style,
-    )
-  }
-
-  if (snap.kind === "todo") {
-    return todoWriter(
-      {
-        items: snap.items,
-        tail: snap.tail,
-      },
-      theme,
-      style,
-    )
-  }
-
-  return questionWriter(
-    {
-      items: snap.items,
-      tail: snap.tail,
-    },
-    theme,
-    style,
-  )
-}
-
-export function blockWriter(text: string, theme: RunEntryTheme = RUN_THEME_FALLBACK.entry): ScrollbackWriter {
-  return textBlockWriter(clean(text), theme)
-}
-
-export function spacerWriter(): ScrollbackWriter {
-  return blankWriter()
-}

packages/opencode/src/cli/cmd/run/session-data.ts

@@ -1,881 +0,0 @@
-// Core reducer for direct interactive mode.
-//
-// Takes raw SDK events and produces two outputs:
-//   - StreamCommit[]: append-only scrollback entries (text, tool, error, etc.)
-//   - FooterOutput:   status bar patches and view transitions (permission, question)
-//
-// The reducer mutates SessionData in place for performance but has no
-// external side effects -- no IO, no footer calls. The caller
-// (stream.transport.ts) feeds events in and forwards output to the footer
-// through stream.ts.
-//
-// Key design decisions:
-//
-// - Text parts buffer in `data.text` until their message role is confirmed as
-//   "assistant". This prevents echoing user-role text parts. The `ready()`
-//   check gates output: if we see a text delta before the message.updated
-//   event that tells us the role, we stash it and flush later via `replay()`.
-//
-// - Tool echo stripping: bash tools may echo their own output in the next
-//   assistant text part. `stashEcho()` records completed bash output, and
-//   `stripEcho()` removes it from the start of the next assistant chunk.
-//
-// - Permission and question requests queue in `data.permissions` and
-//   `data.questions`. The footer shows whichever is first. When a reply
-//   event arrives, the queue entry is removed and the footer falls back
-//   to the next pending request or to the prompt view.
-import type { Event, PermissionRequest, QuestionRequest, ToolPart } from "@opencode-ai/sdk/v2"
-import { Locale } from "../../../util/locale"
-import { toolView } from "./tool"
-import type { FooterOutput, FooterPatch, FooterView, StreamCommit } from "./types"
-
-const money = new Intl.NumberFormat("en-US", {
-  style: "currency",
-  currency: "USD",
-})
-
-type Tokens = {
-  input?: number
-  output?: number
-  reasoning?: number
-  cache?: {
-    read?: number
-    write?: number
-  }
-}
-
-type PartKind = "assistant" | "reasoning"
-type MessageRole = "assistant" | "user"
-type Dict = Record<string, unknown>
-type SessionCommit = StreamCommit
-
-// Mutable accumulator for the reducer. Each field tracks a different aspect
-// of the stream so we can produce correct incremental output:
-//
-// - ids:    parts and error keys we've already committed (dedup guard)
-// - tools:  tool parts we've emitted a "start" for but not yet completed
-// - call:   tool call inputs, keyed by msg:call, for enriching permission views
-// - role:   message ID → "assistant" | "user", learned from message.updated
-// - msg:    part ID → message ID
-// - part:   part ID → "assistant" | "reasoning" (text parts only)
-// - text:   part ID → full accumulated text so far
-// - sent:   part ID → byte offset of last flushed text (for incremental output)
-// - end:    part IDs whose time.end has arrived (part is finished)
-// - echo:   message ID → bash outputs to strip from the next assistant chunk
-export type SessionData = {
-  announced: boolean
-  ids: Set<string>
-  tools: Set<string>
-  call: Map<string, Dict>
-  permissions: PermissionRequest[]
-  questions: QuestionRequest[]
-  role: Map<string, MessageRole>
-  msg: Map<string, string>
-  part: Map<string, PartKind>
-  text: Map<string, string>
-  sent: Map<string, number>
-  end: Set<string>
-  echo: Map<string, Set<string>>
-}
-
-export type SessionDataInput = {
-  data: SessionData
-  event: Event
-  sessionID: string
-  thinking: boolean
-  limits: Record<string, number>
-}
-
-export type SessionDataOutput = {
-  data: SessionData
-  commits: SessionCommit[]
-  footer?: FooterOutput
-}
-
-export function createSessionData(): SessionData {
-  return {
-    announced: false,
-    ids: new Set(),
-    tools: new Set(),
-    call: new Map(),
-    permissions: [],
-    questions: [],
-    role: new Map(),
-    msg: new Map(),
-    part: new Map(),
-    text: new Map(),
-    sent: new Map(),
-    end: new Set(),
-    echo: new Map(),
-  }
-}
-
-function modelKey(provider: string, model: string): string {
-  return `${provider}/${model}`
-}
-
-function formatUsage(
-  tokens: Tokens | undefined,
-  limit: number | undefined,
-  cost: number | undefined,
-): string | undefined {
-  const total =
-    (tokens?.input ?? 0) +
-    (tokens?.output ?? 0) +
-    (tokens?.reasoning ?? 0) +
-    (tokens?.cache?.read ?? 0) +
-    (tokens?.cache?.write ?? 0)
-
-  if (total <= 0) {
-    if (typeof cost === "number" && cost > 0) {
-      return money.format(cost)
-    }
-    return
-  }
-
-  const text =
-    limit && limit > 0 ? `${Locale.number(total)} (${Math.round((total / limit) * 100)}%)` : Locale.number(total)
-
-  if (typeof cost === "number" && cost > 0) {
-    return `${text} · ${money.format(cost)}`
-  }
-
-  return text
-}
-
-function formatError(error: {
-  name?: string
-  message?: string
-  data?: {
-    message?: string
-  }
-}): string {
-  if (error.data?.message) {
-    return String(error.data.message)
-  }
-
-  if (error.message) {
-    return String(error.message)
-  }
-
-  if (error.name) {
-    return String(error.name)
-  }
-
-  return "unknown error"
-}
-
-function isAbort(error: { name?: string } | undefined): boolean {
-  return error?.name === "MessageAbortedError"
-}
-
-function msgErr(id: string): string {
-  return `msg:${id}:error`
-}
-
-function patch(patch?: FooterPatch, view?: FooterView): FooterOutput | undefined {
-  if (!patch && !view) {
-    return
-  }
-
-  return {
-    patch,
-    view,
-  }
-}
-
-function out(data: SessionData, commits: SessionCommit[], footer?: FooterOutput): SessionDataOutput {
-  if (!footer) {
-    return {
-      data,
-      commits,
-    }
-  }
-
-  return {
-    data,
-    commits,
-    footer,
-  }
-}
-
-function pickView(data: SessionData): FooterView {
-  const permission = data.permissions[0]
-  if (permission) {
-    return { type: "permission", request: permission }
-  }
-
-  const question = data.questions[0]
-  if (question) {
-    return { type: "question", request: question }
-  }
-
-  return { type: "prompt" }
-}
-
-function queueFooter(data: SessionData): FooterOutput {
-  const view = pickView(data)
-  if (view.type === "permission") {
-    return {
-      view,
-      patch: { status: "awaiting permission" },
-    }
-  }
-
-  if (view.type === "question") {
-    return {
-      view,
-      patch: { status: "awaiting answer" },
-    }
-  }
-
-  return {
-    view,
-    patch: { status: "" },
-  }
-}
-
-function upsert<T extends { id: string }>(list: T[], item: T) {
-  const idx = list.findIndex((entry) => entry.id === item.id)
-  if (idx === -1) {
-    list.push(item)
-    return
-  }
-
-  list[idx] = item
-}
-
-function remove<T extends { id: string }>(list: T[], id: string): boolean {
-  const idx = list.findIndex((entry) => entry.id === id)
-  if (idx === -1) {
-    return false
-  }
-
-  list.splice(idx, 1)
-  return true
-}
-
-function key(msg: string, call: string): string {
-  return `${msg}:${call}`
-}
-
-function enrichPermission(data: SessionData, request: PermissionRequest): PermissionRequest {
-  if (!request.tool) {
-    return request
-  }
-
-  const input = data.call.get(key(request.tool.messageID, request.tool.callID))
-  if (!input) {
-    return request
-  }
-
-  const meta = request.metadata ?? {}
-  if (meta.input === input) {
-    return request
-  }
-
-  return {
-    ...request,
-    metadata: {
-      ...meta,
-      input,
-    },
-  }
-}
-
-// Updates the active permission request when the matching tool part gets
-// new input (e.g., a diff). This keeps the permission UI in sync with the
-// tool's evolving state. Only triggers a footer update if the currently
-// displayed permission was the one that changed.
-function syncPermission(data: SessionData, part: ToolPart): FooterOutput | undefined {
-  data.call.set(key(part.messageID, part.callID), part.state.input)
-  if (data.permissions.length === 0) {
-    return
-  }
-
-  let changed = false
-  let active = false
-  data.permissions = data.permissions.map((request, index) => {
-    if (!request.tool || request.tool.messageID !== part.messageID || request.tool.callID !== part.callID) {
-      return request
-    }
-
-    const next = enrichPermission(data, request)
-    if (next === request) {
-      return request
-    }
-
-    changed = true
-    active ||= index === 0
-    return next
-  })
-
-  if (!changed || !active) {
-    return
-  }
-
-  return {
-    view: pickView(data),
-  }
-}
-
-function toolStatus(part: ToolPart): string {
-  if (part.tool !== "task") {
-    return `running ${part.tool}`
-  }
-
-  const state = part.state as {
-    input?: {
-      description?: unknown
-      subagent_type?: unknown
-    }
-  }
-  const desc = state.input?.description
-  if (typeof desc === "string" && desc.trim()) {
-    return `running ${desc.trim()}`
-  }
-
-  const type = state.input?.subagent_type
-  if (typeof type === "string" && type.trim()) {
-    return `running ${type.trim()}`
-  }
-
-  return "running task"
-}
-
-// Returns true if we can flush this part's text to scrollback.
-//
-// We gate on the message role being "assistant" because user-role messages
-// also contain text parts (the user's own input) which we don't want to
-// echo. If we haven't received the message.updated event yet, we return
-// false and the text stays buffered until replay() flushes it.
-function ready(data: SessionData, partID: string): boolean {
-  const msg = data.msg.get(partID)
-  if (!msg) {
-    return true
-  }
-
-  const role = data.role.get(msg)
-  if (!role) {
-    return false
-  }
-
-  return role === "assistant"
-}
-
-function syncText(data: SessionData, partID: string, next: string) {
-  const prev = data.text.get(partID) ?? ""
-  if (!next) {
-    return prev
-  }
-
-  if (!prev || next.length >= prev.length) {
-    data.text.set(partID, next)
-    return next
-  }
-
-  return prev
-}
-
-// Records bash tool output for echo stripping. Some models echo bash output
-// verbatim at the start of their next text part. We save both the raw and
-// trimmed forms so stripEcho() can match either.
-function stashEcho(data: SessionData, part: ToolPart) {
-  if (part.tool !== "bash") {
-    return
-  }
-
-  if (typeof part.messageID !== "string" || !part.messageID) {
-    return
-  }
-
-  const output = (part.state as { output?: unknown }).output
-  if (typeof output !== "string") {
-    return
-  }
-
-  const text = output.replace(/^\n+/, "")
-  if (!text.trim()) {
-    return
-  }
-
-  const set = data.echo.get(part.messageID) ?? new Set<string>()
-  set.add(text)
-  const trim = text.replace(/\n+$/, "")
-  if (trim && trim !== text) {
-    set.add(trim)
-  }
-  data.echo.set(part.messageID, set)
-}
-
-function stripEcho(data: SessionData, msg: string | undefined, chunk: string): string {
-  if (!msg) {
-    return chunk
-  }
-
-  const set = data.echo.get(msg)
-  if (!set || set.size === 0) {
-    return chunk
-  }
-
-  data.echo.delete(msg)
-  const list = [...set].sort((a, b) => b.length - a.length)
-  for (const item of list) {
-    if (!item || !chunk.startsWith(item)) {
-      continue
-    }
-
-    return chunk.slice(item.length).replace(/^\n+/, "")
-  }
-
-  return chunk
-}
-
-function flushPart(data: SessionData, commits: SessionCommit[], partID: string, interrupted = false) {
-  const kind = data.part.get(partID)
-  if (!kind) {
-    return
-  }
-
-  const text = data.text.get(partID) ?? ""
-  const sent = data.sent.get(partID) ?? 0
-  let chunk = text.slice(sent)
-  const msg = data.msg.get(partID)
-
-  if (sent === 0) {
-    chunk = chunk.replace(/^\n+/, "")
-    if (kind === "reasoning" && chunk) {
-      chunk = `Thinking: ${chunk.replace(/\[REDACTED\]/g, "")}`
-    }
-    if (kind === "assistant" && chunk) {
-      chunk = stripEcho(data, msg, chunk)
-    }
-  }
-
-  if (chunk) {
-    data.sent.set(partID, text.length)
-    commits.push({
-      kind,
-      text: chunk,
-      phase: "progress",
-      source: kind,
-      messageID: msg,
-      partID,
-    })
-  }
-
-  if (!interrupted) {
-    return
-  }
-
-  commits.push({
-    kind,
-    text: "",
-    phase: "final",
-    source: kind,
-    messageID: msg,
-    partID,
-    interrupted: true,
-  })
-}
-
-function drop(data: SessionData, partID: string) {
-  data.part.delete(partID)
-  data.text.delete(partID)
-  data.sent.delete(partID)
-  data.msg.delete(partID)
-  data.end.delete(partID)
-}
-
-// Called when we learn a message's role (from message.updated). Flushes any
-// buffered text parts that were waiting on role confirmation. User-role
-// parts are silently dropped.
-function replay(data: SessionData, commits: SessionCommit[], messageID: string, role: MessageRole, thinking: boolean) {
-  for (const [partID, msg] of [...data.msg.entries()]) {
-    if (msg !== messageID || data.ids.has(partID)) {
-      continue
-    }
-
-    if (role === "user") {
-      data.ids.add(partID)
-      drop(data, partID)
-      continue
-    }
-
-    const kind = data.part.get(partID)
-    if (!kind) {
-      continue
-    }
-
-    if (kind === "reasoning" && !thinking) {
-      if (data.end.has(partID)) {
-        data.ids.add(partID)
-      }
-      drop(data, partID)
-      continue
-    }
-
-    flushPart(data, commits, partID)
-
-    if (!data.end.has(partID)) {
-      continue
-    }
-
-    data.ids.add(partID)
-    drop(data, partID)
-  }
-}
-
-function startTool(part: ToolPart): SessionCommit {
-  return {
-    kind: "tool",
-    text: toolStatus(part),
-    phase: "start",
-    source: "tool",
-    messageID: part.messageID,
-    partID: part.id,
-    tool: part.tool,
-    part,
-    toolState: "running",
-  }
-}
-
-function doneTool(part: ToolPart): SessionCommit {
-  return {
-    kind: "tool",
-    text: "",
-    phase: "final",
-    source: "tool",
-    messageID: part.messageID,
-    partID: part.id,
-    tool: part.tool,
-    part,
-    toolState: "completed",
-  }
-}
-
-function failTool(part: ToolPart, text: string): SessionCommit {
-  return {
-    kind: "tool",
-    text,
-    phase: "final",
-    source: "tool",
-    messageID: part.messageID,
-    partID: part.id,
-    tool: part.tool,
-    part,
-    toolState: "error",
-    toolError: text,
-  }
-}
-
-// Emits "interrupted" final entries for all in-flight parts. Called when a turn is aborted.
-export function flushInterrupted(data: SessionData, commits: SessionCommit[]) {
-  for (const partID of data.part.keys()) {
-    if (data.ids.has(partID)) {
-      continue
-    }
-
-    const msg = data.msg.get(partID)
-    if (msg && data.role.get(msg) === "user") {
-      continue
-    }
-
-    flushPart(data, commits, partID, true)
-  }
-}
-
-// The main reducer. Takes one SDK event and returns scrollback commits and
-// footer updates. Called once per event from the stream transport's watch loop.
-//
-// Event handling follows the SDK event types:
-//   message.updated      → learn role, flush buffered parts, track usage
-//   message.part.delta   → accumulate text, flush if ready
-//   message.part.updated → handle text/reasoning/tool state transitions
-//   permission.*         → manage the permission queue, drive footer view
-//   question.*           → manage the question queue, drive footer view
-//   session.error        → emit error scrollback entry
-export function reduceSessionData(input: SessionDataInput): SessionDataOutput {
-  const commits: SessionCommit[] = []
-  const data = input.data
-  const event = input.event
-
-  if (event.type === "message.updated") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    const info = event.properties.info
-    if (typeof info.id === "string") {
-      data.role.set(info.id, info.role)
-      replay(data, commits, info.id, info.role, input.thinking)
-    }
-
-    if (info.role !== "assistant") {
-      return out(data, commits)
-    }
-
-    let next: FooterPatch | undefined
-    if (!data.announced) {
-      data.announced = true
-      next = { status: "assistant responding" }
-    }
-
-    const usage = formatUsage(
-      info.tokens,
-      input.limits[modelKey(info.providerID, info.modelID)],
-      typeof info.cost === "number" ? info.cost : undefined,
-    )
-    if (usage) {
-      next = {
-        ...(next ?? {}),
-        usage,
-      }
-    }
-
-    if (typeof info.id === "string" && info.error && !isAbort(info.error) && !data.ids.has(msgErr(info.id))) {
-      data.ids.add(msgErr(info.id))
-      commits.push({
-        kind: "error",
-        text: formatError(info.error),
-        phase: "start",
-        source: "system",
-        messageID: info.id,
-      })
-    }
-
-    return out(data, commits, patch(next))
-  }
-
-  if (event.type === "message.part.delta") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    if (
-      typeof event.properties.partID !== "string" ||
-      typeof event.properties.field !== "string" ||
-      typeof event.properties.delta !== "string"
-    ) {
-      return out(data, commits)
-    }
-
-    if (event.properties.field !== "text") {
-      return out(data, commits)
-    }
-
-    const partID = event.properties.partID
-    if (data.ids.has(partID)) {
-      return out(data, commits)
-    }
-
-    if (typeof event.properties.messageID === "string") {
-      data.msg.set(partID, event.properties.messageID)
-    }
-
-    const text = data.text.get(partID) ?? ""
-    data.text.set(partID, text + event.properties.delta)
-
-    const kind = data.part.get(partID)
-    if (!kind) {
-      return out(data, commits)
-    }
-
-    if (kind === "reasoning" && !input.thinking) {
-      return out(data, commits)
-    }
-
-    if (!ready(data, partID)) {
-      return out(data, commits)
-    }
-
-    flushPart(data, commits, partID)
-    return out(data, commits)
-  }
-
-  if (event.type === "message.part.updated") {
-    const part = event.properties.part
-    if (part.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    if (part.type === "tool") {
-      const view = syncPermission(data, part)
-
-      if (part.state.status === "running") {
-        if (data.ids.has(part.id)) {
-          return out(data, commits, view)
-        }
-
-        if (!data.tools.has(part.id)) {
-          data.tools.add(part.id)
-          commits.push(startTool(part))
-        }
-
-        return out(data, commits, view ?? patch({ status: toolStatus(part) }))
-      }
-
-      if (part.state.status === "completed") {
-        const seen = data.tools.has(part.id)
-        const mode = toolView(part.tool)
-        data.tools.delete(part.id)
-        if (data.ids.has(part.id)) {
-          return out(data, commits, view)
-        }
-
-        if (!seen) {
-          commits.push(startTool(part))
-        }
-
-        data.ids.add(part.id)
-        stashEcho(data, part)
-
-        const output = part.state.output
-        if (mode.output && typeof output === "string" && output.trim()) {
-          commits.push({
-            kind: "tool",
-            text: output,
-            phase: "progress",
-            source: "tool",
-            messageID: part.messageID,
-            partID: part.id,
-            tool: part.tool,
-            part,
-            toolState: "completed",
-          })
-        }
-
-        if (mode.final) {
-          commits.push(doneTool(part))
-        }
-
-        return out(data, commits, view)
-      }
-
-      if (part.state.status === "error") {
-        data.tools.delete(part.id)
-        if (data.ids.has(part.id)) {
-          return out(data, commits, view)
-        }
-
-        data.ids.add(part.id)
-        const text =
-          typeof part.state.error === "string" && part.state.error.trim() ? part.state.error : "unknown error"
-        commits.push(failTool(part, text))
-        return out(data, commits, view)
-      }
-    }
-
-    if (part.type !== "text" && part.type !== "reasoning") {
-      return out(data, commits)
-    }
-
-    if (data.ids.has(part.id)) {
-      return out(data, commits)
-    }
-
-    const kind = part.type === "text" ? "assistant" : "reasoning"
-    if (typeof part.messageID === "string") {
-      data.msg.set(part.id, part.messageID)
-    }
-
-    const msg = part.messageID
-    const role = msg ? data.role.get(msg) : undefined
-    if (role === "user") {
-      data.ids.add(part.id)
-      drop(data, part.id)
-      return out(data, commits)
-    }
-
-    if (kind === "reasoning" && !input.thinking) {
-      if (part.time?.end) {
-        data.ids.add(part.id)
-      }
-      drop(data, part.id)
-      return out(data, commits)
-    }
-
-    data.part.set(part.id, kind)
-    syncText(data, part.id, part.text)
-
-    if (part.time?.end) {
-      data.end.add(part.id)
-    }
-
-    if (msg && !role) {
-      return out(data, commits)
-    }
-
-    if (!ready(data, part.id)) {
-      return out(data, commits)
-    }
-
-    flushPart(data, commits, part.id)
-
-    if (!part.time?.end) {
-      return out(data, commits)
-    }
-
-    data.ids.add(part.id)
-    drop(data, part.id)
-    return out(data, commits)
-  }
-
-  if (event.type === "permission.asked") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    upsert(data.permissions, enrichPermission(data, event.properties))
-    return out(data, commits, queueFooter(data))
-  }
-
-  if (event.type === "permission.replied") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    if (!remove(data.permissions, event.properties.requestID)) {
-      return out(data, commits)
-    }
-
-    return out(data, commits, queueFooter(data))
-  }
-
-  if (event.type === "question.asked") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    upsert(data.questions, event.properties)
-    return out(data, commits, queueFooter(data))
-  }
-
-  if (event.type === "question.replied" || event.type === "question.rejected") {
-    if (event.properties.sessionID !== input.sessionID) {
-      return out(data, commits)
-    }
-
-    if (!remove(data.questions, event.properties.requestID)) {
-      return out(data, commits)
-    }
-
-    return out(data, commits, queueFooter(data))
-  }
-
-  if (event.type === "session.error") {
-    if (event.properties.sessionID !== input.sessionID || !event.properties.error) {
-      return out(data, commits)
-    }
-
-    commits.push({
-      kind: "error",
-      text: formatError(event.properties.error),
-      phase: "start",
-      source: "system",
-    })
-    return out(data, commits)
-  }
-
-  return out(data, commits)
-}

packages/opencode/src/cli/cmd/run/session.shared.ts

@@ -1,192 +0,0 @@
-// Session message extraction and prompt history.
-//
-// Fetches session messages from the SDK and extracts user turn text for
-// the prompt history ring. Also finds the most recently used variant for
-// the current model so the footer can pre-select it.
-import path from "path"
-import { fileURLToPath } from "url"
-import type { RunInput, RunPrompt } from "./types"
-
-const LIMIT = 200
-
-export type SessionMessages = NonNullable<Awaited<ReturnType<RunInput["sdk"]["session"]["messages"]>>["data"]>
-
-type Turn = {
-  prompt: RunPrompt
-  provider: string | undefined
-  model: string | undefined
-  variant: string | undefined
-}
-
-export type RunSession = {
-  first: boolean
-  turns: Turn[]
-}
-
-function copy(prompt: RunPrompt): RunPrompt {
-  return {
-    text: prompt.text,
-    parts: structuredClone(prompt.parts),
-  }
-}
-
-function same(a: RunPrompt, b: RunPrompt): boolean {
-  return a.text === b.text && JSON.stringify(a.parts) === JSON.stringify(b.parts)
-}
-
-function fileName(url: string, filename?: string) {
-  if (filename) {
-    return filename
-  }
-
-  try {
-    const next = new URL(url)
-    if (next.protocol === "file:") {
-      return path.basename(fileURLToPath(next)) || url
-    }
-  } catch {}
-
-  return url
-}
-
-function fileSource(
-  part: Extract<SessionMessages[number]["parts"][number], { type: "file" }>,
-  text: { start: number; end: number; value: string },
-) {
-  if (part.source) {
-    return {
-      ...structuredClone(part.source),
-      text,
-    }
-  }
-
-  return {
-    type: "file" as const,
-    path: part.filename ?? part.url,
-    text,
-  }
-}
-
-function prompt(msg: SessionMessages[number]): RunPrompt {
-  const files: Array<Extract<SessionMessages[number]["parts"][number], { type: "file" }>> = []
-  const parts: RunPrompt["parts"] = []
-  for (const part of msg.parts) {
-    if (part.type === "file") {
-      if (!part.source?.text) {
-        files.push(part)
-        continue
-      }
-
-      parts.push({
-        type: "file",
-        mime: part.mime,
-        filename: part.filename,
-        url: part.url,
-        source: structuredClone(part.source),
-      })
-      continue
-    }
-
-    if (part.type === "agent" && part.source) {
-      parts.push({
-        type: "agent",
-        name: part.name,
-        source: structuredClone(part.source),
-      })
-    }
-  }
-
-  let text = msg.parts
-    .filter((part): part is Extract<SessionMessages[number]["parts"][number], { type: "text" }> => {
-      return part.type === "text" && !part.synthetic
-    })
-    .map((part) => part.text)
-    .join("")
-  let cursor = Bun.stringWidth(text)
-
-  for (const part of files) {
-    const value = "@" + fileName(part.url, part.filename)
-    const gap = text ? " " : ""
-    const start = cursor + Bun.stringWidth(gap)
-    text += gap + value
-    const end = start + Bun.stringWidth(value)
-    cursor = end
-    parts.push({
-      type: "file",
-      mime: part.mime,
-      filename: part.filename,
-      url: part.url,
-      source: fileSource(part, {
-        start,
-        end,
-        value,
-      }),
-    })
-  }
-
-  return { text, parts }
-}
-
-function turn(msg: SessionMessages[number]): Turn | undefined {
-  if (msg.info.role !== "user") {
-    return
-  }
-
-  return {
-    prompt: prompt(msg),
-    provider: msg.info.model.providerID,
-    model: msg.info.model.modelID,
-    variant: msg.info.model.variant,
-  }
-}
-
-export function createSession(messages: SessionMessages): RunSession {
-  return {
-    first: messages.length === 0,
-    turns: messages.flatMap((msg) => {
-      const item = turn(msg)
-      return item ? [item] : []
-    }),
-  }
-}
-
-export async function resolveSession(sdk: RunInput["sdk"], sessionID: string, limit = LIMIT): Promise<RunSession> {
-  const response = await sdk.session.messages({
-    sessionID,
-    limit,
-  })
-  return createSession(response.data ?? [])
-}
-
-export function sessionHistory(session: RunSession, limit = LIMIT): RunPrompt[] {
-  const out: RunPrompt[] = []
-
-  for (const turn of session.turns) {
-    if (!turn.prompt.text.trim()) {
-      continue
-    }
-
-    if (out[out.length - 1] && same(out[out.length - 1], turn.prompt)) {
-      continue
-    }
-
-    out.push(copy(turn.prompt))
-  }
-
-  return out.slice(-limit)
-}
-
-export function sessionVariant(session: RunSession, model: RunInput["model"]): string | undefined {
-  if (!model) {
-    return
-  }
-
-  for (let idx = session.turns.length - 1; idx >= 0; idx -= 1) {
-    const turn = session.turns[idx]
-    if (turn.provider !== model.providerID || turn.model !== model.modelID) {
-      continue
-    }
-
-    return turn.variant
-  }
-}

packages/opencode/src/cli/cmd/run/splash.ts

@@ -1,291 +0,0 @@
-// Entry and exit splash banners for direct interactive mode scrollback.
-//
-// Renders the opencode ASCII logo with half-block shadow characters, the
-// session title, and contextual hints (entry: "/exit to finish", exit:
-// "opencode -s <id>" to resume). These are scrollback snapshots, so they
-// become immutable terminal history once committed.
-//
-// The logo uses a cell-based renderer. cells() classifies each character
-// in the logo template as text, full-block, half-block-mix, or
-// half-block-top, and draw() renders it with foreground/background shadow
-// colors from the theme.
-import {
-  BoxRenderable,
-  type ColorInput,
-  RGBA,
-  TextAttributes,
-  TextRenderable,
-  type ScrollbackRenderContext,
-  type ScrollbackSnapshot,
-  type ScrollbackWriter,
-} from "@opentui/core"
-import { Locale } from "../../../util/locale"
-import { logo } from "../../logo"
-import type { RunEntryTheme } from "./theme"
-
-export const SPLASH_TITLE_LIMIT = 50
-export const SPLASH_TITLE_FALLBACK = "Untitled session"
-
-type SplashInput = {
-  title: string | undefined
-  session_id: string
-}
-
-type SplashWriterInput = SplashInput & {
-  theme: RunEntryTheme
-  background: ColorInput
-  showSession?: boolean
-}
-
-export type SplashMeta = {
-  title: string
-  session_id: string
-}
-
-type Cell = {
-  char: string
-  mark: "text" | "full" | "mix" | "top"
-}
-
-let id = 0
-
-function cells(line: string): Cell[] {
-  const list: Cell[] = []
-  for (const char of line) {
-    if (char === "_") {
-      list.push({ char: " ", mark: "full" })
-      continue
-    }
-
-    if (char === "^") {
-      list.push({ char: "▀", mark: "mix" })
-      continue
-    }
-
-    if (char === "~") {
-      list.push({ char: "▀", mark: "top" })
-      continue
-    }
-
-    list.push({ char, mark: "text" })
-  }
-
-  return list
-}
-
-function title(text: string | undefined): string {
-  if (!text) {
-    return SPLASH_TITLE_FALLBACK
-  }
-
-  if (!text.trim()) {
-    return SPLASH_TITLE_FALLBACK
-  }
-
-  return Locale.truncate(text.trim(), SPLASH_TITLE_LIMIT)
-}
-
-function write(
-  root: BoxRenderable,
-  ctx: ScrollbackRenderContext,
-  line: {
-    left: number
-    top: number
-    text: string
-    fg: ColorInput
-    bg?: ColorInput
-    attrs?: number
-  },
-): void {
-  if (line.left >= ctx.width) {
-    return
-  }
-
-  root.add(
-    new TextRenderable(ctx.renderContext, {
-      id: `run-direct-splash-line-${id++}`,
-      position: "absolute",
-      left: line.left,
-      top: line.top,
-      width: Math.max(1, ctx.width - line.left),
-      height: 1,
-      wrapMode: "none",
-      content: line.text,
-      fg: line.fg,
-      bg: line.bg,
-      attributes: line.attrs,
-    }),
-  )
-}
-
-function push(
-  lines: Array<{ left: number; top: number; text: string; fg: ColorInput; bg?: ColorInput; attrs?: number }>,
-  left: number,
-  top: number,
-  text: string,
-  fg: ColorInput,
-  bg?: ColorInput,
-  attrs?: number,
-): void {
-  lines.push({ left, top, text, fg, bg, attrs })
-}
-
-function color(input: ColorInput, fallback: RGBA): RGBA {
-  if (input instanceof RGBA) {
-    return input
-  }
-
-  if (typeof input === "string") {
-    if (input === "transparent" || input === "none") {
-      return RGBA.fromValues(0, 0, 0, 0)
-    }
-
-    if (input.startsWith("#")) {
-      return RGBA.fromHex(input)
-    }
-  }
-
-  return fallback
-}
-
-function shade(base: RGBA, overlay: RGBA, alpha: number): RGBA {
-  const r = base.r + (overlay.r - base.r) * alpha
-  const g = base.g + (overlay.g - base.g) * alpha
-  const b = base.b + (overlay.b - base.b) * alpha
-  return RGBA.fromInts(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255))
-}
-
-function draw(
-  lines: Array<{ left: number; top: number; text: string; fg: ColorInput; bg?: ColorInput; attrs?: number }>,
-  row: string,
-  input: {
-    left: number
-    top: number
-    fg: ColorInput
-    shadow: ColorInput
-    attrs?: number
-  },
-) {
-  let x = input.left
-  for (const cell of cells(row)) {
-    if (cell.mark === "full") {
-      push(lines, x, input.top, cell.char, input.fg, input.shadow, input.attrs)
-      x += 1
-      continue
-    }
-
-    if (cell.mark === "mix") {
-      push(lines, x, input.top, cell.char, input.fg, input.shadow, input.attrs)
-      x += 1
-      continue
-    }
-
-    if (cell.mark === "top") {
-      push(lines, x, input.top, cell.char, input.shadow, undefined, input.attrs)
-      x += 1
-      continue
-    }
-
-    push(lines, x, input.top, cell.char, input.fg, undefined, input.attrs)
-    x += 1
-  }
-}
-
-function build(input: SplashWriterInput, kind: "entry" | "exit", ctx: ScrollbackRenderContext): ScrollbackSnapshot {
-  const width = Math.max(1, ctx.width)
-  const meta = splashMeta(input)
-  const lines: Array<{ left: number; top: number; text: string; fg: ColorInput; bg?: ColorInput; attrs?: number }> = []
-  const bg = color(input.background, RGBA.fromValues(0, 0, 0, 0))
-  const left = color(input.theme.system.body, RGBA.fromInts(100, 116, 139))
-  const right = color(input.theme.assistant.body, RGBA.fromInts(248, 250, 252))
-  const leftShadow = shade(bg, left, 0.25)
-  const rightShadow = shade(bg, right, 0.25)
-  let y = 0
-
-  for (let i = 0; i < logo.left.length; i += 1) {
-    const leftText = logo.left[i] ?? ""
-    const rightText = logo.right[i] ?? ""
-
-    draw(lines, leftText, {
-      left: 0,
-      top: y,
-      fg: left,
-      shadow: leftShadow,
-    })
-    draw(lines, rightText, {
-      left: leftText.length + 1,
-      top: y,
-      fg: right,
-      shadow: rightShadow,
-      attrs: TextAttributes.BOLD,
-    })
-    y += 1
-  }
-
-  y += 1
-
-  if (input.showSession !== false) {
-    const label = "Session".padEnd(10, " ")
-    push(lines, 0, y, label, input.theme.system.body, undefined, TextAttributes.DIM)
-    push(lines, label.length, y, meta.title, input.theme.assistant.body, undefined, TextAttributes.BOLD)
-    y += 1
-  }
-
-  if (kind === "entry") {
-    push(lines, 0, y, "Type /exit or /quit to finish.", input.theme.system.body, undefined, undefined)
-    y += 1
-  }
-
-  if (kind === "exit") {
-    const next = "Continue".padEnd(10, " ")
-    push(lines, 0, y, next, input.theme.system.body, undefined, TextAttributes.DIM)
-    push(
-      lines,
-      next.length,
-      y,
-      `opencode -s ${meta.session_id}`,
-      input.theme.assistant.body,
-      undefined,
-      TextAttributes.BOLD,
-    )
-    y += 1
-  }
-
-  const height = Math.max(1, y)
-  const root = new BoxRenderable(ctx.renderContext, {
-    id: `run-direct-splash-${kind}-${id++}`,
-    position: "absolute",
-    left: 0,
-    top: 0,
-    width,
-    height,
-  })
-
-  for (const line of lines) {
-    write(root, ctx, line)
-  }
-
-  return {
-    root,
-    width,
-    height,
-    rowColumns: width,
-    startOnNewLine: true,
-    trailingNewline: false,
-  }
-}
-
-export function splashMeta(input: SplashInput): SplashMeta {
-  return {
-    title: title(input.title),
-    session_id: input.session_id,
-  }
-}
-
-export function entrySplash(input: SplashWriterInput): ScrollbackWriter {
-  return (ctx) => build(input, "entry", ctx)
-}
-
-export function exitSplash(input: SplashWriterInput): ScrollbackWriter {
-  return (ctx) => build(input, "exit", ctx)
-}

packages/opencode/src/cli/cmd/run/stream.transport.ts

@@ -1,380 +0,0 @@
-// SDK event subscription and prompt turn coordination.
-//
-// Creates a long-lived event stream subscription and feeds every event
-// through the session-data reducer. The reducer produces scrollback commits
-// and footer patches, which get forwarded to the footer through stream.ts.
-//
-// Prompt turns are one-at-a-time: runPromptTurn() sends the prompt to the
-// SDK, arms a deferred Wait, and resolves when a session.status idle event
-// arrives for this session. If the turn is aborted (user interrupt), it
-// flushes any in-progress parts as interrupted entries.
-//
-// The tick counter prevents stale idle events from resolving the wrong turn
-// -- each turn gets a monotonically increasing tick, and idle events only
-// resolve the wait if the tick matches.
-import type { Event, OpencodeClient } from "@opencode-ai/sdk/v2"
-import { createSessionData, flushInterrupted, reduceSessionData } from "./session-data"
-import { writeSessionOutput } from "./stream"
-import type { FooterApi, RunFilePart, RunInput, RunPrompt, StreamCommit } from "./types"
-
-type Trace = {
-  write(type: string, data?: unknown): void
-}
-
-type StreamInput = {
-  sdk: OpencodeClient
-  sessionID: string
-  thinking: boolean
-  limits: () => Record<string, number>
-  footer: FooterApi
-  trace?: Trace
-  signal?: AbortSignal
-}
-
-type Wait = {
-  tick: number
-  armed: boolean
-  done: Promise<void>
-  resolve: () => void
-  reject: (error: unknown) => void
-}
-
-export type SessionTurnInput = {
-  agent: string | undefined
-  model: RunInput["model"]
-  variant: string | undefined
-  prompt: RunPrompt
-  files: RunFilePart[]
-  includeFiles: boolean
-  signal?: AbortSignal
-}
-
-export type SessionTransport = {
-  runPromptTurn(input: SessionTurnInput): Promise<void>
-  close(): Promise<void>
-}
-
-// Creates a deferred promise tied to a specific turn tick.
-function defer(tick: number): Wait {
-  let resolve: () => void = () => {}
-  let reject: (error: unknown) => void = () => {}
-  const done = new Promise<void>((next, fail) => {
-    resolve = next
-    reject = fail
-  })
-
-  return {
-    tick,
-    armed: false,
-    done,
-    resolve,
-    reject,
-  }
-}
-
-// Races the turn's deferred promise against an abort signal.
-function waitTurn(done: Promise<void>, signal: AbortSignal): Promise<"idle" | "abort"> {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      resolve("abort")
-      return
-    }
-
-    const onAbort = () => {
-      signal.removeEventListener("abort", onAbort)
-      resolve("abort")
-    }
-
-    signal.addEventListener("abort", onAbort, { once: true })
-    done.then(
-      () => {
-        signal.removeEventListener("abort", onAbort)
-        resolve("idle")
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort)
-        reject(error)
-      },
-    )
-  })
-}
-
-export function formatUnknownError(error: unknown): string {
-  if (typeof error === "string") {
-    return error
-  }
-
-  if (error instanceof Error) {
-    return error.message || error.name
-  }
-
-  if (error && typeof error === "object") {
-    const value = error as { message?: unknown; name?: unknown }
-    if (typeof value.message === "string" && value.message.trim()) {
-      return value.message
-    }
-
-    if (typeof value.name === "string" && value.name.trim()) {
-      return value.name
-    }
-  }
-
-  return "unknown error"
-}
-
-// Opens an SDK event subscription and returns a SessionTransport.
-//
-// The background `watch` loop consumes every SDK event, runs it through the
-// reducer, and writes output to the footer. When a session.status idle
-// event arrives, it resolves the current turn's Wait so runPromptTurn()
-// can return.
-//
-// The transport is single-turn: only one runPromptTurn() call can be active
-// at a time. The prompt queue enforces this from above.
-export async function createSessionTransport(input: StreamInput): Promise<SessionTransport> {
-  const abort = new AbortController()
-  const halt = () => {
-    abort.abort()
-  }
-  input.signal?.addEventListener("abort", halt, { once: true })
-
-  const events = await input.sdk.event.subscribe(undefined, {
-    signal: abort.signal,
-  })
-  input.trace?.write("recv.subscribe", {
-    sessionID: input.sessionID,
-  })
-
-  const closeStream = () => {
-    // Pass undefined explicitly so TS accepts AsyncGenerator.return().
-    void events.stream.return(undefined).catch(() => {})
-  }
-
-  let data = createSessionData()
-  let wait: Wait | undefined
-  let tick = 0
-  let fault: unknown
-  let closed = false
-
-  const fail = (error: unknown) => {
-    if (fault) {
-      return
-    }
-
-    fault = error
-    const next = wait
-    wait = undefined
-    next?.reject(error)
-  }
-
-  const mark = (event: Event) => {
-    if (
-      event.type !== "session.status" ||
-      event.properties.sessionID !== input.sessionID ||
-      event.properties.status.type !== "idle"
-    ) {
-      return
-    }
-
-    const next = wait
-    if (!next || !next.armed) {
-      return
-    }
-
-    tick = next.tick + 1
-    wait = undefined
-    next.resolve()
-  }
-
-  const flush = (type: "turn.abort" | "turn.cancel") => {
-    const commits: StreamCommit[] = []
-    flushInterrupted(data, commits)
-    writeSessionOutput(
-      {
-        footer: input.footer,
-        trace: input.trace,
-      },
-      {
-        data,
-        commits,
-      },
-    )
-    input.trace?.write(type, {
-      sessionID: input.sessionID,
-    })
-  }
-
-  const watch = (async () => {
-    try {
-      for await (const item of events.stream) {
-        if (input.footer.isClosed) {
-          break
-        }
-
-        const event = item as Event
-        input.trace?.write("recv.event", event)
-        const next = reduceSessionData({
-          data,
-          event,
-          sessionID: input.sessionID,
-          thinking: input.thinking,
-          limits: input.limits(),
-        })
-        data = next.data
-
-        if (next.commits.length > 0 || next.footer?.patch || next.footer?.view) {
-          input.trace?.write("reduce.output", {
-            commits: next.commits,
-            footer: next.footer,
-          })
-        }
-
-        writeSessionOutput(
-          {
-            footer: input.footer,
-            trace: input.trace,
-          },
-          next,
-        )
-
-        mark(event)
-      }
-    } catch (error) {
-      if (!abort.signal.aborted) {
-        fail(error)
-      }
-    } finally {
-      if (!abort.signal.aborted && !fault) {
-        fail(new Error("session event stream closed"))
-      }
-      closeStream()
-    }
-  })()
-
-  const runPromptTurn = async (next: SessionTurnInput): Promise<void> => {
-    if (next.signal?.aborted || input.footer.isClosed) {
-      return
-    }
-
-    if (fault) {
-      throw fault
-    }
-
-    if (wait) {
-      throw new Error("prompt already running")
-    }
-
-    const item = defer(tick)
-    wait = item
-    data.announced = false
-
-    const turn = new AbortController()
-    const stop = () => {
-      turn.abort()
-    }
-    next.signal?.addEventListener("abort", stop, { once: true })
-    abort.signal.addEventListener("abort", stop, { once: true })
-
-    try {
-      const req = {
-        sessionID: input.sessionID,
-        agent: next.agent,
-        model: next.model,
-        variant: next.variant,
-        parts: [
-          ...(next.includeFiles ? next.files : []),
-          { type: "text" as const, text: next.prompt.text },
-          ...next.prompt.parts,
-        ],
-      }
-      input.trace?.write("send.prompt", req)
-      await input.sdk.session.prompt(req, {
-        signal: turn.signal,
-      })
-      input.trace?.write("send.prompt.ok", {
-        sessionID: input.sessionID,
-      })
-
-      item.armed = true
-
-      if (turn.signal.aborted || next.signal?.aborted || input.footer.isClosed) {
-        if (wait === item) {
-          wait = undefined
-        }
-        flush("turn.abort")
-        return
-      }
-
-      if (!input.footer.isClosed && !data.announced) {
-        input.trace?.write("ui.patch", {
-          phase: "running",
-          status: "waiting for assistant",
-        })
-        input.footer.event({
-          type: "turn.wait",
-        })
-      }
-
-      if (tick > item.tick) {
-        if (wait === item) {
-          wait = undefined
-        }
-        return
-      }
-
-      const state = await waitTurn(item.done, turn.signal)
-      if (wait === item) {
-        wait = undefined
-      }
-
-      if (state === "abort") {
-        flush("turn.abort")
-      }
-
-      return
-    } catch (error) {
-      if (wait === item) {
-        wait = undefined
-      }
-
-      const canceled = turn.signal.aborted || next.signal?.aborted === true || input.footer.isClosed
-      if (canceled) {
-        flush("turn.cancel")
-        return
-      }
-
-      if (error === fault) {
-        throw error
-      }
-
-      input.trace?.write("send.prompt.error", {
-        sessionID: input.sessionID,
-        error: formatUnknownError(error),
-      })
-      throw error
-    } finally {
-      input.trace?.write("turn.end", {
-        sessionID: input.sessionID,
-      })
-      next.signal?.removeEventListener("abort", stop)
-      abort.signal.removeEventListener("abort", stop)
-    }
-  }
-
-  const close = async () => {
-    if (closed) {
-      return
-    }
-
-    closed = true
-    input.signal?.removeEventListener("abort", halt)
-    abort.abort()
-    closeStream()
-    await watch.catch(() => {})
-  }
-
-  return {
-    runPromptTurn,
-    close,
-  }
-}

packages/opencode/src/cli/cmd/run/stream.ts

@@ -1,59 +0,0 @@
-// Thin bridge between the session-data reducer output and the footer API.
-//
-// The reducer produces StreamCommit[] and an optional FooterOutput (patch +
-// view change). This module forwards them to footer.append() and
-// footer.event() respectively, adding trace writes along the way. It also
-// defaults status updates to phase "running" if the caller didn't set a
-// phase -- a convenience so reducer code doesn't have to repeat that.
-import type { FooterApi, FooterPatch } from "./types"
-import type { SessionDataOutput } from "./session-data"
-
-type Trace = {
-  write(type: string, data?: unknown): void
-}
-
-type OutputInput = {
-  footer: FooterApi
-  trace?: Trace
-}
-
-// Default to "running" phase when a status string arrives without an explicit phase.
-function patch(next: FooterPatch): FooterPatch {
-  if (typeof next.status === "string" && next.phase === undefined) {
-    return {
-      phase: "running",
-      ...next,
-    }
-  }
-
-  return next
-}
-
-// Forwards reducer output to the footer: commits go to scrollback, patches update the status bar.
-export function writeSessionOutput(input: OutputInput, out: SessionDataOutput): void {
-  for (const commit of out.commits) {
-    input.trace?.write("ui.commit", commit)
-    input.footer.append(commit)
-  }
-
-  if (out.footer?.patch) {
-    const next = patch(out.footer.patch)
-    input.trace?.write("ui.patch", next)
-    input.footer.event({
-      type: "stream.patch",
-      patch: next,
-    })
-  }
-
-  if (!out.footer?.view) {
-    return
-  }
-
-  input.trace?.write("ui.patch", {
-    view: out.footer.view,
-  })
-  input.footer.event({
-    type: "stream.view",
-    view: out.footer.view,
-  })
-}

packages/opencode/src/cli/cmd/run/theme.ts

@@ -1,239 +0,0 @@
-// Theme resolution for direct interactive mode.
-//
-// Derives scrollback and footer colors from the terminal's actual palette.
-// resolveRunTheme() queries the renderer for the terminal's 16-color palette,
-// detects dark/light mode, and maps through the TUI's theme system to produce
-// a RunTheme. Falls back to a hardcoded dark-mode palette if detection fails.
-//
-// The theme has three parts:
-//   entry  → per-EntryKind colors for plain scrollback text
-//   footer → highlight, muted, text, surface, and line colors for the footer
-//   block  → richer text/syntax/diff colors for static tool snapshots
-import { RGBA, SyntaxStyle, type CliRenderer, type ColorInput } from "@opentui/core"
-import type { TuiThemeCurrent } from "@opencode-ai/plugin/tui"
-import type { EntryKind } from "./types"
-
-type Tone = {
-  body: ColorInput
-  start?: ColorInput
-}
-
-export type RunEntryTheme = Record<EntryKind, Tone>
-
-export type RunFooterTheme = {
-  highlight: ColorInput
-  warning: ColorInput
-  success: ColorInput
-  error: ColorInput
-  muted: ColorInput
-  text: ColorInput
-  shade: ColorInput
-  surface: ColorInput
-  pane: ColorInput
-  border: ColorInput
-  line: ColorInput
-}
-
-export type RunBlockTheme = {
-  text: ColorInput
-  muted: ColorInput
-  syntax?: SyntaxStyle
-  diffAdded: ColorInput
-  diffRemoved: ColorInput
-  diffAddedBg: ColorInput
-  diffRemovedBg: ColorInput
-  diffContextBg: ColorInput
-  diffHighlightAdded: ColorInput
-  diffHighlightRemoved: ColorInput
-  diffLineNumber: ColorInput
-  diffAddedLineNumberBg: ColorInput
-  diffRemovedLineNumberBg: ColorInput
-}
-
-export type RunTheme = {
-  background: ColorInput
-  footer: RunFooterTheme
-  entry: RunEntryTheme
-  block: RunBlockTheme
-}
-
-export const transparent = RGBA.fromValues(0, 0, 0, 0)
-
-function alpha(color: RGBA, value: number): RGBA {
-  const a = Math.max(0, Math.min(1, value))
-  return RGBA.fromValues(color.r, color.g, color.b, a)
-}
-
-function rgba(hex: string, value?: number): RGBA {
-  const color = RGBA.fromHex(hex)
-  if (value === undefined) {
-    return color
-  }
-
-  return alpha(color, value)
-}
-
-function mode(bg: RGBA): "dark" | "light" {
-  const lum = 0.299 * bg.r + 0.587 * bg.g + 0.114 * bg.b
-  if (lum > 0.5) {
-    return "light"
-  }
-
-  return "dark"
-}
-
-function fade(color: RGBA, base: RGBA, fallback: number, scale: number, limit: number): RGBA {
-  if (color.a === 0) {
-    return alpha(color, fallback)
-  }
-
-  const target = Math.min(limit, color.a * scale)
-  const mix = Math.min(1, target / color.a)
-
-  return RGBA.fromValues(
-    base.r + (color.r - base.r) * mix,
-    base.g + (color.g - base.g) * mix,
-    base.b + (color.b - base.b) * mix,
-    color.a,
-  )
-}
-
-function map(theme: TuiThemeCurrent, syntax?: SyntaxStyle): RunTheme {
-  const bg = theme.background
-  const pane = theme.backgroundElement
-  const shade = fade(pane, bg, 0.12, 0.56, 0.72)
-  const surface = fade(pane, bg, 0.18, 0.76, 0.9)
-  const line = fade(pane, bg, 0.24, 0.9, 0.98)
-
-  return {
-    background: theme.background,
-    footer: {
-      highlight: theme.primary,
-      warning: theme.warning,
-      success: theme.success,
-      error: theme.error,
-      muted: theme.textMuted,
-      text: theme.text,
-      shade,
-      surface,
-      pane,
-      border: theme.border,
-      line,
-    },
-    entry: {
-      system: {
-        body: theme.textMuted,
-      },
-      user: {
-        body: theme.primary,
-      },
-      assistant: {
-        body: theme.text,
-      },
-      reasoning: {
-        body: theme.textMuted,
-      },
-      tool: {
-        body: theme.text,
-        start: theme.textMuted,
-      },
-      error: {
-        body: theme.error,
-      },
-    },
-    block: {
-      text: theme.text,
-      muted: theme.textMuted,
-      syntax,
-      diffAdded: theme.diffAdded,
-      diffRemoved: theme.diffRemoved,
-      diffAddedBg: theme.diffAddedBg,
-      diffRemovedBg: theme.diffRemovedBg,
-      diffContextBg: theme.diffContextBg,
-      diffHighlightAdded: theme.diffHighlightAdded,
-      diffHighlightRemoved: theme.diffHighlightRemoved,
-      diffLineNumber: theme.diffLineNumber,
-      diffAddedLineNumberBg: theme.diffAddedLineNumberBg,
-      diffRemovedLineNumberBg: theme.diffRemovedLineNumberBg,
-    },
-  }
-}
-
-const seed = {
-  highlight: rgba("#38bdf8"),
-  muted: rgba("#64748b"),
-  text: rgba("#f8fafc"),
-  panel: rgba("#0f172a"),
-  success: rgba("#22c55e"),
-  warning: rgba("#f59e0b"),
-  error: rgba("#ef4444"),
-}
-
-function tone(body: ColorInput, start?: ColorInput): Tone {
-  return {
-    body,
-    start,
-  }
-}
-
-export const RUN_THEME_FALLBACK: RunTheme = {
-  background: RGBA.fromValues(0, 0, 0, 0),
-  footer: {
-    highlight: seed.highlight,
-    warning: seed.warning,
-    success: seed.success,
-    error: seed.error,
-    muted: seed.muted,
-    text: seed.text,
-    shade: alpha(seed.panel, 0.68),
-    surface: alpha(seed.panel, 0.86),
-    pane: seed.panel,
-    border: seed.muted,
-    line: alpha(seed.panel, 0.96),
-  },
-  entry: {
-    system: tone(seed.muted),
-    user: tone(seed.highlight),
-    assistant: tone(seed.text),
-    reasoning: tone(seed.muted),
-    tool: tone(seed.text, seed.muted),
-    error: tone(seed.error),
-  },
-  block: {
-    text: seed.text,
-    muted: seed.muted,
-    diffAdded: seed.success,
-    diffRemoved: seed.error,
-    diffAddedBg: alpha(seed.success, 0.18),
-    diffRemovedBg: alpha(seed.error, 0.18),
-    diffContextBg: alpha(seed.panel, 0.72),
-    diffHighlightAdded: seed.success,
-    diffHighlightRemoved: seed.error,
-    diffLineNumber: seed.muted,
-    diffAddedLineNumberBg: alpha(seed.success, 0.12),
-    diffRemovedLineNumberBg: alpha(seed.error, 0.12),
-  },
-}
-
-export async function resolveRunTheme(renderer: CliRenderer): Promise<RunTheme> {
-  try {
-    const colors = await renderer.getPalette({
-      size: 16,
-    })
-    const bg = colors.defaultBackground ?? colors.palette[0]
-    if (!bg) {
-      return RUN_THEME_FALLBACK
-    }
-
-    const pick = renderer.themeMode ?? mode(RGBA.fromHex(bg))
-    const mod = await import("../tui/context/theme")
-    const theme = mod.resolveTheme(mod.generateSystem(colors, pick), pick) as TuiThemeCurrent
-    try {
-      return map(theme, mod.generateSyntax(theme))
-    } catch {
-      return map(theme)
-    }
-  } catch {
-    return RUN_THEME_FALLBACK
-  }
-}

packages/opencode/src/cli/cmd/run/trace.ts

@@ -1,94 +0,0 @@
-// Dev-only JSONL event trace for direct interactive mode.
-//
-// Enable with OPENCODE_DIRECT_TRACE=1. Writes one JSON line per event to
-// ~/.local/share/opencode/log/direct/<timestamp>-<pid>.jsonl. Also writes
-// a latest.json pointer so you can quickly find the most recent trace.
-//
-// The trace captures the full closed loop: outbound prompts, inbound SDK
-// events, reducer output, footer commits, and turn lifecycle markers.
-// Useful for debugging stream ordering, permission behavior, and
-// footer/transcript mismatches.
-//
-// Lazy-initialized: the first call to trace() decides whether tracing is
-// active based on the env var, and subsequent calls return the cached result.
-import fs from "fs"
-import path from "path"
-import { Global } from "../../../global"
-
-export type Trace = {
-  write(type: string, data?: unknown): void
-}
-
-let state: Trace | false | undefined
-
-function stamp() {
-  return new Date()
-    .toISOString()
-    .replace(/[-:]/g, "")
-    .replace(/\.\d+Z$/, "Z")
-}
-
-function file() {
-  return path.join(Global.Path.log, "direct", `${stamp()}-${process.pid}.jsonl`)
-}
-
-function latest() {
-  return path.join(Global.Path.log, "direct", "latest.json")
-}
-
-function text(data: unknown) {
-  return JSON.stringify(
-    data,
-    (_key, value) => {
-      if (typeof value === "bigint") {
-        return String(value)
-      }
-
-      return value
-    },
-    0,
-  )
-}
-
-export function trace() {
-  if (state !== undefined) {
-    return state || undefined
-  }
-
-  if (!process.env.OPENCODE_DIRECT_TRACE) {
-    state = false
-    return
-  }
-
-  const target = file()
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  fs.writeFileSync(
-    latest(),
-    text({
-      time: new Date().toISOString(),
-      pid: process.pid,
-      cwd: process.cwd(),
-      argv: process.argv.slice(2),
-      path: target,
-    }) + "\n",
-  )
-  state = {
-    write(type: string, data?: unknown) {
-      fs.appendFileSync(
-        target,
-        text({
-          time: new Date().toISOString(),
-          pid: process.pid,
-          type,
-          data,
-        }) + "\n",
-      )
-    },
-  }
-  state.write("trace.start", {
-    argv: process.argv.slice(2),
-    cwd: process.cwd(),
-    path: target,
-  })
-  return state
-}

packages/opencode/src/cli/cmd/run/types.ts

@@ -1,195 +0,0 @@
-// Shared type vocabulary for the direct interactive mode (`run --interactive`).
-//
-// Direct mode uses a split-footer terminal layout: immutable scrollback for the
-// session transcript, and a mutable footer for prompt input, status, and
-// permission/question UI. Every module in run/* shares these types to stay
-// aligned on that two-lane model.
-//
-// Data flow through the system:
-//
-//   SDK events → session-data reducer → StreamCommit[] + FooterOutput
-//     → stream.ts bridges to footer API
-//       → footer.ts queues commits and patches the footer view
-//         → OpenTUI split-footer renderer writes to terminal
-import type { OpencodeClient, PermissionRequest, QuestionRequest, ToolPart } from "@opencode-ai/sdk/v2"
-
-export type RunFilePart = {
-  type: "file"
-  url: string
-  filename: string
-  mime: string
-}
-
-type PromptModel = Parameters<OpencodeClient["session"]["prompt"]>[0]["model"]
-type PromptInput = Parameters<OpencodeClient["session"]["prompt"]>[0]
-
-export type RunPromptPart = NonNullable<PromptInput["parts"]>[number]
-
-export type RunPrompt = {
-  text: string
-  parts: RunPromptPart[]
-}
-
-export type RunAgent = NonNullable<Awaited<ReturnType<OpencodeClient["app"]["agents"]>>["data"]>[number]
-
-type RunResourceMap = NonNullable<Awaited<ReturnType<OpencodeClient["experimental"]["resource"]["list"]>>["data"]>
-
-export type RunResource = RunResourceMap[string]
-
-export type RunInput = {
-  sdk: OpencodeClient
-  directory: string
-  sessionID: string
-  sessionTitle?: string
-  resume?: boolean
-  agent: string | undefined
-  model: PromptModel | undefined
-  variant: string | undefined
-  files: RunFilePart[]
-  initialInput?: string
-  thinking: boolean
-  demo?: RunDemo
-  demoText?: string
-}
-
-export type RunDemo = "on" | "permission" | "question" | "mix" | "text"
-
-// The semantic role of a scrollback entry. Maps 1:1 to theme colors.
-export type EntryKind = "system" | "user" | "assistant" | "reasoning" | "tool" | "error"
-
-// Whether the assistant is actively processing a turn.
-export type FooterPhase = "idle" | "running"
-
-// Full snapshot of footer status bar state. Every update replaces the whole
-// object in the SolidJS signal so the view re-renders atomically.
-export type FooterState = {
-  phase: FooterPhase
-  status: string
-  queue: number
-  model: string
-  duration: string
-  usage: string
-  first: boolean
-  interrupt: number
-  exit: number
-}
-
-// A partial update to FooterState. The footer merges this onto the current state.
-export type FooterPatch = Partial<FooterState>
-
-export type RunDiffStyle = "auto" | "stacked"
-
-export type ScrollbackOptions = {
-  diffStyle?: RunDiffStyle
-}
-
-// Which interactive surface the footer is showing. Only one view is active at
-// a time. The reducer drives transitions: when a permission arrives the view
-// switches to "permission", and when the permission resolves it falls back to
-// "prompt".
-export type FooterView =
-  | { type: "prompt" }
-  | { type: "permission"; request: PermissionRequest }
-  | { type: "question"; request: QuestionRequest }
-
-// The reducer emits this alongside scrollback commits so the footer can update in the same frame.
-export type FooterOutput = {
-  patch?: FooterPatch
-  view?: FooterView
-}
-
-// Typed messages sent to RunFooter.event(). The prompt queue and stream
-// transport both emit these to update footer state without reaching into
-// internal signals directly.
-export type FooterEvent =
-  | {
-      type: "queue"
-      queue: number
-    }
-  | {
-      type: "first"
-      first: boolean
-    }
-  | {
-      type: "model"
-      model: string
-    }
-  | {
-      type: "turn.send"
-      queue: number
-    }
-  | {
-      type: "turn.wait"
-    }
-  | {
-      type: "turn.idle"
-      queue: number
-    }
-  | {
-      type: "turn.duration"
-      duration: string
-    }
-  | {
-      type: "stream.patch"
-      patch: FooterPatch
-    }
-  | {
-      type: "stream.view"
-      view: FooterView
-    }
-
-export type PermissionReply = Parameters<OpencodeClient["permission"]["reply"]>[0]
-
-export type QuestionReply = Parameters<OpencodeClient["question"]["reply"]>[0]
-
-export type QuestionReject = Parameters<OpencodeClient["question"]["reject"]>[0]
-
-export type FooterKeybinds = {
-  leader: string
-  variantCycle: string
-  interrupt: string
-  historyPrevious: string
-  historyNext: string
-  inputSubmit: string
-  inputNewline: string
-}
-
-// Lifecycle phase of a scrollback entry. "start" opens the entry, "progress"
-// appends content (coalesced in the footer queue), "final" closes it.
-export type StreamPhase = "start" | "progress" | "final"
-
-export type StreamSource = "assistant" | "reasoning" | "tool" | "system"
-
-export type StreamToolState = "running" | "completed" | "error"
-
-// A single append-only commit to scrollback. The session-data reducer produces
-// these from SDK events, and RunFooter.append() queues them for the next
-// microtask flush. Once flushed, they become immutable terminal scrollback
-// rows -- they cannot be rewritten.
-export type StreamCommit = {
-  kind: EntryKind
-  text: string
-  phase: StreamPhase
-  source: StreamSource
-  messageID?: string
-  partID?: string
-  tool?: string
-  part?: ToolPart
-  interrupted?: boolean
-  toolState?: StreamToolState
-  toolError?: string
-}
-
-// The public contract between the stream transport / prompt queue and
-// the footer. RunFooter implements this. The transport and queue never
-// touch the renderer directly -- they go through this interface.
-export type FooterApi = {
-  readonly isClosed: boolean
-  onPrompt(fn: (input: RunPrompt) => void): () => void
-  onClose(fn: () => void): () => void
-  event(next: FooterEvent): void
-  append(commit: StreamCommit): void
-  idle(): Promise<void>
-  close(): void
-  destroy(): void
-}

packages/opencode/src/cli/cmd/run/variant.shared.ts

@@ -1,126 +0,0 @@
-// Model variant resolution and persistence.
-//
-// Variants are provider-specific reasoning effort levels (e.g., "high", "max").
-// Resolution priority: CLI --variant flag > saved preference > session history.
-//
-// The saved variant persists across sessions in ~/.local/state/opencode/model.json
-// so your last-used variant sticks. Cycling (ctrl+t) updates both the active
-// variant and the persisted file.
-import path from "path"
-import { Global } from "../../../global"
-import { Filesystem } from "../../../util/filesystem"
-import { createSession, sessionVariant, type RunSession, type SessionMessages } from "./session.shared"
-import type { RunInput } from "./types"
-
-const MODEL_FILE = path.join(Global.Path.state, "model.json")
-
-type ModelState = {
-  variant?: Record<string, string | undefined>
-}
-
-function modelKey(provider: string, model: string): string {
-  return `${provider}/${model}`
-}
-
-function variantKey(model: NonNullable<RunInput["model"]>): string {
-  return modelKey(model.providerID, model.modelID)
-}
-
-export function formatModelLabel(model: NonNullable<RunInput["model"]>, variant: string | undefined): string {
-  const label = variant ? ` · ${variant}` : ""
-  return `${model.modelID} · ${model.providerID}${label}`
-}
-
-export function cycleVariant(current: string | undefined, variants: string[]): string | undefined {
-  if (variants.length === 0) {
-    return undefined
-  }
-
-  if (!current) {
-    return variants[0]
-  }
-
-  const idx = variants.indexOf(current)
-  if (idx === -1 || idx === variants.length - 1) {
-    return undefined
-  }
-
-  return variants[idx + 1]
-}
-
-export function pickVariant(model: RunInput["model"], input: RunSession | SessionMessages): string | undefined {
-  return sessionVariant(Array.isArray(input) ? createSession(input) : input, model)
-}
-
-function fitVariant(value: string | undefined, variants: string[]): string | undefined {
-  if (!value) {
-    return undefined
-  }
-
-  if (variants.length === 0 || variants.includes(value)) {
-    return value
-  }
-
-  return undefined
-}
-
-// Picks the active variant. CLI flag wins, then saved preference, then session
-// history. fitVariant() checks saved and session values against the available
-// variants list -- if the provider doesn't offer a variant, it drops.
-export function resolveVariant(
-  input: string | undefined,
-  session: string | undefined,
-  saved: string | undefined,
-  variants: string[],
-): string | undefined {
-  if (input !== undefined) {
-    return input
-  }
-
-  const fallback = fitVariant(saved, variants)
-  const current = fitVariant(session, variants)
-  if (current !== undefined) {
-    return current
-  }
-
-  return fallback
-}
-
-export async function resolveSavedVariant(model: RunInput["model"]): Promise<string | undefined> {
-  if (!model) {
-    return undefined
-  }
-
-  try {
-    const state = await Filesystem.readJson<ModelState>(MODEL_FILE)
-    return state.variant?.[variantKey(model)]
-  } catch {
-    return undefined
-  }
-}
-
-export function saveVariant(model: RunInput["model"], variant: string | undefined): void {
-  if (!model) {
-    return
-  }
-
-  void (async () => {
-    const state = await Filesystem.readJson<ModelState>(MODEL_FILE).catch(() => ({}) as ModelState)
-    const map = {
-      ...(state.variant ?? {}),
-    }
-    const key = variantKey(model)
-    if (variant) {
-      map[key] = variant
-    }
-
-    if (!variant) {
-      delete map[key]
-    }
-
-    await Filesystem.writeJson(MODEL_FILE, {
-      ...state,
-      variant: map,
-    })
-  })().catch(() => {})
-}

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -1,6 +1,7 @@
 import { render, TimeToFirstDraw, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/solid"
 import { Clipboard } from "@tui/util/clipboard"
 import { Selection } from "@tui/util/selection"
+import { Terminal } from "@tui/util/terminal"
 import { createCliRenderer, MouseButton, type CliRendererConfig } from "@opentui/core"
 import { RouteProvider, useRoute } from "@tui/context/route"
 import {
@@ -60,66 +61,6 @@ import { TuiConfig } from "@/config/tui"
 import { createTuiApi, TuiPluginRuntime, type RouteMap } from "./plugin"
 import { FormatError, FormatUnknownError } from "@/cli/error"
 
-async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
-  // can't set raw mode if not a TTY
-  if (!process.stdin.isTTY) return "dark"
-
-  return new Promise((resolve) => {
-    let timeout: NodeJS.Timeout
-
-    const cleanup = () => {
-      process.stdin.setRawMode(false)
-      process.stdin.removeListener("data", handler)
-      clearTimeout(timeout)
-    }
-
-    const handler = (data: Buffer) => {
-      const str = data.toString()
-      const match = str.match(/\x1b]11;([^\x07\x1b]+)/)
-      if (match) {
-        cleanup()
-        const color = match[1]
-        // Parse RGB values from color string
-        // Formats: rgb:RR/GG/BB or #RRGGBB or rgb(R,G,B)
-        let r = 0,
-          g = 0,
-          b = 0
-
-        if (color.startsWith("rgb:")) {
-          const parts = color.substring(4).split("/")
-          r = parseInt(parts[0], 16) >> 8 // Convert 16-bit to 8-bit
-          g = parseInt(parts[1], 16) >> 8 // Convert 16-bit to 8-bit
-          b = parseInt(parts[2], 16) >> 8 // Convert 16-bit to 8-bit
-        } else if (color.startsWith("#")) {
-          r = parseInt(color.substring(1, 3), 16)
-          g = parseInt(color.substring(3, 5), 16)
-          b = parseInt(color.substring(5, 7), 16)
-        } else if (color.startsWith("rgb(")) {
-          const parts = color.substring(4, color.length - 1).split(",")
-          r = parseInt(parts[0])
-          g = parseInt(parts[1])
-          b = parseInt(parts[2])
-        }
-
-        // Calculate luminance using relative luminance formula
-        const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
-
-        // Determine if dark or light based on luminance threshold
-        resolve(luminance > 0.5 ? "light" : "dark")
-      }
-    }
-
-    process.stdin.setRawMode(true)
-    process.stdin.on("data", handler)
-    process.stdout.write("\x1b]11;?\x07")
-
-    timeout = setTimeout(() => {
-      cleanup()
-      resolve("dark")
-    }, 1000)
-  })
-}
-
 import type { EventSource } from "./context/sdk"
 import { DialogVariant } from "./component/dialog-variant"
 
@@ -178,7 +119,7 @@ export function tui(input: {
     const unguard = win32InstallCtrlCGuard()
     win32DisableProcessedInput()
 
-    const mode = await getTerminalBackgroundColor()
+    const mode = await Terminal.getTerminalBackgroundColor()
 
     // Re-clear after getTerminalBackgroundColor() — setRawMode(false) restores
     // the original console mode which re-enables ENABLE_PROCESSED_INPUT.
@@ -256,7 +197,6 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
   const route = useRoute()
   const dimensions = useTerminalDimensions()
   const renderer = useRenderer()
-
   const dialog = useDialog()
   const local = useLocal()
   const kv = useKV()

packages/opencode/src/cli/cmd/tui/attach.ts

@@ -1,5 +1,6 @@
 import { cmd } from "../cmd"
 import { UI } from "@/cli/ui"
+import { tui } from "./app"
 import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
 import { TuiConfig } from "@/config/tui"
 import { Instance } from "@/project/instance"
@@ -69,8 +70,7 @@ export const AttachCommand = cmd({
         directory: directory && existsSync(directory) ? directory : process.cwd(),
         fn: () => TuiConfig.get(),
       })
-      const app = await import("./app")
-      await app.tui({
+      await tui({
         url: args.url,
         config,
         args: {

packages/opencode/src/cli/cmd/tui/context/theme.tsx

@@ -509,9 +509,7 @@ export function tint(base: RGBA, overlay: RGBA, alpha: number): RGBA {
   return RGBA.fromInts(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255))
 }
 
-// TODO: i exported this, just for keeping it simple for now, but this should
-// probably go into something shared if we decide to use this in opencode run
-export function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJson {
+function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJson {
   const bg = RGBA.fromHex(colors.defaultBackground ?? colors.palette[0]!)
   const fg = RGBA.fromHex(colors.defaultForeground ?? colors.palette[7]!)
   const transparent = RGBA.fromValues(bg.r, bg.g, bg.b, 0)
@@ -705,11 +703,11 @@ function generateMutedTextColor(bg: RGBA, isDark: boolean): RGBA {
   return RGBA.fromInts(grayValue, grayValue, grayValue)
 }
 
-export function generateSyntax(theme: TuiThemeCurrent) {
+function generateSyntax(theme: Theme) {
   return SyntaxStyle.fromTheme(getSyntaxRules(theme))
 }
 
-function generateSubtleSyntax(theme: TuiThemeCurrent) {
+function generateSubtleSyntax(theme: Theme) {
   const rules = getSyntaxRules(theme)
   return SyntaxStyle.fromTheme(
     rules.map((rule) => {
@@ -733,7 +731,7 @@ function generateSubtleSyntax(theme: TuiThemeCurrent) {
   )
 }
 
-function getSyntaxRules(theme: TuiThemeCurrent) {
+function getSyntaxRules(theme: Theme) {
   return [
     {
       scope: ["default"],

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -1,4 +1,5 @@
 import { cmd } from "@/cli/cmd/cmd"
+import { tui } from "./app"
 import { Rpc } from "@/util/rpc"
 import { type rpc } from "./worker"
 import path from "path"
@@ -207,8 +208,7 @@ export const TuiThreadCommand = cmd({
       }, 1000).unref?.()
 
       try {
-        const app = await import("./app")
-        await app.tui({
+        await tui({
           url: transport.url,
           async onSnapshot() {
             const tui = writeHeapSnapshot("tui.heapsnapshot")

packages/opencode/src/cli/cmd/tui/util/terminal.ts

@@ -2,6 +2,28 @@ import { RGBA } from "@opentui/core"
 
 export namespace Terminal {
   export type Colors = Awaited<ReturnType<typeof colors>>
+
+  function parse(color: string): RGBA | null {
+    if (color.startsWith("rgb:")) {
+      const parts = color.substring(4).split("/")
+      return RGBA.fromInts(parseInt(parts[0], 16) >> 8, parseInt(parts[1], 16) >> 8, parseInt(parts[2], 16) >> 8, 255)
+    }
+    if (color.startsWith("#")) {
+      return RGBA.fromHex(color)
+    }
+    if (color.startsWith("rgb(")) {
+      const parts = color.substring(4, color.length - 1).split(",")
+      return RGBA.fromInts(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), 255)
+    }
+    return null
+  }
+
+  function mode(bg: RGBA | null): "dark" | "light" {
+    if (!bg) return "dark"
+    const luminance = (0.299 * bg.r + 0.587 * bg.g + 0.114 * bg.b) / 255
+    return luminance > 0.5 ? "light" : "dark"
+  }
+
   /**
    * Query terminal colors including background, foreground, and palette (0-15).
    * Uses OSC escape sequences to retrieve actual terminal color values.
@@ -31,46 +53,26 @@ export namespace Terminal {
         clearTimeout(timeout)
       }
 
-      const parseColor = (colorStr: string): RGBA | null => {
-        if (colorStr.startsWith("rgb:")) {
-          const parts = colorStr.substring(4).split("/")
-          return RGBA.fromInts(
-            parseInt(parts[0], 16) >> 8, // Convert 16-bit to 8-bit
-            parseInt(parts[1], 16) >> 8,
-            parseInt(parts[2], 16) >> 8,
-            255,
-          )
-        }
-        if (colorStr.startsWith("#")) {
-          return RGBA.fromHex(colorStr)
-        }
-        if (colorStr.startsWith("rgb(")) {
-          const parts = colorStr.substring(4, colorStr.length - 1).split(",")
-          return RGBA.fromInts(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), 255)
-        }
-        return null
-      }
-
       const handler = (data: Buffer) => {
         const str = data.toString()
 
         // Match OSC 11 (background color)
         const bgMatch = str.match(/\x1b]11;([^\x07\x1b]+)/)
         if (bgMatch) {
-          background = parseColor(bgMatch[1])
+          background = parse(bgMatch[1])
         }
 
         // Match OSC 10 (foreground color)
         const fgMatch = str.match(/\x1b]10;([^\x07\x1b]+)/)
         if (fgMatch) {
-          foreground = parseColor(fgMatch[1])
+          foreground = parse(fgMatch[1])
         }
 
         // Match OSC 4 (palette colors)
         const paletteMatches = str.matchAll(/\x1b]4;(\d+);([^\x07\x1b]+)/g)
         for (const match of paletteMatches) {
           const index = parseInt(match[1])
-          const color = parseColor(match[2])
+          const color = parse(match[2])
           if (color) paletteColors[index] = color
         }
 
@@ -100,15 +102,36 @@ export namespace Terminal {
     })
   }
 
+  // Keep startup mode detection separate from `colors()`: the TUI boot path only
+  // needs OSC 11 and should resolve on the first background response instead of
+  // waiting on the full palette query used by system theme generation.
   export async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
-    const result = await colors()
-    if (!result.background) return "dark"
+    if (!process.stdin.isTTY) return "dark"
 
-    const { r, g, b } = result.background
-    // Calculate luminance using relative luminance formula
-    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+    return new Promise((resolve) => {
+      let timeout: NodeJS.Timeout
 
-    // Determine if dark or light based on luminance threshold
-    return luminance > 0.5 ? "light" : "dark"
+      const cleanup = () => {
+        process.stdin.setRawMode(false)
+        process.stdin.removeListener("data", handler)
+        clearTimeout(timeout)
+      }
+
+      const handler = (data: Buffer) => {
+        const match = data.toString().match(/\x1b]11;([^\x07\x1b]+)/)
+        if (!match) return
+        cleanup()
+        resolve(mode(parse(match[1])))
+      }
+
+      process.stdin.setRawMode(true)
+      process.stdin.on("data", handler)
+      process.stdout.write("\x1b]11;?\x07")
+
+      timeout = setTimeout(() => {
+        cleanup()
+        resolve("dark")
+      }, 1000)
+    })
   }
 }

packages/opencode/src/cli/cmd/tui/worker.ts

@@ -7,10 +7,10 @@ import { Rpc } from "@/util/rpc"
 import { upgrade } from "@/cli/upgrade"
 import { Config } from "@/config/config"
 import { GlobalBus } from "@/bus/global"
-import type { GlobalEvent } from "@opencode-ai/sdk/v2"
 import { Flag } from "@/flag/flag"
 import { writeHeapSnapshot } from "node:v8"
 import { Heap } from "@/cli/heap"
+import { AppRuntime } from "@/effect/app-runtime"
 
 await Log.init({
   print: process.argv.includes("--print-logs"),
@@ -74,7 +74,7 @@ export const rpc = {
   async checkUpgrade(input: { directory: string }) {
     await Instance.provide({
       directory: input.directory,
-      init: InstanceBootstrap,
+      init: () => AppRuntime.runPromise(InstanceBootstrap),
       fn: async () => {
         await upgrade().catch(() => {})
       },

packages/opencode/src/config/config.ts

@@ -22,21 +22,19 @@ import { Instance, type InstanceContext } from "../project/instance"
 import { LSPServer } from "../lsp/server"
 import { Installation } from "@/installation"
 import { ConfigMarkdown } from "./markdown"
-import { constants, existsSync } from "fs"
+import { existsSync } from "fs"
 import { Bus } from "@/bus"
 import { GlobalBus } from "@/bus/global"
 import { Event } from "../server/event"
 import { Glob } from "../util/glob"
-import { iife } from "@/util/iife"
 import { Account } from "@/account"
 import { isRecord } from "@/util/record"
 import { ConfigPaths } from "./paths"
-import { Filesystem } from "@/util/filesystem"
 import type { ConsoleState } from "./console-state"
 import { AppFileSystem } from "@/filesystem"
 import { InstanceState } from "@/effect/instance-state"
 import { makeRuntime } from "@/effect/run-service"
-import { Duration, Effect, Layer, Option, Context } from "effect"
+import { Context, Duration, Effect, Exit, Fiber, Layer, Option } from "effect"
 import { Flock } from "@/util/flock"
 import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
 import { Npm } from "@/npm"
@@ -140,53 +138,11 @@ export namespace Config {
   }
 
   export type InstallInput = {
-    signal?: AbortSignal
     waitTick?: (input: { dir: string; attempt: number; delay: number; waited: number }) => void | Promise<void>
   }
 
-  export async function installDependencies(dir: string, input?: InstallInput) {
-    if (!(await isWritable(dir))) return
-    await using _ = await Flock.acquire(`config-install:${Filesystem.resolve(dir)}`, {
-      signal: input?.signal,
-      onWait: (tick) =>
-        input?.waitTick?.({
-          dir,
-          attempt: tick.attempt,
-          delay: tick.delay,
-          waited: tick.waited,
-        }),
-    })
-    input?.signal?.throwIfAborted()
-
-    const pkg = path.join(dir, "package.json")
-    const target = Installation.isLocal() ? "*" : Installation.VERSION
-    const json = await Filesystem.readJson<{ dependencies?: Record<string, string> }>(pkg).catch(() => ({
-      dependencies: {},
-    }))
-    json.dependencies = {
-      ...json.dependencies,
-      "@opencode-ai/plugin": target,
-    }
-    await Filesystem.writeJson(pkg, json)
-
-    const gitignore = path.join(dir, ".gitignore")
-    const ignore = await Filesystem.exists(gitignore)
-    if (!ignore) {
-      await Filesystem.write(
-        gitignore,
-        ["node_modules", "package.json", "package-lock.json", "bun.lock", ".gitignore"].join("\n"),
-      )
-    }
-    await Npm.install(dir)
-  }
-
-  async function isWritable(dir: string) {
-    try {
-      await fsNode.access(dir, constants.W_OK)
-      return true
-    } catch {
-      return false
-    }
+  type Package = {
+    dependencies?: Record<string, string>
   }
 
   function rel(item: string, patterns: string[]) {
@@ -1111,7 +1067,7 @@ export namespace Config {
   type State = {
     config: Info
     directories: string[]
-    deps: Promise<void>[]
+    deps: Fiber.Fiber<void, never>[]
     consoleState: ConsoleState
   }
 
@@ -1119,6 +1075,7 @@ export namespace Config {
     readonly get: () => Effect.Effect<Info>
     readonly getGlobal: () => Effect.Effect<Info>
     readonly getConsoleState: () => Effect.Effect<ConsoleState>
+    readonly installDependencies: (dir: string, input?: InstallInput) => Effect.Effect<void, AppFileSystem.Error>
     readonly update: (config: Info) => Effect.Effect<void>
     readonly updateGlobal: (config: Info) => Effect.Effect<Info>
     readonly invalidate: (wait?: boolean) => Effect.Effect<void>
@@ -1320,6 +1277,74 @@ export namespace Config {
           return yield* cachedGlobal
         })
 
+        const install = Effect.fnUntraced(function* (dir: string) {
+          const pkg = path.join(dir, "package.json")
+          const gitignore = path.join(dir, ".gitignore")
+          const plugin = path.join(dir, "node_modules", "@opencode-ai", "plugin", "package.json")
+          const target = Installation.isLocal() ? "*" : Installation.VERSION
+          const json = yield* fs.readJson(pkg).pipe(
+            Effect.catch(() => Effect.succeed({} satisfies Package)),
+            Effect.map((x): Package => (isRecord(x) ? (x as Package) : {})),
+          )
+          const hasDep = json.dependencies?.["@opencode-ai/plugin"] === target
+          const hasIgnore = yield* fs.existsSafe(gitignore)
+          const hasPkg = yield* fs.existsSafe(plugin)
+
+          if (!hasDep) {
+            yield* fs.writeJson(pkg, {
+              ...json,
+              dependencies: {
+                ...json.dependencies,
+                "@opencode-ai/plugin": target,
+              },
+            })
+          }
+
+          if (!hasIgnore) {
+            yield* fs.writeFileString(
+              gitignore,
+              ["node_modules", "package.json", "package-lock.json", "bun.lock", ".gitignore"].join("\n"),
+            )
+          }
+
+          if (hasDep && hasIgnore && hasPkg) return
+
+          yield* Effect.promise(() => Npm.install(dir))
+        })
+
+        const installDependencies = Effect.fn("Config.installDependencies")(function* (
+          dir: string,
+          input?: InstallInput,
+        ) {
+          if (
+            !(yield* fs.access(dir, { writable: true }).pipe(
+              Effect.as(true),
+              Effect.orElseSucceed(() => false),
+            ))
+          )
+            return
+
+          const key =
+            process.platform === "win32" ? "config-install:win32" : `config-install:${AppFileSystem.resolve(dir)}`
+
+          yield* Effect.acquireUseRelease(
+            Effect.promise((signal) =>
+              Flock.acquire(key, {
+                signal,
+                onWait: (tick) =>
+                  input?.waitTick?.({
+                    dir,
+                    attempt: tick.attempt,
+                    delay: tick.delay,
+                    waited: tick.waited,
+                  }),
+              }),
+            ),
+            () => install(dir),
+            (lease) => Effect.promise(() => lease.release()),
+          )
+        })
+
         const loadInstanceState = Effect.fnUntraced(function* (ctx: InstanceContext) {
           const auth = yield* authSvc.all().pipe(Effect.orDie)
 
@@ -1402,7 +1427,7 @@ export namespace Config {
             log.debug("loading config from OPENCODE_CONFIG_DIR", { path: Flag.OPENCODE_CONFIG_DIR })
           }
 
-          const deps: Promise<void>[] = []
+          const deps: Fiber.Fiber<void, never>[] = []
 
           for (const dir of unique(directories)) {
             if (dir.endsWith(".opencode") || dir === Flag.OPENCODE_CONFIG_DIR) {
@@ -1416,12 +1441,18 @@ export namespace Config {
               }
             }
 
-            const dep = iife(async () => {
-              await installDependencies(dir)
-            })
-            void dep.catch((err) => {
-              log.warn("background dependency install failed", { dir, error: err })
-            })
+            const dep = yield* installDependencies(dir).pipe(
+              Effect.exit,
+              Effect.tap((exit) =>
+                Exit.isFailure(exit)
+                  ? Effect.sync(() => {
+                      log.warn("background dependency install failed", { dir, error: String(exit.cause) })
+                    })
+                  : Effect.void,
+              ),
+              Effect.asVoid,
+              Effect.forkScoped,
+            )
             deps.push(dep)
 
             result.command = mergeDeep(result.command ?? {}, yield* Effect.promise(() => loadCommand(dir)))
@@ -1558,7 +1589,9 @@ export namespace Config {
         })
 
         const waitForDependencies = Effect.fn("Config.waitForDependencies")(function* () {
-          yield* InstanceState.useEffect(state, (s) => Effect.promise(() => Promise.all(s.deps).then(() => undefined)))
+          yield* InstanceState.useEffect(state, (s) =>
+            Effect.forEach(s.deps, Fiber.join, { concurrency: "unbounded" }).pipe(Effect.asVoid),
+          )
         })
 
         const update = Effect.fn("Config.update")(function* (config: Info) {
@@ -1613,6 +1646,7 @@ export namespace Config {
           get,
           getGlobal,
           getConsoleState,
+          installDependencies,
           update,
           updateGlobal,
           invalidate,
@@ -1642,6 +1676,10 @@ export namespace Config {
     return runPromise((svc) => svc.getConsoleState())
   }
 
+  export async function installDependencies(dir: string, input?: InstallInput) {
+    return runPromise((svc) => svc.installDependencies(dir, input))
+  }
+
   export async function update(config: Info) {
     return runPromise((svc) => svc.update(config))
   }

packages/opencode/src/effect/app-runtime.ts

@@ -49,7 +49,7 @@ import { ShareNext } from "@/share/share-next"
 import { SessionShare } from "@/share/session"
 
 export const AppLayer = Layer.mergeAll(
-  Observability.layer,
+  // Observability.layer,
   AppFileSystem.defaultLayer,
   Bus.defaultLayer,
   Auth.defaultLayer,
@@ -95,6 +95,6 @@ export const AppLayer = Layer.mergeAll(
   Installation.defaultLayer,
   ShareNext.defaultLayer,
   SessionShare.defaultLayer,
-)
+).pipe(Layer.provide(Observability.layer))
 
 export const AppRuntime = ManagedRuntime.make(AppLayer, { memoMap })

packages/opencode/src/effect/bootstrap-runtime.ts

@@ -1,10 +1,27 @@
 import { Layer, ManagedRuntime } from "effect"
 import { memoMap } from "./run-service"
 
+import { Plugin } from "@/plugin"
+import { LSP } from "@/lsp"
 import { FileWatcher } from "@/file/watcher"
 import { Format } from "@/format"
 import { ShareNext } from "@/share/share-next"
+import { File } from "@/file"
+import { Vcs } from "@/project/vcs"
+import { Snapshot } from "@/snapshot"
+import { Bus } from "@/bus"
+import { Observability } from "./oltp"
 
-export const BootstrapLayer = Layer.mergeAll(Format.defaultLayer, ShareNext.defaultLayer, FileWatcher.defaultLayer)
+export const BootstrapLayer = Layer.mergeAll(
+  Plugin.defaultLayer,
+  ShareNext.defaultLayer,
+  Format.defaultLayer,
+  LSP.defaultLayer,
+  File.defaultLayer,
+  FileWatcher.defaultLayer,
+  Vcs.defaultLayer,
+  Snapshot.defaultLayer,
+  Bus.defaultLayer,
+).pipe(Layer.provide(Observability.layer))
 
 export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })

packages/opencode/src/file/index.ts

@@ -1,6 +1,5 @@
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { Git } from "@/git"
 import { Effect, Layer, Context } from "effect"
@@ -644,26 +643,4 @@ export namespace File {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(Git.defaultLayer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export function init() {
-    return runPromise((svc) => svc.init())
-  }
-
-  export async function status() {
-    return runPromise((svc) => svc.status())
-  }
-
-  export async function read(file: string): Promise<Content> {
-    return runPromise((svc) => svc.read(file))
-  }
-
-  export async function list(dir?: string) {
-    return runPromise((svc) => svc.list(dir))
-  }
-
-  export async function search(input: { query: string; limit?: number; dirs?: boolean; type?: "file" | "directory" }) {
-    return runPromise((svc) => svc.search(input))
-  }
 }

packages/opencode/src/file/ripgrep.ts

@@ -3,7 +3,7 @@ import path from "path"
 import { Global } from "../global"
 import fs from "fs/promises"
 import z from "zod"
-import { Effect, Layer, Context } from "effect"
+import { Effect, Layer, Context, Schema } from "effect"
 import * as Stream from "effect/Stream"
 import { ChildProcess } from "effect/unstable/process"
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
@@ -94,8 +94,43 @@ export namespace Ripgrep {
 
   const Result = z.union([Begin, Match, End, Summary])
 
+  const Hit = Schema.Struct({
+    type: Schema.Literal("match"),
+    data: Schema.Struct({
+      path: Schema.Struct({
+        text: Schema.String,
+      }),
+      lines: Schema.Struct({
+        text: Schema.String,
+      }),
+      line_number: Schema.Number,
+      absolute_offset: Schema.Number,
+      submatches: Schema.mutable(
+        Schema.Array(
+          Schema.Struct({
+            match: Schema.Struct({
+              text: Schema.String,
+            }),
+            start: Schema.Number,
+            end: Schema.Number,
+          }),
+        ),
+      ),
+    }),
+  })
+
+  const Row = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("begin"), data: Schema.Unknown }),
+    Hit,
+    Schema.Struct({ type: Schema.Literal("end"), data: Schema.Unknown }),
+    Schema.Struct({ type: Schema.Literal("summary"), data: Schema.Unknown }),
+  ])
+
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Row))
+
   export type Result = z.infer<typeof Result>
   export type Match = z.infer<typeof Match>
+  export type Item = Match["data"]
   export type Begin = z.infer<typeof Begin>
   export type End = z.infer<typeof End>
   export type Summary = z.infer<typeof Summary>
@@ -289,6 +324,13 @@ export namespace Ripgrep {
       follow?: boolean
       maxDepth?: number
     }) => Stream.Stream<string, PlatformError>
+    readonly search: (input: {
+      cwd: string
+      pattern: string
+      glob?: string[]
+      limit?: number
+      follow?: boolean
+    }) => Effect.Effect<{ items: Item[]; partial: boolean }, PlatformError | Error>
   }
 
   export class Service extends Context.Service<Service, Interface>()("@opencode/Ripgrep") {}
@@ -298,6 +340,32 @@ export namespace Ripgrep {
     Effect.gen(function* () {
       const spawner = yield* ChildProcessSpawner
       const afs = yield* AppFileSystem.Service
+      const bin = Effect.fn("Ripgrep.path")(function* () {
+        return yield* Effect.promise(() => filepath())
+      })
+      const args = Effect.fn("Ripgrep.args")(function* (input: {
+        mode: "files" | "search"
+        glob?: string[]
+        hidden?: boolean
+        follow?: boolean
+        maxDepth?: number
+        limit?: number
+        pattern?: string
+      }) {
+        const out = [yield* bin(), input.mode === "search" ? "--json" : "--files", "--glob=!.git/*"]
+        if (input.follow) out.push("--follow")
+        if (input.hidden !== false) out.push("--hidden")
+        if (input.maxDepth !== undefined) out.push(`--max-depth=${input.maxDepth}`)
+        if (input.glob) {
+          for (const g of input.glob) {
+            out.push(`--glob=${g}`)
+          }
+        }
+        if (input.limit) out.push(`--max-count=${input.limit}`)
+        if (input.mode === "search") out.push("--no-messages")
+        if (input.pattern) out.push("--", input.pattern)
+        return out
+      })
 
       const files = Effect.fn("Ripgrep.files")(function* (input: {
         cwd: string
@@ -306,7 +374,7 @@ export namespace Ripgrep {
         follow?: boolean
         maxDepth?: number
       }) {
-        const rgPath = yield* Effect.promise(() => filepath())
+        const rgPath = yield* bin()
         const isDir = yield* afs.isDir(input.cwd)
         if (!isDir) {
           return yield* Effect.die(
@@ -318,23 +386,77 @@ export namespace Ripgrep {
           )
         }
 
-        const args = [rgPath, "--files", "--glob=!.git/*"]
-        if (input.follow) args.push("--follow")
-        if (input.hidden !== false) args.push("--hidden")
-        if (input.maxDepth !== undefined) args.push(`--max-depth=${input.maxDepth}`)
-        if (input.glob) {
-          for (const g of input.glob) {
-            args.push(`--glob=${g}`)
-          }
-        }
+        const cmd = yield* args({
+          mode: "files",
+          glob: input.glob,
+          hidden: input.hidden,
+          follow: input.follow,
+          maxDepth: input.maxDepth,
+        })
 
         return spawner
-          .streamLines(ChildProcess.make(args[0], args.slice(1), { cwd: input.cwd }))
+          .streamLines(ChildProcess.make(cmd[0], cmd.slice(1), { cwd: input.cwd }))
           .pipe(Stream.filter((line: string) => line.length > 0))
       })
 
+      const search = Effect.fn("Ripgrep.search")(function* (input: {
+        cwd: string
+        pattern: string
+        glob?: string[]
+        limit?: number
+        follow?: boolean
+      }) {
+        return yield* Effect.scoped(
+          Effect.gen(function* () {
+            const cmd = yield* args({
+              mode: "search",
+              glob: input.glob,
+              follow: input.follow,
+              limit: input.limit,
+              pattern: input.pattern,
+            })
+
+            const handle = yield* spawner.spawn(
+              ChildProcess.make(cmd[0], cmd.slice(1), {
+                cwd: input.cwd,
+                stdin: "ignore",
+              }),
+            )
+
+            const [items, stderr, code] = yield* Effect.all(
+              [
+                Stream.decodeText(handle.stdout).pipe(
+                  Stream.splitLines,
+                  Stream.filter((line) => line.length > 0),
+                  Stream.mapEffect((line) =>
+                    decode(line).pipe(Effect.mapError((cause) => new Error("invalid ripgrep output", { cause }))),
+                  ),
+                  Stream.filter((row): row is Schema.Schema.Type<typeof Hit> => row.type === "match"),
+                  Stream.map((row): Item => row.data),
+                  Stream.runCollect,
+                  Effect.map((chunk) => [...chunk]),
+                ),
+                Stream.mkString(Stream.decodeText(handle.stderr)),
+                handle.exitCode,
+              ],
+              { concurrency: "unbounded" },
+            )
+
+            if (code !== 0 && code !== 1 && code !== 2) {
+              return yield* Effect.fail(new Error(`ripgrep failed: ${stderr}`))
+            }
+
+            return {
+              items,
+              partial: code === 2,
+            }
+          }),
+        )
+      })
+
       return Service.of({
         files: (input) => Stream.unwrap(files(input)),
+        search,
       })
     }),
   )
@@ -401,46 +523,4 @@ export namespace Ripgrep {
 
     return lines.join("\n")
   }
-
-  export async function search(input: {
-    cwd: string
-    pattern: string
-    glob?: string[]
-    limit?: number
-    follow?: boolean
-  }) {
-    const args = [`${await filepath()}`, "--json", "--hidden", "--glob=!.git/*"]
-    if (input.follow) args.push("--follow")
-
-    if (input.glob) {
-      for (const g of input.glob) {
-        args.push(`--glob=${g}`)
-      }
-    }
-
-    if (input.limit) {
-      args.push(`--max-count=${input.limit}`)
-    }
-
-    args.push("--")
-    args.push(input.pattern)
-
-    const result = await Process.text(args, {
-      cwd: input.cwd,
-      nothrow: true,
-    })
-    if (result.code !== 0) {
-      return []
-    }
-
-    // Handle both Unix (\n) and Windows (\r\n) line endings
-    const lines = result.text.trim().split(/\r?\n/).filter(Boolean)
-    // Parse JSON lines from ripgrep output
-
-    return lines
-      .map((line) => JSON.parse(line))
-      .map((parsed) => Result.parse(parsed))
-      .filter((r) => r.type === "match")
-      .map((r) => r.data)
-  }
 }

packages/opencode/src/format/formatter.ts

@@ -1,4 +1,3 @@
-import { text } from "node:stream/consumers"
 import { Npm } from "@/npm"
 import { Instance } from "../project/instance"
 import { Filesystem } from "../util/filesystem"
@@ -217,26 +216,16 @@ export const rlang: Info = {
   name: "air",
   extensions: [".R"],
   async enabled() {
-    const airPath = which("air")
-    if (airPath == null) return false
+    const air = which("air")
+    if (air == null) return false
 
-    try {
-      const proc = Process.spawn(["air", "--help"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      })
-      await proc.exited
-      if (!proc.stdout) return false
-      const output = await text(proc.stdout)
+    const output = await Process.text([air, "--help"], { nothrow: true })
 
-      // Check for "Air: An R language server and formatter"
-      const firstLine = output.split("\n")[0]
-      const hasR = firstLine.includes("R language")
-      const hasFormatter = firstLine.includes("formatter")
-      if (hasR && hasFormatter) return ["air", "format", "$FILE"]
-    } catch {
-      return false
-    }
+    // Check for "Air: An R language server and formatter"
+    const firstLine = output.text.split("\n")[0]
+    const hasR = firstLine.includes("R language")
+    const hasFormatter = firstLine.includes("formatter")
+    if (output.code === 0 && hasR && hasFormatter) return [air, "format", "$FILE"]
     return false
   },
 }
@@ -246,11 +235,10 @@ export const uvformat: Info = {
   extensions: [".py", ".pyi"],
   async enabled() {
     if (await ruff.enabled()) return false
-    if (which("uv") !== null) {
-      const proc = Process.spawn(["uv", "format", "--help"], { stderr: "pipe", stdout: "pipe" })
-      const code = await proc.exited
-      if (code === 0) return ["uv", "format", "--", "$FILE"]
-    }
+    const uv = which("uv")
+    if (uv == null) return false
+    const output = await Process.run([uv, "format", "--help"], { nothrow: true })
+    if (output.code === 0) return [uv, "format", "--", "$FILE"]
     return false
   },
 }

packages/opencode/src/lsp/index.ts

@@ -13,7 +13,6 @@ import { Process } from "../util/process"
 import { spawn as lspspawn } from "./launch"
 import { Effect, Layer, Context } from "effect"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 
 export namespace LSP {
   const log = Log.create({ service: "lsp" })
@@ -508,37 +507,6 @@ export namespace LSP {
 
   export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer))
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export const init = async () => runPromise((svc) => svc.init())
-
-  export const status = async () => runPromise((svc) => svc.status())
-
-  export const hasClients = async (file: string) => runPromise((svc) => svc.hasClients(file))
-
-  export const touchFile = async (input: string, waitForDiagnostics?: boolean) =>
-    runPromise((svc) => svc.touchFile(input, waitForDiagnostics))
-
-  export const diagnostics = async () => runPromise((svc) => svc.diagnostics())
-
-  export const hover = async (input: LocInput) => runPromise((svc) => svc.hover(input))
-
-  export const definition = async (input: LocInput) => runPromise((svc) => svc.definition(input))
-
-  export const references = async (input: LocInput) => runPromise((svc) => svc.references(input))
-
-  export const implementation = async (input: LocInput) => runPromise((svc) => svc.implementation(input))
-
-  export const documentSymbol = async (uri: string) => runPromise((svc) => svc.documentSymbol(uri))
-
-  export const workspaceSymbol = async (query: string) => runPromise((svc) => svc.workspaceSymbol(query))
-
-  export const prepareCallHierarchy = async (input: LocInput) => runPromise((svc) => svc.prepareCallHierarchy(input))
-
-  export const incomingCalls = async (input: LocInput) => runPromise((svc) => svc.incomingCalls(input))
-
-  export const outgoingCalls = async (input: LocInput) => runPromise((svc) => svc.outgoingCalls(input))
-
   export namespace Diagnostic {
     const MAX_PER_FILE = 20
 

packages/opencode/src/project/bootstrap.ts

@@ -9,24 +9,26 @@ import { Bus } from "../bus"
 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"
+import * as Effect from "effect/Effect"
 
-export async function InstanceBootstrap() {
+export const InstanceBootstrap = Effect.gen(function* () {
   Log.Default.info("bootstrapping", { directory: Instance.directory })
-  await Plugin.init()
-  void BootstrapRuntime.runPromise(ShareNext.Service.use((svc) => svc.init()))
-  void BootstrapRuntime.runPromise(Format.Service.use((svc) => svc.init()))
-  await LSP.init()
-  File.init()
-  void BootstrapRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
-  Vcs.init()
-  Snapshot.init()
+  yield* Plugin.Service.use((svc) => svc.init())
+  yield* ShareNext.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
+  yield* Format.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
+  yield* LSP.Service.use((svc) => svc.init())
+  yield* File.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
+  yield* FileWatcher.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
+  yield* Vcs.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
+  yield* Snapshot.Service.use((svc) => svc.init()).pipe(Effect.forkDetach)
 
-  Bus.subscribe(Command.Event.Executed, async (payload) => {
-    if (payload.properties.name === Command.Default.INIT) {
-      Project.setInitialized(Instance.project.id)
-    }
-  })
-}
+  yield* Bus.Service.use((svc) =>
+    svc.subscribeCallback(Command.Event.Executed, async (payload) => {
+      if (payload.properties.name === Command.Default.INIT) {
+        Project.setInitialized(Instance.project.id)
+      }
+    }),
+  )
+}).pipe(Effect.withSpan("InstanceBootstrap"))

packages/opencode/src/project/vcs.ts

@@ -4,7 +4,6 @@ import path from "path"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { FileWatcher } from "@/file/watcher"
 import { Git } from "@/git"
@@ -231,22 +230,4 @@ export namespace Vcs {
     Layer.provide(AppFileSystem.defaultLayer),
     Layer.provide(Bus.layer),
   )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function init() {
-    return runPromise((svc) => svc.init())
-  }
-
-  export async function branch() {
-    return runPromise((svc) => svc.branch())
-  }
-
-  export async function defaultBranch() {
-    return runPromise((svc) => svc.defaultBranch())
-  }
-
-  export async function diff(mode: Mode) {
-    return runPromise((svc) => svc.diff(mode))
-  }
 }

packages/opencode/src/pty/index.ts

@@ -1,7 +1,6 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 import { Instance } from "@/project/instance"
 import type { Proc } from "#pty"
 import z from "zod"
@@ -361,34 +360,4 @@ export namespace Pty {
   )
 
   export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Plugin.defaultLayer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function list() {
-    return runPromise((svc) => svc.list())
-  }
-
-  export async function get(id: PtyID) {
-    return runPromise((svc) => svc.get(id))
-  }
-
-  export async function write(id: PtyID, data: string) {
-    return runPromise((svc) => svc.write(id, data))
-  }
-
-  export async function connect(id: PtyID, ws: Socket, cursor?: number) {
-    return runPromise((svc) => svc.connect(id, ws, cursor))
-  }
-
-  export async function create(input: CreateInput) {
-    return runPromise((svc) => svc.create(input))
-  }
-
-  export async function update(id: PtyID, input: UpdateInput) {
-    return runPromise((svc) => svc.update(id, input))
-  }
-
-  export async function remove(id: PtyID) {
-    return runPromise((svc) => svc.remove(id))
-  }
 }

packages/opencode/src/server/control/index.ts

@@ -1,5 +1,7 @@
 import { Auth } from "@/auth"
+import { AppRuntime } from "@/effect/app-runtime"
 import { Log } from "@/util/log"
+import { Effect } from "effect"
 import { ProviderID } from "@/provider/schema"
 import { Hono } from "hono"
 import { describeRoute, resolver, validator, openAPIRouteHandler } from "hono-openapi"
@@ -39,7 +41,12 @@ export function ControlPlaneRoutes(): Hono {
       async (c) => {
         const providerID = c.req.valid("param").providerID
         const info = c.req.valid("json")
-        await Auth.set(providerID, info)
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const auth = yield* Auth.Service
+            yield* auth.set(providerID, info)
+          }),
+        )
         return c.json(true)
       },
     )
@@ -69,7 +76,12 @@ export function ControlPlaneRoutes(): Hono {
       ),
       async (c) => {
         const providerID = c.req.valid("param").providerID
-        await Auth.remove(providerID)
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const auth = yield* Auth.Service
+            yield* auth.remove(providerID)
+          }),
+        )
         return c.json(true)
       },
     )

packages/opencode/src/server/instance/config.ts

@@ -7,6 +7,8 @@ import { mapValues } from "remeda"
 import { errors } from "../error"
 import { Log } from "../../util/log"
 import { lazy } from "../../util/lazy"
+import { AppRuntime } from "../../effect/app-runtime"
+import { Effect } from "effect"
 
 const log = Log.create({ service: "server" })
 
@@ -82,7 +84,12 @@ export const ConfigRoutes = lazy(() =>
       }),
       async (c) => {
         using _ = log.time("providers")
-        const providers = await Provider.list().then((x) => mapValues(x, (item) => item))
+        const providers = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const svc = yield* Provider.Service
+            return mapValues(yield* svc.list(), (item) => item)
+          }),
+        )
         return c.json({
           providers: Object.values(providers),
           default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),

packages/opencode/src/server/instance/experimental.ts

@@ -162,7 +162,13 @@ export const ExperimentalRoutes = lazy(() =>
         },
       }),
       async (c) => {
-        return c.json(await ToolRegistry.ids())
+        const ids = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const registry = yield* ToolRegistry.Service
+            return yield* registry.ids()
+          }),
+        )
+        return c.json(ids)
       },
     )
     .get(
@@ -205,11 +211,17 @@ export const ExperimentalRoutes = lazy(() =>
       ),
       async (c) => {
         const { provider, model } = c.req.valid("query")
-        const tools = await ToolRegistry.tools({
-          providerID: ProviderID.make(provider),
-          modelID: ModelID.make(model),
-          agent: await Agent.get(await Agent.defaultAgent()),
-        })
+        const tools = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const agents = yield* Agent.Service
+            const registry = yield* ToolRegistry.Service
+            return yield* registry.tools({
+              providerID: ProviderID.make(provider),
+              modelID: ModelID.make(model),
+              agent: yield* agents.get(yield* agents.defaultAgent()),
+            })
+          }),
+        )
         return c.json(
           tools.map((t) => ({
             id: t.id,

packages/opencode/src/server/instance/file.ts

@@ -1,6 +1,8 @@
 import { Hono } from "hono"
 import { describeRoute, validator, resolver } from "hono-openapi"
+import { Effect } from "effect"
 import z from "zod"
+import { AppRuntime } from "../../effect/app-runtime"
 import { File } from "../../file"
 import { Ripgrep } from "../../file/ripgrep"
 import { LSP } from "../../lsp"
@@ -34,12 +36,10 @@ export const FileRoutes = lazy(() =>
       ),
       async (c) => {
         const pattern = c.req.valid("query").pattern
-        const result = await Ripgrep.search({
-          cwd: Instance.directory,
-          pattern,
-          limit: 10,
-        })
-        return c.json(result)
+        const result = await AppRuntime.runPromise(
+          Ripgrep.Service.use((svc) => svc.search({ cwd: Instance.directory, pattern, limit: 10 })),
+        )
+        return c.json(result.items)
       },
     )
     .get(
@@ -73,12 +73,16 @@ export const FileRoutes = lazy(() =>
         const dirs = c.req.valid("query").dirs
         const type = c.req.valid("query").type
         const limit = c.req.valid("query").limit
-        const results = await File.search({
-          query,
-          limit: limit ?? 10,
-          dirs: dirs !== "false",
-          type,
-        })
+        const results = await AppRuntime.runPromise(
+          File.Service.use((svc) =>
+            svc.search({
+              query,
+              limit: limit ?? 10,
+              dirs: dirs !== "false",
+              type,
+            }),
+          ),
+        )
         return c.json(results)
       },
     )
@@ -106,11 +110,6 @@ export const FileRoutes = lazy(() =>
         }),
       ),
       async (c) => {
-        /*
-      const query = c.req.valid("query").query
-      const result = await LSP.workspaceSymbol(query)
-      return c.json(result)
-      */
         return c.json([])
       },
     )
@@ -139,7 +138,7 @@ export const FileRoutes = lazy(() =>
       ),
       async (c) => {
         const path = c.req.valid("query").path
-        const content = await File.list(path)
+        const content = await AppRuntime.runPromise(File.Service.use((svc) => svc.list(path)))
         return c.json(content)
       },
     )
@@ -168,7 +167,7 @@ export const FileRoutes = lazy(() =>
       ),
       async (c) => {
         const path = c.req.valid("query").path
-        const content = await File.read(path)
+        const content = await AppRuntime.runPromise(File.Service.use((svc) => svc.read(path)))
         return c.json(content)
       },
     )
@@ -190,7 +189,7 @@ export const FileRoutes = lazy(() =>
         },
       }),
       async (c) => {
-        const content = await File.status()
+        const content = await AppRuntime.runPromise(File.Service.use((svc) => svc.status()))
         return c.json(content)
       },
     ),

packages/opencode/src/server/instance/index.ts

@@ -1,6 +1,7 @@
 import { describeRoute, resolver, validator } from "hono-openapi"
 import { Hono } from "hono"
 import type { UpgradeWebSocket } from "hono/ws"
+import { Effect } from "effect"
 import z from "zod"
 import { Format } from "../../format"
 import { TuiRoutes } from "./tui"
@@ -119,11 +120,17 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono =>
         },
       }),
       async (c) => {
-        const [branch, default_branch] = await Promise.all([Vcs.branch(), Vcs.defaultBranch()])
-        return c.json({
-          branch,
-          default_branch,
-        })
+        return c.json(
+          await AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const vcs = yield* Vcs.Service
+              const [branch, default_branch] = yield* Effect.all([vcs.branch(), vcs.defaultBranch()], {
+                concurrency: 2,
+              })
+              return { branch, default_branch }
+            }),
+          ),
+        )
       },
     )
     .get(
@@ -150,7 +157,14 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono =>
         }),
       ),
       async (c) => {
-        return c.json(await Vcs.diff(c.req.valid("query").mode))
+        return c.json(
+          await AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const vcs = yield* Vcs.Service
+              return yield* vcs.diff(c.req.valid("query").mode)
+            }),
+          ),
+        )
       },
     )
     .get(
@@ -215,7 +229,12 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono =>
         },
       }),
       async (c) => {
-        const skills = await Skill.all()
+        const skills = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const skill = yield* Skill.Service
+            return yield* skill.all()
+          }),
+        )
         return c.json(skills)
       },
     )
@@ -237,7 +256,8 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono =>
         },
       }),
       async (c) => {
-        return c.json(await LSP.status())
+        const items = await AppRuntime.runPromise(LSP.Service.use((lsp) => lsp.status()))
+        return c.json(items)
       },
     )
     .get(

packages/opencode/src/server/instance/middleware.ts

@@ -10,6 +10,7 @@ import { InstanceBootstrap } from "@/project/bootstrap"
 import { Session } from "@/session"
 import { SessionID } from "@/session/schema"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
+import { AppRuntime } from "@/effect/app-runtime"
 
 type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
 
@@ -66,7 +67,7 @@ export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): Middleware
     if (!workspaceID) {
       return Instance.provide({
         directory,
-        init: InstanceBootstrap,
+        init: () => AppRuntime.runPromise(InstanceBootstrap),
         async fn() {
           return next()
         },
@@ -103,7 +104,7 @@ export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): Middleware
         fn: () =>
           Instance.provide({
             directory: target.directory,
-            init: InstanceBootstrap,
+            init: () => AppRuntime.runPromise(InstanceBootstrap),
             async fn() {
               return next()
             },

packages/opencode/src/server/instance/project.ts

@@ -8,6 +8,7 @@ import { ProjectID } from "../../project/schema"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"
 import { InstanceBootstrap } from "../../project/bootstrap"
+import { AppRuntime } from "@/effect/app-runtime"
 
 export const ProjectRoutes = lazy(() =>
   new Hono()
@@ -83,7 +84,7 @@ export const ProjectRoutes = lazy(() =>
           directory: dir,
           worktree: dir,
           project: next,
-          init: InstanceBootstrap,
+          init: () => AppRuntime.runPromise(InstanceBootstrap),
         })
         return c.json(next)
       },

packages/opencode/src/server/instance/provider.ts

@@ -11,6 +11,7 @@ import { mapValues } from "remeda"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"
 import { Log } from "../../util/log"
+import { Effect } from "effect"
 
 const log = Log.create({ service: "server" })
 
@@ -40,27 +41,35 @@ export const ProviderRoutes = lazy(() =>
         },
       }),
       async (c) => {
-        const config = await Config.get()
-        const disabled = new Set(config.disabled_providers ?? [])
-        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-
-        const allProviders = await ModelsDev.get()
-        const filteredProviders: Record<string, (typeof allProviders)[string]> = {}
-        for (const [key, value] of Object.entries(allProviders)) {
-          if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
-            filteredProviders[key] = value
-          }
-        }
-
-        const connected = await Provider.list()
-        const providers = Object.assign(
-          mapValues(filteredProviders, (x) => Provider.fromModelsDevProvider(x)),
-          connected,
+        const result = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const svc = yield* Provider.Service
+            const config = yield* Effect.promise(() => Config.get())
+            const all = yield* Effect.promise(() => ModelsDev.get())
+            const disabled = new Set(config.disabled_providers ?? [])
+            const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
+            const filtered: Record<string, (typeof all)[string]> = {}
+            for (const [key, value] of Object.entries(all)) {
+              if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
+                filtered[key] = value
+              }
+            }
+            const connected = yield* svc.list()
+            const providers = Object.assign(
+              mapValues(filtered, (x) => Provider.fromModelsDevProvider(x)),
+              connected,
+            )
+            return {
+              all: Object.values(providers),
+              default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+              connected: Object.keys(connected),
+            }
+          }),
         )
         return c.json({
-          all: Object.values(providers),
-          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
-          connected: Object.keys(connected),
+          all: result.all,
+          default: result.default,
+          connected: result.connected,
         })
       },
     )

packages/opencode/src/server/instance/pty.ts

@@ -1,7 +1,9 @@
 import { Hono, type MiddlewareHandler } from "hono"
 import { describeRoute, validator, resolver } from "hono-openapi"
 import type { UpgradeWebSocket } from "hono/ws"
+import { Effect } from "effect"
 import z from "zod"
+import { AppRuntime } from "@/effect/app-runtime"
 import { Pty } from "@/pty"
 import { PtyID } from "@/pty/schema"
 import { NotFoundError } from "../../storage/db"
@@ -27,7 +29,14 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
         },
       }),
       async (c) => {
-        return c.json(await Pty.list())
+        return c.json(
+          await AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const pty = yield* Pty.Service
+              return yield* pty.list()
+            }),
+          ),
+        )
       },
     )
     .post(
@@ -50,7 +59,12 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
       }),
       validator("json", Pty.CreateInput),
       async (c) => {
-        const info = await Pty.create(c.req.valid("json"))
+        const info = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            return yield* pty.create(c.req.valid("json"))
+          }),
+        )
         return c.json(info)
       },
     )
@@ -74,7 +88,12 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
       }),
       validator("param", z.object({ ptyID: PtyID.zod })),
       async (c) => {
-        const info = await Pty.get(c.req.valid("param").ptyID)
+        const info = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            return yield* pty.get(c.req.valid("param").ptyID)
+          }),
+        )
         if (!info) {
           throw new NotFoundError({ message: "Session not found" })
         }
@@ -102,7 +121,12 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
       validator("param", z.object({ ptyID: PtyID.zod })),
       validator("json", Pty.UpdateInput),
       async (c) => {
-        const info = await Pty.update(c.req.valid("param").ptyID, c.req.valid("json"))
+        const info = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            return yield* pty.update(c.req.valid("param").ptyID, c.req.valid("json"))
+          }),
+        )
         return c.json(info)
       },
     )
@@ -126,7 +150,12 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
       }),
       validator("param", z.object({ ptyID: PtyID.zod })),
       async (c) => {
-        await Pty.remove(c.req.valid("param").ptyID)
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            yield* pty.remove(c.req.valid("param").ptyID)
+          }),
+        )
         return c.json(true)
       },
     )
@@ -150,6 +179,11 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
       }),
       validator("param", z.object({ ptyID: PtyID.zod })),
       upgradeWebSocket(async (c) => {
+        type Handler = {
+          onMessage: (message: string | ArrayBuffer) => void
+          onClose: () => void
+        }
+
         const id = PtyID.zod.parse(c.req.param("ptyID"))
         const cursor = (() => {
           const value = c.req.query("cursor")
@@ -158,8 +192,17 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
           if (!Number.isSafeInteger(parsed) || parsed < -1) return
           return parsed
         })()
-        let handler: Awaited<ReturnType<typeof Pty.connect>>
-        if (!(await Pty.get(id))) throw new Error("Session not found")
+        let handler: Handler | undefined
+        if (
+          !(await AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const pty = yield* Pty.Service
+              return yield* pty.get(id)
+            }),
+          ))
+        ) {
+          throw new Error("Session not found")
+        }
 
         type Socket = {
           readyState: number
@@ -185,7 +228,12 @@ export function PtyRoutes(upgradeWebSocket: UpgradeWebSocket) {
               ws.close()
               return
             }
-            handler = await Pty.connect(id, socket, cursor)
+            handler = await AppRuntime.runPromise(
+              Effect.gen(function* () {
+                const pty = yield* Pty.Service
+                return yield* pty.connect(id, socket, cursor)
+              }),
+            )
             ready = true
             for (const msg of pending) handler?.onMessage(msg)
             pending.length = 0

packages/opencode/src/session/llm.ts

@@ -94,14 +94,24 @@ export namespace LLM {
       modelID: input.model.id,
       providerID: input.model.providerID,
     })
-    const [language, cfg, provider, auth] = await Promise.all([
-      Provider.getLanguage(input.model),
-      Config.get(),
-      Provider.getProvider(input.model.providerID),
-      Auth.get(input.model.providerID),
-    ])
+    const [language, cfg, provider, info] = await Effect.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        const cfg = yield* Config.Service
+        const provider = yield* Provider.Service
+        return yield* Effect.all(
+          [
+            provider.getLanguage(input.model),
+            cfg.get(),
+            provider.getProvider(input.model.providerID),
+            auth.get(input.model.providerID),
+          ],
+          { concurrency: "unbounded" },
+        )
+      }).pipe(Effect.provide(Layer.mergeAll(Auth.defaultLayer, Config.defaultLayer, Provider.defaultLayer))),
+    )
     // TODO: move this to a proper hook
-    const isOpenaiOauth = provider.id === "openai" && auth?.type === "oauth"
+    const isOpenaiOauth = provider.id === "openai" && info?.type === "oauth"
 
     const system: string[] = []
     system.push(
@@ -200,7 +210,7 @@ export namespace LLM {
       },
     )
 
-    const tools = await resolveTools(input)
+    const tools = resolveTools(input)
 
     // LiteLLM and some Anthropic proxies require the tools parameter to be present
     // when message history contains tool calls, even if no tools are being used.

packages/opencode/src/skill/index.ts

@@ -7,7 +7,6 @@ import { NamedError } from "@opencode-ai/util/error"
 import type { Agent } from "@/agent/agent"
 import { Bus } from "@/bus"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { Global } from "@/global"
 import { Permission } from "@/permission"
@@ -262,22 +261,4 @@ export namespace Skill {
         .map((skill) => `- **${skill.name}**: ${skill.description}`),
     ].join("\n")
   }
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function get(name: string) {
-    return runPromise((skill) => skill.get(name))
-  }
-
-  export async function all() {
-    return runPromise((skill) => skill.all())
-  }
-
-  export async function dirs() {
-    return runPromise((skill) => skill.dirs())
-  }
-
-  export async function available(agent?: Agent.Info) {
-    return runPromise((skill) => skill.available(agent))
-  }
 }

packages/opencode/src/tool/grep.ts

@@ -1,11 +1,8 @@
 import z from "zod"
-import { Effect } from "effect"
-import * as Stream from "effect/Stream"
+import { Effect, Option } from "effect"
 import { Tool } from "./tool"
-import { Filesystem } from "../util/filesystem"
 import { Ripgrep } from "../file/ripgrep"
-import { ChildProcess } from "effect/unstable/process"
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
+import { AppFileSystem } from "../filesystem"
 
 import DESCRIPTION from "./grep.txt"
 import { Instance } from "../project/instance"
@@ -17,7 +14,8 @@ const MAX_LINE_LENGTH = 2000
 export const GrepTool = Tool.define(
   "grep",
   Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner
+    const fs = yield* AppFileSystem.Service
+    const rg = yield* Ripgrep.Service
 
     return {
       description: DESCRIPTION,
@@ -28,6 +26,11 @@ export const GrepTool = Tool.define(
       }),
       execute: (params: { pattern: string; path?: string; include?: string }, ctx: Tool.Context) =>
         Effect.gen(function* () {
+          const empty = {
+            title: params.pattern,
+            metadata: { matches: 0, truncated: false },
+            output: "No files found",
+          }
           if (!params.pattern) {
             throw new Error("pattern is required")
           }
@@ -43,92 +46,58 @@ export const GrepTool = Tool.define(
             },
           })
 
-          let searchPath = params.path ?? Instance.directory
-          searchPath = path.isAbsolute(searchPath) ? searchPath : path.resolve(Instance.directory, searchPath)
+          const searchPath = AppFileSystem.resolve(
+            path.isAbsolute(params.path ?? Instance.directory)
+              ? (params.path ?? Instance.directory)
+              : path.join(Instance.directory, params.path ?? "."),
+          )
           yield* assertExternalDirectoryEffect(ctx, searchPath, { kind: "directory" })
 
-          const rgPath = yield* Effect.promise(() => Ripgrep.filepath())
-          const args = ["-nH", "--hidden", "--no-messages", "--field-match-separator=|", "--regexp", params.pattern]
-          if (params.include) {
-            args.push("--glob", params.include)
-          }
-          args.push(searchPath)
+          const result = yield* rg.search({
+            cwd: searchPath,
+            pattern: params.pattern,
+            glob: params.include ? [params.include] : undefined,
+          })
 
-          const result = yield* Effect.scoped(
-            Effect.gen(function* () {
-              const handle = yield* spawner.spawn(
-                ChildProcess.make(rgPath, args, {
-                  stdin: "ignore",
-                }),
-              )
+          if (result.items.length === 0) return empty
 
-              const [output, errorOutput] = yield* Effect.all(
-                [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
-                { concurrency: 2 },
-              )
-
-              const exitCode = yield* handle.exitCode
-
-              return { output, errorOutput, exitCode }
-            }),
+          const rows = result.items.map((item) => ({
+            path: AppFileSystem.resolve(
+              path.isAbsolute(item.path.text) ? item.path.text : path.join(searchPath, item.path.text),
+            ),
+            line: item.line_number,
+            text: item.lines.text,
+          }))
+          const times = new Map(
+            (yield* Effect.forEach(
+              [...new Set(rows.map((row) => row.path))],
+              Effect.fnUntraced(function* (file) {
+                const info = yield* fs.stat(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
+                if (!info || info.type === "Directory") return undefined
+                return [
+                  file,
+                  info.mtime.pipe(
+                    Option.map((time) => time.getTime()),
+                    Option.getOrElse(() => 0),
+                  ) ?? 0,
+                ] as const
+              }),
+              { concurrency: 16 },
+            )).filter((entry): entry is readonly [string, number] => Boolean(entry)),
           )
+          const matches = rows.flatMap((row) => {
+            const mtime = times.get(row.path)
+            if (mtime === undefined) return []
+            return [{ ...row, mtime }]
+          })
 
-          const { output, errorOutput, exitCode } = result
-
-          // Exit codes: 0 = matches found, 1 = no matches, 2 = errors (but may still have matches)
-          // With --no-messages, we suppress error output but still get exit code 2 for broken symlinks etc.
-          // Only fail if exit code is 2 AND no output was produced
-          if (exitCode === 1 || (exitCode === 2 && !output.trim())) {
-            return {
-              title: params.pattern,
-              metadata: { matches: 0, truncated: false },
-              output: "No files found",
-            }
-          }
-
-          if (exitCode !== 0 && exitCode !== 2) {
-            throw new Error(`ripgrep failed: ${errorOutput}`)
-          }
-
-          const hasErrors = exitCode === 2
-
-          // Handle both Unix (\n) and Windows (\r\n) line endings
-          const lines = output.trim().split(/\r?\n/)
-          const matches = []
-
-          for (const line of lines) {
-            if (!line) continue
-
-            const [filePath, lineNumStr, ...lineTextParts] = line.split("|")
-            if (!filePath || !lineNumStr || lineTextParts.length === 0) continue
-
-            const lineNum = parseInt(lineNumStr, 10)
-            const lineText = lineTextParts.join("|")
-
-            const stats = Filesystem.stat(filePath)
-            if (!stats) continue
-
-            matches.push({
-              path: filePath,
-              modTime: stats.mtime.getTime(),
-              lineNum,
-              lineText,
-            })
-          }
-
-          matches.sort((a, b) => b.modTime - a.modTime)
+          matches.sort((a, b) => b.mtime - a.mtime)
 
           const limit = 100
           const truncated = matches.length > limit
           const finalMatches = truncated ? matches.slice(0, limit) : matches
 
-          if (finalMatches.length === 0) {
-            return {
-              title: params.pattern,
-              metadata: { matches: 0, truncated: false },
-              output: "No files found",
-            }
-          }
+          if (finalMatches.length === 0) return empty
 
           const totalMatches = matches.length
           const outputLines = [`Found ${totalMatches} matches${truncated ? ` (showing first ${limit})` : ""}`]
@@ -143,10 +112,8 @@ export const GrepTool = Tool.define(
               outputLines.push(`${match.path}:`)
             }
             const truncatedLineText =
-              match.lineText.length > MAX_LINE_LENGTH
-                ? match.lineText.substring(0, MAX_LINE_LENGTH) + "..."
-                : match.lineText
-            outputLines.push(`  Line ${match.lineNum}: ${truncatedLineText}`)
+              match.text.length > MAX_LINE_LENGTH ? match.text.substring(0, MAX_LINE_LENGTH) + "..." : match.text
+            outputLines.push(`  Line ${match.line}: ${truncatedLineText}`)
           }
 
           if (truncated) {
@@ -156,7 +123,7 @@ export const GrepTool = Tool.define(
             )
           }
 
-          if (hasErrors) {
+          if (result.partial) {
             outputLines.push("")
             outputLines.push("(Some paths were inaccessible and skipped)")
           }

packages/opencode/src/tool/lsp.ts

@@ -26,6 +26,7 @@ export const LspTool = Tool.define(
   Effect.gen(function* () {
     const lsp = yield* LSP.Service
     const fs = yield* AppFileSystem.Service
+
     return {
       description: DESCRIPTION,
       parameters: z.object({
@@ -41,17 +42,7 @@ export const LspTool = Tool.define(
         Effect.gen(function* () {
           const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(Instance.directory, args.filePath)
           yield* assertExternalDirectoryEffect(ctx, file)
-          yield* ctx.ask({
-            permission: "lsp",
-            patterns: ["*"],
-            always: ["*"],
-            metadata: {
-              operation: args.operation,
-              filePath: file,
-              line: args.line,
-              character: args.character,
-            },
-          })
+          yield* ctx.ask({ permission: "lsp", patterns: ["*"], always: ["*"], metadata: {} })
 
           const uri = pathToFileURL(file).href
           const position = { file, line: args.line - 1, character: args.character - 1 }
@@ -94,7 +85,7 @@ export const LspTool = Tool.define(
             metadata: { result },
             output: result.length === 0 ? `No results found for ${args.operation}` : JSON.stringify(result, null, 2),
           }
-        }).pipe(Effect.orDie),
+        }),
     }
   }),
 )

packages/opencode/src/tool/registry.ts

@@ -36,7 +36,6 @@ import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
 import { Ripgrep } from "../file/ripgrep"
 import { Format } from "../format"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 import { Env } from "../env"
 import { Question } from "../question"
 import { Todo } from "../session/todo"
@@ -344,18 +343,4 @@ export namespace ToolRegistry {
       Layer.provide(Truncate.defaultLayer),
     ),
   )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function ids() {
-    return runPromise((svc) => svc.ids())
-  }
-
-  export async function tools(input: {
-    providerID: ProviderID
-    modelID: ModelID
-    agent: Agent.Info
-  }): Promise<(Tool.Def & { id: string })[]> {
-    return runPromise((svc) => svc.tools(input))
-  }
 }

packages/opencode/src/worktree/index.ts

@@ -17,6 +17,7 @@ import { Effect, Layer, Path, Scope, Context, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { NodePath } from "@effect/platform-node"
 import { AppFileSystem } from "@/filesystem"
+import { BootstrapRuntime } from "@/effect/bootstrap-runtime"
 import { makeRuntime } from "@/effect/run-service"
 import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
 import { InstanceState } from "@/effect/instance-state"
@@ -266,7 +267,7 @@ export namespace Worktree {
         const booted = yield* Effect.promise(() =>
           Instance.provide({
             directory: info.directory,
-            init: InstanceBootstrap,
+            init: () => BootstrapRuntime.runPromise(InstanceBootstrap),
             fn: () => undefined,
           })
             .then(() => true)

packages/opencode/test/auth/auth.test.ts

@@ -1,58 +1,86 @@
-import { test, expect } from "bun:test"
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
 import { Auth } from "../../src/auth"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
-test("set normalizes trailing slashes in keys", async () => {
-  await Auth.set("https://example.com/", {
-    type: "wellknown",
-    key: "TOKEN",
-    token: "abc",
-  })
-  const data = await Auth.all()
-  expect(data["https://example.com"]).toBeDefined()
-  expect(data["https://example.com/"]).toBeUndefined()
-})
+const node = CrossSpawnSpawner.defaultLayer
 
-test("set cleans up pre-existing trailing-slash entry", async () => {
-  // Simulate a pre-fix entry with trailing slash
-  await Auth.set("https://example.com/", {
-    type: "wellknown",
-    key: "TOKEN",
-    token: "old",
-  })
-  // Re-login with normalized key (as the CLI does post-fix)
-  await Auth.set("https://example.com", {
-    type: "wellknown",
-    key: "TOKEN",
-    token: "new",
-  })
-  const data = await Auth.all()
-  const keys = Object.keys(data).filter((k) => k.includes("example.com"))
-  expect(keys).toEqual(["https://example.com"])
-  const entry = data["https://example.com"]!
-  expect(entry.type).toBe("wellknown")
-  if (entry.type === "wellknown") expect(entry.token).toBe("new")
-})
+const it = testEffect(Layer.mergeAll(Auth.defaultLayer, node))
 
-test("remove deletes both trailing-slash and normalized keys", async () => {
-  await Auth.set("https://example.com", {
-    type: "wellknown",
-    key: "TOKEN",
-    token: "abc",
-  })
-  await Auth.remove("https://example.com/")
-  const data = await Auth.all()
-  expect(data["https://example.com"]).toBeUndefined()
-  expect(data["https://example.com/"]).toBeUndefined()
-})
+describe("Auth", () => {
+  it.live("set normalizes trailing slashes in keys", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.set("https://example.com/", {
+          type: "wellknown",
+          key: "TOKEN",
+          token: "abc",
+        })
+        const data = yield* auth.all()
+        expect(data["https://example.com"]).toBeDefined()
+        expect(data["https://example.com/"]).toBeUndefined()
+      }),
+    ),
+  )
 
-test("set and remove are no-ops on keys without trailing slashes", async () => {
-  await Auth.set("anthropic", {
-    type: "api",
-    key: "sk-test",
-  })
-  const data = await Auth.all()
-  expect(data["anthropic"]).toBeDefined()
-  await Auth.remove("anthropic")
-  const after = await Auth.all()
-  expect(after["anthropic"]).toBeUndefined()
+  it.live("set cleans up pre-existing trailing-slash entry", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.set("https://example.com/", {
+          type: "wellknown",
+          key: "TOKEN",
+          token: "old",
+        })
+        yield* auth.set("https://example.com", {
+          type: "wellknown",
+          key: "TOKEN",
+          token: "new",
+        })
+        const data = yield* auth.all()
+        const keys = Object.keys(data).filter((key) => key.includes("example.com"))
+        expect(keys).toEqual(["https://example.com"])
+        const entry = data["https://example.com"]!
+        expect(entry.type).toBe("wellknown")
+        if (entry.type === "wellknown") expect(entry.token).toBe("new")
+      }),
+    ),
+  )
+
+  it.live("remove deletes both trailing-slash and normalized keys", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.set("https://example.com", {
+          type: "wellknown",
+          key: "TOKEN",
+          token: "abc",
+        })
+        yield* auth.remove("https://example.com/")
+        const data = yield* auth.all()
+        expect(data["https://example.com"]).toBeUndefined()
+        expect(data["https://example.com/"]).toBeUndefined()
+      }),
+    ),
+  )
+
+  it.live("set and remove are no-ops on keys without trailing slashes", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.set("anthropic", {
+          type: "api",
+          key: "sk-test",
+        })
+        const data = yield* auth.all()
+        expect(data["anthropic"]).toBeDefined()
+        yield* auth.remove("anthropic")
+        const after = yield* auth.all()
+        expect(after["anthropic"]).toBeUndefined()
+      }),
+    ),
+  )
 })

packages/opencode/test/bus/bus-effect.test.ts

@@ -1,10 +1,10 @@
-import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node"
 import { describe, expect } from "bun:test"
 import { Deferred, Effect, Layer, Stream } from "effect"
 import z from "zod"
 import { Bus } from "../../src/bus"
 import { BusEvent } from "../../src/bus/bus-event"
 import { Instance } from "../../src/project/instance"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
 import { provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
 import { testEffect } from "../lib/effect"
 
@@ -13,9 +13,7 @@ const TestEvent = {
   Pong: BusEvent.define("test.effect.pong", z.object({ message: z.string() })),
 }
 
-const node = NodeChildProcessSpawner.layer.pipe(
-  Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)),
-)
+const node = CrossSpawnSpawner.defaultLayer
 
 const live = Layer.mergeAll(Bus.layer, node)
 

packages/opencode/test/cli/tui/plugin-loader.test.ts

@@ -6,7 +6,6 @@ import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { Global } from "../../../src/global"
 import { TuiConfig } from "../../../src/config/tui"
-import { Config } from "../../../src/config/config"
 import { Filesystem } from "../../../src/util/filesystem"
 
 const { allThemes, addTheme } = await import("../../../src/cli/cmd/tui/context/theme")
@@ -325,7 +324,6 @@ export default {
   })
   const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
   const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
-  const install = spyOn(Config, "installDependencies").mockResolvedValue()
 
   try {
     expect(addTheme(tmp.extra.preloadedThemeName, { theme: { primary: "#303030" } })).toBe(true)
@@ -407,7 +405,6 @@ export default {
     await TuiPluginRuntime.dispose()
     cwd.mockRestore()
     wait.mockRestore()
-    install.mockRestore()
     if (backup === undefined) {
       await fs.rm(globalConfigPath, { force: true })
     } else {
@@ -701,7 +698,6 @@ test("updates installed theme when plugin metadata changes", async () => {
   process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
   const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
   const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
-  const install = spyOn(Config, "installDependencies").mockResolvedValue()
 
   const api = () =>
     createTuiPluginApi({
@@ -746,7 +742,6 @@ test("updates installed theme when plugin metadata changes", async () => {
     await TuiPluginRuntime.dispose()
     cwd.mockRestore()
     wait.mockRestore()
-    install.mockRestore()
     delete process.env.OPENCODE_PLUGIN_META_FILE
   }
 })

packages/opencode/test/config/config.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe, mock, afterEach, beforeEach, spyOn } from "bun:test"
-import { Effect, Layer, Option } from "effect"
+import { Deferred, Effect, Fiber, Layer, Option } from "effect"
 import { NodeFileSystem, NodePath } from "@effect/platform-node"
 import { Config } from "../../src/config/config"
 import { Instance } from "../../src/project/instance"
@@ -7,8 +7,9 @@ import { Auth } from "../../src/auth"
 import { AccessToken, Account, AccountID, OrgID } from "../../src/account"
 import { AppFileSystem } from "../../src/filesystem"
 import { provideTmpdirInstance } from "../fixture/fixture"
-import { tmpdir } from "../fixture/fixture"
+import { tmpdir, tmpdirScoped } from "../fixture/fixture"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { testEffect } from "../lib/effect"
 
 /** Infra layer that provides FileSystem, Path, ChildProcessSpawner for test fixtures */
 const infra = CrossSpawnSpawner.defaultLayer.pipe(
@@ -32,6 +33,18 @@ const emptyAuth = Layer.mock(Auth.Service)({
   all: () => Effect.succeed({}),
 })
 
+const it = testEffect(
+  Config.layer.pipe(
+    Layer.provide(AppFileSystem.defaultLayer),
+    Layer.provide(emptyAuth),
+    Layer.provide(emptyAccount),
+    Layer.provideMerge(infra),
+  ),
+)
+
+const installDeps = (dir: string, input?: Config.InstallInput) =>
+  Config.Service.use((svc) => svc.installDependencies(dir, input))
+
 // Get managed config directory from environment (set in preload.ts)
 const managedConfigDir = process.env.OPENCODE_TEST_MANAGED_CONFIG_DIR!
 
@@ -817,128 +830,134 @@ test("installs dependencies in writable OPENCODE_CONFIG_DIR", async () => {
   }
 })
 
-test("dedupes concurrent config dependency installs for the same dir", async () => {
-  await using tmp = await tmpdir()
-  const dir = path.join(tmp.path, "a")
-  await fs.mkdir(dir, { recursive: true })
+it.live("dedupes concurrent config dependency installs for the same dir", () =>
+  Effect.gen(function* () {
+    const tmp = yield* tmpdirScoped()
+    const dir = path.join(tmp, "a")
+    yield* Effect.promise(() => fs.mkdir(dir, { recursive: true }))
 
-  const ticks: number[] = []
-  let calls = 0
-  let start = () => {}
-  let done = () => {}
-  let blocked = () => {}
-  const ready = new Promise<void>((resolve) => {
-    start = resolve
-  })
-  const gate = new Promise<void>((resolve) => {
-    done = resolve
-  })
-  const waiting = new Promise<void>((resolve) => {
-    blocked = resolve
-  })
-  const online = spyOn(Network, "online").mockReturnValue(false)
-  const targetDir = dir
-  const run = spyOn(Npm, "install").mockImplementation(async (d: string) => {
-    const hit = path.normalize(d) === path.normalize(targetDir)
-    if (hit) {
+    let calls = 0
+    const online = spyOn(Network, "online").mockReturnValue(false)
+    const ready = Deferred.makeUnsafe<void>()
+    const blocked = Deferred.makeUnsafe<void>()
+    const hold = Deferred.makeUnsafe<void>()
+    const target = path.normalize(dir)
+    const run = spyOn(Npm, "install").mockImplementation(async (d: string) => {
+      if (path.normalize(d) !== target) return
       calls += 1
-      start()
-      await gate
-    }
-    const mod = path.join(d, "node_modules", "@opencode-ai", "plugin")
-    await fs.mkdir(mod, { recursive: true })
-    await Filesystem.write(
-      path.join(mod, "package.json"),
-      JSON.stringify({ name: "@opencode-ai/plugin", version: "1.0.0" }),
-    )
-    if (hit) {
-      start()
-      await gate
-    }
-  })
-
-  try {
-    const first = Config.installDependencies(dir)
-    await ready
-    const second = Config.installDependencies(dir, {
-      waitTick: (tick) => {
-        ticks.push(tick.attempt)
-        blocked()
-        blocked = () => {}
-      },
+      Deferred.doneUnsafe(ready, Effect.void)
+      await Effect.runPromise(Deferred.await(hold))
+      const mod = path.join(d, "node_modules", "@opencode-ai", "plugin")
+      await fs.mkdir(mod, { recursive: true })
+      await Filesystem.write(
+        path.join(mod, "package.json"),
+        JSON.stringify({ name: "@opencode-ai/plugin", version: "1.0.0" }),
+      )
     })
-    await waiting
-    done()
-    await Promise.all([first, second])
-  } finally {
-    online.mockRestore()
-    run.mockRestore()
-  }
 
-  expect(calls).toBe(2)
-  expect(ticks.length).toBeGreaterThan(0)
-  expect(await Filesystem.exists(path.join(dir, "package.json"))).toBe(true)
-})
-
-test("serializes config dependency installs across dirs", async () => {
-  if (process.platform !== "win32") return
-
-  await using tmp = await tmpdir()
-  const a = path.join(tmp.path, "a")
-  const b = path.join(tmp.path, "b")
-  await fs.mkdir(a, { recursive: true })
-  await fs.mkdir(b, { recursive: true })
-
-  let calls = 0
-  let open = 0
-  let peak = 0
-  let start = () => {}
-  let done = () => {}
-  const ready = new Promise<void>((resolve) => {
-    start = resolve
-  })
-  const gate = new Promise<void>((resolve) => {
-    done = resolve
-  })
-
-  const online = spyOn(Network, "online").mockReturnValue(false)
-  const run = spyOn(Npm, "install").mockImplementation(async (dir: string) => {
-    const cwd = path.normalize(dir)
-    const hit = cwd === path.normalize(a) || cwd === path.normalize(b)
-    if (hit) {
-      calls += 1
-      open += 1
-      peak = Math.max(peak, open)
-      if (calls === 1) {
-        start()
-        await gate
-      }
-    }
-    const mod = path.join(cwd, "node_modules", "@opencode-ai", "plugin")
-    await fs.mkdir(mod, { recursive: true })
-    await Filesystem.write(
-      path.join(mod, "package.json"),
-      JSON.stringify({ name: "@opencode-ai/plugin", version: "1.0.0" }),
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        online.mockRestore()
+        run.mockRestore()
+      }),
     )
-    if (hit) {
-      open -= 1
-    }
-  })
 
-  try {
-    const first = Config.installDependencies(a)
-    await ready
-    const second = Config.installDependencies(b)
-    done()
-    await Promise.all([first, second])
-  } finally {
-    online.mockRestore()
-    run.mockRestore()
-  }
+    const first = yield* installDeps(dir).pipe(Effect.forkScoped)
+    yield* Deferred.await(ready)
 
-  expect(calls).toBe(2)
-  expect(peak).toBe(1)
-})
+    let done = false
+    const second = yield* installDeps(dir, {
+      waitTick: () => {
+        Deferred.doneUnsafe(blocked, Effect.void)
+      },
+    }).pipe(
+      Effect.tap(() =>
+        Effect.sync(() => {
+          done = true
+        }),
+      ),
+      Effect.forkScoped,
+    )
+
+    yield* Deferred.await(blocked)
+    expect(done).toBe(false)
+
+    yield* Deferred.succeed(hold, void 0)
+    yield* Fiber.join(first)
+    yield* Fiber.join(second)
+
+    expect(calls).toBe(1)
+    expect(yield* Effect.promise(() => Filesystem.exists(path.join(dir, "package.json")))).toBe(true)
+  }),
+)
+
+it.live("serializes config dependency installs across dirs", () =>
+  Effect.gen(function* () {
+    if (process.platform !== "win32") return
+
+    const tmp = yield* tmpdirScoped()
+    const a = path.join(tmp, "a")
+    const b = path.join(tmp, "b")
+    yield* Effect.promise(() => fs.mkdir(a, { recursive: true }))
+    yield* Effect.promise(() => fs.mkdir(b, { recursive: true }))
+
+    let calls = 0
+    let open = 0
+    let peak = 0
+    const ready = Deferred.makeUnsafe<void>()
+    const blocked = Deferred.makeUnsafe<void>()
+    const hold = Deferred.makeUnsafe<void>()
+
+    const online = spyOn(Network, "online").mockReturnValue(false)
+    const run = spyOn(Npm, "install").mockImplementation(async (dir: string) => {
+      const cwd = path.normalize(dir)
+      const hit = cwd === path.normalize(a) || cwd === path.normalize(b)
+      if (hit) {
+        calls += 1
+        open += 1
+        peak = Math.max(peak, open)
+        if (calls === 1) {
+          Deferred.doneUnsafe(ready, Effect.void)
+          await Effect.runPromise(Deferred.await(hold))
+        }
+      }
+      const mod = path.join(cwd, "node_modules", "@opencode-ai", "plugin")
+      await fs.mkdir(mod, { recursive: true })
+      await Filesystem.write(
+        path.join(mod, "package.json"),
+        JSON.stringify({ name: "@opencode-ai/plugin", version: "1.0.0" }),
+      )
+      if (hit) {
+        open -= 1
+      }
+    })
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        online.mockRestore()
+        run.mockRestore()
+      }),
+    )
+
+    const first = yield* installDeps(a).pipe(Effect.forkScoped)
+    yield* Deferred.await(ready)
+
+    const second = yield* installDeps(b, {
+      waitTick: () => {
+        Deferred.doneUnsafe(blocked, Effect.void)
+      },
+    }).pipe(Effect.forkScoped)
+    yield* Deferred.await(blocked)
+    expect(peak).toBe(1)
+
+    yield* Deferred.succeed(hold, void 0)
+    yield* Fiber.join(first)
+    yield* Fiber.join(second)
+
+    expect(calls).toBe(2)
+    expect(peak).toBe(1)
+  }),
+)
 
 test("resolves scoped npm plugins in config", async () => {
   await using tmp = await tmpdir({

packages/opencode/test/file/fsmonitor.test.ts

@@ -1,10 +1,16 @@
 import { $ } from "bun"
 import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
 import fs from "fs/promises"
 import path from "path"
 import { File } from "../../src/file"
 import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
+import { provideInstance, tmpdir } from "../fixture/fixture"
+
+const run = <A, E>(eff: Effect.Effect<A, E, File.Service>) =>
+  Effect.runPromise(provideInstance(Instance.directory)(eff.pipe(Effect.provide(File.defaultLayer))))
+const status = () => run(File.Service.use((svc) => svc.status()))
+const read = (file: string) => run(File.Service.use((svc) => svc.read(file)))
 
 const wintest = process.platform === "win32" ? test : test.skip
 
@@ -27,7 +33,7 @@ describe("file fsmonitor", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        await File.status()
+        await status()
       },
     })
 
@@ -52,7 +58,7 @@ describe("file fsmonitor", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        await File.read("tracked.txt")
+        await read("tracked.txt")
       },
     })
 

packages/opencode/test/file/index.test.ts

@@ -1,18 +1,28 @@
 import { afterEach, describe, test, expect } from "bun:test"
 import { $ } from "bun"
+import { Effect } from "effect"
 import path from "path"
 import fs from "fs/promises"
 import { File } from "../../src/file"
 import { Instance } from "../../src/project/instance"
 import { Filesystem } from "../../src/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
+import { provideInstance, tmpdir } from "../fixture/fixture"
 
 afterEach(async () => {
   await Instance.disposeAll()
 })
 
+const init = () => run(File.Service.use((svc) => svc.init()))
+const run = <A, E>(eff: Effect.Effect<A, E, File.Service>) =>
+  Effect.runPromise(provideInstance(Instance.directory)(eff.pipe(Effect.provide(File.defaultLayer))))
+const status = () => run(File.Service.use((svc) => svc.status()))
+const read = (file: string) => run(File.Service.use((svc) => svc.read(file)))
+const list = (dir?: string) => run(File.Service.use((svc) => svc.list(dir)))
+const search = (input: { query: string; limit?: number; dirs?: boolean; type?: "file" | "directory" }) =>
+  run(File.Service.use((svc) => svc.search(input)))
+
 describe("file/index Filesystem patterns", () => {
-  describe("File.read() - text content", () => {
+  describe("read() - text content", () => {
     test("reads text file via Filesystem.readText()", async () => {
       await using tmp = await tmpdir()
       const filepath = path.join(tmp.path, "test.txt")
@@ -21,7 +31,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.txt")
+          const result = await read("test.txt")
           expect(result.type).toBe("text")
           expect(result.content).toBe("Hello World")
         },
@@ -35,7 +45,7 @@ describe("file/index Filesystem patterns", () => {
         directory: tmp.path,
         fn: async () => {
           // Non-existent file should return empty content
-          const result = await File.read("nonexistent.txt")
+          const result = await read("nonexistent.txt")
           expect(result.type).toBe("text")
           expect(result.content).toBe("")
         },
@@ -50,7 +60,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.txt")
+          const result = await read("test.txt")
           expect(result.content).toBe("content with spaces")
         },
       })
@@ -64,7 +74,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("empty.txt")
+          const result = await read("empty.txt")
           expect(result.type).toBe("text")
           expect(result.content).toBe("")
         },
@@ -79,14 +89,14 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("multiline.txt")
+          const result = await read("multiline.txt")
           expect(result.content).toBe("line1\nline2\nline3")
         },
       })
     })
   })
 
-  describe("File.read() - binary content", () => {
+  describe("read() - binary content", () => {
     test("reads binary file via Filesystem.readArrayBuffer()", async () => {
       await using tmp = await tmpdir()
       const filepath = path.join(tmp.path, "image.png")
@@ -96,7 +106,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("image.png")
+          const result = await read("image.png")
           expect(result.type).toBe("text") // Images return as text with base64 encoding
           expect(result.encoding).toBe("base64")
           expect(result.mimeType).toBe("image/png")
@@ -113,7 +123,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("binary.so")
+          const result = await read("binary.so")
           expect(result.type).toBe("binary")
           expect(result.content).toBe("")
         },
@@ -121,7 +131,7 @@ describe("file/index Filesystem patterns", () => {
     })
   })
 
-  describe("File.read() - Filesystem.mimeType()", () => {
+  describe("read() - Filesystem.mimeType()", () => {
     test("detects MIME type via Filesystem.mimeType()", async () => {
       await using tmp = await tmpdir()
       const filepath = path.join(tmp.path, "test.json")
@@ -132,7 +142,7 @@ describe("file/index Filesystem patterns", () => {
         fn: async () => {
           expect(Filesystem.mimeType(filepath)).toContain("application/json")
 
-          const result = await File.read("test.json")
+          const result = await read("test.json")
           expect(result.type).toBe("text")
         },
       })
@@ -161,7 +171,7 @@ describe("file/index Filesystem patterns", () => {
     })
   })
 
-  describe("File.list() - Filesystem.exists() and readText()", () => {
+  describe("list() - Filesystem.exists() and readText()", () => {
     test("reads .gitignore via Filesystem.exists() and readText()", async () => {
       await using tmp = await tmpdir({ git: true })
 
@@ -171,7 +181,7 @@ describe("file/index Filesystem patterns", () => {
           const gitignorePath = path.join(tmp.path, ".gitignore")
           await fs.writeFile(gitignorePath, "node_modules\ndist\n", "utf-8")
 
-          // This is used internally in File.list()
+          // This is used internally in list()
           expect(await Filesystem.exists(gitignorePath)).toBe(true)
 
           const content = await Filesystem.readText(gitignorePath)
@@ -204,8 +214,8 @@ describe("file/index Filesystem patterns", () => {
           const gitignorePath = path.join(tmp.path, ".gitignore")
           expect(await Filesystem.exists(gitignorePath)).toBe(false)
 
-          // File.list() should still work
-          const nodes = await File.list()
+          // list() should still work
+          const nodes = await list()
           expect(Array.isArray(nodes)).toBe(true)
         },
       })
@@ -244,8 +254,8 @@ describe("file/index Filesystem patterns", () => {
           // Filesystem.readText() on non-existent file throws
           await expect(Filesystem.readText(nonExistentPath)).rejects.toThrow()
 
-          // But File.read() handles this gracefully
-          const result = await File.read("does-not-exist.txt")
+          // But read() handles this gracefully
+          const result = await read("does-not-exist.txt")
           expect(result.content).toBe("")
         },
       })
@@ -272,8 +282,8 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          // File.read() handles missing images gracefully
-          const result = await File.read("broken.png")
+          // read() handles missing images gracefully
+          const result = await read("broken.png")
           expect(result.type).toBe("text")
           expect(result.content).toBe("")
         },
@@ -290,7 +300,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.ts")
+          const result = await read("test.ts")
           expect(result.type).toBe("text")
           expect(result.content).toBe("export const value = 1")
         },
@@ -305,7 +315,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.mts")
+          const result = await read("test.mts")
           expect(result.type).toBe("text")
           expect(result.content).toBe("export const value = 1")
         },
@@ -320,7 +330,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.sh")
+          const result = await read("test.sh")
           expect(result.type).toBe("text")
           expect(result.content).toBe("#!/usr/bin/env bash\necho hello")
         },
@@ -335,7 +345,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("Dockerfile")
+          const result = await read("Dockerfile")
           expect(result.type).toBe("text")
           expect(result.content).toBe("FROM alpine:3.20")
         },
@@ -350,7 +360,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.txt")
+          const result = await read("test.txt")
           expect(result.encoding).toBeUndefined()
           expect(result.type).toBe("text")
         },
@@ -365,7 +375,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("test.jpg")
+          const result = await read("test.jpg")
           expect(result.encoding).toBe("base64")
           expect(result.mimeType).toBe("image/jpeg")
         },
@@ -380,7 +390,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await expect(File.read("../outside.txt")).rejects.toThrow("Access denied")
+          await expect(read("../outside.txt")).rejects.toThrow("Access denied")
         },
       })
     })
@@ -391,13 +401,13 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await expect(File.read("../outside.txt")).rejects.toThrow("Access denied")
+          await expect(read("../outside.txt")).rejects.toThrow("Access denied")
         },
       })
     })
   })
 
-  describe("File.status()", () => {
+  describe("status()", () => {
     test("detects modified file", async () => {
       await using tmp = await tmpdir({ git: true })
       const filepath = path.join(tmp.path, "file.txt")
@@ -409,7 +419,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           const entry = result.find((f) => f.path === "file.txt")
           expect(entry).toBeDefined()
           expect(entry!.status).toBe("modified")
@@ -426,7 +436,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           const entry = result.find((f) => f.path === "new.txt")
           expect(entry).toBeDefined()
           expect(entry!.status).toBe("added")
@@ -447,7 +457,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           // Deleted files appear in both numstat (as "modified") and diff-filter=D (as "deleted")
           const entries = result.filter((f) => f.path === "gone.txt")
           expect(entries.some((e) => e.status === "deleted")).toBe(true)
@@ -470,7 +480,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           expect(result.some((f) => f.path === "keep.txt" && f.status === "modified")).toBe(true)
           expect(result.some((f) => f.path === "remove.txt" && f.status === "deleted")).toBe(true)
           expect(result.some((f) => f.path === "brand-new.txt" && f.status === "added")).toBe(true)
@@ -484,7 +494,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           expect(result).toEqual([])
         },
       })
@@ -496,7 +506,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           expect(result).toEqual([])
         },
       })
@@ -519,7 +529,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.status()
+          const result = await status()
           const entry = result.find((f) => f.path === "data.bin")
           expect(entry).toBeDefined()
           expect(entry!.status).toBe("modified")
@@ -530,7 +540,7 @@ describe("file/index Filesystem patterns", () => {
     })
   })
 
-  describe("File.list()", () => {
+  describe("list()", () => {
     test("returns files and directories with correct shape", async () => {
       await using tmp = await tmpdir({ git: true })
       await fs.mkdir(path.join(tmp.path, "subdir"))
@@ -540,7 +550,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list()
+          const nodes = await list()
           expect(nodes.length).toBeGreaterThanOrEqual(2)
           for (const node of nodes) {
             expect(node).toHaveProperty("name")
@@ -564,7 +574,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list()
+          const nodes = await list()
           const dirs = nodes.filter((n) => n.type === "directory")
           const files = nodes.filter((n) => n.type === "file")
           // Dirs come first
@@ -589,7 +599,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list()
+          const nodes = await list()
           const names = nodes.map((n) => n.name)
           expect(names).not.toContain(".git")
           expect(names).not.toContain(".DS_Store")
@@ -608,7 +618,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list()
+          const nodes = await list()
           const logNode = nodes.find((n) => n.name === "app.log")
           const tsNode = nodes.find((n) => n.name === "main.ts")
           const buildNode = nodes.find((n) => n.name === "build")
@@ -628,7 +638,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list("sub")
+          const nodes = await list("sub")
           expect(nodes.length).toBe(2)
           expect(nodes.map((n) => n.name).sort()).toEqual(["a.txt", "b.txt"])
           // Paths should be relative to project root (normalize for Windows)
@@ -643,7 +653,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await expect(File.list("../outside")).rejects.toThrow("Access denied")
+          await expect(list("../outside")).rejects.toThrow("Access denied")
         },
       })
     })
@@ -655,7 +665,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const nodes = await File.list()
+          const nodes = await list()
           expect(nodes.length).toBeGreaterThanOrEqual(1)
           // Without git, ignored should be false for all
           for (const node of nodes) {
@@ -666,7 +676,7 @@ describe("file/index Filesystem patterns", () => {
     })
   })
 
-  describe("File.search()", () => {
+  describe("search()", () => {
     async function setupSearchableRepo() {
       const tmp = await tmpdir({ git: true })
       await fs.writeFile(path.join(tmp.path, "index.ts"), "code", "utf-8")
@@ -685,9 +695,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "", type: "file" })
+          const result = await search({ query: "", type: "file" })
           expect(result.length).toBeGreaterThan(0)
         },
       })
@@ -699,7 +709,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.search({ query: "main", type: "file" })
+          const result = await search({ query: "main", type: "file" })
           expect(result.some((f) => f.includes("main"))).toBe(true)
         },
       })
@@ -711,9 +721,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "", type: "directory" })
+          const result = await search({ query: "", type: "directory" })
           expect(result.length).toBeGreaterThan(0)
           // Find first hidden dir index
           const firstHidden = result.findIndex((d) => d.split("/").some((p) => p.startsWith(".") && p.length > 1))
@@ -731,9 +741,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "main", type: "file" })
+          const result = await search({ query: "main", type: "file" })
           expect(result.some((f) => f.includes("main"))).toBe(true)
         },
       })
@@ -745,9 +755,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "", type: "file" })
+          const result = await search({ query: "", type: "file" })
           // Files don't end with /
           for (const f of result) {
             expect(f.endsWith("/")).toBe(false)
@@ -762,9 +772,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "", type: "directory" })
+          const result = await search({ query: "", type: "directory" })
           // Directories end with /
           for (const d of result) {
             expect(d.endsWith("/")).toBe(true)
@@ -779,9 +789,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: "", type: "file", limit: 2 })
+          const result = await search({ query: "", type: "file", limit: 2 })
           expect(result.length).toBeLessThanOrEqual(2)
         },
       })
@@ -793,9 +803,9 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
+          await init()
 
-          const result = await File.search({ query: ".hidden", type: "directory" })
+          const result = await search({ query: ".hidden", type: "directory" })
           expect(result.length).toBeGreaterThan(0)
           expect(result[0]).toContain(".hidden")
         },
@@ -808,19 +818,19 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
-          expect(await File.search({ query: "fresh", type: "file" })).toEqual([])
+          await init()
+          expect(await search({ query: "fresh", type: "file" })).toEqual([])
 
           await fs.writeFile(path.join(tmp.path, "fresh.ts"), "fresh", "utf-8")
 
-          const result = await File.search({ query: "fresh", type: "file" })
+          const result = await search({ query: "fresh", type: "file" })
           expect(result).toContain("fresh.ts")
         },
       })
     })
   })
 
-  describe("File.read() - diff/patch", () => {
+  describe("read() - diff/patch", () => {
     test("returns diff and patch for modified tracked file", async () => {
       await using tmp = await tmpdir({ git: true })
       const filepath = path.join(tmp.path, "file.txt")
@@ -832,7 +842,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("file.txt")
+          const result = await read("file.txt")
           expect(result.type).toBe("text")
           expect(result.content).toBe("modified content")
           expect(result.diff).toBeDefined()
@@ -856,7 +866,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("staged.txt")
+          const result = await read("staged.txt")
           expect(result.diff).toBeDefined()
           expect(result.patch).toBeDefined()
         },
@@ -873,7 +883,7 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          const result = await File.read("clean.txt")
+          const result = await read("clean.txt")
           expect(result.type).toBe("text")
           expect(result.content).toBe("unchanged")
           expect(result.diff).toBeUndefined()
@@ -893,10 +903,10 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: one.path,
         fn: async () => {
-          await File.init()
-          const results = await File.search({ query: "a.ts", type: "file" })
+          await init()
+          const results = await search({ query: "a.ts", type: "file" })
           expect(results).toContain("a.ts")
-          const results2 = await File.search({ query: "b.ts", type: "file" })
+          const results2 = await search({ query: "b.ts", type: "file" })
           expect(results2).not.toContain("b.ts")
         },
       })
@@ -904,10 +914,10 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: two.path,
         fn: async () => {
-          await File.init()
-          const results = await File.search({ query: "b.ts", type: "file" })
+          await init()
+          const results = await search({ query: "b.ts", type: "file" })
           expect(results).toContain("b.ts")
-          const results2 = await File.search({ query: "a.ts", type: "file" })
+          const results2 = await search({ query: "a.ts", type: "file" })
           expect(results2).not.toContain("a.ts")
         },
       })
@@ -920,8 +930,8 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
-          const results = await File.search({ query: "before", type: "file" })
+          await init()
+          const results = await search({ query: "before", type: "file" })
           expect(results).toContain("before.ts")
         },
       })
@@ -934,10 +944,10 @@ describe("file/index Filesystem patterns", () => {
       await Instance.provide({
         directory: tmp.path,
         fn: async () => {
-          await File.init()
-          const results = await File.search({ query: "after", type: "file" })
+          await init()
+          const results = await search({ query: "after", type: "file" })
           expect(results).toContain("after.ts")
-          const stale = await File.search({ query: "before", type: "file" })
+          const stale = await search({ query: "before", type: "file" })
           expect(stale).not.toContain("before.ts")
         },
       })

packages/opencode/test/file/path-traversal.test.ts

@@ -1,10 +1,16 @@
 import { test, expect, describe } from "bun:test"
+import { Effect } from "effect"
 import path from "path"
 import fs from "fs/promises"
 import { Filesystem } from "../../src/util/filesystem"
 import { File } from "../../src/file"
 import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
+import { provideInstance, tmpdir } from "../fixture/fixture"
+
+const run = <A, E>(eff: Effect.Effect<A, E, File.Service>) =>
+  Effect.runPromise(provideInstance(Instance.directory)(eff.pipe(Effect.provide(File.defaultLayer))))
+const read = (file: string) => run(File.Service.use((svc) => svc.read(file)))
+const list = (dir?: string) => run(File.Service.use((svc) => svc.list(dir)))
 
 describe("Filesystem.contains", () => {
   test("allows paths within project", () => {
@@ -32,10 +38,10 @@ describe("Filesystem.contains", () => {
 })
 
 /*
- * Integration tests for File.read() and File.list() path traversal protection.
+ * Integration tests for read() and list() path traversal protection.
  *
  * These tests verify the HTTP API code path is protected. The HTTP endpoints
- * in server.ts (GET /file/content, GET /file) call File.read()/File.list()
+ * in server.ts (GET /file/content, GET /file) call read()/list()
  * directly - they do NOT go through ReadTool or the agent permission layer.
  *
  * This is a SEPARATE code path from ReadTool, which has its own checks.
@@ -51,7 +57,7 @@ describe("File.read path traversal protection", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        await expect(File.read("../../../etc/passwd")).rejects.toThrow("Access denied: path escapes project directory")
+        await expect(read("../../../etc/passwd")).rejects.toThrow("Access denied: path escapes project directory")
       },
     })
   })
@@ -62,7 +68,7 @@ describe("File.read path traversal protection", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        await expect(File.read("src/nested/../../../../../../../etc/passwd")).rejects.toThrow(
+        await expect(read("src/nested/../../../../../../../etc/passwd")).rejects.toThrow(
           "Access denied: path escapes project directory",
         )
       },
@@ -79,7 +85,7 @@ describe("File.read path traversal protection", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const result = await File.read("valid.txt")
+        const result = await read("valid.txt")
         expect(result.content).toBe("valid content")
       },
     })
@@ -93,7 +99,7 @@ describe("File.list path traversal protection", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        await expect(File.list("../../../etc")).rejects.toThrow("Access denied: path escapes project directory")
+        await expect(list("../../../etc")).rejects.toThrow("Access denied: path escapes project directory")
       },
     })
   })
@@ -108,7 +114,7 @@ describe("File.list path traversal protection", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const result = await File.list("subdir")
+        const result = await list("subdir")
         expect(Array.isArray(result)).toBe(true)
       },
     })

packages/opencode/test/file/ripgrep.test.ts

@@ -38,7 +38,9 @@ describe("file.ripgrep", () => {
     expect(hasVisible).toBe(true)
     expect(hasHidden).toBe(false)
   })
+})
 
+describe("Ripgrep.Service", () => {
   test("search returns empty when nothing matches", async () => {
     await using tmp = await tmpdir({
       init: async (dir) => {
@@ -46,16 +48,34 @@ describe("file.ripgrep", () => {
       },
     })
 
-    const hits = await Ripgrep.search({
-      cwd: tmp.path,
-      pattern: "needle",
+    const result = await Effect.gen(function* () {
+      const rg = yield* Ripgrep.Service
+      return yield* rg.search({ cwd: tmp.path, pattern: "needle" })
+    }).pipe(Effect.provide(Ripgrep.defaultLayer), Effect.runPromise)
+
+    expect(result.partial).toBe(false)
+    expect(result.items).toEqual([])
+  })
+
+  test("search returns matched rows", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "match.ts"), "const value = 'needle'\n")
+        await Bun.write(path.join(dir, "skip.txt"), "const value = 'other'\n")
+      },
     })
 
-    expect(hits).toEqual([])
-  })
-})
+    const result = await Effect.gen(function* () {
+      const rg = yield* Ripgrep.Service
+      return yield* rg.search({ cwd: tmp.path, pattern: "needle", glob: ["*.ts"] })
+    }).pipe(Effect.provide(Ripgrep.defaultLayer), Effect.runPromise)
+
+    expect(result.partial).toBe(false)
+    expect(result.items).toHaveLength(1)
+    expect(result.items[0]?.path.text).toContain("match.ts")
+    expect(result.items[0]?.lines.text).toContain("needle")
+  })
 
-describe("Ripgrep.Service", () => {
   test("files returns stream of filenames", async () => {
     await using tmp = await tmpdir({
       init: async (dir) => {

packages/opencode/test/lsp/index.test.ts

@@ -1,55 +1,55 @@
-import { describe, expect, spyOn, test } from "bun:test"
+import { describe, expect, spyOn } from "bun:test"
 import path from "path"
-import * as Lsp from "../../src/lsp/index"
+import { Effect, Layer } from "effect"
+import { LSP } from "../../src/lsp"
 import { LSPServer } from "../../src/lsp/server"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(LSP.defaultLayer, CrossSpawnSpawner.defaultLayer))
 
 describe("lsp.spawn", () => {
-  test("does not spawn builtin LSP for files outside instance", async () => {
-    await using tmp = await tmpdir()
-    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+  it.live("does not spawn builtin LSP for files outside instance", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
 
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await Lsp.LSP.touchFile(path.join(tmp.path, "..", "outside.ts"))
-          await Lsp.LSP.hover({
-            file: path.join(tmp.path, "..", "hover.ts"),
-            line: 0,
-            character: 0,
-          })
-        },
-      })
+          try {
+            yield* lsp.touchFile(path.join(dir, "..", "outside.ts"))
+            yield* lsp.hover({
+              file: path.join(dir, "..", "hover.ts"),
+              line: 0,
+              character: 0,
+            })
+            expect(spy).toHaveBeenCalledTimes(0)
+          } finally {
+            spy.mockRestore()
+          }
+        }),
+      ),
+    ),
+  )
 
-      expect(spy).toHaveBeenCalledTimes(0)
-    } finally {
-      spy.mockRestore()
-      await Instance.disposeAll()
-    }
-  })
+  it.live("would spawn builtin LSP for files inside instance", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
 
-  test("would spawn builtin LSP for files inside instance", async () => {
-    await using tmp = await tmpdir()
-    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await Lsp.LSP.hover({
-            file: path.join(tmp.path, "src", "inside.ts"),
-            line: 0,
-            character: 0,
-          })
-        },
-      })
-
-      expect(spy).toHaveBeenCalledTimes(1)
-    } finally {
-      spy.mockRestore()
-      await Instance.disposeAll()
-    }
-  })
+          try {
+            yield* lsp.hover({
+              file: path.join(dir, "src", "inside.ts"),
+              line: 0,
+              character: 0,
+            })
+            expect(spy).toHaveBeenCalledTimes(1)
+          } finally {
+            spy.mockRestore()
+          }
+        }),
+      ),
+    ),
+  )
 })

packages/opencode/test/lsp/lifecycle.test.ts

@@ -1,23 +1,13 @@
-import { describe, expect, test, spyOn, beforeEach, afterEach } from "bun:test"
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
 import path from "path"
-import * as Lsp from "../../src/lsp/index"
+import { Effect, Layer } from "effect"
+import { LSP } from "../../src/lsp"
 import { LSPServer } from "../../src/lsp/server"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 
-function withInstance(fn: (dir: string) => Promise<void>) {
-  return async () => {
-    await using tmp = await tmpdir()
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: () => fn(tmp.path),
-      })
-    } finally {
-      await Instance.disposeAll()
-    }
-  }
-}
+const it = testEffect(Layer.mergeAll(LSP.defaultLayer, CrossSpawnSpawner.defaultLayer))
 
 describe("LSP service lifecycle", () => {
   let spawnSpy: ReturnType<typeof spyOn>
@@ -30,97 +20,112 @@ describe("LSP service lifecycle", () => {
     spawnSpy.mockRestore()
   })
 
-  test(
-    "init() completes without error",
-    withInstance(async () => {
-      await Lsp.LSP.init()
-    }),
+  it.live("init() completes without error", () => provideTmpdirInstance(() => LSP.Service.use((lsp) => lsp.init())))
+
+  it.live("status() returns empty array initially", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.status()
+          expect(Array.isArray(result)).toBe(true)
+          expect(result.length).toBe(0)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "status() returns empty array initially",
-    withInstance(async () => {
-      const result = await Lsp.LSP.status()
-      expect(Array.isArray(result)).toBe(true)
-      expect(result.length).toBe(0)
-    }),
+  it.live("diagnostics() returns empty object initially", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.diagnostics()
+          expect(typeof result).toBe("object")
+          expect(Object.keys(result).length).toBe(0)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "diagnostics() returns empty object initially",
-    withInstance(async () => {
-      const result = await Lsp.LSP.diagnostics()
-      expect(typeof result).toBe("object")
-      expect(Object.keys(result).length).toBe(0)
-    }),
+  it.live("hasClients() returns true for .ts files in instance", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.hasClients(path.join(dir, "test.ts"))
+          expect(result).toBe(true)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "hasClients() returns true for .ts files in instance",
-    withInstance(async (dir) => {
-      const result = await Lsp.LSP.hasClients(path.join(dir, "test.ts"))
-      expect(result).toBe(true)
-    }),
+  it.live("hasClients() returns false for files outside instance", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.hasClients(path.join(dir, "..", "outside.ts"))
+          expect(typeof result).toBe("boolean")
+        }),
+      ),
+    ),
   )
 
-  test(
-    "hasClients() returns false for files outside instance",
-    withInstance(async (dir) => {
-      const result = await Lsp.LSP.hasClients(path.join(dir, "..", "outside.ts"))
-      // hasClients checks servers but doesn't check containsPath — getClients does
-      // So hasClients may return true even for outside files (it checks extension + root)
-      // The guard is in getClients, not hasClients
-      expect(typeof result).toBe("boolean")
-    }),
+  it.live("workspaceSymbol() returns empty array with no clients", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.workspaceSymbol("test")
+          expect(Array.isArray(result)).toBe(true)
+          expect(result.length).toBe(0)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "workspaceSymbol() returns empty array with no clients",
-    withInstance(async () => {
-      const result = await Lsp.LSP.workspaceSymbol("test")
-      expect(Array.isArray(result)).toBe(true)
-      expect(result.length).toBe(0)
-    }),
+  it.live("definition() returns empty array for unknown file", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.definition({
+            file: path.join(dir, "nonexistent.ts"),
+            line: 0,
+            character: 0,
+          })
+          expect(Array.isArray(result)).toBe(true)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "definition() returns empty array for unknown file",
-    withInstance(async (dir) => {
-      const result = await Lsp.LSP.definition({
-        file: path.join(dir, "nonexistent.ts"),
-        line: 0,
-        character: 0,
-      })
-      expect(Array.isArray(result)).toBe(true)
-    }),
+  it.live("references() returns empty array for unknown file", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.references({
+            file: path.join(dir, "nonexistent.ts"),
+            line: 0,
+            character: 0,
+          })
+          expect(Array.isArray(result)).toBe(true)
+        }),
+      ),
+    ),
   )
 
-  test(
-    "references() returns empty array for unknown file",
-    withInstance(async (dir) => {
-      const result = await Lsp.LSP.references({
-        file: path.join(dir, "nonexistent.ts"),
-        line: 0,
-        character: 0,
-      })
-      expect(Array.isArray(result)).toBe(true)
-    }),
-  )
-
-  test(
-    "multiple init() calls are idempotent",
-    withInstance(async () => {
-      await Lsp.LSP.init()
-      await Lsp.LSP.init()
-      await Lsp.LSP.init()
-      // Should not throw or create duplicate state
-    }),
+  it.live("multiple init() calls are idempotent", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          yield* lsp.init()
+          yield* lsp.init()
+          yield* lsp.init()
+        }),
+      ),
+    ),
   )
 })
 
 describe("LSP.Diagnostic", () => {
   test("pretty() formats error diagnostic", () => {
-    const result = Lsp.LSP.Diagnostic.pretty({
+    const result = LSP.Diagnostic.pretty({
       range: { start: { line: 9, character: 4 }, end: { line: 9, character: 10 } },
       message: "Type 'string' is not assignable to type 'number'",
       severity: 1,
@@ -129,7 +134,7 @@ describe("LSP.Diagnostic", () => {
   })
 
   test("pretty() formats warning diagnostic", () => {
-    const result = Lsp.LSP.Diagnostic.pretty({
+    const result = LSP.Diagnostic.pretty({
       range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } },
       message: "Unused variable",
       severity: 2,
@@ -138,7 +143,7 @@ describe("LSP.Diagnostic", () => {
   })
 
   test("pretty() defaults to ERROR when no severity", () => {
-    const result = Lsp.LSP.Diagnostic.pretty({
+    const result = LSP.Diagnostic.pretty({
       range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
       message: "Something wrong",
     } as any)

packages/opencode/test/project/vcs.test.ts

@@ -1,5 +1,6 @@
 import { $ } from "bun"
 import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
 import fs from "fs/promises"
 import path from "path"
 import { tmpdir } from "../fixture/fixture"
@@ -20,8 +21,14 @@ async function withVcs(directory: string, body: () => Promise<void>) {
   return Instance.provide({
     directory,
     fn: async () => {
-      void AppRuntime.runPromise(FileWatcher.Service.use((svc) => svc.init()))
-      Vcs.init()
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const watcher = yield* FileWatcher.Service
+          const vcs = yield* Vcs.Service
+          yield* watcher.init()
+          yield* vcs.init()
+        }),
+      )
       await Bun.sleep(500)
       await body()
     },
@@ -32,7 +39,12 @@ function withVcsOnly(directory: string, body: () => Promise<void>) {
   return Instance.provide({
     directory,
     fn: async () => {
-      Vcs.init()
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          yield* vcs.init()
+        }),
+      )
       await body()
     },
   })
@@ -80,7 +92,12 @@ describeVcs("Vcs", () => {
     await using tmp = await tmpdir({ git: true })
 
     await withVcs(tmp.path, async () => {
-      const branch = await Vcs.branch()
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
       expect(branch).toBeDefined()
       expect(typeof branch).toBe("string")
     })
@@ -90,7 +107,12 @@ describeVcs("Vcs", () => {
     await using tmp = await tmpdir()
 
     await withVcs(tmp.path, async () => {
-      const branch = await Vcs.branch()
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
       expect(branch).toBeUndefined()
     })
   })
@@ -123,7 +145,12 @@ describeVcs("Vcs", () => {
       await fs.writeFile(head, `ref: refs/heads/${branch}\n`)
 
       await pending
-      const current = await Vcs.branch()
+      const current = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.branch()
+        }),
+      )
       expect(current).toBe(branch)
     })
   })
@@ -139,7 +166,12 @@ describe("Vcs diff", () => {
     await $`git branch -M main`.cwd(tmp.path).quiet()
 
     await withVcsOnly(tmp.path, async () => {
-      const branch = await Vcs.defaultBranch()
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.defaultBranch()
+        }),
+      )
       expect(branch).toBe("main")
     })
   })
@@ -150,7 +182,12 @@ describe("Vcs diff", () => {
     await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet()
 
     await withVcsOnly(tmp.path, async () => {
-      const branch = await Vcs.defaultBranch()
+      const branch = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.defaultBranch()
+        }),
+      )
       expect(branch).toBe("trunk")
     })
   })
@@ -163,7 +200,12 @@ describe("Vcs diff", () => {
     await $`git worktree add -b feature/test ${dir} HEAD`.cwd(tmp.path).quiet()
 
     await withVcsOnly(dir, async () => {
-      const [branch, base] = await Promise.all([Vcs.branch(), Vcs.defaultBranch()])
+      const [branch, base] = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* Effect.all([vcs.branch(), vcs.defaultBranch()], { concurrency: 2 })
+        }),
+      )
       expect(branch).toBe("feature/test")
       expect(base).toBe("main")
     })
@@ -177,7 +219,12 @@ describe("Vcs diff", () => {
     await fs.writeFile(path.join(tmp.path, "file.txt"), "changed\n", "utf-8")
 
     await withVcsOnly(tmp.path, async () => {
-      const diff = await Vcs.diff("git")
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("git")
+        }),
+      )
       expect(diff).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
@@ -194,7 +241,12 @@ describe("Vcs diff", () => {
     await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8")
 
     await withVcsOnly(tmp.path, async () => {
-      const diff = await Vcs.diff("git")
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("git")
+        }),
+      )
       expect(diff).toEqual(
         expect.arrayContaining([
           expect.objectContaining({
@@ -215,7 +267,12 @@ describe("Vcs diff", () => {
     await $`git commit --no-gpg-sign -m "branch file"`.cwd(tmp.path).quiet()
 
     await withVcsOnly(tmp.path, async () => {
-      const diff = await Vcs.diff("branch")
+      const diff = await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const vcs = yield* Vcs.Service
+          return yield* vcs.diff("branch")
+        }),
+      )
       expect(diff).toEqual(
         expect.arrayContaining([
           expect.objectContaining({

packages/opencode/test/provider/amazon-bedrock.test.ts

@@ -9,6 +9,17 @@ import { Provider } from "../../src/provider/provider"
 import { Env } from "../../src/env"
 import { Global } from "../../src/global"
 import { Filesystem } from "../../src/util/filesystem"
+import { Effect } from "effect"
+import { AppRuntime } from "../../src/effect/app-runtime"
+
+async function list() {
+  return AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const provider = yield* Provider.Service
+      return yield* provider.list()
+    }),
+  )
+}
 
 test("Bedrock: config region takes precedence over AWS_REGION env var", async () => {
   await using tmp = await tmpdir({
@@ -35,7 +46,7 @@ test("Bedrock: config region takes precedence over AWS_REGION env var", async ()
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
     },
@@ -60,7 +71,7 @@ test("Bedrock: falls back to AWS_REGION env var when no config region", async ()
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
     },
@@ -116,7 +127,7 @@ test("Bedrock: loads when bearer token from auth.json is present", async () => {
         Env.set("AWS_BEARER_TOKEN_BEDROCK", "")
       },
       fn: async () => {
-        const providers = await Provider.list()
+        const providers = await list()
         expect(providers[ProviderID.amazonBedrock]).toBeDefined()
         expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
       },
@@ -161,7 +172,7 @@ test("Bedrock: config profile takes precedence over AWS_PROFILE env var", async
       Env.set("AWS_ACCESS_KEY_ID", "test-key-id")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].options?.region).toBe("us-east-1")
     },
@@ -192,7 +203,7 @@ test("Bedrock: includes custom endpoint in options when specified", async () =>
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].options?.endpoint).toBe(
         "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com",
@@ -228,7 +239,7 @@ test("Bedrock: autoloads when AWS_WEB_IDENTITY_TOKEN_FILE is present", async ()
       Env.set("AWS_ACCESS_KEY_ID", "")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].options?.region).toBe("us-east-1")
     },
@@ -268,7 +279,7 @@ test("Bedrock: model with us. prefix should not be double-prefixed", async () =>
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       // The model should exist with the us. prefix
       expect(providers[ProviderID.amazonBedrock].models["us.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
@@ -305,7 +316,7 @@ test("Bedrock: model with global. prefix should not be prefixed", async () => {
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].models["global.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
     },
@@ -341,7 +352,7 @@ test("Bedrock: model with eu. prefix should not be double-prefixed", async () =>
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       expect(providers[ProviderID.amazonBedrock].models["eu.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
     },
@@ -377,7 +388,7 @@ test("Bedrock: model without prefix in US region should get us. prefix added", a
       Env.set("AWS_PROFILE", "default")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.amazonBedrock]).toBeDefined()
       // Non-prefixed model should still be registered
       expect(providers[ProviderID.amazonBedrock].models["anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()

packages/opencode/test/provider/gitlab-duo.test.ts

@@ -30,7 +30,7 @@
 //       Env.set("GITLAB_TOKEN", "test-gitlab-token")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].key).toBe("test-gitlab-token")
 //     },
@@ -62,7 +62,7 @@
 //       Env.set("GITLAB_INSTANCE_URL", "https://gitlab.example.com")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].options?.instanceUrl).toBe("https://gitlab.example.com")
 //     },
@@ -100,7 +100,7 @@
 //       Env.set("GITLAB_TOKEN", "")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //     },
 //   })
@@ -135,7 +135,7 @@
 //       Env.set("GITLAB_TOKEN", "")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].key).toBe("glpat-test-pat-token")
 //     },
@@ -167,7 +167,7 @@
 //       Env.set("GITLAB_INSTANCE_URL", "https://gitlab.company.internal")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].options?.instanceUrl).toBe("https://gitlab.company.internal")
 //     },
@@ -198,7 +198,7 @@
 //       Env.set("GITLAB_TOKEN", "env-token")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //     },
 //   })
@@ -221,7 +221,7 @@
 //       Env.set("GITLAB_TOKEN", "test-token")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].options?.aiGatewayHeaders?.["anthropic-beta"]).toContain(
 //         "context-1m-2025-08-07",
@@ -257,7 +257,7 @@
 //       Env.set("GITLAB_TOKEN", "test-token")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       expect(providers[ProviderID.gitlab].options?.featureFlags).toBeDefined()
 //       expect(providers[ProviderID.gitlab].options?.featureFlags?.duo_agent_platform_agentic_chat).toBe(true)
@@ -282,7 +282,7 @@
 //       Env.set("GITLAB_TOKEN", "test-token")
 //     },
 //     fn: async () => {
-//       const providers = await Provider.list()
+//       const providers = await list()
 //       expect(providers[ProviderID.gitlab]).toBeDefined()
 //       const models = Object.keys(providers[ProviderID.gitlab].models)
 //       expect(models.length).toBeGreaterThan(0)
@@ -306,7 +306,7 @@
 //         Env.set("GITLAB_TOKEN", "test-token")
 //       },
 //       fn: async () => {
-//         const providers = await Provider.list()
+//         const providers = await list()
 //         const gitlab = providers[ProviderID.gitlab]
 //         expect(gitlab).toBeDefined()
 //         gitlab.models["duo-workflow-sonnet-4-6"] = {
@@ -332,10 +332,10 @@
 //           release_date: "",
 //           variants: {},
 //         }
-//         const model = await Provider.getModel(ProviderID.gitlab, ModelID.make("duo-workflow-sonnet-4-6"))
+//         const model = await getModel(ProviderID.gitlab, ModelID.make("duo-workflow-sonnet-4-6"))
 //         expect(model).toBeDefined()
 //         expect(model.options?.workflowRef).toBe("claude_sonnet_4_6")
-//         const language = await Provider.getLanguage(model)
+//         const language = await getLanguage(model)
 //         expect(language).toBeDefined()
 //         expect(language).toBeInstanceOf(GitLabWorkflowLanguageModel)
 //       },
@@ -354,11 +354,11 @@
 //         Env.set("GITLAB_TOKEN", "test-token")
 //       },
 //       fn: async () => {
-//         const providers = await Provider.list()
+//         const providers = await list()
 //         expect(providers[ProviderID.gitlab]).toBeDefined()
-//         const model = await Provider.getModel(ProviderID.gitlab, ModelID.make("duo-chat-sonnet-4-5"))
+//         const model = await getModel(ProviderID.gitlab, ModelID.make("duo-chat-sonnet-4-5"))
 //         expect(model).toBeDefined()
-//         const language = await Provider.getLanguage(model)
+//         const language = await getLanguage(model)
 //         expect(language).toBeDefined()
 //         expect(language).not.toBeInstanceOf(GitLabWorkflowLanguageModel)
 //       },
@@ -377,10 +377,10 @@
 //         Env.set("GITLAB_TOKEN", "test-token")
 //       },
 //       fn: async () => {
-//         const providers = await Provider.list()
+//         const providers = await list()
 //         const gitlab = providers[ProviderID.gitlab]
 //         expect(gitlab.options?.featureFlags).toBeDefined()
-//         const model = await Provider.getModel(ProviderID.gitlab, ModelID.make("duo-chat-sonnet-4-5"))
+//         const model = await getModel(ProviderID.gitlab, ModelID.make("duo-chat-sonnet-4-5"))
 //         expect(model).toBeDefined()
 //         expect(model.options).toBeDefined()
 //       },
@@ -401,7 +401,7 @@
 //         Env.set("GITLAB_TOKEN", "test-token")
 //       },
 //       fn: async () => {
-//         const providers = await Provider.list()
+//         const providers = await list()
 //         const models = Object.keys(providers[ProviderID.gitlab].models)
 //         expect(models).toContain("duo-chat-haiku-4-5")
 //         expect(models).toContain("duo-chat-sonnet-4-5")

packages/opencode/test/provider/provider.test.ts

@@ -11,8 +11,47 @@ import { Provider } from "../../src/provider/provider"
 import { ProviderID, ModelID } from "../../src/provider/schema"
 import { Filesystem } from "../../src/util/filesystem"
 import { Env } from "../../src/env"
+import { Effect } from "effect"
+import { AppRuntime } from "../../src/effect/app-runtime"
 
-function paid(providers: Awaited<ReturnType<typeof Provider.list>>) {
+async function run<A, E>(fn: (provider: Provider.Interface) => Effect.Effect<A, E, never>) {
+  return AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const provider = yield* Provider.Service
+      return yield* fn(provider)
+    }),
+  )
+}
+
+async function list() {
+  return run((provider) => provider.list())
+}
+
+async function getProvider(providerID: ProviderID) {
+  return run((provider) => provider.getProvider(providerID))
+}
+
+async function getModel(providerID: ProviderID, modelID: ModelID) {
+  return run((provider) => provider.getModel(providerID, modelID))
+}
+
+async function getLanguage(model: Provider.Model) {
+  return run((provider) => provider.getLanguage(model))
+}
+
+async function closest(providerID: ProviderID, query: string[]) {
+  return run((provider) => provider.closest(providerID, query))
+}
+
+async function getSmallModel(providerID: ProviderID) {
+  return run((provider) => provider.getSmallModel(providerID))
+}
+
+async function defaultModel() {
+  return run((provider) => provider.defaultModel())
+}
+
+function paid(providers: Awaited<ReturnType<typeof list>>) {
   const item = providers[ProviderID.make("opencode")]
   expect(item).toBeDefined()
   return Object.values(item.models).filter((model) => model.cost.input > 0).length
@@ -35,7 +74,7 @@ test("provider loaded from env variable", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       // Provider should retain its connection source even if custom loaders
       // merge additional options.
@@ -66,7 +105,7 @@ test("provider loaded from config with apiKey option", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
     },
   })
@@ -90,7 +129,7 @@ test("disabled_providers excludes provider", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeUndefined()
     },
   })
@@ -115,7 +154,7 @@ test("enabled_providers restricts to only listed providers", async () => {
       Env.set("OPENAI_API_KEY", "test-openai-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       expect(providers[ProviderID.openai]).toBeUndefined()
     },
@@ -144,7 +183,7 @@ test("model whitelist filters models for provider", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       const models = Object.keys(providers[ProviderID.anthropic].models)
       expect(models).toContain("claude-sonnet-4-20250514")
@@ -175,7 +214,7 @@ test("model blacklist excludes specific models", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       const models = Object.keys(providers[ProviderID.anthropic].models)
       expect(models).not.toContain("claude-sonnet-4-20250514")
@@ -210,7 +249,7 @@ test("custom model alias via config", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       expect(providers[ProviderID.anthropic].models["my-alias"]).toBeDefined()
       expect(providers[ProviderID.anthropic].models["my-alias"].name).toBe("My Custom Alias")
@@ -253,7 +292,7 @@ test("custom provider with npm package", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("custom-provider")]).toBeDefined()
       expect(providers[ProviderID.make("custom-provider")].name).toBe("Custom Provider")
       expect(providers[ProviderID.make("custom-provider")].models["custom-model"]).toBeDefined()
@@ -286,7 +325,7 @@ test("env variable takes precedence, config merges options", async () => {
       Env.set("ANTHROPIC_API_KEY", "env-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       // Config options should be merged
       expect(providers[ProviderID.anthropic].options.timeout).toBe(60000)
@@ -312,11 +351,11 @@ test("getModel returns model for valid provider/model", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model = await Provider.getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
+      const model = await getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
       expect(model).toBeDefined()
       expect(String(model.providerID)).toBe("anthropic")
       expect(String(model.id)).toBe("claude-sonnet-4-20250514")
-      const language = await Provider.getLanguage(model)
+      const language = await getLanguage(model)
       expect(language).toBeDefined()
     },
   })
@@ -339,7 +378,7 @@ test("getModel throws ModelNotFoundError for invalid model", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      expect(Provider.getModel(ProviderID.anthropic, ModelID.make("nonexistent-model"))).rejects.toThrow()
+      expect(getModel(ProviderID.anthropic, ModelID.make("nonexistent-model"))).rejects.toThrow()
     },
   })
 })
@@ -358,7 +397,7 @@ test("getModel throws ModelNotFoundError for invalid provider", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      expect(Provider.getModel(ProviderID.make("nonexistent-provider"), ModelID.make("some-model"))).rejects.toThrow()
+      expect(getModel(ProviderID.make("nonexistent-provider"), ModelID.make("some-model"))).rejects.toThrow()
     },
   })
 })
@@ -392,7 +431,7 @@ test("defaultModel returns first available model when no config set", async () =
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model = await Provider.defaultModel()
+      const model = await defaultModel()
       expect(model.providerID).toBeDefined()
       expect(model.modelID).toBeDefined()
     },
@@ -417,7 +456,7 @@ test("defaultModel respects config model setting", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model = await Provider.defaultModel()
+      const model = await defaultModel()
       expect(String(model.providerID)).toBe("anthropic")
       expect(String(model.modelID)).toBe("claude-sonnet-4-20250514")
     },
@@ -456,7 +495,7 @@ test("provider with baseURL from config", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("custom-openai")]).toBeDefined()
       expect(providers[ProviderID.make("custom-openai")].options.baseURL).toBe("https://custom.openai.com/v1")
     },
@@ -494,7 +533,7 @@ test("model cost defaults to zero when not specified", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("test-provider")].models["test-model"]
       expect(model.cost.input).toBe(0)
       expect(model.cost.output).toBe(0)
@@ -532,7 +571,7 @@ test("model options are merged from existing model", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.options.customOption).toBe("custom-value")
     },
@@ -561,7 +600,7 @@ test("provider removed when all models filtered out", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeUndefined()
     },
   })
@@ -584,7 +623,7 @@ test("closest finds model by partial match", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const result = await Provider.closest(ProviderID.anthropic, ["sonnet-4"])
+      const result = await closest(ProviderID.anthropic, ["sonnet-4"])
       expect(result).toBeDefined()
       expect(String(result?.providerID)).toBe("anthropic")
       expect(String(result?.modelID)).toContain("sonnet-4")
@@ -606,7 +645,7 @@ test("closest returns undefined for nonexistent provider", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const result = await Provider.closest(ProviderID.make("nonexistent"), ["model"])
+      const result = await closest(ProviderID.make("nonexistent"), ["model"])
       expect(result).toBeUndefined()
     },
   })
@@ -639,10 +678,10 @@ test("getModel uses realIdByKey for aliased models", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic].models["my-sonnet"]).toBeDefined()
 
-      const model = await Provider.getModel(ProviderID.anthropic, ModelID.make("my-sonnet"))
+      const model = await getModel(ProviderID.anthropic, ModelID.make("my-sonnet"))
       expect(model).toBeDefined()
       expect(String(model.id)).toBe("my-sonnet")
       expect(model.name).toBe("My Sonnet Alias")
@@ -682,7 +721,7 @@ test("provider api field sets model api.url", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       // api field is stored on model.api.url, used by getSDK to set baseURL
       expect(providers[ProviderID.make("custom-api")].models["model-1"].api.url).toBe("https://api.example.com/v1")
     },
@@ -722,7 +761,7 @@ test("explicit baseURL overrides api field", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("custom-api")].options.baseURL).toBe("https://custom.override.com/v1")
     },
   })
@@ -754,7 +793,7 @@ test("model inherits properties from existing database model", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.name).toBe("Custom Name for Sonnet")
       expect(model.capabilities.toolcall).toBe(true)
@@ -782,7 +821,7 @@ test("disabled_providers prevents loading even with env var", async () => {
       Env.set("OPENAI_API_KEY", "test-openai-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.openai]).toBeUndefined()
     },
   })
@@ -807,7 +846,7 @@ test("enabled_providers with empty array allows no providers", async () => {
       Env.set("OPENAI_API_KEY", "test-openai-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(Object.keys(providers).length).toBe(0)
     },
   })
@@ -836,7 +875,7 @@ test("whitelist and blacklist can be combined", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       const models = Object.keys(providers[ProviderID.anthropic].models)
       expect(models).toContain("claude-sonnet-4-20250514")
@@ -875,7 +914,7 @@ test("model modalities default correctly", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("test-provider")].models["test-model"]
       expect(model.capabilities.input.text).toBe(true)
       expect(model.capabilities.output.text).toBe(true)
@@ -918,7 +957,7 @@ test("model with custom cost values", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("test-provider")].models["test-model"]
       expect(model.cost.input).toBe(5)
       expect(model.cost.output).toBe(15)
@@ -945,7 +984,7 @@ test("getSmallModel returns appropriate small model", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model = await Provider.getSmallModel(ProviderID.anthropic)
+      const model = await getSmallModel(ProviderID.anthropic)
       expect(model).toBeDefined()
       expect(model?.id).toContain("haiku")
     },
@@ -970,7 +1009,7 @@ test("getSmallModel respects config small_model override", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model = await Provider.getSmallModel(ProviderID.anthropic)
+      const model = await getSmallModel(ProviderID.anthropic)
       expect(model).toBeDefined()
       expect(String(model?.providerID)).toBe("anthropic")
       expect(String(model?.id)).toBe("claude-sonnet-4-20250514")
@@ -1019,7 +1058,7 @@ test("multiple providers can be configured simultaneously", async () => {
       Env.set("OPENAI_API_KEY", "test-openai-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       expect(providers[ProviderID.openai]).toBeDefined()
       expect(providers[ProviderID.anthropic].options.timeout).toBe(30000)
@@ -1060,7 +1099,7 @@ test("provider with custom npm package", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("local-llm")]).toBeDefined()
       expect(providers[ProviderID.make("local-llm")].models["llama-3"].api.npm).toBe("@ai-sdk/openai-compatible")
       expect(providers[ProviderID.make("local-llm")].options.baseURL).toBe("http://localhost:11434/v1")
@@ -1097,7 +1136,7 @@ test("model alias name defaults to alias key when id differs", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic].models["sonnet"].name).toBe("sonnet")
     },
   })
@@ -1137,7 +1176,7 @@ test("provider with multiple env var options only includes apiKey when single en
       Env.set("MULTI_ENV_KEY_1", "test-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("multi-env")]).toBeDefined()
       // When multiple env options exist, key should NOT be auto-set
       expect(providers[ProviderID.make("multi-env")].key).toBeUndefined()
@@ -1179,7 +1218,7 @@ test("provider with single env var includes apiKey automatically", async () => {
       Env.set("SINGLE_ENV_KEY", "my-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("single-env")]).toBeDefined()
       // Single env option should auto-set key
       expect(providers[ProviderID.make("single-env")].key).toBe("my-api-key")
@@ -1216,7 +1255,7 @@ test("model cost overrides existing cost values", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.cost.input).toBe(999)
       expect(model.cost.output).toBe(888)
@@ -1263,7 +1302,7 @@ test("completely new provider not in database can be configured", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("brand-new-provider")]).toBeDefined()
       expect(providers[ProviderID.make("brand-new-provider")].name).toBe("Brand New")
       const model = providers[ProviderID.make("brand-new-provider")].models["new-model"]
@@ -1297,7 +1336,7 @@ test("disabled_providers and enabled_providers interaction", async () => {
       Env.set("GOOGLE_GENERATIVE_AI_API_KEY", "test-google")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       // anthropic: in enabled, not in disabled = allowed
       expect(providers[ProviderID.anthropic]).toBeDefined()
       // openai: in enabled, but also in disabled = NOT allowed
@@ -1337,7 +1376,7 @@ test("model with tool_call false", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("no-tools")].models["basic-model"].capabilities.toolcall).toBe(false)
     },
   })
@@ -1372,7 +1411,7 @@ test("model defaults tool_call to true when not specified", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("default-tools")].models["model"].capabilities.toolcall).toBe(true)
     },
   })
@@ -1411,7 +1450,7 @@ test("model headers are preserved", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("headers-provider")].models["model"]
       expect(model.headers).toEqual({
         "X-Custom-Header": "custom-value",
@@ -1454,7 +1493,7 @@ test("provider env fallback - second env var used if first missing", async () =>
       Env.set("FALLBACK_KEY", "fallback-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       // Provider should load because fallback env var is set
       expect(providers[ProviderID.make("fallback-env")]).toBeDefined()
     },
@@ -1478,8 +1517,8 @@ test("getModel returns consistent results", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const model1 = await Provider.getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
-      const model2 = await Provider.getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
+      const model1 = await getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
+      const model2 = await getModel(ProviderID.anthropic, ModelID.make("claude-sonnet-4-20250514"))
       expect(model1.providerID).toEqual(model2.providerID)
       expect(model1.id).toEqual(model2.id)
       expect(model1).toEqual(model2)
@@ -1516,7 +1555,7 @@ test("provider name defaults to id when not in database", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("my-custom-id")].name).toBe("my-custom-id")
     },
   })
@@ -1540,7 +1579,7 @@ test("ModelNotFoundError includes suggestions for typos", async () => {
     },
     fn: async () => {
       try {
-        await Provider.getModel(ProviderID.anthropic, ModelID.make("claude-sonet-4")) // typo: sonet instead of sonnet
+        await getModel(ProviderID.anthropic, ModelID.make("claude-sonet-4")) // typo: sonet instead of sonnet
         expect(true).toBe(false) // Should not reach here
       } catch (e: any) {
         expect(e.data.suggestions).toBeDefined()
@@ -1568,7 +1607,7 @@ test("ModelNotFoundError for provider includes suggestions", async () => {
     },
     fn: async () => {
       try {
-        await Provider.getModel(ProviderID.make("antropic"), ModelID.make("claude-sonnet-4")) // typo: antropic
+        await getModel(ProviderID.make("antropic"), ModelID.make("claude-sonnet-4")) // typo: antropic
         expect(true).toBe(false) // Should not reach here
       } catch (e: any) {
         expect(e.data.suggestions).toBeDefined()
@@ -1592,7 +1631,7 @@ test("getProvider returns undefined for nonexistent provider", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const provider = await Provider.getProvider(ProviderID.make("nonexistent"))
+      const provider = await getProvider(ProviderID.make("nonexistent"))
       expect(provider).toBeUndefined()
     },
   })
@@ -1615,7 +1654,7 @@ test("getProvider returns provider info", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const provider = await Provider.getProvider(ProviderID.anthropic)
+      const provider = await getProvider(ProviderID.anthropic)
       expect(provider).toBeDefined()
       expect(String(provider?.id)).toBe("anthropic")
     },
@@ -1639,7 +1678,7 @@ test("closest returns undefined when no partial match found", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const result = await Provider.closest(ProviderID.anthropic, ["nonexistent-xyz-model"])
+      const result = await closest(ProviderID.anthropic, ["nonexistent-xyz-model"])
       expect(result).toBeUndefined()
     },
   })
@@ -1663,7 +1702,7 @@ test("closest checks multiple query terms in order", async () => {
     },
     fn: async () => {
       // First term won't match, second will
-      const result = await Provider.closest(ProviderID.anthropic, ["nonexistent", "haiku"])
+      const result = await closest(ProviderID.anthropic, ["nonexistent", "haiku"])
       expect(result).toBeDefined()
       expect(result?.modelID).toContain("haiku")
     },
@@ -1699,7 +1738,7 @@ test("model limit defaults to zero when not specified", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("no-limit")].models["model"]
       expect(model.limit.context).toBe(0)
       expect(model.limit.output).toBe(0)
@@ -1734,7 +1773,7 @@ test("provider options are deeply merged", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       // Custom options should be merged
       expect(providers[ProviderID.anthropic].options.timeout).toBe(30000)
       expect(providers[ProviderID.anthropic].options.headers["X-Custom"]).toBe("custom-value")
@@ -1772,7 +1811,7 @@ test("custom model inherits npm package from models.dev provider config", async
       Env.set("OPENAI_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.openai].models["my-custom-model"]
       expect(model).toBeDefined()
       expect(model.api.npm).toBe("@ai-sdk/openai")
@@ -1807,7 +1846,7 @@ test("custom model inherits api.url from models.dev provider", async () => {
       Env.set("OPENROUTER_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.openrouter]).toBeDefined()
 
       // New model not in database should inherit api.url from provider
@@ -1908,7 +1947,7 @@ test("model variants are generated for reasoning models", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       // Claude sonnet 4 has reasoning capability
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.capabilities.reasoning).toBe(true)
@@ -1946,7 +1985,7 @@ test("model variants can be disabled via config", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.variants).toBeDefined()
       expect(model.variants!["high"]).toBeUndefined()
@@ -1989,7 +2028,7 @@ test("model variants can be customized via config", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.variants!["high"]).toBeDefined()
       expect(model.variants!["high"].thinking.budgetTokens).toBe(20000)
@@ -2028,7 +2067,7 @@ test("disabled key is stripped from variant config", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.variants!["max"]).toBeDefined()
       expect(model.variants!["max"].disabled).toBeUndefined()
@@ -2066,7 +2105,7 @@ test("all variants can be disabled via config", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.variants).toBeDefined()
       expect(Object.keys(model.variants!).length).toBe(0)
@@ -2104,7 +2143,7 @@ test("variant config merges with generated variants", async () => {
       Env.set("ANTHROPIC_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
       expect(model.variants!["high"]).toBeDefined()
       // Should have both the generated thinking config and the custom option
@@ -2142,7 +2181,7 @@ test("variants filtered in second pass for database models", async () => {
       Env.set("OPENAI_API_KEY", "test-api-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.openai].models["gpt-5"]
       expect(model.variants).toBeDefined()
       expect(model.variants!["high"]).toBeUndefined()
@@ -2188,7 +2227,7 @@ test("custom model with variants enabled and disabled", async () => {
   await Instance.provide({
     directory: tmp.path,
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("custom-reasoning")].models["reasoning-model"]
       expect(model.variants).toBeDefined()
       // Enabled variants should exist
@@ -2246,7 +2285,7 @@ test("Google Vertex: retains baseURL for custom proxy", async () => {
       Env.set("GOOGLE_APPLICATION_CREDENTIALS", "test-creds")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("vertex-proxy")]).toBeDefined()
       expect(providers[ProviderID.make("vertex-proxy")].options.baseURL).toBe("https://my-proxy.com/v1")
     },
@@ -2291,7 +2330,7 @@ test("Google Vertex: supports OpenAI compatible models", async () => {
       Env.set("GOOGLE_APPLICATION_CREDENTIALS", "test-creds")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       const model = providers[ProviderID.make("vertex-openai")].models["gpt-4"]
 
       expect(model).toBeDefined()
@@ -2319,7 +2358,7 @@ test("cloudflare-ai-gateway loads with env variables", async () => {
       Env.set("CLOUDFLARE_API_TOKEN", "test-token")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("cloudflare-ai-gateway")]).toBeDefined()
     },
   })
@@ -2351,7 +2390,7 @@ test("cloudflare-ai-gateway forwards config metadata options", async () => {
       Env.set("CLOUDFLARE_API_TOKEN", "test-token")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.make("cloudflare-ai-gateway")]).toBeDefined()
       expect(providers[ProviderID.make("cloudflare-ai-gateway")].options.metadata).toEqual({
         invoked_by: "test",
@@ -2399,7 +2438,7 @@ test("plugin config providers persist after instance dispose", async () => {
     directory: tmp.path,
     fn: async () => {
       await Plugin.init()
-      return Provider.list()
+      return list()
     },
   })
   expect(first[ProviderID.make("demo")]).toBeDefined()
@@ -2409,7 +2448,7 @@ test("plugin config providers persist after instance dispose", async () => {
 
   const second = await Instance.provide({
     directory: tmp.path,
-    fn: async () => Provider.list(),
+    fn: async () => list(),
   })
   expect(second[ProviderID.make("demo")]).toBeDefined()
   expect(second[ProviderID.make("demo")].models[ModelID.make("chat")]).toBeDefined()
@@ -2445,7 +2484,7 @@ test("plugin config enabled and disabled providers are honored", async () => {
       Env.set("OPENAI_API_KEY", "test-openai-key")
     },
     fn: async () => {
-      const providers = await Provider.list()
+      const providers = await list()
       expect(providers[ProviderID.anthropic]).toBeDefined()
       expect(providers[ProviderID.openai]).toBeUndefined()
     },
@@ -2466,7 +2505,7 @@ test("opencode loader keeps paid models when config apiKey is present", async ()
 
   const none = await Instance.provide({
     directory: base.path,
-    fn: async () => paid(await Provider.list()),
+    fn: async () => paid(await list()),
   })
 
   await using keyed = await tmpdir({
@@ -2489,7 +2528,7 @@ test("opencode loader keeps paid models when config apiKey is present", async ()
 
   const keyedCount = await Instance.provide({
     directory: keyed.path,
-    fn: async () => paid(await Provider.list()),
+    fn: async () => paid(await list()),
   })
 
   expect(none).toBe(0)
@@ -2510,7 +2549,7 @@ test("opencode loader keeps paid models when auth exists", async () => {
 
   const none = await Instance.provide({
     directory: base.path,
-    fn: async () => paid(await Provider.list()),
+    fn: async () => paid(await list()),
   })
 
   await using keyed = await tmpdir({
@@ -2544,7 +2583,7 @@ test("opencode loader keeps paid models when auth exists", async () => {
 
     const keyedCount = await Instance.provide({
       directory: keyed.path,
-      fn: async () => paid(await Provider.list()),
+      fn: async () => paid(await list()),
     })
 
     expect(none).toBe(0)

packages/opencode/test/provider/transform.test.ts

@@ -1842,6 +1842,11 @@ describe("ProviderTransform.message - cache control on gateway", () => {
           type: "ephemeral",
         },
       },
+      alibaba: {
+        cacheControl: {
+          type: "ephemeral",
+        },
+      },
     })
   })
 
@@ -1894,6 +1899,11 @@ describe("ProviderTransform.message - cache control on gateway", () => {
           type: "ephemeral",
         },
       },
+      alibaba: {
+        cacheControl: {
+          type: "ephemeral",
+        },
+      },
     })
   })
 })

packages/opencode/test/pty/pty-output-isolation.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, test } from "bun:test"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { Effect } from "effect"
 import { Instance } from "../../src/project/instance"
 import { Pty } from "../../src/pty"
 import { tmpdir } from "../fixture/fixture"
@@ -10,48 +12,48 @@ describe("pty", () => {
 
     await Instance.provide({
       directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        const b = await Pty.create({ command: "cat", title: "b" })
-        try {
-          const outA: string[] = []
-          const outB: string[] = []
+      fn: () =>
+        AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            const a = yield* pty.create({ command: "cat", title: "a" })
+            const b = yield* pty.create({ command: "cat", title: "b" })
+            try {
+              const outA: string[] = []
+              const outB: string[] = []
 
-          const ws = {
-            readyState: 1,
-            data: { events: { connection: "a" } },
-            send: (data: unknown) => {
-              outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op (simulate abrupt drop)
-            },
-          }
+              const ws = {
+                readyState: 1,
+                data: { events: { connection: "a" } },
+                send: (data: unknown) => {
+                  outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
+                },
+                close: () => {
+                  // no-op (simulate abrupt drop)
+                },
+              }
 
-          // Connect "a" first with ws.
-          Pty.connect(a.id, ws as any)
+              yield* pty.connect(a.id, ws as any)
 
-          // Now "reuse" the same ws object for another connection.
-          ws.data = { events: { connection: "b" } }
-          ws.send = (data: unknown) => {
-            outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-          }
-          Pty.connect(b.id, ws as any)
+              ws.data = { events: { connection: "b" } }
+              ws.send = (data: unknown) => {
+                outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
+              }
+              yield* pty.connect(b.id, ws as any)
 
-          // Clear connect metadata writes.
-          outA.length = 0
-          outB.length = 0
+              outA.length = 0
+              outB.length = 0
 
-          // Output from a must never show up in b.
-          Pty.write(a.id, "AAA\n")
-          await sleep(100)
+              yield* pty.write(a.id, "AAA\n")
+              yield* Effect.promise(() => sleep(100))
 
-          expect(outB.join("")).not.toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-          await Pty.remove(b.id)
-        }
-      },
+              expect(outB.join("")).not.toContain("AAA")
+            } finally {
+              yield* pty.remove(a.id)
+              yield* pty.remove(b.id)
+            }
+          }),
+        ),
     })
   })
 
@@ -60,42 +62,43 @@ describe("pty", () => {
 
     await Instance.provide({
       directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        try {
-          const outA: string[] = []
-          const outB: string[] = []
+      fn: () =>
+        AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            const a = yield* pty.create({ command: "cat", title: "a" })
+            try {
+              const outA: string[] = []
+              const outB: string[] = []
 
-          const ws = {
-            readyState: 1,
-            data: { events: { connection: "a" } },
-            send: (data: unknown) => {
-              outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op (simulate abrupt drop)
-            },
-          }
+              const ws = {
+                readyState: 1,
+                data: { events: { connection: "a" } },
+                send: (data: unknown) => {
+                  outA.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
+                },
+                close: () => {
+                  // no-op (simulate abrupt drop)
+                },
+              }
 
-          // Connect "a" first.
-          Pty.connect(a.id, ws as any)
-          outA.length = 0
+              yield* pty.connect(a.id, ws as any)
+              outA.length = 0
 
-          // Simulate Bun reusing the same websocket object for another
-          // connection before the next onOpen calls Pty.connect.
-          ws.data = { events: { connection: "b" } }
-          ws.send = (data: unknown) => {
-            outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-          }
+              ws.data = { events: { connection: "b" } }
+              ws.send = (data: unknown) => {
+                outB.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
+              }
 
-          Pty.write(a.id, "AAA\n")
-          await sleep(100)
+              yield* pty.write(a.id, "AAA\n")
+              yield* Effect.promise(() => sleep(100))
 
-          expect(outB.join("")).not.toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-        }
-      },
+              expect(outB.join("")).not.toContain("AAA")
+            } finally {
+              yield* pty.remove(a.id)
+            }
+          }),
+        ),
     })
   })
 
@@ -104,38 +107,40 @@ describe("pty", () => {
 
     await Instance.provide({
       directory: dir.path,
-      fn: async () => {
-        const a = await Pty.create({ command: "cat", title: "a" })
-        try {
-          const out: string[] = []
+      fn: () =>
+        AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            const a = yield* pty.create({ command: "cat", title: "a" })
+            try {
+              const out: string[] = []
 
-          const ctx = { connId: 1 }
-          const ws = {
-            readyState: 1,
-            data: ctx,
-            send: (data: unknown) => {
-              out.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
-            },
-            close: () => {
-              // no-op
-            },
-          }
+              const ctx = { connId: 1 }
+              const ws = {
+                readyState: 1,
+                data: ctx,
+                send: (data: unknown) => {
+                  out.push(typeof data === "string" ? data : Buffer.from(data as Uint8Array).toString("utf8"))
+                },
+                close: () => {
+                  // no-op
+                },
+              }
 
-          Pty.connect(a.id, ws as any)
-          out.length = 0
+              yield* pty.connect(a.id, ws as any)
+              out.length = 0
 
-          // Mutating fields on ws.data should not look like a new
-          // connection lifecycle when the object identity stays stable.
-          ctx.connId = 2
+              ctx.connId = 2
 
-          Pty.write(a.id, "AAA\n")
-          await sleep(100)
+              yield* pty.write(a.id, "AAA\n")
+              yield* Effect.promise(() => sleep(100))
 
-          expect(out.join("")).toContain("AAA")
-        } finally {
-          await Pty.remove(a.id)
-        }
-      },
+              expect(out.join("")).toContain("AAA")
+            } finally {
+              yield* pty.remove(a.id)
+            }
+          }),
+        ),
     })
   })
 })

packages/opencode/test/pty/pty-session.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test"
+import { AppRuntime } from "../../src/effect/app-runtime"
 import { Bus } from "../../src/bus"
+import { Effect } from "effect"
 import { Instance } from "../../src/project/instance"
 import { Pty } from "../../src/pty"
 import type { PtyID } from "../../src/pty/schema"
@@ -27,33 +29,37 @@ describe("pty", () => {
 
     await Instance.provide({
       directory: dir.path,
-      fn: async () => {
-        const log: Array<{ type: "created" | "exited" | "deleted"; id: PtyID }> = []
-        const off = [
-          Bus.subscribe(Pty.Event.Created, (evt) => log.push({ type: "created", id: evt.properties.info.id })),
-          Bus.subscribe(Pty.Event.Exited, (evt) => log.push({ type: "exited", id: evt.properties.id })),
-          Bus.subscribe(Pty.Event.Deleted, (evt) => log.push({ type: "deleted", id: evt.properties.id })),
-        ]
+      fn: () =>
+        AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            const log: Array<{ type: "created" | "exited" | "deleted"; id: PtyID }> = []
+            const off = [
+              Bus.subscribe(Pty.Event.Created, (evt) => log.push({ type: "created", id: evt.properties.info.id })),
+              Bus.subscribe(Pty.Event.Exited, (evt) => log.push({ type: "exited", id: evt.properties.id })),
+              Bus.subscribe(Pty.Event.Deleted, (evt) => log.push({ type: "deleted", id: evt.properties.id })),
+            ]
 
-        let id: PtyID | undefined
-        try {
-          const info = await Pty.create({
-            command: "/usr/bin/env",
-            args: ["sh", "-c", "sleep 0.1"],
-            title: "sleep",
-          })
-          id = info.id
+            let id: PtyID | undefined
+            try {
+              const info = yield* pty.create({
+                command: "/usr/bin/env",
+                args: ["sh", "-c", "sleep 0.1"],
+                title: "sleep",
+              })
+              id = info.id
 
-          await wait(() => pick(log, id!).includes("exited"))
+              yield* Effect.promise(() => wait(() => pick(log, id!).includes("exited")))
 
-          await Pty.remove(id)
-          await wait(() => pick(log, id!).length >= 3)
-          expect(pick(log, id!)).toEqual(["created", "exited", "deleted"])
-        } finally {
-          off.forEach((x) => x())
-          if (id) await Pty.remove(id)
-        }
-      },
+              yield* pty.remove(id)
+              yield* Effect.promise(() => wait(() => pick(log, id!).length >= 3))
+              expect(pick(log, id!)).toEqual(["created", "exited", "deleted"])
+            } finally {
+              off.forEach((x) => x())
+              if (id) yield* pty.remove(id)
+            }
+          }),
+        ),
     })
   })
 
@@ -64,29 +70,33 @@ describe("pty", () => {
 
     await Instance.provide({
       directory: dir.path,
-      fn: async () => {
-        const log: Array<{ type: "created" | "exited" | "deleted"; id: PtyID }> = []
-        const off = [
-          Bus.subscribe(Pty.Event.Created, (evt) => log.push({ type: "created", id: evt.properties.info.id })),
-          Bus.subscribe(Pty.Event.Exited, (evt) => log.push({ type: "exited", id: evt.properties.id })),
-          Bus.subscribe(Pty.Event.Deleted, (evt) => log.push({ type: "deleted", id: evt.properties.id })),
-        ]
+      fn: () =>
+        AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const pty = yield* Pty.Service
+            const log: Array<{ type: "created" | "exited" | "deleted"; id: PtyID }> = []
+            const off = [
+              Bus.subscribe(Pty.Event.Created, (evt) => log.push({ type: "created", id: evt.properties.info.id })),
+              Bus.subscribe(Pty.Event.Exited, (evt) => log.push({ type: "exited", id: evt.properties.id })),
+              Bus.subscribe(Pty.Event.Deleted, (evt) => log.push({ type: "deleted", id: evt.properties.id })),
+            ]
 
-        let id: PtyID | undefined
-        try {
-          const info = await Pty.create({ command: "/bin/sh", title: "sh" })
-          id = info.id
+            let id: PtyID | undefined
+            try {
+              const info = yield* pty.create({ command: "/bin/sh", title: "sh" })
+              id = info.id
 
-          await sleep(100)
+              yield* Effect.promise(() => sleep(100))
 
-          await Pty.remove(id)
-          await wait(() => pick(log, id!).length >= 3)
-          expect(pick(log, id!)).toEqual(["created", "exited", "deleted"])
-        } finally {
-          off.forEach((x) => x())
-          if (id) await Pty.remove(id)
-        }
-      },
+              yield* pty.remove(id)
+              yield* Effect.promise(() => wait(() => pick(log, id!).length >= 3))
+              expect(pick(log, id!)).toEqual(["created", "exited", "deleted"])
+            } finally {
+              off.forEach((x) => x())
+              if (id) yield* pty.remove(id)
+            }
+          }),
+        ),
     })
   })
 })

packages/opencode/test/pty/pty-shell.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, test } from "bun:test"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { Effect } from "effect"
 import { Instance } from "../../src/project/instance"
 import { Pty } from "../../src/pty"
 import { Shell } from "../../src/shell/shell"
@@ -17,14 +19,18 @@ describe("pty shell args", () => {
         await using dir = await tmpdir()
         await Instance.provide({
           directory: dir.path,
-          fn: async () => {
-            const info = await Pty.create({ command: ps, title: "pwsh" })
-            try {
-              expect(info.args).toEqual([])
-            } finally {
-              await Pty.remove(info.id)
-            }
-          },
+          fn: () =>
+            AppRuntime.runPromise(
+              Effect.gen(function* () {
+                const pty = yield* Pty.Service
+                const info = yield* pty.create({ command: ps, title: "pwsh" })
+                try {
+                  expect(info.args).toEqual([])
+                } finally {
+                  yield* pty.remove(info.id)
+                }
+              }),
+            ),
         })
       },
       { timeout: 30000 },
@@ -43,14 +49,18 @@ describe("pty shell args", () => {
         await using dir = await tmpdir()
         await Instance.provide({
           directory: dir.path,
-          fn: async () => {
-            const info = await Pty.create({ command: bash, title: "bash" })
-            try {
-              expect(info.args).toEqual(["-l"])
-            } finally {
-              await Pty.remove(info.id)
-            }
-          },
+          fn: () =>
+            AppRuntime.runPromise(
+              Effect.gen(function* () {
+                const pty = yield* Pty.Service
+                const info = yield* pty.create({ command: bash, title: "bash" })
+                try {
+                  expect(info.args).toEqual(["-l"])
+                } finally {
+                  yield* pty.remove(info.id)
+                }
+              }),
+            ),
         })
       },
       { timeout: 30000 },

packages/opencode/test/server/project-init-git.test.ts

@@ -43,7 +43,6 @@ describe("project.initGit endpoint", () => {
         worktree: tmp.path,
       })
       expect(reloadSpy).toHaveBeenCalledTimes(1)
-      expect(reloadSpy.mock.calls[0]?.[0]?.init).toBe(InstanceBootstrap)
       expect(seen.some((evt) => evt.directory === tmp.path && evt.payload.type === "server.instance.disposed")).toBe(
         true,
       )

packages/opencode/test/session/instruction.test.ts

@@ -219,6 +219,59 @@ describe("Instruction.resolve", () => {
   test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
 })
 
+describe("Instruction.system", () => {
+  test("loads both project and global AGENTS.md when both exist", async () => {
+    const originalConfigDir = process.env["OPENCODE_CONFIG_DIR"]
+    delete process.env["OPENCODE_CONFIG_DIR"]
+
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Project Instructions")
+      },
+    })
+
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    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(projectTmp.path, "AGENTS.md"))).toBe(true)
+                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+
+                const rules = yield* svc.system()
+                expect(rules).toHaveLength(2)
+                expect(rules).toContain(
+                  `Instructions from: ${path.join(projectTmp.path, "AGENTS.md")}\n# Project Instructions`,
+                )
+                expect(rules).toContain(
+                  `Instructions from: ${path.join(globalTmp.path, "AGENTS.md")}\n# Global Instructions`,
+                )
+              }),
+            ),
+          ),
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+      if (originalConfigDir === undefined) {
+        delete process.env["OPENCODE_CONFIG_DIR"]
+      } else {
+        process.env["OPENCODE_CONFIG_DIR"] = originalConfigDir
+      }
+    }
+  })
+})
+
 describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
   let originalConfigDir: string | undefined
 

packages/opencode/test/session/llm.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test"
 import path from "path"
 import { tool, type ModelMessage } from "ai"
-import { Cause, Exit, Stream } from "effect"
+import { Cause, Effect, Exit, Stream } from "effect"
 import z from "zod"
 import { makeRuntime } from "../../src/effect/run-service"
 import { LLM } from "../../src/session/llm"
@@ -15,6 +15,16 @@ import { tmpdir } from "../fixture/fixture"
 import type { Agent } from "../../src/agent/agent"
 import type { MessageV2 } from "../../src/session/message-v2"
 import { SessionID, MessageID } from "../../src/session/schema"
+import { AppRuntime } from "../../src/effect/app-runtime"
+
+async function getModel(providerID: ProviderID, modelID: ModelID) {
+  return AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const provider = yield* Provider.Service
+      return yield* provider.getModel(providerID, modelID)
+    }),
+  )
+}
 
 describe("session.llm.hasToolCalls", () => {
   test("returns false for empty messages array", () => {
@@ -325,7 +335,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-1")
         const agent = {
           name: "test",
@@ -416,7 +426,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-raw-abort")
         const agent = {
           name: "test",
@@ -490,7 +500,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-service-abort")
         const agent = {
           name: "test",
@@ -581,7 +591,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-tools")
         const agent = {
           name: "test",
@@ -699,7 +709,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.openai, ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.openai, ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-2")
         const agent = {
           name: "test",
@@ -819,7 +829,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.openai, ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.openai, ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-data-url")
         const agent = {
           name: "test",
@@ -942,7 +952,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-3")
         const agent = {
           name: "test",
@@ -1043,7 +1053,7 @@ describe("session.llm.stream", () => {
     await Instance.provide({
       directory: tmp.path,
       fn: async () => {
-        const resolved = await Provider.getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
         const sessionID = SessionID.make("session-test-4")
         const agent = {
           name: "test",

packages/opencode/test/session/prompt-effect.test.ts

@@ -204,7 +204,7 @@ const it = testEffect(makeHttp())
 const unix = process.platform !== "win32" ? it.live : it.live.skip
 
 // Config that registers a custom "test" provider with a "test-model" model
-// so Provider.getModel("test", "test-model") succeeds inside the loop.
+// so provider model lookup succeeds inside the loop.
 const cfg = {
   provider: {
     test: {

packages/opencode/test/skill/skill.test.ts

@@ -1,13 +1,15 @@
-import { afterEach, test, expect } from "bun:test"
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
 import { Skill } from "../../src/skill"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+import { provideInstance, provideTmpdirInstance, tmpdir } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
 import path from "path"
 import fs from "fs/promises"
 
-afterEach(async () => {
-  await Instance.disposeAll()
-})
+const node = CrossSpawnSpawner.defaultLayer
+
+const it = testEffect(Layer.mergeAll(Skill.defaultLayer, node))
 
 async function createGlobalSkill(homeDir: string) {
   const skillDir = path.join(homeDir, ".claude", "skills", "global-test-skill")
@@ -26,14 +28,29 @@ This skill is loaded from the global home directory.
   )
 }
 
-test("discovers skills from .opencode/skill/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".opencode", "skill", "test-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
+const withHome = <A, E, R>(home: string, self: Effect.Effect<A, E, R>) =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const prev = process.env.OPENCODE_TEST_HOME
+      process.env.OPENCODE_TEST_HOME = home
+      return prev
+    }),
+    () => self,
+    (prev) =>
+      Effect.sync(() => {
+        process.env.OPENCODE_TEST_HOME = prev
+      }),
+  )
+
+describe("skill", () => {
+  it.live("discovers skills from .opencode/skill/ directory", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Bun.write(
+              path.join(dir, ".opencode", "skill", "test-skill", "SKILL.md"),
+              `---
 name: test-skill
 description: A test skill for verification.
 ---
@@ -42,230 +59,217 @@ description: A test skill for verification.
 
 Instructions here.
 `,
-      )
-    },
-  })
+            ),
+          )
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const testSkill = skills.find((s) => s.name === "test-skill")
-      expect(testSkill).toBeDefined()
-      expect(testSkill!.description).toBe("A test skill for verification.")
-      expect(testSkill!.location).toContain(path.join("skill", "test-skill", "SKILL.md"))
-    },
-  })
-})
+          const skill = yield* Skill.Service
+          const list = yield* skill.all()
+          expect(list.length).toBe(1)
+          const item = list.find((x) => x.name === "test-skill")
+          expect(item).toBeDefined()
+          expect(item!.description).toBe("A test skill for verification.")
+          expect(item!.location).toContain(path.join("skill", "test-skill", "SKILL.md"))
+        }),
+      { git: true },
+    ),
+  )
 
-test("returns skill directories from Skill.dirs", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".opencode", "skill", "dir-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
+  it.live("returns skill directories from Skill.dirs", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        withHome(
+          dir,
+          Effect.gen(function* () {
+            yield* Effect.promise(() =>
+              Bun.write(
+                path.join(dir, ".opencode", "skill", "dir-skill", "SKILL.md"),
+                `---
 name: dir-skill
 description: Skill for dirs test.
 ---
 
 # Dir Skill
 `,
-      )
-    },
-  })
+              ),
+            )
 
-  const home = process.env.OPENCODE_TEST_HOME
-  process.env.OPENCODE_TEST_HOME = tmp.path
+            const skill = yield* Skill.Service
+            const dirs = yield* skill.dirs()
+            expect(dirs).toContain(path.join(dir, ".opencode", "skill", "dir-skill"))
+            expect(dirs.length).toBe(1)
+          }),
+        ),
+      { git: true },
+    ),
+  )
 
-  try {
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const dirs = await Skill.dirs()
-        const skillDir = path.join(tmp.path, ".opencode", "skill", "dir-skill")
-        expect(dirs).toContain(skillDir)
-        expect(dirs.length).toBe(1)
-      },
-    })
-  } finally {
-    process.env.OPENCODE_TEST_HOME = home
-  }
-})
-
-test("discovers multiple skills from .opencode/skill/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir1 = path.join(dir, ".opencode", "skill", "skill-one")
-      const skillDir2 = path.join(dir, ".opencode", "skill", "skill-two")
-      await Bun.write(
-        path.join(skillDir1, "SKILL.md"),
-        `---
+  it.live("discovers multiple skills from .opencode/skill/ directory", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Promise.all([
+              Bun.write(
+                path.join(dir, ".opencode", "skill", "skill-one", "SKILL.md"),
+                `---
 name: skill-one
 description: First test skill.
 ---
 
 # Skill One
 `,
-      )
-      await Bun.write(
-        path.join(skillDir2, "SKILL.md"),
-        `---
+              ),
+              Bun.write(
+                path.join(dir, ".opencode", "skill", "skill-two", "SKILL.md"),
+                `---
 name: skill-two
 description: Second test skill.
 ---
 
 # Skill Two
 `,
-      )
-    },
-  })
+              ),
+            ]),
+          )
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(2)
-      expect(skills.find((s) => s.name === "skill-one")).toBeDefined()
-      expect(skills.find((s) => s.name === "skill-two")).toBeDefined()
-    },
-  })
-})
+          const skill = yield* Skill.Service
+          const list = yield* skill.all()
+          expect(list.length).toBe(2)
+          expect(list.find((x) => x.name === "skill-one")).toBeDefined()
+          expect(list.find((x) => x.name === "skill-two")).toBeDefined()
+        }),
+      { git: true },
+    ),
+  )
 
-test("skips skills with missing frontmatter", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".opencode", "skill", "no-frontmatter")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `# No Frontmatter
+  it.live("skips skills with missing frontmatter", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Bun.write(
+              path.join(dir, ".opencode", "skill", "no-frontmatter", "SKILL.md"),
+              `# No Frontmatter
 
 Just some content without YAML frontmatter.
 `,
-      )
-    },
-  })
+            ),
+          )
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills).toEqual([])
-    },
-  })
-})
+          const skill = yield* Skill.Service
+          expect(yield* skill.all()).toEqual([])
+        }),
+      { git: true },
+    ),
+  )
 
-test("discovers skills from .claude/skills/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".claude", "skills", "claude-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
+  it.live("discovers skills from .claude/skills/ directory", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Bun.write(
+              path.join(dir, ".claude", "skills", "claude-skill", "SKILL.md"),
+              `---
 name: claude-skill
 description: A skill in the .claude/skills directory.
 ---
 
 # Claude Skill
 `,
+            ),
+          )
+
+          const skill = yield* Skill.Service
+          const list = yield* skill.all()
+          expect(list.length).toBe(1)
+          const item = list.find((x) => x.name === "claude-skill")
+          expect(item).toBeDefined()
+          expect(item!.location).toContain(path.join(".claude", "skills", "claude-skill", "SKILL.md"))
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("discovers global skills from ~/.claude/skills/ directory", () =>
+    Effect.gen(function* () {
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir({ git: true })),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
       )
-    },
-  })
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const claudeSkill = skills.find((s) => s.name === "claude-skill")
-      expect(claudeSkill).toBeDefined()
-      expect(claudeSkill!.location).toContain(path.join(".claude", "skills", "claude-skill", "SKILL.md"))
-    },
-  })
-})
+      yield* withHome(
+        tmp.path,
+        Effect.gen(function* () {
+          yield* Effect.promise(() => createGlobalSkill(tmp.path))
+          yield* Effect.gen(function* () {
+            const skill = yield* Skill.Service
+            const list = yield* skill.all()
+            expect(list.length).toBe(1)
+            expect(list[0].name).toBe("global-test-skill")
+            expect(list[0].description).toBe("A global skill from ~/.claude/skills for testing.")
+            expect(list[0].location).toContain(path.join(".claude", "skills", "global-test-skill", "SKILL.md"))
+          }).pipe(provideInstance(tmp.path))
+        }),
+      )
+    }),
+  )
 
-test("discovers global skills from ~/.claude/skills/ directory", async () => {
-  await using tmp = await tmpdir({ git: true })
+  it.live("returns empty array when no skills exist", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const skill = yield* Skill.Service
+          expect(yield* skill.all()).toEqual([])
+        }),
+      { git: true },
+    ),
+  )
 
-  const originalHome = process.env.OPENCODE_TEST_HOME
-  process.env.OPENCODE_TEST_HOME = tmp.path
-
-  try {
-    await createGlobalSkill(tmp.path)
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const skills = await Skill.all()
-        expect(skills.length).toBe(1)
-        expect(skills[0].name).toBe("global-test-skill")
-        expect(skills[0].description).toBe("A global skill from ~/.claude/skills for testing.")
-        expect(skills[0].location).toContain(path.join(".claude", "skills", "global-test-skill", "SKILL.md"))
-      },
-    })
-  } finally {
-    process.env.OPENCODE_TEST_HOME = originalHome
-  }
-})
-
-test("returns empty array when no skills exist", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills).toEqual([])
-    },
-  })
-})
-
-test("discovers skills from .agents/skills/ directory", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const skillDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(skillDir, "SKILL.md"),
-        `---
+  it.live("discovers skills from .agents/skills/ directory", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Bun.write(
+              path.join(dir, ".agents", "skills", "agent-skill", "SKILL.md"),
+              `---
 name: agent-skill
 description: A skill in the .agents/skills directory.
 ---
 
 # Agent Skill
 `,
+            ),
+          )
+
+          const skill = yield* Skill.Service
+          const list = yield* skill.all()
+          expect(list.length).toBe(1)
+          const item = list.find((x) => x.name === "agent-skill")
+          expect(item).toBeDefined()
+          expect(item!.location).toContain(path.join(".agents", "skills", "agent-skill", "SKILL.md"))
+        }),
+      { git: true },
+    ),
+  )
+
+  it.live("discovers global skills from ~/.agents/skills/ directory", () =>
+    Effect.gen(function* () {
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir({ git: true })),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
       )
-    },
-  })
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(1)
-      const agentSkill = skills.find((s) => s.name === "agent-skill")
-      expect(agentSkill).toBeDefined()
-      expect(agentSkill!.location).toContain(path.join(".agents", "skills", "agent-skill", "SKILL.md"))
-    },
-  })
-})
-
-test("discovers global skills from ~/.agents/skills/ directory", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  const originalHome = process.env.OPENCODE_TEST_HOME
-  process.env.OPENCODE_TEST_HOME = tmp.path
-
-  try {
-    const skillDir = path.join(tmp.path, ".agents", "skills", "global-agent-skill")
-    await fs.mkdir(skillDir, { recursive: true })
-    await Bun.write(
-      path.join(skillDir, "SKILL.md"),
-      `---
+      yield* withHome(
+        tmp.path,
+        Effect.gen(function* () {
+          const skillDir = path.join(tmp.path, ".agents", "skills", "global-agent-skill")
+          yield* Effect.promise(() => fs.mkdir(skillDir, { recursive: true }))
+          yield* Effect.promise(() =>
+            Bun.write(
+              path.join(skillDir, "SKILL.md"),
+              `---
 name: global-agent-skill
 description: A global skill from ~/.agents/skills for testing.
 ---
@@ -274,119 +278,114 @@ description: A global skill from ~/.agents/skills for testing.
 
 This skill is loaded from the global home directory.
 `,
-    )
+            ),
+          )
 
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const skills = await Skill.all()
-        expect(skills.length).toBe(1)
-        expect(skills[0].name).toBe("global-agent-skill")
-        expect(skills[0].description).toBe("A global skill from ~/.agents/skills for testing.")
-        expect(skills[0].location).toContain(path.join(".agents", "skills", "global-agent-skill", "SKILL.md"))
-      },
-    })
-  } finally {
-    process.env.OPENCODE_TEST_HOME = originalHome
-  }
-})
+          yield* Effect.gen(function* () {
+            const skill = yield* Skill.Service
+            const list = yield* skill.all()
+            expect(list.length).toBe(1)
+            expect(list[0].name).toBe("global-agent-skill")
+            expect(list[0].description).toBe("A global skill from ~/.agents/skills for testing.")
+            expect(list[0].location).toContain(path.join(".agents", "skills", "global-agent-skill", "SKILL.md"))
+          }).pipe(provideInstance(tmp.path))
+        }),
+      )
+    }),
+  )
 
-test("discovers skills from both .claude/skills/ and .agents/skills/", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const claudeDir = path.join(dir, ".claude", "skills", "claude-skill")
-      const agentDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(claudeDir, "SKILL.md"),
-        `---
+  it.live("discovers skills from both .claude/skills/ and .agents/skills/", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Promise.all([
+              Bun.write(
+                path.join(dir, ".claude", "skills", "claude-skill", "SKILL.md"),
+                `---
 name: claude-skill
 description: A skill in the .claude/skills directory.
 ---
 
 # Claude Skill
 `,
-      )
-      await Bun.write(
-        path.join(agentDir, "SKILL.md"),
-        `---
+              ),
+              Bun.write(
+                path.join(dir, ".agents", "skills", "agent-skill", "SKILL.md"),
+                `---
 name: agent-skill
 description: A skill in the .agents/skills directory.
 ---
 
 # Agent Skill
 `,
-      )
-    },
-  })
+              ),
+            ]),
+          )
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const skills = await Skill.all()
-      expect(skills.length).toBe(2)
-      expect(skills.find((s) => s.name === "claude-skill")).toBeDefined()
-      expect(skills.find((s) => s.name === "agent-skill")).toBeDefined()
-    },
-  })
-})
+          const skill = yield* Skill.Service
+          const list = yield* skill.all()
+          expect(list.length).toBe(2)
+          expect(list.find((x) => x.name === "claude-skill")).toBeDefined()
+          expect(list.find((x) => x.name === "agent-skill")).toBeDefined()
+        }),
+      { git: true },
+    ),
+  )
 
-test("properly resolves directories that skills live in", async () => {
-  await using tmp = await tmpdir({
-    git: true,
-    init: async (dir) => {
-      const opencodeSkillDir = path.join(dir, ".opencode", "skill", "agent-skill")
-      const opencodeSkillsDir = path.join(dir, ".opencode", "skills", "agent-skill")
-      const claudeDir = path.join(dir, ".claude", "skills", "claude-skill")
-      const agentDir = path.join(dir, ".agents", "skills", "agent-skill")
-      await Bun.write(
-        path.join(claudeDir, "SKILL.md"),
-        `---
+  it.live("properly resolves directories that skills live in", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          yield* Effect.promise(() =>
+            Promise.all([
+              Bun.write(
+                path.join(dir, ".claude", "skills", "claude-skill", "SKILL.md"),
+                `---
 name: claude-skill
 description: A skill in the .claude/skills directory.
 ---
 
 # Claude Skill
 `,
-      )
-      await Bun.write(
-        path.join(agentDir, "SKILL.md"),
-        `---
+              ),
+              Bun.write(
+                path.join(dir, ".agents", "skills", "agent-skill", "SKILL.md"),
+                `---
 name: agent-skill
 description: A skill in the .agents/skills directory.
 ---
 
 # Agent Skill
 `,
-      )
-      await Bun.write(
-        path.join(opencodeSkillDir, "SKILL.md"),
-        `---
+              ),
+              Bun.write(
+                path.join(dir, ".opencode", "skill", "agent-skill", "SKILL.md"),
+                `---
 name: opencode-skill
 description: A skill in the .opencode/skill directory.
 ---
 
 # OpenCode Skill
 `,
-      )
-      await Bun.write(
-        path.join(opencodeSkillsDir, "SKILL.md"),
-        `---
+              ),
+              Bun.write(
+                path.join(dir, ".opencode", "skills", "agent-skill", "SKILL.md"),
+                `---
 name: opencode-skill
 description: A skill in the .opencode/skills directory.
 ---
 
 # OpenCode Skill
 `,
-      )
-    },
-  })
+              ),
+            ]),
+          )
 
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const dirs = await Skill.dirs()
-      expect(dirs.length).toBe(4)
-    },
-  })
+          const skill = yield* Skill.Service
+          expect((yield* skill.dirs()).length).toBe(4)
+        }),
+      { git: true },
+    ),
+  )
 })

packages/opencode/test/tool/edit.test.ts

@@ -65,6 +65,18 @@ const readFileTime = (sessionID: SessionID, filepath: string) =>
 const subscribeBus = <D extends BusEvent.Definition>(def: D, callback: () => unknown) =>
   runtime.runPromise(Bus.Service.use((bus) => bus.subscribeCallback(def, callback)))
 
+async function onceBus<D extends BusEvent.Definition>(def: D) {
+  const result = Promise.withResolvers<void>()
+  const unsub = await subscribeBus(def, () => {
+    unsub()
+    result.resolve()
+  })
+  return {
+    wait: result.promise,
+    unsub,
+  }
+}
+
 describe("tool.edit", () => {
   describe("creating new files", () => {
     test("creates new file when oldString is empty", async () => {
@@ -128,23 +140,25 @@ describe("tool.edit", () => {
         fn: async () => {
           const { FileWatcher } = await import("../../src/file/watcher")
 
-          const events: string[] = []
-          const unsubUpdated = await subscribeBus(FileWatcher.Event.Updated, () => events.push("updated"))
+          const updated = await onceBus(FileWatcher.Event.Updated)
 
-          const edit = await resolve()
-          await Effect.runPromise(
-            edit.execute(
-              {
-                filePath: filepath,
-                oldString: "",
-                newString: "content",
-              },
-              ctx,
-            ),
-          )
+          try {
+            const edit = await resolve()
+            await Effect.runPromise(
+              edit.execute(
+                {
+                  filePath: filepath,
+                  oldString: "",
+                  newString: "content",
+                },
+                ctx,
+              ),
+            )
 
-          expect(events).toContain("updated")
-          unsubUpdated()
+            await updated.wait
+          } finally {
+            updated.unsub()
+          }
         },
       })
     })
@@ -359,23 +373,25 @@ describe("tool.edit", () => {
 
           const { FileWatcher } = await import("../../src/file/watcher")
 
-          const events: string[] = []
-          const unsubUpdated = await subscribeBus(FileWatcher.Event.Updated, () => events.push("updated"))
+          const updated = await onceBus(FileWatcher.Event.Updated)
 
-          const edit = await resolve()
-          await Effect.runPromise(
-            edit.execute(
-              {
-                filePath: filepath,
-                oldString: "original",
-                newString: "modified",
-              },
-              ctx,
-            ),
-          )
+          try {
+            const edit = await resolve()
+            await Effect.runPromise(
+              edit.execute(
+                {
+                  filePath: filepath,
+                  oldString: "original",
+                  newString: "modified",
+                },
+                ctx,
+              ),
+            )
 
-          expect(events).toContain("updated")
-          unsubUpdated()
+            await updated.wait
+          } finally {
+            updated.unsub()
+          }
         },
       })
     })