dsh-ptc-plus 0.3.2 → 0.4.1

package/internal/repl-value-observer.js

@@ -0,0 +1,114 @@
+import { types } from 'node:util'
+import { runInContext } from 'node:vm'
+import { parse } from 'acorn'
+import { randomUUID } from 'node:crypto'
+import { walkAst, SKIP_AST_CHILDREN } from './ast-traversal.js'
+import { bindingNodes } from './binding-pattern-traversal.js'
+
+const MAX_ENTRIES = 128
+const MAX_TEXT = 512
+const MAX_PROPERTIES = 5
+const ownDescriptor = Object.getOwnPropertyDescriptor
+const isArray = Array.isArray
+const isProxy = types.isProxy
+const stringify = JSON.stringify
+const now = Date.now
+const bigintText = BigInt.prototype.toString
+const BIGINT_LIMIT = 10n ** 128n
+const unreadable = () => ({ status: 'unreadable', text: '', truncated: false })
+
+function primitiveText(value) {
+  if (typeof value === 'string') return stringify(value.slice(0, MAX_TEXT))
+  if (typeof value === 'bigint') return value > -BIGINT_LIMIT && value < BIGINT_LIMIT
+    ? `${bigintText.call(value)}n` : '[bigint: more than 128 digits]'
+  if (typeof value === 'symbol' || typeof value === 'function') return `[${typeof value}: unreadable]`
+  if (value === null) return 'null'
+  if (typeof value === 'object') return isProxy(value) ? '[proxy: unreadable]' : '[object]'
+  return Object.is(value, -0) ? '-0' : String(value)
+}
+
+/** Inspect own descriptors only, rejecting proxies before any reflective operation. */
+export function previewBindingValue(value) {
+  if (['function', 'symbol'].includes(typeof value)) return unreadable()
+  if (value === null || typeof value !== 'object') {
+    const text = primitiveText(value)
+    return { status: 'readable', text: text.slice(0, MAX_TEXT), truncated: text.length > MAX_TEXT
+      || (typeof value === 'bigint' && (value <= -BIGINT_LIMIT || value >= BIGINT_LIMIT)) }
+  }
+  // Only arrays provide a finite slot range without enumerating the whole object.
+  if (isProxy(value) || !isArray(value)) return unreadable()
+  const keys = Array.from({ length: Math.min(ownDescriptor(value, 'length').value, MAX_PROPERTIES) }, (_value, index) => String(index))
+  const properties = keys.map(key => {
+    const descriptor = ownDescriptor(value, key)
+    const text = descriptor === undefined ? '[empty]'
+      : Object.hasOwn(descriptor, 'value') ? primitiveText(descriptor.value) : '[accessor: unreadable]'
+    return `${stringify(key)}: ${text}`
+  })
+  const text = `array { ${properties.join(', ')} }`
+  // Uninspected own properties remain unknown even when all indexed slots fit.
+  return { status: 'readable', text: text.slice(0, MAX_TEXT), truncated: true }
+}
+
+/** Probe the actual evaluator without consulting a Node version or any session value. */
+export async function supportsAwaitLexicals(context, evaluate) {
+  const prefix = `__ptc_observation_${randomUUID().replaceAll('-', '')}`
+  const names = [`${prefix}_let`, `${prefix}_const`]
+  try {
+    await evaluate(`let ${names[0]} = await Promise.resolve(41); const ${names[1]} = 42;`)
+    return names.every((name, index) => ownDescriptor(context, name) === undefined
+      && runInContext(name, context, { timeout: 25 }) === index + 41)
+  } catch {
+    return false
+  } finally {
+    // Lexical probe names are private and never enter the binding inventory.
+    for (const name of names) delete context[name]
+  }
+}
+
+/** Successful programs prove storage; await lexical reads additionally require a runtime probe. */
+export function createReplValueObserver(context, { awaitLexicals = false } = {}) {
+  const lexicals = new Set()
+  const globals = new Set()
+  return {
+    record(program) {
+      try {
+        const tree = parse(program, { ecmaVersion: 'latest', allowAwaitOutsideFunction: true })
+        let awaits = false
+        walkAst(tree, node => {
+          if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(node.type)) return SKIP_AST_CHILDREN
+          if (node.type === 'AwaitExpression' || node.await === true) awaits = true
+        })
+        if (awaits && !awaitLexicals) return
+        for (const statement of tree.body) {
+          if (statement.type !== 'VariableDeclaration') continue
+          for (const declaration of statement.declarations) {
+            for (const binding of bindingNodes(declaration.id)) {
+              (statement.kind === 'var' ? globals : lexicals).add(binding.name)
+            }
+          }
+        }
+      } catch {}
+    },
+    observe(names) {
+      const at = now()
+      const entries = names.slice(0, MAX_ENTRIES).map(name => {
+        let preview = unreadable()
+        try {
+          if (lexicals.has(name)) {
+            // Lexical storage shadows global properties, even while uninitialized.
+            if (/^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(name) && now() - at < 100) {
+              preview = previewBindingValue(runInContext(name, context, { timeout: 25, displayErrors: false }))
+            }
+          } else if (globals.has(name)) {
+            const descriptor = ownDescriptor(context, name)
+            if (descriptor !== undefined && Object.hasOwn(descriptor, 'value')) {
+              preview = previewBindingValue(descriptor.value)
+            }
+          }
+        } catch {}
+        return { name, ...preview }
+      })
+      return { at, entries }
+    },
+  }
+}

package/internal/rpc-contract.js

@@ -0,0 +1,52 @@
+import Schema from '@deepseek-ai/schemastery'
+import { strictCodec } from './typert-codec-compat.js'
+
+const resultSchema = Schema.union([
+  Schema.object({ ok: Schema.const(true).required(), value: Schema.any() }),
+  Schema.object({
+    ok: Schema.const(false).required(),
+    error: Schema.object({
+      code: Schema.string().required(),
+      message: Schema.string().required(),
+      details: Schema.any().required(),
+    }).required(),
+  }),
+]).required()
+
+/** Shared executable wire definitions; business payload validation stays with each owner. */
+export const RPC_CONTRACTS = Object.freeze({
+  bindings: Object.freeze({ service: 'ptcPlusBindings' }),
+  repl: Object.freeze({ service: 'ptcPlusRepl' }),
+})
+
+export function rpcDescriptor({ service }) {
+  return {
+    id: `dsh-ptc-plus#${service}/invoke`,
+    service,
+    namespace: service,
+    method: 'invoke',
+    invocation: { kind: 'direct' },
+    parameters: [
+      { name: 'operation', wire: 'operation', source: 'json',
+        codec: strictCodec({
+          typeSymbol: 'dsh-ptc-plus#RpcOperation',
+          schema: Schema.string().required(),
+        }) },
+      { name: 'payload', wire: 'payload', source: 'json',
+        codec: strictCodec({
+          typeSymbol: 'dsh-ptc-plus#RpcPayload',
+          schema: Schema.any(),
+        }) },
+    ],
+    cancellation: { parameter: 'signal' },
+    result: strictCodec({
+      typeSymbol: 'dsh-ptc-plus#RpcResult',
+      schema: resultSchema,
+    }),
+  }
+}
+
+export const RPC_REMOTE = Object.freeze({
+  package: 'dsh-ptc-plus',
+  descriptors: Object.values(RPC_CONTRACTS).map(rpcDescriptor),
+})

package/internal/runtime-bridge-owner.js

@@ -1,5 +1,6 @@
-/** Own the CodeRuntime patch, per-cell lease, journal projection, and session settlement. */
+/** Own the execution-seam takeover, per-cell lease, journal projection, and session settlement. */
 import { AsyncLocalStorage } from 'node:async_hooks'
+import { executionPolicies } from './binding-update-policy.js'
 import { assertObjectJsonSchema, validateJsonSchemaValue } from '@deepseek-ai/dsh-tools'
 import { normalizeBindingDescriptors } from './binding-descriptors.js'
 import { SessionRuntime } from './session-runtime.js'
@@ -20,7 +21,14 @@ import {
 } from './program-bindings.js'
 import { deepFreeze } from './record-utils.js'
 import { withReplMemorySnapshot } from './repl-memory-projection.js'
+import { withUserBindingDraftCapability } from './user-binding-draft-projection.js'
 import { generatedRunCodeDescriptionMeta } from './run-code-description.js'
+import { BINDING_SUBMISSION } from './user-binding-authoring.js'
+import {
+  USER_BINDINGS_META_KEY,
+  userBindingsSnapshotsEqual,
+  withUserBindingsSnapshot,
+} from './user-bindings.js'
 
 export const RUN_CODE = 'run_code'
 
@@ -63,12 +71,12 @@ const PROGRAM_CAPABILITY_METADATA = deepFreeze([
     namespace: 'repl',
     members: [{
       name: 'state',
-      description: 'List, save, restore, or delete named durable REPL states.',
+      description: 'Manage named REPL checkpoints. list returns checkpoint names, not variable names. Save captures the final durable state of this cell, including subsequent mutations; it is lost if the cell becomes volatile or is discarded. Save, restore and delete take effect after cell settlement and journal confirmation, not when the receipt is awaited. Restore changes bindings for subsequent cells and does not undo external effects.',
       parameters: {
         type: 'object',
         properties: {
-          action: { enum: ['list', 'save', 'restore', 'delete'] },
-          name: { type: 'string' },
+          action: { enum: ['list', 'save', 'restore', 'delete'], description: 'list reads the current cell control view, including tentative names; mutations are accepted for settlement.' },
+          name: { type: 'string', description: 'Required for save/delete; omit for restore to select the durable head.' },
         },
         oneOf: [
           { required: ['action'], properties: { action: { const: 'list' } } },
@@ -77,7 +85,19 @@ const PROGRAM_CAPABILITY_METADATA = deepFreeze([
           { required: ['action', 'name'], properties: { action: { const: 'delete' } } },
         ],
       },
-      returns: { type: 'object' },
+      returns: {
+        type: 'object',
+        properties: {
+          action: { enum: ['save', 'restore', 'delete'] },
+          name: { type: 'string' },
+          saved: { const: true, description: 'Save accepted for the final durable cell boundary, subject to settlement and confirmation.' },
+          restored: { const: true, description: 'Restore accepted; use a later cell to compute from restored bindings.' },
+          deleted: { const: true, description: 'Deletion accepted for settlement; removes the checkpoint name, not external effects.' },
+          names: { type: 'array', items: { type: 'string' }, description: 'Sorted checkpoint names in the current cell control view, including tentative operations.' },
+          mode: { enum: ['durable', 'volatile'] },
+          volatileReason: { type: 'string' },
+        },
+      },
       effect: 'ptc-state',
       authority: 'ptc-plus-program-binding',
       completeness: 'complete',
@@ -123,26 +143,71 @@ const PROGRAM_CAPABILITY_METADATA = deepFreeze([
 
 export function createRuntimeBridgeOwner({
   ctx,
+  seam,
   sessionConfig,
+  userBindingsCwd,
+  observeSession,
   maxNestedRunCodeDepth,
   presentationGeneration,
   sessionId,
   toolSchemasForAgent,
+  userBindingDraftForAgent,
+  bindingSubmissionForAgent,
 }) {
   const scope = new AsyncLocalStorage()
+  const childScope = new AsyncLocalStorage()
+  const childRuntimes = new Set()
+  const childDisposals = new WeakMap()
+  const childFinalizers = new WeakSet()
+  const disposeChildRuntime = (child) => {
+    let disposal = childDisposals.get(child)
+    if (disposal === undefined) {
+      disposal = child.dispose()
+      childDisposals.set(child, disposal)
+    }
+    return disposal
+  }
   // AgentRegistry.withInitiator is AsyncLocalStorage-based. The arrow preserves
   // its receiver when a worker callback re-enters the host tool pipeline.
   const withInitiator = ctx.agents === undefined || typeof ctx.agents.withInitiator !== 'function'
     ? undefined
     : (agent, operation) => ctx.agents.withInitiator(agent, operation)
-  const sessions = new SessionRuntime(sessionConfig, { withInitiator })
+  const sessions = new SessionRuntime(sessionConfig, { withInitiator, userBindingsCwd, observeSession })
   let currentConfig = sessions.config
-  const runtime = ctx.codeRuntime
-  const ownRun = Object.getOwnPropertyDescriptor(runtime, 'run')
-  const upstreamRun = runtime.run
   const patchedDefinitions = new Map()
   const pending = new WeakMap()
+  const nativeRunCodeHandoffs = new Set()
   let active = true
+  const runIsolated = async (request, executionToken, depth, cellConfig, inheritedTools) => {
+    const child = new SessionRuntime({ ...cellConfig, durableReplay: false, userBindingsEnabled: false,
+      replViewEnabled: false }, { withInitiator, userBindingsCwd })
+    childRuntimes.add(child)
+    const projected = projectBindings(request, depth, executionToken, inheritedTools, cellConfig)
+    childFinalizers.add(child)
+    try {
+      return await child.run({ id: 'isolated-cell', session: { header: {
+        cwd: executionToken?.session?.header?.cwd,
+      } } }, { ...projected.request, executionToken })
+    } finally {
+      projected.release()
+      try {
+        await disposeChildRuntime(child)
+        childRuntimes.delete(child)
+      } finally {
+        childDisposals.delete(child)
+        childFinalizers.delete(child)
+      }
+    }
+  }
+  const withDraftCapability = (meta, current) => currentConfig.userBindingsEnabled !== true
+    || typeof userBindingDraftForAgent !== 'function'
+    ? meta
+    : withUserBindingDraftCapability(
+        meta,
+        userBindingDraftForAgent(current.agent),
+        presentationGeneration,
+        current.bindingCandidate ?? null,
+      )
 
   const projectBindings = (
     request,
@@ -165,7 +230,7 @@ export function createRuntimeBridgeOwner({
       toolsNamespace === undefined ? Object.create(null) : toolsNamespace.functions
     )
     const ensureLease = () => {
-      if (!lease.active) throw new Error('PTC execution lease expired')
+      if (!active || !lease.active) throw new Error('PTC execution lease expired')
     }
     const runCode = async (value) => {
       ensureLease()
@@ -173,13 +238,42 @@ export function createRuntimeBridgeOwner({
       if (depth >= cellConfig.maxNestedRunCodeDepth) {
         throw new RangeError(`code.run recursion depth exceeds configured maximum ${cellConfig.maxNestedRunCodeDepth}`)
       }
-      if (typeof functions[RUN_CODE] === 'function') return functions[RUN_CODE](args)
+      const languageSemantics = executionPolicies(cellConfig).languageSemantics
+      const nativeRunCode = functions[RUN_CODE]
+      if (typeof nativeRunCode === 'function') {
+        ensureLease()
+        let settleHandoff
+        const handoff = {
+          active: true,
+          executionToken,
+          depth: depth + 1,
+          cellConfig,
+          functions,
+          settled: new Promise(resolve => { settleHandoff = resolve }),
+        }
+        nativeRunCodeHandoffs.add(handoff)
+        try {
+          return await childScope.run(handoff, () => nativeRunCode.call(functions, args))
+        } finally {
+          handoff.active = false
+          nativeRunCodeHandoffs.delete(handoff)
+          settleHandoff()
+        }
+      }
+      if (languageSemantics !== 'legacy-v1') {
+        const child = await runIsolated({ ...request, program: args.code }, executionToken,
+          depth + 1, cellConfig, functions)
+        if (child.error !== undefined) {
+          throw new Error(`nested run_code failed (${child.error.kind}): ${child.error.message}`)
+        }
+        return { logs: child.logs, ...(child.value === undefined ? {} : { result: child.value }) }
+      }
       const childProjected = projectBindings(
         { ...request, program: args.code }, depth + 1, executionToken, functions, cellConfig,
       )
       let child
       try {
-        child = await upstreamRun.call(runtime, childProjected.request)
+        child = await seam.invokeUpstream(childProjected.request)
       } finally {
         childProjected.release()
       }
@@ -224,7 +318,10 @@ export function createRuntimeBridgeOwner({
     )))
     const metadata = Object.freeze([
       ...toolCapabilityMetadata(schemas, annotations),
-      ...PROGRAM_CAPABILITY_METADATA,
+      ...PROGRAM_CAPABILITY_METADATA.map(entry => entry.namespace === 'code'
+        && cellConfig.userBindingsEnabled === true
+        ? { ...entry, members: [...entry.members, BINDING_SUBMISSION] }
+        : entry),
     ])
     projected.push(namespace('capabilities', {
       tree: async value => {
@@ -246,7 +343,14 @@ export function createRuntimeBridgeOwner({
         return capabilityInspect(metadata, value.symbols, value.budget)
       },
     }, 'CapabilityExplorationError', 'operation'))
-    projected.push(namespace('code', { run: runCode }, 'CodeExecutionError', 'operation'))
+    projected.push(namespace('code', {
+      run: runCode,
+      ...(cellConfig.userBindingsEnabled === true ? {
+        submitBindingDraft: bindingSubmissionForAgent(executionToken?.agent, ensureLease, candidate => {
+          executionToken.bindingCandidate = candidate
+        }),
+      } : {}),
+    }, 'CodeExecutionError', 'operation'))
     return { request: { ...request, bindings: projected }, release }
   }
 
@@ -278,8 +382,12 @@ export function createRuntimeBridgeOwner({
         meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
       }
       if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+      if (settlement.userBindings !== undefined) {
+        meta = withUserBindingsSnapshot(meta, settlement.userBindings)
+      }
       meta = generatedRunCodeDescriptionMeta(args, meta)
-      return withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
+      meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
+      return withDraftCapability(meta, current)
     }
     const ownExecute = Object.getOwnPropertyDescriptor(definition, 'execute')
     const originalExecute = definition.execute
@@ -324,11 +432,22 @@ export function createRuntimeBridgeOwner({
   }
 
   const patchedRun = function (request) {
-    if (!active) return upstreamRun.call(runtime, request)
+    const child = childScope.getStore()
+    if (child !== undefined) {
+      if (!active || !child.active) return Promise.reject(new Error('PTC execution lease expired'))
+      if (executionPolicies(child.cellConfig).languageSemantics !== 'legacy-v1') {
+        return runIsolated(request, child.executionToken, child.depth, child.cellConfig, child.functions)
+      }
+    }
+    if (!active) return seam.invokeUpstream(request)
     const current = scope.getStore()
-    if (current === undefined) return upstreamRun.call(runtime, request)
+    if (current === undefined) return seam.invokeUpstream(request)
     const projected = projectBindings(request, 0, current)
-    return sessions.runTentative(current, { ...projected.request, executionToken: current })
+    return sessions.runTentative(current, {
+      ...projected.request,
+      executionToken: current,
+      ...(current.userBindings === undefined ? {} : { userBindings: current.userBindings }),
+    })
       .then((execution) => {
         current.settlement = execution.settlement
         return execution.result
@@ -336,11 +455,7 @@ export function createRuntimeBridgeOwner({
       .finally(projected.release)
   }
 
-  Object.defineProperty(runtime, 'run', {
-    configurable: true,
-    writable: true,
-    value: patchedRun,
-  })
+  const releaseSeam = seam.takeOver(patchedRun)
 
   return Object.freeze({
     config: sessions.config,
@@ -348,6 +463,7 @@ export function createRuntimeBridgeOwner({
       sessions.reconfigure(nextConfig)
       currentConfig = sessions.config
     },
+    observeRepl(id, memory, signal) { return sessions.observe(id, memory, signal) },
     // A composite tool's outer result owns the final durability decision.
     async executeTentative(callSeq, operation) {
       const settlement = {
@@ -373,7 +489,7 @@ export function createRuntimeBridgeOwner({
         throw error
       }
     },
-    handleExecute(exec, next, executionArguments = exec.arguments) {
+    handleExecute(exec, next, executionArguments = exec.arguments, userBindings = undefined) {
       if (exec.parent !== undefined) return scope.run(undefined, next)
       const id = sessionId(exec.agent)
       if (id === undefined) return next()
@@ -390,6 +506,7 @@ export function createRuntimeBridgeOwner({
         session: exec.agent?.session,
         agent: exec.agent,
         executionArguments,
+        ...(userBindings === undefined ? {} : { userBindings }),
       }
       if (current.deferredSettlement !== undefined) {
         current.deferredSettlement.current = current
@@ -404,7 +521,11 @@ export function createRuntimeBridgeOwner({
             meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
           }
           if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+          if (settlement.userBindings !== undefined) {
+            meta = withUserBindingsSnapshot(meta, settlement.userBindings)
+          }
           meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
+          meta = withDraftCapability(meta, current)
           return { ...result, meta }
         }
         return result
@@ -429,6 +550,12 @@ export function createRuntimeBridgeOwner({
           Object.hasOwn(meta, RECOVERY_BOUNDARY_KEY) ? meta[RECOVERY_BOUNDARY_KEY] : undefined,
           settlement.recoveryBoundaries,
         )
+        && userBindingsSnapshotsEqual(
+          Object.hasOwn(meta, USER_BINDINGS_META_KEY)
+            ? meta[USER_BINDINGS_META_KEY]
+            : undefined,
+          settlement.userBindings,
+        )
       if (current.deferredSettlement !== undefined) {
         current.deferredSettlement.innerConfirmed = confirmed
         return
@@ -443,10 +570,20 @@ export function createRuntimeBridgeOwner({
     },
     async dispose() {
       active = false
-      if (runtime.run === patchedRun) {
-        if (ownRun === undefined) delete runtime.run
-        else Object.defineProperty(runtime, 'run', ownRun)
+      const failures = []
+      const children = [...childRuntimes]
+      const childResultsPromise = Promise.allSettled(
+        children.map(child => disposeChildRuntime(child)),
+      )
+      await Promise.all([...nativeRunCodeHandoffs].map(handoff => handoff.settled))
+      const childResults = await childResultsPromise
+      for (const [index, result] of childResults.entries()) {
+        const child = children[index]
+        if (!childFinalizers.has(child)) childDisposals.delete(child)
+        if (result.status === 'rejected') failures.push(result.reason)
+        else childRuntimes.delete(child)
       }
+      releaseSeam()
       for (const patched of patchedDefinitions.values()) {
         if (patched.output.presentationMeta === patched.patchedPresentationMeta) {
           if (patched.originalPresentationMeta === undefined) delete patched.output.presentationMeta
@@ -459,7 +596,14 @@ export function createRuntimeBridgeOwner({
         }
       }
       patchedDefinitions.clear()
-      await sessions.dispose()
+      try {
+        await sessions.dispose()
+      } catch (error) {
+        failures.push(error)
+      }
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus runtime bridge disposal failed')
+      }
     },
   })
 }

package/internal/runtime-config.js

@@ -1,65 +1,66 @@
 import {
   CONFIG_DEFAULTS,
+  CONFIG_FIELDS,
   MAX_TIMER_DELAY_MS,
 } from './config-spec.js'
 
 export { MAX_TIMER_DELAY_MS }
 
-/** Positive-safe-integer limits applied to runtime budget fields. */
-const BUDGET_KEYS = Object.freeze([
-  'computeMs',
-  'maxOutputBytes',
-  'maxOldGenerationSizeMb',
-  'maxValueNodes',
-  'maxValueEdges',
-  'maxValueArrayLength',
-  'maxValueBigIntDigits',
-])
+/** The wall-clock ceiling field carries the platform timer limit as its maximum. */
+const MAX_WALL_MS_FIELD = CONFIG_FIELDS.find(field => field.key === 'maxWallMs')
 
-/** Boolean runtime behavior switches. */
-const BOOLEAN_KEYS = Object.freeze([
-  'enhancedToolView',
-  'autoDescribeRunCode',
-  'cordisToolsEnabled',
-  'canonicalizeToolCalls',
-  'looseTopLevelRedeclarations',
-  'looseTopLevelFunctionClassRedeclarations',
-  'durableReplay',
-  'autoRewriteImports',
-  'autoStripExports',
-  'autoSplitRedeclarations',
-  'tipsEnabled',
-])
+/** Validate one integer field against the bounds declared in CONFIG_FIELDS. */
+function assertIntegerField(field, value) {
+  if (!Number.isSafeInteger(value) || value < field.min) {
+    throw new TypeError(`ptc-plus: ${field.key} must be a positive safe integer`)
+  }
+  if (value > field.max) {
+    throw new TypeError(`ptc-plus: ${field.key} must not exceed ${field.max}`)
+  }
+}
 
-/** Positive-safe-integer field groups that validate like budgets. */
-const POSITIVE_KEYS = Object.freeze([
-  'maxNestedRunCodeDepth',
-  'tipCooldownMessages',
-  'tipEscalationFailures',
-])
+/** Validate one field against its CONFIG_FIELDS declaration. */
+function assertField(field, value) {
+  if (field.type === 'boolean') {
+    if (typeof value !== 'boolean') {
+      throw new TypeError(`ptc-plus: ${field.key} must be a boolean`)
+    }
+    return
+  }
+  if (field.type === 'enum') {
+    if (!field.options.includes(value)) {
+      throw new TypeError(`ptc-plus: ${field.key} must be one of ${field.options.join(', ')}`)
+    }
+    return
+  }
+  assertIntegerField(field, value)
+}
 
 /**
  * Resolve plugin/runtime config from raw input, applying the shared defaults
- * and the same validation the Host Config schema exposes.
- * @param config - raw config object; unknown keys are preserved for forwards compatibility.
+ * and validating every declared field with the rules the Host Config schema
+ * exposes. Unknown keys are preserved for forwards compatibility.
+ * @param config - raw config object.
  * @returns a resolved config object.
  */
 export function resolveConfig(config = {}) {
   const resolved = { ...CONFIG_DEFAULTS, ...config }
-  if (typeof resolved.enabled !== 'boolean') {
-    throw new TypeError('ptc-plus: enabled must be a boolean')
-  }
-  for (const key of [...BUDGET_KEYS, ...POSITIVE_KEYS]) {
-    const value = resolved[key]
-    if (!Number.isSafeInteger(value) || value < 1) {
-      throw new TypeError(`ptc-plus: ${key} must be a positive safe integer`)
-    }
-  }
-  validateMaxWallMs(resolved.maxWallMs)
-  for (const key of BOOLEAN_KEYS) {
-    if (typeof resolved[key] !== 'boolean') {
-      throw new TypeError(`ptc-plus: ${key} must be a boolean`)
-    }
+  for (const field of CONFIG_FIELDS) assertField(field, resolved[field.key])
+  // Migrate complete old policies; mixed choices retain their explicit
+  // compatibility state until the user selects the unified language.
+  const legacyKeys = [
+    'looseTopLevelRedeclarations', 'looseTopLevelFunctionClassRedeclarations',
+    'autoRewriteImports', 'autoStripExports', 'autoSplitRedeclarations',
+  ]
+  if (!Object.hasOwn(config, 'bindingUpdates')
+    && legacyKeys.some(key => Object.hasOwn(config, key))) {
+    if (legacyKeys.every(key => resolved[key] === true)) {
+      resolved.bindingUpdates = 'stateful'
+    } else if (legacyKeys.slice(0, 2).every(key => resolved[key] === false)
+      && resolved.autoSplitRedeclarations === false
+      && resolved.autoRewriteImports && resolved.autoStripExports) {
+      resolved.bindingUpdates = 'protected'
+    } else resolved.legacyBindingSettings = true
   }
   return resolved
 }
@@ -70,11 +71,6 @@ export function resolveConfig(config = {}) {
  * @returns the validated value.
  */
 export function validateMaxWallMs(value) {
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TypeError('ptc-plus: maxWallMs must be a positive safe integer')
-  }
-  if (value > MAX_TIMER_DELAY_MS) {
-    throw new TypeError(`ptc-plus: maxWallMs must not exceed ${MAX_TIMER_DELAY_MS}`)
-  }
+  assertIntegerField(MAX_WALL_MS_FIELD, value)
   return value
 }