dsh-ptc-plus 0.4.2 → 0.4.3

package/index.js

@@ -14,12 +14,12 @@ 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'
-import { resolveConfig } from './internal/runtime-config.js'
+import { resolveConfig, watchVolatileConfig } from './internal/runtime-config.js'
 import {
   CONFIG_FIELDS,
   SETTINGS_NAMESPACE,
 } from './internal/config-spec.js'
-import { installSettingsSectionCompat } from './internal/settings-compat.js'
+import { configFieldSchema, 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'
@@ -35,19 +35,13 @@ const INSTALL_CLEANUP = Symbol('ptc-plus install cleanup')
 /** Plugin name used by loader diagnostics. */
 export const name = 'ptc-plus'
 
-/** Runtime limits and behavior exposed to Cordis configuration. */
-function configSchemaField(field) {
-  const base = field.type === 'boolean'
-    ? Schema.boolean().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)
-}
-
 export const Config = Schema.object(Object.fromEntries(
-  CONFIG_FIELDS.map(field => [field.key, configSchemaField(field)]),
+  CONFIG_FIELDS.map(field => [
+    field.key,
+    // Runtime limits and behavior exposed to Cordis configuration. The shape
+    // each field takes is owned by the installed settings generation.
+    configFieldSchema({ Schema, field, settingsModule: dshSettings }),
+  ]),
 ))
 
 /**
@@ -408,22 +402,27 @@ function installPtCRuntime(ctx, resolvedConfig, seam, toolSchemasForAgent, sessi
       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', async ({ agent }) => {
-      directSurface.disposeAgent(agent)
-      editTransport.disposeAgent(agent)
-      await Promise.all([
-        runtimeBridge.disposeAgent(agent),
-        userBindings.clearAgentPresentation(agent),
-      ])
-    }))
-    disposers.push(ctx.on('session/disposed', async (session) => {
-      directSurface.disposeSession(session)
-      editTransport.disposeSession(session)
-      await Promise.all([
-        runtimeBridge.disposeSession(session),
-        userBindings.clearSessionPresentation(session?.id ?? session),
-      ])
-    }))
+    const disposeLifecycleOwners = async (operations, message) => {
+      const results = await Promise.allSettled(operations.map(operation => (
+        Promise.resolve().then(operation)
+      )))
+      const failures = results
+        .filter(result => result.status === 'rejected')
+        .map(result => result.reason)
+      if (failures.length > 0) throw new AggregateError(failures, message)
+    }
+    disposers.push(ctx.on('agent/disposed', ({ agent }) => disposeLifecycleOwners([
+      () => directSurface.disposeAgent(agent),
+      () => editTransport.disposeAgent(agent),
+      () => runtimeBridge.disposeAgent(agent),
+      () => userBindings.clearAgentPresentation(agent),
+    ], 'ptc-plus: agent disposal failed')))
+    disposers.push(ctx.on('session/disposed', session => disposeLifecycleOwners([
+      () => directSurface.disposeSession(session),
+      () => editTransport.disposeSession(session),
+      () => runtimeBridge.disposeSession(session),
+      () => userBindings.clearSessionPresentation(session?.id ?? session),
+    ], 'ptc-plus: session disposal failed')))
     disposers.push(ctx.on('agent-preset/selected', (sessionId) => {
       directSurface.resetSessionComposition(sessionId)
       const agent = ctx.agents?.get?.(String(sessionId))
@@ -512,18 +511,22 @@ function installPtCRuntime(ctx, resolvedConfig, seam, toolSchemasForAgent, sessi
 }
 
 /** Register the session-bound REPL runtime. */
-export function apply(ctx, config = {}) {
+export const 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),
+    attach: (scope, seam) => applyWithExecutionSeam(scope, resolvedConfig, seam, ctx, config),
+    reportFailure: (error, seamName) => ctx.logger?.warn?.(
+      `ptc-plus: execution seam ${seamName} failed to attach`,
+      error,
+    ),
   })
 }
 
 /** Install the plugin into the scope of the seam the host registered. */
-function applyWithExecutionSeam(ctx, resolvedConfig, seam) {
+function applyWithExecutionSeam(ctx, resolvedConfig, seam, volatileHost, volatileConfig) {
   const toolSchemasForAgent = agent => typeof ctx.tools.schemas === 'function'
     ? ctx.tools.schemas(agent)
     : []
@@ -767,7 +770,7 @@ function applyWithExecutionSeam(ctx, resolvedConfig, seam) {
   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 configSource = () => resolveConfig(volatileConfig ?? resolvedConfig)
   let configurationGeneration = 0
   let settingsWriter
   let configurationRollback = false
@@ -826,6 +829,7 @@ function applyWithExecutionSeam(ctx, resolvedConfig, seam) {
   if (typeof ctx.inject === 'function') {
     installSettingsSectionCompat({
       ctx,
+      ownerFiber: volatileHost.fiber,
       settingsModule: dshSettings,
       namespace: SETTINGS_NAMESPACE,
       schema: Config,
@@ -841,5 +845,6 @@ function applyWithExecutionSeam(ctx, resolvedConfig, seam) {
       },
     })
   }
+  watchVolatileConfig(volatileHost, ctx, volatileConfig, () => reconcile())
   if (configurationGeneration === 0) return reconcile(settingsWriter === undefined)
 }

package/internal/async-local-storage-intrinsics.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
+import { WORKER_REALM_MUTATION, defineWorkerRealmProperty } from './worker-realm-surfaces.js'
 
 const bind = Function.prototype.call.bind(Function.prototype.bind)
-const defineProperty = Object.defineProperty
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
 const apply = Reflect.apply
 const nativeGetStore = AsyncLocalStorage.prototype.getStore
@@ -10,9 +10,12 @@ const nativeRun = AsyncLocalStorage.prototype.run
 const nativeRunDescriptor = getOwnPropertyDescriptor(AsyncLocalStorage.prototype, 'run')
 
 function protect(scope) {
-  defineProperty(scope, 'getStore', { value: bind(nativeGetStore, scope) })
-  defineProperty(scope, 'enterWith', { value: bind(nativeEnterWith, scope) })
-  defineProperty(scope, 'run', { value: bind(nativeRun, scope) })
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'private AsyncLocalStorage receiver methods',
+    scope, 'getStore', { value: bind(nativeGetStore, scope) })
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'private AsyncLocalStorage receiver methods',
+    scope, 'enterWith', { value: bind(nativeEnterWith, scope) })
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'private AsyncLocalStorage receiver methods',
+    scope, 'run', { value: bind(nativeRun, scope) })
   return scope
 }
 
@@ -22,17 +25,19 @@ export function createPrivateAsyncLocalStorage() {
 
 export function protectNextAsyncLocalStorageRun(invoke) {
   let scope
-  defineProperty(AsyncLocalStorage.prototype, 'run', {
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.TEMPORARY, 'AsyncLocalStorage.prototype.run',
+    AsyncLocalStorage.prototype, 'run', {
     ...nativeRunDescriptor,
     value: function (...args) {
       scope ??= protect(this)
       return apply(nativeRun, this, args)
     },
-  })
+    })
   try {
     invoke()
   } finally {
-    defineProperty(AsyncLocalStorage.prototype, 'run', nativeRunDescriptor)
+    defineWorkerRealmProperty(WORKER_REALM_MUTATION.RESTORE, 'AsyncLocalStorage.prototype.run',
+      AsyncLocalStorage.prototype, 'run', nativeRunDescriptor)
   }
   return scope
 }

package/internal/callable-source-facts.js

@@ -43,6 +43,16 @@ function callableSourceStart(source, node) {
   return start + tokens.getToken().start
 }
 
+function removeCallableSourceMarks(source, prefix, suffix, sources, options) {
+  const tree = parse(prefix + source + suffix, options)
+  const markers = new Set(sources.entries.map(entry => entry.marker))
+  const offset = prefix.length
+  const edits = tree.comments.filter(comment => markers.has(comment.value)
+    && comment.start >= offset && comment.end <= offset + source.length)
+    .map(comment => ({ start: comment.start - offset, end: comment.end - offset, text: '' }))
+  return edits.length === 0 ? source : applySourceEdits(source, identitySourceMap(source.length), edits).code
+}
+
 export function callableMarkerPosition(node, source, comments) {
   if (node.type !== 'ArrowFunctionExpression') return node.body.start + 1
   let start = source.lastIndexOf('=>', node.body.start - 1)
@@ -129,6 +139,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
   const nativeFunctions = typedRecords.map(record => markedNodes.get(record.marker))
     .filter(node => t.isFunction(node) && !isMethod(node)).sort((left, right) => left.start - right.start)
   const nativeRecipes = new Map()
+  const aliasMarkers = []
   const nativeFunctionIndex = start => {
     let low = 0, high = nativeFunctions.length
     while (low < high) {
@@ -175,7 +186,17 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
       original = lowered.source
       const entries = [...originals].map(([key, text]) => [key, key === marker ? original : text])
       for (const [node, fact] of markedCallableOwners(lowered.emitted, entries)) {
-        sources.aliases.push([lowered.emittedSource.slice(node.start, node.end), fact.original])
+        const generated = lowered.emittedSource.slice(node.start, node.end)
+        aliasMarkers.push([generated, fact.marker])
+        const generatedMethod = isMethod(node)
+        const markerFree = removeCallableSourceMarks(
+          generated,
+          generatedMethod ? 'class Source {' : '(',
+          generatedMethod ? '}' : ')',
+          sources,
+          options,
+        )
+        if (markerFree !== generated) aliasMarkers.push([markerFree, fact.marker])
       }
     }
     // Prefer source-preserving erasure. Runtime TypeScript constructs such as
@@ -202,6 +223,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     } catch {
       lowerCallable()
     }
+    original = removeCallableSourceMarks(original, prefix, suffix, sources, options)
     entry.buffer = sources.buffers.length
     sources.buffers.push(original)
     entry.start = 0
@@ -209,6 +231,8 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     originals.set(marker, original)
     if (!method && t.isFunction(node)) nativeRecipes.set(node, { node, start, end: node.end, text: original })
   }
+  const finalFacts = factMap(sources)
+  for (const [generated, marker] of aliasMarkers) sources.aliases.push([generated, originalText(finalFacts.get(marker))])
   return { ...marked, callableSources: sources, nativeJavaScript }
 }
 
@@ -273,6 +297,18 @@ export function collectCallableSources(code, sources, parserOptions = {}, transf
   }).concat(sources.aliases ?? [])
 }
 
+/** Restore only callable marks whose transformed starts have exact source-map ownership. */
+export function restoreMappedCallableSourceMarks(mapped, input, transformation, sources, parserOptions = {}) {
+  if (sources === undefined || sources.length === 0) return mapped
+  const { tree, owners } = callableSourceOwners(mapped.code, sources, parserOptions,
+    { code: input, map: transformation.map })
+  const edits = [...owners].map(([node, fact]) => {
+    const start = callableMarkerPosition(node, mapped.code, tree.comments)
+    return { start, end: start, text: `/*${fact.marker}*/` }
+  })
+  return edits.length === 0 ? mapped : applySourceEdits(mapped.code, mapped.sourceMap, edits)
+}
+
 /** Emission ranges come from typed nodes and exact generator mappings. */
 export function regionCallableRanges(input, generated, sourceRanges, parserOptions) {
   if (!sourceRanges?.length) return []

package/internal/cell-analysis.js

@@ -20,7 +20,7 @@ import {
 import { applySourceEdits, mapSourcePosition, mapSourceSpan, sourceRangeHasOriginalText } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 import { compileStatefulRoot } from './stateful-root-compiler.js'
-import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizeStatefulScopes } from './repl-scope-normalizer.js'
+import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizationFailureInput, normalizeStatefulScopes } from './repl-scope-normalizer.js'
 import { markCallableSources, collectCallableSources } from './callable-source-facts.js'
 import { LegacyPreflightError, prepareLegacyProgram } from './legacy-cell-analysis.js'
 import { adaptLegacyModuleImports } from './managed-module-operations.js'
@@ -220,6 +220,49 @@ function isFunction(node) {
     || node.type === 'ArrowFunctionExpression'
 }
 
+function lowerCellImportMeta(result, importMeta, originalSource) {
+  if (!result.code.includes('import')) return result
+  const tree = parseSource(result.code, {
+    sourceType: 'unambiguous',
+    errorRecovery: true,
+    allowAwaitOutsideFunction: true,
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    plugins: CELL_PARSER_PLUGINS,
+  }).program
+  const references = []
+  walkAst(tree, (node) => {
+    if (node.type === 'MetaProperty' && node.meta?.name === 'import' && node.property?.name === 'meta') {
+      references.push(node)
+    }
+  })
+  if (references.length === 0) return result
+  if (importMeta === null || typeof importMeta !== 'object'
+    || typeof importMeta.url !== 'string' || typeof importMeta.filename !== 'string'
+    || typeof importMeta.dirname !== 'string') {
+    const node = references[0]
+    throw new ModuleRewriteError('import.meta requires the session module base', mapSourcePosition({
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+    }, result.code, originalSource, result.sourceMap))
+  }
+  const binding = createGeneratedNameAllocator(tree)('import_meta')
+  const directiveEnd = tree.directives.at(-1)?.end ?? tree.interpreter?.end ?? 0
+  const declaration = `\nconst ${binding}={__proto__:null,url:${JSON.stringify(importMeta.url)},filename:${JSON.stringify(importMeta.filename)},dirname:${JSON.stringify(importMeta.dirname)}};\n`
+  const edits = [
+    { start: directiveEnd, end: directiveEnd, text: declaration },
+    ...references.map(node => ({
+      start: node.start,
+      end: node.end,
+      text: binding,
+      mappings: [{ generatedStart: 0, generatedEnd: binding.length,
+        originalStart: node.start, originalEnd: node.end }],
+    })),
+  ]
+  return { ...result, ...applySourceEdits(result.code, result.sourceMap, edits), importMetaBinding: binding }
+}
+
 
 function staticModuleClassification(moduleLoads) {
   const reasons = new Map()
@@ -282,14 +325,16 @@ export function classifyDurability(code, knownBindings = new Set(), {
   const reasons = new Map()
   const addReason = reason => reasons.set(renderDurabilityReason(reason), reason)
   for (const reason of staticModuleClassification(moduleLoads)) addReason(reason)
-  const classifyModule = (source) => {
+  const classifyModule = (source, form) => {
     if (source?.type !== 'Literal' || typeof source.value !== 'string') {
       addReason(DYNAMIC_MODULE_REASON)
       return
     }
     const classification = classifyModuleSource(source.value)
     if (classification.status === 'forbidden') {
-      throw new PreflightError(`cell import of ${source.value} is forbidden because it exposes kernel control`, source)
+      const span = sourceMap === undefined || originalSource === undefined ? declarationSpan(source)
+        : mapSourceSpan(declarationSpan(source), code, originalSource, sourceMap)
+      throw new PreflightError(`cell ${form} of ${source.value} is forbidden because it exposes kernel control`, undefined, span)
     }
     if (classification.reason !== undefined) addReason(classification.reason)
   }
@@ -327,7 +372,7 @@ export function classifyDurability(code, knownBindings = new Set(), {
       nestedScopes = [...scopes, loopBindings(node)]
     }
     if (node.type === 'ImportExpression') {
-      classifyModule(node.source)
+      classifyModule(node.source, 'import')
     }
     const sourceOwnedThis = sourceMap === undefined
       || sourceRangeHasOriginalText(sourceMap, code, originalSource, node.start, node.end)
@@ -336,7 +381,7 @@ export function classifyDurability(code, knownBindings = new Set(), {
     }
     if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 'require'
       && !isBound('require', nestedScopes)) {
-      classifyModule(node.arguments[0])
+      classifyModule(node.arguments[0], 'require')
     }
     if (node.type === 'Identifier' && isReferenceIdentifier(node, parent, parentKey)
       && !isBound(node.name, nestedScopes) && AMBIENT_GLOBALS.has(node.name)
@@ -462,21 +507,31 @@ export function prepareProgram(program, options = {}) {
     let normalized
     let prepared
     let callableSources
+    let diagnosticInput
     const intrinsicContext = { bindings: new Set() }
     try {
       const marked = markCallableSources(program, undefined, { plugins: CELL_PARSER_PLUGINS, allowImportExportEverywhere: true, allowUndeclaredExports: true },
         { lowerNativeSource: lowerNativeLanguageSource, nativeUsing: options.nativeUsing })
+      const moduleMetadata = lowerCellImportMeta(marked, options.importMeta, program)
+      diagnosticInput = moduleMetadata
       callableSources = marked.callableSources
-      normalized = normalizeStatefulScopes(marked.code, marked.sourceMap, { mode: options.languageSemantics,
-        nativeJavaScript: marked.nativeJavaScript, deferDecorators: true, deferResources: true, intrinsicContext })
+      normalized = normalizeStatefulScopes(moduleMetadata.code, moduleMetadata.sourceMap, { mode: options.languageSemantics,
+        callableSources, nativeJavaScript: marked.nativeJavaScript,
+        deferDecorators: true, deferResources: true, intrinsicContext })
+      if (moduleMetadata.importMetaBinding !== undefined) {
+        normalized.internalBindings = new Set(normalized.internalBindings)
+        normalized.internalBindings.add(moduleMetadata.importMetaBinding)
+      }
+      diagnosticInput = normalized
       prepared = compileStatefulRoot(normalized.code, { ...options, sourceMap: normalized.sourceMap,
         internalBindings: normalized.internalBindings, dynamicBindings: normalized.dynamicBindings,
         privateBindings: normalized.privateBindings, originalSource: program })
     } catch (error) {
       if (error instanceof ModuleRewriteError) throw error
       const position = error.loc === undefined ? undefined : { line: error.loc.line, column: error.loc.column + 1 }
-      throw new ModuleRewriteError(error.message, normalized === undefined ? position
-        : mapSourcePosition(position, normalized.code, program, normalized.sourceMap))
+      const failureInput = normalizationFailureInput(error) ?? diagnosticInput
+      throw new ModuleRewriteError(error.message, failureInput === undefined ? position
+        : mapSourcePosition(position, failureInput.code, program, failureInput.sourceMap))
     }
     prepared = { ...prepared, deferredHelpers: normalized.deferredHelpers }
     intrinsicContext.expression = `this[${JSON.stringify(prepared.rootRuntimeName)}].intrinsics`

package/internal/config-spec.js

@@ -96,7 +96,7 @@ export const CONFIG_FIELDS = Object.freeze([
   {
     key: 'userBindingsEnabled',
     type: 'boolean',
-    default: false,
+    default: true,
     label: '启用全局用户 Binding',
     labelEn: 'Enable Global User Bindings',
     description: '管理 TypeScript helper，并将已启用条目作为跨会话的默认 REPL 绑定。',

package/internal/cordis-tools-owner.js

@@ -133,12 +133,22 @@ function requireCompanionServices(agent) {
 
 async function companionSkillDirectory(agentPresets) {
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
-  if (typeof preset?.path !== 'string' || !isAbsolute(preset.path)) {
-    throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
-  }
   if (typeof preset.broken === 'string' && preset.broken.length > 0) {
     throw new Error(`ptc-plus: DSH cordis preset is unavailable: ${preset.broken}`)
   }
+  // The generations that discover presets from their composition directories
+  // publish an absolute path, and the preset's sibling `skills` directory is
+  // then the companion Skill root. A generation that declares presets without
+  // any composition path publishes no root through this surface at all, so the
+  // report names that missing publication instead of claiming a shape failure
+  // on a healthy host. A published path that is not absolute is still a
+  // contract contradiction.
+  if (preset?.path === undefined) {
+    throw new Error('ptc-plus: the installed DSH agentPresets generation publishes no composition path for the "cordis" preset, so it does not publish the companion Skill root that cordisToolsEnabled mounts')
+  }
+  if (typeof preset.path !== 'string' || !isAbsolute(preset.path)) {
+    throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
+  }
   return join(dirname(preset.path), 'skills')
 }
 
@@ -329,6 +339,7 @@ export function createCordisToolsOwner(
 
   const installAgent = (agent) => {
     if (disposed) return Promise.resolve()
+    if (withdrawn.has(agent)) return Promise.resolve()
     const mounted = mounts.get(agent)
     if (mounted !== undefined) {
       return mounted.withdrawn === true ? Promise.resolve() : mounted.activation
@@ -416,11 +427,11 @@ export function createCordisToolsOwner(
   /**
    * Install for a call the host makes on its own behalf.
    *
-   * DSH 0.1.6 announces `agent/created` serially and rejects `agents.create()`
-   * when a listener rejects, so a scope this owner cannot serve must withdraw
-   * instead of failing an operation another plugin asked for. Install-time
-   * enumeration stays strict: there the plugin speaks for what it claims to
-   * have published, and `ready` reports the same failure.
+   * The public host lifecycle announces `agent/created` serially and rejects
+   * `agents.create()` when a listener rejects, so a scope this owner cannot
+   * serve must withdraw instead of failing an operation another plugin asked
+   * for. Install-time enumeration stays strict: there the plugin speaks for
+   * what it claims to have published, and `ready` reports the same failure.
    */
   const installForHost = (agent) => {
     let activation
@@ -451,8 +462,7 @@ export function createCordisToolsOwner(
       if (disposed) return
       for (const agent of [...pending]) {
         void Promise.resolve().then(() => installAgent(agent)).catch(error => {
-          pending.delete(agent)
-          ctx.logger?.warn?.('ptc-plus: deferred Cordis activation failed', error)
+          withdraw(agent, error)
         })
       }
     })

package/internal/edit-transport-owner.js

@@ -238,11 +238,34 @@ export function createEditTransportOwner(ctx, {
     }
   }
 
+  const disposeInstalled = (installed) => {
+    const failures = []
+    for (const key of ['disposePresentation', 'disposeRegistration']) {
+      const dispose = installed[key]
+      if (dispose === undefined) continue
+      try {
+        dispose()
+        installed[key] = undefined
+      } catch (error) {
+        failures.push(error)
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'ptc-plus: edit_run_code scope disposal failed')
+    }
+  }
+
   const uninstall = (agent) => {
     const installed = installedScopes.get(agent)
     if (installed === undefined) return
-    installedScopes.delete(agent)
-    installed.dispose()
+    try {
+      disposeInstalled(installed)
+    } finally {
+      if (installed.disposePresentation === undefined
+        && installed.disposeRegistration === undefined) {
+        installedScopes.delete(agent)
+      }
+    }
   }
 
   return Object.freeze({
@@ -251,11 +274,19 @@ export function createEditTransportOwner(ctx, {
       currentDurableReplay = nextConfig.durableReplay
     },
     isInstalled(agent) {
-      return installedScopes.has(agent)
+      const installed = installedScopes.get(agent)
+      return installed?.disposePresentation !== undefined
+        && installed.disposeRegistration !== undefined
     },
     ensureInstalled(agent) {
       const installed = installedScopes.get(agent)
-      if (installed !== undefined) return installed.definition
+      if (installed !== undefined) {
+        if (installed.disposePresentation !== undefined
+          && installed.disposeRegistration !== undefined) {
+          return installed.definition
+        }
+        uninstall(agent)
+      }
       const liveSchemas = typeof toolSchemasForAgent === 'function'
         ? toolSchemasForAgent(agent)
         : []
@@ -271,24 +302,31 @@ export function createEditTransportOwner(ctx, {
       if (typeof disposeRegistration !== 'function') {
         throw new Error('ptc-plus: DSH tools.register did not return a disposer')
       }
-      let disposePresentation
+      const nextInstalled = {
+        definition,
+        disposePresentation: undefined,
+        disposeRegistration,
+        sessionId: sessionId(agent),
+      }
+      installedScopes.set(agent, nextInstalled)
       try {
-        disposePresentation = scopedTools.presentAs('both')
+        const disposePresentation = scopedTools.presentAs('both')
         if (typeof disposePresentation !== 'function') {
           throw new Error('ptc-plus: DSH tools.presentAs did not return a disposer')
         }
+        nextInstalled.disposePresentation = disposePresentation
       } catch (error) {
-        disposeRegistration()
+        try {
+          uninstall(agent)
+        } catch (cleanupError) {
+          throw new AggregateError(
+            [error, cleanupError],
+            'ptc-plus: edit_run_code installation and rollback failed',
+            { cause: error },
+          )
+        }
         throw error
       }
-      let active = true
-      const dispose = () => {
-        if (!active) return
-        active = false
-        disposePresentation()
-        disposeRegistration()
-      }
-      installedScopes.set(agent, { definition, dispose, sessionId: sessionId(agent) })
       return definition
     },
     handleResult(exec, result) {
@@ -305,28 +343,50 @@ export function createEditTransportOwner(ctx, {
       releaseClaim(pending.id, pending.targetCallSeq)
     },
     disposeAgent(agent) {
-      uninstall(agent)
+      let failure
+      try {
+        uninstall(agent)
+      } catch (error) {
+        failure = error
+      }
       const id = sessionId(agent)
       if (id !== undefined) {
         discardSettlements(id)
         editClaims.delete(id)
       }
+      if (failure !== undefined) throw failure
     },
     disposeSession(session) {
       const id = String(session.id)
+      const failures = []
       for (const [agent, installed] of installedScopes) {
         if (installed.sessionId !== id) continue
-        installedScopes.delete(agent)
-        installed.dispose()
+        try {
+          uninstall(agent)
+        } catch (error) {
+          failures.push(error)
+        }
       }
       discardSettlements(id)
       editClaims.delete(id)
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus: edit_run_code session disposal failed')
+      }
     },
     dispose() {
       discardSettlements()
       editClaims.clear()
-      for (const installed of installedScopes.values()) installed.dispose()
-      installedScopes.clear()
+      const failures = []
+      for (const agent of [...installedScopes.keys()]) {
+        try {
+          uninstall(agent)
+        } catch (error) {
+          failures.push(error)
+        }
+      }
+      if (failures.length > 0) {
+        throw new AggregateError(failures, 'ptc-plus: edit_run_code owner disposal failed')
+      }
     },
   })
 }