dsh-ptc-plus 0.4.3 → 0.4.10

package/internal/direct-surface-owner.js

@@ -1,4 +1,7 @@
 /** Own PTC direct presentation, prompt projection, and stream normalization. */
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm'
+import { validateJsonSchemaValue } from '@deepseek-ai/dsh-tools'
+import { PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
 import { canonicalizeToolCallStream } from './tool-call-canonicalizer.js'
 import { editRunCodeSchema } from './rejected-cell-editor.js'
 import { sessionRuntimeContexts } from './runtime-contexts.js'
@@ -19,6 +22,12 @@ const RUN_CODE_CODE_DESCRIPTION = 'Code for the next REPL cell, parsed as the bo
 const RUN_CODE_DESCRIPTION_DESCRIPTION = 'Short active-voice summary of what this cell does, 5-10 words (shown in the UI).'
 const CODE_TRANSPORT_INSTRUCTION = '`run_code` and `edit_run_code` are the only tools callable directly. Call every native tool declared by the SDK from inside a program.'
 const PTC_COLLAPSE_SECTION_NAMES = Object.freeze(['tools:ptc-only', 'tools:code-only'])
+const INVALID_TOOL_JSON_FAILURE = Object.freeze({
+  code: 'MALFORMED_RESPONSE',
+  message: 'DeepSeek Messages stream: tool input is invalid JSON',
+})
+const MALFORMED_TOOL_REJECTION_ID = 'dsh-ptc-plus-malformed-tool-json'
+const MALFORMED_TOOL_REJECTION_ARGUMENTS = '{"dsh_ptc_plus_malformed_tool_json":'
 
 function adaptRunCodeSchema(tool) {
   const parameters = tool.parameters
@@ -139,6 +148,314 @@ async function* bindCallPolicies(source, policy, calls) {
   }
 }
 
+function invalidToolJsonFinish(chunk) {
+  const failure = chunk?.reason?.failure
+  return chunk?.type === 'finish'
+    && chunk.reason.kind === 'error'
+    && failure?.code === INVALID_TOOL_JSON_FAILURE.code
+    && failure?.message === INVALID_TOOL_JSON_FAILURE.message
+}
+
+function invalidToolJsonError(error) {
+  const failure = error?.failure ?? error
+  return failure?.code === INVALID_TOOL_JSON_FAILURE.code
+    && failure?.message === INVALID_TOOL_JSON_FAILURE.message
+}
+
+function directToolSchemas(tools) {
+  const schemas = new Map()
+  if (!Array.isArray(tools)) return schemas
+  for (const tool of tools) {
+    if (tool?.name !== RUN_CODE && tool?.name !== EDIT_RUN_CODE) continue
+    if (schemas.has(tool.name) || !isRecord(tool.parameters)) return new Map()
+    schemas.set(tool.name, tool.parameters)
+  }
+  return schemas
+}
+
+function repairableDirectCall(chunks, tools) {
+  const finish = chunks.at(-1)
+  if (!invalidToolJsonFinish(finish)) return undefined
+  const completed = completedToolBlocks(chunks)
+  if (completed?.length !== 1) return undefined
+  const body = chunks.slice(0, -1)
+  const starts = body.filter(chunk => chunk?.type === 'block-start' && chunk.blockType === 'tool-call')
+  const deltas = body.filter(chunk => chunk?.type === 'tool-call-delta')
+  const ends = body.filter(chunk => chunk?.type === 'block-end' && chunk.block?.type === 'tool-call')
+  const usages = body.filter(chunk => chunk?.type === 'usage')
+  if (starts.length !== 1 || deltas.length === 0 || ends.length !== 1
+    || usages.length > 1
+    || body.some(chunk => chunk?.type !== 'usage' && !toolStreamChunk(chunk))) {
+    return undefined
+  }
+  const index = starts[0].index
+  const end = ends[0]
+  const id = end.block.id
+  const name = end.block.name
+  if (!Number.isSafeInteger(index) || index < 0 || typeof id !== 'string' || id.length === 0
+    || (name !== RUN_CODE && name !== EDIT_RUN_CODE)
+    || end.index !== index
+    || typeof end.block.arguments !== 'string'
+    || deltas.some(chunk => chunk.index !== index || chunk.id !== id
+      || (chunk.name !== undefined && chunk.name !== name)
+      || typeof chunk.argumentsDelta !== 'string')) {
+    return undefined
+  }
+  const raw = deltas.map(chunk => chunk.argumentsDelta).join('')
+  if (raw !== end.block.arguments || !raw.endsWith('}')) return undefined
+  const candidate = raw.slice(0, -1)
+  let value
+  try {
+    value = JSON.parse(candidate)
+  } catch {
+    return undefined
+  }
+  const schema = directToolSchemas(tools).get(name)
+  if (!isRecord(value) || schema === undefined
+    || validateJsonSchemaValue(schema, value).length !== 0) return undefined
+  return { index, candidate }
+}
+
+function canonicalToolBlock(index, block) {
+  return [
+    { type: 'block-start', index, blockType: 'tool-call' },
+    {
+      type: 'tool-call-delta', index, id: block.id, name: block.name,
+      argumentsDelta: block.arguments,
+    },
+    { type: 'block-end', index, block },
+  ]
+}
+
+function repairedDirectChunks(chunks, repair, usageAlreadyEmitted) {
+  const end = chunks.find(chunk => chunk?.type === 'block-end'
+    && chunk.index === repair.index && chunk.block?.type === 'tool-call')
+  const block = { ...end.block, arguments: repair.candidate }
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...canonicalToolBlock(repair.index, block),
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function completedToolBlocks(chunks) {
+  const body = chunks.slice(0, -1)
+  if (body.filter(chunk => chunk?.type === 'usage').length > 1
+    || body.some(chunk => chunk?.type !== 'usage' && !toolStreamChunk(chunk))) {
+    return undefined
+  }
+  const calls = new Map()
+  for (const chunk of chunks) {
+    if (chunk?.type === 'block-start' && chunk.blockType === 'tool-call') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      const call = calls.get(chunk.index)
+      if (call?.started === true || call?.block !== undefined) return undefined
+      if (call === undefined) calls.set(chunk.index, {
+        arguments: '', hasDelta: false, started: true,
+      })
+      else call.started = true
+    } else if (chunk?.type === 'tool-call-delta') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      let call = calls.get(chunk.index)
+      if (call === undefined) {
+        call = { arguments: '', hasDelta: false, started: false }
+        calls.set(chunk.index, call)
+      }
+      if (call.block !== undefined
+        || typeof chunk.id !== 'string' || chunk.id.length === 0
+        || (call.id !== undefined && call.id !== chunk.id)
+        || (chunk.name !== undefined && (typeof chunk.name !== 'string' || chunk.name.length === 0
+          || (call.name !== undefined && call.name !== chunk.name)))
+        || typeof chunk.argumentsDelta !== 'string') return undefined
+      call.id ??= chunk.id
+      if (chunk.name !== undefined) call.name ??= chunk.name
+      call.hasDelta = true
+      call.arguments += chunk.argumentsDelta
+    } else if (chunk?.type === 'block-end' && chunk.block?.type === 'tool-call') {
+      if (!Number.isSafeInteger(chunk.index) || chunk.index < 0) return undefined
+      let call = calls.get(chunk.index)
+      if (call === undefined) {
+        call = { arguments: '', hasDelta: false, started: false }
+        calls.set(chunk.index, call)
+      }
+      if (call.block !== undefined
+        || typeof chunk.block.id !== 'string' || chunk.block.id.length === 0
+        || typeof chunk.block.name !== 'string' || chunk.block.name.length === 0
+        || typeof chunk.block.arguments !== 'string'
+        || (call.id !== undefined && call.id !== chunk.block.id)
+        || (call.name !== undefined && call.name !== chunk.block.name)
+        || (call.hasDelta && call.arguments !== chunk.block.arguments)) return undefined
+      call.block = chunk.block
+    }
+  }
+  if (calls.size === 0 || [...calls.values()].some(call => call.block === undefined)) {
+    return undefined
+  }
+  const completed = [...calls].map(([index, call]) => ({ index, block: call.block }))
+  if (new Set(completed.map(call => call.block.id)).size !== completed.length) return undefined
+  return completed
+}
+
+function firstUsageChunk(chunks) {
+  return chunks.find(chunk => chunk?.type === 'usage')
+}
+
+function settleMalformedToolCalls(chunks, priorIndexes, usageAlreadyEmitted) {
+  if (!invalidToolJsonFinish(chunks.at(-1))) return undefined
+  const calls = completedToolBlocks(chunks)
+  if (calls === undefined || calls.some(call => priorIndexes.has(call.index))) return undefined
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...calls.flatMap(call => canonicalToolBlock(call.index, call.block)),
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function toolStreamChunk(chunk) {
+  return chunk?.type === 'tool-call-delta'
+    || (chunk?.type === 'block-start' && chunk.blockType === 'tool-call')
+    || (chunk?.type === 'block-end' && chunk.block?.type === 'tool-call')
+}
+
+function unusedString(base, used) {
+  let value = base
+  for (let suffix = 2; used.has(value); suffix++) value = `${base}-${suffix}`
+  return value
+}
+
+function visibleBlockClosures(openBlocks, chunks) {
+  const closing = new Map([...openBlocks].map(([index, block]) => [index, { ...block }]))
+  for (const chunk of chunks) {
+    const block = closing.get(chunk?.index)
+    if (block === undefined) continue
+    if (chunk.type === `${block.type}-delta` && typeof chunk.text === 'string') {
+      block.text += chunk.text
+    } else if (chunk.type === 'block-end' && chunk.block?.type === block.type) {
+      block.final = chunk.block
+    }
+  }
+  return [...closing].map(([index, block]) => ({
+    type: 'block-end',
+    index,
+    block: block.final ?? { type: block.type, text: block.text },
+  }))
+}
+
+function rejectedMalformedToolStream(
+  chunks,
+  priorIndexes = new Set(),
+  openBlocks = new Map(),
+  usageAlreadyEmitted = false,
+) {
+  const usedIndexes = new Set(priorIndexes)
+  const usedIds = new Set()
+  for (const chunk of chunks) {
+    if (Number.isSafeInteger(chunk?.index) && chunk.index >= 0) usedIndexes.add(chunk.index)
+    if (typeof chunk?.id === 'string') usedIds.add(chunk.id)
+    if (typeof chunk?.block?.id === 'string') usedIds.add(chunk.block.id)
+  }
+  let index = 0
+  while (usedIndexes.has(index)) index++
+  const id = unusedString(MALFORMED_TOOL_REJECTION_ID, usedIds)
+  const usage = usageAlreadyEmitted ? undefined : firstUsageChunk(chunks)
+  return [
+    ...visibleBlockClosures(openBlocks, chunks),
+    { type: 'block-start', index, blockType: 'tool-call' },
+    {
+      type: 'tool-call-delta', index, id, name: RUN_CODE,
+      argumentsDelta: MALFORMED_TOOL_REJECTION_ARGUMENTS,
+    },
+    {
+      type: 'block-end', index,
+      block: {
+        type: 'tool-call', id, name: RUN_CODE,
+        arguments: MALFORMED_TOOL_REJECTION_ARGUMENTS,
+      },
+    },
+    ...usage === undefined ? [] : [usage],
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  ]
+}
+
+function recoveredMalformedChunks(chunks, tools, priorIndexes, openBlocks, usageAlreadyEmitted) {
+  if (usageAlreadyEmitted && firstUsageChunk(chunks) !== undefined) {
+    return rejectedMalformedToolStream(chunks, priorIndexes, openBlocks, true)
+  }
+  const repair = repairableDirectCall(chunks, tools)
+  const settled = repair !== undefined && !priorIndexes.has(repair.index)
+    ? repairedDirectChunks(chunks, repair, usageAlreadyEmitted)
+    : settleMalformedToolCalls(chunks, priorIndexes, usageAlreadyEmitted)
+  return settled === undefined
+    ? rejectedMalformedToolStream(chunks, priorIndexes, openBlocks, usageAlreadyEmitted)
+    : [...visibleBlockClosures(openBlocks, chunks), ...settled]
+}
+
+function observeVisibleBlock(openBlocks, chunk) {
+  if (chunk?.type === 'block-start'
+    && (chunk.blockType === 'text' || chunk.blockType === 'reasoning')) {
+    openBlocks.set(chunk.index, { type: chunk.blockType, text: '' })
+  } else if (chunk?.type === 'text-delta' || chunk?.type === 'reasoning-delta') {
+    const block = openBlocks.get(chunk.index)
+    const type = chunk.type === 'text-delta' ? 'text' : 'reasoning'
+    if (block?.type === type) block.text += chunk.text
+  } else if (chunk?.type === 'block-end') {
+    openBlocks.delete(chunk.index)
+  }
+}
+
+async function* recoverMalformedToolCallStream(source, tools) {
+  let pending = []
+  const priorIndexes = new Set()
+  const openBlocks = new Map()
+  let usageSeen = false
+  try {
+    for await (const chunk of source) {
+      if (pending.length === 0) {
+        if (toolStreamChunk(chunk)) pending.push(chunk)
+        else if (chunk?.type === 'usage' && usageSeen) pending.push(chunk)
+        else if (invalidToolJsonFinish(chunk)) {
+          yield* rejectedMalformedToolStream([chunk], priorIndexes, openBlocks, usageSeen)
+          openBlocks.clear()
+        } else {
+          if (Number.isSafeInteger(chunk?.index) && chunk.index >= 0) priorIndexes.add(chunk.index)
+          observeVisibleBlock(openBlocks, chunk)
+          if (chunk?.type === 'usage') usageSeen = true
+          yield chunk
+        }
+        continue
+      }
+      pending.push(chunk)
+      if (chunk?.type !== 'finish') continue
+      const output = invalidToolJsonFinish(chunk)
+        ? recoveredMalformedChunks(pending, tools, priorIndexes, openBlocks, usageSeen)
+        : pending
+      for (const outputChunk of output) {
+        if (Number.isSafeInteger(outputChunk?.index) && outputChunk.index >= 0) {
+          priorIndexes.add(outputChunk.index)
+        }
+        if (outputChunk?.type === 'usage') usageSeen = true
+        yield outputChunk
+      }
+      if (invalidToolJsonFinish(chunk)) openBlocks.clear()
+      pending = []
+    }
+  } catch (error) {
+    if (invalidToolJsonError(error)) {
+      yield* recoveredMalformedChunks([
+        ...pending,
+        { type: 'finish', reason: { kind: 'error', failure: INVALID_TOOL_JSON_FAILURE } },
+      ], tools, priorIndexes, openBlocks, usageSeen)
+      return
+    } else {
+      yield* pending
+      throw error
+    }
+  }
+  yield* pending
+}
+
 export function createDirectSurfaceOwner({
   editTransport,
   runtimeConfig,
@@ -147,6 +464,7 @@ export function createDirectSurfaceOwner({
   toolSchemasForAgent,
   userBindingsForAgent = async () => undefined,
   setAgentPresentation = async () => {},
+  sessionLogView,
 }) {
   // Composition is anchored to Agent identity because DSH selects presentation
   // once per composed agent. Request signals bind the exact assembly to stream
@@ -317,6 +635,7 @@ export function createDirectSurfaceOwner({
       }
       const runtimeContexts = sessionPtc
         ? sessionRuntimeContexts(agent, tipConfig, {
+          sessionLogView,
           cordisRecoveryRequired(view) {
             return cordisRecovery.required(agent, view)
           },
@@ -383,7 +702,8 @@ export function createDirectSurfaceOwner({
           editToolName: EDIT_RUN_CODE,
         })
         : next()
-      return bindCallPolicies(source, policy, policy.owner.calls)
+      const recovered = recoverMalformedToolCallStream(source, options.tools)
+      return bindCallPolicies(recovered, policy, policy.owner.calls)
     },
     executionRejection(exec) {
       if (exec.name === EDIT_RUN_CODE && exec.parent !== undefined) {
@@ -430,12 +750,18 @@ export function createDirectSurfaceOwner({
       const outer = missingPath === 'description'
         && policy?.autoDescribeRunCode !== true
         && !(isRecord(exec.arguments) && typeof exec.arguments.description === 'string')
-      const context = {
-        name: 'tools:ptc-plus-run-code-arguments',
-        text: outer
-          ? 'The run_code outer transport arguments are invalid at JSON path $.description. Add a sibling string `description` field to run_code; a description nested inside a native-tool argument does not satisfy this outer requirement.'
-          : `A nested native-tool argument is missing required property "${missingPath}". Add a string description at that path in the native-tool arguments; the outer run_code description does not satisfy this nested requirement.`,
-      }
+      const text = outer
+        ? 'The run_code outer transport arguments are invalid at JSON path $.description. Add a sibling string `description` field to run_code; a description nested inside a native-tool argument does not satisfy this outer requirement.'
+        : `A nested native-tool argument is missing required property "${missingPath}". Add a string description at that path in the native-tool arguments; the outer run_code description does not satisfy this nested requirement.`
+      // additionalContexts enter the durable inbox as messages, not prompt sections.
+      const context = createUserMessage({
+        source: {
+          kind: PTC_MESSAGE_SOURCE_KIND,
+          form: 'notice',
+          summary: boundContextSummary('tools:ptc-plus-run-code-arguments'),
+        },
+        content: [{ type: 'text', text }],
+      })
       return {
         ...diagnosed,
         additionalContexts: [...diagnosed.additionalContexts ?? [], context],

package/internal/edit-transport-owner.js

@@ -17,7 +17,7 @@ import {
   editRejectedCell,
   editRunCodeSchema,
 } from './rejected-cell-editor.js'
-import { editTargetForCall, projectSessionLog } from './session-log-view.js'
+import { projectSessionLog } from './session-log-view.js'
 import { RUN_CODE } from './runtime-bridge-owner.js'
 import { isRecord } from './record-utils.js'
 import {
@@ -67,6 +67,8 @@ export function createEditTransportOwner(ctx, {
   presentationGeneration,
   sessionId,
   toolSchemasForAgent,
+  readSessionLog,
+  sessionLogView = projectSessionLog,
 }) {
   let currentDurableReplay = durableReplay
   const editExecutionMetadata = new WeakMap()
@@ -143,13 +145,14 @@ export function createEditTransportOwner(ctx, {
   definition.execute = async (args, exec) => {
     const agent = exec?.agent
     const callId = typeof exec?.callId === 'string' ? exec.callId : undefined
-    const persistedTargetCallSeq = liveToolCallSeq(agent?.session, callId, EDIT_RUN_CODE)
-    if (persistedTargetCallSeq === undefined && projectSessionLog(agent).editableRun !== undefined) {
+    const sessionLog = await readSessionLog(agent?.session, exec.signal)
+    const persistedTargetCallSeq = liveToolCallSeq(sessionLog, callId, EDIT_RUN_CODE)
+    if (persistedTargetCallSeq === undefined && sessionLogView(agent).editableRun !== undefined) {
       throw new Error('ptc-plus: edit_run_code requires a unique persisted tool/call event')
     }
     const target = persistedTargetCallSeq === undefined
       ? undefined
-      : editTargetForCall(agent, callId, persistedTargetCallSeq)
+      : sessionLogView(agent, { callId, callSeq: persistedTargetCallSeq }).requestedEditTarget
     if (target?.source === undefined || target.callSeq === undefined) {
       return { edited: false, reason: 'no run_code cell is currently eligible for safe editing' }
     }
@@ -190,7 +193,7 @@ export function createEditTransportOwner(ctx, {
         agent,
         signal: exec.signal,
       })
-      const tentative = await executeTentative(persistedCallSeq, dispatch)
+      const tentative = await executeTentative(persistedCallSeq, dispatch, sessionLog)
       const inner = tentative.result
       finalizeTentative = tentative.finalize
       const journalValue = isRecord(inner?.meta) && Object.hasOwn(inner.meta, JOURNAL_KEY)

package/internal/execution-provider-owner.js

@@ -0,0 +1,157 @@
+import { createExecutionSeam, EXECUTION_SEAM_SERVICE } from './execution-seam-compat.js'
+
+export const name = 'ptc-plus-execution-provider'
+export const inject = ['loader']
+
+export function apply(ctx, config = {}) {
+  const ownerFiber = ctx.fiber
+  const { originalEntryId = 'ptc-runtime', isolation = 'ptc-plus-original' } = config
+  if (typeof originalEntryId !== 'string' || originalEntryId.length === 0
+    || typeof isolation !== 'string' || isolation.length === 0) {
+    throw new TypeError('ptc-plus: execution provider requires an original entry id and named isolation')
+  }
+  // Profile rows belong to the Include's tree; the global Loader resolves root IDs.
+  const entryTree = ownerFiber.entry?.parent.tree ?? ctx.loader
+  const originalEntry = entryTree.resolve(originalEntryId)
+  const isolated = () => originalEntry.options.isolate?.[EXECUTION_SEAM_SERVICE] === isolation
+  if (!isolated()) throw new Error(`ptc-plus: original entry ${originalEntryId} must isolate ${EXECUTION_SEAM_SERVICE} as ${isolation}`)
+  const originalContext = originalEntry.context.extend({ [originalEntry.constructor.key]: undefined })
+  let watcher
+  let live
+  let stopped = false
+  let suspended = false
+  let generation
+  const pending = new Set()
+  let resolveAttachment
+  let rejectAttachment
+  const attachment = new Promise((resolve, reject) => {
+    resolveAttachment = resolve
+    rejectAttachment = reject
+  })
+  const readOriginal = () => {
+    const original = isolated() ? originalContext.get(EXECUTION_SEAM_SERVICE) : undefined
+    if (stopped || original === undefined) {
+      throw new Error(`ptc-plus: original ${EXECUTION_SEAM_SERVICE} generation is unavailable`)
+    }
+    return original
+  }
+  const release = () => {
+    const entry = live
+    if (entry === undefined) return
+    live = undefined
+    entry.seam.retire()
+    const unregistration = entry.unregister?.()
+    const disposal = Promise.allSettled([unregistration, entry.disposeChild?.()]).then(results => {
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus: execution provider disposal failed')
+    })
+    pending.add(disposal)
+    disposal.then(() => pending.delete(disposal), error => {
+      pending.delete(disposal)
+      ctx.logger.warn(error)
+    })
+    return disposal
+  }
+  const suspend = () => {
+    suspended = true
+    const disposal = release()
+    const previous = watcher
+    watcher = undefined
+    return Promise.all([disposal, previous?.dispose()])
+  }
+  const publish = () => {
+    const resolutions = new WeakMap()
+    const delegate = {
+      get language() { return readOriginal().language },
+      get isolation() { return readOriginal().isolation },
+      get executionInstructions() { return readOriginal().executionInstructions },
+      get sandboxMode() { return readOriginal().sandboxMode },
+      get timeout() { return readOriginal().timeout },
+      resolve(request) {
+        const original = readOriginal()
+        const spec = original.resolve(request)
+        if (spec !== null && typeof spec === 'object') {
+          resolutions.set(spec, { original, generation })
+        }
+        return spec
+      },
+      run(spec) {
+        const resolved = resolutions.get(spec)
+        if (resolved?.generation?.active === false) throw new Error('ptc-plus: resolved spec belongs to an unavailable original generation')
+        const original = resolved?.original ?? readOriginal()
+        return original.run(spec)
+      },
+    }
+    const seam = createExecutionSeam(delegate, EXECUTION_SEAM_SERVICE)
+    const entry = { seam }
+    live = entry
+    entry.disposeChild = ctx.effect(() => {
+      const child = ctx.plugin({
+        name: 'ptc-plus-composed-runtime',
+        apply(childContext) {
+          childContext.effect(() => {
+            if (stopped || live !== entry || !isolated()) return () => {}
+            entry.unregister = childContext.provide(EXECUTION_SEAM_SERVICE, seam.provider)
+            return () => entry.unregister()
+          }, 'ptc-plus owned execution registration')
+        },
+      })
+      entry.child = child
+      return () => child.dispose()
+    }, 'ptc-plus owned execution child')
+    return entry.child.await().then(() => {
+      if (!stopped && live === entry && entry.unregister !== undefined && entry.child.state === 2) resolveAttachment()
+    }, error => {
+      rejectAttachment(error)
+      throw error
+    })
+  }
+  const watch = () => {
+    if (stopped || watcher !== undefined || !isolated()) return
+    ctx.effect(() => {
+      const observer = originalContext.inject([EXECUTION_SEAM_SERVICE], scope => {
+        if (stopped || !isolated()) return
+        createExecutionSeam(scope.get(EXECUTION_SEAM_SERVICE), EXECUTION_SEAM_SERVICE)
+        const currentGeneration = { active: true }
+        generation = currentGeneration
+        scope.effect(() => () => {
+          currentGeneration.active = false
+          if (generation === currentGeneration) generation = undefined
+        }, 'ptc-plus original generation scope')
+        if (live === undefined) return publish()
+        return live.seam.sourceChanged()
+      })
+      watcher = observer
+      return () => observer.dispose()
+    }, 'ptc-plus original execution observer')
+  }
+  ctx.on('loader/partial-dispose', (entry, _legacy, active) => {
+    if (entry === originalEntry && (!active || !isolated())) void suspend().catch(error => ctx.logger.warn(error))
+  }, { prepend: true, global: true })
+  ctx.on('loader/patch-context', (entry, next) => {
+    if (entry === originalEntry && !isolated()) void suspend().catch(error => ctx.logger.warn(error))
+    next()
+    if (entry === originalEntry && isolated() && suspended && !stopped && ownerFiber.state === 2) {
+      stopped = true
+      resolveAttachment()
+      void suspend().catch(error => ctx.logger.warn(error))
+      void ownerFiber.restart().catch(error => ctx.logger.warn(error))
+    }
+  }, { prepend: true, global: true })
+  ctx.effect(() => () => {
+    stopped = true
+    resolveAttachment()
+    const suspension = suspend()
+    return Promise.all([suspension, ...pending])
+  }, 'ptc-plus execution provider composition')
+  if (originalEntry.disabled) resolveAttachment()
+  const timer = setTimeout(() => rejectAttachment(new Error(
+    `ptc-plus: original execution entry ${originalEntryId} did not publish ${EXECUTION_SEAM_SERVICE}`,
+  )), 30_000)
+  ctx.effect(() => () => clearTimeout(timer), 'ptc-plus original execution provider wait')
+  const originalReady = originalEntry.fiber?.await() ?? Promise.resolve()
+  return originalReady.then(() => {
+    watch()
+    return attachment
+  }).finally(() => clearTimeout(timer))
+}