fix(tui): show compaction progress

.opencode/plugins/orchestrator.ts

@@ -0,0 +1,36 @@
+export default {
+  id: "Orchestrator",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("orchestrator", (agent) => {
+        agent.description = "Coordinates work by delegating implementation tasks to the minion subagent."
+        agent.mode = "primary"
+        agent.system = [
+          "You are Orchestrator, the primary coordinating agent for this repository. You do meta work only: you coordinate, brief, and synthesize — you do not perform the work itself.",
+          "Delegate ALL actual work to the minion subagent — implementation, exploration, discovery, searching the codebase, reading files to understand a problem, and even trivial one-line edits. Task size is never a reason to do it yourself, and there is no 'final integration' exception.",
+          "You are not hard-banned from tools, but direct tool use is reserved for coordination overhead: a quick peek to phrase a better brief, a fast read-only check to verify a minion's reported result, or answering a question about coordination state. If a tool call is producing the answer or the artifact the user asked for, that call belongs to a minion, not you.",
+          "Exploration is work. If the user asks how something works or where something lives, delegate the investigation to a minion rather than exploring yourself.",
+          "Always start minion subagents in the background. Even if you have nothing else to coordinate right now, the user may assign you new work while a Minion runs, and you must stay free to receive it. Never poll; you will be notified when they finish.",
+          "Give each minion a clear, self-contained brief: the goal, constraints, expected output, and any files or context already known from the user or previous minion reports.",
+          "Synthesize minion results, decide next steps, and report back concisely.",
+        ].join("\n")
+      })
+
+      agents.update("minion", (agent) => {
+        agent.description = "Subagent that executes focused tasks delegated by Orchestrator."
+        agent.mode = "subagent"
+        agent.model = { providerID: "opencode", id: "glm-5.2" }
+        agent.system = [
+          "You are minion, a focused execution subagent for this repository.",
+          "Complete the specific task delegated to you by Orchestrator using the available tools.",
+          "Inspect the codebase before making assumptions, make targeted changes when requested, and verify your work when feasible.",
+          "Follow the repository's AGENTS.md conventions: respect the style guide, run `bun typecheck` from the affected package directory after code changes, never run tests from the repo root, and do not modify packages/opencode unless the task explicitly says V1 work.",
+          "If the task is ambiguous or you hit a blocker, stop and report your findings instead of guessing.",
+          "Keep your final response concise: summarize what you did, list important files changed or findings, and call out blockers or verification gaps.",
+          "Do not delegate to other subagents; execute the assigned work yourself.",
+        ].join("\n")
+        agent.permissions.push({ action: "subagent", resource: "*", effect: "deny" })
+      })
+    })
+  },
+}

.opencode/skills/debug-opencode/SKILL.md

@@ -104,25 +104,6 @@ bun dev api <operationId> --param key=value
 - If no compatible background server is registered, `bun dev api` starts one through the daemon service. Use `bun dev service status`, `bun dev service restart`, and `bun dev service stop` when you need explicit lifecycle control.
 - Prefer raw method/path calls for quick server debugging and operation IDs when exercising documented OpenAPI routes with path or query parameters.
 
-## Auditing installed `opencode2` sessions
-
-Installed next-channel sessions normally use `~/.local/share/opencode/opencode-next.db` and `~/.local/share/opencode/log/opencode.log`; `OPENCODE_DB` can override the database. Before calling `opencode2 api`, inspect `~/.local/state/opencode/service.json` because the command may start a daemon when none is healthy.
-
-For a supplied `ses_...` ID, compare three sources:
-
-- `opencode2 api get /api/session/active` and the Session/message endpoints for live server state.
-- The database's ordered `event` rows for durable history.
-- `packages/tui/src/context/data.tsx` and the relevant route for client projection and rendering.
-
-Locate an uncertain database without modifying it:
-
-```bash
-SESSION=ses_...
-for db in ~/.local/share/opencode/*.db; do
-  sqlite3 "file:$db?mode=ro" "select 1 from session where id='$SESSION' limit 1" 2>/dev/null | grep -q 1 && printf '%s\n' "$db"
-done
-```
-
 ## Logs
 
 - Log files live under `~/.local/share/opencode/log/`. In a local/dev checkout the active file is `opencode-local.log`; `opencode.log` is used for non-local (released) channel installs. Both are append-only, shared across every CLI and server process on the machine.

AGENTS.md

@@ -151,7 +151,6 @@ const table = sqliteTable("session", {
 
 ## V2 Session Core
 
-- Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_input` row before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. The serialized runner promotes admitted inputs into visible user messages at safe boundaries.
 - Reusing a Session ID adopts the existing Session. Reusing a prompt message ID reconciles an exact retry only when Session, prompt, and delivery mode match; conflicting reuse fails. Historical projected prompts lazily synthesize promoted inbox records during exact retry.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.

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

@@ -928,7 +928,6 @@ export type SessionContextOutput = {
         readonly time: { readonly created: number }
         readonly type: "model-switched"
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
       }
     | {
         readonly id: string
@@ -1622,7 +1621,6 @@ export type SessionMessageOutput = {
         readonly time: { readonly created: number }
         readonly type: "model-switched"
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
       }
     | {
         readonly id: string
@@ -1822,7 +1820,6 @@ export type MessageListOutput = {
         readonly time: { readonly created: number }
         readonly type: "model-switched"
         readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
-        readonly previous?: { readonly id: string; readonly providerID: string; readonly variant?: string }
       }
     | {
         readonly id: string

packages/core/src/config.ts

@@ -23,7 +23,6 @@ import { ConfigPlugin } from "./config/plugin"
 import { ConfigProvider } from "./config/provider"
 import { ConfigReference } from "./config/reference"
 import { ConfigToolOutput } from "./config/tool-output"
-import { ConfigVariable } from "./config/variable"
 import { ConfigWatcher } from "./config/watcher"
 import { ConfigV1 } from "./v1/config/config"
 import { ConfigMigrateV1 } from "./v1/config/migrate"
@@ -149,10 +148,9 @@ const layer = Layer.effect(
     const loadFile = Effect.fnUntraced(function* (filepath: string) {
       const text = yield* fs.readFileStringSafe(filepath)
       if (!text) return
-      const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
 
       const errors: ParseError[] = []
-      const input: unknown = parse(substituted, errors, { allowTrailingComma: true })
+      const input: unknown = parse(text, errors, { allowTrailingComma: true })
       if (errors.length) return
 
       const info = Option.getOrUndefined(

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

@@ -2,7 +2,7 @@ export * as ConfigExternalPlugin from "./external"
 
 import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/v2/effect"
 import type { Plugin as PromisePlugin } from "@opencode-ai/plugin/v2/promise"
-import { Effect, Schema } from "effect"
+import { Effect, Schema, Stream } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
 import { Config } from "../../config"
@@ -42,6 +42,7 @@ export const Plugin = define({
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const npm = yield* Npm.Service
+    const active = new Set<string>()
     const load = Effect.fn("ConfigExternalPlugin.load")(function* () {
       const configured: { package: string; options?: Record<string, unknown> }[] = []
 
@@ -116,7 +117,23 @@ export const Plugin = define({
         }).pipe(Effect.catchCause(() => Effect.succeed(undefined))),
       ).pipe(Effect.map((plugins) => plugins.filter((plugin) => plugin !== undefined)))
     })
-    for (const plugin of yield* load()) yield* ctx.plugin.add(plugin)
+    const reconcile = Effect.fn("ConfigExternalPlugin.reconcile")(function* () {
+      const plugins = yield* load()
+      const next = new Set(plugins.map((plugin) => plugin.id))
+      for (const id of active) {
+        if (!next.has(id)) yield* ctx.plugin.remove(id)
+      }
+      for (const plugin of plugins) yield* ctx.plugin.add(plugin)
+      active.clear()
+      for (const id of next) active.add(id)
+    })
+
+    yield* reconcile()
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
+      Stream.runForEach(() => reconcile()),
+      Effect.forkScoped({ startImmediately: true }),
+    )
   }),
 })
 

packages/core/src/config/variable.ts

@@ -1,85 +0,0 @@
-export * as ConfigVariable from "./variable"
-
-import os from "os"
-import path from "path"
-import { Effect } from "effect"
-import { FSUtil } from "../fs-util"
-import { InvalidError } from "../v1/config/error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-  env?: Record<string, string>
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export const substitute = Effect.fn("ConfigVariable.substitute")(function* (input: SubstituteInput) {
-  const text = input.text.replace(
-    /\{env:([^}]+)\}/g,
-    (_, varName: string) => (input.env?.[varName] ?? process.env[varName]) || "",
-  )
-  if (!text.includes("{file:")) return text
-  return yield* substituteFiles(input, text)
-})
-
-const substituteFiles = Effect.fnUntraced(function* (input: SubstituteInput, text: string) {
-  const fs = yield* FSUtil.Service
-  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir
-  const configSource = input.type === "path" ? input.path : input.source
-  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  let out = ""
-  let cursor = 0
-
-  for (const match of matches) {
-    const token = match[0]
-    const index = match.index
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath
-    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath)
-    const fileContent = yield* fs.readFileString(resolvedPath).pipe(
-      Effect.catch((error) => {
-        if (input.missing === "empty") return Effect.succeed("")
-
-        const message = `bad file reference: "${token}"`
-        return Effect.fail(
-          new InvalidError(
-            {
-              path: configSource,
-              message:
-                error._tag === "PlatformError" && error.reason._tag === "NotFound"
-                  ? `${message} ${resolvedPath} does not exist`
-                  : message,
-            },
-            { cause: error },
-          ),
-        )
-      }),
-    )
-
-    out += JSON.stringify(fileContent.trim()).slice(1, -1)
-    cursor = index + token.length
-  }
-
-  return out + text.slice(cursor)
-})

packages/core/src/filesystem/ignore.ts

@@ -45,7 +45,7 @@ const FILES = [
   "**/.nyc_output/**",
 ]
 
-export const PATTERNS = [...FILES, ...FOLDERS, `**/{${Array.from(FOLDERS).join(",")}}/**`]
+export const PATTERNS = [...FILES, ...FOLDERS]
 
 export function match(filepath: string, opts?: { extra?: string[]; whitelist?: string[] }) {
   for (const pattern of opts?.whitelist || []) {

packages/core/src/filesystem/watcher.ts

@@ -89,11 +89,9 @@ const layer = Layer.effect(
                     type: "update",
                   } satisfies Update)
                 })
-                if ("on" in subscription && typeof subscription.on === "function") {
-                  subscription.on("error", (error: unknown) =>
-                    Effect.runFork(Effect.logError("watcher callback failed", { path: target, error })),
-                  )
-                }
+                subscription.on("error", (error) =>
+                  Effect.runFork(Effect.logError("watcher callback failed", { path: target, error })),
+                )
                 return { unsubscribe: () => Promise.resolve(subscription.close()) }
               })
             : subscribeDirectory(native, backend, directory, ignore, pubsub)

packages/core/src/plugin/host.ts

@@ -302,7 +302,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         }),
     },
     tool: {
-      register: (input, options) => tools.register(input, options),
+      register: (input) => tools.register(input),
       execute: {
         before: (callback) =>
           toolHooks.hook.before((event) => {

packages/core/src/session.ts

@@ -540,8 +540,7 @@ const layer = Layer.effect(
             const started = yield* Effect.gen(function* () {
               const shell = yield* Shell.Service
               return yield* shell.create({ command: input.command, cwd: session.location.directory })
-            })
-              .pipe(Effect.provide(locations.get(session.location)))
+            }).pipe(Effect.provide(locations.get(session.location)))
             yield* events.publish(
               SessionEvent.Shell.Started,
               {
@@ -564,7 +563,8 @@ const layer = Layer.effect(
                     .pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(missingShellOutput())))
                 : missingShellOutput()
               return { shell: terminal.info, output }
-            }).pipe(Effect.provide(locations.get(session.location)))
+            })
+              .pipe(Effect.provide(locations.get(session.location)))
             yield* events.publish(SessionEvent.Shell.Ended, {
               sessionID: input.sessionID,
               shell: completed.shell,

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

@@ -8,7 +8,6 @@ export type MemoryState = {
 }
 
 export interface Adapter {
-  readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
   readonly getAssistant: (
     messageID: SessionMessage.ID,
@@ -30,15 +29,6 @@ export function memory(state: MemoryState): Adapter {
   const latestAssistantIndex = () => state.messages.findLastIndex((message) => message.type === "assistant")
 
   return {
-    getModel() {
-      return Effect.sync(
-        () =>
-          state.messages.findLast(
-            (message): message is SessionMessage.ModelSelected | SessionMessage.Assistant =>
-              message.type === "model-switched" || message.type === "assistant",
-          )?.model,
-      )
-    },
     getCurrentAssistant() {
       return Effect.sync(() => {
         const index = latestAssistantIndex()
@@ -125,19 +115,15 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         )
       },
       "session.model.selected": (event) => {
-        return Effect.gen(function* () {
-          const previous = yield* adapter.getModel()
-          yield* adapter.appendMessage(
-            SessionMessage.ModelSelected.make({
-              id: SessionMessage.ID.fromEvent(event.id),
-              type: "model-switched",
-              metadata: event.metadata,
-              model: event.data.model,
-              previous,
-              time: { created: event.created },
-            }),
-          )
-        })
+        return adapter.appendMessage(
+          SessionMessage.ModelSelected.make({
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "model-switched",
+            metadata: event.metadata,
+            model: event.data.model,
+            time: { created: event.created },
+          }),
+        )
       },
       "session.moved": () => Effect.void,
       "session.renamed": () => Effect.void,

packages/core/src/session/projector.ts

@@ -5,7 +5,6 @@ import { DateTime, Effect, Layer, Schema } from "effect"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
 import { makeGlobalNode } from "../effect/app-node"
-import { ModelV2 } from "../model"
 import { SessionEvent } from "./event"
 import { SessionV1 } from "../v1/session"
 import { WorkspaceTable } from "../control-plane/workspace.sql"
@@ -357,17 +356,6 @@ function run(db: DatabaseService, event: MessageEvent) {
     }
     const appendMessage = (message: SessionMessage.Message) => insertMessage(db, event, message)
     const adapter: SessionMessageUpdater.Adapter = {
-      getModel() {
-        return db
-          .select({ model: SessionTable.model })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, event.data.sessionID))
-          .get()
-          .pipe(
-            Effect.orDie,
-            Effect.map((row) => (row?.model ? Schema.decodeUnknownSync(ModelV2.Ref)(row.model) : undefined)),
-          )
-      },
       getCurrentAssistant() {
         return Effect.gen(function* () {
           // A newer step supersedes stale incomplete rows; never resume an older assistant projection.
@@ -582,13 +570,13 @@ const layer = Layer.effectDiscard(
     )
     yield* events.project(SessionEvent.ModelSelected, (event) =>
       Effect.gen(function* () {
-        yield* run(db, event)
         yield* db
           .update(SessionTable)
           .set({ model: event.data.model, time_updated: DateTime.toEpochMillis(event.created) })
           .where(eq(SessionTable.id, event.data.sessionID))
           .run()
           .pipe(Effect.orDie)
+        yield* run(db, event)
       }),
     )
     yield* events.project(SessionEvent.Renamed, (event) =>

packages/core/src/tool/AGENTS.md

@@ -28,8 +28,7 @@ Leaves own resolution, permission, and side-effect ordering. Translate only expe
 
 ## Registration
 
-Built-ins and plugin tools register through `Tools.Service.register({ [name]: tool })`. Registrations may provide a
-group, which flattens direct model names to `<group>_<tool>`, and may be deferred from direct model exposure.
+Built-ins and plugin tools register through `Tools.Service.register({ [name]: tool })`.
 
 Registrations are scoped:
 

packages/core/src/tool/glob.ts

@@ -5,7 +5,6 @@ import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { Effect, Schema } from "effect"
 import path from "path"
 import { FileSystem } from "../filesystem"
-import { FSUtil } from "../fs-util"
 import { Location } from "../location"
 import { Ripgrep } from "../ripgrep"
 import { RelativePath } from "../schema"
@@ -37,7 +36,6 @@ export const toModelOutput = (output: ModelOutput) => {
 export const Plugin = {
   id: "core-glob-tool",
   effect: Effect.fn("GlobTool.Plugin")(function* (ctx: PluginContext) {
-    const fs = yield* FSUtil.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service
     const permission = yield* PermissionV2.Service
@@ -73,13 +71,6 @@ export const Plugin = {
                 source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
               })
               const cwd = path.resolve(location.directory, input.path ?? ".")
-              yield* fs
-                .stat(cwd)
-                .pipe(
-                  Effect.catchReason("PlatformError", "NotFound", () =>
-                    Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
-                  ),
-                )
               return yield* ripgrep
                 .glob({
                   cwd,
@@ -97,11 +88,7 @@ export const Plugin = {
                   ),
                 )
             }).pipe(
-              Effect.mapError((error) =>
-                error instanceof ToolFailure
-                  ? error
-                  : new ToolFailure({ message: `Unable to find files matching ${input.pattern}` }),
-              ),
+              Effect.mapError(() => new ToolFailure({ message: `Unable to find files matching ${input.pattern}` })),
             ),
         }),
       })

packages/core/src/tool/grep.ts

@@ -91,13 +91,7 @@ export const Plugin = {
                 source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
               })
               const target = path.resolve(location.directory, input.path ?? ".")
-              const info = yield* fs
-                .stat(target)
-                .pipe(
-                  Effect.catchReason("PlatformError", "NotFound", () =>
-                    Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
-                  ),
-                )
+              const info = yield* fs.stat(target).pipe(Effect.catch(() => Effect.succeed(undefined)))
               return yield* ripgrep
                 .grep({
                   cwd: info?.type === "Directory" ? target : path.dirname(target),
@@ -127,13 +121,7 @@ export const Plugin = {
                     ),
                   ),
                 )
-            }).pipe(
-              Effect.mapError((error) =>
-                error instanceof ToolFailure
-                  ? error
-                  : new ToolFailure({ message: `Unable to grep for ${input.pattern}` }),
-              ),
-            ),
+            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to grep for ${input.pattern}` }))),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/mcp.ts

@@ -1,5 +1,6 @@
 export * as McpTool from "./mcp"
 
+import { createHash } from "node:crypto"
 import { ToolFailure } from "@opencode-ai/llm"
 import { McpEvent } from "@opencode-ai/schema/mcp-event"
 import { Effect, Exit, type JsonSchema, Layer, Scope, Semaphore, Stream } from "effect"
@@ -10,11 +11,35 @@ import { Tool } from "./tool"
 import { Tools } from "./tools"
 import { ToolRegistry } from "./registry"
 
+const MAX_NAME_LENGTH = 64
+const HASH_LENGTH = 8
+
+const sanitize = (value: string) => value.replace(/[^A-Za-z0-9_-]/g, "_")
+
+// Deterministic short suffix used to keep overlong or colliding names unique and stable across restarts.
+const hashSuffix = (raw: string) => "_" + createHash("sha1").update(raw).digest("hex").slice(0, HASH_LENGTH)
+
+const fit = (base: string, raw: string) => base.slice(0, MAX_NAME_LENGTH - HASH_LENGTH - 1) + hashSuffix(raw)
+
 /**
- * Registry and permission action name for an MCP tool.
+ * Registry/permission action name for an MCP tool: V1-compatible `<server>_<tool>` so existing deny
+ * rules keep working. Sanitized to a valid tool name, prefixed when it would not start with a letter,
+ * and hashed down when it would exceed the 64-char limit.
  */
-export const name = (server: string, tool: string) =>
-  `${server.replace(/[^a-zA-Z0-9_-]/g, "_")}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`
+export const name = (server: string, tool: string) => {
+  const joined = sanitize(server) + "_" + sanitize(tool)
+  const base = /^[A-Za-z]/.test(joined) ? joined : "mcp_" + joined
+  return base.length > MAX_NAME_LENGTH ? fit(base, `${server}\u0000${tool}`) : base
+}
+
+const toContent = (part: MCP.ToolResultContent): Tool.Content =>
+  part.type === "text" ? { type: "text", text: part.text } : { type: "file", data: part.data, mime: part.mimeType }
+
+const errorText = (content: ReadonlyArray<MCP.ToolResultContent>) =>
+  content
+    .flatMap((part) => (part.type === "text" ? [part.text] : []))
+    .join("\n")
+    .trim()
 
 export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
@@ -25,71 +50,47 @@ export const layer = Layer.effectDiscard(
     const lock = Semaphore.makeUnsafe(1)
     let current: Scope.Closeable | undefined
 
+    const make = (server: MCP.ServerName, tool: MCP.Tool) =>
+      Tool.make({
+        description: tool.description ?? "",
+        jsonSchema: (tool.inputSchema as JsonSchema.JsonSchema | undefined) ?? { type: "object", properties: {} },
+        execute: (input) =>
+          Effect.gen(function* () {
+            const result = yield* mcp.callTool({ server, name: tool.name, args: (input ?? {}) as Record<string, unknown> }).pipe(
+              Effect.catchTags({
+                "MCP.NotFoundError": (error) => new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
+                "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message }),
+              }),
+            )
+            if (result.isError)
+              return yield* new ToolFailure({ message: errorText(result.content) || "MCP tool returned an error" })
+            return { structured: result.structured ?? {}, content: result.content.map(toContent) }
+          }),
+      })
+
     // Register the current tool set under a fresh child scope, then close the previous one so the
     // registry never has a gap where MCP tools disappear mid-swap.
     const reconcile = lock.withPermit(
       Effect.gen(function* () {
-        const groups = new Map<string, Record<string, Tool.AnyTool>>()
+        const used = new Set<string>()
+        const record: Record<string, Tool.AnyTool> = {}
         for (const tool of yield* mcp.tools()) {
-          const group = groups.get(tool.server) ?? {}
-          const schema = (tool.inputSchema ?? {}) as JsonSchema.JsonSchema
-          group[tool.name] = Tool.make({
-            description: tool.description ?? "",
-            jsonSchema: {
-              ...schema,
-              type: "object",
-              properties: schema.properties ?? {},
-              additionalProperties: false,
-            },
-            execute: (input) =>
-              Effect.gen(function* () {
-                const result = yield* mcp
-                  .callTool({
-                    server: tool.server,
-                    name: tool.name,
-                    args: (input ?? {}) as Record<string, unknown>,
-                  })
-                  .pipe(
-                    Effect.catchTags({
-                      "MCP.NotFoundError": (error) =>
-                        new ToolFailure({ message: `MCP server "${error.server}" is not available` }),
-                      "MCP.ToolCallError": (error) => new ToolFailure({ message: error.message }),
-                    }),
-                  )
-                if (result.isError)
-                  return yield* new ToolFailure({
-                    message:
-                      result.content
-                        .flatMap((part) => (part.type === "text" ? [part.text] : []))
-                        .join("\n")
-                        .trim() || "MCP tool returned an error",
-                  })
-                return {
-                  structured: result.structured ?? {},
-                  content: result.content.map((part) =>
-                    part.type === "text"
-                      ? { type: "text" as const, text: part.text }
-                      : { type: "file" as const, data: part.data, mime: part.mimeType },
-                  ),
-                }
-              }),
-          })
-          groups.set(tool.server, group)
+          const initial = name(tool.server, tool.name)
+          const key = used.has(initial) ? fit(initial, `${tool.server}\u0000${tool.name}`) : initial
+          used.add(key)
+          record[key] = make(tool.server, tool)
         }
         const next = yield* Scope.fork(scope)
-        yield* Effect.forEach(groups, ([group, record]) => tools.register(record, { group }), {
-          discard: true,
-        }).pipe(Scope.provide(next), Effect.orDie)
+        yield* tools.register(record).pipe(Scope.provide(next), Effect.orDie)
         if (current) yield* Scope.close(current, Exit.void)
         current = next
       }),
     )
 
     yield* reconcile.pipe(Effect.forkScoped)
-    yield* events.subscribe(McpEvent.ToolsChanged).pipe(
-      Stream.runForEach(() => reconcile),
-      Effect.forkScoped({ startImmediately: true }),
-    )
+    yield* events
+      .subscribe(McpEvent.ToolsChanged)
+      .pipe(Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }))
   }),
 )
 

packages/core/src/tool/registry.ts

@@ -23,10 +23,7 @@ export type ExecuteInput = {
 export interface Interface {
   readonly materialize: (input: MaterializeInput) => Effect.Effect<Materialization>
   /** Internal registration capability exposed publicly only through Tools.Service. */
-  readonly register: (
-    tools: Readonly<Record<string, AnyTool>>,
-    options?: Tools.RegisterOptions,
-  ) => Effect.Effect<void, RegistrationError, Scope.Scope>
+  readonly register: (tools: Readonly<Record<string, AnyTool>>) => Effect.Effect<void, RegistrationError, Scope.Scope>
 }
 
 export interface MaterializeInput {
@@ -52,13 +49,7 @@ const registryLayer = Layer.effect(
   Effect.gen(function* () {
     const resources = yield* ToolOutputStore.Service
     const toolHooks = yield* ToolHooks.Service
-    type Registration = {
-      readonly identity: object
-      readonly tool: AnyTool
-      readonly name: string
-      readonly group?: string
-      readonly deferred: boolean
-    }
+    type Registration = { readonly identity: object; readonly tool: AnyTool }
     const local = new Map<string, Array<{ readonly token: object; readonly registration: Registration }>>()
 
     const settleWith = Effect.fn("ToolRegistry.settle")(function* (input: ExecuteInput, advertised?: object) {
@@ -82,16 +73,12 @@ const registryLayer = Layer.effect(
         input: input.call.input,
       }
       yield* toolHooks.runBefore(beforeEvent)
-      const pending = yield* settle(
-        registration.tool,
-        { ...input.call, input: beforeEvent.input },
-        {
-          sessionID: input.sessionID,
-          agent: input.agent,
-          assistantMessageID: input.assistantMessageID,
-          toolCallID: input.call.id,
-        },
-      ).pipe(
+      const pending = yield* settle(registration.tool, { ...input.call, input: beforeEvent.input }, {
+        sessionID: input.sessionID,
+        agent: input.agent,
+        assistantMessageID: input.assistantMessageID,
+        toolCallID: input.call.id,
+      }).pipe(
         Effect.map((output) => ({ output })),
         Effect.catchTag("LLM.ToolFailure", (failure) =>
           Effect.succeed({ result: { type: "error" as const, value: failure.message } }),
@@ -101,11 +88,7 @@ const registryLayer = Layer.effect(
       if ("result" in pending) {
         settlement = pending
       } else {
-        const bounded = yield* resources.bound({
-          sessionID: input.sessionID,
-          toolCallID: input.call.id,
-          output: pending.output,
-        })
+        const bounded = yield* resources.bound({ sessionID: input.sessionID, toolCallID: input.call.id, output: pending.output })
         const result = ToolOutput.toResultValue(bounded.output)
         settlement =
           result.type === "error"
@@ -136,33 +119,20 @@ const registryLayer = Layer.effect(
     })
 
     return Service.of({
-      register: Effect.fn("ToolRegistry.register")(function* (tools, options) {
-        const entries = registrationEntries(tools, options?.group)
+      register: Effect.fn("ToolRegistry.register")(function* (tools) {
+        const entries = registrationEntries(tools)
         if (entries.length === 0) return
         yield* Effect.uninterruptible(
           Effect.gen(function* () {
             const token = {}
-            for (const entry of entries)
-              local.set(entry.key, [
-                ...(local.get(entry.key) ?? []),
-                {
-                  token,
-                  registration: {
-                    identity: {},
-                    tool: entry.tool,
-                    name: entry.name,
-                    group: entry.group,
-                    deferred: options?.deferred ?? false,
-                  },
-                },
-              ])
+            for (const [name, tool] of entries)
+              local.set(name, [...(local.get(name) ?? []), { token, registration: { identity: {}, tool } }])
             yield* Effect.addFinalizer(() =>
               Effect.sync(() => {
-                for (const entry of entries) {
-                  const registrations =
-                    local.get(entry.key)?.filter((registration) => registration.token !== token) ?? []
-                  if (registrations.length > 0) local.set(entry.key, registrations)
-                  else local.delete(entry.key)
+                for (const [name] of entries) {
+                  const registrations = local.get(name)?.filter((registration) => registration.token !== token) ?? []
+                  if (registrations.length > 0) local.set(name, registrations)
+                  else local.delete(name)
                 }
               }),
             )
@@ -179,11 +149,7 @@ const registryLayer = Layer.effect(
         const usePatch = input.model.provider.toLowerCase() === "openai" || input.model.id.toLowerCase().includes("gpt")
         for (const [name, registration] of registrations) {
           const wrongEditTool = name === "apply_patch" ? !usePatch : (name === "edit" || name === "write") && usePatch
-          if (
-            registration.deferred ||
-            wrongEditTool ||
-            whollyDisabled(permission(registration.tool, name), input.permissions ?? [])
-          )
+          if (wrongEditTool || whollyDisabled(permission(registration.tool, name), input.permissions ?? []))
             registrations.delete(name)
         }
         return {

packages/core/src/tool/shell.ts

@@ -18,9 +18,8 @@ export const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000
 export const MAX_TIMEOUT_MS = 10 * 60 * 1_000
 export const MAX_CAPTURE_BYTES = 1024 * 1024
 
-const BACKGROUND_STARTED = "The command was moved to the background."
-const BACKGROUND_INSTRUCTION =
-  "You will be notified automatically when the command finishes. DO NOT sleep, poll, or proactively check on its progress."
+const BACKGROUND_STARTED =
+  "The command has not completed; it is now running in the background."
 
 export const Input = Schema.Struct({
   command: Schema.String.annotate({ description: "Shell command string to execute" }),
@@ -55,11 +54,10 @@ const Output = Schema.Struct({
 type Output = typeof Output.Type
 
 const modelOutput = (output: Output): string | undefined => {
+  if (output.status === "running") return undefined
   const warnings = output.warnings?.length
     ? `\n\nWarnings:\n${output.warnings.map((warning) => `- ${warning}`).join("\n")}`
     : ""
-  if (output.status === "running")
-    return `${warnings.trimStart()}${warnings ? "\n\n" : ""}${BACKGROUND_INSTRUCTION}`
   if (output.timeout) return `${warnings.trimStart()}${warnings ? "\n\n" : ""}Command timed out before completion.`
   return `${warnings.trimStart()}${warnings ? "\n\n" : ""}Command exited with code ${output.exit}.`
 }

packages/core/src/tool/tools.ts

@@ -3,12 +3,9 @@ export * as Tools from "./tools"
 import { Context, Effect, Scope } from "effect"
 import { Tool } from "./tool"
 
-export type RegisterOptions = Tool.RegisterOptions
-
 export interface Interface {
   readonly register: (
     tools: Readonly<Record<string, Tool.AnyTool>>,
-    options?: Tool.RegisterOptions,
   ) => Effect.Effect<void, Tool.RegistrationError, Scope.Scope>
 }
 

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

@@ -292,72 +292,6 @@ describe("Config", () => {
     ),
   )
 
-  it.live("substitutes environment variables and relative file contents", () =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => {
-        const previous = {
-          token: process.env.OPENCODE_TEST_MCP_TOKEN,
-          missing: process.env.OPENCODE_TEST_MISSING,
-        }
-        process.env.OPENCODE_TEST_MCP_TOKEN = "secret"
-        delete process.env.OPENCODE_TEST_MISSING
-        return previous
-      }),
-      () =>
-        Effect.acquireUseRelease(
-          Effect.promise(() => tmpdir()),
-          (tmp) =>
-            Effect.gen(function* () {
-              yield* Effect.promise(() =>
-                Promise.all([
-                  fs.writeFile(path.join(tmp.path, "token.txt"), 'file\n"token"\n'),
-                  fs.writeFile(
-                    path.join(tmp.path, "opencode.jsonc"),
-                    `{
-                      // Ignored reference: {file:missing.txt}
-                      "username": "user-{env:OPENCODE_TEST_MISSING}",
-                      "mcp": {
-                        "servers": {
-                          "remote": {
-                            "type": "remote",
-                            "url": "https://example.com/mcp",
-                            "headers": {
-                              "Authorization": "Bearer {env:OPENCODE_TEST_MCP_TOKEN}",
-                              "X-Token": "{file:token.txt}"
-                            }
-                          }
-                        }
-                      }
-                    }`,
-                  ),
-                ]),
-              )
-
-              return yield* Effect.gen(function* () {
-                const config = yield* Config.Service
-                const document = (yield* config.entries()).find((entry) => entry.type === "document")
-                expect(document?.info.username).toBe("user-")
-                const remote = document?.info.mcp?.servers?.remote
-                expect(remote?.type).toBe("remote")
-                if (remote?.type !== "remote") return
-                expect(remote.headers).toEqual({
-                  Authorization: "Bearer secret",
-                  "X-Token": 'file\n"token"',
-                })
-              }).pipe(Effect.provide(testLayer(tmp.path)))
-            }),
-          (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-        ),
-      (previous) =>
-        Effect.sync(() => {
-          if (previous.token === undefined) delete process.env.OPENCODE_TEST_MCP_TOKEN
-          else process.env.OPENCODE_TEST_MCP_TOKEN = previous.token
-          if (previous.missing === undefined) delete process.env.OPENCODE_TEST_MISSING
-          else process.env.OPENCODE_TEST_MISSING = previous.missing
-        }),
-    ),
-  )
-
   it.live("does not load legacy config.json files", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/config/reload.test.ts

@@ -27,7 +27,7 @@ const decode = Schema.decodeUnknownSync(Config.Info)
 const document = path.join(import.meta.dir, "opencode.json")
 
 describe("config plugin reloads", () => {
-  it.live("reloads config-backed domains without reloading external plugins", () =>
+  it.live("reloads every config-backed domain", () =>
     Effect.gen(function* () {
       const agents = yield* AgentV2.Service
       const catalog = yield* Catalog.Service
@@ -69,7 +69,8 @@ describe("config plugin reloads", () => {
             (yield* commands.get("second"))?.description === "Second command" &&
             (yield* references.list()).some((reference) => reference.name === "second") &&
             (yield* catalog.provider.get(ProviderV2.ID.make("first"))) === undefined &&
-            (yield* catalog.provider.get(ProviderV2.ID.make("second"))) !== undefined
+            (yield* catalog.provider.get(ProviderV2.ID.make("second"))) !== undefined &&
+            (yield* agents.get(AgentV2.ID.make("configured")))?.description === "Second plugin"
           )
         }),
       )
@@ -80,7 +81,10 @@ describe("config plugin reloads", () => {
       expect(
         (yield* skills.sources()).some((source) => source.type === "directory" && source.path === "/skills/second"),
       ).toBe(true)
-      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("First plugin")
+
+      entries = [config("second")]
+      yield* events.publish(ConfigSchema.Event.Updated, {})
+      yield* waitUntil(agents.get(AgentV2.ID.make("configured")).pipe(Effect.map((agent) => agent === undefined)))
     }).pipe(Effect.provideService(Global.Service, Global.Service.of(Global.make()))),
   )
 })

packages/core/test/filesystem/ignore.test.ts

@@ -1,7 +1,5 @@
 import { expect, test } from "bun:test"
 import { Ignore } from "@opencode-ai/core/filesystem/ignore"
-// @ts-ignore
-import { createWrapper } from "@parcel/watcher/wrapper"
 
 test("match nested and non-nested", () => {
   expect(Ignore.match("node_modules/index.js")).toBe(true)
@@ -10,30 +8,3 @@ test("match nested and non-nested", () => {
   expect(Ignore.match("node_modules/bar")).toBe(true)
   expect(Ignore.match("node_modules/bar/")).toBe(true)
 })
-
-test("parcel patterns ignore built-in folders at any depth", async () => {
-  let ignoreGlobs: string[] = []
-  const watcher = createWrapper({
-    subscribe: async (
-      _directory: string,
-      _callback: (...args: unknown[]) => unknown,
-      options: { ignoreGlobs?: string[] },
-    ) => {
-      ignoreGlobs = options.ignoreGlobs ?? []
-    },
-  })
-  await watcher.subscribe("/tmp/project", () => {}, { ignore: Ignore.PATTERNS })
-  const patterns = ignoreGlobs.map((source) => new RegExp(source))
-
-  for (const path of [
-    "nested/node_modules",
-    "nested/node_modules/package/index.js",
-    "nested/.git",
-    "nested/.git/HEAD",
-    "nested/dist",
-    "nested/dist/index.js",
-  ]) {
-    expect(patterns.some((pattern) => pattern.test(path))).toBe(true)
-  }
-  expect(patterns.some((pattern) => pattern.test("nested/src/index.ts"))).toBe(false)
-})

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

@@ -2,7 +2,7 @@ import { $ } from "bun"
 import { describe, expect } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { Deferred, Duration, Effect, Fiber, Layer, Option, Schedule, Stream } from "effect"
+import { Deferred, Duration, Effect, Fiber, Layer, Option, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
@@ -149,14 +149,12 @@ describeWatcher("LocationWatcher", () => {
         const update = yield* watcher
           .subscribe({ path: target, type: "file" })
           .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
-        yield* fs.writeFileString(sibling, "sibling")
-        const writes = yield* Effect.suspend(() => fs.writeFileString(target, `target-${Math.random()}`)).pipe(
-          Effect.repeat(Schedule.spaced("10 millis")),
-          Effect.forkScoped,
-        )
-        const event = yield* Fiber.join(update).pipe(Effect.ensuring(Fiber.interrupt(writes)))
+        yield* Effect.yieldNow
 
-        expect(event.valueOrUndefined?.path).toBe(target)
+        yield* fs.writeFileString(sibling, "sibling")
+        yield* fs.writeFileString(target, "target")
+
+        expect((yield* Fiber.join(update)).valueOrUndefined?.path).toBe(target)
       }).pipe(Effect.provide(AppNodeBuilder.build(Watcher.node))),
     ),
   )
@@ -199,24 +197,6 @@ describeWatcher("LocationWatcher", () => {
     ),
   )
 
-  it.live("ignores dependency, VCS, and build directories at any depth", () =>
-    withTmp((directory) =>
-      Effect.gen(function* () {
-        const afs = yield* FSUtil.Service
-        yield* ready(directory)
-        const roots = ["node_modules", ".git", "dist"].map((name) => path.join(directory, "nested", name))
-        const files = roots.map((root) => path.join(root, "package", "index.js"))
-        yield* noUpdate(
-          (event) => roots.some((root) => event.file === root || event.file.startsWith(`${root}${path.sep}`)),
-          Effect.forEach(files, (file) => afs.writeWithDirs(file, "ignored"), {
-            concurrency: "unbounded",
-            discard: true,
-          }),
-        )
-      }),
-    ),
-  )
-
   it.live("cleanup stops publishing events", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service

packages/core/test/mcp.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { MCPClient } from "@opencode-ai/core/mcp/client"
-import { McpTool } from "@opencode-ai/core/tool/mcp"
 
 describe("MCP errors", () => {
   test("expose useful messages", () => {
@@ -13,7 +12,3 @@ describe("MCP errors", () => {
     expect(new MCPClient.ConnectError({ server: "demo", message: "offline" }).message).toBe("offline")
   })
 })
-
-test("MCP tool names match V1 sanitization", () => {
-  expect(McpTool.name("context 7", "resolve.library/id")).toBe("context_7_resolve_library_id")
-})

packages/core/test/plugin.test.ts

@@ -126,38 +126,6 @@ describe("PluginV2", () => {
     }),
   )
 
-  it.effect("groups tool names and defers registrations from direct exposure", () =>
-    Effect.gen(function* () {
-      const plugins = yield* PluginV2.Service
-      const registry = yield* ToolRegistry.Service
-      const tool = (description: string) =>
-        Tool.make({
-          description,
-          input: Schema.Struct({}),
-          output: Schema.Struct({ ok: Schema.Boolean }),
-          execute: () => Effect.succeed({ ok: true }),
-        })
-      const plugin = define({
-        id: "grouped-tools",
-        effect: (ctx) =>
-          Effect.gen(function* () {
-            yield* ctx.tool.register({ plain: tool("Plain") }).pipe(Effect.orDie)
-            yield* ctx.tool.register({ "look/up": tool("Lookup") }, { group: "context 7" }).pipe(Effect.orDie)
-            yield* ctx.tool
-              .register({ search: tool("Search") }, { group: "context 7", deferred: true })
-              .pipe(Effect.orDie)
-          }),
-      })
-
-      yield* plugins.add(PluginV2.ID.make(plugin.id), plugin.effect)
-
-      expect((yield* registry.materialize({ model: testModel })).definitions.map((tool) => tool.name)).toEqual([
-        "plain",
-        "context_7_look_up",
-      ])
-    }),
-  )
-
   it.effect("fires before/after tool hooks with mutable events around settlement", () =>
     Effect.gen(function* () {
       const plugins = yield* PluginV2.Service

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

@@ -562,9 +562,9 @@ describe("SessionV2.create", () => {
       yield* session.switchModel({ sessionID: created.id, model })
 
       expect(yield* session.get(created.id)).toMatchObject({ model })
-      const events = Array.from(yield* logEvents(session, created.id, true).pipe(Stream.take(1), Stream.runCollect))
-      expect(events).toMatchObject([{ type: "session.model.selected" }])
-      expect(events[0]?.data).toEqual({ sessionID: created.id, model })
+      expect(
+        Array.from(yield* logEvents(session, created.id, true).pipe(Stream.take(1), Stream.runCollect)),
+      ).toMatchObject([{ type: "session.model.selected", data: { model } }])
     }),
   )
 

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

@@ -34,7 +34,6 @@ const sessionsLayer = AppNodeBuilder.build(SessionV2.node, [[SessionExecution.no
 const sessionID = SessionV2.ID.make("ses_projector_test")
 const created = DateTime.makeUnsafe(0)
 const model = { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") }
-const previousModel = { ...model, variant: ModelV2.VariantID.make("medium") }
 const encodeMessage = Schema.encodeSync(SessionMessage.Message)
 
 const assistantRow = (
@@ -239,7 +238,6 @@ describe("SessionProjector", () => {
           directory: "/project",
           title: "test",
           version: "test",
-          model: previousModel,
         })
         .run()
         .pipe(Effect.orDie)
@@ -339,7 +337,6 @@ describe("SessionProjector", () => {
         text: "synthetic context",
         metadata: { source: "projector-test" },
       })
-      expect(messages.find((message) => message.type === "model-switched")).toMatchObject({ previous: previousModel })
       expect(messages.find((message) => message.type === "shell")).toMatchObject({
         shell: { command: "pwd", status: "exited", exit: 0 },
         output: { output: "/project", truncated: false },

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

@@ -1,87 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Location } from "@opencode-ai/core/location"
-import { PermissionV2 } from "@opencode-ai/core/permission"
-import { Ripgrep } from "@opencode-ai/core/ripgrep"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { SessionV2 } from "@opencode-ai/core/session"
-import { GlobTool } from "@opencode-ai/core/tool/glob"
-import { GrepTool } from "@opencode-ai/core/tool/grep"
-import { ToolRegistry } from "@opencode-ai/core/tool/registry"
-import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { location } from "./fixture/location"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-import { executeTool, registerToolPlugin, toolIdentity } from "./lib/tool"
-
-const globToolNode = makeLocationNode({
-  name: "test/glob-tool-plugin",
-  layer: Layer.effectDiscard(registerToolPlugin(GlobTool.Plugin)),
-  deps: [ToolRegistry.toolsNode, FSUtil.node, Ripgrep.node, Location.node, PermissionV2.node],
-})
-const grepToolNode = makeLocationNode({
-  name: "test/grep-tool-plugin",
-  layer: Layer.effectDiscard(registerToolPlugin(GrepTool.Plugin)),
-  deps: [ToolRegistry.toolsNode, FSUtil.node, Ripgrep.node, Location.node, PermissionV2.node],
-})
-const permission = Layer.succeed(
-  PermissionV2.Service,
-  PermissionV2.Service.of({
-    assert: () => Effect.void,
-    ask: () => Effect.die("unused"),
-    reply: () => Effect.die("unused"),
-    get: () => Effect.die("unused"),
-    forSession: () => Effect.die("unused"),
-    list: () => Effect.die("unused"),
-  }),
-)
-const sessionID = SessionV2.ID.make("ses_search_tool_test")
-
-const withTools = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) =>
-  Effect.gen(function* () {
-    return yield* body(yield* ToolRegistry.Service)
-  }).pipe(
-    Effect.provide(
-      AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, globToolNode, grepToolNode]), [
-        [
-          Location.node,
-          Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
-        ],
-        [PermissionV2.node, permission],
-        [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
-      ]),
-    ),
-  )
-
-const call = (name: "glob" | "grep", input: unknown) => ({
-  sessionID,
-  ...toolIdentity,
-  call: { type: "tool-call" as const, id: `call-${name}`, name, input },
-})
-
-const it = testEffect(Layer.empty)
-
-describe("search tools", () => {
-  for (const name of ["glob", "grep"] as const) {
-    it.live(`${name} reports a missing search path`, () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) =>
-          withTools(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const result = yield* executeTool(
-                registry,
-                call(name, { path: "missing", pattern: name === "glob" ? "*" : "needle" }),
-              )
-              expect(result).toEqual({ type: "error", value: "Search path does not exist: missing" })
-            }),
-          ),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      ),
-    )
-  }
-})

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

@@ -171,11 +171,9 @@ const withSession = <A, E, R>(directory: string, body: (registry: ToolRegistry.I
     })
     const locations = yield* LocationServiceMap.Service
     const locationLayer = locations.get(location)
-    return yield* Effect.gen(function* () {
-      const registry = yield* ToolRegistry.Service
-      yield* waitForTool(registry, ShellTool.name)
-      return yield* body(registry)
-    }).pipe(Effect.provide(locationLayer), Effect.ensuring(locations.invalidate(location)))
+    const registry = yield* ToolRegistry.Service.pipe(Effect.provide(locationLayer))
+    yield* waitForTool(registry, ShellTool.name)
+    return yield* body(registry).pipe(Effect.provide(locationLayer))
   })
 
 describe("ShellTool", () => {
@@ -480,13 +478,9 @@ describe("ShellTool", () => {
             const structured = settled.output?.structured as Record<string, unknown> | undefined
             const shellID = typeof structured?.shellID === "string" ? structured.shellID : undefined
             expect(settled.output?.structured).toMatchObject({ truncated: false })
-            expect(settled.output?.content[0]).toEqual({
+            expect(settled.output?.content[0]).toMatchObject({
               type: "text",
-              text: "The command was moved to the background.",
-            })
-            expect(settled.output?.content[1]).toMatchObject({
-              type: "text",
-              text: expect.stringContaining("DO NOT sleep, poll"),
+              text: expect.stringContaining("running in the background"),
             })
             expect(shellID).toStartWith("sh_")
 

packages/plugin/src/v2/effect/tool.ts

@@ -186,17 +186,8 @@ export const validateName = (name: string) =>
     ? Effect.void
     : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }))
 
-export const registrationEntries = (tools: Readonly<Record<string, AnyTool>>, group?: string) =>
-  Object.entries(tools).map(([name, tool]) => {
-    const normalized = name.replace(/[^a-zA-Z0-9_-]/g, "_")
-    const parent = group?.replace(/[^a-zA-Z0-9_-]/g, "_")
-    return {
-      key: parent === undefined ? normalized : `${parent}_${normalized}`,
-      name: normalized,
-      group: parent,
-      tool,
-    }
-  })
+export const registrationEntries = (tools: Readonly<Record<string, AnyTool>>) =>
+  Object.entries(tools).map(([name, tool]) => [name.replace(/[^a-zA-Z0-9_-]/g, "_"), tool] as const)
 
 export const withPermission = <Input extends SchemaType<any>, Output extends SchemaType<any>>(
   tool: Definition<Input, Output>,
@@ -244,15 +235,7 @@ export interface ToolExecuteAfterEvent {
   outputPaths?: ReadonlyArray<string>
 }
 
-export interface RegisterOptions {
-  readonly group?: string
-  readonly deferred?: boolean
-}
-
 export interface ToolDomain {
-  readonly register: (
-    tools: Readonly<Record<string, AnyTool>>,
-    options?: RegisterOptions,
-  ) => Effect.Effect<void, RegistrationError, Scope.Scope>
+  readonly register: (tools: Readonly<Record<string, AnyTool>>) => Effect.Effect<void, RegistrationError, Scope.Scope>
   readonly execute: Hooks<{ before: ToolExecuteBeforeEvent; after: ToolExecuteAfterEvent }>
 }

packages/schema/src/session-message.ts

@@ -44,7 +44,6 @@ export const ModelSelected = Schema.Struct({
   ...Base,
   type: Schema.Literal("model-switched"),
   model: Model.Ref,
-  previous: Model.Ref.pipe(optional),
 }).annotate({ identifier: "Session.Message.ModelSelected" })
 
 export interface User extends Schema.Schema.Type<typeof User> {}

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -4310,7 +4310,6 @@ export type SessionMessageModelSelected = {
   }
   type: "model-switched"
   model: ModelRef
-  previous?: ModelRef
 }
 
 export type SessionMessageUser = {
@@ -7986,7 +7985,6 @@ export type SessionMessageModelSelected2 = {
   }
   type: "model-switched"
   model: ModelRef2
-  previous?: ModelRef2
 }
 
 export type SessionMessageUser2 = {

packages/tui/src/app.tsx

@@ -409,8 +409,8 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
       else
         toast.show({
           variant: "error",
-          title: `MCP server failed: ${server.name}`,
-          message: "Open MCPs to view details.",
+          title: "MCP server failed to connect",
+          message: `${server.name}: ${status.error}`,
         })
     }
   })

packages/tui/src/component/dialog-mcp.tsx

@@ -1,17 +1,12 @@
 import { createEffect, createMemo, createSignal, onMount, Show } from "solid-js"
+import { createStore } from "solid-js/store"
 import { useData } from "../context/data"
 import { pipe, sortBy } from "remeda"
-import { DialogSelect } from "../ui/dialog-select"
+import { DialogSelect, type DialogSelectRef } from "../ui/dialog-select"
 import { useDialog } from "../ui/dialog"
 import { useTheme, type Theme } from "../context/theme"
-import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core"
+import { TextAttributes } from "@opentui/core"
 import type { McpServer } from "@opencode-ai/sdk/v2"
-import { useClipboard } from "../context/clipboard"
-import { useToast } from "../ui/toast"
-import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
-import { useTuiConfig } from "../config"
-import { getScrollAcceleration } from "../util/scroll"
-import { useBindings } from "../keymap"
 
 // Sort by how much attention a server needs: auth prompts first, then failures,
 // then healthy servers, and intentionally-off servers last.
@@ -36,8 +31,9 @@ export function DialogMcp() {
   const data = useData()
   const dialog = useDialog()
   const { theme } = useTheme()
+  const [expanded, setExpanded] = createStore<Record<string, boolean>>({})
   const [focused, setFocused] = createSignal<string>()
-  const [detail, setDetail] = createSignal<McpServer>()
+  const [, setRef] = createSignal<DialogSelectRef<unknown>>()
 
   onMount(() => {
     dialog.setSize("large")
@@ -70,6 +66,9 @@ export function DialogMcp() {
             {meta.icon} {meta.label}
           </span>
         ),
+        details: meta.error && expanded[server.name] ? [meta.error] : undefined,
+        detailsColor: theme.error,
+        detailsWrap: true,
       }
     }),
   )
@@ -80,103 +79,24 @@ export function DialogMcp() {
     return server ? statusMeta(server.status, theme).error : undefined
   })
 
-  const open = (name: string | undefined) => {
-    const server = servers().find((entry) => entry.name === name)
-    if (!server || !statusMeta(server.status, theme).error) return
-    setDetail(server)
-  }
-
   return (
-    <box>
-      <Show
-        when={detail()}
-        fallback={
-          <DialogSelect
-            title="MCPs"
-            options={options()}
-            current={focused()}
-            preserveSelection
-            onMove={(option) => setFocused(option.value as string)}
-            onSelect={(option) => open(option.value as string)}
-            footer={
-              <Show when={focusedError()}>
-                <text fg={theme.textMuted}>enter to view error</text>
-              </Show>
-            }
-          />
-        }
-      >
-        {(server) => <DialogMcpError server={server()} onBack={() => setDetail()} />}
-      </Show>
-    </box>
-  )
-}
-
-function DialogMcpError(props: { server: McpServer; onBack: () => void }) {
-  const dialog = useDialog()
-  const clipboard = useClipboard()
-  const toast = useToast()
-  const { theme } = useTheme()
-  const dimensions = useTerminalDimensions()
-  const tuiConfig = useTuiConfig()
-  const [copied, setCopied] = createSignal(false)
-  const error = () => statusMeta(props.server.status, theme).error ?? "Unknown MCP connection error"
-  const height = createMemo(() => Math.max(3, Math.floor(dimensions().height / 2) - 5))
-  let scroll: ScrollBoxRenderable | undefined
-
-  onMount(() => dialog.setSize("large"))
-
-  const copy = () => {
-    if (!clipboard.write) return
-    void clipboard
-      .write(error())
-      .then(() => setCopied(true))
-      .catch(toast.error)
-  }
-
-  useBindings(() => ({
-    bindings: [{ key: "escape", desc: "Back to MCP servers", group: "Dialog", cmd: props.onBack }],
-  }))
-
-  useKeyboard((event) => {
-    if (event.name === "c") return copy()
-    if (event.name === "up") return scroll?.scrollBy(-1)
-    if (event.name === "down") return scroll?.scrollBy(1)
-    if (event.name === "pageup") return scroll?.scrollBy(-height())
-    if (event.name === "pagedown") return scroll?.scrollBy(height())
-    if (event.name === "home") return scroll?.scrollTo(0)
-    if (event.name === "end" && scroll) return scroll.scrollTo(scroll.scrollHeight)
-  })
-
-  return (
-    <box paddingLeft={4} paddingRight={4} paddingBottom={1} gap={1}>
-      <box flexDirection="row" justifyContent="space-between">
-        <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          MCP / {props.server.name}
-        </text>
-        <text fg={theme.textMuted} onMouseUp={props.onBack}>
-          esc back
-        </text>
-      </box>
-      <text fg={theme.error}>✗ Failed</text>
-      <box backgroundColor={theme.backgroundElement} paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1}>
-        <scrollbox
-          ref={(element: ScrollBoxRenderable) => (scroll = element)}
-          height={height()}
-          scrollbarOptions={{ visible: false }}
-          scrollAcceleration={getScrollAcceleration(tuiConfig)}
-        >
-          <text fg={theme.text} wrapMode="word">
-            {error()}
-          </text>
-        </scrollbox>
-      </box>
-      <box flexDirection="row" justifyContent="space-between">
-        <text fg={theme.textMuted}>↑↓ scroll</text>
-        <text fg={theme.textMuted} onMouseUp={copy}>
-          {copied() ? "✓ copied" : "c copy details"}
-        </text>
-      </box>
-    </box>
+    <DialogSelect
+      ref={setRef}
+      title="MCPs"
+      options={options()}
+      preserveSelection
+      onMove={(option) => setFocused(option.value as string)}
+      onSelect={(option) => {
+        const name = option.value as string
+        const server = servers().find((entry) => entry.name === name)
+        if (!server || !statusMeta(server.status, theme).error) return
+        setExpanded(name, (open) => !open)
+      }}
+      footer={
+        <Show when={focusedError()}>
+          <text fg={theme.textMuted}>enter to {expanded[focused()!] ? "hide" : "view"} error</text>
+        </Show>
+      }
+    />
   )
 }

packages/tui/src/component/prompt/index.tsx

@@ -160,6 +160,7 @@ export function Prompt(props: PromptProps) {
   const dialog = useDialog()
   const toast = useToast()
   const status = createMemo(() => data.session.status(props.sessionID ?? ""))
+  const compaction = createMemo(() => data.session.compaction.get(props.sessionID ?? ""))
   const activeSubagents = createMemo(() => {
     if (!props.sessionID) return 0
     return data.session.family(props.sessionID).filter(
@@ -1637,6 +1638,18 @@ export function Prompt(props: PromptProps) {
         </box>
         <box width="100%" flexDirection="row" justifyContent="space-between">
           <Switch>
+            <Match when={compaction()}>
+              <box flexDirection="row" gap={1} flexGrow={1} justifyContent="flex-start">
+                <box marginLeft={1}>
+                  <Spinner>Compacting conversation...</Spinner>
+                </box>
+                <Show when={compaction() === "auto"}>
+                  <text fg={theme.text}>
+                    esc <span style={{ fg: theme.textMuted }}>interrupt</span>
+                  </text>
+                </Show>
+              </box>
+            </Match>
             <Match when={status() === "running"}>
               <box flexDirection="row" gap={1} flexGrow={1} justifyContent="flex-start">
                 <box marginLeft={1}>

packages/tui/src/context/data.tsx

@@ -26,6 +26,7 @@ import { useSDK } from "./sdk"
 import { createSignal, onCleanup } from "solid-js"
 
 export type DataSessionStatus = "idle" | "running"
+type CompactionReason = Extract<V2Event, { type: "session.compaction.started" }>["data"]["reason"]
 
 const messageIDFromEvent = (eventID: string) => eventID.replace(/^evt_/, "msg_")
 
@@ -51,6 +52,7 @@ type Data = {
     // session ID in that family, including the key itself once its info arrives.
     family: Record<string, string[]>
     status: Record<string, DataSessionStatus>
+    compaction: Record<string, CompactionReason>
     message: Record<string, SessionMessage[]>
     permission: Record<string, PermissionV2Request[]>
     question: Record<string, QuestionV2Request[]>
@@ -85,6 +87,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         info: {},
         family: {},
         status: {},
+        compaction: {},
         message: {},
         permission: {},
         question: {},
@@ -100,15 +103,8 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
       directory: process.cwd(),
     })
     const messageIndex = new Map<string, Map<string, number>>()
-    let connectionGeneration = 0
-    let statusChanges: Set<string> | undefined
     let bootstrapping: Promise<void> | undefined
 
-    function setSessionStatus(sessionID: string, status: DataSessionStatus) {
-      statusChanges?.add(sessionID)
-      setStore("session", "status", sessionID, status)
-    }
-
     const message = {
       update(sessionID: string, fn: (messages: SessionMessage[], index: Map<string, number>) => void) {
         setStore(
@@ -207,6 +203,25 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
       )
     }
 
+    const startCompaction = (sessionID: string, reason: CompactionReason) => {
+      if (store.session.status[sessionID] !== "running") setStore("session", "status", sessionID, "running")
+      if (store.session.compaction[sessionID] !== reason)
+        setStore("session", "compaction", sessionID, reason)
+    }
+
+    const clearCompaction = (sessionID: string, settleManual = true) => {
+      const reason = store.session.compaction[sessionID]
+      if (!reason) return
+      setStore(
+        "session",
+        "compaction",
+        produce((draft) => {
+          delete draft[sessionID]
+        }),
+      )
+      if (settleManual && reason === "manual") setStore("session", "status", sessionID, "idle")
+    }
+
     function handleEvent(event: V2Event) {
       switch (event.type) {
         case "session.created":
@@ -242,7 +257,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         case "session.model.selected":
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "model", event.data.model)
-          if (!store.session.message[event.data.sessionID]) break
           message.update(event.data.sessionID, (draft, index) => {
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
@@ -251,35 +265,22 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               time: { created: event.created },
             })
           })
-          void sdk.api.session
-            .message({ sessionID: event.data.sessionID, messageID: messageIDFromEvent(event.id) })
-            .then((item) => {
-              message.update(event.data.sessionID, (draft, index) => {
-                const position = index.get(item.id)
-                if (position === undefined) return message.append(draft, index, mutable(item))
-                draft[position] = mutable(item)
-              })
-            })
-            .catch((error) => console.error("Failed to load projected model switch message", error))
           break
         case "session.renamed":
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "title", event.data.title)
           break
         case "session.prompt.promoted": {
-          setSessionStatus(event.data.sessionID, "running")
+          setStore("session", "status", event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             const position = index.get(event.data.inputID)
-            if (position === undefined) return
-            const existing = draft[position]
-            if (existing?.type === "user" && existing.metadata?.queued === true) {
+            const existing = position === undefined ? undefined : draft[position]
+            if (existing?.type === "user") {
               existing.time.created = event.created
-              delete existing.metadata.queued
-              if (Object.keys(existing.metadata).length === 0) existing.metadata = undefined
-              draft.splice(position, 1)
-              draft.push(existing)
-              index.clear()
-              draft.forEach((message, indexValue) => index.set(message.id, indexValue))
+              if (existing.metadata?.queued === true) {
+                delete existing.metadata.queued
+                if (Object.keys(existing.metadata).length === 0) existing.metadata = undefined
+              }
               return
             }
           })
@@ -321,7 +322,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.shell.started":
-          setSessionStatus(event.data.sessionID, "running")
+          setStore("session", "status", event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
@@ -332,7 +333,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.shell.ended":
-          setSessionStatus(event.data.sessionID, "idle")
+          setStore("session", "status", event.data.sessionID, "idle")
           message.update(event.data.sessionID, (draft) => {
             const match = message.shell(draft, event.data.shell.id)
             if (!match) return
@@ -342,7 +343,8 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.step.started":
-          setSessionStatus(event.data.sessionID, "running")
+          clearCompaction(event.data.sessionID, false)
+          setStore("session", "status", event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             if (index.has(event.data.assistantMessageID)) return
             const currentAssistant = message.activeAssistant(draft)
@@ -359,7 +361,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.step.ended":
-          setSessionStatus(event.data.sessionID, "running")
+          setStore("session", "status", event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             const currentAssistant = message.assistant(draft, index, event.data.assistantMessageID)
             if (!currentAssistant) return
@@ -538,11 +540,14 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.retried":
+          setStore("session", "status", event.data.sessionID, "running")
+          break
         case "session.compaction.started":
-          setSessionStatus(event.data.sessionID, "running")
+          startCompaction(event.data.sessionID, event.data.reason)
           break
         case "session.execution.settled":
-          setSessionStatus(event.data.sessionID, "idle")
+          setStore("session", "status", event.data.sessionID, "idle")
+          clearCompaction(event.data.sessionID, false)
           break
         case "session.revert.staged":
           if (store.session.info[event.data.sessionID])
@@ -556,6 +561,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         case "session.compaction.delta":
           break
         case "session.compaction.ended":
+          clearCompaction(event.data.sessionID)
           message.update(event.data.sessionID, (draft, index) => {
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
@@ -676,6 +682,17 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         status(sessionID: string) {
           return store.session.status[sessionID] ?? "idle"
         },
+        compaction: {
+          get(sessionID: string) {
+            return store.session.compaction[sessionID]
+          },
+          startManual(sessionID: string) {
+            startCompaction(sessionID, "manual")
+          },
+          clearManual(sessionID: string) {
+            if (store.session.compaction[sessionID] === "manual") clearCompaction(sessionID)
+          },
+        },
         async refresh(sessionID: string) {
           setStore("session", "info", sessionID, mutable(await sdk.api.session.get({ sessionID })))
           registerSession(sessionID)
@@ -861,6 +878,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
 
     async function bootstrap() {
       if (bootstrapping) return bootstrapping
+      setStore("session", "compaction", reconcile({}))
       bootstrapping = Promise.allSettled([
         sdk.api.session
           .list({
@@ -879,6 +897,15 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             )
             for (const session of response.data) registerSession(session.id)
           }),
+        sdk.api.session
+          .active()
+          .then((active) =>
+            setStore(
+              "session",
+              "status",
+              Object.fromEntries(Object.keys(active.data).map((sessionID) => [sessionID, "running" as const])),
+            ),
+          ),
         result.location.refresh(),
         result.location.agent.refresh(),
         result.location.integration.refresh(),
@@ -900,30 +927,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
       return bootstrapping
     }
 
-    function refreshActive() {
-      const generation = ++connectionGeneration
-      const changed = new Set<string>()
-      statusChanges = changed
-      void sdk.api.session
-        .active()
-        .then((active) => {
-          if (generation !== connectionGeneration) return
-          const status: Record<string, DataSessionStatus> = Object.fromEntries(
-            Object.keys(active.data).map((sessionID) => [sessionID, "running" as const]),
-          )
-          for (const sessionID of changed) status[sessionID] = store.session.status[sessionID]
-          setStore("session", "status", reconcile(status))
-        })
-        .catch(() => undefined)
-        .finally(() => {
-          if (statusChanges === changed) statusChanges = undefined
-        })
-    }
-
     onCleanup(
       sdk.event.listen(({ details }) => {
         if (details.type === "server.connected") {
-          refreshActive()
           void bootstrap()
           return
         }

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

@@ -382,7 +382,25 @@ export function Session() {
         aliases: ["summarize"],
       },
       run: () => {
-        void sdk.api.session.compact({ sessionID: route.sessionID })
+        const sessionID = route.sessionID
+        if (data.session.status(sessionID) === "running") {
+          toast.show({
+            variant: "warning",
+            title: "Compaction unavailable",
+            message: "Wait for the current session activity to finish.",
+          })
+          dialog.clear()
+          return
+        }
+        data.session.compaction.startManual(sessionID)
+        void sdk.api.session.compact({ sessionID }).catch((error) => {
+          data.session.compaction.clearManual(sessionID)
+          toast.show({
+            variant: "error",
+            title: "Compaction failed",
+            message: errorMessage(error),
+          })
+        })
         dialog.clear()
       },
     },
@@ -1231,8 +1249,7 @@ function SessionSwitchMessageV2(props: { message: SessionMessage }) {
   const { theme } = useTheme()
   const text = () => {
     if (props.message.type === "agent-switched") return `Switched agent to ${props.message.agent}`
-    if (props.message.type === "model-switched")
-      return switchLabel(props.message.model, ctx.models(), props.message.previous)
+    if (props.message.type === "model-switched") return switchLabel(props.message.model, ctx.models())
     return ""
   }
   return <text fg={theme.textMuted}>{text()}</text>
@@ -2080,16 +2097,14 @@ function Shell(props: ToolProps) {
     return request?.source?.type === "tool" && request.source.callID === props.part.id
   })
   const color = createMemo(() => (permission() ? theme.warning : theme.text))
-  const shellID = createMemo(() => stringValue(props.metadata.shellID))
-  const backgroundRunning = createMemo(() => {
-    const id = shellID()
-    return Boolean(id && data.shell.get(id))
+  const isRunning = createMemo(() => {
+    if (props.part.state.status === "running") return true
+    const shellID = stringValue(props.metadata.shellID)
+    return Boolean(shellID && data.shell.get(shellID))
   })
-  const isRunning = createMemo(() => props.part.state.status === "running" || backgroundRunning())
   const command = createMemo(() => stringValue(props.input.command))
   const output = createMemo(() => {
     if (props.part.state.status === "pending") return ""
-    if (shellID()) return ""
     const content = props.part.state.content[0]
     return stripAnsi(content?.type === "text" ? content.text.trim() : "")
   })
@@ -2132,11 +2147,6 @@ function Shell(props: ToolProps) {
             </Spinner>
           </Show>
         </Show>
-        <Show when={shellID()}>
-          <text>
-            <span style={{ bg: theme.backgroundElement, fg: theme.textMuted }}> Backgrounded </span>
-          </text>
-        </Show>
         <Show when={collapsed().overflow}>
           <text fg={theme.textMuted}>{expanded() ? "Click to collapse" : "Click to expand"}</text>
         </Show>

packages/tui/src/routes/session/rows.ts

@@ -28,24 +28,23 @@ export function createSessionRows(sessionID: Accessor<string>) {
   function reduce() {
     const messages = data.session.message.list(sessionID())
     const boundary = revertBoundary()
-    const rows = reduceSessionRows(boundary ? messages.filter((message) => message.id < boundary) : messages)
-    partitionPending(rows, pendingPermissions())
-    return rows
+    return reduceSessionRows(boundary ? messages.filter((message) => message.id < boundary) : messages)
   }
 
-  function pendingPermissions() {
-    return new Set(
+  createEffect(() => {
+    const pending = new Set(
       (data.session.permission.list(sessionID()) ?? []).flatMap((request) =>
         request.source?.type === "tool" ? [request.source.callID] : [],
       ),
     )
-  }
-
-  createEffect(() => {
-    const pending = pendingPermissions()
     setRows(
       produce((draft) => {
-        partitionPending(draft, pending)
+        draft.forEach((row) => {
+          if (row.type !== "group") return
+          const refs = [...row.refs, ...row.pending]
+          row.refs = refs.filter((ref) => !pending.has(ref.partID))
+          row.pending = refs.filter((ref) => pending.has(ref.partID))
+        })
       }),
     )
   })
@@ -70,20 +69,6 @@ export function createSessionRows(sessionID: Accessor<string>) {
     }),
   )
 
-  createEffect(
-    on(
-      () =>
-        data.session.message
-          .list(sessionID())
-          .flatMap((message) =>
-            message.type === "user"
-              ? [{ id: message.id, created: message.time.created, queued: message.metadata?.queued === true }]
-              : [],
-          ),
-      () => setRows(reconcile(reduce())),
-    ),
-  )
-
   const appendMessage = (messageID: string) =>
     setRows(
       produce((draft) => {
@@ -149,6 +134,7 @@ export function createSessionRows(sessionID: Accessor<string>) {
   }
   const subscriptions = [
     data.on("session.prompt.admitted", input),
+    data.on("session.prompt.promoted", input),
     data.on("session.context.updated", message),
     data.on("session.synthetic", (event) => {
       if (event.data.sessionID === sessionID() && event.data.description?.trim())
@@ -239,15 +225,6 @@ function completePrevious(rows: SessionRow[], index = rows.length) {
   if (previous?.type === "group") previous.completed = true
 }
 
-function partitionPending(rows: SessionRow[], pending: Set<string>) {
-  rows.forEach((row) => {
-    if (row.type !== "group") return
-    const refs = [...row.refs, ...row.pending]
-    row.refs = refs.filter((ref) => !pending.has(ref.partID))
-    row.pending = refs.filter((ref) => pending.has(ref.partID))
-  })
-}
-
 function exploration(name: string) {
   return ["read", "glob", "grep"].includes(name.toLowerCase())
 }

packages/tui/src/util/model.ts

@@ -34,12 +34,11 @@ export function formatRef(model: { providerID: string; id: string; variant?: str
 export function switchLabel(
   model: { providerID: string; id: string; variant?: string },
   models?: readonly { providerID: string; id: string; name: string }[],
-  previous?: { providerID: string; id: string; variant?: string },
 ) {
-  if (previous?.providerID === model.providerID && previous.id === model.id)
-    return `Switched variant to ${model.variant ?? "default"}`
   const display = models?.find((item) => item.providerID === model.providerID && item.id === model.id)?.name
   if (display === undefined) return `Switched model to ${formatRef(model)}`
+  // Variant-only switches publish the same model id; without the variant the
+  // notice would look like a redundant model switch.
   const variant = model.variant && model.variant !== "default" ? ` (${model.variant})` : ""
   return `Switched model to ${display}${variant}`
 }

packages/tui/test/cli/tui/data.test.tsx

@@ -8,7 +8,6 @@ import { onMount } from "solid-js"
 import { ProjectProvider } from "../../../src/context/project"
 import { SDKProvider } from "../../../src/context/sdk"
 import { DataProvider, useData } from "../../../src/context/data"
-import { createSessionRows } from "../../../src/routes/session/rows"
 import { createApi, createClient, createEventStream, createFetch, directory, json } from "../../fixture/tui-sdk"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 
@@ -110,20 +109,12 @@ test("refreshes resources into reactive getters", async () => {
 
 test("reconnects the event stream and bootstraps fresh data", async () => {
   const events = createEventStream()
-  const requests = { active: 0, event: 0, model: 0 }
-  let resolveActive!: (response: Response) => void
+  const requests = { event: 0, model: 0 }
   const calls = createFetch((url) => {
     if (url.pathname === "/api/event") {
       requests.event++
       return events.v2()
     }
-    if (url.pathname === "/api/session/active") {
-      requests.active++
-      if (requests.active === 1) return json({ data: { "session-stale": { type: "running" } }, watermarks: {} })
-      return new Promise<Response>((resolve) => {
-        resolveActive = resolve
-      })
-    }
     if (url.pathname !== "/api/model") return
     requests.model++
     return json({
@@ -166,7 +157,6 @@ test("reconnects the event stream and bootstraps fresh data", async () => {
 
   try {
     await wait(() => data.location.model.list()?.[0]?.id === "model-1")
-    await wait(() => data.session.status("session-stale") === "running")
     expect(data.connection.status()).toBe("connected")
     expect(data.connection.attempt()).toBe(0)
 
@@ -175,25 +165,7 @@ test("reconnects the event stream and bootstraps fresh data", async () => {
     expect(data.connection.attempt()).toBe(1)
     expect(data.connection.error()).toBe("Event stream disconnected")
 
-    await wait(() => requests.active === 2 && data.connection.status() === "connected", 4000)
-    emitEvent(events, {
-      id: "evt_step_started_after_reconnect",
-      created: 1,
-      type: "session.step.started",
-      durable: durable("session-new"),
-      data: {
-        sessionID: "session-new",
-        assistantMessageID: "message-new",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    await wait(() => data.session.status("session-new") === "running")
-    resolveActive(json({ data: {}, watermarks: {} }))
-
     await wait(() => data.location.model.list()?.[0]?.id === "model-2", 4000)
-    await wait(() => data.session.status("session-stale") === "idle")
-    expect(data.session.status("session-new")).toBe("running")
     expect(requests.event).toBe(2)
     expect(data.connection.status()).toBe("connected")
     expect(data.connection.attempt()).toBe(0)
@@ -203,87 +175,6 @@ test("reconnects the event stream and bootstraps fresh data", async () => {
   }
 })
 
-test("completes exploration when a queued prompt is promoted", async () => {
-  const events = createEventStream()
-  const sessionID = "session-promotion"
-  const calls = createFetch((url) => {
-    if (url.pathname === `/api/session/${sessionID}/message`) return json({ data: [], cursor: {} })
-  }, events)
-  let rows!: ReturnType<typeof createSessionRows>
-
-  function Probe() {
-    rows = createSessionRows(() => sessionID)
-    return <box />
-  }
-
-  const app = await testRender(() => (
-    <TestTuiContexts>
-      <SDKProvider client={createClient(calls.fetch)} api={createApi(calls.fetch)}>
-        <ProjectProvider>
-          <DataProvider>
-            <Probe />
-          </DataProvider>
-        </ProjectProvider>
-      </SDKProvider>
-    </TestTuiContexts>
-  ))
-
-  try {
-    emitEvent(events, {
-      id: "evt_step_started",
-      created: 1,
-      type: "session.step.started",
-      durable: durable(sessionID),
-      data: {
-        sessionID,
-        assistantMessageID: "message-assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    emitEvent(events, {
-      id: "evt_tool_started",
-      created: 2,
-      type: "session.tool.input.started",
-      durable: durable(sessionID, 1),
-      data: {
-        sessionID,
-        assistantMessageID: "message-assistant",
-        callID: "call-read",
-        name: "read",
-      },
-    })
-    await wait(() => rows.some((row) => row.type === "group" && !row.completed))
-
-    emitEvent(events, {
-      id: "evt_prompt_admitted",
-      created: 3,
-      type: "session.prompt.admitted",
-      durable: durable(sessionID, 2),
-      data: {
-        sessionID,
-        inputID: "message-user",
-        prompt: { text: "Continue" },
-        delivery: "steer",
-      },
-    })
-    await wait(() => rows.at(-1)?.type === "message")
-    expect(rows.find((row) => row.type === "group")?.completed).toBe(false)
-
-    emitEvent(events, {
-      id: "evt_prompt_promoted",
-      created: 4,
-      type: "session.prompt.promoted",
-      durable: durable(sessionID, 3),
-      data: { sessionID, inputID: "message-user" },
-    })
-    await wait(() => rows.find((row) => row.type === "group")?.completed === true)
-    expect(rows.at(-1)).toEqual({ type: "message", messageID: "message-user" })
-  } finally {
-    app.renderer.destroy()
-  }
-})
-
 test("connectedOnce is false until first connect and persists across disconnect", async () => {
   const encoder = new TextEncoder()
   let stream: ReadableStreamDefaultController<Uint8Array> | undefined
@@ -419,6 +310,61 @@ test("tracks session status from active sessions and execution events", async ()
     })
     await wait(() => data.session.status("session-live") === "idle")
 
+    emitEvent(events, {
+      id: "evt_compaction_started",
+      created: 0,
+      type: "session.compaction.started",
+      durable: durable("session-compact"),
+      data: {
+        sessionID: "session-compact",
+        reason: "manual",
+      },
+    })
+    await wait(() => data.session.compaction.get("session-compact") === "manual")
+    expect(data.session.status("session-compact")).toBe("running")
+
+    emitEvent(events, {
+      id: "evt_compaction_ended",
+      created: 0,
+      type: "session.compaction.ended",
+      durable: durable("session-compact", 1, 2),
+      data: {
+        sessionID: "session-compact",
+        reason: "manual",
+        text: "Summary",
+        recent: "",
+      },
+    })
+    await wait(() => data.session.compaction.get("session-compact") === undefined)
+    expect(data.session.status("session-compact")).toBe("idle")
+
+    emitEvent(events, {
+      id: "evt_auto_compaction_started",
+      created: 0,
+      type: "session.compaction.started",
+      durable: durable("session-auto-compact"),
+      data: {
+        sessionID: "session-auto-compact",
+        reason: "auto",
+      },
+    })
+    await wait(() => data.session.compaction.get("session-auto-compact") === "auto")
+
+    emitEvent(events, {
+      id: "evt_post_compaction_step",
+      created: 0,
+      type: "session.step.started",
+      durable: durable("session-auto-compact", 1, 2),
+      data: {
+        sessionID: "session-auto-compact",
+        assistantMessageID: "message-after-compaction",
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+      },
+    })
+    await wait(() => data.session.compaction.get("session-auto-compact") === undefined)
+    expect(data.session.status("session-auto-compact")).toBe("running")
+
     emitEvent(events, {
       id: "evt_failed_step_started",
       created: 0,
@@ -876,18 +822,7 @@ test("adds and dismisses question requests from live events", async () => {
 
 test("settles pending tools when a live failure arrives", async () => {
   const events = createEventStream()
-  const calls = createFetch((url) => {
-    if (url.pathname === "/api/session/session-1/message/msg_model_1")
-      return json({
-        data: {
-          id: "msg_model_1",
-          type: "model-switched",
-          previous: { id: "model-1", providerID: "provider-1", variant: "medium" },
-          model: { id: "model-1", providerID: "provider-1", variant: "high" },
-          time: { created: 0 },
-        },
-      })
-  }, events)
+  const calls = createFetch(undefined, events)
   let sync!: ReturnType<typeof useData>
   let ready!: () => void
   const mounted = new Promise<void>((resolve) => {
@@ -928,7 +863,7 @@ test("settles pending tools when a live failure arrives", async () => {
       durable: durable("session-1", 1),
       data: {
         sessionID: "session-1",
-        model: { id: "model-1", providerID: "provider-1", variant: "high" },
+        model: { id: "model-1", providerID: "provider-1" },
       },
     })
     emitEvent(events, {
@@ -1015,11 +950,6 @@ test("settles pending tools when a live failure arrives", async () => {
       "model-switched",
       "assistant",
     ])
-    expect(sync.session.message.get("session-1", "msg_model_1")).toMatchObject({
-      type: "model-switched",
-      previous: { id: "model-1", providerID: "provider-1", variant: "medium" },
-      model: { id: "model-1", providerID: "provider-1", variant: "high" },
-    })
   } finally {
     app.renderer.destroy()
   }

packages/tui/test/util/model.test.ts

@@ -34,16 +34,4 @@ describe("util.model", () => {
       "Switched model to removed/gone/high",
     )
   })
-
-  test("distinguishes variant-only switches from model switches", () => {
-    const previous = { providerID: "openai", id: "gpt-5.5", variant: "medium" }
-
-    expect(switchLabel({ ...previous, variant: "high" }, undefined, previous)).toBe("Switched variant to high")
-    expect(switchLabel({ providerID: "openai", id: "gpt-5.5" }, undefined, previous)).toBe(
-      "Switched variant to default",
-    )
-    expect(switchLabel({ providerID: "anthropic", id: "sonnet", variant: "high" }, undefined, previous)).toBe(
-      "Switched model to anthropic/sonnet/high",
-    )
-  })
 })

packages/web/src/content/docs/config.mdx

@@ -749,12 +749,12 @@ You can configure file watcher ignore patterns through the `watcher` option.
 {
   "$schema": "https://opencode.ai/config.json",
   "watcher": {
-    "ignore": ["**/generated/**"]
+    "ignore": ["node_modules/**", "dist/**", ".git/**"]
   }
 }
 ```
 
-Patterns follow glob syntax. Common dependency, VCS, build, and cache directories are ignored automatically at any depth.
+Patterns follow glob syntax. Use this to exclude noisy directories from file watching.
 
 ---