dsh-ptc-plus 0.5.0 → 0.5.2

package/src/client-capabilities-view.js

@@ -4,6 +4,10 @@ import { CAPABILITY_CONFIGURATION_KEYS, capabilityProfileConfiguration, validate
 import { readCapabilityCommandReceipt } from '../internal/capability-command-receipt.js'
 import { createFallbackModal } from './client-primitives.js'
 import { CAPABILITY_SORT_COLUMNS, capabilitySortDirection, cycleCapabilitySort, sortCapabilityEntries } from './client-capability-sort.js'
+import {
+  PROMPT_ASSETS, PROMPT_TEXT_MAX_SLOT_BYTES, PROMPT_TEXT_SCHEMA,
+  accountPromptText, parsePromptTextDocument, resolvePromptText,
+} from '../internal/prompt-text.js'
 
 export function capabilityCommandText(t, text) {
   if (text?.key) return t(text.key, text.params)
@@ -11,6 +15,20 @@ export function capabilityCommandText(t, text) {
   return receipt ? t(`capabilities.receipt.${receipt.state}`, { session: receipt.sessionId, error: receipt.error ?? '' }) : text
 }
 
+// Host-owned context the model sees in PTC mode. The plugin never receives the host's
+// own instruction text and cannot edit these bytes; it can only name the section it
+// appends into or replaces. Listing them keeps the pane answering "what does the model
+// actually see" instead of silently showing plugin-owned anchors only.
+const HOST_CONTEXT_SECTIONS = Object.freeze([
+  Object.freeze({ id: 'host:system-prompt', presence: 'capabilities.prompt.hostPresenceEvery' }),
+  Object.freeze({ id: 'host:tools:sdk', presence: 'capabilities.prompt.hostPresenceCapabilities' }),
+])
+// The prompt table is one column model shared by the colgroup, the header and every
+// data row. Slot chips do not get a column: they render in their own full-width
+// sub-row, because a narrow chip column stacked a five-slot anchor into a tall stack.
+const PROMPT_TABLE_COLUMN_KEYS = Object.freeze(['channel', 'anchor', 'presence', 'bytes', 'reason', 'kind'])
+const PROMPT_TABLE_COLUMNS = PROMPT_TABLE_COLUMN_KEYS.length
+
 function capabilityChoiceLabel(t, value) {
   return t(value === 'inherit' ? 'capabilities.quick.noOverride'
     : ['enabled', 'pending', 'unknown'].includes(value) ? `capabilities.quick.${value}`
@@ -30,13 +48,66 @@ function validCatalogRule(rule, temporary = false) {
         ? ['enabled', 'closed'].includes(choice) : CAPABILITY_DISCLOSURES.includes(choice))))
 }
 
+/** A Chat snapshot without a node store cannot order a receipt against the conversation. */
+const noSnapshot = () => undefined
+
+/**
+ * The first human message is the conversation's opening position. DSH may reuse
+ * a blank Session, so capability commands recorded before that message are
+ * history from an earlier attempt, not part of this conversation; they must not
+ * appear above the user's first sentence.
+ */
+export function firstHumanMessageSeq(nodes) {
+  if (nodes === null || nodes === undefined || typeof nodes.values !== 'function') return null
+  let first = null
+  for (const node of nodes.values()) {
+    if (node?.kind !== 'user' || node.data?.source?.kind !== 'user') continue
+    const seq = node.anchorSeq ?? node.data?.seq
+    if (!Number.isSafeInteger(seq)) continue
+    if (first === null || seq < first) first = seq
+  }
+  return first
+}
+
+/**
+ * A capability receipt belongs to chat only after the conversation has opened.
+ * A blank Session has nothing to announce, and a receipt recorded before the
+ * first human message describes a previous attempt's publication. A truncated
+ * Chat window cannot prove where the conversation opened, so its earliest
+ * loaded message must not hide a receipt the session may still own.
+ */
+export function capabilityReceiptVisible(node, { blank = false, firstUserSeq = null, windowComplete = true } = {}) {
+  if (blank === true) return false
+  if (windowComplete !== true) return true
+  return !(Number.isSafeInteger(node?.seq) && Number.isSafeInteger(firstUserSeq) && node.seq < firstUserSeq)
+}
+
 export function createCapabilityCommandCard(React) {
   const h = React.createElement
-  return function CapabilityCommandCard({ node, t }) {
+  return function CapabilityCommandCard({ node, t, useChat, useSession }) {
     const [showSource, setShowSource] = React.useState(false)
+    // Both hooks are always called so the seat keeps one hook order whether or
+    // not the surrounding Chat or Session supplies its store.
+    const readSession = typeof useSession === 'function' ? useSession : noSnapshot
+    const blank = readSession(snapshot => snapshot?.blank === true) === true
+    // `hasMore` marks a window that does not reach the session start; only a
+    // complete window may claim its earliest human message is the first one.
+    const windowComplete = readSession(snapshot => snapshot?.hasMore !== true)
+    const readChat = typeof useChat === 'function' ? useChat : noSnapshot
+    const firstUserSeq = readChat(snapshot => firstHumanMessageSeq(snapshot?.nodes))
+    // A capability notice is the outcome of a `/capabilities` command the user
+    // submitted. What a new session publishes is a model-visible runtime context,
+    // not chat, so a node without that submitted input is not a user command and
+    // renders no notice: a fresh session has no change to announce.
+    if (typeof node.args !== 'string') return null
+    if (!capabilityReceiptVisible(node, { blank, firstUserSeq, windowComplete })) return null
     const command = `/${node.name ?? 'capabilities'}${node.args ? ` ${String(node.args).trim()}` : ''}`
     const text = node.outcome?.text
     const receipt = readCapabilityCommandReceipt(text)
+    // Pending is the plan's publication state, not an outcome: it becomes true
+    // only at the next accepted model step, so a durable notice would state a
+    // future that a historical row can no longer verify.
+    if (receipt?.state === 'pending') return null
     const legacyRefresh = text === 'Session capability environment refreshed; the model-visible notification is recorded.'
     if (receipt || String(node.args ?? '').trim() === 'refresh' || legacyRefresh) {
       const outcome = receipt ? t(`capabilities.card.${receipt.state}`, { error: receipt.error ?? '' })
@@ -128,12 +199,13 @@ export function capabilityPlanReason(t, entry) {
 export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal = createFallbackModal(React) }) {
   const h = React.createElement
   const field = key => CONFIG_FIELDS.find(item => item.key === key)
-  const responsibilityGroups = [
-    { tab: 'manual', keys: ['rules'] },
-    { tab: 'budgets', keys: ['description', 'recovery', 'preview'] },
-    { tab: 'statistics', keys: ['statistics'] },
-  ]
-  const responsibilities = responsibilityGroups.flatMap(group => group.keys)
+  // Each group owns one settings tab; the prompt text switch lives in the same
+  // capabilities section, so 新会话设置 must list it or a saved choice would be
+  // invisible there.
+  // 新会话设置 is one row of equally sized choices. Groups only existed to give each
+  // tab a caption; that produced a second row as soon as 提示文本 was added, so the
+  // choices stay flat and the navigation target is decided by `onNavigate` instead.
+  const responsibilities = ['rules', 'description', 'recovery', 'preview', 'statistics', 'promptText']
   const choicesFor = (configuration, plan) => {
     const historical = plan && ['ptc-capability-plan/v1', 'ptc-capability-plan/v3'].includes(plan.schema)
       && configuration && configuration.capabilityPolicy === undefined
@@ -143,10 +215,13 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
       enabled: configuration?.capabilityManagementEnabled ?? plan?.enabled,
       statistics,
       recoveryEnabled: configuration?.capabilityRecoveryEnabled ?? (historical ? plan.enabled : undefined),
-      previewEnabled: configuration?.modelPreviewEnabled ?? (historical ? plan.enabled : undefined) }
+      previewEnabled: configuration?.modelPreviewEnabled ?? (historical ? plan.enabled : undefined),
+      // The switch is new: a stored configuration without it means "on", the
+      // documented default, while an unreadable configuration stays unknown.
+      promptTextEnabled: configuration === undefined ? undefined : configuration.capabilityPromptTextEnabled !== false }
   }
   const flagsFor = settings => ({ rules: settings.enabled, description: settings.enabled, statistics: settings.statistics?.enabled,
-    recovery: settings.recoveryEnabled, preview: settings.previewEnabled })
+    recovery: settings.recoveryEnabled, preview: settings.previewEnabled, promptText: settings.promptTextEnabled })
   const choiceState = (retained, applied, key) => typeof retained[key] !== 'boolean' ? 'unknown'
     : retained[key] ? typeof applied[key] !== 'boolean' ? 'unknown' : applied[key] === false ? 'paused' : 'selected'
       : key === 'rules' || key === 'description' ? 'host' : 'unselected'
@@ -176,17 +251,16 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
     return h('section', { className: 'ptcPlusCombination', 'aria-label': t('capabilities.combination.saved') },
       h('div', { className: 'ptcPlusTaskHead' }, h('h4', null, t('capabilities.combination.saved')),
         h('span', { className: 'ptcPlusCapabilitySaveState', role: 'status' }, feedback)),
-      h('div', { className: 'ptcPlusCombinationChoices' }, ...responsibilityGroups.map(group =>
-        h('div', { key: group.tab, className: 'ptcPlusCombinationGroup', role: 'group',
-          'aria-label': t(`capabilities.tab.${group.tab}`) },
-        h('strong', { className: 'ptcPlusCombinationGroupTitle' }, t(`capabilities.tab.${group.tab}`)),
-        h('div', { className: 'ptcPlusCombinationGroupChoices' }, ...group.keys.map(key => {
-          const state = choiceState(retained, applied, key)
-          return h('button', { key, type: 'button', className: 'ptcPlusCombinationChoice', 'data-state': state,
-            'aria-controls': key === 'rules' || key === 'statistics' ? `${id}-pane-${group.tab}` : `${id}-context-pane-${key}`,
-            onClick: () => onNavigate(key) }, h('span', null, t(`capabilities.combination.${key}`)),
-            h('small', null, t(`capabilities.combination.state.${state}`)))
-        }))))),
+      h('div', { className: 'ptcPlusCombinationChoices' }, ...responsibilities.map(key => {
+        const state = choiceState(retained, applied, key)
+        return h('button', { key, type: 'button', className: 'ptcPlusCombinationChoice', 'data-state': state,
+          'data-choice': key,
+          'aria-controls': key === 'promptText' ? `${id}-pane-prompt`
+            : key === 'rules' || key === 'statistics' ? `${id}-pane-${key === 'rules' ? 'manual' : 'statistics'}`
+              : `${id}-context-pane-${key}`,
+          onClick: () => onNavigate(key) }, h('span', null, t(`capabilities.combination.${key}`)),
+          h('small', null, t(`capabilities.combination.state.${state}`)))
+      })),
       h('p', { className: 'ptcPlusDetail', role: 'status' }, effect),
       h('details', { className: 'ptcPlusCapabilitySessionTools' }, h('summary', { tabIndex: 0 }, t('capabilities.existingSessions')),
         renderRefresh?.(),
@@ -286,7 +360,6 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
           'aria-label': t('capabilities.batch.cancel'), onClick: close }, '×')),
       h('div', { className: 'ptcPlusCapabilityBatchBody' },
         h('p', { className: 'ptcPlusDetail', role: 'status' }, t('capabilities.batch.targets', { count: operation.targets.length })),
-        h('p', { className: 'ptcPlusDetail' }, t('capabilities.batch.scope', { scope: operation.scope })),
         operation.excluded ? h('p', { className: 'ptcPlusDetail' }, t('capabilities.batch.excluded', { count: operation.excluded })) : null,
         operation.targets.length ? h('ul', { className: 'ptcPlusCapabilityBatchTargets', 'aria-label': t('capabilities.batch.targetList') },
           ...operation.targets.map(target => h('li', { key: target.id }, h('span', null, target.name), h('code', null, target.id))))
@@ -298,7 +371,8 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
               options: ['keep', 'automatic', ...(dimension === 'availability' ? ['enabled', 'closed'] : CAPABILITY_DISCLOSURES)]
                 .map(choice => ({ value: choice, label: t(choice === 'keep' ? 'capabilities.batch.keep'
                   : choice === 'automatic' ? 'capabilities.policy.inheritRule'
-                    : choice === 'enabled' ? 'capabilities.quick.enabled' : `capabilities.${choice}`) })) })))),
+                    : choice === 'enabled' ? 'capabilities.action.enable'
+                      : choice === 'closed' ? 'capabilities.action.close' : `capabilities.${choice}`) })) })))),
         h('p', { className: 'ptcPlusDetail' }, t('capabilities.batch.effect')),
         h('p', { className: 'ptcPlusDetail' }, t('capabilities.batch.sourceClosure')),
         missing ? h('p', { className: 'ptcPlusMessage', role: 'alert' }, t('capabilities.batch.changedTargets', { count: missing })) : null,
@@ -321,6 +395,7 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
     const [availability, setAvailability] = React.useState('all')
     const [sort, setSort] = React.useState(null)
     const [selected, setSelected] = React.useState(null)
+    const [picked, setPicked] = React.useState([])
     const [filtersOpen, setFiltersOpen] = React.useState(false)
     const [batchOperation, setBatchOperation] = React.useState(null)
     const [inheritedRulesOpen, setInheritedRulesOpen] = React.useState(false)
@@ -379,6 +454,15 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
         : column === 'source' ? displayedSource(item)
           : column === 'availability' ? t(`capabilities.rowState.${state(item)}`)
             : t(`capabilities.${item.resolvedRule.disclosure}`))
+    const pickedIds = picked.filter(id => entries.some(item => item.id === id))
+    const pickedEntries = pickedIds.map(id => entries.find(item => item.id === id)).filter(Boolean)
+    const pickedTargets = pickedEntries.filter(item => item.availability === 'available')
+    const allVisiblePicked = visible.length > 0 && visible.every(item => pickedIds.includes(item.id))
+    const someVisiblePicked = visible.some(item => pickedIds.includes(item.id))
+    const togglePick = id => setPicked(current => current.includes(id) ? current.filter(item => item !== id) : [...current, id])
+    const toggleAllVisible = () => setPicked(current => allVisiblePicked
+      ? current.filter(id => !visible.some(item => item.id === id))
+      : [...new Set([...current, ...visible.map(item => item.id)])])
     const entry = visible.find(item => item.id === selected)
     const plan = sessionId ? plans?.find(item => item.sessionId === sessionId) : undefined
     const effective = plan?.effective.entries.find(item => item.id === entry?.id)
@@ -430,11 +514,15 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
         h('button', { type: 'button', className: 'ptcPlusButton', 'aria-haspopup': 'dialog',
           onClick: () => setFiltersOpen(true) }, t('capabilities.filterAction')),
         h('button', { type: 'button', className: 'ptcPlusButton', 'aria-haspopup': 'dialog',
-          disabled: disabled('capabilityPolicy'), onClick: () => setBatchOperation({
-            targets: visible.filter(item => item.availability === 'available').map(item => ({ id: item.id, name: item.name })),
-            excluded: visible.filter(item => item.availability !== 'available').length,
-            scope: [...filterLabels, ...(query.trim() ? [t('capabilities.batch.search', { query: query.trim() })] : [])].join(' · ') || t('capabilities.batch.all'),
-          }) }, t('capabilities.batchSettings')),
+          'aria-label': t('capabilities.batchSettings'),
+          disabled: disabled('capabilityPolicy') || pickedTargets.length === 0,
+          onClick: () => setBatchOperation({
+            targets: pickedTargets.map(item => ({ id: item.id, name: item.name })),
+            excluded: pickedIds.length - pickedTargets.length,
+          }) }, t('capabilities.batchSettings'),
+          pickedIds.length ? h('span', { className: 'ptcPlusCapabilityBatchCount', 'aria-hidden': true,
+            title: t('capabilities.selectionCount', { count: pickedIds.length }) },
+            String(pickedIds.length)) : null),
         h('button', { type: 'button', className: 'ptcPlusButton', 'aria-haspopup': 'dialog',
           onClick: () => setInheritedRulesOpen(true) }, t('capabilities.inheritedRules'))),
       filtersOpen ? h(CapabilityDialog, { title: t('capabilities.filterAction'), onClose: () => setFiltersOpen(false), t,
@@ -468,7 +556,12 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
           h('div', { className: 'ptcPlusCapabilityTable', role: 'table', 'aria-label': t('capabilities.management') },
             h('div', { className: 'ptcPlusCapabilityColumns', role: 'row' },
               ...CAPABILITY_SORT_COLUMNS.map(column => h('span', { key: column.key, role: 'columnheader',
-                'aria-sort': capabilitySortDirection(sort, column.key) },
+                'aria-sort': capabilitySortDirection(sort, column.key),
+                ...(column.key === 'name' ? { 'aria-label': t('capabilities.member'), className: 'ptcPlusCapabilityPickHead' } : {}) },
+                ...(column.key === 'name' ? [h('input', { type: 'checkbox', className: 'ptcPlusPick', checked: allVisiblePicked,
+                  ref: node => { if (node) node.indeterminate = someVisiblePicked && !allVisiblePicked },
+                  disabled: visible.length === 0, 'aria-label': t('capabilities.selectAllVisible'),
+                  onChange: toggleAllVisible })] : []),
                 h('button', { type: 'button', className: 'ptcPlusCapabilitySort', title: t('capabilities.sortCycle'),
                   onClick: () => setSort(current => cycleCapabilitySort(current, column.key)) },
                 t(`capabilities.${column.label}`), h('span', { 'aria-hidden': true },
@@ -476,7 +569,12 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
             h('div', { className: 'ptcPlusCapabilityList', role: 'rowgroup' }, ...visible.map(item => h('div', { key: item.id, className: 'ptcPlusCapabilityItem', role: 'row',
               'data-selected': entry?.id === item.id, 'data-availability': item.availability,
               onClick: () => setSelected(item.id) },
-              h('div', { className: 'ptcPlusCapabilityIdentity', role: 'cell' }, h('span', { className: 'ptcPlusCapabilityName' }, item.name), h('code', null, item.id)),
+              h('div', { className: 'ptcPlusCapabilityIdentity', role: 'cell' },
+                h('input', { type: 'checkbox', className: 'ptcPlusPick', checked: pickedIds.includes(item.id),
+                  'aria-label': t('capabilities.selectForBatch', { name: item.name ?? item.id }),
+                  onClick: event => event.stopPropagation(), onChange: () => togglePick(item.id) }),
+                h('div', { className: 'ptcPlusCapabilityIdentityText' },
+                  h('span', { className: 'ptcPlusCapabilityName' }, item.name), h('code', null, item.id))),
               h('span', { className: 'ptcPlusCapabilityBadge', role: 'cell', 'data-kind': type(item) }, t(`capabilities.type.${type(item)}`)),
               h('span', { className: 'ptcPlusCapabilitySource', role: 'cell' }, displayedSource(item)),
               // The cell stays a plain cell so its empty area selects the row; only the switch and
@@ -865,17 +963,375 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
     event.currentTarget.parentElement.querySelectorAll('[role=tab]')[next].focus({ preventScroll: true })
   }
 
+  /**
+   * Per-asset editor for the fixed prompt text the plugin writes.
+   *
+   * One row per registered asset: the built-in sentence stays visible as the
+   * placeholder, so a user compares against it instead of a blank box. The
+   * document is written through the normal settings path, which validates it;
+   * a document the panel cannot read is reported here instead of blanking the
+   * whole workbench.
+   */
+  // Registry codes are protocol identifiers. The pane shows a localized label and
+  // keeps the raw code in the element title, so a Chinese UI never reads like a
+  // dump of `fact-derived` / `protocol-exact-text` constants.
+  const PROMPT_REASON_KEYS = Object.freeze({
+    'fact-derived': 'factDerived',
+    'aggregate-frozen': 'aggregateFrozen',
+    'protocol-exact-text': 'protocolExactText',
+    'protocol-structural': 'protocolStructural',
+    'shadows-host': 'shadowsHost',
+    'other-owner': 'otherOwner',
+  })
+
+  function promptReasonLabel(t, reason) {
+    const key = PROMPT_REASON_KEYS[reason]
+    return key === undefined ? reason : t(`capabilities.prompt.reason.${key}`)
+  }
+
+  function promptKindLabel(t, kind) {
+    return kind === undefined ? '' : t(`capabilities.prompt.kind.${kind}`)
+  }
+
+  function PromptTextSettings({ value, disabled, onChange, t, id }) {
+    let document
+    let readError
+    try {
+      document = parsePromptTextDocument(value.promptText)
+    } catch (error) {
+      readError = error.message
+      document = { schema: PROMPT_TEXT_SCHEMA, overrides: {} }
+    }
+    // The workbench receives `disabled` as a per-field predicate, not a boolean.
+    // The feature's own pause switch is separate from the settings lock: off means
+    // every channel falls back to the built-in text while the saved document stays.
+    const paused = value.capabilityPromptTextEnabled === false
+    const blocked = paused || disabled === true
+      || (typeof disabled === 'function' && disabled('promptText') === true)
+    const resolved = resolvePromptText(value.promptText)
+    const account = accountPromptText(resolved)
+    // The pane stages edits in a draft and writes the document once, so the fields
+    // and the preview always describe the same pending bytes. 保存 writes the draft;
+    // 取消 drops it; a saved document still differs from the built-ins, so reopening
+    // the pane shows that difference without a draft.
+    const [draft, setDraft] = React.useState(null)
+    const [selectedAnchorId, setSelectedAnchorId] = React.useState(null)
+    const anchorPanelRef = React.useRef(null)
+    const [openSlots, setOpenSlots] = React.useState({})
+    const overrides = draft ?? document.overrides
+    const byteCount = text => new TextEncoder().encode(text).length
+    const group = number => String(Math.round(number)).replace(/\B(?=(\d{3})+(?!\d))/gu, ' ')
+    const bytePair = bytes => t('capabilities.prompt.bytesPair', {
+      bytes: group(bytes), kb: (bytes / 1024).toFixed(1),
+    })
+    const write = next => onChange(CONFIG_FIELDS.find(field => field.key === 'promptText'),
+      JSON.stringify({ schema: PROMPT_TEXT_SCHEMA, overrides: next }))
+    const update = (slotId, next) => {
+      const base = { ...overrides }
+      if (next === undefined) delete base[slotId]
+      else base[slotId] = next
+      setDraft(base)
+    }
+    const save = () => {
+      if (draft === null) return
+      write(draft)
+      setDraft(null)
+    }
+    const cancel = () => setDraft(null)
+    const pending = draft !== null
+    const unmeasuredSlots = account.counts.unmeasuredSlots
+    const dynamicSlots = account.counts.dynamicSlots
+    const unwiredAnchors = account.anchors.filter(anchor => anchor.wired !== true)
+    const measuredBytes = account.owners.A + account.owners.B + account.owners.C
+    const ownerOf = anchor => (anchor.owner === 'mixed' ? 'mixed' : anchor.owner)
+    const ownerAnchors = key => account.anchors.filter(anchor => ownerOf(anchor) === key).length
+    // Icons are monochrome inline SVG: the mockup's cards carry a glyph, and an
+    // icon font or an emoji would bring its own colour into the settings surface.
+    const icon = path => h('svg', {
+      viewBox: '0 0 20 20', width: 16, height: 16, fill: 'none', stroke: 'currentColor',
+      'stroke-width': 1.6, 'stroke-linecap': 'round', 'stroke-linejoin': 'round', 'aria-hidden': 'true',
+    }, ...path.map((d, index) => h('path', { key: index, d })))
+    const card = (key, labelKey, glyph) => {
+      const mixed = key === 'mixed'
+      const bytes = account.owners[key] ?? 0
+      const value_ = mixed
+        ? t('capabilities.prompt.cardMixed', { count: ownerAnchors('mixed') })
+        : bytes > 0
+          ? `${bytePair(bytes)} · ${t('capabilities.prompt.cardMetaAnchors', { count: ownerAnchors(key) })}`
+          : t('capabilities.prompt.cardMetaAnchors', { count: ownerAnchors(key) })
+      return h('div', { key, className: 'ptcPlusPromptCard', 'data-owner': key },
+        h('span', { className: 'ptcPlusPromptCardIcon' }, glyph),
+        h('span', { className: 'ptcPlusPromptCardBody' },
+          h('span', { className: 'ptcPlusPromptCardLabel' }, t(labelKey)),
+          mixed
+            ? h('span', { className: 'ptcPlusPromptCardMeta' }, value_)
+            : h('span', { className: 'ptcPlusPromptCardValue', 'data-owner-bytes': String(account.owners[key] ?? 0) }, value_)))
+    }
+    const cards = h('div', { className: 'ptcPlusPromptCards' },
+      card('A', 'capabilities.prompt.ownerEditable', icon(['M4 16h3l9-9-3-3-9 9v3Z', 'M12.5 4.5 15.5 7.5'])),
+      card('B', 'capabilities.prompt.ownerReadOnly', icon(['M5.5 9V6.5a4.5 4.5 0 0 1 9 0V9', 'M4.5 9h11v7h-11Z'])),
+      card('C', 'capabilities.prompt.ownerOther', icon(['M10 10a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z', 'M4 17c0-3 2.7-5 6-5s6 2 6 5'])),
+      card('mixed', 'capabilities.prompt.ownerMixed', icon(['M4 6h12', 'M4 10h12', 'M4 14h12', 'M13 4v4', 'M7 8v4'])))
+    const strip = h('p', { className: 'ptcPlusPromptStrip', 'data-prompt-strip': String(unwiredAnchors.length) },
+      t('capabilities.prompt.strip', {
+        anchors: unwiredAnchors.length, bytes: group(measuredBytes),
+        kb: (measuredBytes / 1024).toFixed(1), total: account.counts.total,
+      }))
+    const reasonsOf = anchor => {
+      const reasons = [...new Set(anchor.slots.map(slot => slot.reason).filter(Boolean))]
+      return reasons.length === 0 ? '—' : reasons.map(reason => promptReasonLabel(t, reason)).join(' + ')
+    }
+    const kindsOf = anchor => [...new Set(anchor.slots.map(slot => slot.kind))]
+      .map(kind => promptKindLabel(t, kind)).join(' + ')
+    const splitOf = anchor => {
+      const measured = anchor.slots.filter(slot => slot.measured === true && slot.bytes > 0)
+      return measured.length > 1
+        ? t('capabilities.prompt.anchorBytesSplit', {
+          parts: measured.map(slot => `${slot.slotId.split('.').pop()} ${slot.bytes}`).join(' / '),
+        })
+        : null
+    }
+    const select = anchorId => setSelectedAnchorId(anchorId)
+    // The expanded panel sits below the table, so on a short viewport selecting a
+    // lower row would otherwise leave the editor it opened off-screen.
+    React.useEffect(() => {
+      if (selectedAnchorId === null) return
+      const node = anchorPanelRef.current
+      if (node === null || typeof node.scrollIntoView !== 'function') return
+      node.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
+    }, [selectedAnchorId])
+    const rowKey = (event, anchorId) => {
+      if (event.key !== 'Enter' && event.key !== ' ') return
+      event.preventDefault()
+      select(anchorId)
+    }
+    const anchorRow = (anchor, index) => {
+      const split = splitOf(anchor)
+      return h('tr', {
+        key: anchor.anchorId,
+        className: 'ptcPlusPromptRow',
+        'data-anchor-id': anchor.anchorId,
+        'data-wired': anchor.wired === true ? 'true' : 'false',
+        // A plain <table> row cannot carry aria-selected (that needs role="grid"),
+        // so the expanded row is announced with aria-current instead.
+        'data-selected': selectedAnchorId === anchor.anchorId ? 'true' : 'false',
+        'aria-current': selectedAnchorId === anchor.anchorId ? 'true' : undefined,
+        tabIndex: 0,
+        onClick: () => select(anchor.anchorId),
+        onKeyDown: event => rowKey(event, anchor.anchorId),
+      },
+        h('td', { className: 'ptcPlusPromptIndex' }, String(index)),
+        h('td', null, h('span', { className: 'ptcPlusPromptChannel', 'data-channel': anchor.channel }, anchor.channel)),
+        h('td', null, h('code', { className: 'ptcPlusPromptAnchorId', title: anchor.anchorId }, anchor.anchorId)),
+        h('td', null, h('span', { className: 'ptcPlusPromptPresence', title: t(anchor.presence) }, t(anchor.presence))),
+        h('td', { className: 'ptcPlusPromptBytesCell' },
+          anchor.wired !== true
+            ? h('span', { 'data-anchor-bytes': 'unwired' }, t('capabilities.prompt.unwiredRow', { slots: anchor.unmeasuredSlots }))
+            : h('span', { 'data-anchor-bytes': String(anchor.bytes) },
+              paused ? t('capabilities.prompt.pausedBytes', { bytes: anchor.bytes }) : t('capabilities.prompt.cardBytes', { bytes: anchor.bytes }),
+              split === null ? null : h('small', { className: 'ptcPlusPromptSplit', 'data-anchor-split': 'true' }, split))),
+        h('td', { className: 'ptcPlusPromptReasonCell' }, reasonsOf(anchor)),
+        h('td', { className: 'ptcPlusPromptKindCell' }, kindsOf(anchor),
+          anchor.wired !== true ? h('span', { className: 'ptcPlusPromptTag', 'data-prompt-unwired-tag': 'true' },
+            t('capabilities.prompt.unwiredTag')) : null))
+    }
+    const hostRow = (section, index) => h('tr', {
+      key: section.id, className: 'ptcPlusPromptRow ptcPlusPromptHostRow', 'data-host-row': section.id,
+    },
+      h('td', { className: 'ptcPlusPromptIndex' }, String(index)),
+      h('td', null, h('span', { className: 'ptcPlusPromptChannel' }, 'prompt')),
+      h('td', null, h('code', { className: 'ptcPlusPromptAnchorId', title: section.id }, section.id)),
+      h('td', null, h('span', { className: 'ptcPlusPromptPresence' }, t(section.presence))),
+      h('td', { className: 'ptcPlusPromptBytesCell' }, t('capabilities.prompt.hostUnavailable')),
+      h('td', { className: 'ptcPlusPromptReasonCell' }, '—'),
+      h('td', { className: 'ptcPlusPromptKindCell' }, t('capabilities.prompt.ownerHost')))
+    const table = h('table', { className: 'ptcPlusPromptTable' },
+      h('colgroup', null,
+        h('col', { className: 'ptcPlusPromptColIndex' }),
+        h('col', { className: 'ptcPlusPromptColChannel' }),
+        h('col', { className: 'ptcPlusPromptColAnchor' }),
+        h('col', { className: 'ptcPlusPromptColPresence' }),
+        h('col', { className: 'ptcPlusPromptColBytes' }),
+        h('col', { className: 'ptcPlusPromptColReason' }),
+        h('col', { className: 'ptcPlusPromptColKind' })),
+      h('thead', null, h('tr', null,
+        h('th', { scope: 'col', className: 'ptcPlusPromptIndex' }, ''),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnChannel')),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnAnchor')),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnPresence')),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnBytesSplit')),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnReason')),
+        h('th', { scope: 'col' }, t('capabilities.prompt.columnKind')))),
+      h('tbody', null,
+        ...account.anchors.map((anchor, index) => anchorRow(anchor, index + 1)),
+        ...HOST_CONTEXT_SECTIONS.map((section, index) => hostRow(section, account.anchors.length + index + 1))))
+    const chip = (anchor, slot) => {
+      const templateBytes = slot.measured === true && slot.kind === 'projected'
+      const aggregateSet = slot.kind === 'aggregate'
+      const shared = {
+        className: 'ptcPlusPromptChip',
+        'data-slot-id': slot.slotId,
+        'data-slot-kind': slot.kind,
+        ...(templateBytes ? { 'data-prompt-template-bytes': 'true' } : {}),
+        ...(aggregateSet ? { 'data-prompt-aggregate-set': 'true' } : {}),
+        title: templateBytes
+          ? `${slot.slotId} · ${t('capabilities.prompt.templateBytes')}`
+          : aggregateSet ? `${slot.slotId} · ${t('capabilities.prompt.aggregateFrozen')}` : slot.slotId,
+      }
+      if (slot.owner !== 'A') {
+        return h('span', { key: slot.slotId, ...shared, 'data-readonly': 'true' },
+          h('span', { className: 'ptcPlusPromptChipLabel' }, slot.slotId),
+          h('span', { className: 'ptcPlusPromptChipNote' },
+            t('capabilities.prompt.readonlyReason', { reason: promptReasonLabel(t, slot.reason), kind: promptKindLabel(t, slot.kind) })))
+      }
+      const selected = (openSlots[anchor.anchorId] ?? editableSlots(anchor)[0]?.slotId) === slot.slotId
+      return h('button', {
+        key: slot.slotId,
+        ...shared,
+        type: 'button',
+        disabled: blocked,
+        'aria-pressed': selected,
+        onClick: () => setOpenSlots(previous => ({ ...previous, [anchor.anchorId]: slot.slotId })),
+      }, h('span', { className: 'ptcPlusPromptChipLabel' }, slot.slotId))
+    }
+    // One editor per anchor: the chips choose which editable slot is open, so the
+    // run_code anchor keeps its three descriptions behind one field.
+    const editableSlots = anchor => anchor.slots.filter(slot => slot.owner === 'A'
+      && PROMPT_ASSETS.find(candidate => candidate.id === slot.slotId)?.defaultText !== null)
+    const editorFor = anchor => {
+      const slots = editableSlots(anchor)
+      if (anchor.wired !== true || slots.length === 0) return null
+      const selectedId = openSlots[anchor.anchorId] ?? slots[0].slotId
+      const slot = slots.find(candidate => candidate.slotId === selectedId) ?? slots[0]
+      const asset = PROMPT_ASSETS.find(candidate => candidate.id === slot.slotId)
+      const override = Object.hasOwn(overrides, slot.slotId) ? overrides[slot.slotId] : undefined
+      const current = override ?? asset.defaultText
+      // The built-in sentence is the field's value, not a placeholder: the user must be
+      // able to tweak the shipped wording without retyping it.
+      return h('div', { key: slot.slotId, className: 'ptcPlusPromptEditor', 'data-editor-slot': slot.slotId },
+        h('textarea', {
+          id: `${id}-prompt-${slot.slotId}`, rows: 3, disabled: blocked, spellCheck: false,
+          className: 'ptcPlusPromptTextarea', 'aria-label': slot.slotId, value: current,
+          onChange: event => update(slot.slotId, event.target.value === '' ? undefined : event.target.value),
+        }),
+        h('div', { className: 'ptcPlusPromptEditorFoot' },
+          h('span', { className: 'ptcPlusPromptHint' },
+            t('capabilities.prompt.bytesOfLimit', { used: byteCount(current), max: PROMPT_TEXT_MAX_SLOT_BYTES })),
+          h('span', { className: 'ptcPlusPromptEditorActions' },
+            asset.omittable ? h('button', {
+              type: 'button', className: 'ptcPlusButton', disabled: blocked,
+              onClick: () => update(slot.slotId, ''),
+            }, t('capabilities.prompt.omit')) : null,
+            h('button', {
+              type: 'button', className: 'ptcPlusButton', disabled: blocked || override === undefined,
+              onClick: () => update(slot.slotId, undefined),
+            }, t('capabilities.prompt.reset')))))
+    }
+    const defaultAnchor = account.anchors.find(anchor => anchor.wired === true && editableSlots(anchor).length > 0)
+    const selectedAnchor = account.anchors.find(anchor => anchor.anchorId === selectedAnchorId) ?? defaultAnchor
+    const selectedIndex = selectedAnchor === undefined ? 0 : account.anchors.indexOf(selectedAnchor) + 1
+    const anchorPanel = h('section', { className: 'ptcPlusPromptPanel', 'data-prompt-panel': 'anchor', ref: anchorPanelRef },
+      h('h5', { className: 'ptcPlusPromptPanelTitle' },
+        t('capabilities.prompt.rowExpand', { index: selectedIndex })),
+      selectedAnchor === undefined
+        ? h('p', { className: 'ptcPlusPromptHint' }, t('capabilities.prompt.rowExpandHint'))
+        : h('div', { className: 'ptcPlusPromptPanelBody' },
+          h('div', { className: 'ptcPlusPromptChips', 'data-anchor-chips': selectedAnchor.anchorId },
+            ...selectedAnchor.slots.map(slot => chip(selectedAnchor, slot))),
+          selectedAnchor.wired !== true
+            ? h('p', { className: 'ptcPlusPromptHint' }, t('capabilities.prompt.unwiredRow', { slots: selectedAnchor.unmeasuredSlots }))
+            : editorFor(selectedAnchor)))
+    // Saving shows what will change. The preview is derived from the same draft the
+    // editors write, so it cannot disagree with them; a saved document that already
+    // differs from the built-ins shows here too, because saving would rewrite it.
+    const changes = account.anchors.flatMap(anchor => anchor.slots
+      .map(slot => ({ slot, builtin: PROMPT_ASSETS.find(asset => asset.id === slot.slotId)?.defaultText }))
+      .filter(entry => typeof entry.builtin === 'string'
+        && Object.hasOwn(overrides, entry.slot.slotId)
+        && overrides[entry.slot.slotId] !== entry.builtin)
+      .map(entry => {
+        const effective = overrides[entry.slot.slotId]
+        const effect = anchor.channel === 'plan' ? t('capabilities.prompt.effectPlan')
+          : anchor.channel === 'install' ? t('capabilities.prompt.effectInstall')
+            : anchor.channel === 'prompt' ? t('capabilities.prompt.effectPrompt')
+              : t('capabilities.prompt.effectTrigger')
+        return {
+          anchor, slot: entry.slot, effect,
+          before: byteCount(entry.builtin), after: byteCount(effective), delta: byteCount(effective) - byteCount(entry.builtin),
+        }
+      }))
+    const restoreSlot = slotId => update(slotId, undefined)
+    const diffPanel = h('section', {
+      className: 'ptcPlusPromptPanel',
+      ...(changes.length === 0 ? {} : { 'data-prompt-diff': 'true' }),
+      'data-prompt-diff-panel': 'true',
+    },
+      h('h5', { className: 'ptcPlusPromptPanelTitle' }, t('capabilities.prompt.diffTitle')),
+      changes.length === 0
+        ? h('p', { className: 'ptcPlusPromptHint' }, t('capabilities.prompt.diffEmpty'))
+        : h('ul', { className: 'ptcPlusPromptDiffList' },
+          ...changes.map((entry, index) => h('li', {
+            key: entry.slot.slotId, className: 'ptcPlusPromptDiffRow',
+            'data-diff-anchor': entry.anchor.anchorId, 'data-diff-slot': entry.slot.slotId,
+          },
+            h('span', { className: 'ptcPlusPromptDot', 'data-tone': String(index % 3) }),
+            h('span', { className: 'ptcPlusPromptDiffBody' },
+              h('span', { className: 'ptcPlusPromptDiffHead' },
+                h('code', { className: 'ptcPlusPromptDiffSlot' }, entry.slot.slotId),
+                h('span', { className: 'ptcPlusPromptHint' }, entry.effect)),
+              h('span', { className: 'ptcPlusPromptDiffDelta' },
+                t('capabilities.prompt.diffBytes', {
+                  before: group(entry.before), after: group(entry.after),
+                  delta: entry.delta > 0 ? `+${group(entry.delta)}` : group(entry.delta),
+                }),
+                h('button', {
+                  type: 'button', className: 'ptcPlusButton', disabled: blocked,
+                  onClick: () => restoreSlot(entry.slot.slotId),
+                }, t('capabilities.prompt.reset'))))))),
+      h('div', { className: 'ptcPlusPromptActions' },
+        h('button', {
+          type: 'button', className: 'ptcPlusButton', 'data-kind': 'primary', disabled: blocked || !pending,
+          onClick: save,
+        }, t('capabilities.prompt.save')),
+        h('button', { type: 'button', className: 'ptcPlusButton', disabled: blocked || !pending, onClick: cancel },
+          t('capabilities.prompt.cancel'))))
+    return h('section', {
+      className: 'ptcPlusPromptText', 'data-prompt-paused': paused ? 'true' : 'false',
+    },
+      h('header', { className: 'ptcPlusPromptHeader' },
+        h('span', { className: 'ptcPlusPromptHeaderIcon' }, icon(['M10 2.5 12 8l5.5 2-5.5 2-2 5.5-2-5.5L2.5 10 8 8Z'])),
+        h('span', { className: 'ptcPlusPromptHeaderBody' },
+          h('h4', { className: 'ptcPlusPromptTitle' }, t('capabilities.prompt.title')),
+          h('p', { className: 'ptcPlusPromptSubtitle' }, t('capabilities.prompt.subtitle')))),
+      paused
+        ? h('p', { className: 'ptcPlusPromptPaused', role: 'status', 'data-prompt-paused-notice': 'true' },
+          t('capabilities.prompt.paused'))
+        : null,
+      readError === undefined ? null : h('p', { className: 'ptcPlusPromptHint' }, t('capabilities.prompt.unreadable', { error: readError })),
+      ...resolved.reported.map((entry, index) => h('p', { key: `report-${index}`, className: 'ptcPlusPromptHint' },
+        t('capabilities.prompt.reported', {
+          asset: entry.slotId ?? entry.anchorId ?? 'document', reason: entry.reason,
+        }))),
+      cards,
+      strip,
+      h('p', { className: 'ptcPlusPromptHint', 'data-prompt-slot-counts': 'true' },
+        t('capabilities.prompt.slotCounts', { bytes: group(measuredBytes), unmeasured: unmeasuredSlots, dynamic: dynamicSlots })),
+      table,
+      h('div', { className: 'ptcPlusPromptPanels' }, anchorPanel, diffPanel),
+      h('p', { className: 'ptcPlusPromptIntro' }, t('capabilities.prompt.intro')))
+  }
+
   function CapabilityWorkbench({ value, configurationReady, catalog, catalogError, plans, plansError, plansPending, plansStale, disabled, onChange, onReload, t, renderField, renderPlans, renderRefresh, id, selectedSessionId, onSessionSelect,
     allocation, allocationError, allocationPending, onApplyConfiguration, configurationWritable, saving, saveStatus }) {
     const [tab, setTab] = React.useState('manual')
     const [contextSection, setContextSection] = React.useState('description')
-    const tabs = ['manual', 'budgets', 'statistics', 'plans']
+    const tabs = ['manual', 'budgets', 'statistics', 'prompt', 'plans']
     const feedback = saving ? t('state.syncing') : saveStatus && saveStatus.key !== 'status.applied' ? t(saveStatus.key, saveStatus.params)
       : t(configurationWritable ? 'capabilities.savedForNew' : 'footer.readOnly')
     return h('div', { className: 'ptcPlusCapabilityWorkbench' },
       h(CombinationSummary, { value, configurationReady, plans, plansError, plansPending, plansStale, selectedSessionId,
         feedback, onReload, renderRefresh, renderPlans, t, id, onNavigate: key => {
-          setTab(key === 'rules' ? 'manual' : key === 'statistics' ? 'statistics' : 'budgets')
+          setTab(key === 'rules' ? 'manual' : key === 'statistics' ? 'statistics' : key === 'promptText' ? 'prompt' : 'budgets')
           if (['description', 'recovery', 'preview'].includes(key)) setContextSection(key)
         } }),
       h('div', { className: 'ptcPlusCapabilityTabs', role: 'tablist', 'aria-label': t('capabilities.settingsTabs') },
@@ -885,7 +1341,7 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
         }, t(`capabilities.tab.${key}`)))),
       ...tabs.map(key => h('div', { key, className: 'ptcPlusCapabilityPane', role: 'tabpanel', id: `${id}-pane-${key}`,
         'aria-labelledby': `${id}-tab-${key}`, hidden: tab !== key },
-        h('div', { className: 'ptcPlusTaskHead' }, h('h4', null, t(`capabilities.title.${key}`)),
+        key === 'prompt' ? null : h('div', { className: 'ptcPlusTaskHead' }, h('h4', null, t(`capabilities.title.${key}`)),
           key === 'manual' ? h('label', { className: 'ptcPlusCapabilityManagement' }, h('span', null, t('capabilities.management')),
             h('input', { type: 'checkbox', role: 'switch', className: 'ptcPlusCheck', checked: value.capabilityManagementEnabled === true,
               disabled: disabled('capabilityManagementEnabled'), 'aria-label': t('capabilities.management'),
@@ -902,7 +1358,10 @@ export function createCapabilitySettingsViews(React, { SearchIcon, Select, Modal
             h(AllocationEvidence, { allocation, allocationError, allocationPending, selectedSessionId, statistics: true, onReload, t }))
             : key === 'budgets' ? h(ContextSettings, { value, configurationReady, disabled, onChange, t, renderField, allocation, allocationError, allocationPending,
               selectedSessionId, onReload, renderRefresh, id, section: contextSection, setSection: setContextSection })
-              : h(ConfigurationProfiles, { value, plans, disabled, writable: configurationWritable, onChange, onApplyConfiguration, t }))))
+              // Rendered only while its tab is active: eight idle textareas in a hidden
+              // pane would change every generic textbox query in the settings card.
+              : key === 'prompt' ? (tab === 'prompt' ? h(PromptTextSettings, { value, disabled, onChange, t, id }) : null)
+                : h(ConfigurationProfiles, { value, plans, disabled, writable: configurationWritable, onChange, onApplyConfiguration, t }))))
   }
 
   return { CapabilityWorkbench }
@@ -973,9 +1432,13 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
     const available = React.useSyncExternalStore(source.subscribe, source.getSnapshot)
     const [catalog, setCatalog] = React.useState([])
     const [management, setManagement] = React.useState('unknown')
+    const [savedSettings, setSavedSettings] = React.useState(null)
     const [loading, setLoading] = React.useState(false)
     const [error, setError] = React.useState(null)
     const [drafts, setDrafts] = React.useState(emptyDrafts)
+    const [picked, setPicked] = React.useState([])
+    const [batchOpen, setBatchOpen] = React.useState(false)
+    const [batchChoices, setBatchChoices] = React.useState({ availability: 'keep', disclosure: 'keep' })
     const [selectedId, setSelectedId] = React.useState(null)
     const [pane, setPane] = React.useState('list')
     const [query, setQuery] = React.useState('')
@@ -1009,7 +1472,10 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
       applying.current = false
       setCatalog([])
       setManagement('unknown')
+      setSavedSettings(null)
       setDrafts(emptyDrafts())
+      setPicked([])
+      setBatchOpen(false)
       setSelectedId(null)
       setPane('list')
       setFocusDimension(null)
@@ -1026,8 +1492,11 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
           throw new Error('Invalid capability catalog')
         }
         setCatalog(payload.entries)
+        setPicked(current => current.filter(id => payload.entries.some(entry => entry.id === id)))
         setManagement(['managed', 'paused', 'off', 'unknown'].includes(payload.management)
           ? payload.management : 'unknown')
+        setSavedSettings(payload.savedSettings !== null && typeof payload.savedSettings === 'object'
+          && !Array.isArray(payload.savedSettings) ? payload.savedSettings : null)
         setError(null)
         return payload.entries
       } catch (failure) {
@@ -1038,24 +1507,24 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
     }, [sessionId])
     React.useEffect(() => {
       if (!open || !enabled || !available) {
-        request.current?.abort(); request.current = null; setLoading(false); return
+        if (!applying.current) { request.current?.abort(); request.current = null }
+        setLoading(false)
+        return
       }
+      // An in-flight apply owns the shared catalog request and reloads it on completion.
+      if (applying.current) return
       const controller = new AbortController()
       request.current = controller
       void load(controller.signal)
       return () => { controller.abort(); if (request.current === controller) request.current = null }
     }, [open, enabled, available, load])
-    React.useEffect(() => {
-      if (!enabled || !available) {
-        request.current?.abort()
-        request.current = null
-        applying.current = false
-        setPending(false)
-      }
-    }, [enabled, available])
     const choices = drafts
     const choiceFor = entry => choices[entry.id] ?? entry.temporary ?? 'inherit'
-    const writesBlocked = management === 'paused' || management === 'off'
+    // Session writes also require the saved configuration to keep capability
+    // management and context on; a frozen managed session cannot be edited
+    // while the current settings have them off.
+    const savedBlocks = savedSettings !== null && (savedSettings.enabled === false || savedSettings.contextEnabled === false)
+    const writesBlocked = management === 'paused' || management === 'off' || savedBlocks
     const sourceKey = entry => entry.source?.kind === 'mcp' ? 'mcp:' + (entry.source.server ?? '')
       : entry.source?.kind === 'skill' ? 'skill:' + (entry.source.bucket ?? '')
         : entry.source?.kind ?? 'unknown'
@@ -1109,26 +1578,51 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
       ?? ['tools', 'skills', 'mcp', 'mcp_tools'].map(group => matches.find(entry => category(entry) === group)).find(Boolean)
     const staged = Object.entries(choices).flatMap(([id, choice]) => typeof choice === 'object'
       ? Object.entries(choice).map(([dimension, selection]) => [id, selection, dimension]) : [[id, choice]])
-    const chooseDimension = (id, dimension, choice) => {
-      setDrafts(current => {
-        const patch = typeof current[id] === 'object' ? { ...current[id] } : {}
-        const original = catalog.find(entry => entry.id === id)?.temporaryRule?.[dimension] ?? 'inherit'
-        if (choice === original && choice === 'inherit') delete patch[dimension]
+    const pickedRows = picked.map(id => catalog.find(entry => entry.id === id)).filter(Boolean)
+    const allMatchesPicked = matches.length > 0 && matches.every(entry => picked.includes(entry.id))
+    const someMatchesPicked = matches.some(entry => picked.includes(entry.id))
+    const togglePick = id => setPicked(current => current.includes(id) ? current.filter(item => item !== id) : [...current, id])
+    const toggleAllMatches = () => setPicked(current => allMatchesPicked
+      ? current.filter(id => !matches.some(entry => entry.id === id))
+      : [...new Set([...current, ...matches.map(entry => entry.id)])])
+    // One staging rule for single and batch edits: an item keeps one temporary
+    // patch, "inherit" removes the dimension and reselecting the stored choice
+    // never dirties the draft.
+    const stageDimension = (current, entry, dimension, choice) => {
+      const next = { ...current }
+      const patch = typeof next[entry.id] === 'object' && next[entry.id] !== null ? { ...next[entry.id] } : {}
+      const original = storedDimension(entry, dimension) ?? 'inherit'
+      const selectedChoice = patch[dimension] ?? original
+      if (choice !== selectedChoice) {
+        if (choice === original) delete patch[dimension]
         else patch[dimension] = choice
-        const next = { ...current }; if (Object.keys(patch).length) next[id] = patch; else delete next[id]; return next
-      })
+      }
+      if (Object.keys(patch).length) next[entry.id] = patch; else delete next[entry.id]
+      return next
+    }
+    const chooseDimension = (id, dimension, choice) => {
+      const entry = catalog.find(item => item.id === id)
+      if (entry) setDrafts(current => stageDimension(current, entry, dimension, choice))
     }
     const choose = (id, next) => {
       const entry = catalog.find(item => item.id === id)
       if (!entry) return
       const original = entry.temporary ?? 'inherit'
+      if (next === (choices[id] ?? original)) return
       setDrafts(current => {
         const nextChoices = { ...current }
-        if (next === original && next === 'inherit') delete nextChoices[id]
+        if (next === original) delete nextChoices[id]
         else nextChoices[id] = next
         return nextChoices
       })
     }
+    const stageBatch = (ids, selections) => setDrafts(current => ids.reduce((draft, id) => {
+      const entry = catalog.find(item => item.id === id)
+      if (!entry) return draft
+      return ['availability', 'disclosure'].reduce((next, dimension) =>
+        selections[dimension] === undefined || selections[dimension] === 'keep'
+          ? next : stageDimension(next, entry, dimension, selections[dimension]), draft)
+    }, current))
     const hasInheritanceReset = staged.some(([, selection]) => selection === 'inherit')
     const apply = async targetScope => {
       if (applying.current || !enabled || !available || writesBlocked || staged.length === 0) return
@@ -1140,58 +1634,71 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
       const controller = new AbortController()
       request.current?.abort()
       request.current = controller
-      let completed = 0
-      let pendingCount = 0
-      let failure = null
-      let savedOnly = null
-      for (const [id, selection, dimension] of staged) {
-        if (controller.signal.aborted) break
-        try {
-          const result = await commands.run(sessionId, `set ${targetScope} ${encodeURIComponent(id)} ${dimension ? dimension + ' ' : ''}${selection}`, controller.signal)
-          const receipt = readCapabilityCommandReceipt(result.text)
-          if (!receipt || receipt.sessionId !== sessionId || !['recorded', 'pending'].includes(receipt.state)) {
-            throw new Error(receipt ? capabilityCommandText(t, result.text) : t('capabilities.quick.unknownReceipt'))
+      // One owner releases the shared request slot and the pending state on every exit path, so a
+      // closed, superseded or failed apply cannot strand the workbench in "applying".
+      const finish = () => {
+        if (request.current === controller) request.current = null
+        applying.current = false
+        if (mounted.current) setPending(false)
+      }
+      try {
+        let completed = 0
+        let pendingCount = 0
+        let failure = null
+        let savedOnly = null
+        for (const [id, selection, dimension] of staged) {
+          if (controller.signal.aborted) break
+          try {
+            const result = await commands.run(sessionId, `set ${targetScope} ${encodeURIComponent(id)} ${dimension ? dimension + ' ' : ''}${selection}`, controller.signal)
+            const receipt = readCapabilityCommandReceipt(result.text)
+            if (!receipt || receipt.sessionId !== sessionId || !['recorded', 'pending'].includes(receipt.state)) {
+              throw new Error(receipt ? capabilityCommandText(t, result.text) : t('capabilities.quick.unknownReceipt'))
+            }
+            if (receipt?.state === 'pending') pendingCount += 1
+            completed += 1
+          } catch (cause) {
+            failure = String(cause?.message ?? cause)
+            savedOnly = readCapabilityCommandReceipt(failure)?.state === 'saved-only'
+              ? readCapabilityCommandReceipt(failure) : null
+            break
           }
-          if (receipt?.state === 'pending') pendingCount += 1
-          completed += 1
-        } catch (cause) {
-          failure = String(cause?.message ?? cause)
-          savedOnly = readCapabilityCommandReceipt(failure)?.state === 'saved-only'
-            ? readCapabilityCommandReceipt(failure) : null
-          break
         }
+        if (request.current !== controller || controller.signal.aborted || !mounted.current) return
+        const refreshed = await load(controller.signal)
+        if (request.current !== controller || controller.signal.aborted || !mounted.current) return
+        const confirmed = refreshed ? staged.slice(0, completed).filter(([id, selection, dimension]) => {
+          const entry = refreshed.find(item => item.id === id)
+          if (dimension) return entry && (targetScope === 'session'
+            ? (entry.temporaryRule?.[dimension] ?? 'inherit') === selection
+            : (entry.savedRule?.[dimension] ?? 'automatic') === selection && entry.temporaryRule?.[dimension] === undefined)
+          return entry && (targetScope === 'session' ? entry.temporary === selection
+            : entry.saved === selection && entry.temporary === 'inherit')
+        }) : []
+        setDrafts(current => {
+          const nextChoices = { ...current }
+          for (const [id, selection, dimension] of confirmed) {
+            if (savedOnly && id === staged[completed]?.[0] && dimension === staged[completed]?.[2]) continue
+            if (dimension) {
+              if (nextChoices[id]?.[dimension] !== submitted[id]?.[dimension]) continue
+              const patch = { ...nextChoices[id] }; delete patch[dimension]
+              if (Object.keys(patch).length) nextChoices[id] = patch; else delete nextChoices[id]
+            } else if (nextChoices[id] === submitted[id]) delete nextChoices[id]
+          }
+          return nextChoices
+        })
+        if (savedOnly) setStatus({ key: 'capabilities.quick.savedOnly', params: { count: completed, error: savedOnly.error ?? '' } })
+        else if (failure || !refreshed || confirmed.length < completed) setStatus({ key: 'capabilities.quick.partial',
+          params: { count: confirmed.length, error: failure ?? t('capabilities.quick.confirmationUnavailable') } })
+        else setStatus({ key: pendingCount ? 'capabilities.quick.pendingApplied' : 'capabilities.quick.applied', params: { count: completed } })
+      } finally {
+        finish()
       }
-      if (request.current !== controller || controller.signal.aborted || !mounted.current) return
-      const refreshed = await load(controller.signal)
-      if (request.current !== controller || controller.signal.aborted || !mounted.current) return
-      const confirmed = refreshed ? staged.slice(0, completed).filter(([id, selection, dimension]) => {
-        const entry = refreshed.find(item => item.id === id)
-        if (dimension) return entry && (targetScope === 'session'
-          ? (entry.temporaryRule?.[dimension] ?? 'inherit') === selection
-          : (entry.savedRule?.[dimension] ?? 'automatic') === selection && entry.temporaryRule?.[dimension] === undefined)
-        return entry && (targetScope === 'session' ? entry.temporary === selection
-          : entry.saved === selection && entry.temporary === 'inherit')
-      }) : []
-      setDrafts(current => {
-        const nextChoices = { ...current }
-        for (const [id, selection, dimension] of confirmed) {
-          if (savedOnly && id === staged[completed]?.[0] && dimension === staged[completed]?.[2]) continue
-          if (dimension) {
-            if (nextChoices[id]?.[dimension] !== submitted[id]?.[dimension]) continue
-            const patch = { ...nextChoices[id] }; delete patch[dimension]
-            if (Object.keys(patch).length) nextChoices[id] = patch; else delete nextChoices[id]
-          } else if (nextChoices[id] === submitted[id]) delete nextChoices[id]
-        }
-        return nextChoices
-      })
-      if (savedOnly) setStatus({ key: 'capabilities.quick.savedOnly', params: { count: completed, error: savedOnly.error ?? '' } })
-      else if (failure || !refreshed || confirmed.length < completed) setStatus({ key: 'capabilities.quick.partial',
-        params: { count: confirmed.length, error: failure ?? t('capabilities.quick.confirmationUnavailable') } })
-      else setStatus({ key: pendingCount ? 'capabilities.quick.pendingApplied' : 'capabilities.quick.applied', params: { count: completed } })
-      if (request.current === controller) { request.current = null; applying.current = false; setPending(false) }
     }
     const discard = () => { setDrafts(emptyDrafts()); setStatus(null) }
     const close = () => {
+      // A confirmed apply keeps its own lifecycle: refusing the close keeps an accidental
+      // Escape or backdrop click from aborting host commands the user already submitted.
+      if (applying.current) return
       request.current?.abort()
       request.current = null
       applying.current = false
@@ -1203,35 +1710,124 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
     const filter = (label, value, onChange, options, disabled = false) => h('div', { className: 'ptcPlusCapabilityFilter' },
       h('span', null, label), h(Select, { label, value, onChange, disabled,
         options: options.map(([key, text]) => ({ value: key, label: text })) }))
+    const ruleLabel = (rule, empty) => capabilityRuleLabel(t, rule, empty)
+    const statusLabel = value => value && typeof value === 'object' ? ruleLabel(value) : capabilityChoiceLabel(t, value)
+    // The stored temporary value for one dimension, including the legacy scalar
+    // form where a single selection covered both dimensions.
+    const storedDimension = (entry, dimension) => {
+      const rule = entry.temporaryRule !== null && typeof entry.temporaryRule === 'object' && !Array.isArray(entry.temporaryRule)
+        ? entry.temporaryRule : undefined
+      const override = rule?.[dimension]
+      if (override !== undefined) return override
+      if (entry.temporary === 'automatic') return 'automatic'
+      if (typeof entry.temporary === 'string' && !['inherit', 'automatic', 'unknown', 'pending'].includes(entry.temporary)) {
+        return dimension === 'availability' ? (entry.temporary === 'closed' ? 'closed' : 'enabled')
+          : (CAPABILITY_DISCLOSURES.includes(entry.temporary) ? entry.temporary : undefined)
+      }
+      return undefined
+    }
+    // The value a dimension falls back to when this session keeps no temporary
+    // change; the frozen plan already resolved the saved layers.
+    const frozenDimension = (entry, dimension) => {
+      const source = entry.sourceDimensions?.[dimension]
+      if (typeof source === 'string') return source
+      const effective = entry.effectiveDimensions?.[dimension]
+      if (typeof effective === 'string' && storedDimension(entry, dimension) === undefined) return effective
+      if (dimension === 'availability') return entry.effective === 'closed' ? 'closed'
+        : ['full', 'on-demand', 'host', 'enabled'].includes(entry.effective) ? 'enabled' : undefined
+      return ['full', 'on-demand', 'host'].includes(entry.effective) ? entry.effective : undefined
+    }
+    const stateText = value => value === undefined ? t('capabilities.quick.unknown') : statusLabel(value)
+    const dimensionCurrent = (entry, dimension) => choices[entry.id]?.[dimension] ?? storedDimension(entry, dimension) ?? 'inherit'
+    const dimensionImpact = (entry, dimension) => {
+      const draft = choices[entry.id]?.[dimension]
+      const choice = draft ?? storedDimension(entry, dimension) ?? 'inherit'
+      const stagedChange = draft !== undefined
+      if (choice === 'inherit') return { state: frozenDimension(entry, dimension), origin: 'capabilities.quick.originPlan', staged: stagedChange }
+      if (choice === 'automatic') return { upper: true, staged: stagedChange }
+      return { state: choice, origin: 'capabilities.quick.originSession', staged: stagedChange }
+    }
+    const impactLine = impact => impact.upper
+      ? t(impact.staged ? 'capabilities.quick.impactUpperPending' : 'capabilities.quick.impactUpper')
+      : t(impact.staged ? 'capabilities.quick.impactPending' : 'capabilities.quick.impact',
+        { state: stateText(impact.state), source: t(impact.origin) })
+    const dimensionOptions = (entry, dimension) => {
+      const restore = stateText(frozenDimension(entry, dimension))
+      const inherit = storedDimension(entry, dimension) === undefined
+        ? t('capabilities.quick.noChange', { state: restore })
+        : t('capabilities.quick.undoTemp', { state: restore })
+      // "Let the level above decide" only differs from "no change" while the
+      // session's frozen source still carries an explicit rule for the dimension.
+      const sourceDimension = entry.sourceRule?.[dimension]
+      const distinctRule = sourceDimension !== undefined && sourceDimension !== 'automatic'
+      return ['inherit', ...(distinctRule || dimensionCurrent(entry, dimension) === 'automatic' ? ['automatic'] : []),
+        ...(dimension === 'availability' ? ['enabled', 'closed'] : CAPABILITY_DISCLOSURES)]
+        .map(choice => ({ value: choice, label: choice === 'inherit' ? inherit
+          : choice === 'automatic' ? t('capabilities.quick.upperRule')
+            : t(choice === 'enabled' ? 'capabilities.action.enable' : choice === 'closed' ? 'capabilities.action.close' : `capabilities.${choice}`) }))
+    }
+    const legacyFrozenState = entry => {
+      const stored = typeof entry.temporary === 'string' && !['inherit', 'automatic', 'unknown', 'pending'].includes(entry.temporary)
+      if (stored) return ['full', 'on-demand', 'closed'].includes(entry.sessionSourceSelection) ? entry.sessionSourceSelection : undefined
+      return ['full', 'on-demand', 'closed', 'host'].includes(entry.effective) ? entry.effective : undefined
+    }
+    const choiceCurrent = entry => choices[entry.id] ?? entry.temporary ?? 'inherit'
+    const choiceImpact = entry => {
+      const draft = choices[entry.id]
+      const choice = draft ?? entry.temporary ?? 'inherit'
+      const stagedChange = draft !== undefined
+      if (choice === 'inherit') return { state: legacyFrozenState(entry), origin: 'capabilities.quick.originPlan', staged: stagedChange }
+      if (choice === 'automatic') return { upper: true, staged: stagedChange }
+      return { state: choice, origin: 'capabilities.quick.originSession', staged: stagedChange }
+    }
     const choiceOptions = selected ? [
       'inherit', 'automatic',
       ...(selected.category === 'server' ? [] : ['full', 'on-demand']), 'closed',
-    ].map(choice => ({ value: choice, label: t(choice === 'inherit' ? 'capabilities.quick.inherit' : `capabilities.${choice}`) })) : []
-    const ruleLabel = (rule, empty) => capabilityRuleLabel(t, rule, empty)
+    ].map(choice => ({ value: choice, label: choice === 'inherit'
+      ? t(selected.temporary !== undefined && selected.temporary !== 'inherit' ? 'capabilities.quick.undoChange' : 'capabilities.quick.keepUnchanged')
+      : choice === 'automatic' ? t('capabilities.quick.upperRule')
+        : t(`capabilities.${choice}`) })) : []
     const dimensionFacts = dimensions => ['availability', 'disclosure'].map(dimension =>
       `${t(`capabilities.policy.${dimension}`)}: ${statusLabel(dimensions[dimension])} (${dimensions[`${dimension}Source`] ?? t('capabilities.quick.unknown')})`).join(' · ')
-    const statusLabel = value => value && typeof value === 'object' ? ruleLabel(value) : capabilityChoiceLabel(t, value)
+    // A dimension whose effective value comes from the session-only temporary
+    // choice is marked beside the frozen inheritance it replaces.
+    const temporaryDimension = (entry, dimension) => {
+      const rule = entry.temporaryRule !== null && typeof entry.temporaryRule === 'object' && !Array.isArray(entry.temporaryRule)
+        ? entry.temporaryRule : undefined
+      const override = rule?.[dimension]
+      if (override !== undefined && override !== 'automatic') return override
+      if (typeof entry.temporary === 'string' && !['inherit', 'automatic'].includes(entry.temporary)) {
+        return dimension === 'availability' ? (entry.temporary === 'closed' ? 'closed' : 'enabled') : entry.temporary
+      }
+      return undefined
+    }
+    const dimensionCell = (entry, dimension, value) => temporaryDimension(entry, dimension) === value
+      ? t('capabilities.quick.temporaryState', { state: statusLabel(value) }) : statusLabel(value)
     const openEditor = (entry, dimension = 'availability') => { setSelectedId(entry.id); setPane('detail'); setFocusDimension(dimension) }
     const renderRow = entry => h('div', { key: entry.id, role: 'row',
       className: 'ptcPlusSessionCapabilityRow ptcPlusCapabilityItem', 'data-capability-id': entry.id, 'data-selected': selected?.id === entry.id,
       onClick: () => openEditor(entry) },
       h('div', { role: 'cell', className: 'ptcPlusCapabilityIdentity' },
-        h('button', { type: 'button', className: 'ptcPlusSessionCapabilityName ptcPlusCapabilityName',
-          'aria-current': selected?.id === entry.id ? 'true' : undefined,
-          onClick: event => { event.stopPropagation(); openEditor(entry) } }, entry.name ?? entry.id),
-        entry.name && entry.name !== entry.id ? h('code', null, entry.id) : null),
+        h('input', { type: 'checkbox', className: 'ptcPlusPick', checked: picked.includes(entry.id), disabled: writesBlocked,
+          'aria-label': t('capabilities.selectForBatch', { name: entry.name ?? entry.id }),
+          onClick: event => event.stopPropagation(), onChange: () => togglePick(entry.id) }),
+        h('div', { className: 'ptcPlusCapabilityIdentityText' },
+          h('button', { type: 'button', className: 'ptcPlusSessionCapabilityName ptcPlusCapabilityName',
+            'aria-current': selected?.id === entry.id ? 'true' : undefined,
+            onClick: event => { event.stopPropagation(); openEditor(entry) } }, entry.name ?? entry.id),
+          entry.name && entry.name !== entry.id ? h('code', null, entry.id) : null)),
       h('span', { role: 'cell', className: 'ptcPlusCapabilityBadge', 'data-kind': type(entry) }, t(`capabilities.type.${type(entry)}`)),
       h('span', { role: 'cell', className: 'ptcPlusCapabilitySource' }, displayedSource(entry)),
       h('div', { role: 'cell', className: 'ptcPlusCapabilityAvailability', 'data-state': effectiveAvailability(entry) },
         h('button', { type: 'button', className: 'ptcPlusCapabilityContext',
           'aria-label': t('capabilities.policy.availabilityFor', { name: entry.id }),
           title: t('capabilities.quick.effective'),
-          onClick: event => { event.stopPropagation(); openEditor(entry, 'availability') } }, statusLabel(effectiveAvailability(entry)))),
+          onClick: event => { event.stopPropagation(); openEditor(entry, 'availability') } }, dimensionCell(entry, 'availability', effectiveAvailability(entry)))),
       h('div', { role: 'cell', className: 'ptcPlusCapabilityContextCell' },
         h('button', { type: 'button', className: 'ptcPlusCapabilityContext',
           'aria-label': t('capabilities.editContextFor', { name: entry.id }),
           title: t('capabilities.quick.effective'),
-          onClick: event => { event.stopPropagation(); openEditor(entry, 'disclosure') } }, statusLabel(effectiveContext(entry)))),
+          onClick: event => { event.stopPropagation(); openEditor(entry, 'disclosure') } }, dimensionCell(entry, 'disclosure', effectiveContext(entry)))),
       h('span', { role: 'cell', className: 'ptcPlusSessionCapabilityPending', 'data-changed': Object.hasOwn(choices, entry.id),
         'data-label': t('capabilities.quick.changed') },
         Object.hasOwn(choices, entry.id) ? statusLabel(choices[entry.id]) : '—'))
@@ -1240,7 +1836,7 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
     h('div', { className: 'ptcPlusSessionCapabilityHead' },
       h('div', null, h('h2', null, t('capabilities.quick.modalTitle')),
         h('p', null, t('capabilities.quick.sessionIdentity', { session: sessionId }))),
-      h('button', { type: 'button', className: 'ptcPlusDialogClose', 'aria-label': t('settings.close'), onClick: close }, '×')),
+      h('button', { type: 'button', className: 'ptcPlusDialogClose', 'aria-label': t('settings.close'), disabled: pending, onClick: close }, '×')),
     h('div', { className: 'ptcPlusSessionCapabilityToolbar' },
       h('label', { className: 'ptcPlusSearch' },
         h('svg', { viewBox: '0 0 24 24', width: 16, height: 16, 'aria-hidden': true },
@@ -1256,13 +1852,27 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
       filter(t('capabilities.quick.state'), stateFilter, setStateFilter,
         [['all', t('capabilities.quick.allStates')], ['changed', t('capabilities.quick.changed')],
           ...['full', 'on-demand', 'closed', 'pending'].map(key => [key, statusLabel(key)])])),
-    writesBlocked ? h('p', { className: 'ptcPlusCapabilityNotice', role: 'status' },
-      t(management === 'paused' ? 'capabilities.quick.sessionPaused' : 'capabilities.quick.sessionManagementOff')) : null,
+    // A blocked workbench states why writes are off and how to restore them; the banner styling
+    // keeps that condition from reading as an incidental list message.
+    writesBlocked ? h('p', { className: 'ptcPlusCapabilityNotice ptcPlusCapabilityBlocked', role: 'status' },
+      h('svg', { className: 'ptcPlusCapabilityBlockedIcon', viewBox: '0 0 16 16', width: 14, height: 14,
+        'aria-hidden': true, fill: 'none' },
+        h('path', { d: 'M8 2.3 14.7 13.5H1.3L8 2.3Z', stroke: 'currentColor', strokeWidth: 1.3, strokeLinejoin: 'round' }),
+        h('path', { d: 'M8 6.4v3M8 11.2v.7', stroke: 'currentColor', strokeWidth: 1.3, strokeLinecap: 'round' })),
+      t(management === 'paused' ? 'capabilities.quick.sessionPaused'
+        : management === 'off' ? 'capabilities.quick.sessionManagementOff'
+          : savedSettings?.contextEnabled === false ? 'capabilities.quick.savedPaused'
+            : 'capabilities.quick.savedManagementOff')) : null,
     h('div', { className: 'ptcPlusSessionCapabilityWorkspace', 'data-pane': pane },
       h('div', { className: 'ptcPlusSessionCapabilityList', role: 'table', 'aria-label': t('capabilities.quick.members'), ref: list },
         h('div', { className: 'ptcPlusSessionCapabilityColumns ptcPlusCapabilityColumns', role: 'row' },
           ...CAPABILITY_SORT_COLUMNS.map(column => h('span', { key: column.key, role: 'columnheader',
-            'aria-sort': capabilitySortDirection(sort, column.key) },
+            'aria-sort': capabilitySortDirection(sort, column.key),
+            ...(column.key === 'name' ? { 'aria-label': t('capabilities.member'), className: 'ptcPlusCapabilityPickHead' } : {}) },
+            ...(column.key === 'name' ? [h('input', { type: 'checkbox', className: 'ptcPlusPick', checked: allMatchesPicked,
+              ref: node => { if (node) node.indeterminate = someMatchesPicked && !allMatchesPicked },
+              disabled: writesBlocked || matches.length === 0, 'aria-label': t('capabilities.selectAllVisible'),
+              onChange: toggleAllMatches })] : []),
             h('button', { type: 'button', className: 'ptcPlusCapabilitySort', title: t('capabilities.sortCycle'),
               onClick: () => setSort(current => cycleCapabilitySort(current, column.key)) },
             t(`capabilities.${column.label}`), h('span', { 'aria-hidden': true },
@@ -1308,34 +1918,73 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
             h('ul', null, ...catalog.filter(entry => entry.id !== selected.id
               && entry.source?.kind === 'mcp' && entry.source.server === selected.source?.server)
               .map(entry => h('li', { key: entry.id }, entry.name ?? entry.id)))) : null,
-          selected.savedRule ? h(React.Fragment, null, ...['availability', 'disclosure'].map(dimension =>
-            h('div', { className: 'ptcPlusCapabilityFilter', key: dimension, 'data-capability-dimension': dimension },
+          selected.savedRule ? h(React.Fragment, null, ...['availability', 'disclosure'].map(dimension => h(React.Fragment, { key: dimension },
+            h('div', { className: 'ptcPlusCapabilityFilter', 'data-capability-dimension': dimension },
               h('span', null, t(`capabilities.policy.${dimension}`)),
               h(Select, { label: t(`capabilities.policy.${dimension}`), disabled: !enabled || !available || pending || writesBlocked,
-                value: choices[selected.id]?.[dimension] ?? selected.temporaryRule?.[dimension] ?? 'inherit',
+                value: dimensionCurrent(selected, dimension),
                 onChange: next => chooseDimension(selected.id, dimension, next),
-                options: ['inherit', 'automatic', ...(dimension === 'availability' ? ['enabled', 'closed'] : CAPABILITY_DISCLOSURES)]
-                  .map(choice => ({ value: choice, label: t(choice === 'inherit' ? 'capabilities.quick.inherit'
-                    : choice === 'automatic' ? 'capabilities.policy.inheritRule' : choice === 'enabled' ? 'capabilities.quick.enabled' : `capabilities.${choice}`) })) }))))
-            : h('div', { className: 'ptcPlusCapabilityFilter' },
-              h('span', null, t('capabilities.quick.choice')),
-              h(Select, { label: t('capabilities.quick.choice'), value: choiceFor(selected),
-                disabled: !enabled || !available || pending || writesBlocked, options: choiceOptions,
-                onChange: next => choose(selected.id, next) })),
-          choices[selected.id] === 'inherit' ? h('p', { className: 'ptcPlusDetail' },
+                options: dimensionOptions(selected, dimension) })),
+            h('p', { className: 'ptcPlusDetail ptcPlusCapabilityImpact', 'data-impact-dimension': dimension },
+              impactLine(dimensionImpact(selected, dimension))))))
+            : h(React.Fragment, null,
+              h('div', { className: 'ptcPlusCapabilityFilter' },
+                h('span', null, t('capabilities.quick.choice')),
+                h(Select, { label: t('capabilities.quick.choice'), value: choiceCurrent(selected),
+                  disabled: !enabled || !available || pending || writesBlocked, options: choiceOptions,
+                  onChange: next => choose(selected.id, next) })),
+              h('p', { className: 'ptcPlusDetail ptcPlusCapabilityImpact', 'data-impact-dimension': 'selection' },
+                impactLine(choiceImpact(selected)))),
+          (typeof choices[selected.id] === 'string' ? choices[selected.id] === 'inherit'
+            : Object.values(choices[selected.id] ?? {}).includes('inherit')) ? h('p', { className: 'ptcPlusDetail' },
             t('capabilities.quick.inheritSessionOnly')) : null) : h('p', null, t('capabilities.noMatches')))),
+    batchOpen ? h(Modal, { open: true, onClose: () => setBatchOpen(false), title: t('capabilities.batchSettings'),
+      closeLabel: t('capabilities.batch.cancel'), headless: true, className: 'ptcPlusCapabilityBatchModal' },
+      h('div', { className: 'ptcPlusCapabilityBatchHead' }, h('h2', null, t('capabilities.batchSettings')),
+        h('button', { type: 'button', className: 'ptcPlusDialogClose', 'aria-label': t('capabilities.batch.cancel'),
+          onClick: () => setBatchOpen(false) }, '\u00d7')),
+      h('div', { className: 'ptcPlusCapabilityBatchBody' },
+        h('p', { className: 'ptcPlusDetail', role: 'status' }, t('capabilities.batch.selected', { count: pickedRows.length })),
+        h('ul', { className: 'ptcPlusCapabilityBatchTargets', 'aria-label': t('capabilities.batch.targetList') },
+          ...pickedRows.map(entry => h('li', { key: entry.id }, h('span', null, entry.name ?? entry.id), h('code', null, entry.id)))),
+        h('div', { className: 'ptcPlusCapabilityBatchFields' }, ...['availability', 'disclosure'].map(dimension =>
+          h('div', { key: dimension, className: 'ptcPlusCapabilityFilter' }, h('span', null, t(`capabilities.policy.${dimension}`)),
+            h(Select, { value: batchChoices[dimension], label: t(`capabilities.batch.${dimension}`),
+              onChange: choice => setBatchChoices(current => ({ ...current, [dimension]: choice })),
+              options: ['keep', 'inherit', ...(dimension === 'availability' ? ['enabled', 'closed'] : CAPABILITY_DISCLOSURES)]
+                .map(choice => ({ value: choice, label: choice === 'keep' ? t('capabilities.batch.keep')
+                  : choice === 'inherit' ? t('capabilities.batch.sessionInherit')
+                    : choice === 'enabled' ? t('capabilities.action.enable')
+                      : choice === 'closed' ? t('capabilities.action.close') : t(`capabilities.${choice}`) })) })))),
+        h('p', { className: 'ptcPlusDetail' }, t('capabilities.batch.sessionStage'))),
+      h('div', { className: 'ptcPlusCapabilityBatchFooter' },
+        h('button', { type: 'button', className: 'ptcPlusButton', onClick: () => setBatchOpen(false) }, t('capabilities.batch.cancel')),
+        h('button', { type: 'button', className: 'ptcPlusButton', 'data-kind': 'primary',
+          disabled: pickedRows.length === 0 || !['availability', 'disclosure'].some(dimension => batchChoices[dimension] !== 'keep'),
+          onClick: () => { stageBatch(pickedRows.map(entry => entry.id), batchChoices); setBatchOpen(false) } },
+          t('capabilities.batch.stage', { count: pickedRows.length })))) : null,
     h('div', { className: 'ptcPlusSessionCapabilityFooter' },
       h('span', { role: 'status' }, pending ? t('capabilities.quick.applying') : status ? t(status.key, status.params)
         : t('capabilities.quick.changes', { count: staged.length })),
       h('button', { type: 'button', className: 'ptcPlusButton', disabled: pending || staged.length === 0, onClick: discard },
         t('capabilities.quick.discard')),
-      h('button', { type: 'button', className: 'ptcPlusButton', title: t('capabilities.quick.sessionHint'),
+      // Session-scoped temporary application stays the footer's primary action; saving global
+      // defaults is an explicit secondary choice, so no default-looking control changes global state.
+      h('button', { type: 'button', className: 'ptcPlusButton', 'data-kind': 'primary', title: t('capabilities.quick.sessionHint'),
         disabled: pending || !enabled || !available || writesBlocked || staged.length === 0, onClick: () => void apply('session') },
         t('capabilities.quick.applySession')),
-      h('button', { type: 'button', className: 'ptcPlusButton', 'data-kind': 'primary',
+      h('button', { type: 'button', className: 'ptcPlusButton',
         title: t(hasInheritanceReset ? 'capabilities.quick.inheritSessionOnly' : 'capabilities.quick.globalHint'),
         disabled: pending || !enabled || !available || writesBlocked || staged.length === 0 || hasInheritanceReset,
         onClick: () => void apply('global') },
-        t('capabilities.quick.applyGlobal'))))
+        t('capabilities.quick.applyGlobal')),
+      h('button', { type: 'button', className: 'ptcPlusButton', 'aria-haspopup': 'dialog',
+        'aria-label': t('capabilities.batchSettings'),
+        disabled: pending || writesBlocked || picked.length === 0,
+        onClick: () => { setBatchChoices({ availability: 'keep', disclosure: 'keep' }); setBatchOpen(true) } },
+        t('capabilities.batchSettings'),
+        picked.length ? h('span', { className: 'ptcPlusCapabilityBatchCount', 'aria-hidden': true,
+          title: t('capabilities.selectionCount', { count: picked.length }) },
+          String(picked.length)) : null)))
   }
 }