dsh-ptc-plus 0.4.10 → 0.5.1

package/src/client-tool-view.js

@@ -1,5 +1,6 @@
 import { derivePtcToolView } from './client-activity.js'
 import { isHostComponent } from './client-host-compat.js'
+import { createToolHover, toolHoverExcerpt } from './client-tool-hover.js'
 
 /**
  * run_code / edit_run_code tool rows. The row is a pure projection of the
@@ -7,14 +8,16 @@ import { isHostComponent } from './client-host-compat.js'
  * DisclosureRow when the host provides it and an accessible fallback otherwise.
  */
 export function createPtcToolView(React, deps) {
-  const { CodeBlock, DisclosureRow, icons } = deps
+  const { CodeBlock, DisclosureRow, createPortal, icons } = deps
   const h = React.createElement
   const hasDisclosureRow = isHostComponent(DisclosureRow)
+  const { ToolHoverAnchor } = createToolHover(React, createPortal)
 
-  function PTCPlusToolRow({ toolName, block, inspect, t }) {
+  function PTCPlusToolRow({ toolName, block, inspect, t, hoverEnabled = true }) {
     const [open, setOpen] = React.useState(false)
     const view = derivePtcToolView(block, toolName)
-    const expandable = view.code !== '' || view.output !== '' || typeof inspect === 'function'
+    const previewable = view.code !== '' || view.output !== ''
+    const expandable = previewable || typeof inspect === 'function'
     const stateKey = {
       running: 'tool.running',
       ok: 'tool.completed',
@@ -30,12 +33,17 @@ export function createPtcToolView(React, deps) {
       if (expandable) setOpen(current => !current)
     }
     const summaryText = summary === '' ? null : summary
+    // An auto-filled summary stays visually identical but declares its provenance in the DOM
+    // and on hover, so readers can tell who wrote it without changing the model-facing result.
+    const generatedSummary = view.descriptionGenerated && outputSummary === ''
     const summaryLine = stateText === null && summaryText === null ? null
       : h('div', { className: 'ptcPlusToolSummaryLine', 'data-state': view.state, role: 'status' },
         stateText === null ? null : h('span', { className: 'ptcPlusToolState' }, stateText),
         summaryText === null ? null : h('span', { className: 'ptcPlusToolSep', 'aria-hidden': true }),
-        summaryText === null ? null : h('span', { className: 'ptcPlusToolDescription' }, summaryText))
-    const body = !open ? null : h('div', { className: 'ptcPlusToolBody' },
+        summaryText === null ? null : h('span', { className: 'ptcPlusToolDescription',
+          'data-generated': generatedSummary ? 'true' : undefined,
+          title: generatedSummary ? t('tool.descriptionGenerated') : undefined }, summaryText))
+    const renderBody = (withInspect) => h('div', { className: 'ptcPlusToolBody' },
       view.code === '' ? null : h('div', { className: 'ptcPlusToolSection' },
         h('span', { className: 'ptcPlusToolSectionLabel' }, t('tool.source')),
         isHostComponent(CodeBlock)
@@ -51,7 +59,7 @@ export function createPtcToolView(React, deps) {
             className: 'ptcPlusIoText',
             'data-error': view.state === 'error' || undefined,
           }, view.output))),
-      typeof inspect !== 'function' ? null : h('button', {
+      !withInspect || typeof inspect !== 'function' ? null : h('button', {
         type: 'button', className: 'ptcPlusInspect', onClick: inspect,
       }, h(icons.inspect, { 'aria-hidden': true }), t('tool.inspect')))
     const features = view.features.length === 0 ? null : h('div', { className: 'ptcPlusFeatures' },
@@ -62,8 +70,36 @@ export function createPtcToolView(React, deps) {
       feature.detail === '' ? null
         : h('span', { className: 'ptcPlusFeatureDetail', title: feature.detail }, feature.detail))))
     const collapsedContent = h('div', { className: 'ptcPlusToolPreview' }, summaryLine, features)
+    const body = open ? renderBody(true) : null
+    const sourceExcerpt = toolHoverExcerpt(view.code, 6)
+    const outputExcerpt = toolHoverExcerpt(view.output, 3)
+    const preview = h(React.Fragment, null,
+      h('div', { className: 'ptcPlusToolHoverHeader', 'data-state': view.state },
+        h('span', { className: 'ptcPlusToolHoverHeading' },
+          t(toolName === 'edit_run_code' ? 'tool.editPreview' : 'tool.preview')),
+        h('span', { className: 'ptcPlusToolHoverState' }, t(stateKey))),
+      h('div', { className: 'ptcPlusToolHoverContent' },
+        view.description === '' ? null : h('div', { className: 'ptcPlusToolHoverDescription',
+          'data-generated': view.descriptionGenerated ? 'true' : undefined,
+          title: view.descriptionGenerated ? t('tool.descriptionGenerated') : undefined }, view.description),
+        view.code === '' ? null : h('div', { className: 'ptcPlusToolHoverSection' },
+          h('span', { className: 'ptcPlusToolSectionLabel' }, `${t('tool.source')} · TypeScript`),
+          isHostComponent(CodeBlock) ? h(CodeBlock, {
+            code: sourceExcerpt.text, lang: 'typescript', showHeader: false, lineNumbers: true,
+            className: 'ptcPlusToolCode ptcPlusToolHoverCode',
+          }) : h('pre', { className: 'ptcPlusToolCode ptcPlusToolHoverCode' }, sourceExcerpt.text)),
+        view.output === '' ? null : h('div', { className: 'ptcPlusToolHoverSection' },
+          h('span', { className: 'ptcPlusToolSectionLabel' }, t('tool.result')),
+          h('pre', { className: 'ptcPlusIoText', 'data-error': view.state === 'error' || undefined }, outputExcerpt.text)),
+        features),
+      h('div', { className: 'ptcPlusToolHoverFooter' },
+        h('span', null, t('tool.previewHint')),
+        h('span', { className: 'ptcPlusToolHoverBounded',
+          'data-truncated': sourceExcerpt.truncated || outputExcerpt.truncated || undefined,
+        }, t('tool.previewBounded'))))
+    const wrapRow = anchor => h(ToolHoverAnchor, { disabled: !hoverEnabled || open || !previewable, content: preview }, anchor)
     if (hasDisclosureRow) {
-      return h('div', { className: 'ptcPlusTool' },
+      return wrapRow(
         h(DisclosureRow, {
           icon: expandable
             ? h(icons.chevron, { size: 14 })
@@ -84,7 +120,7 @@ export function createPtcToolView(React, deps) {
           children: body,
         }))
     }
-    return h('div', { className: 'ptcPlusTool' },
+    return wrapRow(h(React.Fragment, null,
       h('div', {
         className: 'ptcPlusToolSummary', 'data-state': view.state,
         'data-expandable': expandable || undefined,
@@ -108,7 +144,7 @@ export function createPtcToolView(React, deps) {
       h('span', { className: 'ptcPlusToolSep', 'aria-hidden': true }),
       h('span', { className: 'ptcPlusToolDescription' }, summary)),
       features,
-      body)
+      body))
   }
 
   return { PTCPlusToolRow }

package/src/client-transport.js

@@ -7,9 +7,9 @@ import { normalizeReplMemorySnapshot } from '../internal/repl-memory-projection.
  * - observeRepl watches one visible REPL region, retries the watch with bounded
  *   backoff and only reports an observation that still matches the requested
  *   inventory. Everything it starts is aborted by its disposer.
- * - createBindingCommandAvailability publishes one boolean per session for the
- *   `binding` command, keyed by epoch so a late `commands.list` answer can never
- *   revive a subscription that already ended.
+ * - createCommandAccess publishes command availability per session, keyed by
+ *   epoch so late directory replies cannot revive an ended subscription.
+ *   Execution receipts must also match the connection and preset generations.
  */
 export function createReplObserver({ rpc, ctx }) {
   function observeRepl(sessionId, element, memory, onObservation) {
@@ -28,25 +28,33 @@ export function createReplObserver({ rpc, ctx }) {
       previous?.abort()
     }
     const watch = async current => {
+      let receipt
       try {
-        await rpc.call(RPC_CONTRACTS.repl, 'watch', { sessionId }, current.signal)
+        receipt = await rpc.call(RPC_CONTRACTS.repl, 'watch', { sessionId }, current.signal)
       } catch {}
       if (disposed || controller !== current) return
       controller = undefined
       current.abort()
       if (!visible || document.visibilityState === 'hidden') { stop(); return }
+      if (receipt?.ok === true && receipt.value?.changed === true) {
+        retries = 0
+        sync()
+        return
+      }
       const delay = retryDelays[retries++]
       if (delay === undefined) return
       retryTimer = setTimeout(() => { retryTimer = undefined; sync() }, delay)
     }
     const read = async current => {
-      if (!memory.available || memory.entries.length === 0 || memory.observation !== undefined) return
+      if (!memory.available || memory.entries.length === 0) return
       try {
         const result = await rpc.call(RPC_CONTRACTS.repl, 'observe', { sessionId, memory }, current.signal)
         if (disposed || controller !== current || current.signal.aborted || result?.ok !== true || result.value === null) return
         const observed = normalizeReplMemorySnapshot(result.value)
         const { observation, ...inventory } = observed
-        if (observation !== undefined && JSON.stringify(inventory) === JSON.stringify(memory)) onObservation(observed)
+        const { observation: _previousObservation, ...expected } = memory
+        if (!observed.available || (observation !== undefined
+          && JSON.stringify(inventory) === JSON.stringify(expected))) onObservation(observed)
       } catch {}
     }
     const sync = () => {
@@ -78,14 +86,15 @@ export function createReplObserver({ rpc, ctx }) {
   return { observeRepl }
 }
 
-export function createBindingCommandAvailability(scope) {
+export function createCommandAccess(scope, name) {
   const entries = new Map()
   let commandRemote
+  let connectionGeneration = 0
   const entryFor = (sessionId) => {
     const id = String(sessionId)
     let entry = entries.get(id)
     if (entry === undefined) {
-      entry = { available: false, epoch: 0, listeners: new Set() }
+      entry = { available: false, epoch: 0, commandGeneration: 0, listeners: new Set() }
       entry.source = {
         getSnapshot: () => entry.available,
         subscribe(listener) {
@@ -119,7 +128,7 @@ export function createBindingCommandAvailability(scope) {
       const result = await commandRemote?.list(String(sessionId))
       available = result?.ok === true
         && Array.isArray(result.value)
-        && result.value.some(command => command?.name === 'binding')
+        && result.value.some(command => command?.name === name)
     } catch {}
     if (entry.epoch === epoch) publish(entry, available)
   }
@@ -128,10 +137,12 @@ export function createBindingCommandAvailability(scope) {
     const entry = entries.get(String(sessionId))
     if (entry === undefined || entry.listeners.size === 0) return
     entry.epoch += 1
+    entry.commandGeneration += 1
     publish(entry, false)
     void refresh(sessionId)
   }
   scope.inject(['remote', 'remote.commands'], commandScope => {
+    connectionGeneration++
     commandRemote = commandScope.get('remote.commands')
     commandScope.effect(() => commandScope.remote.$on('commands/change', () => {
       for (const sessionId of entries.keys()) void refresh(sessionId)
@@ -139,6 +150,7 @@ export function createBindingCommandAvailability(scope) {
     commandScope.effect(() => commandScope.remote.$on('agent-preset/selected', reset))
     for (const sessionId of entries.keys()) void refresh(sessionId)
     commandScope.effect(() => () => {
+      connectionGeneration++
       commandRemote = undefined
       for (const entry of entries.values()) {
         entry.epoch++
@@ -147,13 +159,36 @@ export function createBindingCommandAvailability(scope) {
     })
   })
   scope.on('connection/reset', () => {
+    connectionGeneration++
     for (const sessionId of entries.keys()) reset(sessionId)
   })
   scope.effect(() => () => {
+    connectionGeneration++
     for (const entry of entries.values()) entry.epoch++
     entries.clear()
   })
   return Object.freeze({
     source: sessionId => entryFor(sessionId).source,
+    async run(sessionId, input, signal) {
+      signal?.throwIfAborted()
+      const remote = commandRemote
+      const generation = connectionGeneration
+      const entry = entries.get(String(sessionId))
+      const commandGeneration = entry?.commandGeneration
+      if (!entries.get(String(sessionId))?.available || typeof remote?.execute !== 'function') {
+        throw new Error(`/${name} is unavailable in this session`)
+      }
+      const result = await remote.execute(String(sessionId), `/${name}${input ? ` ${input}` : ''}`, [], signal)
+      signal?.throwIfAborted()
+      if (remote !== commandRemote || generation !== connectionGeneration
+        || commandGeneration !== entry?.commandGeneration) throw new Error('Command connection changed')
+      if (result?.ok !== true || !result.value) throw new Error(result?.error?.message ?? 'Command was not accepted')
+      if (result.value.result?.kind !== 'success') throw new Error(result.value.result?.text ?? 'Command failed')
+      return result.value.result
+    },
   })
 }
+
+export function createBindingCommandAvailability(scope) {
+  return createCommandAccess(scope, 'binding')
+}

package/src/client-workbench.js

@@ -12,7 +12,7 @@ import { isHostComponent, isHostIconComponent } from './client-host-compat.js'
  * discard an unsaved draft.
  */
 export function createUserBindingsWorkbench(React, deps) {
-  const { TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal, icons, catalogOwner } = deps
+  const { TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal, Select, icons, catalogOwner } = deps
   const h = React.createElement
 
   const initialState = Object.freeze({
@@ -120,7 +120,7 @@ export function createUserBindingsWorkbench(React, deps) {
         }
         if (action.imported === true) next.importPath = ''
         next.message = action.removed === true ? { key: 'bindings.removed' }
-          : action.imported === true ? { key: 'bindings.imported' } : state.message
+          : action.imported === true ? { key: 'bindings.imported' } : stored ? { key: stored.enabled ? 'bindings.toggleEnabled' : 'bindings.toggleDisabled', params: { name: stored.name } } : state.message
         return next
       }
       case 'reloadResult': {
@@ -450,10 +450,9 @@ export function createUserBindingsWorkbench(React, deps) {
                     })),
                   h('label', { className: 'ptcPlusBindingField' },
                     h('span', { className: 'ptcPlusBindingFieldLabel' }, t('bindings.scope')),
-                    h('select', {
-                      className: 'ptcPlusSelect', value: state.draft.scope, disabled: state.busy || !state.editing,
-                      onChange: event => edit('scope', event.target.value),
-                    }, h('option', { value: 'namespace' }, 'namespace'), h('option', { value: 'top-level' }, 'top-level'))),
+                    h(Select, { value: state.draft.scope, disabled: state.busy || !state.editing,
+                      label: t('bindings.scope'), onChange: next => edit('scope', next),
+                      options: [{ value: 'namespace', label: 'namespace' }, { value: 'top-level', label: 'top-level' }] })),
                   h('label', { className: 'ptcPlusBindingField' },
                     h('span', { className: 'ptcPlusBindingFieldLabel' }, t('bindings.symbols')),
                     h('input', {
@@ -502,7 +501,7 @@ export function createUserBindingsWorkbench(React, deps) {
     const trapFocus = event => {
       if (event.key !== 'Tab') return
       const controls = [...content.current.querySelectorAll('button:not(:disabled),input:not(:disabled),textarea:not(:disabled),select:not(:disabled),[contenteditable=true],summary')]
-        .filter(element => element.getClientRects().length > 0)
+        .filter(element => element.getClientRects().length > 0 && !element.closest('[aria-hidden=true],[hidden]'))
       const first = controls[0]
       const last = controls.at(-1)
       if ((event.shiftKey && document.activeElement === first) || (!event.shiftKey && document.activeElement === last)) {

package/src/client.js

@@ -3,8 +3,11 @@ import { RPC_CONTRACTS } from '../internal/rpc-contract.js'
 import { CONFIG_DEFAULTS, SETTINGS_NAMESPACE } from '../internal/config-spec.js'
 import { createPtcToolView } from './client-tool-view.js'
 import { createPtcSettingsView } from './client-settings-view.js'
+import { createCapabilityCommandCard, createCapabilityRefreshView, createSessionCapabilityControlsView } from './client-capabilities-view.js'
+import { capabilityProfileConfiguration } from '../internal/runtime-config.js'
 import { createReplView } from './client-repl-view.js'
 import { createAuthoringView } from './client-authoring-view.js'
+import { bindingToggleConversationDefinition } from './client-binding-toggle.js'
 import { createIndicatorView } from './client-indicator-view.js'
 import { createTypeScriptEditor } from './client-code-editor.js'
 import { createBindingConsole } from './client-console.js'
@@ -29,7 +32,7 @@ import { installStyles } from './client-styles.js'
 import { featureEnabled, registerGated } from './client-feature-gates.js'
 import { createCatalogOwner } from './client-catalog.js'
 import { createUserBindingsWorkbench } from './client-workbench.js'
-import { createBindingCommandAvailability, createReplObserver } from './client-transport.js'
+import { createBindingCommandAvailability, createCommandAccess, createReplObserver } from './client-transport.js'
 import { createActionButton, resolvePrimitives } from './client-primitives.js'
 
 /** Settings snapshot used until the installed generation serves a transport. */
@@ -87,10 +90,7 @@ function createPreferenceScope(ctx) {
   })
 }
 
-window.__ModuleLoader__.load({
-  // Replaced by the bundle entry with the package name from package.json.
-  id: __PTC_PLUS_CLIENT_MODULE_ID__,
-  factory: (require) => {
+export function createClientPlugin(require) {
     const React = require('react')
     const { createPortal } = require('react-dom')
     let primitives
@@ -106,6 +106,7 @@ window.__ModuleLoader__.load({
       Menu,
       MenuFallback,
       Modal,
+      Select,
       Toast,
       Tooltip,
     } = resolvePrimitives(primitives, React, createPortal)
@@ -123,7 +124,6 @@ window.__ModuleLoader__.load({
       play: IconPlayOutline16,
       stop: IconStopFill16,
     } = hostIconComponents(primitives)
-    const module = { exports: {} }
     const h = React.createElement
     const TypeScriptEditor = createTypeScriptEditor(React)
 
@@ -138,7 +138,7 @@ window.__ModuleLoader__.load({
     const BindingConsole = createBindingConsole(React, { TypeScriptEditor, IconButton, ActionButton,
       icons: { play: IconPlayOutline16, stop: IconStopFill16, reset: IconRefreshOutline16, clear: IconTrashOutline16 } })
     const { PTCPlusToolRow } = createPtcToolView(React, {
-      CodeBlock, DisclosureRow,
+      CodeBlock, DisclosureRow, createPortal,
       icons: { chevron: IconChevronDownOutline14, check: IconCheckOutline14, inspect: IconInspectOutline12 },
     })
 
@@ -167,7 +167,7 @@ window.__ModuleLoader__.load({
       const catalogOwner = createCatalogOwner({ callUserBindings })
       ctx.effect(() => () => catalogOwner.dispose(), 'ptc-plus: binding catalog sources')
       const { useWorkbenchController, UserBindingsWorkbench, BindingsDialog } = createUserBindingsWorkbench(React, {
-        TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal,
+        TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal, Select,
         catalogOwner,
         icons: {
           refresh: IconRefreshOutline16, plus: IconPlusOutline16, check: IconCheckOutline14,
@@ -176,12 +176,43 @@ window.__ModuleLoader__.load({
         },
       })
       const { observeRepl } = createReplObserver({ rpc, ctx })
+      const capabilityCommands = createCommandAccess(ctx, 'capabilities')
+      const CapabilityCommandCard = createCapabilityCommandCard(React)
+      const CapabilityRefreshButton = createCapabilityRefreshView(React, capabilityCommands)
+      const SessionCapabilityControls = createSessionCapabilityControlsView(React, {
+        commands: capabilityCommands, Modal, Select,
+        async inspectSessionCatalog(sessionId, signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'session-catalog', { sessionId }, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Session capability catalog unavailable')
+          return result.value
+        },
+      })
       const { PTCPlusSettingsCard, PTCPlusSettingsDialog } = createPtcSettingsView(React, {
-        ActionButton, BindingsDialog, Modal, useWorkbenchController,
-        icons: { chevron: IconChevronDownOutline14 },
+        ActionButton, BindingsDialog, Modal, Select, useWorkbenchController, CapabilityRefreshButton,
+        async inspectCapabilityTargets(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'targets', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability refresh targets unavailable')
+          return result.value
+        },
+        async inspectCapabilityPlans(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'inspect', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability plans unavailable')
+          return result.value
+        },
+        async inspectCapabilityCatalog(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'catalog', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability catalog unavailable')
+          return result.value
+        },
+        async inspectCapabilityAllocation(payload, signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'allocation', payload, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability allocation unavailable')
+          return result.value
+        },
+        icons: { search: IconSearchOutline16, chevron: IconChevronDownOutline14 },
       })
-      const { ReplComposer, ReplConsole, ReplMemoryCard, replPopoverIsOpen, placeReplPopover } = createReplView(React, {
-        CodeBlock, featureEnabled, normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
+      const { ReplComposer, ReplConsole, ReplMemoryCard, replPopoverIsOpen, placeReplPopover, useObservedReplMemory } = createReplView(React, {
+        CodeBlock, Select, featureEnabled, normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
         useSessionPreset, sessionUsesPtcPreset, useWorkbenchController, UserBindingsWorkbench,
         icons: { search: IconSearchOutline16, chevron: IconChevronDownOutline14 },
       })
@@ -204,6 +235,15 @@ window.__ModuleLoader__.load({
           && (key !== 'bindingUpdates' || after.value.legacyBindingSettings !== true)
           ? 'status.applied' : 'status.conflict'
       }
+      const updateCapabilityConfiguration = async configuration => {
+        const before = preferenceScope.getSnapshot()
+        if (before.status !== 'ready' || before.writable !== true || !featureEnabled(before, 'plugin')) throw new Error('Capability settings are not writable')
+        const validated = capabilityProfileConfiguration(configuration)
+        await preferenceScope.mutate(Object.entries(validated).map(([key, value]) => ({ op: 'set', path: [key], value })))
+        const after = preferenceScope.getSnapshot()
+        if (after.status !== 'ready' || Object.entries(validated).some(([key, value]) => after.value?.[key] !== value)) throw new Error('Capability configuration was not applied')
+        return 'status.applied'
+      }
       // One gated-registration shape for every settings-driven contribution.
       const settingsGate = (feature, register) => ({
         subscribe: listener => preferenceScope.subscribe(listener),
@@ -217,20 +257,25 @@ window.__ModuleLoader__.load({
       const settingsCard = publishSettingsCard(ctx, {
         bundleName: __PTC_PLUS_CLIENT_MODULE_ID__,
         locale: LOCALE_NS,
-        injectProps: () => ({ ...settingsProps(), updateSetting }),
+        injectProps: () => ({ ...settingsProps(), updateSetting, updateCapabilityConfiguration }),
         component: PTCPlusSettingsCard,
       })
 
+      function ConfiguredToolRow(props) {
+        const snapshot = React.useSyncExternalStore(preferenceScope.subscribe, preferenceScope.getSnapshot)
+        return h(PTCPlusToolRow, { ...props, hoverEnabled: featureEnabled(snapshot, 'toolHover') })
+      }
+
       ctx.slots.inject('tool.call.toolview', () => registerGated(ctx, settingsGate('toolView', () => {
         // Two rows share one eligibility decision; roll both back if either fails.
         const disposers = []
         try {
           disposers.push(ctx.slots.register({
             name: 'tool.call.toolview', key: 'run_code', locale: LOCALE_NS,
-          }, PTCPlusToolRow))
+          }, ConfiguredToolRow))
           disposers.push(ctx.slots.register({
             name: 'tool.call.toolview', key: 'edit_run_code', locale: LOCALE_NS,
-          }, PTCPlusToolRow))
+          }, ConfiguredToolRow))
         } catch (error) {
           disposers.reverse().forEach(dispose => dispose())
           throw error
@@ -283,7 +328,7 @@ window.__ModuleLoader__.load({
       const { BindingAuthorButton, BindingReviewDock, BindingCommandCard } = createAuthoringView(React, {
         ActionButton, IconButton, Menu, MenuFallback, Toast, Tooltip, CodeBlock, Modal, createPortal, BindingsDialog, PTCPlusSettingsDialog,
         useWorkbenchController, useBindingReview, catalogOwner, callUserBindings, subscribeReset,
-        settingsCardSeat: settingsCard.seat, updateSetting, menuChildren,
+        settingsCardSeat: settingsCard.seat, updateSetting, updateCapabilityConfiguration, menuChildren, SessionCapabilityControls,
         icons: {
           sparkle: IconSparkle16, chevron: IconChevronDownOutline14,
           close: IconCloseOutline16, check: IconCheckOutline14,
@@ -294,6 +339,7 @@ window.__ModuleLoader__.load({
         normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
         ReplMemoryCard, replPopoverIsOpen, placeReplPopover,
         catalogOwner, subscribeReset,
+        useObservedReplMemory, observeRepl,
       })
 
       ctx.slots.inject('conversation.session.header.actions', () => registerGated(ctx, settingsGate('plugin', () => ctx.slots.register({
@@ -304,6 +350,15 @@ window.__ModuleLoader__.load({
         name: 'conversation.chat.commandview', key: 'binding', locale: LOCALE_NS,
         inject: settingsProps,
       }, props => h(BindingCommandCard, { ...props, key: props.node.commandId })))))
+      ctx.slots.inject('conversation.chat.commandview', () => registerGated(ctx, settingsGate('plugin', () => ctx.slots.register({
+        name: 'conversation.chat.commandview', key: 'capabilities', locale: LOCALE_NS,
+      }, props => h(CapabilityCommandCard, props)))))
+      ctx.inject(['uiConversation'], scope => scope.effect(() => scope.uiConversation.events.register(bindingToggleConversationDefinition),
+        'ptc-plus binding configuration receipts'))
+      ctx.slots.inject('conversation.chat.node', () => ctx.effect(() => ctx.slots.register({
+        name: 'conversation.chat.node', key: 'ptc-plus-binding-toggle', locale: LOCALE_NS,
+      }, ({ node, t }) => h('p', { className: 'ptcPlusCapabilityReceipt', role: 'status' },
+        t(node.data.enabled ? 'bindings.toggleEnabled' : 'bindings.toggleDisabled', { name: node.data.name }))), 'ptc-plus binding configuration receipt renderer'))
       ctx.slots.inject('conversation.input.dock', () => ctx.slots.inject('conversation.input.left', () =>
         registerGated(ctx, settingsGate('bindings', () => ctx.slots.register({
           name: 'conversation.input.dock', id: 'ptc-plus-binding-review', order: -30, locale: LOCALE_NS,
@@ -326,21 +381,20 @@ window.__ModuleLoader__.load({
             return () => { unsubscribePreset(); unsubscribeSettings() }
           },
           isEnabled: () => sessionUsesPtcPreset(preset)
-            && featureEnabled(preferenceScope.getSnapshot(), 'bindings'),
+            && featureEnabled(preferenceScope.getSnapshot(), 'plugin'),
           register: () => ctx.slots.register({
             name: 'conversation.input.left', id: 'ptc-plus-binding-author', order: 20, locale: LOCALE_NS,
             inject: sessionId => ({
-              hooks: { ptcSettings: preferenceScope, bindingCommand: availability.source(sessionId) },
+              hooks: { ptcSettings: preferenceScope, bindingCommand: availability.source(sessionId),
+                capabilityCommand: capabilityCommands.source(sessionId) },
             }),
           }, props => props.sessionId === undefined ? null : h(BindingAuthorButton, { ...props, key: props.sessionId })),
         }))
       })
     }
 
-    module.exports = {
+    return {
       apply,
       inject: ['slots', 'locale', 'connection', 'remote'],
     }
-    return module.exports
-  },
-})
+}