dsh-ptc-plus 0.4.8 → 0.5.0

package/internal/capability-statistics.js

@@ -0,0 +1,210 @@
+const CATEGORIES = new Set(['tool', 'skill', 'resource', 'resource-template', 'task'])
+const OUTCOMES = new Set(['complete', 'failed', 'cancelled', 'unknown'])
+const USE_EVIDENCE = new Map([
+  ['tool', 'host-execution-result'], ['task', 'host-execution-result'], ['skill', 'skill-body-accepted'],
+  ['resource', 'resource-access'], ['resource-template', 'resource-access'],
+])
+
+function fail(label) { throw new TypeError(`ptc-plus: invalid capability statistics ${label}`) }
+function record(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(label)
+  return value
+}
+function identity(value, label) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 4096) fail(label)
+  return value
+}
+function integer(value, label, minimum = 0) {
+  if (!Number.isSafeInteger(value) || value < minimum) fail(label)
+  return value
+}
+function key(value) { return JSON.stringify(value) }
+function orderSamples(a, b) { return b.eligibleOrder - a.eligibleOrder }
+function freeze(value) {
+  if (value && typeof value === 'object') {
+    for (const item of Object.values(value)) freeze(item)
+    Object.freeze(value)
+  }
+  return value
+}
+
+/** Bounds are explicit calibration inputs; no observation, clock or process directory is inferred. */
+export function createCapabilityStatistics(configuration) {
+  const options = record(configuration, 'configuration')
+  const limits = {}
+  for (const name of ['windowSize', 'maxFamilies', 'maxScopes', 'maxCapabilitiesPerFamily']) limits[name] = integer(options[name], name, 1)
+  return freeze({ schema: 'ptc-capability-statistics/v1', status: 'usable', limits, families: [], windows: [] })
+}
+
+function observation(raw) {
+  const value = record(raw, 'availability observation')
+  const category = value.category
+  if (!CATEGORIES.has(category)) fail('category')
+  if (!['full', 'on-demand', 'host'].includes(value.disclosure)) fail('availability disclosure')
+  const useEvidence = value.useEvidence ?? null
+  if (useEvidence !== null && useEvidence !== USE_EVIDENCE.get(category)) fail('owner use evidence')
+  const outcome = useEvidence === null ? null : value.outcome ?? 'unknown'
+  if (outcome !== null && !OUTCOMES.has(outcome)) fail('owner outcome evidence')
+  return {
+    workspaceId: identity(value.workspaceId, 'workspace identity'),
+    id: identity(value.id, 'capability identity'), revision: identity(value.revision, 'capability revision'), category,
+    disclosure: value.disclosure, planRevision: identity(value.planRevision, 'plan revision'),
+    used: useEvidence !== null, outcome,
+  }
+}
+
+function sampleObservation(value) {
+  const item = record(value, 'retained observation')
+  identity(item.workspaceId, 'retained workspace identity')
+  identity(item.id, 'retained capability identity')
+  identity(item.revision, 'retained capability revision')
+  if (!CATEGORIES.has(item.category) || typeof item.used !== 'boolean' || !Array.isArray(item.exposures) || item.exposures.length < 1) fail('retained evidence')
+  if (!Array.isArray(item.outcomes) || item.outcomes.some(outcome => !OUTCOMES.has(outcome))
+    || new Set(item.outcomes).size !== item.outcomes.length || item.used !== (item.outcomes.length > 0)) fail('retained outcomes')
+  for (const exposure of item.exposures) {
+    record(exposure, 'retained exposure')
+    if (!['full', 'on-demand', 'host'].includes(exposure.disclosure)) fail('retained disclosure')
+    identity(exposure.planRevision, 'retained plan revision')
+  }
+}
+
+/** Validate retained state before it can supply an automatic-allocation denominator. */
+export function validateCapabilityStatistics(state) {
+  const value = record(state, 'state')
+  if (value.schema !== 'ptc-capability-statistics/v1' || !['usable', 'capacity-exceeded'].includes(value.status)) fail('state schema or status')
+  const template = createCapabilityStatistics(value.limits)
+  if (!Array.isArray(value.families) || !Array.isArray(value.windows)
+    || value.families.length > template.limits.maxFamilies || value.windows.length > template.limits.maxScopes) fail('state bounds')
+  const familyKeys = new Set()
+  const orders = new Set()
+  for (const family of value.families) {
+    record(family, 'retained family')
+    const familyKey = key([identity(family.userId, 'user identity'), identity(family.familyId, 'family identity')])
+    if (familyKeys.has(familyKey)) fail('duplicate family')
+    familyKeys.add(familyKey)
+    integer(family.observationRevision, 'observation revision')
+    if (!['active', 'settled', 'unknown'].includes(family.settlement)) fail('family settlement')
+    if (family.eligibleOrder !== null) {
+      integer(family.eligibleOrder, 'qualification order', 1)
+      const orderKey = key([family.userId, family.eligibleOrder])
+      if (orders.has(orderKey)) fail('duplicate qualification order')
+      orders.add(orderKey)
+    } else if (family.settlement === 'settled') fail('settled family without qualification order')
+    if (!Array.isArray(family.observations) || family.observations.length > value.limits.maxCapabilitiesPerFamily) fail('family observation bounds')
+    const observationKeys = new Set()
+    for (const item of family.observations) {
+      sampleObservation(item)
+      const observationKey = key([item.workspaceId, item.id, item.revision])
+      if (observationKeys.has(observationKey)) fail('duplicate observation')
+      observationKeys.add(observationKey)
+      if (item.exposures.length > value.limits.maxCapabilitiesPerFamily) fail('exposure bounds')
+    }
+  }
+  const windowKeys = new Set()
+  for (const window of value.windows) {
+    record(window, 'window')
+    identity(window.userId, 'window user identity')
+    if (window.workspaceId !== null) identity(window.workspaceId, 'window workspace identity')
+    identity(window.id, 'window capability identity')
+    identity(window.revision, 'window capability revision')
+    integer(window.floor, 'evicted qualification frontier')
+    const windowKey = key([window.userId, window.workspaceId, window.id, window.revision])
+    if (windowKeys.has(windowKey)) fail('duplicate window')
+    windowKeys.add(windowKey)
+  }
+  return value
+}
+
+function windowKey(userId, workspaceId, item) { return key([userId, workspaceId, item.id, item.revision]) }
+function qualifies(family, window) {
+  return family.userId === window.userId && family.settlement === 'settled' && family.eligibleOrder > window.floor
+    && family.observations.some(item => item.id === window.id && item.revision === window.revision
+      && (window.workspaceId === null || item.workspaceId === window.workspaceId))
+}
+
+/**
+ * Public adapters supply actual family/workspace identities, monotone observation revisions,
+ * and an immutable qualification order. Observations are cumulative additions, never log guesses.
+ * A resumed or unknown family contributes no negative sample until owner-proven settlement.
+ */
+export function reduceCapabilityStatistics(previous, event) {
+  validateCapabilityStatistics(previous)
+  if (previous.status !== 'usable') return previous
+  const value = record(event, 'event')
+  if (value.type !== 'family-observation') fail('event type')
+  const userId = identity(value.userId, 'user identity')
+  const familyId = identity(value.familyId, 'family identity')
+  const observationRevision = integer(value.observationRevision, 'observation revision')
+  const settlement = value.settlement
+  if (!['active', 'settled', 'unknown'].includes(settlement)) fail('family settlement')
+  const eligibleOrder = value.eligibleOrder == null ? null : integer(value.eligibleOrder, 'qualification order', 1)
+  if (settlement === 'settled' && eligibleOrder === null) fail('settlement qualification order')
+  if (!Array.isArray(value.observations) || value.observations.length > previous.limits.maxCapabilitiesPerFamily) fail('observation bounds')
+  const additions = value.observations.map(observation)
+  const state = structuredClone(previous)
+  let family = state.families.find(item => item.userId === userId && item.familyId === familyId)
+  if (family) {
+    if (family.eligibleOrder !== null && eligibleOrder !== family.eligibleOrder) fail('changed qualification order')
+    if (observationRevision <= family.observationRevision) return previous
+    family.observationRevision = observationRevision
+    family.settlement = settlement
+    family.eligibleOrder ??= eligibleOrder
+  } else {
+    if (eligibleOrder !== null && state.families.some(item => item.userId === userId && item.eligibleOrder === eligibleOrder)) fail('qualification order collision')
+    family = { userId, familyId, observationRevision, settlement, eligibleOrder, observations: [] }
+    state.families.push(family)
+  }
+  for (const addition of additions) {
+    let retained = family.observations.find(item => item.workspaceId === addition.workspaceId && item.id === addition.id && item.revision === addition.revision)
+    if (!retained) {
+      retained = { workspaceId: addition.workspaceId, id: addition.id, revision: addition.revision, category: addition.category, used: false, exposures: [], outcomes: [] }
+      family.observations.push(retained)
+    } else if (retained.category !== addition.category) fail('changed capability category')
+    retained.used ||= addition.used
+    if (addition.outcome !== null && !retained.outcomes.includes(addition.outcome)) retained.outcomes.push(addition.outcome)
+    const exposure = { disclosure: addition.disclosure, planRevision: addition.planRevision }
+    if (!retained.exposures.some(item => item.disclosure === exposure.disclosure && item.planRevision === exposure.planRevision)) retained.exposures.push(exposure)
+    for (const workspaceId of [addition.workspaceId, null]) {
+      const targetKey = windowKey(userId, workspaceId, addition)
+      if (!state.windows.some(item => windowKey(item.userId, item.workspaceId, item) === targetKey)) {
+        state.windows.push({ userId, workspaceId, id: addition.id, revision: addition.revision, floor: 0 })
+      }
+    }
+  }
+  const retainedFamilies = new Set()
+  for (const window of state.windows) {
+    const eligible = state.families.filter(item => qualifies(item, window)).sort(orderSamples)
+    const selected = eligible.slice(0, state.limits.windowSize)
+    for (const item of selected) retainedFamilies.add(key([item.userId, item.familyId]))
+    for (const item of eligible.slice(state.limits.windowSize)) window.floor = Math.max(window.floor, item.eligibleOrder)
+  }
+  state.families = state.families.filter(item => item.settlement !== 'settled' || retainedFamilies.has(key([item.userId, item.familyId])))
+  if (state.families.length > state.limits.maxFamilies || state.windows.length > state.limits.maxScopes
+    || state.families.some(item => item.observations.length > state.limits.maxCapabilitiesPerFamily
+      || item.observations.some(entry => entry.exposures.length > state.limits.maxCapabilitiesPerFamily))) {
+    return freeze({ ...structuredClone(previous), status: 'capacity-exceeded' })
+  }
+  validateCapabilityStatistics(state)
+  return freeze(state)
+}
+
+/** Per-capability eligible windows; workspace and global evidence are never added together. */
+export function capabilityCoverage(state, query) {
+  validateCapabilityStatistics(state)
+  const options = record(query, 'coverage query')
+  const userId = identity(options.userId, 'coverage user identity')
+  const id = identity(options.id, 'coverage capability identity')
+  const revision = identity(options.revision, 'coverage capability revision')
+  const workspaceId = options.workspaceId === null ? null : identity(options.workspaceId, 'coverage workspace identity')
+  if (state.status !== 'usable') return { status: state.status, windowSize: state.limits.windowSize, eligible: null, used: null, coverage: null }
+  const window = state.windows.find(item => item.userId === userId && item.workspaceId === workspaceId && item.id === id && item.revision === revision)
+  const families = window ? state.families.filter(item => qualifies(item, window)).sort(orderSamples).slice(0, state.limits.windowSize) : []
+  // A resumed family can expose a gap behind the irreversible eviction frontier.
+  // Surviving samples do not prove the recent settled window until it is full again.
+  if (window?.floor > 0 && families.length < state.limits.windowSize) {
+    return { status: 'incomplete-window', windowSize: state.limits.windowSize, eligible: null, used: null, coverage: null }
+  }
+  const used = families.filter(family => family.observations.some(item => item.id === id && item.revision === revision && item.used
+    && (workspaceId === null || item.workspaceId === workspaceId))).length
+  return { status: 'usable', windowSize: state.limits.windowSize, eligible: families.length, used, coverage: families.length ? used / families.length : null }
+}

package/internal/compiler-platform.js

@@ -20,6 +20,7 @@ const nativePathToFileURL = pathToFileURL
 const nativeStripTypeScriptTypes = stripTypeScriptTypes
 const runInContext = Script.prototype.runInContext
 const NativeUint8Array = Uint8Array
+const typedArrayLength = descriptor(Object.getPrototypeOf(NativeUint8Array.prototype), 'length').get
 const NativeWeakRef = WeakRef, deref = WeakRef.prototype.deref
 const NativeError = Error
 const parseJson = JSON.parse
@@ -65,11 +66,12 @@ export const compilerPlatformBridge = {
   fileURLToPath: input => nativeFileURLToPath(nativeUrl(input)),
   pathToFileURL: input => ownUrl(nativePathToFileURL(input)),
   encode(source, encoding) {
-    const buffer = new NativeUint8Array(byteLength(source, encoding))
-    const length = apply(codecs[encoding].write, buffer, [source, 0, buffer.length])
+    const size = byteLength(source, encoding)
+    const buffer = new NativeUint8Array(size)
+    const length = apply(codecs[encoding].write, buffer, [source, 0, size])
     return { buffer, length }
   },
-  decode: (buffer, encoding) => apply(codecs[encoding].slice, buffer, [0, buffer.length]),
+  decode: (buffer, encoding) => apply(codecs[encoding].slice, buffer, [0, apply(typedArrayLength, buffer, [])]),
   textEncoder() {
     const encoder = new NativeTextEncoder()
     return { encode: source => apply(encoderEncode, encoder, [source]),

package/internal/compiler-service.js

@@ -2,7 +2,6 @@ import { readFileSync } from 'node:fs'
 import { constants, createContext, Script } from 'node:vm'
 import { fileURLToPath } from 'node:url'
 import { workerData } from 'node:worker_threads'
-import { deserialize } from 'node:v8'
 import { copyCompilerData } from './compiler-data.js'
 import { PreflightError } from './cell-analysis-contract.js'
 import { ModuleRewriteError } from './cell-error.js'
@@ -29,10 +28,7 @@ const define = compilerDescriptors.defineProperty
 const keys = Object.keys
 let compiler
 let compilerScript
-const coverageEnabled = Boolean(process.env.NODE_V8_COVERAGE)
-const bytecodeFile = process.env.DSH_PTC_COMPILER_BYTECODE
-let workerCache = bytecodeFile ? deserialize(readFileSync(bytecodeFile)) : undefined
-if (workerCache?.source !== compilerSource) workerCache = undefined
+let workerCache
 // Bytecode contains no compiler realm or program state. Match the complete
 // source: V8's cache validation alone does not prove source text equality.
 let cachedData = workerData?.compilerCache?.source === compilerSource
@@ -43,9 +39,6 @@ if (workerData !== null && typeof workerData === 'object') delete workerData.com
 /** Reuse compiled compiler code across fresh workers, never their realm state. */
 export function compilerWorkerCache() {
   if (compilerScript === undefined) return undefined
-  // Instrumented compiler instances neither produce nor consume bytecode.
-  // Coverage's runner supplies a snapshot from its uninstrumented preparation.
-  if (workerCache === undefined && coverageEnabled) return undefined
   workerCache ??= { source: compilerSource, data: apply(createCachedData, compilerScript, []) }
   return { source: workerCache.source, data: new NativeUint8Array(workerCache.data) }
 }
@@ -58,7 +51,7 @@ function compilerEntry() {
   // Workers can execute host-prepared cells without compiling dynamic source.
   // Capture source and platform before user code, but parse only on first use.
   compilerScript = new NativeScript(compilerSource, { __proto__: null, filename, displayErrors: false,
-    cachedData: coverageEnabled ? undefined : cachedData })
+    cachedData })
   cachedData = undefined
   const context = nativeCreateContext(dontContextify)
   define(context, '__compilerBaseUrl', { value: import.meta.url })

package/internal/config-spec.js

@@ -1,3 +1,5 @@
+import { CAPABILITY_POLICY_DEFAULT } from './capability-policy.js'
+
 /** Configuration fields shared by the Host schema and settings card. */
 export const MAX_TIMER_DELAY_MS = 2_147_483_647
 
@@ -11,6 +13,54 @@ export const SETTINGS_NAMESPACE = 'ptc-plus'
  * exists in both locales or in neither.
  */
 export const CONFIG_FIELDS = Object.freeze([
+  { key: 'capabilityContextEnabled', type: 'boolean', default: true,
+    label: '能力与上下文', labelEn: 'Capabilities and context',
+    description: '整体暂停能力规则、统计采集、说明恢复和结果预览，保留各项设置；新会话或明确刷新后生效。',
+    descriptionEn: 'Pauses capability rules, statistics collection, description recovery and result previews while retaining each setting. Applies to new sessions or explicit refreshes.' },
+  { key: 'capabilityManagementEnabled', type: 'boolean', default: false,
+    label: '实验性能力管理', labelEn: 'Experimental capability management',
+    description: '为新 PTC 会话应用可用性与说明规则；已有会话使用 /capabilities refresh 生效。收益尚未经过模型对照验收。',
+    descriptionEn: 'Applies availability and disclosure rules to new PTC sessions. Use /capabilities refresh for existing sessions. Model cost benefits remain unverified.' },
+  { key: 'capabilityPolicy', preserveOmission: true, type: 'string', default: CAPABILITY_POLICY_DEFAULT,
+    label: '能力规则', labelEn: 'Capability rules',
+    description: '分别设置可用性、说明方式以及常用集、统计和预算分配；默认、类别、MCP 来源、单项依次覆盖。',
+    descriptionEn: 'Choose availability, disclosure and baseline, statistics and budget allocation separately. Default, category, MCP source and item rules apply in order.' },
+  { key: 'capabilityRecoveryEnabled', preserveOmission: true, type: 'boolean', default: false,
+    label: '压缩后恢复已使用的 API 说明', labelEn: 'Recover used API descriptions after compaction',
+    description: '只补回已展开、仍有效且不可见的近期 API 说明，不恢复 Skill 正文。',
+    descriptionEn: 'Restores only expanded, current, no longer visible API descriptions from recent use; never Skill bodies.' },
+  { key: 'modelPreviewEnabled', preserveOmission: true, type: 'boolean', default: false,
+    label: '限制模型侧结果与日志展示', labelEn: 'Bound model-facing results and logs',
+    description: '独立使用插件预览预算；关闭时沿用宿主展示，程序值始终完整。',
+    descriptionEn: 'Independently selects the plugin preview budget. Otherwise retains Host presentation; program values remain complete.' },
+  { key: 'capabilityBaseline', type: 'string', default: '[]',
+    label: '初始常用能力', labelEn: 'Initial common capabilities',
+    description: '从能力列表勾选常用项；adaptive 选用常用集依据时参与分配，不生成使用记录。',
+    descriptionEn: 'Select common capabilities as an optional allocation basis for adaptive disclosure. Creates no usage records.' },
+  { key: 'capabilityOverrides', type: 'string', default: '{}',
+    label: '旧版能力选择', labelEn: 'Legacy capability selections',
+    description: '旧配置迁移输入；新规则由能力工作台分别保存可用性与说明方式。',
+    descriptionEn: 'Migration input for older settings. The workbench saves availability and disclosure separately in the policy.' },
+  { key: 'capabilityStatistics', type: 'string',
+    default: '{"enabled":false,"windowSize":100,"minimumSamples":10,"fullThreshold":0.5}',
+    label: '能力统计设置', labelEn: 'Capability statistics settings',
+    description: '独立采集使用统计，并设置样本窗口、最低样本数和完整披露阈值；关闭或不可用时保留手动基线。',
+    descriptionEn: 'Collect usage statistics independently and set the sample window, minimum samples and full-disclosure threshold. Disabled or unavailable statistics preserve the manual baseline.' },
+  { key: 'capabilityProfiles', type: 'string', default: '{"schema":"ptc-capability-profiles/v1","profiles":[]}',
+    label: '保存的能力配置', labelEn: 'Saved capability configurations',
+    description: '在能力工作台命名保存、导入导出和切换配置；已有会话需要主动刷新。',
+    descriptionEn: 'Name, save, import, export and switch configurations in the capability workbench. Existing sessions require explicit refresh.' },
+  { key: 'capabilityBudgetBytes', type: 'integer', default: 16384, min: 1, max: Number.MAX_SAFE_INTEGER,
+    label: '完整说明预算 (UTF-8 bytes)', labelEn: 'Full contract budget (UTF-8 bytes)',
+    description: '显式 full 可以超出此预算；不截断调用契约。', descriptionEn: 'Explicit full selections may exceed this budget; calling contracts are never truncated.' },
+  { key: 'capabilityDirectoryBytes', type: 'integer', default: 2048, min: 512, max: Number.MAX_SAFE_INTEGER,
+    label: '能力导航预算 (UTF-8 bytes)', labelEn: 'Capability navigation budget (UTF-8 bytes)', description: '', descriptionEn: '' },
+  { key: 'capabilityRecoveryBytes', type: 'integer', default: 8192, min: 1, max: Number.MAX_SAFE_INTEGER,
+    label: '压缩后说明恢复预算 (UTF-8 bytes)', labelEn: 'Description recovery budget (UTF-8 bytes)', description: '', descriptionEn: '' },
+  { key: 'modelPreviewTokens', type: 'integer', default: 4096, min: 1, max: Number.MAX_SAFE_INTEGER,
+    label: '模型结果预览预算 (estimated tokens)', labelEn: 'Model result preview budget (estimated tokens)',
+    description: '选用模型侧预览时复用 DSH spill policy；完整内容需要宿主 spill store，程序值保持完整。',
+    descriptionEn: 'Uses DSH spill policy when model-facing previews are selected. Complete content requires a host spill store; program values remain complete.' },
   {
     key: 'legacyBindingSettings',
     type: 'boolean',
@@ -38,6 +88,15 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '开启时使用增强工具卡片；关闭后使用 DSH 原生工具卡片。',
     descriptionEn: 'Uses enhanced tool cards when enabled and DSH native tool cards when disabled.',
   },
+  {
+    key: 'toolHoverPreviewEnabled',
+    type: 'boolean',
+    default: true,
+    label: '悬停预览执行内容',
+    labelEn: 'Preview execution content on hover',
+    description: '在增强执行卡片上停留或键盘聚焦时显示简短预览；滚动时自动隐藏。',
+    descriptionEn: 'Shows a quick preview on enhanced tool cards after hovering or keyboard focus; hides while scrolling.',
+  },
   {
     key: 'replViewEnabled',
     type: 'boolean',
@@ -53,8 +112,8 @@ export const CONFIG_FIELDS = Object.freeze([
     default: true,
     label: '显示 PTC Plus 快捷入口',
     labelEn: 'Show the PTC Plus shortcut',
-    description: '在输入框旁显示 PTC Plus 快捷入口：查看和启停全局绑定、编写新绑定，并直接打开插件设置窗口；隐藏后仍可使用 /binding 命令。',
-    descriptionEn: 'Shows the PTC Plus shortcut beside the composer: global binding access and toggles, authoring, and direct access to the plugin settings dialog. Hiding it keeps /binding commands available.',
+    description: '在输入框旁显示星光菜单：打开插件设置、刷新当前会话能力，并在全局绑定开启时查看、启停和编写绑定；隐藏后仍可使用斜杠命令。',
+    descriptionEn: 'Shows the sparkle menu beside the composer: open settings, refresh current-session capabilities, and manage or author global bindings when enabled. Hiding it does not remove slash commands.',
   },
   {
     key: 'autoDescribeRunCode',
@@ -296,12 +355,6 @@ export const CONFIG_GROUPS = Object.freeze([
     labelEn: 'Plugin switch',
     fields: Object.freeze(['enabled']),
   },
-  {
-    key: 'calls',
-    label: '调用容错',
-    labelEn: 'Tool call tolerance',
-    fields: Object.freeze(['autoDescribeRunCode', 'canonicalizeToolCalls']),
-  },
   {
     key: 'syntax',
     label: 'REPL 语法',
@@ -322,11 +375,17 @@ export const CONFIG_GROUPS = Object.freeze([
     labelEn: 'Tool extensions',
     fields: Object.freeze(['userBindingsEnabled', 'cordisToolsEnabled']),
   },
+  {
+    key: 'calls',
+    label: '调用容错',
+    labelEn: 'Tool call tolerance',
+    fields: Object.freeze(['autoDescribeRunCode', 'canonicalizeToolCalls']),
+  },
   {
     key: 'interface',
     label: '界面显示',
     labelEn: 'Interface display',
-    fields: Object.freeze(['enhancedToolView', 'replViewEnabled', 'bindingAuthorButtonVisible']),
+    fields: Object.freeze(['enhancedToolView', 'toolHoverPreviewEnabled', 'replViewEnabled', 'bindingAuthorButtonVisible']),
   },
   {
     key: 'limits',
@@ -344,8 +403,19 @@ export const CONFIG_GROUPS = Object.freeze([
       'maxValueBigIntDigits',
     ]),
   },
+  { key: 'capabilities', label: '能力与上下文', labelEn: 'Capabilities and context',
+    fields: Object.freeze(['capabilityContextEnabled', 'capabilityManagementEnabled', 'capabilityBaseline', 'capabilityOverrides',
+      'capabilityStatistics', 'capabilityPolicy', 'capabilityRecoveryEnabled', 'modelPreviewEnabled', 'capabilityProfiles', 'capabilityBudgetBytes', 'capabilityDirectoryBytes', 'capabilityRecoveryBytes', 'modelPreviewTokens']) },
 ])
 
+/** Functional modules share the same section order across every settings entry. */
+export const CONFIG_MODULES = Object.freeze([
+  { key: 'workspace', label: '核心工作区', labelEn: 'Core workspace', groups: Object.freeze(['syntax', 'recovery']) },
+  { key: 'extensions', label: '扩展与容错', labelEn: 'Extensions and tolerance', groups: Object.freeze(['extensions', 'calls']) },
+  { key: 'presentation', label: '界面与资源', labelEn: 'Interface and resources', groups: Object.freeze(['interface', 'limits']) },
+  { key: 'experimental', label: '实验性', labelEn: 'Experimental', groups: Object.freeze(['capabilities']) },
+].map(Object.freeze))
+
 /** Resolved defaults, derived once from the field definitions. */
 export const CONFIG_DEFAULTS = Object.freeze(
   Object.fromEntries(CONFIG_FIELDS.map(field => [field.key, field.default])),

package/internal/cordis-tools-owner.js

@@ -149,8 +149,9 @@ function containsCompanionSkill(directory, fileExists) {
 
 /** Resolve the official Cordis companion Skill across DSH preset generations. */
 export async function resolveCompanionSkillDirectory(agentPresets, options = {}) {
-  const fileExists = options.fileExists ?? existsSync
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
+  const resolution = typeof options === 'function' ? options() : options
+  const fileExists = resolution.fileExists ?? existsSync
   if (typeof preset?.broken === 'string' && preset.broken.length > 0) {
     throw new Error(`ptc-plus: DSH cordis preset is unavailable: ${preset.broken}`)
   }
@@ -166,7 +167,7 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
   }
 
   for (const layout of COMPANION_PACKAGE_LAYOUTS) {
-    const pkg = options.packageOf?.(layout.name, options.packageBaseUrl)
+    const pkg = resolution.packageOf?.(layout.name, resolution.packageBaseUrl)
     if (pkg === undefined) continue
     if (pkg?.name !== layout.name || typeof pkg.dir !== 'string' || !isAbsolute(pkg.dir)) {
       throw new Error(`ptc-plus: DSH pluginPackages returned an invalid ${layout.name} package resource`)
@@ -175,10 +176,10 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
     if (containsCompanionSkill(directory, fileExists)) return directory
   }
 
-  if (options.packageOf === undefined && options.resolveLegacyPackageManifest !== undefined) {
+  if (resolution.packageOf === undefined && resolution.resolveLegacyPackageManifest !== undefined) {
     let manifest
     try {
-      manifest = options.resolveLegacyPackageManifest('@deepseek-ai/dsh-agent-presets/package.json')
+      manifest = resolution.resolveLegacyPackageManifest('@deepseek-ai/dsh-agent-presets/package.json')
     } catch (error) {
       if (error?.code !== 'MODULE_NOT_FOUND' && error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') throw error
     }
@@ -320,22 +321,24 @@ export function createCordisToolsOwner(
   const cordisInspectLeases = createCordisInspectLeases(ctx)
   const scopedCordisPlugin = cordisInspectLeases.plugin(cordisPlugin)
   const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin)
-  const pluginPackages = ctx.get?.('pluginPackages')
   const packageBaseUrl = ctx.baseUrl
-  const skillResolution = companionResolution ?? {
-    packageOf: pluginPackages === undefined
-      ? undefined
-      : (name, parentURL) => {
-          if (typeof pluginPackages?.packageOf !== 'function') {
-            throw new Error('ptc-plus: cordisToolsEnabled requires the DSH pluginPackages.packageOf API')
-          }
-          return pluginPackages.packageOf(name, parentURL)
-        },
-    packageBaseUrl,
-    resolveLegacyPackageManifest: pluginPackages === undefined && typeof packageBaseUrl === 'string'
-      ? specifier => createRequire(packageBaseUrl).resolve(specifier)
-      : undefined,
-  }
+  const skillResolution = companionResolution ?? (() => {
+    const pluginPackages = ctx.get?.('pluginPackages')
+    return {
+      packageOf: pluginPackages === undefined
+        ? undefined
+        : (name, parentURL) => {
+            if (typeof pluginPackages?.packageOf !== 'function') {
+              throw new Error('ptc-plus: cordisToolsEnabled requires the DSH pluginPackages.packageOf API')
+            }
+            return pluginPackages.packageOf(name, parentURL)
+          },
+      packageBaseUrl,
+      resolveLegacyPackageManifest: pluginPackages === undefined && typeof packageBaseUrl === 'string'
+        ? specifier => createRequire(packageBaseUrl).resolve(specifier)
+        : undefined,
+    }
+  })
   let disposed = false
 
   const leafErrors = error => error instanceof AggregateError