dsh-ptc-plus 0.4.10 → 0.5.1

package/internal/repl-observation-interest.js

@@ -12,6 +12,11 @@ export function createReplObservationInterest(ctx, initiallyEnabled, observe = a
     for (const watcher of [...watchers]) watcher.release()
     for (const controller of inspections) controller.abort()
   }
+  const releaseEvents = typeof ctx.on === 'function' ? ctx.effect(() => ctx.on('session/event', session => {
+    for (const watcher of [...watchers]) {
+      if (watcher.sessionId === session.id) watcher.changed()
+    }
+  }), 'ptc-plus: model source observation changes') : undefined
   const handler = async (endpoint, payload, signal) => {
     if (!enabled || !['watch', 'observe'].includes(endpoint) || typeof payload?.sessionId !== 'string'
       || payload.sessionId.length === 0 || payload.sessionId.length > 256
@@ -32,11 +37,13 @@ export function createReplObservationInterest(ctx, initiallyEnabled, observe = a
       }
     }
     return new Promise(resolve => {
-      const watcher = { sessionId: payload.sessionId, release() {
+      const finish = value => {
         signal.removeEventListener('abort', watcher.release)
         watchers.delete(watcher)
-        resolve({ ok: true, value: null })
-      } }
+        resolve({ ok: true, value })
+      }
+      const watcher = { sessionId: payload.sessionId,
+        release: () => finish(null), changed: () => finish({ changed: true }) }
       watchers.add(watcher)
       signal.addEventListener('abort', watcher.release, { once: true })
       if (signal.aborted) watcher.release()
@@ -62,6 +69,7 @@ export function createReplObservationInterest(ctx, initiallyEnabled, observe = a
     async dispose() {
       enabled = false
       clear()
+      await releaseEvents?.()
       for (const release of [...registrations]) await release()
       if (typeof injection === 'function') await injection()
       else await injection?.dispose?.()

package/internal/rpc-contract.js

@@ -17,6 +17,7 @@ const resultSchema = Schema.union([
 export const RPC_CONTRACTS = Object.freeze({
   bindings: Object.freeze({ service: 'ptcPlusBindings' }),
   repl: Object.freeze({ service: 'ptcPlusRepl' }),
+  capabilities: Object.freeze({ service: 'ptcPlusCapabilities' }),
 })
 
 export function rpcDescriptor({ service }) {

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,93 @@ 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 targetDescription = pendingEdit.targetDescription ?? `run_code call ${pendingEdit.targetCallSeq}`
+          const status = outcome.edited
+            ? `edit_run_code settled${outcome.error === undefined ? '' : ' with execution error'} (target ${targetDescription})`
+            : `edit_run_code did not execute the accepted revision (target ${targetDescription})`
+          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?.exec === exec && inherited.submission?.sessionId === id)) return operation()
     const submission = sessions.beginSubmission({ id }, exec.signal)
+    const composite = ownsDerived
+      ? {
+          persistedCallSeq: inherited.persistedCallSeq,
+          sourceCallSeq: inherited.sourceCallSeq,
+          sessionLog: inherited.sessionLog,
+          deferredSettlement: inherited.deferredSettlement,
+          derivedExecution: inherited.derivedExecution,
+        }
+      : {}
     try {
-      return await scope.run({ ...inherited, submission }, operation)
+      // Only reentry for this exact execution shares admission. Background
+      // continuations can inherit a settled execution's asynchronous context.
+      // Only proved derived edits retain composite source and settlement under
+      // a fresh admission; other roots own a fresh log and no child handoff.
+      return await scope.run({ ...composite, exec, submission }, () => childScope.run(undefined, operation))
     } finally {
       sessions.releaseSubmission(submission)
     }
@@ -479,6 +655,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 +683,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 +709,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 +738,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 +768,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 +827,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 +857,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