dsh-ptc-plus 0.4.1 → 0.4.3

package/internal/session-log-view.js

@@ -1,16 +1,17 @@
 import {
   foldSessionTimeline,
 } from './session-journal-recovery.js'
+import { isCanonicalSequence } from './session-journal.js'
 import { sessionEvents } from './session-events.js'
 import { readRuntimeMessage } from './runtime-messages.js'
 
-const SYSTEM_PROMPT_PLUGIN = '@deepseek-ai/dsh-system-prompt'
+import { isHostRuntimeContextSource } from './message-sources.js'
 const SYSTEM_PROMPT_CLEARED = 'Current runtime context: none. Earlier runtime-context snapshots no longer apply.'
 
 /** DSH's empty aggregate uses an exact owner marker without a snapshot form. */
 export function systemPromptSnapshotSections(message) {
   const source = message?.source
-  if (source?.kind !== 'plugin' || source.plugin !== SYSTEM_PROMPT_PLUGIN) return undefined
+  if (!isHostRuntimeContextSource(source)) return undefined
   if (source.form === undefined && Array.isArray(message.content) && message.content.length === 1
     && message.content[0]?.type === 'text' && message.content[0].text === SYSTEM_PROMPT_CLEARED) {
     return Object.freeze([])
@@ -101,7 +102,7 @@ export function projectSessionLog(agent, requestedEdit) {
   try {
     const nodes = agent?.session?.surface?.nodes
     const knownSeqs = new Set(events.map(event => event?.seq))
-    if (Array.isArray(nodes) && nodes.every(seq => Number.isSafeInteger(seq) && seq >= 0 && knownSeqs.has(seq))) {
+    if (Array.isArray(nodes) && nodes.every(seq => isCanonicalSequence(seq) && knownSeqs.has(seq))) {
       visibleRuntimeMessages = Object.freeze(nodes.flatMap(seq => {
         const record = runtimeMessagesBySeq.get(seq)
         return record === undefined ? [] : [record]
@@ -126,6 +127,6 @@ export function projectSessionLog(agent, requestedEdit) {
 /** Return the target snapshot captured at one persisted edit call event. */
 export function editTargetForCall(agent, callId, callSeq) {
   if (typeof callId !== 'string' || callId.length === 0
-    || !Number.isSafeInteger(callSeq) || callSeq < 0) return undefined
+    || !isCanonicalSequence(callSeq)) return undefined
   return projectSessionLog(agent, { callId, callSeq }).requestedEditTarget
 }

package/internal/session-runtime.js

@@ -4,6 +4,7 @@ import { diagnostic, renderDiagnostic } from './diagnostic.js'
 import { createFailureTracker, messageOf } from './failure-reporting.js'
 import {
   createJournal,
+  isCanonicalSequence,
   liveToolCallSeq,
   normalizeJournal,
   reduceStateOperations,
@@ -29,6 +30,17 @@ import {
 } from './repl-memory-projection.js'
 
 const WORKER_URL = new URL('./kernel-worker.js', import.meta.url)
+const UNAVAILABLE_SURFACE_GENERATION = Symbol('unavailableSurfaceGeneration')
+
+function surfaceGeneration(session, provenanceRequired = true) {
+  try {
+    return session?.surface?.replaceGeneration
+      ?? (provenanceRequired ? UNAVAILABLE_SURFACE_GENERATION : undefined)
+  } catch {
+    return provenanceRequired ? UNAVAILABLE_SURFACE_GENERATION : undefined
+  }
+}
+
 function recoveryDiagnostic(count) {
   return diagnostic({
     code: 'PTC-R002',
@@ -66,20 +78,16 @@ class ReplayCancelled extends Error {
 }
 
 class SessionKernel {
-  constructor({ config, history, cwd, session, userBindingsCwd, withInitiator, observeValues }) {
+  constructor({ config, history, cwd, session, surfaceProvenanceRequired, userBindingsCwd, withInitiator, observeValues }) {
     this.config = config
     this.history = history
     this.initialRecoveryBoundary = recoveryBoundaryForHistory(history)
-    this.surfaceGeneration = undefined
-    try {
-      this.surfaceGeneration = session?.surface?.replaceGeneration
-    } catch {
-      this.surfaceGeneration = undefined
-    }
+    this.surfaceGeneration = surfaceGeneration(session, surfaceProvenanceRequired)
     this.cwd = cwd
     this.userBindingsCwd = userBindingsCwd
     this.observeValues = observeValues
     this.session = session
+    this.surfaceProvenanceRequired = surfaceProvenanceRequired
     this.withInitiator = withInitiator
     this.durability = durabilityState()
     this.bindingCatalog = new BindingCatalog()
@@ -103,10 +111,19 @@ class SessionKernel {
       cwd,
       compilerCache: compilerWorkerCache,
       onMessage: message => this.cellExecutor.onMessage(message),
+      onUnmatchedOutputFailure: message => {
+        const active = this.active
+        if (active === undefined) return false
+        active.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        return true
+      },
       onFailure: message => {
         this.pendingInspection?.finish()
         this.workerObservation = undefined
-        this.active?.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        const active = this.active
+        if (active === undefined) return false
+        active.resolve({ logs: [], error: { kind: 'worker-exit', message } }, true)
+        return true
       },
     })
     this.failures = createFailureTracker()
@@ -181,10 +198,10 @@ class SessionKernel {
     const current = () => {
       if (this.disposed || !this.config.replViewEnabled || signal?.aborted
         || this.client.worker === undefined || this.unsettledCells > 0) return false
-      try {
-        return this.session?.surface?.replaceGeneration === this.surfaceGeneration
-          && isDeepStrictEqual(expected, createReplMemorySnapshot(this.bindingCatalog.snapshot()))
-      } catch { return false }
+      return surfaceGeneration(this.session, this.surfaceProvenanceRequired) === this.surfaceGeneration
+        && (!this.surfaceProvenanceRequired
+          || this.surfaceGeneration !== UNAVAILABLE_SURFACE_GENERATION)
+        && isDeepStrictEqual(expected, createReplMemorySnapshot(this.bindingCatalog.snapshot()))
     }
     return new Promise(resolve => {
       let finished = false
@@ -234,13 +251,10 @@ class SessionKernel {
     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) {
+    const currentGeneration = surfaceGeneration(this.session, this.surfaceProvenanceRequired)
+    const hasLiveState = this.liveCallSeqs.size > 0
+    if (this.surfaceProvenanceRequired
+      && (currentGeneration !== this.surfaceGeneration || hasLiveState)) {
       this.surfaceGeneration = currentGeneration
       const visibleCallSeqs = visibleExecutableCallSeqs(this.session)
       const contractsLiveState = [...this.liveCallSeqs].some(callSeq => (
@@ -597,6 +611,7 @@ function sessionOf(sessionContext) {
       callId: undefined,
       persistedCallSeq: undefined,
       cwd: undefined,
+      surfaceProvenanceRequired: false,
     }
   }
   const session = sessionContext.session
@@ -606,6 +621,7 @@ function sessionOf(sessionContext) {
     callId: sessionContext.callId,
     persistedCallSeq: sessionContext.persistedCallSeq,
     cwd: typeof session?.header?.cwd === 'string' ? session.header.cwd : undefined,
+    surfaceProvenanceRequired: true,
   }
 }
 
@@ -657,12 +673,19 @@ export class SessionRuntime {
       return completed({ logs: [], error: { kind: 'exception', message: messageOf(error) } })
     }
     request = { ...request, bindings: bindingDescriptors.namespaces, bindingDescriptors }
-    const { id: sessionId, session, callId, persistedCallSeq, cwd } = sessionOf(sessionContext)
+    const {
+      id: sessionId,
+      session,
+      callId,
+      persistedCallSeq,
+      cwd,
+      surfaceProvenanceRequired,
+    } = sessionOf(sessionContext)
     let callSeq
     let sourceCallSeq
     try {
       if (persistedCallSeq !== undefined
-        && (!Number.isSafeInteger(persistedCallSeq) || persistedCallSeq < 0)) {
+        && !isCanonicalSequence(persistedCallSeq)) {
         throw new Error('persisted tool call sequence must be a non-negative safe integer')
       }
       if (cellConfig.durableReplay) {
@@ -700,6 +723,7 @@ export class SessionRuntime {
         history,
         cwd,
         session,
+        surfaceProvenanceRequired,
         userBindingsCwd: this.userBindingsCwd,
         withInitiator: this.withInitiator,
         observeValues: () => this.config.replViewEnabled && this.observeSession(sessionId),
@@ -713,6 +737,7 @@ export class SessionRuntime {
       policies.bindingPolicy,
       policies.rewritesEnabled,
       policies.languageSemantics,
+      policies.moduleTransform,
     )
     const workerReservation = kernel.reserveWorkerConfiguration(cellConfig)
     let result

package/internal/session-state.js

@@ -1,10 +1,12 @@
 // Runtime state transitions shared by the session coordinator and cell executor.
 
 import { userBindingCatalogEntries } from './user-bindings.js'
+import { boundedDefinitionSource } from './repl-memory-projection.js'
 import { LEGACY_USER_BINDINGS_SHADOW_POLICY } from './session-journal-schema.js'
 import { advanceLegacyBindings } from './legacy-binding-catalog.js'
 import { dynamicBindingOrigin } from './dynamic-binding-evidence.js'
 import { LEGACY_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import { sourceLineStarts, sourceOffsetAtPosition } from './source-position-map.js'
 
 /**
  * Reuse counts belong to a logical binding identity, not to one declaration
@@ -236,7 +238,7 @@ export class BindingCatalog {
           definition: previous?.origin === undefined && previous?.definition !== undefined
             ? previous.definition
             : fact.state === 'local' && typeof source === 'string' && source.length > 0
-              ? Object.freeze({ source: source.slice(0, MAX_DEFINITION_SOURCE_LENGTH), line: 1, column: 1 }) : undefined,
+              ? Object.freeze({ source: boundedDefinitionSource(source), line: 1, column: 1 }) : undefined,
           writable: previous?.writable ?? true,
           userBindingState: fact.state,
           unavailable: fact.state !== 'local',
@@ -290,41 +292,17 @@ function applyRootBindingFacts(entries, facts, rootCandidates, dynamicOrigins, i
   }
 }
 
-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 offsets = typeof source === 'string' ? sourceLineStarts(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)
+    const start = sourceOffsetAtPosition(source, span, offsets)
+    const end = sourceOffsetAtPosition(source, span.end, offsets)
     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)}...`
+    const bounded = boundedDefinitionSource(source.slice(start, end))
     if (bounded.length === 0) return undefined
     const definition = Object.freeze({ source: bounded, line: span.line, column: span.column })
     extracted.set(key, definition)

package/internal/settings-compat.js

@@ -1,3 +1,55 @@
+/**
+ * Whether the installed settings generation owns the plugin's exported `Config`
+ * document.
+ *
+ * A generation that still attaches through the provider section installer — on
+ * its settings service, or on the package helper an older release published —
+ * validates the plugin's own fields and has no volatile contract. The
+ * generation that serves the exported `Config` itself, and commits only fields
+ * marked volatile, publishes neither installer. Both probes read the installed
+ * public surface, so no release identity selects the shape.
+ *
+ * @param settingsModule - the installed public settings package surface.
+ * @returns whether that generation serves the plugin's Config document itself.
+ */
+export function hostOwnsSettingsDocument(settingsModule) {
+  return typeof settingsModule?.installSettingsSection !== 'function'
+    && typeof settingsModule?.SettingsProvider?.prototype?.installSection !== 'function'
+}
+
+/**
+ * Build one exported `Config` field for the installed settings generation.
+ *
+ * A generation that serves the document itself keeps a form mounted and commits
+ * new values into the retained handle only for fields whose nearest schema
+ * ancestor is marked volatile, so the marker is applied there. A builder that
+ * does not publish that capability causes a dependency error during import; silently
+ * emitting ordinary fields would hide the form and every Client feature gated
+ * by its settings snapshot. The generation that installs its own section
+ * validates the same fields itself
+ * and must not receive the marker, because its validated defaults would become
+ * live handles its document path never commits.
+ *
+ * @param options.Schema - the schema builder the plugin imports.
+ * @param options.field - one field definition from `internal/config-spec.js`.
+ * @param options.settingsModule - the installed public settings package surface.
+ * @returns the Cordis schema field for that definition.
+ */
+export function configFieldSchema({ Schema, field, settingsModule }) {
+  const base = field.type === 'boolean'
+    ? Schema.boolean().default(field.default)
+    : field.type === 'enum'
+      // Keep omission visible until resolveConfig migrates legacy policies.
+      ? Schema.union(field.options.map(option => Schema.const(option)))
+      : Schema.number().step(1).min(field.min).max(field.max).default(field.default)
+  const described = base.description(field.description)
+  if (!hostOwnsSettingsDocument(settingsModule)) return described
+  if (typeof described.volatile !== 'function') {
+    throw new Error('ptc-plus: the host settings contract requires @deepseek-ai/schemastery with volatile(); reinstall the plugin to update its dependencies')
+  }
+  return described.volatile()
+}
+
 /** Install an optional settings section across current and legacy DSH settings APIs. */
 export function installSettingsSectionCompat({
   ctx,
@@ -6,6 +58,7 @@ export function installSettingsSectionCompat({
   schema,
   entry,
   hooks,
+  ownerFiber,
   onProvider,
 }) {
   ctx.inject(['settings'], settingsContext => {
@@ -16,7 +69,19 @@ export function installSettingsSectionCompat({
       return
     }
     if (typeof settingsModule?.installSettingsSection !== 'function') {
-      throw new Error('ptc-plus: incompatible settings service; expected installSection or installSettingsSection')
+      // The newest settings generation owns its document and card from the
+      // plugin's exported Config, so it exposes no section installer to call.
+      // Treat that shape as a host-owned surface instead of a load failure;
+      // the host commits volatile-only changes into the retained handles and
+      // notifies this fiber through `loader/volatile-update`.
+      if (typeof provider?.configure === 'function') {
+        // The host records the own-page policy against the profile entry's own
+        // 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')
+      }
+      return
     }
     const mountedOwner = new Proxy(ctx, {
       get(target, property) {

package/internal/source-position-map.js

@@ -117,6 +117,25 @@ export function sourceOffsetAt(sourceMap, generatedOffset) {
   return segmentOffsetAt(segment, generatedOffset)
 }
 
+/** Whether a complete generated interval still contains its exact original text. */
+export function sourceRangeHasOriginalText(sourceMap, generatedSource, originalSource, generatedStart, generatedEnd) {
+  if (typeof generatedSource !== 'string' || typeof originalSource !== 'string'
+    || generatedEnd <= generatedStart || generatedStart < 0 || generatedEnd > generatedSource.length) return false
+  let cursor = generatedStart
+  for (let index = segmentIndexAt(sourceMap, generatedStart); index < sourceMap.length && cursor < generatedEnd; index += 1) {
+    const segment = sourceMap.at(index)
+    if (segment.generatedStart > cursor || segment.generatedEnd <= cursor) break
+    const end = Math.min(generatedEnd, segment.generatedEnd)
+    const length = end - cursor
+    const originalStart = segmentOffsetAt(segment, cursor)
+    if (segment.originalEnd <= segment.originalStart
+      || originalStart + length > originalSource.length
+      || generatedSource.slice(cursor, end) !== originalSource.slice(originalStart, originalStart + length)) return false
+    cursor = end
+  }
+  return cursor === generatedEnd
+}
+
 function segmentOffsetAt(segment, generatedOffset) {
   const generatedLength = segment.generatedEnd - segment.generatedStart
   const originalLength = segment.originalEnd - segment.originalStart
@@ -268,6 +287,25 @@ export function sourceLineStarts(source) {
   return starts
 }
 
+/** Convert one-based JavaScript source coordinates without admitting a
+ * position inside a line terminator. End coordinates may point immediately
+ * after the final content character. */
+export function sourceOffsetAtPosition(source, position, starts) {
+  if (typeof source !== 'string' || position === null || typeof position !== 'object'
+    || !Number.isSafeInteger(position.line) || position.line < 1
+    || !Number.isSafeInteger(position.column) || position.column < 1) return undefined
+  const lineStarts = starts ?? sourceLineStarts(source)
+  if (!Array.isArray(lineStarts) || position.line > lineStarts.length) return undefined
+  const lineStart = lineStarts[position.line - 1]
+  const nextLineStart = lineStarts[position.line]
+  let lineEnd = source.length
+  if (nextLineStart !== undefined) {
+    lineEnd = nextLineStart - (source[nextLineStart - 2] === '\r' && source[nextLineStart - 1] === '\n' ? 2 : 1)
+  }
+  const offset = lineStart + position.column - 1
+  return offset <= lineEnd ? offset : undefined
+}
+
 /** Visit maintained emitter coordinates without re-encoding available raw maps.
  * All line numbers at this boundary are zero-based; absent origins stay absent. */
 export function visitSourceMappings(transformed, visit) {

package/internal/stateful-root-compiler.js

@@ -191,8 +191,10 @@ function rewriteRootReferences(code, sourceMap, runtime, candidateNames, candida
     }
     handled.add(path.node.start)
   } })
+  const classificationSource = applySourceEdits(code, sourceMap, classificationEdits)
   return { ...applySourceEdits(code, sourceMap, edits),
-    classificationCode: applySourceEdits(code, sourceMap, classificationEdits).code,
+    classificationCode: classificationSource.code,
+    classificationSourceMap: classificationSource.sourceMap,
     implicitDeclarations: [...implicitDeclarations.values()],
     readNames: [...readNames] }
 }

package/internal/typescript-transform.js

@@ -1,7 +1,9 @@
 import loadAmaro from './compiler-amaro.cjs'
 
-export { LEGACY_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM, PROTECTED_MODULE_TRANSFORM,
-  moduleTransformForLanguage, supportedUserBindingTransform } from './module-transform-contract.js'
+export { LEGACY_USER_BINDING_TRANSFORM, PREVIOUS_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM,
+  PROTECTED_MODULE_TRANSFORM, isStatefulUserBindingTransform,
+  historicalModuleTransformForLanguage, moduleTransformForLanguage, moduleTransformMatchesLanguage,
+  normalizeModuleTransform, supportedUserBindingTransform } from './module-transform-contract.js'
 
 /** Keep binding-module lowering independent of the Host's experimental transform API. */
 export function transformTypeScriptModule(source) {