effect: introduce defineService and drop per-call Effect.provide

Wave A migrated TuiConfig/Installation callers to `AppRuntime.runPromise(svc.use(fn).pipe(Effect.provide(svc.layer)))`, which couples every call site to the service's layer construction. `defineService(Service, layer)` composes `makeRuntime` on top of an existing service so the service exposes its own runPromise/runFork/etc. Each per-service runtime shares the global memoMap, so dependencies are still built once. Call sites collapse from: await AppRuntime.runPromise( TuiConfig.Service.use((svc) => svc.get()).pipe(Effect.provide(TuiConfig.layer)), ) to: await TuiConfig.runPromise((svc) => svc.get()) Same shape applied to Installation. No per-method async wrappers.
effect(cli): kill TuiConfig/Installation/SessionCompaction facades
2026-08-06 01:00:54 -04:00 · 2026-05-12 19:32:23 -04:00 · 2026-05-12 16:29:18 -04:00
39 changed files with 222 additions and 371 deletions
@@ -78,7 +78,7 @@ const streamText = LLM.stream(request).pipe(
  Stream.tap((event) =>
    Effect.sync(() => {
      if (event.type === "text-delta") process.stdout.write(`\ntext: ${event.text}`)
-      if (event.type === "finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
+      if (event.type === "request-finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
    }),
  ),
  Stream.runDrain,
@@ -185,7 +185,7 @@ const FakeProtocol = Protocol.make<FakeBody, string, string, void>({
    event: Schema.String,
    initial: () => undefined,
    step: (_, frame) => Effect.succeed([undefined, [{ type: "text-delta", id: "text-0", text: frame }]] as const),
-    onHalt: () => [{ type: "finish", reason: "stop" }],
+    onHalt: () => [{ type: "request-finish", reason: "stop" }],
  },
 })

@@ -17,7 +17,6 @@ export type {
  ExecutableTools,
  Tool as ToolShape,
  ToolExecute,
-  ToolExecuteContext,
  Tools,
  ToolSchema,
 } from "./tool"
@@ -380,7 +380,7 @@ type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 const NO_EVENTS: StepResult["1"] = []

 // `response.completed` / `response.incomplete` are clean finishes that emit a
-// `finish` event; `response.failed` is a hard failure that emits a
+// `request-finish` event; `response.failed` is a hard failure that emits a
 // `provider-error`. All three end the stream — kept in one set so `step` and
 // the protocol's `terminal` predicate stay in sync.
 const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"])
@@ -80,7 +80,7 @@ export const finish = (
      usage: input.usage,
      providerMetadata: input.providerMetadata,
    }),
-    LLMEvent.finish(input),
+    LLMEvent.requestFinish(input),
  )
  return { ...stepped, stepStarted: false }
 }
@@ -1,5 +1,5 @@
 import { Schema } from "effect"
-import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
+import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, ResponseID, RouteID, ToolCallID } from "./ids"
 import { ModelRef } from "./options"
 import { ToolResultValue } from "./messages"

@@ -66,13 +66,14 @@ export class Usage extends Schema.Class<Usage>("LLM.Usage")({
  get visibleOutputTokens() {
    return Math.max(0, (this.outputTokens ?? 0) - (this.reasoningTokens ?? 0))
  }
-
-  static from(input: UsageInput) {
-    return input instanceof Usage ? input : new Usage(input)
-  }
 }

-export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
+export const RequestStart = Schema.Struct({
+  type: Schema.tag("request-start"),
+  id: ResponseID,
+  model: ModelRef,
+}).annotate({ identifier: "LLM.Event.RequestStart" })
+export type RequestStart = Schema.Schema.Type<typeof RequestStart>

 export const StepStart = Schema.Struct({
  type: Schema.tag("step-start"),
@@ -184,13 +185,13 @@ export const StepFinish = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.StepFinish" })
 export type StepFinish = Schema.Schema.Type<typeof StepFinish>

-export const Finish = Schema.Struct({
-  type: Schema.tag("finish"),
+export const RequestFinish = Schema.Struct({
+  type: Schema.tag("request-finish"),
  reason: FinishReason,
  usage: Schema.optional(Usage),
  providerMetadata: Schema.optional(ProviderMetadata),
-}).annotate({ identifier: "LLM.Event.Finish" })
-export type Finish = Schema.Schema.Type<typeof Finish>
+}).annotate({ identifier: "LLM.Event.RequestFinish" })
+export type RequestFinish = Schema.Schema.Type<typeof RequestFinish>

 export const ProviderErrorEvent = Schema.Struct({
  type: Schema.tag("provider-error"),
@@ -201,6 +202,7 @@ export const ProviderErrorEvent = Schema.Struct({
 export type ProviderErrorEvent = Schema.Schema.Type<typeof ProviderErrorEvent>

 const llmEventTagged = Schema.Union([
+  RequestStart,
  StepStart,
  TextStart,
  TextDelta,
@@ -215,15 +217,13 @@ const llmEventTagged = Schema.Union([
  ToolResult,
  ToolError,
  StepFinish,
-  Finish,
+  RequestFinish,
  ProviderErrorEvent,
 ]).pipe(Schema.toTaggedUnion("type"))

 type WithID<Event extends { readonly id: unknown }, ID> = Omit<Event, "type" | "id"> & { readonly id: ID | string }
-type WithUsage<Event extends { readonly usage?: Usage }> = Omit<Event, "type" | "usage"> & {
-  readonly usage?: UsageInput
-}

+const responseID = (value: ResponseID | string) => ResponseID.make(value)
 const contentBlockID = (value: ContentBlockID | string) => ContentBlockID.make(value)
 const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)

@@ -233,6 +233,7 @@ const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
 * `events.filter(LLMEvent.guards["tool-call"])`.
 */
 export const LLMEvent = Object.assign(llmEventTagged, {
+  requestStart: (input: WithID<RequestStart, ResponseID>) => RequestStart.make({ ...input, id: responseID(input.id) }),
  stepStart: StepStart.make,
  textStart: (input: WithID<TextStart, ContentBlockID>) => TextStart.make({ ...input, id: contentBlockID(input.id) }),
  textDelta: (input: WithID<TextDelta, ContentBlockID>) => TextDelta.make({ ...input, id: contentBlockID(input.id) }),
@@ -251,18 +252,11 @@ export const LLMEvent = Object.assign(llmEventTagged, {
  toolCall: (input: WithID<ToolCall, ToolCallID>) => ToolCall.make({ ...input, id: toolCallID(input.id) }),
  toolResult: (input: WithID<ToolResult, ToolCallID>) => ToolResult.make({ ...input, id: toolCallID(input.id) }),
  toolError: (input: WithID<ToolError, ToolCallID>) => ToolError.make({ ...input, id: toolCallID(input.id) }),
-  stepFinish: (input: WithUsage<StepFinish>) =>
-    StepFinish.make({
-      ...input,
-      usage: input.usage === undefined ? undefined : Usage.from(input.usage),
-    }),
-  finish: (input: WithUsage<Finish>) =>
-    Finish.make({
-      ...input,
-      usage: input.usage === undefined ? undefined : Usage.from(input.usage),
-    }),
+  stepFinish: StepFinish.make,
+  requestFinish: RequestFinish.make,
  providerError: ProviderErrorEvent.make,
  is: {
+    requestStart: llmEventTagged.guards["request-start"],
    stepStart: llmEventTagged.guards["step-start"],
    textStart: llmEventTagged.guards["text-start"],
    textDelta: llmEventTagged.guards["text-delta"],
@@ -277,7 +271,7 @@ export const LLMEvent = Object.assign(llmEventTagged, {
    toolResult: llmEventTagged.guards["tool-result"],
    toolError: llmEventTagged.guards["tool-error"],
    stepFinish: llmEventTagged.guards["step-finish"],
-    finish: llmEventTagged.guards.finish,
+    requestFinish: llmEventTagged.guards["request-finish"],
    providerError: llmEventTagged.guards["provider-error"],
  },
 })
@@ -12,7 +12,6 @@ import {
  ToolFailure,
  ToolResultPart,
  type ToolResultValue,
-  Usage,
 } from "./schema"
 import { type AnyTool, type ExecutableTools, type Tools, toDefinitions } from "./tool"

@@ -73,42 +72,19 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
          tools: [...options.request.tools.filter((tool) => !runtimeToolNames.has(tool.name)), ...runtimeTools],
        })

-  const loop = (
-    request: LLMRequest,
-    step: number,
-    usage: Usage | undefined,
-    providerMetadata: ProviderMetadata | undefined,
-  ): Stream.Stream<LLMEvent, LLMError> =>
+  const loop = (request: LLMRequest, step: number): Stream.Stream<LLMEvent, LLMError> =>
    Stream.unwrap(
      Effect.gen(function* () {
-        const state: StepState = {
-          assistantContent: [],
-          toolCalls: [],
-          finishReason: undefined,
-          usage: undefined,
-          providerMetadata: undefined,
-        }
+        const state: StepState = { assistantContent: [], toolCalls: [], finishReason: undefined }

        const modelStream = options
          .stream(request)
-          .pipe(Stream.map((event) => indexStep(event, step)))
          .pipe(Stream.tap((event) => Effect.sync(() => accumulate(state, event))))
-          .pipe(Stream.filter((event) => event.type !== "finish"))

        const continuation = Stream.unwrap(
          Effect.gen(function* () {
-            const totalUsage = addUsage(usage, state.usage)
-            const totalProviderMetadata = mergeProviderMetadata(providerMetadata, state.providerMetadata)
-            const finishStream = Stream.fromIterable([
-              LLMEvent.finish({
-                reason: state.finishReason ?? "unknown",
-                usage: totalUsage,
-                providerMetadata: totalProviderMetadata,
-              }),
-            ])
-
-            if (state.finishReason !== "tool-calls" || state.toolCalls.length === 0) return finishStream
-            if (options.toolExecution === "none") return finishStream
+            if (state.finishReason !== "tool-calls" || state.toolCalls.length === 0) return Stream.empty
+            if (options.toolExecution === "none") return Stream.empty

            const dispatched = yield* Effect.forEach(
              state.toolCalls,
@@ -117,14 +93,10 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
            )
            const resultStream = Stream.fromIterable(dispatched.flatMap(([call, result]) => emitEvents(call, result)))

-            if (!options.stopWhen) return resultStream.pipe(Stream.concat(finishStream))
-            if (options.stopWhen({ step, request })) return resultStream.pipe(Stream.concat(finishStream))
+            if (!options.stopWhen) return resultStream
+            if (options.stopWhen({ step, request })) return resultStream

-            return resultStream.pipe(
-              Stream.concat(
-                loop(followUpRequest(request, state, dispatched), step + 1, totalUsage, totalProviderMetadata),
-              ),
-            )
+            return resultStream.pipe(Stream.concat(loop(followUpRequest(request, state, dispatched), step + 1)))
          }),
        )

@@ -132,21 +104,13 @@ export const stream = <T extends Tools>(options: StreamOptions<T>): Stream.Strea
      }),
    )

-  return loop(initialRequest, 0, undefined, undefined)
-}
-
-const indexStep = (event: LLMEvent, index: number): LLMEvent => {
-  if (event.type === "step-start") return LLMEvent.stepStart({ index })
-  if (event.type === "step-finish") return LLMEvent.stepFinish({ ...event, index })
-  return event
+  return loop(initialRequest, 0)
 }

 interface StepState {
  assistantContent: ContentPart[]
  toolCalls: ToolCallPart[]
  finishReason: FinishReason | undefined
-  usage: Usage | undefined
-  providerMetadata: ProviderMetadata | undefined
 }

 const accumulate = (state: StepState, event: LLMEvent) => {
@@ -190,43 +154,9 @@ const accumulate = (state: StepState, event: LLMEvent) => {
    )
    return
  }
-  if (event.type === "step-finish") {
+  if (event.type === "step-finish" || event.type === "request-finish") {
    state.finishReason = event.reason === "stop" && state.toolCalls.length > 0 ? "tool-calls" : event.reason
-    state.usage = addUsage(state.usage, event.usage)
-    state.providerMetadata = mergeProviderMetadata(state.providerMetadata, event.providerMetadata)
-    return
  }
-  if (event.type === "finish") {
-    state.finishReason ??= event.reason
-    state.usage ??= event.usage
-    state.providerMetadata = mergeProviderMetadata(state.providerMetadata, event.providerMetadata)
-  }
-}
-
-const addUsage = (left: Usage | undefined, right: Usage | undefined) => {
-  if (!left) return right
-  if (!right) return left
-  type UsageKey =
-    | "inputTokens"
-    | "outputTokens"
-    | "nonCachedInputTokens"
-    | "cacheReadInputTokens"
-    | "cacheWriteInputTokens"
-    | "reasoningTokens"
-    | "totalTokens"
-  const sum = (key: UsageKey) =>
-    left[key] === undefined && right[key] === undefined ? undefined : Number(left[key] ?? 0) + Number(right[key] ?? 0)
-
-  return new Usage({
-    inputTokens: sum("inputTokens"),
-    outputTokens: sum("outputTokens"),
-    nonCachedInputTokens: sum("nonCachedInputTokens"),
-    cacheReadInputTokens: sum("cacheReadInputTokens"),
-    cacheWriteInputTokens: sum("cacheWriteInputTokens"),
-    reasoningTokens: sum("reasoningTokens"),
-    totalTokens: sum("totalTokens"),
-    providerMetadata: mergeProviderMetadata(left.providerMetadata, right.providerMetadata),
-  })
 }

 const sameProviderMetadata = (left: ProviderMetadata | undefined, right: ProviderMetadata | undefined) =>
@@ -270,17 +200,17 @@ const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<ToolResultVal
  if (!tool.execute)
    return Effect.succeed({ type: "error" as const, value: `Tool has no execute handler: ${call.name}` })

-  return decodeAndExecute(tool, call).pipe(
+  return decodeAndExecute(tool, call.input).pipe(
    Effect.catchTag("LLM.ToolFailure", (failure) =>
      Effect.succeed({ type: "error" as const, value: failure.message } satisfies ToolResultValue),
    ),
  )
 }

-const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<ToolResultValue, ToolFailure> =>
-  tool._decode(call.input).pipe(
+const decodeAndExecute = (tool: AnyTool, input: unknown): Effect.Effect<ToolResultValue, ToolFailure> =>
+  tool._decode(input).pipe(
    Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })),
-    Effect.flatMap((decoded) => tool.execute!(decoded, { id: call.id, name: call.name })),
+    Effect.flatMap((decoded) => tool.execute!(decoded)),
    Effect.flatMap((value) =>
      tool._encode(value).pipe(
        Effect.mapError(
@@ -1,5 +1,5 @@
 import { Effect, JsonSchema, Schema } from "effect"
-import type { ToolCallPart, ToolDefinition as ToolDefinitionClass } from "./schema"
+import type { ToolDefinition as ToolDefinitionClass } from "./schema"
 import { ToolDefinition, ToolFailure } from "./schema"

 /**
@@ -8,14 +8,9 @@ import { ToolDefinition, ToolFailure } from "./schema"
 * beyond pure data conversion belongs in the handler closure.
 */
 export type ToolSchema<T> = Schema.Codec<T, any, never, never>
-export interface ToolExecuteContext {
-  readonly id: ToolCallPart["id"]
-  readonly name: ToolCallPart["name"]
-}

 export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (
  params: Schema.Schema.Type<Parameters>,
-  context?: ToolExecuteContext,
 ) => Effect.Effect<Schema.Schema.Type<Success>, ToolFailure>

 /**
@@ -66,7 +61,7 @@ type TypedToolConfig = {
 type DynamicToolConfig = {
  readonly description: string
  readonly jsonSchema: JsonSchema.JsonSchema
-  readonly execute?: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
+  readonly execute?: (params: unknown) => Effect.Effect<unknown, ToolFailure>
 }

 /**
@@ -115,7 +110,7 @@ export function make<Parameters extends ToolSchema<any>, Success extends ToolSch
 export function make(config: {
  readonly description: string
  readonly jsonSchema: JsonSchema.JsonSchema
-  readonly execute: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>
+  readonly execute: (params: unknown) => Effect.Effect<unknown, ToolFailure>
 }): AnyExecutableTool
 export function make(config: {
  readonly description: string
@@ -51,7 +51,7 @@ const request = LLM.request({

 const raiseEvent = (event: FakeEvent): import("../src/schema").LLMEvent =>
  event.type === "finish"
-    ? { type: "finish", reason: event.reason }
+    ? { type: "request-finish", reason: event.reason }
    : { type: "text-delta", id: "text-0", text: event.text }

 const fakeProtocol = Protocol.make<FakeBody, FakeEvent, FakeEvent, void>({
@@ -112,8 +112,8 @@ describe("llm route", () => {
      const events = Array.from(yield* llm.stream(request).pipe(Stream.runCollect))
      const response = yield* llm.generate(request)

-      expect(events.map((event) => event.type)).toEqual(["text-delta", "finish"])
-      expect(response.events.map((event) => event.type)).toEqual(["text-delta", "finish"])
+      expect(events.map((event) => event.type)).toEqual(["text-delta", "request-finish"])
+      expect(response.events.map((event) => event.type)).toEqual(["text-delta", "request-finish"])
    }),
  )

@@ -127,7 +127,7 @@ describe("llm constructors", () => {
      LLMResponse.text({
        events: [
          { type: "text-delta", id: "text-0", text: "hi" },
-          { type: "finish", reason: "stop" },
+          { type: "request-finish", reason: "stop" },
        ],
      }),
    ).toBe("hi")
@@ -124,7 +124,7 @@ describe("Anthropic Messages route", () => {
        providerMetadata: { anthropic: { signature: "sig_1" } },
      })
      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
+        type: "request-finish",
        reason: "stop",
        providerMetadata: { anthropic: { stopSequence: "\n\nHuman:" } },
      })
@@ -182,7 +182,7 @@ describe("Anthropic Messages route", () => {
        },
        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "tool-calls",
          providerMetadata: undefined,
          usage,
@@ -275,7 +275,7 @@ describe("Anthropic Messages route", () => {
        providerMetadata: { anthropic: { blockType: "web_search_tool_result" } },
      })
      expect(response.text).toBe("Found it.")
-      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
+      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "stop" })
    }),
  )

@@ -169,12 +169,12 @@ describe("Bedrock Converse route", () => {
      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))

      expect(response.text).toBe("Hello!")
-      const finishes = response.events.filter((event) => event.type === "finish")
+      const finishes = response.events.filter((event) => event.type === "request-finish")
      // Bedrock splits the finish across `messageStop` (carries reason) and
      // `metadata` (carries usage). We consolidate them into a single
-      // terminal `finish` event with both.
+      // terminal `request-finish` event with both.
      expect(finishes).toHaveLength(1)
-      expect(finishes[0]).toMatchObject({ type: "finish", reason: "stop" })
+      expect(finishes[0]).toMatchObject({ type: "request-finish", reason: "stop" })
      expect(response.usage).toMatchObject({
        inputTokens: 5,
        outputTokens: 2,
@@ -213,7 +213,7 @@ describe("Bedrock Converse route", () => {
        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
        { type: "tool-input-delta", id: "tool_1", name: "lookup", text: ':"weather"}' },
      ])
-      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
+      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "tool-calls" })
    }),
  )

@@ -232,7 +232,7 @@ describe("Gemini route", () => {
        { type: "text-end", id: "text-0" },
        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "stop",
          usage,
        },
@@ -291,7 +291,7 @@ describe("Gemini route", () => {
        },
        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "tool-calls",
          usage,
        },
@@ -325,7 +325,7 @@ describe("Gemini route", () => {
        { type: "tool-call", id: "tool_0", name: "lookup", input: { query: "weather" } },
        { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
      ])
-      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
+      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "tool-calls" })
    }),
  )

@@ -344,10 +344,10 @@ describe("Gemini route", () => {
        ),
      )

-      expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(length.events.at(-1)).toMatchObject({ type: "finish", reason: "length" })
-      expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(filtered.events.at(-1)).toMatchObject({ type: "finish", reason: "content-filter" })
+      expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "request-finish"])
+      expect(length.events.at(-1)).toMatchObject({ type: "request-finish", reason: "length" })
+      expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "request-finish"])
+      expect(filtered.events.at(-1)).toMatchObject({ type: "request-finish", reason: "content-filter" })
    }),
  )

@@ -249,7 +249,7 @@ describe("OpenAI Chat route", () => {
        { type: "text-end", id: "text-0" },
        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "stop",
          usage,
        },
@@ -288,7 +288,7 @@ describe("OpenAI Chat route", () => {
          providerMetadata: undefined,
        },
        { type: "step-finish", index: 0, reason: "tool-calls", usage: undefined, providerMetadata: undefined },
-        { type: "finish", reason: "tool-calls", usage: undefined },
+        { type: "request-finish", reason: "tool-calls", usage: undefined },
      ])
    }),
  )
@@ -231,7 +231,7 @@ describe("OpenAI-compatible Chat route", () => {

      expect(response.text).toBe("Hello!")
      expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
-      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
+      expect(response.events.at(-1)).toMatchObject({ type: "request-finish", reason: "stop" })
    }),
  )
 })
@@ -366,7 +366,7 @@ describe("OpenAI Responses route", () => {
          usage,
        },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "stop",
          providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
          usage,
@@ -447,7 +447,7 @@ describe("OpenAI Responses route", () => {
        },
        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
        {
-          type: "finish",
+          type: "request-finish",
          reason: "tool-calls",
          providerMetadata: undefined,
          usage,
@@ -120,8 +120,8 @@ export const runWeatherToolLoop = (request: LLMRequest) =>

 export const expectFinish = (
  events: ReadonlyArray<LLMEvent>,
-  reason: Extract<LLMEvent, { readonly type: "finish" }>["reason"],
-) => expect(events.at(-1)).toMatchObject({ type: "finish", reason })
+  reason: Extract<LLMEvent, { readonly type: "request-finish" }>["reason"],
+) => expect(events.at(-1)).toMatchObject({ type: "request-finish", reason })

 export const expectWeatherToolCall = (response: LLMResponse) =>
  expect(response.toolCalls).toMatchObject([
@@ -129,12 +129,10 @@ export const expectWeatherToolCall = (response: LLMResponse) =>
  ])

 export const expectWeatherToolLoop = (events: ReadonlyArray<LLMEvent>) => {
-  const finishes = events.filter(LLMEvent.is.finish)
-  expect(finishes).toHaveLength(1)
-  expect(finishes[0]?.reason).toBe("stop")
-
-  const stepFinishes = events.filter(LLMEvent.is.stepFinish)
-  expect(stepFinishes.map((event) => event.reason)).toEqual(["tool-calls", "stop"])
+  const finishes = events.filter(LLMEvent.is.requestFinish)
+  expect(finishes).toHaveLength(2)
+  expect(finishes[0]?.reason).toBe("tool-calls")
+  expect(finishes.at(-1)?.reason).toBe("stop")

  const toolCalls = events.filter(LLMEvent.is.toolCall)
  expect(toolCalls).toHaveLength(1)
@@ -274,7 +272,7 @@ export const eventSummary = (events: ReadonlyArray<LLMEvent>) => {
      summary.push({ type: "tool-error", name: event.name, message: event.message })
      continue
    }
-    if (event.type === "finish") {
+    if (event.type === "request-finish") {
      summary.push({ type: "finish", reason: event.reason, usage: usageSummary(event.usage) })
    }
  }
@@ -44,11 +44,6 @@ describe("llm schema", () => {
    expect(() => Schema.decodeUnknownSync(LLMEvent)({ type: "bogus" })).toThrow()
  })

-  test("finish constructors accept usage input", () => {
-    expect(LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 1 } }).usage).toBeInstanceOf(Usage)
-    expect(LLMEvent.finish({ reason: "stop", usage: { outputTokens: 2 } }).usage).toBeInstanceOf(Usage)
-  })
-
  test("content part tagged union exposes guards", () => {
    expect(ContentPart.guards.text({ type: "text", text: "hi" })).toBe(true)
    expect(ContentPart.guards.media({ type: "text", text: "hi" })).toBe(false)
@@ -4,8 +4,7 @@ import { GenerationOptions, LLM, LLMEvent, LLMRequest, LLMResponse, ToolChoice }
 import { LLMClient } from "../src/route"
 import * as AnthropicMessages from "../src/protocols/anthropic-messages"
 import * as OpenAIChat from "../src/protocols/openai-chat"
-import { tool, ToolFailure, type ToolExecuteContext } from "../src/tool"
-import { ToolRuntime } from "../src/tool-runtime"
+import { tool, ToolFailure } from "../src/tool"
 import { it } from "./lib/effect"
 import * as TestToolRuntime from "./lib/tool-runtime"
 import { dynamicResponse, scriptedResponses } from "./lib/http"
@@ -130,7 +129,7 @@ describe("LLMClient tools", () => {
        name: "get_weather",
        result: { type: "json", value: { temperature: 22, condition: "sunny" } },
      })
-      expect(events.at(-1)?.type).toBe("finish")
+      expect(events.at(-1)?.type).toBe("request-finish")
      expect(LLMResponse.text({ events })).toBe("It's sunny in Paris.")
    }),
  )
@@ -149,40 +148,11 @@ describe("LLMClient tools", () => {
        ),
      )

-      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
+      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(1)
      expect(events.find(LLMEvent.is.toolResult)).toMatchObject({ type: "tool-result", id: "call_1" })
    }),
  )

-  it.effect("passes tool call context to execute", () =>
-    Effect.gen(function* () {
-      let context: ToolExecuteContext | undefined
-      const contextual = tool({
-        description: "Capture tool context.",
-        parameters: Schema.Struct({ value: Schema.String }),
-        success: Schema.Struct({ ok: Schema.Boolean }),
-        execute: (_params, ctx) =>
-          Effect.sync(() => {
-            context = ctx
-            return { ok: true }
-          }),
-      })
-      const events = Array.from(
-        yield* TestToolRuntime.runTools({ request: baseRequest, tools: { contextual } }).pipe(
-          Stream.runCollect,
-          Effect.provide(
-            scriptedResponses([
-              sseEvents(toolCallChunk("call_ctx", "contextual", '{"value":"x"}'), finishChunk("tool_calls")),
-            ]),
-          ),
-        ),
-      )
-
-      expect(events.some(LLMEvent.is.toolResult)).toBe(true)
-      expect(context).toEqual({ id: "call_ctx", name: "contextual" })
-    }),
-  )
-
  it.effect("can expose tool schemas without executing tool calls", () =>
    Effect.gen(function* () {
      const layer = scriptedResponses([
@@ -349,7 +319,7 @@ describe("LLMClient tools", () => {
        "text-delta",
        "text-end",
        "step-finish",
-        "finish",
+        "request-finish",
      ])
      expect(LLMResponse.text({ events })).toBe("Done.")
    }),
@@ -373,57 +343,7 @@ describe("LLMClient tools", () => {
        ),
      )

-      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
-      expect(events.filter(LLMEvent.is.stepStart).map((event) => event.index)).toEqual([0, 1])
-      expect(events.filter(LLMEvent.is.stepFinish).map((event) => event.index)).toEqual([0, 1])
-    }),
-  )
-
-  it.effect("emits one final finish with aggregate usage", () =>
-    Effect.gen(function* () {
-      let calls = 0
-      const events = Array.from(
-        yield* ToolRuntime.stream({
-          request: baseRequest,
-          tools: { get_weather },
-          stopWhen: ToolRuntime.stepCountIs(2),
-          stream: () =>
-            Stream.fromIterable<LLMEvent>(
-              calls++ === 0
-                ? [
-                    LLMEvent.stepStart({ index: 0 }),
-                    LLMEvent.toolCall({ id: "call_1", name: "get_weather", input: { city: "Paris" } }),
-                    LLMEvent.stepFinish({
-                      index: 0,
-                      reason: "tool-calls",
-                      usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
-                    }),
-                    LLMEvent.finish({
-                      reason: "tool-calls",
-                      usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
-                    }),
-                  ]
-                : [
-                    LLMEvent.stepStart({ index: 0 }),
-                    LLMEvent.textDelta({ id: "text_1", text: "Done." }),
-                    LLMEvent.stepFinish({
-                      index: 0,
-                      reason: "stop",
-                      usage: { inputTokens: 4, outputTokens: 5, totalTokens: 9 },
-                    }),
-                    LLMEvent.finish({ reason: "stop", usage: { inputTokens: 4, outputTokens: 5, totalTokens: 9 } }),
-                  ],
-            ),
-        }).pipe(Stream.runCollect),
-      )
-
-      expect(events.filter(LLMEvent.is.stepFinish).map((event) => event.index)).toEqual([0, 1])
-      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
-      expect(events.find(LLMEvent.is.finish)?.usage).toMatchObject({
-        inputTokens: 5,
-        outputTokens: 7,
-        totalTokens: 12,
-      })
+      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(2)
    }),
  )

@@ -442,7 +362,7 @@ describe("LLMClient tools", () => {
        }).pipe(Stream.runCollect, Effect.provide(layer)),
      )

-      expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
+      expect(events.filter(LLMEvent.is.requestFinish)).toHaveLength(1)
      expect(events.find(LLMEvent.is.toolResult)).toMatchObject({ type: "tool-result", id: "call_1" })
    }),
  )
@@ -197,7 +197,7 @@ Most of the original facade-removal backlog is already done. The practical remai
 ## Checklist

 - [ ] `src/npm/index.ts` (`Npm`) - still exports runtime-backed async facade helpers on top of `Npm.Service`
- [ ] `src/cli/cmd/tui/config/tui.ts` (`TuiConfig`) - still exports runtime-backed async facade helpers on top of `TuiConfig.Service`
+- [x] `src/cli/cmd/tui/config/tui.ts` (`TuiConfig`) - facades removed
 - [x] `src/session/session.ts` / `src/session/prompt.ts` / `src/session/revert.ts` / `src/session/summary.ts` - service-local facades removed
 - [x] `src/agent/agent.ts` (`Agent`) - service-local facades removed
 - [x] `src/permission/index.ts` (`Permission`) - service-local facades removed
@@ -40,7 +40,7 @@ export type SessionInfo = {
  variant: string | undefined
 }

-type Config = Awaited<ReturnType<typeof TuiConfig.get>>
+type Config = TuiConfig.Resolved
 type BootService = {
  readonly resolveModelInfo: (
    sdk: RunInput["sdk"],
@@ -60,8 +60,14 @@ const configTask: { current?: Promise<Config> } = {}

 class Service extends Context.Service<Service, BootService>()("@opencode/RunBoot") {}

+// Exposed on `TuiConfigLoader` so tests can mock without depending on the
+// TuiConfig namespace; production calls the TuiConfig per-service runtime.
+export const TuiConfigLoader = {
+  get: () => TuiConfig.runPromise((svc) => svc.get()),
+}
+
 function loadConfig() {
-  return reusePendingTask(configTask, () => TuiConfig.get())
+  return reusePendingTask(configTask, () => TuiConfigLoader.get())
 }

 function emptyModelInfo(): ModelInfo {
@@ -66,7 +66,7 @@ export const AttachCommand = cmd({
        }
      })()
      const headers = ServerAuth.headers({ password: args.password, username: args.username })
-      const config = await TuiConfig.get()
+      const config = await TuiConfig.runPromise((svc) => svc.get())
      const { tui } = await import("./app")

      try {
@@ -14,9 +14,9 @@ import { Global } from "@opencode-ai/core/global"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { CurrentWorkingDirectory } from "./cwd"
 import { ConfigPlugin } from "@/config/plugin"
+import { defineService } from "@/effect/run-service"
 import { TuiKeybind } from "./keybind"
 import { InstallationLocal, InstallationVersion } from "@opencode-ai/core/installation/version"
-import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import { Filesystem } from "@/util/filesystem"
 import * as Log from "@opencode-ai/core/util/log"
 import { ConfigVariable } from "@/config/variable"
@@ -246,12 +246,4 @@ export const layer = Layer.effect(

 export const defaultLayer = layer.pipe(Layer.provide(Npm.defaultLayer), Layer.provide(AppFileSystem.defaultLayer))

-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export async function waitForDependencies() {
-  await runPromise((svc) => svc.waitForDependencies())
-}
-
-export async function get() {
-  return runPromise((svc) => svc.get())
-}
+export const { runPromise, runFork, runCallback } = defineService(Service, defaultLayer)
@@ -42,6 +42,11 @@ import { createCommandShim } from "./command-shim"

 ensureRuntimePluginSupport({ additional: keymapRuntimeModules })

+// Exposed as a separate function so tests can mock it without touching the
+// TuiConfig service. Production callers wait on plugin install fibers via the
+// TuiConfig per-service runtime; tests replace this with a no-op.
+export const waitForDependencies = () => TuiConfig.runPromise((svc) => svc.waitForDependencies())
+
 type PluginLoad = {
  options: ConfigPlugin.Options | undefined
  spec: string
@@ -837,7 +842,7 @@ async function addPluginBySpec(state: RuntimeState | undefined, raw: string) {
    state.pending.delete(spec)
    return true
  }
-  const ready = await resolveExternalPlugins([cfg], () => TuiConfig.waitForDependencies()).catch((error) => {
+  const ready = await resolveExternalPlugins([cfg], () => waitForDependencies()).catch((error) => {
    fail("failed to add tui plugin", { path: next, error })
    return [] as PluginLoad[]
  })
@@ -1049,7 +1054,7 @@ async function load(input: { api: Api; config: TuiConfig.Resolved }) {
      })
    }

-    const ready = await resolveExternalPlugins(records, () => TuiConfig.waitForDependencies())
+    const ready = await resolveExternalPlugins(records, () => waitForDependencies())
    await addExternalPluginEntries(next, ready)

    applyInitialPluginEnabledState(next, config)
@@ -187,7 +187,7 @@ export const TuiThreadCommand = cmd({
      }

      const prompt = await input(args.prompt)
-      const config = await TuiConfig.get()
+      const config = await TuiConfig.runPromise((svc) => svc.get())

      const network = resolveNetworkOptionsNoConfig(args)
      const external =
@@ -57,7 +57,7 @@ export const UninstallCommand = {
    UI.empty()
    prompts.intro("Uninstall OpenCode")

-    const method = await Installation.method()
+    const method = await Installation.runPromise((svc) => svc.method())
    prompts.log.info(`Installation method: ${method}`)

    const targets = await collectRemovalTargets(args, method)
@@ -3,6 +3,7 @@ import { UI } from "../ui"
 import * as prompts from "@clack/prompts"
 import { Installation } from "../../installation"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { Effect } from "effect"

 export const UpgradeCommand = {
  command: "upgrade [target]",
@@ -25,7 +26,7 @@ export const UpgradeCommand = {
    UI.println(UI.logo("  "))
    UI.empty()
    prompts.intro("Upgrade")
-    const detectedMethod = await Installation.method()
+    const detectedMethod = await Installation.runPromise((svc) => svc.method())
    const method = (args.method as Installation.Method) ?? detectedMethod
    if (method === "unknown") {
      prompts.log.error(`opencode is installed to ${process.execPath} and may be managed by a package manager`)
@@ -43,7 +44,9 @@ export const UpgradeCommand = {
      }
    }
    prompts.log.info("Using method: " + method)
-    const target = args.target ? args.target.replace(/^v/, "") : await Installation.latest()
+    const target = args.target
+      ? args.target.replace(/^v/, "")
+      : await Installation.runPromise((svc) => svc.latest())

    if (InstallationVersion === target) {
      prompts.log.warn(`opencode upgrade skipped: ${target} is already installed`)
@@ -54,7 +57,12 @@ export const UpgradeCommand = {
    prompts.log.info(`From ${InstallationVersion} → ${target}`)
    const spinner = prompts.spinner()
    spinner.start("Upgrading...")
-    const err = await Installation.upgrade(method, target).catch((err) => err)
+    const err = await Installation.runPromise((installation) =>
+      installation.upgrade(method, target).pipe(
+        Effect.map(() => undefined as Installation.UpgradeFailedError | Error | undefined),
+        Effect.catch((error) => Effect.succeed(error as Installation.UpgradeFailedError | Error | undefined)),
+      ),
+    ).catch((err: Error) => err)
    if (err) {
      spinner.stop("Upgrade failed", 1)
      if (err instanceof Installation.UpgradeFailedError) {
@@ -4,30 +4,40 @@ import { AppRuntime } from "@/effect/app-runtime"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Installation } from "@/installation"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { Effect } from "effect"

 export async function upgrade() {
-  const config = await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.getGlobal()))
-  if (config.autoupdate === false || Flag.OPENCODE_DISABLE_AUTOUPDATE) return
-  const method = await Installation.method()
-  const latest = await Installation.latest(method).catch(() => {})
-  if (!latest) return
+  await AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const cfg = yield* Config.Service
+      const installation = yield* Installation.Service
+      const bus = yield* Bus.Service

-  if (Flag.OPENCODE_ALWAYS_NOTIFY_UPDATE) {
-    await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
-    return
-  }
+      const config = yield* cfg.getGlobal()
+      if (config.autoupdate === false || Flag.OPENCODE_DISABLE_AUTOUPDATE) return
+      const method = yield* installation.method()
+      const latest = yield* installation.latest(method).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      if (!latest) return

-  if (InstallationVersion === latest) return
+      if (Flag.OPENCODE_ALWAYS_NOTIFY_UPDATE) {
+        yield* bus.publish(Installation.Event.UpdateAvailable, { version: latest })
+        return
+      }

-  const kind = Installation.getReleaseType(InstallationVersion, latest)
+      if (InstallationVersion === latest) return

-  if (config.autoupdate === "notify" || kind !== "patch") {
-    await Bus.publish(Installation.Event.UpdateAvailable, { version: latest })
-    return
-  }
+      const kind = Installation.getReleaseType(InstallationVersion, latest)

-  if (method === "unknown") return
-  await Installation.upgrade(method, latest)
-    .then(() => Bus.publish(Installation.Event.Updated, { version: latest }))
-    .catch(() => {})
+      if (config.autoupdate === "notify" || kind !== "patch") {
+        yield* bus.publish(Installation.Event.UpdateAvailable, { version: latest })
+        return
+      }
+
+      if (method === "unknown") return
+      yield* installation.upgrade(method, latest).pipe(
+        Effect.flatMap(() => bus.publish(Installation.Event.Updated, { version: latest })),
+        Effect.catch(() => Effect.void),
+      )
+    }),
+  )
 }
@@ -55,3 +55,16 @@ export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Laye
      getRuntime().runCallback(attach(service.use(fn))),
  }
 }
+
+/**
+ * Composition of `makeRuntime` for services that own their own runtime. Returns
+ * the service class, the supplied layer, and the per-service runtime methods
+ * (`runPromise`, `runFork`, etc.). Each runtime uses the shared `memoMap`, so
+ * dependencies are built once across all `defineService` runtimes.
+ *
+ * Use for services that don't belong in `AppLayer` (TUI-specific config, etc.)
+ * or for services where call sites want to bypass `AppRuntime` provisioning.
+ */
+export function defineService<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
+  return { Service: service, layer, ...makeRuntime(service, layer) }
+}
@@ -7,10 +7,10 @@ import path from "path"
 import { BusEvent } from "@/bus/bus-event"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import * as Log from "@opencode-ai/core/util/log"
-import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import semver from "semver"
 import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
 import { NpmConfig } from "@opencode-ai/core/npm-config"
+import { defineService } from "@/effect/run-service"

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

@@ -325,10 +325,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(CrossSpawnSpawner.defaultLayer),
 )

-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export const latest = (...args: Parameters<Interface["latest"]>) => runPromise((s) => s.latest(...args))
-export const method = () => runPromise((s) => s.method())
-export const upgrade = (...args: Parameters<Interface["upgrade"]>) => runPromise((s) => s.upgrade(...args))
+export const { runPromise, runFork, runCallback } = defineService(Service, defaultLayer)

 export * as Installation from "."
@@ -16,7 +16,6 @@ import { Effect, Layer, Context, Schema } from "effect"
 import * as DateTime from "effect/DateTime"
 import { InstanceState } from "@/effect/instance-state"
 import { isOverflow as overflow, usable } from "./overflow"
-import { makeRuntime } from "@/effect/run-service"
 import { serviceUse } from "@/effect/service-use"
 import { SyncEvent } from "@/sync"
 import { SessionEvent } from "@/v2/session-event"
@@ -649,14 +648,4 @@ export const defaultLayer = Layer.suspend(() =>
  ),
 )

-const { runPromise } = makeRuntime(Service, defaultLayer)
-
-export async function isOverflow(input: { tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
-  return runPromise((svc) => svc.isOverflow(input))
-}
-
-export async function prune(input: { sessionID: SessionID }) {
-  return runPromise((svc) => svc.prune(input))
-}
-
 export * as SessionCompaction from "./compaction"
@@ -3,10 +3,15 @@ import type { KeyEvent, Renderable } from "@opentui/core"
 import type { Binding } from "@opentui/keymap"
 import { createBindingLookup } from "@opentui/keymap/extras"
 import { OpencodeClient, type Provider } from "@opencode-ai/sdk/v2"
-import { TuiConfig, type Resolved } from "@/cli/cmd/tui/config/tui"
+import { type Resolved } from "@/cli/cmd/tui/config/tui"
 import { formatBindings } from "@/cli/cmd/run/keymap.shared"
 import { TuiKeybind } from "@/cli/cmd/tui/config/keybind"
-import { resolveDiffStyle, resolveFooterKeybinds, resolveModelInfo } from "@/cli/cmd/run/runtime.boot"
+import {
+  TuiConfigLoader,
+  resolveDiffStyle,
+  resolveFooterKeybinds,
+  resolveModelInfo,
+} from "@/cli/cmd/run/runtime.boot"

 type RunBinding = Binding<Renderable, KeyEvent>

@@ -108,7 +113,7 @@ describe("run runtime boot", () => {
  })

  test("reads footer keybinds from resolved keybind config", async () => {
-    spyOn(TuiConfig, "get").mockResolvedValue(
+    spyOn(TuiConfigLoader, "get").mockResolvedValue(
      config({
        leader: "ctrl+g",
        bindings: {
@@ -139,7 +144,7 @@ describe("run runtime boot", () => {
  })

  test("falls back to default keybinds when config load fails", async () => {
-    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
+    spyOn(TuiConfigLoader, "get").mockRejectedValue(new Error("boom"))

    const result = await resolveFooterKeybinds()

@@ -156,11 +161,11 @@ describe("run runtime boot", () => {
  })

  test("reads diff style and falls back to auto", async () => {
-    spyOn(TuiConfig, "get").mockResolvedValue(config({ diff_style: "stacked" }))
+    spyOn(TuiConfigLoader, "get").mockResolvedValue(config({ diff_style: "stacked" }))
    await expect(resolveDiffStyle()).resolves.toBe("stacked")

    mock.restore()
-    spyOn(TuiConfig, "get").mockRejectedValue(new Error("boom"))
+    spyOn(TuiConfigLoader, "get").mockRejectedValue(new Error("boom"))
    await expect(resolveDiffStyle()).resolves.toBe("auto")
  })

@@ -5,8 +5,6 @@ import { pathToFileURL } from "url"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
-
 const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")

 test("adds tui plugin at runtime from spec", async () => {
@@ -35,7 +33,7 @@ test("adds tui plugin at runtime from spec", async () => {
  const config = createTuiResolvedConfig({
    plugin: [],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -77,7 +75,7 @@ test("retries runtime add for file plugins after dependency wait", async () => {
  const config = createTuiResolvedConfig({
    plugin: [],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockImplementation(async () => {
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockImplementation(async () => {
    await Bun.write(
      path.join(tmp.extra.mod, "index.ts"),
      `export default {
@@ -5,8 +5,6 @@ import { pathToFileURL } from "url"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
-
 const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")

 test("installs plugin without loading it", async () => {
@@ -54,7 +52,7 @@ test("installs plugin without loading it", async () => {
  const config = createTuiResolvedConfig({
    plugin: [],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const api = createTuiPluginApi({
    state: {
@@ -5,7 +5,6 @@ import { pathToFileURL } from "url"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
 import { Npm } from "@opencode-ai/core/npm"

 const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
@@ -55,7 +54,7 @@ test("loads npm tui plugin from package ./tui export", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })

@@ -116,7 +115,7 @@ test("does not use npm package exports dot for tui entry", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })

@@ -178,7 +177,7 @@ test("rejects npm tui export that resolves outside plugin directory", async () =
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })

@@ -240,7 +239,7 @@ test("rejects npm tui plugin that exports server and tui together", async () =>
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })

@@ -298,7 +297,7 @@ test("does not use npm package main for tui entry", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })
  const warn = spyOn(console, "warn").mockImplementation(() => {})
@@ -363,7 +362,7 @@ test("does not use directory package main for tui entry", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -410,7 +409,7 @@ test("uses directory index fallback for tui when package.json is missing", async
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -467,7 +466,7 @@ test("uses npm package name when tui plugin id is omitted", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const install = spyOn(Npm, "add").mockResolvedValue({ directory: tmp.extra.mod, entrypoint: undefined })

@@ -5,8 +5,6 @@ import { pathToFileURL } from "url"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
-
 const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")

 test("skips external tui plugins in pure mode", async () => {
@@ -48,7 +46,7 @@ test("skips external tui plugins in pure mode", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -7,7 +7,6 @@ import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig, mockTuiRuntime } from "../../fixture/tui-runtime"
 import { Global } from "@opencode-ai/core/global"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
 import { Filesystem } from "@/util/filesystem"

 const { allThemes, addTheme } = await import("../../../src/cli/cmd/tui/context/theme")
@@ -339,7 +338,7 @@ export default {
    },
  })
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()

  try {
    expect(addTheme(tmp.extra.preloadedThemeName, { theme: { primary: "#303030" } })).toBe(true)
@@ -539,7 +538,7 @@ test("continues loading when a plugin is missing config metadata", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -784,7 +783,7 @@ test("auto-disposes plugin keymap layers", async () => {
      }
    },
  } as NonNullable<Parameters<typeof createTuiPluginApi>[0]>["keymap"]
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -830,7 +829,7 @@ test("plugin keymap proxy preserves real keymap receiver", async () => {
  })

  const harness = createTestKeymap({ defaultKeys: true })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -893,7 +892,7 @@ test("auto-disposes plugin keymap transformers", async () => {
    prependCommandTransformer: track,
    appendCommandTransformer: track,
  } as unknown as NonNullable<Parameters<typeof createTuiPluginApi>[0]>["keymap"]
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -950,7 +949,7 @@ test("manual onDispose for plugin keymap layers stays idempotent", async () => {
      }
    },
  } as NonNullable<Parameters<typeof createTuiPluginApi>[0]>["keymap"]
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)

  try {
@@ -1021,7 +1020,7 @@ 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 wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()

  const mkApi = () =>
    createTuiPluginApi({
@@ -5,8 +5,6 @@ import { pathToFileURL } from "url"
 import { tmpdir } from "../../fixture/fixture"
 import { createTuiPluginApi } from "../../fixture/tui-plugin"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
-
 const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")

 test("toggles plugin runtime state by exported id", async () => {
@@ -53,7 +51,7 @@ test("toggles plugin runtime state by exported id", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const api = createTuiPluginApi()

@@ -130,7 +128,7 @@ test("kv plugin_enabled overrides tui config on startup", async () => {
      },
    ],
  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const api = createTuiPluginApi()
  api.kv.set("plugin_enabled", {
@@ -160,7 +158,7 @@ test("kv plugin_enabled overrides tui config on startup", async () => {
 test("loads disabled-by-default internal plugin inactive and activates on demand", async () => {
  await using tmp = await tmpdir()
  const config = createTuiResolvedConfig()
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
  const api = createTuiPluginApi()

@@ -2,6 +2,7 @@ import { spyOn } from "bun:test"
 import path from "path"
 import { createBindingLookup } from "@opentui/keymap/extras"
 import { TuiConfig } from "../../src/cli/cmd/tui/config/tui"
+import { TuiPluginRuntime } from "../../src/cli/cmd/tui/plugin/runtime"
 import { TuiKeybind } from "../../src/cli/cmd/tui/config/keybind"

 type PluginSpec = string | [string, Record<string, unknown>]
@@ -34,7 +35,7 @@ export function mockTuiRuntime(dir: string, plugin: PluginSpec[], opts?: { plugi
    scope: "local" as const,
    source: path.join(dir, "tui.json"),
  }))
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const wait = spyOn(TuiPluginRuntime, "waitForDependencies").mockResolvedValue()
  const cwd = spyOn(process, "cwd").mockImplementation(() => dir)

  const config = createTuiResolvedConfig({
@@ -1,19 +1,15 @@
 import { describe, expect, test } from "bun:test"
 import path from "path"
+import fs from "fs/promises"
 import { pathToFileURL } from "url"
 import { Effect, Layer } from "effect"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { provideInstance, TestInstance, tmpdirScoped } from "../fixture/fixture"
+import { provideTestInstance, tmpdir } from "../fixture/fixture"
 import { ProviderAuth } from "@/provider/auth"
 import { ProviderID } from "../../src/provider/schema"
 import { Plugin } from "@/plugin"
 import { Auth } from "@/auth"
 import { Bus } from "@/bus"
 import { TestConfig } from "../fixture/config"
-import { testEffect } from "../lib/effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-
-const it = testEffect(Layer.mergeAll(CrossSpawnSpawner.defaultLayer, AppFileSystem.defaultLayer))

 function layer(directory: string, plugins: string[]) {
  return ProviderAuth.layer.pipe(
@@ -41,15 +37,13 @@ function layer(directory: string, plugins: string[]) {
 }

 describe("plugin.auth-override", () => {
-  it.instance(
-    "user plugin overrides built-in github-copilot auth",
-    () =>
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const fs = yield* AppFileSystem.Service
-        const pluginDir = path.join(tmp.directory, ".opencode", "plugin")
+  test("user plugin overrides built-in github-copilot auth", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const pluginDir = path.join(dir, ".opencode", "plugin")
+        await fs.mkdir(pluginDir, { recursive: true })

-        yield* fs.writeWithDirs(
+        await Bun.write(
          path.join(pluginDir, "custom-copilot-auth.ts"),
          [
            "export default {",
@@ -67,26 +61,37 @@ describe("plugin.auth-override", () => {
            "",
          ].join("\n"),
        )
+      },
+    })

-        const plain = yield* tmpdirScoped({ git: true })
-        const plugin = pathToFileURL(path.join(pluginDir, "custom-copilot-auth.ts")).href
-        const methods = yield* ProviderAuth.Service.use((svc) => svc.methods()).pipe(
-          Effect.provide(layer(tmp.directory, [plugin])),
-        )
-        const plainMethods = yield* ProviderAuth.Service.use((svc) => svc.methods()).pipe(
-          Effect.provide(layer(plain, [])),
-          provideInstance(plain),
-        )
+    await using plain = await tmpdir()

-        const copilot = methods[ProviderID.make("github-copilot")]
-        expect(copilot).toBeDefined()
-        expect(copilot.length).toBe(1)
-        expect(copilot[0].label).toBe("Test Override Auth")
-        expect(plainMethods[ProviderID.make("github-copilot")][0].label).not.toBe("Test Override Auth")
+    const plugin = pathToFileURL(path.join(tmp.path, ".opencode", "plugin", "custom-copilot-auth.ts")).href
+    const [methods, plainMethods] = await Promise.all([
+      provideTestInstance({
+        directory: tmp.path,
+        fn: async () => {
+          return Effect.runPromise(
+            ProviderAuth.Service.use((svc) => svc.methods()).pipe(Effect.provide(layer(tmp.path, [plugin]))),
+          )
+        },
      }),
-    { git: true },
-    30000,
-  )
+      provideTestInstance({
+        directory: plain.path,
+        fn: async () => {
+          return Effect.runPromise(
+            ProviderAuth.Service.use((svc) => svc.methods()).pipe(Effect.provide(layer(plain.path, []))),
+          )
+        },
+      }),
+    ])
+
+    const copilot = methods[ProviderID.make("github-copilot")]
+    expect(copilot).toBeDefined()
+    expect(copilot.length).toBe(1)
+    expect(copilot[0].label).toBe("Test Override Auth")
+    expect(plainMethods[ProviderID.make("github-copilot")][0].label).not.toBe("Test Override Auth")
+  }, 30000)
 })

 const file = path.join(import.meta.dir, "../../src/plugin/index.ts")