dsh-ptc-plus 0.4.10 → 0.5.1

package/internal/runtime-config.js

@@ -1,3 +1,4 @@
+import { capabilityPolicyForConfig } from './capability-policy.js'
 import {
   CONFIG_DEFAULTS,
   CONFIG_FIELDS,
@@ -6,6 +7,43 @@ import {
 
 export { MAX_TIMER_DELAY_MS }
 
+/** Reusable configurations contain capability settings, never session evidence. */
+export const CAPABILITY_CONFIGURATION_KEYS = Object.freeze(CONFIG_FIELDS
+  .filter(field => (field.key.startsWith('capability') && field.key !== 'capabilityProfiles') || ['modelPreviewTokens', 'modelPreviewEnabled'].includes(field.key))
+  .map(field => field.key))
+
+export function capabilityProfileConfiguration(value, { allowInvalidStatistics = false } = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).some(key => !CAPABILITY_CONFIGURATION_KEYS.includes(key))) {
+    throw new TypeError('ptc-plus: invalid capability configuration fields')
+  }
+  const resolved = resolveConfig(value)
+  let statistics
+  try { statistics = JSON.parse(resolved.capabilityStatistics) } catch {}
+  if (!allowInvalidStatistics && (!statistics || typeof statistics.enabled !== 'boolean'
+    || !Number.isSafeInteger(statistics.windowSize) || statistics.windowSize < 1
+    || !Number.isSafeInteger(statistics.minimumSamples) || statistics.minimumSamples < 1 || statistics.minimumSamples > statistics.windowSize
+    || !Number.isFinite(statistics.fullThreshold) || statistics.fullThreshold < 0 || statistics.fullThreshold > 1)) {
+    throw new TypeError('ptc-plus: invalid saved capability statistics settings')
+  }
+  return Object.fromEntries(CAPABILITY_CONFIGURATION_KEYS.map(key => [key, resolved[key]]))
+}
+
+export function validateCapabilityProfiles(value) {
+  if (!value || value.schema !== 'ptc-capability-profiles/v1' || !Array.isArray(value.profiles) || value.profiles.length > 100) {
+    throw new TypeError('ptc-plus: invalid capability profiles document')
+  }
+  const ids = new Set()
+  const names = new Set()
+  return { schema: value.schema, profiles: value.profiles.map(profile => {
+    if (!profile || typeof profile.id !== 'string' || !profile.id.trim() || profile.id.length > 100
+      || typeof profile.name !== 'string' || !profile.name.trim() || profile.name.length > 80
+      || ids.has(profile.id) || names.has(profile.name.trim())) throw new TypeError('ptc-plus: invalid or duplicate capability profile')
+    ids.add(profile.id); names.add(profile.name.trim())
+    return { id: profile.id, name: profile.name.trim(), configuration: capabilityProfileConfiguration(profile.configuration) }
+  }) }
+}
+
 /** The wall-clock ceiling field carries the platform timer limit as its maximum. */
 const MAX_WALL_MS_FIELD = CONFIG_FIELDS.find(field => field.key === 'maxWallMs')
 
@@ -21,6 +59,10 @@ function assertIntegerField(field, value) {
 
 /** Validate one field against its CONFIG_FIELDS declaration. */
 function assertField(field, value) {
+  if (field.type === 'string') {
+    if (typeof value !== 'string') throw new TypeError(`ptc-plus: ${field.key} must be a string`)
+    return
+  }
   if (field.type === 'boolean') {
     if (typeof value !== 'boolean') {
       throw new TypeError(`ptc-plus: ${field.key} must be a boolean`)
@@ -74,6 +116,22 @@ export function resolveConfig(config = {}) {
     resolved[field.key] = liveConfigValue(resolved[field.key], CONFIG_DEFAULTS[field.key])
   }
   for (const field of CONFIG_FIELDS) assertField(field, resolved[field.key])
+  validateCapabilityProfiles(JSON.parse(resolved.capabilityProfiles))
+  for (const [key, array] of [['capabilityBaseline', true], ['capabilityOverrides', false]]) {
+    let value
+    try { value = JSON.parse(resolved[key]) } catch { throw new TypeError(`ptc-plus: ${key} must contain valid JSON`) }
+    if (array ? !Array.isArray(value) || value.some(id => typeof id !== 'string' || !id.trim())
+      : value === null || typeof value !== 'object' || Array.isArray(value)
+        || Object.entries(value).some(([id, selection]) => !id.trim() || !['full', 'on-demand', 'closed'].includes(selection)
+          || (id.startsWith('mcpServers.') && (id === 'mcpServers.' || selection !== 'closed')))) {
+      throw new TypeError(`ptc-plus: invalid ${key}`)
+    }
+  }
+  resolved.capabilityPolicy = JSON.stringify(capabilityPolicyForConfig(provided.has('capabilityPolicy') ? resolved : { ...resolved, capabilityPolicy: undefined }))
+  if (!provided.has('capabilityPolicy') && resolved.capabilityManagementEnabled) {
+    if (!provided.has('capabilityRecoveryEnabled')) resolved.capabilityRecoveryEnabled = true
+    if (!provided.has('modelPreviewEnabled')) resolved.modelPreviewEnabled = true
+  }
   // Migrate complete old policies; mixed choices retain their explicit
   // compatibility state until the user selects the unified language.
   const legacyKeys = [

package/internal/runtime-contexts.js

@@ -1,14 +1,77 @@
 import { latestRecoveryTip, runtimeHistoryForView } from './recovery-tips.js'
+import { foldSurface, deriveEventMessage, snapshotSessionEvent } from '@deepseek-ai/dsh-session'
+import { currentSessionMessageProjections } from '@deepseek-ai/dsh-session-format-catalog/message-projections'
+import { readSessionLog } from './session-events.js'
+import { JOURNAL_KEY } from './session-journal.js'
 import { projectSessionLog, runtimeMessageFacts, systemPromptSnapshotSections } from './session-log-view.js'
 import {
   PTC_BINDING_CATALOG, PTC_DELIVERY_CONTEXT, PTC_STATE_NAMES, readRuntimeMessage,
   runtimeBindingCatalogMessage, runtimeNoticeMessage, runtimeStateMessage,
+  projectRuntimeAvailability,
+  runtimeAvailabilityMessage,
 } from './runtime-messages.js'
 
 const REWRITE_FEEDBACK = 'tools:ptc-plus-rewrite-info'
 const CORDIS_RECOVERY = 'tools:ptc-plus-cordis-recovery'
 const CORDIS_RECOVERY_TEXT = 'Recorded Cordis values in the recovered REPL are historical data, not proof that process-local Plugins, Runs, approvals, or Inspect observations still exist in the current DSH process. Before relying on prior Cordis IDs, state, or capability data, follow the current Cordis owner guidance and call the live read-only Cordis Inspect bindings through `tools.*`; do not rerun mutating Cordis calls merely to reconstruct history.'
 
+// A historical plugin result proves that this provider was used, not that its
+// bindings remain known, recoverable, initialized or currently alive.
+function hadPluginComputation(session) {
+  return (session?.events ?? []).some(event => event.type === 'tool/result'
+    && Object.hasOwn(event.data?.meta ?? {}, JOURNAL_KEY))
+}
+
+/** Persist actual provider release through public Session and single-writer owners. */
+export async function handBackRuntimeSessions(ctx, owners) {
+  const service = name => owners ? owners[name] : typeof ctx.get === 'function' ? ctx.get(name) : ctx[name]
+  const sessions = service('sessions')
+  const persistence = service('sessionPersistence')
+  const query = service('sessionQuery')
+  if (!sessions?.list || !sessions?.flush || !persistence?.list || !persistence?.open) {
+    throw new Error('PTC Plus provider handback requires the public session and persistence owners')
+  }
+  const live = new Map(sessions.list().map(session => [session.id, session]))
+  const failures = []
+  const withdraw = (session, log) => {
+    if (!projectRuntimeAvailability(session.deriveMessages(), false, hadPluginComputation(log))) return undefined
+    return session.append('user/message', runtimeAvailabilityMessage('unloaded'), { surfaceOp: 'append' })
+  }
+  for (const session of live.values()) {
+    try {
+      const log = await readSessionLog(session, query)
+      const event = withdraw(session, log)
+      const pending = session.deriveMessages().some(message => message.source?.form === 'runtime-availability')
+      if ((event || pending) && await sessions.flush(session) !== true) throw new Error('No public durability listener confirmed the session handback')
+    } catch (error) { failures.push(new Error(`PTC Plus handback failed for session ${session.id}`, { cause: error })) }
+  }
+  const entries = await persistence.list()
+  for (const entry of entries) {
+    const id = entry.header.id
+    if (live.has(id)) continue
+    try {
+      const handle = await persistence.open(id, 'write')
+      try {
+        const stored = await handle.read()
+        const definitions = new Map(currentSessionMessageProjections.map(item => [item.type, item]))
+        for (const definition of sessions.messageProjections ?? []) definitions.set(definition.type, definition)
+        const projections = [...definitions.values()]
+        const surface = foldSurface(stored.events, projections)
+        const messages = surface.nodes.map(seq => deriveEventMessage(stored.events[seq], surface.projectedMessages)).filter(Boolean)
+        if (!projectRuntimeAvailability(messages, false, hadPluginComputation({ events: stored.events }))) continue
+        // This is a new fact from the releasing provider, not a Session resume.
+        // The exclusive writer's next offset owns the new event's identity.
+        const event = snapshotSessionEvent({ type: 'user/message', seq: stored.events.length, time: Date.now(),
+          data: runtimeAvailabilityMessage('unloaded'), surfaceOp: 'append' })
+        foldSurface([...stored.events, event], projections)
+        await handle.append([event])
+        await handle.flush()
+      } finally { await handle.close() }
+    } catch (error) { failures.push(new Error(`PTC Plus handback failed for session ${id}`, { cause: error })) }
+  }
+  if (failures.length) throw new AggregateError(failures, 'PTC Plus provider released, but session handback is incomplete')
+}
+
 function continuationFeedback(view) {
   const run = view.latestRun
   const rewrites = run?.rewrites
@@ -74,7 +137,7 @@ export function projectRuntimeMessages(view, contexts, pending = []) {
 }
 
 /** Passive message delivery follows the actual public assembly and accepted step. */
-export function createRuntimeMessageOwner(contextsForRequest, sessionLogView = projectSessionLog) {
+export function createRuntimeMessageOwner(contextsForRequest, sessionLogView = projectSessionLog, activeForRequest, sessionQuery) {
   const requests = new WeakMap()
   const disposedAgents = new WeakSet()
   let disposed = false
@@ -84,7 +147,7 @@ export function createRuntimeMessageOwner(contextsForRequest, sessionLogView = p
   return Object.freeze({
     async assemble(initial, context, next) {
       const assembly = await next()
-      if (!disposed && context?.agent !== null && typeof context?.agent === 'object'
+      if (!disposed && context?.ptcPlusCapabilityObservation !== true && context?.agent !== null && typeof context?.agent === 'object'
         && !disposedAgents.has(context.agent)) requests.set(context.agent, {
         context,
         allowed: hasWitness(initial) && hasWitness(assembly),
@@ -98,9 +161,15 @@ export function createRuntimeMessageOwner(contextsForRequest, sessionLogView = p
       const request = requests.get(payload.agent)
       if (disposed || decision.kind !== 'enter' || payload.signal?.aborted === true
         || request?.allowed !== true || request.context.signal !== payload.signal) return decision
-      const messages = projectRuntimeMessages(
-        sessionLogView(payload.agent), contextsForRequest(request.context), decision.messages,
-      )
+      const view = sessionLogView(payload.agent)
+      const messages = projectRuntimeMessages(view, contextsForRequest(request.context), decision.messages)
+      if (activeForRequest !== undefined) {
+        const log = await readSessionLog(payload.agent.session, sessionQuery, payload.signal)
+        const availability = projectRuntimeAvailability([
+          ...(payload.agent.session.deriveMessages?.() ?? []), ...decision.messages, ...messages,
+        ], activeForRequest(request.context), hadPluginComputation(log))
+        if (availability) messages.push(availability)
+      }
       return messages.length === 0 ? decision : { ...decision, messages: [...decision.messages, ...messages] }
     },
     disposeAgent(agent) { disposedAgents.add(agent); requests.delete(agent) },

package/internal/runtime-intrinsics.js

@@ -98,6 +98,7 @@ export const runtimeIntrinsics = {
 if (typeof Buffer === 'function') {
   runtimeIntrinsics.bufferByteLength = Buffer.byteLength
   runtimeIntrinsics.bufferConcat = Buffer.concat
+  runtimeIntrinsics.bufferFrom = Buffer.from
   runtimeIntrinsics.bufferIsBuffer = Buffer.isBuffer
   runtimeIntrinsics.bufferSubarray = uncurry(Buffer.prototype.subarray)
   runtimeIntrinsics.bufferToString = uncurry(Buffer.prototype.toString)

package/internal/runtime-messages.js

@@ -23,6 +23,45 @@ const STATE_PREFIX = 'PTC Plus recovery status. Replaces earlier PTC recovery st
 const CATALOG_PREFIX = 'Global binding API reference for run_code (replaces the previous global binding reference):'
 const EMPTY_CATALOG = 'No entries documented.'
 const PREVIOUS_EMPTY_CATALOG = 'No global binding API documentation is currently configured. Earlier binding catalogs no longer apply.'
+const AVAILABILITY_TEXT = Object.freeze({
+  active: 'PTC Plus is the current continuous-computation provider. Follow its current tool schemas and capability plan; earlier withdrawals do not restore old computation state.',
+  disabled: 'PTC Plus is disabled. Earlier PTC Plus continuous-computation instructions, capability plans, discovery instructions, calling-contract disclosures and global binding references no longer describe the current runtime. Use the current Host tools and contracts. Historical computations and effects remain historical; no old PTC Plus heap has been restored. Tasks, Skill instructions, other producers and tool results are unchanged.',
+  unloaded: 'PTC Plus has released its computation provider. Earlier PTC Plus continuous-computation instructions, capability plans, discovery instructions, calling-contract disclosures and global binding references no longer describe the current runtime. Use the current Host tools and contracts. Historical computations and effects remain historical; no old PTC Plus heap has been restored. Tasks, Skill instructions, other producers and tool results are unchanged.',
+})
+
+// Historical wording stays readable so recorded sessions keep their provenance;
+// new messages use the current text above.
+const PREVIOUS_AVAILABILITY_TEXT = Object.freeze({
+  active: ['PTC Plus is the current continuous-computation provider. Follow its current tool schemas and newly supplied capability plan; earlier withdrawals do not restore old computation state.'],
+})
+
+export function runtimeAvailabilityMessage(state) {
+  if (!Object.hasOwn(AVAILABILITY_TEXT, state)) throw new TypeError('invalid PTC provider availability')
+  return createUserMessage({ source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'runtime-availability', state },
+    content: [{ type: 'text', text: AVAILABILITY_TEXT[state] }] })
+}
+
+export function readRuntimeAvailability(message) {
+  const state = message?.source?.state
+  if (!isPtcMessageSource(message?.source) || message.source.form !== 'runtime-availability'
+    || !Object.hasOwn(AVAILABILITY_TEXT, state) || message.content?.length !== 1
+    || message.content[0]?.type !== 'text') return undefined
+  const text = message.content[0].text
+  return text === AVAILABILITY_TEXT[state]
+    || (PREVIOUS_AVAILABILITY_TEXT[state] ?? []).includes(text) ? state : undefined
+}
+
+/** Availability reconciles plugin declarations only, never tasks or other producers. */
+export function projectRuntimeAvailability(messages, active, computationDeclared = false) {
+  const last = messages.map(readRuntimeAvailability).filter(Boolean).at(-1)
+  if (active) return last && last !== 'active' ? runtimeAvailabilityMessage('active') : undefined
+  if (last === 'disabled' || last === 'unloaded') return undefined
+  const declared = computationDeclared || last === 'active' || messages.some(message => isPtcMessageSource(message?.source)
+    && (['capability-navigation', 'capability-descriptions', 'capability-contracts'].includes(message.source.form)
+      || message.source.form === 'capability-plan' && message.source.snapshot?.plan?.enabled === true
+      || readRuntimeMessage(message)?.form === 'catalog' && readRuntimeMessage(message).sections.length > 0))
+  return declared ? runtimeAvailabilityMessage('disabled') : undefined
+}
 
 export function recoveryTipIdentity(name) {
   if (typeof name !== 'string') return undefined
@@ -60,6 +99,8 @@ export function readRuntimeMessage(message) {
     || !Array.isArray(message.content) || message.content.length !== 1
     || message.content[0]?.type !== 'text') return undefined
   const text = message.content[0].text
+  const availability = readRuntimeAvailability(message)
+  if (availability !== undefined) return { form: 'runtime-availability', state: availability }
   if (source.form === 'snapshot') {
     const sections = stateSections(source.sections)
     if (sections !== undefined && [STATE_PREFIX, PREVIOUS_STATE_PREFIX, LEGACY_STATE_PREFIX]

package/internal/sdk-projection.js

@@ -1,88 +1,16 @@
-/** Adapt the host program SDK without weakening the declared direct tool surface. */
-import { parse } from '@babel/parser'
+/** Adapt the Host's TypeScript cell introduction while preserving its SDK members. */
 
-const PROJECTION_ERROR = 'ptc-plus: incompatible tools SDK projection: '
 const TYPESCRIPT_FENCE = '```ts\n'
 
-function incompatible(message, cause = undefined) {
-  return new Error(`${PROJECTION_ERROR}${message}`, cause === undefined ? undefined : { cause })
-}
-
-function lineStart(source, offset) {
-  return source.lastIndexOf('\n', offset - 1) + 1
-}
-
-function memberName(member) {
-  if (member.type !== 'TSPropertySignature') return undefined
-  if (member.key.type === 'Identifier') return member.key.name
-  if (member.key.type === 'StringLiteral') return member.key.value
-  return undefined
-}
-
-function supportedFence(source) {
-  const starts = []
-  for (let offset = 0; offset < source.length;) {
-    const start = source.indexOf(TYPESCRIPT_FENCE, offset)
-    if (start < 0) break
-    if (start === 0 || source[start - 1] === '\n') starts.push(start)
-    offset = start + TYPESCRIPT_FENCE.length
-  }
-  if (starts.length !== 1) {
-    throw incompatible(`expected exactly one ${JSON.stringify(TYPESCRIPT_FENCE.trim())} fence`)
-  }
-  const codeStart = starts[0] + TYPESCRIPT_FENCE.length
-  const codeEnd = source.indexOf('\n```', codeStart)
-  if (codeEnd < 0) throw incompatible('the TypeScript fence is not closed')
-  return { codeStart, codeEnd }
-}
-
-/** Remove one direct-only tool from the host-generated program SDK. */
-export function projectProgramSdk(nativeSdk, excludedName = 'edit_run_code') {
+export function projectProgramSdk(nativeSdk, { languageSemantics = 'legacy-v1' } = {}) {
   if (typeof nativeSdk !== 'string') return ''
-  if (!nativeSdk.includes(excludedName)) return nativeSdk
-
-  const { codeStart, codeEnd } = supportedFence(nativeSdk)
-  const code = nativeSdk.slice(codeStart, codeEnd)
-  let ast
-  try {
-    ast = parse(code, { sourceType: 'module', plugins: ['typescript'] })
-  } catch (error) {
-    throw incompatible('the TypeScript fence could not be parsed', error)
-  }
-
-  const removals = []
-  for (const interfaceName of ['ToolArgsMap', 'ToolOutputMap']) {
-    const declarations = ast.program.body.filter(statement => (
-      statement.type === 'TSInterfaceDeclaration' && statement.id.name === interfaceName
-    ))
-    if (declarations.length !== 1) {
-      throw incompatible(`expected exactly one ${interfaceName} interface`)
-    }
-    const declaration = declarations[0]
-    const members = declaration.body.body.filter(member => memberName(member) === excludedName)
-    if (members.length !== 1) {
-      throw incompatible(`expected exactly one ${excludedName} member in ${interfaceName}`)
-    }
-    const member = members[0]
-    if (declaration.body.body.length === 1) {
-      removals.push([declaration.body.start + 1, declaration.body.end - 1])
-      continue
-    }
-    const commentStart = member.leadingComments?.[0]?.start
-    const startOffset = commentStart ?? member.start
-    const start = lineStart(code, startOffset)
-    let end = member.end
-    if (code[end] === '\n') end += 1
-    removals.push([start, end])
-  }
-
-  let projectedCode = code
-  for (const [start, end] of removals.sort((left, right) => right[0] - left[0])) {
-    projectedCode = projectedCode.slice(0, start) + projectedCode.slice(end)
-  }
-  const projected = nativeSdk.slice(0, codeStart) + projectedCode + nativeSdk.slice(codeEnd)
-  if (projected.includes(excludedName)) {
-    throw incompatible(`residual ${excludedName} token remains after projection`)
+  if (languageSemantics === 'legacy-v1' || !nativeSdk.startsWith('## Writing code for run_code\n')) {
+    return nativeSdk
   }
-  return projected
+  const fence = nativeSdk.indexOf(TYPESCRIPT_FENCE)
+  if (fence < 0) return nativeSdk
+  return nativeSdk.slice(0, fence).replace(
+    '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/session-cell-executor.js

@@ -2,7 +2,9 @@ import { resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import {
   decodeValue,
-  encodeValue,
+  encodeValueAtBoundary,
+  valueEncodingFailure,
+  valueEncodingHelp,
   normalizeValueWire,
   prepareValueWire,
   valueWiresEqual,
@@ -88,11 +90,11 @@ function parseDiagnostic(error, source, position, repair) {
     }),
     help: repair === undefined
       ? source.length >= LONG_CELL_CODE_UNITS
-        ? ['this cell was not executed; when edit_run_code is declared for the current request and the correction is small and localized, use it to avoid resending this long source; otherwise retry only this cell with corrected source in run_code']
+        ? ['this cell was not executed; when tools.edit_run_code is available in the program SDK and the correction is small and localized, call it inside a new run_code cell to avoid resending this long source; otherwise retry only this cell with corrected source in run_code']
         : ['this cell was not executed; correct the reported syntax and retry only this cell with run_code']
       : [
           `this cell was not executed; validated syntax repair: append ${JSON.stringify(repair.delimiter)} at the end of this cell`,
-          `when this correction matches your intent and edit_run_code is declared, prefer the direct tool call ${repair.invocation} with its target guard to run the complete corrected cell; validation proves syntax/preflight acceptance, not intended behavior; otherwise submit corrected source in run_code`,
+          `when this correction matches your intent and tools.edit_run_code is available in the program SDK, use ${repair.invocation} inside a new run_code cell with its target guard; the accepted edit runs the complete corrected cell after that new cell finishes; validation proves syntax/preflight acceptance, not intended behavior; otherwise submit corrected source in run_code`,
         ],
   })
 }
@@ -316,16 +318,16 @@ function exceptionDiagnostic({
         && error.toolName.startsWith('cordis_')
         ? ['bindings assigned before this Cordis failure remain live; reuse them instead of resending large source']
         : longCellFailure
-          ? ['inspect relevant live state in a new short `run_code` cell; edit_run_code executes the complete corrected cell, not only the failing expression']
+          ? ['inspect relevant live state in a new short `run_code` cell; tools.edit_run_code accepts a complete corrected-cell run after that new cell finishes; it reruns prior effects, so acceptance does not prove a retry is safe']
           : languageSemantics !== 'legacy-v1'
-            ? ['completed declarations and actual assignments remain available; correct the failed initializer and continue with the same binding names']
+            ? ['completed declarations and actual assignments remain available; continue with the same binding names from the execution facts, inspecting relevant live values in a short cell when their state is uncertain']
           : declared.size === 0 ? []
             : ['use fresh names for one-off top-level bindings after partial execution; later declarations may be uninitialized']),
     ],
   })
 }
 
-function invalidOutputDiagnostic(detail) {
+function invalidOutputDiagnostic(detail, failure) {
   return diagnostic({
     code: 'PTC-O001',
     severity: 'error',
@@ -334,15 +336,16 @@ function invalidOutputDiagnostic(detail) {
     stateEffect: 'partially-applied',
     help: [
       'the worker remains live; inspect a retained binding in a later cell without rerunning the failed cell',
-      'reduce the returned graph when it exceeds the configured value budget',
+      valueEncodingHelp(failure),
     ],
   })
 }
 
 /** Retain validated recorded wording while still comparing the actual failure. */
-function replayFailureDiagnostic(actual, replay) {
+function replayFailureDiagnostic(actual, replay, legacy) {
   const recorded = replay?.diagnostics?.find(item => item.code === actual.code)
-  return recorded?.message === actual.message ? recorded : actual
+  return recorded !== undefined && (recorded.message === actual.message
+    || recorded.message === legacy?.message) ? recorded : actual
 }
 
 function stateArguments(value) {
@@ -417,7 +420,9 @@ export class SessionCellExecutor {
     const priorBindingCatalog = userBindingPlan.catalog
     const catalog = priorBindingCatalog.inputs()
     const { bindingPolicy, rewritesEnabled, moduleSemantics, languageSemantics, moduleTransform } = executionPolicies(config, replayRecord)
-    const moduleDirectory = kernel.cwd ?? process.cwd()
+    const executionCwd = replayRecord === undefined ? request.cwd ?? kernel.cwd
+      : replayRecord.executionCwd ?? kernel.cwd
+    const moduleDirectory = executionCwd ?? process.cwd()
     const moduleFilename = resolve(moduleDirectory, 'repl')
     const prepareCell = program => prepareProgram(program, {
       knownBindings: catalog.knownBindings,
@@ -446,7 +451,10 @@ export class SessionCellExecutor {
     } catch (error) {
       const result = earlyResult('exception', messageOf(error))
       const position = parseCellPosition(error)
+      // sourceCallSeq proves the assistant ancestor, not the editable identity
+      // of derived text. A parse-rejected derived edit does not publish that text.
       const repair = error instanceof PreflightError || replayRecord !== undefined
+        || request.callSeq !== request.sourceCallSeq
         ? undefined
         : validatedEofClosureRepair({
             source: request.program,
@@ -474,6 +482,7 @@ export class SessionCellExecutor {
 
     let worker
     try {
+      await kernel.prepareWorker()
       worker = await kernel.client.ensure(config.maxOldGenerationSizeMb)
     } catch (error) {
       const result = earlyResult('worker-exit', messageOf(error))
@@ -483,11 +492,12 @@ export class SessionCellExecutor {
     }
     if (request.signal?.aborted) {
       const result = earlyResult('abort', String(request.signal.reason))
-      kernel.completeJournal(request.journal, 'discarded', result)
       kernel.rollbackToDurable()
       // A refused reclamation stays recorded on the kernel so disposal remains
       // observable instead of becoming an unhandled rejection after this abort.
-      kernel.resetWorker(worker)
+      const reclamation = await kernel.resetWorker(worker)
+      if (reclamation.failed) result.error.message += `; helper reclamation failed: ${messageOf(reclamation.reason)}`
+      kernel.completeJournal(request.journal, 'discarded', result)
       return result
     }
 
@@ -586,6 +596,7 @@ export class SessionCellExecutor {
             moduleLoads: prepared.moduleLoads,
             languageSemantics,
             moduleTransform,
+            cwd: executionCwd,
             rootRuntimeName: prepared.rootRuntimeName,
             rootBindings: prepared.rootBindings,
             importBindingNamespaces: new Map([...catalog.importBindings].map(([name, binding]) => [name, binding.namespace])),
@@ -675,7 +686,7 @@ export class SessionCellExecutor {
     }
     if (action === 'save') {
       if (active.durability.status === 'volatile') {
-        throw new Error('cannot save a durable REPL state from a volatile segment; restore a durable state first')
+        throw new Error(`cannot save a durable REPL state from a volatile segment; volatile reason: ${active.durability.reason ?? 'replayability is unproved'}. This save rejection leaves live bindings usable in the current worker; continue computation from them. It does not undo external effects.`)
       }
       active.control.names.add(name)
       active.journal.operations.push({ action, name })
@@ -896,7 +907,11 @@ export class SessionCellExecutor {
         longCellFailure: active.request.program.length >= LONG_CELL_CODE_UNITS,
         failureOrigin: message.failureOrigin,
       })
-      const failure = replayFailureDiagnostic(actualFailure, active.replay)
+      const legacyFailure = message.valueFailure === undefined ? undefined : exceptionDiagnostic({
+        error: { ...rawError, message: message.valueFailure.legacyMessage },
+        languageSemantics: active.prepared.languageSemantics,
+      })
+      const failure = replayFailureDiagnostic(actualFailure, active.replay, legacyFailure)
       const error = {
         kind: 'exception',
         message: renderDiagnostic(failure, active.request.program),
@@ -908,7 +923,8 @@ export class SessionCellExecutor {
       return
     }
     if (typeof message.invalidOutput === 'string') {
-      const failure = replayFailureDiagnostic(invalidOutputDiagnostic(message.invalidOutput), active.replay)
+      const failure = replayFailureDiagnostic(invalidOutputDiagnostic(message.invalidOutput, message.valueFailure), active.replay,
+        message.valueFailure === undefined ? undefined : invalidOutputDiagnostic(message.valueFailure.legacyMessage))
       const error = { kind: 'invalid-output', message: renderDiagnostic(failure, active.request.program) }
       active.diagnostics.push(failure)
       active.resolve({ logs, error })
@@ -919,7 +935,11 @@ export class SessionCellExecutor {
         || (message.hasValue ? message.value === undefined : message.value !== undefined)) {
         throw new TypeError('invalid PTC completion envelope')
       }
-      const completion = message.hasValue ? prepareValueWire(message.value, active.valueLimits) : undefined
+      const completion = message.hasValue
+        ? active.request.programCompletion === true
+          ? { wire: normalizeValueWire(message.value, active.valueLimits) }
+          : prepareValueWire(message.value, active.valueLimits)
+        : undefined
       active.completion = {
         hasValue: message.hasValue,
         ...(message.hasValue ? { value: completion.wire } : {}),
@@ -932,10 +952,13 @@ export class SessionCellExecutor {
       }
       active.resolve({
         logs,
-        ...(message.hasValue ? { value: completion.projectedValue } : {}),
+        ...(message.hasValue && active.request.programCompletion !== true
+          ? { value: completion.projectedValue } : {}),
       })
     } catch (error) {
-      const failure = replayFailureDiagnostic(invalidOutputDiagnostic(messageOf(error)), active.replay)
+      const valueFailure = valueEncodingFailure(error)
+      const failure = replayFailureDiagnostic(invalidOutputDiagnostic(messageOf(error), valueFailure), active.replay,
+        valueFailure === undefined ? undefined : invalidOutputDiagnostic(valueFailure.legacyMessage))
       const invalid = { kind: 'invalid-output', message: renderDiagnostic(failure, active.request.program) }
       active.diagnostics.push(failure)
       active.resolve({ logs, error: invalid })
@@ -990,7 +1013,7 @@ export class SessionCellExecutor {
       const value = kernel.withInitiator === undefined || agent === undefined
         ? await invoke()
         : await kernel.withInitiator(agent, invoke)
-      const valueWire = encodeValue(value, active.valueLimits)
+      const valueWire = encodeValueAtBoundary(value, active.valueLimits, 'result')
       if (call !== undefined) {
         call.ok = true
         call.value = valueWire

package/internal/session-events.js

@@ -18,6 +18,34 @@ export function advanceSessionSurface(nodes, event) {
   return next
 }
 
+/** Read model source from the Host projection, independently of execution history. */
+export function sessionSourceMessages(session, events, nodes) {
+  if (Array.isArray(session?.surface?.sourceMessages)) {
+    return new Map(session.surface.sourceMessages)
+  }
+  const visible = new Set(nodes)
+  const sources = new Map()
+  const messages = typeof session?.deriveMessages === 'function'
+    ? session.deriveMessages()
+    : undefined
+  for (const event of events) {
+    if (event.type !== 'assistant/message' || !visible.has(event.seq)) continue
+    let message
+    if (typeof session?.deriveEventMessage === 'function') {
+      message = session.deriveEventMessage(event)
+    } else if (messages !== undefined) {
+      const id = event.data?.message?.id
+      const matches = typeof id === 'string' ? messages.filter(item => item.id === id) : []
+      if (matches.length === 1) message = matches[0]
+    } else if (Array.isArray(session?.events)) {
+      // The historical array-backed contract has no pure message projections.
+      message = event.data?.message
+    }
+    if (message !== undefined && message !== null) sources.set(event.seq, message)
+  }
+  return sources
+}
+
 export async function readSessionLog(session, query, signal) {
   if (session === undefined || session === null || Array.isArray(session.events)) return session
   if (typeof query?.observeSession !== 'function') {
@@ -31,10 +59,16 @@ export async function readSessionLog(session, query, signal) {
       nodes = []
       for (const event of observation.events) nodes = advanceSessionSurface(nodes, event)
     }
+    // Do not pair an immutable raw cut with a newer live message projection.
+    // A cut without exact model-source evidence cannot retain old bindings.
+    const sources = session.seq - 1 === observation.cursor
+      ? sessionSourceMessages(session, observation.events, nodes)
+      : new Map()
     return Object.freeze({
       id: session.id, header: observation.header, events: observation.events,
       surface: Object.freeze({
         nodes: Object.freeze([...nodes]),
+        sourceMessages: Object.freeze([...sources].map(entry => Object.freeze(entry))),
       }),
     })
   } finally {