dsh-ptc-plus 0.2.4 → 0.3.2

package/internal/session-runtime.js

@@ -7,12 +7,17 @@ import {
   pathToHead,
   reduceStateOperations,
   recoverJournal,
+  visibleExecutableCallSeqs,
 } from './session-journal.js'
 import { normalizeBindingDescriptors } from './binding-descriptors.js'
 import { resolveConfig } from './runtime-config.js'
 import { WorkerClient } from './worker-client.js'
 import { BindingCatalog, durabilityState, transitionDurability } from './session-state.js'
 import { SessionCellExecutor } from './session-cell-executor.js'
+import {
+  createReplMemorySnapshot,
+  unavailableReplMemorySnapshot,
+} from './repl-memory-projection.js'
 
 const WORKER_URL = new URL('./kernel-worker.js', import.meta.url)
 function recoveryDiagnostic(count) {
@@ -37,6 +42,13 @@ function rewritePolicy(config) {
   }
 }
 
+function bindingPolicy(config) {
+  return {
+    variableRedeclarations: config.looseTopLevelRedeclarations,
+    functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations,
+  }
+}
+
 function resolvedRuntimeConfig(config) {
   return Object.freeze(resolveConfig(config))
 }
@@ -63,12 +75,25 @@ class SessionKernel {
   constructor({ config, history, cwd, session, withInitiator }) {
     this.config = config
     this.history = history
+    this.initialRecoveryBoundary = history.available === false && history.volatileSuffix.length > 0
+      ? {
+          failedCallSeq: history.volatileSuffix[0].seq,
+          frontierCallSeq: history.head === undefined ? null : history.nodes[history.head]?.callSeq ?? null,
+        }
+      : undefined
+    this.surfaceGeneration = undefined
+    try {
+      this.surfaceGeneration = session?.surface?.replaceGeneration
+    } catch {
+      this.surfaceGeneration = undefined
+    }
     this.cwd = cwd
     this.session = session
     this.withInitiator = withInitiator
     this.durability = durabilityState()
     this.bindingCatalog = new BindingCatalog()
     this.replayed = false
+    this.liveCallSeqs = new Set()
     this.recoveryNotice = history.volatileSuffix.length === 0
       ? undefined
       : recoveryDiagnostic(history.volatileSuffix.length)
@@ -132,10 +157,62 @@ class SessionKernel {
   }
 
   async execute(request, config) {
-    const recoveryBoundaries = []
+    const recoveryBoundaries = this.initialRecoveryBoundary === undefined
+      ? []
+      : [this.initialRecoveryBoundary]
+    this.initialRecoveryBoundary = undefined
     const finishResult = result => recoveryBoundaries.length === 0
       ? result
       : { ...result, recoveryBoundaries: recoveryBoundaries.map(boundary => ({ ...boundary })) }
+    let currentGeneration
+    try {
+      currentGeneration = this.session?.surface?.replaceGeneration
+    } catch {
+      currentGeneration = undefined
+    }
+    if (currentGeneration !== undefined && currentGeneration !== this.surfaceGeneration) {
+      this.surfaceGeneration = currentGeneration
+      const visibleCallSeqs = visibleExecutableCallSeqs(this.session)
+      const contractsLiveState = [...this.liveCallSeqs].some(callSeq => (
+        !(visibleCallSeqs instanceof Set) || !visibleCallSeqs.has(callSeq)
+      ))
+      if ((config.durableReplay && !this.replayed) || contractsLiveState) {
+        const worker = this.client.worker
+        if (worker !== undefined) await this.client.reset(worker)
+        this.rollbackToDurable()
+        if (config.durableReplay) {
+          this.recoveryNotice = undefined
+          try {
+            this.history = recoverJournal(this.session, request.callSeq, {
+              visibleCallSeqs,
+            })
+          } catch (error) {
+            this.history = emptyHistory()
+            this.recoveryNotice = recoveryDiagnostic(1)
+            this.initialRecoveryBoundary = undefined
+          }
+          if (this.history.volatileSuffix.length > 0) {
+            this.recoveryNotice = recoveryDiagnostic(this.history.volatileSuffix.length)
+          }
+          this.initialRecoveryBoundary = this.history.available === false && this.history.volatileSuffix.length > 0
+            ? {
+                failedCallSeq: this.history.volatileSuffix[0].seq,
+                frontierCallSeq: this.history.head === undefined
+                  ? null
+                  : this.history.nodes[this.history.head]?.callSeq ?? null,
+              }
+            : undefined
+          if (this.initialRecoveryBoundary !== undefined) {
+            recoveryBoundaries.push(this.initialRecoveryBoundary)
+            this.initialRecoveryBoundary = undefined
+          }
+        } else {
+          this.history = emptyHistory()
+          this.replayed = true
+          this.recoveryNotice = recoveryDiagnostic(1)
+        }
+      }
+    }
     if (!this.replayed && config.durableReplay) {
       let skipped = 0
       while (!this.replayed) {
@@ -171,6 +248,7 @@ class SessionKernel {
             }
             const recovered = recoverJournal(this.session, request.callSeq, {
               extraBoundaries: [boundary],
+              visibleCallSeqs: visibleExecutableCallSeqs(this.session),
             })
             recoveryBoundaries.push(boundary)
             this.history = recovered
@@ -241,6 +319,7 @@ class SessionKernel {
         throw new ReplayFailure(node, error)
       }
     }
+    for (const node of path) this.liveCallSeqs.add(node.callSeq)
   }
 
   completeJournal(journal, status, result, volatileReason, diagnostics = [], completion = undefined) {
@@ -268,6 +347,7 @@ class SessionKernel {
     this.durability = durabilityState()
     this.replayed = false
     this.bindingCatalog = new BindingCatalog()
+    this.liveCallSeqs.clear()
   }
 
   settleCell(active, result, terminate = false) {
@@ -300,14 +380,17 @@ class SessionKernel {
           callSeq: request.callSeq,
           program: request.program,
           bindingCatalog: active.appliedBindingCatalog
-            ?? active.priorBindingCatalog.advance(prepared),
+            ?? active.priorBindingCatalog.advance(prepared, request.program),
           worker,
         })
       }
     }
     if (replay !== undefined && !terminate) {
       this.bindingCatalog = active.appliedBindingCatalog
-        ?? active.priorBindingCatalog.advance(prepared)
+        ?? active.priorBindingCatalog.advance(prepared, request.program)
+    }
+    if (replay === undefined && !terminate) {
+      this.liveCallSeqs.add(request.callSeq ?? request.sourceCallSeq)
     }
     this.active = undefined
     if (terminate) void this.client.reset(worker)
@@ -353,6 +436,18 @@ class SessionKernel {
     }
   }
 
+  replMemoryFor(journal) {
+    const tentative = this.tentatives.get(journal)
+    if (journal.status === 'discarded'
+      || journal.operations.some(operation => operation.action === 'restore')) {
+      return unavailableReplMemorySnapshot()
+    }
+    if (tentative === undefined) {
+      return createReplMemorySnapshot(this.bindingCatalog.snapshot())
+    }
+    return createReplMemorySnapshot(tentative.bindingCatalog.snapshot())
+  }
+
   finishStateOperations(operations, index, worker) {
     const transition = reduceStateOperations(this.history, operations, index)
     this.history.head = transition.head
@@ -442,10 +537,13 @@ export class SessionRuntime {
         sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
         callSeq = persistedCallSeq ?? sourceCallSeq
       } else {
-        try {
-          sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
-        } catch {
-          sourceCallSeq = undefined
+        sourceCallSeq = persistedCallSeq
+        if (sourceCallSeq === undefined) {
+          try {
+            sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
+          } catch {
+            sourceCallSeq = undefined
+          }
         }
       }
     } catch (error) {
@@ -456,7 +554,9 @@ export class SessionRuntime {
       let history
       try {
         history = cellConfig.durableReplay
-          ? recoverJournal(session, callSeq)
+          ? recoverJournal(session, callSeq, {
+            visibleCallSeqs: visibleExecutableCallSeqs(session),
+          })
           : emptyHistory()
       } catch (error) {
         return completed({ logs: [], error: { kind: 'recovery', message: `cannot reconstruct REPL from session log: ${messageOf(error)}` } })
@@ -473,7 +573,7 @@ export class SessionRuntime {
     const journal = createJournal(
       /* c8 ignore next */
       this.pendingNoops.get(sessionId) ?? [],
-      cellConfig.looseTopLevelRedeclarations ? 'loose' : 'strict',
+      bindingPolicy(cellConfig),
       rewritePolicy(cellConfig),
     )
     const workerReservation = kernel.reserveWorkerConfiguration(cellConfig)
@@ -487,6 +587,7 @@ export class SessionRuntime {
       journal,
       kernel,
       sessionId,
+      replMemory: kernel.replMemoryFor(journal),
       ...(result.recoveryBoundaries === undefined
         ? {}
         : { recoveryBoundaries: result.recoveryBoundaries }),

package/internal/session-state.js

@@ -19,13 +19,28 @@ export function transitionDurability(state, transition) {
 
 export class BindingCatalog {
   #known
+  #kinds
+  #definitions
   #imports
   #namespaces
+  #writable
 
-  constructor(known = new Set(), imports = new Map(), namespaces = new Set()) {
+  constructor(
+    known = new Set(),
+    imports = new Map(),
+    namespaces = new Set(),
+    kinds = new Map(),
+    definitions = new Map(),
+    writable = new Set(),
+  ) {
     this.#known = new Set(known)
+    this.#kinds = new Map([...this.#known].map(name => [name, kinds.get(name) ?? 'variable']))
+    this.#definitions = new Map([...this.#known]
+      .filter(name => definitions.has(name))
+      .map(name => [name, definitions.get(name)]))
     this.#imports = new Map(imports)
     this.#namespaces = new Set(namespaces)
+    this.#writable = new Set([...writable].filter(name => this.#known.has(name)))
     Object.freeze(this)
   }
 
@@ -34,12 +49,109 @@ export class BindingCatalog {
       knownBindings: new Set(this.#known),
       importBindings: new Map(this.#imports),
       importNamespaces: new Set(this.#namespaces),
+      writableBindings: new Set(this.#writable),
     }
   }
 
-  advance(prepared) {
+  advance(prepared, source = undefined, committedRedeclarations = undefined) {
     const known = new Set(this.#known)
-    for (const name of prepared.declared) known.add(name)
-    return new BindingCatalog(known, prepared.imports, prepared.importNamespaces)
+    const kinds = new Map(this.#kinds)
+    const definitions = new Map(this.#definitions)
+    const writable = new Set(this.#writable)
+    const touched = new Set()
+    const redeclared = new Set((prepared.redeclared ?? []).map(declaration => declaration.name))
+    const commitGated = prepared.commitTargets
+    const committed = committedRedeclarations instanceof Set
+      ? committedRedeclarations
+      : new Set([...redeclared, ...commitGated])
+    const uncommitted = new Set()
+    const extractDefinition = sourceDefinitionExtractor(source)
+    for (const declaration of prepared.declarations ?? []) {
+      if (typeof declaration?.name !== 'string') continue
+      const dependency = typeof declaration.commitDependency === 'string'
+        && commitGated.has(declaration.commitDependency)
+        ? declaration.commitDependency
+        : commitGated.has(declaration.name) ? declaration.name : undefined
+      if (dependency !== undefined && !committed.has(dependency)) {
+        uncommitted.add(declaration.name)
+        continue
+      }
+      touched.add(declaration.name)
+      kinds.set(declaration.name, declaration.kind ?? 'variable')
+      const definition = extractDefinition(declaration.definitionSpan)
+      if (definition !== undefined) definitions.set(declaration.name, definition)
+      if (!redeclared.has(declaration.name)) {
+        if (declaration.writable === true) writable.add(declaration.name)
+        else writable.delete(declaration.name)
+      }
+    }
+    for (const name of prepared.declared) {
+      if (!uncommitted.has(name)) touched.add(name)
+    }
+    for (const name of touched) {
+      known.delete(name)
+      known.add(name)
+    }
+    const imports = new Map(prepared.imports)
+    for (const [name, binding] of imports) {
+      if (typeof binding?.commitDependency !== 'string'
+        || !commitGated.has(binding.commitDependency)
+        || committed.has(binding.commitDependency)) continue
+      if (this.#imports.has(name)) imports.set(name, this.#imports.get(name))
+      else imports.delete(name)
+    }
+    return new BindingCatalog(known, imports, prepared.importNamespaces, kinds, definitions, writable)
+  }
+
+  snapshot() {
+    return [...this.#known].reverse()
+      .filter(name => !this.#namespaces.has(name))
+      .map(name => ({
+        name,
+        kind: this.#kinds.get(name) ?? 'variable',
+        ...(this.#definitions.has(name) ? { definition: this.#definitions.get(name) } : {}),
+      }))
+  }
+}
+
+const MAX_DEFINITION_SOURCE_LENGTH = 1024
+
+function lineOffsets(source) {
+  const offsets = [0]
+  for (let index = 0; index < source.length; index += 1) {
+    if (source.charCodeAt(index) === 10) offsets.push(index + 1)
+  }
+  return offsets
+}
+
+function offsetAt(offsets, sourceLength, position) {
+  if (position === null || typeof position !== 'object'
+    || !Number.isSafeInteger(position.line) || position.line < 1
+    || !Number.isSafeInteger(position.column) || position.column < 1
+    || position.line > offsets.length) return undefined
+  const lineStart = offsets[position.line - 1]
+  const lineEnd = position.line < offsets.length ? offsets[position.line] - 1 : sourceLength
+  const offset = lineStart + position.column - 1
+  return offset <= lineEnd ? offset : undefined
+}
+
+function sourceDefinitionExtractor(source) {
+  const offsets = typeof source === 'string' ? lineOffsets(source) : undefined
+  const extracted = new Map()
+  return span => {
+    if (offsets === undefined || span === null || typeof span !== 'object') return undefined
+    const start = offsetAt(offsets, source.length, span)
+    const end = offsetAt(offsets, source.length, span.end)
+    if (start === undefined || end === undefined || end <= start) return undefined
+    const key = `${start}:${end}`
+    if (extracted.has(key)) return extracted.get(key)
+    const length = end - start
+    const bounded = length <= MAX_DEFINITION_SOURCE_LENGTH
+      ? source.slice(start, end)
+      : `${source.slice(start, start + MAX_DEFINITION_SOURCE_LENGTH - 3)}...`
+    if (bounded.length === 0) return undefined
+    const definition = Object.freeze({ source: bounded, line: span.line, column: span.column })
+    extracted.set(key, definition)
+    return definition
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.2.4",
+  "version": "0.3.2",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -17,12 +17,15 @@
     "docs",
     "assets/dsh-ptc-plus-banner-en.webp",
     "assets/dsh-ptc-plus-banner-zh.webp",
-    "assets/ptc-plus-repair.png",
+    "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-settings-en.png",
     "assets/ptc-plus-settings-zh.png",
     "cordis.patch.yml",
     "README.md",
-    "README.zh.md",
+    "README.en.md",
     "LICENSE"
   ],
   "engines": {
@@ -96,10 +99,10 @@
     }
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-settings": "alpha",
-    "@deepseek-ai/dsh-skill-filesystem": "alpha",
-    "@deepseek-ai/dsh-tool-cordis": "alpha",
-    "@deepseek-ai/dsh-tools": "alpha",
+    "@deepseek-ai/dsh-settings": "next",
+    "@deepseek-ai/dsh-skill-filesystem": "next",
+    "@deepseek-ai/dsh-tool-cordis": "next",
+    "@deepseek-ai/dsh-tools": "next",
     "esbuild": "0.28.2",
     "yaml": "^2.9.0"
   }