dsh-ptc-plus 0.5.1 → 0.5.3

package/src/client-capabilities-view.js

@@ -4,13 +4,49 @@ 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'
+
+/**
+ * One capability, three separate facts, in the reader's language. Saved,
+ * delivered and usable are different questions, so a reader must be able to see
+ * which one failed instead of reading one blanket "applied".
+ */
+export function capabilityProofCopy(t, proof) {
+  const delivery = ['delivered', 'pending', 'absent'].includes(proof?.delivery) ? proof.delivery : undefined
+  const usability = ['proven', 'unproven'].includes(proof?.usability) ? proof.usability : undefined
+  if (delivery === undefined || usability === undefined) return t('capabilities.quick.unknown')
+  return t('capabilities.proof.line', {
+    saved: t(proof.saved === true ? 'capabilities.proof.saved.yes' : 'capabilities.proof.saved.no'),
+    delivery: t(`capabilities.proof.delivery.${delivery}`),
+    usability: t(`capabilities.proof.usability.${usability}`),
+  })
+}
 
 export function capabilityCommandText(t, text) {
   if (text?.key) return t(text.key, text.params)
   const receipt = readCapabilityCommandReceipt(text)
-  return receipt ? t(`capabilities.receipt.${receipt.state}`, { session: receipt.sessionId, error: receipt.error ?? '' }) : text
+  if (!receipt) return text
+  const line = t(`capabilities.receipt.${receipt.state}`, { session: receipt.sessionId, error: receipt.error ?? '' })
+  return receipt.proof === undefined ? line : `${line} ${capabilityProofCopy(t, receipt.proof)}`
 }
 
+// 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 +66,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 ?? '' })
@@ -44,9 +133,14 @@ export function createCapabilityCommandCard(React) {
           : node.outcome ? (typeof text === 'string' && !text.trim() ? undefined : capabilityCommandText(t, text))
             ?? t(node.outcome.kind === 'error' ? 'capabilities.commandFailed' : 'capabilities.refreshAcknowledged')
             : t('capabilities.refreshing')
+      // A command that names one capability carries that capability's three
+      // facts; the notice states them beside its session outcome so "saved"
+      // cannot be read as "delivered" or "usable".
+      const notice = receipt?.proof === undefined || outcome === undefined
+        ? outcome : `${outcome} ${capabilityProofCopy(t, receipt.proof)}`
       return h('p', { className: 'ptcPlusCapabilityCommandNotice',
         role: node.outcome?.kind === 'error' ? 'alert' : 'status',
-        'data-state': node.outcome?.kind ?? 'pending' }, outcome)
+        'data-state': node.outcome?.kind ?? 'pending' }, notice)
     }
     let json
     if (typeof text === 'string') {
@@ -128,12 +222,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 +238,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 +274,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?.(),
@@ -889,17 +986,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') },
@@ -909,7 +1364,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'),
@@ -926,7 +1381,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 }
@@ -992,6 +1450,10 @@ export function createCapabilityRefreshView(React, commands) {
 export function createSessionCapabilityControlsView(React, { commands, Modal, Select, inspectSessionCatalog }) {
   const h = React.createElement
   const emptyDrafts = () => ({})
+  // The panel reports the three capability facts only where it holds evidence:
+  // the receipts its own commands returned. A catalogue row says what the plan
+  // will do; it cannot say a cell reached the capability.
+  const emptyProofs = () => ({})
   return function SessionCapabilityControls({ sessionId, open, enabled, t, onClose }) {
     const source = React.useMemo(() => commands.source(sessionId), [sessionId])
     const available = React.useSyncExternalStore(source.subscribe, source.getSnapshot)
@@ -1013,6 +1475,7 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
     const [sort, setSort] = React.useState(null)
     const [focusDimension, setFocusDimension] = React.useState(null)
     const [status, setStatus] = React.useState(null)
+    const [proofs, setProofs] = React.useState(emptyProofs)
     const [pending, setPending] = React.useState(false)
     const request = React.useRef(null)
     const applying = React.useRef(false)
@@ -1045,6 +1508,7 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
       setPane('list')
       setFocusDimension(null)
       setStatus(null)
+      setProofs(emptyProofs())
       setPending(false)
       setError(null)
     }, [sessionId])
@@ -1211,15 +1675,20 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
         let pendingCount = 0
         let failure = null
         let savedOnly = null
+        const observed = {}
         for (const [id, selection, dimension] of staged) {
           if (controller.signal.aborted) break
+          const line = `set ${targetScope} ${encodeURIComponent(id)} ${dimension ? dimension + ' ' : ''}${selection}`
           try {
-            const result = await commands.run(sessionId, `set ${targetScope} ${encodeURIComponent(id)} ${dimension ? dimension + ' ' : ''}${selection}`, controller.signal)
+            const result = await commands.run(sessionId, line, 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
+            // A receipt that names the capability carries the only proof this
+            // panel can hold: what the save did and did not establish.
+            if (receipt.proof !== undefined) observed[receipt.proof.id] = { proof: receipt.proof, command: `/capabilities ${line}` }
             completed += 1
           } catch (cause) {
             failure = String(cause?.message ?? cause)
@@ -1228,6 +1697,7 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
             break
           }
         }
+        if (mounted.current && Object.keys(observed).length) setProofs(current => ({ ...current, ...observed }))
         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
@@ -1465,6 +1935,13 @@ export function createSessionCapabilityControlsView(React, { commands, Modal, Se
             h('dt', null, t('capabilities.quick.effective')), h('dd', null, statusLabel(selected.effective)),
             selected.sourceDimensions ? h(React.Fragment, null, h('dt', null, t('capabilities.policy.frozenSource')), h('dd', null, dimensionFacts(selected.sourceDimensions))) : null,
             selected.effectiveDimensions ? h(React.Fragment, null, h('dt', null, t('capabilities.policy.effectiveDimensions')), h('dd', null, dimensionFacts(selected.effectiveDimensions))) : null),
+          h('div', { className: 'ptcPlusCapabilityProof', 'data-capability-proof': selected.id },
+            h('h4', null, t('capabilities.proof.title')),
+            proofs[selected.id]
+              ? h(React.Fragment, null,
+                h('p', { className: 'ptcPlusDetail', role: 'status' }, capabilityProofCopy(t, proofs[selected.id].proof)),
+                h('small', null, t('capabilities.proof.observed', { command: proofs[selected.id].command })))
+              : h('p', { className: 'ptcPlusDetail' }, t('capabilities.proof.unobserved'))),
           selected.source?.kind === 'mcp' && selected.category !== 'server'
             ? (() => {
               const server = catalog.find(entry => entry.category === 'server' && entry.source?.server === selected.source.server)