dsh-ptc-plus 0.4.8 → 0.4.10

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: 8,
+    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,

package/internal/session-runtime.js

@@ -244,6 +244,7 @@ class SessionKernel {
   }
 
   async execute(request, config) {
+    const observedSession = request.sessionLog ?? this.session
     const recoveryBoundaries = this.initialRecoveryBoundary === undefined
       ? []
       : [this.initialRecoveryBoundary]
@@ -256,7 +257,7 @@ class SessionKernel {
     if (this.surfaceProvenanceRequired
       && (currentGeneration !== this.surfaceGeneration || hasLiveState)) {
       this.surfaceGeneration = currentGeneration
-      const visibleCallSeqs = visibleExecutableCallSeqs(this.session)
+      const visibleCallSeqs = visibleExecutableCallSeqs(observedSession)
       const contractsLiveState = [...this.liveCallSeqs].some(callSeq => (
         !(visibleCallSeqs instanceof Set) || !visibleCallSeqs.has(callSeq)
       ))
@@ -267,7 +268,7 @@ class SessionKernel {
         if (config.durableReplay) {
           this.recoveryNotice = undefined
           try {
-            this.history = recoverJournal(this.session, request.callSeq, {
+            this.history = recoverJournal(observedSession, request.callSeq, {
               visibleCallSeqs,
             })
           } catch (error) {
@@ -309,9 +310,9 @@ class SessionKernel {
             if (!(error instanceof ReplayFailure)) throw error
             const previousPathLength = pathToHead(this.history).length
             const boundary = recoveryBoundaryForHistory(this.history, error.node)
-            const recovered = recoverJournal(this.session, request.callSeq, {
+            const recovered = recoverJournal(observedSession, request.callSeq, {
               extraBoundaries: [boundary],
-              visibleCallSeqs: visibleExecutableCallSeqs(this.session),
+              visibleCallSeqs: visibleExecutableCallSeqs(observedSession),
             })
             const nextPathLength = pathToHead(recovered).length
             if (nextPathLength >= previousPathLength) throw new Error('recovery did not contract the historical frontier')
@@ -631,6 +632,8 @@ export class SessionRuntime {
     this.kernels = new Map()
     this.pendingNoops = new Map()
     this.settlements = new WeakSet()
+    this.preparingCells = new Set()
+    this.submissions = new WeakSet()
     this.disposed = false
     this.userBindingsCwd = options.userBindingsCwd ?? process.cwd()
     if (typeof this.userBindingsCwd !== 'string' || !isAbsolute(this.userBindingsCwd)) {
@@ -638,6 +641,7 @@ export class SessionRuntime {
     }
     this.withInitiator = typeof options.withInitiator === 'function' ? options.withInitiator : undefined
     this.observeSession = options.observeSession ?? (() => false)
+    this.readSessionLog = options.readSessionLog ?? (async session => session)
     this.disposal = undefined
   }
 
@@ -647,8 +651,31 @@ export class SessionRuntime {
     return execution.result
   }
 
+  beginSubmission(sessionContext, signal) {
+    const admission = { sessionId: sessionOf(sessionContext).id, config: this.config,
+      signal, cancelled: this.disposed }
+    this.submissions.add(admission)
+    if (!this.disposed) this.preparingCells.add(admission)
+    return admission
+  }
+
+  releaseSubmission(admission) {
+    this.preparingCells.delete(admission)
+    this.submissions.delete(admission)
+  }
+
+  assertSubmission(admission) {
+    if (this.disposed) throw new Error('PTC runtime disposed')
+    if (admission.cancelled || !this.submissions.has(admission)) throw new Error('PTC session disposed')
+  }
+
   reconfigure(config) {
     const resolved = resolvedRuntimeConfig(config)
+    for (const admission of this.preparingCells) {
+      if (!admission.signal?.aborted && resolved.maxOldGenerationSizeMb !== admission.config.maxOldGenerationSizeMb) {
+        throw new Error('ptc-plus: maxOldGenerationSizeMb cannot change while a session worker is active; retry after the session is disposed')
+      }
+    }
     const kernels = [...this.kernels.values()]
     for (const kernel of kernels) kernel.assertReconfigurationAllowed(resolved)
     for (const kernel of kernels) kernel.reconfigure(resolved)
@@ -665,7 +692,6 @@ export class SessionRuntime {
   async runTentative(sessionContext, request) {
     const completed = result => Object.freeze({ result, settlement: undefined })
     if (this.disposed) return completed({ logs: [], error: { kind: 'abort', message: 'PTC runtime disposed' } })
-    const cellConfig = this.config
     let bindingDescriptors
     try {
       bindingDescriptors = normalizeBindingDescriptors(request?.bindings)
@@ -683,34 +709,49 @@ export class SessionRuntime {
     } = sessionOf(sessionContext)
     let callSeq
     let sourceCallSeq
+    let sessionLog
+    const admission = sessionContext?.submission ?? this.beginSubmission(sessionContext, request.signal)
+    if (!this.submissions.has(admission) || admission.sessionId !== sessionId) {
+      return completed({ logs: [], error: { kind: 'exception', message: 'PTC submission does not belong to this session runtime' } })
+    }
+    const cellConfig = admission.config
+    const aborted = () => this.disposed || admission.cancelled
+    const abortResult = () => completed({ logs: [], error: { kind: 'abort',
+      message: request.signal?.aborted ? String(request.signal.reason)
+        : this.disposed ? 'PTC runtime disposed' : 'PTC session disposed' } })
     try {
+      sessionLog = sessionContext?.sessionLog ?? await this.readSessionLog(session, request.signal)
+      if (aborted()) return abortResult()
       if (persistedCallSeq !== undefined
         && !isCanonicalSequence(persistedCallSeq)) {
         throw new Error('persisted tool call sequence must be a non-negative safe integer')
       }
       if (cellConfig.durableReplay) {
-        sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
+        sourceCallSeq = liveToolCallSeq(sessionLog, callId, 'run_code')
         callSeq = persistedCallSeq ?? sourceCallSeq
       } else {
         sourceCallSeq = persistedCallSeq
         if (sourceCallSeq === undefined) {
           try {
-            sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
+            sourceCallSeq = liveToolCallSeq(sessionLog, callId, 'run_code')
           } catch {
             sourceCallSeq = undefined
           }
         }
       }
     } catch (error) {
+      if (aborted() || request.signal?.aborted) return abortResult()
       return completed({ logs: [], error: { kind: 'recovery', message: `cannot identify current run_code call in session log: ${messageOf(error)}` } })
+    } finally {
+      this.releaseSubmission(admission)
     }
     let kernel = this.kernels.get(sessionId)
     if (kernel === undefined) {
       let history
       try {
         history = cellConfig.durableReplay
-          ? recoverJournal(session, callSeq, {
-            visibleCallSeqs: visibleExecutableCallSeqs(session),
+          ? recoverJournal(sessionLog, callSeq, {
+            visibleCallSeqs: visibleExecutableCallSeqs(sessionLog),
           })
           : emptyHistory()
       } catch (error) {
@@ -742,7 +783,7 @@ export class SessionRuntime {
     const workerReservation = kernel.reserveWorkerConfiguration(cellConfig)
     let result
     try {
-      result = await kernel.run({ ...request, journal, callSeq, sourceCallSeq }, cellConfig)
+      result = await kernel.run({ ...request, journal, callSeq, sourceCallSeq, sessionLog }, cellConfig)
     } finally {
       kernel.releaseWorkerConfiguration(workerReservation)
     }
@@ -793,6 +834,12 @@ export class SessionRuntime {
 
   async disposeSession(sessionId) {
     const id = String(sessionId)
+    for (const admission of this.preparingCells) {
+      if (admission.sessionId === id) {
+        admission.cancelled = true
+        this.preparingCells.delete(admission)
+      }
+    }
     const kernel = this.kernels.get(id)
     this.pendingNoops.delete(id)
     if (kernel === undefined) return
@@ -815,6 +862,7 @@ export class SessionRuntime {
 
   async #dispose() {
     this.disposed = true
+    this.preparingCells.clear()
     const entries = [...this.kernels]
     const results = await Promise.allSettled(entries.map(async ([id, kernel]) => {
       await kernel.dispose()

package/internal/settings-compat.js

@@ -63,7 +63,14 @@ export function installSettingsSectionCompat({
 }) {
   ctx.inject(['settings'], settingsContext => {
     const provider = settingsContext.settings
-    onProvider(provider)
+    const sectionInstalled = typeof provider?.installSection === 'function'
+      || typeof settingsModule?.installSettingsSection === 'function'
+    const writeNamespace = sectionInstalled ? namespace : (ownerFiber ?? ctx.fiber)?.entry?.options?.id
+    const writer = typeof provider?.update === 'function'
+      && typeof writeNamespace === 'string' && writeNamespace.length > 0
+      ? Object.freeze({ update: patch => provider.update(writeNamespace, patch) }) : undefined
+    const unbind = onProvider(provider, writer)
+    if (typeof unbind === 'function') settingsContext.effect(() => unbind, 'ptc-plus settings writer')
     if (typeof provider?.installSection === 'function') {
       provider.installSection(ctx, namespace, schema, entry, hooks)
       return
@@ -79,7 +86,10 @@ export function installSettingsSectionCompat({
         // fiber, so the owner is the plugin's entry context rather than the
         // scope this installation happens to run in.
         const dispose = provider.configure({ auto: false }, ownerFiber ?? ctx.fiber)
-        ctx.effect?.(() => dispose, 'ptc-plus settings page policy')
+        // The policy belongs to the settings surface that accepted it, so its
+        // disposer is released when that surface goes away instead of
+        // accumulating on the plugin scope across settings reloads.
+        settingsContext.effect?.(() => dispose, 'ptc-plus settings page policy')
       }
       return
     }

package/internal/user-bindings-owner.js

@@ -274,7 +274,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
     entry: current.entry,
   })
   const candidateView = current => Object.freeze({ requestId: current.requestId, commandId: current.commandId, ...draftView(current) })
-  const settleDraft = (current, state, enabled = false) => {
+  const settleDraft = async (current, state, enabled = false) => {
     const retainReview = draftsByCapability.get(current.capability) === current
     removeDraft(current)
     const action = Object.freeze({ requestId: current.requestId, id: current.entry.id, state, enabled })
@@ -282,7 +282,8 @@ export function createUserBindingsOwner(ctx, options = {}) {
       reviewsByCapability.set(current.capability, { agent: current.agent, candidate: candidateView(current), action })
     }
     try {
-      const accepting = sessionEvents(current.agent.session)?.find(event => (
+      const sessionLog = await (options.readSessionLog ?? (async session => session))(current.agent.session)
+      const accepting = sessionEvents(sessionLog)?.find(event => (
         event.type === 'tool/result' && event.surfaceOp === 'append'
         && event.data?.meta?.[USER_BINDING_DRAFT_META_KEY]?.candidate?.requestId === current.requestId
       ))
@@ -303,7 +304,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
       drafts.delete(current.sessionId)
     }
   }
-  const clearDraft = (capability, version) => {
+  const clearDraft = async (capability, version) => {
     const current = draftFor(capability)
     if (current === null) return null
     if (!Number.isSafeInteger(version) || version < 1 || version !== current.version) {
@@ -314,7 +315,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
     if (current.state !== 'ready') {
       throw Object.assign(new Error('binding draft is being saved'), { code: 'BINDINGS_BUSY' })
     }
-    settleDraft(current, 'discarded')
+    await settleDraft(current, 'discarded')
     return null
   }
   const saveDraft = async (capability, version, expectedRevision, activate = false) => {
@@ -333,7 +334,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
       const result = current.mode === 'new'
         ? await store.create(entry, expectedRevision)
         : await store.update(entry, expectedRevision)
-      settleDraft(current, 'saved', activate === true)
+      await settleDraft(current, 'saved', activate === true)
       return result
     } catch (error) {
       if (drafts.get(current.sessionId) === current && current.state === 'saving') {

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "PTC Plus",
+    "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "PTC Plus",
+    "description": "面向 DeepSeek Harness PTC 模式的会话级 Agent 原生 REPL。"
+  }
+}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "icon": "assets/ptc-plus-icon.svg",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
   "exports": {
     ".": "./index.js",
+    "./execution-provider": "./internal/execution-provider-owner.js",
     "./client": "./client.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
     "index.js",
@@ -29,15 +31,12 @@
     "assets/ptc-plus-icon.svg",
     "assets/dsh-ptc-plus-banner-en.webp",
     "assets/dsh-ptc-plus-banner-zh.webp",
-    "assets/ptc-plus-bindings-en.png",
-    "assets/ptc-plus-bindings-zh.png",
-    "assets/ptc-plus-repair-zh.png",
-    "assets/ptc-plus-repair-en.png",
     "assets/ptc-plus-repl-workspace-en.png",
     "assets/ptc-plus-repl-workspace-zh.png",
     "assets/ptc-plus-settings-en.png",
     "assets/ptc-plus-settings-zh.png",
     "cordis.patch.yml",
+    "locale",
     "README.md",
     "README.en.md",
     "LICENSE"
@@ -64,6 +63,7 @@
     "@codemirror/state": "^6.7.4",
     "@codemirror/view": "^6.43.11",
     "@deepseek-ai/schemastery": "^3.18.3",
+    "@deepseek-ai/dsh-util-values": "^0.2.0-rc.2 || ^0.2.1-alpha.1",
     "@jridgewell/trace-mapping": "^0.3.31",
     "@lezer/highlight": "^1.2.3",
     "acorn": "^8.15.0",
@@ -71,6 +71,7 @@
     "codemirror": "^6.0.2",
     "fflate": "^0.8.3",
     "pathe": "^2.0.3",
+    "react-is": "^19.3.0",
     "tslib": "^2.8.1",
     "typescript": "^6.0.3"
   },
@@ -88,9 +89,11 @@
     "build": "node scripts/client-bundle.mjs build && node scripts/compiler-bundle.mjs build",
     "build:check": "node scripts/client-bundle.mjs check && node scripts/compiler-bundle.mjs check",
     "test:client": "vitest run --config scripts/client-test.config.mjs",
+    "test:client:visual": "node scripts/client-visual-check.mjs",
     "test:semantics": "node --test --test-concurrency=1 test/semantic-test262.test.js test/semantic-dialect.test.js test/semantic-boundaries.test.js",
     "semantic:check": "node scripts/semantic-obligations.mjs",
     "test:client:web": "node scripts/client-web-smoke.mjs",
+    "test:client:fallback": "node scripts/client-fallback-smoke.mjs",
     "test:client:layout": "node scripts/client-binding-layout.mjs",
     "host:baseline:update": "node scripts/dsh-dependency-baseline.mjs update",
     "host:baseline:verify": "node scripts/dsh-dependency-baseline.mjs verify",
@@ -110,8 +113,8 @@
     "coverage": "node scripts/coverage.mjs",
     "coverage:focus": "node scripts/coverage.mjs --focus",
     "test:ci:runtime": "node --test --test-concurrency=1 test/package-contract.test.js test/compiler-platform.test.js test/direct-surface-policy.test.js test/isolated-entrance.test.js test/plugin-native-call-transport.test.js",
-    "verify": "npm run review:validate && npm run host:baseline:verify && npm run semantic:check && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node --check scripts/migrate-session-log.mjs && node --check scripts/expensive-headless-acceptance.mjs && node --check scripts/ab-headless-trajectories.mjs && npm run test:client && npm run coverage",
-    "verify:ci": "npm run review:validate && npm run host:baseline:verify && npm run semantic:check && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node --check scripts/migrate-session-log.mjs && npm run test:client && npm run test:ci:runtime",
+    "verify": "npm run review:validate && npm run host:baseline:verify && npm run semantic:check && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node --check scripts/migrate-session-log.mjs && node --check scripts/expensive-headless-acceptance.mjs && node --check scripts/ab-headless-trajectories.mjs && npm run test:client:visual && npm run coverage",
+    "verify:ci": "npm run review:validate && npm run host:baseline:verify && npm run semantic:check && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node --check scripts/migrate-session-log.mjs && npm run test:client:visual && npm run test:ci:runtime",
     "check": "node scripts/review-findings.mjs check",
     "test:expensive": "node scripts/expensive-headless-acceptance.mjs",
     "test:ab": "node scripts/ab-headless-trajectories.mjs"
@@ -139,19 +142,15 @@
     },
     "client": {
       "platform": "web",
-      "external": [
-        "react"
-      ],
+      "immediately": true,
       "inject": [
         "@deepseek-ai/dsh-api-gateway",
         "@deepseek-ai/dsh-api-remotes",
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-settings-plugins",
         "@deepseek-ai/dsh-client-ui-conversation",
-        "@deepseek-ai/dsh-client-connection",
-        "@deepseek-ai/dsh-client-ui-primitives"
+        "@deepseek-ai/dsh-client-connection"
       ]
     }
   },