dsh-ptc-plus 0.5.6 → 0.5.8

package/docs/runtime-reference.md

@@ -148,17 +148,17 @@ Missing-description diagnostics append a complete DSH user message to `additiona
     tipEscalationFailures: 2
 ```
 
-The five legacy binding and module switches remain migration inputs. Complete enabled/protected choices map to the corresponding new policy; mixed old choices retain their effective controls until the user explicitly selects the new switch. The Host schema preserves an omitted `bindingUpdates` value until migration, and the settings card resolves the same policy. Selecting the switch also clears the compatibility marker.
+The five legacy binding and module switches remain migration inputs. Complete enabled/protected choices map to the corresponding new policy; mixed old choices retain their effective controls until the user explicitly selects a policy. The Host schema preserves an omitted `bindingUpdates` value until migration, and the settings card resolves the same policy. The **Binding update semantics** selector displays **Legacy settings (not migrated)** until a policy is selected, then shows **Allow redeclarations and overrides** (`stateful`) or **Protect names** (`protected`). Selecting a policy also clears the compatibility marker.
 
 `enabled: false` is the settings-based kill switch: the Host keeps the settings namespace, client card, and passive cleanup that can withdraw old PTC declarations at the next permitted accepted step. It removes execution hooks, prompt sections, and tool surfaces without reading binding storage. Settings are applied live when their owner can reconcile them, except the capability inputs frozen per session above and the activation-only seam wait `executionSeamTimeoutMs`, which is read when the plugin activates or reloads. A submitted cell retains one configuration snapshot for its budgets and policies through preflight, execution, binding calls, completion validation, and diagnostics; an update accepted while it runs applies to cells submitted afterward. Worker lifecycle bounds are not cell budgets: `maxOldGenerationSizeMb` is fixed at creation, and `workerReclaimMs` and `startupProbeMs` are read from the current configuration when a worker is created or closed. Node fixes a worker's V8 old-generation limit at creation, so changing `maxOldGenerationSizeMb` while a session worker is active or a submitted cell is preparing to execute is rejected and rolled back rather than reported as applied. Other non-`enabled` updates reconfigure existing owners without replacing session-bound bindings. The settings card renders in whichever settings seat the installed DSH declares — the sidebar **Plugins → Installed** page per-bundle configuration (`plugins.row.config`), or the preceding Host's **Settings → Plugin configuration** card (`settings.plugin.item`) ([ADR 0019](adr/0019-plugin-settings-and-kill-switch.md)) — places the main switch beside the PTC Plus title and disables every other control while the plugin is off. The card does not register in General settings; the sparkle menu opens the same complete form in an application dialog. If a live enable or reconfiguration cannot install a complete runtime, PTC Plus unwinds or restores every owner and persists the last applied settings; a failed compensating settings write is surfaced as an activation diagnostic. The TypeScript language check is deferred until runtime activation, so a non-TypeScript host can load the plugin in disabled mode but cannot enable it.
 
 `startupProbeMs` bounds the worker startup conformance probe, which must settle before the kernel reports ready. The worker reads the value from its startup data and falls back to 5000 ms when it is absent; a healthy probe settles inside the worker's own microtasks, so the bound can only fire when startup itself yields or blocks, and the failure is reported as a startup diagnostic without executing any cell. That worker-side read is verified by inspection rather than by a timer test, because a healthy probe never reaches the bound.
 
-`officialReplPriority` defaults to `false` and is evaluated against the live provider capability rather than a release number: a provider that declares `retainsState: true` keeps a program environment per state owner, and a provider that predates that declaration answers through the one retained source form (`programFormat: 'repl'`). With the setting enabled and such a provider live, this host attachment installs no session runtime, so `run_code` and its descriptors — `programFormat`, `retainsState`, `executionInstructions`, `sandboxMode` and `timeout` — stay with the official provider, and the plugin's REPL guidance, session-state semantics, recovery, editor tool, capability SDK, REPL observation and binding workbench are suspended until ownership changes back. The settings card, enablement and stored global bindings remain available so the switch can be reversed. Changing the setting or the host mode re-evaluates ownership as an installation change: the retired attachment disposes its live kernels before the other shape installs, so no committed cell mixes owners. Calls executed under the official mode produce no plugin journal records and are never recovery evidence. The plugin's provider surface forwards `programFormat` to the live original, answers `retainsState` for itself (an installed session kernel retains a per-session environment; otherwise the original declaration decides) and retains weak owner-to-original dispatch provenance for `release(owner)` — captured Agent cleanup reaches the original instances that served that owner even after adapter removal or source replacement, and a failed cleanup remains available for explicit retry. Owner-keyed retained environments and the executed program format belong to the provider that actually runs the program, and non-session consumers such as the workflow adapter keep executing through it — while `executionInstructions`, `sandboxMode` and `timeout` stay withheld while PTC Plus owns session execution. The plugin's own session kernel state is keyed by session and released through the plugin lifecycle, not by `release(owner)`.
+`officialReplPriority` defaults to `false` and is evaluated against the live provider capability rather than a release number: a provider that declares `retainsState: true` keeps a program environment per state owner, and a provider that predates that declaration answers through the one retained source form (`programFormat: 'repl'`). With the setting enabled and such a provider live, this host attachment installs no session runtime, so `run_code` and its descriptors — `programFormat`, `retainsState`, `executionInstructions`, `sandboxMode` and `timeout` — stay with the official provider, and the plugin's REPL guidance, session-state semantics, recovery, editor tool, capability SDK, REPL observation and binding workbench are suspended until ownership changes back. The settings card, enablement and stored global bindings remain available so the switch can be reversed. Changing the setting or the host mode re-evaluates ownership as an installation change: the retired attachment disposes its live kernels before the other shape installs, so no committed cell mixes owners. Calls executed under the official mode produce no plugin journal records and are never recovery evidence. The plugin's provider surface forwards `programFormat` to the live original, answers `retainsState` for itself (an installed session kernel retains a per-session environment; otherwise the original declaration decides) and retains weak owner-to-original dispatch provenance for `release(owner)` — captured Agent cleanup reaches the original instances that served that owner even after adapter removal or source replacement, and a failed cleanup remains available for explicit retry. Owner-keyed retained environments and the executed program format belong to the provider that actually runs the program, and non-session consumers such as the workflow adapter keep executing through it — while `executionInstructions`, `sandboxMode` and `timeout` stay withheld while PTC Plus owns session execution. The plugin's own kernel is keyed by session. For a live session Agent, `release(owner)` implements the Host's explicit reset: it releases the kernel and appends a durable reset boundary, clearing earlier bindings, named checkpoints and edit targets from subsequent computation. For an Agent scope whose public Cordis fiber uid is already null, release is lifecycle cleanup and preserves proven cold recovery. Both routes also clean up original-provider state; failures propagate for Host-managed retry. Non-session owners retain original-provider delegation.
 
-`cordisToolsEnabled: true` atomically mounts the official `@deepseek-ai/dsh-tool-cordis` plugin and exactly the shipped `cordis-plugin-development` companion Skill in agent scopes that expose the `run_code` and `skill` tools plus the public preset and Skill services. PTC Plus resolves the official `cordis` preset through DSH's public preset service, lets the maintained filesystem provider read its Skill root as an immutable bundled Host resource, and filters that provider at the public registration boundary so sibling Skills are never published to the PTC scope. It does not copy the Skill or switch the agent's preset. The first request waits until the Cordis tool fiber, owner guidance, exact Skill provider, and scoped Skill load are all ready. An agent scope that omits one of those surfaces is left for later: the owner publishes nothing there, reports nothing, and retries when the tool surface changes or the next prompt is assembled. A scope whose exposed preset, Skill/tool service, declared Cordis service, inspect manifest, or activation contradicts the host contract fails the setting change at installation and removes every provisional contribution; reached through the host's own `agent/created` or assemble call it withdraws from that scope with one warning instead, so this plugin's unavailability never fails an agent another plugin created ([ADR 0029](adr/0029-keep-plugin-unavailability-out-of-the-host-agent-lifecycle.md)). Disable and agent/runtime disposal remove both fibers. Native agents inherit neither the resulting `tools.*` members nor the Skill, and the code-only direct-tool projection remains `[run_code]`. Cordis can evaluate model-written plugins against the live runtime, so enabling it grants shell-equivalent trust.
+`cordisToolsEnabled: true` atomically mounts the official `@deepseek-ai/dsh-tool-cordis` plugin and exactly the selected official companion Skill in agent scopes that expose the `run_code` and `skill` tools plus the public preset and Skill services. PTC Plus resolves the official `cordis` preset through DSH's public preset service, lets the maintained filesystem provider read its Skill root as an immutable bundled Host resource, and filters that provider at the public registration boundary so sibling Skills are never published to the PTC scope. It does not copy the Skill or switch the agent's preset. The first request waits until the Cordis tool fiber, owner guidance, exact Skill provider, and scoped Skill load are all ready. An agent scope that omits one of those surfaces is left for later: the owner publishes nothing there, reports nothing, and retries when the tool surface changes or the next prompt is assembled. A scope whose exposed preset, Skill/tool service, declared Cordis service, inspect manifest, or activation contradicts the host contract fails the setting change at installation and removes every provisional contribution; reached through the host's own `agent/created` or assemble call it withdraws from that scope with one warning instead, so this plugin's unavailability never fails an agent another plugin created ([ADR 0029](adr/0029-keep-plugin-unavailability-out-of-the-host-agent-lifecycle.md)). Disable and agent/runtime disposal remove both fibers. Native agents inherit neither the resulting `tools.*` members nor the Skill, and the code-only direct-tool projection remains `[run_code]`. Cordis can evaluate model-written plugins against the live runtime, so enabling it grants shell-equivalent trust.
 
-The Skill root uses the preset's absolute composition path when that generation publishes one. A pathless generation is resolved through the active Host's public `pluginPackages.packageOf` service, which returns the official singular or plural preset package from that installation rather than an ambient package reachable from the plugin profile. An older generation with no such service may resolve only its historical plural package relative to the Host's `ctx.baseUrl`; the fallback is disabled whenever `pluginPackages` exists. The exact `cordis-plugin-development/SKILL.md` must exist before the mount begins. An invalid published path remains authoritative and fails instead of falling through to another generation's package layout.
+The Skill root uses the preset's absolute composition path when that generation publishes one. A pathless generation is resolved through the active Host's public `pluginPackages.packageOf` service, which returns the official singular or plural preset package from that installation rather than an ambient package reachable from the plugin profile. An older generation with no such service may resolve only its historical plural package relative to the Host's `ctx.baseUrl`; the fallback is disabled whenever `pluginPackages` exists. The root must contain `dsh-doc/SKILL.md` or the historical `cordis-plugin-development/SKILL.md`; `dsh-doc` takes precedence when both exist. The selected official name and resource base remain intact through discovery, loading and readiness validation. An invalid published path remains authoritative and fails instead of falling through to another generation's package layout.
 
 Keep large Cordis host or client source in a top-level binding before calling a Cordis tool. If that call rejects while the worker stays live, an initialized binding can be reused in a short continuation. Decide whether to retry from the operation owner's retry/idempotence contract and available execution facts; a thrown call or a smaller cell does not prove that no effect occurred.
 

package/internal/capability-environment.js

@@ -496,8 +496,11 @@ const callingRevision = capability => capability === undefined || capability.eff
 
 function contractUpdateMessage(snapshot, sessionId) {
   const dependencies = new Map()
+  // Recorded generations retain their exact body for restoration and deduplication.
+  const grouped = snapshot.schema === 'ptc-capability-contracts/v2'
+  const onDemand = grouped ? snapshot.changes.filter(change => change.capability !== null && change.disclosure === 'on-demand') : []
   const text = ['PTC Plus current calling contracts. These updates replace the earlier contracts for the listed capabilities only; session enablement and disclosure choices are unchanged.',
-    ...snapshot.changes.map(change => change.capability === null
+    ...snapshot.changes.filter(change => !grouped || change.capability === null || change.disclosure === 'full').map(change => change.capability === null
       ? `### ${change.id}\nThe Host no longer supplies this capability. Its earlier calling contract no longer applies.`
       : change.disclosure === 'full'
         ? [...(change.capability.dependencies ?? []).flatMap(item => {
@@ -508,6 +511,7 @@ function contractUpdateMessage(snapshot, sessionId) {
           return [`### dependency:${item.id}\n${item.text}`]
         }), `### ${change.id}\n${change.capability.contract}`].join('\n\n')
         : `### ${change.id}\nThe Host calling contract has changed. Retrieve the current complete contract with capabilities.search(${JSON.stringify({ query: change.id })}) before invoking it.`),
+    ...(onDemand.length === 0 ? [] : [`### Updated on-demand contracts\nBefore invoking any capability below, retrieve its current complete contract with capabilities.search({query: "<capability ID>"}):\n${onDemand.map(change => `- ${change.id}`).join('\n')}`]),
     ...(snapshot.overageBytes > 0 ? [`The currently selected full contracts exceed the configured budget by ${snapshot.overageBytes} UTF-8 bytes.`] : [])].join('\n\n')
   return createUserMessage({ source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'capability-contracts', sessionId,
     digest: digest(snapshot), snapshot }, content: [{ type: 'text', text }] })
@@ -517,7 +521,7 @@ function readContractUpdate(message, planDigest, sessionId) {
   const source = message?.source
   const snapshot = source?.snapshot
   if (source?.kind !== PTC_MESSAGE_SOURCE_KIND || source.form !== 'capability-contracts'
-    || source.sessionId !== sessionId || snapshot?.schema !== 'ptc-capability-contracts/v1'
+    || source.sessionId !== sessionId || !['ptc-capability-contracts/v1', 'ptc-capability-contracts/v2'].includes(snapshot?.schema)
     || snapshot.planDigest !== planDigest || source.digest !== digest(snapshot)
     || !Array.isArray(snapshot.views) || !Array.isArray(snapshot.changes)
     || !Number.isSafeInteger(snapshot.overageBytes) || snapshot.overageBytes < 0) return undefined
@@ -1953,7 +1957,7 @@ export function createCapabilityEnvironment({ ctx, config, toolSchemasForAgent,
             .filter(item => state.snapshot.capabilities.some(original => original.id === item.id)),
           manual: { baseline: [], overrides: Object.fromEntries(state.snapshot.plan.entries.map(entry => [entry.id, entry.selection === 'host' ? 'full' : entry.selection])) },
           navigationText: NAVIGATION, configurationRevision: state.snapshot.plan.configurationRevision })
-          additions.push(contractUpdateMessage({ schema: 'ptc-capability-contracts/v1', planDigest, views, changes,
+          additions.push(contractUpdateMessage({ schema: 'ptc-capability-contracts/v2', planDigest, views, changes,
             overageBytes: livePlan.budgets.overageBytes }, sessionId))
         }
         const expandedVisible = new Set([...visible, ...messages].flatMap(message => message.source?.form === 'capability-descriptions'

package/internal/config-spec.js

@@ -130,8 +130,8 @@ export const CONFIG_FIELDS = Object.freeze([
     type: 'enum',
     options: Object.freeze(['stateful', 'protected']),
     default: 'stateful',
-    label: '跨 cell 声明策略',
-    labelEn: 'Cross-cell declaration policy',
+    label: '绑定更新语义',
+    labelEn: 'Binding update semantics',
     description: '同一作用域的声明和赋值可更新变量、函数、类及导入。选“启用名称保护”时改为检测跨 cell 重声明，并保护新建的 const 和 import；静态 import/export 始终可用。',
     descriptionEn: 'Declarations and assignments update variables, functions, classes and imports in the same scope. With “Protect names” selected, cross-cell redeclarations are detected instead and newly created const and import bindings are protected; static import/export remains available.',
   },

package/internal/cordis-tools-owner.js

@@ -8,7 +8,7 @@ import { RUN_CODE } from './runtime-bridge-owner.js'
 import { sessionExecutionAvailable } from './host-tool-sdk.js'
 
 const CORDIS_PRESET_ID = 'cordis'
-const CORDIS_SKILL_NAME = 'cordis-plugin-development'
+const COMPANION_SKILL_NAMES = Object.freeze(['dsh-doc', 'cordis-plugin-development'])
 const CORDIS_SKILL_PROVIDER = 'ptc-plus-cordis'
 const COMPANION_SKILL_TOOL = 'skill'
 const COMPANION_PACKAGE_LAYOUTS = Object.freeze([
@@ -22,19 +22,19 @@ const COMPANION_PACKAGE_LAYOUTS = Object.freeze([
   }),
 ])
 
-function exactCompanionCandidates(observation) {
+function exactCompanionCandidates(observation, skillName) {
   if (Array.isArray(observation)) {
-    return observation.filter(candidate => candidate?.name === CORDIS_SKILL_NAME)
+    return observation.filter(candidate => candidate?.name === skillName)
   }
   if (observation === null || typeof observation !== 'object'
     || !Array.isArray(observation.candidates)) return observation
   return {
     ...observation,
-    candidates: observation.candidates.filter(candidate => candidate?.name === CORDIS_SKILL_NAME),
+    candidates: observation.candidates.filter(candidate => candidate?.name === skillName),
   }
 }
 
-function exactCompanionProvider(provider) {
+function exactCompanionProvider(provider, skillName) {
   if (provider === null || typeof provider !== 'object'
     || typeof provider.name !== 'string'
     || typeof provider.list !== 'function'
@@ -44,17 +44,17 @@ function exactCompanionProvider(provider) {
   return {
     ...provider,
     async list(options) {
-      return exactCompanionCandidates(await Reflect.apply(provider.list, provider, [options]))
+      return exactCompanionCandidates(await Reflect.apply(provider.list, provider, [options]), skillName)
     },
     async get(candidate, options) {
-      if (candidate?.name !== CORDIS_SKILL_NAME) return undefined
+      if (candidate?.name !== skillName) return undefined
       const skill = await Reflect.apply(provider.get, provider, [candidate, options])
-      return skill?.name === CORDIS_SKILL_NAME ? skill : undefined
+      return skill?.name === skillName ? skill : undefined
     },
   }
 }
 
-function exactCompanionSkillPlugin(skillFilesystemPlugin) {
+function exactCompanionSkillPlugin(skillFilesystemPlugin, skillName) {
   return {
     ...skillFilesystemPlugin,
     apply(pluginCtx, config) {
@@ -68,7 +68,7 @@ function exactCompanionSkillPlugin(skillFilesystemPlugin) {
       const facade = new Proxy(skills, {
         get(target, property) {
           if (property === 'registerProvider') {
-            return create => target.registerProvider(control => exactCompanionProvider(create(control)))
+            return create => target.registerProvider(control => exactCompanionProvider(create(control), skillName))
           }
           const value = Reflect.get(target, property, target)
           return typeof value === 'function' ? value.bind(target) : value
@@ -144,12 +144,13 @@ function requireCompanionServices(agent) {
   return { agentPresets, skills }
 }
 
-function containsCompanionSkill(directory, fileExists) {
-  return fileExists(join(directory, CORDIS_SKILL_NAME, 'SKILL.md'))
+function companionSkill(directory, fileExists) {
+  const skillName = COMPANION_SKILL_NAMES.find(name => fileExists(join(directory, name, 'SKILL.md')))
+  return skillName === undefined ? undefined : { skillRoot: directory, skillName }
 }
 
 /** Resolve the official Cordis companion Skill across DSH preset generations. */
-export async function resolveCompanionSkillDirectory(agentPresets, options = {}) {
+export async function resolveCompanionSkillResource(agentPresets, options = {}) {
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
   const resolution = typeof options === 'function' ? options() : options
   const fileExists = resolution.fileExists ?? existsSync
@@ -161,10 +162,11 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
       throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
     }
     const directory = join(dirname(preset.path), 'skills')
-    if (!containsCompanionSkill(directory, fileExists)) {
-      throw new Error(`ptc-plus: DSH cordis preset does not contain ${CORDIS_SKILL_NAME}/SKILL.md beside its composition`)
+    const resource = companionSkill(directory, fileExists)
+    if (resource === undefined) {
+      throw new Error(`ptc-plus: DSH cordis preset does not contain a supported companion SKILL.md beside its composition`)
     }
-    return directory
+    return resource
   }
 
   for (const layout of COMPANION_PACKAGE_LAYOUTS) {
@@ -174,7 +176,8 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
       throw new Error(`ptc-plus: DSH pluginPackages returned an invalid ${layout.name} package resource`)
     }
     const directory = layout.skillRoot(pkg.dir)
-    if (containsCompanionSkill(directory, fileExists)) return directory
+    const resource = companionSkill(directory, fileExists)
+    if (resource !== undefined) return resource
   }
 
   if (resolution.packageOf === undefined && resolution.resolveLegacyPackageManifest !== undefined) {
@@ -186,29 +189,30 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
     }
     if (manifest !== undefined) {
       const directory = join(dirname(manifest), 'presets', CORDIS_PRESET_ID, 'skills')
-      if (containsCompanionSkill(directory, fileExists)) return directory
+      const resource = companionSkill(directory, fileExists)
+      if (resource !== undefined) return resource
     }
   }
-  throw new Error(`ptc-plus: the active DSH installation does not publish a loadable ${CORDIS_SKILL_NAME} companion Skill through its package-resolution surface`)
+  throw new Error(`ptc-plus: the active DSH installation does not publish a loadable official companion Skill through its package-resolution surface`)
 }
 
-async function requireCompanionSkill(agent, skills) {
+async function requireCompanionSkill(agent, skills, skillName) {
   const lookup = {
     cwd: agent.session?.header?.cwd,
     scope: agent,
   }
   const owned = (await skills.list(lookup)).filter(skill => skill?.provider === CORDIS_SKILL_PROVIDER)
   const summary = owned[0]
-  if (owned.length !== 1 || summary?.name !== CORDIS_SKILL_NAME
+  if (owned.length !== 1 || summary?.name !== skillName
     || summary.invocation?.modelInvocable !== true) {
-    throw new Error(`ptc-plus: official Cordis Skill provider must publish exactly ${JSON.stringify(CORDIS_SKILL_NAME)} as model-invocable`)
+    throw new Error(`ptc-plus: official Cordis Skill provider must publish exactly ${JSON.stringify(skillName)} as model-invocable`)
   }
-  const skill = await skills.get(CORDIS_SKILL_NAME, lookup)
+  const skill = await skills.get(skillName, lookup)
   if (skill?.provider !== CORDIS_SKILL_PROVIDER
     || skill.invocation?.modelInvocable !== true
     || typeof skill.content !== 'string'
     || skill.content.length === 0) {
-    throw new Error(`ptc-plus: official Cordis companion Skill ${JSON.stringify(CORDIS_SKILL_NAME)} is not loadable`)
+    throw new Error(`ptc-plus: official Cordis companion Skill ${JSON.stringify(skillName)} is not loadable`)
   }
 }
 
@@ -321,7 +325,6 @@ export function createCordisToolsOwner(
   const withdrawn = new Map()
   const cordisInspectLeases = createCordisInspectLeases(ctx)
   const scopedCordisPlugin = cordisInspectLeases.plugin(cordisPlugin)
-  const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin)
   const packageBaseUrl = ctx.baseUrl
   const skillResolution = companionResolution ?? (() => {
     const pluginPackages = ctx.get?.('pluginPackages')
@@ -423,13 +426,14 @@ export function createCordisToolsOwner(
     mounts.set(agent, mount)
     mount.activation = Promise.resolve().then(async () => {
       const { agentPresets, skills } = requireCompanionServices(agent)
-      const skillDirectory = await resolveCompanionSkillDirectory(agentPresets, skillResolution)
+      const { skillRoot, skillName } = await resolveCompanionSkillResource(agentPresets, skillResolution)
+      const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin, skillName)
       if (mount.disposed) return
 
       const skillFiber = agent.ctx.plugin(scopedSkillPlugin, {
         providerName: CORDIS_SKILL_PROVIDER,
         includeDefaultRoots: false,
-        bundledSkillDir: skillDirectory,
+        bundledSkillDir: skillRoot,
         watch: false,
       })
       if (typeof skillFiber?.dispose !== 'function') {
@@ -449,7 +453,7 @@ export function createCordisToolsOwner(
       await Promise.resolve(cordisFiber)
       if (mount.disposed) return
 
-      await requireCompanionSkill(agent, skills)
+      await requireCompanionSkill(agent, skills, skillName)
       if (mount.disposed) return
       mount.activated = true
     }).catch(async error => {

package/internal/execution-seam-compat.js

@@ -94,19 +94,16 @@ export function createExecutionSeam(service, serviceName) {
       requireCompatible()
       return installed === undefined ? upstreamRun.call(service, input) : installed.execute(input)
     },
-    /**
-     * Release one owner's retained environment. The resources live in the
-     * original generation (the session kernel releases its state through its
-     * own lifecycle). Adapter retirement only closes execution; the original
-     * still owns cleanup for references retained by its consumers.
-     */
-    release(owner) {
-      if (typeof service.release !== 'function') return Promise.resolve()
-      try {
-        return Promise.resolve(service.release.call(service, owner))
-      } catch (error) {
-        return Promise.reject(error)
-      }
+    /** Release both the installed environment and any original-provider state. */
+    async release(owner) {
+      const entry = installed
+      const results = await Promise.allSettled([
+        Promise.resolve().then(() => entry?.release?.(owner)),
+        Promise.resolve().then(() => service.release?.call(service, owner)),
+      ])
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (failures.length === 1) throw failures[0]
+      if (failures.length > 1) throw new AggregateError(failures, 'ptc-plus: execution environment release failed')
     },
     [PLUGIN_EXECUTION_SEAM]() { return seam },
   })
@@ -143,11 +140,12 @@ export function createExecutionSeam(service, serviceName) {
       requireCompatible()
       return upstreamRun.call(service, spec)
     },
-    installExecute(execute) {
+    installExecute(execute, release) {
       requireAvailable()
       if (typeof execute !== 'function') throw new TypeError('ptc-plus: execution entry must be a function')
       if (installed !== undefined) throw new Error('ptc-plus: execution seam already installed')
-      const entry = { execute, language: service.language }
+      if (release !== undefined && typeof release !== 'function') throw new TypeError('ptc-plus: release entry must be a function')
+      const entry = { execute, release, language: service.language }
       installed = entry
       const restore = () => {
         if (installed !== entry) return

package/internal/runtime-bridge-owner.js

@@ -697,7 +697,13 @@ function applyEditableSlots(definition, promptText, slotPatches) {
       .finally(projected.release)
   }
 
-  const releaseSeam = seam.installExecute(patchedRun)
+  const releaseSeam = seam.installExecute(patchedRun, owner => {
+    if (owner?.session === undefined || sessionId(owner) === undefined) return
+    // Host uses release for explicit reset and for its retained-environment effect.
+    // Cordis clears the public Agent scope uid before invoking disposal effects.
+    if (owner.ctx?.fiber?.uid === null) return sessions.disposeAgent(sessionId(owner))
+    return sessions.resetEnvironment(owner.session)
+  })
 
   /**
    * Whether this execution is the derived execution the edit transport submitted.

package/internal/runtime-contexts.js

@@ -23,8 +23,12 @@ function hadPluginComputation(session) {
     && Object.hasOwn(event.data?.meta ?? {}, JOURNAL_KEY))
 }
 
-/** Persist actual provider release through public Session and single-writer owners. */
+/** Persist provider-only release through public Session and single-writer owners. */
 export async function handBackRuntimeSessions(ctx, owners) {
+  // Cordis FiberState.UNLOADING: application teardown has no continuing model
+  // request to hand back. Archive-wide writes do not belong to process cleanup;
+  // a restarted provider reconciles availability at the next accepted step.
+  if (ctx.root?.fiber.state === 5) return
   const service = name => owners ? owners[name] : typeof ctx.get === 'function' ? ctx.get(name) : ctx[name]
   const sessions = service('sessions')
   const persistence = service('sessionPersistence')

package/internal/runtime-messages.js

@@ -1,3 +1,4 @@
+import { ENVIRONMENT_RESET_VERSION } from './session-journal-schema.js'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import {
   CATALOG_PREFIX, EMPTY_CATALOG, LEGACY_STATE_PREFIX, PREVIOUS_EMPTY_CATALOG, PREVIOUS_STATE_PREFIX,
@@ -185,3 +186,10 @@ export function runtimeNoticeMessage(tip) {
   if (readRuntimeMessage(message) === undefined) throw new Error('invalid PTC recovery notice')
   return message
 }
+
+/** A persisted computation boundary; the Host separately owns its reset receipt. */
+export function environmentResetMessage() {
+  return createUserMessage({ source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'environment-reset', version: ENVIRONMENT_RESET_VERSION },
+    content: [{ type: 'text', text: 'PTC Plus computation reset: earlier session bindings, named checkpoints and edit targets are retired. New computation starts empty with the configured global bindings. Completed external effects remain.' }],
+  })
+}