fix(server): detect OpenCode version via spawn spec

Store the originating worktree slug when questions are enqueued and use
the stored worktree client when replying/rejecting from the global
permission center. This ensures question responses are sent through the
correct worktree, matching the behavior already implemented for
permissions.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "codenomad-workspace",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "codenomad-workspace",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "license": "MIT",
       "dependencies": {
         "7zip-bin": "^5.2.0",
@@ -11985,7 +11985,7 @@
     },
     "packages/electron-app": {
       "name": "@neuralnomads/codenomad-electron-app",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "license": "MIT",
       "dependencies": {
         "@codenomad/ui": "file:../ui",
@@ -12021,7 +12021,7 @@
     },
     "packages/server": {
       "name": "@neuralnomads/codenomad",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "license": "MIT",
       "dependencies": {
         "@fastify/cors": "^8.5.0",
@@ -12062,7 +12062,7 @@
     },
     "packages/tauri-app": {
       "name": "@codenomad/tauri-app",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "license": "MIT",
       "devDependencies": {
         "@tauri-apps/cli": "^2.9.4"
@@ -12070,7 +12070,7 @@
     },
     "packages/ui": {
       "name": "@codenomad/ui",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "license": "MIT",
       "dependencies": {
         "@git-diff-view/solid": "^0.0.8",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codenomad-workspace",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "private": true,
   "description": "CodeNomad monorepo workspace",
   "license": "MIT",

packages/electron-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-electron-app",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "CodeNomad - AI coding assistant",
   "license": "MIT",
   "author": {

packages/opencode-config/package.json

@@ -4,6 +4,6 @@
   "private": true,
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "1.2.4"
+    "@opencode-ai/plugin": "1.2.6"
   }
-}
+}

packages/server/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@neuralnomads/codenomad",
-      "version": "0.11.1",
+      "version": "0.11.3",
       "dependencies": {
         "@fastify/cors": "^8.5.0",
         "@fastify/reply-from": "^9.8.0",

packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {

packages/server/src/server/http-server.ts

@@ -367,6 +367,21 @@ function registerInstanceProxyRoutes(app: FastifyInstance, deps: InstanceProxyDe
 
 const INSTANCE_PROXY_HOST = "127.0.0.1"
 
+// Special-case OpenCode directory override.
+//
+// UI clients may need to scope certain requests to an arbitrary directory that is not
+// part of the Git worktree list. Since the OpenCode SDK does not reliably support
+// injecting per-request headers, we encode an override into the *path* and strip it
+// before proxying to the instance.
+//
+// Example proxied request path:
+//   /workspaces/:id/worktrees/:slug/instance/__dir/<base64url>/session/create
+//
+// The server will decode <base64url> -> absolute directory, validate it, then set
+// x-opencode-directory accordingly and forward the request to /session/create.
+const OPENCODE_DIR_OVERRIDE_PREFIX = "__dir/"
+const OPENCODE_DIR_OVERRIDE_MAX_LEN = 4096
+
 async function proxyWorkspaceRequest(args: {
   request: FastifyRequest
   reply: FastifyReply
@@ -457,19 +472,43 @@ async function proxyWorkspaceRequest(args: {
     return
   }
 
-  const directory = await resolveWorktreeDirectory({
-    workspaceId,
-    workspacePath: workspace.path,
-    worktreeSlug,
-    logger,
-  })
-
-  if (!directory) {
-    reply.code(404).send({ error: "Worktree not found" })
+  let extracted: { overrideDirectory: string | null; forwardedSuffix: string | undefined }
+  try {
+    extracted = extractOpencodeDirectoryOverride(args.pathSuffix)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid directory override"
+    reply.code(400).send({ error: message })
     return
   }
+  let directory: string | null = null
+  let forwardedSuffix = extracted.forwardedSuffix
 
-  const normalizedSuffix = normalizeInstanceSuffix(args.pathSuffix)
+  if (extracted.overrideDirectory) {
+    try {
+      directory = validateAndNormalizeOverrideDirectory({
+        overrideDirectory: extracted.overrideDirectory,
+        workspaceRoot: workspace.path,
+      })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Invalid directory override"
+      reply.code(400).send({ error: message })
+      return
+    }
+  } else {
+    directory = await resolveWorktreeDirectory({
+      workspaceId,
+      workspacePath: workspace.path,
+      worktreeSlug,
+      logger,
+    })
+
+    if (!directory) {
+      reply.code(404).send({ error: "Worktree not found" })
+      return
+    }
+  }
+
+  const normalizedSuffix = normalizeInstanceSuffix(forwardedSuffix)
   const queryIndex = (request.raw.url ?? "").indexOf("?")
   const search = queryIndex >= 0 ? (request.raw.url ?? "").slice(queryIndex) : ""
   const targetUrl = `http://${INSTANCE_PROXY_HOST}:${port}${normalizedSuffix}${search}`
@@ -533,6 +572,89 @@ async function proxyWorkspaceRequest(args: {
   })
 }
 
+function extractOpencodeDirectoryOverride(pathSuffix: string | undefined): {
+  overrideDirectory: string | null
+  forwardedSuffix: string | undefined
+} {
+  if (!pathSuffix) {
+    return { overrideDirectory: null, forwardedSuffix: pathSuffix }
+  }
+
+  // Fastify wildcard param does not include a leading slash.
+  const trimmed = pathSuffix.replace(/^\/+/, "")
+  if (!trimmed.startsWith(OPENCODE_DIR_OVERRIDE_PREFIX)) {
+    return { overrideDirectory: null, forwardedSuffix: pathSuffix }
+  }
+
+  const rest = trimmed.slice(OPENCODE_DIR_OVERRIDE_PREFIX.length)
+  const slashIndex = rest.indexOf("/")
+  const encoded = (slashIndex >= 0 ? rest.slice(0, slashIndex) : rest).trim()
+  const remaining = slashIndex >= 0 ? rest.slice(slashIndex + 1) : ""
+
+  if (!encoded) {
+    throw new Error("Missing directory override")
+  }
+
+  if (encoded.length > OPENCODE_DIR_OVERRIDE_MAX_LEN) {
+    throw new Error("Directory override too large")
+  }
+
+  let overrideDirectory = ""
+  try {
+    overrideDirectory = decodeBase64Url(encoded)
+  } catch {
+    throw new Error("Invalid directory override")
+  }
+  const forwardedSuffix = remaining
+  return { overrideDirectory, forwardedSuffix }
+}
+
+function decodeBase64Url(input: string): string {
+  // base64url -> base64
+  const normalized = input.replace(/-/g, "+").replace(/_/g, "/")
+  const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - (normalized.length % 4))
+  const base64 = `${normalized}${padding}`
+  return Buffer.from(base64, "base64").toString("utf-8")
+}
+
+function validateAndNormalizeOverrideDirectory(params: { overrideDirectory: string; workspaceRoot: string }): string {
+  const raw = params.overrideDirectory.trim()
+  if (!raw) {
+    throw new Error("Override directory is empty")
+  }
+
+  if (!path.isAbsolute(raw)) {
+    throw new Error("Override directory must be an absolute path")
+  }
+
+  if (!fs.existsSync(raw)) {
+    throw new Error(`Override directory does not exist: ${raw}`)
+  }
+
+  const stats = fs.statSync(raw)
+  if (!stats.isDirectory()) {
+    throw new Error(`Override path is not a directory: ${raw}`)
+  }
+
+  const normalizedOverride = fs.realpathSync(raw)
+  const normalizedRoot = fs.realpathSync(params.workspaceRoot)
+
+  if (!isSubpath(normalizedOverride, normalizedRoot)) {
+    throw new Error("Override directory must be within the workspace root")
+  }
+
+  return normalizedOverride
+}
+
+function isSubpath(candidate: string, root: string): boolean {
+  const rel = path.relative(root, candidate)
+  if (rel === "") return true
+  if (rel === "..") return false
+  if (rel.startsWith(`..${path.sep}`)) return false
+  if (path.isAbsolute(rel)) return false
+  return true
+}
+
 function normalizeInstanceSuffix(pathSuffix: string | undefined) {
   if (!pathSuffix || pathSuffix === "/") {
     return "/"

packages/server/src/server/routes/settings.ts

@@ -1,7 +1,6 @@
 import { FastifyInstance } from "fastify"
 import { z } from "zod"
-import { spawnSync } from "child_process"
-import { buildSpawnSpec } from "../../workspaces/runtime"
+import { probeBinaryVersion } from "../../workspaces/runtime"
 import type { SettingsService } from "../../settings/service"
 import type { Logger } from "../../logger"
 
@@ -15,37 +14,8 @@ const ValidateBinarySchema = z.object({
 })
 
 function validateBinaryPath(binaryPath: string): { valid: boolean; version?: string; error?: string } {
-  if (!binaryPath) {
-    return { valid: false, error: "Missing binary path" }
-  }
-
-  const spec = buildSpawnSpec(binaryPath, ["--version"])
-  try {
-    const result = spawnSync(spec.command, spec.args, {
-      encoding: "utf8",
-      windowsVerbatimArguments: Boolean((spec.options as { windowsVerbatimArguments?: boolean }).windowsVerbatimArguments),
-    })
-
-    if (result.error) {
-      return { valid: false, error: result.error.message }
-    }
-    if (result.status !== 0) {
-      const stderr = result.stderr?.trim()
-      const stdout = result.stdout?.trim()
-      const combined = stderr || stdout
-      const error = combined ? `Exited with code ${result.status}: ${combined}` : `Exited with code ${result.status}`
-      return { valid: false, error }
-    }
-
-    const stdout = (result.stdout ?? "").trim()
-    const firstLine = stdout.split(/\r?\n/).find((line) => line.trim().length > 0)
-    const normalized = firstLine?.trim()
-    const versionMatch = normalized?.match(/([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/)
-    const version = versionMatch?.[1]
-    return { valid: true, version }
-  } catch (error) {
-    return { valid: false, error: error instanceof Error ? error.message : String(error) }
-  }
+  const result = probeBinaryVersion(binaryPath)
+  return { valid: result.valid, version: result.version, error: result.error }
 }
 
 export function registerSettingsRoutes(app: FastifyInstance, deps: RouteDeps) {

packages/server/src/workspaces/manager.ts

@@ -8,7 +8,7 @@ import { FileSystemBrowser } from "../filesystem/browser"
 import { searchWorkspaceFiles, WorkspaceFileSearchOptions } from "../filesystem/search"
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache"
 import { WorkspaceDescriptor, WorkspaceFileResponse, FileSystemEntry } from "../api-types"
-import { WorkspaceRuntime, ProcessExitInfo } from "./runtime"
+import { WorkspaceRuntime, ProcessExitInfo, probeBinaryVersion } from "./runtime"
 import { Logger } from "../logger"
 import { getOpencodeConfigDir } from "../opencode-config.js"
 import {
@@ -283,28 +283,22 @@ export class WorkspaceManager {
       return undefined
     }
 
-    try {
-      const result = spawnSync(resolvedPath, ["--version"], { encoding: "utf8" })
-      if (result.status === 0 && result.stdout) {
-        const line = result.stdout.split(/\r?\n/).find((entry) => entry.trim().length > 0)
-        if (line) {
-          const normalized = line.trim()
-          const versionMatch = normalized.match(/([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/)
-          if (versionMatch) {
-            const version = versionMatch[1]
-            this.options.logger.debug({ binary: resolvedPath, version }, "Detected binary version")
-            return version
-          }
-          this.options.logger.debug({ binary: resolvedPath, reported: normalized }, "Binary reported version string")
-          return normalized
-        }
-      } else if (result.error) {
-        this.options.logger.warn({ binary: resolvedPath, err: result.error }, "Failed to read binary version")
+    const result = probeBinaryVersion(resolvedPath)
+    if (result.valid) {
+      if (result.version) {
+        this.options.logger.debug({ binary: resolvedPath, version: result.version }, "Detected binary version")
+        return result.version
       }
-    } catch (error) {
-      this.options.logger.warn({ binary: resolvedPath, err: error }, "Failed to detect binary version")
+      if (result.reported) {
+        this.options.logger.debug({ binary: resolvedPath, reported: result.reported }, "Binary reported version string")
+        return result.reported
+      }
+      return undefined
     }
 
+    if (result.error) {
+      this.options.logger.warn({ binary: resolvedPath, err: result.error }, "Failed to detect binary version")
+    }
     return undefined
   }
 

packages/server/src/workspaces/runtime.ts

@@ -8,6 +8,8 @@ import { Logger } from "../logger"
 export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"])
 export const WINDOWS_POWERSHELL_EXTENSIONS = new Set([".ps1"])
 
+const VERSION_REGEX = /([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/
+
 export function buildSpawnSpec(binaryPath: string, args: string[]) {
   if (process.platform !== "win32") {
     return { command: binaryPath, args, options: {} as const }
@@ -40,6 +42,61 @@ export function buildSpawnSpec(binaryPath: string, args: string[]) {
   return { command: binaryPath, args, options: {} as const }
 }
 
+export function probeBinaryVersion(binaryPath: string): {
+  valid: boolean
+  version?: string
+  reported?: string
+  error?: string
+} {
+  if (!binaryPath) {
+    return { valid: false, error: "Missing binary path" }
+  }
+
+  const spec = buildSpawnSpec(binaryPath, ["--version"])
+
+  try {
+    const result = spawnSync(spec.command, spec.args, {
+      encoding: "utf8",
+      windowsVerbatimArguments: Boolean(
+        (spec.options as { windowsVerbatimArguments?: boolean }).windowsVerbatimArguments,
+      ),
+    })
+
+    if (result.error) {
+      return { valid: false, error: result.error.message }
+    }
+
+    if (result.status !== 0) {
+      const stderr = result.stderr?.trim()
+      const stdout = result.stdout?.trim()
+      const combined = stderr || stdout
+      const error = combined ? `Exited with code ${result.status}: ${combined}` : `Exited with code ${result.status}`
+      return { valid: false, error }
+    }
+
+    const stdoutLines = String(result.stdout ?? "")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+    const stderrLines = String(result.stderr ?? "")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+
+    // Prefer stdout; fall back to stderr (some tools report version there).
+    const reported = stdoutLines[0] ?? stderrLines[0]
+    if (!reported) {
+      return { valid: true }
+    }
+
+    const versionMatch = reported.match(VERSION_REGEX)
+    const version = versionMatch?.[1]
+    return { valid: true, version, reported }
+  } catch (error) {
+    return { valid: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
 const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i
 
 function redactEnvironment(env: Record<string, string | undefined>): Record<string, string | undefined> {

packages/tauri-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codenomad/tauri-app",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "private": true,
   "license": "MIT",
   "scripts": {

packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codenomad/ui",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "private": true,
   "license": "MIT",
   "type": "module",

packages/ui/src/components/agent-selector.tsx

@@ -31,10 +31,10 @@ export default function AgentSelector(props: AgentSelectorProps) {
   const availableAgents = createMemo(() => {
     const allAgents = instanceAgents()
     if (isChildSession()) {
-      return allAgents
+      return allAgents.filter((agent) => !agent.hidden)
     }
 
-    const filtered = allAgents.filter((agent) => agent.mode !== "subagent")
+    const filtered = allAgents.filter((agent) => !agent.hidden && agent.mode !== "subagent")
 
     const currentAgent = allAgents.find((a) => a.name === props.currentAgent)
     if (currentAgent && !filtered.find((a) => a.name === props.currentAgent)) {
@@ -103,10 +103,10 @@ export default function AgentSelector(props: AgentSelectorProps) {
         >
           <div class="flex-1 min-w-0">
             <Select.Value<Agent>>
-              {(state) => (
+              {() => (
                 <div class="selector-trigger-label selector-trigger-label--stacked">
                   <span class="selector-trigger-primary selector-trigger-primary--align-left">
-                    {t("agentSelector.trigger.primary", { agent: state.selectedOption()?.name ?? t("agentSelector.none") })}
+                    {t("agentSelector.trigger.primary", { agent: props.currentAgent || t("agentSelector.none") })}
                   </span>
                 </div>
               )}

packages/ui/src/components/alert-dialog.tsx

@@ -115,28 +115,36 @@ const AlertDialog: Component = () => {
           >
             <Dialog.Portal>
               <Dialog.Overlay class="modal-overlay" />
-              <div class="fixed inset-0 z-50 flex items-center justify-center p-4">
-                <Dialog.Content class="modal-surface w-full max-w-sm p-6 border border-base shadow-2xl" tabIndex={-1}>
-                  <div class="flex items-start gap-3">
-                    <div
-                      class="flex h-12 w-12 shrink-0 items-center justify-center rounded-xl border text-base font-semibold"
-                      style={{
-                        "background-color": accent.badgeBg,
-                        "border-color": accent.badgeBorder,
-                        color: accent.badgeText,
-                      }}
-                      aria-hidden
-                    >
-                      {accent.symbol}
-                    </div>
-                    <div class="flex-1 min-w-0">
-                      <Dialog.Title class="text-lg font-semibold text-primary">{title}</Dialog.Title>
-                      <Dialog.Description class="text-sm text-secondary mt-1 whitespace-pre-line break-words">
-                        {payload.message}
-                        {payload.detail && <p class="mt-2 text-secondary">{payload.detail}</p>}
-                      </Dialog.Description>
-                    </div>
-                  </div>
+               <div class="fixed inset-0 z-50 flex items-center justify-center p-4">
+                 <Dialog.Content
+                   class="modal-surface w-full max-w-xl md:max-w-2xl p-6 border border-base shadow-2xl max-h-[85vh] overflow-hidden flex flex-col"
+                   tabIndex={-1}
+                 >
+                   <div class="flex items-start gap-3 min-h-0">
+                     <div
+                       class="flex h-12 w-12 shrink-0 items-center justify-center rounded-xl border text-base font-semibold"
+                       style={{
+                         "background-color": accent.badgeBg,
+                         "border-color": accent.badgeBorder,
+                         color: accent.badgeText,
+                       }}
+                       aria-hidden
+                     >
+                       {accent.symbol}
+                     </div>
+                     <div class="flex-1 min-w-0 min-h-0">
+                       <Dialog.Title class="text-lg font-semibold text-primary">{title}</Dialog.Title>
+                       <Dialog.Description class="text-sm text-secondary mt-1">
+                         <div
+                           class="max-h-[60vh] overflow-auto pr-2 whitespace-pre-wrap break-words"
+                           style={{ "overflow-wrap": "anywhere" }}
+                         >
+                           {payload.message}
+                           {payload.detail && <div class="mt-3">{payload.detail}</div>}
+                         </div>
+                       </Dialog.Description>
+                     </div>
+                   </div>
 
                     <Show when={isPrompt}>
                       <div class="mt-4">
@@ -185,14 +193,14 @@ const AlertDialog: Component = () => {
                        {confirmLabel}
                      </button>
                    </div>
-                </Dialog.Content>
-              </div>
-            </Dialog.Portal>
-          </Dialog>
-        )
-      }}
-    </Show>
-  )
-}
+                 </Dialog.Content>
+               </div>
+             </Dialog.Portal>
+           </Dialog>
+         )
+       }}
+     </Show>
+   )
+ }
 
 export default AlertDialog

packages/ui/src/components/info-view.tsx

@@ -1,5 +1,5 @@
 import { Component, For, createSignal, createEffect, Show, onMount, onCleanup, createMemo } from "solid-js"
-import { instances, getInstanceLogs, isInstanceLogStreaming, setInstanceLogStreaming } from "../stores/instances"
+import { getInstanceLogs, instances, isInstanceLogStreaming, setInstanceLogStreaming } from "../stores/instances"
 import { ChevronDown } from "lucide-solid"
 import InstanceInfo from "./instance-info"
 import { useI18n } from "../lib/i18n"
@@ -86,8 +86,8 @@ const InfoView: Component<InfoViewProps> = (props) => {
   return (
     <div class="log-container">
       <div class="flex-1 flex flex-col lg:flex-row gap-4 p-4 overflow-hidden">
-        <div class="lg:w-80 flex-shrink-0 overflow-y-auto">
-          <Show when={instance()}>{(inst) => <InstanceInfo instance={inst()} />}</Show>
+        <div class="lg:w-80 flex-shrink-0 min-h-0 overflow-y-auto max-h-[40vh] lg:max-h-none">
+          <Show when={instance()}>{(inst) => <InstanceInfo instance={inst()} showDisposeButton />}</Show>
         </div>
 
         <div class="panel flex-1 flex flex-col min-h-0 overflow-hidden">

packages/ui/src/components/instance-info.tsx

@@ -1,14 +1,21 @@
-import { Component, For, Show, createMemo } from "solid-js"
+import { Component, For, Show, createMemo, createSignal } from "solid-js"
 import type { Instance } from "../types/instance"
 import { useOptionalInstanceMetadataContext } from "../lib/contexts/instance-metadata-context"
 import InstanceServiceStatus from "./instance-service-status"
 import { useI18n } from "../lib/i18n"
+import { showConfirmDialog } from "../stores/alerts"
+import { disposeInstance } from "../stores/instances"
+import { showToastNotification } from "../lib/notifications"
+import { getLogger } from "../lib/logger"
 
 interface InstanceInfoProps {
   instance: Instance
   compact?: boolean
+  showDisposeButton?: boolean
 }
 
+const log = getLogger("actions")
+
 const InstanceInfo: Component<InstanceInfoProps> = (props) => {
   const { t } = useI18n()
   const metadataContext = useOptionalInstanceMetadataContext()
@@ -16,6 +23,8 @@ const InstanceInfo: Component<InstanceInfoProps> = (props) => {
   const instanceAccessor = metadataContext?.instance ?? (() => props.instance)
   const metadataAccessor = metadataContext?.metadata ?? (() => props.instance.metadata)
 
+  const [isDisposing, setIsDisposing] = createSignal(false)
+
   const currentInstance = () => instanceAccessor()
   const metadata = () => metadataAccessor()
   const binaryVersion = () => currentInstance().binaryVersion || metadata()?.version
@@ -25,6 +34,46 @@ const InstanceInfo: Component<InstanceInfoProps> = (props) => {
     return env ? Object.entries(env) : []
   })
 
+  const disposeEnabled = createMemo(() => Boolean(currentInstance()?.client) && !isDisposing())
+
+  const handleDisposeInstance = async () => {
+    if (!disposeEnabled()) return
+
+    const confirmed = await showConfirmDialog(t("infoView.dispose.confirm.message"), {
+      title: t("infoView.dispose.confirm.title"),
+      variant: "warning",
+      confirmLabel: t("infoView.dispose.confirm.confirmLabel"),
+      cancelLabel: t("infoView.dispose.confirm.cancelLabel"),
+    })
+
+    if (!confirmed) return
+
+    setIsDisposing(true)
+    try {
+      const ok = await disposeInstance(currentInstance().id)
+      if (ok) {
+        showToastNotification({
+          message: t("infoView.dispose.toast.success"),
+          variant: "success",
+          duration: 8000,
+        })
+      } else {
+        showToastNotification({
+          message: t("infoView.dispose.toast.error"),
+          variant: "error",
+        })
+      }
+    } catch (error) {
+      log.error("Failed to dispose instance", error)
+      showToastNotification({
+        message: t("infoView.dispose.toast.error"),
+        variant: "error",
+      })
+    } finally {
+      setIsDisposing(false)
+    }
+  }
+
   return (
     <div class="panel">
       <div class="panel-header">
@@ -156,6 +205,19 @@ const InstanceInfo: Component<InstanceInfoProps> = (props) => {
             </div>
           </div>
         </div>
+
+        <Show when={props.showDisposeButton}>
+          <div class="pt-3 border-t border-base">
+            <button
+              type="button"
+              class="button-danger button-small w-full"
+              onClick={handleDisposeInstance}
+              disabled={!disposeEnabled()}
+            >
+              {isDisposing() ? t("infoView.dispose.actions.disposing") : t("infoView.dispose.actions.dispose")}
+            </button>
+          </div>
+        </Show>
       </div>
     </div>
   )

packages/ui/src/components/message-part.tsx

@@ -3,7 +3,6 @@ import ToolCall from "./tool-call"
 import { isItemExpanded, toggleItemExpanded } from "../stores/tool-call-state"
 import { Markdown } from "./markdown"
 import { useTheme } from "../lib/theme"
-import { useConfig } from "../stores/preferences"
 import { partHasRenderableText, SDKPart, TextPart, ClientPart } from "../types/message"
 
 type ToolCallPart = Extract<ClientPart, { type: "tool" }>
@@ -17,16 +16,18 @@ interface MessagePartProps {
   // Other synthetic text parts (tool traces, read outputs, etc.) should be hidden.
   primaryUserTextPartId?: string | null
   onRendered?: () => void
- }
-   export default function MessagePart(props: MessagePartProps) {
+}
+
+export default function MessagePart(props: MessagePartProps) {
 
   const { isDark } = useTheme()
-  const { preferences } = useConfig()
   const partType = () => props.part?.type || ""
   const reasoningId = () => `reasoning-${props.part?.id || ""}`
   const isReasoningExpanded = () => isItemExpanded(reasoningId())
   const isAssistantMessage = () => props.messageType === "assistant"
   const textContainerClass = () => (isAssistantMessage() ? "message-text message-text-assistant" : "message-text")
+  const markdownContainerClass = () => "message-text message-text-assistant"
+  const textContainerRole = () => props.messageType || "assistant"
 
   const shouldHideTextPart = () => {
     const part = props.part
@@ -57,6 +58,11 @@ interface MessagePartProps {
     return ""
   }
 
+  const canRenderMarkdown = () => {
+    const id = (props.part as unknown as { id?: unknown })?.id
+    return typeof id === "string" && id.length > 0
+  }
+
   function reasoningSegmentHasText(segment: unknown): boolean {
     if (typeof segment === "string") {
       return segment.trim().length > 0
@@ -91,20 +97,28 @@ interface MessagePartProps {
 
   const createTextPartForMarkdown = (): TextPart => {
     const part = props.part
-    if ((part.type === "text" || part.type === "reasoning") && typeof part.text === "string") {
+    if (part.type === "text" && typeof part.text === "string") {
+      // Pass through the original part so `renderCache` updates persist.
+      return part as unknown as TextPart
+    }
+
+    if (part.type === "reasoning" && typeof (part as any).text === "string") {
+      // Reasoning parts render as markdown in some views; normalize to TextPart.
       return {
         id: part.id,
         type: "text",
-        text: part.text,
-        synthetic: part.type === "text" ? part.synthetic : false,
-        version: (part as { version?: number }).version
+        text: (part as any).text,
+        synthetic: false,
+        version: (part as { version?: number }).version,
+        renderCache: (part as any).renderCache,
       }
     }
+
     return {
       id: part.id,
-      type: "text", 
+      type: "text",
       text: "",
-      synthetic: false
+      synthetic: false,
     }
   }
 
@@ -117,22 +131,18 @@ interface MessagePartProps {
     <Switch>
       <Match when={partType() === "text"}>
         <Show when={!shouldHideTextPart() && partHasRenderableText(props.part)}>
-          <div class={textContainerClass()}>
-                <Show
-                 when={isAssistantMessage()}
-                 fallback={<span class="text-primary">{plainTextContent()}</span>}
-               >
-                 <Markdown
-                   part={createTextPartForMarkdown()}
-                   instanceId={props.instanceId}
-                   sessionId={props.sessionId}
-                   isDark={isDark()}
-                 size={isAssistantMessage() ? "tight" : "base"}
-                 onRendered={props.onRendered}
-               />
-              </Show>
-
-           </div>
+          <div class={canRenderMarkdown() ? markdownContainerClass() : textContainerClass()} data-role={textContainerRole()}>
+            <Show when={canRenderMarkdown()} fallback={<span class="text-primary">{plainTextContent()}</span>}>
+              <Markdown
+                part={createTextPartForMarkdown()}
+                instanceId={props.instanceId}
+                sessionId={props.sessionId}
+                isDark={isDark()}
+                size={isAssistantMessage() ? "tight" : "base"}
+                onRendered={props.onRendered}
+              />
+            </Show>
+          </div>
         </Show>
       </Match>
 

packages/ui/src/components/unified-picker.tsx

@@ -287,13 +287,14 @@ const UnifiedPicker: Component<UnifiedPickerProps> = (props) => {
     if (mode() !== "mention") return
 
     const query = props.searchQuery.toLowerCase()
+    const visibleAgents = props.agents.filter((agent) => !agent.hidden)
     const filtered = query
-      ? props.agents.filter(
+      ? visibleAgents.filter(
           (agent) =>
             agent.name.toLowerCase().includes(query) ||
             (agent.description && agent.description.toLowerCase().includes(query)),
         )
-      : props.agents
+      : visibleAgents
 
     setFilteredAgents(filtered)
   })

packages/ui/src/lib/i18n/messages/en/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "Enable streaming to watch your OpenCode server activity.",
   "infoView.logs.empty.waiting": "Waiting for server output...",
   "infoView.logs.scrollToBottom": "Scroll to bottom",
+
+  "infoView.dispose.actions.dispose": "Dispose instance",
+  "infoView.dispose.actions.disposing": "Disposing...",
+  "infoView.dispose.confirm.title": "Dispose instance?",
+  "infoView.dispose.confirm.message": "This clears cached per-project state for this directory and reloads the instance.",
+  "infoView.dispose.confirm.confirmLabel": "Dispose",
+  "infoView.dispose.confirm.cancelLabel": "Cancel",
+  "infoView.dispose.toast.success": "Instance disposed. Reloading...",
+  "infoView.dispose.toast.error": "Failed to dispose instance.",
 } as const

packages/ui/src/lib/i18n/messages/es/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "Activa el streaming para ver la actividad de tu servidor de OpenCode.",
   "infoView.logs.empty.waiting": "Esperando la salida del servidor...",
   "infoView.logs.scrollToBottom": "Desplazarse al final",
+
+  "infoView.dispose.actions.dispose": "Desechar instancia",
+  "infoView.dispose.actions.disposing": "Desechando...",
+  "infoView.dispose.confirm.title": "¿Desechar instancia?",
+  "infoView.dispose.confirm.message": "Esto borra el estado en caché por proyecto para este directorio y recarga la instancia.",
+  "infoView.dispose.confirm.confirmLabel": "Desechar",
+  "infoView.dispose.confirm.cancelLabel": "Cancelar",
+  "infoView.dispose.toast.success": "Instancia desechada. Recargando...",
+  "infoView.dispose.toast.error": "No se pudo desechar la instancia.",
 } as const

packages/ui/src/lib/i18n/messages/fr/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "Activez le streaming pour suivre l'activité de votre serveur OpenCode.",
   "infoView.logs.empty.waiting": "En attente de la sortie du serveur...",
   "infoView.logs.scrollToBottom": "Aller en bas",
+
+  "infoView.dispose.actions.dispose": "Réinitialiser l'instance",
+  "infoView.dispose.actions.disposing": "Réinitialisation...",
+  "infoView.dispose.confirm.title": "Réinitialiser l'instance ?",
+  "infoView.dispose.confirm.message": "Cela efface l'état en cache pour ce répertoire et recharge l'instance.",
+  "infoView.dispose.confirm.confirmLabel": "Réinitialiser",
+  "infoView.dispose.confirm.cancelLabel": "Annuler",
+  "infoView.dispose.toast.success": "Instance réinitialisée. Rechargement...",
+  "infoView.dispose.toast.error": "Impossible de réinitialiser l'instance.",
 } as const

packages/ui/src/lib/i18n/messages/ja/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "ストリーミングを有効にして OpenCode サーバーの動作を監視します。",
   "infoView.logs.empty.waiting": "サーバー出力を待機中...",
   "infoView.logs.scrollToBottom": "最下部へスクロール",
+
+  "infoView.dispose.actions.dispose": "インスタンスを破棄",
+  "infoView.dispose.actions.disposing": "破棄しています...",
+  "infoView.dispose.confirm.title": "インスタンスを破棄しますか？",
+  "infoView.dispose.confirm.message": "このディレクトリのプロジェクト状態キャッシュをクリアし、インスタンスを再読み込みします。",
+  "infoView.dispose.confirm.confirmLabel": "破棄",
+  "infoView.dispose.confirm.cancelLabel": "キャンセル",
+  "infoView.dispose.toast.success": "インスタンスを破棄しました。再読み込み中...",
+  "infoView.dispose.toast.error": "インスタンスの破棄に失敗しました。",
 } as const

packages/ui/src/lib/i18n/messages/ru/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "Включите стриминг, чтобы наблюдать за активностью сервера OpenCode.",
   "infoView.logs.empty.waiting": "Ожидание вывода сервера…",
   "infoView.logs.scrollToBottom": "Прокрутить вниз",
+
+  "infoView.dispose.actions.dispose": "Сбросить инстанс",
+  "infoView.dispose.actions.disposing": "Сброс...",
+  "infoView.dispose.confirm.title": "Сбросить инстанс?",
+  "infoView.dispose.confirm.message": "Это очистит кэш состояния проекта для этого каталога и перезагрузит инстанс.",
+  "infoView.dispose.confirm.confirmLabel": "Сбросить",
+  "infoView.dispose.confirm.cancelLabel": "Отмена",
+  "infoView.dispose.toast.success": "Инстанс сброшен. Перезагрузка...",
+  "infoView.dispose.toast.error": "Не удалось сбросить инстанс.",
 } as const

packages/ui/src/lib/i18n/messages/zh-Hans/logs.ts

@@ -15,4 +15,13 @@ export const logMessages = {
   "infoView.logs.paused.description": "启用流式输出以查看 OpenCode 服务器活动。",
   "infoView.logs.empty.waiting": "正在等待服务器输出...",
   "infoView.logs.scrollToBottom": "滚动到底部",
+
+  "infoView.dispose.actions.dispose": "释放实例",
+  "infoView.dispose.actions.disposing": "正在释放...",
+  "infoView.dispose.confirm.title": "要释放实例吗？",
+  "infoView.dispose.confirm.message": "这将清除此目录的项目缓存状态，并重新加载实例。",
+  "infoView.dispose.confirm.confirmLabel": "释放",
+  "infoView.dispose.confirm.cancelLabel": "取消",
+  "infoView.dispose.toast.success": "实例已释放。正在重新加载...",
+  "infoView.dispose.toast.error": "释放实例失败。",
 } as const

packages/ui/src/lib/sdk-manager.ts

@@ -4,12 +4,12 @@ import { CODENOMAD_API_BASE } from "./api-client"
 class SDKManager {
   private clients = new Map<string, OpencodeClient>()
 
-  private key(instanceId: string, worktreeSlug: string): string {
-    return `${instanceId}:${worktreeSlug || "root"}`
+  private key(instanceId: string, proxyPath: string): string {
+    return `${instanceId}:${normalizeProxyPath(proxyPath)}`
   }
 
-  createClient(instanceId: string, proxyPath: string, worktreeSlug = "root"): OpencodeClient {
-    const key = this.key(instanceId, worktreeSlug)
+  createClient(instanceId: string, proxyPath: string, _worktreeSlug = "root"): OpencodeClient {
+    const key = this.key(instanceId, proxyPath)
     const existing = this.clients.get(key)
     if (existing) {
       return existing
@@ -23,12 +23,12 @@ class SDKManager {
     return client
   }
 
-  getClient(instanceId: string, worktreeSlug = "root"): OpencodeClient | null {
-    return this.clients.get(this.key(instanceId, worktreeSlug)) ?? null
+  getClient(instanceId: string, proxyPath: string): OpencodeClient | null {
+    return this.clients.get(this.key(instanceId, proxyPath)) ?? null
   }
 
-  destroyClient(instanceId: string, worktreeSlug = "root"): void {
-    this.clients.delete(this.key(instanceId, worktreeSlug))
+  destroyClient(instanceId: string, proxyPath: string): void {
+    this.clients.delete(this.key(instanceId, proxyPath))
   }
 
   destroyClientsForInstance(instanceId: string): void {
@@ -46,7 +46,7 @@ class SDKManager {
 
 export type { OpencodeClient }
 
-function buildInstanceBaseUrl(proxyPath: string): string {
+export function buildInstanceBaseUrl(proxyPath: string): string {
   const normalized = normalizeProxyPath(proxyPath)
   const base = stripTrailingSlashes(CODENOMAD_API_BASE)
   return `${base}${normalized}/`

packages/ui/src/lib/sse-manager.ts

@@ -54,6 +54,13 @@ interface BackgroundProcessRemovedEvent {
   }
 }
 
+interface ServerInstanceDisposedEvent {
+  type: "server.instance.disposed"
+  properties: {
+    directory: string
+  }
+}
+
 type SSEEvent =
   | MessageUpdateEvent
   | MessageRemovedEvent
@@ -74,6 +81,7 @@ type SSEEvent =
   | TuiToastEvent
   | BackgroundProcessUpdatedEvent
   | BackgroundProcessRemovedEvent
+  | ServerInstanceDisposedEvent
   | { type: string; properties?: Record<string, unknown> }
 
 type ConnectionStatus = InstanceStreamStatus
@@ -173,6 +181,9 @@ class SSEManager {
       case "background.process.removed":
         this.onBackgroundProcessRemoved?.(instanceId, event as BackgroundProcessRemovedEvent)
         break
+      case "server.instance.disposed":
+        this.onInstanceDisposed?.(instanceId, event as ServerInstanceDisposedEvent)
+        break
       default:
         log.warn("Unknown SSE event type", { type: event.type })
     }
@@ -205,6 +216,7 @@ class SSEManager {
   onLspUpdated?: (instanceId: string, event: EventLspUpdated) => void
   onBackgroundProcessUpdated?: (instanceId: string, event: BackgroundProcessUpdatedEvent) => void
   onBackgroundProcessRemoved?: (instanceId: string, event: BackgroundProcessRemovedEvent) => void
+  onInstanceDisposed?: (instanceId: string, event: ServerInstanceDisposedEvent) => void
   onConnectionLost?: (instanceId: string, reason: string) => void | Promise<void>
 
   getStatus(instanceId: string): ConnectionStatus | null {

packages/ui/src/stores/instances.ts

@@ -6,7 +6,7 @@ import { getPermissionCreatedAt, getPermissionSessionId } from "../types/permiss
 import type { QuestionRequest } from "@opencode-ai/sdk/v2"
 import { getQuestionSessionId } from "../types/question"
 import { requestData } from "../lib/opencode-api"
-import { sdkManager } from "../lib/sdk-manager"
+import { buildInstanceBaseUrl, sdkManager } from "../lib/sdk-manager"
 import { sseManager } from "../lib/sse-manager"
 import { serverApi } from "../lib/api-client"
 import { serverEvents } from "../lib/server-events"
@@ -18,7 +18,14 @@ import {
   fetchProviders,
   clearInstanceDraftPrompts,
 } from "./sessions"
-import { ensureWorktreesLoaded, ensureWorktreeMapLoaded, getOrCreateWorktreeClient, getWorktreeSlugForSession } from "./worktrees"
+import {
+  ensureWorktreesLoaded,
+  ensureWorktreeMapLoaded,
+  getOrCreateWorktreeClient,
+  getWorktreeSlugForSession,
+  reloadWorktreeMap,
+  reloadWorktrees,
+} from "./worktrees"
 import { fetchCommands, clearCommands } from "./commands"
 import { serverSettings } from "./preferences"
 import { setSessionPendingPermission, setSessionPendingQuestion } from "./session-state"
@@ -45,6 +52,8 @@ const permissionSessionCounts = new Map<string, Map<string, number>>()
 const permissionWorktreeSlugByInstance = new Map<string, Map<string, string>>()
 
 const [questionQueues, setQuestionQueues] = createSignal<Map<string, QuestionRequest[]>>(new Map())
+// Track which worktree a question was enqueued under (by question request id).
+const questionWorktreeSlugByInstance = new Map<string, Map<string, string>>()
 const [activeQuestionId, setActiveQuestionId] = createSignal<Map<string, string | null>>(new Map())
 const questionSessionCounts = new Map<string, Map<string, number>>()
 const questionEnqueuedAt = new Map<string, number>()
@@ -76,6 +85,9 @@ const [disconnectedInstance, setDisconnectedInstance] = createSignal<Disconnecte
 
 const MAX_LOG_ENTRIES = 1000
 
+const pendingDisposeRequests = new Map<string, Promise<boolean>>()
+const pendingRehydrations = new Map<string, Promise<void>>()
+
 function workspaceDescriptorToInstance(descriptor: WorkspaceDescriptor): Instance {
   const existing = instances().get(descriptor.id)
   return {
@@ -228,10 +240,15 @@ async function syncPendingQuestions(instanceId: string): Promise<void> {
   }
 }
 
-async function hydrateInstanceData(instanceId: string) {
+async function hydrateInstanceData(instanceId: string, options?: { force?: boolean }) {
   try {
-    await ensureWorktreesLoaded(instanceId)
-    await ensureWorktreeMapLoaded(instanceId)
+    if (options?.force) {
+      await reloadWorktrees(instanceId)
+      await reloadWorktreeMap(instanceId)
+    } else {
+      await ensureWorktreesLoaded(instanceId)
+      await ensureWorktreeMapLoaded(instanceId)
+    }
     await fetchSessions(instanceId)
     await fetchAgents(instanceId)
     await fetchProviders(instanceId)
@@ -246,6 +263,91 @@ async function hydrateInstanceData(instanceId: string) {
   }
 }
 
+async function postInstanceDispose(instanceId: string): Promise<boolean> {
+  const instance = instances().get(instanceId)
+  if (!instance?.proxyPath) {
+    throw new Error("Instance not ready")
+  }
+
+  const baseUrl = buildInstanceBaseUrl(instance.proxyPath)
+  const url = new URL("instance/dispose", baseUrl)
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    credentials: "include",
+    headers: {
+      Accept: "application/json",
+    },
+  })
+
+  if (!response.ok) {
+    const message = await response.text().catch(() => "")
+    throw new Error(message || `Dispose request failed with ${response.status}`)
+  }
+
+  const contentType = response.headers.get("content-type") ?? ""
+  if (contentType.includes("application/json")) {
+    const data = await response.json().catch(() => undefined)
+    if (typeof data === "boolean") return data
+    if (data && typeof data === "object" && "data" in (data as any)) {
+      return Boolean((data as any).data)
+    }
+    return Boolean(data)
+  }
+
+  const text = await response.text().catch(() => "")
+  if (text.trim() === "true") return true
+  if (text.trim() === "false") return false
+  return Boolean(text)
+}
+
+async function rehydrateInstance(instanceId: string, options?: { reason?: string }): Promise<void> {
+  if (pendingRehydrations.has(instanceId)) {
+    return pendingRehydrations.get(instanceId)
+  }
+
+  const promise = (async () => {
+    const instance = instances().get(instanceId)
+    if (!instance?.client) {
+      return
+    }
+
+    log.info("Rehydrating instance", { instanceId, reason: options?.reason })
+    clearCacheForInstance(instanceId)
+    clearCommands(instanceId)
+    clearInstanceMetadata(instanceId)
+    clearInstanceDraftPrompts(instanceId)
+    clearPermissionQueue(instanceId)
+    clearQuestionQueue(instanceId)
+
+    await hydrateInstanceData(instanceId, { force: true })
+  })().finally(() => {
+    pendingRehydrations.delete(instanceId)
+  })
+
+  pendingRehydrations.set(instanceId, promise)
+  return promise
+}
+
+async function disposeInstance(instanceId: string): Promise<boolean> {
+  if (pendingDisposeRequests.has(instanceId)) {
+    return pendingDisposeRequests.get(instanceId)!
+  }
+
+  const promise = (async () => {
+    const ok = await postInstanceDispose(instanceId)
+    if (ok) {
+      await rehydrateInstance(instanceId, { reason: "disposed" })
+    }
+    return ok
+  })().finally(() => {
+    pendingDisposeRequests.delete(instanceId)
+  })
+
+  pendingDisposeRequests.set(instanceId, promise)
+  return promise
+}
+
   void (async function initializeWorkspaces() {
   try {
     const workspaces = await serverApi.fetchWorkspaces()
@@ -777,6 +879,16 @@ function addQuestionToQueue(instanceId: string, request: QuestionRequest): void
   if (sessionId) {
     incrementQuestionSessionPendingCount(instanceId, sessionId)
     setSessionPendingQuestion(instanceId, sessionId, true)
+
+    // Record the worktree slug at the time the question is enqueued.
+    // This is used to respond in the same worktree context even from the global permission center.
+    const slug = getWorktreeSlugForSession(instanceId, sessionId)
+    let byQuestionId = questionWorktreeSlugByInstance.get(instanceId)
+    if (!byQuestionId) {
+      byQuestionId = new Map()
+      questionWorktreeSlugByInstance.set(instanceId, byQuestionId)
+    }
+    byQuestionId.set(request.id, slug)
   }
 }
 
@@ -797,6 +909,7 @@ function removeQuestionFromQueue(instanceId: string, requestId: string): void {
   })
 
   questionEnqueuedAt.delete(requestId)
+  questionWorktreeSlugByInstance.get(instanceId)?.delete(requestId)
   recomputeActiveInterruption(instanceId)
 
   if (removedSessionId) {
@@ -809,6 +922,7 @@ function clearQuestionQueue(instanceId: string): void {
   for (const request of getQuestionQueue(instanceId)) {
     questionEnqueuedAt.delete(request.id)
   }
+  questionWorktreeSlugByInstance.delete(instanceId)
 
   setQuestionQueues((prev) => {
     const next = new Map(prev)
@@ -834,7 +948,7 @@ function setActiveQuestionIdForInstance(instanceId: string, requestId: string):
 
 async function sendQuestionReply(
   instanceId: string,
-  _sessionId: string,
+  sessionId: string,
   requestId: string,
   answers: string[][],
 ): Promise<void> {
@@ -844,8 +958,13 @@ async function sendQuestionReply(
   }
 
   try {
+    const stored = questionWorktreeSlugByInstance.get(instanceId)?.get(requestId)
+    const fallback = sessionId ? getWorktreeSlugForSession(instanceId, sessionId) : "root"
+    const worktreeSlug = stored ?? fallback
+    const client = getOrCreateWorktreeClient(instanceId, worktreeSlug)
+
     await requestData(
-      instance.client.question.reply({
+      client.question.reply({
         requestID: requestId,
         answers,
       }),
@@ -859,15 +978,20 @@ async function sendQuestionReply(
   }
 }
 
-async function sendQuestionReject(instanceId: string, _sessionId: string, requestId: string): Promise<void> {
+async function sendQuestionReject(instanceId: string, sessionId: string, requestId: string): Promise<void> {
   const instance = instances().get(instanceId)
   if (!instance?.client) {
     throw new Error("Instance not ready")
   }
 
   try {
+    const stored = questionWorktreeSlugByInstance.get(instanceId)?.get(requestId)
+    const fallback = sessionId ? getWorktreeSlugForSession(instanceId, sessionId) : "root"
+    const worktreeSlug = stored ?? fallback
+    const client = getOrCreateWorktreeClient(instanceId, worktreeSlug)
+
     await requestData(
-      instance.client.question.reject({
+      client.question.reject({
         requestID: requestId,
       }),
       "question.reject",
@@ -939,6 +1063,30 @@ sseManager.onLspUpdated = async (instanceId) => {
   }
 }
 
+sseManager.onInstanceDisposed = (sourceInstanceId, event) => {
+  const directory = event?.properties?.directory
+  if (!directory) {
+    void rehydrateInstance(sourceInstanceId, { reason: "disposed" })
+    return
+  }
+
+  const matchingInstanceIds: string[] = []
+  for (const instance of instances().values()) {
+    if (instance.folder === directory) {
+      matchingInstanceIds.push(instance.id)
+    }
+  }
+
+  if (matchingInstanceIds.length === 0) {
+    void rehydrateInstance(sourceInstanceId, { reason: "disposed" })
+    return
+  }
+
+  for (const instanceId of matchingInstanceIds) {
+    void rehydrateInstance(instanceId, { reason: "disposed" })
+  }
+}
+
 async function acknowledgeDisconnectedInstance(): Promise<void> {
   const pending = disconnectedInstance()
   if (!pending) {
@@ -995,4 +1143,5 @@ export {
   disconnectedInstance,
   acknowledgeDisconnectedInstance,
   fetchLspStatus,
+  disposeInstance,
 }

packages/ui/src/stores/session-api.ts

@@ -526,6 +526,7 @@ async function fetchAgents(instanceId: string): Promise<void> {
       name: agent.name,
       description: agent.description || "",
       mode: agent.mode,
+      hidden: agent.hidden,
       model: agent.model?.modelID
         ? {
             providerId: agent.model.providerID || "",

packages/ui/src/stores/worktrees.ts

@@ -329,12 +329,38 @@ function buildWorktreeProxyPath(instanceId: string, slug: string): string {
   return `/workspaces/${encodeURIComponent(instanceId)}/worktrees/${encodeURIComponent(normalizedSlug)}/instance`
 }
 
+function encodeBase64UrlUtf8(input: string): string {
+  const bytes = new TextEncoder().encode(input)
+  // Convert bytes -> base64 (btoa expects a binary string)
+  let binary = ""
+  const chunkSize = 0x8000
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize)
+    binary += String.fromCharCode(...chunk)
+  }
+  const base64 = btoa(binary)
+  // base64 -> base64url (strip padding)
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "")
+}
+
+function buildWorktreeProxyPathWithDirectoryOverride(instanceId: string, slug: string, directory: string): string {
+  const base = buildWorktreeProxyPath(instanceId, slug)
+  const encoded = encodeBase64UrlUtf8(directory)
+  return `${base}/__dir/${encoded}`
+}
+
 function getOrCreateWorktreeClient(instanceId: string, slug: string): OpencodeClient {
   const normalized = normalizeWorktreeSlug(instanceId, slug || "root")
   const proxyPath = buildWorktreeProxyPath(instanceId, normalized)
   return sdkManager.createClient(instanceId, proxyPath, normalized)
 }
 
+function getOrCreateWorktreeClientWithDirectoryOverride(instanceId: string, slug: string, directory: string): OpencodeClient {
+  const normalized = normalizeWorktreeSlug(instanceId, slug || "root")
+  const proxyPath = buildWorktreeProxyPathWithDirectoryOverride(instanceId, normalized, directory)
+  return sdkManager.createClient(instanceId, proxyPath, normalized)
+}
+
 function getRootClient(instanceId: string): OpencodeClient {
   return getOrCreateWorktreeClient(instanceId, "root")
 }
@@ -359,7 +385,9 @@ export {
   removeParentSessionMapping,
   getWorktreeSlugForDirectory,
   buildWorktreeProxyPath,
+  buildWorktreeProxyPathWithDirectoryOverride,
   getOrCreateWorktreeClient,
+  getOrCreateWorktreeClientWithDirectoryOverride,
   getRootClient,
   createWorktree,
   deleteWorktree,

packages/ui/src/styles/components/buttons.css

@@ -54,3 +54,28 @@ button.button-tertiary:hover:not(:disabled) {
 button.button-tertiary:focus-visible {
   box-shadow: 0 0 0 2px var(--focus-ring-offset), 0 0 0 4px var(--focus-ring-color);
 }
+
+.button-danger,
+button.button-danger {
+  @apply px-6 py-3 text-base rounded-lg;
+  background-color: var(--button-danger-bg);
+  color: var(--button-danger-text);
+  border-color: var(--button-danger-bg);
+}
+
+.button-danger:hover:not(:disabled),
+button.button-danger:hover:not(:disabled) {
+  background-color: var(--button-danger-hover-bg);
+  border-color: var(--button-danger-hover-bg);
+}
+
+.button-danger:focus-visible,
+button.button-danger:focus-visible {
+  box-shadow: 0 0 0 2px var(--focus-ring-offset), 0 0 0 4px var(--focus-ring-color);
+}
+
+/* Smaller sizing variant for destructive actions in tight spaces. */
+.button-danger.button-small,
+button.button-danger.button-small {
+  @apply px-4 py-2 text-sm;
+}

packages/ui/src/styles/markdown.css

@@ -9,6 +9,9 @@
     line-height: var(--line-height-normal);
     font-weight: var(--font-weight-regular);
     color: var(--text-primary);
+    /* Message containers may use `whitespace-pre-wrap` for plain text.
+       Markdown should always match assistant rendering (normal whitespace). */
+    white-space: normal;
   }
 
   .markdown-body p,
@@ -28,7 +31,7 @@
   .markdown-body h5,
   .markdown-body h6 {
     font-family: inherit;
-    color: inherit;
+    color: var(--markdown-heading-color, inherit);
     font-weight: var(--font-weight-semibold);
     line-height: 1.3;
     margin-top: 0.9em;
@@ -71,7 +74,7 @@
 
   .markdown-body strong {
     font-weight: var(--font-weight-regular);
-    color: var(--message-assistant-border);
+    color: var(--markdown-accent, var(--message-assistant-border));
   }
 
   .markdown-body em {

packages/ui/src/styles/messaging/message-base.css

@@ -1,6 +1,10 @@
 /* Message item base styles */
 .message-item-base {
   @apply flex flex-col gap-2 p-3 w-full;
+
+  /* Markdown rendering uses these to theme emphasis + headings per message role. */
+  --markdown-accent: var(--message-user-border);
+  --markdown-heading-color: var(--message-user-border);
 }
 
 .message-item-header {
@@ -71,6 +75,9 @@
   padding: 0.6rem 0.65rem;
   margin-top: 0;
   margin-bottom: 0;
+
+  --markdown-accent: var(--message-assistant-border);
+  --markdown-heading-color: var(--text-primary);
 }
 
 .message-item-base:not(.assistant-message) {

packages/ui/src/styles/utilities.css

@@ -64,6 +64,8 @@
     button.button-primary,
     .button-secondary,
     button.button-secondary,
+    .button-danger,
+    button.button-danger,
     .button-tertiary,
     button.button-tertiary) {
   @apply inline-flex items-center justify-center gap-2 font-medium transition-colors rounded-md;
@@ -74,6 +76,8 @@
     button.button-primary,
     .button-secondary,
     button.button-secondary,
+    .button-danger,
+    button.button-danger,
     .button-tertiary,
     button.button-tertiary):focus-visible {
   outline: none;
@@ -84,6 +88,8 @@
     button.button-primary,
     .button-secondary,
     button.button-secondary,
+    .button-danger,
+    button.button-danger,
     .button-tertiary,
     button.button-tertiary):disabled {
   @apply cursor-not-allowed opacity-50;

packages/ui/src/types/session.ts

@@ -68,6 +68,7 @@ export interface Agent {
   name: string
   description: string
   mode: string
+  hidden?: boolean
   model?: {
     providerId: string
     modelId: string

temp/package/package.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/sdk",
+  "version": "1.2.6",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "build": "./script/build.ts"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client.js",
+      "types": "./dist/client.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server.js",
+      "types": "./dist/server.d.ts"
+    },
+    "./v2": {
+      "import": "./dist/v2/index.js",
+      "types": "./dist/v2/index.d.ts"
+    },
+    "./v2/client": {
+      "import": "./dist/v2/client.js",
+      "types": "./dist/v2/client.d.ts"
+    },
+    "./v2/server": {
+      "import": "./dist/v2/server.js",
+      "types": "./dist/v2/server.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@hey-api/openapi-ts": "0.90.10",
+    "@tsconfig/node22": "22.0.2",
+    "@types/node": "22.13.9",
+    "typescript": "5.8.2",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "directory": "dist"
+  }
+}