diff --git a/apps/buddy/electron/main/extensions/__tests__/ExtensionCapabilities.spec.ts b/apps/buddy/electron/main/extensions/__tests__/ExtensionCapabilities.spec.ts
new file mode 100644
index 00000000..8dcf8c6d
--- /dev/null
+++ b/apps/buddy/electron/main/extensions/__tests__/ExtensionCapabilities.spec.ts
@@ -0,0 +1,33 @@
+import type { RuntimeRequestHandler } from '../../../../shared/runtime/rpcPeer'
+import { expect, it, vi } from 'vitest'
+import { EXTENSION_CAPABILITIES_RPC, extensionCapabilitiesSchema } from '../../../../shared/extensions/extensionAuthoring'
+import { EXTENSION_API_VERSION, extensionPlacementSchema } from '../../../../shared/extensions/extensionManifest'
+import { registerExtensionAuthoringRpc } from '../registerExtensionAuthoringRpc'
+
+vi.mock('../compileExtension', () => ({ compileExtension: () => {
+  throw new Error('Unexpected compilation')
+} }))
+
+it('discovers a compact host index and exact target contracts without loading plugins', async () => {
+  const handlers = new Map<string, RuntimeRequestHandler>()
+  const dispose = registerExtensionAuthoringRpc({ onRequest: (method, handler) => {
+    handlers.set(method, handler)
+    return () => handlers.delete(method)
+  } }, async () => { throw new Error('Unexpected inspection') })
+  try {
+    const query = (params: unknown) => Promise.resolve(handlers.get(EXTENSION_CAPABILITIES_RPC)!(params))
+    const index = extensionCapabilitiesSchema.parse(await query({}))
+    expect(index.apiVersion).toBe(EXTENSION_API_VERSION)
+    expect(index.targets.some(target => target.target === 'composer.accessory' && target.scope === 'composer')).toBe(true)
+    expect(index.targets.every(target => !target.description && !target.height)).toBe(true)
+    const detail = extensionCapabilitiesSchema.parse(await query({ target: 'composer.accessory' }))
+    expect(detail.targets).toEqual([expect.objectContaining({ kind: 'slot', selection: 'multiple', height: { min: 32, max: 240, default: 64 } })])
+    const placement = { id: 'tests.content.slot', view: 'tests.content.view', kind: 'slot', target: detail.targets[0]!.target }
+    expect(extensionPlacementSchema.parse(placement)).toMatchObject({ height: detail.targets[0]!.height!.default })
+    expect(extensionPlacementSchema.safeParse({ ...placement, height: detail.targets[0]!.height!.max + 1 }).success).toBe(false)
+    expect(extensionCapabilitiesSchema.parse(await query({ target: 'document.body' })).targets).toEqual([])
+    expect(extensionCapabilitiesSchema.parse(await query({ kind: 'runtime' })).targets.map(target => target.target)).toEqual(['commands', 'workbench.panes', 'workbench.interactions'])
+    await expect(query({ kind: 'arbitrary' })).rejects.toThrow()
+  }
+  finally { dispose() }
+})
diff --git a/apps/buddy/electron/main/extensions/registerExtensionAuthoringRpc.ts b/apps/buddy/electron/main/extensions/registerExtensionAuthoringRpc.ts
index 78448c47..aa6a1e69 100644
--- a/apps/buddy/electron/main/extensions/registerExtensionAuthoringRpc.ts
+++ b/apps/buddy/electron/main/extensions/registerExtensionAuthoringRpc.ts
@@ -1,13 +1,20 @@
 import type { ExtensionInspection } from '../../../shared/extensions/extensionAuthoring'
 import type { RuntimeRpcPeerContract } from '../../../shared/runtime/rpcPeer'
 import { buildExtensionPackage } from '../../../platform/extensions/buildExtensionPackage'
-import { EXTENSION_BUILD_RPC, EXTENSION_INSPECT_RPC, extensionInspectionSchema, extensionInspectRequestSchema } from '../../../shared/extensions/extensionAuthoring'
+import { EXTENSION_BUILD_RPC, EXTENSION_CAPABILITIES_RPC, EXTENSION_INSPECT_RPC, extensionCapabilitiesRequestSchema, extensionInspectionSchema, extensionInspectRequestSchema } from '../../../shared/extensions/extensionAuthoring'
+import { EXTENSION_API_VERSION } from '../../../shared/extensions/extensionManifest'
+import { queryWorkbenchCapabilities } from '../../../shared/workbench/workbenchUi'
 import { compileExtension } from './compileExtension'
 
-export function registerExtensionAuthoringRpc(peer: RuntimeRpcPeerContract, inspect: (id: string) => Promise<ExtensionInspection>): () => void {
+export function registerExtensionAuthoringRpc(peer: Pick<RuntimeRpcPeerContract, 'onRequest'>, inspect: (id: string) => Promise<ExtensionInspection>): () => void {
   const lifetime = new AbortController()
   let active = 0
   const stopInspect = peer.onRequest(EXTENSION_INSPECT_RPC, async input => extensionInspectionSchema.parse(await inspect(extensionInspectRequestSchema.parse(input).id)))
+  const stopCapabilities = peer.onRequest(EXTENSION_CAPABILITIES_RPC, async (input) => {
+    const query = extensionCapabilitiesRequestSchema.parse(input)
+    const targets = queryWorkbenchCapabilities(query)
+    return { apiVersion: EXTENSION_API_VERSION, targets: query.kind || query.target ? targets : targets.map(({ kind, target, title, scope }) => ({ kind, target, title, scope })) }
+  })
   const stop = peer.onRequest(EXTENSION_BUILD_RPC, async (input, signal) => {
     if (active >= 2)
       return { ok: false, code: 'EXTENSION_COMPILER_BUSY', diagnostics: [] }
@@ -21,5 +28,6 @@ export function registerExtensionAuthoringRpc(peer: RuntimeRpcPeerContract, insp
     lifetime.abort()
     stop()
     stopInspect()
+    stopCapabilities()
   }
 }
diff --git a/apps/buddy/electron/main/extensions/registerExtensionIpc.ts b/apps/buddy/electron/main/extensions/registerExtensionIpc.ts
index ac6d8677..73ac0581 100644
--- a/apps/buddy/electron/main/extensions/registerExtensionIpc.ts
+++ b/apps/buddy/electron/main/extensions/registerExtensionIpc.ts
@@ -181,6 +181,10 @@ export function registerExtensionIpc(options: {
         case 'devtools': return await service.devtools(input.id)
         case 'revokeResources': return await service.revokeResources(input.id)
         case 'execute': return await service.execute(input.id, input.command, input.resource)
+        case 'executeMenu': return await service.executeMenu(input.id, input.menu, input.invocation)
+        case 'executeSlash': return await service.executeSlash(input.id, input.command, input.arguments, input.instanceId)
+        case 'updatePanes': return service.updatePanes(input.panes)
+        case 'endInteraction': return service.endInteraction(input.id)
         case 'openView': return await service.openView(input.view)
         case 'closeView': return service.closeView(input.viewId, input.generation, input.token)
         case 'viewRequest': return await service.viewRequest(input.viewId, input.generation, input.token, input.method, input.params)
diff --git a/apps/buddy/electron/main/extensions/runtime/host.js b/apps/buddy/electron/main/extensions/runtime/host.js
index 03a9aeff..c2b90f11 100644
--- a/apps/buddy/electron/main/extensions/runtime/host.js
+++ b/apps/buddy/electron/main/extensions/runtime/host.js
@@ -4,7 +4,15 @@ const subscriptions = new Set()
 let entry
 let manifest
 let context
+let registrationError = null
 let activated = false
+let panes = Object.freeze([])
+const paneListeners = new Set()
+const interactions = new Map()
+function applyPanes(next) {
+  panes = Object.freeze(next.map(pane => Object.freeze({ ...pane, rect: Object.freeze(pane.rect) })))
+  for (const listener of paneListeners) listener(panes)
+}
 const code = error => /^EXTENSION_[A-Z_]+$/.test(error?.message) ? error.message : 'EXTENSION_ACTIVATION_FAILED'
 const request = (method, params = null) => bridge.request(method, params)
 function disposable(cleanup) {
@@ -24,6 +32,7 @@ bridge.subscribe(async ({ id, method, params }) => {
     let result = null
     if (method === 'activate') {
       manifest = params.manifest
+      applyPanes(params.panes ?? [])
       entry = manifest.entry ? await import(`/__package/${manifest.entry}`) : {}
       context = Object.freeze({
         extension: Object.freeze({ id: manifest.id, version: manifest.version, apiVersion: manifest.apiVersion }),
@@ -32,13 +41,38 @@ bridge.subscribe(async ({ id, method, params }) => {
           return value
         } },
         commands: { register(id, callback) {
-          if (!manifest.contributes.commands.some(command => command.id === id) || commands.has(id) || typeof callback !== 'function')
-            throw new Error('EXTENSION_COMMAND_INVALID')
+          if (activated || !manifest.contributes.commands.some(command => command.id === id) || commands.has(id) || typeof callback !== 'function') {
+            registrationError = new Error('EXTENSION_COMMAND_INVALID')
+            throw registrationError
+          }
           commands.set(id, callback)
           return disposable(() => commands.delete(id))
         } },
-        views: { open: (type, options = {}) => request('views.open', { type, resource: options.resource ?? null, state: options.state ?? {} }) },
-        placements: { show: id => request('placements.show', { id }), hide: id => request('placements.hide', { id }) },
+        workbench: {
+          get panes() { return panes },
+          onPanesChange: (listener) => {
+            paneListeners.add(listener)
+            return disposable(() => paneListeners.delete(listener))
+          },
+        },
+        interactions: { start: async (title) => {
+          const id = crypto.randomUUID()
+          const controller = new AbortController()
+          interactions.set(id, controller)
+          try {
+            await request('interactions.start', { id, title })
+            if (controller.signal.aborted)
+              throw new Error('EXTENSION_INTERACTION_ENDED')
+            return Object.freeze({ id, signal: controller.signal, end: () => request('interactions.end', { id }) })
+          }
+          catch (error) {
+            controller.abort()
+            interactions.delete(id)
+            throw error
+          }
+        } },
+        views: { broadcast: message => request('views.broadcast', message), open: (type, options = {}) => request('views.open', { type, resource: options.resource ?? null, state: options.state ?? {} }) },
+        placements: { show: (id, options) => request('placements.show', { id, ...(typeof options === 'string' ? { instanceId: options } : options ?? {}) }), hide: (id, options) => request('placements.hide', { id, ...(typeof options === 'string' ? { instanceId: options } : options ?? {}) }) },
         resources: { readText: resource => request('resources.readText', { id: resource.id }) },
         storage: { get: () => request('storage.get'), set: value => request('storage.set', { value, version: manifest.dataVersion }) },
         network: { get: url => request('network.get', { url }) },
@@ -61,6 +95,8 @@ bridge.subscribe(async ({ id, method, params }) => {
           throw new Error('EXTENSION_ENTRY_INVALID')
         await entry.activate(context)
       }
+      if (registrationError)
+        throw registrationError
       if (manifest.contributes.commands.some(command => !commands.has(command.id)))
         throw new Error('EXTENSION_COMMAND_MISSING')
       activated = true
@@ -68,9 +104,19 @@ bridge.subscribe(async ({ id, method, params }) => {
     else if (method === 'command') {
       if (!activated || !commands.has(params.command))
         throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
-      result = await commands.get(params.command)(Object.freeze({ resource: params.resource, arguments: params.arguments ?? null })) ?? null
+      result = await commands.get(params.command)(Object.freeze({ resource: params.resource, arguments: params.arguments ?? null, invocation: params.invocation ?? null })) ?? null
+    }
+    else if (method === 'panes') {
+      applyPanes(params.panes)
+    }
+    else if (method === 'interactionEnded') {
+      interactions.get(params.id)?.abort()
+      interactions.delete(params.id)
     }
     else if (method === 'deactivate') {
+      for (const controller of interactions.values()) controller.abort()
+      interactions.clear()
+      paneListeners.clear()
       activated = false
       try {
         await entry?.deactivate?.()
diff --git a/apps/buddy/electron/main/extensions/runtime/view.js b/apps/buddy/electron/main/extensions/runtime/view.js
index 027075ef..e9dc0228 100644
--- a/apps/buddy/electron/main/extensions/runtime/view.js
+++ b/apps/buddy/electron/main/extensions/runtime/view.js
@@ -13,6 +13,9 @@ let mount = null
 let anchor = null
 let control = null
 let overlay = false
+let interactionId = null
+const activationListeners = new Set()
+const messageListeners = new Set()
 const environmentListeners = new Set()
 const mountListeners = new Set()
 const anchorListeners = new Set()
@@ -47,6 +50,14 @@ addEventListener('message', (event) => {
     parent.postMessage({ channel: 'lexora-extension', token, pong: data.ping }, '*')
     return
   }
+  if (data.activation) {
+    for (const listener of activationListeners) listener(Object.freeze(data.activation))
+    return
+  }
+  if (Object.hasOwn(data, 'message')) {
+    for (const listener of messageListeners) listener(data.message)
+    return
+  }
   if (data.workbench) {
     applyWorkbench(data.workbench)
     return
@@ -91,6 +102,10 @@ addEventListener('message', (event) => {
   else item.reject(new Error(data.value))
 })
 addEventListener('keydown', (event) => {
+  if (interactionId && event.isTrusted && event.key === 'Escape') {
+    event.preventDefault()
+    parent.postMessage({ channel: 'lexora-extension', token, endInteraction: true }, '*')
+  }
   if (control && event.isTrusted && event.key === 'Escape')
     parent.postMessage({ channel: 'lexora-extension', token, dismiss: true }, '*')
 })
@@ -104,11 +119,12 @@ addEventListener('pagehide', () => {
 async function initialize() {
   try {
     const initial = await request('bootstrap')
+    interactionId = initial.interactionId
     overlay = initial.presentation === 'decoration'
     anchor = initial.anchor ?? anchor
     mount = initial.mount ?? mount
     control = initial.control
-    if (overlay || initial.presentation === 'control' || initial.location === 'mount') {
+    if (overlay || initial.presentation === 'control' || initial.presentation === 'slot' || initial.location === 'mount') {
       const style = document.createElement('style')
       style.textContent = 'html,body{height:100%;background:transparent}body>main{height:100%;box-sizing:border-box;padding:0}'
       document.head.append(style)
@@ -131,6 +147,9 @@ async function initialize() {
     }
     const api = Object.freeze({
       apiVersion: initial.apiVersion,
+      instanceId: initial.instanceId,
+      interaction: interactionId ? Object.freeze({ id: interactionId, setRegions: regions => request('interaction.setRegions', regions), onActivate: listener => subscribe(activationListeners, listener) }) : null,
+      onMessage: listener => subscribe(messageListeners, listener),
       get workbench() { return workbench },
       onWorkbenchChange: listener => subscribe(workbenchListeners, listener),
       get visible() { return visible },
diff --git a/apps/buddy/electron/preload/extensions.ts b/apps/buddy/electron/preload/extensions.ts
index 42808127..fd1a0708 100644
--- a/apps/buddy/electron/preload/extensions.ts
+++ b/apps/buddy/electron/preload/extensions.ts
@@ -20,6 +20,10 @@ export function createExtensionApi(): ExtensionApi {
     devtools: id => request({ action: 'devtools', id }),
     revokeResources: id => request({ action: 'revokeResources', id }),
     execute: (id, command, resource) => request({ action: 'execute', id, command, resource }),
+    executeMenu: (id, menu, invocation) => request({ action: 'executeMenu', id, menu, invocation }),
+    executeSlash: (id, command, argumentsText, instanceId) => request({ action: 'executeSlash', id, command, arguments: argumentsText, instanceId }),
+    updatePanes: panes => request({ action: 'updatePanes', panes }),
+    endInteraction: id => request({ action: 'endInteraction', id }),
     openView: view => request({ action: 'openView', view }),
     closeView: (viewId, generation, token) => request({ action: 'closeView', viewId, generation, token }),
     viewRequest: (viewId, generation, token, method, params) => request({ action: 'viewRequest', viewId, generation, token, method, params }),
diff --git a/apps/buddy/extensions/README.md b/apps/buddy/extensions/README.md
index 3003ebc7..779799b2 100644
--- a/apps/buddy/extensions/README.md
+++ b/apps/buddy/extensions/README.md
@@ -32,4 +32,4 @@ API 1 不开放 Node、shell 或任意 Desktop API。文件只读，仅能访问
 
 需要独立开发窗口时，先构建 Electron，再运行 `node extensions/tools.mjs dev /path/to/plugin`。开发窗口使用单独的临时配置；修改后重新加载构建目录并重启扩展。SDK 快照可以通过 `node extensions/tools.mjs export-sdk /path/to/plugin-sdk/sdk` 导出。
 
-API 2 通过 `contributes.placements` 将视图挂到输入框或侧边栏装饰、工作台顶部/底部面板，以及用户选择的思考等级控件。内容仍在隔离视图运行；宿主提供锚点几何、允许的控件值与生命周期。清单和调用示例见 [插件协议](../service/resources/skills/plugin-creator/references/protocol.md)。API 1 插件继续可用。
+API 2 通过 `contributes.placements` 提供装饰、工作台面板与思考等级控件。API 3 增加可选择的内容区、操作菜单、独立分屏挂载、带插件命名空间的输入命令与可取消交互。创作时用 `lexora_plugin_capabilities` 按需查询当前宿主支持的位置。内容仍在隔离视图运行；清单和调用示例见 [插件协议](../service/resources/skills/plugin-creator/references/protocol.md)。旧版插件继续可用。
diff --git a/apps/buddy/extensions/sdk/authoring.ts b/apps/buddy/extensions/sdk/authoring.ts
index 6d35c12d..3810799d 100644
--- a/apps/buddy/extensions/sdk/authoring.ts
+++ b/apps/buddy/extensions/sdk/authoring.ts
@@ -1,3 +1,4 @@
 export { compileExtensionSource } from '../../platform/extensions/compileExtensionSource'
 export { extensionIconUrl } from '../../platform/extensions/extensionIcon'
 export { extensionManifestSchema, extensionPathSchema } from '../../shared/extensions/extensionManifest'
+export { queryWorkbenchCapabilities, workbenchCapabilityQuerySchema } from '../../shared/workbench/workbenchUi'
diff --git a/apps/buddy/platform/extensions/ExtensionService.ts b/apps/buddy/platform/extensions/ExtensionService.ts
index 88b8e6f5..739f1604 100644
--- a/apps/buddy/platform/extensions/ExtensionService.ts
+++ b/apps/buddy/platform/extensions/ExtensionService.ts
@@ -1,7 +1,8 @@
-import type { ExtensionResource, ExtensionStatus, ExtensionViewInput, ExtensionViewSession, ExtensionWorkbenchEvent } from '../../shared/extensions/extensionApi'
+import type { ExtensionMenuInvocation, ExtensionResource, ExtensionStatus, ExtensionViewInput, ExtensionViewSession, ExtensionWorkbenchEvent } from '../../shared/extensions/extensionApi'
 import type { ExtensionInspection } from '../../shared/extensions/extensionAuthoring'
 import type { ExtensionResourceSelection } from '../../shared/extensions/extensionResources'
 import type { SpaceFileTarget } from '../../shared/spaces/spaceFileApi'
+import type { WorkbenchPaneSnapshot } from '../../shared/workbench/workbenchInteraction'
 import type { JsonValue } from '../../shared/workbench/workbenchState'
 import type { ExtensionCompiler } from './compileExtensionSource'
 import type { ExtensionPackage, ExtensionPackageStore } from './ExtensionPackageStore'
@@ -10,9 +11,11 @@ import { basename } from 'node:path'
 import { z } from 'zod'
 import { extensionError, extensionJsonSchema, extensionResourceSchema } from '../../shared/extensions/extensionApi'
 import { EXTENSION_CATALOG_URL } from '../../shared/extensions/extensionCatalog'
+import { extensionCommandNamespace } from '../../shared/extensions/extensionCommands'
 import { extensionCompatible, extensionManifestSchema } from '../../shared/extensions/extensionManifest'
 import { extensionDirectoryScanSchema, extensionResourceSelectionSchema } from '../../shared/extensions/extensionResources'
 import { extensionNotificationSchema, extensionScheduleIdSchema, extensionScheduleInputSchema } from '../../shared/extensions/extensionSchedule'
+import { workbenchHitRegionsSchema } from '../../shared/workbench/workbenchInteraction'
 import { controlProposalSchema, extensionPresentationRequestSchema } from '../../shared/workbench/workbenchUi'
 import { publicWebUrl, readResponseBytes } from '../network/publicWebTransport'
 import { ExtensionCatalogService } from './ExtensionCatalogService'
@@ -47,6 +50,7 @@ interface RunningExtension {
   ready: Promise<void>
   active: boolean
   inFlight: number
+  panesPending?: boolean
 }
 interface RunningView {
   input: ExtensionViewInput
@@ -71,6 +75,8 @@ export class ExtensionService {
   readonly #views = new Map<string, RunningView>()
   readonly #diagnostics = new Map<string, Pick<ExtensionStatus, 'error' | 'activationMs' | 'logs'>>()
   readonly #notificationTimes = new Map<string, number>()
+  readonly #interactions = new Map<string, { running: RunningExtension, title: string, abort: AbortController }>()
+  #panes: WorkbenchPaneSnapshot[] = []
   #loading: Promise<void> | undefined
   #mutating = Promise.resolve()
   #compiling = Promise.resolve()
@@ -271,17 +277,80 @@ export class ExtensionService {
 
   async execute(id: string, command: string, target: SpaceFileTarget | null): Promise<void> {
     const running = await this.#activate(id)
+    await this.#executeCommand(running, command, target)
+  }
+
+  updatePanes(panes: WorkbenchPaneSnapshot[]): void {
+    this.#panes = panes
+    for (const running of this.#running.values()) {
+      if (running.active)
+        this.#publishPanes(running)
+    }
+  }
+
+  #publishPanes(running: RunningExtension): void {
+    if (running.package.manifest.apiVersion < 3 || running.panesPending || running.abort.signal.aborted)
+      return
+    const panes = this.#panes
+    running.panesPending = true
+    void running.host.call('panes', { panes }).catch(() => {}).finally(() => {
+      running.panesPending = false
+      if (panes !== this.#panes)
+        this.#publishPanes(running)
+    })
+  }
+
+  async executeSlash(id: string, command: string, argumentsText: string, instanceId?: string): Promise<JsonValue> {
+    const running = await this.#activate(id)
+    const contribution = running.package.manifest.contributes.commands.find(item => item.id === command)
+    if (!contribution?.slash || contribution.hidden)
+      throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
+    if (instanceId && !this.#panes.some(pane => pane.id === instanceId && pane.visible))
+      throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
+    return this.#executeCommand(running, command, null, { target: 'slash', instanceId: instanceId ?? null }, argumentsText)
+  }
+
+  async endInteraction(id: string): Promise<void> {
+    const interaction = this.#interactions.get(id)
+    if (!interaction)
+      return
+    this.#interactions.delete(id)
+    interaction.abort.abort()
+    for (const [viewId, view] of this.#views) {
+      if (view.input.interactionId === id) {
+        view.dispose()
+        this.#views.delete(viewId)
+      }
+    }
+    const { running } = interaction
+    const removing = this.#ports.workbench({ kind: 'interaction', requestId: randomUUID(), extensionId: running.package.manifest.id, generation: running.generation, interactionId: id, title: null }, AbortSignal.timeout(10000))
+    if (!running.abort.signal.aborted)
+      void running.host.call('interactionEnded', { id }).catch(() => {})
+    await removing
+  }
+
+  async executeMenu(id: string, menuId: string, input: ExtensionMenuInvocation): Promise<JsonValue> {
+    const running = await this.#activate(id)
+    const menu = running.package.manifest.contributes.menus.find(menu => menu.id === menuId && menu.target === input.target)
+    if (!menu)
+      throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
+    const invocation = { target: input.target, instanceId: input.instanceId ?? null, ...(running.package.manifest.permissions.selectedContent && ['composer.actions', 'message.actions'].includes(input.target) && input.content !== undefined ? { content: input.content } : {}) }
+    return this.#executeCommand(running, menu.command, input.target === 'resource.actions' ? input.resource : null, invocation)
+  }
+
+  async #executeCommand(running: RunningExtension, command: string, target: SpaceFileTarget | null, invocation: JsonValue = null, argumentsValue: JsonValue = null): Promise<JsonValue> {
     if (!running.package.manifest.contributes.commands.some(item => item.id === command))
       throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
     let resource: ExtensionResource | null = null
     if (target && running.package.manifest.permissions.selectedResource === 'read') {
       await this.#ports.readText(target, running.abort.signal)
       this.#assertCurrent(running)
-      resource = await this.store.grant(id, target)
+      resource = await this.store.grant(running.package.manifest.id, target)
     }
     this.#assertCurrent(running)
-    await running.host.call('command', { command, resource, arguments: null })
+    const result = await running.host.call('command', { command, resource, arguments: argumentsValue, invocation })
     this.#assertCurrent(running)
+    return extensionJsonSchema.parse(result)
   }
 
   async openView(input: ExtensionViewInput): Promise<ExtensionViewSession> {
@@ -296,9 +365,20 @@ export class ExtensionService {
         throw new Error('EXTENSION_PLACEMENT_UNAVAILABLE')
       if (view.resource === 'selected-file' && !input.resource)
         throw new Error('EXTENSION_RESOURCE_REQUIRED')
+      if (input.interactionId) {
+        const interaction = this.#interactions.get(input.interactionId)
+        const placement = running.package.manifest.contributes.placements.find(item => item.id === input.placementId)
+        if (interaction?.running !== running || placement?.kind !== 'view' || !placement.interaction)
+          throw new Error('EXTENSION_INTERACTION_ENDED')
+      }
+      else if (running.package.manifest.contributes.placements.some(item => item.id === input.placementId && item.kind === 'view' && item.interaction)) {
+        throw new Error('EXTENSION_INTERACTION_REQUIRED')
+      }
       if (input.resource)
         await this.#resource(running, input.resource.id)
       this.#assertCurrent(running)
+      if (input.interactionId && !this.#interactions.has(input.interactionId))
+        throw new Error('EXTENSION_INTERACTION_ENDED')
       if (this.#viewOpenings.get(input.viewId) !== request)
         throw new Error('EXTENSION_VIEW_EXPIRED')
       const old = this.#views.get(input.viewId)
@@ -338,7 +418,7 @@ export class ExtensionService {
     const placement = view.running.package.manifest.contributes.placements.find(placement => placement.id === view.input.placementId)
     let result: JsonValue
     if (method === 'bootstrap') {
-      result = { apiVersion: view.running.package.manifest.apiVersion, entry: contribution.entry, location: placement?.kind === 'view' ? 'mount' : contribution.location, presentation: placement?.kind ?? (contribution.location === 'window-overlay' ? 'decoration' : 'view'), resource: view.input.resource, state: view.input.state, stateVersion: view.input.stateVersion, expectedStateVersion: contribution.stateVersion }
+      result = { apiVersion: view.running.package.manifest.apiVersion, instanceId: view.input.instanceId ?? null, interactionId: view.input.interactionId ?? null, interactionMode: placement?.kind === 'view' ? placement.interaction ?? null : null, entry: contribution.entry, location: placement?.kind === 'view' ? 'mount' : contribution.location, presentation: placement?.kind ?? (contribution.location === 'window-overlay' ? 'decoration' : 'view'), resource: view.input.resource, state: view.input.state, stateVersion: view.input.stateVersion, expectedStateVersion: contribution.stateVersion }
     }
     else if (method === 'view.setState') {
       if (contribution.location !== 'context' || (placement && placement.kind !== 'view'))
@@ -363,6 +443,8 @@ export class ExtensionService {
       if (placement?.kind !== 'view')
         throw new Error('EXTENSION_METHOD_DENIED')
       const presentation = extensionPresentationRequestSchema.parse(params)
+      if (placement.interaction && ((presentation.target && !['workbench', 'workbench.pane'].includes(presentation.target)) || presentation.position === 'static'))
+        throw new Error('EXTENSION_METHOD_DENIED')
       const saved = await this.#ports.workbench({ kind: 'presentation', requestId: randomUUID(), viewId: id, generation, token, presentation }, view.running.abort.signal)
       if (saved !== id)
         throw new Error('EXTENSION_PRESENTATION_FAILED')
@@ -495,11 +577,20 @@ export class ExtensionService {
         else { throw new Error('EXTENSION_METHOD_DENIED') }
       }
     }
+    else if (method === 'interaction.setRegions') {
+      if (placement?.kind !== 'view' || placement.interaction !== 'regions' || !view.input.interactionId || !this.#interactions.has(view.input.interactionId))
+        throw new Error('EXTENSION_METHOD_DENIED')
+      const regions = workbenchHitRegionsSchema.parse(params)
+      const saved = await this.#ports.workbench({ kind: 'regions', requestId: randomUUID(), viewId: id, generation, token, regions }, view.abort.signal)
+      if (!saved)
+        throw new Error('EXTENSION_VIEW_EXPIRED')
+      result = null
+    }
     else if (method === 'commands.execute') {
       const input = z.object({ command: z.string().max(180), arguments: extensionJsonSchema }).strict().parse(params)
       if (!view.running.package.manifest.contributes.commands.some(item => item.id === input.command))
         throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
-      result = extensionJsonSchema.parse(await view.running.host.call('command', { ...input, resource: view.input.resource }))
+      result = extensionJsonSchema.parse(await view.running.host.call('command', { ...input, resource: view.input.resource, invocation: { target: 'view', instanceId: view.input.instanceId ?? null } }))
     }
     else {
       if (method === 'resources.readText') {
@@ -543,17 +634,29 @@ export class ExtensionService {
       let running = this.#running.get(dependency)
       if (!running) {
         const pkg = this.store.installed[dependency]!.current
+        if (pkg.manifest.contributes.commands.some(command => command.slash) && [...this.#running.values()].some(other => other.package.manifest.contributes.commands.some(command => command.slash) && extensionCommandNamespace(other.package.manifest.id) === extensionCommandNamespace(dependency))) {
+          this.#log(dependency, 'activation.failed', 'EXTENSION_COMMAND_NAMESPACE_CONFLICT')
+          throw new Error('EXTENSION_COMMAND_NAMESPACE_CONFLICT')
+        }
         const generation = randomUUID()
         const abort = new AbortController()
-        const host = this.#ports.createHost(pkg, (method, params) => this.#brokerByGeneration(dependency, generation, method, params), () => this.#failed(dependency, generation))
+        let host: ExtensionHost
+        try {
+          host = this.#ports.createHost(pkg, (method, params) => this.#brokerByGeneration(dependency, generation, method, params), () => this.#failed(dependency, generation))
+        }
+        catch (error) {
+          this.#log(dependency, 'activation.failed', extensionError(error))
+          throw error
+        }
         running = { package: pkg, generation, abort, host, ready: Promise.resolve(), active: false, inFlight: 0 }
         this.#running.set(dependency, running)
         const start = performance.now()
         const instance = running
         this.#clearError(dependency)
-        running.ready = host.call('activate', { manifest: pkg.manifest }).then(() => {
+        running.ready = host.call('activate', { manifest: pkg.manifest, panes: pkg.manifest.apiVersion >= 3 ? this.#panes : [] }).then(() => {
           this.#assertCurrent(instance)
           instance.active = true
+          this.#publishPanes(instance)
           this.#log(dependency, 'activated', undefined, Math.round(performance.now() - start))
         }).catch(async (error: unknown) => {
           if (this.#running.get(dependency) === instance) {
@@ -647,12 +750,46 @@ export class ExtensionService {
         const { id: resource } = z.object({ id: z.string().uuid() }).strict().parse(params)
         result = await this.#ports.readText(await this.#resource(running, resource), running.abort.signal)
       }
+      else if (method === 'interactions.start') {
+        const input = z.object({ id: z.string().uuid(), title: z.string().min(1).max(100) }).strict().parse(params)
+        if (running.package.manifest.apiVersion < 3 || this.#interactions.has(input.id) || [...this.#interactions.values()].filter(item => item.running === running).length >= 4)
+          throw new Error('EXTENSION_INTERACTION_UNAVAILABLE')
+        const abort = new AbortController()
+        this.#interactions.set(input.id, { running, title: input.title, abort })
+        try {
+          const created = await this.#ports.workbench({ kind: 'interaction', requestId: randomUUID(), extensionId: id, generation: running.generation, interactionId: input.id, title: input.title }, AbortSignal.any([running.abort.signal, abort.signal]))
+          if (created !== input.id || abort.signal.aborted)
+            throw new Error('EXTENSION_INTERACTION_ENDED')
+        }
+        catch (error) {
+          await this.endInteraction(input.id).catch(() => {})
+          throw error
+        }
+        result = input.id
+      }
+      else if (method === 'interactions.end') {
+        const input = z.object({ id: z.string().uuid() }).strict().parse(params)
+        const interaction = this.#interactions.get(input.id)
+        if (interaction && interaction.running !== running)
+          throw new Error('EXTENSION_METHOD_DENIED')
+        await this.endInteraction(input.id)
+        result = null
+      }
+      else if (method === 'views.broadcast') {
+        if (running.package.manifest.apiVersion < 3)
+          throw new Error('EXTENSION_METHOD_DENIED')
+        await this.#ports.workbench({ kind: 'message', requestId: randomUUID(), extensionId: id, generation: running.generation, message: extensionJsonSchema.parse(params) }, running.abort.signal)
+        result = null
+      }
       else if (method === 'placements.show' || method === 'placements.hide') {
-        const input = z.object({ id: z.string().max(180) }).strict().parse(params)
+        const input = z.object({ id: z.string().max(180), instanceId: z.string().uuid().optional(), interactionId: z.string().uuid().optional() }).strict().parse(params)
         const placement = running.package.manifest.contributes.placements.find(placement => placement.id === input.id)
-        if (placement?.kind !== 'view')
+        if (placement?.kind !== 'view' || (input.instanceId && placement.target !== 'workbench.pane'))
           throw new Error('EXTENSION_PLACEMENT_UNAVAILABLE')
-        result = await this.#ports.workbench({ kind: 'placement', requestId: randomUUID(), extensionId: id, generation: running.generation, placementId: placement.id, visible: method === 'placements.show' }, running.abort.signal)
+        const interaction = input.interactionId ? this.#interactions.get(input.interactionId) : null
+        if (!!placement.interaction !== !!input.interactionId || (input.interactionId && interaction?.running !== running))
+          throw new Error('EXTENSION_INTERACTION_ENDED')
+        result = await this.#ports.workbench({ kind: 'placement', requestId: randomUUID(), extensionId: id, generation: running.generation, placementId: placement.id, visible: method === 'placements.show', ...(input.instanceId ? { instanceId: input.instanceId } : {}), ...(input.interactionId ? { interactionId: input.interactionId } : {}) }, interaction ? AbortSignal.any([running.abort.signal, interaction.abort.signal]) : running.abort.signal)
         if (method === 'placements.show' && !result)
           throw new Error('EXTENSION_VIEW_UNAVAILABLE')
       }
@@ -731,6 +868,10 @@ export class ExtensionService {
       return
     this.#running.delete(id)
     running.abort.abort()
+    for (const [interactionId, interaction] of this.#interactions) {
+      if (interaction.running === running)
+        void this.endInteraction(interactionId).catch(() => {})
+    }
     for (const [viewId, view] of this.#views) {
       if (view.running === running) {
         view.dispose()
diff --git a/apps/buddy/platform/extensions/__tests__/ExtensionPackageStore.spec.ts b/apps/buddy/platform/extensions/__tests__/ExtensionPackageStore.spec.ts
index 08dd7e11..5498a53c 100644
--- a/apps/buddy/platform/extensions/__tests__/ExtensionPackageStore.spec.ts
+++ b/apps/buddy/platform/extensions/__tests__/ExtensionPackageStore.spec.ts
@@ -5,7 +5,7 @@ import { join } from 'node:path'
 import { strToU8, zipSync } from 'fflate'
 import { afterEach, describe, expect, it } from 'vitest'
 import { extensionJsonSchema } from '../../../shared/extensions/extensionApi'
-import { extensionManifestSchema } from '../../../shared/extensions/extensionManifest'
+import { addedExtensionPermissions, extensionManifestSchema } from '../../../shared/extensions/extensionManifest'
 import { compileExtensionSource } from '../compileExtensionSource'
 import { readExtensionDirectory, unpackExtension } from '../extensionFiles'
 import { extensionActivationOrder, ExtensionPackageStore } from '../ExtensionPackageStore'
@@ -31,7 +31,7 @@ describe('extension package contract', () => {
   })
   it('rejects foreign contribution ownership, duplicate IDs, and unsupported API versions', () => {
     const value = manifest()
-    expect(extensionManifestSchema.safeParse({ ...value, apiVersion: 3 }).success).toBe(false)
+    expect(extensionManifestSchema.safeParse({ ...value, apiVersion: 4 }).success).toBe(false)
     expect(extensionManifestSchema.safeParse({ ...value, contributes: { ...value.contributes, commands: [{ id: 'another.reader.open', title: 'Open' }] } }).success).toBe(false)
     expect(extensionManifestSchema.safeParse({ ...value, contributes: { ...value.contributes, commands: [value.contributes.commands[0], value.contributes.commands[0]] } }).success).toBe(false)
   })
@@ -202,3 +202,58 @@ it('keeps API 1 compatible and validates UI placements and permission upgrades i
   }
   expect(extensionManifestSchema.safeParse({ ...value, contributes: { ...value.contributes, views: [{ ...value.contributes.views[0], resource: 'selected-file' }] }, permissions: { ...value.permissions, selectedResource: 'read' } }).success).toBe(false)
 })
+
+it('requires API 3 and a bounded declaration for a content slot', () => {
+  const value = manifest({
+    apiVersion: 3,
+    id: 'tests.footer',
+    contributes: {
+      views: [{ id: 'tests.footer.content', title: 'Footer', entry: 'view.js', resource: 'none' }],
+      placements: [{ id: 'tests.footer.slot', kind: 'slot', target: 'composer.footer', view: 'tests.footer.content' }],
+    },
+  })
+  const previous = manifest({ id: 'tests.footer', apiVersion: 2, contributes: { views: [] } })
+  expect(addedExtensionPermissions(previous.permissions, value.permissions)).toEqual([])
+  expect(extensionManifestSchema.safeParse({ ...value, apiVersion: 2 }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...value, contributes: { ...value.contributes, placements: [{ ...value.contributes.placements[0], presentation: { position: 'absolute' } }] } }).success).toBe(false)
+})
+
+it('validates each content target size and menu command ownership with API compatibility', () => {
+  const content = (target: string, height: number) => ({ id: 'tests.reader.content', kind: 'slot', target, height, view: 'tests.reader.view' })
+  const base = { schemaVersion: 1, id: 'tests.reader', name: 'Regions', version: '1.0.0', apiVersion: 3, engines: { lexora: '*' }, entry: 'extension.js', contributes: { commands: [{ id: 'tests.reader.run', title: 'Run' }], views: [{ id: 'tests.reader.view', title: 'View', entry: 'view.js', resource: 'none' }] } }
+  const parse = (placement: unknown) => extensionManifestSchema.safeParse({ ...base, contributes: { ...base.contributes, placements: [placement] } })
+  expect(parse(content('composer.footer', 64)).success).toBe(false)
+  expect(parse(content('composer.accessory', 64)).success).toBe(true)
+  expect(parse(content('task.welcome', 400)).success).toBe(true)
+  expect(parse(content('workbench.pane.empty', 641)).success).toBe(false)
+  expect(parse(content('arbitrary.selector', 64)).success).toBe(false)
+  const withMenu = { ...base, contributes: { ...base.contributes, menus: [{ id: 'tests.reader.menu', command: 'tests.reader.run', target: 'message.actions' }] } }
+  expect(extensionManifestSchema.safeParse(withMenu).success).toBe(true)
+  expect(extensionManifestSchema.safeParse({ ...withMenu, apiVersion: 2 }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...withMenu, contributes: { ...withMenu.contributes, commands: [] } }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...base, apiVersion: 2, permissions: { selectedContent: true } }).success).toBe(false)
+  const previous = manifest()
+  const next = manifest({ apiVersion: 3, permissions: { selectedResource: 'read', selectedContent: true } })
+  expect(addedExtensionPermissions(previous.permissions, next.permissions)).toEqual(['selectedContent'])
+})
+
+it('validates ASCII command names while allowing localized descriptions and system names inside plugin namespaces', () => {
+  const base = manifest({ apiVersion: 3, contributes: { commands: [{ id: 'tests.reader.run', title: 'Run', slash: { name: 'read-file' } }] } })
+  const command = base.contributes.commands[0]!
+  for (const name of ['/read', 'Read', '读取', 'café', 'read file', 'read:1', '-read', 'read\u202E', '', 'a'.repeat(65)]) {
+    expect(extensionManifestSchema.safeParse({ ...base, contributes: { commands: [{ ...command, slash: { name } }] } }).success, name).toBe(false)
+  }
+  for (const name of ['read-file', 'compact', 'review', 'start-2'])
+    expect(extensionManifestSchema.safeParse({ ...base, contributes: { commands: [{ ...command, slash: { name } }] } }).success, name).toBe(true)
+  expect(extensionManifestSchema.safeParse({ ...base, apiVersion: 2 }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...base, contributes: { commands: [{ ...command, hidden: true }] } }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...base, contributes: { commands: [command, { ...command, id: 'tests.reader.other' }] } }).success).toBe(false)
+})
+
+it('restricts transient interactions to absolute API 3 workbench and pane mounts', () => {
+  const base = manifest({ apiVersion: 3, contributes: { views: [{ id: 'tests.reader.game', title: 'Game', entry: 'view.js', resource: 'none' }], placements: [{ id: 'tests.reader.layer', view: 'tests.reader.game', kind: 'view', target: 'workbench', interaction: 'regions', presentation: { position: 'absolute' } }] } })
+  expect(extensionManifestSchema.safeParse({ ...base, apiVersion: 2 }).success).toBe(false)
+  for (const target of ['app.sidebar', 'workbench.sidebar'])
+    expect(extensionManifestSchema.safeParse({ ...base, contributes: { ...base.contributes, placements: [{ ...base.contributes.placements[0], target }] } }).success).toBe(false)
+  expect(extensionManifestSchema.safeParse({ ...base, contributes: { ...base.contributes, placements: [{ ...base.contributes.placements[0], presentation: { position: 'static' } }] } }).success).toBe(false)
+})
diff --git a/apps/buddy/platform/extensions/__tests__/ExtensionService.spec.ts b/apps/buddy/platform/extensions/__tests__/ExtensionService.spec.ts
index 63d54916..6981a73c 100644
--- a/apps/buddy/platform/extensions/__tests__/ExtensionService.spec.ts
+++ b/apps/buddy/platform/extensions/__tests__/ExtensionService.spec.ts
@@ -40,7 +40,7 @@ async function fixture(overrides: Partial<ExtensionServicePorts> = {}) {
     createView: () => ({ token: randomUUID(), url: 'lexora-extension://fixture/__view.html', dispose: () => {} }),
     workbench: async (event) => {
       events.push(event)
-      return event.kind === 'state' ? event.viewId : randomUUID()
+      return event.kind === 'interaction' ? event.interactionId : event.kind === 'state' || event.kind === 'regions' ? event.viewId : randomUUID()
     },
     readText: async target => `Content of ${target.path}`,
     get: async () => new Response('network'),
@@ -204,6 +204,22 @@ it('authorizes each placement and control request against its own live view sess
   await expect(service.viewRequest(session.id, session.generation, session.token, 'control.propose', proposal)).rejects.toThrow('EXTENSION_VIEW_EXPIRED')
 })
 
+it('keeps a content slot limited to its selected view surface', async () => {
+  const { root, store, service, hosts } = await fixture()
+  const value = manifest({ apiVersion: 3, id: 'tests.footer', contributes: {
+    views: [{ id: 'tests.footer.content', title: 'Footer', entry: 'view.js', resource: 'none' }],
+    placements: [{ id: 'tests.footer.slot', view: 'tests.footer.content', kind: 'slot', target: 'composer.footer' }],
+  } })
+  await service.install((await reviewPackage(root, store, value)).token)
+  const session = await service.openView({ viewId: randomUUID(), extensionId: value.id, viewType: 'tests.footer.content', placementId: 'tests.footer.slot', resource: null, state: null, stateVersion: 0 })
+  const request = (method: string, params: JsonValue) => service.viewRequest(session.id, session.generation, session.token, method, params)
+  expect(await request('bootstrap', null)).toEqual(expect.objectContaining({ apiVersion: 3, presentation: 'slot' }))
+  await expect(request('view.setState', {})).rejects.toThrow('EXTENSION_METHOD_DENIED')
+  await expect(request('view.setPresentation', { height: 200 })).rejects.toThrow('EXTENSION_METHOD_DENIED')
+  await expect(request('control.propose', { revision: randomUUID(), value: 'high' })).rejects.toThrow('EXTENSION_METHOD_DENIED')
+  await expect(hosts[0]!.broker('placements.show', { id: 'tests.footer.slot' })).rejects.toThrow('EXTENSION_PLACEMENT_UNAVAILABLE')
+})
+
 it('does not let an older concurrent open replace a newer view endpoint', async () => {
   const { store, service } = await fixture()
   const resource = await store.grant('tests.reader', target)
@@ -312,3 +328,129 @@ it('keeps export permission separate from reads and expires writers with their o
   await expect(request('resources.commitSave', { id })).rejects.toThrow('EXTENSION_VIEW_EXPIRED')
   expect(await readFile(destination, 'utf8')).toBe('original')
 })
+
+it.each([false, true])('limits menu invocation to user-selected content with permission %s', async (selectedContent) => {
+  const { root, store, service, hosts } = await fixture()
+  const value = manifest({ apiVersion: 3, id: 'tests.actions', permissions: { selectedContent, selectedResource: 'read' }, contributes: {
+    commands: [{ id: 'tests.actions.run', title: 'Run', hidden: true }],
+    menus: ['composer', 'message', 'task', 'resource'].map(kind => ({ id: `tests.actions.${kind}`, command: 'tests.actions.run', target: `${kind}.actions` as 'composer.actions' | 'message.actions' | 'task.actions' | 'resource.actions' })),
+    views: [{ id: 'tests.actions.view', title: 'View', entry: 'view.js', resource: 'none' }],
+  } })
+  await service.install((await reviewPackage(root, store, value)).token)
+  const instanceId = randomUUID()
+  await service.executeMenu(value.id, 'tests.actions.composer', { target: 'composer.actions', instanceId, content: 'Selected draft', resource: target })
+  expect(hosts[0]!.commands.at(-1)).toEqual({ command: 'tests.actions.run', resource: null, arguments: null, invocation: { target: 'composer.actions', instanceId, ...(selectedContent ? { content: 'Selected draft' } : {}) } })
+  await service.executeMenu(value.id, 'tests.actions.task', { target: 'task.actions', instanceId, content: 'Unrelated text', resource: target })
+  expect(hosts[0]!.commands.at(-1)).toMatchObject({ resource: null, invocation: { target: 'task.actions', instanceId } })
+  expect(JSON.stringify(hosts[0]!.commands.at(-1))).not.toContain('Unrelated text')
+  await service.executeMenu(value.id, 'tests.actions.resource', { target: 'resource.actions', instanceId, content: 'Unrelated text', resource: target })
+  const fileCommand = hosts[0]!.commands.at(-1) as { resource: { id: string, name: string } }
+  expect(fileCommand.resource).toEqual({ id: expect.any(String), name: 'README.md' })
+  expect(await hosts[0]!.broker('resources.readText', { id: fileCommand.resource.id })).toBe('Content of README.md')
+  await expect(service.executeMenu(value.id, 'tests.actions.composer', { target: 'message.actions', resource: null })).rejects.toThrow('EXTENSION_COMMAND_UNAVAILABLE')
+  const session = await service.openView({ viewId: randomUUID(), extensionId: value.id, instanceId, viewType: 'tests.actions.view', resource: null, state: {}, stateVersion: 1 })
+  await service.viewRequest(session.id, session.generation, session.token, 'commands.execute', { command: 'tests.actions.run', arguments: null })
+  expect(hosts[0]!.commands.at(-1)).toEqual({ command: 'tests.actions.run', arguments: null, resource: null, invocation: { target: 'view', instanceId } })
+  await expect(service.viewRequest(session.id, session.generation, session.token, 'commands.execute', { command: 'tests.actions.run', arguments: null, invocation: { target: 'composer.actions', content: 'forged' } })).rejects.toThrow()
+})
+
+it('carries pane identity through scoped placement requests and rejects scope on global mounts', async () => {
+  const { root, store, service, hosts, events } = await fixture()
+  const value = manifest({ apiVersion: 3, id: 'tests.panes', contributes: {
+    views: [{ id: 'tests.panes.view', title: 'Pane', entry: 'view.js', resource: 'none' }],
+    placements: [
+      { id: 'tests.panes.local', kind: 'view', target: 'workbench.pane', view: 'tests.panes.view' },
+      { id: 'tests.panes.global', kind: 'view', target: 'workbench', view: 'tests.panes.view' },
+    ],
+  } })
+  await service.install((await reviewPackage(root, store, value)).token)
+  const instanceId = randomUUID()
+  const session = await service.openView({ viewId: randomUUID(), extensionId: value.id, viewType: 'tests.panes.view', instanceId, placementId: 'tests.panes.local', resource: null, state: {}, stateVersion: 1 })
+  expect(await service.viewRequest(session.id, session.generation, session.token, 'bootstrap', null)).toMatchObject({ instanceId })
+  await hosts[0]!.broker('placements.show', { id: 'tests.panes.local', instanceId })
+  await hosts[0]!.broker('placements.hide', { id: 'tests.panes.local', instanceId })
+  expect(events).toEqual([
+    expect.objectContaining({ kind: 'placement', instanceId, visible: true }),
+    expect.objectContaining({ kind: 'placement', instanceId, visible: false }),
+  ])
+  await expect(hosts[0]!.broker('placements.show', { id: 'tests.panes.global', instanceId })).rejects.toThrow('EXTENSION_PLACEMENT_UNAVAILABLE')
+})
+
+async function interactionFixture() {
+  const f = await fixture()
+  const value = manifest({ apiVersion: 3, id: 'tests.game', contributes: {
+    commands: [{ id: 'tests.game.start', title: 'Start', slash: { name: 'game-start' } }],
+    views: [{ id: 'tests.game.view', title: 'Game', entry: 'view.js', resource: 'none' }],
+    placements: [{ id: 'tests.game.layer', kind: 'view', view: 'tests.game.view', target: 'workbench', interaction: 'regions', presentation: { position: 'absolute', width: '100%', height: '100%' } }],
+  } })
+  await f.service.install((await reviewPackage(f.root, f.store, value)).token)
+  await f.service.execute(value.id, 'tests.game.start', null)
+  return { ...f, broker: f.hosts[0]!.broker, input: { extensionId: value.id, viewId: randomUUID(), viewType: 'tests.game.view', placementId: 'tests.game.layer', resource: null, state: {}, stateVersion: 1 } }
+}
+
+it('passes explicit slash arguments and origin only, and rejects obsolete panes', async () => {
+  const f = await interactionFixture()
+  const pane = { id: randomUUID(), active: true, visible: true, rect: { x: 0, y: 0, width: 300, height: 400 } }
+  f.service.updatePanes([pane])
+  await f.service.executeSlash('tests.game', 'tests.game.start', 'level=2', pane.id)
+  expect(f.hosts[0]!.commands.at(-1)).toEqual({ command: 'tests.game.start', resource: null, arguments: 'level=2', invocation: { target: 'slash', instanceId: pane.id } })
+  f.service.updatePanes([{ ...pane, visible: false }])
+  await expect(f.service.executeSlash('tests.game', 'tests.game.start', '', pane.id)).rejects.toThrow('EXTENSION_COMMAND_UNAVAILABLE')
+  await expect(f.service.executeSlash('tests.reader', 'tests.reader.open', '')).rejects.toThrow('EXTENSION_COMMAND_UNAVAILABLE')
+})
+
+it('allows the same local name in different plugin namespaces without sharing handlers', async () => {
+  const f = await interactionFixture()
+  const value = manifest({ id: 'tests.other', apiVersion: 3, contributes: { commands: [{ id: 'tests.other.start', title: 'Start', slash: { name: 'game-start' } }] } })
+  await f.service.install((await reviewPackage(f.root, f.store, value)).token)
+  await f.service.executeSlash(value.id, 'tests.other.start', 'second')
+  await f.service.executeSlash('tests.game', 'tests.game.start', 'first')
+  expect((await f.service.list()).filter(item => item.state === 'active').map(item => item.manifest.id).sort()).toEqual(['tests.game', 'tests.other'])
+  expect(f.hosts[0]!.commands.at(-1)).toMatchObject({ command: 'tests.game.start', arguments: 'first' })
+  expect(f.hosts[1]!.commands.at(-1)).toMatchObject({ command: 'tests.other.start', arguments: 'second' })
+})
+
+it('requires an owned live interaction and immediately revokes its views on exit', async () => {
+  const f = await interactionFixture()
+  await expect(f.service.openView(f.input)).rejects.toThrow('EXTENSION_INTERACTION_REQUIRED')
+  const id = randomUUID()
+  await f.broker('interactions.start', { id, title: 'Game' })
+  await f.broker('placements.show', { id: 'tests.game.layer', interactionId: id })
+  const view = await f.service.openView({ ...f.input, interactionId: id })
+  const request = (method: string, params: JsonValue) => f.service.viewRequest(view.id, view.generation, view.token, method, params)
+  expect(await request('bootstrap', null)).toMatchObject({ interactionId: id, interactionMode: 'regions' })
+  await request('interaction.setRegions', [{ id: 'target', label: 'Hit target', rect: { x: 20, y: 20, width: 48, height: 48 } }])
+  await expect(request('interaction.setRegions', [{ id: 'target', label: '', rect: { x: 0, y: 0, width: -1, height: 20 } }])).rejects.toThrow()
+  await expect(request('view.setPresentation', { target: 'app.sidebar' })).rejects.toThrow('EXTENSION_METHOD_DENIED')
+  await f.service.execute('tests.reader', 'tests.reader.open', null)
+  await expect(f.hosts[1]!.broker('interactions.end', { id })).rejects.toThrow('EXTENSION_METHOD_DENIED')
+  await f.service.endInteraction(id)
+  await expect(request('bootstrap', null)).rejects.toThrow('EXTENSION_VIEW_EXPIRED')
+  await expect(f.broker('placements.show', { id: 'tests.game.layer', interactionId: id })).rejects.toThrow('EXTENSION_INTERACTION_ENDED')
+  await expect(f.service.openView({ ...f.input, interactionId: id })).rejects.toThrow('EXTENSION_INTERACTION_ENDED')
+  expect(f.events).toContainEqual(expect.objectContaining({ kind: 'interaction', interactionId: id, title: null }))
+})
+
+it('cancels interaction endpoints when the host stops and keeps broadcasts owned', async () => {
+  const f = await interactionFixture()
+  const id = randomUUID()
+  await f.broker('interactions.start', { id, title: 'Game' })
+  const view = await f.service.openView({ ...f.input, interactionId: id })
+  await f.broker('views.broadcast', { score: 3 })
+  expect(f.events).toContainEqual(expect.objectContaining({ kind: 'message', extensionId: 'tests.game', generation: view.generation, message: { score: 3 } }))
+  await f.service.enable('tests.game', false)
+  await expect(f.service.viewRequest(view.id, view.generation, view.token, 'bootstrap', null)).rejects.toThrow('EXTENSION_VIEW_EXPIRED')
+  expect(f.events).toContainEqual(expect.objectContaining({ kind: 'interaction', interactionId: id, title: null }))
+})
+
+it('rejects a duplicate plugin namespace and releases it when the original host stops', async () => {
+  const f = await interactionFixture()
+  const value = manifest({ id: 'other.game', apiVersion: 3, contributes: { commands: [{ id: 'other.game.run', title: 'Run', slash: { name: 'run' } }] } })
+  await f.service.install((await reviewPackage(f.root, f.store, value)).token)
+  await expect(f.service.executeSlash(value.id, 'other.game.run', '')).rejects.toThrow('EXTENSION_COMMAND_NAMESPACE_CONFLICT')
+  expect((await f.service.list()).find(item => item.manifest.id === 'tests.game')?.state).toBe('active')
+  await f.service.enable('tests.game', false)
+  await f.service.restart(value.id)
+  await f.service.executeSlash(value.id, 'other.game.run', '')
+  expect((await f.service.list()).find(item => item.manifest.id === value.id)?.state).toBe('active')
+})
diff --git a/apps/buddy/service/resources/skills/plugin-creator/SKILL.md b/apps/buddy/service/resources/skills/plugin-creator/SKILL.md
index 1d67984d..3ec4d581 100644
--- a/apps/buddy/service/resources/skills/plugin-creator/SKILL.md
+++ b/apps/buddy/service/resources/skills/plugin-creator/SKILL.md
@@ -19,6 +19,8 @@ description: 创建、修改并验证可安装的 Lexora 桌面插件，包括
 
 读取 [能力选择与组合](references/capabilities.md)，将需求对应到输入来源、呈现方式、运行入口与状态归属，再确定最小清单。一个插件可以组合多种正式扩展点，也可以只提供命令或一个文件视图；现有示例不是插件类别或必须复制的模板。
 
+查询宿主扩展能力时，通过 `lexora_tool_search` 查找 `lexora_plugin_capabilities`。先无参数查询当前宿主的简短目录，再按 `kind` 或 `target` 获取所需能力的契约；不要把完整目录提前塞进提示词。内容区的共同规则见 [内容插槽](references/slots.md)。没有匹配位置时说明能力缺口，不借助 CSS 选择器或相近区域模拟替换。
+
 先说明所选组合能完成的用户行为，再创作。文件阅读工具需要按文件打开的独立视图和各自的阅读状态；常驻信息条可能需要底部挂载、宿主查询命令与私有设置。不要因为都“有界面”就统一做导航页，也不要为了演示全部 API 给插件添加无关权限。
 
 ## 阅读协议并创作
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/api.d.ts b/apps/buddy/service/resources/skills/plugin-creator/references/api.d.ts
index ae0bcbe4..326b8849 100644
--- a/apps/buddy/service/resources/skills/plugin-creator/references/api.d.ts
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/api.d.ts
@@ -24,12 +24,24 @@ export interface ScheduleApi {
   set: (schedule: ScheduleInput) => Promise<Schedule>
   remove: (id: string) => Promise<void>
 }
+export interface CommandInvocation {
+  readonly target: 'composer.actions' | 'task.actions' | 'resource.actions' | 'message.actions' | 'view' | 'slash'
+  readonly instanceId: string | null
+  readonly content?: string
+}
+export interface Rect { readonly x: number, readonly y: number, readonly width: number, readonly height: number }
+export interface PaneSnapshot { readonly id: string, readonly active: boolean, readonly visible: boolean, readonly rect: Rect }
+export interface Interaction { readonly id: string, readonly signal: AbortSignal, end: () => Promise<void> }
+export interface PlacementOptions { instanceId?: string, interactionId?: string }
+export interface HitRegion { id: string, label: string, rect: Rect }
 export interface ExtensionContext {
-  readonly extension: { readonly id: string, readonly version: string, readonly apiVersion: 1 | 2 }
+  readonly extension: { readonly id: string, readonly version: string, readonly apiVersion: 1 | 2 | 3 }
   readonly subscriptions: { add: <T extends Disposable>(disposable: T) => T }
-  readonly commands: { register: (id: string, execute: (context: { resource: Resource | null, arguments: Json }) => Json | void | Promise<Json | void>) => Disposable }
-  readonly placements: { show: (id: string) => Promise<string>, hide: (id: string) => Promise<string | null> }
-  readonly views: { open: (type: string, options?: { resource?: Resource | null, state?: Json }) => Promise<string> }
+  readonly commands: { register: (id: string, execute: (context: { resource: Resource | null, arguments: Json, invocation: CommandInvocation | null }) => Json | void | Promise<Json | void>) => Disposable }
+  readonly placements: { show: (id: string, options?: string | PlacementOptions) => Promise<string>, hide: (id: string, options?: string | PlacementOptions) => Promise<string | null> }
+  readonly workbench: { readonly panes: readonly PaneSnapshot[], onPanesChange: (listener: (panes: readonly PaneSnapshot[]) => void) => Disposable }
+  readonly interactions: { start: (title: string) => Promise<Interaction> }
+  readonly views: { broadcast: (message: Json) => Promise<void>, open: (type: string, options?: { resource?: Resource | null, state?: Json }) => Promise<string> }
   readonly resources: ResourceApi
   readonly network: NetworkApi
   readonly storage: { get: () => Promise<Json>, set: (value: Json) => Promise<void> }
@@ -48,7 +60,7 @@ export interface ControlSnapshot {
   readonly options: readonly { readonly value: string, readonly label: string }[]
   readonly disabled: boolean
 }
-export type MountTarget = 'workbench' | 'app.sidebar' | 'workbench.sidebar'
+export type MountTarget = 'workbench' | 'app.sidebar' | 'workbench.sidebar' | 'workbench.pane'
 export type MountLength = number | `${number}%` | null
 export interface ViewPresentation {
   target?: MountTarget
@@ -63,6 +75,7 @@ export interface ViewPresentation {
   left?: MountLength
 }
 export interface MountGeometry {
+  readonly instanceId?: string
   readonly target: MountTarget
   readonly visible: boolean
   readonly width: number
@@ -76,6 +89,13 @@ export interface WorkbenchContextSnapshot {
   readonly pages: readonly { readonly id: string, readonly title: string }[]
 }
 export interface ViewContext {
+  readonly interaction: {
+    readonly id: string
+    setRegions: (regions: readonly HitRegion[]) => Promise<void>
+    onActivate: (listener: (event: { readonly id: string, readonly x: number, readonly y: number }) => void) => Disposable
+  } | null
+  onMessage: (listener: (message: Json) => void) => Disposable
+  readonly instanceId: string | null
   readonly workbench: WorkbenchContextSnapshot
   onWorkbenchChange: (listener: (snapshot: WorkbenchContextSnapshot) => void) => Disposable
   readonly visible: boolean
@@ -91,7 +111,7 @@ export interface ViewContext {
   } | null
   readonly environment: { language: string, colorScheme: 'light' | 'dark', colors: Record<string, string> }
   onEnvironmentChange: (listener: (environment: ViewContext['environment']) => void) => Disposable
-  readonly apiVersion: 1 | 2
+  readonly apiVersion: 1 | 2 | 3
   readonly resource: Resource | null
   readonly state: Json
   readonly stateVersion: number
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/capabilities.md b/apps/buddy/service/resources/skills/plugin-creator/references/capabilities.md
index fa88c89b..6fb80f6d 100644
--- a/apps/buddy/service/resources/skills/plugin-creator/references/capabilities.md
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/capabilities.md
@@ -5,9 +5,13 @@
 | 用户需要 | 清单与入口 | 状态和边界 |
 | --- | --- | --- |
 | 对当前文件提供阅读、统计或专用展示 | `selectedResource: "read"`；`resource: "selected-file"` 的视图；宿主可见命令将收到的 `resource` 传给 `views.open`，视图用 `resources.readText(context.resource)` 读取 | 用户先打开文件，再执行插件命令。句柄不包含任意路径，每次打开是独立实例；不能枚举目录、读其他视图的文件或写回文件 |
+| 输入 `/插件名:命令` 执行插件动作 | API 3 命令声明 `slash`，并在 `activate` 注册处理函数；见 [注册命令](commands.md) | 精确匹配，包内校验注册，跨插件命名空间隔离，不请求模型 |
+| 需要真实分屏布局或临时覆盖交互 | API 3；见 [交互会话](interactions.md) | 订阅布局；稀疏点击区域或独占交互；宿主提供独立退出入口 |
 | 执行一次动作，无需常驻页面 | 宿主 `activate` 注册 `contributes.commands` 中的命令 | 可见命令进入命令面板和已安装插件卡片的“运行命令”菜单；命令收到的 `resource` 可能为空。只供自己视图调用的命令设为 `hidden: true` |
 | 目录入口、较完整的页面或设置表单 | `contributes.navigation` 引用 `resource: "none"` 的视图 | API 2 可省略视图 `location`；页面由 `render` 绘制。需要持久配置时通过自身隐藏命令调用宿主私有存储 |
-| 将自定义内容挂到页面区域 | `kind: "view"`、`target` 与 `presentation`；宿主命令调用 `placements.show/hide` | 区域包括 `workbench`、`app.sidebar`、`workbench.sidebar`。插件渲染隔离内容，通过通用外框布局接口声明定位和尺寸。挂载口没有面板 UI 或交互 |
+| 将自定义内容挂到页面区域 | `kind: "view"`、`target` 与 `presentation`；宿主命令调用 `placements.show/hide` | 通过能力查询选择全局、页面或分屏目标。插件渲染隔离内容，通过通用外框布局接口声明定位和尺寸。挂载口没有面板 UI 或交互 |
+| 在业务区域执行操作 | `contributes.menus` 引用已声明命令；用能力查询选目标 | 输入、消息、文件或任务操作共享一套协议；仅点击时按权限提供所选内容，分屏标识固定到发起位置 |
+| 替换或追加宿主内容 | `kind: "slot"`；按需查 [内容插槽目录](slots.md) | 按目录的单选或多选策略由用户选择提供者；不可用时回退。位置和外框归宿主，插件只绘制自己的内容 |
 | 限定生效页面或响应页面变化 | 贡献的 `when`；视图的 `workbench/onWorkbenchChange` 与 `visible/onVisibilityChange` | 按稳定页面 ID 与公开上下文匹配；离开范围隐藏而保留实例，业务暂停或继续由插件决定。未知上下文不匹配，不读取父页面 DOM |
 | 自定义浮动内容或运行时换区域 | `presentation.position: "absolute"`；`setPresentation` 更新目标及外框 CSS 布局；`mount/onMountChange` 获取局部几何 | 拖动、折叠、恢复入口等由插件自行实现。宿主不理解这些行为，只维持独立实例、投影和边界；换位置保留会话，关闭销毁 |
 | 用户选择的文件或目录 | `localResources: true`；交互视图的 `resources.pickFiles/pickDirectory` | 返回不透明句柄；任意文件格式都可读取。以 `scanDirectory` 按需筛选授权目录，`readText/readBytes/getUrl` 分别用于文本、分段二进制和受控 URL；只保存 ID，URL 按视图重新获取 |
@@ -23,7 +27,7 @@
 ## 状态与模块
 
 - `activate(context)` 管理命令、私有设置、通知和定时任务；`render(context, container)` 管理自己的隔离 UI。只需要视图时不创建空宿主；需要命令时必须同时声明宿主入口和命令 ID。
-- 资源页签及普通挂载面板用 `ViewContext.state/setState` 保存该实例的筛选、阅读位置等 JSON。升级比较 `stateVersion` 与 `expectedStateVersion`，转换后再保存。导航页面、装饰和替换控件不支持这条持久化路径。
+- 资源页签及普通挂载面板用 `ViewContext.state/setState` 保存该实例的筛选、阅读位置等 JSON。升级比较 `stateVersion` 与 `expectedStateVersion`，转换后再保存。导航页面、装饰、内容插槽和替换控件不支持这条持久化路径。
 - 挂载目标和外框布局通过 `setPresentation` 更新；内容样式、交互及业务状态完全由插件实现，业务状态使用 `setState` 或宿主私有存储。宿主不会依据插件数量提供面板切换或自动避让。不能用父页面 CSS 选择器或 Vue Teleport 穿透隔离。
 - 扩展级配置用宿主 `storage.get/set`。视图通过自身命令读写，不访问宿主内存；更改数据结构时增加 `dataVersion` 并提供 `migrate`。不要把一个文件的阅读位置存成覆盖所有文件的全局值。
 - 每个视图具有独立 JS 环境。没有通用跨视图广播；需要设置同步时设计明确刷新入口或有界的读取周期，并在销毁时取消，不能承诺不存在的订阅事件。源码中的纯函数可通过包内相对导入复用。
@@ -33,4 +37,4 @@
 
 验收从用户行为出发，不以采用某个样例的文件名或界面作为成功依据。例如文件阅读工具应验证两份不同文件、空内容、各自筛选状态及重开恢复；网络信息条应验证允许来源、请求失败后的状态、关闭与再次显示；自定义控件应验证当前快照、禁用或隐藏时提交被拒绝，以及故障后内置控件可用。
 
-对每项需求明确已有 API 是否覆盖。没有任意插槽、父页面 DOM、静默覆写用户文件、通用 IPC 或 Agent 调用权限；核心要求超出已开放能力时先明确缺口与可实现范围，不能把样例资源或相近布局当作已经满足核心要求，也不用内部接口模拟完整实现。
+对每项需求明确已有 API 是否覆盖。只有当前宿主能力查询返回的正式位置，没有任意 DOM 插槽、父页面 DOM、静默覆写用户文件、通用 IPC 或 Agent 调用权限；核心要求超出已开放能力时先明确缺口与可实现范围，不能把样例资源或相近布局当作已经满足核心要求，也不用内部接口模拟完整实现。
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/commands.md b/apps/buddy/service/resources/skills/plugin-creator/references/commands.md
new file mode 100644
index 00000000..5a24ad64
--- /dev/null
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/commands.md
@@ -0,0 +1,30 @@
+# 注册命令
+
+API 3 可将既有命令公开为输入框 `/插件名:命令`。先声明，再在 `activate` 中通过 `context.commands.register(id, handler)` 注册；命令面板、菜单、视图调用与 Slash 共用同一处理函数。
+
+```json
+{ "id": "local.example.start", "title": "开始", "slash": { "name": "start", "description": "开始一次交互" } }
+```
+
+```ts
+export function activate(context: ExtensionContext) {
+  context.commands.register('local.example.start', async ({ arguments: args, invocation }) => {
+    if (invocation?.target === 'slash') {
+      // args 是用户显式输入的参数字符串，instanceId 是发起分屏。
+      await start(args as string, invocation.instanceId)
+    }
+  })
+}
+```
+
+名称是插件内的本地名称，宿主使用插件 ID 中发布者后面的名称作为命名空间，例如 `local.example` 的命令为 `/example:start`。中文显示名称不参与匹配。顶级 `/review`、`/compact`、`/skills`、`/status` 等只归系统所有；插件可声明本地 `review`，但只能通过 `/example:review` 调用，不生成顶级短别名。
+
+本地命令名长度为 1–64，匹配 `[a-z][a-z0-9-]*`：英文小写字母开头，后续允许数字和连字符。`title` 和 `description` 用于中文说明。包内本地名称唯一，隐藏命令不能声明 Slash；非法清单在编译或安装时拒绝，不自动修正或改名。不同插件命名空间内可使用同一命令名；如果两个发布者使用相同插件名并都提供 Slash，后启动的插件报命名空间冲突，需修改插件名。
+
+每个声明必须在 `activate` 完成前注册一次。未知 ID、重复注册、非函数处理器或缺少注册都会使该插件启动失败；捕获注册错误也不能使错误插件启动。修正后显式重启。
+
+候选按前缀显示；选中只插入命令，确认发送才执行。执行严格匹配完整名称和大小写，参数保持为字符串，不自动解析引号、JSON 或自然语言。插件本地命令不依赖模型配置，可以在任务流式输出时执行。只传命令参数与发起分屏，不传输入框附件、引用、会话身份或历史；带这些内容时拒绝执行并保留草稿。命令不可用或失败时也保留草稿，不降级为模型提示。
+
+`invocation.target` 为 `slash`，`resource` 为 null，`arguments` 为最多 8192 字符的参数字符串。命令面板调用仍提供既有资源语义且参数为空；视图调用的参数仍为 JSON。插件应按实际调用入口验证自己的参数。
+
+停止覆盖交互不能只依赖 Slash；参见 [交互会话](interactions.md) 的宿主退出机制。
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/interactions.md b/apps/buddy/service/resources/skills/plugin-creator/references/interactions.md
new file mode 100644
index 00000000..16096c1d
--- /dev/null
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/interactions.md
@@ -0,0 +1,51 @@
+# 分屏与临时交互
+
+API 3 提供真实布局快照和可取消的交互会话。先查询 `lexora_plugin_capabilities({kind:"runtime"})`，类型以 [api.d.ts](api.d.ts) 为准。
+
+## 分屏快照
+
+宿主入口通过 `context.workbench.panes` 获取当前快照，并用 `onPanesChange` 订阅分割、拖动、关闭、页面切换和可见性变化。每个分屏只有不透明 `id`、`active`、`visible`、`rect`；坐标单位是 CSS 像素，相对 `workbench` 挂载口。不可见分屏的矩形归零，订阅可能合并中间更新。
+
+不要读取宿主持久化文件、探测父 DOM、发送心跳或按宽度横排推测布局。只对可见分屏计算几何；用户切换页面或窗口隐藏时，暂停交互计时由插件负责。分屏 ID 只在当前布局中有效。
+
+## 会话和退出
+
+临时覆盖层在 `kind:"view"` 的 placement 声明 `interaction:"regions"` 或 `"exclusive"`，目标限定为 `workbench` / `workbench.pane`，必须为绝对定位。打开前创建会话：
+
+```ts
+const interaction = await context.interactions.start('互动游戏')
+interaction.signal.addEventListener('abort', cleanup, { once: true })
+try {
+  await context.placements.show('local.example.game', {
+    interactionId: interaction.id,
+    instanceId: originPaneId,
+  })
+}
+catch (error) {
+  await interaction.end()
+  throw error
+}
+```
+
+`instanceId` 仅适用于分屏挂载，省略时选择当前活动分屏；全工作台挂载省略该字段。同一会话可拥有多个视图。每个插件同时最多 4 个会话；会话不恢复到下一次启动。
+
+宿主在覆盖区域外提供结束按钮，Esc 也可结束交互；无需重新输入命令。结束会立即撤回会话视图，再通知 `signal` 取消；即使插件清理失败，宿主仍能移除覆盖。禁用、崩溃或窗口文档替换都会回收会话。原有任务继续执行，结束交互不会停止模型任务。结束后的 ID 不能再次打开视图。
+
+## 局部点击区域
+
+`regions` 模式的 iframe 仅绘制。透明空白不会挡住下方的输入框、滚动或选择；只有显式声明的区域接收点击。不要依赖 iframe 内普通 DOM 监听器，使用：
+
+```ts
+await context.interaction!.setRegions([
+  { id: 'target', label: '击中目标', rect: { x: 20, y: 30, width: 64, height: 64 } },
+])
+context.interaction!.onActivate(({ id, x, y }) => hit(id, x, y))
+```
+
+区域坐标相对当前视图，最多 64 个，ID 唯一、标签非空；裁剪与视图边界一致。宿主将鼠标、触摸点击或键盘按钮激活转发为统一事件；不提供全局键盘监听或任意事件透传。更新位置、大小或移除目标时同步更新区域；传 `[]` 暂停全部交互。
+
+`exclusive` 模式允许 iframe 内完整交互，覆盖区域会阻挡下方操作，但仍保留宿主退出入口。普通持久挂载不需要会话。
+
+## 多视图状态
+
+宿主入口可用 `context.views.broadcast(message)` 向本插件当前视图广播有限 JSON，视图通过 `onMessage` 接收。广播不是持久化，也不保证新打开的视图收到历史消息；新视图应通过自己的命令拉取初始状态。布局订阅和会话状态由宿主入口统一维护，视图只绘制。涉及计时器、音频和事件监听时，绑定会话的 `signal` 或视图的 `signal` 清理。
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/protocol.md b/apps/buddy/service/resources/skills/plugin-creator/references/protocol.md
index b930b1a6..f4752bfc 100644
--- a/apps/buddy/service/resources/skills/plugin-creator/references/protocol.md
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/protocol.md
@@ -1,4 +1,4 @@
-# Lexora 插件 API 2
+# Lexora 插件协议
 
 一个包包含根 `extension.json` 和包内文件。源码包支持自包含 `.ts`、`.mts`、`.js`、`.mjs`，以及静态 CSS、图片等资源；原始 HTML、Vue 单文件组件、npm 裸导入不属于当前编译协议。第三方库需作者预先打包。不要生成 `package.json`、锁文件、构建脚本、`node_modules` 或远程 CDN 依赖。
 
@@ -27,9 +27,10 @@
 
 | 字段 | 结构 |
 | --- | --- |
-| `commands` | 数组，每项必填 `id`、`title`；`hidden` 可选，默认 false。存在命令时必须设置清单顶层的宿主 `entry` |
+| `commands` | 数组，每项必填 `id`、`title`；`hidden` 可选，默认 false；API 3 可声明 `slash: {name, description?}`，规则见 [注册命令](commands.md)。存在命令时必须设置清单顶层的宿主 `entry` |
+| `menus` | API 3；数组，每项必填 `id`、`command`、`target`，可选 `order`（-1000 至 1000，默认 0）、`when`；引用自己的已声明命令 |
 | `views` | 数组，每项必填 `id`、`title`、`entry`；`resource` 为 `selected-file`（默认）或 `none`；`location` 默认 `context`；`stateVersion` 为正整数，默认 1 |
-| `placements` | 数组，每项必填 `id`、`view`、`kind`，并按 kind 添加后文规定的 `anchor`、`target` 和 `presentation`；不要把它们写入视图定义 |
+| `placements` | 数组，每项必填 `id`、`view`、`kind`，并按 kind 添加后文规定的 `anchor`、`target` 或 `presentation`；不要把它们写入视图定义 |
 | `navigation` | 单个对象，必填 `title`、`view`，引用自己的无资源视图 |
 
 插件 ID 使用小写字母开头的两段名称，中间以 `.` 分隔，每段可含小写字母、数字与 `-`；贡献 ID 在插件 ID 后追加由小写字母、数字、`.`、`-` 组成的后缀。声明文件路径使用包内相对路径，`.ts` 文件名直接指向源码，编译工具负责产出运行文件。
@@ -42,13 +43,13 @@
 | `context` | `selected-file` 或 `none` | 工作区资源页签，由用户打开 |
 | `window-overlay` | `none` | 启用后自动挂载的透明窗口效果，每插件最多一个；无法点击或聚焦 |
 
-页面与小视图由插件绘制，均使用 `render(context, container)`，共用隔离和通信 API。API 2 将视图内容与挂载位置分开，通过 `contributes.placements` 选择正式扩展点；`page` 和 `window-overlay` 在 API 1、API 2 中均可使用。插件不能查询或修改宿主 DOM。
+页面与小视图由插件绘制，均使用 `render(context, container)`，共用隔离和通信 API。API 2 起将视图内容与挂载位置分开，通过 `contributes.placements` 选择正式扩展点；`page` 和 `window-overlay` 继续可用。插件不能查询或修改宿主 DOM。
 
 装饰、替换控件和普通挂载面板的 `container` 默认填满隔离视图，无内边距，支持子元素使用百分比高度。装饰的绘制范围仍受锚点及祖先裁剪约束；页面保持普通文档流，可按内容滚动。
 
 导航入口位于自动化下方，声明 `contributes.navigation: { "title": "插件名称", "view": "local.plugin.settings" }`，引用一个 `resource: "none"` 的视图（API 1 仍需 `location: "page"`）。不需要设置页的效果插件可以没有导航。
 
-导航页面、装饰和替换控件不能使用 `context.setState()`；需要持久设置时声明宿主入口和隐藏命令，以 `context.storage.get/set` 保存。多个视图使用同一设置时明确刷新时机，插件局部开关必须能在不重载视图的情况下关闭并重新启用。资源页签的 `setState` 用于保存该页签的 JSON 状态。
+导航页面、装饰、内容插槽和替换控件不能使用 `context.setState()`；需要持久设置时声明宿主入口和隐藏命令，以 `context.storage.get/set` 保存。多个视图使用同一设置时明确刷新时机，插件局部开关必须能在不重载视图的情况下关闭并重新启用。资源页签的 `setState` 用于保存该页签的 JSON 状态。
 
 ## 权限
 
@@ -58,7 +59,8 @@
 | `controls: ["model.reasoning"]` | 提供可由用户选用的思考等级控件 |
 | `notifications: true` | 宿主 `context.notifications.show({title,body})` |
 | `schedules: true` | 宿主持久间隔任务，需要宿主入口与已声明命令 |
-| `selectedResource: "read"` | 读取明确分配给视图的文件资源 |
+| `selectedResource: "read"` | 读取用户选择并明确分配的文件资源 |
+| `selectedContent: true` | API 3；用户点击插件操作时获取当前草稿或该条消息文本，不订阅输入或读取对话历史 |
 | `localResources: true` | 用户通过系统窗口选择文件或目录，视图读取文本、二进制或受控 URL |
 | `resourceExport: true` | 用户通过系统另存为窗口确认目标后，保存插件提供的字节 |
 | `network: ["https://example.com"]` | 通过宿主向列出的 HTTPS origin 发 GET 请求 |
@@ -90,14 +92,15 @@
 | kind | 必填字段 | 行为 |
 | --- | --- | --- |
 | `decoration` | `anchor` | 自动挂载至 `app.sidebar`、`workbench.sidebar`、`workbench.pane` 或 `composer.input`；每个锚点实例分别挂载，只在该区域内绘制，不接收指针和焦点 |
-| `view` | `target` | `workbench`、`app.sidebar` 或 `workbench.sidebar`；`presentation` 描述区域内布局；宿主入口调用 `context.placements.show(id)` / `hide(id)` 显示或关闭 |
-| `control` | `target` | 当前支持 `model.reasoning`；用户在控件样式选择中启用后才替换内置控件 |
+| `view` | `target` | 用 `lexora_plugin_capabilities({kind:"mount"})` 查询目标；`presentation` 描述区域内布局，宿主入口调用 `context.placements.show(id, instanceId?)` / `hide(id, instanceId?)` |
+| `control` | `target` | 当前支持 `model.reasoning`；用户在插件管理页选择后才替换内置控件 |
+| `slot` | `target` | 需要将 `apiVersion` 设为 3；用户在插件管理页选择后替换目标内容，具体目标和尺寸按需查 [内容插槽目录](slots.md) |
 
-挂载口只提供容器，不提供面板外壳或交互。声明示意：`{id,view,kind:"view",target:"workbench",presentation:{position:"absolute",width:420,height:180,right:16,bottom:16}}`。三个目标分别属于持续存在的工作台、应用侧栏和任务侧栏。挂载口暂时不可用时保留实例，恢复后继续投影。插件自行渲染全部内容、样式与交互；插件之间保留独立实例，宿主不生成切换器、不自动避让或折叠。
+挂载口只提供容器，不提供面板外壳或交互。声明示意：`{id,view,kind:"view",target:"workbench",presentation:{position:"absolute",width:420,height:180,right:16,bottom:16}}`。目标所属范围由能力目录返回。API 3 的分屏挂载以 `instanceId` 区分实例；从命令 `invocation.instanceId` 传入发起操作的分屏，不要在异步完成后重新选择焦点。省略时使用调用时的活动分屏，标识失效则拒绝打开。每个分屏分别保存状态，分屏移除时结束该实例。挂载口暂时不可用时保留实例，恢复后继续投影。插件自行渲染全部内容、样式与交互；插件之间保留独立实例，宿主不生成切换器、不自动避让或折叠。
 
 `presentation` 是隔离视图外框的布局声明：`position` 为 `static`（默认，正常布局）或 `absolute`（相对挂载口）；`order` 为 -1000 至 1000（默认 1，与核心内容的 0 比较）；`zIndex` 为 0–20 的扩展层内顺序，不覆盖核心弹窗。`width/height/top/right/bottom/left` 使用 0–8192 的像素数或 0%–100% 字符串；`null` 清除该 CSS 值。未指定尺寸时宽度 100%、高度 56px，最大尺寸及可见内容受目标容器边界约束。内容内部自由使用 DOM/CSS、Canvas 等；不访问父页面 DOM。
 
-`context.setPresentation({...})` 合并更新上述字段，传 `target` 可转移挂载口。实例、会话与状态保留；插件的定时器、媒体等不会因为换位置而重建。布局值由宿主持久化，业务状态由插件自己保存。`context.mount` / `onMountChange` 提供目标容器宽高、可见性和当前视图的局部矩形，供插件响应尺寸变化或实现拖动等交互，不包含屏幕坐标、其他插件信息或父 DOM。
+`context.setPresentation({...})` 合并更新上述字段，传 `target` 可转移挂载口。进入分屏区域要求该视图在创建时已绑定分屏，不会把全局实例隐式移入当前焦点分屏。实例、会话与状态保留；插件的定时器、媒体等不会因为换位置而重建。布局值由宿主持久化，业务状态由插件自己保存。`context.mount` / `onMountChange` 提供目标容器宽高、可见性和当前视图的局部矩形，供插件响应尺寸变化或实现拖动等交互，不包含屏幕坐标、其他插件信息或父 DOM。
 
 宿主不认识“折叠”“展开”“贴边”或“播放器”。需要这些效果时，插件自己渲染触发入口、控制布局并保存自己的状态。缩小视图外框不销毁内容；调用宿主命令中的 `placements.hide` 才关闭实例。插件负责再次打开的入口，可以使用自己的可见 UI、已声明命令或导航。不要依赖宿主替插件提供关闭栏或恢复按钮。
 
@@ -109,11 +112,19 @@
 
 组合视图可用导航页管理设置、挂载面板展示持续内容、隐藏命令连接私有存储。设置更新后的刷新时机由插件明确处理，页面之间没有隐式共享 JS 状态。
 
+## 操作菜单
+
+API 3 的 `contributes.menus` 将已有命令放进业务区域的「更多操作」。先用 `lexora_plugin_capabilities({kind:"menu"})` 查询目标与输入契约，再声明 `{id,command,target,order?,when?}`。`hidden` 仅隐藏命令面板与管理卡片入口，不隐藏显式声明的菜单。
+
+命令参数中的 `invocation` 包含 `target`、`instanceId`，仅在声明 `selectedContent` 且用户点击对应操作后附带 `content`。文件菜单通过原有 `selectedResource` 权限提供 `resource` 句柄。视图调用自己的命令时 `invocation.target` 为 `view`，只附带该视图的实例标识；命令面板和定时调用的 `invocation` 为空。
+
+输入操作可返回 `{insertText:string}`。宿主在原草稿仍可编辑且内容未改变时，将结果作为纯文本插入原选择位置；更换草稿、编辑内容或关闭视图后忽略迟到结果，不自动发送。其他菜单忽略命令返回值。`when` 支持宿主公开上下文，消息菜单额外提供 `message.role`，文件菜单提供当前 `resource.scheme`；不能用条件读取未公开的数据。
+
 ## 页面上下文与生效条件
 
 视图通过 `context.workbench` 读取只读快照：`values` 是公开语义上下文，`pages` 列出已登记页面的稳定 `id/title`。`onWorkbenchChange` 订阅变化。当前 `page.id` 使用 `lexora.tasks`、`lexora.automations`、`lexora.extensions`、`lexora.settings` 或 `extension:<插件ID>`；自动化和设置通过 `page.section` 提供子页标识，如 `plans`、`history`、`general`、`models`。其他页面不保留上一个页面的 section。未来页面通过登记扩展，不以名称、URL 或 DOM 选择器识别。这里不提供任务正文、输入内容、文件路径、路由参数或 Provider/模型身份。
 
-`contributes.views`、`placements`、`commands` 和 `navigation` 可声明可选的 `when`。例如 `"when": {"page.id": ["lexora.tasks", "lexora.automations"]}`；对象中的不同 key 为 AND，数组内为 OR，标量严格相等，缺失 key 不匹配。空对象或省略表示不限定，不执行表达式代码。最多 32 个 key，每个数组最多 32 项，值限字符串（256 字符）、布尔和有限数字。视图定义与挂载的条件同时满足才显示。只限定某个挂载实例时优先在 placement 声明；view 的条件影响该定义的所有实例，navigation 的条件只限定入口。
+`contributes.views`、`placements`、`commands`、`menus` 和 `navigation` 可声明可选的 `when`。例如 `"when": {"page.id": ["lexora.tasks", "lexora.automations"]}`；对象中的不同 key 为 AND，数组内为 OR，标量严格相等，缺失 key 不匹配。空对象或省略表示不限定，不执行表达式代码。最多 32 个 key，每个数组最多 32 项，值限字符串（256 字符）、布尔和有限数字。视图定义与挂载的条件同时满足才显示。只限定某个挂载实例时优先在 placement 声明；view 的条件影响该定义的所有实例，navigation 的条件只限定入口。
 
 条件只控制 UI 的可用性，不授予权限、不启动插件，也不阻止插件自身调用命令或后台调度。命令菜单与导航入口随上下文更新。首次不满足条件的视图不激活；已打开视图离开范围时隐藏，挂载面板退出布局占位，实例、状态与会话保留，返回后恢复。控件不匹配时使用内置控件并拒绝旧提交。`placements.hide` 仍表示关闭实例，与条件隐藏不同。
 
@@ -174,3 +185,5 @@ context.subscriptions.add(context.commands.register('local.example.open', async
 ## 主题与样式
 
 直接创建元素、设置样式，或引入包内 CSS：`link.href = new URL('./style.css', import.meta.url).href`。使用 `--lexora-background`、`--lexora-text`、`--lexora-muted`、`--lexora-border`、`--lexora-accent`、`--lexora-accent-solid`。`context.environment` 提供语言、配色与颜色；`context.onEnvironmentChange` 订阅切换。效果应柔和短暂，不遮挡正文或确认操作。
+
+临时覆盖层、分屏布局订阅与局部点击区域见 [交互会话](interactions.md)。
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/sdk-workflow.md b/apps/buddy/service/resources/skills/plugin-creator/references/sdk-workflow.md
index 9c2716d3..a6933bcc 100644
--- a/apps/buddy/service/resources/skills/plugin-creator/references/sdk-workflow.md
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/sdk-workflow.md
@@ -15,3 +15,5 @@ pnpm run package:source <插件仓库>
 安装包在 SDK 的 `.output/packages/`。开发预览可使用 `pnpm dev <插件仓库> <插件名>`，采用独立临时配置。打包会更新插件仓库的 `catalog/v1/index.json`，不会上传。运行验证仍需真实 Lexora 窗口；普通浏览器打开文件不能代替插件隔离环境验收。
 
 在 Lexora 的「插件 → 安装插件包」选择输出包并确认权限。只有用户要求发布时才同步远端。
+
+离线开发可从 SDK 的 `authoring.mjs` 导入 `queryWorkbenchCapabilities` 查询该 SDK 快照支持的目标；它不代表用户已安装宿主的版本。应用内优先查询 `lexora_plugin_capabilities`。
diff --git a/apps/buddy/service/resources/skills/plugin-creator/references/slots.md b/apps/buddy/service/resources/skills/plugin-creator/references/slots.md
new file mode 100644
index 00000000..8322a44c
--- /dev/null
+++ b/apps/buddy/service/resources/skills/plugin-creator/references/slots.md
@@ -0,0 +1,9 @@
+# 内容插槽
+
+内容插槽由宿主负责位置和布局，插件提供隔离视图。通过 `lexora_plugin_capabilities({kind:"slot"})` 查询当前宿主支持的位置，也可指定 `target` 只读取一个位置。目录返回用途、作用范围、单选或多选策略，以及高度的最小值、最大值和默认值；不要根据 CSS 类名推测目标。
+
+清单使用 API 3，声明 `{id,kind:"slot",target,view,height?}`。`view` 指向本插件 `resource:"none"` 的视图。内容插槽不接受 `presentation`，不通过 `placements.show/hide` 开关，本身不要求权限。
+
+安装后由用户在插件管理的「界面呈现」中选择；单选目标替换内置内容，多选目标按用户选择顺序追加内容。未选、尚未就绪或提供者不可用时显示内置回退；没有内置内容的追加区为空。输入辅助区总高度受宿主限制，超出后滚动。
+
+每个可见宿主位置拥有独立视图，`context.instanceId` 是所在分屏的不透明标识，可能为空。它可以关联自己发起的命令和分屏挂载，不提供任务身份、历史或输入文字。视图销毁时清理资源；临时内容不使用 `setState`，需要共享业务状态时通过自身宿主命令访问私有存储。
diff --git a/apps/buddy/service/src/chat/ChatCommandService.ts b/apps/buddy/service/src/chat/ChatCommandService.ts
index c8b0a8e6..6ccde700 100644
--- a/apps/buddy/service/src/chat/ChatCommandService.ts
+++ b/apps/buddy/service/src/chat/ChatCommandService.ts
@@ -63,6 +63,7 @@ export class ChatCommandService {
       || draft.content.quotes?.length
       || directives.length !== 1
       || directives[0]?.commandMode !== 'action'
+      || directives[0].commandId
       || directives[0].value !== `/${command.name}`
     ) {
       throw new BuddyServiceError('VALIDATION_FAILED')
diff --git a/apps/buddy/service/src/chat/ChatTurnService.ts b/apps/buddy/service/src/chat/ChatTurnService.ts
index e73b8a26..b06d3c41 100644
--- a/apps/buddy/service/src/chat/ChatTurnService.ts
+++ b/apps/buddy/service/src/chat/ChatTurnService.ts
@@ -670,6 +670,8 @@ async function materializeComposerDirectives(
   skills: Pick<SkillService, 'materializeForSpace'>,
 ) {
   const directives = content.body.flatMap(paragraph => paragraph.content.filter(node => node.type === 'prompt_directive'))
+  if (directives.some(node => node.directive === 'slash_command' && node.commandId))
+    throw new BuddyServiceError('VALIDATION_FAILED')
   const textCommand = parseBuddyChatCommand(buddyUserContentToText(content))
   if (textCommand && isBuddyRunChatCommand(textCommand.name))
     throw new BuddyServiceError('VALIDATION_FAILED')
diff --git a/apps/buddy/service/src/plugins/pluginAuthoringCapability.ts b/apps/buddy/service/src/plugins/pluginAuthoringCapability.ts
index 63b57a7f..d6c24b06 100644
--- a/apps/buddy/service/src/plugins/pluginAuthoringCapability.ts
+++ b/apps/buddy/service/src/plugins/pluginAuthoringCapability.ts
@@ -9,11 +9,17 @@ import { Type } from 'typebox'
 import { Check } from 'typebox/value'
 import { readExtensionDirectory } from '../../../platform/extensions/extensionFiles'
 import { containsCanonicalPath } from '../../../platform/filesystem/filePaths'
-import { EXTENSION_BUILD_RPC, EXTENSION_INSPECT_RPC, EXTENSION_REVIEW_REQUEST, extensionBuildResultSchema, extensionInspectionSchema } from '../../../shared/extensions/extensionAuthoring'
+import { EXTENSION_BUILD_RPC, EXTENSION_CAPABILITIES_RPC, EXTENSION_INSPECT_RPC, EXTENSION_REVIEW_REQUEST, extensionBuildResultSchema, extensionCapabilitiesSchema, extensionInspectionSchema } from '../../../shared/extensions/extensionAuthoring'
+import { workbenchCapabilityKinds } from '../../../shared/workbench/workbenchContributionCatalog'
 import { resolveGrantedPath } from '../directories/resolveGrantedPath'
 
 const name = 'lexora_plugin_build'
 const inspectName = 'lexora_plugin_inspect'
+const capabilitiesName = 'lexora_plugin_capabilities'
+const capabilitiesParameters = Type.Object({
+  kind: Type.Optional(Type.Union(workbenchCapabilityKinds.map(kind => Type.Literal(kind)))),
+  target: Type.Optional(Type.String({ minLength: 1, maxLength: 100, description: 'Exact target from the host catalog. Omit both filters for a compact index; specify either for detailed contracts.' })),
+}, { additionalProperties: false })
 const inspectParameters = Type.Object({ id: Type.String({ maxLength: 120, pattern: '^[a-z][a-z0-9-]*\\.[a-z][a-z0-9-]*$', description: 'Plugin ID to inspect. This only reads host status; it does not start or install the plugin.' }) }, { additionalProperties: false })
 const parameters = Type.Object({
   source: Type.String({ minLength: 1, maxLength: 4096, description: 'Plugin source directory containing extension.json, relative to the workspace or absolute.' }),
@@ -24,6 +30,8 @@ const parameters = Type.Object({
 export function createPluginAuthoringCapability(context: BuddyCapabilityContext, peer: Pick<RuntimeRpcPeerContract, 'request' | 'notify'>): BuddyCapability {
   return {
     classify(event) {
+      if (event.toolName === capabilitiesName)
+        return Check(capabilitiesParameters, event.input) ? { access: 'read', paths: [] } : { blocked: true, reason: 'VALIDATION_FAILED' }
       if (event.toolName === inspectName)
         return Check(inspectParameters, event.input) ? { access: 'read', paths: [] } : { blocked: true, reason: 'VALIDATION_FAILED' }
       if (event.toolName !== name)
@@ -32,10 +40,24 @@ export function createPluginAuthoringCapability(context: BuddyCapabilityContext,
         return { blocked: true, reason: 'VALIDATION_FAILED' }
       return { access: 'write', paths: [{ path: event.input.source, mode: 'existing' }, { path: event.input.output, mode: 'create' }] }
     },
-    disclosure: { group: 'plugins', keywords: 'plugin extension build create inspect 插件 创建 编译 校验 安装 诊断', toolNames: [name, inspectName] },
+    disclosure: { group: 'plugins', keywords: 'plugin extension build create inspect capabilities 插件 创建 编译 校验 安装 诊断 插槽', toolNames: [name, inspectName, capabilitiesName] },
     extension: {
       name: 'lexora-plugin-authoring',
       factory(pi) {
+        pi.registerTool(defineTool({
+          name: capabilitiesName,
+          label: 'Discover plugin capabilities',
+          parameters: capabilitiesParameters,
+          description: 'Query the actual Lexora host for contribution targets and runtime capabilities. No filters returns a compact index; filter by kind or exact target for sizing, selection, scope and interaction rules. Read-only.',
+          async execute(_toolCallId, input, signal) {
+            try {
+              const abort = signal ? AbortSignal.any([signal, context.signal]) : context.signal
+              const capabilities = extensionCapabilitiesSchema.parse(await peer.request(EXTENSION_CAPABILITIES_RPC, input, 10000, abort))
+              return response({ ok: true, ...capabilities })
+            }
+            catch { return response({ ok: false, code: 'EXTENSION_CAPABILITIES_FAILED' }) }
+          },
+        }))
         pi.registerTool(defineTool({
           name: inspectName,
           label: 'Inspect plugin',
@@ -101,7 +123,7 @@ export function createPluginAuthoringCapability(context: BuddyCapabilityContext,
           },
         }))
         pi.on('tool_result', (event) => {
-          if ([name, inspectName].includes(event.toolName) && event.details && typeof event.details === 'object' && 'ok' in event.details && event.details.ok === false)
+          if ([name, inspectName, capabilitiesName].includes(event.toolName) && event.details && typeof event.details === 'object' && 'ok' in event.details && event.details.ok === false)
             return { isError: true }
         })
       },
diff --git a/apps/buddy/shared/conversation/buddyUserContent.ts b/apps/buddy/shared/conversation/buddyUserContent.ts
index 34222b08..5ac06656 100644
--- a/apps/buddy/shared/conversation/buddyUserContent.ts
+++ b/apps/buddy/shared/conversation/buddyUserContent.ts
@@ -36,6 +36,7 @@ const skillDirectiveSchema = z.object({
 
 const slashDirectiveSchema = z.object({
   commandMode: z.enum(['prompt', 'action']),
+  commandId: z.string().min(1).max(180).regex(/^[a-z][a-z0-9.-]+$/).optional(),
   directive: z.literal('slash_command'),
   type: z.literal('prompt_directive'),
   value: z.string().min(1),
diff --git a/apps/buddy/shared/extensions/extensionApi.ts b/apps/buddy/shared/extensions/extensionApi.ts
index d2d798a8..d42f204d 100644
--- a/apps/buddy/shared/extensions/extensionApi.ts
+++ b/apps/buddy/shared/extensions/extensionApi.ts
@@ -1,3 +1,4 @@
+import type { WorkbenchHitRegion, WorkbenchPaneSnapshot } from '../workbench/workbenchInteraction'
 import type { JsonValue } from '../workbench/workbenchState'
 import type { ControlProposal, WorkbenchPresentation } from '../workbench/workbenchUi'
 import type { ExtensionCatalogSnapshot } from './extensionCatalog'
@@ -5,6 +6,8 @@ import type { ExtensionInstallation } from './extensionInstallation'
 import type { ExtensionManifest } from './extensionManifest'
 import { z } from 'zod'
 import { spaceFileTargetSchema } from '../spaces/spaceFileApi'
+import { workbenchPanesSchema } from '../workbench/workbenchInteraction'
+import { workbenchMenuSchema } from '../workbench/workbenchUi'
 import { extensionIdSchema } from './extensionManifest'
 
 export const EXTENSION_IPC = {
@@ -24,12 +27,21 @@ export const extensionViewInputSchema = z.object({
   extensionId: extensionIdSchema,
   viewType: z.string().max(180),
   placementId: z.string().min(1).max(180).optional(),
+  interactionId: z.string().uuid().optional(),
+  instanceId: z.string().uuid().optional(),
   resource: extensionResourceSchema.nullable(),
   state: extensionJsonSchema,
   stateVersion: z.number().int().min(0).max(10000),
 }).strict()
 export type ExtensionResource = z.infer<typeof extensionResourceSchema>
 export type ExtensionViewInput = z.infer<typeof extensionViewInputSchema>
+export const extensionMenuInvocationSchema = z.object({
+  target: workbenchMenuSchema,
+  instanceId: z.string().uuid().optional(),
+  content: z.string().max(131072).optional(),
+  resource: spaceFileTargetSchema.nullable().default(null),
+}).strict()
+export type ExtensionMenuInvocation = z.infer<typeof extensionMenuInvocationSchema>
 export interface ExtensionViewSession {
   id: string
   extensionId: string
@@ -72,7 +84,10 @@ export type ExtensionWorkbenchEvent
   = | { kind: 'cancel', requestId: string }
     | { kind: 'open', requestId: string, extensionId: string, generation: string, viewType: string, resource: ExtensionResource | null, state: JsonValue, stateVersion: number }
     | { kind: 'state', requestId: string, viewId: string, generation: string, token: string, state: JsonValue, stateVersion: number }
-    | { kind: 'placement', requestId: string, extensionId: string, generation: string, placementId: string, visible: boolean }
+    | { kind: 'interaction', requestId: string, extensionId: string, generation: string, interactionId: string, title: string | null }
+    | { kind: 'message', requestId: string, extensionId: string, generation: string, message: JsonValue }
+    | { kind: 'regions', requestId: string, viewId: string, generation: string, token: string, regions: WorkbenchHitRegion[] }
+    | { kind: 'placement', requestId: string, extensionId: string, generation: string, placementId: string, visible: boolean, instanceId?: string, interactionId?: string }
     | { kind: 'control', requestId: string, viewId: string, generation: string, token: string, proposal: ControlProposal }
     | { kind: 'presentation', requestId: string, viewId: string, generation: string, token: string, presentation: WorkbenchPresentation }
 
@@ -91,6 +106,10 @@ export const extensionManagementSchema = z.discriminatedUnion('action', [
   z.object({ action: z.literal('devtools'), id: extensionIdSchema }).strict(),
   z.object({ action: z.literal('revokeResources'), id: extensionIdSchema }).strict(),
   z.object({ action: z.literal('execute'), id: extensionIdSchema, command: z.string().max(180), resource: spaceFileTargetSchema.nullable() }).strict(),
+  z.object({ action: z.literal('executeMenu'), id: extensionIdSchema, menu: z.string().max(180), invocation: extensionMenuInvocationSchema }).strict(),
+  z.object({ action: z.literal('executeSlash'), id: extensionIdSchema, command: z.string().max(180), arguments: z.string().max(8192), instanceId: z.string().uuid().optional() }).strict(),
+  z.object({ action: z.literal('updatePanes'), panes: workbenchPanesSchema }).strict(),
+  z.object({ action: z.literal('endInteraction'), id: z.string().uuid() }).strict(),
   z.object({ action: z.literal('openView'), view: extensionViewInputSchema }).strict(),
   z.object({ action: z.literal('closeView'), viewId: z.string().uuid(), generation: z.string().uuid(), token: z.string().uuid() }).strict(),
   z.object({ action: z.literal('viewRequest'), viewId: z.string().uuid(), generation: z.string().uuid(), token: z.string().uuid(), method: z.string().max(80), params: extensionJsonSchema }).strict(),
@@ -111,6 +130,10 @@ export interface ExtensionApi {
   devtools: (id: string) => Promise<void>
   revokeResources: (id: string) => Promise<void>
   execute: (id: string, command: string, resource: import('../spaces/spaceFileApi').SpaceFileTarget | null) => Promise<void>
+  executeMenu: (id: string, menu: string, invocation: ExtensionMenuInvocation) => Promise<JsonValue>
+  executeSlash: (id: string, command: string, argumentsText: string, instanceId?: string) => Promise<JsonValue>
+  updatePanes: (panes: WorkbenchPaneSnapshot[]) => Promise<void>
+  endInteraction: (id: string) => Promise<void>
   openView: (view: ExtensionViewInput) => Promise<ExtensionViewSession>
   closeView: (viewId: string, generation: string, token: string) => Promise<void>
   viewRequest: (viewId: string, generation: string, token: string, method: string, params: JsonValue) => Promise<JsonValue>
diff --git a/apps/buddy/shared/extensions/extensionAuthoring.ts b/apps/buddy/shared/extensions/extensionAuthoring.ts
index 60c25ab5..8c90a642 100644
--- a/apps/buddy/shared/extensions/extensionAuthoring.ts
+++ b/apps/buddy/shared/extensions/extensionAuthoring.ts
@@ -1,9 +1,25 @@
 import { z } from 'zod'
+import { workbenchCapabilityKinds } from '../workbench/workbenchContributionCatalog'
+import { workbenchCapabilityQuerySchema } from '../workbench/workbenchUi'
 import { extensionIdSchema, extensionVersionSchema } from './extensionManifest'
 
 export const EXTENSION_BUILD_RPC = 'extensions.build'
 export const EXTENSION_REVIEW_REQUEST = 'extensions.reviewPackage'
 export const EXTENSION_INSPECT_RPC = 'extensions.inspect'
+export const EXTENSION_CAPABILITIES_RPC = 'extensions.capabilities'
+export { workbenchCapabilityQuerySchema as extensionCapabilitiesRequestSchema }
+export const extensionCapabilitiesSchema = z.object({
+  apiVersion: z.number().int().positive(),
+  targets: z.array(z.object({
+    kind: z.enum(workbenchCapabilityKinds),
+    target: z.string(),
+    title: z.object({ 'zh-CN': z.string(), 'en-US': z.string() }).strict(),
+    scope: z.enum(['application', 'page', 'pane', 'composer', 'resource', 'message']),
+    description: z.string().optional(),
+    selection: z.enum(['single', 'multiple']).optional(),
+    height: z.object({ min: z.number(), max: z.number(), default: z.number() }).strict().optional(),
+  }).strict()),
+}).strict()
 export const extensionInspectRequestSchema = z.object({ id: extensionIdSchema }).strict()
 export const extensionInspectionSchema = z.object({
   id: extensionIdSchema,
diff --git a/apps/buddy/shared/extensions/extensionCommands.ts b/apps/buddy/shared/extensions/extensionCommands.ts
new file mode 100644
index 00000000..20115475
--- /dev/null
+++ b/apps/buddy/shared/extensions/extensionCommands.ts
@@ -0,0 +1,3 @@
+export function extensionCommandNamespace(id: string): string {
+  return id.slice(id.indexOf('.') + 1)
+}
diff --git a/apps/buddy/shared/extensions/extensionManifest.ts b/apps/buddy/shared/extensions/extensionManifest.ts
index 0619d37b..d2523771 100644
--- a/apps/buddy/shared/extensions/extensionManifest.ts
+++ b/apps/buddy/shared/extensions/extensionManifest.ts
@@ -1,9 +1,10 @@
 import { satisfies, valid, validRange } from 'semver'
 import { z } from 'zod'
+import { workbenchSlashSchema } from '../workbench/workbenchCommand'
 import { workbenchConditionSchema } from '../workbench/workbenchContext'
-import { workbenchAnchorSchema, workbenchControlSchema, workbenchMountTargetSchema, workbenchPresentationSchema } from '../workbench/workbenchUi'
+import { workbenchAnchorSchema, workbenchControls, workbenchControlSchema, workbenchMenuSchema, workbenchMountTargetSchema, workbenchPresentationSchema, workbenchSlots, workbenchSlotSchema } from '../workbench/workbenchUi'
 
-export const EXTENSION_API_VERSION = 2
+export const EXTENSION_API_VERSION = 3
 export const EXTENSION_PROTOCOL = 'lexora-extension'
 export const EXTENSION_ICON_LIMIT = 64 * 1024
 export const extensionIconUrlSchema = z.string().max(Math.ceil(EXTENSION_ICON_LIMIT / 3) * 4 + 40).regex(/^data:image\/(?:svg\+xml|png|jpeg|webp);base64,[A-Za-z0-9+/]+={0,2}$/)
@@ -19,6 +20,7 @@ export const extensionPlacementSchema = z.discriminatedUnion('kind', [
   z.object({
     ...placementBase,
     kind: z.literal('view'),
+    interaction: z.enum(['regions', 'exclusive']).optional(),
     target: workbenchMountTargetSchema.optional(),
     presentation: workbenchPresentationSchema.omit({ target: true }).default({}),
     location: z.enum(['workbench.top', 'workbench.bottom', 'workbench.floating']).optional(),
@@ -27,24 +29,35 @@ export const extensionPlacementSchema = z.discriminatedUnion('kind', [
   }).strict().superRefine((value, context) => {
     if (!!value.target === !!value.location || (value.target && (value.height !== undefined || value.width !== undefined)))
       context.addIssue({ code: 'custom', message: 'Declare a mount target and presentation, or a legacy location' })
-  }).transform(({ id, view, kind, when, target, presentation, location, height, width }) => ({
+  }).transform(({ id, view, kind, when, target, presentation, location, height, width, interaction }) => ({
     id,
     view,
     kind,
+    ...(interaction ? { interaction } : {}),
     ...(when ? { when } : {}),
     target: target ?? 'workbench' as const,
     presentation: location ? { position: location === 'workbench.floating' ? 'absolute' as const : 'static' as const, order: location === 'workbench.top' ? -1 : 1, height: height ?? 56, ...(width === undefined ? {} : { width }), ...presentation } : presentation,
   })),
   z.object({ ...placementBase, kind: z.literal('decoration'), anchor: workbenchAnchorSchema }).strict(),
-  z.object({ ...placementBase, kind: z.literal('control'), target: workbenchControlSchema, height: z.number().int().min(32).max(160).default(64) }).strict(),
-])
+  z.object({ ...placementBase, kind: z.literal('control'), target: workbenchControlSchema, height: z.number().int().optional() }).strict(),
+  z.object({ ...placementBase, kind: z.literal('slot'), target: workbenchSlotSchema, height: z.number().int().optional() }).strict(),
+]).transform((placement, context) => {
+  if (placement.kind !== 'slot' && placement.kind !== 'control')
+    return placement
+  const bounds = (placement.kind === 'slot' ? workbenchSlots[placement.target] : workbenchControls[placement.target]).height
+  const height = placement.height ?? bounds.default
+  if (height < bounds.min || height > bounds.max)
+    context.addIssue({ code: 'custom', message: `Height for ${placement.target} must be ${bounds.min}-${bounds.max}` })
+  return { ...placement, height }
+})
 export type ExtensionPlacement = z.infer<typeof extensionPlacementSchema>
 export const extensionPermissionsSchema = z.object({
   windowEffects: z.boolean().default(false),
-  controls: z.array(workbenchControlSchema).max(1).default([]),
+  controls: z.array(workbenchControlSchema).max(workbenchControlSchema.options.length).default([]),
   notifications: z.boolean().default(false),
   schedules: z.boolean().default(false),
   selectedResource: z.enum(['none', 'read']).default('none'),
+  selectedContent: z.boolean().default(false),
   localResources: z.boolean().default(false),
   resourceExport: z.boolean().default(false),
   network: z.array(z.string().url().max(512).refine((value) => {
@@ -62,21 +75,22 @@ export const extensionManifestSchema = z.object({
   categories: z.array(z.string().min(1).max(40)).max(8).default([]),
   tags: z.array(z.string().min(1).max(40)).max(16).default([]),
   version: extensionVersionSchema,
-  apiVersion: z.union([z.literal(1), z.literal(EXTENSION_API_VERSION)]),
+  apiVersion: z.union([z.literal(1), z.literal(2), z.literal(EXTENSION_API_VERSION)]),
   engines: z.object({ lexora: z.string().max(100).refine(value => validRange(value) !== null) }).strict(),
   entry: extensionPathSchema.optional(),
   dataVersion: z.number().int().min(1).max(10000).default(1),
   dependencies: z.record(extensionIdSchema, z.string().max(100).refine(value => validRange(value) !== null)).default({}),
   permissions: extensionPermissionsSchema.prefault({}),
   contributes: z.object({
-    commands: z.array(z.object({ id: contributionId, title: z.string().min(1).max(100), hidden: z.boolean().default(false), when: workbenchConditionSchema.optional() }).strict()).max(64).default([]),
+    commands: z.array(z.object({ id: contributionId, title: z.string().min(1).max(100), hidden: z.boolean().default(false), slash: workbenchSlashSchema.optional(), when: workbenchConditionSchema.optional() }).strict()).max(64).default([]),
+    menus: z.array(z.object({ id: contributionId, command: contributionId, target: workbenchMenuSchema, order: z.number().int().min(-1000).max(1000).default(0), when: workbenchConditionSchema.optional() }).strict()).max(32).default([]),
     views: z.array(z.object({ id: contributionId, title: z.string().min(1).max(100), entry: extensionPathSchema, stateVersion: z.number().int().min(1).max(10000).default(1), resource: z.enum(['selected-file', 'none']).default('selected-file'), location: z.enum(['context', 'page', 'window-overlay']).default('context'), when: workbenchConditionSchema.optional() }).strict()).max(16).default([]),
     placements: z.array(extensionPlacementSchema).max(16).default([]),
     navigation: z.object({ title: z.string().min(1).max(40), view: contributionId, when: workbenchConditionSchema.optional() }).strict().optional(),
   }).strict(),
 }).strict().superRefine((manifest, context) => {
   const ids = new Set<string>()
-  for (const contribution of [...manifest.contributes.commands, ...manifest.contributes.views, ...manifest.contributes.placements]) {
+  for (const contribution of [...manifest.contributes.commands, ...manifest.contributes.views, ...manifest.contributes.placements, ...manifest.contributes.menus]) {
     if (!contribution.id.startsWith(`${manifest.id}.`) || ids.has(contribution.id))
       context.addIssue({ code: 'custom', message: 'Contribution IDs must be unique and owned by the extension' })
     ids.add(contribution.id)
@@ -93,14 +107,32 @@ export const extensionManifestSchema = z.object({
     context.addIssue({ code: 'custom', message: 'Window overlays require windowEffects permission' })
   if (manifest.contributes.views.filter(view => view.location === 'window-overlay').length > 1)
     context.addIssue({ code: 'custom', message: 'An extension can provide one window overlay' })
-  if (manifest.contributes.navigation && !manifest.contributes.views.some(view => view.id === manifest.contributes.navigation?.view && view.resource === 'none' && (view.location === 'page' || (manifest.apiVersion === 2 && view.location === 'context'))))
+  if (manifest.contributes.navigation && !manifest.contributes.views.some(view => view.id === manifest.contributes.navigation?.view && view.resource === 'none' && (view.location === 'page' || (manifest.apiVersion >= 2 && view.location === 'context'))))
     context.addIssue({ code: 'custom', message: 'Navigation must reference a page view' })
   if (manifest.apiVersion === 1 && (manifest.contributes.placements.length || manifest.permissions.controls.length))
     context.addIssue({ code: 'custom', message: 'UI placements and controls require API 2' })
+  if (manifest.apiVersion < 3 && manifest.contributes.placements.some(placement => placement.kind === 'slot'))
+    context.addIssue({ code: 'custom', message: 'Content slots require API 3' })
+  if (manifest.apiVersion < 3 && (manifest.contributes.menus.length || manifest.permissions.selectedContent || manifest.contributes.placements.some(placement => placement.kind === 'view' && placement.target === 'workbench.pane')))
+    context.addIssue({ code: 'custom', message: 'Menus, selected content and pane mounts require API 3' })
+  const slashNames = new Set<string>()
+  for (const command of manifest.contributes.commands) {
+    if (!command.slash)
+      continue
+    if (manifest.apiVersion < 3 || command.hidden || slashNames.has(command.slash.name))
+      context.addIssue({ code: 'custom', message: 'Slash commands require API 3, visible commands and unique names within the plugin' })
+    slashNames.add(command.slash.name)
+  }
+  for (const menu of manifest.contributes.menus) {
+    if (!manifest.contributes.commands.some(command => command.id === menu.command))
+      context.addIssue({ code: 'custom', message: 'Menus must reference an owned command' })
+  }
   for (const placement of manifest.contributes.placements) {
     const view = manifest.contributes.views.find(view => view.id === placement.view)
     if (!view || view.resource !== 'none' || view.location !== 'context')
       context.addIssue({ code: 'custom', message: 'Placements require a resource-free view definition' })
+    if (placement.kind === 'view' && placement.interaction && (manifest.apiVersion < 3 || !['workbench', 'workbench.pane'].includes(placement.target) || placement.presentation.position !== 'absolute'))
+      context.addIssue({ code: 'custom', message: 'Interactions require API 3 and an absolute workbench or pane mount' })
     if (placement.kind === 'decoration' && !manifest.permissions.windowEffects)
       context.addIssue({ code: 'custom', message: 'Decorations require windowEffects permission' })
     if (placement.kind === 'control' && !manifest.permissions.controls.includes(placement.target))
@@ -123,6 +155,7 @@ export function addedExtensionPermissions(previous: ExtensionPermissions | undef
     ...(next.notifications && !previous?.notifications ? ['notifications'] : []),
     ...(next.schedules && !previous?.schedules ? ['schedules'] : []),
     ...(next.selectedResource === 'read' && previous?.selectedResource !== 'read' ? ['selectedResource:read'] : []),
+    ...(next.selectedContent && !previous?.selectedContent ? ['selectedContent'] : []),
     ...(next.localResources && !previous?.localResources ? ['localResources'] : []),
     ...(next.resourceExport && !previous?.resourceExport ? ['resourceExport'] : []),
     ...next.network.filter(origin => !previous?.network.includes(origin)).map(origin => `network:${origin}`),
diff --git a/apps/buddy/shared/workbench/workbenchCommand.ts b/apps/buddy/shared/workbench/workbenchCommand.ts
new file mode 100644
index 00000000..b4a8a520
--- /dev/null
+++ b/apps/buddy/shared/workbench/workbenchCommand.ts
@@ -0,0 +1,12 @@
+import { z } from 'zod'
+
+export const workbenchSlashSchema = z.object({ name: z.string().min(1).max(64).regex(/^[a-z][a-z0-9-]*$/), description: z.string().max(200).optional() }).strict()
+export function qualifyWorkbenchCommand(namespace: string, name: string): string {
+  return `${namespace}:${name}`
+}
+
+export interface WorkbenchSlashCommand { id: string, name: string, title: string, description?: string }
+export function parseSlashInvocation(value: string): { name: string, arguments: string } | null {
+  const match = /^\/(\S+)(?:\s([\s\S]*))?$/u.exec(value.trim())
+  return match ? { name: match[1]!, arguments: match[2]?.trimStart() ?? '' } : null
+}
diff --git a/apps/buddy/shared/workbench/workbenchContributionCatalog.ts b/apps/buddy/shared/workbench/workbenchContributionCatalog.ts
new file mode 100644
index 00000000..c022fab8
--- /dev/null
+++ b/apps/buddy/shared/workbench/workbenchContributionCatalog.ts
@@ -0,0 +1,96 @@
+import { z } from 'zod'
+
+interface TargetDefinition {
+  title: { 'zh-CN': string, 'en-US': string }
+  scope: 'application' | 'page' | 'pane' | 'composer' | 'resource' | 'message'
+  description: string
+}
+interface ContentDefinition extends TargetDefinition {
+  selection: 'single' | 'multiple'
+  height: { min: number, max: number, default: number }
+}
+
+export const workbenchSlots = {
+  'composer.footer': { title: { 'zh-CN': '输入区下方', 'en-US': 'Below the composer' }, scope: 'composer', selection: 'single', height: { min: 20, max: 48, default: 28 }, description: 'Replace the short footer below each composer. The built-in reminder returns when unavailable.' },
+  'composer.accessory': { title: { 'zh-CN': '输入辅助区', 'en-US': 'Composer accessories' }, scope: 'composer', selection: 'multiple', height: { min: 32, max: 240, default: 64 }, description: 'Add independent panels above each composer. Selected providers appear in user order; no draft content is shared.' },
+  'task.welcome': { title: { 'zh-CN': '新任务欢迎区', 'en-US': 'New task welcome' }, scope: 'pane', selection: 'single', height: { min: 64, max: 400, default: 240 }, description: 'Replace the welcome artwork and greeting while a task has no messages. The composer remains host-owned.' },
+  'workbench.pane.empty': { title: { 'zh-CN': '空白分屏', 'en-US': 'Empty pane' }, scope: 'pane', selection: 'single', height: { min: 64, max: 640, default: 240 }, description: 'Replace the empty surface of a pane without a view. Unavailable providers restore the built-in launcher.' },
+} as const satisfies Record<string, ContentDefinition>
+
+export const workbenchControls = {
+  'model.reasoning': { title: { 'zh-CN': '思考等级控件', 'en-US': 'Reasoning control' }, scope: 'composer', selection: 'single', height: { min: 32, max: 160, default: 64 }, description: 'Replace the reasoning selector using host-owned options and revision-checked proposals. Requires controls permission.' },
+} as const satisfies Record<string, ContentDefinition>
+
+export const workbenchMounts = {
+  'workbench': { title: { 'zh-CN': '工作台', 'en-US': 'Workbench' }, scope: 'application', description: 'Persistent mount across pages. Supports static or absolute presentation and placements.show/hide.' },
+  'app.sidebar': { title: { 'zh-CN': '应用侧栏', 'en-US': 'Application sidebar' }, scope: 'application', description: 'Mount within the application sidebar.' },
+  'workbench.sidebar': { title: { 'zh-CN': '任务侧栏', 'en-US': 'Task sidebar' }, scope: 'page', description: 'Mount within the task sidebar; the view is parked while the sidebar is unavailable.' },
+  'workbench.pane': { title: { 'zh-CN': '分屏区域', 'en-US': 'Pane' }, scope: 'pane', description: 'Mount in a specific pane. Pass the originating instanceId to placements.show/hide; omission selects the active pane. Each pane has independent view state.' },
+} as const satisfies Record<string, TargetDefinition>
+
+export const workbenchMenus = {
+  'composer.actions': { title: { 'zh-CN': '输入操作', 'en-US': 'Composer actions' }, scope: 'composer', description: 'Commands next to composer tools. A click may share draft text with selectedContent permission. Returning {insertText:string} inserts plain text only if the captured draft is unchanged; it never sends.' },
+  'task.actions': { title: { 'zh-CN': '任务操作', 'en-US': 'Task actions' }, scope: 'pane', description: 'Commands in the task header. Receives the originating pane instanceId, without task identity or history.' },
+  'resource.actions': { title: { 'zh-CN': '文件操作', 'en-US': 'File actions' }, scope: 'resource', description: 'Commands for the selected file. selectedResource:read grants an opaque handle through existing directory authorization.' },
+  'message.actions': { title: { 'zh-CN': '消息操作', 'en-US': 'Message actions' }, scope: 'message', description: 'Commands on a completed message. A click may share that message text with selectedContent permission; no conversation history is shared.' },
+} as const satisfies Record<string, TargetDefinition>
+
+export const workbenchDecorations = {
+  'app.sidebar': { title: { 'zh-CN': '应用侧栏装饰', 'en-US': 'Application sidebar decoration' }, scope: 'application', description: 'Noninteractive decoration; windowEffects permission required.' },
+  'workbench.sidebar': { title: { 'zh-CN': '任务侧栏装饰', 'en-US': 'Task sidebar decoration' }, scope: 'page', description: 'Noninteractive task-sidebar decoration.' },
+  'workbench.pane': { title: { 'zh-CN': '分屏装饰', 'en-US': 'Pane decoration' }, scope: 'pane', description: 'Independent noninteractive decoration per pane; receives local geometry and filtered input activity.' },
+  'composer.input': { title: { 'zh-CN': '输入框装饰', 'en-US': 'Composer decoration' }, scope: 'composer', description: 'Noninteractive decoration per input; activity includes caret geometry, never text or keys.' },
+} as const satisfies Record<string, TargetDefinition>
+
+export const workbenchRuntimeCapabilities = {
+  'commands': { title: { 'zh-CN': '注册输入命令', 'en-US': 'Registered commands' }, scope: 'application', description: 'API 3 commands may declare slash:{name,description?}. Host exposes /plugin-name:name only (plugin-name is the part after the publisher in the plugin ID); top-level names are system-owned. Local names match [a-z][a-z0-9-]* (max 64). Titles and descriptions may be localized. Duplicate local names or invalid/missing handler registrations fail validation or activation. Another active plugin using the same plugin namespace prevents activation. Slash executes exact names with string arguments and origin pane; no model request. See commands.md.' },
+  'workbench.panes': { title: { 'zh-CN': '分屏布局订阅', 'en-US': 'Pane snapshots' }, scope: 'application', description: 'API 3 host workbench.panes and onPanesChange expose opaque id, active, visible, and rect relative to the workbench mount. Subscribe to layout and visibility changes; no task identity, history, or DOM access. See interactions.md.' },
+  'workbench.interactions': { title: { 'zh-CN': '临时交互', 'en-US': 'Transient interactions' }, scope: 'application', description: 'API 3 interactions.start(title) returns id, AbortSignal, end(). Mount placements on workbench/workbench.pane declare interaction:regions or exclusive and require {interactionId,instanceId?}. Host exit and Escape revoke views without waiting for plugin cleanup. Regions mode only receives declared hit regions via view.interaction; other pixels pass through. Sessions never restore after restart. See interactions.md.' },
+} as const satisfies Record<string, TargetDefinition>
+
+function keys<T extends Record<string, unknown>>(entries: T): [keyof T & string, ...(keyof T & string)[]] {
+  return Object.keys(entries) as [keyof T & string, ...(keyof T & string)[]]
+}
+export const workbenchSlotSchema = z.enum(keys(workbenchSlots))
+export const workbenchControlSchema = z.enum(keys(workbenchControls))
+export const workbenchMountTargetSchema = z.enum(keys(workbenchMounts))
+export const workbenchMenuSchema = z.enum(keys(workbenchMenus))
+export const workbenchAnchorSchema = z.enum(keys(workbenchDecorations))
+export type WorkbenchSlot = keyof typeof workbenchSlots
+export type WorkbenchControl = keyof typeof workbenchControls
+export type WorkbenchMountTarget = keyof typeof workbenchMounts
+export type WorkbenchMenu = keyof typeof workbenchMenus
+export type WorkbenchAnchor = keyof typeof workbenchDecorations
+
+function catalog<K extends string, T extends Record<string, TargetDefinition>>(kind: K, targets: T) {
+  return keys(targets).map(target => ({ kind, target, ...targets[target] }))
+}
+export const workbenchUiTargetCatalog = [...catalog('control', workbenchControls), ...catalog('slot', workbenchSlots)]
+export type WorkbenchUiSelectionTarget = Pick<(typeof workbenchUiTargetCatalog)[number], 'kind' | 'target'>
+export const workbenchContributionCatalog = [...workbenchUiTargetCatalog, ...catalog('mount', workbenchMounts), ...catalog('menu', workbenchMenus), ...catalog('decoration', workbenchDecorations), ...catalog('runtime', workbenchRuntimeCapabilities)]
+export const workbenchCapabilityKinds = ['slot', 'control', 'mount', 'menu', 'decoration', 'runtime'] as const
+export const workbenchCapabilityQuerySchema = z.object({ kind: z.enum(workbenchCapabilityKinds).optional(), target: z.string().min(1).max(100).optional() }).strict()
+export function queryWorkbenchCapabilities(query: z.infer<typeof workbenchCapabilityQuerySchema>) {
+  return workbenchContributionCatalog.filter(entry => (!query.kind || entry.kind === query.kind) && (!query.target || entry.target === query.target))
+}
+export function workbenchUiSelectionKey(selection: WorkbenchUiSelectionTarget): string {
+  return `workbench.${selection.kind === 'control' ? 'controls' : 'slots'}.${selection.target}`
+}
+export function parseWorkbenchUiSelection(value: unknown, multiple: boolean): string[] | null {
+  if (typeof value !== 'string')
+    return null
+  if (!value)
+    return []
+  if (!multiple)
+    return value.length <= 180 ? [value] : null
+  try {
+    const parsed: unknown = JSON.parse(value)
+    return Array.isArray(parsed) && parsed.length <= 8 && parsed.every(id => typeof id === 'string' && id.length > 0 && id.length <= 180) && new Set(parsed).size === parsed.length ? parsed : null
+  }
+  catch {
+    return null
+  }
+}
+export function workbenchMountKey(target: WorkbenchMountTarget, instanceId?: string | null): string {
+  return workbenchMounts[target].scope === 'pane' ? `${target}:${instanceId ?? ''}` : target
+}
diff --git a/apps/buddy/shared/workbench/workbenchInteraction.ts b/apps/buddy/shared/workbench/workbenchInteraction.ts
new file mode 100644
index 00000000..a3224097
--- /dev/null
+++ b/apps/buddy/shared/workbench/workbenchInteraction.ts
@@ -0,0 +1,10 @@
+import { z } from 'zod'
+
+export const workbenchRectSchema = z.object({ x: z.number().finite(), y: z.number().finite(), width: z.number().finite().nonnegative(), height: z.number().finite().nonnegative() }).strict()
+export const workbenchPaneSnapshotSchema = z.object({ id: z.string().uuid(), active: z.boolean(), visible: z.boolean(), rect: workbenchRectSchema }).strict()
+export const workbenchPanesSchema = z.array(workbenchPaneSnapshotSchema).max(16).refine(panes => new Set(panes.map(pane => pane.id)).size === panes.length)
+export type WorkbenchPaneSnapshot = z.infer<typeof workbenchPaneSnapshotSchema>
+export const workbenchHitRegionsSchema = z.array(z.object({ id: z.string().min(1).max(80), label: z.string().min(1).max(120), rect: workbenchRectSchema }).strict()).max(64).refine(regions => new Set(regions.map(region => region.id)).size === regions.length)
+export type WorkbenchHitRegion = z.infer<typeof workbenchHitRegionsSchema>[number]
+export interface WorkbenchRegionActivation { id: string, x: number, y: number }
+export interface WorkbenchInteraction { id: string, title: string }
diff --git a/apps/buddy/shared/workbench/workbenchUi.ts b/apps/buddy/shared/workbench/workbenchUi.ts
index dcf165ce..dc0bc6e2 100644
--- a/apps/buddy/shared/workbench/workbenchUi.ts
+++ b/apps/buddy/shared/workbench/workbenchUi.ts
@@ -1,8 +1,8 @@
+import type { WorkbenchAnchor, WorkbenchMountTarget } from './workbenchContributionCatalog'
 import { z } from 'zod'
+import { workbenchMountTargetSchema } from './workbenchContributionCatalog'
 
-export const workbenchAnchorSchema = z.enum(['app.sidebar', 'workbench.sidebar', 'workbench.pane', 'composer.input'])
-export const workbenchControlSchema = z.enum(['model.reasoning'])
-export const workbenchMountTargetSchema = z.enum(['workbench', 'app.sidebar', 'workbench.sidebar'])
+export * from './workbenchContributionCatalog'
 const mountLengthSchema = z.union([z.number().min(0).max(8192), z.string().regex(/^(?:100|\d{1,2})(?:\.\d{1,3})?%$/).refine(value => Number.parseFloat(value) <= 100)])
 export const workbenchPresentationSchema = z.object({
   target: workbenchMountTargetSchema.optional(),
@@ -18,12 +18,10 @@ export const workbenchPresentationSchema = z.object({
 }).strict()
 export const extensionPresentationRequestSchema = workbenchPresentationSchema
 export type WorkbenchPresentation = z.infer<typeof workbenchPresentationSchema>
-export type WorkbenchMountTarget = z.infer<typeof workbenchMountTargetSchema>
-export type WorkbenchAnchor = z.infer<typeof workbenchAnchorSchema>
-export type WorkbenchControl = z.infer<typeof workbenchControlSchema>
 
 export interface MountGeometry {
   target: WorkbenchMountTarget
+  instanceId?: string
   visible: boolean
   width: number
   height: number
diff --git a/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue b/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue
index c626af13..e9c86030 100644
--- a/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue
+++ b/apps/buddy/src/app/bootstrap/DesktopAppProvider.vue
@@ -3,12 +3,12 @@ import type { DesktopShellBindings } from '../shell/desktopShellBindings'
 import type { DesktopBrowserGuestSurfaceHost } from '@/platform/browser/browserGuestSurface'
 import { DEFAULT_DESKTOP_CHAT_PREFERENCES } from '@buddy-electron/shared/desktopApi'
 import { useMessage } from 'naive-ui'
-import { computed, nextTick, onScopeDispose, provide, toRef, useTemplateRef, watch } from 'vue'
+import { computed, nextTick, onMounted, onScopeDispose, provide, ref, toRef, useTemplateRef, watch } from 'vue'
 import { useRouter } from 'vue-router'
 import { resolveBuddyLocale, translateBuddy } from '@/i18n/buddyI18n'
 import { useProvideAutomationContext } from '@/modules/automations'
-import { useExtensionState, useExtensionViews, useProvideExtensionContext } from '@/modules/extensions'
-import { DesktopExtensionControl, DesktopExtensionFrameHost, DesktopExtensionOverlays, DesktopExtensionReviewHost } from '@/modules/extensions/ui'
+import { useExtensionState, useExtensionUiContributions, useExtensionViews, useProvideExtensionContext } from '@/modules/extensions'
+import { DesktopExtensionControl, DesktopExtensionFrameHost, DesktopExtensionMenu, DesktopExtensionOverlays, DesktopExtensionReviewHost, DesktopExtensionSlot } from '@/modules/extensions/ui'
 import { useProvideSettingsContext } from '@/modules/settings'
 import { useProvideSkillsContext } from '@/modules/skills'
 import { useProvideTaskEnvironment, useTaskIndex, useTaskResourcePanel } from '@/modules/tasks'
@@ -16,9 +16,11 @@ import DesktopBrowserGuestHost from '@/platform/browser/DesktopBrowserGuestHost.
 import { useBrowserGuestHost } from '@/platform/browser/useBrowserGuestHost'
 import { requireDesktopApi } from '@/platform/desktop/desktopApi'
 import { runtimeAvailabilityKey } from '@/platform/runtime/runtimeAvailability'
+import { useProvideWorkbenchCommands } from '@/shared/ui/contributions/workbenchCommands'
 import { useProvideWorkbenchUi } from '@/shared/ui/contributions/workbenchUiContext'
 import { useProvideDesktopUi } from '@/shared/ui/desktopUiContext'
 import { SemanticAnchorRegistry } from '@/workbench/browser/surfaces/SemanticAnchorRegistry'
+import { WorkbenchPaneRegistry } from '@/workbench/browser/surfaces/WorkbenchPaneRegistry'
 import WorkbenchSurfaceHost from '@/workbench/browser/surfaces/WorkbenchSurfaceHost.vue'
 import { useDesktopPages } from '../router/useDesktopPages'
 import { useDesktopShellState } from '../shell/useDesktopShellState'
@@ -55,6 +57,32 @@ const workbench = useDesktopWorkbench({ api, stores, taskIndex, router, resource
 provide(desktopWorkbenchKey, workbench)
 const extensions = useExtensionState(api.extensions)
 const pages = useDesktopPages(router, extensions.installed, stores.applicationSettings.language)
+const paneRegistry = new WorkbenchPaneRegistry(() => workbench.controller.layout.activePane)
+onMounted(() => paneRegistry.start())
+onScopeDispose(() => paneRegistry.dispose())
+onScopeDispose(workbench.controller.subscribe(paneRegistry.invalidate))
+onScopeDispose(paneRegistry.subscribe(() => {
+  void api.extensions.updatePanes(paneRegistry.snapshot).catch(() => {})
+}))
+const commandRevision = ref(0)
+onScopeDispose(workbench.controller.registry.subscribe(() => commandRevision.value++))
+onScopeDispose(workbench.controller.subscribe(() => commandRevision.value++))
+useProvideWorkbenchCommands({
+  reportFailure: () => message.error(translateBuddy(stores.applicationSettings.language.value, 'desktop.command.inputFailed')),
+  entries: computed(() => {
+    void commandRevision.value
+    return [...workbench.controller.registry.commands.values()].flatMap(command => command.slash && (!command.enabled || command.enabled(workbench.controller.context)) ? [{ id: command.id, name: command.slash.name, title: command.label, description: command.slash.description }] : [])
+  }),
+  execute: async (id, argumentsText, instanceId) => {
+    const controller = workbench.controller
+    const command = controller.registry.commands.get(id)
+    const pane = instanceId ? controller.pane(instanceId) : controller.context.pane
+    const context = { ...controller.context, pane, source: 'slash' as const, arguments: argumentsText }
+    if (!command?.slash || (instanceId && !pane) || (command.enabled && !command.enabled(context)))
+      throw new Error('EXTENSION_COMMAND_UNAVAILABLE')
+    return (await command.execute(context) ?? null) as import('@buddy-shared/workbench/workbenchState').JsonValue
+  },
+})
 const extensionViews = useExtensionViews(api.extensions, extensions.installed, computed(() => pages.context.value.values))
 watch(() => pages.context.value.values, (values, _, cleanup) => {
   const leases = Object.entries(values).map(([key, value]) => workbench.controller.contextKeys.set(key, value))
@@ -63,9 +91,10 @@ watch(() => pages.context.value.values, (values, _, cleanup) => {
 }, { immediate: true, flush: 'sync' })
 const anchors = new SemanticAnchorRegistry()
 onScopeDispose(() => anchors.dispose())
-useProvideWorkbenchUi({ anchors, controlRenderer: DesktopExtensionControl })
-const controls = useExtensionContributions({ controller: workbench.controller, renderers: workbench.renderers, persistence: workbench.persistence, installed: extensions.installed, api: api.extensions, views: extensionViews, ready: () => workbench.initialized })
-useProvideExtensionContext({ state: extensions, views: extensionViews, anchors, controls, workbench: pages.context, language: stores.applicationSettings.language, isDark: toRef(() => props.isDark), startCreation: prompt => workbench.startTaskWithSkill('plugin-creator', prompt), focusView: (id) => {
+useProvideWorkbenchUi({ anchors, panes: paneRegistry, controlRenderer: DesktopExtensionControl, slotRenderer: DesktopExtensionSlot, menuRenderer: DesktopExtensionMenu })
+useExtensionContributions({ controller: workbench.controller, renderers: workbench.renderers, persistence: workbench.persistence, installed: extensions.installed, api: api.extensions, views: extensionViews, ready: () => workbench.initialized })
+const ui = useExtensionUiContributions(extensions.installed, workbench.controller.configuration)
+useProvideExtensionContext({ state: extensions, views: extensionViews, anchors, ui, workbench: pages.context, language: stores.applicationSettings.language, isDark: toRef(() => props.isDark), startCreation: prompt => workbench.startTaskWithSkill('plugin-creator', prompt), endInteraction: id => workbench.controller.interactions.end(id), focusView: (id) => {
   workbench.controller.focus(id)
 } })
 onScopeDispose(workbench.controller.subscribe(() => void nextTick(extensionViews.layout)))
diff --git a/apps/buddy/src/app/workbench/DesktopTaskContribution.vue b/apps/buddy/src/app/workbench/DesktopTaskContribution.vue
index f60c2dfd..3c826d12 100644
--- a/apps/buddy/src/app/workbench/DesktopTaskContribution.vue
+++ b/apps/buddy/src/app/workbench/DesktopTaskContribution.vue
@@ -41,12 +41,14 @@ async function load() {
     if (disposed)
       return
     task.value = loaded
-    if (workbench.controller.owner(props.view.id)?.id === workbench.controller.layout.activePane)
+    if (props.visible && workbench.controller.owner(props.view.id)?.id === workbench.controller.layout.activePane)
       workbench.activeTask.value = loaded
   }
   catch {
-    if (!disposed)
+    if (!disposed) {
       failed.value = true
+      workbench.controller.navigation.fail(props.view.id)
+    }
   }
 }
 watch(() => props.view.resource.id, load, { immediate: true })
@@ -62,7 +64,7 @@ watch(() => props.visible, (visible) => {
 
 <template>
   <DesktopTaskViewProvider v-if="task" :context="context">
-    <DesktopTaskEditor :reading-positions="workbench.readingPositions">
+    <DesktopTaskEditor :active="visible" :reading-positions="workbench.readingPositions" @ready="workbench.controller.navigation.ready(view.id)">
       <template #title>
         <WorkbenchPaneTitle :view="view" />
       </template>
diff --git a/apps/buddy/src/app/workbench/DesktopWorkbenchArea.vue b/apps/buddy/src/app/workbench/DesktopWorkbenchArea.vue
index 1ab9ee65..d5ec59ec 100644
--- a/apps/buddy/src/app/workbench/DesktopWorkbenchArea.vue
+++ b/apps/buddy/src/app/workbench/DesktopWorkbenchArea.vue
@@ -14,7 +14,11 @@ import WorkbenchSurface from '@/workbench/browser/WorkbenchSurface.vue'
 import DesktopDirectoryFileSurface from './DesktopDirectoryFileSurface.vue'
 
 const props = defineProps<{ bindings: DesktopShellBindings, tasksVisible: boolean }>()
-const { layout, revision, labels } = useWorkbench()
+const { controller, layout, revision, labels } = useWorkbench()
+const pendingTaskIds = computed(() => {
+  void revision.value
+  return [...controller.navigation.entries.values()].filter(entry => entry.status === 'loading' && entry.view.resource.scheme === 'task').map(entry => entry.view.resource.id)
+})
 const { language } = useDesktopUi()
 const sidebar = props.bindings.taskIndex.sidebar
 const collapsed = computed({ get: () => sidebar.collapsed.value, set: value => void sidebar.setCollapsed(value) })
@@ -48,7 +52,7 @@ function focusContext() {
   <WorkbenchLayout v-model:sidebar-collapsed="collapsed" v-model:sidebar-width="width" :language="language" :context-visible="(tasksVisible || bindings.contextPanelGlobal.value) && bindings.resources.isOpen.value" :sidebar-collapsible="tasksVisible" :sidebar-resizable="tasksVisible">
     <template v-if="tasksVisible" #sidebar>
       <WorkbenchMountPoint target="workbench.sidebar">
-        <DesktopTaskIndexView :index="bindings.taskIndex" :active-task-id="bindings.workbench.activeTask.value?.session.activeTaskId.value ?? null" @open-task="bindings.workbench.openTask" @new-task="bindings.workbench.newTask" />
+        <DesktopTaskIndexView :pending-task-ids="pendingTaskIds" :index="bindings.taskIndex" :active-task-id="bindings.workbench.activeTask.value?.session.activeTaskId.value ?? null" @open-task="bindings.workbench.openTask" @new-task="bindings.workbench.newTask" />
       </WorkbenchMountPoint>
     </template>
     <div v-show="tasksVisible" class="desktop-workbench-area__tasks">
diff --git a/apps/buddy/src/app/workbench/TaskWorkspacePool.ts b/apps/buddy/src/app/workbench/TaskWorkspacePool.ts
index f9277f5f..5b9f9010 100644
--- a/apps/buddy/src/app/workbench/TaskWorkspacePool.ts
+++ b/apps/buddy/src/app/workbench/TaskWorkspacePool.ts
@@ -30,23 +30,26 @@ export class TaskWorkspacePool {
     const existing = this.#entries.get(key)
     if (existing)
       return Promise.resolve(existing.task)
-    const open = this.#load(resource).finally(() => this.#loading.delete(key))
+    const open: Promise<TaskCapability> = Promise.resolve().then(() => this.#load(resource, () => this.#loading.get(key) === open)).finally(() => {
+      if (this.#loading.get(key) === open)
+        this.#loading.delete(key)
+    })
     this.#loading.set(key, open)
     return open
   }
 
-  async #load(resource: ResourceRef): Promise<TaskCapability> {
+  async #load(resource: ResourceRef, current: () => boolean): Promise<TaskCapability> {
     if (resource.scheme === 'draft')
       await this.prepareLayout()
     const conversation = resource.scheme === 'task' ? await this.#options.api.localChat.conversations.get(resource.id) : null
-    if ((resource.scheme === 'task' && !conversation) || this.#disposed || conversation?.deletedAt || (this.#retained && !this.#retained.has(resourceKey(resource))))
+    if (!current() || (resource.scheme === 'task' && !conversation) || this.#disposed || conversation?.deletedAt || (this.#retained && !this.#retained.has(resourceKey(resource))))
       throw new Error('TASK_UNAVAILABLE')
     if (conversation) {
       if (!this.#options.index.data.conversations.value.some(item => item.id === conversation.id))
         await this.#options.index.data.refreshConversations()
       this.#options.index.data.applyConversation(conversation)
     }
-    if (this.#disposed || (this.#retained && !this.#retained.has(resourceKey(resource))))
+    if (!current() || this.#disposed || (this.#retained && !this.#retained.has(resourceKey(resource))))
       throw new Error('TASK_UNAVAILABLE')
     const scope = effectScope(true)
     let currentResource = resource
@@ -96,6 +99,10 @@ export class TaskWorkspacePool {
   retain(resources: ResourceRef[]): void {
     const keys = new Set(resources.map(resourceKey))
     this.#retained = keys
+    for (const key of this.#loading.keys()) {
+      if (!keys.has(key))
+        this.#loading.delete(key)
+    }
     for (const [key, entry] of this.#entries) {
       if (keys.has(key))
         continue
diff --git a/apps/buddy/src/app/workbench/__tests__/useExtensionContributions.spec.ts b/apps/buddy/src/app/workbench/__tests__/useExtensionContributions.spec.ts
index e3a77dff..4b0cb20a 100644
--- a/apps/buddy/src/app/workbench/__tests__/useExtensionContributions.spec.ts
+++ b/apps/buddy/src/app/workbench/__tests__/useExtensionContributions.spec.ts
@@ -4,11 +4,12 @@ import type { ExtensionViews } from '@/modules/extensions'
 import type { WorkbenchPersistence } from '@/workbench/services/WorkbenchPersistence'
 import { extensionManifestSchema } from '@buddy-shared/extensions/extensionManifest'
 import { deferred } from '@buddy-tests/deferred'
-import { afterEach, expect, it } from 'vitest'
+import { afterEach, expect, it, vi } from 'vitest'
 import { effectScope, nextTick, shallowRef } from 'vue'
+import { useExtensionUiContributions } from '@/modules/extensions'
 import { ViewRendererRegistry } from '@/workbench/browser/ViewRendererRegistry'
 import { ContributionRegistry } from '@/workbench/services/ContributionRegistry'
-import { WorkbenchController } from '@/workbench/services/WorkbenchController'
+import { restoreWorkbenchLayout, WorkbenchController } from '@/workbench/services/WorkbenchController'
 import { useExtensionContributions } from '../useExtensionContributions'
 
 const scopes: ReturnType<typeof effectScope>[] = []
@@ -21,7 +22,7 @@ function setup() {
   controller.registry.register('configuration', scope => scope.configuration({ id: 'workbench.controls.model.reasoning', defaultValue: '', validate: value => typeof value === 'string' }))
   const replies = new Map<string, string | null>()
   let receive: (event: ExtensionWorkbenchEvent) => void = () => {}
-  const api: Partial<ExtensionApi> = { onWorkbench: (listener) => {
+  const api: Partial<ExtensionApi> = { endInteraction: async () => {}, onWorkbench: (listener) => {
     receive = listener
     return () => {}
   }, replyWorkbench: (id, view) => replies.set(id, view) }
@@ -29,8 +30,9 @@ function setup() {
   const persistence = { flush: async () => {} } as unknown as WorkbenchPersistence
   const scope = effectScope()
   scopes.push(scope)
-  const contributions = scope.run(() => useExtensionContributions({ controller, renderers: new ViewRendererRegistry(), persistence, installed, api: api as ExtensionApi, views, ready: () => ready.value }))!
-  const show = (): ExtensionWorkbenchEvent => ({ kind: 'placement', requestId: crypto.randomUUID(), extensionId: status.manifest.id, generation: status.generation!, placementId: 'tests.music.dock', visible: true })
+  scope.run(() => useExtensionContributions({ controller, renderers: new ViewRendererRegistry(), persistence, installed, api: api as ExtensionApi, views, ready: () => ready.value }))!
+  const contributions = scope.run(() => useExtensionUiContributions(installed, controller.configuration))!
+  const show = (): Extract<ExtensionWorkbenchEvent, { kind: 'placement' }> => ({ kind: 'placement', requestId: crypto.randomUUID(), extensionId: status.manifest.id, generation: status.generation!, placementId: 'tests.music.dock', visible: true })
   return { installed, ready, controller, status, contributions, views, replies, show, receive: (event: ExtensionWorkbenchEvent) => receive(event) }
 }
 async function settle() {
@@ -98,10 +100,76 @@ it('rebinds an updated placement without duplicating its view or replacing saved
   expect(fixture.controller.layout.views[id]?.state).toEqual({ version: 1, value: { volume: 0.37 } })
 })
 
+it.each(['running', 'restoring'])('migrates a global placement into the active pane with its saved identity and state when %s', async (mode) => {
+  const f = setup()
+  f.ready.value = true
+  f.controller.registry.register('tasks', scope => scope.view({ id: 'task', renderer: 'task', label: 'Task', locations: ['main'], supports: () => true, multiple: false }))
+  await f.controller.open({ scheme: 'task', id: 'one', data: {} }, 'One', { viewType: 'task' })
+  const first = f.controller.layout.activePane
+  await f.controller.open({ scheme: 'task', id: 'two', data: {} }, 'Two', { viewType: 'task', direction: 'right' })
+  const second = f.controller.layout.activePane
+  const original = f.show()
+  f.receive(original)
+  await settle()
+  const id = f.replies.get(original.requestId)!
+  const state = { version: 1, value: { volume: 0.37 } }
+  f.controller.updateView(id, { state })
+  if (mode === 'restoring') {
+    f.ready.value = false
+    f.controller.layout = restoreWorkbenchLayout(JSON.parse(JSON.stringify(f.controller.layout)))
+  }
+  const manifest = extensionManifestSchema.parse({ ...f.status.manifest, apiVersion: 3, version: '2.0.0', contributes: { ...f.status.manifest.contributes, views: f.status.manifest.contributes.views.map(view => ({ ...view, stateVersion: 2 })), placements: [{ id: 'tests.music.dock', kind: 'view', view: 'tests.music.player', target: 'workbench.pane' }] } })
+  f.installed.value = [{ ...f.status, manifest, revision: 'pane-package' }]
+  const reopened = f.show()
+  f.receive(reopened)
+  f.ready.value = true
+  await settle()
+  expect(f.replies.get(reopened.requestId)).toBe(id)
+  expect(Object.values(f.controller.layout.views).filter(view => view.resource.scheme === 'extension')).toHaveLength(1)
+  expect(f.controller.layout.views[id]).toMatchObject({ id, mountInstanceId: second, state })
+  f.controller.activate(first)
+  f.installed.value = [...f.installed.value]
+  expect(f.controller.layout.views[id]?.mountInstanceId).toBe(second)
+  const otherPane = { ...f.show(), kind: 'placement' as const, instanceId: first }
+  f.receive(otherPane)
+  await settle()
+  const otherId = f.replies.get(otherPane.requestId)!
+  expect(otherId).not.toBe(id)
+  expect(f.controller.layout.views[otherId]).toMatchObject({ mountInstanceId: first, state: { version: 2, value: {} } })
+  expect(restoreWorkbenchLayout(JSON.parse(JSON.stringify(f.controller.layout))).views[id]).toMatchObject({ id, mountInstanceId: second, state })
+})
+
+it('migrates a pane placement to global scope without retaining the old pane lifecycle', async () => {
+  const f = setup()
+  f.ready.value = true
+  f.installed.value = [{ ...f.status, revision: 'pane-package', manifest: extensionManifestSchema.parse({ ...f.status.manifest, apiVersion: 3, contributes: { ...f.status.manifest.contributes, placements: [{ id: 'tests.music.dock', kind: 'view', view: 'tests.music.player', target: 'workbench.pane' }] } }) }]
+  f.controller.registry.register('tasks', scope => scope.view({ id: 'task', renderer: 'task', label: 'Task', locations: ['main'], supports: () => true, multiple: false }))
+  await f.controller.open({ scheme: 'task', id: 'one', data: {} }, 'One', { viewType: 'task' })
+  const task = (await f.controller.open({ scheme: 'task', id: 'two', data: {} }, 'Two', { viewType: 'task', direction: 'right' }))!
+  const pane = f.controller.layout.activePane
+  const original = f.show()
+  f.receive(original)
+  await settle()
+  const id = f.replies.get(original.requestId)!
+  const state = { version: 1, value: { volume: 0.37 } }
+  f.controller.updateView(id, { state })
+  expect(f.controller.layout.views[id]?.mountInstanceId).toBe(pane)
+  f.installed.value = [f.status]
+  const reopened = f.show()
+  f.receive(reopened)
+  await settle()
+  expect(f.replies.get(reopened.requestId)).toBe(id)
+  expect(f.controller.layout.views[id]?.mountInstanceId).toBeUndefined()
+  await f.controller.close(task)
+  expect(f.controller.pane(pane)).toBeNull()
+  expect(Object.values(f.controller.layout.views).filter(view => view.resource.scheme === 'extension')).toHaveLength(1)
+  expect(restoreWorkbenchLayout(JSON.parse(JSON.stringify(f.controller.layout))).views[id]).toMatchObject({ id, state })
+})
+
 it('restores control selection without relying on unrelated layout changes', () => {
   const fixture = setup()
   fixture.controller.configuration.restore({ 'workbench.controls.model.reasoning': 'tests.reasoning.control' })
-  expect(fixture.contributions.selection.value['model.reasoning']).toBe('tests.reasoning.control')
+  expect(fixture.contributions.entries.value.find(entry => entry.target === 'model.reasoning')!.selected[0]).toBe('tests.reasoning.control')
 })
 
 it('rejects an obsolete token when a view is reopened in the same host', async () => {
@@ -137,3 +205,72 @@ it('persists presentation separately from plugin state and ignores expired sessi
   await settle()
   expect(f.controller.layout.views[id]?.presentation?.height).toBe(280)
 })
+
+it('keeps pane placements independent across focus, close and restore', async () => {
+  const f = setup()
+  f.ready.value = true
+  f.installed.value = [{ ...f.status, revision: 'pane-package', manifest: extensionManifestSchema.parse({ ...f.status.manifest, apiVersion: 3, contributes: { ...f.status.manifest.contributes, placements: [{ id: 'tests.music.dock', kind: 'view', view: 'tests.music.player', target: 'workbench.pane' }] } }) }]
+  f.controller.registry.register('tasks', scope => scope.view({ id: 'task', renderer: 'task', label: 'Task', locations: ['main'], supports: () => true, multiple: false }))
+  await f.controller.open({ scheme: 'task', id: 'one', data: {} }, 'One', { viewType: 'task' })
+  const first = f.controller.layout.activePane
+  const secondTask = (await f.controller.open({ scheme: 'task', id: 'two', data: {} }, 'Two', { viewType: 'task', direction: 'right' }))!
+  const second = f.controller.layout.activePane
+  const show = (instanceId: string) => ({ ...f.show(), kind: 'placement' as const, placementId: 'tests.music.dock', extensionId: f.status.manifest.id, generation: f.status.generation!, visible: true, instanceId })
+  const left = show(first)
+  const right = show(second)
+  f.receive(left)
+  f.receive(right)
+  f.controller.activate(first)
+  await settle()
+  await vi.waitFor(() => expect(f.replies.has(right.requestId)).toBe(true))
+  const leftId = f.replies.get(left.requestId)!
+  const rightId = f.replies.get(right.requestId)!
+  expect(leftId).not.toBe(rightId)
+  expect(f.controller.layout.views[leftId]?.mountInstanceId).toBe(first)
+  expect(f.controller.layout.views[rightId]?.mountInstanceId).toBe(second)
+  f.controller.updateView(leftId, { state: { version: 1, value: { count: 7 } } })
+  f.controller.updateView(rightId, { state: { version: 1, value: { count: 3 } } })
+  const saved = JSON.parse(JSON.stringify(f.controller.layout))
+  expect(restoreWorkbenchLayout(saved).views[leftId]?.state.value).toEqual({ count: 7 })
+  f.receive({ ...left, requestId: crypto.randomUUID(), visible: false })
+  await settle()
+  expect(f.controller.layout.views[leftId]).toBeUndefined()
+  expect(f.controller.layout.views[rightId]?.state.value).toEqual({ count: 3 })
+  await f.controller.close(secondTask)
+  expect(f.controller.layout.views[rightId]).toBeUndefined()
+  const obsolete = show(second)
+  f.receive(obsolete)
+  await settle()
+  expect(f.replies.get(obsolete.requestId)).toBeNull()
+  saved.root = { kind: 'pane', id: first, view: null }
+  const restored = restoreWorkbenchLayout(saved)
+  expect(restored.root).toEqual(saved.root)
+  expect(restored.views[leftId]?.state.value).toEqual({ count: 7 })
+  expect(restored.views[rightId]).toBeUndefined()
+})
+
+it('withdraws transient surfaces immediately and never restores an ended interaction', async () => {
+  const f = setup()
+  f.ready.value = true
+  f.installed.value = [{ ...f.status, revision: 'next', manifest: extensionManifestSchema.parse({ ...f.status.manifest, apiVersion: 3, contributes: { ...f.status.manifest.contributes, placements: [{ id: 'tests.music.dock', kind: 'view', view: 'tests.music.player', target: 'workbench', interaction: 'regions', presentation: { position: 'absolute' } }] } }) }]
+  const interactionId = crypto.randomUUID()
+  f.receive({ kind: 'interaction', requestId: crypto.randomUUID(), extensionId: f.status.manifest.id, generation: f.status.generation!, interactionId, title: 'Music' })
+  await settle()
+  const show = { ...f.show(), interactionId }
+  f.receive(show)
+  await settle()
+  expect(Object.values(f.controller.layout.views)).toHaveLength(1)
+  expect(Object.values(restoreWorkbenchLayout(f.controller.layout).views)).toHaveLength(0)
+  f.controller.interactions.end(interactionId)
+  expect(Object.values(f.controller.layout.views)).toHaveLength(0)
+  f.receive({ ...show, requestId: crypto.randomUUID() })
+  await settle()
+  expect(Object.values(f.controller.layout.views)).toHaveLength(0)
+})
+
+it('exposes plugin short names as namespaces without publisher prefixes or global aliases', async () => {
+  const f = setup()
+  f.installed.value = [{ ...f.status, revision: 'next', manifest: extensionManifestSchema.parse({ ...f.status.manifest, entry: 'host.js', apiVersion: 3, contributes: { ...f.status.manifest.contributes, commands: [{ id: 'tests.music.review', title: '检查播放列表', slash: { name: 'review', description: '检查当前播放列表' } }] } }) }]
+  await settle()
+  expect([...f.controller.registry.commands.values()].filter(command => command.slash).map(command => command.slash)).toEqual([{ name: 'music:review', description: '检查当前播放列表' }])
+})
diff --git a/apps/buddy/src/app/workbench/registerDesktopContributions.ts b/apps/buddy/src/app/workbench/registerDesktopContributions.ts
index af0a42c6..bca14313 100644
--- a/apps/buddy/src/app/workbench/registerDesktopContributions.ts
+++ b/apps/buddy/src/app/workbench/registerDesktopContributions.ts
@@ -1,6 +1,7 @@
 import type { ViewRendererRegistry } from '@/workbench/browser/ViewRendererRegistry'
 import type { WorkbenchController } from '@/workbench/services/WorkbenchController'
 import type { WorkingCopyService } from '@/workbench/services/WorkingCopyService'
+import { parseWorkbenchUiSelection, workbenchUiSelectionKey, workbenchUiTargetCatalog } from '@buddy-shared/workbench/workbenchUi'
 import { buddyColorThemes, createBuddyColorVariables } from '@/theme/buddyTheme'
 import { panes } from '@/workbench/common/workbench'
 import { workbenchLabels } from '@/workbench/common/workbenchLabels'
@@ -10,9 +11,8 @@ import DesktopTaskContribution from './DesktopTaskContribution.vue'
 export function registerDesktopContributions(controller: WorkbenchController, renderers: ViewRendererRegistry, copies: WorkingCopyService, language: () => string) {
   const labels = () => workbenchLabels(language())
   controller.registry.register('lexora.tasks', (scope) => {
-    scope.configuration({ id: 'workbench.controls.model.reasoning', defaultValue: '', validate: value => typeof value === 'string' && value.length <= 180 })
     scope.cleanup(renderers.register('tasks.editor', DesktopTaskContribution))
-    scope.view({ id: 'tasks.editor', renderer: 'tasks.editor', locations: ['main'], label: 'Task', supports: resource => ['task', 'draft'].includes(resource.scheme), multiple: false })
+    scope.view({ id: 'tasks.editor', renderer: 'tasks.editor', locations: ['main'], label: 'Task', supports: resource => ['task', 'draft'].includes(resource.scheme), multiple: false, prepareBeforeOpen: true })
   })
   controller.registry.register('lexora.files', (scope) => {
     scope.cleanup(renderers.register('files.view', DesktopFileContribution))
@@ -23,6 +23,8 @@ export function registerDesktopContributions(controller: WorkbenchController, re
     }, keybinding: 'Mod+S', shortcutScope: 'context', enabled: context => !!context.view && copies.dirty(context.view.resource), execute: context => copies.save(context.view!.resource) })
   })
   controller.registry.register('lexora.workbench', (scope) => {
+    for (const target of workbenchUiTargetCatalog)
+      scope.configuration({ id: workbenchUiSelectionKey(target), defaultValue: '', validate: value => parseWorkbenchUiSelection(value, target.selection === 'multiple') !== null })
     for (const theme of Object.values(buddyColorThemes))
       scope.theme({ id: theme.colorScheme, colorScheme: theme.colorScheme, tokens: createBuddyColorVariables(theme) })
     scope.command({ id: 'editor.wordWrap', label: language() === 'en-US' ? 'Toggle word wrap' : '切换自动换行', enabled: context => context.values['resource.scheme'] === 'file', execute: (context) => {
diff --git a/apps/buddy/src/app/workbench/useDesktopWorkbench.ts b/apps/buddy/src/app/workbench/useDesktopWorkbench.ts
index a5cd62d8..7e6f625b 100644
--- a/apps/buddy/src/app/workbench/useDesktopWorkbench.ts
+++ b/apps/buddy/src/app/workbench/useDesktopWorkbench.ts
@@ -65,9 +65,13 @@ export function useDesktopWorkbench(options: { api: LexoraDesktopApi, stores: De
   const deletedTasks = new Set<string>()
   const initialized = shallowRef(false)
   let navigationVersion = 0
+  let routeVersion = 0
   onScopeDispose(router.beforeEach((to) => {
-    if (to.path !== '/tasks')
+    if (to.path !== '/tasks') {
       navigationVersion += 1
+      routeVersion += 1
+      controller.cancelNavigation()
+    }
   }))
 
   function center(): string {
@@ -230,22 +234,26 @@ export function useDesktopWorkbench(options: { api: LexoraDesktopApi, stores: De
       }
     }
 
-    const version = ++navigationVersion
+    navigationVersion += 1
+    const version = routeVersion
     let id: string | null = null
     try {
+      await router.push('/tasks')
+      if (destination.signal?.aborted || version !== routeVersion)
+        return
       id = await controller.open(resource, title, { paneId: targetPaneId, ...destination })
     }
     finally {
       if (currentView)
         confirmedDraftCloses.delete(currentView.id)
     }
-    if (!id || destination.signal?.aborted || version !== navigationVersion)
+    if (!id || destination.signal?.aborted || version !== routeVersion)
       return
-    await router.push('/tasks')
     try {
       const task = await pool.open(resource)
-      if (!destination.signal?.aborted && controller.layout.views[id] && version === navigationVersion && controller.owner(id)?.id === controller.layout.activePane) {
-        activeTask.value = task
+      if (!destination.signal?.aborted && controller.layout.views[id] && version === routeVersion) {
+        if (controller.owner(id)?.id === controller.layout.activePane)
+          activeTask.value = task
         if (destination.initialContent) {
           task.workspace.composer.updateComposerContent(buddyUserContentToText(destination.initialContent), userContentToChatComposerDocument(destination.initialContent))
           await task.flushDrafts()
@@ -473,7 +481,7 @@ export function useDesktopWorkbench(options: { api: LexoraDesktopApi, stores: De
     if (!initialized.value)
       return
     const resources = options.resources()
-    pool.retain(Object.values(controller.layout.views).map(view => view.resource))
+    pool.retain(controller.renderedViews.map(view => view.resource))
     const referencedFiles = new Set(Object.values(controller.layout.views).map(view => resourceKey(view.resource)))
     for (const copy of copies.copies.values()) {
       if (!referencedFiles.has(resourceKey(copy.resource)))
@@ -507,6 +515,7 @@ export function useDesktopWorkbench(options: { api: LexoraDesktopApi, stores: De
       resources.selectTab(typeof focused.state.contextTabId === 'string' ? focused.state.contextTabId : focused.id)
   }))
   onScopeDispose(() => {
+    controller.dispose()
     pool.dispose()
     models.dispose()
     persistence.dispose()
diff --git a/apps/buddy/src/app/workbench/useExtensionContributions.ts b/apps/buddy/src/app/workbench/useExtensionContributions.ts
index bc0498e7..3b818a5e 100644
--- a/apps/buddy/src/app/workbench/useExtensionContributions.ts
+++ b/apps/buddy/src/app/workbench/useExtensionContributions.ts
@@ -1,33 +1,23 @@
 import type { ExtensionApi, ExtensionStatus, ExtensionWorkbenchEvent } from '@buddy-shared/extensions/extensionApi'
-import type { WorkbenchControl } from '@buddy-shared/workbench/workbenchUi'
 import type { Ref } from 'vue'
 import type { ExtensionViews } from '@/modules/extensions'
 import type { ViewRendererRegistry } from '@/workbench/browser/ViewRendererRegistry'
 import type { ViewLocation } from '@/workbench/common/workbench'
 import type { WorkbenchController } from '@/workbench/services/WorkbenchController'
 import type { WorkbenchPersistence } from '@/workbench/services/WorkbenchPersistence'
+import { extensionCommandNamespace } from '@buddy-shared/extensions/extensionCommands'
 import { spaceFileTargetSchema } from '@buddy-shared/spaces/spaceFileApi'
+import { qualifyWorkbenchCommand } from '@buddy-shared/workbench/workbenchCommand'
 import { matchesWorkbenchContext } from '@buddy-shared/workbench/workbenchContext'
-import { computed, onScopeDispose, shallowRef, watch } from 'vue'
+import { onScopeDispose, watch } from 'vue'
 import { DesktopExtensionView } from '@/modules/extensions/ui'
 
 export function useExtensionContributions(options: { controller: WorkbenchController, renderers: ViewRendererRegistry, persistence: WorkbenchPersistence, installed: Readonly<Ref<ExtensionStatus[]>>, api: ExtensionApi, views: ExtensionViews, ready: () => boolean }) {
   const { controller, renderers, persistence, installed, api, views } = options
   onScopeDispose(renderers.register('extensions.view', DesktopExtensionView))
   const owners = new Map<string, { revision: string, dispose: () => void }>()
-  const configurationRevision = shallowRef(0)
-  onScopeDispose(controller.configuration.subscribe(() => configurationRevision.value++))
-  const selection = computed(() => {
-    void configurationRevision.value
-    return { 'model.reasoning': String(controller.configuration.get('workbench.controls.model.reasoning') ?? '') }
-  })
-  function select(target: WorkbenchControl, id: string) {
-    if (id && !installed.value.some(item => item.enabled && item.compatible && item.manifest.contributes.placements.some(placement => placement.kind === 'control' && placement.target === target && placement.id === id)))
-      return
-    controller.configuration.set(`workbench.controls.${target}`, id)
-  }
   watch(installed, (items) => {
-    const enabled = items.filter(item => item.enabled && item.compatible)
+    const enabled = items.filter(item => item.enabled && item.compatible && !['failed', 'blocked'].includes(item.state))
     for (const [id, owner] of owners) {
       if (!enabled.some(item => item.manifest.id === id && item.revision === owner.revision)) {
         owner.dispose()
@@ -45,10 +35,12 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
         }
         for (const placement of item.manifest.contributes.placements) {
           if (placement.kind === 'view')
-            scope.placement({ id: placement.id, viewType: placement.view, location: 'mount', target: placement.target, presentation: placement.presentation, when: placement.when })
+            scope.placement({ id: placement.id, viewType: placement.view, location: 'mount', target: placement.target, presentation: placement.presentation, interaction: placement.interaction, when: placement.when })
         }
         for (const command of item.manifest.contributes.commands.filter(command => !command.hidden)) {
-          scope.command({ id: command.id, label: command.title, enabled: () => matchesWorkbenchContext(command.when, controller.contextKeys.snapshot()), execute: async ({ view }) => {
+          scope.command({ id: command.id, label: command.title, slash: command.slash ? { ...command.slash, name: qualifyWorkbenchCommand(extensionCommandNamespace(id), command.slash.name) } : undefined, enabled: () => matchesWorkbenchContext(command.when, controller.contextKeys.snapshot()), execute: async ({ view, pane, source, arguments: argumentsText }) => {
+            if (source === 'slash')
+              return api.executeSlash(id, command.id, argumentsText ?? '', pane?.id)
             const parsed = view && ['file', 'file-preview'].includes(view.resource.scheme) ? spaceFileTargetSchema.safeParse(view.resource.data) : null
             await api.execute(id, command.id, parsed?.success ? parsed.data : null)
           } })
@@ -70,8 +62,9 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
       const descriptor = plugin?.manifest.contributes.views.find(descriptor => descriptor.id === placement?.view)
       if (!descriptor || placement?.kind !== 'view')
         continue
-      if (view.type !== descriptor.id || view.location !== 'mount' || view.placement !== placement.id || view.title !== descriptor.title) {
-        controller.rebindAuxiliary(view.id, { type: descriptor.id, placement: placement.id, title: descriptor.title, location: 'mount', resource: { ...view.resource, data: { ...view.resource.data, viewType: descriptor.id } } })
+      const mountInstanceId = placement.target === 'workbench.pane' ? view.mountInstanceId ?? controller.layout.activePane : undefined
+      if (view.type !== descriptor.id || view.location !== 'mount' || view.placement !== placement.id || view.title !== descriptor.title || view.mountInstanceId !== mountInstanceId) {
+        controller.rebindAuxiliary(view.id, { type: descriptor.id, placement: placement.id, title: descriptor.title, location: 'mount', mountInstanceId, resource: { ...view.resource, data: { ...view.resource.data, viewType: descriptor.id } } })
       }
     }
   }
@@ -82,7 +75,7 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
       return
     for (const request of requests.values()) {
       const { event, abort } = request
-      if (event.kind === 'open' || event.kind === 'placement') {
+      if (event.kind === 'open' || event.kind === 'placement' || (event.kind === 'interaction' && event.title !== null) || event.kind === 'message') {
         const plugin = installed.value.find(item => item.manifest.id === event.extensionId)
         const current = plugin?.enabled && plugin.compatible && plugin.generation === event.generation
         if (!current) {
@@ -119,7 +112,26 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
     try {
       if (signal.aborted)
         return
-      if (event.kind === 'control') {
+      if (event.kind === 'interaction') {
+        if (event.title === null) {
+          controller.removeInteraction(event.interactionId)
+        }
+        else {
+          controller.interactions.add({ id: event.interactionId, title: event.title }, () => {
+            controller.removeInteraction(event.interactionId)
+            void api.endInteraction(event.interactionId).catch(() => {})
+          })
+        }
+        viewId = event.interactionId
+      }
+      else if (event.kind === 'message') {
+        views.broadcast(event.extensionId, event.generation, event.message)
+      }
+      else if (event.kind === 'regions') {
+        if (views.setRegions(event.viewId, event.generation, event.token, event.regions))
+          viewId = event.viewId
+      }
+      else if (event.kind === 'control') {
         if (views.proposeControl(event.viewId, event.generation, event.token, event.proposal))
           viewId = event.viewId
       }
@@ -129,9 +141,12 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
         const descriptor = plugin?.manifest.contributes.views.find(view => view.id === placement?.view)
         if (placement?.kind !== 'view' || !descriptor)
           return
-        const existing = Object.values(controller.layout.views).find(view => view.resource.scheme === 'extension' && view.resource.data.extensionId === event.extensionId && view.resource.data.placementId === placement.id)
+        const instanceId = placement.target === 'workbench.pane' ? event.instanceId ?? controller.layout.activePane : undefined
+        if (instanceId && !controller.pane(instanceId))
+          return
+        const existing = Object.values(controller.layout.views).find(view => view.resource.scheme === 'extension' && view.resource.data.extensionId === event.extensionId && view.resource.data.placementId === placement.id && view.mountInstanceId === instanceId && view.interactionId === event.interactionId)
         if (event.visible) {
-          viewId = await controller.open({ scheme: 'extension', id: placement.id, data: { extensionId: event.extensionId, viewType: placement.view, resource: null, placementId: placement.id } }, descriptor.title, { signal, placement: placement.id, viewType: placement.view, location: 'mount', focus: false, state: { version: descriptor.stateVersion, value: {} } })
+          viewId = await controller.open({ scheme: 'extension', id: placement.id, data: { extensionId: event.extensionId, viewType: placement.view, resource: null, placementId: placement.id } }, descriptor.title, { signal, placement: placement.id, mountInstanceId: instanceId, interactionId: event.interactionId, viewType: placement.view, location: 'mount', focus: false, state: { version: descriptor.stateVersion, value: {} } })
         }
         else if (existing && await controller.close(existing.id, signal)) {
           viewId = existing.id
@@ -155,6 +170,8 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
           const placement = view.placement ? controller.registry.placements.get(view.placement) : null
           if (!placement || placement.viewType !== view.type)
             return
+          if (event.presentation.target === 'workbench.pane' && !view.mountInstanceId)
+            return
           controller.updateView(view.id, { presentation: { ...view.presentation, ...event.presentation } })
         }
         else {
@@ -182,5 +199,4 @@ export function useExtensionContributions(options: { controller: WorkbenchContro
     for (const owner of owners.values()) owner.dispose()
     owners.clear()
   })
-  return { selection, select }
 }
diff --git a/apps/buddy/src/i18n/locales/en-US/app.ts b/apps/buddy/src/i18n/locales/en-US/app.ts
index c4e8e763..d0be974f 100644
--- a/apps/buddy/src/i18n/locales/en-US/app.ts
+++ b/apps/buddy/src/i18n/locales/en-US/app.ts
@@ -35,6 +35,8 @@ export default {
   'desktop.command.app.about': 'About Lexora Buddy',
   'desktop.command.app.checkUpdates': 'Check for updates…',
   'desktop.command.app.quit': 'Quit',
+  'desktop.command.run': 'Run command',
+  'desktop.command.inputFailed': 'Command unavailable or failed. Your input was kept.',
   'desktop.command.failed': 'The action failed. Try again.',
   'desktop.command.help.feedback': 'Feedback',
   'desktop.command.help.openDocumentation': 'Documentation',
diff --git a/apps/buddy/src/i18n/locales/zh-CN/app.ts b/apps/buddy/src/i18n/locales/zh-CN/app.ts
index bce7128c..8bb75679 100644
--- a/apps/buddy/src/i18n/locales/zh-CN/app.ts
+++ b/apps/buddy/src/i18n/locales/zh-CN/app.ts
@@ -33,6 +33,8 @@ export default {
   'desktop.command.app.about': '关于 Lexora Buddy',
   'desktop.command.app.checkUpdates': '检查更新…',
   'desktop.command.app.quit': '退出',
+  'desktop.command.run': '执行命令',
+  'desktop.command.inputFailed': '命令不可用或执行失败，输入已保留。',
   'desktop.command.failed': '操作失败，请稍后重试',
   'desktop.command.help.feedback': '意见反馈',
   'desktop.command.help.openDocumentation': '使用文档',
diff --git a/apps/buddy/src/modules/extensions/extensionContext.ts b/apps/buddy/src/modules/extensions/extensionContext.ts
index 83e1dbd1..e7950958 100644
--- a/apps/buddy/src/modules/extensions/extensionContext.ts
+++ b/apps/buddy/src/modules/extensions/extensionContext.ts
@@ -1,7 +1,7 @@
 import type { WorkbenchContextSnapshot } from '@buddy-shared/workbench/workbenchContext'
-import type { WorkbenchControl } from '@buddy-shared/workbench/workbenchUi'
 import type { Ref } from 'vue'
 import type { useExtensionState } from './state/useExtensionState'
+import type { useExtensionUiContributions } from './state/useExtensionUiContributions'
 import type { useExtensionViews } from './widgets/useExtensionViews'
 import type { WorkbenchAnchors } from '@/shared/ui/contributions/workbenchUiContext'
 import { createInjectionState } from '@vueuse/core'
@@ -9,11 +9,12 @@ import { createInjectionState } from '@vueuse/core'
 export interface ExtensionContext {
   workbench: Readonly<Ref<WorkbenchContextSnapshot>>
   anchors: WorkbenchAnchors
-  controls: { selection: Readonly<Ref<Record<WorkbenchControl, string>>>, select: (target: WorkbenchControl, id: string) => void }
+  ui: ReturnType<typeof useExtensionUiContributions>
   state: ReturnType<typeof useExtensionState>
   views: ReturnType<typeof useExtensionViews>
   language: Readonly<Ref<string>>
   isDark: Readonly<Ref<boolean>>
+  endInteraction: (id: string) => void
   focusView: (id: string) => void
   startCreation: (prompt: string) => Promise<void>
 }
diff --git a/apps/buddy/src/modules/extensions/index.ts b/apps/buddy/src/modules/extensions/index.ts
index 8188f401..714facb5 100644
--- a/apps/buddy/src/modules/extensions/index.ts
+++ b/apps/buddy/src/modules/extensions/index.ts
@@ -1,4 +1,5 @@
 export { useProvideExtensionContext } from './extensionContext'
 export { useExtensionState } from './state/useExtensionState'
+export { useExtensionUiContributions } from './state/useExtensionUiContributions'
 export { useExtensionViews } from './widgets/useExtensionViews'
 export type { ExtensionViews } from './widgets/useExtensionViews'
diff --git a/apps/buddy/src/modules/extensions/state/__tests__/useExtensionUiContributions.spec.ts b/apps/buddy/src/modules/extensions/state/__tests__/useExtensionUiContributions.spec.ts
new file mode 100644
index 00000000..1ffcc0ea
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/state/__tests__/useExtensionUiContributions.spec.ts
@@ -0,0 +1,37 @@
+import type { ExtensionStatus } from '@buddy-shared/extensions/extensionApi'
+import { extensionManifestSchema } from '@buddy-shared/extensions/extensionManifest'
+import { parseWorkbenchUiSelection, workbenchUiSelectionKey, workbenchUiTargetCatalog } from '@buddy-shared/workbench/workbenchUi'
+import { expect, it } from 'vitest'
+import { effectScope, shallowRef } from 'vue'
+import { ContributionRegistry } from '@/workbench/services/ContributionRegistry'
+import { WorkbenchController } from '@/workbench/services/WorkbenchController'
+import { useExtensionUiContributions } from '../useExtensionUiContributions'
+
+it('retains ordered selections through disabled providers and rejects malformed settings', () => {
+  const manifest = extensionManifestSchema.parse({ schemaVersion: 1, apiVersion: 3, id: 'tests.accessories', name: 'Accessories', version: '1.0.0', engines: { lexora: '*' }, contributes: {
+    views: [{ id: 'tests.accessories.view', title: 'Panel', entry: 'view.js', resource: 'none' }],
+    placements: ['first', 'second'].map(name => ({ id: `tests.accessories.${name}`, view: 'tests.accessories.view', kind: 'slot', target: 'composer.accessory' })),
+  } })
+  const status: ExtensionStatus = { manifest, revision: 'one', enabled: true, compatible: true, development: false, pending: null, state: 'active', generation: crypto.randomUUID(), error: null, activationMs: null, logs: [] }
+  const installed = shallowRef([status])
+  const controller = new WorkbenchController(new ContributionRegistry())
+  controller.registry.register('configuration', scope => workbenchUiTargetCatalog.forEach(target => scope.configuration({ id: workbenchUiSelectionKey(target), defaultValue: '', validate: value => parseWorkbenchUiSelection(value, target.selection === 'multiple') !== null })))
+  const scope = effectScope()
+  const ui = scope.run(() => useExtensionUiContributions(installed, controller.configuration))!
+  const target = { kind: 'slot', target: 'composer.accessory' } as const
+  const selected = ['tests.accessories.second', 'tests.accessories.first']
+  try {
+    ui.choose(target, selected)
+    expect(ui.selected(target).map(provider => provider.placement.id)).toEqual(selected)
+    expect(() => controller.configuration.set(workbenchUiSelectionKey(target), 'unparsed')).toThrow()
+    ui.choose(target, [selected[0]!, selected[0]!])
+    expect(ui.selected(target).map(provider => provider.placement.id)).toEqual(selected)
+    installed.value = [{ ...status, enabled: false }]
+    expect(ui.selected(target)).toEqual([])
+    expect(controller.configuration.get(workbenchUiSelectionKey(target))).toBe(JSON.stringify(selected))
+    ui.choose(target, [selected[1]!])
+    installed.value = [status]
+    expect(ui.selected(target).map(provider => provider.placement.id)).toEqual([selected[1]])
+  }
+  finally { scope.stop() }
+})
diff --git a/apps/buddy/src/modules/extensions/state/useExtensionUiContributions.ts b/apps/buddy/src/modules/extensions/state/useExtensionUiContributions.ts
new file mode 100644
index 00000000..63e7a650
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/state/useExtensionUiContributions.ts
@@ -0,0 +1,37 @@
+import type { ExtensionStatus } from '@buddy-shared/extensions/extensionApi'
+import type { WorkbenchUiSelectionTarget } from '@buddy-shared/workbench/workbenchUi'
+import type { Ref } from 'vue'
+import type { ConfigurationService } from '@/workbench/services/ConfigurationService'
+import { parseWorkbenchUiSelection, workbenchUiSelectionKey, workbenchUiTargetCatalog } from '@buddy-shared/workbench/workbenchUi'
+import { computed, onScopeDispose, shallowRef } from 'vue'
+
+export function useExtensionUiContributions(installed: Readonly<Ref<ExtensionStatus[]>>, configuration: ConfigurationService) {
+  const revision = shallowRef(0)
+  onScopeDispose(configuration.subscribe(() => revision.value++))
+  const entries = computed(() => {
+    void revision.value
+    return workbenchUiTargetCatalog.map(target => ({
+      ...target,
+      selected: parseWorkbenchUiSelection(configuration.get(workbenchUiSelectionKey(target)), target.selection === 'multiple') ?? [],
+      providers: installed.value.filter(plugin => plugin.enabled && plugin.compatible)
+        .flatMap(plugin => plugin.manifest.contributes.placements.flatMap(placement => (placement.kind === 'control' || placement.kind === 'slot') && placement.kind === target.kind && placement.target === target.target ? [{ plugin, placement, title: plugin.manifest.contributes.views.find(view => view.id === placement.view)?.title ?? plugin.manifest.name }] : []))
+        .sort((left, right) => left.placement.id.localeCompare(right.placement.id)),
+    }))
+  })
+  function entry(target: WorkbenchUiSelectionTarget) {
+    return entries.value.find(entry => entry.kind === target.kind && entry.target === target.target)!
+  }
+  function selected(target: WorkbenchUiSelectionTarget) {
+    const current = entry(target)
+    return current.selected.flatMap(id => current.providers.filter(provider => provider.placement.id === id))
+  }
+  function choose(target: WorkbenchUiSelectionTarget, ids: string[]): void {
+    const current = entry(target)
+    const multiple = current.selection === 'multiple'
+    const value = multiple ? JSON.stringify(ids) : ids[0] ?? ''
+    if ((!multiple && ids.length > 1) || !parseWorkbenchUiSelection(value, multiple) || ids.some(id => !current.selected.includes(id) && !current.providers.some(provider => provider.placement.id === id)))
+      return
+    configuration.set(workbenchUiSelectionKey(target), value)
+  }
+  return { entries, selected, choose }
+}
diff --git a/apps/buddy/src/modules/extensions/ui.ts b/apps/buddy/src/modules/extensions/ui.ts
index c18c5cce..0227e664 100644
--- a/apps/buddy/src/modules/extensions/ui.ts
+++ b/apps/buddy/src/modules/extensions/ui.ts
@@ -1,6 +1,8 @@
 export { default as DesktopExtensionControl } from './widgets/DesktopExtensionControl.vue'
 export { default as DesktopExtensionFrameHost } from './widgets/DesktopExtensionFrameHost.vue'
 export { default as DesktopExtensionManager } from './widgets/DesktopExtensionManager.vue'
+export { default as DesktopExtensionMenu } from './widgets/DesktopExtensionMenu.vue'
 export { default as DesktopExtensionOverlays } from './widgets/DesktopExtensionOverlays.vue'
 export { default as DesktopExtensionReviewHost } from './widgets/DesktopExtensionReviewHost.vue'
+export { default as DesktopExtensionSlot } from './widgets/DesktopExtensionSlot.vue'
 export { default as DesktopExtensionView } from './widgets/DesktopExtensionView.vue'
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionControl.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionControl.vue
index 6008355a..03367573 100644
--- a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionControl.vue
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionControl.vue
@@ -2,6 +2,7 @@
 import type { ExtensionViewInput } from '@buddy-shared/extensions/extensionApi'
 import type { WorkbenchControlProps } from '@/shared/ui/contributions/workbenchUiContext'
 import { computed, shallowRef, useTemplateRef, watch } from 'vue'
+import { useWorkbenchUiScope } from '@/shared/ui/contributions/workbenchUiContext'
 import { ControlBinding } from '@/workbench/browser/controls/ControlBinding'
 import { useExtensionContext } from '../extensionContext'
 import DesktopExtensionSurface from './DesktopExtensionSurface.vue'
@@ -9,25 +10,16 @@ import DesktopExtensionSurface from './DesktopExtensionSurface.vue'
 const props = defineProps<WorkbenchControlProps>()
 const emit = defineEmits<{ change: [value: string], dismiss: [] }>()
 defineSlots<{ default: () => unknown }>()
-const { state, views, controls, language } = useExtensionContext()
+const { views, ui } = useExtensionContext()
+const scope = useWorkbenchUiScope()
 const root = useTemplateRef<HTMLElement>('root')
-const providers = computed(() => state.installed.value.filter(plugin => plugin.enabled && plugin.compatible)
-  .flatMap(plugin => plugin.manifest.contributes.placements.filter(placement => placement.kind === 'control' && placement.target === props.target)
-    .map(placement => ({ plugin, placement })))
-  .sort((left, right) => left.placement.id.localeCompare(right.placement.id)))
-const selected = computed(() => controls.selection.value[props.target] ?? '')
-const provider = computed(() => providers.value.find(provider => provider.placement.id === selected.value))
+const provider = computed(() => ui.selected({ kind: 'control', target: props.target })[0])
 const input = shallowRef<ExtensionViewInput | null>(null)
-function choose(id: string) {
-  views.retryControl(id)
-  if (id !== selected.value)
-    controls.select(props.target, id)
-}
 function createInput() {
   const contribution = provider.value
-  input.value = contribution ? { viewId: crypto.randomUUID(), extensionId: contribution.plugin.manifest.id, viewType: contribution.placement.view, placementId: contribution.placement.id, resource: null, state: null, stateVersion: 0 } : null
+  input.value = contribution ? { viewId: crypto.randomUUID(), extensionId: contribution.plugin.manifest.id, viewType: contribution.placement.view, placementId: contribution.placement.id, instanceId: scope?.instanceId(), resource: null, state: null, stateVersion: 0 } : null
 }
-watch([() => provider.value?.placement.id, () => provider.value?.plugin.revision], createInput, { immediate: true, flush: 'sync' })
+watch([() => provider.value?.placement.id, () => provider.value?.plugin.revision, () => scope?.instanceId()], createInput, { immediate: true, flush: 'sync' })
 const entry = computed(() => input.value ? views.surfaces.get(input.value.viewId) : null)
 const ready = computed(() => !!entry.value?.ready && entry.value.eligible && !entry.value.error && !['failed', 'blocked'].includes(provider.value?.plugin.state ?? 'failed'))
 const binding = new ControlBinding(() => document.visibilityState === 'visible' && !!root.value?.getClientRects().length && getComputedStyle(root.value).visibility !== 'hidden' && !root.value.closest('[inert], [hidden]') && ready.value, value => emit('change', value))
@@ -40,20 +32,6 @@ const height = computed(() => provider.value?.placement.kind === 'control' ? pro
 
 <template>
   <div ref="root" class="extension-control" :data-workbench-control="target">
-    <div v-if="providers.length || selected" class="extension-control__choice">
-      <select :value="selected" :aria-label="language === 'en-US' ? 'Reasoning control style' : '思考等级样式'" @change="choose(($event.target as HTMLSelectElement).value)">
-        <option value="">
-          {{ language === 'en-US' ? 'Built-in' : '内置' }}
-        </option>
-        <option v-if="selected && !provider" :value="selected" disabled>
-          {{ language === 'en-US' ? 'Unavailable' : '暂不可用' }}
-        </option>
-        <option v-for="item in providers" :key="item.placement.id" :value="item.placement.id">
-          {{ item.plugin.manifest.name }}
-        </option>
-      </select>
-      <span v-if="selected && !ready" role="status">{{ language === 'en-US' ? 'Using built-in control' : '使用内置控件' }}</span>
-    </div>
     <div class="extension-control__content" :style="ready ? { height: `${height}px` } : undefined">
       <DesktopExtensionSurface v-if="input" :input="input" :visible="ready" :control="control" silent class="extension-control__surface" />
       <slot v-if="!ready" />
@@ -63,8 +41,6 @@ const height = computed(() => provider.value?.placement.kind === 'control' ? pro
 
 <style scoped>
 .extension-control { min-width: 0; }
-.extension-control__choice { display: flex; justify-content: flex-end; align-items: center; gap: 6px; margin-bottom: 6px; font-size: 11px; color: var(--buddy-text-secondary); }
-.extension-control__choice select { min-width: 0; max-width: 70%; border: 1px solid var(--buddy-border-subtle); border-radius: 4px; background: var(--buddy-surface-base); color: var(--buddy-text-secondary); font: inherit; padding: 2px 4px; }
 .extension-control__content { position: relative; min-height: 32px; }
 .extension-control__surface { position: absolute; inset: 0; }
 </style>
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionFrameHost.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionFrameHost.vue
index d2bc04bb..30341cb5 100644
--- a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionFrameHost.vue
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionFrameHost.vue
@@ -4,6 +4,7 @@ import type { ExtensionSurface } from './useExtensionViews'
 import type { SurfaceLayout, SurfaceLayoutLease } from '@/shared/ui/surfaces/surfaceLayout'
 import { extensionJsonSchema } from '@buddy-shared/extensions/extensionApi'
 import { onMounted, onScopeDispose, useTemplateRef, watch } from 'vue'
+import { SurfaceHitRegions } from '@/workbench/browser/surfaces/SurfaceHitRegions'
 import { useExtensionContext } from '../extensionContext'
 import { extensionErrorCode } from '../state/useExtensionState'
 
@@ -11,6 +12,7 @@ interface Frame {
   element: HTMLIFrameElement
   surface: ExtensionSurface
   layout: SurfaceLayoutLease
+  hitRegions: SurfaceHitRegions | null
   geometry: AnchorGeometry | null
   mount: MountGeometry | null
   visible: boolean
@@ -19,7 +21,7 @@ interface Frame {
   ping: { id: string, time: number } | null
 }
 const props = defineProps<{ layout: SurfaceLayout }>()
-const { state, views, anchors, focusView, language, isDark, workbench } = useExtensionContext()
+const { state, views, endInteraction, anchors, focusView, language, isDark, workbench } = useExtensionContext()
 const root = useTemplateRef<HTMLElement>('root')
 const frames = new Map<string, Frame>()
 function isOverlay(surface: ExtensionSurface) {
@@ -50,6 +52,12 @@ function environment() {
 watch([language, isDark], () => {
   for (const [token, frame] of frames) send(token, frame, { environment: environment() })
 }, { flush: 'post' })
+onScopeDispose(views.onMessage((extensionId, generation, message) => {
+  for (const [token, frame] of frames) {
+    if (frame.surface.session?.extensionId === extensionId && frame.surface.session.generation === generation)
+      send(token, frame, { message })
+  }
+}))
 watch(() => [...views.surfaces.values()].map(surface => surface.control?.snapshot()), () => {
   for (const [token, frame] of frames) {
     const control = frame.surface.control?.snapshot()
@@ -71,6 +79,7 @@ function sync() {
   const retained = new Set([...views.surfaces.values()].map(surface => surface.session?.token).filter(Boolean))
   for (const [token, frame] of frames) {
     if (!retained.has(token)) {
+      frame.hitRegions?.dispose()
       frame.layout.dispose()
       frame.element.remove()
       frames.delete(token)
@@ -84,7 +93,7 @@ function sync() {
     const options = {
       anchor: surface.element,
       visible: surface.visible && surface.eligible,
-      interactive: !overlay,
+      interactive: !overlay && surface.interactionMode !== 'regions',
       layer: overlay ? 'decoration' as const : 'content' as const,
       onLayout: (geometry: { visible: boolean, width: number, height: number }) => {
         const frame = frames.get(session.token)
@@ -97,7 +106,7 @@ function sync() {
         if (surface.mount) {
           const bounds = surface.mount.element.getBoundingClientRect()
           const rect = surface.element.getBoundingClientRect()
-          const mount = { target: surface.mount.target, visible: geometry.visible, width: bounds.width, height: bounds.height, rect: { x: rect.left - bounds.left, y: rect.top - bounds.top, width: geometry.width, height: geometry.height } }
+          const mount = { target: surface.mount.target, instanceId: surface.mount.instanceId, visible: geometry.visible, width: bounds.width, height: bounds.height, rect: { x: rect.left - bounds.left, y: rect.top - bounds.top, width: geometry.width, height: geometry.height } }
           if (JSON.stringify(mount) !== JSON.stringify(frame.mount)) {
             frame.mount = mount
             send(session.token, frame, { mount })
@@ -120,6 +129,7 @@ function sync() {
     if (existing) {
       existing.surface = surface
       existing.layout.update(options)
+      existing.hitRegions?.update({ ...options, visible: options.visible && surface.ready, onLayout: undefined }, surface.regions)
       continue
     }
     const element = document.createElement('iframe')
@@ -131,9 +141,20 @@ function sync() {
     if (overlay)
       element.dataset.extensionOverlay = session.extensionId
     element.style.cssText = 'position:fixed;border:0;visibility:hidden;left:-10000px;width:1px;height:1px'
-    frames.set(session.token, { element, surface, layout: props.layout.attach(element, options), geometry: null, mount: null, visible: false, control: surface.control?.snapshot() ?? null, started: performance.now(), ping: null })
+    const hitRegions = surface.interactionMode === 'regions'
+      ? new SurfaceHitRegions(props.layout, { ...options, visible: false }, (activation) => {
+          const frame = frames.get(session.token)
+          if (frame?.visible && frame.surface.ready && frame.surface.eligible)
+            send(session.token, frame, { activation })
+        })
+      : null
+    frames.set(session.token, { element, hitRegions, surface, layout: props.layout.attach(element, options), geometry: null, mount: null, visible: false, control: surface.control?.snapshot() ?? null, started: performance.now(), ping: null })
     element.src = session.url
     root.value.append(element)
+    if (hitRegions) {
+      root.value.append(hitRegions.element)
+      hitRegions.update({ ...options, visible: options.visible && surface.ready }, surface.regions)
+    }
   }
   props.layout.invalidate()
 }
@@ -145,6 +166,10 @@ async function receive(event: MessageEvent) {
   const session = frame?.surface.session
   if (!frame || !session || event.source !== frame.element.contentWindow)
     return
+  if (data.endInteraction === true && frame.surface.input.interactionId) {
+    endInteraction(frame.surface.input.interactionId)
+    return
+  }
   if (typeof data.pong === 'string' && data.pong === frame.ping?.id) {
     frame.ping = null
     return
@@ -165,8 +190,10 @@ async function receive(event: MessageEvent) {
       return
     if (data.method === 'bootstrap' && value && typeof value === 'object')
       value = { ...value, workbench: workbench.value, visible: frame.visible && document.visibilityState === 'visible', environment: environment(), anchor: frame.geometry, mount: frame.mount, control: frame.surface.control?.snapshot() ?? null }
-    if (data.method === 'view.ready')
+    if (data.method === 'view.ready') {
       frame.surface.ready = true
+      sync()
+    }
     if (data.method === 'view.failed') {
       views.fail(frame.surface, 'EXTENSION_VIEW_FAILED')
       return
@@ -235,6 +262,7 @@ onScopeDispose(() => {
   window.removeEventListener('blur', focused)
   document.removeEventListener('visibilitychange', visibilityChanged)
   for (const frame of frames.values()) {
+    frame.hitRegions?.dispose()
     frame.layout.dispose()
     frame.element.remove()
   }
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionInstallReview.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionInstallReview.vue
index 8dff2e15..7a73a126 100644
--- a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionInstallReview.vue
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionInstallReview.vue
@@ -15,17 +15,23 @@ const permissions = computed(() => {
   const { permissions } = props.review.manifest
   return [
     ...(permissions.windowEffects ? [{ key: 'windowEffects', icon: Alert20Regular, title: english.value ? 'Display window effects' : '显示窗口特效', description: english.value ? 'Draw over Lexora and receive typing activity. Typed text and keys are never shared.' : '在 Lexora 窗口绘制效果，接收对话输入活动；不会获取输入文字或按键。' }] : []),
-    ...permissions.controls.map(target => ({ key: `controls:${target}`, icon: Alert20Regular, title: english.value ? 'Provide a reasoning control' : '提供思考等级控件', description: english.value ? 'After you select this style, display available levels and submit your selection.' : '由你选择启用后，展示可用等级并提交你的选择。' })),
+    ...(permissions.controls.length ? [{ key: 'controls', icon: Alert20Regular, title: english.value ? 'Provide optional controls' : '提供可选控件', description: english.value ? 'After you enable a control, the plugin can submit your choices through it.' : '由你启用控件后，插件可以通过它提交你的选择。' }] : []),
     ...(permissions.notifications ? [{ key: 'notifications', icon: Alert20Regular, title: labels.value.notifications, description: english.value ? 'Show reminders in your system notification center.' : '通过系统通知向你发送提醒。' }] : []),
     ...(permissions.schedules ? [{ key: 'schedules', icon: Clock20Regular, title: english.value ? 'Run scheduled tasks' : '执行后台定时任务', description: english.value ? 'Continue running while Lexora is open, even when the plugin page is closed.' : 'Lexora 运行期间，关闭插件页面后仍可执行。' }] : []),
     ...(permissions.selectedResource === 'read' ? [{ key: 'selectedResource:read', icon: Document20Regular, title: labels.value.selected, description: english.value ? 'Read the content of files you select for this plugin.' : '读取你为此插件选中的文件内容。' }] : []),
+    ...(permissions.selectedContent ? [{ key: 'selectedContent', icon: Document20Regular, title: english.value ? 'Read content you select' : '读取你选择的内容', description: english.value ? 'Receive the current draft or message when you invoke its action.' : '当你主动执行操作时，获取当前草稿或该条消息。' }] : []),
     ...(permissions.localResources ? [{ key: 'localResources', icon: Document20Regular, title: english.value ? 'Read files and folders you select' : '读取你选择的文件和目录', description: english.value ? 'Choose files or folders in a system dialog. The plugin can read selected files and scan selected folders until you revoke access.' : '通过系统窗口选择文件或目录；插件可读取所选文件、扫描所选目录，授权保留到你撤销。' }] : []),
     ...(permissions.resourceExport ? [{ key: 'resourceExport', icon: Document20Regular, title: english.value ? 'Save files to a location you choose' : '保存文件到你选择的位置', description: english.value ? 'Each export opens a system save dialog. Reading a file does not grant permission to overwrite it.' : '每次导出都由你通过系统保存窗口选择目标；读取文件不会自动授予覆写权限。' }] : []),
     ...permissions.network.map(origin => ({ key: `network:${origin}`, icon: Globe20Regular, title: `${labels.value.network} ${origin}`, description: english.value ? 'Send requests to this website and read its responses.' : '向此网站发送请求并读取响应。' })),
   ]
 })
+function isNewPermission(key: string): boolean {
+  return key === 'controls'
+    ? props.review.addedPermissions.some(permission => permission.startsWith('controls:'))
+    : props.review.addedPermissions.includes(key)
+}
 const source = computed(() => props.review.development ? (english.value ? 'Development folder' : '开发目录') : props.review.source ? (english.value ? 'Lexora Marketplace' : 'Lexora 插件市场') : (english.value ? 'Local package' : '本地插件包'))
-const sharesFiles = computed(() => (props.review.manifest.permissions.selectedResource === 'read' || props.review.manifest.permissions.localResources) && props.review.manifest.permissions.network.length > 0)
+const sharesContent = computed(() => (props.review.manifest.permissions.selectedResource === 'read' || props.review.manifest.permissions.localResources || props.review.manifest.permissions.selectedContent) && props.review.manifest.permissions.network.length > 0)
 </script>
 
 <template>
@@ -65,7 +71,7 @@ const sharesFiles = computed(() => (props.review.manifest.permissions.selectedRe
           <div>
             <div class="extension-install-review__permission-title">
               <span>{{ permission.title }}</span>
-              <span v-if="review.currentVersion && review.addedPermissions.includes(permission.key)" class="extension-install-review__new">{{ english ? 'New' : '新增' }}</span>
+              <span v-if="review.currentVersion && isNewPermission(permission.key)" class="extension-install-review__new">{{ english ? 'New' : '新增' }}</span>
             </div>
             <p>{{ permission.description }}</p>
           </div>
@@ -86,8 +92,8 @@ const sharesFiles = computed(() => (props.review.manifest.permissions.selectedRe
     </section>
     <p class="extension-install-review__trust">
       {{ english ? 'Only install plugins from sources you trust.' : '请确认你信任此插件的来源。' }}
-      <template v-if="sharesFiles">
-        {{ english ? 'This plugin can send selected file content to the listed websites.' : '此插件可以向上述网站发送已授权读取的文件内容。' }}
+      <template v-if="sharesContent">
+        {{ english ? 'This plugin can send authorized content to the listed websites.' : '此插件可以向上述网站发送已授权读取的内容。' }}
       </template>
     </p>
     <template #footer>
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionManager.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionManager.vue
index 36c8a34f..9228717d 100644
--- a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionManager.vue
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionManager.vue
@@ -15,6 +15,7 @@ import DesktopExtensionCard from './DesktopExtensionCard.vue'
 import DesktopExtensionCatalog from './DesktopExtensionCatalog.vue'
 import DesktopExtensionInstallations from './DesktopExtensionInstallations.vue'
 import DesktopExtensionInstallReview from './DesktopExtensionInstallReview.vue'
+import DesktopExtensionUiSettings from './DesktopExtensionUiSettings.vue'
 
 const { state, language, workbench, startCreation } = useExtensionContext()
 const { controller } = useWorkbench()
@@ -149,6 +150,7 @@ onScopeDispose(cancel)
         @revoke-resources="run(() => state.api.revokeResources(item.manifest.id))"
       />
     </div>
+    <DesktopExtensionUiSettings v-if="section === 'installed'" :language="language" />
   </DesktopExtensionWorkbench>
   <NModal v-model:show="installationLog" preset="card" :title="language === 'en-US' ? 'Installation log' : '安装记录'" class="extension-dialog">
     <DesktopExtensionInstallations :jobs="state.installations.value" :language="language" @cancel="id => state.api.cancelInstallation(id).then(state.refresh)" />
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionMenu.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionMenu.vue
new file mode 100644
index 00000000..d00b7d40
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionMenu.vue
@@ -0,0 +1,58 @@
+<script setup lang="ts">
+import type { WorkbenchMenuProps } from '@/shared/ui/contributions/workbenchUiContext'
+import { matchesWorkbenchContext } from '@buddy-shared/workbench/workbenchContext'
+import { MoreHorizontal20Regular } from '@vicons/fluent'
+import { NButton, NDropdown, useMessage } from 'naive-ui'
+import { computed, onScopeDispose, shallowRef } from 'vue'
+import { resolveBuddyLocale, translateBuddy } from '@/i18n/buddyI18n'
+import { useWorkbenchUiScope } from '@/shared/ui/contributions/workbenchUiContext'
+import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
+import { useExtensionContext } from '../extensionContext'
+
+const props = defineProps<WorkbenchMenuProps>()
+const { state, workbench, language } = useExtensionContext()
+const scope = useWorkbenchUiScope()
+const message = useMessage()
+const busy = shallowRef(false)
+let disposed = false
+onScopeDispose(() => {
+  disposed = true
+})
+const items = computed(() => {
+  const values = { ...workbench.value.values, ...props.values }
+  return state.installed.value.filter(plugin => plugin.enabled && plugin.compatible).flatMap(plugin => plugin.manifest.contributes.menus.flatMap((menu) => {
+    const command = plugin.manifest.contributes.commands.find(command => command.id === menu.command)
+    return menu.target === props.target && command && matchesWorkbenchContext(menu.when, values) && matchesWorkbenchContext(command.when, values) ? [{ key: menu.id, label: command.title, plugin, menu }] : []
+  })).sort((left, right) => left.menu.order - right.menu.order || left.key.localeCompare(right.key))
+})
+async function execute(key: string): Promise<void> {
+  const item = items.value.find(item => item.key === key)
+  if (!item || props.disabled || busy.value)
+    return
+  const instanceId = scope?.instanceId()
+  busy.value = true
+  try {
+    const selection = props.capture?.()
+    const result = await state.api.executeMenu(item.plugin.manifest.id, item.menu.id, { target: props.target, instanceId, resource: selection?.resource ?? null, ...(item.plugin.manifest.permissions.selectedContent && selection?.content !== undefined ? { content: selection.content } : {}) })
+    if (!disposed && !props.disabled && scope?.instanceId() === instanceId)
+      selection?.apply?.(result)
+  }
+  catch {
+    if (!disposed)
+      message.error(translateBuddy(resolveBuddyLocale(language.value), 'desktop.command.failed'))
+  }
+  finally {
+    busy.value = false
+  }
+}
+</script>
+
+<template>
+  <NDropdown v-if="items.length" trigger="click" :options="items" :disabled="disabled || busy" @select="execute">
+    <NButton quaternary class="buddy-icon-button" :data-workbench-menu="target" :disabled="disabled || busy" :loading="busy" :aria-label="language === 'en-US' ? 'More actions' : '更多操作'">
+      <template #icon>
+        <DesktopIcon :component="MoreHorizontal20Regular" />
+      </template>
+    </NButton>
+  </NDropdown>
+</template>
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionSlot.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionSlot.vue
new file mode 100644
index 00000000..cf42f0c2
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionSlot.vue
@@ -0,0 +1,41 @@
+<script setup lang="ts">
+import type { ExtensionViewInput } from '@buddy-shared/extensions/extensionApi'
+import type { WorkbenchSlot } from '@buddy-shared/workbench/workbenchUi'
+import { computed, shallowRef, watch } from 'vue'
+import { useWorkbenchUiScope } from '@/shared/ui/contributions/workbenchUiContext'
+import { useExtensionContext } from '../extensionContext'
+import DesktopExtensionSurface from './DesktopExtensionSurface.vue'
+
+const props = defineProps<{ target: WorkbenchSlot }>()
+defineSlots<{ default: () => unknown }>()
+const { ui, views } = useExtensionContext()
+const scope = useWorkbenchUiScope()
+const providers = computed(() => ui.selected({ kind: 'slot', target: props.target }))
+const inputs = shallowRef(new Map<string, ExtensionViewInput>())
+watch(() => providers.value.map(({ plugin, placement }) => `${placement.id}:${plugin.revision}:${scope?.instanceId() ?? ''}`), (keys) => {
+  inputs.value = new Map(keys.map((key, index) => {
+    const { plugin, placement } = providers.value[index]!
+    return [key, inputs.value.get(key) ?? { viewId: crypto.randomUUID(), extensionId: plugin.manifest.id, viewType: placement.view, placementId: placement.id, instanceId: scope?.instanceId(), resource: null, state: null, stateVersion: 0 }]
+  }))
+}, { immediate: true, flush: 'sync' })
+const surfaces = computed(() => [...inputs.value.values()].map((input) => {
+  const entry = views.surfaces.get(input.viewId)
+  const provider = providers.value.find(provider => provider.placement.id === input.placementId)!
+  return { input, height: provider.placement.height, ready: !!entry?.ready && entry.eligible && !entry.error && !['failed', 'blocked'].includes(provider.plugin.state) }
+}))
+</script>
+
+<template>
+  <div class="extension-slot" :data-workbench-slot="target">
+    <div v-for="surface in surfaces" :key="surface.input.viewId" class="extension-slot__content" :style="{ height: surface.ready ? `${surface.height}px` : '0px' }">
+      <DesktopExtensionSurface :input="surface.input" :visible="surface.ready" silent class="extension-slot__surface" />
+    </div>
+    <slot v-if="!surfaces.some(surface => surface.ready)" />
+  </div>
+</template>
+
+<style scoped>
+.extension-slot { min-width: 0; }
+.extension-slot__content { position: relative; min-width: 0; }
+.extension-slot__surface { position: absolute; inset: 0; }
+</style>
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionUiSettings.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionUiSettings.vue
new file mode 100644
index 00000000..965e33fb
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionUiSettings.vue
@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import type { WorkbenchUiSelectionTarget } from '@buddy-shared/workbench/workbenchUi'
+import { computed } from 'vue'
+import { useExtensionContext } from '../extensionContext'
+
+defineProps<{ language: string }>()
+const { ui, views } = useExtensionContext()
+const entries = computed(() => ui.entries.value.filter(entry => entry.providers.length || entry.selected.length))
+function choose(entry: WorkbenchUiSelectionTarget, event: Event): void {
+  const id = (event.target as HTMLSelectElement).value
+  if (entry.kind === 'control' && id)
+    views.retryControl(id)
+  ui.choose(entry, id ? [id] : [])
+}
+</script>
+
+<template>
+  <section v-if="entries.length" class="extension-ui-settings">
+    <h2>{{ language === 'en-US' ? 'Interface appearance' : '界面呈现' }}</h2>
+    <div v-for="entry in entries" :key="entry.target" class="extension-ui-settings__row" :data-ui-target="entry.target">
+      <label v-if="entry.selection === 'single'" :for="`ui-${entry.target}`">{{ entry.title[language === 'en-US' ? 'en-US' : 'zh-CN'] }}</label>
+      <span v-else :id="`label-${entry.target}`">{{ entry.title[language === 'en-US' ? 'en-US' : 'zh-CN'] }}</span>
+      <select v-if="entry.selection === 'single'" :id="`ui-${entry.target}`" :value="entry.selected[0] ?? ''" @change="choose(entry, $event)">
+        <option value="">
+          {{ language === 'en-US' ? 'Default' : '默认内容' }}
+        </option>
+        <option v-if="entry.selected[0] && !entry.providers.some(provider => provider.placement.id === entry.selected[0])" :value="entry.selected[0]" disabled>
+          {{ language === 'en-US' ? 'Unavailable' : '暂不可用' }}
+        </option>
+        <option v-for="provider in entry.providers" :key="provider.placement.id" :value="provider.placement.id">
+          {{ provider.plugin.manifest.name }} · {{ provider.title }}
+        </option>
+      </select>
+      <div v-else role="group" :aria-labelledby="`label-${entry.target}`" class="extension-ui-settings__choices">
+        <label v-for="id in entry.selected.filter(id => !entry.providers.some(provider => provider.placement.id === id))" :key="id">
+          <input type="checkbox" checked @change="ui.choose(entry, entry.selected.filter(value => value !== id))">
+          {{ language === 'en-US' ? 'Unavailable' : '暂不可用' }}
+        </label>
+        <label v-for="provider in entry.providers" :key="provider.placement.id">
+          <input type="checkbox" :disabled="entry.selected.length >= 8 && !entry.selected.includes(provider.placement.id)" :checked="entry.selected.includes(provider.placement.id)" @change="ui.choose(entry, ($event.target as HTMLInputElement).checked ? [...entry.selected, provider.placement.id] : entry.selected.filter(id => id !== provider.placement.id))">
+          {{ provider.plugin.manifest.name }} · {{ provider.title }}
+        </label>
+      </div>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.extension-ui-settings { display: grid; gap: 12px; margin-top: 18px; padding: 16px; border: 1px solid var(--buddy-border-subtle); border-radius: var(--buddy-radius-micro); }
+.extension-ui-settings h2 { margin: 0; color: var(--buddy-text-strong); font-size: 14px; }
+.extension-ui-settings__row { display: flex; align-items: center; justify-content: space-between; gap: 16px; color: var(--buddy-text-secondary); font-size: 13px; }
+.extension-ui-settings__row select { min-width: 140px; max-width: 50%; border: 1px solid var(--buddy-border-subtle); border-radius: 6px; padding: 6px 8px; background: var(--buddy-surface-base); color: var(--buddy-text-primary); font: inherit; }
+.extension-ui-settings__choices { display: grid; gap: 8px; }
+.extension-ui-settings__choices label { display: flex; gap: 8px; align-items: center; }
+</style>
diff --git a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionView.vue b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionView.vue
index 00c4ca3e..8345bf40 100644
--- a/apps/buddy/src/modules/extensions/widgets/DesktopExtensionView.vue
+++ b/apps/buddy/src/modules/extensions/widgets/DesktopExtensionView.vue
@@ -2,6 +2,7 @@
 import type { ExtensionViewInput } from '@buddy-shared/extensions/extensionApi'
 import type { WorkbenchView } from '@/workbench/common/workbench'
 import { extensionViewInputSchema } from '@buddy-shared/extensions/extensionApi'
+import { workbenchMountKey } from '@buddy-shared/workbench/workbenchUi'
 import { computed } from 'vue'
 import { useWorkbench } from '@/workbench/browser/workbenchContext'
 import DesktopExtensionSurface from './DesktopExtensionSurface.vue'
@@ -12,11 +13,11 @@ const mount = computed(() => {
   void revision.value
   const placement = props.view.placement ? controller.registry.placements.get(props.view.placement) : null
   const target = props.view.presentation?.target ?? placement?.target
-  const element = target ? mountPoints.value.get(target) : null
-  return target && element ? { target, element } : null
+  const element = target ? mountPoints.value.get(workbenchMountKey(target, props.view.mountInstanceId)) : null
+  return target && element ? { target, element, instanceId: props.view.mountInstanceId } : null
 })
 const input = computed<ExtensionViewInput | null>(() => {
-  const parsed = extensionViewInputSchema.safeParse({ viewId: props.view.id, extensionId: props.view.resource.data.extensionId, viewType: props.view.type, placementId: props.view.resource.data.placementId, resource: props.view.resource.data.resource ?? null, state: props.view.state.value ?? {}, stateVersion: props.view.state.version ?? 0 })
+  const parsed = extensionViewInputSchema.safeParse({ viewId: props.view.id, interactionId: props.view.interactionId, instanceId: props.view.mountInstanceId, extensionId: props.view.resource.data.extensionId, viewType: props.view.type, placementId: props.view.resource.data.placementId, resource: props.view.resource.data.resource ?? null, state: props.view.state.value ?? {}, stateVersion: props.view.state.version ?? 0 })
   return parsed.success ? parsed.data : null
 })
 </script>
diff --git a/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionControl.spec.ts b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionControl.spec.ts
index 21a3a8c7..24d68302 100644
--- a/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionControl.spec.ts
+++ b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionControl.spec.ts
@@ -3,12 +3,18 @@ import type { ExtensionApi, ExtensionStatus, ExtensionViewInput } from '@buddy-s
 import type { WorkbenchContextValues } from '@buddy-shared/workbench/workbenchContext'
 import type { ExtensionContext } from '../../extensionContext'
 import type { ExtensionViews } from '../useExtensionViews'
+import type { WorkbenchContext } from '@/workbench/browser/workbenchContext'
 import { extensionManifestSchema } from '@buddy-shared/extensions/extensionManifest'
 import { afterEach, expect, it, vi } from 'vitest'
-import { createApp, h, nextTick, shallowRef } from 'vue'
+import { createApp, h, nextTick, provide, shallowRef } from 'vue'
 import { SemanticAnchorRegistry } from '@/workbench/browser/surfaces/SemanticAnchorRegistry'
+import { workbenchKey } from '@/workbench/browser/workbenchContext'
+import { ContributionRegistry } from '@/workbench/services/ContributionRegistry'
+import { WorkbenchController } from '@/workbench/services/WorkbenchController'
 import { useProvideExtensionContext } from '../../extensionContext'
+import { useExtensionUiContributions } from '../../state/useExtensionUiContributions'
 import DesktopExtensionControl from '../DesktopExtensionControl.vue'
+import DesktopExtensionUiSettings from '../DesktopExtensionUiSettings.vue'
 import { useExtensionViews } from '../useExtensionViews'
 
 const disposables: (() => void)[] = []
@@ -34,7 +40,9 @@ async function setup() {
   const status: ExtensionStatus = { manifest, revision: 'package-1', enabled: true, compatible: true, development: false, pending: null, state: 'active', generation: crypto.randomUUID(), error: null, activationMs: null, logs: [] }
   const installed = shallowRef([status])
   const context = shallowRef<WorkbenchContextValues>({ 'page.id': 'lexora.tasks' })
-  const selection = shallowRef({ 'model.reasoning': 'tests.control.reasoning' })
+  const controller = new WorkbenchController(new ContributionRegistry())
+  controller.registry.register('configuration', scope => scope.configuration({ id: 'workbench.controls.model.reasoning', defaultValue: '', validate: value => typeof value === 'string' }))
+  controller.configuration.set('workbench.controls.model.reasoning', 'tests.control.reasoning')
   const value = shallowRef('low')
   const mounted = shallowRef(true)
   const opened: ExtensionViewInput[] = []
@@ -53,28 +61,22 @@ async function setup() {
   document.body.append(element)
   const app = createApp({
     setup() {
+      provide(workbenchKey, { controller } as WorkbenchContext)
       views = useExtensionViews(api, installed, context)
-      useProvideExtensionContext({
-        views,
-        workbench: shallowRef({ values: context.value, pages: [] }),
-        state: { installed, api } as ExtensionContext['state'],
-        anchors: new SemanticAnchorRegistry(),
-        controls: { selection, select: (target, id) => { selection.value = { ...selection.value, [target]: id } } },
-        language: shallowRef('en-US'),
-        isDark: shallowRef(false),
-        focusView: () => {},
-        startCreation: async () => {},
-      })
-      return () => mounted.value
-        ? h(DesktopExtensionControl, {
-            target: 'model.reasoning',
-            contextKey: 'model-a',
-            value: value.value,
-            options: [{ value: 'low', label: 'Low' }, { value: 'high', label: 'High' }],
-            disabled: false,
-            onChange: next => value.value = next,
-          }, { default: () => h('div', { 'data-native-control': '' }, value.value) })
-        : null
+      useProvideExtensionContext({ endInteraction: () => {}, views, workbench: shallowRef({ values: context.value, pages: [] }), state: { installed, api } as ExtensionContext['state'], anchors: new SemanticAnchorRegistry(), ui: useExtensionUiContributions(installed, controller.configuration), language: shallowRef('en-US'), isDark: shallowRef(false), focusView: () => {}, startCreation: async () => {} })
+      return () => h('div', [
+        h(DesktopExtensionUiSettings, { language: 'en-US' }),
+        mounted.value
+          ? h(DesktopExtensionControl, {
+              target: 'model.reasoning',
+              contextKey: 'model-a',
+              value: value.value,
+              options: [{ value: 'low', label: 'Low' }, { value: 'high', label: 'High' }],
+              disabled: false,
+              onChange: next => value.value = next,
+            }, { default: () => h('div', { 'data-native-control': '' }, value.value) })
+          : null,
+      ])
     },
   })
   app.mount(element)
diff --git a/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionFrameHost.spec.ts b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionFrameHost.spec.ts
new file mode 100644
index 00000000..fc9ca09d
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionFrameHost.spec.ts
@@ -0,0 +1,77 @@
+// @vitest-environment jsdom
+import type { ExtensionApi, ExtensionStatus } from '@buddy-shared/extensions/extensionApi'
+import type { ExtensionContext } from '../../extensionContext'
+import type { ExtensionViews } from '../useExtensionViews'
+import type { SurfaceLayout } from '@/shared/ui/surfaces/surfaceLayout'
+import { extensionManifestSchema } from '@buddy-shared/extensions/extensionManifest'
+import { afterEach, expect, it, vi } from 'vitest'
+import { createApp, h, nextTick, shallowRef } from 'vue'
+import { SemanticAnchorRegistry } from '@/workbench/browser/surfaces/SemanticAnchorRegistry'
+import { ContributionRegistry } from '@/workbench/services/ContributionRegistry'
+import { WorkbenchController } from '@/workbench/services/WorkbenchController'
+import { useProvideExtensionContext } from '../../extensionContext'
+import { useExtensionUiContributions } from '../../state/useExtensionUiContributions'
+import DesktopExtensionFrameHost from '../DesktopExtensionFrameHost.vue'
+import { useExtensionViews } from '../useExtensionViews'
+
+const disposables: (() => void)[] = []
+afterEach(() => disposables.splice(0).forEach(dispose => dispose()))
+
+it('delivers each broadcast once per frame only within the matching extension and generation', async () => {
+  const installed = shallowRef<ExtensionStatus[]>(['tests.first', 'tests.second'].map(id => ({ manifest: extensionManifestSchema.parse({ schemaVersion: 1, id, name: id, version: '1.0.0', apiVersion: 3, engines: { lexora: '*' }, contributes: {} }), revision: 'first', enabled: true, compatible: true, development: false, pending: null, state: 'active', generation: crypto.randomUUID(), error: null, activationMs: null, logs: [] })))
+  const api: Partial<ExtensionApi> = {
+    openView: async input => ({ id: input.viewId, extensionId: input.extensionId, generation: installed.value.find(item => item.manifest.id === input.extensionId)!.generation!, token: crypto.randomUUID(), url: 'about:blank' }),
+    closeView: async () => {},
+  }
+  const layout: SurfaceLayout = { attach: () => ({ update: () => {}, dispose: () => {} }), invalidate: () => {} }
+  const controller = new WorkbenchController(new ContributionRegistry())
+  let views!: ExtensionViews
+  const element = document.createElement('div')
+  document.body.append(element)
+  const app = createApp({
+    setup() {
+      views = useExtensionViews(api as ExtensionApi, installed, shallowRef({}))
+      useProvideExtensionContext({ state: { installed, api } as ExtensionContext['state'], views, ui: useExtensionUiContributions(installed, controller.configuration), anchors: new SemanticAnchorRegistry(), workbench: shallowRef({ values: {}, pages: [] }), language: shallowRef('en-US'), isDark: shallowRef(false), endInteraction: () => {}, focusView: () => {}, startCreation: async () => {} })
+      return () => h(DesktopExtensionFrameHost, { layout })
+    },
+  })
+  app.mount(element)
+  disposables.push(() => {
+    app.unmount()
+    element.remove()
+  })
+  for (const extensionId of ['tests.first', 'tests.first', 'tests.second']) {
+    views.show({ extensionId, viewId: crypto.randomUUID(), viewType: `${extensionId}.view`, resource: null, state: {}, stateVersion: 1 }, element, true)
+  }
+  await nextTick()
+  await vi.waitFor(() => expect(element.querySelectorAll('iframe')).toHaveLength(3))
+  const frames = [...element.querySelectorAll('iframe')].map((frame) => {
+    const messages: unknown[] = []
+    const target = frame.contentWindow!
+    target.addEventListener('message', ({ data }) => {
+      if (data?.channel === 'lexora-extension' && 'message' in data)
+        messages.push(data)
+    })
+    return { target, messages, session: views.surfaces.get(frame.dataset.extensionView!)!.session! }
+  })
+  const message = { action: 'increment', amount: 1 }
+  const plugin = installed.value[0]!
+  views.broadcast(plugin.manifest.id, crypto.randomUUID(), { action: 'obsolete' })
+  views.broadcast(plugin.manifest.id, plugin.generation!, message)
+  await Promise.all(frames.map(({ target }) => new Promise<void>((resolve) => {
+    const marker = crypto.randomUUID()
+    const receive = (event: MessageEvent) => {
+      if (event.data === marker) {
+        target.removeEventListener('message', receive)
+        resolve()
+      }
+    }
+    target.addEventListener('message', receive)
+    target.postMessage(marker, '*')
+  })))
+  expect(frames.map(frame => frame.messages)).toEqual([
+    [{ channel: 'lexora-extension', token: frames[0]!.session.token, message }],
+    [{ channel: 'lexora-extension', token: frames[1]!.session.token, message }],
+    [],
+  ])
+})
diff --git a/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionSlot.spec.ts b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionSlot.spec.ts
new file mode 100644
index 00000000..cdab8efb
--- /dev/null
+++ b/apps/buddy/src/modules/extensions/widgets/__tests__/DesktopExtensionSlot.spec.ts
@@ -0,0 +1,89 @@
+// @vitest-environment jsdom
+import type { ExtensionApi, ExtensionStatus, ExtensionViewInput } from '@buddy-shared/extensions/extensionApi'
+import type { WorkbenchContextValues } from '@buddy-shared/workbench/workbenchContext'
+import type { ExtensionContext } from '../../extensionContext'
+import type { ExtensionViews } from '../useExtensionViews'
+import type { WorkbenchContext } from '@/workbench/browser/workbenchContext'
+import { extensionManifestSchema } from '@buddy-shared/extensions/extensionManifest'
+import { afterEach, expect, it } from 'vitest'
+import { createApp, h, nextTick, provide, shallowRef } from 'vue'
+import { SemanticAnchorRegistry } from '@/workbench/browser/surfaces/SemanticAnchorRegistry'
+import { workbenchKey } from '@/workbench/browser/workbenchContext'
+import { ContributionRegistry } from '@/workbench/services/ContributionRegistry'
+import { WorkbenchController } from '@/workbench/services/WorkbenchController'
+import { useProvideExtensionContext } from '../../extensionContext'
+import { useExtensionUiContributions } from '../../state/useExtensionUiContributions'
+import DesktopExtensionSlot from '../DesktopExtensionSlot.vue'
+import DesktopExtensionUiSettings from '../DesktopExtensionUiSettings.vue'
+import { useExtensionViews } from '../useExtensionViews'
+
+const cleanups: (() => void)[] = []
+afterEach(() => cleanups.splice(0).forEach(cleanup => cleanup()))
+
+it('keeps the built-in footer until a selected slot view is ready and restores it when unavailable', async () => {
+  const manifest = extensionManifestSchema.parse({
+    schemaVersion: 1,
+    id: 'tests.footer',
+    name: 'Lyrics',
+    version: '1.0.0',
+    apiVersion: 3,
+    engines: { lexora: '*' },
+    contributes: {
+      views: [{ id: 'tests.footer.lyrics', title: 'Lyrics', entry: 'lyrics.js', resource: 'none' }],
+      placements: [{ id: 'tests.footer.placement', kind: 'slot', target: 'composer.footer', view: 'tests.footer.lyrics' }],
+    },
+  })
+  const status: ExtensionStatus = { manifest, revision: 'package-1', enabled: true, compatible: true, development: false, pending: null, state: 'active', generation: crypto.randomUUID(), error: null, activationMs: null, logs: [] }
+  const installed = shallowRef([status])
+  const context = shallowRef<WorkbenchContextValues>({ 'page.id': 'lexora.tasks' })
+  const controller = new WorkbenchController(new ContributionRegistry())
+  controller.registry.register('configuration', scope => scope.configuration({ id: 'workbench.slots.composer.footer', defaultValue: '', validate: value => typeof value === 'string' }))
+  const opened: ExtensionViewInput[] = []
+  const api = {
+    openView: async (input: ExtensionViewInput) => {
+      opened.push(input)
+      return { id: input.viewId, extensionId: input.extensionId, generation: status.generation!, token: crypto.randomUUID(), url: 'about:blank' }
+    },
+    closeView: async () => {},
+  } as unknown as ExtensionApi
+  let views!: ExtensionViews
+  const element = document.createElement('div')
+  document.body.append(element)
+  const app = createApp({
+    setup() {
+      provide(workbenchKey, { controller } as WorkbenchContext)
+      views = useExtensionViews(api, installed, context)
+      useProvideExtensionContext({ endInteraction: () => {}, workbench: shallowRef({ values: context.value, pages: [] }), anchors: new SemanticAnchorRegistry(), ui: useExtensionUiContributions(installed, controller.configuration), state: { installed, api } as ExtensionContext['state'], views, language: shallowRef('en-US'), isDark: shallowRef(false), focusView: () => {}, startCreation: async () => {} })
+      return () => h('div', [
+        h(DesktopExtensionUiSettings, { language: 'en-US' }),
+        ...[0, 1].map(index => h(DesktopExtensionSlot, { target: 'composer.footer' }, { default: () => h('p', `Verify results ${index}`) })),
+      ])
+    },
+  })
+  app.mount(element)
+  cleanups.push(() => {
+    app.unmount()
+    element.remove()
+  })
+
+  expect(element.textContent).toContain('Verify results 0')
+  expect(opened).toHaveLength(0)
+  const select = element.querySelector('select')!
+  select.value = 'tests.footer.placement'
+  select.dispatchEvent(new Event('change', { bubbles: true }))
+  await nextTick()
+  await nextTick()
+  expect(opened).toHaveLength(2)
+  expect(new Set(opened.map(input => input.viewId)).size).toBe(2)
+  expect(element.textContent).toContain('Verify results 0')
+
+  for (const surface of views.surfaces.values()) surface.ready = true
+  await nextTick()
+  expect(element.textContent).not.toContain('Verify results')
+
+  installed.value = [{ ...status, enabled: false, state: 'disabled' }]
+  await nextTick()
+  expect(element.textContent).toContain('Verify results 0')
+  expect(element.textContent).toContain('Verify results 1')
+  expect(controller.configuration.get('workbench.slots.composer.footer')).toBe('tests.footer.placement')
+})
diff --git a/apps/buddy/src/modules/extensions/widgets/useExtensionViews.ts b/apps/buddy/src/modules/extensions/widgets/useExtensionViews.ts
index 2ba5c6d3..dcccce77 100644
--- a/apps/buddy/src/modules/extensions/widgets/useExtensionViews.ts
+++ b/apps/buddy/src/modules/extensions/widgets/useExtensionViews.ts
@@ -1,5 +1,7 @@
 import type { ExtensionApi, ExtensionStatus, ExtensionViewInput, ExtensionViewSession } from '@buddy-shared/extensions/extensionApi'
 import type { WorkbenchContextValues } from '@buddy-shared/workbench/workbenchContext'
+import type { WorkbenchHitRegion } from '@buddy-shared/workbench/workbenchInteraction'
+import type { JsonValue } from '@buddy-shared/workbench/workbenchState'
 import type { ControlProposal, ControlSnapshot, WorkbenchMountTarget } from '@buddy-shared/workbench/workbenchUi'
 import type { Ref } from 'vue'
 import type { SemanticAnchor } from '@/shared/ui/contributions/workbenchUiContext'
@@ -21,9 +23,11 @@ export interface ExtensionSurface {
   opening: boolean
   ready: boolean
   anchor: SemanticAnchor | null
-  mount: { target: WorkbenchMountTarget, element: HTMLElement } | null
+  mount: { target: WorkbenchMountTarget, element: HTMLElement, instanceId?: string } | null
   control: ExtensionControlBinding | null
   error: string
+  regions: readonly WorkbenchHitRegion[]
+  interactionMode: 'regions' | 'exclusive' | null
 }
 interface SurfaceLifecycle {
   revision: string | null
@@ -38,13 +42,14 @@ interface ControlFailure {
 }
 
 function identity(input: ExtensionViewInput): string {
-  return JSON.stringify([input.extensionId, input.viewType, input.placementId, input.resource])
+  return JSON.stringify([input.extensionId, input.viewType, input.placementId, input.interactionId, input.resource])
 }
 
 export function useExtensionViews(api: ExtensionApi, installed: Readonly<Ref<ExtensionStatus[]>>, context: Readonly<Ref<WorkbenchContextValues>>) {
   const surfaces = shallowReactive(new Map<string, ExtensionSurface>())
   const lifecycles = new WeakMap<ExtensionSurface, SurfaceLifecycle>()
   const controlFailures = new Map<string, ControlFailure>()
+  const messageListeners = new Set<(extensionId: string, generation: string, message: JsonValue) => void>()
   let layout = () => {}
   const close = (session: ExtensionViewSession) => void api.closeView(session.id, session.generation, session.token).catch(() => {})
   function reset(surface: ExtensionSurface) {
@@ -55,6 +60,7 @@ export function useExtensionViews(api: ExtensionApi, installed: Readonly<Ref<Ext
     surface.opening = false
     surface.ready = false
     surface.error = ''
+    surface.regions = []
   }
   async function open(surface: ExtensionSurface) {
     const lifecycle = lifecycles.get(surface)!
@@ -101,6 +107,7 @@ export function useExtensionViews(api: ExtensionApi, installed: Readonly<Ref<Ext
       const manifest = status?.manifest
       const view = manifest?.contributes.views.find(view => view.id === surface.input.viewType)
       const placement = manifest?.contributes.placements.find(placement => placement.id === surface.input.placementId)
+      surface.interactionMode = placement?.kind === 'view' ? placement.interaction ?? null : null
       surface.eligible = matchesWorkbenchContext(view?.when, context.value) && matchesWorkbenchContext(placement?.when, context.value)
       if (!status?.enabled || !status.compatible || ['failed', 'blocked'].includes(status.state)) {
         reset(surface)
@@ -142,7 +149,7 @@ export function useExtensionViews(api: ExtensionApi, installed: Readonly<Ref<Ext
       previous.control = binding?.control ?? null
     }
     else {
-      const surface = shallowReactive<ExtensionSurface>({ input, element, visible, eligible: true, session: null, opening: false, ready: false, mount: binding?.mount ?? null, anchor: binding?.anchor ?? null, control: binding?.control ?? null, error: '' })
+      const surface = shallowReactive<ExtensionSurface>({ input, element, visible, eligible: true, session: null, opening: false, ready: false, mount: binding?.mount ?? null, anchor: binding?.anchor ?? null, control: binding?.control ?? null, error: '', regions: [], interactionMode: null })
       lifecycles.set(surface, { revision: null, generation: null, request: 0 })
       surfaces.set(input.viewId, surface)
     }
@@ -183,8 +190,22 @@ export function useExtensionViews(api: ExtensionApi, installed: Readonly<Ref<Ext
   }
   onScopeDispose(() => {
     for (const id of surfaces.keys()) hide(id)
+    messageListeners.clear()
   })
-  return { surfaces, show, hide, fail, retryControl, proposeControl, layout: () => layout(), setLayout: (callback: () => void) => {
+  function setRegions(id: string, generation: string, token: string, regions: WorkbenchHitRegion[]): boolean {
+    const surface = surfaces.get(id)
+    if (!surface || surface.interactionMode !== 'regions' || surface.session?.generation !== generation || surface.session.token !== token)
+      return false
+    surface.regions = regions
+    layout()
+    return true
+  }
+  return { setRegions, onMessage: (listener: (extensionId: string, generation: string, message: JsonValue) => void) => {
+    messageListeners.add(listener)
+    return () => messageListeners.delete(listener)
+  }, broadcast: (extensionId: string, generation: string, message: JsonValue) => {
+    for (const listener of messageListeners) listener(extensionId, generation, message)
+  }, surfaces, show, hide, fail, retryControl, proposeControl, layout: () => layout(), setLayout: (callback: () => void) => {
     layout = callback
   } }
 }
diff --git a/apps/buddy/src/modules/files/widgets/DesktopFileEditor.vue b/apps/buddy/src/modules/files/widgets/DesktopFileEditor.vue
index 61e6853c..f3bfaea5 100644
--- a/apps/buddy/src/modules/files/widgets/DesktopFileEditor.vue
+++ b/apps/buddy/src/modules/files/widgets/DesktopFileEditor.vue
@@ -3,8 +3,10 @@ import type { JsonValue } from '@buddy-shared/workbench/workbenchState'
 import type * as Monaco from 'monaco-editor/editor/editor.api.js'
 import type { TextModelPool } from '@/workbench/browser/TextModelPool'
 import type { WorkbenchView } from '@/workbench/common/workbench'
+import { spaceFileTargetSchema } from '@buddy-shared/spaces/spaceFileApi'
 import { NButton } from 'naive-ui'
 import { computed, onScopeDispose, shallowRef, useTemplateRef, watch } from 'vue'
+import WorkbenchMenu from '@/shared/ui/contributions/WorkbenchMenu.vue'
 import DesktopDocumentContent from '@/shared/ui/files/DesktopDocumentContent.vue'
 import DesktopDocumentToolbar from '@/shared/ui/files/DesktopDocumentToolbar.vue'
 import { fileDocumentModes, isMarkdownFile, resolveFileDocumentMode } from '@/shared/ui/files/fileDocumentPresentation'
@@ -99,6 +101,7 @@ onScopeDispose(controller.configuration.subscribe(() => editor?.updateOptions({
     <Teleport v-if="visible" :to="toolbarTarget ?? 'body'" :disabled="!toolbarTarget">
       <DesktopDocumentToolbar v-model="mode" :name="String(view.resource.data.path)" :modes="modes" :language="language" :embedded="!!toolbarTarget">
         <template #actions>
+          <WorkbenchMenu target="resource.actions" :values="{ 'resource.scheme': view.resource.scheme }" :capture="() => ({ resource: spaceFileTargetSchema.parse(view.resource.data) })" />
           <NButton v-if="mode === 'edit' || copies.dirty(view.resource)" size="tiny" secondary :loading="copy?.saving" :disabled="!copy || copy.loading || copy.saving || !!copy.conflict || !copies.dirty(view.resource)" @click="copies.save(view.resource)">
             {{ labels.save }}
           </NButton>
diff --git a/apps/buddy/src/modules/files/widgets/DesktopFilePreview.vue b/apps/buddy/src/modules/files/widgets/DesktopFilePreview.vue
index 36c0420e..752295ff 100644
--- a/apps/buddy/src/modules/files/widgets/DesktopFilePreview.vue
+++ b/apps/buddy/src/modules/files/widgets/DesktopFilePreview.vue
@@ -2,7 +2,9 @@
 import type { LocalChatApi } from '@buddy-electron/shared/localChatApi'
 import type { LocalSpaceFilePreview, SpaceFileTarget } from '@buddy-shared/spaces/spaceFileApi'
 import type { WorkbenchView } from '@/workbench/common/workbench'
+import { spaceFileTargetSchema } from '@buddy-shared/spaces/spaceFileApi'
 import { computed, shallowRef, watch } from 'vue'
+import WorkbenchMenu from '@/shared/ui/contributions/WorkbenchMenu.vue'
 import DesktopDocumentContent from '@/shared/ui/files/DesktopDocumentContent.vue'
 import DesktopDocumentToolbar from '@/shared/ui/files/DesktopDocumentToolbar.vue'
 import { fileDocumentModes, isMarkdownFile, resolveFileDocumentMode } from '@/shared/ui/files/fileDocumentPresentation'
@@ -31,7 +33,11 @@ watch(() => props.view.resource, () => void loadPreview(), { immediate: true })
 <template>
   <div class="file-preview">
     <Teleport v-if="visible" :to="toolbarTarget ?? 'body'" :disabled="!toolbarTarget">
-      <DesktopDocumentToolbar v-model="mode" :name="String(view.resource.data.path)" :modes="modes" :language="language" :embedded="!!toolbarTarget" />
+      <DesktopDocumentToolbar v-model="mode" :name="String(view.resource.data.path)" :modes="modes" :language="language" :embedded="!!toolbarTarget">
+        <template #actions>
+          <WorkbenchMenu target="resource.actions" :values="{ 'resource.scheme': view.resource.scheme }" :capture="() => ({ resource: spaceFileTargetSchema.parse(view.resource.data) })" />
+        </template>
+      </DesktopDocumentToolbar>
     </Teleport>
     <div v-if="failed" class="file-preview__notice" role="alert">
       <span>{{ labels.failed }}</span>
diff --git a/apps/buddy/src/modules/prompt-input/editor/chatComposerResourceEditing.ts b/apps/buddy/src/modules/prompt-input/editor/chatComposerResourceEditing.ts
index a014790a..df3d993f 100644
--- a/apps/buddy/src/modules/prompt-input/editor/chatComposerResourceEditing.ts
+++ b/apps/buddy/src/modules/prompt-input/editor/chatComposerResourceEditing.ts
@@ -181,6 +181,7 @@ export const ChatComposerPromptDirective = Node.create({
   addAttributes() {
     return {
       commandMode: { default: null, rendered: false },
+      commandId: { default: null, rendered: false },
       directive: { default: 'skill', rendered: false },
       skill: { default: null, rendered: false },
       value: { default: '', rendered: false },
diff --git a/apps/buddy/src/modules/prompt-input/model/chatComposerDocument.ts b/apps/buddy/src/modules/prompt-input/model/chatComposerDocument.ts
index b93851bf..85f5a35d 100644
--- a/apps/buddy/src/modules/prompt-input/model/chatComposerDocument.ts
+++ b/apps/buddy/src/modules/prompt-input/model/chatComposerDocument.ts
@@ -44,12 +44,12 @@ function inlineNodeToEditorNode(node: BuddyInlineNodeV1): JSONContent {
       attrs: { resourceId: node.resourceId },
       type: CHAT_RESOURCE_REFERENCE_NODE_NAME,
     }
-    case 'prompt_directive': return node.directive === 'slash_command' && isRetiredBuddyPromptCommand(node.value)
+    case 'prompt_directive': return node.directive === 'slash_command' && !node.commandId && isRetiredBuddyPromptCommand(node.value)
       ? { text: node.value, type: 'text' }
       : {
           attrs: node.directive === 'skill'
             ? { directive: node.directive, value: node.value, ...(node.skill ? { skill: { ...node.skill } } : {}) }
-            : { commandMode: node.commandMode, directive: node.directive, value: node.value },
+            : { commandMode: node.commandMode, ...(node.commandId ? { commandId: node.commandId } : {}), directive: node.directive, value: node.value },
           type: CHAT_PROMPT_DIRECTIVE_NODE_NAME,
         }
   }
@@ -71,7 +71,7 @@ function editorNodeToInlineNode(node: JSONContent): unknown {
       if (attrs.directive === 'skill' && attrs.commandMode != null)
         throw new Error('Skill directives cannot have a command mode')
       return {
-        ...(attrs.directive === 'skill' ? (attrs.skill ? { skill: attrs.skill } : {}) : { commandMode: attrs.commandMode }),
+        ...(attrs.directive === 'skill' ? (attrs.skill ? { skill: attrs.skill } : {}) : { commandMode: attrs.commandMode, ...(attrs.commandId ? { commandId: attrs.commandId } : {}) }),
         directive: attrs.directive,
         type: 'prompt_directive',
         value: attrs.value,
diff --git a/apps/buddy/src/modules/prompt-input/model/chatComposerInput.ts b/apps/buddy/src/modules/prompt-input/model/chatComposerInput.ts
index 25ef57a6..a5387577 100644
--- a/apps/buddy/src/modules/prompt-input/model/chatComposerInput.ts
+++ b/apps/buddy/src/modules/prompt-input/model/chatComposerInput.ts
@@ -11,6 +11,7 @@ import { chatComposerDocumentToUserContent } from './chatComposerDocument'
 export interface ChatPromptContextOption extends LocalPromptContextItem {
   description: string | null
   category?: 'artifact' | 'current' | 'history' | 'space' | 'external'
+  commandId?: string
   resourceId?: string
   entryKind?: 'file' | 'directory'
   fileName?: string
@@ -31,6 +32,7 @@ export interface ChatComposerContextOptions {
   directory?: BuddyComposerDirectory
   files: ReadonlyArray<ChatPromptContextOption>
   skills: ReadonlyArray<ChatPromptContextOption>
+  commands?: ReadonlyArray<ChatPromptContextOption>
 }
 
 export function createChatComposerSourceOptions(
@@ -113,14 +115,16 @@ export function createChatComposerSuggestions(
   if (!trigger)
     return []
   const candidates = trigger.kind === 'slash'
-    ? BUDDY_CHAT_COMMANDS.map(command => ({
+    ? [...BUDDY_CHAT_COMMANDS.map(command => ({
         description: translateCommand(command.descriptionKey),
         kind: 'slashCommand' as const,
         label: `/${command.name}`,
         path: null,
         value: `/${command.name}`,
-      }))
+      })), ...options.commands ?? []]
     : trigger.kind === 'skill' ? options.skills : createChatComposerSourceOptions(options.files)
+  if (trigger.kind === 'slash')
+    return candidates.filter(option => option.value.slice(1).startsWith(trigger.query)).slice(0, CHAT_COMPOSER_SUGGESTION_LIMIT).map(option => ({ option }))
   if (trigger.kind === 'mention')
     return candidates.map(option => ({ option }))
   return rankChatComposerOptions(candidates, trigger.query)
diff --git a/apps/buddy/src/modules/tasks/widgets/composer/DesktopChatComposer.vue b/apps/buddy/src/modules/tasks/widgets/composer/DesktopChatComposer.vue
index a5a35e80..d8323530 100644
--- a/apps/buddy/src/modules/tasks/widgets/composer/DesktopChatComposer.vue
+++ b/apps/buddy/src/modules/tasks/widgets/composer/DesktopChatComposer.vue
@@ -5,6 +5,7 @@ import type { BuddyPermissionMode } from '@buddy-shared/permissions/permissionMo
 import type { JSONContent } from '@tiptap/core'
 import type { DesktopChatComposerProps } from './typing'
 import type { ChatComposerSubmitPayload, ChatPromptContextOption } from '@/modules/prompt-input'
+import type { WorkbenchMenuSelection } from '@/shared/ui/contributions/workbenchUiContext'
 import { EditorContent } from '@tiptap/vue-3'
 import {
   ArrowUp20Regular,
@@ -14,10 +15,13 @@ import { NButton, NTooltip } from 'naive-ui'
 import { computed, shallowRef, toRef, useTemplateRef } from 'vue'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
 import { DesktopModelSelector } from '@/modules/models/ui'
+import { createChatComposerContentFromText } from '@/modules/prompt-input'
 import { DesktopChatComposerFrame, DesktopPermissionModeSelector } from '@/modules/prompt-input/ui'
 import ChatContextUsage from '@/modules/tasks/widgets/composer/ChatContextUsage.vue'
 import DesktopChatComposerInteractionHost from '@/modules/tasks/widgets/composer/DesktopChatComposerInteractionHost.vue'
 import { useChatComposer } from '@/modules/tasks/widgets/composer/useChatComposer'
+import WorkbenchMenu from '@/shared/ui/contributions/WorkbenchMenu.vue'
+import WorkbenchSlot from '@/shared/ui/contributions/WorkbenchSlot.vue'
 import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
 import ChatQuoteStrip from '../quotes/ChatQuoteStrip.vue'
 import ChatComposerSourceMenu from './ChatComposerSourceMenu.vue'
@@ -43,13 +47,13 @@ defineSlots<{
 }>()
 
 const { t } = useBuddyI18n(() => props.language)
-const queuesSubmission = computed(() => props.isRunning || props.hasQueuedMessages)
 const resourceStrip = useTemplateRef('resourceStrip')
 const {
   activeSuggestionIndex,
   activeTrigger,
   attachFiles,
   canSubmit,
+  isLocalCommand,
   closeSuggestions,
   editor,
   isLoadingContext,
@@ -91,6 +95,7 @@ const {
   onLocateResource: resourceId => resourceStrip.value?.highlightResource(resourceId),
 })
 
+const queuesSubmission = computed(() => !isLocalCommand.value && (props.isRunning || props.hasQueuedMessages))
 const modelSelectorRef = useTemplateRef<InstanceType<typeof DesktopModelSelector>>('modelSelectorRef')
 
 defineExpose({
@@ -145,6 +150,24 @@ async function selectConversationFile(option: ChatPromptContextOption) {
   if (await selectPanelResource(option))
     sourceMenuOpen.value = false
 }
+function captureDraft(): WorkbenchMenuSelection {
+  const current = editor.value
+  if (!current || !current.isEditable || current.isDestroyed)
+    return {}
+  const draftId = props.draftId
+  const { doc, selection } = current.state
+  return {
+    content: current.getText(),
+    apply(result) {
+      if (editor.value !== current || current.isDestroyed || !current.isEditable || props.isSending || props.draftId !== draftId || !current.state.doc.eq(doc))
+        return
+      if (!result || typeof result !== 'object' || Array.isArray(result) || typeof result.insertText !== 'string' || !result.insertText || result.insertText.length > 131072)
+        return
+      const content = createChatComposerContentFromText(result.insertText).content ?? []
+      current.chain().focus().insertContentAt({ from: selection.from, to: selection.to }, content).run()
+    },
+  }
+}
 </script>
 
 <template>
@@ -155,6 +178,7 @@ async function selectConversationFile(option: ChatPromptContextOption) {
     @drop="handleFileDrop"
   >
     <template #attachments>
+      <WorkbenchSlot target="composer.accessory" class="desktop-chat-composer__accessory" />
       <ChatQuoteStrip :quotes="quotes" :language="language" :disabled="isSending" removable @remove="removeQuote" />
       <ComposerResourceStrip
         ref="resourceStrip"
@@ -212,6 +236,7 @@ async function selectConversationFile(option: ChatPromptContextOption) {
     </template>
 
     <template #leading>
+      <WorkbenchMenu target="composer.actions" :disabled="isSending" :capture="captureDraft" />
       <ChatComposerSourceMenu
         v-model:show="sourceMenuOpen"
         :disabled="isSelectingFiles || isSending"
@@ -309,7 +334,7 @@ async function selectConversationFile(option: ChatPromptContextOption) {
             <NButton
               class="buddy-icon-button desktop-chat-composer__send-action"
               type="primary"
-              :aria-label="t('desktop.chat.send')"
+              :aria-label="isLocalCommand ? t('desktop.command.run') : t('desktop.chat.send')"
               :disabled="!canSubmit"
               :loading="isSending"
               @click="submit"
@@ -320,14 +345,16 @@ async function selectConversationFile(option: ChatPromptContextOption) {
             </NButton>
           </span>
         </template>
-        {{ modelInputIssueMessage || t('desktop.chat.send') }}
+        {{ isLocalCommand ? t('desktop.command.run') : modelInputIssueMessage || t('desktop.chat.send') }}
       </NTooltip>
     </template>
 
     <template #footer>
-      <p class="desktop-chat-composer__disclaimer">
-        {{ t('desktop.chat.disclaimer') }}
-      </p>
+      <WorkbenchSlot target="composer.footer" class="desktop-chat-composer__footer">
+        <p class="desktop-chat-composer__disclaimer">
+          {{ t('desktop.chat.disclaimer') }}
+        </p>
+      </WorkbenchSlot>
     </template>
   </DesktopChatComposerFrame>
 </template>
@@ -437,8 +464,12 @@ async function selectConversationFile(option: ChatPromptContextOption) {
     }
   }
 
+  &__accessory { max-height: min(240px, 30vh); overflow: auto; }
+
+  &__footer { margin-top: 0.45rem; }
+
   &__disclaimer {
-    margin: 0.45rem 0 0;
+    margin: 0;
     color: var(--buddy-text-muted);
     font-size: 0.68rem;
     text-align: center;
diff --git a/apps/buddy/src/modules/tasks/widgets/composer/__tests__/chatComposerEditing.spec.ts b/apps/buddy/src/modules/tasks/widgets/composer/__tests__/chatComposerEditing.spec.ts
index 906337f7..fb47489c 100644
--- a/apps/buddy/src/modules/tasks/widgets/composer/__tests__/chatComposerEditing.spec.ts
+++ b/apps/buddy/src/modules/tasks/widgets/composer/__tests__/chatComposerEditing.spec.ts
@@ -5,6 +5,7 @@ import type { LocalRuntimeModelOption } from '@buddy-shared/providers/providerAp
 import type { JSONContent } from '@tiptap/core'
 import type { ComposerResourceView } from '../../../state/composer/typing'
 import type { ChatComposerContextOptions, ChatComposerSubmitPayload, ChatPromptContextOption } from '@/modules/prompt-input'
+import type { WorkbenchCommandPort } from '@/shared/ui/contributions/workbenchCommands'
 import { deferred } from '@buddy-tests/deferred'
 import { EditorContent } from '@tiptap/vue-3'
 import { afterEach, describe, expect, it } from 'vitest'
@@ -12,6 +13,7 @@ import { createApp, defineComponent, h, nextTick, shallowRef } from 'vue'
 import { chatComposerDocumentToUserContent, createChatComposerContentFromText, getChatComposerResourceIds } from '@/modules/prompt-input'
 import { replaceChatComposerDocument } from '@/modules/prompt-input/editor/chatComposerResourceEditing'
 import { insertChatComposerResources } from '@/modules/prompt-input/ui'
+import { useProvideWorkbenchCommands } from '@/shared/ui/contributions/workbenchCommands'
 import { CONVERSATION_STATUS_PANEL_KEY } from '../../../state/runs/conversationStatusPanel'
 import { useChatComposer } from '../useChatComposer'
 
@@ -45,6 +47,7 @@ async function mountComposer(options: {
   selectSource?: (source: BuddyComposerSource) => Promise<string | null>
   model?: LocalRuntimeModelOption
   statusPanel?: boolean
+  commands?: WorkbenchCommandPort
 } = {}) {
   const canSend = shallowRef(true)
   const statusPanelOpen = shallowRef(false)
@@ -60,7 +63,7 @@ async function mountComposer(options: {
   let composer!: ReturnType<typeof useChatComposer>
   const root = document.createElement('div')
   document.body.append(root)
-  const app = createApp(defineComponent({
+  const component = defineComponent({
     setup() {
       composer = useChatComposer({
         canSend,
@@ -93,6 +96,13 @@ async function mountComposer(options: {
         statusPanelOpen.value ? h('aside', { 'data-testid': 'conversation-status-panel' }, 'Conversation status') : null,
       ]
     },
+  })
+  const app = createApp(defineComponent({
+    setup() {
+      if (options.commands)
+        useProvideWorkbenchCommands(options.commands)
+      return () => h(component)
+    },
   }))
   if (options.statusPanel !== false)
     app.provide(CONVERSATION_STATUS_PANEL_KEY, { open: () => { statusPanelOpen.value = true } })
@@ -610,3 +620,81 @@ describe('chat composer editing', () => {
     expect(flow.composer.isLoadingContext.value).toBe(false)
   })
 })
+
+function localCommands(execute: WorkbenchCommandPort['execute']) {
+  const errors: string[] = []
+  const entries = shallowRef([{ id: 'tests.game.start', name: 'game:start', title: 'Start game' }])
+  return { errors, entries, execute, reportFailure: () => {
+    errors.push('failed')
+  } }
+}
+
+it('inserts a stable local command reference without executing, then runs without a model', async () => {
+  const executions: { id: string, args: string }[] = []
+  const commands = localCommands(async (id, args) => {
+    executions.push({ id, args })
+    return null
+  })
+  const flow = await mountComposer({ commands })
+  flow.canSend.value = false
+  flow.editor.commands.setContent(createChatComposerContentFromText('/game:star'))
+  flow.editor.commands.setTextSelection('/game:star'.length + 1)
+  flow.composer.activeTrigger.value = { kind: 'slash', query: 'game:star' }
+  flow.composer.selectSuggestion({ kind: 'slashCommand', commandId: 'tests.game.start', value: '/game:start', label: '/game:start', description: null, path: null })
+  expect(executions).toEqual([])
+  expect(chatComposerDocumentToUserContent(flow.editor.getJSON()).body[0]!.content[0]).toMatchObject({ commandId: 'tests.game.start', value: '/game:start', commandMode: 'action' })
+  flow.editor.commands.insertContent('level=2')
+  expect(flow.composer.canSubmit.value).toBe(true)
+  flow.keydown('Enter')
+  await nextTick()
+  expect(executions).toEqual([{ id: 'tests.game.start', args: 'level=2' }])
+  expect(flow.sent).toEqual([])
+  expect(flow.editor.getText()).toBe('')
+})
+
+it.each(['/game:star', '/GAME:start', '/start', '/game:started'])('keeps an unmatched local command %s out of the model path', async (text) => {
+  let executed = false
+  const commands = localCommands(async () => {
+    executed = true
+    return null
+  })
+  const flow = await mountComposer({ commands })
+  flow.editor.commands.setContent(createChatComposerContentFromText(text))
+  flow.keydown('Enter')
+  await nextTick()
+  expect(flow.editor.getText()).toBe(text)
+  expect(flow.sent).toEqual([])
+  expect(executed).toBe(false)
+  expect(commands.errors).toEqual(['failed'])
+})
+
+it('retains a failed or removed command draft and never dispatches it as a prompt', async () => {
+  const commands = localCommands(async () => {
+    throw new Error('Unavailable')
+  })
+  const flow = await mountComposer({ commands })
+  flow.editor.commands.setContent(createChatComposerContentFromText('/game:start'))
+  flow.keydown('Enter')
+  await nextTick()
+  expect(flow.editor.getText()).toBe('/game:start')
+  commands.entries.value = []
+  flow.keydown('Enter')
+  await nextTick()
+  expect(flow.editor.getText()).toBe('/game:start')
+  expect(commands.errors).toEqual(['failed', 'failed'])
+  expect(flow.sent).toEqual([])
+})
+
+it('does not clear edits or a different draft after an asynchronous local command completes', async () => {
+  const result = deferred<null>()
+  const commands = localCommands(async () => result.promise)
+  const flow = await mountComposer({ commands })
+  flow.editor.commands.setContent(createChatComposerContentFromText('/game:start'))
+  flow.keydown('Enter')
+  flow.editor.commands.setContent(createChatComposerContentFromText('New work'))
+  flow.draftId.value = 'draft-2'
+  result.resolve(null)
+  await nextTick()
+  expect(flow.editor.getText()).toBe('New work')
+  expect(flow.sent).toEqual([])
+})
diff --git a/apps/buddy/src/modules/tasks/widgets/composer/useChatComposer.ts b/apps/buddy/src/modules/tasks/widgets/composer/useChatComposer.ts
index 8b8f1237..542b6b6c 100644
--- a/apps/buddy/src/modules/tasks/widgets/composer/useChatComposer.ts
+++ b/apps/buddy/src/modules/tasks/widgets/composer/useChatComposer.ts
@@ -16,8 +16,10 @@ import { composerParentDirectory } from './chatComposerSourcePresentation'
 import { addChatQuote, removeChatQuote } from './chatQuoteEditing'
 import { useChatComposerEditor } from './useChatComposerEditor'
 import { useChatComposerSuggestions } from './useChatComposerSuggestions'
+import { useComposerCommands } from './useComposerCommands'
 
 export function useChatComposer(options: UseChatComposerOptions) {
+  const localCommands = useComposerCommands(options.draftId)
   const conversationStatusPanel = useConversationStatusPanel()
   let editingSession = 0
   watch(options.draftId, () => {
@@ -66,9 +68,12 @@ export function useChatComposer(options: UseChatComposerOptions) {
     resourceIds: resourceIds.value,
     resources: options.resources.value,
   }))
-  const canSubmit = computed(() => options.canSend.value && modelInputIssue.value === null && (
-    serializedContent.value.content.length > 0 || resourceIds.value.length > 0 || quotes.value.length > 0
-  ) && resourceIds.value.every(id => resourceById.value.get(id)?.resource.state === 'ready'))
+  const isLocalCommand = computed(() => localCommands.handles(serializedContent.value))
+  const canSubmit = computed(() => isLocalCommand.value
+    ? !localCommands.pending.value && !options.isSending.value
+    : options.canSend.value && modelInputIssue.value === null && (
+      serializedContent.value.content.length > 0 || resourceIds.value.length > 0 || quotes.value.length > 0
+    ) && resourceIds.value.every(id => resourceById.value.get(id)?.resource.state === 'ready'))
   const panelResources = computed(() => (contentJSON.value.attrs?.panelResourceIds as string[] ?? [])
     .flatMap(id => resourceById.value.get(id) ?? []))
   const resourceStripResources = computed<ComposerResourceCard[]>(() => {
@@ -92,7 +97,12 @@ export function useChatComposer(options: UseChatComposerOptions) {
     const current = editor.value
     if (!current?.isEditable)
       return
-    const command = parseBuddyChatCommand(serializeChatComposerContent(current.getJSON()).content)
+    const payload = serializeChatComposerContent(current.getJSON())
+    if (localCommands.handles(payload)) {
+      void localCommands.execute(current, payload)
+      return
+    }
+    const command = parseBuddyChatCommand(payload.content)
     if (command) {
       const definition = getBuddyChatCommandDefinition(command.name)
       if (definition.kind === 'action' && definition.action !== 'run') {
@@ -210,6 +220,11 @@ export function useChatComposer(options: UseChatComposerOptions) {
       void insertResolvedChatComposerResource(currentEditor, { from, to }, () => resolveOption(option))
       return
     }
+    if (option.kind === 'slashCommand' && option.commandId) {
+      query.closeSuggestions()
+      currentEditor.chain().focus().insertContentAt({ from, to }, [{ type: CHAT_PROMPT_DIRECTIVE_NODE_NAME, attrs: { directive: 'slash_command', commandMode: 'action', commandId: option.commandId, value: option.value } }, { type: 'text', text: ' ' }]).run()
+      return
+    }
     const command = option.kind === 'slashCommand' ? parseBuddyChatCommand(option.value) : null
     if (option.kind === 'slashCommand') {
       if (!command)
@@ -258,6 +273,7 @@ export function useChatComposer(options: UseChatComposerOptions) {
     activeTrigger: query.activeTrigger,
     attachFiles,
     canSubmit,
+    isLocalCommand,
     closeSuggestions: query.closeSuggestions,
     contextOptions: query.contextOptions,
     editor,
diff --git a/apps/buddy/src/modules/tasks/widgets/composer/useChatComposerSuggestions.ts b/apps/buddy/src/modules/tasks/widgets/composer/useChatComposerSuggestions.ts
index 559bfce5..dbdd69b1 100644
--- a/apps/buddy/src/modules/tasks/widgets/composer/useChatComposerSuggestions.ts
+++ b/apps/buddy/src/modules/tasks/widgets/composer/useChatComposerSuggestions.ts
@@ -3,12 +3,14 @@ import type { ChatComposerContextOptions, ChatComposerTrigger, ChatPromptContext
 import { computed, onScopeDispose, shallowRef, watch } from 'vue'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
 import { createChatComposerSourceOptions, createChatComposerSuggestions, getChatComposerResourceIds, shouldSubmitChatComposerKey } from '@/modules/prompt-input'
+import { useWorkbenchCommands } from '@/shared/ui/contributions/workbenchCommands'
 
 export function useChatComposerSuggestions(
   options: Pick<UseChatComposerOptions, 'composerContent' | 'draftId' | 'language' | 'loadContextOptions' | 'resources'>,
   onSelect: (option: ChatPromptContextOption | undefined, action?: 'complete' | 'select') => void,
   getImageLabel: (resourceId: string) => string | undefined,
 ) {
+  const commands = useWorkbenchCommands()
   const { t } = useBuddyI18n(options.language)
   const contextOptions = shallowRef<ChatComposerContextOptions>({ files: [], skills: [] })
   const activeTrigger = shallowRef<ChatComposerTrigger | null>(null)
@@ -41,7 +43,7 @@ export function useChatComposerSuggestions(
     })
   })
   const sourceOptions = computed(() => [...createChatComposerSourceOptions(currentOptions.value, fileQuery.value), ...createChatComposerSourceOptions(contextOptions.value.files)])
-  const suggestions = computed(() => createChatComposerSuggestions(activeTrigger.value, { ...contextOptions.value, files: sourceOptions.value }, key => t(key)))
+  const suggestions = computed(() => createChatComposerSuggestions(activeTrigger.value, { ...contextOptions.value, files: sourceOptions.value, commands: commands?.entries.value.map(command => ({ commandId: command.id, description: command.description ?? command.title, kind: 'slashCommand', label: `/${command.name}`, value: `/${command.name}`, path: null })) }, key => t(key)))
 
   function invalidateQuery() {
     contextRequestId += 1
diff --git a/apps/buddy/src/modules/tasks/widgets/composer/useComposerCommands.ts b/apps/buddy/src/modules/tasks/widgets/composer/useComposerCommands.ts
new file mode 100644
index 00000000..bb045899
--- /dev/null
+++ b/apps/buddy/src/modules/tasks/widgets/composer/useComposerCommands.ts
@@ -0,0 +1,53 @@
+import type { Editor } from '@tiptap/core'
+import type { Ref } from 'vue'
+import type { ChatComposerSubmitPayload } from '@/modules/prompt-input'
+import { parseBuddyChatCommand } from '@buddy-shared/conversation/buddyChatCommands'
+import { getBuddyUserContentResourceIds } from '@buddy-shared/conversation/buddyUserContent'
+import { parseSlashInvocation } from '@buddy-shared/workbench/workbenchCommand'
+import { computed, shallowRef } from 'vue'
+import { useWorkbenchCommands } from '@/shared/ui/contributions/workbenchCommands'
+import { useWorkbenchUiScope } from '@/shared/ui/contributions/workbenchUiContext'
+
+export function useComposerCommands(draftId: Readonly<Ref<string>>) {
+  const port = useWorkbenchCommands()
+  const scope = useWorkbenchUiScope()
+  const pending = shallowRef(false)
+  const entries = computed(() => port?.entries.value ?? [])
+
+  function handles(payload: ChatComposerSubmitPayload): boolean {
+    const nodes = payload.userContent?.body.flatMap(paragraph => paragraph.content) ?? []
+    return nodes.some(node => node.type === 'prompt_directive' && node.directive === 'slash_command' && !!node.commandId)
+      || (payload.content.trimStart().startsWith('/') && !parseBuddyChatCommand(payload.content))
+  }
+
+  async function execute(editor: Editor, payload: ChatComposerSubmitPayload): Promise<void> {
+    if (pending.value)
+      return
+    const content = payload.userContent
+    const invocation = parseSlashInvocation(payload.content)
+    const directives = content?.body.flatMap(paragraph => paragraph.content.filter(node => node.type === 'prompt_directive')) ?? []
+    const reference = directives.find(node => node.directive === 'slash_command' && node.commandId)
+    const candidates = entries.value.filter(entry => entry.name === invocation?.name && (!reference || (reference.directive === 'slash_command' && entry.id === reference.commandId)))
+    if (!port || !content || !invocation || candidates.length !== 1 || directives.length > (reference ? 1 : 0) || getBuddyUserContentResourceIds(content).length || content.quotes?.length) {
+      port?.reportFailure()
+      return
+    }
+    const id = draftId.value
+    const instanceId = scope?.instanceId()
+    const doc = editor.state.doc
+    pending.value = true
+    try {
+      await port.execute(candidates[0]!.id, invocation.arguments, instanceId)
+      if (!editor.isDestroyed && editor.isEditable && id === draftId.value && instanceId === scope?.instanceId() && editor.state.doc.eq(doc))
+        editor.commands.clearContent()
+    }
+    catch {
+      port?.reportFailure()
+    }
+    finally {
+      pending.value = false
+    }
+  }
+
+  return { entries, pending, handles, execute }
+}
diff --git a/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskIndex.vue b/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskIndex.vue
index e2e4ee8d..302e6f3e 100644
--- a/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskIndex.vue
+++ b/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskIndex.vue
@@ -29,6 +29,7 @@ import DesktopTaskMarkManager from './DesktopTaskMarkManager.vue'
 
 const props = defineProps<{
   activeConversationId: string | null
+  pendingConversationIds?: readonly string[]
   marks: TaskMarks
   appSidebarCollapsed: boolean
   language: BuddyLocale
@@ -55,6 +56,7 @@ const marksOpen = shallowRef(false)
 const searchOpen = shallowRef(false)
 function markBindings(conversationId: string) {
   return {
+    loading: props.pendingConversationIds?.includes(conversationId),
     marks: props.marks.items.value,
     markState: props.marks.states.value.get(conversationId),
     marksBusy: props.marks.busy.value,
diff --git a/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskRow.vue b/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskRow.vue
index 91aa00e5..b6cbdcba 100644
--- a/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskRow.vue
+++ b/apps/buddy/src/modules/tasks/widgets/task-index/DesktopTaskRow.vue
@@ -15,7 +15,7 @@ import {
   TagDismiss20Regular,
 } from '@vicons/fluent'
 import { NDropdown, NTooltip } from 'naive-ui'
-import { computed, h, useId, useTemplateRef } from 'vue'
+import { computed, h, shallowRef, useId, useTemplateRef, watch } from 'vue'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
 import DesktopOverflowingLabel from '@/modules/tasks/widgets/task-index/DesktopOverflowingLabel.vue'
 import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
@@ -27,6 +27,7 @@ import { useTaskHistoryDrag } from './useTaskHistoryDrag'
 const props = defineProps<{
   taskId: string
   active: boolean
+  loading?: boolean
   marks: readonly LocalTaskMark[]
   markState?: LocalTaskMarkState
   marksBusy: boolean
@@ -59,6 +60,14 @@ const emit = defineEmits<{
 }>()
 
 const { t } = useBuddyI18n(() => props.language)
+const opening = shallowRef(false)
+watch(() => props.loading, (loading, _, cleanup) => {
+  opening.value = false
+  if (loading) {
+    const timer = setTimeout(() => opening.value = true, 200)
+    cleanup(() => clearTimeout(timer))
+  }
+}, { immediate: true })
 const relativeTimeLabel = computed(() => (
   formatTaskRelativeTime(props.occurredAt, props.now, props.language)
 ))
@@ -174,8 +183,10 @@ useTaskHistoryDrag({
         class="desktop-task-sidebar__task"
         :class="{ 'is-active': active }"
         type="button"
+        :aria-busy="loading || undefined"
         @click="emit('open')"
       >
+        <span v-if="opening" class="desktop-task-row__opening" aria-hidden="true"><DesktopIcon :component="SpinnerIos20Regular" /></span>
         <DesktopOverflowingLabel :paused="dragging" :text="title" />
       </button>
       <div class="desktop-task-row__trailing">
@@ -393,6 +404,14 @@ button {
   }
 }
 
+.desktop-task-row__opening {
+  display: flex;
+  flex: none;
+  margin-right: 6px;
+  color: var(--buddy-text-muted);
+  .n-icon { font-size: 16px; animation: desktop-task-row-spin 1s linear infinite; }
+}
+
 .desktop-task-row__activity {
   display: grid;
   width: var(--buddy-task-sidebar-action-size, 1.75rem);
@@ -456,7 +475,8 @@ button {
 }
 
 @media (prefers-reduced-motion: reduce) {
-  .desktop-task-row__activity.is-running .n-icon {
+  .desktop-task-row__activity.is-running .n-icon,
+  .desktop-task-row__opening .n-icon {
     animation: none;
   }
 }
diff --git a/apps/buddy/src/modules/tasks/widgets/transcript/BuddyChatActionToolbar.vue b/apps/buddy/src/modules/tasks/widgets/transcript/BuddyChatActionToolbar.vue
index fdfeb97d..801316b5 100644
--- a/apps/buddy/src/modules/tasks/widgets/transcript/BuddyChatActionToolbar.vue
+++ b/apps/buddy/src/modules/tasks/widgets/transcript/BuddyChatActionToolbar.vue
@@ -9,6 +9,7 @@ import { useTimeoutFn } from '@vueuse/core'
 import { NButton, NTooltip, useMessage } from 'naive-ui'
 import { shallowRef } from 'vue'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
+import WorkbenchMenu from '@/shared/ui/contributions/WorkbenchMenu.vue'
 import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
 import { formatChatMessageTimeLabel } from '../../model/transcript/chatMessageTime'
 import BuddyChatTokenUsage from './BuddyChatTokenUsage.vue'
@@ -54,6 +55,7 @@ async function copyContent() {
 
 <template>
   <div class="buddy-chat-action-toolbar">
+    <WorkbenchMenu v-if="actions.showCopy" target="message.actions" :values="{ 'message.role': role }" :capture="() => ({ content: copyText })" />
     <time
       v-if="actions.showTime && role === 'user'"
       class="buddy-chat-action-toolbar__time"
diff --git a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspace.vue b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspace.vue
index f92a51c9..5a75e0a2 100644
--- a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspace.vue
+++ b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspace.vue
@@ -6,6 +6,7 @@ import { readBuddyUserMessageContent } from '@buddy-shared/conversation/buddyUse
 import { computed, defineAsyncComponent, nextTick, shallowRef, useTemplateRef, watch } from 'vue'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
 import DesktopRuntimePane from '@/platform/runtime/DesktopRuntimePane.vue'
+import WorkbenchSlot from '@/shared/ui/contributions/WorkbenchSlot.vue'
 import { useConversationNodeDetail } from '../../state/conversations/useConversationNodeDetail'
 import ConversationNodeDetail from '../canvas/ConversationNodeDetail.vue'
 import { useConversationDetailResize } from '../canvas/useConversationDetailResize'
@@ -18,7 +19,7 @@ import DesktopTaskComposer from './DesktopTaskComposer.vue'
 import DesktopTaskNotices from './DesktopTaskNotices.vue'
 import { useChatWorkspace } from './useChatWorkspace'
 
-const props = defineProps<ChatWorkspaceProps>()
+const props = withDefaults(defineProps<ChatWorkspaceProps>(), { active: true })
 const emit = defineEmits<ChatWorkspaceEmits>()
 defineSlots<{
   composerLeadingContext?: () => unknown
@@ -62,11 +63,21 @@ watch(() => props.viewMode, (value) => {
 }, { immediate: true })
 const messageList = useTemplateRef<BuddyChatMessageListHandle>('messageList')
 const { isEmpty, isLoading, language, transcriptBindings, viewport, welcomeVariant } = useChatWorkspace(props, messageList)
+watch([pageRef, isLoading], ([element, loading], _, cleanup) => {
+  if (!element || loading)
+    return
+  let cancelled = false
+  cleanup(() => cancelled = true)
+  void nextTick(() => {
+    if (!cancelled)
+      emit('ready')
+  })
+}, { flush: 'post' })
 useTaskResultRead({
   root: pageRef,
   conversationId: computed(() => props.workspace.session.activeConversationId.value),
   marks: () => props.workspace.marks,
-  disabled: computed(() => isLoading.value || props.workspace.status.isClosing.value || props.workspace.status.runtimeState.value.status !== 'ready'),
+  disabled: computed(() => !props.active || isLoading.value || props.workspace.status.isClosing.value || props.workspace.status.runtimeState.value.status !== 'ready'),
 })
 
 async function focusComposer() {
@@ -166,7 +177,7 @@ function openDetailChanges(id: string) {
 </script>
 
 <template>
-  <DesktopRuntimePane :loading="isLoading" :language="language">
+  <DesktopRuntimePane :loading="isLoading" :language="language" :animate="false">
     <section ref="pageRef" class="desktop-chat-page" :class="{ 'is-loading': isLoading, 'is-empty': isEmpty && viewMode !== 'canvas', 'has-node-detail': detailVisible, 'is-question-preview': !composerVisible, 'is-resizing-detail': detailResize.dragging.value }" :style="{ '--conversation-detail-width': `${detailResize.width.value}px` }" :data-view-mode="viewMode">
       <main class="desktop-chat-page__content">
         <DesktopConversationCanvas
@@ -182,11 +193,12 @@ function openDetailChanges(id: string) {
           @edit-node="editNode"
           @open-node-artifact="nodeDetail.close(); emit('openNodeArtifact', $event)"
         />
-        <DesktopChatWelcome
-          v-if="viewMode !== 'canvas' && isEmpty && !isLoading && welcomeVariant"
-          :language="language"
-          :variant="welcomeVariant"
-        />
+        <WorkbenchSlot v-if="viewMode !== 'canvas' && isEmpty && !isLoading && welcomeVariant" target="task.welcome">
+          <DesktopChatWelcome
+            :language="language"
+            :variant="welcomeVariant"
+          />
+        </WorkbenchSlot>
 
         <DesktopChatTranscript
           v-else-if="viewMode !== 'canvas' && transcriptBindings"
@@ -243,7 +255,7 @@ function openDetailChanges(id: string) {
             ref="composerRef"
             :composer="workspace.composer"
             :skill-scope-id="workspace.session.spaceId.value"
-            :focus-ready="composerVisible && !isLoading && workspace.status.runtimeState.value.status === 'ready'"
+            :focus-ready="active && composerVisible && !isLoading && workspace.status.runtimeState.value.status === 'ready'"
             :execution="workspace.execution"
             :language="language"
           >
diff --git a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspaceHeader.vue b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspaceHeader.vue
index 10cbdbf9..80cbc2d5 100644
--- a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspaceHeader.vue
+++ b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopChatWorkspaceHeader.vue
@@ -2,6 +2,7 @@
 import type { BuddyLocale } from '@/i18n/buddyI18n'
 import { Chat20Regular } from '@vicons/fluent'
 import { useBuddyI18n } from '@/i18n/buddyI18n'
+import WorkbenchMenu from '@/shared/ui/contributions/WorkbenchMenu.vue'
 import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
 
 const props = defineProps<{
@@ -26,6 +27,7 @@ const { t } = useBuddyI18n(() => props.language)
     </div>
 
     <div class="desktop-chat-workspace-header__actions">
+      <WorkbenchMenu target="task.actions" />
       <slot name="leadingActions" />
       <button
         v-if="canToggleCanvas"
diff --git a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskEditor.vue b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskEditor.vue
index c035bd68..8a037b91 100644
--- a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskEditor.vue
+++ b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskEditor.vue
@@ -17,7 +17,8 @@ import { desktopRouteLocations } from '@/shared/navigation/desktopRoutes'
 import { useDesktopUi } from '@/shared/ui/desktopUiContext'
 import DesktopIcon from '@/shared/ui/icon/DesktopIcon.vue'
 
-defineProps<{ readingPositions?: ChatReadingPositions }>()
+withDefaults(defineProps<{ readingPositions?: ChatReadingPositions, active?: boolean }>(), { active: true })
+const emit = defineEmits<{ ready: [] }>()
 const router = useRouter()
 const {
   resources: contextActions,
@@ -109,10 +110,12 @@ useProvideChatContent({
       </template>
     </DesktopChatWorkspaceHeader>
     <DesktopChatWorkspace
+      :active="active"
       :reading-positions="readingPositions"
       :view-mode="viewMode"
       :reveal-message-id="notificationTargetMessageId"
       :workspace="workspace"
+      @ready="emit('ready')"
       @show-canvas="viewMode = 'canvas'"
       @open-settings="router.push(desktopRouteLocations.settings($event))"
       @open-artifact="contextActions.openArtifact"
diff --git a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskIndexView.vue b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskIndexView.vue
index cae28cc8..7a9f7a94 100644
--- a/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskIndexView.vue
+++ b/apps/buddy/src/modules/tasks/widgets/workspace/DesktopTaskIndexView.vue
@@ -3,12 +3,12 @@ import type { TaskIndex } from '../../contracts'
 import { useDesktopUi } from '@/shared/ui/desktopUiContext'
 import DesktopTaskIndex from '../task-index/DesktopTaskIndex.vue'
 
-const props = defineProps<{ activeTaskId: string | null, index: TaskIndex }>()
+const props = defineProps<{ activeTaskId: string | null, pendingTaskIds?: readonly string[], index: TaskIndex }>()
 const emit = defineEmits<{ openTask: [id: string], newTask: [spaceId?: string | null] }>()
 const { language, appSidebarCollapsed } = useDesktopUi()
 const { pinnedItems, sidebar, spaces, tasks: items, ...actions } = props.index
 </script>
 
 <template>
-  <DesktopTaskIndex :active-conversation-id="activeTaskId" :marks="index.marks" :app-sidebar-collapsed="appSidebarCollapsed" :language="language" :pinned-items="pinnedItems" :sidebar="sidebar" :spaces="spaces" :select-space-directory="actions.selectSpaceDirectory" :tasks="items" :create-space="actions.createSpace" :update-space="actions.updateSpace" @delete-space="actions.deleteSpace" @delete-task="actions.deleteTask" @new-task="emit('newTask', $event)" @open-space-directory="actions.openSpaceDirectory" @open-task="emit('openTask', $event)" @rename-task="actions.renameTask" @update-pinned-items="actions.setPinnedItems" />
+  <DesktopTaskIndex :pending-conversation-ids="pendingTaskIds" :active-conversation-id="activeTaskId" :marks="index.marks" :app-sidebar-collapsed="appSidebarCollapsed" :language="language" :pinned-items="pinnedItems" :sidebar="sidebar" :spaces="spaces" :select-space-directory="actions.selectSpaceDirectory" :tasks="items" :create-space="actions.createSpace" :update-space="actions.updateSpace" @delete-space="actions.deleteSpace" @delete-task="actions.deleteTask" @new-task="emit('newTask', $event)" @open-space-directory="actions.openSpaceDirectory" @open-task="emit('openTask', $event)" @rename-task="actions.renameTask" @update-pinned-items="actions.setPinnedItems" />
 </template>
diff --git a/apps/buddy/src/modules/tasks/widgets/workspace/typing.ts b/apps/buddy/src/modules/tasks/widgets/workspace/typing.ts
index 3261afb4..d9f55af5 100644
--- a/apps/buddy/src/modules/tasks/widgets/workspace/typing.ts
+++ b/apps/buddy/src/modules/tasks/widgets/workspace/typing.ts
@@ -6,6 +6,7 @@ import type { BuddyLocale } from '@/i18n/buddyI18n'
 import type { DesktopSettingsCategory } from '@/shared/navigation/desktopRoutes'
 
 export interface ChatWorkspaceProps {
+  active?: boolean
   readingPositions?: ChatReadingPositions
   viewMode?: 'chat' | 'canvas'
   revealMessageId: string | null
@@ -13,6 +14,7 @@ export interface ChatWorkspaceProps {
 }
 
 export interface ChatWorkspaceEmits {
+  ready: []
   showCanvas: []
   openNodeArtifact: [artifact: LocalArtifact]
   openNodeChanges: [changes: LocalChangeSetSummary]
diff --git a/apps/buddy/src/platform/runtime/DesktopRuntimePane.vue b/apps/buddy/src/platform/runtime/DesktopRuntimePane.vue
index d3954932..03838259 100644
--- a/apps/buddy/src/platform/runtime/DesktopRuntimePane.vue
+++ b/apps/buddy/src/platform/runtime/DesktopRuntimePane.vue
@@ -9,7 +9,8 @@ const props = withDefaults(defineProps<{
   enabled?: boolean
   loading?: boolean
   language?: BuddyLocale
-}>(), { enabled: true, loading: false })
+  animate?: boolean
+}>(), { enabled: true, loading: false, animate: true })
 const runtime = inject(runtimeAvailabilityKey, null)
 const { t } = useBuddyI18n(() => props.language ?? runtime?.language.value ?? 'zh-CN')
 const pending = computed(() => props.loading || (props.enabled && runtime?.loading.value) || false)
@@ -18,6 +19,7 @@ const error = computed(() => props.enabled && runtime?.failed.value ? t('desktop
 
 <template>
   <DesktopPaneBoundary
+    :animate="animate"
     :loading="pending"
     :error="error"
     :label="t('desktop.loading.pane')"
diff --git a/apps/buddy/src/shared/ui/contributions/WorkbenchMenu.vue b/apps/buddy/src/shared/ui/contributions/WorkbenchMenu.vue
new file mode 100644
index 00000000..afae645c
--- /dev/null
+++ b/apps/buddy/src/shared/ui/contributions/WorkbenchMenu.vue
@@ -0,0 +1,11 @@
+<script setup lang="ts">
+import type { WorkbenchMenuProps } from './workbenchUiContext'
+import { useOptionalWorkbenchUi } from './workbenchUiContext'
+
+defineProps<WorkbenchMenuProps>()
+const host = useOptionalWorkbenchUi()
+</script>
+
+<template>
+  <component :is="host.menuRenderer" v-if="host" :target="target" :disabled="disabled" :values="values" :capture="capture" />
+</template>
diff --git a/apps/buddy/src/shared/ui/contributions/WorkbenchSlot.vue b/apps/buddy/src/shared/ui/contributions/WorkbenchSlot.vue
new file mode 100644
index 00000000..a7d9774b
--- /dev/null
+++ b/apps/buddy/src/shared/ui/contributions/WorkbenchSlot.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { WorkbenchSlot } from '@buddy-shared/workbench/workbenchUi'
+import { useOptionalWorkbenchUi } from './workbenchUiContext'
+
+defineProps<{ target: WorkbenchSlot }>()
+defineSlots<{ default: () => unknown }>()
+const host = useOptionalWorkbenchUi()
+</script>
+
+<template>
+  <component :is="host.slotRenderer" v-if="host" :target="target">
+    <slot />
+  </component>
+  <slot v-else />
+</template>
diff --git a/apps/buddy/src/shared/ui/contributions/WorkbenchUiScope.vue b/apps/buddy/src/shared/ui/contributions/WorkbenchUiScope.vue
new file mode 100644
index 00000000..a2cc9ea7
--- /dev/null
+++ b/apps/buddy/src/shared/ui/contributions/WorkbenchUiScope.vue
@@ -0,0 +1,10 @@
+<script setup lang="ts">
+import { useProvideWorkbenchUiScope } from './workbenchUiContext'
+
+const props = defineProps<{ instanceId?: string }>()
+useProvideWorkbenchUiScope({ instanceId: () => props.instanceId })
+</script>
+
+<template>
+  <slot />
+</template>
diff --git a/apps/buddy/src/shared/ui/contributions/workbenchCommands.ts b/apps/buddy/src/shared/ui/contributions/workbenchCommands.ts
new file mode 100644
index 00000000..396603a2
--- /dev/null
+++ b/apps/buddy/src/shared/ui/contributions/workbenchCommands.ts
@@ -0,0 +1,11 @@
+import type { WorkbenchSlashCommand } from '@buddy-shared/workbench/workbenchCommand'
+import type { JsonValue } from '@buddy-shared/workbench/workbenchState'
+import type { Ref } from 'vue'
+import { createInjectionState } from '@vueuse/core'
+
+export interface WorkbenchCommandPort {
+  entries: Readonly<Ref<readonly WorkbenchSlashCommand[]>>
+  reportFailure: () => void
+  execute: (id: string, argumentsText: string, instanceId?: string) => Promise<JsonValue>
+}
+export const [useProvideWorkbenchCommands, useWorkbenchCommands] = createInjectionState((commands: WorkbenchCommandPort) => commands)
diff --git a/apps/buddy/src/shared/ui/contributions/workbenchUiContext.ts b/apps/buddy/src/shared/ui/contributions/workbenchUiContext.ts
index 2b760270..85ad11eb 100644
--- a/apps/buddy/src/shared/ui/contributions/workbenchUiContext.ts
+++ b/apps/buddy/src/shared/ui/contributions/workbenchUiContext.ts
@@ -1,4 +1,7 @@
-import type { ComposerActivity, WorkbenchAnchor, WorkbenchControl } from '@buddy-shared/workbench/workbenchUi'
+import type { SpaceFileTarget } from '@buddy-shared/spaces/spaceFileApi'
+import type { WorkbenchContextValues } from '@buddy-shared/workbench/workbenchContext'
+import type { JsonValue } from '@buddy-shared/workbench/workbenchState'
+import type { ComposerActivity, WorkbenchAnchor, WorkbenchControl, WorkbenchMenu } from '@buddy-shared/workbench/workbenchUi'
 import type { Component } from 'vue'
 import { createInjectionState } from '@vueuse/core'
 import { watch } from 'vue'
@@ -23,10 +26,26 @@ export interface WorkbenchControlProps {
 }
 export interface WorkbenchUiHost {
   anchors: WorkbenchAnchors
+  panes?: { register: (id: string | null, element: HTMLElement) => () => void }
   controlRenderer: Component
+  slotRenderer: Component
+  menuRenderer: Component
+}
+export interface WorkbenchMenuSelection {
+  content?: string
+  resource?: SpaceFileTarget
+  apply?: (result: JsonValue) => void
+}
+export interface WorkbenchMenuProps {
+  target: WorkbenchMenu
+  disabled?: boolean
+  values?: WorkbenchContextValues
+  capture?: () => WorkbenchMenuSelection
 }
 const [useProvideWorkbenchUi, useOptionalWorkbenchUi] = createInjectionState((host: WorkbenchUiHost) => host)
 export { useOptionalWorkbenchUi, useProvideWorkbenchUi }
+const [useProvideWorkbenchUiScope, useWorkbenchUiScope] = createInjectionState((scope: { instanceId: () => string | undefined }) => scope)
+export { useProvideWorkbenchUiScope, useWorkbenchUiScope }
 
 export function useWorkbenchAnchor(kind: WorkbenchAnchor, element: () => HTMLElement | null, caret?: () => DOMRect | null): void {
   const host = useOptionalWorkbenchUi()
diff --git a/apps/buddy/src/shared/ui/loading/DesktopPaneBoundary.vue b/apps/buddy/src/shared/ui/loading/DesktopPaneBoundary.vue
index ed4619c9..aa71e975 100644
--- a/apps/buddy/src/shared/ui/loading/DesktopPaneBoundary.vue
+++ b/apps/buddy/src/shared/ui/loading/DesktopPaneBoundary.vue
@@ -1,22 +1,23 @@
 <script setup lang="ts">
 import { NButton } from 'naive-ui'
 
-defineProps<{
+withDefaults(defineProps<{
+  animate?: boolean
   loading: boolean
   error?: string | null
   label: string
   retryLabel: string
-}>()
+}>(), { animate: true })
 const emit = defineEmits<{ retry: [] }>()
 defineSlots<{ default: () => unknown }>()
 </script>
 
 <template>
-  <div class="desktop-pane-boundary" :aria-busy="loading">
+  <div class="desktop-pane-boundary" :class="{ 'is-animated': animate }" :aria-busy="loading">
     <div class="desktop-pane-boundary__content" :class="{ 'is-covered': loading || error }" :inert="loading || !!error" :aria-hidden="loading || !!error">
       <slot />
     </div>
-    <Transition name="pane-reveal">
+    <Transition name="pane-reveal" :css="animate">
       <div v-if="loading || error" class="desktop-pane-boundary__cover" :role="error ? 'alert' : 'status'">
         <div class="desktop-pane-boundary__status">
           <span v-if="!error" class="desktop-pane-boundary__spinner" aria-hidden="true" />
@@ -41,7 +42,7 @@ defineSlots<{ default: () => unknown }>()
   flex-direction: column;
 }
 .desktop-pane-boundary { position: relative; isolation: isolate; }
-.desktop-pane-boundary__content { transition: opacity 160ms ease; }
+.is-animated > .desktop-pane-boundary__content { transition: opacity 160ms ease; }
 .desktop-pane-boundary__content.is-covered { opacity: 0; pointer-events: none; }
 .desktop-pane-boundary__cover {
   position: absolute;
@@ -76,6 +77,6 @@ defineSlots<{ default: () => unknown }>()
 @keyframes pane-spin { to { transform: rotate(360deg); } }
 @media (prefers-reduced-motion: reduce) {
   .desktop-pane-boundary__spinner { animation: none; }
-  .desktop-pane-boundary__content, .pane-reveal-enter-active, .pane-reveal-leave-active { transition: none; }
+  .is-animated > .desktop-pane-boundary__content, .pane-reveal-enter-active, .pane-reveal-leave-active { transition: none; }
 }
 </style>
diff --git a/apps/buddy/src/shared/ui/surfaces/surfaceLayout.ts b/apps/buddy/src/shared/ui/surfaces/surfaceLayout.ts
index 2a6186bc..8572cee9 100644
--- a/apps/buddy/src/shared/ui/surfaces/surfaceLayout.ts
+++ b/apps/buddy/src/shared/ui/surfaces/surfaceLayout.ts
@@ -2,6 +2,7 @@ export interface SurfaceLayoutOptions {
   anchor: HTMLElement | null
   visible: boolean
   interactive: boolean
+  childrenOnly?: boolean
   layer: 'content' | 'decoration'
   onLayout?: (geometry: { visible: boolean, width: number, height: number }) => void
 }
diff --git a/apps/buddy/src/workbench/browser/WorkbenchHost.vue b/apps/buddy/src/workbench/browser/WorkbenchHost.vue
index 26642f9d..3b5048c1 100644
--- a/apps/buddy/src/workbench/browser/WorkbenchHost.vue
+++ b/apps/buddy/src/workbench/browser/WorkbenchHost.vue
@@ -5,20 +5,24 @@ import type { DropPosition, ResourceRef, WorkbenchView } from '../common/workben
 import type { WorkbenchController } from '../services/WorkbenchController'
 import type { WorkingCopyService } from '../services/WorkingCopyService'
 import { formatKeybinding, matchesKeybinding } from '@buddy-shared/shortcuts/keybinding'
+import { workbenchMountKey } from '@buddy-shared/workbench/workbenchUi'
 import { PointerActivationConstraints } from '@dnd-kit/dom'
 import { DragDropProvider, DragOverlay, KeyboardSensor, PointerSensor } from '@dnd-kit/vue'
 import { NInput, NModal } from 'naive-ui'
 import { computed, onMounted, onScopeDispose, provide, shallowRef, triggerRef } from 'vue'
+import { useOptionalWorkbenchUi } from '@/shared/ui/contributions/workbenchUiContext'
 import { workbenchLabels } from '../common/workbenchLabels'
 import WorkbenchMountPortals from './mounts/WorkbenchMountPortals.vue'
 import { useWorkbenchResize } from './useWorkbenchResize'
 import { workbenchKey } from './workbenchContext'
 import { createWorkbenchDragPlugins } from './workbenchDragPlugins'
+import WorkbenchInteractionControls from './WorkbenchInteractionControls.vue'
 import WorkbenchViewPortals from './WorkbenchViewPortals.vue'
 
 const props = defineProps<{ controller: WorkbenchController, copies: WorkingCopyService, language: string, backupError: boolean, active: boolean, keybindings: Readonly<Record<string, readonly string[]>>, platform: string }>()
 const emit = defineEmits<{ retryBackup: [], dropResource: [resource: ResourceRef, paneId: string, position: DropPosition] }>()
 defineSlots<{ default: () => unknown, view: (props: { view: WorkbenchView, visible: boolean }) => unknown }>()
+const ui = useOptionalWorkbenchUi()
 const plugins = createWorkbenchDragPlugins()
 const sensors = [PointerSensor.configure({ activationConstraints: () => [new PointerActivationConstraints.Distance({ value: 6 })] }), KeyboardSensor]
 const resize = useWorkbenchResize(props.controller)
@@ -29,13 +33,16 @@ const palette = shallowRef(false)
 const query = shallowRef('')
 const commandFailed = shallowRef(false)
 const dragging = shallowRef(false)
-const mountPoints = shallowRef(new Map<WorkbenchMountTarget, HTMLElement>())
-function registerMountPoint(target: WorkbenchMountTarget, element: HTMLElement): () => void {
-  mountPoints.value = new Map(mountPoints.value).set(target, element)
+const mountPoints = shallowRef(new Map<string, HTMLElement>())
+function registerMountPoint(target: WorkbenchMountTarget, element: HTMLElement, instanceId?: string): () => void {
+  const unregisterPane = target === 'workbench' || (target === 'workbench.pane' && instanceId) ? ui?.panes?.register(target === 'workbench' ? null : instanceId!, element) : undefined
+  const key = workbenchMountKey(target, instanceId)
+  mountPoints.value = new Map(mountPoints.value).set(key, element)
   return () => {
-    if (mountPoints.value.get(target) === element) {
+    unregisterPane?.()
+    if (mountPoints.value.get(key) === element) {
       const next = new Map(mountPoints.value)
-      next.delete(target)
+      next.delete(key)
       mountPoints.value = next
     }
   }
@@ -57,7 +64,6 @@ function refresh() {
   revision.value++
 }
 onScopeDispose(props.controller.subscribe(refresh))
-onScopeDispose(props.controller.registry.subscribe(refresh))
 onScopeDispose(props.copies.subscribe(refresh))
 const commands = computed(() => {
   void revision.value
@@ -99,7 +105,16 @@ onScopeDispose(props.controller.registry.register('lexora.commandPalette', (scop
     query.value = ''
   } })
 }))
+const interactions = computed(() => {
+  void revision.value
+  return [...props.controller.interactions.entries.values()]
+})
 function keyboard(event: KeyboardEvent) {
+  if (event.key === 'Escape' && !event.defaultPrevented && !event.isComposing && interactions.value.length) {
+    event.preventDefault()
+    props.controller.interactions.end(interactions.value.at(-1)!.id)
+    return
+  }
   if (event.isComposing || event.defaultPrevented || event.repeat)
     return
   if ((event.target as Element | null)?.closest('[role="dialog"], .n-modal'))
@@ -140,6 +155,7 @@ provide(workbenchKey, { resize, controller: props.controller, copies: props.copi
       </div>
       <slot />
       <div v-if="resize.active.value.length" class="workbench__resize-shield" />
+      <WorkbenchInteractionControls :entries="interactions" :language="language" @end="controller.interactions.end($event)" />
       <WorkbenchMountPortals />
       <WorkbenchViewPortals>
         <template #default="{ view, visible }">
diff --git a/apps/buddy/src/workbench/browser/WorkbenchInteractionControls.vue b/apps/buddy/src/workbench/browser/WorkbenchInteractionControls.vue
new file mode 100644
index 00000000..6a16eee1
--- /dev/null
+++ b/apps/buddy/src/workbench/browser/WorkbenchInteractionControls.vue
@@ -0,0 +1,23 @@
+<script setup lang="ts">
+import type { WorkbenchInteraction } from '@buddy-shared/workbench/workbenchInteraction'
+
+defineProps<{ entries: readonly WorkbenchInteraction[], language: string }>()
+const emit = defineEmits<{ end: [id: string] }>()
+</script>
+
+<template>
+  <Teleport to="body">
+    <div v-if="entries.length" class="workbench-interactions" data-testid="workbench-interactions">
+      <button v-for="entry in entries" :key="entry.id" type="button" @click="emit('end', entry.id)">
+        <span>{{ language === 'zh-CN' ? '结束' : 'End' }} {{ entry.title }}</span><kbd>Esc</kbd>
+      </button>
+    </div>
+  </Teleport>
+</template>
+
+<style scoped>
+.workbench-interactions { position: fixed; top: 48px; right: 16px; z-index: 2147483647; display: flex; flex-wrap: wrap; gap: 8px; max-width: calc(100vw - 32px); }
+.workbench-interactions button { display: flex; gap: 12px; align-items: center; border: 1px solid var(--buddy-border-subtle); border-radius: 6px; padding: 8px 12px; background: var(--buddy-surface-raised); color: var(--buddy-text-primary); font: inherit; cursor: pointer; }
+.workbench-interactions button:focus-visible { outline: 2px solid var(--buddy-accent-solid); }
+.workbench-interactions kbd { font-size: 11px; color: var(--buddy-text-secondary); }
+</style>
diff --git a/apps/buddy/src/workbench/browser/WorkbenchNavigationStatus.vue b/apps/buddy/src/workbench/browser/WorkbenchNavigationStatus.vue
new file mode 100644
index 00000000..fdfee300
--- /dev/null
+++ b/apps/buddy/src/workbench/browser/WorkbenchNavigationStatus.vue
@@ -0,0 +1,33 @@
+<script setup lang="ts">
+import type { PendingWorkbenchView } from '../services/WorkbenchNavigation'
+import { onScopeDispose, shallowRef } from 'vue'
+import { useWorkbench } from './workbenchContext'
+
+const props = defineProps<{ entry: PendingWorkbenchView }>()
+const { controller, labels } = useWorkbench()
+const delayed = shallowRef(false)
+const timer = setTimeout(() => delayed.value = true, 200)
+onScopeDispose(() => clearTimeout(timer))
+function retry() {
+  void controller.open(props.entry.view.resource, props.entry.view.title, { ...props.entry.options, signal: undefined })
+}
+</script>
+
+<template>
+  <div v-if="entry.status === 'failed' || delayed" class="workbench-navigation-status" :role="entry.status === 'failed' ? 'alert' : 'status'">
+    <span class="workbench-navigation-status__title">{{ entry.view.title }}</span>
+    <span>{{ entry.status === 'failed' ? labels.failed : labels.loading }}</span>
+    <button v-if="entry.status === 'failed'" type="button" @click="retry">
+      {{ labels.retry }}
+    </button>
+    <button type="button" @click="controller.navigation.cancel(entry.paneId)">
+      {{ labels.cancel }}
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.workbench-navigation-status { position: absolute; z-index: 4; top: 3rem; right: 12px; display: flex; align-items: center; gap: 8px; max-width: calc(100% - 24px); padding: 8px 12px; border: 1px solid var(--buddy-border-subtle); border-radius: 6px; background: var(--buddy-surface-base); color: var(--buddy-text-secondary); font-size: 12px; }
+.workbench-navigation-status__title { overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
+.workbench-navigation-status button { flex-shrink: 0; border: 0; padding: 0; background: transparent; color: var(--buddy-accent-solid); cursor: pointer; }
+</style>
diff --git a/apps/buddy/src/workbench/browser/WorkbenchPane.vue b/apps/buddy/src/workbench/browser/WorkbenchPane.vue
index fd71e88e..518f3c48 100644
--- a/apps/buddy/src/workbench/browser/WorkbenchPane.vue
+++ b/apps/buddy/src/workbench/browser/WorkbenchPane.vue
@@ -2,13 +2,24 @@
 import type { WorkbenchPane } from '../common/workbench'
 import { useDragDropMonitor, useDroppable } from '@dnd-kit/vue'
 import { computed, useTemplateRef } from 'vue'
-import { useWorkbenchAnchor } from '@/shared/ui/contributions/workbenchUiContext'
+import WorkbenchSlot from '@/shared/ui/contributions/WorkbenchSlot.vue'
+import { useProvideWorkbenchUiScope, useWorkbenchAnchor } from '@/shared/ui/contributions/workbenchUiContext'
+import { panes } from '../common/workbench'
 import { resolveWorkbenchDrop } from '../common/workbenchDrop'
+import WorkbenchMountPoint from './mounts/WorkbenchMountPoint.vue'
 import { useWorkbench } from './workbenchContext'
+import WorkbenchNavigationStatus from './WorkbenchNavigationStatus.vue'
 import WorkbenchSurface from './WorkbenchSurface.vue'
 
 const props = defineProps<{ pane: WorkbenchPane }>()
-const { controller, layout, labels, dropPosition } = useWorkbench()
+useProvideWorkbenchUiScope({ instanceId: () => props.pane.id })
+const { controller, layout, revision, labels, dropPosition } = useWorkbench()
+const pending = computed(() => {
+  void revision.value
+  return controller.navigation.entries.get(props.pane.id)
+})
+const viewIds = computed(() => [props.pane.view, pending.value?.status === 'loading' ? pending.value.view.id : null].filter((id): id is string => !!id))
+const focused = computed(() => layout.value.activePane === props.pane.id && panes(layout.value.root).length > 1)
 const element = useTemplateRef<HTMLElement>('element')
 useWorkbenchAnchor('workbench.pane', () => element.value)
 useDroppable({ id: () => `pane:${props.pane.id}`, accept: 'workbench-task', element, data: () => ({ paneId: props.pane.id }) })
@@ -27,14 +38,19 @@ const drop = computed(() => dropPosition.value?.paneId === props.pane.id ? dropP
 </script>
 
 <template>
-  <section ref="element" class="workbench-pane" :class="{ 'is-focused': layout.activePane === pane.id }" :data-pane-id="pane.id" tabindex="-1" @focusin="controller.activate(pane.id)" @pointerdown="controller.activate(pane.id)">
-    <WorkbenchSurface v-if="pane.view" :view-id="pane.view" />
-    <div v-else class="workbench-pane__empty">
-      <p>{{ labels.empty }}</p>
-      <button type="button" @click="controller.registry.execute('task.new', controller.context)">
-        {{ labels.newTask }}
-      </button>
-    </div>
+  <section ref="element" class="workbench-pane" :class="{ 'is-focused': focused }" :data-pane-id="pane.id" tabindex="-1" @focusin="controller.activate(pane.id)" @pointerdown="controller.activate(pane.id)">
+    <WorkbenchMountPoint target="workbench.pane" :instance-id="pane.id">
+      <WorkbenchSurface v-for="id in viewIds" :key="id" :view-id="id" :preparing="id !== pane.view" />
+      <WorkbenchSlot v-if="!pane.view" target="workbench.pane.empty" class="workbench-pane__empty-slot">
+        <div class="workbench-pane__empty">
+          <p>{{ labels.empty }}</p>
+          <button type="button" @click="controller.registry.execute('task.new', controller.context)">
+            {{ labels.newTask }}
+          </button>
+        </div>
+      </WorkbenchSlot>
+    </WorkbenchMountPoint>
+    <WorkbenchNavigationStatus v-if="pending" :key="pending.view.id" :entry="pending" />
     <div v-if="drop" class="workbench-pane__drop" :class="drop" :data-drop-position="drop" />
   </section>
 </template>
@@ -43,6 +59,7 @@ const drop = computed(() => dropPosition.value?.paneId === props.pane.id ? dropP
 .workbench-pane { position: relative; display: flex; flex-direction: column; min-width: 0; min-height: 0; height: 100%; overflow: hidden; background: var(--buddy-surface-canvas); }
 .workbench-pane.is-focused { box-shadow: inset 0 2px var(--buddy-accent-solid); }
 .workbench-pane__empty { margin: auto; padding: 24px; text-align: center; font-size: 12px; color: var(--buddy-text-secondary); }
+.workbench-pane__empty-slot { width: 100%; margin: auto; }
 .workbench-pane__empty button { background: var(--buddy-state-hover); color: var(--buddy-text-primary); border: 1px solid var(--buddy-border-subtle); border-radius: 6px; padding: 8px 14px; cursor: pointer; }
 .workbench-pane__drop { position: absolute; inset: 0; z-index: 10; background: color-mix(in srgb, var(--buddy-accent-solid) 16%, transparent); border: 2px solid var(--buddy-accent-solid); pointer-events: none; }
 .workbench-pane__drop.left { right: 50%; }
diff --git a/apps/buddy/src/workbench/browser/WorkbenchSurface.vue b/apps/buddy/src/workbench/browser/WorkbenchSurface.vue
index 74806fd1..bf873916 100644
--- a/apps/buddy/src/workbench/browser/WorkbenchSurface.vue
+++ b/apps/buddy/src/workbench/browser/WorkbenchSurface.vue
@@ -2,7 +2,7 @@
 import { useTemplateRef, watch } from 'vue'
 import { useWorkbench } from './workbenchContext'
 
-const props = withDefaults(defineProps<{ viewId: string, visible?: boolean }>(), { visible: true })
+const props = withDefaults(defineProps<{ viewId: string, visible?: boolean, preparing?: boolean }>(), { visible: true, preparing: false })
 const { mountView, controller } = useWorkbench()
 const element = useTemplateRef<HTMLElement>('element')
 watch([element, () => props.viewId, () => props.visible], ([element, id, visible], _, cleanup) => {
@@ -12,9 +12,10 @@ watch([element, () => props.viewId, () => props.visible], ([element, id, visible
 </script>
 
 <template>
-  <div ref="element" class="workbench-surface" @focusin="controller.focus(viewId)" @pointerdown="controller.focus(viewId)" />
+  <div ref="element" class="workbench-surface" :class="{ 'is-preparing': preparing }" :inert="preparing || undefined" :aria-hidden="preparing || undefined" @focusin="controller.focus(viewId)" @pointerdown="controller.focus(viewId)" />
 </template>
 
 <style scoped>
 .workbench-surface { display: flex; flex: 1; flex-direction: column; min-width: 0; min-height: 0; overflow: hidden; }
+.workbench-surface.is-preparing { position: absolute; inset: 0; visibility: hidden; pointer-events: none; }
 </style>
diff --git a/apps/buddy/src/workbench/browser/WorkbenchViewBoundary.vue b/apps/buddy/src/workbench/browser/WorkbenchViewBoundary.vue
index c4573415..13e2df98 100644
--- a/apps/buddy/src/workbench/browser/WorkbenchViewBoundary.vue
+++ b/apps/buddy/src/workbench/browser/WorkbenchViewBoundary.vue
@@ -2,11 +2,13 @@
 import { onErrorCaptured, shallowRef } from 'vue'
 import { useWorkbench } from './workbenchContext'
 
+const emit = defineEmits<{ error: [] }>()
 const { labels } = useWorkbench()
 const failed = shallowRef(false)
 const attempt = shallowRef(0)
 onErrorCaptured(() => {
   failed.value = true
+  emit('error')
   return false
 })
 </script>
diff --git a/apps/buddy/src/workbench/browser/WorkbenchViewPortals.vue b/apps/buddy/src/workbench/browser/WorkbenchViewPortals.vue
index 17bb7263..6a55029e 100644
--- a/apps/buddy/src/workbench/browser/WorkbenchViewPortals.vue
+++ b/apps/buddy/src/workbench/browser/WorkbenchViewPortals.vue
@@ -1,13 +1,18 @@
 <script setup lang="ts">
 import type { WorkbenchView } from '../common/workbench'
 import { computed, useTemplateRef } from 'vue'
+import WorkbenchUiScope from '@/shared/ui/contributions/WorkbenchUiScope.vue'
+import { panes } from '../common/workbench'
 import { useWorkbench } from './workbenchContext'
 import WorkbenchViewBoundary from './WorkbenchViewBoundary.vue'
 
 defineSlots<{ default: (props: { view: WorkbenchView, visible: boolean }) => unknown }>()
-const { controller, layout, labels, viewTarget, viewVisible } = useWorkbench()
+const { controller, layout, revision, labels, viewTarget, viewVisible } = useWorkbench()
 const parking = useTemplateRef<HTMLElement>('parking')
-const views = computed(() => Object.values(layout.value.views))
+const views = computed(() => {
+  void revision.value
+  return controller.renderedViews
+})
 </script>
 
 <template>
@@ -15,12 +20,14 @@ const views = computed(() => Object.values(layout.value.views))
   <template v-if="parking">
     <Teleport v-for="view in views" :key="view.id" defer :to="viewTarget(view.id) ?? parking">
       <section :id="`workbench-view-${view.id}`" class="workbench__view" role="region" :aria-label="view.title" :data-view-id="view.id" :data-resource-id="view.resource.id">
-        <WorkbenchViewBoundary>
-          <slot v-if="controller.registry.views.has(view.type)" :view="view" :visible="viewVisible(view.id)" />
-          <div v-else class="workbench__missing">
-            <p>{{ labels.missing }}</p><code>{{ view.type }}</code>
-          </div>
-        </WorkbenchViewBoundary>
+        <WorkbenchUiScope :instance-id="view.mountInstanceId ?? controller.navigation.find(view.id)?.paneId ?? panes(layout.root).find(pane => pane.view === view.id)?.id">
+          <WorkbenchViewBoundary @error="controller.navigation.fail(view.id)">
+            <slot v-if="controller.registry.views.has(view.type)" :view="view" :visible="viewVisible(view.id)" />
+            <div v-else class="workbench__missing">
+              <p>{{ labels.missing }}</p><code>{{ view.type }}</code>
+            </div>
+          </WorkbenchViewBoundary>
+        </WorkbenchUiScope>
       </section>
     </Teleport>
   </template>
diff --git a/apps/buddy/src/workbench/browser/__tests__/WorkbenchHost.spec.ts b/apps/buddy/src/workbench/browser/__tests__/WorkbenchHost.spec.ts
index 90c45f2d..f72f9133 100644
--- a/apps/buddy/src/workbench/browser/__tests__/WorkbenchHost.spec.ts
+++ b/apps/buddy/src/workbench/browser/__tests__/WorkbenchHost.spec.ts
@@ -71,11 +71,20 @@ it('keeps a contributed view instance alive across splits, moves and missing con
     await nextTick()
     expect(created).toBe(2)
     expect(element.querySelector('[data-instance="1"]')).toBe(original)
+    const previousPane = controller.pane(secondPane)!
+    const replacement = await controller.open({ scheme: 'sample', id: 'three', data: {} }, 'Replacement', { paneId: secondPane })
+    await nextTick()
+    expect(created).toBe(3)
+    expect(disposed).toBe(1)
+    expect(controller.pane(secondPane)).not.toBe(previousPane)
+    expect(previousPane.view).not.toBe(replacement)
+    expect(element.querySelector('[data-instance="3"]')?.closest('[data-pane-id]')?.getAttribute('data-pane-id')).toBe(secondPane)
+    expect(element.querySelector('[data-instance="1"]')).toBe(original)
     await controller.move(first, secondPane)
     await nextTick()
     expect(element.querySelector('[data-instance="1"]')).toBe(original)
     expect(original.closest('[data-pane-id]')?.getAttribute('data-pane-id')).toBe(secondPane)
-    expect(disposed).toBe(1)
+    expect(disposed).toBe(2)
     controller.updateView(first, { state: { message: 'Updated view state' } })
     await nextTick()
     expect(element.querySelector('[data-instance="1"]')).toBe(original)
@@ -83,13 +92,13 @@ it('keeps a contributed view instance alive across splits, moves and missing con
     const saved = JSON.stringify(controller.layout)
     unregister()
     await nextTick()
-    expect(disposed).toBe(2)
+    expect(disposed).toBe(3)
     expect(element.textContent).toContain('This view is unavailable')
     expect(JSON.stringify(controller.layout)).toBe(saved)
     register()
     await nextTick()
     expect(element.textContent).toContain('Updated view state')
-    expect(created).toBe(3)
+    expect(created).toBe(4)
   }
   finally {
     app.unmount()
@@ -226,3 +235,54 @@ it('preserves independent plugin content when changing mounts or removing the ta
     element.remove()
   }
 })
+
+it('prepares a view inside its destination pane and reveals the same DOM without an empty intermediate layout', async () => {
+  const registry = new ContributionRegistry()
+  registry.register('sample', scope => scope.view({ id: 'sample', renderer: 'sample', locations: ['main'], label: 'Sample', supports: () => true, multiple: false, prepareBeforeOpen: true }))
+  const controller = new WorkbenchController(registry)
+  const original = (await controller.open({ scheme: 'sample', id: 'original', data: {} }, 'Original'))!
+  const copies = new WorkingCopyService({ read: async () => ({ text: '', etag: '' }), save: async () => {
+    throw new Error('unused')
+  } })
+  const element = document.createElement('div')
+  document.body.append(element)
+  const Layout = defineComponent({ setup() {
+    const { layout } = useWorkbench()
+    return () => h(WorkbenchLayoutNode, { node: layout.value.root })
+  } })
+  const app = createApp({
+    render: () => h(WorkbenchHost, { controller, copies, language: 'en-US', backupError: false, active: true, keybindings: {}, platform: 'linux' }, {
+      default: () => h(Layout),
+      view: ({ view, visible }: { view: WorkbenchView, visible: boolean }) => h('input', { 'data-ready-view': view.id, 'data-visible': visible, 'value': view.title }),
+    }),
+  })
+  app.mount(element)
+  try {
+    await nextTick()
+    const originalNode = element.querySelector(`[data-ready-view="${original}"]`)!
+    const opening = controller.open({ scheme: 'sample', id: 'next', data: {} }, 'Next')
+    const candidate = controller.navigation.entries.get(controller.layout.activePane)!.view.id
+    await nextTick()
+    const preparedNode = element.querySelector(`[data-ready-view="${candidate}"]`)!
+    const preparedSurface = preparedNode.closest('.workbench-surface')!
+    expect(preparedSurface.classList.contains('is-preparing')).toBe(true)
+    expect(preparedSurface.hasAttribute('inert')).toBe(true)
+    expect(preparedNode.getAttribute('data-visible')).toBe('false')
+    expect(preparedNode.closest('[data-pane-id]')).toBe(originalNode.closest('[data-pane-id]'))
+    expect(originalNode.closest('.is-preparing')).toBeNull()
+    controller.navigation.ready(candidate)
+    await opening
+    await nextTick()
+    expect(element.querySelector(`[data-ready-view="${candidate}"]`)).toBe(preparedNode)
+    expect(preparedNode.closest('.workbench-surface')).toBe(preparedSurface)
+    expect(preparedSurface.classList.contains('is-preparing')).toBe(false)
+    expect(preparedSurface.hasAttribute('inert')).toBe(false)
+    expect(preparedNode.getAttribute('data-visible')).toBe('true')
+    expect(element.contains(originalNode)).toBe(false)
+  }
+  finally {
+    app.unmount()
+    registry.dispose()
+    element.remove()
+  }
+})
diff --git a/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPoint.vue b/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPoint.vue
index d9fb97bf..a1e493de 100644
--- a/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPoint.vue
+++ b/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPoint.vue
@@ -3,17 +3,17 @@ import type { WorkbenchMountTarget } from '@buddy-shared/workbench/workbenchUi'
 import { useTemplateRef, watch } from 'vue'
 import { useWorkbench } from '../workbenchContext'
 
-const props = defineProps<{ target: WorkbenchMountTarget }>()
+const props = defineProps<{ target: WorkbenchMountTarget, instanceId?: string }>()
 const { registerMountPoint } = useWorkbench()
 const element = useTemplateRef<HTMLElement>('element')
-watch([element, () => props.target], ([element, target], _, cleanup) => {
+watch([element, () => props.target, () => props.instanceId], ([element, target, instanceId], _, cleanup) => {
   if (element)
-    cleanup(registerMountPoint(target, element))
+    cleanup(registerMountPoint(target, element, instanceId))
 })
 </script>
 
 <template>
-  <div ref="element" class="workbench-mount-point" :data-mount-point="target">
+  <div ref="element" class="workbench-mount-point" :data-mount-point="target" :data-mount-instance="instanceId">
     <div class="workbench-mount-point__content">
       <slot />
     </div>
@@ -22,5 +22,5 @@ watch([element, () => props.target], ([element, target], _, cleanup) => {
 
 <style scoped>
 .workbench-mount-point { position: relative; display: flex; flex: 1; flex-direction: column; min-width: 0; min-height: 0; overflow: hidden; }
-.workbench-mount-point__content { display: flex; flex: 1; flex-direction: column; min-width: 0; min-height: 0; }
+.workbench-mount-point__content { position: relative; display: flex; flex: 1; flex-direction: column; min-width: 0; min-height: 0; }
 </style>
diff --git a/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPortals.vue b/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPortals.vue
index 45d35e35..86e695c1 100644
--- a/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPortals.vue
+++ b/apps/buddy/src/workbench/browser/mounts/WorkbenchMountPortals.vue
@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import { workbenchMountKey } from '@buddy-shared/workbench/workbenchUi'
 import { computed, useTemplateRef } from 'vue'
 import { useWorkbench } from '../workbenchContext'
 import WorkbenchSurface from '../WorkbenchSurface.vue'
@@ -13,7 +14,7 @@ const mounts = computed(() => {
     if (view.location !== 'mount' || !placement || placement.viewType !== view.type)
       return []
     const presentation = { target: placement.target, ...placement.presentation, ...view.presentation }
-    return [{ view, target: controller.matchesViewContext(view) ? mountPoints.value.get(presentation.target) : null, style: workbenchMountStyle(presentation) }]
+    return [{ view, target: controller.matchesViewContext(view) ? mountPoints.value.get(workbenchMountKey(presentation.target, view.mountInstanceId)) : null, style: { ...workbenchMountStyle(presentation), ...(placement.interaction === 'regions' ? { pointerEvents: 'none' as const } : {}) } }]
   })
 })
 </script>
diff --git a/apps/buddy/src/workbench/browser/surfaces/SurfaceHitRegions.ts b/apps/buddy/src/workbench/browser/surfaces/SurfaceHitRegions.ts
new file mode 100644
index 00000000..444fa3b0
--- /dev/null
+++ b/apps/buddy/src/workbench/browser/surfaces/SurfaceHitRegions.ts
@@ -0,0 +1,49 @@
+import type { WorkbenchHitRegion, WorkbenchRegionActivation } from '@buddy-shared/workbench/workbenchInteraction'
+import type { SurfaceLayout, SurfaceLayoutLease, SurfaceLayoutOptions } from '@/shared/ui/surfaces/surfaceLayout'
+
+export class SurfaceHitRegions {
+  readonly element = document.createElement('div')
+  readonly #lease: SurfaceLayoutLease
+  #regions: readonly WorkbenchHitRegion[] = []
+  #visible = false
+  constructor(layout: SurfaceLayout, options: SurfaceLayoutOptions, readonly activate: (event: WorkbenchRegionActivation) => void) {
+    this.element.dataset.workbenchHitRegions = ''
+    this.#lease = layout.attach(this.element, this.#options(options))
+  }
+
+  update(options: SurfaceLayoutOptions, regions: readonly WorkbenchHitRegion[]): void {
+    this.#lease.update(this.#options(options))
+    if (regions === this.#regions)
+      return
+    this.#regions = regions
+    const buttons = regions.map((region) => {
+      const button = document.createElement('button')
+      button.type = 'button'
+      button.dataset.hitRegion = region.id
+      button.setAttribute('aria-label', region.label)
+      Object.assign(button.style, { position: 'absolute', left: `${region.rect.x}px`, top: `${region.rect.y}px`, width: `${region.rect.width}px`, height: `${region.rect.height}px`, padding: '0', border: '0', background: 'transparent', pointerEvents: 'auto', cursor: 'pointer' })
+      button.addEventListener('click', (event) => {
+        if (!event.isTrusted || !this.#visible || !this.#regions.includes(region))
+          return
+        const bounds = this.element.getBoundingClientRect()
+        this.activate({ id: region.id, x: event.detail ? event.clientX - bounds.left : region.rect.x + region.rect.width / 2, y: event.detail ? event.clientY - bounds.top : region.rect.y + region.rect.height / 2 })
+      })
+      return button
+    })
+    this.element.replaceChildren(...buttons)
+  }
+
+  #options(options: SurfaceLayoutOptions): SurfaceLayoutOptions {
+    this.#visible = options.visible
+    return { ...options, interactive: true, childrenOnly: true, onLayout: (geometry) => {
+      this.#visible = geometry.visible
+    } }
+  }
+
+  dispose(): void {
+    this.#visible = false
+    this.#regions = []
+    this.#lease.dispose()
+    this.element.remove()
+  }
+}
diff --git a/apps/buddy/src/workbench/browser/surfaces/SurfaceLayoutController.ts b/apps/buddy/src/workbench/browser/surfaces/SurfaceLayoutController.ts
index f937b3b7..7432fb2d 100644
--- a/apps/buddy/src/workbench/browser/surfaces/SurfaceLayoutController.ts
+++ b/apps/buddy/src/workbench/browser/surfaces/SurfaceLayoutController.ts
@@ -164,7 +164,7 @@ export class SurfaceLayoutController implements SurfaceLayout {
     Object.assign(element.style, {
       position: 'fixed',
       visibility: 'visible',
-      pointerEvents: options.interactive ? 'auto' : 'none',
+      pointerEvents: options.interactive && !options.childrenOnly ? 'auto' : 'none',
       left: `${bounds.left}px`,
       top: `${bounds.top}px`,
       width: `${bounds.width}px`,
@@ -173,7 +173,7 @@ export class SurfaceLayoutController implements SurfaceLayout {
       clipPath: `inset(${clip.top - bounds.top}px ${bounds.right - clip.right}px ${bounds.bottom - clip.bottom}px ${clip.left - bounds.left}px)`,
     })
     options.onLayout?.({ visible: true, width: bounds.width, height: bounds.height })
-    element.tabIndex = options.interactive ? 0 : -1
+    element.tabIndex = options.interactive && !options.childrenOnly ? 0 : -1
     element.inert = !options.interactive
     if (options.interactive)
       element.removeAttribute('aria-hidden')
diff --git a/apps/buddy/src/workbench/browser/surfaces/WorkbenchPaneRegistry.ts b/apps/buddy/src/workbench/browser/surfaces/WorkbenchPaneRegistry.ts
new file mode 100644
index 00000000..bf15c972
--- /dev/null
+++ b/apps/buddy/src/workbench/browser/surfaces/WorkbenchPaneRegistry.ts
@@ -0,0 +1,96 @@
+import type { WorkbenchPaneSnapshot } from '@buddy-shared/workbench/workbenchInteraction'
+
+export class WorkbenchPaneRegistry {
+  readonly #elements = new Map<string, HTMLElement>()
+  readonly #listeners = new Set<() => void>()
+  #root: HTMLElement | null = null
+  #snapshot: WorkbenchPaneSnapshot[] = []
+  #resize: ResizeObserver | null = null
+  #mutation: MutationObserver | null = null
+  #frame = 0
+  constructor(readonly active: () => string) {}
+
+  get snapshot(): WorkbenchPaneSnapshot[] { return this.#snapshot }
+  subscribe(listener: () => void): () => void {
+    this.#listeners.add(listener)
+    return () => this.#listeners.delete(listener)
+  }
+
+  register(id: string | null, element: HTMLElement): () => void {
+    if (id === null)
+      this.#root = element
+    else
+      this.#elements.set(id, element)
+    this.#observe()
+    return () => {
+      if (id === null && this.#root === element)
+        this.#root = null
+      else if (id && this.#elements.get(id) === element)
+        this.#elements.delete(id)
+      this.#observe()
+    }
+  }
+
+  start(): void {
+    this.#resize = new ResizeObserver(this.invalidate)
+    this.#mutation = new MutationObserver(this.invalidate)
+    window.addEventListener('resize', this.invalidate)
+    document.addEventListener('visibilitychange', this.invalidate)
+    document.addEventListener('scroll', this.invalidate, true)
+    this.#observe()
+  }
+
+  readonly invalidate = (): void => {
+    if (!this.#resize)
+      return
+    if (document.visibilityState === 'hidden') {
+      cancelAnimationFrame(this.#frame)
+      this.#frame = 0
+      this.#measure()
+    }
+    else if (!this.#frame) {
+      this.#frame = requestAnimationFrame(() => {
+        this.#frame = 0
+        this.#measure()
+      })
+    }
+  }
+
+  #measure(): void {
+    const origin = this.#root?.getBoundingClientRect()
+    const next = [...this.#elements].map(([id, element]) => {
+      const rect = element.getBoundingClientRect()
+      const visible = !!origin && document.visibilityState === 'visible' && element.isConnected && !element.closest('[hidden], [inert]') && getComputedStyle(element).visibility !== 'hidden' && rect.width > 0 && rect.height > 0
+      return { id, active: id === this.active(), visible, rect: visible ? { x: rect.left - origin.left, y: rect.top - origin.top, width: rect.width, height: rect.height } : { x: 0, y: 0, width: 0, height: 0 } }
+    })
+    if (JSON.stringify(next) === JSON.stringify(this.#snapshot))
+      return
+    this.#snapshot = next
+    for (const listener of this.#listeners) listener()
+  }
+
+  #observe(): void {
+    this.#resize?.disconnect()
+    this.#mutation?.disconnect()
+    const ancestors = new Set<HTMLElement>()
+    for (const element of this.#elements.values()) {
+      this.#resize?.observe(element)
+      for (let parent: HTMLElement | null = element; parent; parent = parent.parentElement) ancestors.add(parent)
+    }
+    for (const element of ancestors) this.#mutation?.observe(element, { attributes: true, attributeFilter: ['hidden', 'inert', 'class', 'style'] })
+    if (this.#root)
+      this.#resize?.observe(this.#root)
+    this.invalidate()
+  }
+
+  dispose(): void {
+    cancelAnimationFrame(this.#frame)
+    this.#resize?.disconnect()
+    this.#mutation?.disconnect()
+    this.#resize = null
+    window.removeEventListener('resize', this.invalidate)
+    document.removeEventListener('visibilitychange', this.invalidate)
+    document.removeEventListener('scroll', this.invalidate, true)
+    this.#listeners.clear()
+  }
+}
diff --git a/apps/buddy/src/workbench/browser/surfaces/WorkbenchSurfaceHost.vue b/apps/buddy/src/workbench/browser/surfaces/WorkbenchSurfaceHost.vue
index e05150f9..794263ef 100644
--- a/apps/buddy/src/workbench/browser/surfaces/WorkbenchSurfaceHost.vue
+++ b/apps/buddy/src/workbench/browser/surfaces/WorkbenchSurfaceHost.vue
@@ -17,5 +17,5 @@ onScopeDispose(() => layout.dispose())
 
 <style scoped>
 .workbench-surface-host { display: contents; }
-:global(body:has(.workbench.is-dragging, .workbench.is-resizing, .desktop-workbench-layout.is-resizing) [data-workbench-surface]) { pointer-events: none !important; }
+:global(body:has(.workbench.is-dragging, .workbench.is-resizing, .desktop-workbench-layout.is-resizing) [data-workbench-surface], body:has(.workbench.is-dragging, .workbench.is-resizing, .desktop-workbench-layout.is-resizing) [data-workbench-hit-regions] button) { pointer-events: none !important; }
 </style>
diff --git a/apps/buddy/src/workbench/browser/workbenchContext.ts b/apps/buddy/src/workbench/browser/workbenchContext.ts
index 0076b284..bedcdae9 100644
--- a/apps/buddy/src/workbench/browser/workbenchContext.ts
+++ b/apps/buddy/src/workbench/browser/workbenchContext.ts
@@ -13,8 +13,8 @@ export interface WorkbenchContext {
   copies: WorkingCopyService
   layout: Readonly<Ref<WorkbenchLayout>>
   revision: Readonly<Ref<number>>
-  mountPoints: Readonly<Ref<ReadonlyMap<WorkbenchMountTarget, HTMLElement>>>
-  registerMountPoint: (target: WorkbenchMountTarget, element: HTMLElement) => () => void
+  mountPoints: Readonly<Ref<ReadonlyMap<string, HTMLElement>>>
+  registerMountPoint: (target: WorkbenchMountTarget, element: HTMLElement, instanceId?: string) => () => void
   viewTarget: (id: string) => HTMLElement | null
   labels: Readonly<Ref<ReturnType<typeof workbenchLabels>>>
   dropPosition: Ref<{ paneId: string, position: DropPosition } | null>
diff --git a/apps/buddy/src/workbench/common/workbench.ts b/apps/buddy/src/workbench/common/workbench.ts
index 039e43db..b8ac72cf 100644
--- a/apps/buddy/src/workbench/common/workbench.ts
+++ b/apps/buddy/src/workbench/common/workbench.ts
@@ -12,19 +12,21 @@ export interface WorkbenchView {
   type: string
   location: ViewLocation
   placement?: string
+  interactionId?: string
+  mountInstanceId?: string
   presentation?: WorkbenchPresentation
   resource: ResourceRef
   title: string
   state: Record<string, JsonValue>
 }
-export interface WorkbenchPane { kind: 'pane', id: string, view: string | null }
+export interface WorkbenchPane { readonly kind: 'pane', readonly id: string, readonly view: string | null }
 export interface WorkbenchSplit {
-  kind: 'split'
-  id: string
-  axis: 'horizontal' | 'vertical'
-  ratio: number
-  first: WorkbenchNode
-  second: WorkbenchNode
+  readonly kind: 'split'
+  readonly id: string
+  readonly axis: 'horizontal' | 'vertical'
+  readonly ratio: number
+  readonly first: WorkbenchNode
+  readonly second: WorkbenchNode
 }
 export type WorkbenchNode = WorkbenchPane | WorkbenchSplit
 export interface WorkbenchLayout {
@@ -43,6 +45,7 @@ export interface ViewDescriptor {
   locations: readonly [ViewLocation, ...ViewLocation[]]
   supports: (resource: ResourceRef) => boolean
   priority?: number
+  prepareBeforeOpen?: boolean
   multiple: boolean
 }
 export interface ViewPlacement {
@@ -51,9 +54,12 @@ export interface ViewPlacement {
   viewType: string
   location: 'mount'
   target: WorkbenchMountTarget
+  interaction?: 'regions' | 'exclusive'
   presentation: WorkbenchPresentation
 }
 export interface CommandContext {
+  source?: 'palette' | 'slash'
+  arguments?: string
   view: WorkbenchView | null
   pane: WorkbenchPane | null
   values: Readonly<Record<string, boolean | string | number>>
@@ -61,6 +67,7 @@ export interface CommandContext {
 export interface WorkbenchCommand {
   id: string
   label: string
+  slash?: { name: string, description?: string }
   keybinding?: string
   alternateKeybindings?: readonly string[]
   shortcutScope?: ShortcutScope
@@ -83,7 +90,11 @@ export function panes(node: WorkbenchNode): WorkbenchPane[] {
 export function mapNode(node: WorkbenchNode, id: string, replace: (node: WorkbenchNode) => WorkbenchNode): WorkbenchNode {
   if (node.id === id)
     return replace(node)
-  return node.kind === 'pane' ? node : { ...node, first: mapNode(node.first, id, replace), second: mapNode(node.second, id, replace) }
+  if (node.kind === 'pane')
+    return node
+  const first = mapNode(node.first, id, replace)
+  const second = mapNode(node.second, id, replace)
+  return first === node.first && second === node.second ? node : { ...node, first, second }
 }
 export function removePane(node: WorkbenchNode, id: string): WorkbenchNode | null {
   if (node.id === id)
@@ -92,5 +103,7 @@ export function removePane(node: WorkbenchNode, id: string): WorkbenchNode | nul
     return node
   const first = removePane(node.first, id)
   const second = removePane(node.second, id)
-  return first && second ? { ...node, first, second } : first ?? second
+  if (!first || !second)
+    return first ?? second
+  return first === node.first && second === node.second ? node : { ...node, first, second }
 }
diff --git a/apps/buddy/src/workbench/services/WorkbenchController.ts b/apps/buddy/src/workbench/services/WorkbenchController.ts
index f23311c2..b7583d47 100644
--- a/apps/buddy/src/workbench/services/WorkbenchController.ts
+++ b/apps/buddy/src/workbench/services/WorkbenchController.ts
@@ -1,10 +1,13 @@
 import type { JsonValue } from '@buddy-shared/workbench/workbenchState'
 import type { CommandContext, ResourceRef, SplitDirection, ViewLocation, WorkbenchNode, WorkbenchPane, WorkbenchView } from '../common/workbench'
 import type { ContributionRegistry } from './ContributionRegistry'
+import type { PendingWorkbenchView } from './WorkbenchNavigation'
 import { matchesWorkbenchContext } from '@buddy-shared/workbench/workbenchContext'
 import { createLayout, createPane, mapNode, panes, removePane, resourceKey } from '../common/workbench'
 import { ConfigurationService } from './ConfigurationService'
 import { ContextKeyService } from './ContextKeyService'
+import { WorkbenchInteractions } from './WorkbenchInteractions'
+import { WorkbenchNavigation } from './WorkbenchNavigation'
 
 export interface OpenViewOptions {
   signal?: AbortSignal
@@ -12,6 +15,8 @@ export interface OpenViewOptions {
   viewType?: string
   location?: ViewLocation
   placement?: string
+  interactionId?: string
+  mountInstanceId?: string
   direction?: SplitDirection
   move?: boolean
   duplicate?: boolean
@@ -29,9 +34,13 @@ export class WorkbenchController {
   layout
   readonly registry: ContributionRegistry
   readonly configuration: ConfigurationService
+  readonly interactions = new WorkbenchInteractions(() => this.changed())
+  readonly navigation = new WorkbenchNavigation(() => this.changed())
   readonly contextKeys = new ContextKeyService()
   readonly beforeClose: (view: WorkbenchView, closing?: ReadonlySet<string>) => Promise<ViewCloseDecision>
   readonly #listeners = new Set<() => void>()
+  readonly #stopRegistry: () => void
+  readonly #openRequests = new Map<string, AbortController>()
   #tail: Promise<unknown> = Promise.resolve()
   #contextView: string | null = null
   #contextFocused = false
@@ -41,6 +50,7 @@ export class WorkbenchController {
     this.registry = registry
     this.configuration = new ConfigurationService(registry)
     this.beforeClose = beforeClose
+    this.#stopRegistry = registry.subscribe(() => this.changed())
   }
 
   subscribe(listener: () => void): () => void {
@@ -69,71 +79,140 @@ export class WorkbenchController {
     return panes(this.layout.root).find(pane => pane.view === id) ?? null
   }
 
-  open(resource: ResourceRef, title: string, options: OpenViewOptions = {}): Promise<string | null> {
-    return this.#enqueue(async () => {
-      if (options.signal?.aborted)
-        return null
-      const descriptor = this.registry.resolve(resource, options.viewType)
-      const requestedLocation = options.location ?? descriptor.locations[0]
-      if (!descriptor.locations.includes(requestedLocation))
-        throw new Error(`View location is unavailable: ${descriptor.id}:${requestedLocation}`)
-      if (options.placement) {
-        const placement = this.registry.placements.get(options.placement)
-        if (!placement || placement.viewType !== descriptor.id || placement.location !== requestedLocation)
-          throw new Error('View placement is unavailable')
-      }
-      const existing = Object.values(this.layout.views).find(view => view.type === descriptor.id && resourceKey(view.resource) === resourceKey(resource)
-        && (requestedLocation === 'main' || !descriptor.multiple || !options.duplicate))
-      if (existing && !options.move) {
-        if (options.focus !== false)
-          this.focus(existing.id)
-        return existing.id
-      }
-      const location = existing?.location ?? requestedLocation
-      const view: WorkbenchView = existing ?? { id: crypto.randomUUID(), type: descriptor.id, location, ...(options.placement ? { placement: options.placement } : {}), resource: structuredClone(resource), title, state: structuredClone(options.state ?? {}) }
-      if (location !== 'main') {
-        this.layout.views[view.id] = view
-        if (options.focus !== false)
-          this.focus(view.id)
-        else
-          this.changed()
-        return view.id
+  get renderedViews(): WorkbenchView[] {
+    return [...Object.values(this.layout.views), ...[...this.navigation.entries.values()].filter(entry => entry.status === 'loading').map(entry => entry.view)]
+  }
+
+  cancelNavigation(): void {
+    for (const request of this.#openRequests.values()) request.abort()
+    this.navigation.clear()
+  }
+
+  dispose(): void {
+    this.cancelNavigation()
+    this.#stopRegistry()
+  }
+
+  async open(resource: ResourceRef, title: string, options: OpenViewOptions = {}): Promise<string | null> {
+    if (options.signal?.aborted)
+      return null
+    const descriptor = this.registry.resolve(resource, options.viewType)
+    const location = options.location ?? descriptor.locations[0]
+    if (!descriptor.locations.includes(location))
+      throw new Error(`View location is unavailable: ${descriptor.id}:${location}`)
+    const target = location === 'main' ? this.pane(options.paneId ?? this.layout.activePane) ?? panes(this.layout.root)[0]! : null
+    const request = new AbortController()
+    if (target) {
+      this.#openRequests.get(target.id)?.abort()
+      this.navigation.cancel(target.id)
+      this.#openRequests.set(target.id, request)
+    }
+    const signal = options.signal ? AbortSignal.any([options.signal, request.signal]) : request.signal
+    options = { ...options, ...(target ? { paneId: target.id } : {}), signal }
+    let prepared: PendingWorkbenchView | undefined
+    const cancel = () => {
+      if (prepared && this.navigation.entries.get(prepared.paneId)?.view.id === prepared.view.id)
+        this.navigation.cancel(prepared.paneId)
+    }
+    signal.addEventListener('abort', cancel, { once: true })
+    try {
+      if (descriptor.prepareBeforeOpen && target?.view && !options.direction && !options.placement && !options.interactionId
+        && !Object.values(this.layout.views).some(view => view.type === descriptor.id && resourceKey(view.resource) === resourceKey(resource))) {
+        prepared = this.navigation.begin(target.id, target.view, {
+          id: crypto.randomUUID(),
+          type: descriptor.id,
+          location,
+          resource: structuredClone(resource),
+          title,
+          state: structuredClone(options.state ?? {}),
+        }, options)
+        if (!await prepared.ready || signal.aborted)
+          return null
       }
-      const target = this.pane(options.paneId ?? this.layout.activePane) ?? panes(this.layout.root)[0]!
-      const source = this.owner(view.id)
-      if (source === target) {
-        this.activate(target.id)
+      return await this.#enqueue(async () => {
+        if (options.signal?.aborted || (options.interactionId && !this.interactions.entries.has(options.interactionId)))
+          return null
+        if (prepared && (this.pane(prepared.paneId)?.view !== prepared.previousViewId || this.navigation.find(prepared.view.id)?.status !== 'loading'))
+          return null
+        if (this.registry.views.get(descriptor.id) !== descriptor)
+          return null
+        const requestedLocation = options.location ?? descriptor.locations[0]
+        if (options.placement) {
+          const placement = this.registry.placements.get(options.placement)
+          if (!placement || placement.viewType !== descriptor.id || placement.location !== requestedLocation || (placement.target === 'workbench.pane' && !this.pane(options.mountInstanceId ?? '')))
+            throw new Error('View placement is unavailable')
+        }
+        const existing = Object.values(this.layout.views).find(view => view.type === descriptor.id && resourceKey(view.resource) === resourceKey(resource) && view.mountInstanceId === options.mountInstanceId && view.interactionId === options.interactionId
+          && (requestedLocation === 'main' || !descriptor.multiple || !options.duplicate))
+        if (existing && !options.move) {
+          if (options.focus !== false)
+            this.focus(existing.id)
+          return existing.id
+        }
+        if (options.interactionId && requestedLocation !== 'mount')
+          throw new Error('Interactions require a mount')
+        const location = existing?.location ?? requestedLocation
+        const view: WorkbenchView = existing ?? (prepared ? this.navigation.find(prepared.view.id)?.view : null) ?? { id: crypto.randomUUID(), type: descriptor.id, location, ...(options.interactionId ? { interactionId: options.interactionId } : {}), ...(options.placement ? { placement: options.placement } : {}), ...(options.mountInstanceId ? { mountInstanceId: options.mountInstanceId } : {}), resource: structuredClone(resource), title, state: structuredClone(options.state ?? {}) }
+        if (location !== 'main') {
+          this.layout.views[view.id] = view
+          if (options.focus !== false)
+            this.focus(view.id)
+          else
+            this.changed()
+          return view.id
+        }
+        const target = this.pane(options.paneId ?? this.layout.activePane) ?? panes(this.layout.root)[0]!
+        const source = this.owner(view.id)
+        if (source === target) {
+          this.activate(target.id)
+          return view.id
+        }
+        if (options.direction && panes(this.layout.root).length >= 16 && !source)
+          return null
+        const previous = !options.direction && target.view ? this.layout.views[target.view] : null
+        const decision = previous ? await this.beforeClose(previous) : true
+        if (!decision)
+          return null
+        const plan = typeof decision === 'object' ? decision : null
+        if (options.signal?.aborted || (prepared && this.navigation.find(prepared.view.id)?.status !== 'loading')) {
+          plan?.cancel?.()
+          return null
+        }
+        if (source)
+          this.#collapse(source)
+        const destination = options.direction ? this.#split(target.id, options.direction) : this.pane(target.id)!
+        if (previous)
+          delete this.layout.views[previous.id]
+        this.layout.views[view.id] = this.layout.views[view.id] ?? view
+        this.layout.root = mapNode(this.layout.root, destination.id, () => ({ ...destination, view: view.id }))
+        if (!prepared || (this.layout.activePane === target.id && !this.#contextFocused)) {
+          this.layout.activePane = destination.id
+          this.#contextView = null
+          this.#contextFocused = false
+        }
+        for (const id of plan?.views ?? []) this.#removeView(id)
+        plan?.commit?.()
+        this.changed()
+        await plan?.complete?.()
         return view.id
-      }
-      if (options.direction && panes(this.layout.root).length >= 16 && !source)
-        return null
-      const previous = !options.direction && target.view ? this.layout.views[target.view] : null
-      const decision = previous ? await this.beforeClose(previous) : true
-      if (!decision)
-        return null
-      const plan = typeof decision === 'object' ? decision : null
-      if (options.signal?.aborted) {
-        plan?.cancel?.()
-        return null
-      }
-      if (source) {
-        source.view = null
-        this.#collapse(source)
-      }
-      const destination = options.direction ? this.#split(target.id, options.direction) : this.pane(target.id)!
-      if (previous)
-        delete this.layout.views[previous.id]
-      this.layout.views[view.id] = this.layout.views[view.id] ?? view
-      destination.view = view.id
-      this.layout.activePane = destination.id
-      this.#contextView = null
-      this.#contextFocused = false
-      for (const id of plan?.views ?? []) this.#removeView(id)
-      plan?.commit?.()
-      this.changed()
-      await plan?.complete?.()
-      return view.id
-    })
+      })
+    }
+    finally {
+      signal.removeEventListener('abort', cancel)
+      if (target && this.#openRequests.get(target.id) === request)
+        this.#openRequests.delete(target.id)
+      if (prepared && this.navigation.find(prepared.view.id)?.status === 'loading')
+        cancel()
+    }
+  }
+
+  removeInteraction(id: string): void {
+    this.interactions.remove(id)
+    for (const view of Object.values(this.layout.views)) {
+      if (view.interactionId === id && view.location === 'mount')
+        this.#removeView(view.id)
+    }
+    this.changed()
   }
 
   activate(paneId: string): void {
@@ -188,6 +267,12 @@ export class WorkbenchController {
   }
 
   updateView(id: string, change: Partial<Pick<WorkbenchView, 'title' | 'state' | 'resource' | 'presentation'>>): void {
+    const pending = this.navigation.find(id)
+    if (pending) {
+      this.navigation.entries.set(pending.paneId, { ...pending, view: { ...pending.view, ...change } })
+      this.changed()
+      return
+    }
     const view = this.layout.views[id]
     if (!view)
       return
@@ -195,7 +280,7 @@ export class WorkbenchController {
     this.changed()
   }
 
-  rebindAuxiliary(id: string, change: Pick<WorkbenchView, 'type' | 'resource' | 'location' | 'title' | 'placement'>): void {
+  rebindAuxiliary(id: string, change: Pick<WorkbenchView, 'type' | 'resource' | 'location' | 'title' | 'placement' | 'mountInstanceId'>): void {
     const view = this.layout.views[id]
     if (!view || view.location === 'main' || change.location === 'main' || resourceKey(view.resource) !== resourceKey(change.resource))
       throw new Error('Invalid auxiliary view replacement')
@@ -255,16 +340,18 @@ export class WorkbenchController {
   }
 
   changed(): void {
+    for (const entry of this.navigation.entries.values()) {
+      if (this.pane(entry.paneId)?.view !== entry.previousViewId || !this.registry.views.has(entry.view.type))
+        this.navigation.remove(entry.paneId)
+    }
     for (const listener of this.#listeners) listener()
   }
 
   #removeView(id: string): void {
     const pane = this.owner(id)
     delete this.layout.views[id]
-    if (pane) {
-      pane.view = null
+    if (pane)
       this.#collapse(pane)
-    }
     if (this.#contextView === id) {
       this.#contextView = null
       this.#contextFocused = false
@@ -293,6 +380,12 @@ export class WorkbenchController {
 
   #collapse(pane: WorkbenchPane): void {
     this.layout.root = removePane(this.layout.root, pane.id) ?? createPane(pane.id)
+    if (!this.pane(pane.id)) {
+      for (const view of Object.values(this.layout.views)) {
+        if (view.mountInstanceId === pane.id)
+          this.#removeView(view.id)
+      }
+    }
     if (this.layout.activePane === pane.id)
       this.layout.activePane = panes(this.layout.root)[0]!.id
   }
diff --git a/apps/buddy/src/workbench/services/WorkbenchInteractions.ts b/apps/buddy/src/workbench/services/WorkbenchInteractions.ts
new file mode 100644
index 00000000..8340e725
--- /dev/null
+++ b/apps/buddy/src/workbench/services/WorkbenchInteractions.ts
@@ -0,0 +1,25 @@
+import type { WorkbenchInteraction } from '@buddy-shared/workbench/workbenchInteraction'
+
+export class WorkbenchInteractions {
+  readonly entries = new Map<string, WorkbenchInteraction>()
+  readonly #end = new Map<string, () => void>()
+  constructor(readonly changed: () => void) {}
+
+  add(entry: WorkbenchInteraction, end: () => void): void {
+    this.entries.set(entry.id, entry)
+    this.#end.set(entry.id, end)
+    this.changed()
+  }
+
+  remove(id: string): void {
+    this.#end.delete(id)
+    if (this.entries.delete(id))
+      this.changed()
+  }
+
+  end(id: string): void {
+    const end = this.#end.get(id)
+    this.remove(id)
+    end?.()
+  }
+}
diff --git a/apps/buddy/src/workbench/services/WorkbenchNavigation.ts b/apps/buddy/src/workbench/services/WorkbenchNavigation.ts
new file mode 100644
index 00000000..af86a17c
--- /dev/null
+++ b/apps/buddy/src/workbench/services/WorkbenchNavigation.ts
@@ -0,0 +1,71 @@
+import type { WorkbenchView } from '../common/workbench'
+import type { OpenViewOptions } from './WorkbenchController'
+
+export interface PendingWorkbenchView {
+  paneId: string
+  previousViewId: string
+  view: WorkbenchView
+  options: OpenViewOptions
+  status: 'loading' | 'failed'
+  ready: Promise<boolean>
+}
+
+export class WorkbenchNavigation {
+  readonly entries = new Map<string, PendingWorkbenchView>()
+  readonly #resolve = new Map<string, (ready: boolean) => void>()
+
+  constructor(readonly changed: () => void) {}
+
+  begin(paneId: string, previousViewId: string, view: WorkbenchView, options: OpenViewOptions): PendingWorkbenchView {
+    this.cancel(paneId)
+    const { promise, resolve } = Promise.withResolvers<boolean>()
+    const entry: PendingWorkbenchView = { paneId, previousViewId, view, options, status: 'loading', ready: promise }
+    this.#resolve.set(view.id, resolve)
+    this.entries.set(paneId, entry)
+    this.changed()
+    return entry
+  }
+
+  find(viewId: string): PendingWorkbenchView | undefined {
+    return [...this.entries.values()].find(entry => entry.view.id === viewId)
+  }
+
+  ready(viewId: string): void {
+    const entry = this.find(viewId)
+    if (entry?.status === 'loading')
+      this.#settle(entry, true)
+  }
+
+  fail(viewId: string): void {
+    const entry = this.find(viewId)
+    if (!entry || entry.status === 'failed')
+      return
+    this.entries.set(entry.paneId, { ...entry, status: 'failed' })
+    this.#settle(entry, false)
+    this.changed()
+  }
+
+  cancel(paneId: string): void {
+    if (this.remove(paneId))
+      this.changed()
+  }
+
+  remove(paneId: string): boolean {
+    const entry = this.entries.get(paneId)
+    if (!entry)
+      return false
+    this.entries.delete(paneId)
+    this.#settle(entry, false)
+    return true
+  }
+
+  clear(): void {
+    for (const id of this.entries.keys()) this.remove(id)
+    this.changed()
+  }
+
+  #settle(entry: PendingWorkbenchView, ready: boolean): void {
+    this.#resolve.get(entry.view.id)?.(ready)
+    this.#resolve.delete(entry.view.id)
+  }
+}
diff --git a/apps/buddy/src/workbench/services/WorkbenchPersistence.ts b/apps/buddy/src/workbench/services/WorkbenchPersistence.ts
index de127baf..b81512ae 100644
--- a/apps/buddy/src/workbench/services/WorkbenchPersistence.ts
+++ b/apps/buddy/src/workbench/services/WorkbenchPersistence.ts
@@ -61,7 +61,7 @@ export class WorkbenchPersistence {
     this.#tail = this.#tail.catch(() => {}).then(async () => {
       while (this.#saved !== this.#revision) {
         const revision = this.#revision
-        const snapshot = JSON.parse(JSON.stringify({ version: 1, layout: this.#controller.layout, backups: this.#copies.backups(), configuration: this.#controller.configuration.snapshot() }))
+        const snapshot = JSON.parse(JSON.stringify({ version: 1, layout: { ...this.#controller.layout, views: Object.fromEntries(Object.entries(this.#controller.layout.views).filter(([, view]) => !view.interactionId)) }, backups: this.#copies.backups(), configuration: this.#controller.configuration.snapshot() }))
         await this.#api.write(snapshot)
         this.#saved = revision
       }
diff --git a/apps/buddy/src/workbench/services/__tests__/workbench.spec.ts b/apps/buddy/src/workbench/services/__tests__/workbench.spec.ts
index 57712e6f..e9cccecd 100644
--- a/apps/buddy/src/workbench/services/__tests__/workbench.spec.ts
+++ b/apps/buddy/src/workbench/services/__tests__/workbench.spec.ts
@@ -326,3 +326,121 @@ it('retains protected views when a close request is cancelled during its guard',
   expect(committed).toBe(false)
   expect(cancelled).toBe(true)
 })
+
+describe('prepared view navigation', () => {
+  async function fixture() {
+    const contributions = registry()
+    const controller = new WorkbenchController(contributions)
+    const original = (await controller.open(resource, 'Original'))!
+    contributions.views.get('text')!.prepareBeforeOpen = true
+    return { controller, original, paneId: controller.layout.activePane }
+  }
+
+  it('retains the displayed view, command context and persisted layout until the replacement is ready', async () => {
+    const { controller, original, paneId } = await fixture()
+    const snapshot = JSON.stringify(controller.layout)
+    const opening = controller.open({ ...resource, id: 'next' }, 'Next')
+    const candidate = controller.navigation.entries.get(paneId)!.view
+    expect(JSON.stringify(controller.layout)).toBe(snapshot)
+    expect(controller.context.view?.id).toBe(original)
+    expect(controller.renderedViews.map(view => view.id)).toEqual([original, candidate.id])
+    controller.updateView(candidate.id, { title: 'Loaded title' })
+    controller.navigation.ready(candidate.id)
+    expect(await opening).toBe(candidate.id)
+    expect(controller.pane(paneId)?.view).toBe(candidate.id)
+    expect(controller.context.view?.title).toBe('Loaded title')
+    expect(controller.layout.views[original]).toBeUndefined()
+    expect(controller.navigation.entries.size).toBe(0)
+  })
+
+  it('only commits the latest same-pane request and keeps the original on failure or cancellation', async () => {
+    const { controller, original, paneId } = await fixture()
+    const first = controller.open({ ...resource, id: 'slow' }, 'Slow')
+    const stale = controller.navigation.entries.get(paneId)!.view.id
+    const second = controller.open({ ...resource, id: 'failed' }, 'Failed')
+    const failed = controller.navigation.entries.get(paneId)!.view.id
+    controller.navigation.ready(stale)
+    expect(await first).toBeNull()
+    controller.navigation.fail(failed)
+    expect(await second).toBeNull()
+    expect(controller.pane(paneId)?.view).toBe(original)
+    expect(controller.navigation.entries.get(paneId)?.status).toBe('failed')
+    expect(controller.renderedViews.map(view => view.id)).toEqual([original])
+    const retry = controller.open({ ...resource, id: 'failed' }, 'Retry')
+    const replacement = controller.navigation.entries.get(paneId)!.view.id
+    controller.navigation.ready(replacement)
+    expect(await retry).toBe(replacement)
+    const cancelled = controller.open({ ...resource, id: 'cancelled' }, 'Cancelled')
+    controller.navigation.cancel(paneId)
+    expect(await cancelled).toBeNull()
+    expect(controller.pane(paneId)?.view).toBe(replacement)
+  })
+
+  it('prepares different panes concurrently and does not steal focus when a background pane finishes', async () => {
+    const { controller, paneId } = await fixture()
+    await controller.open({ ...resource, id: 'right' }, 'Right', { direction: 'right' })
+    const right = controller.layout.activePane
+    const leftOpen = controller.open({ ...resource, id: 'left-next' }, 'Left next', { paneId })
+    const rightOpen = controller.open({ ...resource, id: 'right-next' }, 'Right next', { paneId: right })
+    const leftView = controller.navigation.entries.get(paneId)!.view.id
+    const rightView = controller.navigation.entries.get(right)!.view.id
+    controller.navigation.ready(rightView)
+    expect(await rightOpen).toBe(rightView)
+    expect(controller.navigation.entries.get(paneId)?.view.id).toBe(leftView)
+    controller.navigation.ready(leftView)
+    expect(await leftOpen).toBe(leftView)
+    expect(controller.pane(paneId)?.view).toBe(leftView)
+    expect(controller.layout.activePane).toBe(right)
+    expect(controller.context.view?.id).toBe(rightView)
+  })
+
+  it('cancels a preparation when its pane is closed', async () => {
+    const { controller, original, paneId } = await fixture()
+    await controller.open({ ...resource, id: 'other' }, 'Other', { direction: 'right' })
+    const pending = controller.open({ ...resource, id: 'next' }, 'Next', { paneId })
+    const candidate = controller.navigation.entries.get(paneId)!.view.id
+    await controller.close(original)
+    expect(await pending).toBeNull()
+    controller.navigation.ready(candidate)
+    expect(controller.pane(paneId)).toBeNull()
+    expect(controller.navigation.entries.size).toBe(0)
+    expect(controller.renderedViews.map(view => view.resource.id)).toEqual(['other'])
+  })
+
+  it('releases pending views when their contribution is removed', async () => {
+    const contributions = new ContributionRegistry()
+    const unregister = contributions.register('preview', scope => scope.view({ id: 'preview', renderer: 'preview', locations: ['main'], label: 'Preview', supports: () => true, multiple: false, prepareBeforeOpen: true }))
+    const controller = new WorkbenchController(contributions)
+    const original = await controller.open(resource, 'Original')
+    const opening = controller.open({ ...resource, id: 'next' }, 'Next')
+    unregister()
+    expect(await opening).toBeNull()
+    expect(controller.navigation.entries.size).toBe(0)
+    expect(controller.context.view?.id).toBe(original)
+    controller.dispose()
+  })
+
+  it('releases a prepared close guard when cancelled before the commit', async () => {
+    const contributions = registry()
+    const gate = deferred<import('../WorkbenchController').ViewCloseDecision>()
+    const entered = deferred<void>()
+    const controller = new WorkbenchController(contributions, () => {
+      entered.resolve()
+      return gate.promise
+    })
+    const original = (await controller.open(resource, 'Original'))!
+    contributions.views.get('text')!.prepareBeforeOpen = true
+    const opening = controller.open({ ...resource, id: 'next' }, 'Next')
+    const candidate = controller.navigation.entries.get(controller.layout.activePane)!
+    controller.navigation.ready(candidate.view.id)
+    await entered.promise
+    controller.navigation.cancel(candidate.paneId)
+    let editable = false
+    gate.resolve({ cancel: () => editable = true, commit: () => {
+      throw new Error('Must preserve the original')
+    } })
+    expect(await opening).toBeNull()
+    expect(editable).toBe(true)
+    expect(controller.context.view?.id).toBe(original)
+  })
+})
diff --git a/apps/buddy/src/workbench/services/restoreWorkbenchLayout.ts b/apps/buddy/src/workbench/services/restoreWorkbenchLayout.ts
index f13166c8..152534f0 100644
--- a/apps/buddy/src/workbench/services/restoreWorkbenchLayout.ts
+++ b/apps/buddy/src/workbench/services/restoreWorkbenchLayout.ts
@@ -46,6 +46,8 @@ export function restoreWorkbenchLayout(value: unknown): WorkbenchLayout {
       return null
     seenNodes.add(node.id)
     if (node.kind === 'pane') {
+      if (!legacy && node.view === null)
+        return { kind: 'pane', id: node.id, view: null }
       const candidates = legacy && Array.isArray(node.views) ? [node.active, ...node.views] : [node.view]
       const id = candidates.find(id => typeof id === 'string' && views[id]?.location === 'main' && !seenResources.has(resourceKey(views[id]!.resource)))
       if (typeof id !== 'string')
@@ -73,5 +75,6 @@ export function restoreWorkbenchLayout(value: unknown): WorkbenchLayout {
   const auxiliary = !legacy && record(value.auxiliary) ? structuredClone(value.auxiliary) as Record<string, JsonValue> : {}
   if (legacyResources.length)
     auxiliary.legacyResources = legacyResources
-  return { version: 2, root, views: Object.fromEntries(Object.entries(views).filter(([id, view]) => retained.has(id) || view.location !== 'main')), activePane, auxiliary }
+  const paneIds = new Set(panes(root).map(pane => pane.id))
+  return { version: 2, root, views: Object.fromEntries(Object.entries(views).filter(([id, view]) => (!view.interactionId) && (retained.has(id) || view.location !== 'main') && (view.mountInstanceId === undefined || (typeof view.mountInstanceId === 'string' && paneIds.has(view.mountInstanceId))))), activePane, auxiliary }
 }