dsh-ptc-plus 0.5.0 → 0.5.1

package/internal/edit-transport-owner.js

@@ -39,6 +39,15 @@ import {
 
 export const EDIT_RUN_CODE = 'edit_run_code'
 
+const TARGET_FIRST_LINE_LIMIT = 120
+
+/** Bounded identity of the cell an edit actually captured, for model-facing reasons. */
+function targetSummary(target) {
+  const line = typeof target?.source === 'string' ? target.source.split(/\r?\n/, 1)[0].trim() : ''
+  const firstLine = line.length > TARGET_FIRST_LINE_LIMIT ? `${line.slice(0, TARGET_FIRST_LINE_LIMIT)}…` : line
+  return `run_code call ${target?.callSeq}${firstLine === '' ? '' : `, first line: ${firstLine}`}`
+}
+
 function nestedEditStart(sessionLog, exec) {
   const events = sessionEvents(sessionLog)
   if (!Array.isArray(events) || typeof exec?.callId !== 'string'
@@ -188,13 +197,16 @@ export function createEditTransportOwner(ctx, {
       return { accepted: false, scheduled: false, reason: 'no run_code cell is currently eligible for safe editing' }
     }
     const edited = editRejectedCell(args, target.source)
-    if (!edited.edited) return { accepted: false, scheduled: false, reason: edited.reason }
+    if (!edited.edited) {
+      return { accepted: false, scheduled: false, reason: `${edited.reason} (edit target: ${targetSummary(target)})` }
+    }
     const expectedTargetCallSeq = args[EXPECTED_TARGET_CALL_SEQ]
     if (expectedTargetCallSeq !== undefined && expectedTargetCallSeq !== target.callSeq) {
       return {
         accepted: false,
         scheduled: false,
-        reason: `validated repair targets run_code call ${expectedTargetCallSeq}, but this edit captured call ${target.callSeq}`,
+        reason: `validated repair targets run_code call ${expectedTargetCallSeq}, but this edit captured ${targetSummary(target)}.`
+          + ' Only the most recent settled cell stays editable; if the intended cell is no longer editable, re-submit its corrected source with run_code instead.',
       }
     }
     if (typeof ctx.tools.execute !== 'function') {
@@ -207,7 +219,8 @@ export function createEditTransportOwner(ctx, {
       editClaims.set(id, claims)
     }
     if (claims.has(target.callSeq)) {
-      return { accepted: false, scheduled: false, reason: 'the current edit target already has a derived execution' }
+      return { accepted: false, scheduled: false,
+        reason: `the current edit target already has a derived execution (edit target: ${targetSummary(target)})` }
     }
     claims.set(target.callSeq, 'scheduled')
     const receipt = { accepted: true, scheduled: true, target_call_seq: target.callSeq }
@@ -219,6 +232,7 @@ export function createEditTransportOwner(ctx, {
       rootCallSeq: start.rootCallSeq,
       subCallId: exec.callId,
       targetCallSeq: target.callSeq,
+      targetDescription: targetSummary(target),
       finalized: false,
       finalizeTentative: undefined,
       finish(confirmed) {

package/internal/execution-provider-owner.js

@@ -64,12 +64,32 @@ export function apply(ctx, config = {}) {
   }
   const publish = () => {
     const resolutions = new WeakMap()
+    const ownerOriginals = new WeakMap()
+    const isOwner = owner => owner !== null && (typeof owner === 'object' || typeof owner === 'function')
     const delegate = {
       get language() { return readOriginal().language },
       get isolation() { return readOriginal().isolation },
+      get programFormat() { return readOriginal().programFormat ?? 'function-body' },
       get executionInstructions() { return readOriginal().executionInstructions },
       get sandboxMode() { return readOriginal().sandboxMode },
       get timeout() { return readOriginal().timeout },
+      release(owner) {
+        const originals = isOwner(owner) ? ownerOriginals.get(owner) : undefined
+        if (originals !== undefined) {
+          return Promise.all([...originals].map(original => Promise.resolve()
+            .then(() => original.release(owner))
+            .then(() => originals.delete(original)))).then(() => undefined)
+        }
+        let original
+        try {
+          original = readOriginal()
+        } catch {
+          // No retained dispatch belongs to this owner and execution is unavailable.
+          return Promise.resolve()
+        }
+        if (typeof original.release !== 'function') return Promise.resolve()
+        return Promise.resolve(original.release.call(original, owner))
+      },
       resolve(request) {
         const original = readOriginal()
         const spec = serviceName === EXECUTION_SEAM_SERVICE ? original.resolve(request) : request
@@ -82,6 +102,11 @@ export function apply(ctx, config = {}) {
         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()
+        if (isOwner(spec?.stateOwner) && typeof original.release === 'function') {
+          let originals = ownerOriginals.get(spec.stateOwner)
+          if (originals === undefined) ownerOriginals.set(spec.stateOwner, originals = new Set())
+          originals.add(original)
+        }
         return original.run(spec)
       },
     }

package/internal/execution-seam-compat.js

@@ -60,6 +60,10 @@ export function createExecutionSeam(service, serviceName) {
   const provider = Object.freeze({
     get language() { requireCompatible(); return service.language },
     get isolation() { requireCompatible(); return installed === undefined ? service.isolation : 'worker-thread' },
+    // Source evaluation form belongs to the provider that actually receives
+    // the program. Program-format consumers delegate to the original provider,
+    // so this descriptor always follows the original generation.
+    get programFormat() { requireCompatible(); return service.programFormat ?? 'function-body' },
     get executionInstructions() { requireCompatible(); return installed === undefined ? service.executionInstructions ?? '' : '' },
     get sandboxMode() { requireCompatible(); return installed === undefined ? service.sandboxMode : undefined },
     get timeout() { requireCompatible(); return installed === undefined ? service.timeout : undefined },
@@ -71,6 +75,20 @@ 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)
+      }
+    },
     [PLUGIN_EXECUTION_SEAM]() { return seam },
   })
   const seam = Object.freeze({

package/internal/official-repl-priority.js

@@ -0,0 +1,51 @@
+/**
+ * Official persistent-REPL priority.
+ *
+ * The official `persistent-in-memory` execution mode is a live provider
+ * capability, not a release fact: a provider reports `programFormat` `'repl'`
+ * exactly when it retains a REPL per state owner. While the user selects the
+ * official REPL priority and that provider is live, the plugin yields PTC
+ * session execution to the official implementation and installs no session
+ * runtime: `run_code`, its descriptors and its guidance stay official. The
+ * decision is re-evaluated on every configuration change and host source
+ * change, so either side can take over without restarting the host.
+ */
+
+/**
+ * Decide whether this configuration yields PTC session execution to the
+ * official provider.
+ * @param {object} config - resolved plugin configuration.
+ * @param {object} provider - the live provider surface registered for the seam.
+ * @returns {boolean} true when the official persistent REPL owns execution.
+ */
+export function defersToOfficialRepl(config, provider) {
+  if (config?.officialReplPriority !== true) return false
+  try {
+    return provider?.programFormat === 'repl'
+  } catch {
+    // An unreadable capability descriptor cannot prove official ownership;
+    // the plugin keeps its execution responsibility instead of guessing.
+    return false
+  }
+}
+
+/**
+ * Runtime record for an attachment that yields execution to the official
+ * provider. It owns no execution resources: the official provider releases
+ * anything it retained through its own lifecycle, and the plugin's settings,
+ * storage and UI owners remain available so the user can switch back.
+ */
+export function createDeferredRuntime() {
+  return Object.freeze({
+    cancelCordisActivation() {
+      // No Cordis companion is installed while execution is deferred.
+    },
+    contextsForRequest: () => [],
+    async reconfigure() {
+      // This attachment has no owners to reconfigure.
+    },
+    async dispose() {
+      // Nothing is owned here; disposal returns immediately.
+    },
+  })
+}

package/internal/runtime-bridge-owner.js

@@ -587,9 +587,10 @@ export function createRuntimeBridgeOwner({
               valueText = '; value omitted from preview'
             }
           }
+          const targetDescription = pendingEdit.targetDescription ?? `run_code call ${pendingEdit.targetCallSeq}`
           const status = outcome.edited
-            ? `edit_run_code settled${outcome.error === undefined ? '' : ' with execution error'}`
-            : 'edit_run_code did not execute the accepted revision'
+            ? `edit_run_code settled${outcome.error === undefined ? '' : ' with execution error'} (target ${targetDescription})`
+            : `edit_run_code did not execute the accepted revision (target ${targetDescription})`
           const detail = [
             ...(hasRenderedContent || !Array.isArray(outcome.logs) ? [] : outcome.logs),
             ...(!hasRenderedContent && typeof outcome.error === 'string' ? [outcome.error] : []),
@@ -625,9 +626,9 @@ export function createRuntimeBridgeOwner({
     const inherited = scope.getStore()
     const ownsDerived = ownedDerivedScope(exec) !== undefined
     if ((exec.parent !== undefined && !ownsDerived) || id === undefined
-      || inherited?.submission?.sessionId === id) return operation()
+      || (inherited?.exec === exec && inherited.submission?.sessionId === id)) return operation()
     const submission = sessions.beginSubmission({ id }, exec.signal)
-    const composite = inherited?.deferredSettlement !== undefined && inherited.id === id
+    const composite = ownsDerived
       ? {
           persistedCallSeq: inherited.persistedCallSeq,
           sourceCallSeq: inherited.sourceCallSeq,
@@ -637,9 +638,11 @@ export function createRuntimeBridgeOwner({
         }
       : {}
     try {
-      // Derived edits retain their proved source under a fresh admission for
-      // the same session. Delegated agents own a fresh log and no child handoff.
-      return await scope.run({ ...composite, submission }, () => childScope.run(undefined, operation))
+      // Only reentry for this exact execution shares admission. Background
+      // continuations can inherit a settled execution's asynchronous context.
+      // Only proved derived edits retain composite source and settlement under
+      // a fresh admission; other roots own a fresh log and no child handoff.
+      return await scope.run({ ...composite, exec, submission }, () => childScope.run(undefined, operation))
     } finally {
       sessions.releaseSubmission(submission)
     }

package/internal/sdk-projection.js

@@ -10,7 +10,7 @@ export function projectProgramSdk(nativeSdk, { languageSemantics = 'legacy-v1' }
   const fence = nativeSdk.indexOf(TYPESCRIPT_FENCE)
   if (fence < 0) return nativeSdk
   return nativeSdk.slice(0, fence).replace(
-    '`code` — the body of an async TypeScript function (erasable syntax only — no `enum` or namespaces; type annotations are advisory, the code runs type-stripped)',
-    '`code` — a PTC Plus TypeScript cell (runtime `enum` and namespaces are supported; type annotations are advisory)',
+    'the body of an async TypeScript function (erasable syntax only — no `enum` or namespaces; type annotations are advisory, the code runs type-stripped)',
+    'a PTC Plus TypeScript cell (runtime `enum` and namespaces are supported; type annotations are advisory)',
   ) + nativeSdk.slice(fence)
 }

package/internal/user-bindings-owner.js

@@ -1,5 +1,5 @@
 import { PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
-import { bindingToggleMessage, readBindingToggle } from './binding-toggle-receipt.js'
+import { bindingToggleMessage } from './binding-toggle-receipt.js'
 import { RPC_CONTRACTS } from './rpc-contract.js'
 import { randomUUID } from 'node:crypto'
 import { dirname } from 'node:path'
@@ -186,7 +186,6 @@ export function createUserBindingsOwner(ctx, options = {}) {
     valueLimits: options.valueLimits,
   }
   let disposed = false
-  const pendingConfigurationReceipts = new WeakMap()
   const codeConsole = new UserBindingConsole(currentOptions)
   const commandRegistrations = new Map()
   const sessionAgents = new Map()
@@ -387,15 +386,11 @@ export function createUserBindingsOwner(ctx, options = {}) {
     const sessions = new Set((ctx.agents?.list?.() ?? []).map(agent => agent.session).filter(Boolean))
     for (const session of sessions) {
       try {
+        // Before the first accepted step these are initial settings, not changes
+        // to an environment the model has received. The catalog owns first delivery.
+        if (session.deriveMessages()[0]?.role !== 'system') continue
         const message = createUserMessage(bindingToggleMessage(entry, next.revision))
-        // The Host alone establishes the first system head. Before that accepted
-        // boundary, keep UI configuration facts pending without waking the Agent.
-        if (session.deriveMessages()[0]?.role === 'system') session.append('user/message', message, { surfaceOp: 'append' })
-        else {
-          const pending = pendingConfigurationReceipts.get(session) ?? []
-          pending.push(message)
-          pendingConfigurationReceipts.set(session, pending)
-        }
+        session.append('user/message', message, { surfaceOp: 'append' })
       } catch (error) { reportContainedFailure('ptc-plus: binding configuration saved but its session receipt could not be appended', error) }
     }
     return next
@@ -916,23 +911,6 @@ export function createUserBindingsOwner(ctx, options = {}) {
   mountAuthoring()
 
   return Object.freeze({
-    committedEvent(session, event) {
-      if (event.type !== 'user/message' || !readBindingToggle(event.data)) return
-      const pending = pendingConfigurationReceipts.get(session)
-      if (pending) pendingConfigurationReceipts.set(session, pending.filter(message => message.id !== event.data.id))
-    },
-    async preStep(payload, next) {
-      const decision = await next()
-      if (disposed || decision?.kind !== 'enter' || payload.signal?.aborted || payload.agent?.signal?.aborted) return decision
-      const session = payload.agent?.session
-      const pending = pendingConfigurationReceipts.get(session)
-      if (!pending?.length) return decision
-      const visible = new Set(session.deriveMessages().map(message => message.id))
-      const remaining = pending.filter(message => !visible.has(message.id))
-      pendingConfigurationReceipts.set(session, remaining)
-      const proposed = new Set((decision.messages ?? []).map(message => message.id))
-      return { ...decision, messages: [...(decision.messages ?? []), ...remaining.filter(message => !proposed.has(message.id))] }
-    },
     path: store.filename,
     cwd: bindingsCwd,
     async snapshot() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "icon": "assets/ptc-plus-icon.svg",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
@@ -42,7 +42,8 @@
     "LICENSE"
   ],
   "engines": {
-    "node": "^22.19.0 || >=24.0.0"
+    "node": "^22.19.0 || >=24.0.0",
+    "dsh": "*"
   },
   "allowScripts": {
     "esbuild": false

package/src/client-activity.js

@@ -506,6 +506,7 @@ export function derivePtcToolView(block, toolName = undefined) {
     ? block.meta[GENERATED_RUN_CODE_DESCRIPTION_KEY]
     : undefined
   const description = (explicitDescription ?? generatedDescription)?.split(/\r?\n/, 1)[0] ?? ''
+  const descriptionGenerated = explicitDescription === undefined && generatedDescription !== undefined
   const output = settled ? resultText(block) : ''
   const state = !settled ? 'running'
     : block.error?.code === 'interrupted' ? 'stopped'
@@ -514,7 +515,7 @@ export function derivePtcToolView(block, toolName = undefined) {
     ? block.meta.dshPtcPlus
     : undefined
   if (journal === undefined) {
-    return Object.freeze({ state, description, code, output, ptc: false, features: Object.freeze([]) })
+    return Object.freeze({ state, description, descriptionGenerated, code, output, ptc: false, features: Object.freeze([]) })
   }
   const rewrites = isValidRewrites(block.meta.dshPtcPlusRewrites, journal)
     ? block.meta.dshPtcPlusRewrites
@@ -542,5 +543,5 @@ export function derivePtcToolView(block, toolName = undefined) {
       : undefined,
     ...operationFeatures(journal.operations),
   ])
-  return Object.freeze({ state, description, code, output, ptc: true, features: Object.freeze(features) })
+  return Object.freeze({ state, description, descriptionGenerated, code, output, ptc: true, features: Object.freeze(features) })
 }