dsh-ptc-plus 0.4.8 → 0.4.10

package/internal/recovery-tips.js

@@ -1,4 +1,4 @@
-import { recoveryTipIdentity } from './runtime-messages.js'
+import { PTC_STATE_NAMES, recoveryTipIdentity } from './runtime-messages.js'
 
 const PLATFORM_CAUSE_CODES = new Set(['EACCES', 'EINVAL', 'ENOTDIR', 'ENOENT', 'UNKNOWN'])
 const TIP_CONTEXT_PREFIX = 'tools:ptc-plus-tip/'
@@ -8,27 +8,58 @@ const TIP_PREFIXES = Object.freeze({
 })
 
 // TODO(dsh-tips-api): replace this local provider with an adapter after dsh-tips publishes a stable facts and decision interface.
-function tipHistory(view) {
-  const active = new Map()
-  const seen = new Set()
-  const history = []
+export function createRuntimeHistory() {
+  return { seenNames: {}, tips: {}, hadState: false, hadCatalog: false }
+}
+
+export function advanceRuntimeHistory(previous, { sections = [], notice, snapshot = false, catalog = false,
+  index, contextStep, lastSuccessfulRunIndex, resetSuccess = false }) {
+  let next = previous
+  const revise = () => {
+    if (next === previous) next = { ...previous, tips: { ...previous.tips }, seenNames: { ...previous.seenNames } }
+  }
+  if (resetSuccess) {
+    revise()
+    for (const [id, tip] of Object.entries(next.tips)) next.tips[id] = { ...tip, unresolved: 0 }
+    for (const [name, deliveredIndex] of Object.entries(next.seenNames)) {
+      const identity = recoveryTipIdentity(name)
+      if (deliveredIndex > (lastSuccessfulRunIndex ?? -1)) next.tips[identity.id].unresolved += 1
+    }
+  }
+  const hadState = snapshot || sections.some(section => PTC_STATE_NAMES.includes(section.name))
+  if ((hadState && !next.hadState) || (catalog && !next.hadCatalog)) {
+    revise()
+    next.hadState ||= hadState
+    next.hadCatalog ||= catalog
+  }
+  for (const name of [...sections.map(section => section.name), ...(notice === undefined ? [] : [notice])]) {
+    const identity = recoveryTipIdentity(name)
+    if (identity === undefined || Object.hasOwn(next.seenNames, name)) continue
+    revise()
+    next.seenNames[name] = index
+    const earlier = next.tips[identity.id]
+    next.tips[identity.id] = {
+      highestOrdinal: Math.max(earlier?.highestOrdinal ?? 0, identity.ordinal),
+      contextStep,
+      unresolved: (earlier?.unresolved ?? 0) + (index > (lastSuccessfulRunIndex ?? -1) ? 1 : 0),
+    }
+  }
+  return next
+}
+
+export function runtimeHistoryForView(view) {
+  if (view.runtimeHistory !== undefined) return view.runtimeHistory
+  let history = createRuntimeHistory()
+  history.hadState = view.ptcMessages?.some(record => record.form === 'snapshot') === true
+  history.hadCatalog = view.ptcMessages?.some(record => record.form === 'catalog') === true
   const snapshots = [
-    ...view.systemPromptSnapshots,
+    ...(view.systemPromptSnapshots ?? []),
     ...(view.ptcMessages ?? []).filter(record => record.form === 'notice').map(record => ({
       ...record, sections: [{ name: record.name, text: record.text }],
     })),
   ].sort((left, right) => left.index - right.index)
   for (const snapshot of snapshots) {
-    const next = new Map(snapshot.sections.map(section => [section.name, section.text]))
-    for (const [name] of next) {
-      if (active.has(name) || seen.has(name)) continue
-      const identity = recoveryTipIdentity(name)
-      if (identity === undefined) continue
-      seen.add(name)
-      history.push({ ...identity, index: snapshot.index, contextStep: snapshot.contextStep })
-    }
-    active.clear()
-    for (const entry of next) active.set(...entry)
+    history = advanceRuntimeHistory(history, { ...snapshot, lastSuccessfulRunIndex: view.lastSuccessfulRunIndex })
   }
   return history
 }
@@ -79,14 +110,12 @@ export function latestRecoveryTip(view, config) {
   if (candidate === undefined) return undefined
   // Cooldown, escalation, and ordinal are per trigger kind: one kind's tip must
   // not suppress a different kind.
-  const matching = tipHistory(view).filter(item => item.id === candidate.id)
-  const lastTip = matching.at(-1)
+  const lastTip = runtimeHistoryForView(view).tips[candidate.id]
   if (lastTip !== undefined && view.contextStep - lastTip.contextStep < config.cooldownMessages) return undefined
-  const unresolved = matching.filter(item => item.index > (view.lastSuccessfulRunIndex ?? -1))
-  const ordinal = matching.reduce((highest, item) => Math.max(highest, item.ordinal), 0) + 1
+  const ordinal = (lastTip?.highestOrdinal ?? 0) + 1
   if (!Number.isSafeInteger(ordinal)) return undefined
   return {
     name: `${TIP_CONTEXT_PREFIX}${candidate.id}/${ordinal}`,
-    text: renderTip(candidate.id, unresolved.length >= config.escalationFailures, candidate),
+    text: renderTip(candidate.id, (lastTip?.unresolved ?? 0) >= config.escalationFailures, candidate),
   }
 }

package/internal/runtime-bridge-owner.js

@@ -147,6 +147,7 @@ export function createRuntimeBridgeOwner({
   sessionConfig,
   userBindingsCwd,
   observeSession,
+  readSessionLog = async session => session,
   maxNestedRunCodeDepth,
   presentationGeneration,
   sessionId,
@@ -172,7 +173,7 @@ export function createRuntimeBridgeOwner({
   const withInitiator = ctx.agents === undefined || typeof ctx.agents.withInitiator !== 'function'
     ? undefined
     : (agent, operation) => ctx.agents.withInitiator(agent, operation)
-  const sessions = new SessionRuntime(sessionConfig, { withInitiator, userBindingsCwd, observeSession })
+  const sessions = new SessionRuntime(sessionConfig, { withInitiator, userBindingsCwd, observeSession, readSessionLog })
   let currentConfig = sessions.config
   const patchedDefinitions = new Map()
   const pending = new WeakMap()
@@ -364,16 +365,18 @@ export function createRuntimeBridgeOwner({
     }
     if (patchedDefinitions.has(definition)) return
     const output = definition.output
-    const originalPresentationMeta = output.presentationMeta
+    const ownPresentationMeta = Object.getOwnPropertyDescriptor(output, 'presentationMeta')
     const patchedPresentationMeta = (args, value) => {
-      if (!active) {
-        return originalPresentationMeta === undefined
-          ? undefined
-          : originalPresentationMeta(args, value)
-      }
+      const prototype = Object.getPrototypeOf(output)
+      const originalPresentationMeta = ownPresentationMeta === undefined
+        ? prototype === null ? undefined : Reflect.get(prototype, 'presentationMeta', output)
+        : Object.hasOwn(ownPresentationMeta, 'value')
+          ? ownPresentationMeta.value
+          : ownPresentationMeta.get?.call(output)
       const base = originalPresentationMeta === undefined
         ? undefined
-        : originalPresentationMeta(args, value)
+        : originalPresentationMeta.call(output, args, value)
+      if (!active) return base
       const current = scope.getStore()
       const settlement = current?.settlement
       if (settlement === undefined) return generatedRunCodeDescriptionMeta(args, base)
@@ -417,15 +420,15 @@ export function createRuntimeBridgeOwner({
       patchedDefinitions.set(definition, {
         definition,
         output,
-        originalPresentationMeta,
+        ownPresentationMeta,
         patchedPresentationMeta,
         ownExecute,
         patchedExecute,
       })
     } catch (error) {
       if (presentationPatched && output.presentationMeta === patchedPresentationMeta) {
-        if (originalPresentationMeta === undefined) delete output.presentationMeta
-        else output.presentationMeta = originalPresentationMeta
+        if (ownPresentationMeta === undefined) delete output.presentationMeta
+        else Object.defineProperty(output, 'presentationMeta', ownPresentationMeta)
       }
       throw new Error(`ptc-plus: cannot attach the session journal to run_code results: ${error.message}`)
     }
@@ -439,10 +442,10 @@ export function createRuntimeBridgeOwner({
         return runIsolated(request, child.executionToken, child.depth, child.cellConfig, child.functions)
       }
     }
-    if (!active) return seam.invokeUpstream(request)
+    if (!active) return seam.runUpstream(request)
     const current = scope.getStore()
-    if (current === undefined) return seam.invokeUpstream(request)
-    const projected = projectBindings(request, 0, current)
+    if (current === undefined) return seam.runUpstream(request)
+    const projected = projectBindings(request, 0, current, undefined, current.submission?.config ?? currentConfig)
     return sessions.runTentative(current, {
       ...projected.request,
       executionToken: current,
@@ -455,7 +458,26 @@ export function createRuntimeBridgeOwner({
       .finally(projected.release)
   }
 
-  const releaseSeam = seam.takeOver(patchedRun)
+  const releaseSeam = seam.installExecute(patchedRun)
+
+  const withSubmission = async (exec, operation) => {
+    const id = sessionId(exec.agent)
+    const inherited = scope.getStore()
+    if (exec.parent !== undefined || id === undefined || inherited?.submission?.sessionId === id) return operation()
+    const submission = sessions.beginSubmission({ id }, exec.signal)
+    try {
+      return await scope.run({ ...inherited, submission }, operation)
+    } finally {
+      sessions.releaseSubmission(submission)
+    }
+  }
+
+  const readSubmissionLog = async (session, signal) => {
+    const inherited = scope.getStore()
+    const sessionLog = inherited?.sessionLog ?? await readSessionLog(session, signal)
+    if (inherited?.submission !== undefined) sessions.assertSubmission(inherited.submission)
+    return sessionLog
+  }
 
   return Object.freeze({
     config: sessions.config,
@@ -464,8 +486,10 @@ export function createRuntimeBridgeOwner({
       currentConfig = sessions.config
     },
     observeRepl(id, memory, signal) { return sessions.observe(id, memory, signal) },
+    withSubmission,
+    readSubmissionLog,
     // A composite tool's outer result owns the final durability decision.
-    async executeTentative(callSeq, operation) {
+    async executeTentative(callSeq, operation, sessionLog) {
       const settlement = {
         current: undefined,
         innerConfirmed: false,
@@ -480,7 +504,9 @@ export function createRuntimeBridgeOwner({
       }
       try {
         const result = await scope.run({
+          ...(scope.getStore()?.submission === undefined ? {} : { submission: scope.getStore().submission }),
           ...(callSeq === undefined ? {} : { persistedCallSeq: callSeq }),
+          ...(sessionLog === undefined ? {} : { sessionLog }),
           deferredSettlement: settlement,
         }, operation)
         return Object.freeze({ result, finalize })
@@ -489,46 +515,51 @@ export function createRuntimeBridgeOwner({
         throw error
       }
     },
-    handleExecute(exec, next, executionArguments = exec.arguments, userBindings = undefined) {
+    async handleExecute(exec, next, executionArguments = exec.arguments, userBindings = undefined) {
       if (exec.parent !== undefined) return scope.run(undefined, next)
-      const id = sessionId(exec.agent)
-      if (id === undefined) return next()
-      patchRunCodeDefinition(exec.agent)
-      const inherited = scope.getStore()
-      const persistedCallSeq = inherited?.persistedCallSeq
-      const current = {
-        id,
-        callId: String(exec.callId),
-        ...(persistedCallSeq === undefined ? {} : { persistedCallSeq }),
-        ...(inherited?.deferredSettlement === undefined
-          ? {}
-          : { deferredSettlement: inherited.deferredSettlement }),
-        session: exec.agent?.session,
-        agent: exec.agent,
-        executionArguments,
-        ...(userBindings === undefined ? {} : { userBindings }),
-      }
-      if (current.deferredSettlement !== undefined) {
-        current.deferredSettlement.current = current
-      }
-      pending.set(exec, current)
-      return scope.run(current, async () => {
-        const result = await next()
-        const settlement = current.settlement
-        if (result?.isError === true && settlement !== undefined) {
-          let meta = withJournal(result.meta, settlement.journal)
-          if (settlement.recoveryBoundaries !== undefined) {
-            meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
-          }
-          if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
-          if (settlement.userBindings !== undefined) {
-            meta = withUserBindingsSnapshot(meta, settlement.userBindings)
-          }
-          meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
-          meta = withDraftCapability(meta, current)
-          return { ...result, meta }
+      return withSubmission(exec, async () => {
+        const id = sessionId(exec.agent)
+        if (id === undefined) return next()
+        patchRunCodeDefinition(exec.agent)
+        const inherited = scope.getStore()
+        const persistedCallSeq = inherited?.persistedCallSeq
+        const current = {
+          id,
+          submission: inherited?.submission,
+          callId: String(exec.callId),
+          ...(persistedCallSeq === undefined ? {} : { persistedCallSeq }),
+          ...(inherited?.deferredSettlement === undefined
+            ? {}
+            : { deferredSettlement: inherited.deferredSettlement }),
+          session: exec.agent?.session,
+          sessionLog: await readSubmissionLog(exec.agent?.session, exec.signal),
+          agent: exec.agent,
+          executionArguments,
+          ...(userBindings === undefined ? {} : { userBindings }),
+        }
+        sessions.assertSubmission(current.submission)
+        if (current.deferredSettlement !== undefined) {
+          current.deferredSettlement.current = current
         }
-        return result
+        pending.set(exec, current)
+        return scope.run(current, async () => {
+          const result = await next()
+          const settlement = current.settlement
+          if (result?.isError === true && settlement !== undefined) {
+            let meta = withJournal(result.meta, settlement.journal)
+            if (settlement.recoveryBoundaries !== undefined) {
+              meta = withRecoveryBoundaries(meta, settlement.recoveryBoundaries)
+            }
+            if (settlement.rewrites !== undefined) meta = withRewrites(meta, settlement.rewrites)
+            if (settlement.userBindings !== undefined) {
+              meta = withUserBindingsSnapshot(meta, settlement.userBindings)
+            }
+            meta = withReplMemorySnapshot(meta, settlement.replMemory, presentationGeneration)
+            meta = withDraftCapability(meta, current)
+            return { ...result, meta }
+          }
+          return result
+        })
       })
     },
     handleResult(exec, result) {
@@ -539,7 +570,7 @@ export function createRuntimeBridgeOwner({
       pending.delete(exec)
       const settlement = current?.settlement
       if (settlement === undefined) {
-        sessions.noteNoop(id, exec.agent?.session, exec.callId)
+        sessions.noteNoop(id, current?.sessionLog, exec.callId)
         return
       }
       const meta = result?.meta
@@ -586,8 +617,8 @@ export function createRuntimeBridgeOwner({
       releaseSeam()
       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.ownPresentationMeta === undefined) delete patched.output.presentationMeta
+          else Object.defineProperty(patched.output, 'presentationMeta', patched.ownPresentationMeta)
         }
         if (patched.patchedExecute !== undefined
           && patched.definition.execute === patched.patchedExecute) {

package/internal/runtime-contexts.js

@@ -1,5 +1,5 @@
-import { latestRecoveryTip } from './recovery-tips.js'
-import { projectSessionLog, systemPromptSnapshotSections } from './session-log-view.js'
+import { latestRecoveryTip, runtimeHistoryForView } from './recovery-tips.js'
+import { projectSessionLog, runtimeMessageFacts, systemPromptSnapshotSections } from './session-log-view.js'
 import {
   PTC_BINDING_CATALOG, PTC_DELIVERY_CONTEXT, PTC_STATE_NAMES, readRuntimeMessage,
   runtimeBindingCatalogMessage, runtimeNoticeMessage, runtimeStateMessage,
@@ -21,7 +21,7 @@ function continuationFeedback(view) {
 
 /** Build all dynamic PTC contexts from one session-log projection. */
 export function sessionRuntimeContexts(agent, tipConfig, options = {}) {
-  const view = projectSessionLog(agent)
+  const view = (options.sessionLogView ?? projectSessionLog)(agent)
   const rewrite = continuationFeedback(view)
   const tip = latestRecoveryTip(view, tipConfig)
   const cordisRecovery = options.cordisRecoveryRequired?.(view) === true
@@ -42,13 +42,14 @@ export function projectRuntimeMessages(view, contexts, pending = []) {
   const sections = contexts.filter(context => PTC_STATE_NAMES.includes(context.name) && context.name !== PTC_BINDING_CATALOG)
   const catalog = contexts.find(context => context.name === PTC_BINDING_CATALOG)
   const records = view.visibleRuntimeMessages
-  const owned = records.filter(record => record.producer === 'ptc-plus' && record.form === 'snapshot').at(-1)
-  const legacy = records.filter(record => record.producer === 'aggregate').at(-1)
+  const facts = view.visibleRuntimeFacts ?? runtimeMessageFacts(records)
+  const history = runtimeHistoryForView(view)
+  const owned = facts.snapshot
+  const legacy = facts.aggregate
   const pendingAggregate = pending.map(systemPromptSnapshotSections).filter(sections => sections !== undefined).at(-1)
   const retained = owned?.sections
     ?? (pendingAggregate ?? legacy?.sections)?.filter(section => PTC_STATE_NAMES.includes(section.name))
-  const hadState = view.ptcMessages.some(record => record.form === 'snapshot')
-    || view.systemPromptSnapshots.some(record => record.sections.some(section => PTC_STATE_NAMES.includes(section.name)))
+  const hadState = history.hadState
   const messages = []
   const proposed = pending.map(readRuntimeMessage).filter(record => record !== undefined)
   const pendingState = proposed.filter(record => record.form === 'snapshot').at(-1)
@@ -58,23 +59,22 @@ export function projectRuntimeMessages(view, contexts, pending = []) {
     messages.push(runtimeStateMessage(sections))
   }
   const previousCatalog = proposed.filter(record => record.form === 'catalog').at(-1)
-    ?? records.filter(record => record.form === 'catalog').at(-1)
-  const hadCatalog = view.ptcMessages.some(record => record.form === 'catalog')
+    ?? facts.catalog
+  const hadCatalog = history.hadCatalog
   if ((catalog !== undefined || previousCatalog !== undefined || hadCatalog)
     && JSON.stringify(previousCatalog?.sections) !== JSON.stringify(catalog === undefined ? [] : [catalog])) {
     messages.push(runtimeBindingCatalogMessage(catalog))
   }
   for (const tip of contexts.filter(context => context.name.startsWith('tools:ptc-plus-tip/'))) {
     if (proposed.some(record => record.form === 'notice' && record.name === tip.name)) continue
-    if (view.ptcMessages.some(record => record.form === 'notice' && record.name === tip.name)
-      || view.systemPromptSnapshots.some(snapshot => snapshot.sections.some(section => section.name === tip.name))) continue
+    if (Object.hasOwn(history.seenNames, tip.name)) continue
     messages.push(runtimeNoticeMessage(tip))
   }
   return messages
 }
 
 /** Passive message delivery follows the actual public assembly and accepted step. */
-export function createRuntimeMessageOwner(contextsForRequest) {
+export function createRuntimeMessageOwner(contextsForRequest, sessionLogView = projectSessionLog) {
   const requests = new WeakMap()
   const disposedAgents = new WeakSet()
   let disposed = false
@@ -99,7 +99,7 @@ export function createRuntimeMessageOwner(contextsForRequest) {
       if (disposed || decision.kind !== 'enter' || payload.signal?.aborted === true
         || request?.allowed !== true || request.context.signal !== payload.signal) return decision
       const messages = projectRuntimeMessages(
-        projectSessionLog(payload.agent), contextsForRequest(request.context), decision.messages,
+        sessionLogView(payload.agent), contextsForRequest(request.context), decision.messages,
       )
       return messages.length === 0 ? decision : { ...decision, messages: [...decision.messages, ...messages] }
     },

package/internal/session-events.js

@@ -1,7 +1,43 @@
-/** Read the immutable session log across current and legacy DSH session APIs. */
+/** Read an explicit observation or the historical array-backed session contract. */
 export function sessionEvents(session) {
-  if (typeof session?.snapshotEvents === 'function') {
-    return session.snapshotEvents()
+  if (session === undefined || session === null) return undefined
+  const events = session.events
+  if (Array.isArray(events)) return events
+  if (Object.hasOwn(session, 'events')) throw new Error('ptc-plus: legacy session.events is not an event array')
+  throw new Error('ptc-plus: session history requires a public sessionQuery observation')
+}
+
+export function advanceSessionSurface(nodes, event) {
+  if (event?.surfaceOp === 'append') return [...nodes, event.seq]
+  if (event?.surfaceOp?.op !== 'replace') return nodes
+  const first = nodes.indexOf(event.surfaceOp.startSeq ?? event.surfaceOp.start)
+  const last = nodes.indexOf(event.surfaceOp.endSeq ?? event.surfaceOp.end)
+  if (first === -1 || last < first) return nodes
+  const next = [...nodes]
+  next.splice(first, last - first + 1, event.seq)
+  return next
+}
+
+export async function readSessionLog(session, query, signal) {
+  if (session === undefined || session === null || Array.isArray(session.events)) return session
+  if (typeof query?.observeSession !== 'function') {
+    throw new Error('ptc-plus: sessionQuery.observeSession is unavailable for this session')
+  }
+  const observation = await query.observeSession(session.id, { signal, projectionMode: 'none' })
+  try {
+    if (!Array.isArray(observation.events)) throw new Error('ptc-plus: sessionQuery observation did not publish events')
+    let nodes = session.surface?.nodes
+    if (!Array.isArray(nodes) || session.seq - 1 !== observation.cursor) {
+      nodes = []
+      for (const event of observation.events) nodes = advanceSessionSurface(nodes, event)
+    }
+    return Object.freeze({
+      id: session.id, header: observation.header, events: observation.events,
+      surface: Object.freeze({
+        nodes: Object.freeze([...nodes]),
+      }),
+    })
+  } finally {
+    observation[Symbol.dispose]()
   }
-  return session?.events
 }