refactor(plugin): return tool output directly

This reverts commit afe3ebbc35.

.opencode/plugins/orchestrator.ts

@@ -1,36 +0,0 @@
-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,6 +104,25 @@ 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,6 +151,7 @@ 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,6 +928,7 @@ 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
@@ -1621,6 +1622,7 @@ 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
@@ -1820,6 +1822,7 @@ 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/plugin/external.ts

@@ -2,8 +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, Stream } from "effect"
-import { createRequire } from "node:module"
+import { Effect, Schema } from "effect"
 import path from "path"
 import { fileURLToPath, pathToFileURL } from "url"
 import { Config } from "../../config"
@@ -36,9 +35,6 @@ const PluginPackage = Schema.Struct({
   module: Schema.optional(Schema.String),
 })
 
-let importGeneration = 0
-const moduleCache = createRequire(import.meta.url).cache
-
 export const Plugin = define({
   id: "config-plugin",
   effect: Effect.fn(function* (ctx) {
@@ -46,7 +42,6 @@ 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> }[] = []
 
@@ -110,7 +105,7 @@ export const Plugin = define({
             : (yield* npm.add(ref.package)).entrypoint
           if (!entrypoint) return
           yield* Effect.log({ msg: "loading plugin", id: ref.package, entrypoint })
-          const mod = yield* Effect.promise(() => import(cacheBust(entrypoint)))
+          const mod = yield* Effect.promise(() => import(entrypoint))
           const value = (yield* Schema.decodeUnknownEffect(PluginModule)(mod)).default
           const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
           return {
@@ -118,40 +113,13 @@ export const Plugin = define({
             effect: (host: Parameters<typeof plugin.effect>[0]) =>
               plugin.effect({ ...host, options: ref.options ?? {} }),
           }
-        }).pipe(
-          Effect.catchCause((cause) =>
-            Effect.logError("failed to load plugin", { package: ref.package, cause }).pipe(Effect.as(undefined)),
-          ),
-        ),
+        }).pipe(Effect.catchCause(() => Effect.succeed(undefined))),
       ).pipe(Effect.map((plugins) => plugins.filter((plugin) => plugin !== undefined)))
     })
-    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 }),
-    )
+    for (const plugin of yield* load()) yield* ctx.plugin.add(plugin)
   }),
 })
 
-function cacheBust(entrypoint: string) {
-  const url = path.isAbsolute(entrypoint) ? pathToFileURL(entrypoint) : new URL(entrypoint)
-  if (url.protocol === "file:") delete moduleCache[fileURLToPath(url)]
-  url.searchParams.set("opencode-reload", String(++importGeneration))
-  return url.href
-}
-
 const resolvePackageEntrypoint = Effect.fnUntraced(function* (fs: FSUtil.Interface, directory: string) {
   const pkg = yield* fs.readJson(path.join(directory, "package.json")).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(PluginPackage)),

packages/core/src/filesystem/ignore.ts

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

packages/core/src/session.ts

@@ -540,7 +540,8 @@ 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,
               {
@@ -563,8 +564,7 @@ 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,6 +8,7 @@ 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,
@@ -29,6 +30,15 @@ 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()
@@ -115,15 +125,19 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         )
       },
       "session.model.selected": (event) => {
-        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 },
-          }),
-        )
+        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 },
+            }),
+          )
+        })
       },
       "session.moved": () => Effect.void,
       "session.renamed": () => Effect.void,

packages/core/src/session/projector.ts

@@ -5,6 +5,7 @@ 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"
@@ -356,6 +357,17 @@ 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.
@@ -570,13 +582,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

@@ -4,7 +4,7 @@ This folder owns Core's one local tool representation, process and Location regi
 
 ## Representations
 
-- `tool.ts` defines the opaque canonical `Tool.make({ description, input, output, execute, toModelOutput })` value. Shipped built-ins and plugin tools use the same type.
+- `tool.ts` re-exports the opaque canonical `Tool.make({ description, input, output, execute })` value. Shipped built-ins and plugin tools use the same type.
 - `tools.ts` exposes the registration-only `Tools.Service` view used by Location producers.
 - `registry.ts` stores only canonical Location registrations, derives definitions, invokes tools, and applies generic output bounding.
 
@@ -12,7 +12,7 @@ Do not add a second executable entry type, registry-owned executor, authorizatio
 
 ## Construction
 
-Tool schemas and projection use `input` and `output` terminology. A tool value is opaque: its codecs, executor, definition derivation, and catalog permission declaration are private runtime details.
+Tool schemas use `input` and `output` terminology. Executors return `{ structured, content }` directly. A tool value is opaque: its codecs, executor, definition derivation, and catalog permission declaration are private runtime details.
 
 Location-scoped built-in layers acquire `PermissionV2.Service` and every other required Location service while the layer is constructed. The executor captures those services. Permission sources are always constructed from the canonical invocation context:
 
@@ -46,7 +46,7 @@ Definition filtering is catalog visibility, not execution authorization. A call
 
 ## Output
 
-Built-ins return complete validated domain output. `ToolRegistry.Materialization.settle` is the only execution and generic model-output bounding boundary and owns managed retention paths.
+Built-ins return complete structured output and model content together. `ToolRegistry.Materialization.settle` validates and encodes the structured value, then applies generic model-output bounding and owns managed retention paths.
 
 Producer capture limits are separate. For example, Bash keeps `AppProcess.maxOutputBytes` and accurately reports stdout/stderr capture loss, but it does not run model-output truncation or return a managed `outputPath`.
 

packages/core/src/tool/apply-patch.ts

@@ -70,7 +70,6 @@ export const Plugin = {
               "Apply one patch containing add, update, and delete file operations. All targets are resolved and approved before target contents are read. Operations apply sequentially; if a later operation fails, earlier operations remain applied and the failure reports them explicitly. Moves and atomic rollback are not supported yet.",
             input: Input,
             output: Output,
-            toModelOutput: ({ output }) => [{ type: "text", text: toModelOutput(output) }],
             execute: (input, context) => {
               const applied: Array<typeof Applied.Type> = []
               const fail = (path: string) => {
@@ -184,7 +183,13 @@ export const Plugin = {
                   { discard: true },
                 )
                 return { applied, files: patchFiles }
-              }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch"))))
+              }).pipe(
+                Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch"))),
+                Effect.map((structured) => ({
+                  structured,
+                  content: [{ type: "text", text: toModelOutput(structured) }],
+                })),
+              )
             },
           }),
           "edit",

packages/core/src/tool/edit.ts

@@ -101,9 +101,6 @@ export const Plugin = {
               "Replace exact text in one file. Relative paths resolve within the active Location. Absolute paths inside the Location are accepted. Explicit external absolute paths require external_directory approval before edit approval.",
             input: Input,
             output: Output,
-            toModelOutput: ({ input, output }) => [
-              { type: "text", text: toModelOutput(output, input.oldString, input.newString) },
-            ],
             execute: (input, context) => {
               const unableToEdit = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
                 effect.pipe(
@@ -204,7 +201,12 @@ export const Plugin = {
                   ],
                   replacements,
                 } satisfies Output
-              })
+              }).pipe(
+                Effect.map((structured) => ({
+                  structured,
+                  content: [{ type: "text", text: toModelOutput(structured, input.oldString, input.newString) }],
+                })),
+              )
             },
           }),
           "edit",

packages/core/src/tool/glob.ts

@@ -5,6 +5,7 @@ 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"
@@ -36,6 +37,7 @@ 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
@@ -47,14 +49,6 @@ export const Plugin = {
             "Find files by glob pattern within the active Location. Returns concise relative file resources. Use a relative path to narrow the search and limit to bound the result count.",
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [
-            {
-              type: "text",
-              text: toModelOutput(
-                output.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })),
-              ),
-            },
-          ],
           execute: (input, context) =>
             Effect.gen(function* () {
               yield* permission.assert({
@@ -71,6 +65,13 @@ 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,
@@ -88,7 +89,25 @@ export const Plugin = {
                   ),
                 )
             }).pipe(
-              Effect.mapError(() => new ToolFailure({ message: `Unable to find files matching ${input.pattern}` })),
+              Effect.mapError((error) =>
+                error instanceof ToolFailure
+                  ? error
+                  : new ToolFailure({ message: `Unable to find files matching ${input.pattern}` }),
+              ),
+              Effect.map((structured) => ({
+                structured,
+                content: [
+                  {
+                    type: "text",
+                    text: toModelOutput(
+                      structured.map((entry) => ({
+                        ...entry,
+                        path: path.resolve(location.directory, entry.path),
+                      })),
+                    ),
+                  },
+                ],
+              })),
             ),
         }),
       })

packages/core/src/tool/grep.ts

@@ -63,17 +63,6 @@ export const Plugin = {
             "Search file contents by regular expression within the active Location or an absolute managed tool-output file. Use a path to narrow the search, include to filter files by glob, and limit to bound the match count. Returns concise file resources, line numbers, and bounded line previews.",
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [
-            {
-              type: "text",
-              text: toModelOutput(
-                output.map((match) => ({
-                  ...match,
-                  entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
-                })),
-              ),
-            },
-          ],
           execute: (input, context) =>
             Effect.gen(function* () {
               yield* permission.assert({
@@ -91,7 +80,13 @@ 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.catch(() => Effect.succeed(undefined)))
+              const info = yield* fs
+                .stat(target)
+                .pipe(
+                  Effect.catchReason("PlatformError", "NotFound", () =>
+                    Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
+                  ),
+                )
               return yield* ripgrep
                 .grep({
                   cwd: info?.type === "Directory" ? target : path.dirname(target),
@@ -121,7 +116,27 @@ export const Plugin = {
                     ),
                   ),
                 )
-            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to grep for ${input.pattern}` }))),
+            }).pipe(
+              Effect.mapError((error) =>
+                error instanceof ToolFailure
+                  ? error
+                  : new ToolFailure({ message: `Unable to grep for ${input.pattern}` }),
+              ),
+              Effect.map((structured) => ({
+                structured,
+                content: [
+                  {
+                    type: "text",
+                    text: toModelOutput(
+                      structured.map((match) => ({
+                        ...match,
+                        entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
+                      })),
+                    ),
+                  },
+                ],
+              })),
+            ),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/question.ts

@@ -54,9 +54,6 @@ export const Plugin = {
           description,
           input: Input,
           output: Output,
-          toModelOutput: ({ input, output }) => [
-            { type: "text", text: toModelOutput(input.questions, output.answers) },
-          ],
           execute: (input, context) =>
             permission
               .assert({
@@ -77,7 +74,10 @@ export const Plugin = {
                     })
                     .pipe(Effect.orDie),
                 ),
-                Effect.map((answers) => ({ answers })),
+                Effect.map((answers) => ({
+                  structured: { answers },
+                  content: [{ type: "text", text: toModelOutput(input.questions, answers) }],
+                })),
               ),
         }),
       })

packages/core/src/tool/read.ts

@@ -48,14 +48,6 @@ export const Plugin = {
             "Read a text file or supported image, page through a large UTF-8 text file by line offset, or list a directory page. Relative paths resolve from the current location; absolute paths inside it are accepted, while external absolute paths require external_directory approval.",
           input: Input,
           output: Output,
-          toModelOutput: ({ input, output }) => {
-            if (!("encoding" in output) || output.encoding !== "base64" || !SUPPORTED_IMAGE_MIMES.has(output.mime))
-              return []
-            return [
-              { type: "text", text: "Image read successfully" },
-              { type: "file", data: output.content, mime: output.mime, name: input.path },
-            ]
-          },
           execute: (input, context) => {
             return Effect.gen(function* () {
               const source = {
@@ -106,7 +98,9 @@ export const Plugin = {
                   start: type === "directory" ? resolved : dirname(resolved),
                   stop: root,
                 })
-                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root)
+                const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter(
+                  (file) => dirname(file) !== root,
+                )
                 if (candidates.length === 0) return
                 yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates })
               }).pipe(
@@ -132,6 +126,23 @@ export const Plugin = {
                     : `Unable to read ${input.path}`
                 return new ToolFailure({ message })
               }),
+              Effect.map((structured) => ({
+                structured,
+                content:
+                  "encoding" in structured &&
+                  structured.encoding === "base64" &&
+                  SUPPORTED_IMAGE_MIMES.has(structured.mime)
+                    ? [
+                        { type: "text" as const, text: "Image read successfully" },
+                        {
+                          type: "file" as const,
+                          data: structured.content,
+                          mime: structured.mime,
+                          name: input.path,
+                        },
+                      ]
+                    : [],
+              })),
             )
           },
         }),

packages/core/src/tool/shell.ts

@@ -18,8 +18,9 @@ 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 has not completed; it is now running in the background."
+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."
 
 export const Input = Schema.Struct({
   command: Schema.String.annotate({ description: "Shell command string to execute" }),
@@ -44,20 +45,17 @@ const StructuredOutput = Schema.Struct({
   timeout: Schema.Boolean.pipe(Schema.optional),
 })
 
-const Output = Schema.Struct({
-  ...StructuredOutput.fields,
-  output: Schema.String,
-  status: Schema.Literals(["completed", "running"]).pipe(Schema.optional),
-  warnings: Schema.Array(Schema.String).pipe(Schema.optional),
-})
+type Result = typeof StructuredOutput.Type & {
+  readonly output: string
+  readonly status?: "completed" | "running"
+  readonly warnings?: ReadonlyArray<string>
+}
 
-type Output = typeof Output.Type
-
-const modelOutput = (output: Output): string | undefined => {
-  if (output.status === "running") return undefined
+const modelOutput = (output: Result): string | 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}.`
 }
@@ -142,20 +140,7 @@ export const Plugin = {
         [name]: Tool.make({
           description: `Execute one shell command string with the host user's filesystem, process, and network authority. The active Location is the default working directory. Relative workdir values resolve from that Location. External workdir values require external_directory approval; best-effort command-argument path warnings are advisory only. Timeout values are milliseconds (default: ${DEFAULT_TIMEOUT_MS}; maximum: ${MAX_TIMEOUT_MS}). Uses the configured shell when set; otherwise uses /bin/sh on POSIX and COMSPEC or cmd.exe on Windows. Background mode (background=true) launches the command asynchronously and returns immediately; you are notified when it finishes.`,
           input: Input,
-          output: Output,
-          structured: StructuredOutput,
-          toStructuredOutput: ({ output }) => ({
-            truncated: output.truncated,
-            ...(output.exit === undefined ? {} : { exit: output.exit }),
-            ...(output.shellID === undefined ? {} : { shellID: output.shellID }),
-            ...(output.timeout === undefined ? {} : { timeout: output.timeout }),
-          }),
-          toModelOutput: ({ output }) => {
-            const parts: Content[] = [{ type: "text", text: output.output }]
-            const model = modelOutput(output)
-            if (model) parts.push({ type: "text", text: model })
-            return parts
-          },
+          output: StructuredOutput,
           execute: (input, context) =>
             Effect.gen(function* () {
               const source = {
@@ -245,9 +230,9 @@ export const Plugin = {
                 }
               }
 
-              const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(
-                Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)),
-              )
+              const result = yield* runtime.job
+                .block({ id: job.id, sessionID: context.sessionID })
+                .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
               if (result?.type === "backgrounded") {
                 yield* notifyWhenDone(context.sessionID, context.toolCallID, input.command)
                 return {
@@ -258,14 +243,26 @@ export const Plugin = {
                   ...(warnings.length ? { warnings } : {}),
                 }
               }
-              if (result?.info.status === "error") return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
+              if (result?.info.status === "error")
+                return yield* Effect.fail(new Error(result.info.error ?? "Command failed"))
               if (result?.info.status === "cancelled") return yield* Effect.fail(new Error("Command cancelled"))
 
               return {
                 ...(yield* settleShell()),
                 ...(warnings.length ? { warnings } : {}),
               }
-            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to execute command: ${input.command}` }))),
+            }).pipe(
+              Effect.mapError(() => new ToolFailure({ message: `Unable to execute command: ${input.command}` })),
+              Effect.map((result) => {
+                const content: Content[] = [{ type: "text", text: result.output }]
+                const model = modelOutput(result)
+                if (model) content.push({ type: "text", text: model })
+                return {
+                  structured: result,
+                  content,
+                }
+              }),
+            ),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/skill.ts

@@ -64,7 +64,6 @@ export const Plugin = {
           description,
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [{ type: "text", text: output.output }],
           execute: (input, context) =>
             Effect.gen(function* () {
               const current = yield* skills.list()
@@ -87,11 +86,15 @@ export const Plugin = {
                         .toSorted()
                         .slice(0, FILE_LIMIT)
                     : []
-                return {
+                const structured = {
                   name: skill.name,
                   directory,
                   output: toModelOutput(skill, files),
                 }
+                return {
+                  structured,
+                  content: [{ type: "text" as const, text: structured.output }],
+                }
               }).pipe(Effect.mapError((error) => unableToLoad(input.name, error)))
             }),
         }),

packages/core/src/tool/subagent.ts

@@ -92,13 +92,17 @@ export const Plugin = {
       )
     })
 
+    const output = (structured: typeof Output.Type) => ({
+      structured,
+      content: [{ type: "text" as const, text: structured.output }],
+    })
+
     yield* ctx.tool
       .register({
         [name]: Tool.make({
           description,
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [{ type: "text", text: output.output }],
           execute: (input, context) =>
             Effect.gen(function* () {
               const parent = yield* runtime.session
@@ -146,7 +150,7 @@ export const Plugin = {
               if (background) {
                 yield* runtime.job.background(info.id)
                 yield* notifyWhenDone(context.sessionID, child.id, input.description)
-                return { sessionID: child.id, status: "running" as const, output: BACKGROUND_STARTED }
+                return output({ sessionID: child.id, status: "running", output: BACKGROUND_STARTED })
               }
 
               const result = yield* runtime.job.block({ id: child.id, sessionID: context.sessionID }).pipe(
@@ -158,12 +162,16 @@ export const Plugin = {
               )
               if (result?.type === "backgrounded") {
                 yield* notifyWhenDone(context.sessionID, child.id, input.description)
-                return { sessionID: child.id, status: "running" as const, output: BACKGROUND_STARTED }
+                return output({ sessionID: child.id, status: "running", output: BACKGROUND_STARTED })
               }
               if (result?.info.status === "error")
                 return yield* new ToolFailure({ message: result.info.error ?? "Subagent failed" })
               if (result?.info.status === "cancelled") return yield* new ToolFailure({ message: "Subagent cancelled" })
-              return { sessionID: child.id, status: "completed" as const, output: result?.info.output ?? NO_TEXT }
+              return output({
+                sessionID: child.id,
+                status: "completed",
+                output: result?.info.output ?? NO_TEXT,
+              })
             }),
         }),
       })

packages/core/src/tool/todowrite.ts

@@ -33,7 +33,6 @@ export const Plugin = {
             "Create and maintain a structured task list for the current coding session. Use it to track progress during multi-step work and keep todo statuses current.",
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [{ type: "text", text: toModelOutput(output) }],
           execute: (input, context) =>
             Effect.gen(function* () {
               yield* permission.assert({
@@ -45,7 +44,11 @@ export const Plugin = {
                 source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
               })
               yield* todos.update({ sessionID: context.sessionID, todos: input.todos })
-              return { todos: input.todos }
+              const structured = { todos: input.todos }
+              return {
+                structured,
+                content: [{ type: "text" as const, text: toModelOutput(structured) }],
+              }
             }).pipe(Effect.mapError(() => new ToolFailure({ message: "Unable to update todos" }))),
         }),
       })

packages/core/src/tool/webfetch.ts

@@ -124,7 +124,6 @@ export const Plugin = {
           description,
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [{ type: "text", text: output.output }],
           execute: (input, context) =>
             Effect.gen(function* () {
               yield* Effect.try({
@@ -170,7 +169,13 @@ export const Plugin = {
                 format: input.format,
                 output,
               }
-            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to fetch ${input.url}` }))),
+            }).pipe(
+              Effect.mapError(() => new ToolFailure({ message: `Unable to fetch ${input.url}` })),
+              Effect.map((structured) => ({
+                structured,
+                content: [{ type: "text", text: structured.output }],
+              })),
+            ),
         }),
       })
       .pipe(Effect.orDie)

packages/core/src/tool/websearch.ts

@@ -200,7 +200,6 @@ export const Plugin = {
           description,
           input: Input,
           output: Output,
-          toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
           execute: (input, context) => {
             const provider = selectProvider(context.sessionID, config, config.provider)
             return Effect.gen(function* () {
@@ -243,7 +242,13 @@ export const Plugin = {
                 provider,
                 text: text ?? NO_RESULTS,
               }
-            }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to search the web for ${input.query}` })))
+            }).pipe(
+              Effect.mapError(() => new ToolFailure({ message: `Unable to search the web for ${input.query}` })),
+              Effect.map((structured) => ({
+                structured,
+                content: [{ type: "text", text: structured.text }],
+              })),
+            )
           },
         }),
       })

packages/core/src/tool/write.ts

@@ -57,7 +57,6 @@ export const Plugin = {
               "Write content to one file. Relative paths resolve within the active Location. Absolute paths inside the Location are accepted. Explicit external absolute paths require external_directory approval before edit approval.",
             input: Input,
             output: Output,
-            toModelOutput: ({ output }) => [{ type: "text", text: toModelOutput(output) }],
             execute: (input, context) =>
               Effect.gen(function* () {
                 const source = {
@@ -83,7 +82,13 @@ export const Plugin = {
                   source,
                 })
                 return yield* files.writeTextPreservingBom({ target, content: input.content })
-              }).pipe(Effect.mapError(() => new ToolFailure({ message: `Unable to write ${input.path}` }))),
+              }).pipe(
+                Effect.mapError(() => new ToolFailure({ message: `Unable to write ${input.path}` })),
+                Effect.map((structured) => ({
+                  structured,
+                  content: [{ type: "text", text: toModelOutput(structured) }],
+                })),
+              ),
           }),
           "edit",
         ),

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

@@ -1,19 +1,15 @@
-import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Effect, Schema } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Config } from "@opencode-ai/core/config"
 import { ConfigExternalPlugin } from "@opencode-ai/core/config/plugin/external"
-import { EventV2 } from "@opencode-ai/core/event"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Location } from "@opencode-ai/core/location"
 import { Npm } from "@opencode-ai/core/npm"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "../plugin/fixture"
 
@@ -244,49 +240,6 @@ describe("ConfigExternalPlugin", () => {
       })
     }),
   )
-
-  it.live("reloads changed plugin source from the same entrypoint", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const plugins = yield* PluginV2.Service
-          const agents = yield* AgentV2.Service
-          const events = yield* EventV2.Service
-          const fsUtil = yield* FSUtil.Service
-          const location = yield* Location.Service
-          const npm = yield* Npm.Service
-          const host = yield* PluginHost.make(plugins)
-          const plugin = path.join(tmp.path, "plugin.ts")
-          const config = Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  info: decode({ plugins: [plugin] }),
-                }),
-              ]),
-          })
-
-          yield* Effect.promise(() => fs.writeFile(plugin, pluginSource("First source")))
-          yield* ConfigExternalPlugin.Plugin.effect(host).pipe(
-            Effect.provideService(PluginV2.Service, plugins),
-            Effect.provideService(FSUtil.Service, fsUtil),
-            Effect.provideService(Location.Service, location),
-            Effect.provideService(Npm.Service, npm),
-            Effect.provideService(Config.Service, config),
-          )
-          expect((yield* waitForAgent(agents, "hot-reload"))?.description).toBe("First source")
-
-          yield* Effect.promise(() => fs.writeFile(plugin, pluginSource("Second source")))
-          yield* events.publish(ConfigSchema.Event.Updated, {})
-          expect(yield* waitForAgentDescription(agents, "hot-reload", "Second source")).toBe(true)
-        }),
-      ),
-    ),
-  )
 })
 
 const waitForAgent = Effect.fnUntraced(function* (agents: AgentV2.Interface, id: string) {
@@ -297,29 +250,3 @@ const waitForAgent = Effect.fnUntraced(function* (agents: AgentV2.Interface, id:
   }
   return yield* Effect.die(`Timed out waiting for agent ${id}`)
 })
-
-const waitForAgentDescription = Effect.fnUntraced(function* (
-  agents: AgentV2.Interface,
-  id: string,
-  description: string,
-) {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    if ((yield* agents.get(AgentV2.ID.make(id)))?.description === description) return true
-    yield* Effect.sleep("10 millis")
-  }
-  return false
-})
-
-function pluginSource(description: string) {
-  return `export default {
-  id: "source-hot-reload",
-  setup: async (ctx) => {
-    await ctx.agent.transform((agents) => {
-      agents.update("hot-reload", (agent) => {
-        agent.description = ${JSON.stringify(description)}
-        agent.mode = "subagent"
-      })
-    })
-  },
-}`
-}

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 every config-backed domain", () =>
+  it.live("reloads config-backed domains without reloading external plugins", () =>
     Effect.gen(function* () {
       const agents = yield* AgentV2.Service
       const catalog = yield* Catalog.Service
@@ -69,8 +69,7 @@ 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* agents.get(AgentV2.ID.make("configured")))?.description === "Second plugin"
+            (yield* catalog.provider.get(ProviderV2.ID.make("second"))) !== undefined
           )
         }),
       )
@@ -81,10 +80,7 @@ describe("config plugin reloads", () => {
       expect(
         (yield* skills.sources()).some((source) => source.type === "directory" && source.path === "/skills/second"),
       ).toBe(true)
-
-      entries = [config("second")]
-      yield* events.publish(ConfigSchema.Event.Updated, {})
-      yield* waitUntil(agents.get(AgentV2.ID.make("configured")).pipe(Effect.map((agent) => agent === undefined)))
+      expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("First plugin")
     }).pipe(Effect.provideService(Global.Service, Global.Service.of(Global.make()))),
   )
 })

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

@@ -1,5 +1,7 @@
 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)
@@ -8,3 +10,30 @@ 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, Stream } from "effect"
+import { Deferred, Duration, Effect, Fiber, Layer, Option, Schedule, 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,12 +149,14 @@ describeWatcher("LocationWatcher", () => {
         const update = yield* watcher
           .subscribe({ path: target, type: "file" })
           .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
-        yield* Effect.yieldNow
-
         yield* fs.writeFileString(sibling, "sibling")
-        yield* fs.writeFileString(target, "target")
+        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)))
 
-        expect((yield* Fiber.join(update)).valueOrUndefined?.path).toBe(target)
+        expect(event.valueOrUndefined?.path).toBe(target)
       }).pipe(Effect.provide(AppNodeBuilder.build(Watcher.node))),
     ),
   )
@@ -197,6 +199,24 @@ 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/plugin.test.ts

@@ -108,7 +108,7 @@ describe("PluginV2", () => {
                 description: "Plugin tool",
                 input: Schema.Struct({}),
                 output: Schema.Struct({ ok: Schema.Boolean }),
-                execute: () => Effect.succeed({ ok: true }),
+                execute: () => Effect.succeed({ structured: { ok: true }, content: [] }),
               }),
             })
             .pipe(Effect.orDie),
@@ -146,7 +146,8 @@ describe("PluginV2", () => {
                   description: "Echo",
                   input: Schema.Struct({ text: Schema.String }),
                   output: Schema.Struct({ text: Schema.String }),
-                  execute: ({ text }) => Effect.sync(() => executed.push({ text })).pipe(Effect.as({ text })),
+                  execute: ({ text }) =>
+                    Effect.sync(() => executed.push({ text })).pipe(Effect.as({ structured: { text }, content: [] })),
                 }),
               })
               .pipe(Effect.orDie)

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 })
-      expect(
-        Array.from(yield* logEvents(session, created.id, true).pipe(Stream.take(1), Stream.runCollect)),
-      ).toMatchObject([{ type: "session.model.selected", data: { 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 })
     }),
   )
 

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

@@ -34,6 +34,7 @@ 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 = (
@@ -238,6 +239,7 @@ describe("SessionProjector", () => {
           directory: "/project",
           title: "test",
           version: "test",
+          model: previousModel,
         })
         .run()
         .pipe(Effect.orDie)
@@ -337,6 +339,7 @@ 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/session-runner-tool-registry.test.ts

@@ -46,8 +46,7 @@ const make = (permission?: string) => {
     description: "Echo text",
     input: Schema.Struct({ text: Schema.String }),
     output: Schema.Struct({ text: Schema.String }),
-    execute: ({ text }) => Effect.succeed({ text }),
-    toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
+    execute: ({ text }) => Effect.succeed({ structured: { text }, content: [{ type: "text" as const, text }] }),
   })
   return permission ? Tool.withPermission(tool, permission) : tool
 }
@@ -244,7 +243,8 @@ describe("ToolRegistry", () => {
           description: "Context",
           input: Schema.Struct({}),
           output: Schema.Struct({ ok: Schema.Boolean }),
-          execute: (_, context) => Effect.sync(() => contexts.push(context)).pipe(Effect.as({ ok: true })),
+          execute: (_, context) =>
+            Effect.sync(() => contexts.push(context)).pipe(Effect.as({ structured: { ok: true }, content: [] })),
         }),
       })
       yield* executeTool(service, {
@@ -276,7 +276,7 @@ describe("ToolRegistry", () => {
     }),
   )
 
-  it.effect("enforces transformed codecs at execution and projection boundaries", () =>
+  it.effect("validates structured output while preserving executor-provided model content", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const executed: string[] = []
@@ -291,18 +291,23 @@ describe("ToolRegistry", () => {
           description: "Transform values",
           input: Schema.Struct({ value: Transformed }),
           output: Schema.Struct({ value: Transformed }),
-          execute: ({ value }) => Effect.sync(() => executed.push(value)).pipe(Effect.as({ value })),
-          toModelOutput: ({ output }) => [{ type: "text", text: String(output.value) }],
+          execute: ({ value }) =>
+            Effect.sync(() => executed.push(value)).pipe(
+              Effect.as({ structured: { value }, content: [{ type: "text" as const, text: value }] }),
+            ),
         }),
       })
 
       expect(
-        yield* executeTool(service, {
+        yield* settleTool(service, {
           sessionID,
           ...identity,
           call: { type: "tool-call", id: "transformed", name: "transformed", input: { value: true } },
         }),
-      ).toEqual({ type: "text", value: "true" })
+      ).toEqual({
+        result: { type: "text", value: "yes" },
+        output: { structured: { value: true }, content: [{ type: "text", text: "yes" }] },
+      })
       expect(executed).toEqual(["yes"])
       expect(
         yield* executeTool(service, {
@@ -329,7 +334,7 @@ describe("ToolRegistry", () => {
               }),
             ),
           }),
-          execute: () => Effect.succeed({ value: "invalid" }),
+          execute: () => Effect.succeed({ structured: { value: "invalid" }, content: [] }),
         }),
       })
       expect(
@@ -411,8 +416,10 @@ describe("ToolRegistry", () => {
             input: Schema.Struct({ text: Schema.String }),
             output: Schema.Struct({ text: Schema.String }),
             execute: ({ text }) =>
-              Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)), Effect.as({ text })),
-            toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
+              Deferred.succeed(started, undefined).pipe(
+                Effect.andThen(Deferred.await(release)),
+                Effect.as({ structured: { text }, content: [{ type: "text" as const, text }] }),
+              ),
           }),
         })
         .pipe(Scope.provide(scope))

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

@@ -135,7 +135,6 @@ const echo = Layer.effectDiscard(
         description: "Echo text",
         input: Schema.Struct({ text: Schema.String }),
         output: Schema.Struct({ text: Schema.String }),
-        toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
         execute: ({ text }, context) =>
           Effect.gen(function* () {
             authorizations.push(context)
@@ -146,7 +145,7 @@ const echo = Layer.effectDiscard(
               yield* Deferred.succeed(toolExecutionsStarted, undefined)
             }
             if (toolExecutionGate) yield* Deferred.await(toolExecutionGate)
-            return { text }
+            return { structured: { text }, content: [{ type: "text" as const, text }] }
           }).pipe(Effect.ensuring(Effect.sync(() => activeToolExecutions--))),
       }),
       defect: Tool.make({
@@ -161,7 +160,7 @@ const echo = Layer.effectDiscard(
         description: "Produce output that cannot be persisted",
         input: Schema.Struct({}),
         output: Schema.Any,
-        execute: () => Effect.succeed({ big: 1n }),
+        execute: () => Effect.succeed({ structured: { big: 1n }, content: [] }),
       }),
     }),
   ),
@@ -608,7 +607,7 @@ describe("SessionRunnerLLM", () => {
           execute: ({ query }, context) =>
             Effect.sync(() => {
               contexts.push(context)
-              return { answer: query.toUpperCase() }
+              return { structured: { answer: query.toUpperCase() }, content: [] }
             }),
         }),
       })
@@ -2834,7 +2833,9 @@ describe("SessionRunnerLLM", () => {
           input: Schema.Struct({}),
           output: Schema.Struct({}),
           execute: (_, context) =>
-            questions.ask({ sessionID: context.sessionID, questions: [] }).pipe(Effect.as({}), Effect.orDie),
+            questions
+              .ask({ sessionID: context.sessionID, questions: [] })
+              .pipe(Effect.as({ structured: {}, content: [] }), Effect.orDie),
         }),
       })
       yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Ask then stop" }), resume: false })

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

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

packages/plugin/src/v2/effect/README.md

@@ -31,6 +31,36 @@ Configuration supplied for the plugin is available as `ctx.options`.
 
 Registrations are owned by the plugin scope. Closing the scope removes them automatically; a registration may also be removed early through `dispose`.
 
+## Tools
+
+Plugins register named tools through `ctx.tool`. The executor returns validated structured output and model-facing content together.
+
+```ts
+import { define, Tool } from "@opencode-ai/plugin/v2/effect"
+import { Effect, Schema } from "effect"
+
+export const Plugin = define({
+  id: "greeting",
+  effect: (ctx) =>
+    ctx.tool
+      .register({
+        greet: Tool.make({
+          description: "Greet someone",
+          input: Schema.Struct({ name: Schema.String }),
+          output: Schema.Struct({ message: Schema.String }),
+          execute: ({ name }) => {
+            const message = `Hello ${name}`
+            return Effect.succeed({
+              structured: { message },
+              content: [{ type: "text", text: message }],
+            })
+          },
+        }),
+      })
+      .pipe(Effect.orDie),
+})
+```
+
 ## Transform Hooks
 
 Transform hooks contribute to stateful domains:

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

@@ -38,32 +38,19 @@ export type Content =
   | { readonly type: "text"; readonly text: string }
   | { readonly type: "file"; readonly data: string; readonly mime: string; readonly name?: string }
 
-type Config<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
-> = {
+export type Result<Structured = unknown> = {
+  readonly structured: Structured
+  readonly content: ReadonlyArray<Content>
+}
+
+type Config<Input extends SchemaType<any>, OutputSchema extends SchemaType<any>> = {
   readonly description: string
   readonly input: Input
-  readonly output: Output
-  readonly structured?: Structured
-  readonly toStructuredOutput?: (input: {
-    readonly input: Schema.Schema.Type<Input>
-    readonly output: Output["Encoded"]
-  }) => Schema.Schema.Type<Structured>
+  readonly output: OutputSchema
   readonly execute: (
     input: Schema.Schema.Type<Input>,
     context: Context,
-  ) => Effect.Effect<Schema.Schema.Type<Output>, ToolFailure>
-  readonly toModelOutput?: (input: {
-    readonly input: Schema.Schema.Type<Input>
-    readonly output: Output["Encoded"]
-  }) => ReadonlyArray<Content>
-}
-
-export type DynamicOutput = {
-  readonly structured: unknown
-  readonly content: ReadonlyArray<Content>
+  ) => Effect.Effect<Result<Schema.Schema.Type<OutputSchema>>, ToolFailure>
 }
 
 /**
@@ -75,7 +62,7 @@ type DynamicConfig = {
   readonly description: string
   readonly jsonSchema: JsonSchema.JsonSchema
   readonly outputSchema?: JsonSchema.JsonSchema
-  readonly execute: (input: unknown, context: Context) => Effect.Effect<DynamicOutput, ToolFailure>
+  readonly execute: (input: unknown, context: Context) => Effect.Effect<Result, ToolFailure>
 }
 
 type Runtime = {
@@ -86,23 +73,19 @@ type Runtime = {
 
 const runtimes = new WeakMap<AnyTool, Runtime>()
 
-export function make<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
->(config: Config<Input, Output, Structured>): Definition<Input, Structured>
+export function make<Input extends SchemaType<any>, OutputSchema extends SchemaType<any>>(
+  config: Config<Input, OutputSchema>,
+): Definition<Input, OutputSchema>
 export function make(config: DynamicConfig): AnyTool
-export function make(config: Config<any, any, any> | DynamicConfig): AnyTool {
+export function make(config: Config<any, any> | DynamicConfig): AnyTool {
   if ("jsonSchema" in config) return makeDynamic(config)
   return makeTyped(config)
 }
 
-function makeTyped<
-  Input extends SchemaType<any>,
-  Output extends SchemaType<any>,
-  Structured extends SchemaType<any> = Output,
->(config: Config<Input, Output, Structured>): Definition<Input, Structured> {
-  const tool = Object.freeze({}) as Definition<Input, Structured>
+function makeTyped<Input extends SchemaType<any>, OutputSchema extends SchemaType<any>>(
+  config: Config<Input, OutputSchema>,
+): Definition<Input, OutputSchema> {
+  const tool = Object.freeze({}) as Definition<Input, OutputSchema>
   const definitions = new Map<string, ToolDefinition>()
   runtimes.set(tool, {
     definition: (name) => {
@@ -112,7 +95,7 @@ function makeTyped<
         name,
         description: config.description,
         inputSchema: toJsonSchema(config.input),
-        outputSchema: toJsonSchema(config.structured ?? config.output),
+        outputSchema: toJsonSchema(config.output),
       })
       definitions.set(name, definition)
       return definition
@@ -123,14 +106,8 @@ function makeTyped<
         Effect.flatMap((input) =>
           config.execute(input, context).pipe(
             Effect.flatMap((output) =>
-              Schema.encodeEffect(config.output)(output).pipe(
-                Effect.flatMap((output) => {
-                  if (!config.structured || !config.toStructuredOutput)
-                    return Effect.succeed({ output, structured: output })
-                  return Schema.encodeEffect(config.structured)(config.toStructuredOutput({ input, output })).pipe(
-                    Effect.map((structured) => ({ output, structured })),
-                  )
-                }),
+              Schema.encodeEffect(config.output)(output.structured).pipe(
+                Effect.map((structured) => ToolOutput.make(structured, output.content.map(toModelContent))),
                 Effect.mapError(
                   (error) =>
                     new ToolFailure({
@@ -139,12 +116,6 @@ function makeTyped<
                 ),
               ),
             ),
-            Effect.map(({ output, structured }) => ({
-              structured,
-              content:
-                config.toModelOutput?.({ input, output }).map(toModelContent) ??
-                (typeof output === "string" ? [{ type: "text" as const, text: output }] : []),
-            })),
           ),
         ),
       ),
@@ -171,7 +142,7 @@ function makeDynamic(config: DynamicConfig): AnyTool {
     settle: (call, context) =>
       config
         .execute(call.input, context)
-        .pipe(Effect.map((output) => ({ structured: output.structured, content: output.content.map(toModelContent) }))),
+        .pipe(Effect.map((output) => ToolOutput.make(output.structured, output.content.map(toModelContent)))),
   })
   return tool
 }

packages/schema/src/session-message.ts

@@ -44,6 +44,7 @@ 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-next/test/embedded.test.ts

@@ -47,7 +47,7 @@ it.live(
                   description: "Embedded test tool",
                   input: Schema.Struct({}),
                   output: Schema.Struct({ ok: Schema.Boolean }),
-                  execute: () => Effect.succeed({ ok: true }),
+                  execute: () => Effect.succeed({ structured: { ok: true }, content: [] }),
                 }),
               })
               .pipe(Effect.orDie),

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

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

packages/tui/src/context/data.tsx

@@ -20,7 +20,7 @@ import type {
   SkillV2Info,
   V2Event,
 } from "@opencode-ai/sdk/v2"
-import { createStore, produce } from "solid-js/store"
+import { createStore, produce, reconcile } from "solid-js/store"
 import { createSimpleContext } from "./helper"
 import { useSDK } from "./sdk"
 import { createSignal, onCleanup } from "solid-js"
@@ -100,8 +100,15 @@ 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(
@@ -235,6 +242,7 @@ 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),
@@ -243,22 +251,35 @@ 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": {
-          setStore("session", "status", event.data.sessionID, "running")
+          setSessionStatus(event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             const position = index.get(event.data.inputID)
-            const existing = position === undefined ? undefined : draft[position]
-            if (existing?.type === "user") {
+            if (position === undefined) return
+            const existing = draft[position]
+            if (existing?.type === "user" && existing.metadata?.queued === true) {
               existing.time.created = event.created
-              if (existing.metadata?.queued === true) {
-                delete existing.metadata.queued
-                if (Object.keys(existing.metadata).length === 0) existing.metadata = undefined
-              }
+              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))
               return
             }
           })
@@ -300,7 +321,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.shell.started":
-          setStore("session", "status", event.data.sessionID, "running")
+          setSessionStatus(event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
@@ -311,7 +332,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.shell.ended":
-          setStore("session", "status", event.data.sessionID, "idle")
+          setSessionStatus(event.data.sessionID, "idle")
           message.update(event.data.sessionID, (draft) => {
             const match = message.shell(draft, event.data.shell.id)
             if (!match) return
@@ -321,7 +342,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.step.started":
-          setStore("session", "status", event.data.sessionID, "running")
+          setSessionStatus(event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             if (index.has(event.data.assistantMessageID)) return
             const currentAssistant = message.activeAssistant(draft)
@@ -338,7 +359,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           })
           break
         case "session.step.ended":
-          setStore("session", "status", event.data.sessionID, "running")
+          setSessionStatus(event.data.sessionID, "running")
           message.update(event.data.sessionID, (draft, index) => {
             const currentAssistant = message.assistant(draft, index, event.data.assistantMessageID)
             if (!currentAssistant) return
@@ -518,10 +539,10 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           break
         case "session.retried":
         case "session.compaction.started":
-          setStore("session", "status", event.data.sessionID, "running")
+          setSessionStatus(event.data.sessionID, "running")
           break
         case "session.execution.settled":
-          setStore("session", "status", event.data.sessionID, "idle")
+          setSessionStatus(event.data.sessionID, "idle")
           break
         case "session.revert.staged":
           if (store.session.info[event.data.sessionID])
@@ -858,15 +879,6 @@ 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(),
@@ -888,9 +900,30 @@ 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

@@ -1231,7 +1231,8 @@ 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())
+    if (props.message.type === "model-switched")
+      return switchLabel(props.message.model, ctx.models(), props.message.previous)
     return ""
   }
   return <text fg={theme.textMuted}>{text()}</text>
@@ -2079,14 +2080,16 @@ function Shell(props: ToolProps) {
     return request?.source?.type === "tool" && request.source.callID === props.part.id
   })
   const color = createMemo(() => (permission() ? theme.warning : theme.text))
-  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 shellID = createMemo(() => stringValue(props.metadata.shellID))
+  const backgroundRunning = createMemo(() => {
+    const id = shellID()
+    return Boolean(id && data.shell.get(id))
   })
+  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() : "")
   })
@@ -2129,6 +2132,11 @@ 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,23 +28,24 @@ export function createSessionRows(sessionID: Accessor<string>) {
   function reduce() {
     const messages = data.session.message.list(sessionID())
     const boundary = revertBoundary()
-    return reduceSessionRows(boundary ? messages.filter((message) => message.id < boundary) : messages)
+    const rows = reduceSessionRows(boundary ? messages.filter((message) => message.id < boundary) : messages)
+    partitionPending(rows, pendingPermissions())
+    return rows
   }
 
-  createEffect(() => {
-    const pending = new Set(
+  function pendingPermissions() {
+    return new Set(
       (data.session.permission.list(sessionID()) ?? []).flatMap((request) =>
         request.source?.type === "tool" ? [request.source.callID] : [],
       ),
     )
+  }
+
+  createEffect(() => {
+    const pending = pendingPermissions()
     setRows(
       produce((draft) => {
-        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))
-        })
+        partitionPending(draft, pending)
       }),
     )
   })
@@ -69,6 +70,20 @@ 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) => {
@@ -134,7 +149,6 @@ 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())
@@ -225,6 +239,15 @@ 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,11 +34,12 @@ 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,6 +8,7 @@ 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"
 
@@ -109,12 +110,20 @@ test("refreshes resources into reactive getters", async () => {
 
 test("reconnects the event stream and bootstraps fresh data", async () => {
   const events = createEventStream()
-  const requests = { event: 0, model: 0 }
+  const requests = { active: 0, event: 0, model: 0 }
+  let resolveActive!: (response: Response) => void
   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({
@@ -157,6 +166,7 @@ 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)
 
@@ -165,7 +175,25 @@ 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)
@@ -175,6 +203,87 @@ 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
@@ -767,7 +876,18 @@ 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(undefined, events)
+  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)
   let sync!: ReturnType<typeof useData>
   let ready!: () => void
   const mounted = new Promise<void>((resolve) => {
@@ -808,7 +928,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" },
+        model: { id: "model-1", providerID: "provider-1", variant: "high" },
       },
     })
     emitEvent(events, {
@@ -895,6 +1015,11 @@ 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,4 +34,16 @@ 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": ["node_modules/**", "dist/**", ".git/**"]
+    "ignore": ["**/generated/**"]
   }
 }
 ```
 
-Patterns follow glob syntax. Use this to exclude noisy directories from file watching.
+Patterns follow glob syntax. Common dependency, VCS, build, and cache directories are ignored automatically at any depth.
 
 ---
 

specs/v2/tools.md

@@ -7,30 +7,30 @@ V2 has one opaque type for locally executable tools:
 ```ts
 type Definition<Input, Output>
 type AnyTool = Definition<any, any>
+type Result<Structured = unknown> = {
+  readonly structured: Structured
+  readonly content: ReadonlyArray<Tool.Content>
+}
 
 const make: <
   Input extends Schema.Codec<any, any, never, never>,
-  Output extends Schema.Codec<any, any, never, never>,
+  OutputSchema extends Schema.Codec<any, any, never, never>,
 >(config: {
   readonly description: string
   readonly input: Input
-  readonly output: Output
+  readonly output: OutputSchema
   readonly execute: (
     input: Schema.Type<Input>,
     context: Tool.Context,
-  ) => Effect.Effect<Schema.Type<Output>, ToolFailure>
-  readonly toModelOutput?: (input: {
-    readonly input: Schema.Type<Input>
-    readonly output: Output["Encoded"]
-  }) => ReadonlyArray<Tool.Content>
-}) => Definition<Input, Output>
+  ) => Effect.Effect<Result<Schema.Type<OutputSchema>>, ToolFailure>
+}) => Definition<Input, OutputSchema>
 ```
 
 Application tools, built-ins, and statically authored plugin tools use this same constructor and execution contract.
 
 `Tool.Definition` is opaque and has exactly one executor. Its schemas and executor are not public fields. The Tool module privately derives model definitions and interprets invocations for the registry; callers normally rely on `Tool.make` inference rather than naming the carrier type.
 
-Input and output codecs are self-contained. Schema conversion cannot require services. Tool dependencies are acquired during construction and captured by `execute`.
+Input and structured-output codecs are self-contained. Schema conversion cannot require services. Tool dependencies are acquired during construction and captured by `execute`.
 
 ## Invocation Context
 
@@ -122,7 +122,11 @@ yield *
             metadata: { root: root.resource },
           })
 
-          return yield* filesystem.grep(input, root)
+          const structured = yield* filesystem.grep(input, root)
+          return {
+            structured,
+            content: [{ type: "text", text: formatMatches(structured) }],
+          }
         }).pipe(/* translate expected typed errors to ToolFailure */),
     }),
   })
@@ -139,22 +143,20 @@ The Location-scoped registry owns effective lookup and settlement. For each loca
 1. Resolves one effective named registration.
 2. Decodes provider input with the input codec.
 3. Invokes the tool with the runner-supplied context.
-4. Encodes the returned output with the output codec.
-5. Projects encoded output into model-facing content.
+4. Encodes the returned `structured` value with the output codec.
+5. Preserves the executor-provided model-facing `content`.
 6. Bounds the complete model-facing output.
 7. Returns the settlement and managed-output references to the runner, which persists them durably.
 
-Invalid input never invokes the tool. Invalid output never produces a successful settlement.
-
-`toModelOutput` is pure and total. When omitted, the encoded output remains structured output; an encoded string is also projected as text. Projection does not receive invocation identity because presentation depends only on validated input and output.
+Invalid input never invokes the tool. Invalid structured output never produces a successful settlement.
 
 Step materialization captures the effective registration identity for each advertised name without retaining its handler. Settlement rejects the call as stale if that registration was removed or replaced, including when closing an overlay reveals the previously effective registration. The current handler is captured only after this check; removing or replacing its registration afterward does not affect the running invocation.
 
 ## Output Bounding
 
-Tools return complete validated domain output. They do not truncate model-facing output or manage retention files.
+Tools return complete structured output and model-facing content together. Settlement validates the structured value; tools do not truncate model-facing output or manage retention files.
 
-After projection, one generic settlement boundary bounds the channel actually sent to the provider. When content exists, only its textual parts are measured; structured metadata is retained unchanged without being double-counted, and native media remains unchanged under producer-owned limits. When content is empty, the structured output is measured. Oversized provider-facing text or structured output is retained in managed storage and replaced with a bounded text preview while structured metadata and media are preserved; if complete retention fails, settlement fails operationally rather than publishing lossy success. Managed paths never appear in `Tool.make`, tool output schemas, or projection callbacks solely for retention bookkeeping.
+One generic settlement boundary bounds the channel actually sent to the provider. When content exists, only its textual parts are measured; structured metadata is retained unchanged without being double-counted, and native media remains unchanged under producer-owned limits. When content is empty, the structured output is measured. Oversized provider-facing text or structured output is retained in managed storage and replaced with a bounded text preview while structured metadata and media are preserved; if complete retention fails, settlement fails operationally rather than publishing lossy success. Managed paths never appear in `Tool.make`, tool output schemas, or executors solely for retention bookkeeping.
 
 Model-output bounding is not producer memory management. Processes and streaming sources may need separate capture or spooling limits before a tool result exists. Those limits must be modeled at the producer boundary and must not masquerade as model-output truncation. A producer cannot claim a complete retained output after it has already discarded bytes.
 
@@ -172,7 +174,7 @@ Leaf tools translate only errors they deliberately classify as recoverable. Broa
 ## Laws
 
 - **Single executor:** `Tool.make(config)` can invoke only `config.execute`.
-- **Codec boundary:** execution observes decoded input; projection observes encoded output.
+- **Codec boundary:** execution observes decoded input and returns decoded structured output; settlement validates and encodes that structured output.
 - **Durable identity:** invocation-owned records use the exact Session, agent, assistant message, and call IDs supplied by the runner.
 - **Scoped registration:** closing a Scope removes exactly its registration and reveals any prior active overlay.
 - **Captured execution:** registration changes cannot alter an invocation after effective lookup.