dsh-ptc-plus 0.3.2 → 0.4.1

package/internal/compiler-service.js

@@ -0,0 +1,109 @@
+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'
+import { installCompilerPlatform } from './compiler-platform.js'
+import { compilerDescriptors } from './compiler-descriptors.js'
+
+export { PreflightError } from './cell-analysis-contract.js'
+
+const bundleUrl = new URL('../compiler-core.cjs', import.meta.url)
+const filename = fileURLToPath(bundleUrl)
+const directory = fileURLToPath(new URL('./', bundleUrl))
+const compilerSource = readFileSync(bundleUrl, 'utf8')
+const NativeScript = Script
+const nativeCreateContext = createContext
+const dontContextify = constants.DONT_CONTEXTIFY
+const runInContext = Script.prototype.runInContext
+const createCachedData = Script.prototype.createCachedData
+const NativeUint8Array = Uint8Array
+const apply = Reflect.apply
+const hasInstance = Function.prototype[Symbol.hasInstance]
+const nativeErrors = { Error, SyntaxError, TypeError, RangeError, ReferenceError,
+  EvalError, URIError, ModuleRewriteError, PreflightError }
+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
+// 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
+  ? new NativeUint8Array(workerData.compilerCache.data) : undefined
+// Keep the snapshot private before source code can inspect workerData.
+if (workerData !== null && typeof workerData === 'object') delete workerData.compilerCache
+
+/** 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) }
+}
+
+/** Service errors are rehomed here before execution-realm translation. */
+export const isCompilerSyntaxError = error => apply(hasInstance, nativeErrors.SyntaxError, [error])
+
+function compilerEntry() {
+  if (compiler !== undefined) return compiler
+  // 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 = undefined
+  const context = nativeCreateContext(dontContextify)
+  define(context, '__compilerBaseUrl', { value: import.meta.url })
+  define(context, '__filename', { value: filename })
+  define(context, '__dirname', { value: directory })
+  installCompilerPlatform(context)
+  apply(runInContext, compilerScript, [context, { __proto__: null, displayErrors: false }])
+  compiler = context.module.exports.compile
+  return compiler
+}
+
+function compile(operation, args, originalSource) {
+  const result = compilerEntry()(operation, args, originalSource)
+  if (result.error !== undefined) {
+    const { kind, message, properties } = result.error
+    const ErrorClass = nativeErrors[kind] ?? nativeErrors.Error
+    const error = ErrorClass === PreflightError
+      ? new PreflightError(message, undefined, copyCompilerData(properties.span?.value)) : new ErrorClass(message)
+    const names = keys(properties)
+    for (let index = 0; index < names.length; index++) {
+      const name = names[index]
+      const property = properties[name]
+      if (name === 'stack' || !('value' in property)) continue
+      define(error, name, { ...property, value: copyCompilerData(property.value) })
+    }
+    throw error
+  }
+  return copyCompilerData(result.value)
+}
+
+export const prepareProgram = (source, options) => compile('prepareProgram', [source, options])
+export const prepareConsoleProgram = (source, options) => compile('prepareConsoleProgram', [source, options])
+export const classifyDurability = (source, known, options) => compile('classifyDurability', [source, known, options])
+export const compileModuleSource = (source, options) => compile('compileStatefulModule', [source, options])
+export const detectModuleSourceFormat = (source, options) => compile('detectModuleSourceFormat', [source, options])
+export const attachNamespaceSource = (source, attributes, reference, regions) =>
+  compile('attachModuleNamespace', [source, attributes, reference, regions])
+export const linkCommonJsEvidenceSource = (source, prefix) => compile('linkCommonJsEvidenceSource', [source, prefix])
+export const identifier = (value, subject, reserved) => compile('identifier', [value, subject, reserved])
+export const exportedSymbols = (source, transform) => compile('exportedSymbols', [source, transform])
+export const sourceDurability = (source, transform) => compile('sourceDurability', [source, transform])
+export const hashText = (source, encoding, format) => compile('hashText', [source, encoding, format])
+export const deflateText = source => compile('deflateText', [source])
+export const inflateText = (source, maxOutputBytes) => compile('inflateText', [source, maxOutputBytes])
+export const createCallableSourceCatalog = (buffers, ranges) => compile('createCallableSourceCatalog', [buffers, ranges])
+export function compileDynamicSource(source, { resolveOriginalSource, ...options } = {}) {
+  return compile('compileDynamicEnvironmentSource', [source, options], resolveOriginalSource)
+}

package/internal/compiler-source-cache.js

@@ -0,0 +1,32 @@
+import { copyCompilerData } from './compiler-data.js'
+
+/** Cache source-derived metadata within one compiler generation. Input and
+ * output data stay private; callers receive fresh collections on every read. */
+export function createCompilerSourceCache(compute, { maxEntries = 64, maxCharacters = 512 * 1024 } = {}) {
+  const entries = new Map()
+  let characters = 0
+  return (source, transform) => {
+    // Unsupported inputs retain the owner's original validation and errors.
+    if (typeof source !== 'string' || transform !== undefined && typeof transform !== 'string') {
+      return compute(source, transform)
+    }
+    const key = JSON.stringify([source, transform])
+    const cached = entries.get(key)
+    if (cached !== undefined) {
+      entries.delete(key)
+      entries.set(key, cached)
+      return copyCompilerData(cached.value)
+    }
+    const value = compute(source, transform)
+    if (maxEntries > 0 && key.length <= maxCharacters) {
+      while (entries.size >= maxEntries || characters + key.length > maxCharacters) {
+        const oldest = entries.keys().next().value
+        entries.delete(oldest)
+        characters -= oldest.length
+      }
+      entries.set(key, { value })
+      characters += key.length
+    }
+    return copyCompilerData(value)
+  }
+}

package/internal/compiler-source-pieces.js

@@ -0,0 +1,93 @@
+import { createSourceMapBuilder } from './source-position-map.js'
+
+const WIDTH = 6
+const BLOCK_SIZE = 4096
+const TEXT = 0, COPY = 1, MAPPED = 2, JOIN = 3, REGION = 4
+
+/** A numeric piece graph owns output without one object per copied token. */
+export function createSourcePieces(source) {
+  const blocks = []
+  const strings = []
+  const regionFacts = []
+  const stringIds = new Map()
+  let count = 0
+  const get = (id, field) => blocks[Math.floor(id / BLOCK_SIZE)][id % BLOCK_SIZE * WIDTH + field]
+  const put = (size, kind, left, right = 0, start = 0, end = 0) => {
+    if (count % BLOCK_SIZE === 0) blocks.push(new Uint32Array(BLOCK_SIZE * WIDTH))
+    const id = count++
+    blocks.at(-1).set([size, kind, left, right, start, end], id % BLOCK_SIZE * WIDTH)
+    return id
+  }
+  const stringId = value => {
+    let id = stringIds.get(value)
+    if (id === undefined) { id = strings.length; strings.push(value); stringIds.set(value, id) }
+    return id
+  }
+  const length = id => get(id, 0)
+  const text = value => put(value.length, TEXT, stringId(value))
+  const original = (start, end) => put(end - start, COPY, start, end)
+  const mapped = (value, node) => put(value.length, MAPPED, stringId(value), 0, node.start, node.end)
+  const region = (piece, fact) => {
+    const index = regionFacts.length
+    regionFacts.push(fact)
+    return put(length(piece), REGION, piece, index)
+  }
+  const empty = text('')
+  const pair = (left, right) => {
+    if (length(left) === 0) return right
+    if (length(right) === 0) return left
+    if (get(left, 1) === COPY && get(right, 1) === COPY && get(left, 3) === get(right, 2)) {
+      return original(get(left, 2), get(right, 3))
+    }
+    return put(length(left) + length(right), JOIN, left, right)
+  }
+  const join = parts => {
+    const combine = (start, end) => end <= start ? empty : end === start + 1 ? parts[start]
+      : pair(combine(start, (start + end) >>> 1), combine((start + end) >>> 1, end))
+    return combine(0, parts.length)
+  }
+  const slice = (id, start, end = length(id)) => {
+    const size = length(id)
+    if (start === 0 && end === size) return id
+    const kind = get(id, 1), left = get(id, 2), right = get(id, 3)
+    if (kind === REGION) return slice(left, start, end)
+    if (kind === JOIN) {
+      const split = length(left)
+      if (end <= split) return slice(left, start, end)
+      if (start >= split) return slice(right, start - split, end - split)
+      return pair(slice(left, start), slice(right, 0, end - split))
+    }
+    if (kind === COPY) return original(left + start, left + end)
+    const value = strings[left].slice(start, end)
+    if (kind === TEXT) return text(value)
+    const from = get(id, 4), to = get(id, 5), linear = to - from === size
+    return mapped(value, { start: from + (linear ? start : 0), end: linear ? from + end : to })
+  }
+  const emit = id => {
+    const chunks = []
+    let pending = []
+    const mappings = createSourceMapBuilder()
+    const regions = []
+    let offset = 0
+    const visit = id => {
+      const size = length(id)
+      if (size === 0) return
+      const kind = get(id, 1), left = get(id, 2), right = get(id, 3)
+      if (kind === JOIN) { visit(left); visit(right); return }
+      if (kind === REGION) {
+        regions.push({ ...regionFacts[right], start: offset, end: offset + size })
+        visit(left)
+        return
+      }
+      pending.push(kind === COPY ? source.slice(left, right) : strings[left])
+      if (pending.length === BLOCK_SIZE) { chunks.push(pending.join('')); pending = [] }
+      if (kind !== TEXT) mappings.push({ generatedStart: offset, generatedEnd: offset + size,
+        originalStart: kind === COPY ? left : get(id, 4), originalEnd: kind === COPY ? right : get(id, 5) })
+      offset += size
+    }
+    visit(id)
+    chunks.push(pending.join(''))
+    return { text: chunks.join(''), mappings: mappings.finish(), regions }
+  }
+  return { text, original, mapped, join, slice, emit, length, region }
+}

package/internal/compiler-source-regions.js

@@ -0,0 +1,132 @@
+import traverseModule, { NodePath } from '@babel/traverse'
+import { types as t } from '@babel/core'
+
+const traverse = traverseModule.default ?? traverseModule
+const SOURCE_CONTEXT = Object.freeze({ opts: Object.freeze({ noScope: true }) })
+
+class SourceScope {
+  constructor(id, nodeId, parentId) { this.id = id; this.nodeId = nodeId; this.parentId = parentId }
+  get path() { return this.index.get(this.block) }
+  getFunctionParent() {
+    for (let scope = this; scope; scope = scope.parent) {
+      if (t.isFunction(scope.block) || t.isStaticBlock(scope.block)) return scope
+    }
+    return null
+  }
+  getProgramParent() {
+    let scope = this
+    while (scope.parent) scope = scope.parent
+    return scope
+  }
+}
+
+export function sourcePath(node, parentPath, container, key, listKey = null, scope = null) {
+  const path = new NodePath(undefined, parentPath?.node ?? container)
+  path.parentPath = parentPath
+  path.container = container
+  path.key = key
+  path.listKey = listKey
+  path.node = node
+  path.type = node.type
+  path.setContext(SOURCE_CONTEXT)
+  path.scope = scope
+  return path
+}
+
+/** Visit source facts with Babel's syntax predicates, retaining only ancestry.
+ * These paths do not enter Babel's whole-tree path/scope caches. Mutating
+ * transforms use separately bounded work trees instead. */
+export function visitSource(tree, visitor) {
+  const handlers = traverse.visitors.explode({ ...visitor, noScope: true })
+  const callbacks = new Map()
+  let stopped = false
+  const visit = (parentPath, container, key, listKey) => {
+    const node = container[key]
+    if (node === null || node === undefined) return
+    const path = sourcePath(node, parentPath, container, key, listKey)
+    let selected = callbacks.get(node.type)
+    if (selected === undefined) {
+      selected = { enter: [...handlers.enter ?? [], ...handlers[node.type]?.enter ?? []],
+        exit: [...handlers[node.type]?.exit ?? [], ...handlers.exit ?? []] }
+      callbacks.set(node.type, selected)
+    }
+    for (const handler of selected.enter) {
+      handler(path)
+      if (path.shouldStop) { stopped = true; return }
+      if (path.shouldSkip) return
+    }
+    for (const field of t.VISITOR_KEYS[node.type] ?? []) {
+      if (path.skipKeys?.[field]) continue
+      const child = node[field]
+      if (Array.isArray(child)) {
+        for (let index = 0; index < child.length && !stopped; index++) visit(path, child, index, field)
+      } else if (!stopped) visit(path, node, field, null)
+    }
+    for (const handler of selected.exit) {
+      handler(path)
+      if (path.shouldStop) { stopped = true; return }
+    }
+  }
+  if (tree.type === 'File') visit(null, tree, 'program', null)
+  else visit(null, { root: tree }, 'root', null)
+}
+
+/** Compact ancestry survives a work tree; NodePaths are materialized on demand. */
+export function indexSource(tree) {
+  const ids = new WeakMap()
+  const nodes = [], parentIds = [], keys = [], lists = [], scopeIds = []
+  const scopes = []
+  const visit = (node, parentId, key, listKey) => {
+    if (node === null || node === undefined) return
+    const parent = parentId === undefined ? tree : nodes[parentId]
+    const id = nodes.length
+    ids.set(node, id)
+    nodes.push(node)
+    parentIds.push(parentId ?? -1)
+    keys.push(key)
+    lists.push(listKey)
+    let parentScope = parentId === undefined ? -1 : scopeIds[parentId]
+    if (parentId !== undefined && (key === 'key' || listKey === 'decorators') && t.isMethod(parent)
+      || parentId !== undefined && key === 'discriminant' && t.isSwitchStatement(parent)) {
+      parentScope = scopes[parentScope]?.parentId ?? -1
+    }
+    let scopeId = parentScope
+    if (t.isScope(node, parent)) {
+      scopeId = scopes.length
+      scopes.push(new SourceScope(scopeId, id, parentScope))
+    }
+    scopeIds.push(scopeId)
+    for (const field of t.VISITOR_KEYS[node.type] ?? []) {
+      const child = node[field]
+      if (Array.isArray(child)) {
+        for (let index = 0; index < child.length; index++) visit(child[index], id, index, field)
+      } else visit(child, id, field, null)
+    }
+  }
+  visit(tree.type === 'File' ? tree.program : tree, undefined, tree.type === 'File' ? 'program' : 'root', null)
+  const parents = Int32Array.from(parentIds)
+  const nodeScopes = Int32Array.from(scopeIds)
+  const get = node => {
+    let id = ids.get(node)
+    if (id === undefined) return undefined
+    const ancestors = []
+    while (id >= 0) { ancestors.push(id); id = parents[id] }
+    let path = null
+    for (let index = ancestors.length - 1; index >= 0; index--) {
+      id = ancestors[index]
+      const node = nodes[id]
+      const container = lists[id] === null ? path?.node ?? tree : path.node[lists[id]]
+      path = sourcePath(node, path, container, keys[id], lists[id], scopes[nodeScopes[id]])
+    }
+    return path
+  }
+  const index = { get, ids, nodes, scopes, scopeFor: node => scopes[nodeScopes[ids.get(node)]],
+    parentFor: node => nodes[parents[ids.get(node)]] ?? tree,
+  }
+  for (const scope of scopes) {
+    scope.block = nodes[scope.nodeId]
+    scope.parent = scopes[scope.parentId] ?? null
+    scope.index = index
+  }
+  return index
+}

package/internal/compiler-storage-source.js

@@ -0,0 +1,54 @@
+/** One construction contract for compiler-owned storage in every emitted realm. */
+export const compilerStorageSource = `(object, WeakMap, WeakSet, symbol, promise, reflect, arrayConstructor, functionPrototype) => {
+  const define = object.defineProperty, defineProperties = object.defineProperties, setPrototype = object.setPrototypeOf;
+  const uncurry = functionPrototype.bind.bind(functionPrototype.call);
+  const descriptor = (value,writable=false,configurable=false) => {
+    const result=object.create(null);result.value=value;result.writable=writable;result.configurable=configurable;return result;
+  };
+  if(symbol.dispose===void 0)define(symbol,'dispose',descriptor(symbol.for('nodejs.dispose')));
+  if(symbol.asyncDispose===void 0)define(symbol,'asyncDispose',descriptor(symbol.for('nodejs.asyncDispose')));
+  const mapMethods = object.create(null), setMethods = object.create(null);
+  for (const name of ['get','set','has','delete']) mapMethods[name] = descriptor(WeakMap.prototype[name]);
+  for (const name of ['has','add','delete']) setMethods[name] = descriptor(WeakSet.prototype[name]);
+  const values = uncurry(arrayConstructor.prototype.values);
+  const arrayMethods = object.create(null);
+  for (const name of ['push','pop','unshift']) arrayMethods[name] = descriptor(arrayConstructor.prototype[name]);
+  const apply = reflect.apply;
+  for (const name of ['concat','splice']) {
+    const operation = arrayConstructor.prototype[name];
+    arrayMethods[name] = descriptor(function(...args){return array(apply(operation,this,args))});
+  }
+  const next = uncurry(object.getPrototypeOf(values([])).next);
+  const description = uncurry(object.getOwnPropertyDescriptor(symbol.prototype,'description').get);
+  const then = uncurry(promise.prototype.then);
+  function array(value){
+    setPrototype(value,null);
+    defineProperties(value,arrayMethods);
+    define(value,'constructor',descriptor(void 0,true,true));
+    define(value,symbol.iterator,descriptor(function(){
+      const iterator=values(value);
+      setPrototype(iterator,null);
+      define(iterator,'next',descriptor(function(){return next(iterator)}));
+      return iterator;
+    },false,true));
+    return value;
+  }
+  return {
+    functionCall:functionPrototype.call,functionApply:functionPrototype.apply,functionBind:functionPrototype.bind,
+    promiseThen:promise.prototype.then,
+    record(value){return setPrototype(value,null)},
+    observeOwnedPromise(value,fulfilled,rejected){
+      setPrototype(value,null);
+      then(value,result=>{try{fulfilled(result)}catch(error){rejected(error)}},rejected);
+    },
+    async awaitValue(value,fulfilled,rejected){
+      let result;
+      try{result=await value}catch(error){if(rejected)return await rejected(error);throw error}
+      return await fulfilled(result);
+    },
+    weakMapStore(){return defineProperties(new WeakMap(),mapMethods)},
+    weakSetStore(){return defineProperties(new WeakSet(),setMethods)},
+    symbolDescription:description,
+    array
+  };
+}`

package/internal/compiler-text.js

@@ -0,0 +1,15 @@
+import { createHash } from 'node:crypto'
+import { deflateRawSync, inflateRawSync } from 'node:zlib'
+
+/** Exact source facts cross the compiler boundary as strings, never buffers. */
+export function hashText(source, encoding = 'utf8', format = 'base64') {
+  return createHash('sha256').update(source, encoding).digest(format)
+}
+
+export function deflateText(source) {
+  return deflateRawSync(Buffer.from(source, 'utf16le')).toString('base64')
+}
+
+export function inflateText(encoded, maxOutputBytes) {
+  return inflateRawSync(Buffer.from(encoded, 'base64'), { maxOutputLength: maxOutputBytes }).toString('utf16le')
+}

package/internal/compiler-typescript.cjs

@@ -0,0 +1,2 @@
+// Keep the maintained legacy decorator compiler lazy in both source and bundle.
+module.exports = () => require('typescript')

package/internal/config-spec.js

@@ -5,12 +5,21 @@ export const MAX_TIMER_DELAY_MS = 2_147_483_647
 export const SETTINGS_NAMESPACE = 'ptc-plus'
 
 /**
- * Ordered field definitions for the plugin configuration card. `label` and
+ * Shared field definitions for the Host schema and settings card. `label` and
  * `description` are the canonical Host schema copy; `labelEn` and
  * `descriptionEn` carry the English settings-card copy. A field's description
  * exists in both locales or in neither.
  */
 export const CONFIG_FIELDS = Object.freeze([
+  {
+    key: 'legacyBindingSettings',
+    type: 'boolean',
+    default: false,
+    label: '旧绑定设置迁移状态',
+    labelEn: 'Legacy binding settings migration state',
+    description: '',
+    descriptionEn: '',
+  },
   {
     key: 'enabled',
     type: 'boolean',
@@ -29,6 +38,24 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '开启时使用增强工具卡片；关闭后使用 DSH 原生工具卡片。',
     descriptionEn: 'Uses enhanced tool cards when enabled and DSH native tool cards when disabled.',
   },
+  {
+    key: 'replViewEnabled',
+    type: 'boolean',
+    default: true,
+    label: '显示 REPL 页签',
+    labelEn: 'Show REPL tab',
+    description: '在 PTC 会话中显示 REPL 工作台；隐藏后仍可从设置管理全局绑定。',
+    descriptionEn: 'Shows the REPL workspace in PTC sessions. Global bindings remain manageable in Settings.',
+  },
+  {
+    key: 'bindingAuthorButtonVisible',
+    type: 'boolean',
+    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.',
+  },
   {
     key: 'autoDescribeRunCode',
     type: 'boolean',
@@ -38,6 +65,16 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '允许 run_code 缺少外层 description；关闭后恢复 DSH 校验。模型请求和原始调用参数保持不变。',
     descriptionEn: 'Allows run_code to omit its outer description; disabling restores DSH validation. Model requests and original call arguments remain unchanged.',
   },
+  {
+    key: 'bindingUpdates',
+    type: 'enum',
+    options: Object.freeze(['stateful', 'protected']),
+    default: 'stateful',
+    label: '允许重声明和覆盖',
+    labelEn: 'Allow redeclarations and overrides',
+    description: '同一作用域的声明和赋值可更新变量、函数、类及导入。关闭后检测跨 cell 重声明，并保护新建的 const 和 import；静态 import/export 始终可用。',
+    descriptionEn: 'Declarations and assignments update variables, functions, classes and imports in the same scope. Disabling detects cross-cell redeclarations and protects newly created const and import bindings; static import/export remains available.',
+  },
   {
     key: 'canonicalizeToolCalls',
     type: 'boolean',
@@ -56,6 +93,15 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '开启后，PTC agent 可使用官方 Cordis 工具、配套指引和开发 Skill；关闭后移除这些能力。Cordis 工具以 DSH 进程权限运行。',
     descriptionEn: 'When enabled, PTC agents can use the official Cordis tools, guidance, and development Skill; disabling removes them. Cordis tools run with the DSH process permissions.',
   },
+  {
+    key: 'userBindingsEnabled',
+    type: 'boolean',
+    default: false,
+    label: '启用全局用户 Binding',
+    labelEn: 'Enable Global User Bindings',
+    description: '管理 TypeScript helper，并将已启用条目作为跨会话的默认 REPL 绑定。',
+    descriptionEn: 'Manages TypeScript helpers and loads enabled entries as default REPL bindings across sessions.',
+  },
   {
     key: 'looseTopLevelRedeclarations',
     type: 'boolean',
@@ -68,7 +114,7 @@ export const CONFIG_FIELDS = Object.freeze([
   {
     key: 'looseTopLevelFunctionClassRedeclarations',
     type: 'boolean',
-    default: false,
+    default: true,
     label: '允许顶层函数/类重声明',
     labelEn: 'Allow top-level function/class redeclarations',
     description: '允许顶层 function 或 class 声明替换已有的可写 binding；不可写或保留 binding 仍会在执行前被拒绝。',
@@ -125,10 +171,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 60_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '单 cell CPU 时间上限 (ms)',
-    labelEn: 'CPU time limit per cell (ms)',
-    description: '同步计算超过该上限时中断当前 cell。',
-    descriptionEn: 'Interrupts the current cell when synchronous computation exceeds this limit.',
+    label: '单 cell 事件循环活跃时间上限 (ms)',
+    labelEn: 'Event-loop active time limit per cell (ms)',
+    description: '包含同步阻塞等待，不等同于 CPU 用时；超限时丢弃当前 cell 并重置 worker。',
+    descriptionEn: 'Includes synchronous blocking, not just CPU use; exceeding the limit discards the cell and resets the worker.',
   },
   {
     key: 'maxWallMs',
@@ -242,34 +288,46 @@ export const CONFIG_FIELDS = Object.freeze([
   },
 ])
 
-/** Presentation groups keep high-attention decisions separate from advanced policy and limits. */
+/** Purpose-based presentation groups are independent of Host schema field order. */
 export const CONFIG_GROUPS = Object.freeze([
   {
-    key: 'core',
-    label: '常用与兼容性',
-    labelEn: 'Common and compatibility',
-    fields: Object.freeze(['enabled', 'enhancedToolView', 'autoDescribeRunCode', 'canonicalizeToolCalls']),
+    key: 'switch',
+    label: '插件开关',
+    labelEn: 'Plugin switch',
+    fields: Object.freeze(['enabled']),
   },
   {
-    key: 'optional',
-    label: '可选能力',
-    labelEn: 'Optional capabilities',
-    fields: Object.freeze(['cordisToolsEnabled']),
+    key: 'calls',
+    label: '调用容错',
+    labelEn: 'Tool call tolerance',
+    fields: Object.freeze(['autoDescribeRunCode', 'canonicalizeToolCalls']),
   },
   {
-    key: 'advanced',
-    label: '高级行为',
-    labelEn: 'Advanced behavior',
+    key: 'syntax',
+    label: 'REPL 语法',
+    labelEn: 'REPL syntax',
     fields: Object.freeze([
-      'looseTopLevelRedeclarations',
-      'looseTopLevelFunctionClassRedeclarations',
-      'autoRewriteImports',
-      'autoStripExports',
-      'autoSplitRedeclarations',
-      'durableReplay',
-      'tipsEnabled',
+      'bindingUpdates',
     ]),
   },
+  {
+    key: 'recovery',
+    label: '状态与恢复',
+    labelEn: 'State and recovery',
+    fields: Object.freeze(['durableReplay', 'tipsEnabled', 'tipCooldownMessages', 'tipEscalationFailures']),
+  },
+  {
+    key: 'extensions',
+    label: '工具扩展',
+    labelEn: 'Tool extensions',
+    fields: Object.freeze(['userBindingsEnabled', 'cordisToolsEnabled']),
+  },
+  {
+    key: 'interface',
+    label: '界面显示',
+    labelEn: 'Interface display',
+    fields: Object.freeze(['enhancedToolView', 'replViewEnabled', 'bindingAuthorButtonVisible']),
+  },
   {
     key: 'limits',
     label: '资源限制',
@@ -284,8 +342,6 @@ export const CONFIG_GROUPS = Object.freeze([
       'maxValueEdges',
       'maxValueArrayLength',
       'maxValueBigIntDigits',
-      'tipCooldownMessages',
-      'tipEscalationFailures',
     ]),
   },
 ])