dsh-ptc-plus 0.4.8 → 0.5.0

package/internal/session-journal-schema.js

@@ -8,13 +8,15 @@ import {
 export const JOURNAL_KEY = 'dshPtcPlus'
 export const EDIT_TARGET_KEY = 'dshPtcPlusEdit'
 export const DERIVED_RUN_KEY = 'dshPtcPlusDerivedRun'
+export const POST_EDIT_KEY = 'dshPtcPlusPostEdit'
 export const REWRITES_KEY = 'dshPtcPlusRewrites'
 export const RECOVERY_BOUNDARY_KEY = 'dshPtcPlusRecoveryBoundaries'
 export const IMPORT_BOUNDARY_JOURNAL_VERSION = 7
 export const PER_NAME_USER_BINDINGS_JOURNAL_VERSION = 8
 export const LANGUAGE_SEMANTICS_JOURNAL_VERSION = 9
 export const MODULE_TRANSFORM_JOURNAL_VERSION = 10
-export const JOURNAL_VERSION = MODULE_TRANSFORM_JOURNAL_VERSION
+export const EXECUTION_DIRECTORY_JOURNAL_VERSION = 11
+export const JOURNAL_VERSION = EXECUTION_DIRECTORY_JOURNAL_VERSION
 export const LIVE_USER_BINDINGS_SHADOW_POLICY = 'per-name'
 export const LEGACY_USER_BINDINGS_SHADOW_POLICY = 'whole-entry'
 export const LIVE_USER_BINDINGS_REUSE_POLICY = 'implementation-v1'
@@ -32,7 +34,8 @@ export const BINDING_MODES = new Set(['loose', 'strict'])
 export const WHOLE_ENTRY_JOURNAL_FIELDS = new Set(['version', 'bindingPolicy', 'rewritePolicy', 'moduleSemantics', 'userBindingsFingerprint', 'userBindingsReusePolicy', 'status', 'calls', 'operations', 'confirms', 'diagnostics', 'completion', 'volatileReason'])
 export const PER_NAME_JOURNAL_FIELDS = new Set([...WHOLE_ENTRY_JOURNAL_FIELDS, 'userBindingsShadowPolicy', 'userBindingNames'])
 export const LANGUAGE_SEMANTICS_JOURNAL_FIELDS = new Set([...PER_NAME_JOURNAL_FIELDS, 'languageSemantics'])
-export const JOURNAL_FIELDS = new Set([...LANGUAGE_SEMANTICS_JOURNAL_FIELDS, 'moduleTransform'])
+export const MODULE_TRANSFORM_JOURNAL_FIELDS = new Set([...LANGUAGE_SEMANTICS_JOURNAL_FIELDS, 'moduleTransform'])
+export const JOURNAL_FIELDS = new Set([...MODULE_TRANSFORM_JOURNAL_FIELDS, 'executionCwd'])
 export const FINGERPRINT_REUSE_JOURNAL_FIELDS = new Set([...WHOLE_ENTRY_JOURNAL_FIELDS].filter(field => field !== 'userBindingsReusePolicy'))
 export const RELATIONLESS_JOURNAL_FIELDS = new Set([...FINGERPRINT_REUSE_JOURNAL_FIELDS].filter(field => field !== 'userBindingsFingerprint'))
 export const PREDECESSOR_JOURNAL_FIELDS = new Set(['version', 'bindingMode', 'rewritePolicy', 'status', 'calls', 'operations', 'confirms', 'diagnostics', 'completion', 'volatileReason'])
@@ -58,7 +61,7 @@ export const ERROR_FIELDS = new Set(['kind', 'message'])
 export const EDIT_TARGET_FIELDS = new Set(['targetCallSeq'])
 export const DERIVED_RUN_FIELDS = new Set(['code', 'description'])
 
-export const JOURNAL_VERSIONS = new Set([LEGACY_JOURNAL_VERSION, INTERMEDIATE_JOURNAL_VERSION, PREVIOUS_JOURNAL_VERSION, USER_BINDING_RELATIONLESS_JOURNAL_VERSION, FINGERPRINT_REUSE_JOURNAL_VERSION, VERSIONED_BINDING_REUSE_JOURNAL_VERSION, IMPORT_BOUNDARY_JOURNAL_VERSION, PER_NAME_USER_BINDINGS_JOURNAL_VERSION, LANGUAGE_SEMANTICS_JOURNAL_VERSION, JOURNAL_VERSION])
+export const JOURNAL_VERSIONS = new Set([LEGACY_JOURNAL_VERSION, INTERMEDIATE_JOURNAL_VERSION, PREVIOUS_JOURNAL_VERSION, USER_BINDING_RELATIONLESS_JOURNAL_VERSION, FINGERPRINT_REUSE_JOURNAL_VERSION, VERSIONED_BINDING_REUSE_JOURNAL_VERSION, IMPORT_BOUNDARY_JOURNAL_VERSION, PER_NAME_USER_BINDINGS_JOURNAL_VERSION, LANGUAGE_SEMANTICS_JOURNAL_VERSION, MODULE_TRANSFORM_JOURNAL_VERSION, JOURNAL_VERSION])
 export const USER_BINDINGS_REUSE_POLICIES = new Set([LEGACY_USER_BINDINGS_REUSE_POLICY, LIVE_USER_BINDINGS_REUSE_POLICY])
 export const USER_BINDINGS_SHADOW_POLICIES = new Set([LEGACY_USER_BINDINGS_SHADOW_POLICY, LIVE_USER_BINDINGS_SHADOW_POLICY])
 const USER_BINDING_NAME_STATES = new Set(['provider', 'local', 'absent', 'unknown'])

package/internal/session-journal.js

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from 'node:util'
+import { posix, win32 } from 'node:path'
 import { decodeValue, encodeValue, normalizeValueWire } from './value-wire.js'
 import { normalizeDiagnostic } from './diagnostic.js'
 import { assertOwnFields, isRecord } from './record-utils.js'
@@ -19,6 +20,8 @@ import {
   REWRITES_KEY,
   RECOVERY_BOUNDARY_KEY,
   JOURNAL_VERSION,
+  MODULE_TRANSFORM_JOURNAL_VERSION,
+  MODULE_TRANSFORM_JOURNAL_FIELDS,
   LANGUAGE_SEMANTICS_JOURNAL_VERSION,
   LANGUAGE_SEMANTICS_JOURNAL_FIELDS,
   IMPORT_BOUNDARY_JOURNAL_VERSION,
@@ -262,6 +265,10 @@ function normalizeUserBindingsFingerprint(value) {
 
 function migrateJournal(value, resolveLegacyConfirm) {
   if (value.version === JOURNAL_VERSION) return value
+  if (value.version === MODULE_TRANSFORM_JOURNAL_VERSION) {
+    assertOwnFields(value, MODULE_TRANSFORM_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    return { ...value, version: JOURNAL_VERSION, executionCwd: null }
+  }
   if (value.version === LANGUAGE_SEMANTICS_JOURNAL_VERSION) {
     assertOwnFields(value, LANGUAGE_SEMANTICS_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
     const languageSemantics = normalizeLanguageSemantics(value.languageSemantics)
@@ -332,6 +339,24 @@ function migrateJournal(value, resolveLegacyConfirm) {
   }
 }
 
+/**
+ * A recorded execution directory belongs to the execution world that produced
+ * the journal, not to the platform reading it. Judge both absolute spellings so
+ * a Windows Host journal stays valid evidence inside a POSIX audit checkout
+ * (and the reverse), and never rewrite the recorded bytes.
+ */
+function isRecordedExecutionDirectory(value) {
+  return typeof value === 'string' && value.length > 0
+    && (posix.isAbsolute(value) || win32.isAbsolute(value))
+}
+
+function normalizeExecutionCwd(value) {
+  if (value !== null && !isRecordedExecutionDirectory(value)) {
+    throw new Error('invalid dsh-ptc-plus journal execution directory')
+  }
+  return value
+}
+
 /** 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')
@@ -339,10 +364,12 @@ export function normalizeJournal(value, options = {}) {
     || !STATUSES.has(value.status)) {
     throw new Error('invalid dsh-ptc-plus journal')
   }
-  const migrated = migrateJournal(value, options.resolveLegacyConfirm)
+  const migrated = { ...migrateJournal(value, options.resolveLegacyConfirm),
+    ...(value.version < JOURNAL_VERSION ? { executionCwd: null } : {}) }
   assertOwnFields(migrated, JOURNAL_FIELDS, 'dsh-ptc-plus journal')
   const languageSemantics = normalizeLanguageSemantics(migrated.languageSemantics)
   const moduleTransform = normalizeModuleTransform(migrated.moduleTransform, languageSemantics)
+  const executionCwd = normalizeExecutionCwd(migrated.executionCwd)
   const bindingPolicy = normalizeBindingPolicy(migrated.bindingPolicy)
   const rewritePolicy = normalizeRewritePolicy(migrated.rewritePolicy)
   const moduleSemantics = normalizeModuleSemantics(migrated.moduleSemantics)
@@ -374,6 +401,7 @@ export function normalizeJournal(value, options = {}) {
     version: JOURNAL_VERSION,
     languageSemantics,
     moduleTransform,
+    executionCwd,
     bindingPolicy,
     rewritePolicy,
     moduleSemantics,
@@ -1022,7 +1050,7 @@ export function liveToolCallSeq(session, callId, toolName) {
 
 /** Start a mutable journal for one live cell. */
 export function createJournal(confirms = [], bindingPolicy, rewritePolicy, languageSemantics = LEGACY_LANGUAGE_SEMANTICS,
-  moduleTransform = moduleTransformForLanguage(languageSemantics)) {
+  moduleTransform = moduleTransformForLanguage(languageSemantics), executionCwd = null) {
   if (typeof bindingPolicy === 'string') {
     if (!BINDING_MODES.has(bindingPolicy)) throw new TypeError('invalid dsh-ptc-plus journal binding mode')
     bindingPolicy = {
@@ -1035,6 +1063,7 @@ export function createJournal(confirms = [], bindingPolicy, rewritePolicy, langu
     version: JOURNAL_VERSION,
     languageSemantics,
     moduleTransform: normalizeModuleTransform(moduleTransform, languageSemantics),
+    executionCwd: normalizeExecutionCwd(executionCwd),
     bindingPolicy: normalizeBindingPolicy(bindingPolicy),
     rewritePolicy: normalizeRewritePolicy(rewritePolicy),
     moduleSemantics: normalizeModuleSemantics(LIVE_MODULE_SEMANTICS),

package/internal/session-log-view.js

@@ -1,9 +1,12 @@
 import {
-  foldSessionTimeline,
+  advanceSessionTimeline, createSessionTimelineState, replaySessionTimelineFact, validateSessionTimelineState,
 } from './session-journal-recovery.js'
 import { isCanonicalSequence } from './session-journal.js'
-import { sessionEvents } from './session-events.js'
+import { advanceSessionSurface, readSessionLog, sessionEvents } from './session-events.js'
 import { readRuntimeMessage } from './runtime-messages.js'
+import { deepEqualJson, isJsonValue } from '@deepseek-ai/dsh-util-values'
+import { deepFreeze, isRecord } from './record-utils.js'
+import { advanceRuntimeHistory, createRuntimeHistory } from './recovery-tips.js'
 
 import { isHostRuntimeContextSource } from './message-sources.js'
 const SYSTEM_PROMPT_CLEARED = 'Current runtime context: none. Earlier runtime-context snapshots no longer apply.'
@@ -35,30 +38,185 @@ function isContextStep(event) {
     || (event?.type === 'user/message' && event.data?.source?.kind === 'user')
 }
 
-function cordisTranscriptFacts(timeline) {
-  let calls = 0
-  let inspections = 0
-  for (const result of timeline.results.values()) {
-    for (const call of result?.journal?.calls ?? []) {
-      if (call.global !== 'tools' || typeof call.member !== 'string'
-        || !call.member.startsWith('cordis_')) continue
-      calls += 1
-      if (call.ok === true && call.member.startsWith('cordis_inspect')) inspections += 1
+export const SESSION_LOG_PROJECTION_KEY = 'ptcPlusSessionLog'
+
+function emptyLogState() {
+  return { timeline: createSessionTimelineState(), contextStep: 0,
+    runtimeHistory: createRuntimeHistory(), visibleRuntimeFacts: {},
+    systemPromptSnapshots: [], ptcMessages: [], runtimeMessagesBySeq: {}, visibleRuntimeMessages: [], surfaceNodes: [], logFacts: [] }
+}
+
+export function runtimeMessageFacts(records, initial = {}) {
+  const facts = { ...initial }
+  for (const record of records) {
+    if (record.producer === 'aggregate') facts.aggregate = record
+    else if (record.form === 'snapshot') facts.snapshot = record
+    else if (record.form === 'catalog') facts.catalog = record
+  }
+  return facts
+}
+
+function presentationEvent(event) {
+  const recognized = event?.type === 'user/message'
+    && (systemPromptSnapshotSections(event.data) !== undefined || readRuntimeMessage(event.data) !== undefined)
+  const data = recognized ? { source: event.data.source, content: event.data.content }
+    : event?.type === 'user/message' && typeof event.data?.source?.kind === 'string'
+      ? { source: { kind: event.data.source.kind } } : undefined
+  return JSON.parse(JSON.stringify({ seq: event.seq, type: event.type,
+    ...(data === undefined ? {} : { data }),
+    ...(event.surfaceOp === undefined ? {} : { surfaceOp: event.surfaceOp }),
+  }))
+}
+
+function applyLogEvent(state, event, index = event?.seq,
+  timeline = advanceSessionTimeline(state.timeline, event, index)) {
+  const sections = event?.type === 'user/message' ? systemPromptSnapshotSections(event.data) : undefined
+  const ptc = event?.type === 'user/message' ? readRuntimeMessage(event.data) : undefined
+  const contextStep = state.contextStep + (isContextStep(event) ? 1 : 0)
+  const surfaceNodes = advanceSessionSurface(state.surfaceNodes, event)
+  let visibleRuntimeMessages = state.visibleRuntimeMessages
+  if (timeline === state.timeline && sections === undefined && ptc === undefined && contextStep === state.contextStep
+    && surfaceNodes === state.surfaceNodes) return state
+  const next = { ...state, timeline, contextStep,
+    logFacts: [...state.logFacts, deepFreeze({ index, event: presentationEvent(event) })],
+  }
+  next.runtimeHistory = advanceRuntimeHistory(state.runtimeHistory, {
+    sections, notice: ptc?.form === 'notice' ? ptc.name : undefined,
+    snapshot: ptc?.form === 'snapshot', catalog: ptc?.form === 'catalog',
+    index, contextStep: state.contextStep, lastSuccessfulRunIndex: timeline.lastSuccessfulRunIndex,
+    resetSuccess: timeline.lastSuccessfulRunIndex !== state.timeline.lastSuccessfulRunIndex,
+  })
+  if (sections !== undefined) {
+    const snapshot = Object.freeze({ index, contextStep: state.contextStep, sections })
+    next.systemPromptSnapshots = [...state.systemPromptSnapshots, snapshot]
+    next.runtimeMessagesBySeq = { ...state.runtimeMessagesBySeq,
+      [`k${event.seq}`]: Object.freeze({ ...snapshot, producer: 'aggregate', form: 'snapshot' }) }
+  }
+  if (ptc !== undefined) {
+    const record = Object.freeze({ ...ptc, index, contextStep: state.contextStep, producer: 'ptc-plus' })
+    next.ptcMessages = [...state.ptcMessages, record]
+    next.runtimeMessagesBySeq = { ...next.runtimeMessagesBySeq, [`k${event.seq}`]: record }
+  }
+  if (event?.surfaceOp === 'append') {
+    const record = next.runtimeMessagesBySeq[`k${event.seq}`]
+    if (record !== undefined) {
+      visibleRuntimeMessages = [...visibleRuntimeMessages, record]
+      next.visibleRuntimeFacts = runtimeMessageFacts([record], state.visibleRuntimeFacts)
     }
+  } else if (surfaceNodes !== state.surfaceNodes) {
+    visibleRuntimeMessages = surfaceNodes.flatMap(seq => {
+      const record = next.runtimeMessagesBySeq[`k${seq}`]
+      return record === undefined ? [] : [record]
+    })
+    next.visibleRuntimeFacts = runtimeMessageFacts(visibleRuntimeMessages)
   }
-  return Object.freeze({ calls, inspections })
+  next.surfaceNodes = surfaceNodes
+  next.visibleRuntimeMessages = Object.freeze(visibleRuntimeMessages)
+  return next
+}
+
+export function createSessionLogProjection() {
+  return Object.freeze({
+    key: SESSION_LOG_PROJECTION_KEY,
+    stateVersion: 9,
+    stateSchema: Object.freeze({ parse(value) {
+      if (!isJsonValue(value) || !isRecord(value) || !isRecord(value.timeline)
+        || typeof value.timeline.openTurn !== 'boolean' || typeof value.timeline.found !== 'boolean'
+        || !Number.isSafeInteger(value.timeline.scope) || value.timeline.scope < 0
+        || !Number.isSafeInteger(value.contextStep) || value.contextStep < 0
+        || !Array.isArray(value.systemPromptSnapshots) || !Array.isArray(value.ptcMessages)
+        || !Array.isArray(value.visibleRuntimeMessages)
+        || !isRecord(value.runtimeHistory) || !isRecord(value.runtimeHistory.tips)
+        || !isRecord(value.runtimeHistory.seenNames) || !isRecord(value.visibleRuntimeFacts)
+        || !Array.isArray(value.surfaceNodes) || !value.surfaceNodes.every(isCanonicalSequence)
+        || new Set(value.surfaceNodes).size !== value.surfaceNodes.length
+        || !Array.isArray(value.timeline.calls) || !Array.isArray(value.timeline.boundaries)
+        || !isRecord(value.runtimeMessagesBySeq) || !isRecord(value.timeline.cordisTranscript)) {
+        throw new TypeError('invalid PTC session-log projection checkpoint')
+      }
+      validateSessionTimelineState(value.timeline)
+      if (!Array.isArray(value.logFacts)) throw new TypeError('invalid PTC session-log projection checkpoint facts')
+      const timelineFacts = new Map(value.timeline.eventFacts.map(fact => [fact.eventIndex, fact]))
+      let reconstructed = emptyLogState()
+      let lastIndex = -1
+      let timelineCount = 0
+      for (const fact of value.logFacts) {
+        if (!isRecord(fact) || Object.keys(fact).some(key => !['index', 'event'].includes(key))
+          || !isCanonicalSequence(fact.index) || fact.index <= lastIndex
+          || !isRecord(fact.event) || !isCanonicalSequence(fact.event.seq) || typeof fact.event.type !== 'string'
+          || !deepEqualJson(presentationEvent(fact.event), fact.event)) {
+          throw new TypeError('invalid PTC session-log projection checkpoint facts')
+        }
+        lastIndex = fact.index
+        const timelineFact = timelineFacts.get(fact.index)
+        if (timelineFact !== undefined) {
+          if (!deepEqualJson(presentationEvent(timelineFact.event), fact.event)) {
+            throw new TypeError('inconsistent PTC session-log projection checkpoint event identity')
+          }
+          timelineCount += 1
+        }
+        if (timelineFact === undefined
+          && advanceSessionTimeline(reconstructed.timeline, fact.event, fact.index) !== reconstructed.timeline) {
+          throw new TypeError('inconsistent PTC session-log projection checkpoint missing timeline facts')
+        }
+        const timeline = timelineFact === undefined ? reconstructed.timeline
+          : replaySessionTimelineFact(reconstructed.timeline, timelineFact)
+        reconstructed = applyLogEvent(reconstructed, fact.event, fact.index, timeline)
+      }
+      if (timelineCount !== timelineFacts.size || !deepEqualJson(reconstructed, value)) {
+        throw new TypeError('inconsistent PTC session-log projection checkpoint facts')
+      }
+      return deepFreeze(value)
+    } }),
+    init: emptyLogState,
+    apply: applyLogEvent,
+  })
+}
+
+export function createSessionLogOwner(ctx) {
+  const projection = createSessionLogProjection()
+  let registeredService
+  const injection = ctx.inject(['sessionProjections'], scope => {
+    try {
+      scope.effect(() => {
+        const registry = scope.sessionProjections
+        const unregister = registry.register(projection)
+        if (typeof unregister !== 'function') throw new Error('ptc-plus: sessionProjections.register did not return a disposer')
+        registeredService = registry
+        return async () => {
+          await unregister()
+          if (registeredService === registry) registeredService = undefined
+        }
+      }, 'ptc-plus host-only session-log projection')
+    } catch (error) {
+      ctx.logger?.warn?.('ptc-plus: session-log projection unavailable', error)
+    }
+  })
+  ctx.effect(() => () => typeof injection === 'function' ? injection() : injection?.dispose?.(),
+    'ptc-plus session-log projection injection lifecycle')
+  const service = name => typeof ctx.get === 'function' ? ctx.get(name) : ctx[name]
+  return Object.freeze({
+    read: (session, signal) => readSessionLog(session, service('sessionQuery'), signal),
+    project(agent, requestedEdit) {
+      if (Array.isArray(agent?.session?.events)) return projectSessionLog(agent, requestedEdit)
+      const registry = registeredService ?? service('sessionProjections')
+      const state = agent?.session === undefined ? undefined : registry?.stateOf?.(agent.session, SESSION_LOG_PROJECTION_KEY)
+      return projectSessionLog(agent, requestedEdit, state)
+    },
+  })
 }
 
 /** Project session events into immutable facts consumed by prompt presentation. */
-export function projectSessionLog(agent, requestedEdit) {
-  const events = sessionEvents(agent?.session)
-  if (!Array.isArray(events)) {
+export function projectSessionLog(agent, requestedEdit, projectedState) {
+  const events = projectedState === undefined ? sessionEvents(agent?.session) : undefined
+  if (projectedState === undefined && !Array.isArray(events)) {
     return Object.freeze({
       openTurn: false,
       contextStep: 0,
       systemPromptSnapshots: Object.freeze([]),
       ptcMessages: Object.freeze([]),
       visibleRuntimeMessages: undefined,
+      runtimeHistory: Object.freeze(createRuntimeHistory()),
       lastSuccessfulRunIndex: undefined,
       latestRun: undefined,
       editableRun: undefined,
@@ -66,45 +224,30 @@ export function projectSessionLog(agent, requestedEdit) {
       cordisTranscript: Object.freeze({ calls: 0, inspections: 0 }),
     })
   }
-  let contextStep = 0
-  const systemPromptSnapshots = []
-  const ptcMessages = []
-  const runtimeMessagesBySeq = new Map()
-  for (let index = 0; index < events.length; index += 1) {
-    const event = events[index]
-    const sections = event?.type === 'user/message' ? systemPromptSnapshotSections(event.data) : undefined
-    if (sections !== undefined) {
-      const snapshot = Object.freeze({ index, contextStep, sections })
-      systemPromptSnapshots.push(snapshot)
-      runtimeMessagesBySeq.set(event.seq, Object.freeze({ ...snapshot, producer: 'aggregate', form: 'snapshot' }))
-    }
-    const ptc = event?.type === 'user/message' ? readRuntimeMessage(event.data) : undefined
-    if (ptc !== undefined) {
-      const record = Object.freeze({ ...ptc, index, contextStep, producer: 'ptc-plus' })
-      ptcMessages.push(record)
-      runtimeMessagesBySeq.set(event.seq, record)
-    }
-    if (isContextStep(event)) contextStep += 1
+  let state = projectedState ?? emptyLogState()
+  if (projectedState === undefined) {
+    for (let index = 0; index < events.length; index += 1) state = applyLogEvent(state, events[index], index)
   }
-  const timeline = foldSessionTimeline(events)
+  const { timeline, contextStep, systemPromptSnapshots, ptcMessages, runtimeMessagesBySeq } = state
   const requestedEntry = requestedEdit === undefined
     ? undefined
-    : timeline.executableCalls.get(requestedEdit.callSeq)
+    : timeline.executableCalls[`k${requestedEdit.callSeq}`]?.[1]
   const requestedEditTarget = requestedEdit !== undefined
     && requestedEntry?.event.data?.callId === requestedEdit.callId
     && requestedEntry.event.data.name === 'edit_run_code'
-    ? timeline.editTargets.get(requestedEdit.callSeq)
+    ? timeline.editTargets[`k${requestedEdit.callSeq}`]?.[1] ?? undefined
     : undefined
   const latestRun = timeline.openTurn ? timeline.latestRun : undefined
   const editableRun = timeline.openTurn ? timeline.editableRun : undefined
-  const cordisTranscript = cordisTranscriptFacts(timeline)
-  let visibleRuntimeMessages
-  try {
+  const cordisTranscript = Object.freeze(timeline.cordisTranscript)
+  let visibleRuntimeMessages = projectedState === undefined ? undefined : state.visibleRuntimeMessages
+  if (projectedState === undefined) try {
     const nodes = agent?.session?.surface?.nodes
-    const knownSeqs = new Set(events.map(event => event?.seq))
-    if (Array.isArray(nodes) && nodes.every(seq => isCanonicalSequence(seq) && knownSeqs.has(seq))) {
+    const knownSeqs = events === undefined ? undefined : new Set(events.map(event => event?.seq))
+    if (Array.isArray(nodes) && nodes.every(seq => isCanonicalSequence(seq)
+      && (knownSeqs === undefined ? seq < agent.session.seq : knownSeqs.has(seq)))) {
       visibleRuntimeMessages = Object.freeze(nodes.flatMap(seq => {
-        const record = runtimeMessagesBySeq.get(seq)
+        const record = runtimeMessagesBySeq[`k${seq}`]
         return record === undefined ? [] : [record]
       }))
     }
@@ -115,6 +258,9 @@ export function projectSessionLog(agent, requestedEdit) {
     systemPromptSnapshots: Object.freeze(systemPromptSnapshots),
     ptcMessages: Object.freeze(ptcMessages),
     visibleRuntimeMessages,
+    visibleRuntimeFacts: projectedState === undefined && visibleRuntimeMessages !== undefined
+      ? runtimeMessageFacts(visibleRuntimeMessages) : state.visibleRuntimeFacts,
+    runtimeHistory: state.runtimeHistory,
     lastSuccessfulRunIndex: timeline.lastSuccessfulRunIndex,
     latestRun,
     editableRun,