dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/session-journal.js

@@ -2,30 +2,72 @@ 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'
-export const DERIVED_RUN_KEY = 'dshPtcPlusDerivedRun'
-export const REWRITES_KEY = 'dshPtcPlusRewrites'
-export const RECOVERY_BOUNDARY_KEY = 'dshPtcPlusRecoveryBoundaries'
-export const JOURNAL_VERSION = 3
-const LEGACY_JOURNAL_VERSION = 1
-const INTERMEDIATE_JOURNAL_VERSION = 2
-export const RECOVERY_BOUNDARY_EVENT = 'ptc-plus/recovery-boundary'
-
-const STATUSES = new Set(['durable', 'volatile', 'discarded', 'noop'])
-const BINDING_MODES = new Set(['loose', 'strict'])
-const JOURNAL_FIELDS = new Set(['version', 'bindingMode', 'rewritePolicy', 'status', 'calls', 'operations', 'confirms', 'diagnostics', 'completion', 'volatileReason'])
-const LEGACY_JOURNAL_FIELDS = new Set([...JOURNAL_FIELDS].filter(field => field !== 'rewritePolicy'))
-const REWRITE_POLICY_FIELDS = new Set(['autoRewriteImports', 'autoStripExports', 'autoSplitRedeclarations'])
-const CALL_SUCCESS_FIELDS = new Set(['global', 'member', 'args', 'ok', 'value', 'settle'])
-const CALL_ERROR_FIELDS = new Set(['global', 'member', 'args', 'ok', 'error', 'settle'])
-const OPERATION_FIELDS = new Set(['action', 'name'])
-const RETURN_FIELDS = new Set(['kind', 'hasValue', 'value'])
-const THROW_FIELDS = new Set(['kind', 'error'])
-const ERROR_FIELDS = new Set(['kind', 'message'])
-const EDIT_TARGET_FIELDS = new Set(['targetCallSeq'])
-const DERIVED_RUN_FIELDS = new Set(['code', 'description'])
+import { LEGACY_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import {
+  LEGACY_DEFAULT_EXPORT_BINDING,
+  LEGACY_IMPORT_EXPRESSION_BOUNDARY,
+  LIVE_MODULE_SEMANTICS,
+} from './repl-rewrite-contract.js'
+import { userBindingsSnapshotFromMeta } from './user-bindings.js'
+import {
+  JOURNAL_KEY,
+  EDIT_TARGET_KEY,
+  DERIVED_RUN_KEY,
+  REWRITES_KEY,
+  RECOVERY_BOUNDARY_KEY,
+  JOURNAL_VERSION,
+  IMPORT_BOUNDARY_JOURNAL_VERSION,
+  PER_NAME_USER_BINDINGS_JOURNAL_VERSION,
+  PER_NAME_JOURNAL_FIELDS,
+  WHOLE_ENTRY_JOURNAL_FIELDS,
+  LIVE_USER_BINDINGS_SHADOW_POLICY,
+  LEGACY_USER_BINDINGS_SHADOW_POLICY,
+  normalizeJournalUserBindingNames,
+  LIVE_USER_BINDINGS_REUSE_POLICY,
+  LEGACY_USER_BINDINGS_REUSE_POLICY,
+  LEGACY_JOURNAL_VERSION,
+  USER_BINDING_RELATIONLESS_JOURNAL_VERSION,
+  FINGERPRINT_REUSE_JOURNAL_VERSION,
+  VERSIONED_BINDING_REUSE_JOURNAL_VERSION,
+  RECOVERY_BOUNDARY_EVENT,
+  STATUSES,
+  BINDING_MODES,
+  JOURNAL_FIELDS,
+  FINGERPRINT_REUSE_JOURNAL_FIELDS,
+  RELATIONLESS_JOURNAL_FIELDS,
+  PREDECESSOR_JOURNAL_FIELDS,
+  LEGACY_JOURNAL_FIELDS,
+  BINDING_POLICY_FIELDS,
+  REWRITE_POLICY_FIELDS,
+  MODULE_SEMANTICS_FIELDS,
+  LEGACY_MODULE_SEMANTICS_FIELDS,
+  IMPORT_EXPRESSION_BOUNDARIES,
+  DEFAULT_EXPORT_BINDINGS,
+  CALL_SUCCESS_FIELDS,
+  CALL_ERROR_FIELDS,
+  OPERATION_FIELDS,
+  RETURN_FIELDS,
+  THROW_FIELDS,
+  ERROR_FIELDS,
+  EDIT_TARGET_FIELDS,
+  DERIVED_RUN_FIELDS,
+  JOURNAL_VERSIONS,
+  USER_BINDINGS_REUSE_POLICIES,
+  RECOVERY_BOUNDARY_FIELDS,
+  REWRITE_FIELDS,
+  REWRITE_KINDS,
+} from './session-journal-schema.js'
+
+export {
+  JOURNAL_KEY,
+  EDIT_TARGET_KEY,
+  DERIVED_RUN_KEY,
+  REWRITES_KEY,
+  RECOVERY_BOUNDARY_KEY,
+  JOURNAL_VERSION,
+  LIVE_USER_BINDINGS_REUSE_POLICY,
+  RECOVERY_BOUNDARY_EVENT,
+} from './session-journal-schema.js'
 
 function cloneJson(value) {
   if (value === undefined) return undefined
@@ -167,28 +209,131 @@ function normalizeRewritePolicy(value) {
   })
 }
 
+function normalizeBindingPolicy(value) {
+  if (!isRecord(value)) throw new Error('invalid dsh-ptc-plus journal binding policy')
+  assertOwnFields(value, BINDING_POLICY_FIELDS, 'journal binding policy')
+  for (const key of BINDING_POLICY_FIELDS) {
+    if (typeof value[key] !== 'boolean') throw new Error(`invalid dsh-ptc-plus journal binding policy ${key}`)
+  }
+  return Object.freeze({
+    variableRedeclarations: value.variableRedeclarations,
+    functionClassRedeclarations: value.functionClassRedeclarations,
+  })
+}
+
+function normalizeModuleSemantics(value) {
+  if (!isRecord(value)) throw new Error('invalid dsh-ptc-plus journal module semantics')
+  assertOwnFields(value, MODULE_SEMANTICS_FIELDS, 'journal module semantics')
+  if (!DEFAULT_EXPORT_BINDINGS.has(value.defaultExportBinding)) {
+    throw new Error('invalid dsh-ptc-plus journal default export binding semantics')
+  }
+  if (!IMPORT_EXPRESSION_BOUNDARIES.has(value.importExpressionBoundary)) {
+    throw new Error('invalid dsh-ptc-plus journal import expression boundary semantics')
+  }
+  return Object.freeze({
+    defaultExportBinding: value.defaultExportBinding,
+    importExpressionBoundary: value.importExpressionBoundary,
+  })
+}
+
+function migrateLegacyModuleSemantics(value) {
+  if (!isRecord(value)) throw new Error('invalid dsh-ptc-plus journal module semantics')
+  assertOwnFields(value, LEGACY_MODULE_SEMANTICS_FIELDS, 'journal module semantics')
+  return { ...value, importExpressionBoundary: LEGACY_IMPORT_EXPRESSION_BOUNDARY }
+}
+
+function normalizeUserBindingsFingerprint(value) {
+  if (value !== null && (typeof value !== 'string' || !/^[a-f0-9]{64}$/.test(value))) {
+    throw new Error('invalid dsh-ptc-plus journal user binding fingerprint')
+  }
+  return value
+}
+
 function migrateJournal(value, resolveLegacyConfirm) {
-  if (value.version !== LEGACY_JOURNAL_VERSION) return value
-  assertOwnFields(value, LEGACY_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+  if (value.version === JOURNAL_VERSION) return value
+  if (value.version === PER_NAME_USER_BINDINGS_JOURNAL_VERSION) {
+    assertOwnFields(value, PER_NAME_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return { ...value, version: JOURNAL_VERSION, languageSemantics: LEGACY_LANGUAGE_SEMANTICS }
+  }
+  const shadow = { userBindingsShadowPolicy: LEGACY_USER_BINDINGS_SHADOW_POLICY, userBindingNames: null,
+    languageSemantics: LEGACY_LANGUAGE_SEMANTICS }
+  if (value.version === IMPORT_BOUNDARY_JOURNAL_VERSION) {
+    assertOwnFields(value, WHOLE_ENTRY_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return { ...value, version: JOURNAL_VERSION, ...shadow }
+  }
+  if (value.version === VERSIONED_BINDING_REUSE_JOURNAL_VERSION) {
+    assertOwnFields(value, WHOLE_ENTRY_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return { ...value, version: JOURNAL_VERSION, ...shadow, moduleSemantics: migrateLegacyModuleSemantics(value.moduleSemantics) }
+  }
+  if (value.version === FINGERPRINT_REUSE_JOURNAL_VERSION) {
+    assertOwnFields(value, FINGERPRINT_REUSE_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return {
+      ...value,
+      version: JOURNAL_VERSION,
+      moduleSemantics: migrateLegacyModuleSemantics(value.moduleSemantics),
+      userBindingsReusePolicy: LEGACY_USER_BINDINGS_REUSE_POLICY,
+      ...shadow,
+    }
+  }
+  if (value.version === USER_BINDING_RELATIONLESS_JOURNAL_VERSION) {
+    assertOwnFields(value, RELATIONLESS_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return {
+      ...value,
+      version: JOURNAL_VERSION,
+      moduleSemantics: migrateLegacyModuleSemantics(value.moduleSemantics),
+      userBindingsFingerprint: null,
+      userBindingsReusePolicy: LEGACY_USER_BINDINGS_REUSE_POLICY,
+      ...shadow,
+    }
+  }
+  const legacy = value.version === LEGACY_JOURNAL_VERSION
+  assertOwnFields(
+    value,
+    legacy ? LEGACY_JOURNAL_FIELDS : PREDECESSOR_JOURNAL_FIELDS,
+    'dsh-ptc-plus journal',
+  )
+  if (!BINDING_MODES.has(value.bindingMode)) throw new Error('invalid dsh-ptc-plus journal binding mode')
+  const { bindingMode, ...rest } = value
   return {
-    ...value,
+    ...rest,
     version: JOURNAL_VERSION,
-    rewritePolicy: LEGACY_REWRITE_POLICY,
-    confirms: normalizeLegacyConfirms(value.confirms, resolveLegacyConfirm),
+    bindingPolicy: {
+      variableRedeclarations: bindingMode === 'loose',
+      functionClassRedeclarations: false,
+    },
+    rewritePolicy: legacy ? LEGACY_REWRITE_POLICY : value.rewritePolicy,
+    moduleSemantics: {
+      defaultExportBinding: LEGACY_DEFAULT_EXPORT_BINDING,
+      importExpressionBoundary: LEGACY_IMPORT_EXPRESSION_BOUNDARY,
+    },
+    userBindingsFingerprint: null,
+    userBindingsReusePolicy: LEGACY_USER_BINDINGS_REUSE_POLICY,
+    ...shadow,
+    confirms: legacy
+      ? normalizeLegacyConfirms(value.confirms, resolveLegacyConfirm)
+      : value.confirms,
   }
 }
 
 /** Validate and detach one journal emitted by the runtime. */
 export function normalizeJournal(value, options = {}) {
   if (!isRecord(value)) throw new Error('invalid dsh-ptc-plus journal')
-  if (![LEGACY_JOURNAL_VERSION, INTERMEDIATE_JOURNAL_VERSION, JOURNAL_VERSION].includes(value.version)
+  if (!JOURNAL_VERSIONS.has(value.version)
     || !STATUSES.has(value.status)) {
     throw new Error('invalid dsh-ptc-plus journal')
   }
   const migrated = migrateJournal(value, options.resolveLegacyConfirm)
   assertOwnFields(migrated, JOURNAL_FIELDS, 'dsh-ptc-plus journal')
-  if (!BINDING_MODES.has(migrated.bindingMode)) throw new Error('invalid dsh-ptc-plus journal binding mode')
+  const languageSemantics = normalizeLanguageSemantics(migrated.languageSemantics)
+  const bindingPolicy = normalizeBindingPolicy(migrated.bindingPolicy)
   const rewritePolicy = normalizeRewritePolicy(migrated.rewritePolicy)
+  const moduleSemantics = normalizeModuleSemantics(migrated.moduleSemantics)
+  const userBindingsFingerprint = normalizeUserBindingsFingerprint(migrated.userBindingsFingerprint)
+  const userBindingsReusePolicy = migrated.userBindingsReusePolicy
+  const userBindingNames = normalizeJournalUserBindingNames(migrated)
+  if (!USER_BINDINGS_REUSE_POLICIES.has(userBindingsReusePolicy)) {
+    throw new Error('invalid dsh-ptc-plus journal user binding reuse policy')
+  }
   const calls = normalizeCalls(migrated.calls)
   const operations = normalizeOperations(migrated.operations)
   const confirms = normalizeConfirms(migrated.confirms)
@@ -209,8 +354,14 @@ export function normalizeJournal(value, options = {}) {
   }
   return Object.freeze({
     version: JOURNAL_VERSION,
-    bindingMode: migrated.bindingMode,
+    languageSemantics,
+    bindingPolicy,
     rewritePolicy,
+    moduleSemantics,
+    userBindingsFingerprint,
+    userBindingsReusePolicy,
+    userBindingsShadowPolicy: migrated.userBindingsShadowPolicy,
+    userBindingNames,
     status: migrated.status,
     calls: Object.freeze(calls),
     operations: Object.freeze(operations),
@@ -243,15 +394,53 @@ export function normalizeDerivedEditResult(meta, expectedTargetCallSeq) {
   const recoveryBoundaries = meta[RECOVERY_BOUNDARY_KEY] === undefined
     ? undefined
     : normalizeRecoveryBoundaries(meta[RECOVERY_BOUNDARY_KEY])
+  const userBindings = userBindingsForJournal(meta, journal)
   return Object.freeze({
     targetCallSeq: target.targetCallSeq,
     code: derived.code,
     description: derived.description,
     journal,
     ...(recoveryBoundaries === undefined ? {} : { recoveryBoundaries }),
+    ...(userBindings === undefined ? {} : { userBindings }),
   })
 }
 
+export function userBindingsForJournal(meta, journal) {
+  const userBindings = userBindingsSnapshotFromMeta(meta)
+  if (journal.userBindingsFingerprint === null) {
+    if (userBindings !== undefined) {
+      throw new Error('dsh-ptc-plus journal does not declare user binding metadata')
+    }
+    validateUserBindingNameProviders(journal, undefined)
+    return undefined
+  }
+  if (userBindings === undefined) {
+    throw new Error('dsh-ptc-plus journal requires user binding metadata')
+  }
+  if (userBindings.fingerprint !== journal.userBindingsFingerprint) {
+    throw new Error('dsh-ptc-plus journal user binding fingerprint does not match metadata')
+  }
+  validateUserBindingNameProviders(journal, userBindings)
+  return userBindings
+}
+
+function validateUserBindingNameProviders(journal, snapshot) {
+  const providers = new Map((snapshot?.entries ?? []).flatMap(entry => (
+    (entry.scope === 'namespace' ? [entry.name] : entry.symbols).map(name => [name, entry.id])
+  )))
+  for (const fact of journal.userBindingNames ?? []) {
+    if (fact.state === 'provider' && providers.get(fact.name) !== fact.entryId) {
+      throw new Error('journal user binding name evidence has no matching provider')
+    }
+  }
+  if (journal.userBindingNames !== null) {
+    const names = new Set(journal.userBindingNames.map(fact => fact.name))
+    if ([...providers.keys()].some(name => !names.has(name))) {
+      throw new Error('journal user binding name evidence is incomplete')
+    }
+  }
+}
+
 /** Compare only the required persisted relation for one derived edit. */
 export function derivedEditResultsEqual(leftMeta, rightMeta, expectedTargetCallSeq) {
   try {
@@ -292,7 +481,7 @@ function normalizeRecoveryBoundaryValue(value, eventSeq = undefined) {
       && (!Number.isSafeInteger(value.frontierCallSeq) || value.frontierCallSeq < 0))) {
     throw new Error('invalid dsh-ptc-plus recovery boundary')
   }
-  assertOwnFields(value, new Set(['failedCallSeq', 'frontierCallSeq']), 'recovery boundary')
+  assertOwnFields(value, RECOVERY_BOUNDARY_FIELDS, 'recovery boundary')
   if (eventSeq !== undefined && (!Number.isSafeInteger(eventSeq) || eventSeq < 0)) {
     throw new Error('invalid dsh-ptc-plus recovery boundary event sequence')
   }
@@ -394,12 +583,24 @@ export function liveToolCallSeq(session, callId, toolName) {
 }
 
 /** Start a mutable journal for one live cell. */
-export function createJournal(confirms = [], bindingMode, rewritePolicy) {
-  if (!BINDING_MODES.has(bindingMode)) throw new TypeError('invalid dsh-ptc-plus journal binding mode')
+export function createJournal(confirms = [], bindingPolicy, rewritePolicy, languageSemantics = LEGACY_LANGUAGE_SEMANTICS) {
+  if (typeof bindingPolicy === 'string') {
+    if (!BINDING_MODES.has(bindingPolicy)) throw new TypeError('invalid dsh-ptc-plus journal binding mode')
+    bindingPolicy = {
+      variableRedeclarations: bindingPolicy === 'loose',
+      functionClassRedeclarations: false,
+    }
+  }
   return {
     version: JOURNAL_VERSION,
-    bindingMode,
+    languageSemantics: normalizeLanguageSemantics(languageSemantics),
+    bindingPolicy: normalizeBindingPolicy(bindingPolicy),
     rewritePolicy: normalizeRewritePolicy(rewritePolicy),
+    moduleSemantics: normalizeModuleSemantics(LIVE_MODULE_SEMANTICS),
+    userBindingsFingerprint: null,
+    userBindingsReusePolicy: LIVE_USER_BINDINGS_REUSE_POLICY,
+    userBindingsShadowPolicy: LIVE_USER_BINDINGS_SHADOW_POLICY,
+    userBindingNames: null,
     calls: [],
     operations: [],
     confirms: [...confirms],
@@ -407,15 +608,6 @@ export function createJournal(confirms = [], bindingMode, rewritePolicy) {
   }
 }
 
-function sourceForRunCall(call) {
-  try {
-    const args = JSON.parse(call.data.arguments)
-    return isRecord(args) && typeof args.code === 'string' ? args.code : undefined
-  } catch {
-    return undefined
-  }
-}
-
 /** Return an owned state transition; reject volatile saves and unknown named restores. */
 export function reduceStateOperations({ nodes, head, checkpoints }, operations, nodeIndex) {
   const nextCheckpoints = new Map(checkpoints)
@@ -443,398 +635,6 @@ export function reduceStateOperations({ nodes, head, checkpoints }, operations,
   return { head: nextHead, checkpoints: nextCheckpoints, restored }
 }
 
-function applyOperations(state, operations, nodeIndex) {
-  const transition = reduceStateOperations(state, operations, nodeIndex)
-  state.head = transition.head
-  state.checkpoints = transition.checkpoints
-  if (transition.restored) {
-    state.trusted = true
-    state.volatileSuffix.length = 0
-  }
-}
-
-function applyRecord(state, record, invalidCallSeqs) {
-  const { call, code, result } = record
-  if (invalidCallSeqs.has(call.seq)) return
-  if (code === undefined || result?.journal === undefined) {
-    state.trusted = false
-    state.volatileSuffix.push({ seq: call.seq, code, reason: result?.error ?? 'missing dsh-ptc-plus journal result' })
-    return
-  }
-  const journal = result.journal
-  if (journal.status === 'noop') return
-  if (journal.status === 'discarded') {
-    if (journal.volatileReason !== undefined) {
-      state.trusted = false
-      state.volatileSuffix.push({ seq: call.seq, code, reason: journal.volatileReason })
-    }
-    return
-  }
-  if (journal.status === 'volatile') {
-    state.trusted = false
-    state.volatileSuffix.push({ seq: call.seq, code, reason: journal.volatileReason ?? 'volatile cell' })
-    applyOperations(state, journal.operations, undefined)
-    return
-  }
-  if (!state.trusted) {
-    state.trusted = true
-    state.volatileSuffix.length = 0
-  }
-  const node = Object.freeze({
-    code,
-    journal,
-    callSeq: call.seq,
-    parent: state.head,
-  })
-  const index = state.nodes.push(node) - 1
-  state.head = index
-  applyOperations(state, journal.operations, index)
-}
-
-function forceRecoveryHead(state, boundary) {
-  state.head = boundary.frontierCallSeq === null
-    ? undefined
-    : state.nodes.findIndex(node => node.callSeq === boundary.frontierCallSeq)
-  if (state.head === -1) throw new Error('recovery boundary frontier is not reconstructable')
-  state.trusted = true
-  state.volatileSuffix = []
-}
-
-function recordEventSeq(record) {
-  return record.result?.eventSeq ?? record.call.seq
-}
-
-function foldRecords(records, invalidCallSeqs, boundaries = []) {
-  const state = {
-    nodes: [],
-    head: undefined,
-    checkpoints: new Map(),
-    volatileSuffix: [],
-    trusted: true,
-  }
-  let boundaryIndex = 0
-  for (const record of records) {
-    while (boundaryIndex < boundaries.length && boundaries[boundaryIndex].eventSeq < recordEventSeq(record)) {
-      forceRecoveryHead(state, boundaries[boundaryIndex++])
-    }
-    applyRecord(state, record, invalidCallSeqs)
-  }
-  while (boundaryIndex < boundaries.length) forceRecoveryHead(state, boundaries[boundaryIndex++])
-  return state
-}
-
-function dependsOn(nodes, index, ancestor) {
-  for (let cursor = index; cursor !== undefined; cursor = nodes[cursor]?.parent) {
-    if (cursor === ancestor) return true
-  }
-  return false
-}
-
-function timelineRun(call, result, eventIndex, journal) {
-  let args
-  try {
-    const parsed = JSON.parse(call.data.arguments)
-    if (isRecord(parsed)) args = Object.freeze(parsed)
-  } catch {
-    // Invalid persisted arguments cannot support derived source facts.
-  }
-  return Object.freeze({
-    index: eventIndex,
-    callSeq: Number.isSafeInteger(call.seq) ? call.seq : undefined,
-    args,
-    source: typeof args?.code === 'string' ? args.code : undefined,
-    journal,
-    rewrites: validatedRewrites(result.data?.meta),
-  })
-}
-
-function timelineDerivedRun(call, result, eventIndex, derived) {
-  return Object.freeze({
-    index: eventIndex,
-    callSeq: Number.isSafeInteger(call.seq) ? call.seq : undefined,
-    args: Object.freeze({ description: derived.description }),
-    source: derived.code,
-    journal: derived.journal,
-    rewrites: validatedRewrites(result.data?.meta),
-  })
-}
-
-function successfulTimelineRun(run) {
-  return run.journal?.completion?.kind === 'return' && run.journal.status !== 'noop'
-}
-
-/**
- * Fold persisted tool events once into the call/result and edit-target timeline
- * shared by prompt projection and cold journal recovery.
- */
-export function foldSessionTimeline(events) {
-  const empty = {
-    openTurn: false,
-    executableCalls: new Map(),
-    calls: [],
-    results: new Map(),
-    boundaries: [],
-    found: false,
-    unavailableResultSeq: undefined,
-    lastSuccessfulRunIndex: undefined,
-    latestRun: undefined,
-    editableRun: undefined,
-    editTargets: new Map(),
-  }
-  if (!Array.isArray(events)) return empty
-
-  const state = { ...empty }
-  const pendingByCallId = new Map()
-  const seenCallIds = new Set()
-  const claimedEditTargets = new Set()
-  const editClaims = new Map()
-  const journalResultSeqs = new Set()
-  let scope = 0
-
-  const resetTurn = (openTurn) => {
-    state.openTurn = openTurn
-    scope += 1
-    pendingByCallId.clear()
-    seenCallIds.clear()
-    claimedEditTargets.clear()
-    state.latestRun = undefined
-    state.editableRun = undefined
-  }
-
-  for (let eventIndex = 0; eventIndex < events.length; eventIndex += 1) {
-    const event = events[eventIndex]
-    if (event?.type === 'turn/start') {
-      resetTurn(true)
-      continue
-    }
-    if (event?.type === 'turn/end') {
-      resetTurn(false)
-      continue
-    }
-    if (event?.type === RECOVERY_BOUNDARY_EVENT) {
-      throw new Error('legacy recovery boundary requires migration before DSH session restore')
-      continue
-    }
-    if (event?.type === 'tool/call' && typeof event.data?.callId === 'string') {
-      const executable = event.data.name === 'run_code' || event.data.name === 'edit_run_code'
-      let entry = { event, eventIndex, scope }
-      if (executable) {
-        if (Number.isSafeInteger(event.seq) && event.seq >= 0 && state.executableCalls.has(event.seq)) {
-          throw new Error('session log contains a duplicate run_code call sequence')
-        }
-        if (event.data.name === 'edit_run_code') {
-          const targetCallSeq = state.editableRun?.callSeq
-          const target = targetCallSeq !== undefined && state.editableRun.source !== undefined
-            && !claimedEditTargets.has(targetCallSeq)
-            ? Object.freeze({ source: state.editableRun.source, callSeq: targetCallSeq })
-            : undefined
-          entry = { ...entry, editTarget: target }
-          state.editTargets.set(event.seq, target)
-          if (target !== undefined) {
-            claimedEditTargets.add(target.callSeq)
-            editClaims.set(event.seq, target.callSeq)
-          }
-        }
-        state.calls.push(event)
-        if (Number.isSafeInteger(event.seq) && event.seq >= 0) {
-          state.executableCalls.set(event.seq, entry)
-        }
-      }
-      if (seenCallIds.has(event.data.callId)) pendingByCallId.set(event.data.callId, null)
-      else {
-        seenCallIds.add(event.data.callId)
-        pendingByCallId.set(event.data.callId, entry)
-      }
-      continue
-    }
-    if (event?.type !== 'tool/result') continue
-
-    const sourceSeq = event.sourceEventSeqs?.[0]
-    const callId = event.data?.message?.source?.callId
-    let entry = Number.isSafeInteger(sourceSeq) ? state.executableCalls.get(sourceSeq) : undefined
-    if (entry === undefined && !Number.isSafeInteger(sourceSeq) && typeof callId === 'string') {
-      entry = pendingByCallId.get(callId)
-    }
-    if (typeof callId === 'string') pendingByCallId.delete(callId)
-    if (entry === null) {
-      state.latestRun = undefined
-      state.editableRun = undefined
-      continue
-    }
-
-    const call = entry?.event
-    const callSeq = call?.seq
-    const meta = event.data?.meta
-    let normalized
-    if (isRecord(meta) && Object.hasOwn(meta, JOURNAL_KEY)) {
-      if (Number.isSafeInteger(sourceSeq) && journalResultSeqs.has(sourceSeq)) {
-        throw new Error(`session log contains duplicate PTC journal results for call seq ${sourceSeq}`)
-      }
-      if (Number.isSafeInteger(sourceSeq)) journalResultSeqs.add(sourceSeq)
-      if (entry === undefined) {
-        if (Number.isSafeInteger(sourceSeq)) state.unavailableResultSeq ??= sourceSeq
-        continue
-      }
-      const resultSeq = Number.isSafeInteger(sourceSeq) ? sourceSeq : callSeq
-      const raw = {
-        meta,
-        eventSeq: Number.isSafeInteger(event.seq) && event.seq >= 0 ? event.seq : resultSeq,
-        eventIndex,
-      }
-      if (Object.hasOwn(meta, RECOVERY_BOUNDARY_KEY)) {
-        state.boundaries.push(...normalizeRecoveryBoundaries(
-          meta[RECOVERY_BOUNDARY_KEY], raw.eventSeq,
-        ))
-      }
-      try {
-        if (call.data.name === 'edit_run_code') {
-          const derived = normalizeDerivedEditResult(meta, entry.editTarget?.callSeq)
-          normalized = { ...raw, journal: derived.journal, derived }
-        } else if (call.data.name === 'run_code') {
-          const rawJournal = meta[JOURNAL_KEY]
-          const resolveLegacyConfirm = rawJournal?.version === LEGACY_JOURNAL_VERSION
-            ? legacyCallId => {
-              const candidates = [...state.executableCalls.values()]
-                .filter(candidate => candidate.eventIndex < eventIndex
-                  && candidate.event.data?.name === 'run_code'
-                  && candidate.event.data.callId === legacyCallId
-                  && !state.results.has(candidate.event.seq))
-              return candidates.length === 1 ? candidates[0].event.seq : undefined
-            }
-            : undefined
-          normalized = { ...raw, journal: normalizeJournal(rawJournal, { resolveLegacyConfirm }) }
-        }
-      } catch (error) {
-        normalized = { ...raw, error: error.message }
-      }
-      if (Number.isSafeInteger(resultSeq)) state.results.set(resultSeq, normalized)
-      state.found = true
-    }
-
-    const claimedTarget = editClaims.get(callSeq)
-    if (claimedTarget !== undefined) {
-      editClaims.delete(callSeq)
-      if (normalized?.derived === undefined) claimedEditTargets.delete(claimedTarget)
-    }
-    if (entry === undefined || entry.scope !== scope) continue
-    if (call.data.name === 'edit_run_code') {
-      if (normalized?.derived !== undefined) {
-        const run = timelineDerivedRun(call, event, eventIndex, normalized.derived)
-        state.latestRun = run
-        state.editableRun = run
-        if (successfulTimelineRun(run)) state.lastSuccessfulRunIndex = eventIndex
-      }
-      continue
-    }
-    if (call.data.name !== 'run_code') {
-      // Unrelated native settlements do not change the current editable cell.
-      // The edit target is captured at dispatch time and remains valid until a
-      // new executable cell or turn boundary supersedes it.
-      continue
-    }
-    const run = timelineRun(call, event, eventIndex, normalized?.journal)
-    state.latestRun = run
-    state.editableRun = run
-    if (successfulTimelineRun(run)) state.lastSuccessfulRunIndex = eventIndex
-  }
-  return state
-}
-
-/** Fold the session log into the last exactly replayable frontier. */
-export function recoverJournal(session, currentCallSeq, options = {}) {
-  const events = sessionEvents(session)
-  if (!Array.isArray(events)) {
-    return { nodes: [], head: undefined, checkpoints: new Map(), volatileSuffix: [], available: true }
-  }
-  const timeline = foldSessionTimeline(events)
-  const calls = timeline.calls.filter(call => call.seq !== currentCallSeq)
-  const { executableCalls, results, found } = timeline
-  const extraBoundaries = options?.extraBoundaries ?? []
-  const boundaries = [
-    ...timeline.boundaries,
-    ...normalizeRecoveryBoundaries(extraBoundaries, undefined).map(boundary => ({
-      ...boundary,
-      eventSeq: Number.POSITIVE_INFINITY,
-    })),
-  ].sort((left, right) => left.eventSeq - right.eventSeq)
-  if (timeline.unavailableResultSeq !== undefined) {
-    throw new Error(`PTC journal result references unavailable run_code call seq ${timeline.unavailableResultSeq}`)
-  }
-
-  const confirmedNoops = new Set()
-  for (const { journal, eventIndex } of results.values()) {
-    for (const callSeq of journal?.confirms ?? []) {
-      const confirmed = executableCalls.get(callSeq)
-      if (confirmed === undefined || confirmed.eventIndex >= eventIndex || results.has(callSeq)) {
-        throw new Error(`confirmed no-op does not identify an earlier unjournaled run_code call seq ${callSeq}`)
-      }
-      confirmedNoops.add(callSeq)
-    }
-  }
-  const records = []
-  const orderedRecords = []
-  const invalidCallSeqs = new Set()
-  const appliedBoundaries = []
-  let state = foldRecords(records, invalidCallSeqs)
-  let boundaryIndex = 0
-  const applyBoundariesBefore = (seq) => {
-    while (boundaryIndex < boundaries.length && boundaries[boundaryIndex].eventSeq <= seq) {
-      const boundary = boundaries[boundaryIndex++]
-      const failedIndex = state.nodes.findIndex(node => node.callSeq === boundary.failedCallSeq)
-      if (failedIndex < 0) throw new Error('recovery boundary references an unavailable failed cell')
-      const expectedFrontier = state.nodes[failedIndex].parent
-      const frontierIndex = boundary.frontierCallSeq === null
-        ? undefined
-        : state.nodes.findIndex(node => node.callSeq === boundary.frontierCallSeq)
-      if (frontierIndex !== expectedFrontier) {
-        throw new Error('recovery boundary does not identify the failed cell parent')
-      }
-      for (let index = 0; index < state.nodes.length; index += 1) {
-        if (dependsOn(state.nodes, index, failedIndex)) invalidCallSeqs.add(state.nodes[index].callSeq)
-      }
-      appliedBoundaries.push(boundary)
-      state = foldRecords(records, invalidCallSeqs, appliedBoundaries)
-    }
-  }
-  for (const call of calls) {
-    const result = results.get(call.seq)
-    const code = call.data?.name === 'edit_run_code' ? result?.derived?.code : sourceForRunCall(call)
-    const record = { call, code, result }
-    if (call.data?.name === 'edit_run_code' && record.code === undefined && result === undefined) continue
-    if (result?.journal === undefined && confirmedNoops.has(call.seq)) continue
-    orderedRecords.push(record)
-  }
-  orderedRecords.sort((left, right) => (
-    recordEventSeq(left) - recordEventSeq(right) || left.call.seq - right.call.seq
-  ))
-  for (const record of orderedRecords) {
-    applyBoundariesBefore(recordEventSeq(record))
-    records.push(record)
-    applyRecord(state, record, invalidCallSeqs)
-  }
-  applyBoundariesBefore(Number.POSITIVE_INFINITY)
-  return {
-    nodes: state.nodes,
-    head: state.head,
-    checkpoints: state.checkpoints,
-    volatileSuffix: state.volatileSuffix,
-    available: found,
-  }
-}
-
-/** Return source nodes from the empty state to a selected durable head. */
-export function pathToHead(state) {
-  const path = []
-  for (let cursor = state.head; cursor !== undefined;) {
-    const node = state.nodes[cursor]
-    if (node === undefined) throw new Error('invalid dsh-ptc-plus journal head')
-    path.push(node)
-    cursor = node.parent
-  }
-  path.reverse()
-  return path
-}
-
 /** Merge the journal into the tool result's private metadata. */
 export function withJournal(meta, journal) {
   const base = isRecord(meta) ? { ...meta } : meta === undefined ? {} : { value: cloneJson(meta) }
@@ -842,9 +642,6 @@ export function withJournal(meta, journal) {
   return base
 }
 
-const REWRITE_FIELDS = new Set(['kind', 'description', 'source'])
-const REWRITE_KINDS = new Set(['import', 'redeclaration', 'export'])
-
 /** Validate and detach one rewrite record emitted by the runtime. */
 export function normalizeRewrites(value) {
   if (!Array.isArray(value)) throw new Error('invalid dsh-ptc-plus rewrites')