dsh-ptc-plus 0.3.1 → 0.3.2

package/internal/session-runtime.js

@@ -7,6 +7,7 @@ import {
   pathToHead,
   reduceStateOperations,
   recoverJournal,
+  visibleExecutableCallSeqs,
 } from './session-journal.js'
 import { normalizeBindingDescriptors } from './binding-descriptors.js'
 import { resolveConfig } from './runtime-config.js'
@@ -41,6 +42,13 @@ function rewritePolicy(config) {
   }
 }
 
+function bindingPolicy(config) {
+  return {
+    variableRedeclarations: config.looseTopLevelRedeclarations,
+    functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations,
+  }
+}
+
 function resolvedRuntimeConfig(config) {
   return Object.freeze(resolveConfig(config))
 }
@@ -67,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)
@@ -136,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) {
@@ -175,6 +248,7 @@ class SessionKernel {
             }
             const recovered = recoverJournal(this.session, request.callSeq, {
               extraBoundaries: [boundary],
+              visibleCallSeqs: visibleExecutableCallSeqs(this.session),
             })
             recoveryBoundaries.push(boundary)
             this.history = recovered
@@ -245,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) {
@@ -272,6 +347,7 @@ class SessionKernel {
     this.durability = durabilityState()
     this.replayed = false
     this.bindingCatalog = new BindingCatalog()
+    this.liveCallSeqs.clear()
   }
 
   settleCell(active, result, terminate = false) {
@@ -313,6 +389,9 @@ class SessionKernel {
       this.bindingCatalog = active.appliedBindingCatalog
         ?? 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)
     active.finish(result)
@@ -458,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) {
@@ -472,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)}` } })
@@ -489,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)

package/internal/session-state.js

@@ -23,6 +23,7 @@ export class BindingCatalog {
   #definitions
   #imports
   #namespaces
+  #writable
 
   constructor(
     known = new Set(),
@@ -30,6 +31,7 @@ export class BindingCatalog {
     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']))
@@ -38,6 +40,7 @@ export class BindingCatalog {
       .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)
   }
 
@@ -46,28 +49,58 @@ 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, source = undefined) {
+  advance(prepared, source = undefined, committedRedeclarations = undefined) {
     const known = new Set(this.#known)
     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 prepared.declared) touched.add(name)
     for (const name of touched) {
       known.delete(name)
       known.add(name)
     }
-    return new BindingCatalog(known, prepared.imports, prepared.importNamespaces, kinds, definitions)
+    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() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -17,6 +17,8 @@
     "docs",
     "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-settings-en.png",
@@ -97,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"
   }

package/src/client-activity.js

@@ -1,14 +1,21 @@
-const JOURNAL_VERSIONS = new Set([1, 2, 3])
+const JOURNAL_VERSIONS = new Set([1, 2, 3, 4])
 const JOURNAL_STATUSES = new Set(['durable', 'volatile', 'discarded', 'noop'])
 const BINDING_MODES = new Set(['loose', 'strict'])
 const JOURNAL_FIELDS = new Set([
+  'version', 'bindingPolicy', 'rewritePolicy', 'moduleSemantics', 'status', 'calls', 'operations',
+  'confirms', 'diagnostics', 'completion', 'volatileReason',
+])
+const PREDECESSOR_JOURNAL_FIELDS = new Set([
   'version', 'bindingMode', 'rewritePolicy', 'status', 'calls', 'operations',
   'confirms', 'diagnostics', 'completion', 'volatileReason',
 ])
-const LEGACY_JOURNAL_FIELDS = new Set([...JOURNAL_FIELDS].filter(key => key !== 'rewritePolicy'))
+const LEGACY_JOURNAL_FIELDS = new Set([...PREDECESSOR_JOURNAL_FIELDS].filter(key => key !== 'rewritePolicy'))
+const BINDING_POLICY_FIELDS = new Set(['variableRedeclarations', 'functionClassRedeclarations'])
 const REWRITE_POLICY_FIELDS = new Set([
   'autoRewriteImports', 'autoStripExports', 'autoSplitRedeclarations',
 ])
+const MODULE_SEMANTICS_FIELDS = new Set(['defaultExportBinding'])
+const DEFAULT_EXPORT_BINDINGS = new Set(['legacy-variable', 'live-readonly'])
 const CALL_SUCCESS_FIELDS = new Set(['global', 'member', 'args', 'ok', 'value', 'settle'])
 const CALL_ERROR_FIELDS = new Set(['global', 'member', 'args', 'ok', 'error', 'settle'])
 const OPERATION_FIELDS = new Set(['action', 'name'])
@@ -30,9 +37,11 @@ const REWRITE_FIELDS = new Set(['kind', 'description', 'source'])
 const REWRITE_KINDS = new Set(['import', 'redeclaration', 'export'])
 const REWRITE_POLICY_BY_KIND = Object.freeze({
   import: 'autoRewriteImports',
-  redeclaration: 'autoSplitRedeclarations',
   export: 'autoStripExports',
 })
+const MIXED_REDECLARATION = 'split a mixed top-level declaration while preserving native pattern initialization'
+const FUNCTION_REDECLARATION = 'reassigned an existing top-level function declaration for REPL continuity'
+const CLASS_REDECLARATION = 'reassigned an existing top-level class declaration for REPL continuity'
 const EDIT_TARGET_FIELDS = new Set(['targetCallSeq'])
 const DERIVED_RUN_FIELDS = new Set(['code', 'description'])
 const RECOVERY_BOUNDARY_FIELDS = new Set(['failedCallSeq', 'frontierCallSeq'])
@@ -209,6 +218,16 @@ function isValidRewritePolicy(value) {
     && [...REWRITE_POLICY_FIELDS].every(key => typeof value[key] === 'boolean')
 }
 
+function isValidBindingPolicy(value) {
+  return hasExactFields(value, BINDING_POLICY_FIELDS)
+    && [...BINDING_POLICY_FIELDS].every(key => typeof value[key] === 'boolean')
+}
+
+function isValidModuleSemantics(value) {
+  return hasExactFields(value, MODULE_SEMANTICS_FIELDS)
+    && DEFAULT_EXPORT_BINDINGS.has(value.defaultExportBinding)
+}
+
 function isValidCall(value) {
   if (!isRecord(value) || (value.ok !== true && value.ok !== false)) return false
   const fields = value.ok ? CALL_SUCCESS_FIELDS : CALL_ERROR_FIELDS
@@ -249,10 +268,16 @@ function isReadableJournalUnchecked(value) {
   if (!isRecord(value) || !JOURNAL_VERSIONS.has(value.version) || !JOURNAL_STATUSES.has(value.status)) {
     return false
   }
-  const fields = value.version === 1 ? LEGACY_JOURNAL_FIELDS : JOURNAL_FIELDS
-  const required = ['version', 'bindingMode', 'status', 'calls', 'operations', 'diagnostics']
-  if (value.version !== 1) required.push('rewritePolicy')
-  if (!hasClosedFields(value, fields, required) || !BINDING_MODES.has(value.bindingMode)
+  const predecessor = value.version !== 4
+  const fields = value.version === 1 ? LEGACY_JOURNAL_FIELDS : predecessor ? PREDECESSOR_JOURNAL_FIELDS : JOURNAL_FIELDS
+  const required = predecessor
+    ? ['version', 'bindingMode', 'status', 'calls', 'operations', 'diagnostics']
+    : ['version', 'bindingPolicy', 'rewritePolicy', 'moduleSemantics', 'status', 'calls', 'operations', 'diagnostics']
+  if (value.version !== 1 && value.version !== 4) required.push('rewritePolicy')
+  if (!hasClosedFields(value, fields, required)
+    || (predecessor && !BINDING_MODES.has(value.bindingMode))
+    || (value.version === 4 && !isValidBindingPolicy(value.bindingPolicy))
+    || (value.version === 4 && !isValidModuleSemantics(value.moduleSemantics))
     || (value.version !== 1 && !isValidRewritePolicy(value.rewritePolicy))
     || !Array.isArray(value.calls) || !value.calls.every(isValidCall)
     || !Array.isArray(value.operations) || !value.operations.every(isValidOperation)
@@ -295,7 +320,12 @@ function isValidRewrites(value, journal) {
       && Array.isArray(value) && value.every(rewrite => (
       hasClosedFields(rewrite, REWRITE_FIELDS, ['kind', 'description'])
       && REWRITE_KINDS.has(rewrite.kind)
-      && journal.rewritePolicy[REWRITE_POLICY_BY_KIND[rewrite.kind]] === true
+      && (rewrite.kind === 'redeclaration'
+        ? (rewrite.description === FUNCTION_REDECLARATION || rewrite.description === CLASS_REDECLARATION)
+          ? journal.version === 4 && isValidBindingPolicy(journal.bindingPolicy)
+            && journal.bindingPolicy.functionClassRedeclarations === true
+          : journal.rewritePolicy.autoSplitRedeclarations === true
+        : journal.rewritePolicy[REWRITE_POLICY_BY_KIND[rewrite.kind]] === true)
       && typeof rewrite.description === 'string' && rewrite.description.length > 0
       && (rewrite.source === undefined || typeof rewrite.source === 'string')
       ))
@@ -377,7 +407,6 @@ function resultText(block) {
   }
 }
 
-const MIXED_REDECLARATION = 'split a mixed top-level declaration while preserving native pattern initialization'
 const GENERATED_RUN_CODE_DESCRIPTION_KEY = 'dshPtcPlusRunCodeDescription'
 
 function rewriteFeature(rewrites, predicate, key) {