dsh-ptc-plus 0.2.4 → 0.3.1

package/internal/repl-memory-projection.js

@@ -0,0 +1,277 @@
+import { isRecord } from './record-utils.js'
+
+export const REPL_MEMORY_KEY = 'ptcPlusRepl'
+export const REPL_MEMORY_META_KEY = 'dshPtcPlusBindings'
+
+const BINDING_KINDS = new Set(['variable', 'function', 'class', 'import'])
+const MAX_BINDINGS = 128
+const MAX_BINDING_NAME_LENGTH = 128
+const MAX_DEFINITION_SOURCE_LENGTH = 1024
+const MAX_DEFINITION_SOURCE_TOTAL_LENGTH = 16 * 1024
+const MAX_PENDING_REPL_CALLS = 256
+const MAX_CALL_ID_LENGTH = 512
+const MAX_GENERATION_LENGTH = 128
+const SNAPSHOT_FIELDS = new Set(['available', 'entries', 'total', 'omitted'])
+const ENTRY_FIELDS = new Set(['name', 'kind', 'definition'])
+const DEFINITION_FIELDS = new Set(['source', 'line', 'column'])
+const MEMORY_META_FIELDS = new Set(['version', 'generation', 'memory'])
+const PROJECTION_STATE_FIELDS = new Set(['generation', 'memory', 'pendingReplCalls'])
+const PENDING_CALL_FIELDS = new Set(['callId', 'seq'])
+const REPL_TOOL_NAMES = new Set(['run_code', 'edit_run_code'])
+const REPL_MEMORY_META_VERSION = 3
+
+function exactFields(value, fields) {
+  if (!isRecord(value)) return false
+  const keys = Reflect.ownKeys(value)
+  return keys.length === fields.size && keys.every(key => (
+    typeof key === 'string' && fields.has(key)
+    && Object.prototype.propertyIsEnumerable.call(value, key)
+  ))
+}
+
+const EMPTY_REPL_MEMORY = Object.freeze({
+  available: false,
+  entries: Object.freeze([]),
+  total: 0,
+  omitted: 0,
+})
+
+export function unavailableReplMemorySnapshot() {
+  return EMPTY_REPL_MEMORY
+}
+
+function normalizeGeneration(value) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > MAX_GENERATION_LENGTH) {
+    throw new Error('invalid dsh-ptc-plus REPL memory generation')
+  }
+  return value
+}
+
+function normalizeDefinition(value) {
+  if (!exactFields(value, DEFINITION_FIELDS)
+    || typeof value.source !== 'string' || value.source.length === 0
+    || value.source.length > MAX_DEFINITION_SOURCE_LENGTH
+    || !Number.isSafeInteger(value.line) || value.line < 1
+    || !Number.isSafeInteger(value.column) || value.column < 1) {
+    throw new Error('invalid dsh-ptc-plus REPL binding definition')
+  }
+  return Object.freeze({ source: value.source, line: value.line, column: value.column })
+}
+
+function normalizeBinding(value) {
+  if (!exactFields(value, ENTRY_FIELDS) || typeof value.name !== 'string'
+    || value.name.length === 0 || value.name.length > MAX_BINDING_NAME_LENGTH
+    || !BINDING_KINDS.has(value.kind)) {
+    throw new Error('invalid dsh-ptc-plus REPL memory binding')
+  }
+  return Object.freeze({
+    name: value.name,
+    kind: value.kind,
+    definition: normalizeDefinition(value.definition),
+  })
+}
+
+/** Produce bounded, value-independent presentation metadata from the live binding catalog. */
+export function createReplMemorySnapshot(bindings) {
+  const all = Array.isArray(bindings) ? bindings : []
+  const candidates = []
+  const names = new Set()
+  for (const binding of all) {
+    try {
+      const normalized = normalizeBinding(binding)
+      if (names.has(normalized.name)) continue
+      names.add(normalized.name)
+      candidates.push(normalized)
+    } catch {}
+  }
+  const entries = []
+  let sourceLength = 0
+  for (const binding of candidates) {
+    if (entries.length >= MAX_BINDINGS) break
+    if (sourceLength + binding.definition.source.length > MAX_DEFINITION_SOURCE_TOTAL_LENGTH) continue
+    entries.push(binding)
+    sourceLength += binding.definition.source.length
+  }
+  return Object.freeze({
+    available: true,
+    entries: Object.freeze(entries),
+    total: candidates.length,
+    omitted: candidates.length - entries.length,
+  })
+}
+
+/** Validate one complete session-projection value without accepting unknown fields. */
+export function normalizeReplMemorySnapshot(value) {
+  if (!exactFields(value, SNAPSHOT_FIELDS) || typeof value.available !== 'boolean'
+    || !Array.isArray(value.entries) || value.entries.length > MAX_BINDINGS
+    || !Number.isSafeInteger(value.total) || value.total < 0
+    || !Number.isSafeInteger(value.omitted) || value.omitted < 0
+    || value.total !== value.entries.length + value.omitted) {
+    throw new Error('invalid dsh-ptc-plus REPL memory snapshot')
+  }
+  if (!value.available && (value.total !== 0 || value.entries.length !== 0)) {
+    throw new Error('unavailable dsh-ptc-plus REPL memory snapshot must be empty')
+  }
+  const names = new Set()
+  let sourceLength = 0
+  const entries = value.entries.map((entry) => {
+    const normalized = normalizeBinding(entry)
+    if (names.has(normalized.name)) {
+      throw new Error('invalid dsh-ptc-plus REPL memory binding')
+    }
+    sourceLength += normalized.definition.source.length
+    if (sourceLength > MAX_DEFINITION_SOURCE_TOTAL_LENGTH) {
+      throw new Error('dsh-ptc-plus REPL binding definitions exceed the presentation budget')
+    }
+    names.add(normalized.name)
+    return normalized
+  })
+  return Object.freeze({
+    available: value.available,
+    entries: Object.freeze(entries),
+    total: value.total,
+    omitted: value.omitted,
+  })
+}
+
+function normalizeReplMemoryMetadata(value) {
+  if (!exactFields(value, MEMORY_META_FIELDS) || value.version !== REPL_MEMORY_META_VERSION) {
+    throw new Error('invalid dsh-ptc-plus REPL memory metadata')
+  }
+  return Object.freeze({
+    version: REPL_MEMORY_META_VERSION,
+    generation: normalizeGeneration(value.generation),
+    memory: normalizeReplMemorySnapshot(value.memory),
+  })
+}
+
+/** Read current-owner presentation metadata without affecting tool settlement. */
+export function validatedReplMemorySnapshot(meta, generation) {
+  if (!isRecord(meta) || !Object.hasOwn(meta, REPL_MEMORY_META_KEY)) return undefined
+  try {
+    const normalized = normalizeReplMemoryMetadata(meta[REPL_MEMORY_META_KEY])
+    return normalized.generation === normalizeGeneration(generation)
+      ? normalized.memory
+      : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function projectionState(generation, memory, pendingReplCalls) {
+  return Object.freeze({
+    generation,
+    memory,
+    pendingReplCalls: pendingReplCalls === null
+      ? null
+      : Object.freeze(pendingReplCalls),
+  })
+}
+
+function emptyProjectionState(generation) {
+  return projectionState(normalizeGeneration(generation), EMPTY_REPL_MEMORY, [])
+}
+
+function normalizeProjectionState(value, generation) {
+  if (!exactFields(value, PROJECTION_STATE_FIELDS)) {
+    throw new Error('invalid dsh-ptc-plus REPL memory projection state')
+  }
+  const storedGeneration = normalizeGeneration(value.generation)
+  const currentGeneration = normalizeGeneration(generation)
+  if (storedGeneration !== currentGeneration) return emptyProjectionState(currentGeneration)
+  const memory = normalizeReplMemorySnapshot(value.memory)
+  if (value.pendingReplCalls === null) {
+    if (memory.available) {
+      throw new Error('untracked dsh-ptc-plus REPL calls require unavailable memory')
+    }
+    return projectionState(currentGeneration, memory, null)
+  }
+  if (!Array.isArray(value.pendingReplCalls)
+    || value.pendingReplCalls.length > MAX_PENDING_REPL_CALLS) {
+    throw new Error('invalid dsh-ptc-plus pending REPL calls')
+  }
+  let previousSeq
+  const callIds = new Set()
+  const pendingReplCalls = value.pendingReplCalls.map((pending) => {
+    if (!exactFields(pending, PENDING_CALL_FIELDS)
+      || typeof pending.callId !== 'string' || pending.callId.length === 0
+      || pending.callId.length > MAX_CALL_ID_LENGTH || callIds.has(pending.callId)
+      || !Number.isSafeInteger(pending.seq) || pending.seq < 0
+      || (previousSeq !== undefined && previousSeq >= pending.seq)) {
+      throw new Error('invalid dsh-ptc-plus pending REPL call')
+    }
+    callIds.add(pending.callId)
+    previousSeq = pending.seq
+    return Object.freeze({ callId: pending.callId, seq: pending.seq })
+  })
+  return projectionState(currentGeneration, memory, pendingReplCalls)
+}
+
+function eventCallId(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= MAX_CALL_ID_LENGTH
+    ? value
+    : undefined
+}
+
+function trackReplCall(state, event) {
+  if (!REPL_TOOL_NAMES.has(event.data?.name)) return state
+  const seq = event.seq
+  const callId = eventCallId(event.data?.callId)
+  if (!Number.isSafeInteger(seq) || seq < 0 || callId === undefined) return state
+  const pending = state.pendingReplCalls
+  if (pending === null || pending.some(call => call.callId === callId || call.seq === seq)) return state
+  if (pending.length >= MAX_PENDING_REPL_CALLS) {
+    return projectionState(state.generation, EMPTY_REPL_MEMORY, null)
+  }
+  return projectionState(state.generation, state.memory, [
+    ...pending,
+    Object.freeze({ callId, seq }),
+  ].sort((left, right) => left.seq - right.seq))
+}
+
+function settleReplCall(state, event, generation) {
+  if (event.surfaceOp !== undefined && event.surfaceOp !== 'append') return state
+  const pending = state.pendingReplCalls
+  if (pending === null) return state
+  const callId = eventCallId(event.data?.message?.source?.callId)
+  if (callId === undefined) return state
+  const index = pending.findIndex(call => call.callId === callId)
+  if (index < 0) return state
+  const remaining = pending.filter((_call, pendingIndex) => pendingIndex !== index)
+  const memory = validatedReplMemorySnapshot(event.data?.meta, generation) ?? state.memory
+  return projectionState(state.generation, memory, remaining)
+}
+
+/** Merge the binding snapshot into private, model-invisible result presentation metadata. */
+export function withReplMemorySnapshot(meta, snapshot, generation) {
+  const base = isRecord(meta) ? { ...meta } : meta === undefined ? {} : { value: meta }
+  base[REPL_MEMORY_META_KEY] = normalizeReplMemoryMetadata({
+    version: REPL_MEMORY_META_VERSION,
+    generation: normalizeGeneration(generation),
+    memory: snapshot,
+  })
+  return base
+}
+
+/** Build the current runtime owner's value-independent session projection. */
+export function createReplMemoryProjection(generation) {
+  const currentGeneration = normalizeGeneration(generation)
+  return Object.freeze({
+    key: REPL_MEMORY_KEY,
+    stateVersion: 3,
+    stateSchema: Object.freeze({
+      parse: value => normalizeProjectionState(value, currentGeneration),
+    }),
+    init: () => emptyProjectionState(currentGeneration),
+    apply(state, event) {
+      if (event?.type === 'session/end-seed') return emptyProjectionState(currentGeneration)
+      if (event?.type === 'tool/call') return trackReplCall(state, event)
+      if (event?.type === 'tool/result') return settleReplCall(state, event, currentGeneration)
+      return state
+    },
+    wire: Object.freeze({
+      viewSchema: Object.freeze({ parse: normalizeReplMemorySnapshot }),
+      view: state => state.memory,
+    }),
+  })
+}

package/internal/run-code-description.js

@@ -0,0 +1,34 @@
+const GENERATED_RUN_CODE_DESCRIPTION = 'Execute the next TypeScript cell in this session'
+export const GENERATED_RUN_CODE_DESCRIPTION_KEY = 'dshPtcPlusRunCodeDescription'
+
+// Keep presentation provenance outside the canonical JSON argument graph.
+const generatedArguments = new WeakSet()
+
+export function markGeneratedRunCodeArguments(argumentsValue) {
+  if (argumentsValue !== null
+    && (typeof argumentsValue === 'object' || typeof argumentsValue === 'function')) {
+    generatedArguments.add(argumentsValue)
+  }
+  return argumentsValue
+}
+
+export function generatedRunCodeExecutionArguments(argumentsValue) {
+  markGeneratedRunCodeArguments(argumentsValue)
+  return markGeneratedRunCodeArguments({
+    ...argumentsValue,
+    description: GENERATED_RUN_CODE_DESCRIPTION,
+  })
+}
+
+export function generatedRunCodeDescriptionMeta(argumentsValue, meta) {
+  if (!generatedArguments.has(argumentsValue)) return meta
+  const base = meta !== null && typeof meta === 'object' && !Array.isArray(meta)
+    ? meta
+    : meta === undefined ? {} : { value: meta }
+  return {
+    ...base,
+    [GENERATED_RUN_CODE_DESCRIPTION_KEY]: GENERATED_RUN_CODE_DESCRIPTION,
+  }
+}
+
+export { GENERATED_RUN_CODE_DESCRIPTION }

package/internal/runtime-bridge-owner.js

@@ -19,6 +19,8 @@ import {
   toolCapabilityMetadata,
 } from './program-bindings.js'
 import { deepFreeze } from './record-utils.js'
+import { withReplMemorySnapshot } from './repl-memory-projection.js'
+import { generatedRunCodeDescriptionMeta } from './run-code-description.js'
 
 export const RUN_CODE = 'run_code'
 
@@ -123,6 +125,7 @@ export function createRuntimeBridgeOwner({
   ctx,
   sessionConfig,
   maxNestedRunCodeDepth,
+  presentationGeneration,
   sessionId,
   toolSchemasForAgent,
 }) {
@@ -247,7 +250,7 @@ export function createRuntimeBridgeOwner({
     return { request: { ...request, bindings: projected }, release }
   }
 
-  const patchResultMetadata = (agent) => {
+  const patchRunCodeDefinition = (agent) => {
     const definition = ctx.tools.get(RUN_CODE, agent)
     if (definition === undefined) {
       throw new Error('ptc-plus: run_code definition is unavailable for the owning session')
@@ -257,28 +260,65 @@ export function createRuntimeBridgeOwner({
     }
     if (patchedDefinitions.has(definition)) return
     const output = definition.output
-    const original = output.presentationMeta
-    const patched = (args, value) => {
-      if (!active) return original === undefined ? undefined : original(args, value)
-      const base = original === undefined ? undefined : original(args, value)
+    const originalPresentationMeta = output.presentationMeta
+    const patchedPresentationMeta = (args, value) => {
+      if (!active) {
+        return originalPresentationMeta === undefined
+          ? undefined
+          : originalPresentationMeta(args, value)
+      }
+      const base = originalPresentationMeta === undefined
+        ? undefined
+        : originalPresentationMeta(args, value)
       const current = scope.getStore()
       const settlement = current?.settlement
-      if (settlement === undefined) return base
+      if (settlement === undefined) return generatedRunCodeDescriptionMeta(args, base)
       let meta = withJournal(base, settlement.journal)
       if (settlement.recoveryBoundaries !== undefined) {
         meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
       }
-      return settlement.rewrites === undefined ? meta : withRewrites(meta, settlement.rewrites)
+      if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+      meta = generatedRunCodeDescriptionMeta(args, meta)
+      return withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
     }
+    const ownExecute = Object.getOwnPropertyDescriptor(definition, 'execute')
+    const originalExecute = definition.execute
+    const patchedExecute = typeof originalExecute !== 'function'
+      ? undefined
+      : function (args, exec) {
+          const executionArguments = scope.getStore()?.executionArguments ?? args
+          return originalExecute.call(this, executionArguments, exec)
+        }
+    let presentationPatched = false
     try {
       Object.defineProperty(output, 'presentationMeta', {
         configurable: true,
         enumerable: true,
         writable: true,
-        value: patched,
+        value: patchedPresentationMeta,
+      })
+      presentationPatched = true
+      if (patchedExecute !== undefined) {
+        Object.defineProperty(definition, 'execute', {
+          configurable: true,
+          enumerable: ownExecute?.enumerable ?? true,
+          writable: true,
+          value: patchedExecute,
+        })
+      }
+      patchedDefinitions.set(definition, {
+        definition,
+        output,
+        originalPresentationMeta,
+        patchedPresentationMeta,
+        ownExecute,
+        patchedExecute,
       })
-      patchedDefinitions.set(definition, { output, original, patched })
     } catch (error) {
+      if (presentationPatched && output.presentationMeta === patchedPresentationMeta) {
+        if (originalPresentationMeta === undefined) delete output.presentationMeta
+        else output.presentationMeta = originalPresentationMeta
+      }
       throw new Error(`ptc-plus: cannot attach the session journal to run_code results: ${error.message}`)
     }
   }
@@ -333,11 +373,11 @@ export function createRuntimeBridgeOwner({
         throw error
       }
     },
-    handleExecute(exec, next) {
+    handleExecute(exec, next, executionArguments = exec.arguments) {
       if (exec.parent !== undefined) return scope.run(undefined, next)
       const id = sessionId(exec.agent)
       if (id === undefined) return next()
-      patchResultMetadata(exec.agent)
+      patchRunCodeDefinition(exec.agent)
       const inherited = scope.getStore()
       const persistedCallSeq = inherited?.persistedCallSeq
       const current = {
@@ -349,6 +389,7 @@ export function createRuntimeBridgeOwner({
           : { deferredSettlement: inherited.deferredSettlement }),
         session: exec.agent?.session,
         agent: exec.agent,
+        executionArguments,
       }
       if (current.deferredSettlement !== undefined) {
         current.deferredSettlement.current = current
@@ -363,6 +404,7 @@ export function createRuntimeBridgeOwner({
             meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
           }
           if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+          meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
           return { ...result, meta }
         }
         return result
@@ -405,10 +447,16 @@ export function createRuntimeBridgeOwner({
         if (ownRun === undefined) delete runtime.run
         else Object.defineProperty(runtime, 'run', ownRun)
       }
-      for (const { output, original, patched } of patchedDefinitions.values()) {
-        if (output.presentationMeta !== patched) continue
-        if (original === undefined) delete output.presentationMeta
-        else output.presentationMeta = original
+      for (const patched of patchedDefinitions.values()) {
+        if (patched.output.presentationMeta === patched.patchedPresentationMeta) {
+          if (patched.originalPresentationMeta === undefined) delete patched.output.presentationMeta
+          else patched.output.presentationMeta = patched.originalPresentationMeta
+        }
+        if (patched.patchedExecute !== undefined
+          && patched.definition.execute === patched.patchedExecute) {
+          if (patched.ownExecute === undefined) delete patched.definition.execute
+          else Object.defineProperty(patched.definition, 'execute', patched.ownExecute)
+        }
       }
       patchedDefinitions.clear()
       await sessions.dispose()

package/internal/runtime-config.js

@@ -18,6 +18,8 @@ const BUDGET_KEYS = Object.freeze([
 
 /** Boolean runtime behavior switches. */
 const BOOLEAN_KEYS = Object.freeze([
+  'enhancedToolView',
+  'autoDescribeRunCode',
   'cordisToolsEnabled',
   'canonicalizeToolCalls',
   'looseTopLevelRedeclarations',

package/internal/session-cell-executor.js

@@ -12,6 +12,7 @@ import {
   LONG_CELL_CODE_UNITS,
   markBindingFailure,
   messageOf,
+  missingDescriptionPath,
   oneLineMessage,
   safeProperty,
 } from './failure-reporting.js'
@@ -128,7 +129,11 @@ function exceptionDiagnostic({
   declared,
   longCellFailure = false,
 }) {
-  const message = firstLine(error.message, 'Unknown exception')
+  const missingPath = error.name === 'ToolCallError' ? missingDescriptionPath(error) : undefined
+  const missingDescription = missingPath !== undefined
+  const message = missingDescription
+    ? `nested native tool arguments are missing required \`description\` at JSON path $.${missingPath} (${error.toolName ?? 'unknown tool'}); this does not satisfy the outer run_code transport`
+    : firstLine(error.message, 'Unknown exception')
   const rawName = typeof error.name === 'string' && error.name.length > 0
     ? error.name
     /* c8 ignore next */
@@ -147,7 +152,9 @@ function exceptionDiagnostic({
     ...(cause === undefined ? {} : { cause }),
     ...(source === undefined ? {} : { source }),
     help: [
-      'inspect existing bindings and retry only the failing expression',
+      ...(missingDescription
+        ? ['add a string `description` property to the nested native-tool argument object']
+        : ['inspect existing bindings and retry only the failing expression']),
       ...(error.name === 'ToolCallError'
         && typeof error.toolName === 'string'
         && error.toolName.startsWith('cordis_')
@@ -496,7 +503,7 @@ export class SessionCellExecutor {
       })
       active.appliedBindingCatalog = message.moduleLoadFailed === true
         ? active.priorBindingCatalog
-        : active.priorBindingCatalog.advance(active.prepared)
+        : active.priorBindingCatalog.advance(active.prepared, active.request.program)
       const recordedFailure = active.replay?.diagnostics?.find(item => item.code === 'PTC-X001')
       const failure = recordedFailure?.message === actualFailure.message ? recordedFailure : actualFailure
       const error = {
@@ -525,7 +532,10 @@ export class SessionCellExecutor {
         hasValue: message.hasValue,
         ...(message.hasValue ? { value } : {}),
       }
-      active.appliedBindingCatalog = active.priorBindingCatalog.advance(active.prepared)
+      active.appliedBindingCatalog = active.priorBindingCatalog.advance(
+        active.prepared,
+        active.request.program,
+      )
       if (active.replay?.completion?.kind === 'return'
         && (active.replay.completion.hasValue !== message.hasValue
           || (message.hasValue && !valueWiresEqual(active.replay.completion.value, value, active.valueLimits)))) {

package/internal/session-events.js

@@ -0,0 +1,7 @@
+/** Read the immutable session log across current and legacy DSH session APIs. */
+export function sessionEvents(session) {
+  if (typeof session?.snapshotEvents === 'function') {
+    return session.snapshotEvents()
+  }
+  return session?.events
+}

package/internal/session-journal.js

@@ -1,6 +1,7 @@
 import { decodeValue, encodeValue, normalizeValueWire } from './value-wire.js'
 import { normalizeDiagnostic } from './diagnostic.js'
 import { assertOwnFields, isRecord } from './record-utils.js'
+import { sessionEvents } from './session-events.js'
 
 export const JOURNAL_KEY = 'dshPtcPlus'
 export const EDIT_TARGET_KEY = 'dshPtcPlusEdit'
@@ -365,7 +366,7 @@ export function migrateRecoveryBoundaryEvents(events) {
 
 /** Resolve the persisted event identity for one named tool call being dispatched. */
 export function liveToolCallSeq(session, callId, toolName) {
-  const events = session?.events
+  const events = sessionEvents(session)
   if (!Array.isArray(events) || typeof callId !== 'string' || callId.length === 0
     || typeof toolName !== 'string' || toolName.length === 0) return undefined
 
@@ -741,7 +742,7 @@ export function foldSessionTimeline(events) {
 
 /** Fold the session log into the last exactly replayable frontier. */
 export function recoverJournal(session, currentCallSeq, options = {}) {
-  const events = session?.events
+  const events = sessionEvents(session)
   if (!Array.isArray(events)) {
     return { nodes: [], head: undefined, checkpoints: new Map(), volatileSuffix: [], available: true }
   }

package/internal/session-log-view.js

@@ -1,6 +1,7 @@
 import {
   foldSessionTimeline,
 } from './session-journal.js'
+import { sessionEvents } from './session-events.js'
 
 const SYSTEM_PROMPT_PLUGIN = '@deepseek-ai/dsh-system-prompt'
 
@@ -43,7 +44,7 @@ function cordisTranscriptFacts(timeline) {
 
 /** Project session events into immutable facts consumed by prompt presentation. */
 export function projectSessionLog(agent, requestedEdit) {
-  const events = agent?.session?.events
+  const events = sessionEvents(agent?.session)
   if (!Array.isArray(events)) {
     return Object.freeze({
       openTurn: false,

package/internal/session-runtime.js

@@ -13,6 +13,10 @@ import { resolveConfig } from './runtime-config.js'
 import { WorkerClient } from './worker-client.js'
 import { BindingCatalog, durabilityState, transitionDurability } from './session-state.js'
 import { SessionCellExecutor } from './session-cell-executor.js'
+import {
+  createReplMemorySnapshot,
+  unavailableReplMemorySnapshot,
+} from './repl-memory-projection.js'
 
 const WORKER_URL = new URL('./kernel-worker.js', import.meta.url)
 function recoveryDiagnostic(count) {
@@ -300,14 +304,14 @@ class SessionKernel {
           callSeq: request.callSeq,
           program: request.program,
           bindingCatalog: active.appliedBindingCatalog
-            ?? active.priorBindingCatalog.advance(prepared),
+            ?? active.priorBindingCatalog.advance(prepared, request.program),
           worker,
         })
       }
     }
     if (replay !== undefined && !terminate) {
       this.bindingCatalog = active.appliedBindingCatalog
-        ?? active.priorBindingCatalog.advance(prepared)
+        ?? active.priorBindingCatalog.advance(prepared, request.program)
     }
     this.active = undefined
     if (terminate) void this.client.reset(worker)
@@ -353,6 +357,18 @@ class SessionKernel {
     }
   }
 
+  replMemoryFor(journal) {
+    const tentative = this.tentatives.get(journal)
+    if (journal.status === 'discarded'
+      || journal.operations.some(operation => operation.action === 'restore')) {
+      return unavailableReplMemorySnapshot()
+    }
+    if (tentative === undefined) {
+      return createReplMemorySnapshot(this.bindingCatalog.snapshot())
+    }
+    return createReplMemorySnapshot(tentative.bindingCatalog.snapshot())
+  }
+
   finishStateOperations(operations, index, worker) {
     const transition = reduceStateOperations(this.history, operations, index)
     this.history.head = transition.head
@@ -487,6 +503,7 @@ export class SessionRuntime {
       journal,
       kernel,
       sessionId,
+      replMemory: kernel.replMemoryFor(journal),
       ...(result.recoveryBoundaries === undefined
         ? {}
         : { recoveryBoundaries: result.recoveryBoundaries }),