dsh-ptc-plus 0.4.10 → 0.5.0

package/internal/runtime-bridge-owner.js

@@ -1,5 +1,8 @@
 /** Own the execution-seam takeover, per-cell lease, journal projection, and session settlement. */
 import { AsyncLocalStorage } from 'node:async_hooks'
+import { deepEqualJson, snapshotJsonValue } from '@deepseek-ai/dsh-util-values'
+import { decodeValue, renderValueWire } from './value-wire.js'
+import { valueLimitsFromConfig } from './value-wire-schema.js'
 import { executionPolicies } from './binding-update-policy.js'
 import { assertObjectJsonSchema, validateJsonSchemaValue } from '@deepseek-ai/dsh-tools'
 import { normalizeBindingDescriptors } from './binding-descriptors.js'
@@ -17,11 +20,13 @@ import {
   capabilityFind,
   capabilityInspect,
   capabilityTree,
+  createCapabilitySearcher,
   toolCapabilityMetadata,
 } from './program-bindings.js'
 import { deepFreeze } from './record-utils.js'
-import { withReplMemorySnapshot } from './repl-memory-projection.js'
+import { REPL_MEMORY_META_KEY, withReplMemorySnapshot } from './repl-memory-projection.js'
 import { withUserBindingDraftCapability } from './user-binding-draft-projection.js'
+import { POST_EDIT_KEY } from './session-journal-schema.js'
 import { generatedRunCodeDescriptionMeta } from './run-code-description.js'
 import { BINDING_SUBMISSION } from './user-binding-authoring.js'
 import {
@@ -71,7 +76,7 @@ const PROGRAM_CAPABILITY_METADATA = deepFreeze([
     namespace: 'repl',
     members: [{
       name: 'state',
-      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.',
+      description: 'Manage named REPL checkpoints. list returns checkpoint names, not variable names. Save requires a durable cell; a volatile save rejection leaves live bindings usable. 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 discards bindings beyond the selected durable state for subsequent cells; an omitted name selects the prior durable head, or an empty REPL if none exists. Restore does not undo external effects or change enabled binding configuration; subsequent cells may remain volatile.',
       parameters: {
         type: 'object',
         properties: {
@@ -128,7 +133,7 @@ const PROGRAM_CAPABILITY_METADATA = deepFreeze([
             description: 'Child console output in emission order.',
           },
           result: {
-            description: 'Child return value; omitted when the child returns undefined.',
+            description: 'Plugin-owned isolated execution preserves supported PTC Value V1 types and reference relationships; omitted for no return, present for explicit undefined. Native delegation and legacy upstream execution retain their original result contracts.',
           },
         },
         required: ['logs'],
@@ -154,6 +159,7 @@ export function createRuntimeBridgeOwner({
   toolSchemasForAgent,
   userBindingDraftForAgent,
   bindingSubmissionForAgent,
+  capabilityEnvironment,
 }) {
   const scope = new AsyncLocalStorage()
   const childScope = new AsyncLocalStorage()
@@ -173,22 +179,27 @@ export function createRuntimeBridgeOwner({
   const withInitiator = ctx.agents === undefined || typeof ctx.agents.withInitiator !== 'function'
     ? undefined
     : (agent, operation) => ctx.agents.withInitiator(agent, operation)
-  const sessions = new SessionRuntime(sessionConfig, { withInitiator, userBindingsCwd, observeSession, readSessionLog })
+  const sessions = new SessionRuntime(sessionConfig, {
+    withInitiator, userBindingsCwd, observeSession, readSessionLog,
+    sessionForId: id => ctx.get('sessions')?.get(id),
+  })
   let currentConfig = sessions.config
   const patchedDefinitions = new Map()
   const pending = new WeakMap()
   const nativeRunCodeHandoffs = new Set()
   let active = true
-  const runIsolated = async (request, executionToken, depth, cellConfig, inheritedTools) => {
+  const runIsolated = async (request, executionToken, depth, cellConfig, inheritedTools, programCompletion = false) => {
     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 })
+      const execution = await child.runTentative({ id: 'isolated-cell', session: { header: {
+        cwd: request.cwd ?? executionToken?.session?.header?.cwd,
+      } } }, { ...projected.request, executionToken }, { programCompletion })
+      if (execution.settlement !== undefined) child.finalize(execution.settlement, true)
+      return { result: execution.result, completion: execution.settlement?.journal.completion }
     } finally {
       projected.release()
       try {
@@ -263,11 +274,12 @@ export function createRuntimeBridgeOwner({
       }
       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}`)
+          depth + 1, cellConfig, functions, true)
+        if (child.result.error !== undefined) {
+          throw new Error(`nested run_code failed (${child.result.error.kind}): ${child.result.error.message}`)
         }
-        return { logs: child.logs, ...(child.value === undefined ? {} : { result: child.value }) }
+        return { logs: child.result.logs, ...(child.completion.hasValue
+          ? { result: decodeValue(child.completion.value, valueLimitsFromConfig(cellConfig)) } : {}) }
       }
       const childProjected = projectBindings(
         { ...request, program: args.code }, depth + 1, executionToken, functions, cellConfig,
@@ -284,7 +296,8 @@ export function createRuntimeBridgeOwner({
       return { logs: child.logs, ...(child.value === undefined ? {} : { result: child.value }) }
     }
 
-    const schemas = toolSchemasForAgent(executionToken?.agent)
+    const nativeSchemas = toolSchemasForAgent(executionToken?.agent)
+    const schemas = (capabilityEnvironment?.visibleSchemas(executionToken?.agent, nativeSchemas) ?? nativeSchemas)
       .filter(schema => schema?.name === RUN_CODE
         || (schema?.name !== EDIT_RUN_CODE && typeof functions[schema?.name] === 'function'))
     const emptyObjectTools = new Set(schemas.flatMap(schema => (
@@ -294,20 +307,30 @@ export function createRuntimeBridgeOwner({
     )))
     const projected = bindingDescriptors.namespaces.map((binding) => {
       const wrapped = Object.create(null)
-      for (const key of binding.members) {
+      const members = binding.global === 'tools'
+        ? capabilityEnvironment?.projectMembers(executionToken?.agent, binding.members) ?? binding.members
+        : binding.members
+      for (const key of members) {
+        const original = (...args) => binding.functions[key](...args)
+        const invoke = binding.global === 'tools'
+          ? capabilityEnvironment?.adaptFunction(executionToken?.agent, key, original) ?? original
+          : original
         Object.defineProperty(wrapped, key, {
           enumerable: true,
           value: async (...args) => {
             ensureLease()
-            return binding.functions[key](...args)
+            return binding.global === 'tools' && key === EDIT_RUN_CODE
+              ? scope.run(executionToken, () => invoke(...args))
+              : invoke(...args)
           },
         })
       }
       const emptyObjectMembers = binding.global === 'tools'
-        ? binding.members.filter(member => emptyObjectTools.has(member))
+        ? members.filter(member => emptyObjectTools.has(member))
         : []
       return {
         ...binding,
+        members,
         functions: wrapped,
         ...(binding.global === 'tools' ? { emptyObjectMembers } : {}),
       }
@@ -318,12 +341,14 @@ export function createRuntimeBridgeOwner({
         : []
     )))
     const metadata = Object.freeze([
-      ...toolCapabilityMetadata(schemas, annotations),
+      ...(capabilityEnvironment?.toolMetadata(executionToken?.agent, toolCapabilityMetadata(schemas, annotations), schemas) ?? toolCapabilityMetadata(schemas, annotations)),
+      ...(capabilityEnvironment?.metadata(executionToken?.agent) ?? []),
       ...PROGRAM_CAPABILITY_METADATA.map(entry => entry.namespace === 'code'
         && cellConfig.userBindingsEnabled === true
         ? { ...entry, members: [...entry.members, BINDING_SUBMISSION] }
         : entry),
     ])
+    let searchCapabilities
     projected.push(namespace('capabilities', {
       tree: async value => {
         if (value !== undefined) throw new TypeError('capabilities.tree does not accept arguments')
@@ -337,11 +362,24 @@ export function createRuntimeBridgeOwner({
       },
       inspect: async value => {
         ensureLease()
-        if (value === undefined) return capabilityInspect(metadata)
+        if (value === undefined) {
+          const result = capabilityInspect(metadata)
+          capabilityEnvironment?.explored(executionToken?.agent, result)
+          return result
+        }
         if (value === null || typeof value !== 'object' || Array.isArray(value)) {
           throw new TypeError('capabilities.inspect expects an object')
         }
-        return capabilityInspect(metadata, value.symbols, value.budget)
+        const result = capabilityInspect(metadata, value.symbols, value.budget)
+        capabilityEnvironment?.explored(executionToken?.agent, result)
+        return result
+      },
+      search: async value => {
+        ensureLease()
+        searchCapabilities ??= createCapabilitySearcher(metadata)
+        const result = searchCapabilities(value)
+        capabilityEnvironment?.explored(executionToken?.agent, result)
+        return result
       },
     }, 'CapabilityExplorationError', 'operation'))
     projected.push(namespace('code', {
@@ -367,6 +405,10 @@ export function createRuntimeBridgeOwner({
     const output = definition.output
     const ownPresentationMeta = Object.getOwnPropertyDescriptor(output, 'presentationMeta')
     const patchedPresentationMeta = (args, value) => {
+      const projectedCurrent = scope.getStore()
+      if (projectedCurrent !== undefined) {
+        projectedCurrent.presentationMetaCalls = (projectedCurrent.presentationMetaCalls ?? 0) + 1
+      }
       const prototype = Object.getPrototypeOf(output)
       const originalPresentationMeta = ownPresentationMeta === undefined
         ? prototype === null ? undefined : Reflect.get(prototype, 'presentationMeta', output)
@@ -374,8 +416,15 @@ export function createRuntimeBridgeOwner({
           ? ownPresentationMeta.value
           : ownPresentationMeta.get?.call(output)
       const base = originalPresentationMeta === undefined
-        ? undefined
-        : originalPresentationMeta.call(output, args, value)
+        // Installing a projector replaces an optional Host callback with a
+        // required JSON-producing callback, including policy reprojection
+        // after the execution scope has ended. An empty object conveys no
+        // computation evidence; a stale settlement must never fill that gap.
+        ? {}
+        : snapshotJsonValue(originalPresentationMeta.call(output, args, value))
+      // An invalid upstream projection is still the Host's output failure;
+      // adding plugin metadata must not make it appear valid.
+      if (base === undefined) return undefined
       if (!active) return base
       const current = scope.getStore()
       const settlement = current?.settlement
@@ -388,9 +437,50 @@ export function createRuntimeBridgeOwner({
       if (settlement.userBindings !== undefined) {
         meta = withUserBindingsSnapshot(meta, settlement.userBindings)
       }
+      if (current.postEdit?.provenance !== undefined) {
+        meta = { ...meta, [POST_EDIT_KEY]: current.postEdit.provenance }
+      }
       meta = generatedRunCodeDescriptionMeta(args, meta)
       meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
-      return withDraftCapability(meta, current)
+      if (current.postEdit?.provenance?.meta?.[REPL_MEMORY_META_KEY] !== undefined) {
+        meta = { ...meta,
+          [REPL_MEMORY_META_KEY]: current.postEdit.provenance.meta[REPL_MEMORY_META_KEY] }
+      }
+      meta = withDraftCapability(meta, current)
+      return capabilityEnvironment?.complete(current, { meta }).meta ?? meta
+    }
+    const ownProjectContent = Object.getOwnPropertyDescriptor(definition, 'projectContent')
+    const patchedProjectContent = (exec, result) => {
+      const prototype = Object.getPrototypeOf(definition)
+      const originalProjectContent = ownProjectContent === undefined
+        ? prototype === null ? undefined : Reflect.get(prototype, 'projectContent', definition)
+        : Object.hasOwn(ownProjectContent, 'value')
+          ? ownProjectContent.value : ownProjectContent.get?.call(definition)
+      const original = originalProjectContent?.call(definition, exec, result)
+      const current = active ? pending.get(exec) : undefined
+      const derived = current?.derivedExecution
+      // Some public Host implementations omit the metadata projector for a
+      // nested success. Capture its canonical value before policy; the private
+      // relation is admitted only if policy retains that same frozen value.
+      if (current?.deferredSettlement?.current === current && derived !== undefined
+        && current.exec === exec && exec.token !== undefined && exec.parent !== undefined
+        && current.id === sessionId(exec.agent) && derived.agent === exec.agent
+        && derived.callId === exec.callId && derived.rootCallId === exec.rootCallId
+        && derived.parent === exec.parent && deepEqualJson(derived.arguments, exec.arguments)
+        && current.presentationMetaCalls === undefined && result.isError === false
+        && result.value !== null && typeof result.value === 'object'
+        && Object.isFrozen(result.value) && result.meta?.[JOURNAL_KEY] === undefined
+        && current.settlement !== undefined) {
+        const metadata = scope.run(current, () => patchedPresentationMeta(exec.arguments, result.value))
+        if (metadata?.[JOURNAL_KEY] !== undefined) {
+          current.deferredSettlement.projection = { exec, token: exec.token,
+            value: result.value, meta: snapshotJsonValue(result.meta), metadata,
+            presentationMetaCalls: current.presentationMetaCalls }
+        }
+      }
+      const presentation = active ? pending.get(exec)?.postEdit?.presentation : undefined
+      if (presentation === undefined) return original
+      return [...original ?? result.content, ...presentation.content]
     }
     const ownExecute = Object.getOwnPropertyDescriptor(definition, 'execute')
     const originalExecute = definition.execute
@@ -409,6 +499,10 @@ export function createRuntimeBridgeOwner({
         value: patchedPresentationMeta,
       })
       presentationPatched = true
+      Object.defineProperty(definition, 'projectContent', {
+        configurable: true, enumerable: ownProjectContent?.enumerable ?? true,
+        writable: true, value: patchedProjectContent,
+      })
       if (patchedExecute !== undefined) {
         Object.defineProperty(definition, 'execute', {
           configurable: true,
@@ -422,10 +516,20 @@ export function createRuntimeBridgeOwner({
         output,
         ownPresentationMeta,
         patchedPresentationMeta,
+        ownProjectContent,
+        patchedProjectContent,
         ownExecute,
         patchedExecute,
       })
     } catch (error) {
+      if (definition.projectContent === patchedProjectContent) {
+        if (ownProjectContent === undefined) delete definition.projectContent
+        else Object.defineProperty(definition, 'projectContent', ownProjectContent)
+      }
+      if (patchedExecute !== undefined && definition.execute === patchedExecute) {
+        if (ownExecute === undefined) delete definition.execute
+        else Object.defineProperty(definition, 'execute', ownExecute)
+      }
       if (presentationPatched && output.presentationMeta === patchedPresentationMeta) {
         if (ownPresentationMeta === undefined) delete output.presentationMeta
         else Object.defineProperty(output, 'presentationMeta', ownPresentationMeta)
@@ -440,6 +544,7 @@ export function createRuntimeBridgeOwner({
       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)
+          .then(execution => execution.result)
       }
     }
     if (!active) return seam.runUpstream(request)
@@ -451,22 +556,90 @@ export function createRuntimeBridgeOwner({
       executionToken: current,
       ...(current.userBindings === undefined ? {} : { userBindings: current.userBindings }),
     })
-      .then((execution) => {
+      .then(async (execution) => {
         current.settlement = execution.settlement
-        return execution.result
+        const pendingEdit = current.pendingEdit
+        if (pendingEdit === undefined) return execution.result
+        if (!pendingEdit.confirmed || current.signal.aborted) {
+          pendingEdit.finish(false)
+          return execution.result
+        }
+        try {
+          const postEdit = await pendingEdit.dispatch(current.signal, current.exec)
+          current.postEdit = postEdit
+          for (const context of postEdit.presentation?.additionalContexts ?? []) {
+            current.exec.deferContext?.(context)
+          }
+          if (postEdit.presentation?.concludesTurn === true && execution.result.error === undefined) {
+            current.exec.concludeTurn?.()
+          }
+          const outcome = postEdit.outcome
+          const value = postEdit.provenance?.meta?.[JOURNAL_KEY]?.completion
+          const hasRenderedContent = postEdit.presentation?.content?.length > 0
+          let valueText = ''
+          if (!hasRenderedContent && value?.kind === 'return' && value.hasValue) {
+            try {
+              valueText = `; value: ${renderValueWire(value.value, {
+                ...valueLimitsFromConfig(current.submission?.config ?? currentConfig),
+                maxStringBytes: 2048,
+              })}`
+            } catch {
+              valueText = '; value omitted from preview'
+            }
+          }
+          const status = outcome.edited
+            ? `edit_run_code settled${outcome.error === undefined ? '' : ' with execution error'}`
+            : 'edit_run_code did not execute the accepted revision'
+          const detail = [
+            ...(hasRenderedContent || !Array.isArray(outcome.logs) ? [] : outcome.logs),
+            ...(!hasRenderedContent && typeof outcome.error === 'string' ? [outcome.error] : []),
+            ...(!hasRenderedContent && typeof outcome.reason === 'string' ? [outcome.reason] : []),
+          ].filter(item => typeof item === 'string').join('\n')
+          return { ...execution.result,
+            logs: [...execution.result.logs, `${status}${valueText}${detail ? `: ${detail}` : ''}`] }
+        } catch (error) {
+          pendingEdit.finish(false)
+          return { ...execution.result,
+            logs: [...execution.result.logs,
+              `edit_run_code failed after acceptance: ${error instanceof Error ? error.message : String(error)}`] }
+        }
       })
       .finally(projected.release)
   }
 
   const releaseSeam = seam.installExecute(patchedRun)
 
+  const ownedDerivedScope = (exec, executionArguments = exec.arguments) => {
+    const inherited = scope.getStore()
+    const derived = inherited?.derivedExecution
+    if (inherited?.deferredSettlement === undefined
+      || inherited.id !== sessionId(exec.agent) || derived?.agent !== exec.agent
+      || derived.callId !== exec.callId || derived.rootCallId !== exec.rootCallId
+      || derived.parent !== exec.parent || exec.name !== RUN_CODE
+      || !deepEqualJson(derived.arguments, executionArguments)) return undefined
+    return inherited
+  }
+
   const withSubmission = async (exec, operation) => {
     const id = sessionId(exec.agent)
     const inherited = scope.getStore()
-    if (exec.parent !== undefined || id === undefined || inherited?.submission?.sessionId === id) return operation()
+    const ownsDerived = ownedDerivedScope(exec) !== undefined
+    if ((exec.parent !== undefined && !ownsDerived) || id === undefined
+      || inherited?.submission?.sessionId === id) return operation()
     const submission = sessions.beginSubmission({ id }, exec.signal)
+    const composite = inherited?.deferredSettlement !== undefined && inherited.id === id
+      ? {
+          persistedCallSeq: inherited.persistedCallSeq,
+          sourceCallSeq: inherited.sourceCallSeq,
+          sessionLog: inherited.sessionLog,
+          deferredSettlement: inherited.deferredSettlement,
+          derivedExecution: inherited.derivedExecution,
+        }
+      : {}
     try {
-      return await scope.run({ ...inherited, submission }, operation)
+      // Derived edits retain their proved source under a fresh admission for
+      // the same session. Delegated agents own a fresh log and no child handoff.
+      return await scope.run({ ...composite, submission }, () => childScope.run(undefined, operation))
     } finally {
       sessions.releaseSubmission(submission)
     }
@@ -479,6 +652,25 @@ export function createRuntimeBridgeOwner({
     return sessionLog
   }
 
+  const readNestedDispatchLog = async (session, signal) => {
+    const inherited = scope.getStore()
+    if (inherited === undefined || inherited.session !== session
+      || inherited.signal.aborted || signal?.aborted) {
+      throw new Error('ptc-plus: nested edit has no active root run_code cell')
+    }
+    return readSessionLog(session, signal)
+  }
+
+  const rootEditScope = exec => {
+    const current = scope.getStore()
+    if (!active || current === undefined || childScope.getStore() !== undefined
+      || current.deferredSettlement !== undefined
+      || current.callId !== exec.rootCallId || current.agent !== exec.agent
+      || current.session !== exec.agent?.session || current.signal.aborted
+      || exec.signal?.aborted) return undefined
+    return current
+  }
+
   return Object.freeze({
     config: sessions.config,
     reconfigure(nextConfig) {
@@ -488,8 +680,18 @@ export function createRuntimeBridgeOwner({
     observeRepl(id, memory, signal) { return sessions.observe(id, memory, signal) },
     withSubmission,
     readSubmissionLog,
+    readNestedDispatchLog,
+    prepareAgent(agent) { patchRunCodeDefinition(agent) },
+    canScheduleEdit(exec) { return rootEditScope(exec) !== undefined },
+    scheduleEdit(exec, pendingEdit) {
+      const current = rootEditScope(exec)
+      if (current === undefined || current.pendingEdit !== undefined) return false
+      current.pendingEdit = pendingEdit
+      return true
+    },
     // A composite tool's outer result owns the final durability decision.
-    async executeTentative(callSeq, operation, sessionLog) {
+    async executeTentative(callSeq, sourceCallSeq, operation, sessionLog, derivedExecution) {
+      const id = scope.getStore()?.id
       const settlement = {
         current: undefined,
         innerConfirmed: false,
@@ -504,22 +706,27 @@ export function createRuntimeBridgeOwner({
       }
       try {
         const result = await scope.run({
-          ...(scope.getStore()?.submission === undefined ? {} : { submission: scope.getStore().submission }),
+          id,
           ...(callSeq === undefined ? {} : { persistedCallSeq: callSeq }),
+          ...(sourceCallSeq === undefined ? {} : { sourceCallSeq }),
           ...(sessionLog === undefined ? {} : { sessionLog }),
           deferredSettlement: settlement,
+          derivedExecution,
         }, operation)
-        return Object.freeze({ result, finalize })
+        return Object.freeze({ result, finalize,
+          ...(settlement.metadata === undefined ? {} : { metadata: settlement.metadata }) })
       } catch (error) {
         finalize(false)
         throw error
       }
     },
     async handleExecute(exec, next, executionArguments = exec.arguments, userBindings = undefined) {
-      if (exec.parent !== undefined) return scope.run(undefined, next)
+      const ownsDerived = ownedDerivedScope(exec, executionArguments) !== undefined
+      if (exec.parent !== undefined && !ownsDerived) return scope.run(undefined, next)
       return withSubmission(exec, async () => {
         const id = sessionId(exec.agent)
         if (id === undefined) return next()
+        await capabilityEnvironment?.prepare(exec.agent)
         patchRunCodeDefinition(exec.agent)
         const inherited = scope.getStore()
         const persistedCallSeq = inherited?.persistedCallSeq
@@ -528,12 +735,16 @@ export function createRuntimeBridgeOwner({
           submission: inherited?.submission,
           callId: String(exec.callId),
           ...(persistedCallSeq === undefined ? {} : { persistedCallSeq }),
+          ...(inherited?.sourceCallSeq === undefined ? {} : { sourceCallSeq: inherited.sourceCallSeq }),
           ...(inherited?.deferredSettlement === undefined
             ? {}
-            : { deferredSettlement: inherited.deferredSettlement }),
+            : { deferredSettlement: inherited.deferredSettlement,
+                derivedExecution: inherited.derivedExecution }),
           session: exec.agent?.session,
+          signal: exec.signal,
           sessionLog: await readSubmissionLog(exec.agent?.session, exec.signal),
           agent: exec.agent,
+          exec,
           executionArguments,
           ...(userBindings === undefined ? {} : { userBindings }),
         }
@@ -554,26 +765,47 @@ export function createRuntimeBridgeOwner({
             if (settlement.userBindings !== undefined) {
               meta = withUserBindingsSnapshot(meta, settlement.userBindings)
             }
+            if (current.postEdit?.provenance !== undefined) {
+              meta = { ...meta, [POST_EDIT_KEY]: current.postEdit.provenance }
+            }
             meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
+            if (current.postEdit?.provenance?.meta?.[REPL_MEMORY_META_KEY] !== undefined) {
+              meta = { ...meta,
+                [REPL_MEMORY_META_KEY]: current.postEdit.provenance.meta[REPL_MEMORY_META_KEY] }
+            }
             meta = withDraftCapability(meta, current)
-            return { ...result, meta }
+            return capabilityEnvironment?.complete(current, { ...result, meta }) ?? { ...result, meta }
           }
           return result
         })
       })
     },
     handleResult(exec, result) {
-      if (exec.parent !== undefined) return
+      if (exec.parent !== undefined && !pending.has(exec)) return
       const id = sessionId(exec.agent)
       if (id === undefined) return
       const current = pending.get(exec)
       pending.delete(exec)
       const settlement = current?.settlement
       if (settlement === undefined) {
+        current?.pendingEdit?.finish(false)
         sessions.noteNoop(id, current?.sessionLog, exec.callId)
         return
       }
-      const meta = result?.meta
+      const deferred = current.deferredSettlement
+      const projection = deferred?.projection
+      const derived = current.derivedExecution
+      const privateMetadata = projection !== undefined && projection.exec === exec
+        && deferred.current === current && current.exec === exec && current.id === id
+        && derived?.agent === exec.agent && derived.callId === exec.callId
+        && derived.rootCallId === exec.rootCallId && derived.parent === exec.parent
+        && deepEqualJson(derived.arguments, exec.arguments)
+        && projection.token === exec.token && projection.value === result?.value
+        && result.isError === false && deepEqualJson(projection.meta, result.meta)
+        && projection.presentationMetaCalls === current.presentationMetaCalls
+        ? projection.metadata : undefined
+      if (deferred !== undefined) deferred.metadata = privateMetadata
+      const meta = privateMetadata ?? result?.meta
       const confirmed = meta !== null && typeof meta === 'object' && !Array.isArray(meta)
         && Object.hasOwn(meta, JOURNAL_KEY)
         && journalsEqual(meta[JOURNAL_KEY], settlement.journal)
@@ -592,6 +824,8 @@ export function createRuntimeBridgeOwner({
         return
       }
       sessions.finalize(settlement, confirmed)
+      current.pendingEdit?.finish(confirmed && current.postEdit?.provenance !== undefined
+        && deepEqualJson(meta?.[POST_EDIT_KEY], current.postEdit.provenance))
     },
     disposeAgent(agent) {
       return sessions.disposeSession(sessionId(agent) ?? String(agent.id))
@@ -620,6 +854,10 @@ export function createRuntimeBridgeOwner({
           if (patched.ownPresentationMeta === undefined) delete patched.output.presentationMeta
           else Object.defineProperty(patched.output, 'presentationMeta', patched.ownPresentationMeta)
         }
+        if (patched.definition.projectContent === patched.patchedProjectContent) {
+          if (patched.ownProjectContent === undefined) delete patched.definition.projectContent
+          else Object.defineProperty(patched.definition, 'projectContent', patched.ownProjectContent)
+        }
         if (patched.patchedExecute !== undefined
           && patched.definition.execute === patched.patchedExecute) {
           if (patched.ownExecute === undefined) delete patched.definition.execute

package/internal/runtime-config.js

@@ -1,3 +1,4 @@
+import { capabilityPolicyForConfig } from './capability-policy.js'
 import {
   CONFIG_DEFAULTS,
   CONFIG_FIELDS,
@@ -6,6 +7,43 @@ import {
 
 export { MAX_TIMER_DELAY_MS }
 
+/** Reusable configurations contain capability settings, never session evidence. */
+export const CAPABILITY_CONFIGURATION_KEYS = Object.freeze(CONFIG_FIELDS
+  .filter(field => (field.key.startsWith('capability') && field.key !== 'capabilityProfiles') || ['modelPreviewTokens', 'modelPreviewEnabled'].includes(field.key))
+  .map(field => field.key))
+
+export function capabilityProfileConfiguration(value, { allowInvalidStatistics = false } = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some(key => !CAPABILITY_CONFIGURATION_KEYS.includes(key))) {
+    throw new TypeError('ptc-plus: invalid capability configuration fields')
+  }
+  const resolved = resolveConfig(value)
+  let statistics
+  try { statistics = JSON.parse(resolved.capabilityStatistics) } catch {}
+  if (!allowInvalidStatistics && (!statistics || typeof statistics.enabled !== 'boolean'
+    || !Number.isSafeInteger(statistics.windowSize) || statistics.windowSize < 1
+    || !Number.isSafeInteger(statistics.minimumSamples) || statistics.minimumSamples < 1 || statistics.minimumSamples > statistics.windowSize
+    || !Number.isFinite(statistics.fullThreshold) || statistics.fullThreshold < 0 || statistics.fullThreshold > 1)) {
+    throw new TypeError('ptc-plus: invalid saved capability statistics settings')
+  }
+  return Object.fromEntries(CAPABILITY_CONFIGURATION_KEYS.map(key => [key, resolved[key]]))
+}
+
+export function validateCapabilityProfiles(value) {
+  if (!value || value.schema !== 'ptc-capability-profiles/v1' || !Array.isArray(value.profiles) || value.profiles.length > 100) {
+    throw new TypeError('ptc-plus: invalid capability profiles document')
+  }
+  const ids = new Set()
+  const names = new Set()
+  return { schema: value.schema, profiles: value.profiles.map(profile => {
+    if (!profile || typeof profile.id !== 'string' || !profile.id.trim() || profile.id.length > 100
+      || typeof profile.name !== 'string' || !profile.name.trim() || profile.name.length > 80
+      || ids.has(profile.id) || names.has(profile.name.trim())) throw new TypeError('ptc-plus: invalid or duplicate capability profile')
+    ids.add(profile.id); names.add(profile.name.trim())
+    return { id: profile.id, name: profile.name.trim(), configuration: capabilityProfileConfiguration(profile.configuration) }
+  }) }
+}
+
 /** 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')
 
@@ -21,6 +59,10 @@ function assertIntegerField(field, value) {
 
 /** Validate one field against its CONFIG_FIELDS declaration. */
 function assertField(field, value) {
+  if (field.type === 'string') {
+    if (typeof value !== 'string') throw new TypeError(`ptc-plus: ${field.key} must be a string`)
+    return
+  }
   if (field.type === 'boolean') {
     if (typeof value !== 'boolean') {
       throw new TypeError(`ptc-plus: ${field.key} must be a boolean`)
@@ -74,6 +116,22 @@ export function resolveConfig(config = {}) {
     resolved[field.key] = liveConfigValue(resolved[field.key], CONFIG_DEFAULTS[field.key])
   }
   for (const field of CONFIG_FIELDS) assertField(field, resolved[field.key])
+  validateCapabilityProfiles(JSON.parse(resolved.capabilityProfiles))
+  for (const [key, array] of [['capabilityBaseline', true], ['capabilityOverrides', false]]) {
+    let value
+    try { value = JSON.parse(resolved[key]) } catch { throw new TypeError(`ptc-plus: ${key} must contain valid JSON`) }
+    if (array ? !Array.isArray(value) || value.some(id => typeof id !== 'string' || !id.trim())
+      : value === null || typeof value !== 'object' || Array.isArray(value)
+        || Object.entries(value).some(([id, selection]) => !id.trim() || !['full', 'on-demand', 'closed'].includes(selection)
+          || (id.startsWith('mcpServers.') && (id === 'mcpServers.' || selection !== 'closed')))) {
+      throw new TypeError(`ptc-plus: invalid ${key}`)
+    }
+  }
+  resolved.capabilityPolicy = JSON.stringify(capabilityPolicyForConfig(provided.has('capabilityPolicy') ? resolved : { ...resolved, capabilityPolicy: undefined }))
+  if (!provided.has('capabilityPolicy') && resolved.capabilityManagementEnabled) {
+    if (!provided.has('capabilityRecoveryEnabled')) resolved.capabilityRecoveryEnabled = true
+    if (!provided.has('modelPreviewEnabled')) resolved.modelPreviewEnabled = true
+  }
   // Migrate complete old policies; mixed choices retain their explicit
   // compatibility state until the user selects the unified language.
   const legacyKeys = [