dsh-ptc-plus 0.3.2 → 0.4.1

package/index.js

@@ -1,14 +1,16 @@
 /**
  * Session-bound REPL for DeepSeek Harness PTC mode.
  *
- * DSH's run_code bridge does not pass session identity to CodeRuntime.run().
- * The tools/execute around-hook carries that identity into the runtime bridge,
- * which redirects only those runs to a persistent per-session kernel.
+ * DSH's run_code bridge does not pass session identity to the execution seam it
+ * calls. The tools/execute around-hook carries that identity into the runtime
+ * bridge, which redirects only those runs to a persistent per-session kernel.
  */
 
 import Schema from '@deepseek-ai/schemastery'
 import { randomUUID } from 'node:crypto'
 import { createDirectSurfaceOwner } from './internal/direct-surface-owner.js'
+import { createRuntimeMessageOwner } from './internal/runtime-contexts.js'
+import { PTC_DELIVERY_CONTEXT } from './internal/runtime-messages.js'
 import { createCordisToolsOwner } from './internal/cordis-tools-owner.js'
 import { createEditTransportOwner, EDIT_RUN_CODE } from './internal/edit-transport-owner.js'
 import { createRuntimeBridgeOwner, RUN_CODE } from './internal/runtime-bridge-owner.js'
@@ -18,7 +20,14 @@ import {
   SETTINGS_NAMESPACE,
 } from './internal/config-spec.js'
 import { installSettingsSectionCompat } from './internal/settings-compat.js'
+import { installExecutionSeam } from './internal/execution-seam-compat.js'
+import { valueLimitsFromConfig } from './internal/value-wire-schema.js'
 import { createReplMemoryProjection } from './internal/repl-memory-projection.js'
+import { createUserBindingDraftProjection } from './internal/user-binding-draft-projection.js'
+import { createUserBindingsOwner } from './internal/user-bindings-owner.js'
+import { createHostRpc } from './internal/host-rpc.js'
+import { createReplObservationInterest } from './internal/repl-observation-interest.js'
+import { guidancePolicies } from './internal/binding-update-policy.js'
 import * as dshSettings from '@deepseek-ai/dsh-settings'
 
 const INSTALL_CLEANUP = Symbol('ptc-plus install cleanup')
@@ -30,7 +39,10 @@ export const name = 'ptc-plus'
 function configSchemaField(field) {
   const base = field.type === 'boolean'
     ? Schema.boolean().default(field.default)
-    : Schema.number().step(1).min(field.min).max(field.max).default(field.default)
+    : field.type === 'enum'
+      // Keep omission visible until resolveConfig migrates legacy policies.
+      ? Schema.union(field.options.map(option => Schema.const(option)))
+      : Schema.number().step(1).min(field.min).max(field.max).default(field.default)
   return base.description(field.description)
 }
 
@@ -38,18 +50,20 @@ export const Config = Schema.object(Object.fromEntries(
   CONFIG_FIELDS.map(field => [field.key, configSchemaField(field)]),
 ))
 
-/** Services required by the plugin. */
-export const inject = ['tools', 'codeRuntime', 'systemPrompt', 'agents', 'llm']
+/**
+ * Core services required by the plugin. Optional authoring services are
+ * injected on demand. The execution seam is not listed here: the host registers
+ * it under the service name of one generation, so `installExecutionSeam`
+ * selects the live one.
+ */
+export const inject = ['tools', 'systemPrompt', 'agents', 'llm']
 
-function replGuidance(
-  looseTopLevelRedeclarations,
-  looseTopLevelFunctionClassRedeclarations,
-  durableReplay,
-  autoRewriteImports,
-  autoStripExports,
-  autoSplitRedeclarations,
-  cordisToolsEnabled,
-) {
+function replGuidance({ bindingPolicy, rewritesEnabled, languageSemantics, durableReplay, cordisToolsEnabled }) {
+  const looseTopLevelRedeclarations = bindingPolicy.variableRedeclarations
+  const looseTopLevelFunctionClassRedeclarations = bindingPolicy.functionClassRedeclarations
+  const autoRewriteImports = rewritesEnabled.autoRewriteImports
+  const autoStripExports = rewritesEnabled.autoStripExports
+  const autoSplitRedeclarations = rewritesEnabled.autoSplitRedeclarations
   const variableRedeclaration = looseTopLevelRedeclarations
     ? 'Repeated top-level `const`/`let` declarations replace existing bindings.'
     : 'Repeated top-level variable declarations fail before execution, so reuse existing bindings or place one-off declarations inside a block.'
@@ -66,72 +80,133 @@ function replGuidance(
   const splitSyntax = autoSplitRedeclarations
     ? 'Mixed new/existing top-level destructuring is split automatically while preserving assignment semantics.'
     : 'Mixed new/existing top-level destructuring remains unsupported; separate the declaration from the assignment.'
+  const cellConventions = languageSemantics === 'legacy-v1'
+    ? `Cells are async function bodies; ${moduleSyntax} Use dynamic import or require explicitly when static module syntax is unsupported. ${variableRedeclaration} ${functionClassRedeclaration} ${splitSyntax}`
+    : `Cells support TypeScript, top-level await, return, static import and top-level export. ${languageSemantics === 'stateful-v1'
+      ? 'Declarations and assignments update the same logical binding within its scope, including const, functions, classes and imports. A bare declaration preserves an existing value. A declaration publishes its bindings after its whole pattern initializes; explicit assignments preserve actual partial writes. Imports follow their module until locally overwritten; importing again changes that same binding source. Existing closures observe later updates, while saved values retain their identity.'
+      : 'Redeclaration protection is enabled: existing session names cannot be redeclared, and newly created const and import bindings reject assignment. Other declarations follow native scope rules. Previously writable bindings stay writable.'}`
   const recovery = durableReplay
     ? 'Direct Node/OS access remains live but is not replayed after a kernel restart.'
     : 'Durable replay is disabled for this profile. Bindings remain reusable only in the current process; a new kernel starts empty.'
   const cordisRecovery = cordisToolsEnabled
-    ? 'When using Cordis tools, keep large host or client source in a top-level binding before the Cordis call. A Cordis parse or validation error is a runtime failure: bindings assigned before that failure remain live, so retry only the Cordis call with the existing binding instead of resending the source. Treat that binding as the read-only input for the retry.'
+    ? 'Keep large Cordis plugin source in a binding before the tool call so it can be reused after an error. A Cordis parse or validation failure can follow external effects; repeat the call only when its retry rules and current results establish that it is safe.'
     : ''
   return `\`run_code\` continues one persistent PTC REPL. Ordinary top-level bindings remain available to later cells, so reuse them instead of resending setup code. Choose the smallest cell that answers the request and return only the value the next step needs.
 
-The host may append a bounded recovery context after a qualifying failure. Treat that context as a session-log-derived diagnostic: use \`edit_run_code\` only when it explicitly proves a complete-cell rerun is safe; otherwise inspect live state in a new short \`run_code\` cell.
+After an execution error, earlier statements may have taken effect. Inspect relevant values in a short cell and continue from them; repeat external operations only when their retry rules and current results establish that it is safe. \`edit_run_code\` edits and reruns a complete cell.
 
 ## Cell conventions
-Expressions that are neither returned nor printed produce no output. Keep large inspection results in bindings or reduce them to targeted excerpts: \`tools.read\` is bounded inspection, not a lossless whole-file reader. Cells are async function bodies; ${moduleSyntax} Use dynamic import or require explicitly when static module syntax is unsupported. ${variableRedeclaration} ${functionClassRedeclaration} ${splitSyntax}
+Use \`return\` for an explicit result and \`console\` for logs. Keep large inspection results in bindings or reduce them to targeted excerpts: \`tools.read\` is bounded inspection, not a lossless whole-file reader. ${cellConventions}
 
 ## Available capabilities
-Use \`capabilities.tree()\`, \`capabilities.find()\`, and \`capabilities.inspect()\` to discover the current request's live \`tools.*\` members before calling an unfamiliar binding. Prefer direct current-cell work; reserve \`code.run\` for source already held as data.
+Use \`capabilities.tree()\`, \`capabilities.find()\`, and \`capabilities.inspect()\` for unfamiliar program APIs. Prefer direct current-cell work; reserve \`code.run\` for isolated execution of source held as data.
+Program API references expire when their cell ends. Reusable helpers must read the current namespace when called, for example \`async function readNow(args) { return tools.read(args) }\`, rather than retaining an earlier \`tools\` object or method. Background callbacks from completed cells cannot call program APIs.
 
 Native tool availability, executable names, shells, and path syntax depend on the current DSH profile and execution world; inspect them instead of assuming Windows, WSL, POSIX, or a particular shell. ${recovery}${cordisToolsEnabled ? ` ${cordisRecovery}` : ''}`
 }
 
 /** Register the session-bound REPL runtime. */
-function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId) {
+function installPtCRuntime(ctx, resolvedConfig, seam, toolSchemasForAgent, sessionId) {
   const presentationGeneration = randomUUID()
   const replMemoryProjection = createReplMemoryProjection(presentationGeneration)
+  const userBindingDraftProjection = createUserBindingDraftProjection(presentationGeneration)
   let activeConfig = resolvedConfig
   let cordisTools
+  let cordisToolsReady = false
+  const cordisOwners = new Set()
   let runtimeBridge
   let editTransport
   let directSurface
+  let userBindings
+  let observationInterest
   let ready
   let pendingCordisActivation
+  let draftProjectionRegistration
+  let draftProjectionAvailable = false
+  let projectionService
   const disposers = []
+  const disposedOwners = new Set()
   let disposed = false
-  async function dispose() {
-    if (disposed) return
+  let disposal
+  function dispose() {
     disposed = true
     pendingCordisActivation?.cancel()
-    const failures = []
-    for (const dispose of [...disposers].reverse()) {
-      if (typeof dispose !== 'function') continue
-      try {
-        await dispose()
-      } catch (error) {
-        failures.push(error)
-      }
+    if (disposal !== undefined) return disposal
+    const tasks = []
+    for (let index = disposers.length - 1; index >= 0; index -= 1) {
+      const cleanup = disposers[index]
+      if (typeof cleanup !== 'function') continue
+      tasks.push({
+        run: cleanup,
+        complete: () => { if (disposers[index] === cleanup) disposers[index] = undefined },
+      })
+    }
+    for (const owner of [directSurface, editTransport, runtimeBridge, userBindings]) {
+      if (typeof owner?.dispose !== 'function' || disposedOwners.has(owner)) continue
+      tasks.push({ run: () => owner.dispose(), complete: () => disposedOwners.add(owner) })
     }
-    for (const owner of [directSurface, editTransport, runtimeBridge, cordisTools]) {
+    for (const owner of cordisOwners) {
+      tasks.push({
+        run: () => owner.dispose(),
+        complete: () => {
+          cordisOwners.delete(owner)
+          if (cordisTools === owner) {
+            cordisTools = undefined
+            cordisToolsReady = false
+          }
+        },
+      })
+    }
+    const attempts = tasks.map(task => {
       try {
-        await owner?.dispose()
+        return Promise.resolve(task.run())
       } catch (error) {
-        failures.push(error)
+        return Promise.reject(error)
       }
+    })
+    const operation = Promise.allSettled(attempts)
+      .then(results => {
+        const failures = []
+        for (let index = 0; index < results.length; index += 1) {
+          const result = results[index]
+          if (result.status === 'fulfilled') tasks[index].complete()
+          else failures.push(result.reason)
+        }
+        if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus runtime disposal failed')
+      })
+    disposal = operation
+    operation.then(
+      () => { if (disposal === operation) disposal = undefined },
+      () => { if (disposal === operation) disposal = undefined },
+    )
+    return operation
+  }
+  const disposeCordisToolsOwner = async (owner) => {
+    await owner.dispose()
+    cordisOwners.delete(owner)
+    if (cordisTools === owner) {
+      cordisTools = undefined
+      cordisToolsReady = false
     }
-    if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus runtime disposal failed')
+  }
+  const disposeRetainedCordisTools = async () => {
+    const owners = [...cordisOwners]
+    const results = await Promise.allSettled(owners.map(owner => disposeCordisToolsOwner(owner)))
+    const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+    if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus: retained Cordis disposal failed')
   }
   const awaitCordisToolsOwner = async (owner, cancelled) => {
     try {
       await Promise.race([owner.ready, cancelled])
+      if (cordisTools === owner) cordisToolsReady = true
       return owner
     } catch (error) {
       let rollbackError
       try {
-        await owner.dispose()
+        await disposeCordisToolsOwner(owner)
       } catch (caught) {
         rollbackError = caught
       }
-      if (cordisTools === owner) cordisTools = undefined
       if (rollbackError !== undefined) {
         throw new AggregateError(
           [error, rollbackError],
@@ -143,13 +218,17 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
     }
   }
   const activateCordisToolsOwner = async () => {
+    await disposeRetainedCordisTools()
+    if (disposed) throw new Error('ptc-plus: Cordis activation cancelled')
     const owner = createCordisToolsOwner(ctx)
+    cordisOwners.add(owner)
     let cancel
     const cancelled = new Promise((_resolve, reject) => {
       cancel = () => reject(new Error('ptc-plus: Cordis activation cancelled'))
     })
     const activation = { owner, cancel }
     cordisTools = owner
+    cordisToolsReady = false
     pendingCordisActivation = activation
     try {
       return await awaitCordisToolsOwner(owner, cancelled)
@@ -158,19 +237,92 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
     }
   }
   const cancelCordisActivation = () => pendingCordisActivation?.cancel()
+  const registerProjection = (projection, label) => {
+    try {
+      const unregister = projectionService?.register?.(projection)
+      if (typeof unregister !== 'function') {
+        throw new Error('ptc-plus: sessionProjections.register did not return a disposer')
+      }
+      return unregister
+    } catch (error) {
+      ctx.logger?.warn?.(`ptc-plus: ${label} projection unavailable`, error)
+      return undefined
+    }
+  }
+  const setDraftProjectionEnabled = async (enabled) => {
+    if (!enabled) {
+      const unregister = draftProjectionRegistration
+      draftProjectionAvailable = false
+      const results = await Promise.allSettled([
+        Promise.resolve().then(() => userBindings?.setDraftProjectionAvailable(false)),
+        Promise.resolve().then(() => unregister?.()),
+      ])
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus: binding draft projection cleanup failed')
+      }
+      return
+    }
+    if (draftProjectionRegistration !== undefined) {
+      if (draftProjectionAvailable) return
+      await draftProjectionRegistration()
+    }
+    if (projectionService === undefined) return
+    const unregister = registerProjection(userBindingDraftProjection, 'binding draft')
+    if (unregister === undefined) return
+    let active = true
+    let releasing
+    const release = () => {
+      if (!active) return Promise.resolve()
+      if (releasing !== undefined) return releasing
+      const operation = Promise.resolve().then(unregister)
+      releasing = operation
+      operation.then(
+        () => {
+          active = false
+          if (draftProjectionRegistration === release) draftProjectionRegistration = undefined
+          if (releasing === operation) releasing = undefined
+        },
+        () => { if (releasing === operation) releasing = undefined },
+      )
+      return operation
+    }
+    draftProjectionRegistration = release
+    disposers.push(release)
+    draftProjectionAvailable = true
+    try {
+      await userBindings?.setDraftProjectionAvailable(true)
+    } catch (error) {
+      draftProjectionAvailable = false
+      await Promise.allSettled([
+        Promise.resolve().then(() => userBindings?.setDraftProjectionAvailable(false)),
+        release(),
+      ])
+      throw error
+    }
+  }
   try {
+    const hostRpc = createHostRpc(ctx)
+    disposers.push(() => hostRpc.dispose())
+    observationInterest = createReplObservationInterest(ctx, activeConfig.replViewEnabled,
+      (id, memory, signal) => runtimeBridge?.observeRepl(id, memory, signal))
+    disposers.push(() => observationInterest.dispose())
     if (typeof ctx.inject === 'function') {
       const projectionInjection = ctx.inject(['sessionProjections'], (scope) => {
         if (disposed) return
-        try {
-          const unregister = scope.sessionProjections?.register?.(replMemoryProjection)
-          if (typeof unregister !== 'function') {
-            throw new Error('ptc-plus: sessionProjections.register did not return a disposer')
-          }
-          disposers.push(unregister)
-        } catch (error) {
-          ctx.logger?.warn?.('ptc-plus: REPL memory projection unavailable', error)
-        }
+        const service = scope.sessionProjections
+        projectionService = service
+        draftProjectionAvailable = false
+        const unregisterMemory = registerProjection(replMemoryProjection, 'REPL memory')
+        if (unregisterMemory !== undefined) disposers.push(unregisterMemory)
+        void setDraftProjectionEnabled(activeConfig.userBindingsEnabled).catch(error => {
+          ctx.logger?.warn?.('ptc-plus: binding draft projection unavailable', error)
+        })
+        scope.effect?.(() => async () => {
+          if (projectionService !== service) return
+          projectionService = undefined
+          await setDraftProjectionEnabled(false)
+        }, 'ptc-plus: binding draft projection availability')
       })
       if (typeof projectionInjection === 'function') {
         disposers.push(projectionInjection)
@@ -178,23 +330,32 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
         disposers.push(() => projectionInjection.dispose())
       }
     }
-    cordisTools = activeConfig.cordisToolsEnabled
-      ? createCordisToolsOwner(ctx)
-      : undefined
+    cordisTools = activeConfig.cordisToolsEnabled ? createCordisToolsOwner(ctx) : undefined
     if (cordisTools !== undefined) {
       const initialCordisTools = cordisTools
-      ready = awaitCordisToolsOwner(initialCordisTools, new Promise(() => {})).catch(error => {
-        if (cordisTools === initialCordisTools) cordisTools = undefined
-        throw error
-      })
+      cordisOwners.add(initialCordisTools)
+      ready = awaitCordisToolsOwner(initialCordisTools, new Promise(() => {}))
     }
+    userBindings = createUserBindingsOwner(ctx, {
+      enabled: activeConfig.userBindingsEnabled,
+      draftProjectionAvailable,
+      maxWallMs: activeConfig.maxWallMs,
+      maxOutputBytes: activeConfig.maxOutputBytes,
+      maxOldGenerationSizeMb: activeConfig.maxOldGenerationSizeMb,
+      valueLimits: valueLimitsFromConfig(activeConfig),
+    })
     runtimeBridge = createRuntimeBridgeOwner({
       ctx,
+      seam,
+      observeSession: id => observationInterest.has(id),
       sessionConfig: activeConfig,
+      userBindingsCwd: userBindings.cwd,
       maxNestedRunCodeDepth: activeConfig.maxNestedRunCodeDepth,
       presentationGeneration,
       sessionId,
       toolSchemasForAgent,
+      userBindingDraftForAgent: agent => userBindings.draftCapabilityForAgent(agent),
+      bindingSubmissionForAgent: (agent, ensureLease, onAccepted) => userBindings.submissionForAgent(agent, ensureLease, onAccepted),
     })
     editTransport = createEditTransportOwner(ctx, {
       durableReplay: activeConfig.durableReplay,
@@ -209,21 +370,17 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
       canonicalizeToolCalls: activeConfig.canonicalizeToolCalls,
       sessionId,
       toolSchemasForAgent,
+      userBindingsForAgent: () => userBindings.snapshot(),
+      setAgentPresentation: (agent, presentation) => (
+        userBindings.setAgentPresentation(agent, presentation)
+      ),
     })
     disposers.push(ctx.systemPrompt.section({
       name: 'tools:ptc-plus-repl',
       order: 98,
       text: context => {
         if (ctx.tools.get(RUN_CODE, context?.scope) === undefined) return ''
-        return replGuidance(
-          activeConfig.looseTopLevelRedeclarations,
-          activeConfig.looseTopLevelFunctionClassRedeclarations,
-          activeConfig.durableReplay,
-          activeConfig.autoRewriteImports,
-          activeConfig.autoStripExports,
-          activeConfig.autoSplitRedeclarations,
-          activeConfig.cordisToolsEnabled,
-        )
+        return replGuidance(guidancePolicies(activeConfig))
       },
     }))
     disposers.push(ctx.on('system-prompt/assemble', (assembly, context, next) => (
@@ -235,7 +392,13 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
       if (rejected !== undefined) return rejected
       if (exec.name === RUN_CODE) {
         const executionArguments = directSurface.executionArguments(exec)
-        return Promise.resolve(runtimeBridge.handleExecute(exec, next, executionArguments))
+        const requestUserBindings = directSurface.executionUserBindings(exec)
+        return Promise.resolve(runtimeBridge.handleExecute(
+          exec,
+          next,
+          executionArguments,
+          requestUserBindings,
+        ))
           .then(result => directSurface.argumentDiagnostic(exec, result))
       }
       return next()
@@ -245,22 +408,48 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
       if (exec.name === EDIT_RUN_CODE) return editTransport.handleResult(exec, result)
       if (exec.name === RUN_CODE) return runtimeBridge.handleResult(exec, result)
     }))
-    disposers.push(ctx.on('agent/disposed', ({ agent }) => {
+    disposers.push(ctx.on('agent/disposed', async ({ agent }) => {
       directSurface.disposeAgent(agent)
       editTransport.disposeAgent(agent)
-      return runtimeBridge.disposeAgent(agent)
+      await Promise.all([
+        runtimeBridge.disposeAgent(agent),
+        userBindings.clearAgentPresentation(agent),
+      ])
     }))
-    disposers.push(ctx.on('session/disposed', (session) => {
+    disposers.push(ctx.on('session/disposed', async (session) => {
       directSurface.disposeSession(session)
       editTransport.disposeSession(session)
-      return runtimeBridge.disposeSession(session)
+      await Promise.all([
+        runtimeBridge.disposeSession(session),
+        userBindings.clearSessionPresentation(session?.id ?? session),
+      ])
+    }))
+    disposers.push(ctx.on('agent-preset/selected', (sessionId) => {
+      directSurface.resetSessionComposition(sessionId)
+      const agent = ctx.agents?.get?.(String(sessionId))
+      if (agent !== undefined) editTransport.disposeAgent(agent)
+      const cleanup = agent === undefined
+        ? userBindings.clearSessionPresentation(sessionId)
+        : userBindings.setAgentPresentation(agent)
+      const report = ctx.logger?.warn?.bind(
+        ctx.logger,
+        'ptc-plus: failed to reconcile Global User Bindings authoring after preset selection',
+      ) ?? console.warn
+      void cleanup.catch(report)
     }))
   } catch (error) {
-    const cleanup = dispose()
-    if (error !== null && typeof error === 'object') {
-      Object.defineProperty(error, INSTALL_CLEANUP, { value: cleanup })
+    const failedRuntime = Object.freeze({ dispose })
+    let failure = error
+    if (failure === null || (typeof failure !== 'object' && typeof failure !== 'function')) {
+      failure = new Error(String(error), { cause: error })
     }
-    throw error
+    try {
+      Object.defineProperty(failure, INSTALL_CLEANUP, { value: failedRuntime })
+    } catch {
+      failure = new Error(failure.message ?? String(failure), { cause: failure })
+      Object.defineProperty(failure, INSTALL_CLEANUP, { value: failedRuntime })
+    }
+    throw failure
   }
   async function reconfigure(nextConfig) {
     if (disposed) return
@@ -273,26 +462,34 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
       rollbacks.push(() => editTransport.reconfigure(previousConfig))
       directSurface.reconfigure(nextConfig)
       rollbacks.push(() => directSurface.reconfigure(previousConfig))
+      await userBindings.reconfigure(nextConfig)
+      rollbacks.push(() => userBindings.reconfigure(previousConfig))
+      await setDraftProjectionEnabled(nextConfig.userBindingsEnabled)
+      rollbacks.push(() => setDraftProjectionEnabled(previousConfig.userBindingsEnabled))
 
+      if (nextConfig.cordisToolsEnabled && cordisTools !== undefined && !cordisToolsReady) {
+        await disposeRetainedCordisTools()
+      }
       if (nextConfig.cordisToolsEnabled && cordisTools === undefined) {
         await activateCordisToolsOwner()
       } else if (!nextConfig.cordisToolsEnabled && cordisTools !== undefined) {
         const currentCordis = cordisTools
+        cordisToolsReady = false
         try {
-          await currentCordis.dispose()
-          cordisTools = undefined
+          await disposeCordisToolsOwner(currentCordis)
         } catch (error) {
           try {
+            await disposeCordisToolsOwner(currentCordis)
             await activateCordisToolsOwner()
           /* c8 ignore next */
           } catch (rollbackError) {
-            cordisTools = currentCordis
             throw new AggregateError([error, rollbackError], 'ptc-plus: Cordis reconfiguration and rollback failed', { cause: error })
           }
           throw error
         }
       }
       activeConfig = nextConfig
+      observationInterest.reconfigure(nextConfig.replViewEnabled)
     } catch (error) {
       const rollbackFailures = []
       /* c8 ignore next -- the rollback loop's rejection branch is host-specific. */
@@ -308,12 +505,25 @@ function installPtCRuntime(ctx, resolvedConfig, toolSchemasForAgent, sessionId)
     }
   }
 
-  return Object.freeze({ cancelCordisActivation, dispose, reconfigure, ready })
+  return Object.freeze({
+    cancelCordisActivation, dispose, reconfigure, ready,
+    contextsForRequest: context => directSurface.contextsForRequest(context),
+  })
 }
 
 /** Register the session-bound REPL runtime. */
 export function apply(ctx, config = {}) {
+  // Configuration is validated before the plugin waits for the host's seam, so
+  // an unusable configuration fails at the load call rather than later.
   const resolvedConfig = resolveConfig(config)
+  return installExecutionSeam(ctx, {
+    services: inject,
+    attach: (scope, seam) => applyWithExecutionSeam(scope, resolvedConfig, seam),
+  })
+}
+
+/** Install the plugin into the scope of the seam the host registered. */
+function applyWithExecutionSeam(ctx, resolvedConfig, seam) {
   const toolSchemasForAgent = agent => typeof ctx.tools.schemas === 'function'
     ? ctx.tools.schemas(agent)
     : []
@@ -323,7 +533,9 @@ export function apply(ctx, config = {}) {
   }
   let committed
   let activating
+  const retained = new Set()
   let disposed = false
+  let controllerDisposal
   let transitionTail = Promise.resolve()
   let pendingTransitions = 0
   const trackTransition = operation => {
@@ -348,9 +560,26 @@ export function apply(ctx, config = {}) {
     return { promise, resolve, reject }
   }
   const disposeRuntime = record => {
+    if (record?.disposed === true) return Promise.resolve()
     if (record?.disposal !== undefined) return record.disposal
-    record.disposal = record.runtime.dispose()
-    return record.disposal
+    retained.add(record)
+    const operation = Promise.resolve().then(() => record.runtime.dispose())
+    record.disposal = operation
+    operation.then(
+      () => {
+        record.disposed = true
+        retained.delete(record)
+        if (record.disposal === operation) record.disposal = undefined
+      },
+      () => { if (record.disposal === operation) record.disposal = undefined },
+    )
+    return operation
+  }
+  const disposeRetainedRuntimes = async () => {
+    const records = [...retained].filter(record => record.runtime !== undefined)
+    const results = await Promise.allSettled(records.map(record => disposeRuntime(record)))
+    const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+    if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus retained runtime disposal failed')
   }
   const activationError = (error, cleanupError) => new AggregateError(
     [error, cleanupError],
@@ -376,17 +605,18 @@ export function apply(ctx, config = {}) {
       record.completion.resolve({ status: 'superseded' })
       return
     }
-    if (ctx.codeRuntime.language !== 'typescript') {
-      throw new Error('ptc-plus: unsupported code runtime language ' + JSON.stringify(ctx.codeRuntime.language) + '; only "typescript" is supported')
+    if (seam.language !== 'typescript') {
+      throw new Error('ptc-plus: unsupported code runtime language ' + JSON.stringify(seam.language) + '; only "typescript" is supported')
     }
     let candidate
     try {
-      candidate = installPtCRuntime(ctx, record.config, toolSchemasForAgent, sessionId)
+      candidate = installPtCRuntime(ctx, record.config, seam, toolSchemasForAgent, sessionId)
       record.runtime = candidate
     } catch (error) {
-      const cleanup = error?.[INSTALL_CLEANUP]
-      if (cleanup === undefined) throw error
-      const trackedCleanup = trackTransition(cleanup)
+      const failedRuntime = error?.[INSTALL_CLEANUP]
+      if (failedRuntime === undefined) throw error
+      record.runtime = failedRuntime
+      const trackedCleanup = trackTransition(disposeRuntime(record))
       void trackedCleanup.then(
         () => record.completion.reject(error),
         cleanupError => record.completion.reject(activationError(error, cleanupError)),
@@ -427,6 +657,8 @@ export function apply(ctx, config = {}) {
       generation,
       runtime: undefined,
       disposal: undefined,
+      disposed: false,
+      retiring: false,
       trackedDisposal: undefined,
       cancelled: false,
       completion,
@@ -455,10 +687,22 @@ export function apply(ctx, config = {}) {
     apply(nextConfig, generation) {
       if (disposed) return Promise.resolve({ status: 'superseded' })
       if (activating !== undefined) {
-        const cleanup = cancelActivation(activating)
+        cancelActivation(activating)
+        const cleanup = disposeRetainedRuntimes()
+        return beginActivation(nextConfig, generation, cleanup)
+      }
+      if (committed === undefined) {
+        const cleanup = retained.size === 0 ? undefined : disposeRetainedRuntimes()
+        return beginActivation(nextConfig, generation, cleanup)
+      }
+      if (committed.retiring) {
+        const current = committed
+        void disposeRuntime(current)
+        const cleanup = disposeRetainedRuntimes().then(() => {
+          if (committed === current) committed = undefined
+        })
         return beginActivation(nextConfig, generation, cleanup)
       }
-      if (committed === undefined) return beginActivation(nextConfig, generation)
       const current = committed
       if (!nextConfig.cordisToolsEnabled) current.runtime.cancelCordisActivation()
       return enqueueTransition(async () => {
@@ -469,27 +713,60 @@ export function apply(ctx, config = {}) {
         return { status: 'applied' }
       })
     },
-    uninstall() {
-      const activationCleanup = activating === undefined
+    async uninstall() {
+      const active = activating
+      const activationCleanup = active === undefined
         ? Promise.resolve()
-        : cancelActivation(activating)
+        : cancelActivation(active)
       const current = committed
-      committed = undefined
+      if (current !== undefined) current.retiring = true
       const committedCleanup = current === undefined
         ? Promise.resolve()
         : trackTransition(disposeRuntime(current))
-      return Promise.all([activationCleanup, committedCleanup]).then(() => undefined)
+      const records = [...retained].filter(record => (
+        record !== current && record !== active && record.runtime !== undefined
+      ))
+      const results = await Promise.allSettled([
+        activationCleanup,
+        committedCleanup,
+        ...records.map(record => disposeRuntime(record)),
+      ])
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (current?.disposed === true && committed === current) committed = undefined
+      if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus runtime uninstall failed')
     },
     committedConfig() {
-      return committed?.config
+      return committed?.retiring ? undefined : committed?.config
     },
-    async dispose() {
+    dispose() {
       disposed = true
-      await controller.uninstall()
+      if (controllerDisposal !== undefined) return controllerDisposal
+      const operation = controller.uninstall()
+      controllerDisposal = operation
+      operation.then(
+        () => { if (controllerDisposal === operation) controllerDisposal = undefined },
+        () => { if (controllerDisposal === operation) controllerDisposal = undefined },
+      )
+      return operation
     },
   }
   ctx.effect(() => async () => controller.dispose(), 'ptc-plus runtime lifecycle')
 
+  const messageOwner = createRuntimeMessageOwner(context => (
+    committed?.retiring ? [] : committed?.runtime.contextsForRequest(context) ?? []
+  ))
+  ctx.effect(() => ctx.systemPrompt.context({
+    name: PTC_DELIVERY_CONTEXT, order: 98, text: '',
+  }), 'ptc-plus dynamic message delivery witness')
+  ctx.effect(() => ctx.on('system-prompt/assemble', (assembly, context, next) => (
+    messageOwner.assemble(assembly, context, next)
+  )), 'ptc-plus message assembly')
+  ctx.effect(() => ctx.on('agent/pre-step', (payload, next) => (
+    messageOwner.preStep(payload, next)
+  )), 'ptc-plus accepted messages')
+  ctx.effect(() => ctx.on('agent/disposed', ({ agent }) => messageOwner.disposeAgent(agent)), 'ptc-plus message agent disposal')
+  ctx.effect(() => () => messageOwner.dispose(), 'ptc-plus dynamic message lifecycle')
+
   let configSource = () => resolvedConfig
   let configurationGeneration = 0
   let settingsWriter