dsh-ptc-plus 0.4.8 → 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'],
@@ -147,12 +152,14 @@ export function createRuntimeBridgeOwner({
   sessionConfig,
   userBindingsCwd,
   observeSession,
+  readSessionLog = async session => session,
   maxNestedRunCodeDepth,
   presentationGeneration,
   sessionId,
   toolSchemasForAgent,
   userBindingDraftForAgent,
   bindingSubmissionForAgent,
+  capabilityEnvironment,
 }) {
   const scope = new AsyncLocalStorage()
   const childScope = new AsyncLocalStorage()
@@ -172,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 })
+  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 {
@@ -262,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,
@@ -283,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 => (
@@ -293,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 } : {}),
       }
@@ -317,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')
@@ -336,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', {
@@ -364,16 +403,29 @@ export function createRuntimeBridgeOwner({
     }
     if (patchedDefinitions.has(definition)) return
     const output = definition.output
-    const originalPresentationMeta = output.presentationMeta
+    const ownPresentationMeta = Object.getOwnPropertyDescriptor(output, 'presentationMeta')
     const patchedPresentationMeta = (args, value) => {
-      if (!active) {
-        return originalPresentationMeta === undefined
-          ? undefined
-          : originalPresentationMeta(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)
+        : Object.hasOwn(ownPresentationMeta, 'value')
+          ? ownPresentationMeta.value
+          : ownPresentationMeta.get?.call(output)
       const base = originalPresentationMeta === undefined
-        ? undefined
-        : originalPresentationMeta(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
       if (settlement === undefined) return generatedRunCodeDescriptionMeta(args, base)
@@ -385,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
@@ -406,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,
@@ -417,15 +514,25 @@ export function createRuntimeBridgeOwner({
       patchedDefinitions.set(definition, {
         definition,
         output,
-        originalPresentationMeta,
+        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 (originalPresentationMeta === undefined) delete output.presentationMeta
-        else output.presentationMeta = originalPresentationMeta
+        if (ownPresentationMeta === undefined) delete output.presentationMeta
+        else Object.defineProperty(output, 'presentationMeta', ownPresentationMeta)
       }
       throw new Error(`ptc-plus: cannot attach the session journal to run_code results: ${error.message}`)
     }
@@ -437,25 +544,132 @@ 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.invokeUpstream(request)
+    if (!active) return seam.runUpstream(request)
     const current = scope.getStore()
-    if (current === undefined) return seam.invokeUpstream(request)
-    const projected = projectBindings(request, 0, current)
+    if (current === undefined) return seam.runUpstream(request)
+    const projected = projectBindings(request, 0, current, undefined, current.submission?.config ?? currentConfig)
     return sessions.runTentative(current, {
       ...projected.request,
       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.takeOver(patchedRun)
+  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()
+    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 {
+      // 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)
+    }
+  }
+
+  const readSubmissionLog = async (session, signal) => {
+    const inherited = scope.getStore()
+    const sessionLog = inherited?.sessionLog ?? await readSessionLog(session, signal)
+    if (inherited?.submission !== undefined) sessions.assertSubmission(inherited.submission)
+    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,
@@ -464,8 +678,20 @@ export function createRuntimeBridgeOwner({
       currentConfig = sessions.config
     },
     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) {
+    async executeTentative(callSeq, sourceCallSeq, operation, sessionLog, derivedExecution) {
+      const id = scope.getStore()?.id
       const settlement = {
         current: undefined,
         innerConfirmed: false,
@@ -480,69 +706,106 @@ export function createRuntimeBridgeOwner({
       }
       try {
         const result = await scope.run({
+          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
       }
     },
-    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()
-      patchRunCodeDefinition(exec.agent)
-      const inherited = scope.getStore()
-      const persistedCallSeq = inherited?.persistedCallSeq
-      const current = {
-        id,
-        callId: String(exec.callId),
-        ...(persistedCallSeq === undefined ? {} : { persistedCallSeq }),
-        ...(inherited?.deferredSettlement === undefined
-          ? {}
-          : { deferredSettlement: inherited.deferredSettlement }),
-        session: exec.agent?.session,
-        agent: exec.agent,
-        executionArguments,
-        ...(userBindings === undefined ? {} : { userBindings }),
-      }
-      if (current.deferredSettlement !== undefined) {
-        current.deferredSettlement.current = current
-      }
-      pending.set(exec, current)
-      return scope.run(current, async () => {
-        const result = await next()
-        const settlement = current.settlement
-        if (result?.isError === true && settlement !== undefined) {
-          let meta = withJournal(result.meta, settlement.journal)
-          if (settlement.recoveryBoundaries !== undefined) {
-            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 }
+    async handleExecute(exec, next, executionArguments = exec.arguments, userBindings = undefined) {
+      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
+        const current = {
+          id,
+          submission: inherited?.submission,
+          callId: String(exec.callId),
+          ...(persistedCallSeq === undefined ? {} : { persistedCallSeq }),
+          ...(inherited?.sourceCallSeq === undefined ? {} : { sourceCallSeq: inherited.sourceCallSeq }),
+          ...(inherited?.deferredSettlement === undefined
+            ? {}
+            : { 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 }),
         }
-        return result
+        sessions.assertSubmission(current.submission)
+        if (current.deferredSettlement !== undefined) {
+          current.deferredSettlement.current = current
+        }
+        pending.set(exec, current)
+        return scope.run(current, async () => {
+          const result = await next()
+          const settlement = current.settlement
+          if (result?.isError === true && settlement !== undefined) {
+            let meta = withJournal(result.meta, settlement.journal)
+            if (settlement.recoveryBoundaries !== undefined) {
+              meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
+            }
+            if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+            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 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) {
-        sessions.noteNoop(id, exec.agent?.session, exec.callId)
+        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)
@@ -561,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))
@@ -586,8 +851,12 @@ export function createRuntimeBridgeOwner({
       releaseSeam()
       for (const patched of patchedDefinitions.values()) {
         if (patched.output.presentationMeta === patched.patchedPresentationMeta) {
-          if (patched.originalPresentationMeta === undefined) delete patched.output.presentationMeta
-          else patched.output.presentationMeta = patched.originalPresentationMeta
+          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) {