fix(app): hide built-in plugins

.opencode/skills/opencode-dev/SKILL.md

@@ -185,33 +185,6 @@ pmap -x <pid> | sort -k3 -nr | head -25
 
 Heap serialization itself can temporarily increase RSS and allocator high-water marks, so record `ps`/`smaps_rollup` both before and after capture. Large anonymous mappings with a comparatively small live heap require native-allocation or allocator investigation; they cannot be explained from JavaScript retainer paths alone.
 
-## CPU profiles
-
-The CLI installs a `SIGPROF` listener on non-Windows processes in `packages/cli/src/cpu-profile.ts`. One signal starts a ten-second CPU profile and stops it automatically; additional signals are ignored while a profile is active. There is no CPU profile CLI flag or environment variable.
-
-1. Get the PID from the health endpoint. For shared-service performance, target the server PID returned here rather than the short wrapper or TUI process:
-
-```bash
-opencode2 api get /api/health
-```
-
-Use `bun dev api get /api/health` instead when targeting the local/dev channel.
-
-2. Start the capture:
-
-```bash
-kill -PROF <server-pid>
-```
-
-3. Wait for `CPU profile written` in the channel's log before opening the file. Profiles are written to the same log directory as `cpu-<pid>-<timestamp>.cpuprofile`; the log's `path=` field is authoritative:
-
-```bash
-grep 'CPU profile' ~/.local/share/opencode/log/opencode.log | tail
-find ~/.local/share/opencode/log -maxdepth 1 -name 'cpu-<server-pid>-*.cpuprofile' -printf '%T@ %s %p\n' | sort -nr | head
-```
-
-Use `opencode-local.log` for a local/dev process. Load the completed `.cpuprofile` in Chrome DevTools or another V8 CPU profile viewer and inspect the hottest functions, call stacks, and self time during the controlled workload.
-
 ## Debugger
 
 - To debug the V2 CLI or TUI with Bun's inspector, launch the CLI entrypoint through Terminal Control with an inspector URL, then attach a debugger to that URL:

packages/ai/AGENTS.md

@@ -193,7 +193,7 @@ If you find yourself copying a 3-to-5-line snippet between two protocols, lift i
 
 `LLMRequest.system` is the initial privileged prompt that applies ahead of the conversation. `Message.system(...)` is a separate, provider-neutral chronological operator update inside `LLMRequest.messages`; it applies only from its position in history onward and accepts text content only.
 
-Native chronological system messages are route/model-specific. Open Responses lowers them to standard `developer` messages, while Anthropic Messages lowers them to native system messages for Claude Opus 4.8 (`claude-opus-4-8`). Other routes and models intentionally lower the update in place into ordinary user-compatible text using this stable escaped representation:
+Native chronological system messages are route/model-specific. Anthropic Messages lowers them natively for Claude Opus 4.8 (`claude-opus-4-8`). Other routes and models intentionally lower the update in place into ordinary user-compatible text using this stable escaped representation:
 
 ```text
 <system-update>

packages/ai/src/protocols/open-responses.ts

@@ -90,7 +90,6 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
 
 export const InputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
-  Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
     role: Schema.tag("assistant"),
@@ -141,11 +140,6 @@ export const Tool = Schema.Struct({
 export const ToolChoice = Schema.Union([
   Schema.Literals(["auto", "none", "required"]),
   Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
-  Schema.Struct({
-    type: Schema.tag("allowed_tools"),
-    mode: Schema.Literals(["auto", "none", "required"]),
-    tools: Schema.Array(Schema.Struct({ type: Schema.tag("function"), name: Schema.String })),
-  }),
 ])
 
 // Fields shared between the HTTP body and the WebSocket `response.create`
@@ -159,7 +153,6 @@ export const coreFields = {
   tools: optionalArray(Tool),
   tool_choice: Schema.optional(ToolChoice),
   store: Schema.optional(Schema.Boolean),
-  truncation: Schema.optional(OpenResponsesOptions.TruncationSchema),
   service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
   prompt_cache_key: Schema.optional(Schema.String),
   include: optionalArray(OpenResponsesOptions.ResponseIncludableSchema),
@@ -175,8 +168,6 @@ export const coreFields = {
     }),
   ),
   max_output_tokens: Schema.optional(Schema.Number),
-  max_tool_calls: Schema.optional(Schema.Int),
-  parallel_tool_calls: Schema.optional(Schema.Boolean),
   temperature: Schema.optional(Schema.Number),
   top_p: Schema.optional(Schema.Number),
 }
@@ -448,10 +439,14 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 
   for (const message of request.messages) {
     if (message.role === "system") {
-      input.push({
-        role: "developer",
-        content: ProviderShared.joinText(yield* ProviderShared.systemUpdateText(extension.name, message)),
-      })
+      const part = yield* ProviderShared.wrappedSystemUpdate(extension.name, message)
+      const previous = input.at(-1)
+      if (previous && "role" in previous && previous.role === "user")
+        input[input.length - 1] = {
+          role: "user",
+          content: [...previous.content, { type: "input_text", text: part.text }],
+        }
+      else input.push({ role: "user", content: [{ type: "input_text", text: part.text }] })
       continue
     }
 
@@ -585,19 +580,6 @@ const lowerOptions = (request: LLMRequest) => {
       : {}),
     ...(options.textVerbosity ? { text: { verbosity: options.textVerbosity } } : {}),
     ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
-    ...(options.maxToolCalls !== undefined ? { max_tool_calls: options.maxToolCalls } : {}),
-    ...(options.parallelToolCalls !== undefined ? { parallel_tool_calls: options.parallelToolCalls } : {}),
-    ...(options.truncation ? { truncation: options.truncation } : {}),
-  }
-}
-
-const allowedToolChoice = (request: LLMRequest) => {
-  const allowed = OpenResponsesOptions.resolve(request).allowedTools
-  if (!allowed) return undefined
-  return {
-    type: "allowed_tools" as const,
-    mode: allowed.mode,
-    tools: allowed.toolNames.map((name) => ({ type: "function" as const, name })),
   }
 }
 
@@ -620,9 +602,7 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),
             ),
           ),
-    tool_choice:
-      allowedToolChoice(request) ??
-      (request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined),
+    tool_choice: request.toolChoice ? yield* lowerToolChoice(extension.name, request.toolChoice) : undefined,
     stream: true as const,
     max_output_tokens: generation?.maxTokens,
     temperature: generation?.temperature,

packages/ai/src/protocols/openai-responses.ts

@@ -121,8 +121,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request:
         : yield* Effect.forEach(request.tools, (tool) =>
             lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
           ),
-    tool_choice:
-      body.tool_choice ?? (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
+    tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
   } satisfies OpenAIResponsesBody
 })
 

packages/ai/src/protocols/utils/open-responses-options.ts

@@ -1,4 +1,4 @@
-import { Option, Schema } from "effect"
+import { Schema } from "effect"
 import { TextVerbosity, type LLMRequest } from "../../schema/index.js"
 
 export const ResponseIncludables = [
@@ -11,62 +11,52 @@ export const ResponseIncludables = [
   "reasoning.encrypted_content",
   "message.output_text.logprobs",
 ] as const
-export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {})
+export type ResponseIncludable = (typeof ResponseIncludables)[number]
 
 export const ServiceTiers = ["auto", "default", "flex", "priority"] as const
 export type ServiceTier = (typeof ServiceTiers)[number]
 
-export const Truncations = ["auto", "disabled"] as const
-export type Truncation = (typeof Truncations)[number]
+const TEXT_VERBOSITY = new Set<string>(["low", "medium", "high"])
+const INCLUDABLES = new Set<string>(ResponseIncludables)
+const SERVICE_TIERS = new Set<string>(ServiceTiers)
+
+const isTextVerbosity = (value: unknown): value is Schema.Schema.Type<typeof TextVerbosity> =>
+  typeof value === "string" && TEXT_VERBOSITY.has(value)
+
+const isServiceTier = (value: unknown): value is ServiceTier => typeof value === "string" && SERVICE_TIERS.has(value)
 
 export const ReasoningEffort = Schema.String
 export const TextVerbositySchema = TextVerbosity
-export const ResponseIncludableSchema = Schema.declare<ResponseIncludable>(
-  (value): value is ResponseIncludable => typeof value === "string",
-  { title: "ResponseIncludable" },
-)
+export const ResponseIncludableSchema = Schema.Literals(ResponseIncludables)
 export const ServiceTierSchema = Schema.Literals(ServiceTiers)
-export const TruncationSchema = Schema.Literals(Truncations)
 
-export const AllowedTools = Schema.Struct({
-  toolNames: Schema.Array(Schema.String),
-  mode: Schema.optional(Schema.Literals(["auto", "none", "required"])),
-})
-export type AllowedTools = typeof AllowedTools.Type
-
-export const Options = Schema.Struct({
-  instructions: Schema.optional(Schema.String),
-  store: Schema.optional(Schema.Boolean),
-  reasoningEffort: Schema.optional(ReasoningEffort),
-  reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
-  include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
-  textVerbosity: Schema.optional(TextVerbositySchema),
-  serviceTier: Schema.optional(ServiceTierSchema),
-  truncation: Schema.optional(TruncationSchema),
-  allowedTools: Schema.optional(AllowedTools),
-  maxToolCalls: Schema.optional(Schema.Int),
-  parallelToolCalls: Schema.optional(Schema.Boolean),
-})
-export type Options = typeof Options.Type
-
-export type Resolved = Omit<Options, "allowedTools"> & {
-  readonly allowedTools?: AllowedTools & { readonly mode: NonNullable<AllowedTools["mode"]> }
+export interface Resolved {
+  readonly instructions?: string
+  readonly store?: boolean
+  readonly reasoningEffort?: string
+  readonly reasoningSummary?: "auto" | "concise" | "detailed"
+  readonly include?: ReadonlyArray<ResponseIncludable>
+  readonly textVerbosity?: Schema.Schema.Type<typeof TextVerbosity>
+  readonly serviceTier?: ServiceTier
 }
 
-const decodeOptions = Schema.decodeUnknownOption(Options)
-
 export const resolve = (request: LLMRequest): Resolved => {
-  const input = Option.getOrUndefined(
-    decodeOptions(request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"]),
-  )
-  if (!input) return {}
+  const input = request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"]
+  const include = Array.isArray(input?.include)
+    ? input.include.filter((entry): entry is ResponseIncludable => INCLUDABLES.has(entry))
+    : []
+  const reasoningSummary = input?.reasoningSummary
   return {
-    ...input,
-    include: input.include?.length ? input.include : undefined,
-    allowedTools:
-      input.allowedTools && input.allowedTools.toolNames.length > 0
-        ? { ...input.allowedTools, mode: input.allowedTools.mode ?? "auto" }
+    instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
+    store: typeof input?.store === "boolean" ? input.store : undefined,
+    reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
+    reasoningSummary:
+      reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
+        ? reasoningSummary
         : undefined,
+    include: include.length > 0 ? include : undefined,
+    textVerbosity: isTextVerbosity(input?.textVerbosity) ? input.textVerbosity : undefined,
+    serviceTier: isServiceTier(input?.serviceTier) ? input.serviceTier : undefined,
   }
 }
 

packages/ai/src/providers/open-responses-options.ts

@@ -1,7 +1,16 @@
-import type { Options } from "../protocols/utils/open-responses-options.js"
-import type { ProviderOptions } from "../schema/index.js"
+import type { ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options.js"
+import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema/index.js"
 
-export type OpenResponsesOptionsInput = Options & { readonly [key: string]: unknown }
+export interface OpenResponsesOptionsInput {
+  readonly [key: string]: unknown
+  readonly instructions?: string
+  readonly store?: boolean
+  readonly reasoningEffort?: ReasoningEffort
+  readonly reasoningSummary?: "auto" | "concise" | "detailed"
+  readonly include?: ReadonlyArray<ResponseIncludable>
+  readonly textVerbosity?: TextVerbosity
+  readonly serviceTier?: ServiceTier
+}
 
 export type OpenResponsesProviderOptionsInput = ProviderOptions & {
   readonly openresponses?: OpenResponsesOptionsInput

packages/ai/src/testing.ts

@@ -7,7 +7,6 @@ import {
   type FinishReasonDetails,
   type AIError,
   type LLMRequest,
-  type ProviderMetadata,
   type UsageInput,
 } from "./schema/index.js"
 import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect"
@@ -34,22 +33,13 @@ export interface LayerOptions {
 export class Service extends Context.Service<Service, Interface>()("@opencode/ai/TestLLM") {}
 
 export const complete = (
-  options: {
-    readonly reason: FinishReasonDetails
-    readonly usage?: UsageInput
-    readonly providerMetadata?: ProviderMetadata
-  },
+  options: { readonly reason: FinishReasonDetails; readonly usage?: UsageInput },
   ...events: readonly LLMEvent[]
 ) => [
   LLMEvent.stepStart({ index: 0 }),
   ...events,
-  LLMEvent.stepFinish({
-    index: 0,
-    reason: options.reason,
-    usage: options.usage,
-    providerMetadata: options.providerMetadata,
-  }),
-  LLMEvent.finish({ reason: options.reason, providerMetadata: options.providerMetadata }),
+  LLMEvent.stepFinish({ index: 0, reason: options.reason, usage: options.usage }),
+  LLMEvent.finish({ reason: options.reason }),
 ]
 
 export const stop = (...events: readonly LLMEvent[]) => complete({ reason: { normalized: "stop" } }, ...events)

packages/ai/test/provider/openai-compatible-responses.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent, Message, ToolDefinition } from "../../src/index.js"
+import { LLM, LLMEvent, Message } from "../../src/index.js"
 import { configure } from "../../src/providers/openai-compatible-responses.js"
 import { OpenAI } from "../../src/providers.js"
 import { OpenResponses } from "../../src/protocols/open-responses.js"
@@ -56,28 +56,6 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
-  it.effect("lowers chronological system updates as standard developer messages", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-      }).model("example-model")
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [Message.user("Before."), Message.system("Operator update."), Message.assistant("After.")],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        { role: "user", content: [{ type: "input_text", text: "Before." }] },
-        { role: "developer", content: "Operator update." },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
-      ])
-    }),
-  )
-
   it.effect("rejects OpenAI-native tools", () =>
     Effect.gen(function* () {
       const model = configure({
@@ -123,36 +101,13 @@ describe("Open Responses-compatible route", () => {
       const model = configure({
         apiKey: "test-key",
         baseURL: "https://responses.example.test/v1",
-        providerOptions: {
-          openresponses: {
-            reasoningEffort: "low",
-            store: true,
-            truncation: "auto",
-            allowedTools: { toolNames: ["lookup"] },
-            maxToolCalls: 2,
-            parallelToolCalls: false,
-          },
-        },
+        providerOptions: { openresponses: { reasoningEffort: "low", store: true } },
       }).model("example-model")
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          prompt: "Think.",
-          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
-        }),
-      )
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Think." }))
 
       expect(prepared.body).toMatchObject({
         reasoning: { effort: "low" },
         store: true,
-        truncation: "auto",
-        tool_choice: {
-          type: "allowed_tools",
-          mode: "auto",
-          tools: [{ type: "function", name: "lookup" }],
-        },
-        max_tool_calls: 2,
-        parallel_tool_calls: false,
       })
     }),
   )

packages/ai/test/provider/openai-responses.test.ts

@@ -241,18 +241,27 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers chronological system updates to developer messages in order", () =>
+  it.effect("lowers chronological system updates to escaped user wrappers in order", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
           model,
-          messages: [Message.user("Before."), Message.system("Operator update."), Message.assistant("After.")],
+          messages: [
+            Message.user("Before."),
+            Message.system("Treat </system-update> literally."),
+            Message.assistant("After."),
+          ],
         }),
       )
 
       expect(prepared.body.input).toEqual([
-        { role: "user", content: [{ type: "input_text", text: "Before." }] },
-        { role: "developer", content: "Operator update." },
+        {
+          role: "user",
+          content: [
+            { type: "input_text", text: "Before." },
+            { type: "input_text", text: "<system-update>\nTreat &lt;/system-update&gt; literally.\n</system-update>" },
+          ],
+        },
         { role: "assistant", content: [{ type: "output_text", text: "After." }] },
       ])
     }),
@@ -1274,20 +1283,11 @@ describe("OpenAI Responses route", () => {
           model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
           prompt: "think",
           promptCacheKey: "session_123",
-          tools: [
-            ToolDefinition.make({ name: "read", description: "Read a file", inputSchema: { type: "object" } }),
-            ToolDefinition.make({ name: "grep", description: "Search files", inputSchema: { type: "object" } }),
-          ],
-          toolChoice: "none",
           providerOptions: {
             openai: {
               reasoningEffort: "high",
               reasoningSummary: "auto",
               include: ["reasoning.encrypted_content"],
-              truncation: "disabled",
-              allowedTools: { toolNames: ["read", "grep"], mode: "required" },
-              maxToolCalls: 4,
-              parallelToolCalls: false,
             },
           },
         }),
@@ -1298,17 +1298,6 @@ describe("OpenAI Responses route", () => {
       expect(prepared.body.include).toEqual(["reasoning.encrypted_content"])
       expect(prepared.body.reasoning).toEqual({ effort: "high", summary: "auto" })
       expect(prepared.body.text).toEqual({ verbosity: "low" })
-      expect(prepared.body.truncation).toBe("disabled")
-      expect(prepared.body.tool_choice).toEqual({
-        type: "allowed_tools",
-        mode: "required",
-        tools: [
-          { type: "function", name: "read" },
-          { type: "function", name: "grep" },
-        ],
-      })
-      expect(prepared.body.max_tool_calls).toBe(4)
-      expect(prepared.body.parallel_tool_calls).toBe(false)
     }),
   )
 
@@ -1334,17 +1323,20 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("passes forward-compatible includable values through", () =>
+  it.effect("filters unknown includable values out of the include array", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
           model,
           prompt: "hi",
+          // The user passed one invalid entry alongside a valid one. Keep the
+          // valid one so the request still succeeds rather than failing on a
+          // typo from upstream config.
           providerOptions: { openai: { include: ["reasoning.encrypted_content", "bogus.thing"] } },
         }),
       )
 
-      expect(prepared.body.include).toEqual(["reasoning.encrypted_content", "bogus.thing"])
+      expect(prepared.body.include).toEqual(["reasoning.encrypted_content"])
     }),
   )
 
@@ -1358,13 +1350,13 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("passes an unknown includable value through", () =>
+  it.effect("treats an all-invalid include as no include at all", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({ model, prompt: "hi", providerOptions: { openai: { include: ["bogus.thing"] } } }),
       )
 
-      expect(prepared.body.include).toEqual(["bogus.thing"])
+      expect(prepared.body.include).toBeUndefined()
     }),
   )
 

packages/app/src/components/project-settings-extensions.tsx

@@ -7,7 +7,7 @@ import { useMcpToggle } from "@/context/mcp"
 import { useWorkspaceLocation } from "@/context/location"
 import { useServerSDK } from "@/context/server-sdk"
 import { useData } from "@/context/server"
-import { pluginLabel } from "@/utils/plugin"
+import { pluginLabels } from "@/utils/plugin"
 import { ExternalLink } from "./external-link"
 
 type SkillItem = {
@@ -102,10 +102,10 @@ export const ProjectSettingsExtensions: Component = () => {
     () => (serverSDK.connection.status() === "connected" ? directorySDK().directory : undefined),
     (directory) => serverSDK.api.plugin.list({ location: { directory } }).then((result) => result.data),
   )
-  const globalPlugins = createMemo(() => (globalPluginList.latest ?? []).map(pluginLabel))
+  const globalPlugins = createMemo(() => pluginLabels(globalPluginList.latest ?? []))
   const projectPlugins = createMemo(() => {
     const shared = new Set(globalPlugins())
-    return (projectPluginList.latest ?? []).map(pluginLabel).filter((name) => !shared.has(name))
+    return pluginLabels(projectPluginList.latest ?? []).filter((name) => !shared.has(name))
   })
 
   const serverSkills = createMemo(() => data.location.skill.list() ?? [])

packages/app/src/components/settings-v2/extensions.tsx

@@ -6,7 +6,7 @@ import { useLanguage } from "@/context/language"
 import { useData } from "@/context/server"
 import { useServerSDK } from "@/context/server-sdk"
 import { useMcpToggle } from "@/context/mcp"
-import { pluginLabel } from "@/utils/plugin"
+import { pluginLabels } from "@/utils/plugin"
 import { ExternalLink } from "../external-link"
 import { InlineServerSelect } from "./parts/server-select"
 import "./settings-v2.css"
@@ -45,9 +45,7 @@ export const SettingsExtensionsV2: Component = () => {
     () => serverSdk.connection.status() === "connected",
     () => serverSdk.api.plugin.list().then((result) => result.data),
   )
-  const plugins = createMemo<PluginRowItem[]>(() =>
-    (pluginList.latest ?? []).map((item) => ({ name: pluginLabel(item) })),
-  )
+  const plugins = createMemo<PluginRowItem[]>(() => pluginLabels(pluginList.latest ?? []).map((name) => ({ name })))
 
   createEffect(() => {
     if (serverSdk.connection.status() !== "connected") return

packages/app/src/components/status-popover-body.tsx

@@ -6,7 +6,7 @@ import { useMcpToggle } from "@/context/mcp"
 import { useWorkspaceLocation } from "@/context/location"
 import { useData } from "@/context/server"
 import { useServerSDK } from "@/context/server-sdk"
-import { pluginLabel } from "@/utils/plugin"
+import { pluginLabels } from "@/utils/plugin"
 
 const pluginEmptyMessage = (value: string, file: string): JSXElement => {
   const parts = value.split(file)
@@ -39,7 +39,7 @@ export function StatusPopoverBody(props: { shown: boolean }) {
     () => (props.shown ? sdk().directory : undefined),
     (directory) => serverSDK.api.plugin.list({ location: { directory } }).then((result) => result.data),
   )
-  const plugins = createMemo(() => (pluginList.latest ?? []).map(pluginLabel))
+  const plugins = createMemo(() => pluginLabels(pluginList.latest ?? []))
   const pluginCount = createMemo(() => plugins().length)
   const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
 

packages/app/src/pages/session/timeline/observe-element-offset.test.ts

@@ -62,16 +62,13 @@ test("reports a divergent native offset once and ignores equal offsets and unrel
 })
 
 test("keeps checking until stale reset-delay callbacks can no longer win", async () => {
-  const targetWindow = new Window()
-  const mutations = controlledMutations(targetWindow)
-  const animation = controlledAnimationFrames(targetWindow)
-  const route = targetWindow.document.createElement("section")
-  const viewport = targetWindow.document.createElement("div")
+  const route = document.createElement("section")
+  const viewport = document.createElement("div")
   route.append(viewport)
-  targetWindow.document.body.append(route)
+  document.body.append(route)
   const instance = {
     scrollElement: viewport,
-    targetWindow,
+    targetWindow: window,
     scrollOffset: 79_400,
     options: {
       horizontal: false,
@@ -86,23 +83,20 @@ test("keeps checking until stale reset-delay callbacks can no longer win", async
     instance.scrollOffset = offset
   })
 
-  try {
-    mutations.remove(route)
-    mutations.append(targetWindow.document.body, route)
-    animation.run(16)
-    expect(instance.scrollOffset).toBe(0)
+  route.remove()
+  document.body.append(route)
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  await frames(1)
+  expect(instance.scrollOffset).toBe(0)
 
-    instance.scrollOffset = 79_400
-    animation.run(32)
-    animation.run(48)
+  instance.scrollOffset = 79_400
+  await new Promise((resolve) => setTimeout(resolve, 25))
+  await frames(3)
 
-    expect(instance.scrollOffset).toBe(0)
-    expect(calls).toEqual([0, 0])
-    expect(animation.pending()).toBe(0)
-  } finally {
-    cleanup?.()
-    await targetWindow.happyDOM.close()
-  }
+  expect(instance.scrollOffset).toBe(0)
+  expect(calls).toEqual([0, 0])
+  cleanup?.()
+  route.remove()
 })
 
 test.each([
@@ -241,29 +235,3 @@ function controlledMutations(targetWindow: Window) {
     },
   }
 }
-
-function controlledAnimationFrames(targetWindow: Window) {
-  let time = 0
-  let id = 0
-  const callbacks = new Map<number, FrameRequestCallback>()
-  Object.defineProperty(targetWindow.performance, "now", { value: () => time })
-  Object.defineProperty(targetWindow, "requestAnimationFrame", {
-    value: (callback: FrameRequestCallback) => {
-      id += 1
-      callbacks.set(id, callback)
-      return id
-    },
-  })
-  Object.defineProperty(targetWindow, "cancelAnimationFrame", {
-    value: (frame: number) => callbacks.delete(frame),
-  })
-  return {
-    run(at: number) {
-      time = at
-      const pending = [...callbacks.values()]
-      callbacks.clear()
-      pending.forEach((callback) => callback(at))
-    },
-    pending: () => callbacks.size,
-  }
-}

packages/app/src/utils/plugin.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import type { PluginInfo } from "@opencode-ai/client"
+import { pluginLabels } from "./plugin"
+
+describe("pluginLabels", () => {
+  test("omits built-in plugins", () => {
+    const plugins: PluginInfo[] = [
+      { id: "opencode.internal", source: { type: "builtin" }, status: "active", tui: false },
+      { id: "package-plugin", source: { type: "package", package: "example" }, status: "active", tui: false },
+      { id: "local-plugin", source: { type: "local", path: "/tmp/plugin.ts" }, status: "active", tui: false },
+      { id: "sdk-plugin", source: { type: "sdk" }, status: "active", tui: false },
+    ]
+
+    expect(pluginLabels(plugins)).toEqual(["package-plugin", "local-plugin", "sdk-plugin"])
+  })
+})

packages/app/src/utils/plugin.ts

@@ -6,3 +6,7 @@ export function pluginLabel(plugin: PluginInfo) {
   if (plugin.source.type === "local") return plugin.source.path
   return plugin.source.type
 }
+
+export function pluginLabels(plugins: readonly PluginInfo[]) {
+  return plugins.filter((plugin) => plugin.source.type !== "builtin").map(pluginLabel)
+}

packages/cli/src/commands/commands.ts

@@ -1,5 +1,6 @@
-import { Argument, Flag } from "effect/unstable/cli"
+import { Argument, Command, Flag } from "effect/unstable/cli"
 import { Spec } from "../framework/spec"
+import { GlobalFlags } from "./global-flags"
 
 declare const OPENCODE_CLI_NAME: string | undefined
 
@@ -159,29 +160,7 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
     }),
     Spec.make("plugin", {
       description: "Manage plugins",
-      commands: [
-        Spec.make("list", {
-          description: "List plugins",
-          params: {
-            builtin: Flag.boolean("builtin").pipe(
-              Flag.withDescription("Include built-in server plugins"),
-              Flag.withDefault(false),
-            ),
-          },
-        }),
-        Spec.make("add", {
-          description: "Install a plugin and add it to the global configuration",
-          params: {
-            package: Argument.string("package").pipe(Argument.withDescription("npm registry package specifier")),
-          },
-        }),
-        Spec.make("remove", {
-          description: "Remove a plugin from global configuration",
-          params: {
-            package: Argument.string("package").pipe(Argument.withDescription("configured package specifier")),
-          },
-        }),
-      ],
+      commands: [Spec.make("list", { description: "List active plugins" })],
     }),
     Spec.make("models", {
       description: "List all available models",
@@ -342,4 +321,4 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
   ],
 })
 
-export const Commands = Root
+export const Commands = { ...Root, spec: Root.spec.pipe(Command.withGlobalFlags(GlobalFlags.all)) }

packages/cli/src/commands/global-flags.ts

@@ -0,0 +1,12 @@
+export * as GlobalFlags from "./global-flags"
+
+import { Flag, GlobalFlag } from "effect/unstable/cli"
+
+export const CpuProfile = GlobalFlag.setting("cpu-profile")({
+  flag: Flag.string("cpu-profile").pipe(
+    Flag.withDescription("Write a CPU profile to this path when the process stops"),
+    Flag.optional,
+  ),
+})
+
+export const all = [CpuProfile] as const

packages/cli/src/commands/handlers/default.ts

@@ -84,12 +84,8 @@ export default Runtime.handler(Commands, (input) =>
         update: (update) => runPromise(config.update(update)),
       },
       packages: {
-        resolve: (spec, install = true) =>
-          runPromise(
-            (install ? npm.add(spec, { subpaths: ["tui"] }) : npm.resolve(spec, { subpaths: ["tui"] })).pipe(
-              Effect.map((result) => result.entrypoint),
-            ),
-          ),
+        resolve: (spec) =>
+          runPromise(npm.add(spec, { subpaths: ["tui"] }).pipe(Effect.map((result) => result.entrypoint))),
       },
       environment: requestedServer === undefined ? Env.session() : undefined,
       terminalHandoff: () => preflight.finish(),

packages/cli/src/commands/handlers/plugin/add.ts

@@ -1,82 +0,0 @@
-import { EOL } from "node:os"
-import path from "node:path"
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
-import { Effect } from "effect"
-import { applyEdits, modify, parse, type ParseError } from "jsonc-parser"
-import { Global } from "@opencode-ai/util/global"
-import { Npm } from "@opencode-ai/util/npm"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { resolveConfigPath } from "../mcp/add"
-import { Config } from "../../../config"
-
-export default Runtime.handler(
-  Commands.commands.plugin.commands.add,
-  Effect.fn("cli.plugin.add")(function* (input) {
-    if (!(yield* Effect.promise(() => Npm.isRegistryPackage(input.package))))
-      return yield* Effect.fail(
-        new Error("Plugin target must be an npm registry package name, version, tag, or semver range"),
-      )
-    const npm = yield* Npm.Service
-    const installed = yield* npm.add(input.package, { subpaths: ["server", ""] })
-    const tui = yield* npm.resolve(input.package, { subpaths: ["tui"] })
-    const target = configurationTarget(installed.entrypoint, tui.entrypoint)
-    if (!target)
-      return yield* Effect.fail(new Error(`Plugin package has no server or TUI entrypoint: ${input.package}`))
-
-    if (target === "server") {
-      const global = yield* Global.Service
-      const configPath = yield* Effect.promise(() => resolveConfigPath(global.config))
-      const changed = yield* Effect.promise(() => writePluginConfig(configPath, input.package))
-      process.stdout.write(
-        changed
-          ? `Plugin "${input.package}" installed and added to ${configPath}${EOL}`
-          : `Plugin "${input.package}" is already configured in ${configPath}${EOL}`,
-      )
-      return
-    }
-
-    const config = yield* Config.Service
-    yield* config.update((draft) => {
-      if (configured(draft.plugins, input.package)) return
-      draft.plugins = [...(draft.plugins ?? []), input.package]
-    })
-    process.stdout.write(`TUI plugin "${input.package}" installed and added to ${config.path}${EOL}`)
-  }),
-)
-
-export function configurationTarget(server?: string, tui?: string) {
-  if (server) return "server" as const
-  if (tui) return "tui" as const
-}
-
-export async function writePluginConfig(configPath: string, spec: string) {
-  const text = await readFile(configPath, "utf8").catch((error) => {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return "{}"
-    throw error
-  })
-  const errors: ParseError[] = []
-  const config: unknown = parse(text, errors, { allowTrailingComma: true })
-  if (errors.length || typeof config !== "object" || config === null || Array.isArray(config))
-    throw new Error(`Invalid global configuration: ${configPath}`)
-  const plugins = "plugins" in config ? config.plugins : undefined
-  if (plugins !== undefined && !Array.isArray(plugins)) throw new Error(`Invalid plugins configuration: ${configPath}`)
-  if (configured(plugins, spec)) return false
-
-  const updated = applyEdits(
-    text,
-    modify(text, ["plugins"], [...(plugins ?? []), spec], { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-  )
-  await mkdir(path.dirname(configPath), { recursive: true })
-  const temporary = configPath + ".tmp"
-  await writeFile(temporary, updated.endsWith("\n") ? updated : updated + "\n", { mode: 0o600 })
-  await rename(temporary, configPath)
-  return true
-}
-
-function configured(plugins: readonly unknown[] | undefined, spec: string) {
-  return plugins?.some(
-    (entry) =>
-      entry === spec || (typeof entry === "object" && entry !== null && "package" in entry && entry.package === spec),
-  )
-}

packages/cli/src/commands/handlers/plugin/list.ts

@@ -5,69 +5,24 @@ import { Service } from "@opencode-ai/client/effect/service"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
-import { Config } from "../../../config"
-import { Global } from "@opencode-ai/util/global"
-import { discoverTuiPlugins, tuiPluginDirectories } from "@opencode-ai/tui/plugin/discovery"
 
 export default Runtime.handler(
   Commands.commands.plugin.commands.list,
-  Effect.fn("cli.plugin.list")(function* (input) {
+  Effect.fn("cli.plugin.list")(function* () {
     const options = yield* ServiceConfig.options()
     const found = yield* Service.discover(options)
     const endpoint = found ?? (yield* Service.ensure(options))
     const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
     const response = yield* Effect.promise(() => client.plugin.list({ location: { directory: process.cwd() } }))
-    const config = yield* Config.Service
-    const global = yield* Global.Service
-    const info = yield* config.get()
-    const discovered = yield* Effect.promise(() =>
-      tuiPluginDirectories(process.cwd(), global.config).then(discoverTuiPlugins),
-    )
-    const output = format(
-      response.data,
-      [
-        ...(info.plugins ?? []).flatMap((entry) => {
-          const target = typeof entry === "string" ? entry : entry.package
-          return target.startsWith("-") ? [] : [{ target, source: "configured" as const }]
-        }),
-        ...discovered.map((target) => ({ target, source: "discovered" as const })),
-      ],
-      input.builtin,
-    )
-    if (!output) {
-      process.stdout.write("No plugins found" + EOL)
+    const plugins = response.data.toSorted((a, b) => name(a).localeCompare(name(b)))
+    if (plugins.length === 0) {
+      process.stdout.write("No plugins loaded" + EOL)
       return
     }
-    process.stdout.write(output + EOL)
+    process.stdout.write(plugins.map(name).join(EOL) + EOL)
   }),
 )
 
-export function format(
-  plugins: readonly PluginInfo[],
-  tui: ReadonlyArray<{ readonly target: string; readonly source: "configured" | "discovered" }>,
-  builtin = false,
-) {
-  const server = plugins
-    .filter((plugin) => builtin || plugin.source.type !== "builtin")
-    .toSorted((a, b) => name(a).localeCompare(name(b)))
-    .map((plugin) => `${name(plugin)} (${plugin.status})`)
-  const advertised = plugins.flatMap((plugin) =>
-    plugin.status === "active" && plugin.tui && plugin.source.type === "package"
-      ? [{ target: plugin.source.package, source: "advertised" as const }]
-      : [],
-  )
-  const targets = [...tui, ...advertised]
-    .filter((plugin, index, all) => all.findIndex((candidate) => candidate.target === plugin.target) === index)
-    .toSorted((a, b) => a.target.localeCompare(b.target))
-    .map((plugin) => `${plugin.target} (${plugin.source})`)
-  return [
-    targets.length ? ["TUI", ...targets].join(EOL) : undefined,
-    server.length ? ["Server", ...server].join(EOL) : undefined,
-  ]
-    .filter((section) => section !== undefined)
-    .join(EOL + EOL)
-}
-
 function name(plugin: PluginInfo) {
   if (plugin.id) return plugin.id
   if (plugin.source.type === "package") return plugin.source.package

packages/cli/src/commands/handlers/plugin/remove.ts

@@ -1,74 +0,0 @@
-import { EOL } from "node:os"
-import path from "node:path"
-import { readFile, rename, writeFile } from "node:fs/promises"
-import { Effect } from "effect"
-import { applyEdits, modify, parse, type ParseError } from "jsonc-parser"
-import { Global } from "@opencode-ai/util/global"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { Config } from "../../../config"
-import { resolveConfigPath } from "../mcp/add"
-
-export default Runtime.handler(
-  Commands.commands.plugin.commands.remove,
-  Effect.fn("cli.plugin.remove")(function* (input) {
-    const global = yield* Global.Service
-    const configPath = yield* Effect.promise(() => resolveConfigPath(global.config))
-    const server = yield* Effect.promise(() => removePluginConfig(configPath, input.package))
-    const config = yield* Config.Service
-    const info = yield* config.get()
-    const tui = configured(info.plugins, input.package)
-    if (tui)
-      yield* config.update((draft) => {
-        draft.plugins = draft.plugins?.filter((entry) => !matches(entry, input.package))
-      })
-
-    const removed = [server ? configPath : undefined, tui ? config.path : undefined].filter(
-      (file) => file !== undefined,
-    )
-    process.stdout.write(
-      removed.length
-        ? `Plugin "${input.package}" removed from ${removed.join(", ")}${EOL}`
-        : `Plugin "${input.package}" is not configured${EOL}`,
-    )
-  }),
-)
-
-export async function removePluginConfig(configPath: string, spec: string) {
-  const text = await readFile(configPath, "utf8").catch((error) => {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return undefined
-    throw error
-  })
-  if (text === undefined) return false
-  const errors: ParseError[] = []
-  const config: unknown = parse(text, errors, { allowTrailingComma: true })
-  if (errors.length || typeof config !== "object" || config === null || Array.isArray(config))
-    throw new Error(`Invalid global configuration: ${configPath}`)
-  const plugins = "plugins" in config ? config.plugins : undefined
-  if (plugins !== undefined && !Array.isArray(plugins)) throw new Error(`Invalid plugins configuration: ${configPath}`)
-  if (!configured(plugins, spec)) return false
-
-  const updated = applyEdits(
-    text,
-    modify(
-      text,
-      ["plugins"],
-      plugins?.filter((entry) => !matches(entry, spec)),
-      {
-        formattingOptions: { tabSize: 2, insertSpaces: true },
-      },
-    ),
-  )
-  const temporary = configPath + ".tmp"
-  await writeFile(temporary, updated.endsWith("\n") ? updated : updated + "\n", { mode: 0o600 })
-  await rename(temporary, configPath)
-  return true
-}
-
-function configured(plugins: readonly unknown[] | undefined, spec: string) {
-  return plugins?.some((entry) => matches(entry, spec)) ?? false
-}
-
-function matches(entry: unknown, spec: string) {
-  return entry === spec || (typeof entry === "object" && entry !== null && "package" in entry && entry.package === spec)
-}

packages/cli/src/cpu-profile.ts

@@ -1,36 +1,10 @@
 export * as CpuProfile from "./cpu-profile"
 
-import { Global } from "@opencode-ai/util/global"
-import { Effect, FileSystem, Queue } from "effect"
+import { Effect, FileSystem } from "effect"
 import { Session } from "node:inspector"
 import path from "node:path"
 
-export const listen = Effect.gen(function* () {
-  const global = yield* Global.Service
-  if (process.platform === "win32") return
-  const signals = yield* Queue.dropping<void>(1)
-  yield* Effect.acquireRelease(
-    Effect.sync(() => {
-      const handler = () => Queue.offerUnsafe(signals, undefined)
-      process.on("SIGPROF", handler)
-      return handler
-    }),
-    (handler) => Effect.sync(() => process.off("SIGPROF", handler)),
-  )
-  yield* Effect.gen(function* () {
-    yield* Queue.take(signals)
-    const file = path.join(
-      global.log,
-      `cpu-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "")}.cpuprofile`,
-    )
-    yield* run(file, Effect.sleep("10 seconds")).pipe(
-      Effect.catchCause((cause) => Effect.logError("Failed to capture CPU profile", { path: file, cause })),
-    )
-    yield* Queue.poll(signals)
-  }).pipe(Effect.forever, Effect.forkScoped({ startImmediately: true }))
-})
-
-function run<A, E, R>(file: string, effect: Effect.Effect<A, E, R>) {
+export function run<A, E, R>(file: string, effect: Effect.Effect<A, E, R>) {
   const target = path.resolve(file)
   return Effect.acquireUseRelease(
     Effect.gen(function* () {

packages/cli/src/framework/runtime.ts

@@ -1,10 +1,13 @@
-import { Effect, FileSystem, Scope } from "effect"
+import { Effect, FileSystem, Option, Scope } from "effect"
 import { Command } from "effect/unstable/cli"
 import { Spec } from "./spec"
 import { Global } from "@opencode-ai/util/global"
 import { Updater } from "../services/updater"
 import { Config } from "../config"
 import { Npm } from "@opencode-ai/util/npm"
+import { GlobalFlags } from "../commands/global-flags"
+import { CpuProfile } from "../cpu-profile"
+import path from "node:path"
 
 export type Input<Value> =
   Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -87,7 +90,21 @@ function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): Provided
         Command.withHandler((input) =>
           Effect.gen(function* () {
             const module = yield* Effect.promise(handler.load)
-            return yield* module.default(input)
+            const cpuProfile = Option.getOrUndefined(yield* GlobalFlags.CpuProfile)
+            if (!cpuProfile) return yield* module.default(input)
+            const target = path.resolve(cpuProfile)
+            const previous = process.env.OPENCODE_CPU_PROFILE
+            process.env.OPENCODE_CPU_PROFILE = target
+            return yield* (
+              node.name === "serve" ? CpuProfile.run(target, module.default(input)) : module.default(input)
+            ).pipe(
+              Effect.ensuring(
+                Effect.sync(() => {
+                  if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
+                  else process.env.OPENCODE_CPU_PROFILE = previous
+                }),
+              ),
+            )
           }),
         ),
       )

packages/cli/src/index.ts

@@ -13,7 +13,6 @@ import { AppProcess } from "@opencode-ai/util/process"
 import { Config } from "./config"
 import { Npm } from "@opencode-ai/util/npm"
 import { Heap } from "./heap"
-import { CpuProfile } from "./cpu-profile"
 
 const Handlers = Runtime.handlers(Commands, {
   $: () => import("./commands/handlers/default"),
@@ -39,8 +38,6 @@ const Handlers = Runtime.handlers(Commands, {
   },
   plugin: {
     list: () => import("./commands/handlers/plugin/list"),
-    add: () => import("./commands/handlers/plugin/add"),
-    remove: () => import("./commands/handlers/plugin/remove"),
   },
   models: () => import("./commands/handlers/models"),
   export: () => import("./commands/handlers/export"),
@@ -62,7 +59,6 @@ const Handlers = Runtime.handlers(Commands, {
 
 Effect.gen(function* () {
   yield* Heap.listen
-  yield* CpuProfile.listen
   const runFork = Effect.runForkWith(yield* Effect.context<never>())
   const uncaughtException = (cause: Error, origin: "uncaughtException" | "unhandledRejection") => {
     runFork(Effect.logError("uncaught exception", { cause, origin }))

packages/cli/src/run/run.ts

@@ -80,13 +80,7 @@ async function run(input: RunCommandInput, options: ExecutionOptions) {
 }
 
 async function execute(input: RunCommandInput, prepared: Prepared, endpoint: Endpoint, options: ExecutionOptions) {
-  const client = OpenCode.make({
-    baseUrl: endpoint.url,
-    headers: Service.headers(endpoint),
-    // Bun's default five-minute deadline terminates the event stream used by long-running sessions.
-    fetch: ((request: RequestInfo | URL, init?: RequestInit) =>
-      fetch(request, { ...init, timeout: false } as BunFetchRequestInit)) as typeof fetch,
-  })
+  const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
   const explicit = parseRunModel(input.model)
   const target = await resolveSessionTarget({
     client,

packages/cli/src/services/service-config.ts

@@ -110,6 +110,7 @@ export const options = Effect.fnUntraced(function* (input: { readonly checkVersi
       ...selfCommand(),
       "serve",
       "--service",
+      ...(process.env.OPENCODE_CPU_PROFILE ? ["--cpu-profile", process.env.OPENCODE_CPU_PROFILE] : []),
     ],
   }
 })

packages/cli/test/cpu-profile.test.ts

@@ -1,18 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { Global } from "@opencode-ai/util/global"
-import { expect, test } from "bun:test"
-import { Effect } from "effect"
-import { CpuProfile } from "../src/cpu-profile"
-
-test("subscribes and unsubscribes SIGPROF with the CLI scope", async () => {
-  const listeners = process.listenerCount("SIGPROF")
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        yield* CpuProfile.listen
-        expect(process.listenerCount("SIGPROF")).toBe(listeners + (process.platform === "win32" ? 0 : 1))
-      }),
-    ).pipe(Effect.provideService(Global.Service, Global.make()), Effect.provide(NodeFileSystem.layer)),
-  )
-  expect(process.listenerCount("SIGPROF")).toBe(listeners)
-})

packages/cli/test/plugin-add.test.ts

@@ -1,30 +0,0 @@
-import { expect, test } from "bun:test"
-import path from "node:path"
-import { parse } from "jsonc-parser"
-import { configurationTarget, writePluginConfig } from "../src/commands/handlers/plugin/add"
-
-test("routes packages according to their exported runtimes", () => {
-  expect(configurationTarget("server.js", "tui.js")).toBe("server")
-  expect(configurationTarget("server.js", undefined)).toBe("server")
-  expect(configurationTarget(undefined, "tui.js")).toBe("tui")
-  expect(configurationTarget(undefined, undefined)).toBeUndefined()
-})
-
-test("adds a package to global plugin config without replacing unrelated settings", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "opencode.jsonc")
-  await Bun.write(file, '{\n  // retained\n  "model": "provider/model",\n  "plugins": ["first"]\n}\n')
-
-  try {
-    expect(await writePluginConfig(file, "second@1.0.0")).toBe(true)
-    expect(await writePluginConfig(file, "second@1.0.0")).toBe(false)
-    const text = await Bun.file(file).text()
-    expect(text).toContain("// retained")
-    expect(parse(text)).toEqual({
-      model: "provider/model",
-      plugins: ["first", "second@1.0.0"],
-    })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})

packages/cli/test/plugin-list.test.ts

@@ -1,46 +0,0 @@
-import { expect, test } from "bun:test"
-import { EOL } from "node:os"
-import { format } from "../src/commands/handlers/plugin/list"
-
-test("formats server and TUI plugins in sections without builtins", () => {
-  expect(
-    format(
-      [
-        { id: "opencode.agent", source: { type: "builtin" }, status: "active", tui: false },
-        {
-          id: "acme.dual",
-          source: { type: "package", package: "acme-plugin@1.0.0" },
-          status: "active",
-          tui: true,
-        },
-        {
-          source: { type: "package", package: "broken-plugin" },
-          status: "failed",
-          error: "broken",
-          tui: false,
-        },
-      ],
-      [
-        { target: "tui-only", source: "configured" },
-        { target: "/tmp/local.ts", source: "discovered" },
-      ],
-    ),
-  ).toBe(
-    [
-      "TUI",
-      "/tmp/local.ts (discovered)",
-      "acme-plugin@1.0.0 (advertised)",
-      "tui-only (configured)",
-      "",
-      "Server",
-      "acme.dual (active)",
-      "broken-plugin (failed)",
-    ].join(EOL),
-  )
-})
-
-test("includes builtins when requested", () => {
-  expect(
-    format([{ id: "opencode.agent", source: { type: "builtin" }, status: "active", tui: false }], [], true),
-  ).toBe(["Server", "opencode.agent (active)"].join(EOL))
-})

packages/cli/test/plugin-remove.test.ts

@@ -1,23 +0,0 @@
-import { expect, test } from "bun:test"
-import path from "node:path"
-import { parse } from "jsonc-parser"
-import { removePluginConfig } from "../src/commands/handlers/plugin/remove"
-
-test("removes string and object package entries without replacing unrelated settings", async () => {
-  const directory = await Bun.$`mktemp -d`.text().then((value) => value.trim())
-  const file = path.join(directory, "opencode.jsonc")
-  await Bun.write(
-    file,
-    '{\n  // retained\n  "model": "provider/model",\n  "plugins": ["remove-me", { "package": "remove-me", "options": {} }, "keep-me"]\n}\n',
-  )
-
-  try {
-    expect(await removePluginConfig(file, "remove-me")).toBe(true)
-    expect(await removePluginConfig(file, "remove-me")).toBe(false)
-    const text = await Bun.file(file).text()
-    expect(text).toContain("// retained")
-    expect(parse(text)).toEqual({ model: "provider/model", plugins: ["keep-me"] })
-  } finally {
-    await Bun.$`rm -rf ${directory}`
-  }
-})

packages/cli/test/service.test.ts

@@ -19,6 +19,29 @@ test("managed service ports are stable per installation channel", () => {
   expect(ServiceConfig.defaultPort("preview-a")).not.toBe(ServiceConfig.defaultPort("preview-b"))
 })
 
+test("managed service forwards the CPU profile path to the server", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-profile-"))
+  const profile = path.join(root, "server.cpuprofile")
+  try {
+    const previous = process.env.OPENCODE_CPU_PROFILE
+    process.env.OPENCODE_CPU_PROFILE = profile
+    try {
+      const options = await Effect.runPromise(
+        ServiceConfig.options().pipe(
+          Effect.provide(Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })),
+          Effect.provide(NodeFileSystem.layer),
+        ),
+      )
+      expect(options.command.slice(-2)).toEqual(["--cpu-profile", profile])
+    } finally {
+      if (previous === undefined) delete process.env.OPENCODE_CPU_PROFILE
+      else process.env.OPENCODE_CPU_PROFILE = previous
+    }
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
 test("local channel stores service config with the local service filename", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
   try {

packages/client/src/effect/api/api.ts

@@ -579,8 +579,6 @@ export type Endpoint5_31Output =
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
             readonly finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-            readonly rawFinish?: string | undefined
-            readonly providerState?: SessionMessage.ProviderState | undefined
             readonly cost: number & Brand.Brand<"Money.USD">
             readonly tokens: {
               readonly input: number
@@ -603,9 +601,6 @@ export type Endpoint5_31Output =
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
             readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
-            readonly finish?: "content-filter" | undefined
-            readonly rawFinish?: string | undefined
-            readonly providerState?: SessionMessage.ProviderState | undefined
             readonly cost?: (number & Brand.Brand<"Money.USD">) | undefined
             readonly tokens?:
               | {

packages/client/src/promise/generated/types.ts

@@ -1108,8 +1108,6 @@ export type SessionStepEnded = {
     sessionID: string
     assistantMessageID: string
     finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-    rawFinish?: string
-    providerState?: SessionMessageProviderState1
     cost: MoneyUSD
     tokens: TokenUsageInfo
     snapshot?: string
@@ -1147,9 +1145,6 @@ export type SessionStepFailed = {
     sessionID: string
     assistantMessageID: string
     error: SessionStructuredError
-    finish?: "content-filter"
-    rawFinish?: string
-    providerState?: SessionMessageProviderState1
     cost?: MoneyUSD
     tokens?: TokenUsageInfo
     snapshot?: string
@@ -1926,8 +1921,6 @@ export type SessionMessageAssistant = {
   content: Array<SessionMessageAssistantText | SessionMessageAssistantReasoning | SessionMessageAssistantTool>
   snapshot?: { start?: string; end?: string; files?: Array<string> }
   finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-  rawFinish?: string
-  providerState?: SessionMessageProviderState
   cost?: MoneyUSD
   tokens?: TokenUsageInfo
   error?: SessionStructuredError
@@ -2698,8 +2691,6 @@ export type SessionImportInput = {
           >
           readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
           readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
           readonly cost?: number
           readonly tokens?: {
             readonly input: number
@@ -2967,8 +2958,6 @@ export type SessionImportInput = {
           >
           readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
           readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
           readonly cost?: number
           readonly tokens?: {
             readonly input: number
@@ -3236,8 +3225,6 @@ export type SessionImportInput = {
           >
           readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
           readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
-          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
           readonly cost?: number
           readonly tokens?: {
             readonly input: number

packages/client/src/solid/data.ts

@@ -601,8 +601,6 @@ export function createData(config: CreateDataInput) {
             existing.retry = undefined
             existing.error = undefined
             existing.finish = undefined
-            existing.rawFinish = undefined
-            existing.providerState = undefined
             existing.time.completed = undefined
             if (event.data.snapshot) existing.snapshot = { ...existing.snapshot, start: event.data.snapshot }
             return
@@ -630,8 +628,6 @@ export function createData(config: CreateDataInput) {
           if (!currentAssistant) return
           currentAssistant.time.completed = event.created
           currentAssistant.finish = event.data.finish
-          currentAssistant.rawFinish = event.data.rawFinish
-          currentAssistant.providerState = event.data.providerState
           currentAssistant.cost = event.data.cost
           currentAssistant.tokens = event.data.tokens
           if (event.data.snapshot)
@@ -644,9 +640,7 @@ export function createData(config: CreateDataInput) {
           const currentAssistant = message.assistant(draft, index, event.data.assistantMessageID)
           if (!currentAssistant) return
           currentAssistant.time.completed = event.created
-          currentAssistant.finish = event.data.finish ?? "error"
-          currentAssistant.rawFinish = event.data.rawFinish
-          currentAssistant.providerState = event.data.providerState
+          currentAssistant.finish = "error"
           currentAssistant.error = event.data.error
           currentAssistant.retry = undefined
           if (event.data.cost !== undefined && event.data.tokens !== undefined) {

packages/core/src/aisdk-native.ts

@@ -51,22 +51,6 @@ export function map(input: MapInput): Mapping | undefined {
           ...mapGoogleOptions(input.settings),
         },
       }
-    case "@ai-sdk/google-vertex":
-      return {
-        package: "@opencode-ai/ai/providers/google-vertex",
-        settings: {
-          ...baseSettings,
-          ...(typeof input.settings.accessToken === "string" ? { accessToken: input.settings.accessToken } : {}),
-          ...mapAPIKey(input.settings),
-          ...(typeof input.settings.location === "string" ? { location: input.settings.location } : {}),
-          ...(typeof input.settings.project === "string" ? { project: input.settings.project } : {}),
-          ...mapGoogleOptions(
-            input.settings,
-            isStringRecord(input.settings.labels) ? { labels: input.settings.labels } : {},
-          ),
-        },
-        ...(isStringRecord(input.settings.headers) ? { headers: input.settings.headers } : {}),
-      }
     case "@ai-sdk/google-vertex/anthropic":
       return {
         package: "@opencode-ai/ai/providers/google-vertex/messages",
@@ -245,7 +229,7 @@ function mapAPIKey(settings: Readonly<Record<string, unknown>>) {
   return typeof settings.apiKey === "string" ? { apiKey: settings.apiKey } : {}
 }
 
-function mapGoogleOptions(settings: Readonly<Record<string, unknown>>, extra: Readonly<Record<string, unknown>> = {}) {
+function mapGoogleOptions(settings: Readonly<Record<string, unknown>>) {
   const input = settings.thinkingConfig
   const thinkingConfig = {
     ...(isRecord(input) && typeof input.thinkingBudget === "number" ? { thinkingBudget: input.thinkingBudget } : {}),
@@ -259,7 +243,6 @@ function mapGoogleOptions(settings: Readonly<Record<string, unknown>>, extra: Re
     ...(Array.isArray(settings.safetySettings) ? { safetySettings: settings.safetySettings } : {}),
     ...(typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {}),
     ...(Object.keys(thinkingConfig).length > 0 ? { thinkingConfig } : {}),
-    ...extra,
   }
   if (Object.keys(options).length === 0) return {}
   return { providerOptions: { gemini: options } }

packages/core/src/aisdk.ts

@@ -460,20 +460,7 @@ function prompt(request: LLMRequest): LanguageModelV3Prompt {
 function message(input: LLMRequest["messages"][number]): LanguageModelV3Message[] {
   switch (input.role) {
     case "system":
-      // The initial privileged prompt lives in `request.system` and is prepended above. A system message here is a
-      // chronological instruction update, but opaque AI SDK providers do not uniformly allow the system role after
-      // conversation history, so preserve its position using the safe wrapped-user fallback.
-      return [
-        {
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: ProviderShared.wrapSystemUpdate(input.content.filter((part) => part.type === "text")),
-            },
-          ],
-        },
-      ]
+      return [{ role: "system", content: input.content.flatMap(text).join("\n\n") }]
     case "user":
       return [{ role: "user", content: input.content.flatMap(userPart) }]
     case "assistant":

packages/core/src/command.ts

@@ -8,8 +8,10 @@ import { MCP } from "./mcp/index.js"
 import { Bus } from "./bus.js"
 import { AppProcess } from "@opencode-ai/util/process"
 import { ChildProcess } from "effect/unstable/process"
+import { Config } from "./config.js"
 import { Location } from "./location.js"
 import { ShellSelect } from "./shell/select.js"
+import { Global } from "@opencode-ai/util/global"
 
 export const Info = Command.Info
 export type Info = Command.Info
@@ -51,15 +53,16 @@ export interface Interface extends State.Transformable<Draft> {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Command") {}
 
-const layer = () =>
+export const layer = (options?: ShellSelect.Options) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
       const mcp = yield* MCP.Service
       const bus = yield* Bus.Service
       const processes = yield* AppProcess.Service
+      const config = yield* Config.Service
       const location = yield* Location.Service
-      const shell = yield* ShellSelect.Service
+      const global = yield* Global.Service
       const state = State.create<Data, Draft>({
         name: "command",
         initial: () => ({ commands: new Map() }),
@@ -106,9 +109,11 @@ const layer = () =>
           const command = staticCommand(input.name)
           if (command)
             return yield* evaluateTemplate(input.name, command.template, input.arguments ?? "", {
+              config,
               location,
               processes,
-              shell,
+              shell: options,
+              bin: global.bin,
             })
 
           const prompt = (yield* mcp.prompts()).find(
@@ -158,9 +163,11 @@ function evaluateTemplate(
   template: string,
   input: string,
   services: {
+    readonly config: Config.Interface
     readonly location: Location.Info
     readonly processes: AppProcess.Interface
-    readonly shell: ShellSelect.Interface
+    readonly shell?: ShellSelect.Options
+    readonly bin: string
   },
 ) {
   return Effect.gen(function* () {
@@ -190,14 +197,20 @@ const evaluateShell = Effect.fnUntraced(function* (
   command: string,
   text: string,
   services: {
+    readonly config: Config.Interface
     readonly location: Location.Info
     readonly processes: AppProcess.Interface
-    readonly shell: ShellSelect.Interface
+    readonly shell?: ShellSelect.Options
+    readonly bin: string
   },
 ) {
   const matches = Array.from(text.matchAll(shellRegex))
   if (matches.length === 0) return text
-  const shell = yield* services.shell.preferred()
+  const shell = ShellSelect.preferred(
+    Config.latest(yield* services.config.entries(), "shell"),
+    services.shell,
+    services.bin,
+  )
   const outputs = yield* Effect.forEach(
     matches,
     (match) => {
@@ -254,8 +267,12 @@ const placeholderRegex = /\$(\d+)/g
 const quoteTrimRegex = /^["']|["']$/g
 const shellRegex = /!`([^`]+)`/g
 
-export const node = makeLocationNode({
-  service: Service,
-  layer: layer(),
-  deps: [MCP.node, Bus.node, AppProcess.node, Location.node, ShellSelect.node],
-})
+export function configured(options?: ShellSelect.Options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [MCP.node, Bus.node, AppProcess.node, Config.node, Location.node, Global.node],
+  })
+}
+
+export const node = configured()

packages/core/src/config/plugin/compaction.ts

@@ -1,37 +0,0 @@
-export * as ConfigCompactionPlugin from "./compaction.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { SessionCompaction } from "../../session/compaction.js"
-
-export const Plugin = define({
-  id: "opencode.config.compaction",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const compaction = yield* SessionCompaction.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(compaction.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
-    yield* compaction.transform((draft) => {
-      for (const entry of loaded.entries) {
-        if (entry.type !== "document" || !entry.info.compaction) continue
-        draft.configure({
-          ...(entry.info.compaction.auto === undefined ? {} : { auto: entry.info.compaction.auto }),
-          ...(entry.info.compaction.buffer === undefined ? {} : { buffer: entry.info.compaction.buffer }),
-          ...(entry.info.compaction.keep?.tokens === undefined
-            ? {}
-            : { tokens: entry.info.compaction.keep.tokens }),
-        })
-      }
-    })
-  }),
-})

packages/core/src/config/plugin/location-watcher.ts

@@ -1,31 +0,0 @@
-export * as ConfigLocationWatcherPlugin from "./location-watcher.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { LocationWatcherPolicy } from "../../filesystem/location-watcher-policy.js"
-
-export const Plugin = define({
-  id: "opencode.config.location-watcher",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const policy = yield* LocationWatcherPolicy.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(policy.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
-    yield* policy.transform((draft) => {
-      for (const entry of loaded.entries) {
-        if (entry.type !== "document" || !entry.info.watcher?.ignore) continue
-        draft.add(entry.info.watcher.ignore)
-      }
-    })
-  }),
-})

packages/core/src/config/plugin/shell.ts

@@ -1,35 +0,0 @@
-export * as ConfigShellPlugin from "./shell.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { ShellPolicy } from "../../shell/policy.js"
-import { ShellSelect } from "../../shell/select.js"
-
-export const Plugin = define({
-  id: "opencode.config.shell",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const shell = yield* ShellSelect.Service
-    const policy = yield* ShellPolicy.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(Effect.all([shell.reload(), policy.reload()], { concurrency: "unbounded", discard: true })),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
-    yield* shell.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "shell")
-      if (configured) draft.configure(configured)
-    })
-    yield* policy.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "experimental")?.portable_shell_scanner
-      if (configured !== undefined) draft.configure(configured)
-    })
-  }),
-})

packages/core/src/config/plugin/snapshot.ts

@@ -1,30 +0,0 @@
-export * as ConfigSnapshotPlugin from "./snapshot.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { Snapshot } from "../../snapshot.js"
-
-export const Plugin = define({
-  id: "opencode.config.snapshot",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const snapshot = yield* Snapshot.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(snapshot.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
-    yield* snapshot.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "snapshots")
-      if (configured === undefined) return
-      draft.configure(configured)
-    })
-  }),
-})

packages/core/src/config/plugin/tool-output.ts

@@ -1,33 +0,0 @@
-export * as ConfigToolOutputPlugin from "./tool-output.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { ToolOutput } from "../../tool-output.js"
-
-export const Plugin = define({
-  id: "opencode.config.tool-output",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const output = yield* ToolOutput.Service
-    const loaded = { entries: yield* config.entries() }
-    const reload = config.entries().pipe(
-      Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-      Effect.andThen(output.reload()),
-    )
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() => reload),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    loaded.entries = yield* config.entries()
-    yield* output.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "tool_output")
-      if (!configured) return
-      draft.configure({
-        ...(configured.max_lines === undefined ? {} : { maxLines: configured.max_lines }),
-        ...(configured.max_bytes === undefined ? {} : { maxBytes: configured.max_bytes }),
-      })
-    })
-  }),
-})

packages/core/src/filesystem/location-watcher-policy.ts

@@ -1,65 +0,0 @@
-export * as LocationWatcherPolicy from "./location-watcher-policy.js"
-
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Scope } from "effect"
-import { State } from "../state.js"
-
-type Data = {
-  ignore: string[]
-}
-
-export type Draft = {
-  add: (ignore: readonly string[]) => void
-  list: () => readonly string[]
-}
-
-export interface Interface extends State.Transformable<Draft> {
-  readonly current: () => readonly string[]
-  readonly observe: (
-    listener: (ignore: readonly string[]) => Effect.Effect<void>,
-  ) => Effect.Effect<State.Registration, never, Scope.Scope>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/LocationWatcherPolicy") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    let current: readonly string[] = []
-    const listeners = new Set<(ignore: readonly string[]) => Effect.Effect<void>>()
-    const state = State.create<Data, Draft>({
-      name: "location-watcher-policy",
-      initial: () => ({ ignore: [] }),
-      draft: (draft) => ({
-        add: (ignore) => draft.ignore.push(...ignore),
-        list: () => draft.ignore,
-      }),
-      finalize: (draft) =>
-        Effect.sync(() => {
-          current = [...draft.list()]
-        }).pipe(Effect.andThen(Effect.forEach(listeners, (listener) => listener(current), { discard: true }))),
-    })
-    const observe = Effect.fn("LocationWatcherPolicy.observe")(function* (
-      listener: (ignore: readonly string[]) => Effect.Effect<void>,
-    ) {
-      const scope = yield* Scope.Scope
-      let active = true
-      const dispose = Effect.sync(() => {
-        if (!active) return
-        active = false
-        listeners.delete(listener)
-      })
-      listeners.add(listener)
-      yield* Scope.addFinalizer(scope, dispose)
-      return { dispose }
-    })
-    return Service.of({
-      transform: state.transform,
-      reload: state.reload,
-      current: () => current,
-      observe,
-    })
-  }),
-)
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/filesystem/location-watcher.ts

@@ -1,15 +1,15 @@
 export * as LocationWatcher from "./location-watcher.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Cause, Context, Effect, Exit, Layer, Scope, Semaphore, Stream } from "effect"
+import { Context, Effect, Layer, Stream } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
+import { Document } from "@opencode-ai/schema/config"
 import path from "path"
+import { Config } from "../config.js"
 import { Bus } from "../bus.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Git } from "../git.js"
 import { Location } from "../location.js"
-import { PluginSupervisor } from "../plugin/supervisor.js"
-import { LocationWatcherPolicy } from "./location-watcher-policy.js"
 import { Watcher } from "./watcher.js"
 
 export interface Interface {}
@@ -24,86 +24,42 @@ const layer = Layer.effect(
     const bus = yield* Bus.Service
     const fs = yield* FSUtil.Service
     const git = yield* Git.Service
-    const plugins = yield* PluginSupervisor.Service
-    const policy = yield* LocationWatcherPolicy.Service
+    const configService = yield* Config.Service
     const publish = (update: { type: "create" | "update" | "delete"; path: string }) =>
       bus.publish(FileSystem.Event.Changed, {
         file: update.path,
         event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink",
       })
-    const target = yield* Effect.cached(
-      Effect.gen(function* () {
-        if (location.vcs?.type === "git") {
-          const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
-          const vcs = resolved
-            ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved)))
-            : undefined
-          if (vcs) return { path: path.join(vcs, "HEAD"), aliases: [".git", vcs, ...(resolved ? [resolved] : [])] }
-        }
-        if (location.vcs?.type === "hg") {
-          const store = location.vcs.store
-          const vcs = yield* fs.realPath(store).pipe(Effect.catch(() => Effect.succeed(store)))
-          return { path: path.join(vcs, "branch"), aliases: [".hg", vcs] }
-        }
-      }).pipe(
-        Effect.withSpan("LocationWatcher.target", { attributes: { directory: location.directory } }),
-        Effect.catchCause((cause) =>
-          Effect.logError("failed to resolve location watcher target", { cause }).pipe(Effect.as(undefined)),
-        ),
-      ),
-    )
-    const lock = Semaphore.makeUnsafe(1)
-    let requested = 0
-    let stopped = false
-    let active: { path: string; scope: Scope.Closeable } | undefined
-    const reconcile = (ignore: readonly string[]) => {
-      const request = ++requested
-      return lock.withPermit(
-        Effect.gen(function* () {
-          if (stopped || request !== requested) return
-          const resolved = yield* target
-          if (stopped || request !== requested) return
-          const next = resolved && !resolved.aliases.some((alias) => ignore.includes(alias)) ? resolved.path : undefined
-          if (active?.path === next) return
-          if (active) yield* Scope.close(active.scope, Exit.void)
-          active = undefined
-          if (!next) return
-          const scope = yield* Scope.make()
-          active = { path: next, scope }
-          yield* Effect.gen(function* () {
-            const updates = yield* watcher.subscribe({ path: next, type: "file" })
-            yield* Stream.runForEach(updates, publish)
-          }).pipe(
-            Effect.catchCauseIf(
-              (cause) => !Cause.hasInterrupts(cause),
-              (cause) => Effect.logError("location watcher subscription failed", { path: next, cause }),
-            ),
-            Effect.forkIn(scope, { startImmediately: true }),
-          )
-        }).pipe(Effect.withSpan("LocationWatcher.reconcile", { attributes: { directory: location.directory } })),
-      )
-    }
-    yield* Effect.addFinalizer(() =>
-      lock.withPermit(
-        Effect.gen(function* () {
-          stopped = true
-          requested++
-          if (active) yield* Scope.close(active.scope, Exit.void)
-          active = undefined
-        }),
-      ),
-    )
-    yield* policy.observe(reconcile)
+
     yield* Effect.gen(function* () {
-      yield* plugins.flush
-      yield* reconcile(policy.current())
+      const config = (yield* configService.entries())
+        .filter((entry): entry is Document => entry.type === "document")
+        .flatMap((item) => item.info.watcher?.ignore ?? [])
+
+      if (location.vcs?.type === "git") {
+        const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory
+        const vcs = resolved
+          ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved)))
+          : undefined
+        if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
+          const updates = yield* watcher.subscribe({ path: path.join(vcs, "HEAD"), type: "file" })
+          yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
+        }
+      }
+      if (location.vcs?.type === "hg") {
+        const store = location.vcs.store
+        const vcs = yield* fs.realPath(store).pipe(Effect.catch(() => Effect.succeed(store)))
+        if (!config.includes(".hg") && !config.includes(vcs)) {
+          const updates = yield* watcher.subscribe({ path: path.join(vcs, "branch"), type: "file" })
+          yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
+        }
+      }
     }).pipe(
-      Effect.catchCauseIf(
-        (cause) => !Cause.hasInterrupts(cause),
-        (cause) => Effect.logError("failed to start location watcher", { cause }),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
+      Effect.withSpan("LocationWatcher.start", { attributes: { directory: location.directory } }),
+      Effect.catchCause((cause) => Effect.logError("failed to init location watcher service", { cause })),
+      Effect.forkScoped,
     )
+
     return Service.of({})
   }),
 )
@@ -111,13 +67,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [
-    Watcher.node,
-    FSUtil.node,
-    Location.node,
-    Git.node,
-    Bus.node,
-    PluginSupervisor.node,
-    LocationWatcherPolicy.node,
-  ],
+  deps: [Watcher.node, FSUtil.node, Location.node, Config.node, Git.node, Bus.node],
 })

packages/core/src/location-services.ts

@@ -29,8 +29,6 @@ import { PluginSupervisor } from "./plugin/supervisor.js"
 import { Worktree } from "./worktree.js"
 import { Pty } from "./pty.js"
 import { Shell } from "./shell.js"
-import { ShellPolicy } from "./shell/policy.js"
-import { ShellSelect } from "./shell/select.js"
 import { Reference } from "./reference.js"
 import { WebSearch } from "./websearch.js"
 import { ReferenceInstructions } from "./reference/instructions.js"
@@ -73,8 +71,6 @@ const locationServiceNodes = [
   Worktree.refreshNode,
   FileSystemSearch.node,
   FileSystem.node,
-  ShellPolicy.node,
-  ShellSelect.node,
   Pty.node,
   Shell.node,
   Skill.node,

packages/core/src/plugin/internal.ts

@@ -13,19 +13,14 @@ import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { ConfigAgentPlugin } from "../config/plugin/agent.js"
 import { ConfigCommandPlugin } from "../config/plugin/command.js"
-import { ConfigCompactionPlugin } from "../config/plugin/compaction.js"
 import { ConfigFormatterPlugin } from "../config/plugin/formatter.js"
 import { ConfigImagePlugin } from "../config/plugin/image.js"
 import { ConfigInstructionPlugin } from "../config/plugin/instruction.js"
-import { ConfigLocationWatcherPlugin } from "../config/plugin/location-watcher.js"
 import { ConfigMCPPlugin } from "../config/plugin/mcp.js"
 import { ConfigProviderPlugin } from "../config/plugin/provider.js"
 import { ConfigPolicyPlugin } from "../config/plugin/policy.js"
 import { ConfigReferencePlugin } from "../config/plugin/reference.js"
-import { ConfigShellPlugin } from "../config/plugin/shell.js"
-import { ConfigSnapshotPlugin } from "../config/plugin/snapshot.js"
 import { ConfigSkillPlugin } from "../config/plugin/skill.js"
-import { ConfigToolOutputPlugin } from "../config/plugin/tool-output.js"
 import { ConfigPluginSource } from "../config/plugin/source.js"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch.js"
 import { Bus } from "../bus.js"
@@ -34,7 +29,6 @@ import { FileMutation } from "../file-mutation.js"
 import { Formatter } from "../formatter.js"
 import { Form } from "../form.js"
 import { FileSystem } from "../filesystem.js"
-import { LocationWatcherPolicy } from "../filesystem/location-watcher-policy.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Image } from "../image.js"
@@ -50,12 +44,8 @@ import { Permission } from "../permission.js"
 import { Reference } from "../reference.js"
 import { WebSearch } from "../websearch.js"
 import { Ripgrep } from "../ripgrep.js"
-import { SessionCompaction } from "../session/compaction.js"
 import { SessionInstructions } from "../session/instructions.js"
 import { Shell } from "../shell.js"
-import { ShellPolicy } from "../shell/policy.js"
-import { ShellSelect } from "../shell/select.js"
-import { Snapshot } from "../snapshot.js"
 import { Skill } from "../skill.js"
 import { SkillDiscovery } from "../skill/discovery.js"
 import { Watcher } from "../filesystem/watcher.js"
@@ -70,7 +60,6 @@ import { ShellTool } from "../tool/plugin/shell.js"
 import { SkillTool } from "../tool/plugin/skill.js"
 import { SubagentTool } from "../tool/plugin/subagent.js"
 import { Tool } from "../tool.js"
-import { ToolOutput } from "../tool-output.js"
 import { WebFetchTool } from "../tool/plugin/webfetch.js"
 import { WebSearchTool } from "../tool/plugin/websearch.js"
 import { WellKnown } from "../wellknown.js"
@@ -101,7 +90,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const environment = yield* Environment.Service
   const mutation = yield* FileMutation.Service
   const formatter = yield* Formatter.Service
-  const locationWatcherPolicy = yield* LocationWatcherPolicy.Service
   const filesystem = yield* FileSystem.Service
   const fs = yield* FSUtil.Service
   const global = yield* Global.Service
@@ -122,16 +110,11 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const reference = yield* Reference.Service
   const websearch = yield* WebSearch.Service
   const ripgrep = yield* Ripgrep.Service
-  const compaction = yield* SessionCompaction.Service
   const instructions = yield* SessionInstructions.Service
   const shell = yield* Shell.Service
-  const shellPolicy = yield* ShellPolicy.Service
-  const shellSelect = yield* ShellSelect.Service
-  const snapshot = yield* Snapshot.Service
   const skill = yield* Skill.Service
   const skillDiscovery = yield* SkillDiscovery.Service
   const tools = yield* Tool.Service
-  const toolOutput = yield* ToolOutput.Service
   const watcher = yield* Watcher.Service
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
@@ -146,7 +129,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Environment.Service, environment),
     Context.make(FileMutation.Service, mutation),
     Context.make(Formatter.Service, formatter),
-    Context.make(LocationWatcherPolicy.Service, locationWatcherPolicy),
     Context.make(FileSystem.Service, filesystem),
     Context.make(FSUtil.Service, fs),
     Context.make(Global.Service, global),
@@ -167,16 +149,11 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Reference.Service, reference),
     Context.make(WebSearch.Service, websearch),
     Context.make(Ripgrep.Service, ripgrep),
-    Context.make(SessionCompaction.Service, compaction),
     Context.make(SessionInstructions.Service, instructions),
     Context.make(Shell.Service, shell),
-    Context.make(ShellPolicy.Service, shellPolicy),
-    Context.make(ShellSelect.Service, shellSelect),
-    Context.make(Snapshot.Service, snapshot),
     Context.make(Skill.Service, skill),
     Context.make(SkillDiscovery.Service, skillDiscovery),
     Context.make(Tool.Service, tools),
-    Context.make(ToolOutput.Service, toolOutput),
     Context.make(Watcher.Service, watcher),
     Context.make(WellKnown.Service, wellknown),
   )
@@ -198,7 +175,6 @@ export const requirements = LayerNode.group([
   Environment.node,
   FileMutation.node,
   Formatter.node,
-  LocationWatcherPolicy.node,
   FileSystem.node,
   FSUtil.node,
   Global.node,
@@ -219,16 +195,11 @@ export const requirements = LayerNode.group([
   Reference.node,
   WebSearch.node,
   Ripgrep.node,
-  SessionCompaction.node,
   SessionInstructions.node,
   Shell.node,
-  ShellPolicy.node,
-  ShellSelect.node,
-  Snapshot.node,
   Skill.node,
   SkillDiscovery.node,
   Tool.node,
-  ToolOutput.node,
   Watcher.node,
   WellKnown.node,
 ])
@@ -267,13 +238,8 @@ const post = [
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,
-  ConfigCompactionPlugin.Plugin,
   ConfigFormatterPlugin.Plugin,
   ConfigImagePlugin.Plugin,
-  ConfigLocationWatcherPlugin.Plugin,
-  ConfigShellPlugin.Plugin,
-  ConfigSnapshotPlugin.Plugin,
-  ConfigToolOutputPlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,

packages/core/src/pty.ts

@@ -4,10 +4,12 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import type { Disp, Proc } from "#pty"
 import { Context, Effect, Layer, Schema, Types } from "effect"
 import { Pty } from "@opencode-ai/schema/pty"
+import { Config } from "./config.js"
 import { Bus } from "./bus.js"
 import { Location } from "./location.js"
 import { PtyID } from "./pty/schema.js"
 import { ShellSelect } from "./shell/select.js"
+import { Global } from "@opencode-ai/util/global"
 import { lazy } from "./util/lazy.js"
 
 const BUFFER_LIMIT = 1024 * 1024 * 2
@@ -88,13 +90,14 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Pty") {}
 
-const layer = () =>
+export const layer = (options?: ShellSelect.Options) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
       const bus = yield* Bus.Service
       const location = yield* Location.Service
-      const shell = yield* ShellSelect.Service
+      const config = yield* Config.Service
+      const global = yield* Global.Service
       const context = yield* Effect.context()
       const runFork = Effect.runForkWith(context)
       const sessions = new Map<PtyID, Active>()
@@ -164,7 +167,8 @@ const layer = () =>
 
       const create = Effect.fn("Pty.create")(function* (input: CreateInput) {
         const id = PtyID.ascending()
-        const command = input.command || (yield* shell.preferred())
+        const command =
+          input.command || ShellSelect.preferred(Config.latest(yield* config.entries(), "shell"), options, global.bin)
         const args = ShellSelect.login(command) ? [...(input.args ?? []), "-l"] : [...(input.args ?? [])]
         const cwd = input.cwd || location.directory
         const env = {
@@ -313,8 +317,12 @@ const layer = () =>
     }),
   )
 
-export const node = makeLocationNode({
-  service: Service,
-  layer: layer(),
-  deps: [Bus.node, Location.node, ShellSelect.node],
-})
+export function configured(options?: ShellSelect.Options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [Bus.node, Location.node, Config.node, Global.node],
+  })
+}
+
+export const node = configured()

packages/core/src/session.ts

@@ -628,11 +628,7 @@ const layer = Layer.effect(
       }),
       command: Effect.fn("Session.command")(function* (input) {
         const session = yield* result.get(input.sessionID)
-        const commands = yield* Effect.gen(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush
-          return yield* Command.Service
-        }).pipe(Effect.provide(locations.get(session.location)))
+        const commands = yield* Command.Service.pipe(Effect.provide(locations.get(session.location)))
         const command = yield* commands.get(input.command)
         if (!command)
           return yield* new Command.NotFoundError({
@@ -671,8 +667,6 @@ const layer = Layer.effect(
             activeShells.add(input.sessionID)
             yield* execution.awaitIdle(input.sessionID)
             const started = yield* Effect.gen(function* () {
-              const plugins = yield* PluginSupervisor.Service
-              yield* plugins.flush
               const shell = yield* Shell.Service
               return yield* shell
                 .create({
@@ -911,23 +905,19 @@ const layer = Layer.effect(
           const session = yield* result.get(input.sessionID)
           if ((yield* execution.active).has(input.sessionID))
             return yield* new BusyError({ sessionID: input.sessionID })
-          return yield* Effect.gen(function* () {
-            const plugins = yield* PluginSupervisor.Service
-            yield* plugins.flush
-            return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
-              Effect.provideService(Database.Service, database),
-              Effect.provideService(Bus.Service, bus),
-            )
-          }).pipe(Effect.provide(locations.get(session.location)))
+          return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
+            Effect.provideService(Database.Service, database),
+            Effect.provideService(Bus.Service, bus),
+            Effect.provide(locations.get(session.location)),
+          )
         }),
         clear: Effect.fn("Session.revert.clear")(function* (sessionID) {
           const session = yield* result.get(sessionID)
           if ((yield* execution.active).has(sessionID)) return yield* new BusyError({ sessionID })
-          const revert = yield* Effect.gen(function* () {
-            const plugins = yield* PluginSupervisor.Service
-            yield* plugins.flush
-            return yield* SessionRevert.clear(session).pipe(Effect.provideService(Bus.Service, bus))
-          }).pipe(Effect.provide(locations.get(session.location)))
+          const revert = yield* SessionRevert.clear(session).pipe(
+            Effect.provideService(Bus.Service, bus),
+            Effect.provide(locations.get(session.location)),
+          )
           yield* execution.wake(sessionID)
           return revert
         }),

packages/core/src/session/compaction.ts

@@ -3,7 +3,9 @@ export * as SessionCompaction from "./compaction.js"
 import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest, type LanguageModel } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
 import { SessionError } from "@opencode-ai/schema/session-error"
+import { Document, type Entry } from "@opencode-ai/schema/config"
 import { Context, Effect, Layer, Stream } from "effect"
+import { Config } from "../config.js"
 import { Bus } from "../bus.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../effect/app-node-platform.js"
@@ -22,7 +24,6 @@ import type { Info, Ref } from "../model.js"
 import { SessionUsage } from "./usage.js"
 import { PluginHooks } from "../plugin/hooks.js"
 import { Agent } from "../agent.js"
-import { State } from "../state.js"
 
 const DEFAULT_BUFFER = 20_000
 const DEFAULT_KEEP_TOKENS = 15_000
@@ -60,14 +61,10 @@ Rules:
 - Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
 - Do not mention the summary process or that context was compacted.`
 
-export type Settings = {
-  auto: boolean
-  buffer: number
-  tokens: number
-}
-
-export type Draft = {
-  configure: (settings: Partial<Settings>) => void
+type Settings = {
+  readonly auto: boolean
+  readonly buffer: number
+  readonly tokens: number
 }
 
 type Dependencies = {
@@ -77,6 +74,7 @@ type Dependencies = {
     readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
   }
   readonly models: SessionRunnerModel.Interface
+  readonly config: Settings
   readonly hooks: PluginHooks.Interface
 }
 
@@ -113,7 +111,7 @@ export type Outcome =
   | Pick<SessionMessage.CompactionCompleted, "status">
   | Pick<SessionMessage.CompactionFailed, "status" | "error">
 
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
   readonly required: (input: RequiredInput) => boolean
   readonly compact: (input: AutoInput) => Effect.Effect<Outcome>
   readonly compactManual: (input: ManualInput) => Effect.Effect<Outcome>
@@ -167,6 +165,17 @@ const serialize = (message: SessionMessage.Info) => {
   return ""
 }
 
+const settings = (documents: readonly Entry[]) => {
+  const configured = documents
+    .filter((entry): entry is Document => entry.type === "document")
+    .flatMap((entry) => (entry.info.compaction ? [entry.info.compaction] : []))
+  return {
+    auto: configured.findLast((value) => value.auto !== undefined)?.auto ?? true,
+    buffer: configured.findLast((value) => value.buffer !== undefined)?.buffer ?? DEFAULT_BUFFER,
+    tokens: configured.findLast((value) => value.keep?.tokens !== undefined)?.keep?.tokens ?? DEFAULT_KEEP_TOKENS,
+  }
+}
+
 const select = (
   messages: readonly SessionMessage.Info[],
   tokens: number,
@@ -231,17 +240,7 @@ const planContent = (messages: readonly SessionMessage.Info[], tokens: number) =
 }
 
 const make = (dependencies: Dependencies) => {
-  const state = State.create<Settings, Draft>({
-    name: "session-compaction",
-    initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
-    draft: (draft) => ({
-      configure: (settings) => {
-        if (settings.auto !== undefined) draft.auto = settings.auto
-        if (settings.buffer !== undefined) draft.buffer = settings.buffer
-        if (settings.tokens !== undefined) draft.tokens = settings.tokens
-      },
-    }),
-  })
+  const config = dependencies.config
   const failed = Effect.fnUntraced(function* (input: {
     readonly sessionID: SessionSchema.ID
     readonly reason: SessionMessage.Compaction["reason"]
@@ -351,7 +350,7 @@ const make = (dependencies: Dependencies) => {
     return { status: "completed" as const }
   })
   const compact = Effect.fn("SessionCompaction.compact")(function* (input: AutoInput) {
-    const content = planContent(input.messages, state.get().tokens)
+    const content = planContent(input.messages, config.tokens)
     if (content)
       return yield* execute({
         session: input.session,
@@ -369,7 +368,6 @@ const make = (dependencies: Dependencies) => {
     })
   })
   const required = (input: RequiredInput) => {
-    const config = state.get()
     if (!config.auto) return false
     const context = input.model.route.defaults.limits?.context
     if (context === undefined || context <= 0) return false
@@ -390,7 +388,7 @@ const make = (dependencies: Dependencies) => {
     return used >= promptCeiling
   }
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
-    const content = planContent(input.messages, state.get().tokens)
+    const content = planContent(input.messages, config.tokens)
     if (!content)
       return yield* failed({
         sessionID: input.session.id,
@@ -421,8 +419,6 @@ const make = (dependencies: Dependencies) => {
     })
   })
   return Service.of({
-    transform: state.transform,
-    reload: state.reload,
     required,
     compact,
     compactManual,
@@ -434,15 +430,16 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const bus = yield* Bus.Service
     const llm = yield* LLMClient.Service
+    const config = yield* Config.Service
     const models = yield* SessionRunnerModel.Service
     const app = yield* App.Metadata
     const hooks = yield* PluginHooks.Service
-    return make({ bus, llm, models, app, hooks })
+    return make({ bus, llm, models, config: settings(yield* config.entries()), app, hooks })
   }),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, SessionRunnerModel.node, App.node, PluginHooks.node],
+  deps: [Bus.node, llmClient, Config.node, SessionRunnerModel.node, App.node, PluginHooks.node],
 })

packages/core/src/session/message-updater.ts

@@ -195,8 +195,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                 draft.retry = undefined
                 draft.error = undefined
                 draft.finish = undefined
-                draft.rawFinish = undefined
-                draft.providerState = undefined
                 draft.time.completed = undefined
                 if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, start: event.data.snapshot }
               }),
@@ -230,8 +228,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = created
           draft.finish = event.data.finish
-          draft.rawFinish = event.data.rawFinish
-          draft.providerState = castDraft(event.data.providerState)
           draft.cost = event.data.cost
           draft.tokens = event.data.tokens
           if (event.data.snapshot || event.data.files)
@@ -245,9 +241,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.step.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = created
-          draft.finish = event.data.finish ?? "error"
-          draft.rawFinish = event.data.rawFinish
-          draft.providerState = castDraft(event.data.providerState)
+          draft.finish = "error"
           draft.error = castDraft(event.data.error)
           draft.retry = undefined
           if (event.data.cost !== undefined && event.data.tokens !== undefined) {

packages/core/src/session/runner/llm.ts

@@ -34,7 +34,6 @@ import { toSessionError } from "../to-session-error.js"
 import { SessionRunnerRetry } from "./retry.js"
 import { SessionUsage } from "../usage.js"
 import { ToolOutput } from "../../tool-output.js"
-import { PluginSupervisor } from "../../plugin/supervisor.js"
 
 /** How one model call ended: settled, awaiting retry/recovery, or restarted by compaction. */
 type CallOutcome = Data.TaggedEnum<{
@@ -115,7 +114,6 @@ const layer = Layer.effect(
     const snapshots = yield* Snapshot.Service
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
-    const plugins = yield* PluginSupervisor.Service
     const title = yield* SessionTitle.Service
     const toolOutput = yield* ToolOutput.Service
     // Title generation starts once input is visible and must not delay model execution.
@@ -137,7 +135,6 @@ const layer = Layer.effect(
       const promotable = input.promotable ?? "input"
       if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, promotable)))
         return { type: "complete" as const }
-      yield* plugins.flush
       yield* settleStaleToolCalls(input.sessionID)
       while (true) {
         if (yield* runPendingCompaction(input.sessionID, promotable)) {
@@ -329,8 +326,6 @@ const layer = Layer.effect(
             sessionID: session.id,
             assistantMessageID: yield* publisher.startAssistant(),
             finish: finish.finish,
-            rawFinish: finish.rawFinish,
-            providerState: finish.providerState,
             ...stepUsage(finish),
             ...end,
           })
@@ -649,7 +644,6 @@ export const node = makeLocationNode({
     SessionModelTransport.node,
     SessionStore.node,
     SessionCompaction.node,
-    PluginSupervisor.node,
     SessionTitle.node,
     Snapshot.node,
     ToolOutput.node,

packages/core/src/session/runner/publish-llm-event.ts

@@ -35,8 +35,6 @@ export interface StepRecord {
   /** Present once the provider finished the step normally. */
   readonly finish?: {
     readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]["normalized"]
-    readonly rawFinish?: string
-    readonly providerState?: SessionMessage.ProviderState
     readonly tokens: ReturnType<typeof SessionUsage.tokens>
   }
   readonly calls: ReadonlyArray<{
@@ -366,9 +364,6 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
       sessionID: input.sessionID,
       assistantMessageID,
       error: stepFailure,
-      finish: stepSettlement?.finish === "content-filter" ? stepSettlement.finish : undefined,
-      rawFinish: stepSettlement?.rawFinish,
-      providerState: stepSettlement?.providerState,
       ...details,
     })
   })
@@ -522,12 +517,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
       case "step-finish":
         yield* flush()
         if (stepSettlement) return yield* Effect.die(new Error("Duplicate step finish"))
-        stepSettlement = {
-          finish: event.reason.normalized,
-          rawFinish: event.reason.raw,
-          providerState: providerState(event.providerMetadata),
-          tokens: SessionUsage.tokens(event.usage),
-        }
+        stepSettlement = { finish: event.reason.normalized, tokens: SessionUsage.tokens(event.usage) }
         if (event.reason.normalized === "content-filter") {
           providerFailed = true
           yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" })

packages/core/src/shell.ts

@@ -7,6 +7,7 @@ import { produce } from "immer"
 import { Shell } from "@opencode-ai/schema/shell"
 import { AppProcess } from "@opencode-ai/util/process"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { Config } from "./config.js"
 import { Bus } from "./bus.js"
 import { Environment } from "./environment/index.js"
 import { Location } from "./location.js"
@@ -67,14 +68,14 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Shell") {}
 
-const layer = () =>
+export const layer = (options?: ShellSelect.Options) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
       const bus = yield* Bus.Service
       const location = yield* Location.Service
+      const config = yield* Config.Service
       const global = yield* Global.Service
-      const shell = yield* ShellSelect.Service
       const environment = yield* Environment.Service
       const hooks = yield* PluginHooks.Service
       const environments = yield* SessionEnvironment.Service
@@ -145,7 +146,12 @@ const layer = () =>
         return session.info
       })
 
-      const name = () => shell.preferred().pipe(Effect.map(ShellSelect.name))
+      const resolve = () =>
+        config
+          .entries()
+          .pipe(Effect.map((entries) => ShellSelect.preferred(Config.latest(entries, "shell"), options, global.bin)))
+
+      const name = () => resolve().pipe(Effect.map(ShellSelect.name))
 
       const output = Effect.fnUntraced(function* (id: Shell.ID, input?: Shell.OutputInput) {
         const session = yield* require(id)
@@ -190,7 +196,7 @@ const layer = () =>
           command: input.command,
           cwd: input.cwd ?? location.directory,
           timeout: input.timeout,
-          shell: yield* shell.preferred(),
+          shell: yield* resolve(),
           env: {
             ...(sessionEnvironment ?? process.env),
             TERM: "xterm-256color",
@@ -347,16 +353,20 @@ const layer = () =>
     }),
   )
 
-export const node = makeLocationNode({
-  service: Service,
-  layer: layer(),
-  deps: [
-    Bus.node,
-    Location.node,
-    Global.node,
-    ShellSelect.node,
-    Environment.node,
-    PluginHooks.node,
-    SessionEnvironment.node,
-  ],
-})
+export function configured(options?: ShellSelect.Options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [
+      Bus.node,
+      Location.node,
+      Config.node,
+      Global.node,
+      Environment.node,
+      PluginHooks.node,
+      SessionEnvironment.node,
+    ],
+  })
+}
+
+export const node = configured()

packages/core/src/shell/policy.ts

@@ -1,38 +0,0 @@
-export * as ShellPolicy from "./policy.js"
-
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Layer } from "effect"
-import { State } from "../state.js"
-
-type Data = {
-  portableScanner: boolean
-}
-
-export type Draft = {
-  configure: (portableScanner: boolean) => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
-  readonly portableScanner: () => boolean
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ShellPolicy") {}
-
-const layer = Layer.sync(Service, () => {
-  const state = State.create<Data, Draft>({
-    name: "shell-policy",
-    initial: () => ({ portableScanner: false }),
-    draft: (draft) => ({
-      configure: (portableScanner) => {
-        draft.portableScanner = portableScanner
-      },
-    }),
-  })
-  return Service.of({
-    transform: state.transform,
-    reload: state.reload,
-    portableScanner: () => state.get().portableScanner,
-  })
-})
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/shell/select.ts

@@ -3,11 +3,8 @@ export * as ShellSelect from "./select.js"
 import path from "path"
 import { readFile } from "fs/promises"
 import { statSync } from "fs"
-import { Context, Effect, Layer, Schema } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { Schema } from "effect"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { State } from "../state.js"
 import { which } from "../util/which.js"
 
 const META: Record<string, { deny?: boolean; login?: boolean; ps?: boolean }> = {
@@ -33,20 +30,6 @@ export const Options = Schema.Struct({
 })
 export type Options = typeof Options.Type
 
-type Data = {
-  shell?: string
-}
-
-export type Draft = {
-  configure: (shell: string) => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
-  readonly preferred: () => Effect.Effect<string>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ShellSelect") {}
-
 function stat(file: string) {
   return statSync(file, { throwIfNoEntry: false }) ?? undefined
 }
@@ -198,31 +181,3 @@ export async function list(options?: Options, bin?: string): Promise<Item[]> {
   const shells = process.platform === "win32" ? win(options, bin) : await unix()
   return shells.filter((shell) => resolve(shell, options, bin)).map((shell) => info(shell, options, bin))
 }
-
-const layer = (options?: Options) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const global = yield* Global.Service
-      const state = State.create<Data, Draft>({
-        name: "shell-select",
-        initial: () => ({}),
-        draft: (draft) => ({
-          configure: (shell) => {
-            draft.shell = shell
-          },
-        }),
-      })
-      return Service.of({
-        transform: state.transform,
-        reload: state.reload,
-        preferred: () => Effect.sync(() => preferred(state.get().shell, options, global.bin)),
-      })
-    }),
-  )
-
-export function configured(options?: Options) {
-  return makeLocationNode({ service: Service, layer: layer(options), deps: [Global.node] })
-}
-
-export const node = configured()

packages/core/src/snapshot.ts

@@ -3,6 +3,7 @@ export * as Snapshot from "./snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
 import { Context, Effect, Fiber, Layer, Schema, Scope } from "effect"
+import { Config } from "./config.js"
 import { File } from "./file.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Git } from "./git.js"
@@ -11,7 +12,6 @@ import { Location } from "./location.js"
 import { AbsolutePath, RelativePath } from "./schema.js"
 import { ID } from "@opencode-ai/schema/snapshot"
 import { Hash } from "@opencode-ai/util/hash"
-import { State } from "./state.js"
 
 export { ID }
 
@@ -36,11 +36,7 @@ export interface RestoreInput {
   readonly files: ReadonlyMap<RelativePath, ID>
 }
 
-export type Draft = {
-  configure: (enabled: boolean) => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
   /**
    * Capture the current Location-scoped filesystem state as a content-addressed
    * tree. Returns `undefined` when snapshots are disabled, unsupported, or the
@@ -72,20 +68,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Sn
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const config = yield* Config.Service
     const fs = yield* FSUtil.Service
     const git = yield* Git.Service
     const global = yield* Global.Service
     const location = yield* Location.Service
     const lifetime = yield* Scope.Scope
-    const state = State.create<{ enabled: boolean }, Draft>({
-      name: "snapshot",
-      initial: () => ({ enabled: true }),
-      draft: (draft) => ({
-        configure: (enabled) => {
-          draft.enabled = enabled
-        },
-      }),
-    })
     // Cache a scope-owned fiber so caller cancellation stops waiting without poisoning shared initialization.
     const repositoryFiber = yield* Effect.cached(
       Effect.gen(function* () {
@@ -112,10 +100,13 @@ const layer = Layer.effect(
       return RelativePath.make(relative.replaceAll("\\", "/") || ".")
     })
 
-    const enabled = () => location.vcs?.type === "git" && state.get().enabled
+    const enabled = Effect.fnUntraced(function* () {
+      if (location.vcs?.type !== "git") return false
+      return Config.latest(yield* config.entries(), "snapshots") !== false
+    })
 
     const capture = Effect.fn("Snapshot.capture")(function* () {
-      if (!enabled()) return undefined
+      if (!(yield* enabled())) return undefined
       return yield* Effect.gen(function* () {
         const repo = yield* repository
         return ID.make(
@@ -179,28 +170,26 @@ const layer = Layer.effect(
     })
 
     const restore = Effect.fn("Snapshot.restore")(function* (input: RestoreInput) {
-      if (!enabled()) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
+      if (!(yield* enabled())) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)))
       yield* git.tree
         .restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) })
         .pipe(Effect.mapError((cause) => failure("restore", cause)))
     })
 
-    return Service.of({ transform: state.transform, reload: state.reload, capture, files, diff, restore })
+    return Service.of({ capture, files, diff, restore })
   }).pipe(Effect.withSpan("Snapshot.boot")),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [FSUtil.node, Git.node, Global.node, Location.node],
+  deps: [Config.node, FSUtil.node, Git.node, Global.node, Location.node],
 })
 
 export const noopLayer = Layer.succeed(
   Service,
   Service.of({
-    transform: () => Effect.succeed({ dispose: Effect.void }),
-    reload: () => Effect.void,
     capture: () => Effect.succeed(undefined),
     files: () => Effect.succeed([]),
     diff: () => Effect.succeed([]),

packages/core/src/tool-output.ts

@@ -6,8 +6,8 @@ import { Context, Duration, Effect, Layer, Option, Schedule } from "effect"
 import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
+import { Config } from "./config.js"
 import { Identifier } from "./id/id.js"
-import { State } from "./state.js"
 
 export const MAX_LINES = 2_000
 export const MAX_BYTES = 50 * 1024 // 50 KiB
@@ -16,17 +16,7 @@ export const DIRECTORY = "tool-output"
 
 type Result = Tool.Result
 
-export type Limits = {
-  maxLines: number
-  maxBytes: number
-}
-
-export type Draft = {
-  configure: (limits: Partial<Limits>) => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
-  readonly limits: () => Readonly<Limits>
+export interface Interface {
   readonly truncate: (result: Result) => Effect.Effect<Result>
   readonly cleanup: () => Effect.Effect<void>
 }
@@ -56,38 +46,31 @@ const cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs: FSUtil.Interface,
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const config = yield* Config.Service
     const fs = yield* FSUtil.Service
     const global = yield* Global.Service
     const directory = path.join(global.data, DIRECTORY)
-    const state = State.create<Limits, Draft>({
-      name: "tool-output",
-      initial: () => ({ maxLines: MAX_LINES, maxBytes: MAX_BYTES }),
-      draft: (draft) => ({
-        configure: (limits) => {
-          if (limits.maxLines !== undefined) draft.maxLines = limits.maxLines
-          if (limits.maxBytes !== undefined) draft.maxBytes = limits.maxBytes
-        },
-      }),
-    })
 
     const truncate = Effect.fnUntraced(function* (result: Result) {
       if (result.metadata?.truncated !== undefined) return result
       const content =
         typeof result.content === "string" ? [{ type: "text" as const, text: result.content }] : (result.content ?? [])
       const text = content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n")
-      const limits = state.get()
+      const configured = Config.latest(yield* config.entries(), "tool_output")
+      const maxLines = configured?.max_lines ?? MAX_LINES
+      const maxBytes = configured?.max_bytes ?? MAX_BYTES
       const lines = text.split("\n")
       if (text.endsWith("\n")) lines.pop()
       const totalBytes = Buffer.byteLength(text, "utf-8")
-      if (lines.length <= limits.maxLines && totalBytes <= limits.maxBytes)
+      if (lines.length <= maxLines && totalBytes <= maxBytes)
         return { ...result, metadata: { ...result.metadata, truncated: false } }
 
       const kept: string[] = []
       let bytes = 0
       let hitBytes = false
-      for (const line of lines.slice(0, limits.maxLines)) {
+      for (const line of lines.slice(0, maxLines)) {
         const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0)
-        if (bytes + size > limits.maxBytes) {
+        if (bytes + size > maxBytes) {
           hitBytes = true
           break
         }
@@ -130,13 +113,7 @@ const layer = Layer.effect(
       }
     })
 
-    return Service.of({
-      transform: state.transform,
-      reload: state.reload,
-      limits: () => ({ ...state.get() }),
-      truncate,
-      cleanup: () => cleanup(fs, directory),
-    })
+    return Service.of({ truncate, cleanup: () => cleanup(fs, directory) })
   }),
 )
 
@@ -160,5 +137,5 @@ const cleanupNode = makeGlobalNode({
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [FSUtil.node, Global.node, cleanupNode],
+  deps: [Config.node, FSUtil.node, Global.node, cleanupNode],
 })

packages/core/src/tool/plugin/shell.ts

@@ -5,6 +5,7 @@ import { ToolFailure } from "@opencode-ai/ai"
 import type { Content } from "@opencode-ai/schema/tool"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { Deferred, Effect, Schema, Scope } from "effect"
+import { Config } from "../../config.js"
 import { Environment } from "../../environment/index.js"
 import { LocationMutation } from "../../location-mutation.js"
 import { Permission } from "../../permission.js"
@@ -13,7 +14,6 @@ import { NonNegativeInt } from "../../schema.js"
 import { SessionSchema } from "../../session/schema.js"
 import { Shell } from "../../shell.js"
 import { ShellParse } from "../../shell/parse.js"
-import { ShellPolicy } from "../../shell/policy.js"
 import { ToolOutput } from "../../tool-output.js"
 
 export const name = "shell"
@@ -86,9 +86,8 @@ export const Plugin = {
     const environment = yield* Environment.Service
     const mutation = yield* LocationMutation.Service
     const shell = yield* Shell.Service
-    const shellPolicy = yield* ShellPolicy.Service
     const permission = yield* Permission.Service
-    const toolOutput = yield* ToolOutput.Service
+    const config = yield* Config.Service
 
     const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
       sessionID: SessionSchema.ID,
@@ -164,8 +163,10 @@ export const Plugin = {
                     invocation.cwd = target.absolute
                     finalTimeout = invocation.timeout
                     if (!unrestricted) {
+                      const portable =
+                        Config.latest(yield* config.entries(), "experimental")?.portable_shell_scanner === true
                       const parsed = yield* ShellParse.scan(invocation.command, invocation.shell, target.absolute, {
-                        portable: shellPolicy.portableScanner(),
+                        portable,
                       })
                       const directories = yield* Effect.forEach(parsed.directories, (directory) =>
                         mutation.resolve({ path: path.resolve(target.absolute, directory), kind: "directory" }),
@@ -208,16 +209,18 @@ export const Plugin = {
               yield* context.progress({ shellID: info.id })
 
               const captureShell = Effect.fnUntraced(function* () {
-                const limits = toolOutput.limits()
+                const configured = Config.latest(yield* config.entries(), "tool_output")
+                const maxLines = configured?.max_lines ?? ToolOutput.MAX_LINES
+                const maxBytes = configured?.max_bytes ?? ToolOutput.MAX_BYTES
                 const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER })
                 const page = yield* shell.output(info.id, {
-                  cursor: Math.max(0, latest.size - limits.maxBytes),
-                  limit: limits.maxBytes,
+                  cursor: Math.max(0, latest.size - maxBytes),
+                  limit: maxBytes,
                 })
                 const lines = page.output.split("\n")
                 if (page.output.endsWith("\n")) lines.pop()
-                const truncated = latest.size > limits.maxBytes || lines.length > limits.maxLines
-                const output = lines.length > limits.maxLines ? lines.slice(-limits.maxLines).join("\n") : page.output
+                const truncated = latest.size > maxBytes || lines.length > maxLines
+                const output = lines.length > maxLines ? lines.slice(-maxLines).join("\n") : page.output
                 const notice = truncated ? `\n\n[output truncated; full output saved to: ${info.file}]` : ""
                 return {
                   output: `${output || "(no output)"}${notice}`,

packages/core/src/tool/plugin/webfetch.ts

@@ -56,8 +56,8 @@ const headers = (format: Format, userAgent: string) => ({
   "Accept-Language": "en-US,en;q=0.9",
 })
 
-const openCodeUserAgent =
-  "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OpenCode-User/1.0; +https://opencode.ai"
+const browserUserAgent =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
 
 const isCloudflareChallenge = (error: unknown) => {
   if (!error || typeof error !== "object" || !("reason" in error)) return false
@@ -74,14 +74,14 @@ const isCloudflareChallenge = (error: unknown) => {
   return response.status === 403 && response.headers["cf-mitigated"] === "challenge"
 }
 
-const request = (url: string, format: Format, userAgent = openCodeUserAgent) =>
+const request = (url: string, format: Format, userAgent = browserUserAgent) =>
   HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders(headers(format, userAgent)))
 
 const assertHttpUrl = (url: URL) => {
   if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("URL must use http:// or https://")
 }
 
-const execute = (http: HttpClient.HttpClient, url: string, format: Format, userAgent = openCodeUserAgent) =>
+const execute = (http: HttpClient.HttpClient, url: string, format: Format, userAgent = browserUserAgent) =>
   http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk))
 
 const collectBody = (response: HttpClientResponse.HttpClientResponse) =>

packages/core/test/aisdk-native.test.ts

@@ -273,35 +273,6 @@ describe("AISDKNative", () => {
     })
   })
 
-  test("maps Vertex Gemini settings to the native Gemini route", () => {
-    expect(
-      map("@ai-sdk/google-vertex", {
-        accessToken: "vertex-token",
-        baseURL: "https://vertex.example/v1",
-        headers: { "x-test": "value" },
-        labels: { component: "opencode", environment: "test" },
-        location: "eu",
-        project: "vertex-project",
-        thinkingConfig: { thinkingLevel: "high" },
-      }),
-    ).toEqual({
-      package: "@opencode-ai/ai/providers/google-vertex",
-      settings: {
-        accessToken: "vertex-token",
-        baseURL: "https://vertex.example/v1",
-        location: "eu",
-        project: "vertex-project",
-        providerOptions: {
-          gemini: {
-            labels: { component: "opencode", environment: "test" },
-            thinkingConfig: { thinkingLevel: "high" },
-          },
-        },
-      },
-      headers: { "x-test": "value" },
-    })
-  })
-
   test("maps Vertex Anthropic settings to native Messages", () => {
     expect(
       map("@ai-sdk/google-vertex/anthropic", {

packages/core/test/aisdk.test.ts

@@ -104,43 +104,6 @@ it.effect("projects request settings, headers, and body overlays", () =>
   }),
 )
 
-it.effect("lowers chronological system updates to wrapped user messages", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = { languageModel: () => ({ provider: event.model.providerID }) }
-    })
-
-    const resolved = yield* aisdk.model(model("opaque-provider"))
-    const prepared = yield* compileRequest(
-      LLM.request({
-        model: resolved,
-        system: "Initial instructions.",
-        messages: [
-          Message.user("Before."),
-          Message.system("Updated <rules> & constraints."),
-          Message.assistant("After."),
-        ],
-      }),
-    )
-
-    expect(prepared.body.prompt).toEqual([
-      { role: "system", content: "Initial instructions." },
-      { role: "user", content: [{ type: "text", text: "Before." }] },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<system-update>\nUpdated &lt;rules&gt; &amp; constraints.\n</system-update>",
-          },
-        ],
-      },
-      { role: "assistant", content: [{ type: "text", text: "After." }] },
-    ])
-  }),
-)
-
 it.effect("leaves max output tokens unset when the request omits them", () =>
   Effect.gen(function* () {
     const aisdk = yield* AISDK.Service

packages/core/test/command.test.ts

@@ -1,17 +1,19 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { Command } from "@opencode-ai/core/command"
+import { Config } from "@opencode-ai/core/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { Model } from "@opencode-ai/core/model"
 import { Provider } from "@opencode-ai/core/provider"
-import { emptyMcpLayer, testLocationLayer } from "./fixture/mcp"
+import { emptyConfigLayer, emptyMcpLayer, testLocationLayer } from "./fixture/mcp"
 import { testEffect } from "./lib/effect"
 
 const it = testEffect(
   AppNodeBuilder.build(Command.node, [
     [MCP.node, emptyMcpLayer],
+    [Config.node, emptyConfigLayer],
     [Location.node, testLocationLayer],
   ]),
 )

packages/core/test/config/compaction.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect } from "bun:test"
-import { LanguageModel, LLMClient, LLMEvent } from "@opencode-ai/ai"
-import { OpenAIChat } from "@opencode-ai/ai/protocols"
-import { Bus } from "@opencode-ai/core/bus"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigCompactionPlugin } from "@opencode-ai/core/config/plugin/compaction"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { llmClient } from "@opencode-ai/core/effect/app-node-platform"
-import { SessionCompaction } from "@opencode-ai/core/session/compaction"
-import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionMessage } from "@opencode-ai/core/session/message"
-import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
-import { Session } from "@opencode-ai/core/session"
-import { Agent } from "@opencode-ai/core/agent"
-import { Location } from "@opencode-ai/core/location"
-import { Project } from "@opencode-ai/core/project"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { ConfigCompaction } from "@opencode-ai/schema/config/compaction"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { Money } from "@opencode-ai/schema/money"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { DateTime, Effect, Fiber, Layer, Option, Schema, Stream } from "effect"
-import { testEffect } from "../lib/effect"
-import { host } from "../plugin/host"
-
-const model = LanguageModel.make({
-  id: "test-model",
-  provider: "test-provider",
-  route: OpenAIChat.route.with({ limits: { context: 100_000, output: 1_000 } }),
-})
-const config = Config.testLayer()
-const it = testEffect(
-  Layer.merge(
-    config,
-    AppNodeBuilder.build(LayerNode.group([SessionCompaction.node, Config.node, Bus.node]), [
-      [
-        llmClient,
-        Layer.mock(LLMClient.Service)({
-          stream: () => Stream.make(LLMEvent.textDelta({ id: "summary", text: "summary" })),
-        }),
-      ],
-      [
-        SessionRunnerModel.node,
-        Layer.mock(SessionRunnerModel.Service)({
-          resolve: () =>
-            Effect.succeed(
-              SessionRunnerModel.resolved(model, {
-                capabilities: { tools: true, input: ["text"], output: ["text"] },
-                cost: [],
-              }),
-            ),
-        }),
-      ],
-      [Config.node, config],
-    ]),
-  ),
-)
-describe("ConfigCompactionPlugin.Plugin", () => {
-  it.live("merges settings and reloads changed config", () =>
-    Effect.gen(function* () {
-      const compaction = yield* SessionCompaction.Service
-      const config = yield* Config.Test
-      const bus = yield* Bus.Service
-      yield* config.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({ compaction: new ConfigCompaction.Info({ auto: false, buffer: 20_000 }) }),
-        }),
-        new Document({
-          type: "document",
-          info: new Info({
-            compaction: new ConfigCompaction.Info({
-              buffer: 10_000,
-              keep: new ConfigCompaction.Keep({ tokens: 0 }),
-            }),
-          }),
-        }),
-      ])
-      yield* ConfigCompactionPlugin.Plugin.effect(host({ event: { subscribe: () => bus.subscribe(Event.Updated) } }))
-
-      expect(compaction.required(nearInput)).toBe(false)
-      const started = yield* bus
-        .subscribe(SessionEvent.Compaction.Started)
-        .pipe(Stream.runHead, Effect.forkScoped({ startImmediately: true }))
-      expect(
-        yield* compaction.compactManual({
-          session,
-          messages: [
-            {
-              id: SessionMessage.ID.create(),
-              type: "user",
-              text: "Older context",
-              time: { created: DateTime.makeUnsafe(0) },
-            },
-            {
-              id: SessionMessage.ID.create(),
-              type: "user",
-              text: "Recent context",
-              time: { created: DateTime.makeUnsafe(1) },
-            },
-          ],
-          inputID: SessionMessage.ID.make("msg_compaction_manual"),
-        }),
-      ).toEqual({ status: "completed" })
-      expect(Option.getOrThrow(yield* Fiber.join(started)).data.recent).toContain("Recent context")
-
-      yield* config.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({ compaction: new ConfigCompaction.Info({ auto: true, buffer: 20_000 }) }),
-        }),
-        new Document({
-          type: "document",
-          info: new Info({ compaction: new ConfigCompaction.Info({ buffer: 10_000 }) }),
-        }),
-      ])
-      yield* bus.publish(Event.Updated, {})
-      yield* Effect.gen(function* () {
-        for (let attempt = 0; attempt < 200; attempt++) {
-          if (compaction.required(nearInput)) return
-          yield* Effect.sleep("10 millis")
-        }
-        yield* Effect.die(new Error("Timed out waiting for compaction config reload"))
-      })
-      expect(compaction.required(bufferedInput)).toBe(false)
-
-      yield* config.setEntries([
-        new Document({
-          type: "document",
-          info: new Info({ compaction: new ConfigCompaction.Info({ auto: true, buffer: 20_000 }) }),
-        }),
-      ])
-      yield* bus.publish(Event.Updated, {})
-      for (let attempt = 0; attempt < 200; attempt++) {
-        if (compaction.required(bufferedInput)) return
-        yield* Effect.sleep("10 millis")
-      }
-      yield* Effect.die(new Error("Timed out waiting for compaction config reload"))
-    }),
-  )
-})
-
-const session = Session.Info.make({
-  id: Session.ID.make("ses_compaction_config"),
-  projectID: Project.ID.global,
-  cost: Money.USD.zero,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
-  location: Location.Ref.make({ directory: AbsolutePath.make("/tmp") }),
-})
-const input = (tokens: number) => ({
-  session,
-  model,
-  cost: [],
-  messages: [
-    Schema.decodeUnknownSync(SessionMessage.Assistant)({
-      id: SessionMessage.ID.make("msg_compaction_config"),
-      type: "assistant",
-      agent: Agent.defaultID,
-      model: { id: "test-model", providerID: "test-provider" },
-      content: [],
-      tokens: { input: tokens, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 0, completed: 0 },
-    }),
-  ],
-})
-const bufferedInput = input(85_000)
-const nearInput = input(95_000)

packages/core/test/config/shell.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Bus } from "@opencode-ai/core/bus"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigShellPlugin } from "@opencode-ai/core/config/plugin/shell"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { ShellPolicy } from "@opencode-ai/core/shell/policy"
-import { ShellSelect } from "@opencode-ai/core/shell/select"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { ConfigExperimental } from "@opencode-ai/schema/config/experimental"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Effect, Layer } from "effect"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "../plugin/fixture"
-
-const it = testEffect(
-  Layer.merge(PluginTestLayer, AppNodeBuilder.build(LayerNode.group([ShellSelect.node, ShellPolicy.node]))),
-)
-
-describe("ConfigShellPlugin.Plugin", () => {
-  it.live("applies shell policy and reloads changed config", () =>
-    Effect.gen(function* () {
-      const shell = yield* ShellSelect.Service
-      const policy = yield* ShellPolicy.Service
-      const bus = yield* Bus.Service
-      const config = yield* Config.Test
-      const plugins = yield* Plugin.Service
-      yield* ConfigShellPlugin.Plugin.effect(yield* PluginHost.make(plugins))
-
-      const configured = process.platform === "win32" ? FSUtil.windowsPath(process.execPath) : process.execPath
-      expect(yield* shell.preferred()).toBe(configured)
-      expect(policy.portableScanner()).toBe(true)
-
-      yield* config.setEntries([])
-      yield* bus.publish(Event.Updated, {})
-      for (let attempt = 0; attempt < 200; attempt++) {
-        if ((yield* shell.preferred()) !== configured && !policy.portableScanner()) return
-        yield* Effect.sleep("10 millis")
-      }
-      yield* Effect.die(new Error("Timed out waiting for shell config reload"))
-    }).pipe(
-      Effect.provide(
-        Config.testLayer([
-          new Document({
-            type: "document",
-            info: new Info({
-              shell: process.execPath,
-              experimental: new ConfigExperimental.Info({ portable_shell_scanner: true }),
-            }),
-          }),
-        ]),
-      ),
-    ),
-  )
-})

packages/core/test/config/snapshot.test.ts

@@ -1,66 +0,0 @@
-import { $ } from "bun"
-import { describe, expect } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Bus } from "@opencode-ai/core/bus"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigSnapshotPlugin } from "@opencode-ai/core/config/plugin/snapshot"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Location } from "@opencode-ai/core/location"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Snapshot } from "@opencode-ai/core/snapshot"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { Global } from "@opencode-ai/util/global"
-import { Effect } from "effect"
-import { tmpdir } from "../fixture/tmpdir"
-import { it } from "../lib/effect"
-import { PluginTestLayer } from "../plugin/fixture"
-
-describe("ConfigSnapshotPlugin.Plugin", () => {
-  it.live("applies availability and reloads changed config", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          const project = path.join(tmp.path, "project")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(project)
-            await fs.writeFile(path.join(project, "tracked.txt"), "one\n")
-            await $`git init`.cwd(project).quiet()
-            await $`git -c core.fsmonitor=false add .`.cwd(project).quiet()
-          })
-
-          yield* Effect.gen(function* () {
-            const snapshot = yield* Snapshot.Service
-            const bus = yield* Bus.Service
-            const config = yield* Config.Test
-            const plugins = yield* Plugin.Service
-            yield* ConfigSnapshotPlugin.Plugin.effect(yield* PluginHost.make(plugins))
-
-            expect(yield* snapshot.capture()).toBeUndefined()
-
-            yield* config.setEntries([new Document({ type: "document", info: new Info({ snapshots: true }) })])
-            yield* bus.publish(Event.Updated, {})
-            for (let attempt = 0; attempt < 200; attempt++) {
-              if ((yield* snapshot.capture()) !== undefined) return
-              yield* Effect.sleep("10 millis")
-            }
-            yield* Effect.die(new Error("Timed out waiting for snapshot config reload"))
-          }).pipe(
-            Effect.provide(
-              AppNodeBuilder.build(Snapshot.node, [
-                [Location.node, Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))],
-                [Global.node, Global.layerWith({ data: tmp.path, config: path.join(tmp.path, "config") })],
-              ]),
-            ),
-          )
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.provide(PluginTestLayer),
-      Effect.provide(Config.testLayer([new Document({ type: "document", info: new Info({ snapshots: false }) })])),
-    ),
-  )
-})

packages/core/test/config/tool-output.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Bus } from "@opencode-ai/core/bus"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigToolOutputPlugin } from "@opencode-ai/core/config/plugin/tool-output"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { ToolOutput } from "@opencode-ai/core/tool-output"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { ConfigToolOutput } from "@opencode-ai/schema/config/tool-output"
-import { Global } from "@opencode-ai/util/global"
-import { Effect } from "effect"
-import { tmpdir } from "../fixture/tmpdir"
-import { it } from "../lib/effect"
-import { PluginTestLayer } from "../plugin/fixture"
-
-describe("ConfigToolOutputPlugin.Plugin", () => {
-  it.live("applies limits and reloads changed config", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          const output = yield* ToolOutput.Service
-          const bus = yield* Bus.Service
-          const config = yield* Config.Test
-          const plugins = yield* Plugin.Service
-          yield* ConfigToolOutputPlugin.Plugin.effect(yield* PluginHost.make(plugins))
-
-          expect(output.limits()).toEqual({ maxLines: 1, maxBytes: ToolOutput.MAX_BYTES })
-          expect((yield* output.truncate({ content: "one\ntwo" })).metadata?.truncated).toBe(true)
-
-          yield* config.setEntries([
-            new Document({
-              type: "document",
-              info: new Info({
-                tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }),
-              }),
-            }),
-          ])
-          yield* bus.publish(Event.Updated, {})
-          for (let attempt = 0; attempt < 200; attempt++) {
-            const result = yield* output.truncate({ content: "one\ntwo" })
-            if (result.metadata?.truncated === false) {
-              expect(output.limits()).toEqual({ maxLines: 2, maxBytes: 1_000 })
-              return
-            }
-            yield* Effect.sleep("10 millis")
-          }
-          yield* Effect.die(new Error("Timed out waiting for tool output config reload"))
-        }).pipe(
-          Effect.provide(AppNodeBuilder.build(ToolOutput.node, [[Global.node, Global.layerWith({ data: tmp.path })]])),
-        ),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.provide(PluginTestLayer),
-      Effect.provide(
-        Config.testLayer([
-          new Document({
-            type: "document",
-            info: new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 1 }) }),
-          }),
-        ]),
-      ),
-    ),
-  )
-})

packages/core/test/filesystem/watcher.test.ts

@@ -4,24 +4,18 @@ import fs from "fs/promises"
 import path from "path"
 import { Deferred, Duration, Effect, Fiber, Layer, Option, Schedule, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
-import { ConfigLocationWatcherPlugin } from "@opencode-ai/core/config/plugin/location-watcher"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { makeLocationNode, type LocationNode } from "@opencode-ai/util/effect/app-node"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { LocationWatcher } from "@opencode-ai/core/filesystem/location-watcher"
-import { LocationWatcherPolicy } from "@opencode-ai/core/filesystem/location-watcher-policy"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Document, Event, Info, type Entry } from "@opencode-ai/schema/config"
 import { Location } from "@opencode-ai/core/location"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
-import { host } from "../plugin/host"
 
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 const describeNative = process.env.CI ? describe.skip : describe
@@ -29,11 +23,6 @@ const describeNative = process.env.CI ? describe.skip : describe
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([FSUtil.node, Bus.node])))
 
 const configLayer = Config.testLayer()
-const pluginNode = makeLocationNode({
-  service: PluginSupervisor.Service,
-  layer: Layer.succeed(PluginSupervisor.Service, PluginSupervisor.Service.of({ flush: Effect.void })),
-  deps: [],
-})
 
 describe("Watcher.testLayer", () => {
   it.effect("records subscriptions and broadcasts emitted updates through the service", () =>
@@ -146,26 +135,16 @@ describe("Watcher lifecycle", () => {
   })
 })
 
-function provide(
-  directory: string,
-  vcs?: Location.Interface["vcs"],
-  watcher?: Layer.Layer<Watcher.Service>,
-  config: Layer.Layer<Config.Service> = configLayer,
-  plugins: LocationNode<PluginSupervisor.Service> = pluginNode,
-) {
+function provide(directory: string, vcs?: Location.Interface["vcs"], watcher?: Layer.Layer<Watcher.Service>) {
   const locationLayer = Layer.succeed(
     Location.Service,
     Location.Service.of(location({ directory: AbsolutePath.make(directory) }, { vcs })),
   )
-  const built = AppNodeBuilder.build(
-    LayerNode.group([LocationWatcher.node, LocationWatcherPolicy.node, Bus.node, Config.node]),
-    [
-      [Config.node, config],
-      [Location.node, locationLayer],
-      [PluginSupervisor.node, plugins],
-      ...(watcher ? ([[Watcher.node, watcher]] as const) : []),
-    ],
-  )
+  const built = AppNodeBuilder.build(LocationWatcher.node, [
+    [Config.node, configLayer],
+    [Location.node, locationLayer],
+    ...(watcher ? ([[Watcher.node, watcher]] as const) : []),
+  ])
   return Effect.provide(built)
 }
 
@@ -175,8 +154,6 @@ function withTmp<A, E, R>(
     vcs?: "git" | "hg"
     init?: (directory: string) => Promise<void>
     watcher?: Layer.Layer<Watcher.Service>
-    config?: Layer.Layer<Config.Service>
-    plugins?: LocationNode<PluginSupervisor.Service>
   },
 ) {
   return Effect.acquireRelease(
@@ -197,11 +174,7 @@ function withTmp<A, E, R>(
       return { tmp, vcs: { type: "git" as const, store: AbsolutePath.make(path.join(tmp.path, ".git")) } }
     }),
     ({ tmp }) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(
-    Effect.flatMap(({ tmp, vcs }) =>
-      f(tmp.path, vcs).pipe(provide(tmp.path, vcs, options?.watcher, options?.config ?? configLayer, options?.plugins)),
-    ),
-  )
+  ).pipe(Effect.flatMap(({ tmp, vcs }) => f(tmp.path, vcs).pipe(provide(tmp.path, vcs, options?.watcher))))
 }
 
 describe("LocationWatcher subscriptions", () => {
@@ -250,107 +223,6 @@ describe("LocationWatcher subscriptions", () => {
       { vcs: "hg", watcher },
     )
   })
-
-  it.live("reconciles config without duplicate subscriptions", () => {
-    const entries = { current: [] as Entry[] }
-    const subscriptions: Watcher.WatchInput[] = []
-    const counts = { active: 0, released: 0 }
-    const watcher = Layer.succeed(
-      Watcher.Service,
-      Watcher.Service.of({
-        subscribe: (input) =>
-          Effect.sync(() => {
-            subscriptions.push(input)
-            counts.active++
-            return Stream.never.pipe(
-              Stream.ensuring(
-                Effect.sync(() => {
-                  counts.active--
-                  counts.released++
-                }),
-              ),
-            )
-          }),
-      }),
-    )
-    const config = Layer.succeed(
-      Config.Service,
-      Config.Service.of({
-        entries: () => Effect.sync(() => entries.current),
-        update: () => Effect.die("unused config.update"),
-        changes: () => Stream.never,
-      }),
-    )
-    return Effect.gen(function* () {
-      yield* withTmp(
-        () =>
-          Effect.gen(function* () {
-            const policy = yield* LocationWatcherPolicy.Service
-            const bus = yield* Bus.Service
-            yield* Effect.sync(() => subscriptions.length).pipe(
-              Effect.filterOrFail((count) => count === 1),
-              Effect.retry(Schedule.spaced("10 millis")),
-            )
-            expect(counts.active).toBe(1)
-
-            entries.current = [new Document({ type: "document", info: new Info({ watcher: { ignore: [".git"] } }) })]
-            yield* ConfigLocationWatcherPlugin.Plugin.effect(
-              host({ event: { subscribe: () => bus.subscribe(Event.Updated) } }),
-            )
-            yield* Effect.sync(() => counts.active).pipe(
-              Effect.filterOrFail((count) => count === 0),
-              Effect.retry(Schedule.spaced("10 millis")),
-            )
-            expect(counts.released).toBe(1)
-
-            entries.current = []
-            yield* bus.publish(Event.Updated, {})
-            yield* Effect.sync(() => subscriptions.length).pipe(
-              Effect.filterOrFail((count) => count === 2),
-              Effect.retry(Schedule.spaced("10 millis")),
-            )
-            expect(counts.active).toBe(1)
-
-            yield* policy.reload()
-            expect(subscriptions).toHaveLength(2)
-          }),
-        { vcs: "git", watcher, config },
-      )
-      expect(counts.active).toBe(0)
-      expect(counts.released).toBe(2)
-    })
-  })
-
-  it.live("does not start before configured policy is ready", () => {
-    const subscriptions: Watcher.WatchInput[] = []
-    const watcher = Layer.succeed(
-      Watcher.Service,
-      Watcher.Service.of({
-        subscribe: (input) => Effect.sync(() => subscriptions.push(input)).pipe(Effect.as(Stream.never)),
-      }),
-    )
-    const plugins = makeLocationNode({
-      service: PluginSupervisor.Service,
-      layer: Layer.effect(
-        PluginSupervisor.Service,
-        Effect.gen(function* () {
-          const policy = yield* LocationWatcherPolicy.Service
-          yield* policy.transform((draft) => draft.add([".git"]))
-          return PluginSupervisor.Service.of({ flush: Effect.void })
-        }),
-      ),
-      deps: [LocationWatcherPolicy.node],
-    })
-    return withTmp(
-      () =>
-        Effect.gen(function* () {
-          yield* LocationWatcher.Service
-          yield* Effect.sleep("50 millis")
-          expect(subscriptions).toEqual([])
-        }),
-      { vcs: "git", watcher, plugins },
-    )
-  })
 })
 
 function wait(check: (event: WatcherEvent) => boolean) {

packages/core/test/npm.test.ts

@@ -35,17 +35,6 @@ describe("Npm.sanitize", () => {
   })
 })
 
-describe("Npm.isRegistryPackage", () => {
-  test("accepts registry packages and rejects unsupported install targets", async () => {
-    expect(await Npm.isRegistryPackage("plugin")).toBe(true)
-    expect(await Npm.isRegistryPackage("@acme/plugin@beta")).toBe(true)
-    expect(await Npm.isRegistryPackage("plugin@^1.2.0")).toBe(true)
-    expect(await Npm.isRegistryPackage("./plugin")).toBe(false)
-    expect(await Npm.isRegistryPackage("github:acme/plugin")).toBe(false)
-    expect(await Npm.isRegistryPackage("alias@npm:plugin@1.0.0")).toBe(false)
-  })
-})
-
 describe("Npm.add", () => {
   test("resolves cached scoped package specs without reifying", async () => {
     await using tmp = await tmpdir()
@@ -117,31 +106,3 @@ describe("Npm.add", () => {
     expect(entries.fallback.entrypoint).toEndWith("/index.js")
   })
 })
-
-describe("Npm.resolve", () => {
-  test("resolves a TUI entrypoint only when the package is already cached", async () => {
-    await using tmp = await tmpdir()
-    const cache = path.join(tmp.path, "cache")
-    const spec = "fixture-plugin@1.0.0"
-    const directory = path.join(cache, "packages", Npm.sanitize(spec), "node_modules", "fixture-plugin")
-    const missing = await Effect.gen(function* () {
-      const npm = yield* Npm.Service
-      return yield* npm.resolve(spec, { subpaths: ["tui"] })
-    }).pipe(Effect.scoped, Effect.provide(npmLayer(cache)), Effect.runPromise)
-    expect(missing.entrypoint).toBeUndefined()
-
-    await fs.mkdir(directory, { recursive: true })
-    await writePackage(directory, {
-      name: "fixture-plugin",
-      exports: { ".": "./index.js", "./tui": "./tui.js" },
-    })
-    await Bun.write(path.join(directory, "index.js"), "export default {}\n")
-    await Bun.write(path.join(directory, "tui.js"), "export default {}\n")
-
-    const resolved = await Effect.gen(function* () {
-      const npm = yield* Npm.Service
-      return yield* npm.resolve(spec, { subpaths: ["tui"] })
-    }).pipe(Effect.scoped, Effect.provide(npmLayer(cache)), Effect.runPromise)
-    expect(resolved.entrypoint).toEndWith("/tui.js")
-  })
-})

packages/core/test/plugin/fixture.ts

@@ -31,7 +31,6 @@ const npmLayer = Layer.succeed(
   Npm.Service,
   Npm.Service.of({
     add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
-    resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
     which: () => Effect.succeed(undefined),
   }),
 )

packages/core/test/plugin/provider-dynamic.test.ts

@@ -23,7 +23,6 @@ const itWithAISDK = testEffect(Layer.mergeAll(PluginTestLayer, AppNodeBuilder.bu
 function npmEntrypoint(entrypoint?: string) {
   return Npm.Service.of({
     add: () => Effect.succeed({ directory: "", entrypoint }),
-    resolve: () => Effect.succeed({ directory: "", entrypoint }),
     which: () => Effect.succeed(undefined),
   })
 }

packages/core/test/plugin/provider-sap-ai-core.test.ts

@@ -14,7 +14,6 @@ const fixtureProvider = new URL("./fixtures/provider-factory.ts", import.meta.ur
 const it = testEffect(PluginTestLayer)
 const npm = Npm.Service.of({
   add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
-  resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
   which: () => Effect.succeed(undefined),
 })
 

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

@@ -1,5 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Cause, Deferred, Effect, Exit, Layer, Queue } from "effect"
+import { Config } from "@opencode-ai/core/config"
+import { Document, Info } from "@opencode-ai/schema/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
@@ -7,7 +9,6 @@ import { Location } from "@opencode-ai/core/location"
 import { Pty } from "@opencode-ai/core/pty"
 import type { PtyID } from "@opencode-ai/core/pty/schema"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { ShellSelect } from "@opencode-ai/core/shell/select"
 import { location } from "../fixture/location"
 import { testEffect } from "../lib/effect"
 
@@ -17,7 +18,13 @@ const locationLayer = Layer.succeed(
   Location.Service,
   Location.Service.of(location({ directory: AbsolutePath.make("/tmp") })),
 )
-const it = testEffect(AppNodeBuilder.build(LayerNode.group([Pty.node, Bus.node]), [[Location.node, locationLayer]]))
+const configLayer = Layer.mock(Config.Service)({ entries: () => Effect.succeed([]) })
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([Pty.node, Bus.node]), [
+    [Config.node, configLayer],
+    [Location.node, locationLayer],
+  ]),
+)
 const ptyTest = process.platform === "win32" ? it.live.skip : it.live
 
 const subscribePtyEvents = Effect.fn("PtySessionTest.subscribePtyEvents")(function* () {
@@ -200,17 +207,26 @@ describe("pty", () => {
 
 const configuredShell = process.platform === "win32" ? undefined : Bun.which("bash")
 const configuredIt = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Pty.node, Bus.node, ShellSelect.node]), [[Location.node, locationLayer]]),
+  AppNodeBuilder.build(LayerNode.group([Pty.node, Bus.node]), [
+    [
+      Config.node,
+      Layer.mock(Config.Service)({
+        entries: () =>
+          Effect.succeed(
+            configuredShell ? [new Document({ type: "document", info: new Info({ shell: configuredShell }) })] : [],
+          ),
+      }),
+    ],
+    [Location.node, locationLayer],
+  ]),
 )
 const configuredTest = process.platform === "win32" ? configuredIt.live.skip : configuredIt.live
 
 describe("pty create defaults", () => {
-  configuredTest("defaults command, login args, and cwd from shell selection and location", () =>
+  configuredTest("defaults command, login args, and cwd from config and location", () =>
     Effect.gen(function* () {
       if (!configuredShell) return
       const pty = yield* Pty.Service
-      const shell = yield* ShellSelect.Service
-      yield* shell.transform((draft) => draft.configure(configuredShell))
       const info = yield* Effect.acquireRelease(pty.create({ title: "configured" }), (created) =>
         pty.remove(created.id).pipe(Effect.ignore),
       )

packages/core/test/session-compaction.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from "bun:test"
 import { LLMClient, LLMEvent, LanguageModel, type LLMRequest } from "@opencode-ai/ai"
 import { OpenAIChat } from "@opencode-ai/ai/protocols"
+import { Config } from "@opencode-ai/core/config"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { llmClient } from "@opencode-ai/core/effect/app-node-platform"
@@ -66,6 +67,7 @@ const client = Layer.mock(LLMClient.Service)({
   },
   generate: () => Effect.die("unused"),
 })
+const config = Layer.mock(Config.Service)({ entries: () => Effect.succeed([]) })
 const models = Layer.mock(SessionRunnerModel.Service)({
   resolve: () =>
     Effect.succeed(
@@ -81,6 +83,7 @@ const it = testEffect(
     [
       [Bus.node, Bus.configured({ persist: true })],
       [llmClient, client],
+      [Config.node, config],
       [SessionRunnerModel.node, models],
     ],
   ),

packages/core/test/session-prompt.test.ts

@@ -28,7 +28,6 @@ import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationServices } from "@opencode-ai/core/location-services"
 import { Image } from "@opencode-ai/core/image"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
-import { Snapshot } from "@opencode-ai/core/snapshot"
 import { testEffect } from "./lib/effect"
 
 const executionCalls: Session.ID[] = []
@@ -61,7 +60,7 @@ const locations = Layer.effect(
   LocationServiceMap.Service,
   LayerMap.make(
     () =>
-      // These operations resolve Location services lazily and must wait for plugin-projected state.
+      // Attachment admission only needs image normalization and plugin readiness.
       // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
       Layer.unwrap(
         Effect.sync(() => {
@@ -73,12 +72,6 @@ const locations = Layer.effect(
                   ? Effect.succeed(content.content.length > 5 * 1024 * 1024 ? { ...content, content: "AA==" } : content)
                   : Effect.die(new Error("Image service used before plugins were ready")),
             }),
-            Layer.mock(Snapshot.Service, {
-              capture: () =>
-                ready ? Effect.succeed(undefined) : Effect.die(new Error("Snapshot used before plugins were ready")),
-              restore: () =>
-                ready ? Effect.void : Effect.die(new Error("Snapshot used before plugins were ready")),
-            }),
             Layer.succeed(
               PluginSupervisor.Service,
               PluginSupervisor.Service.of({ flush: Effect.sync(() => (ready = true)) }),
@@ -1058,31 +1051,6 @@ describe("Session.prompt", () => {
   )
 })
 
-describe("Session.revert", () => {
-  it.effect("waits for location plugins before staging", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const { db } = yield* Database.Service
-      const session = yield* Session.Service
-      yield* db.insert(SessionMessageTable).values(assistantRow(messageID, 0)).run().pipe(Effect.orDie)
-      yield* session.revert.stage({ sessionID, messageID })
-    }),
-  )
-
-  it.effect("waits for location plugins before clearing", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      yield* bus.publish(SessionEvent.RevertEvent.Staged, {
-        sessionID,
-        revert: { messageID, snapshot: Snapshot.ID.make("tree"), files: [] },
-      })
-      yield* session.revert.clear(sessionID)
-    }),
-  )
-})
-
 describe("Session.inbox", () => {
   it.effect("fails for an unknown session", () =>
     Effect.gen(function* () {

packages/core/test/session-runner-tool-events.test.ts

@@ -353,12 +353,7 @@ test("content-filter finish retains failure evidence until step closeout", async
     publisher.publish(
       LLMEvent.stepFinish({
         index: 0,
-        reason: { normalized: "content-filter", raw: "refusal" },
-        providerMetadata: {
-          anthropic: {
-            stopDetails: { type: "refusal", category: "safety", explanation: "Blocked" },
-          },
-        },
+        reason: { normalized: "content-filter" },
         usage: {
           nonCachedInputTokens: 8,
           outputTokens: 3,
@@ -372,10 +367,6 @@ test("content-filter finish retains failure evidence until step closeout", async
   const settlement = publisher.record().finish
   expect(settlement).toMatchObject({
     finish: "content-filter",
-    rawFinish: "refusal",
-    providerState: {
-      stopDetails: { type: "refusal", category: "safety", explanation: "Blocked" },
-    },
     tokens: { input: 8, output: 2, reasoning: 1 },
   })
   if (!settlement) throw new Error("Expected content-filter settlement")
@@ -390,11 +381,6 @@ test("content-filter finish retains failure evidence until step closeout", async
   expect(published.map((event) => event.type)).toEqual(["session.step.started.1", "session.step.failed.1"])
   expect(published.at(-1)?.data).toMatchObject({
     error: { type: "provider.content-filter", message: "Provider blocked the response" },
-    finish: "content-filter",
-    rawFinish: "refusal",
-    providerState: {
-      stopDetails: { type: "refusal", category: "safety", explanation: "Blocked" },
-    },
     cost: 1.25,
     tokens: { input: 8, output: 2, reasoning: 1 },
     snapshot: "tree-end",

packages/core/test/session-runner.test.ts

@@ -4161,49 +4161,13 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("persists raw finish reasons and provider state", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* TestLLM.push(
-        TestLLM.complete(
-          {
-            reason: { normalized: "stop", raw: "end_turn" },
-            providerMetadata: { openai: { responseId: "response-1", serviceTier: "priority" } },
-          },
-          LLMEvent.textStart({ id: "answer" }),
-          LLMEvent.textDelta({ id: "answer", text: "Complete" }),
-          LLMEvent.textEnd({ id: "answer" }),
-        ),
-      )
-
-      yield* runPrompt(session, "Keep provider finish details")
-
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user" },
-        {
-          type: "assistant",
-          finish: "stop",
-          rawFinish: "end_turn",
-          providerState: { responseId: "response-1", serviceTier: "priority" },
-          content: [{ type: "text", text: "Complete" }],
-        },
-      ])
-    }),
-  )
-
   it.effect("projects content-filter finishes as visible terminal failures", () =>
     Effect.gen(function* () {
       const session = yield* setup
       yield* TestLLM.push(
         TestLLM.complete(
           {
-            reason: { normalized: "content-filter", raw: "SAFETY" },
-            providerMetadata: {
-              openai: {
-                responseId: "response-blocked",
-                refusal: { category: "safety", explanation: "Prompt blocked" },
-              },
-            },
+            reason: { normalized: "content-filter" },
             usage: { nonCachedInputTokens: 8, outputTokens: 3, reasoningTokens: 1 },
           },
           LLMEvent.textStart({ id: "partial" }),
@@ -4218,12 +4182,7 @@ describe("SessionRunnerLLM", () => {
         { type: "user" },
         {
           type: "assistant",
-          finish: "content-filter",
-          rawFinish: "SAFETY",
-          providerState: {
-            responseId: "response-blocked",
-            refusal: { category: "safety", explanation: "Prompt blocked" },
-          },
+          finish: "error",
           error: { type: "provider.content-filter" },
           cost: 0,
           tokens: { input: 8, output: 2, reasoning: 1, cache: { read: 0, write: 0 } },

packages/core/test/snapshot.test.ts

@@ -127,31 +127,6 @@ describe("Snapshot", () => {
     ),
   )
 
-  testEffect(Layer.empty).live("applies availability transforms", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.gen(function* () {
-          const project = path.join(tmp.path, "project")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(project)
-            await fs.writeFile(path.join(project, "tracked.txt"), "one\n")
-            await initGit(project)
-          })
-
-          yield* Effect.gen(function* () {
-            const snapshot = yield* Snapshot.Service
-            const registration = yield* snapshot.transform((draft) => draft.configure(false))
-            expect(yield* snapshot.capture()).toBeUndefined()
-
-            yield* registration.dispose
-            expect(yield* snapshot.capture()).toBeDefined()
-          }).pipe(Effect.provide(snapshotLayer(tmp.path, project)))
-        }),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
   testEffect(Layer.empty).live("treats capture outside Git as unavailable", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/tool-output.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect } from "bun:test"
 import path from "path"
 import { Effect } from "effect"
+import { Config } from "@opencode-ai/core/config"
+import { Document, Info } from "@opencode-ai/schema/config"
+import { ConfigToolOutput } from "@opencode-ai/schema/config/tool-output"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { ToolOutput } from "@opencode-ai/core/tool-output"
@@ -12,18 +15,18 @@ import { it } from "./lib/effect"
 
 const withStore = <A, E, R>(
   body: (output: ToolOutput.Interface, fs: FSUtil.Interface, root: string) => Effect.Effect<A, E, R>,
-  limits?: { maxLines?: number; maxBytes?: number },
+  info = new Info(),
 ) =>
   Effect.acquireUseRelease(
     Effect.promise(() => tmpdir()),
     (tmp) => {
+      const config = Config.testLayer([new Document({ type: "document", info })])
       const layer = AppNodeBuilder.build(LayerNode.group([ToolOutput.node, FSUtil.node]), [
+        [Config.node, config],
         [Global.node, Global.layerWith({ data: tmp.path })],
       ])
       return Effect.gen(function* () {
-        const output = yield* ToolOutput.Service
-        if (limits) yield* output.transform((draft) => draft.configure(limits))
-        return yield* body(output, yield* FSUtil.Service, tmp.path)
+        return yield* body(yield* ToolOutput.Service, yield* FSUtil.Service, tmp.path)
       }).pipe(Effect.provide(layer))
     },
     (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
@@ -47,7 +50,7 @@ describe("ToolOutput", () => {
             { type: "text", text: `... 1 line truncated; full content saved to ${outputPath} ...` },
           ])
         }),
-      { maxLines: 2, maxBytes: 1_000 },
+      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
     ),
   )
 
@@ -64,7 +67,7 @@ describe("ToolOutput", () => {
             },
           ])
         }),
-      { maxLines: 100, maxBytes: 5 },
+      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 100, max_bytes: 5 }) }),
     ),
   )
 
@@ -83,7 +86,7 @@ describe("ToolOutput", () => {
             { type: "text", text: expect.stringMatching(/^\.\.\. 1 line truncated; full content saved to /) },
           ])
         }),
-      { maxLines: 2, maxBytes: 1_000 },
+      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
     ),
   )
 
@@ -116,7 +119,7 @@ describe("ToolOutput", () => {
             metadata: { truncated: false },
           })
         }),
-      { maxLines: 2, maxBytes: 1_000 },
+      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
     ),
   )
 
@@ -130,7 +133,7 @@ describe("ToolOutput", () => {
             { type: "text", text: expect.stringMatching(/^\.\.\. 1 byte truncated; full content saved to /) },
           ])
         }),
-      { maxLines: 2, maxBytes: 3 },
+      new Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 3 }) }),
     ),
   )
 

packages/core/test/tool-shell.test.ts

@@ -32,7 +32,6 @@ import { Permission } from "@opencode-ai/core/permission"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { Shell } from "@opencode-ai/core/shell"
-import { ShellPolicy } from "@opencode-ai/core/shell/policy"
 import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { ShellTool } from "@opencode-ai/core/tool/plugin/shell"
 import { ToolOutput } from "@opencode-ai/core/tool-output"
@@ -132,14 +131,13 @@ const shellPluginSupervisor = makeLocationNode({
     registerToolPlugin(ShellTool.Plugin).pipe(Effect.as(PluginSupervisor.Service.of({ flush: Effect.void }))),
   ),
   deps: [
+    Config.node,
     Environment.node,
     LocationMutation.node,
     Permission.node,
     PluginRuntime.node,
     Shell.node,
-    ShellPolicy.node,
     Tool.node,
-    ToolOutput.node,
   ],
 })
 
@@ -545,7 +543,7 @@ describe("ShellTool", () => {
     { timeout: 15_000 },
   )
 
-  productionIt.live("does not add external-directory permission for an experimental portable heredoc", () =>
+  it.live("does not add external-directory permission for an experimental portable heredoc", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
       (tmp) =>
@@ -626,7 +624,7 @@ describe("ShellTool", () => {
     { timeout: 15_000 },
   )
 
-  productionIt.live("uses configured line limits", () =>
+  it.live("uses configured line limits", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => {

packages/core/test/tool-webfetch.test.ts

@@ -23,8 +23,6 @@ const webFetchToolNode = makeLocationNode({
 })
 
 const sessionID = Session.ID.make("ses_webfetch_test")
-const webFetchUserAgent =
-  "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OpenCode-User/1.0; +https://opencode.ai"
 const requests: Array<{ readonly url: string; readonly headers: Record<string, string> }> = []
 const assertions: Permission.AssertInput[] = []
 let respond = (_request: HttpClientRequest.HttpClientRequest) =>
@@ -378,17 +376,7 @@ describe("WebFetchTool registration", () => {
       expect(assertions).toMatchObject([
         { sessionID, action: "webfetch", resources: [url], save: ["*"], metadata: { url, format: "text", timeout: 4 } },
       ])
-      expect(requests).toMatchObject([
-        {
-          url,
-          headers: {
-            accept: "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1",
-            "accept-language": "en-US,en;q=0.9",
-            "user-agent": webFetchUserAgent,
-          },
-        },
-      ])
-      expect(requests[0]?.headers).not.toHaveProperty("sec-fetch-mode")
+      expect(requests).toMatchObject([{ url, headers: { accept: expect.stringContaining("text/plain;q=1.0") } }])
     }),
   )
 
@@ -409,23 +397,15 @@ describe("WebFetchTool registration", () => {
     }),
   )
 
-  live.effect("follows redirects while approving only the requested URL", () => {
-    const received: Array<Record<string, string | null>> = []
-    return Effect.acquireUseRelease(
+  live.effect("follows redirects while approving only the requested URL", () =>
+    Effect.acquireUseRelease(
       Effect.sync(() =>
         Bun.serve({
           port: 0,
-          fetch: (request) => {
-            received.push({
-              accept: request.headers.get("accept"),
-              "accept-language": request.headers.get("accept-language"),
-              "sec-fetch-mode": request.headers.get("sec-fetch-mode"),
-              "user-agent": request.headers.get("user-agent"),
-            })
-            if (new URL(request.url).pathname === "/redirect")
-              return new Response("", { status: 302, headers: { location: "/target" } })
-            return new Response("redirected", { headers: { "content-type": "text/plain" } })
-          },
+          fetch: (request) =>
+            new URL(request.url).pathname === "/redirect"
+              ? new Response("", { status: 302, headers: { location: "/target" } })
+              : new Response("redirected", { headers: { "content-type": "text/plain" } }),
         }),
       ),
       (server) =>
@@ -441,18 +421,10 @@ describe("WebFetchTool registration", () => {
           expect(assertions).toMatchObject([
             { sessionID, action: "webfetch", resources: [url], save: ["*"], metadata: { url, format: "text" } },
           ])
-          expect(received).toEqual(
-            Array.from({ length: 2 }, () => ({
-              accept: "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1",
-              "accept-language": "en-US,en;q=0.9",
-              "sec-fetch-mode": null,
-              "user-agent": webFetchUserAgent,
-            })),
-          )
         }),
       (server) => Effect.promise(() => server.stop(true)),
-    )
-  })
+    ),
+  )
 
   it.effect("rejects non-HTTP schemes before permission or transport", () =>
     Effect.gen(function* () {
@@ -577,7 +549,7 @@ describe("WebFetchTool registration", () => {
         content: [{ type: "text", text: "ok" }],
       })
       expect(requests).toHaveLength(2)
-      expect(requests[0]?.headers["user-agent"]).toBe(webFetchUserAgent)
+      expect(requests[0]?.headers["user-agent"]).toContain("Mozilla/5.0")
       expect(requests[1]?.headers["user-agent"]).toBe("opencode")
     }),
   )

packages/desktop/src/main/service/background-service.ts

@@ -43,16 +43,14 @@ export async function startBackgroundCli(logger: Logger) {
     onStart: (reason, previousVersion) => logger.log("v2 CLI background service starting", { reason, previousVersion }),
   })
   if (service.auth?.type !== "basic") throw new Error("V2 CLI background service did not provide authentication")
-  const url = new URL(service.url)
-  if (url.hostname === "0.0.0.0") url.hostname = "127.0.0.1"
   logger.log("v2 CLI background service ready", {
     username: service.auth.username,
     version: cli.version,
-    ...endpoint(url.origin),
+    ...endpoint(service.url),
   })
   if (isolated && cli.binary) await cleanCliStages(cli.binary, logger)
   return {
-    url: url.origin,
+    url: service.url,
     username: service.auth.username,
     password: service.auth.password,
     version: cli.version,

packages/schema/src/session-event.ts

@@ -298,8 +298,6 @@ export namespace Step {
       ...Base,
       assistantMessageID: SessionMessage.ID,
       finish: FinishReason,
-      rawFinish: Schema.String.pipe(optional),
-      providerState: SessionMessage.ProviderState.pipe(optional),
       cost: Money.USD,
       tokens: TokenUsage.Info,
       snapshot: Snapshot.ID.pipe(optional),
@@ -315,9 +313,6 @@ export namespace Step {
       ...Base,
       assistantMessageID: SessionMessage.ID,
       error: SessionError.Error,
-      finish: Schema.Literals(["content-filter"]).pipe(optional),
-      rawFinish: Schema.String.pipe(optional),
-      providerState: SessionMessage.ProviderState.pipe(optional),
       cost: Money.USD.pipe(optional),
       tokens: TokenUsage.Info.pipe(optional),
       snapshot: Snapshot.ID.pipe(optional),

packages/schema/src/session-message.ts

@@ -215,8 +215,6 @@ export const Assistant = Schema.Struct({
     files: Schema.Array(RelativePath).pipe(optional),
   }).pipe(optional),
   finish: FinishReason.pipe(optional),
-  rawFinish: Schema.String.pipe(optional),
-  providerState: ProviderState.pipe(optional),
   cost: Money.USD.pipe(optional),
   tokens: TokenUsage.Info.pipe(optional),
   error: SessionError.Error.pipe(optional),

packages/schema/test/session-terminal.test.ts

@@ -1,50 +0,0 @@
-import { expect, test } from "bun:test"
-import { Schema } from "effect"
-import { SessionEvent } from "../src/session-event.js"
-import { SessionMessage } from "../src/session-message.js"
-
-const assistant = {
-  id: "msg_terminal",
-  type: "assistant" as const,
-  agent: "build",
-  model: { providerID: "openai", id: "gpt-test" },
-  content: [],
-  time: { created: 0 },
-}
-
-test("assistant terminal diagnostics remain optional and round trip", () => {
-  const decode = Schema.decodeUnknownSync(SessionMessage.Assistant)
-  const encode = Schema.encodeSync(SessionMessage.Assistant)
-
-  expect(encode(decode(assistant))).toEqual(assistant)
-  expect(
-    encode(
-      decode({
-        ...assistant,
-        finish: "content-filter",
-        rawFinish: "SAFETY",
-        providerState: { promptFeedback: { blockReason: "SAFETY" } },
-      }),
-    ),
-  ).toMatchObject({
-    finish: "content-filter",
-    rawFinish: "SAFETY",
-    providerState: { promptFeedback: { blockReason: "SAFETY" } },
-  })
-})
-
-test("failed steps only override the assistant finish for content filters", () => {
-  const decode = Schema.decodeUnknownSync(SessionEvent.Step.Failed.data)
-  const input = {
-    sessionID: "ses_terminal",
-    assistantMessageID: "msg_terminal",
-    error: { type: "provider.content-filter", message: "Blocked" },
-  }
-
-  expect(decode(input)).toMatchObject(input)
-  expect(decode({ ...input, finish: "content-filter", rawFinish: "SAFETY" })).toMatchObject({
-    finish: "content-filter",
-    rawFinish: "SAFETY",
-  })
-  expect(() => decode({ ...input, finish: "stop" })).toThrow()
-})

packages/server/src/handlers/pty.ts

@@ -1,7 +1,6 @@
 import { Pty } from "@opencode-ai/core/pty"
 import { PtyProtocol } from "@opencode-ai/core/pty/protocol"
 import { PtyTicket } from "@opencode-ai/core/pty/ticket"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor-service"
 import { Location } from "@opencode-ai/core/location"
 import { Effect, Queue } from "effect"
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
@@ -40,8 +39,6 @@ export const PtyHandler = HttpApiBuilder.group(Api, "server.pty", (handlers) =>
       .handle(
         "pty.create",
         Effect.fn(function* (ctx) {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush
           const pty = yield* Pty.Service
           const location = yield* Location.Service
           const cwd = ctx.payload.cwd || location.directory

packages/server/src/handlers/shell.ts

@@ -1,6 +1,5 @@
 import { Shell } from "@opencode-ai/core/shell"
 import { Location } from "@opencode-ai/core/location"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor-service"
 import { Effect } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
 import { ShellNotFoundError } from "@opencode-ai/protocol/errors"
@@ -20,8 +19,6 @@ export const ShellHandler = HttpApiBuilder.group(Api, "server.shell", (handlers)
       .handle(
         "shell.create",
         Effect.fn(function* (ctx) {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush
           const shell = yield* Shell.Service
           const location = yield* Location.Service
           return yield* response(

packages/server/src/routes.ts

@@ -9,12 +9,14 @@ import { EventLogger } from "@opencode-ai/core/event-logger"
 import { FileSystemSearch } from "@opencode-ai/core/filesystem/search"
 import { Credential } from "@opencode-ai/core/credential"
 import { Config } from "@opencode-ai/core/config"
+import { Command } from "@opencode-ai/core/command"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { PtyTicket } from "@opencode-ai/core/pty/ticket"
+import { Pty } from "@opencode-ai/core/pty"
 import { Project } from "@opencode-ai/core/project"
 import { Session } from "@opencode-ai/core/session"
 import { SessionTransfer } from "@opencode-ai/core/session/transfer"
-import { ShellSelect } from "@opencode-ai/core/shell/select"
+import { Shell } from "@opencode-ai/core/shell"
 import { Job } from "@opencode-ai/core/job"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { Global } from "@opencode-ai/util/global"
@@ -113,7 +115,9 @@ function makeRoutes<AuthError, AuthServices>(
       }),
     ],
     [InstructionDiscovery.node, InstructionDiscovery.configured({ project: options.config?.project })],
-    [ShellSelect.node, ShellSelect.configured({ gitbash: options.windows?.gitbash })],
+    [Command.node, Command.configured({ gitbash: options.windows?.gitbash })],
+    [Pty.node, Pty.configured({ gitbash: options.windows?.gitbash })],
+    [Shell.node, Shell.configured({ gitbash: options.windows?.gitbash })],
     [
       MCP.node,
       MCP.configured({

packages/theme/src/tui/defaults.ts

@@ -111,7 +111,6 @@ export const DEFAULT_THEME = {
       subdued: "$hue.neutral.600",
       action: {
         primary: { default: "$hue.neutral.200", $disabled: "$hue.neutral.500" },
-        secondary: { default: "$text.subdued", $hovered: "$text.default" },
         destructive: { default: "$hue.red.200", $disabled: "$hue.neutral.500" },
       },
       formfield: {
@@ -143,7 +142,6 @@ export const DEFAULT_THEME = {
           $selected: "$hue.interactive.700",
           $disabled: "$hue.neutral.300",
         },
-        secondary: { default: "transparent" },
         destructive: {
           default: "$hue.red.600",
           $hovered: "$hue.red.700",
@@ -326,7 +324,6 @@ export const DEFAULT_THEME = {
       subdued: "$hue.neutral.400",
       action: {
         primary: { default: "$hue.neutral.200", $disabled: "$hue.neutral.500" },
-        secondary: { default: "$text.subdued", $hovered: "$text.default" },
         destructive: { default: "$hue.red.200", $disabled: "$hue.neutral.500" },
       },
       formfield: {
@@ -358,7 +355,6 @@ export const DEFAULT_THEME = {
           $selected: "$hue.interactive.600",
           $disabled: "$hue.neutral.800",
         },
-        secondary: { default: "transparent" },
         destructive: {
           default: "$hue.red.600",
           $hovered: "$hue.red.700",

packages/theme/src/tui/schema.ts

@@ -9,7 +9,7 @@ export type BaseHue = Schema.Schema.Type<typeof BaseHue>
 export const HueAlias = Schema.Literals(["accent", "interactive", "neutral"])
 export type HueAlias = Schema.Schema.Type<typeof HueAlias>
 
-export const ActionVariant = Schema.Literals(["primary", "secondary", "destructive"])
+export const ActionVariant = Schema.Literals(["primary", "destructive"])
 export type ActionVariant = Schema.Schema.Type<typeof ActionVariant>
 
 export const ActionState = Schema.Literals(["disabled", "pressed", "focused", "selected", "hovered"])
@@ -90,7 +90,6 @@ export type FormfieldColorDefinition = StatefulColorDefinition
 
 const ActionColorDefinition = Schema.Struct({
   primary: Schema.optional(StatefulColorDefinition),
-  secondary: Schema.optional(StatefulColorDefinition),
   destructive: Schema.optional(StatefulColorDefinition),
 })
 

packages/theme/src/tui/v1-migrate.ts

@@ -82,7 +82,6 @@ function migrateMode(theme: Theme, mode: Mode): FileThemeDefinition {
           $focused: selected,
           $selected: primary,
         },
-        secondary: { default: "$text.subdued", $hovered: "$text.default" },
         destructive: { default: destructive, $disabled: textMuted },
       },
       formfield: {
@@ -108,7 +107,6 @@ function migrateMode(theme: Theme, mode: Mode): FileThemeDefinition {
       },
       action: {
         primary: { default: "transparent", $hovered: backgroundPanel, $focused: primary, $selected: "transparent" },
-        secondary: { default: "transparent" },
         destructive: { default: color("error") },
       },
       formfield: {

packages/tui/package.json

@@ -24,7 +24,6 @@
     "./context/client": "./src/context/client.tsx",
     "./context/theme": "./src/context/theme.tsx",
     "./theme/discovery": "./src/theme/discovery.ts",
-    "./plugin/discovery": "./src/plugin/discovery.ts",
     "./context/editor": "./src/context/editor.ts",
     "./context/clipboard": "./src/context/clipboard.tsx",
     "./attention": "./src/attention.ts",

packages/tui/src/feature-plugins/prompt/footer.tsx

@@ -1,5 +1,5 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
-import { createMemo, createSignal, Match, Show, Switch } from "solid-js"
+import { createMemo, Match, Show, Switch } from "solid-js"
 import { contextUsage, formatContextUsage } from "../../util/session"
 import { useTerminalDimensions } from "@opentui/solid"
 
@@ -10,7 +10,6 @@ const money = new Intl.NumberFormat("en-US", {
 
 export function PromptFooter(props: { context: Plugin.Context; sessionID?: string; mode: "normal" | "shell" }) {
   const dimensions = useTerminalDimensions()
-  const [liveHovered, setLiveHovered] = createSignal(false)
   const subagents = createMemo(() => {
     if (!props.sessionID) return 0
     const count = props.context.data.session
@@ -48,34 +47,16 @@ export function PromptFooter(props: { context: Plugin.Context; sessionID?: strin
       <Match when={props.mode === "normal"}>
         <Switch>
           <Match when={live() || status().length > 0}>
-            <box flexDirection="row" flexShrink={1} minWidth={0}>
-              <Show when={live()}>
-                <box
-                  flexShrink={0}
-                  onMouseOver={() => setLiveHovered(true)}
-                  onMouseOut={() => setLiveHovered(false)}
-                  onMouseUp={() => props.context.keymap.dispatch("session.child.first")}
-                >
-                  <text
-                    fg={liveHovered() ? props.context.theme.text.default : props.context.theme.text.subdued}
-                    wrapMode="none"
-                  >
-                    <Show when={shortcut("session.child.first")}>
-                      {(value) => <span style={{ fg: props.context.theme.text.default }}>{value()} </span>}
-                    </Show>
-                    <Show when={subagents()}>{(value) => <>{value()}</>}</Show>
-                    <Show when={subagents() && shells()}> · </Show>
-                    <Show when={shells()}>{(value) => <>{value()}</>}</Show>
-                  </text>
-                </box>
+            <text fg={props.context.theme.text.subdued} wrapMode="none" truncate flexShrink={1}>
+              <Show when={live() && shortcut("session.child.first")}>
+                {(value) => <span style={{ fg: props.context.theme.text.default }}>{value()} </span>}
               </Show>
-              <Show when={status().length > 0}>
-                <text fg={props.context.theme.text.subdued} wrapMode="none" truncate flexShrink={1}>
-                  <Show when={live()}> · </Show>
-                  {status().join(" · ")}
-                </text>
-              </Show>
-            </box>
+              <Show when={subagents()}>{(value) => <span>{value()}</span>}</Show>
+              <Show when={subagents() && shells()}> · </Show>
+              <Show when={shells()}>{(value) => <span>{value()}</span>}</Show>
+              <Show when={live() && status().length > 0}> · </Show>
+              <Show when={status().length > 0}>{status().join(" · ")}</Show>
+            </text>
           </Match>
           <Match when={dimensions().width >= 44}>
             <text fg={props.context.theme.text.default} flexShrink={0}>

packages/tui/src/plugin/context.tsx

@@ -1,4 +1,3 @@
-import type { PluginInfo } from "@opencode-ai/client"
 import type { Plugin } from "@opencode-ai/plugin/tui"
 import { createMarkdownCodeBlockRenderer, type MarkdownCodeBlockRenderer, type MarkdownOptions } from "@opentui/core"
 import {
@@ -6,7 +5,6 @@ import {
   createContext,
   createEffect,
   createMemo,
-  createSignal,
   on,
   onCleanup,
   onMount,
@@ -14,18 +12,15 @@ import {
   type ParentProps,
 } from "solid-js"
 import path from "path"
-import { readFile, stat } from "fs/promises"
+import { stat } from "fs/promises"
 import { fileURLToPath, pathToFileURL } from "url"
 import type { Page } from "@opencode-ai/plugin/tui/context"
-import { Hash } from "@opencode-ai/util/hash"
 import { resolveSlots, type Claim } from "./structure"
 import { createStore, produce, reconcile as reconcileStore, unwrap } from "solid-js/store"
 import { isDeepEqual } from "remeda"
 import "#runtime-plugin-support"
 import { useConfig } from "../config"
 import { useTuiLifecycle } from "../context/runtime"
-import { useClient } from "../context/client"
-import { useData } from "../context/data"
 import { errorMessage } from "../util/error"
 import { builtins } from "./builtins"
 import { createPluginContext, usePluginHost, type Dispose, type RegisteredSlot, type SlotRender } from "./api"
@@ -33,7 +28,7 @@ import { createSourceWatcher } from "./watch"
 import { discoverTuiPlugins, freshSpecifier, localSource } from "./discovery"
 
 export interface PackageResolver {
-  readonly resolve: (spec: string, install?: boolean) => Promise<string | undefined>
+  readonly resolve: (spec: string) => Promise<string | undefined>
 }
 
 type State =
@@ -79,7 +74,6 @@ type Registration = {
 type Desired = Pick<Registration, "plugin" | "source" | "target" | "version" | "options"> & { enabled: boolean }
 
 const PluginContext = createContext<Value>()
-let sourceVersion = Date.now()
 
 export function combineMarkdownRenderers(
   sources: ReadonlyArray<Readonly<Record<string, MarkdownCodeBlockRenderer>>>,
@@ -96,31 +90,12 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
   const host = usePluginHost()
   const config = useConfig()
   const lifecycle = useTuiLifecycle()
-  const client = useClient()
-  const data = useData()
-  const [serverPlugins, setServerPlugins] = createSignal<
-    ReadonlyArray<
-      Extract<PluginInfo, { readonly status: "active" }> & { readonly source: { readonly type: "package" } }
-    >
-  >([])
   const directory = config.path ? path.dirname(config.path) : process.cwd()
   const [store, setStore] = createStore({
     ready: false,
     states: [] as ReadonlyArray<State>,
     registrations: {} as Record<string, Registration>,
   })
-  // One save can emit several watch events. Remember setup failures so those
-  // events do not repeatedly tear down and restore the last good generation.
-  const setupFailures = new Map<string, { version: string; options: Registration["options"]; error: string }>()
-  const sourceVersions = new Map<string, { digest: string; generation: number }>()
-  const sourceGeneration = async (entrypoint: string) => {
-    const digest = Hash.sha256(await readFile(new URL(entrypoint)))
-    const previous = sourceVersions.get(entrypoint)
-    if (previous?.digest === digest) return previous.generation
-    const generation = ++sourceVersion
-    sourceVersions.set(entrypoint, { digest, generation })
-    return generation
-  }
   const markdown = createMemo(() =>
     combineMarkdownRenderers(
       Object.values(store.registrations).flatMap((registration) =>
@@ -128,18 +103,15 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
       ),
     ),
   )
-  const clearContributions = (id: string) => {
-    setStore("registrations", id, "routes", reconcileStore({}))
-    setStore("registrations", id, "slots", reconcileStore({}))
-    setStore("registrations", id, "markdown", reconcileStore({}))
-  }
 
   const activate = async (id: string) => {
     const item = store.registrations[id]
     if (!item) return false
     await deactivate(id)
     batch(() => {
-      clearContributions(id)
+      setStore("registrations", id, "routes", reconcileStore({}))
+      setStore("registrations", id, "slots", reconcileStore({}))
+      setStore("registrations", id, "markdown", reconcileStore({}))
       setStore("registrations", id, "cleanups", [])
     })
     const owned: Dispose[] = []
@@ -167,17 +139,12 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
       },
     })
     const cleanup = await setup(item.plugin, context, owned).catch((error) => {
-      clearContributions(id)
-      if (item.target)
-        setupFailures.set(item.target, {
-          version: item.version,
-          options: snapshotOptions(item.options),
-          error: errorMessage(error),
-        })
+      setStore("registrations", id, "routes", reconcileStore({}))
+      setStore("registrations", id, "slots", reconcileStore({}))
+      setStore("registrations", id, "markdown", reconcileStore({}))
       throw error
     })
     if (cleanup) owned.push(async () => cleanup())
-    if (item.target && sameGeneration(setupFailures.get(item.target), item)) setupFailures.delete(item.target)
     batch(() => {
       setStore("registrations", id, "cleanups", owned)
       setStore("registrations", id, "active", true)
@@ -201,7 +168,9 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
     await disposeAll(cleanups).finally(() =>
       batch(() => {
         if (store.registrations[id]) {
-          clearContributions(id)
+          setStore("registrations", id, "routes", reconcileStore({}))
+          setStore("registrations", id, "slots", reconcileStore({}))
+          setStore("registrations", id, "markdown", reconcileStore({}))
         }
         setStore("states", (items) =>
           items.map((state) =>
@@ -261,11 +230,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
   const npmFailures = new Map<string, string>()
   const reconcile = async () => {
     await Promise.all(props.directories.map(watcher.wait))
-    const entries = [
-      ...(await discoverTuiPlugins(props.directories)).map((entry) => ({ entry, install: true, server: false })),
-      ...serverPlugins().map((plugin) => ({ entry: plugin.source.package, install: false, server: true })),
-      ...(config.data.plugins ?? []).map((entry) => ({ entry, install: true, server: false })),
-    ]
+    const entries = [...(await discoverTuiPlugins(props.directories)), ...(config.data.plugins ?? [])]
 
     // Resolve: fold entries into one desired generation. A source that fails
     // to import keeps its running previous version and only reports failure.
@@ -273,8 +238,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
     for (const plugin of builtins)
       desired.set(plugin.id, { plugin, source: "builtin", version: "builtin", enabled: true })
     const failures: State[] = []
-    for (const source of entries) {
-      const entry = source.entry
+    for (const entry of entries) {
       const target = typeof entry === "string" ? entry : entry.package
       if (target.startsWith("-")) {
         for (const item of desired.values()) if (matches(target.slice(1), item.plugin.id)) item.enabled = false
@@ -295,14 +259,11 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
       const memo = local ? undefined : npmFailures.get(target)
       const resolved = memo
         ? { status: "failed" as const, error: memo }
-        : await resolvePlugin(target, local, options, previous, props.packages, source.install, sourceGeneration).catch(
-            (error) => ({
-              status: "failed" as const,
-              error: errorMessage(error),
-            }),
-          )
+        : await resolvePlugin(target, local, options, previous, props.packages).catch((error) => ({
+            status: "failed" as const,
+            error: errorMessage(error),
+          }))
       if (resolved.status === "unsupported") {
-        if (source.server) continue
         failures.push({ target, status: "unsupported" })
         continue
       }
@@ -314,21 +275,17 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
           status: "failed",
           error: previous?.active ? `${resolved.error} (previous version still active)` : resolved.error,
         })
-        if (previous) desired.set(previous.plugin.id, toDesired(previous))
+        if (previous)
+          desired.set(previous.plugin.id, {
+            plugin: previous.plugin,
+            source: previous.source,
+            target,
+            version: previous.version,
+            options: previous.options,
+            enabled: previous.active,
+          })
         continue
       }
-      const setupFailure = setupFailures.get(target)
-      if (setupFailure && sameGeneration(setupFailure, { version: resolved.version, options }) && previous) {
-        failures.push({
-          target,
-          id: previous.plugin.id,
-          status: "failed",
-          error: previous.active ? `${setupFailure.error} (previous version still active)` : setupFailure.error,
-        })
-        desired.set(previous.plugin.id, toDesired(previous))
-        continue
-      }
-      setupFailures.delete(target)
       desired.set(resolved.plugin.id, {
         plugin: resolved.plugin,
         source: "external",
@@ -361,7 +318,11 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
           // enabled derives from config directives alone, so config wins over
           // manual dialog toggles on every reconcile — the same semantics
           // config saves had before hot reload existed, just more frequent.
-          return !sameGeneration(registration, item) || registration.active !== item.enabled
+          return (
+            registration.version !== item.version ||
+            !sameOptions(registration.options, item.options) ||
+            registration.active !== item.enabled
+          )
         })
 
     // Swap: cleanup failures surface as a toast, never propagate, so one
@@ -370,11 +331,22 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
     for (const id of changed) {
       const item = desired.get(id)!
       const registration = store.registrations[id]
-      const replaced = !registration || !sameGeneration(registration, item)
+      const replaced =
+        !registration || registration.version !== item.version || !sameOptions(registration.options, item.options)
       // Snapshot the running version before it is overwritten: an import
       // failure keeps last-good in the resolve phase, and a setup failure
       // must not cost the previous version either.
-      const fallback = replaced && registration ? toDesired(registration) : undefined
+      const fallback: Desired | undefined =
+        replaced && registration
+          ? {
+              plugin: registration.plugin,
+              source: registration.source,
+              target: registration.target,
+              version: registration.version,
+              options: registration.options,
+              enabled: registration.active,
+            }
+          : undefined
       if (replaced) {
         if (registration) await deactivateNoisily(id)
         // In-place replacement keeps the registration's key position, which
@@ -467,7 +439,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
   const resolved = createMemo(() => resolveSlots({ paths: new Set(Object.keys(mounted)), claims: claims() }))
   createEffect(
     on(
-      () => JSON.stringify([serverPlugins(), config.data.plugins ?? []]),
+      () => JSON.stringify(config.data.plugins ?? []),
       () => {
         npmFailures.clear()
         void enqueue(reconcile).then(
@@ -477,29 +449,6 @@ export function PluginProvider(props: ParentProps<{ packages: PackageResolver; d
       },
     ),
   )
-  const syncServerPlugins = () =>
-    client.api.plugin
-      .list({ location: data.location.default() })
-      .then((response) =>
-        setServerPlugins(
-          response.data.filter(
-            (
-              plugin,
-            ): plugin is Extract<PluginInfo, { readonly status: "active" }> & {
-              readonly source: { readonly type: "package" }
-            } => plugin.status === "active" && plugin.tui && plugin.source.type === "package",
-          ),
-        ),
-      )
-      .catch(() => undefined)
-  createEffect(
-    on(
-      () => JSON.stringify(data.location.default()),
-      () => void syncServerPlugins(),
-    ),
-  )
-  onCleanup(client.event.on("plugin.updated", syncServerPlugins))
-  onCleanup(client.event.on("server.connected", syncServerPlugins))
   onMount(() => {
     let disposing: Promise<void> | undefined
     const dispose = () => {
@@ -574,18 +523,16 @@ async function resolvePlugin(
   options: Readonly<Record<string, any>> | undefined,
   previous: Registration | undefined,
   packages: PackageResolver,
-  install: boolean,
-  sourceGeneration: (entrypoint: string) => Promise<number>,
 ) {
   // Package entrypoints never change within a session, so a loaded previous
   // version needs no re-resolution (which could otherwise hit npm).
   if (!local && previous && sameOptions(previous.options, options))
     return { status: "unchanged" as const, plugin: previous.plugin, version: previous.version }
-  const entrypoint = local ? await resolveLocal(local) : await packages.resolve(spec, install)
+  const entrypoint = local ? await resolveLocal(local) : await packages.resolve(spec)
   if (!entrypoint) return { status: "unsupported" as const }
-  // Content remains stable across the several mtimes one save may expose to
-  // filesystem watchers, while the generation keeps reverted modules fresh.
-  const version = local ? freshSpecifier(entrypoint, await sourceGeneration(entrypoint)) : entrypoint
+  // The cache-busted specifier doubles as the version: unique per entrypoint
+  // and mtime, so equal versions mean an identical module.
+  const version = local ? freshSpecifier(entrypoint, (await stat(new URL(entrypoint))).mtimeMs) : entrypoint
   if (previous && previous.version === version && sameOptions(previous.options, options))
     return { status: "unchanged" as const, plugin: previous.plugin, version }
   const mod: { readonly default?: unknown } = await import(version)
@@ -599,7 +546,7 @@ function toRegistration(item: Desired): Registration {
     source: item.source,
     target: item.target,
     version: item.version,
-    options: snapshotOptions(item.options),
+    options: item.options,
     active: false,
     routes: {},
     slots: {},
@@ -608,32 +555,10 @@ function toRegistration(item: Desired): Registration {
   }
 }
 
-function toDesired(item: Registration): Desired {
-  return {
-    plugin: item.plugin,
-    source: item.source,
-    target: item.target,
-    version: item.version,
-    options: item.options,
-    enabled: item.active,
-  }
-}
-
 function sameOptions(a: Registration["options"], b: Registration["options"]) {
   return isDeepEqual(a ?? null, b ?? null)
 }
 
-function sameGeneration(
-  a: Pick<Registration, "version" | "options"> | undefined,
-  b: Pick<Registration, "version" | "options">,
-) {
-  return a?.version === b.version && sameOptions(a.options, b.options)
-}
-
-function snapshotOptions(options: Registration["options"]) {
-  return options ? structuredClone(unwrap(options)) : undefined
-}
-
 async function resolveLocal(url: URL) {
   const info = await stat(url)
   if (info.isFile()) return url.href

packages/tui/src/plugin/discovery.ts

@@ -45,13 +45,15 @@ export function localSource(spec: string, directory: string) {
   return undefined
 }
 
-// Key local plugin imports by a numeric source version so edited sources
-// re-import fresh instead of hitting the ESM cache. Bun ignores query params
-// when caching file:// URL imports, so bust with a plain path there; Node keys
-// its cache on the full URL. Fractional versions break Bun's runtime JSX/solid
-// plugin hooks, so always truncate them.
-export function freshSpecifier(entrypoint: string, sourceVersion: number) {
-  const version = Math.trunc(sourceVersion)
+// Key local plugin imports by mtime so edited sources re-import fresh instead
+// of hitting the ESM cache. Bun ignores query params when caching file:// URL
+// imports, so bust with a plain path there; Node keys its cache on the full
+// URL. Mirrors the core plugin supervisor's loader.
+// The mtime is truncated to whole milliseconds: a fractional mtimeMs puts a
+// dot in the query, and Bun's compiled binaries then skip runtime plugin
+// hooks for the import, breaking JSX/solid rewriting for external plugins.
+export function freshSpecifier(entrypoint: string, mtime: number) {
+  const version = Math.trunc(mtime)
   if (typeof Bun !== "undefined") return `${fileURLToPath(entrypoint).replaceAll("\\", "/")}?mtime=${version}`
   return `${entrypoint}?mtime=${version}`
 }

packages/tui/src/routes/session/index.tsx

@@ -275,9 +275,6 @@ export function Session(props: { verticalTabsWidth: number }) {
   const sessionTabs = useSessionTabs()
   const [awayFromBottom, setAwayFromBottom] = createSignal(false)
   const [latestHovered, setLatestHovered] = createSignal(false)
-  createEffect(() => {
-    if (!awayFromBottom()) setLatestHovered(false)
-  })
 
   const clearMessageNavigation = () => {
     setNavigationSlack(0)
@@ -1199,15 +1196,16 @@ export function Session(props: { verticalTabsWidth: number }) {
             <box height={1} flexShrink={0} flexDirection="row" justifyContent="flex-end">
               <Show when={awayFromBottom()}>
                 <box
-                  id="session-jump-to-latest"
                   paddingLeft={1}
+                  paddingRight={1}
+                  backgroundColor={
+                    latestHovered() ? theme.background.action.primary.focused : theme.background.action.primary.default
+                  }
                   onMouseOver={() => setLatestHovered(true)}
                   onMouseOut={() => setLatestHovered(false)}
                   onMouseUp={toBottom}
                 >
-                  <text
-                    fg={latestHovered() ? theme.text.action.secondary.hovered : theme.text.action.secondary.default}
-                  >
+                  <text fg={latestHovered() ? theme.text.action.primary.focused : theme.text.action.primary.default}>
                     Jump to latest ↓
                   </text>
                 </box>

packages/tui/test/feature-plugins/prompt-footer.test.tsx

@@ -1,26 +1,18 @@
 /** @jsxImportSource @opentui/solid */
 import { expect, test } from "bun:test"
-import { RGBA, TextRenderable } from "@opentui/core"
+import { RGBA } from "@opentui/core"
 import { testRender } from "@opentui/solid"
 import type { Context } from "@opencode-ai/plugin/tui/context"
 import { PromptFooter } from "../../src/feature-plugins/prompt/footer"
 
 test("prompt footer separates simultaneous subagent, shell, and usage status", async () => {
   const color = RGBA.fromInts(200, 200, 200)
-  const subdued = RGBA.fromInts(100, 100, 100)
-  const dispatched: string[] = []
   const context = {
     location: { directory: "/workspace" },
-    theme: {
-      text: {
-        default: color,
-        subdued,
-      },
-    },
+    theme: { text: { default: color, subdued: color } },
     keymap: {
       shortcuts: (id: string) =>
         id === "session.child.first" ? ["ctrl+j"] : id === "command.palette.show" ? ["ctrl+p"] : [],
-      dispatch: (id: string) => dispatched.push(id),
     },
     data: {
       session: {
@@ -47,14 +39,6 @@ test("prompt footer separates simultaneous subagent, shell, and usage status", a
     await app.renderOnce()
     expect(app.captureCharFrame()).toContain("ctrl+j 1 subagent · 1 shell · $1.00")
     expect(app.captureCharFrame()).toContain("ctrl+p commands")
-
-    await app.mockMouse.moveTo(2, 0)
-    const live = app.renderer.root.getChildren()[0]?.getChildren()[0]?.getChildren()[0]
-    expect(live).toBeInstanceOf(TextRenderable)
-    expect((live as TextRenderable).fg.toInts()).toEqual(color.toInts())
-
-    await app.mockMouse.click(2, 0)
-    expect(dispatched).toEqual(["session.child.first"])
   } finally {
     app.renderer.destroy()
   }

packages/tui/test/fixture/tui-client.ts

@@ -95,11 +95,6 @@ export function createFetch(override?: FetchHandler, events?: ReturnType<typeof
     if (url.pathname === "/path") return json({ home: "", state: "", config: "", worktree, directory })
     if (url.pathname === "/api/location")
       return json({ directory, project: { id: "proj_test", directory: worktree, canonical: worktree } })
-    if (url.pathname === "/api/plugin")
-      return json({
-        location: { directory, project: { id: "proj_test", directory: worktree, canonical: worktree } },
-        data: [],
-      })
     if (url.pathname === "/api/vcs")
       return json({
         location: { directory, project: { id: "proj_test", directory: worktree, canonical: worktree } },

packages/tui/test/plugin-hot-reload.test.tsx

@@ -4,7 +4,6 @@ import { Effect, FileSystem } from "effect"
 import { Global } from "@opencode-ai/util/global"
 import { mkdir, readFile, symlink, writeFile } from "node:fs/promises"
 import path from "node:path"
-import { pathToFileURL } from "node:url"
 import { createEventStream, createFetch, json } from "./fixture/tui-client"
 import { tmpdir } from "./fixture/fixture"
 
@@ -31,26 +30,12 @@ async function until(read: () => Promise<string>, expected: (value: string | und
   return value
 }
 
-async function bootApp(
-  directory: string,
-  options?: {
-    plugins?: unknown[]
-    resolve?: (spec: string, install?: boolean) => Promise<string | undefined>
-  },
-) {
+async function bootApp(directory: string) {
   const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
   const core = await import("@opentui/core")
   mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
   const events = createEventStream()
   const calls = createFetch((url) => {
-    if (url.pathname === "/api/plugin")
-      return json({
-        location: {
-          directory,
-          project: { id: "proj_test", directory, canonical: directory },
-        },
-        data: options?.plugins ?? [],
-      })
     if (url.pathname !== "/api/fs/list") return
     return json({
       location: {
@@ -69,7 +54,7 @@ async function bootApp(
       app: { name: "test", version: "test", channel: "test" },
       server: { endpoint: { url: server.url.toString() } },
       config: { get: async () => ({}), update: async () => ({}) },
-      packages: { resolve: options?.resolve ?? (async () => undefined) },
+      packages: { resolve: async () => undefined },
       args: {},
       log: () => {},
     }).pipe(
@@ -88,40 +73,6 @@ async function bootApp(
   }
 }
 
-test("loads an advertised package TUI entrypoint only from the local cache", async () => {
-  await using tmp = await tmpdir()
-  const marker = path.join(tmp.path, "marker.txt")
-  const entrypoint = path.join(tmp.path, "tui.ts")
-  await writeFile(entrypoint, lifecycleSource(marker, "test.package", "package"))
-  const resolutions: Array<{ spec: string; install?: boolean }> = []
-
-  await using app = await bootApp(tmp.path, {
-    plugins: [
-      {
-        id: "test.server",
-        source: { type: "package", package: "test-plugin@1.0.0" },
-        status: "active",
-        tui: true,
-      },
-    ],
-    resolve: async (spec, install) => {
-      resolutions.push({ spec, install })
-      return pathToFileURL(entrypoint).href
-    },
-  })
-
-  expect(
-    await until(
-      () => readFile(marker, "utf8"),
-      (value) => value === "package:setup\n",
-    ),
-  ).toBe("package:setup\n")
-  expect(resolutions).toContainEqual({ spec: "test-plugin@1.0.0", install: false })
-
-  process.emit("SIGHUP")
-  await app.task
-})
-
 test("discovers an ancestor TUI plugin directory created after startup", async () => {
   await using tmp = await tmpdir()
   const cwd = path.join(tmp.path, "repo", "packages", "app")
@@ -271,40 +222,30 @@ test("a save whose setup throws restores the previous version", async () => {
   const directory = path.join(tmp.path, ".opencode", "plugins", "tui")
   await mkdir(directory, { recursive: true })
   const marker = path.join(tmp.path, "a.txt")
-  const markerB = path.join(tmp.path, "b.txt")
   const source = path.join(directory, "a.ts")
-  const sourceB = path.join(directory, "b.ts")
   await writeFile(source, lifecycleSource(marker, "test.a", "a1"))
-  await writeFile(sourceB, lifecycleSource(markerB, "test.b", "b1"))
 
   await using app = await bootApp(tmp.path)
   const read = () => readFile(marker, "utf8")
-  const readB = () => readFile(markerB, "utf8")
   expect(await until(read, (value) => value === "a1:setup\n")).toBe("a1:setup\n")
-  expect(await until(readB, (value) => value === "b1:setup\n")).toBe("b1:setup\n")
 
   // The module imports fine but its setup throws — unlike an import failure,
   // the swap has already torn down a1, so keep-last-good means restoring it.
-  const broken = `
+  await writeFile(
+    source,
+    `
 export default {
   id: "test.a",
   setup: async () => {
     throw new Error("setup boom")
   },
 }
-`
-  await writeFile(source, broken)
+`,
+  )
   expect(await until(read, (value) => value === "a1:setup\na1:cleanup\na1:setup\n")).toBe(
     "a1:setup\na1:cleanup\na1:setup\n",
   )
 
-  // Duplicate notifications for unchanged contents must not retry the broken
-  // generation and cycle the restored plugin again.
-  await writeFile(source, broken)
-  await writeFile(sourceB, lifecycleSource(markerB, "test.b", "b2"))
-  expect(await until(readB, (value) => value?.includes("b2:setup") ?? false)).toBe("b1:setup\nb1:cleanup\nb2:setup\n")
-  expect(await read()).toBe("a1:setup\na1:cleanup\na1:setup\n")
-
   // Fixing the file swaps out the restored version normally.
   await writeFile(source, lifecycleSource(marker, "test.a", "a2"))
   expect(await until(read, (value) => value?.includes("a2:setup") ?? false)).toBe(

packages/tui/test/theme/v2/resolve.test.ts

@@ -154,23 +154,6 @@ test("merges partial documents with the selected OpenCode defaults", () => {
   expect(theme.background.action.destructive.pressed).toBeInstanceOf(RGBA)
 })
 
-test("resolves custom secondary actions and falls back per mode", () => {
-  const document = {
-    version: 2,
-    light: {
-      text: { action: { secondary: { default: "#123456", $hovered: "#234567" } } },
-    },
-    dark: {},
-  } as const
-  const lightTheme = resolveSource(document, "light")
-  const darkTheme = resolveSource(document, "dark")
-
-  expect(lightTheme.text.action.secondary.default.toInts()).toEqual([18, 52, 86, 255])
-  expect(lightTheme.text.action.secondary.hovered.toInts()).toEqual([35, 69, 103, 255])
-  expect(darkTheme.text.action.secondary.default).toBe(darkTheme.text.subdued)
-  expect(darkTheme.text.action.secondary.hovered).toBe(darkTheme.text.default)
-})
-
 test("expands user structural fallbacks before merging defaults", () => {
   const expanded = resolveSource(
     {
@@ -231,8 +214,6 @@ test("resolves matched action variants and states", () => {
   expect(theme.text.action.primary.pressed).toBeInstanceOf(RGBA)
   expect(theme.text.action.primary.hovered).toBeInstanceOf(RGBA)
   expect(theme.text.action.primary.selected).toBeInstanceOf(RGBA)
-  expect(theme.text.action.secondary.default).toBe(theme.text.subdued)
-  expect(theme.text.action.secondary.hovered).toBe(theme.text.default)
   expect(theme.background.action.primary.pressed).toBeInstanceOf(RGBA)
   expect(theme.background.action.primary.hovered).toBeInstanceOf(RGBA)
   expect(theme.background.action.primary.selected).toBeInstanceOf(RGBA)

packages/tui/test/theme/v2/v1-migrate.test.ts

@@ -30,8 +30,6 @@ test("migrates resolved V1 modes into V2 tokens", () => {
   expect(migrated.dark.background?.surface?.offset).toBe("$hue.neutral.700")
   expect(migrated.dark.background?.surface?.overlay).toBe("$hue.neutral.600")
   expect(migrated.light.text?.action?.primary?.default).toBe("$text.default")
-  expect(migrated.light.text?.action?.secondary?.default).toBe("$text.subdued")
-  expect(migrated.light.text?.action?.secondary?.$hovered).toBe("$text.default")
   expect(migrated.light.background?.action?.primary?.$selected).toBe("transparent")
   expect(resolved.background.surface.offset.toInts()).toEqual(legacy.backgroundPanel.toInts())
   expect(resolved.background.surface.overlay.toInts()).toEqual(legacy.backgroundElement.toInts())
@@ -44,8 +42,6 @@ test("migrates resolved V1 modes into V2 tokens", () => {
   expect(resolved.hue.interactive[800].toInts()).toEqual(legacy.primary.toInts())
   expect(resolved.background.action.primary.selected.toInts()).toEqual([0, 0, 0, 0])
   expect(resolved.text.action.primary.selected.toInts()).toEqual(legacy.primary.toInts())
-  expect(resolved.text.action.secondary.default.toInts()).toEqual(legacy.textMuted.toInts())
-  expect(resolved.text.action.secondary.hovered.toInts()).toEqual(legacy.text.toInts())
   expect(resolved.background.feedback.error.default.toInts()).toEqual(legacy.background.toInts())
   expect(resolved.contextual.elevated.background.default.toInts()).toEqual(legacy.backgroundPanel.toInts())
   expect(resolved.contextual.elevated.background.action.primary.default.toInts()).toEqual([0, 0, 0, 0])