dsh-ptc-plus 0.4.2 → 0.4.3

package/internal/worker-output-fence.js

@@ -0,0 +1,26 @@
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const FENCE_PREFIX = '\u001eDSH_PTC_OUTPUT_FENCE_V1:'
+const FENCE_SUFFIX = '\u001f'
+const TOKEN = /^[a-f0-9]{48}$/u
+const FENCE = /\u001eDSH_PTC_OUTPUT_FENCE_V1:(?:stdout|stderr):(?:start|end):[a-f0-9]{48}\u001f/gu
+const { regexpTest, replaceString, toString } = internal
+
+export const OUTPUT_FENCE_ALLOWANCE_BYTES = 512
+
+export function validOutputFenceToken(token) {
+  return typeof token === 'string' && regexpTest(TOKEN, token)
+}
+
+export function outputFenceMarker(token, channel, phase) {
+  if (!validOutputFenceToken(token)
+    || (channel !== 'stdout' && channel !== 'stderr')
+    || (phase !== 'start' && phase !== 'end')) {
+    throw new TypeError('invalid worker output fence')
+  }
+  return `${FENCE_PREFIX}${channel}:${phase}:${token}${FENCE_SUFFIX}`
+}
+
+export function stripOutputFenceMarkers(value) {
+  return replaceString(toString(value ?? ''), FENCE, '')
+}

package/internal/worker-realm-surfaces.js

@@ -0,0 +1,197 @@
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const { Error, TypeError, includes, objectFreeze,
+  objectGetOwnPropertyDescriptor, objectHasOwn, toString, Reflect: privateReflect } = internal
+
+export const WORKER_REALM_MUTATION = objectFreeze({
+  STABLE: 'stable-native-divergence',
+  TEMPORARY: 'temporary-compiler-name',
+  PROGRAM: 'per-cell-program-binding',
+  USER: 'user-declaration-binding',
+  RESTORE: 'restoration-only',
+})
+
+const MUTATION_CLASSES = objectFreeze([
+  WORKER_REALM_MUTATION.STABLE,
+  WORKER_REALM_MUTATION.TEMPORARY,
+  WORKER_REALM_MUTATION.PROGRAM,
+  WORKER_REALM_MUTATION.USER,
+  WORKER_REALM_MUTATION.RESTORE,
+])
+
+export const PROCESS_CONTROL_ERROR_CODE = 'ERR_PTC_PROCESS_CONTROL'
+export const WORKER_REALM_SURFACE_CONTRACT = objectFreeze([
+  objectFreeze({
+    surface: 'console',
+    owner: 'internal/kernel-worker.js and internal/user-binding-console-worker.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'native Console methods; output enters the per-cell log budget',
+    reference: 'plain Node worker console methods',
+    verification: 'console-methods',
+  }),
+  objectFreeze({
+    surface: 'process.stdout.write/process.stderr.write',
+    owner: 'internal/kernel-worker.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'captured per cell as writable own methods; direct descriptor output remains covered by the helper transport',
+    reference: 'plain Node worker stream descriptors',
+    verification: 'stream-descriptors',
+  }),
+  objectFreeze({
+    surface: 'process.cwd',
+    owner: 'internal/worker-cwd-virtualization.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'recorded cwd; immutable and non-configurable when a session cwd exists',
+    reference: 'plain Node worker process descriptor',
+    verification: 'cwd-descriptor',
+  }),
+  objectFreeze({
+    surface: 'cwd-projected Node builtins',
+    owner: 'internal/worker-cwd-virtualization.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'relative fs, path, and child-process calls use the recorded cwd while retaining callable descriptors',
+    reference: 'plain Node worker fs, fs/promises, path, and child_process callable descriptors',
+    verification: 'cwd-projected-builtins',
+  }),
+  objectFreeze({
+    surface: 'process.exit/abort/kill/chdir',
+    owner: 'internal/worker-realm-surfaces.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: `immutable lifecycle guards; failures use ${PROCESS_CONTROL_ERROR_CODE}`,
+    reference: 'plain Node worker process descriptors',
+    verification: 'process-controls',
+  }),
+  objectFreeze({
+    surface: 'fd 1/2 and inherited child output',
+    owner: 'internal/worker-client.js and internal/worker-output-capture.js',
+    classification: 'transport-boundary',
+    contract: 'captured in the acknowledged per-cell dual-stream fence window; out-of-round output resets the worker',
+    reference: 'helper stdout/stderr transport contract in ADR 0027',
+    verification: 'descriptor-output',
+  }),
+  objectFreeze({
+    surface: 'cell module metadata',
+    owner: 'internal/session-cell-executor.js and internal/kernel-worker.js and internal/user-binding-console-worker.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'current cells expose import.meta url/filename/dirname; require subset exists without ambient CommonJS wrapper globals',
+    reference: 'plain Node worker CommonJS surface and the session module parent',
+    verification: 'module-surface',
+  }),
+  objectFreeze({
+    surface: 'private AsyncLocalStorage receiver methods',
+    owner: 'internal/async-local-storage-intrinsics.js',
+    classification: WORKER_REALM_MUTATION.STABLE,
+    contract: 'immutable captured getStore, enterWith, and run methods on plugin-private receivers',
+    reference: 'the corresponding native AsyncLocalStorage methods bound to a fresh receiver',
+    verification: 'private-async-local-storage',
+  }),
+  objectFreeze({
+    surface: 'AsyncLocalStorage.prototype.run',
+    owner: 'internal/async-local-storage-intrinsics.js',
+    classification: WORKER_REALM_MUTATION.TEMPORARY,
+    contract: 'native at rest; synchronously replaced only during private REPL bootstrap',
+    reference: 'plain Node worker AsyncLocalStorage descriptors',
+    verification: 'async-local-storage',
+  }),
+])
+
+function assertMutation(classification, surface) {
+  if (!includes(MUTATION_CLASSES, classification)) {
+    throw new TypeError(`unknown worker realm mutation classification: ${classification}`)
+  }
+  if (classification !== WORKER_REALM_MUTATION.STABLE) return
+  let registered = false
+  for (let index = 0; index < WORKER_REALM_SURFACE_CONTRACT.length; index += 1) {
+    const entry = WORKER_REALM_SURFACE_CONTRACT[index]
+    if (entry.surface === surface && entry.classification === classification) registered = true
+  }
+  if (!registered) {
+    throw new TypeError(`stable worker realm mutation requires a matching registered classification: ${surface}`)
+  }
+}
+
+/** The only supported write boundary for worker globals, process surfaces and native prototypes. */
+export function defineWorkerRealmProperty(classification, surface, owner, property, descriptor) {
+  assertMutation(classification, surface)
+  if (!privateReflect.defineProperty(owner, property, descriptor)) {
+    throw new TypeError(`worker realm property ${toString(property)} could not be defined`)
+  }
+  return owner
+}
+
+export function assignWorkerRealmProperty(classification, surface, owner, property, value) {
+  assertMutation(classification, surface)
+  if (!privateReflect.set(owner, property, value)) {
+    throw new TypeError(`worker realm property ${toString(property)} could not be assigned`)
+  }
+  return value
+}
+
+export function deleteWorkerRealmProperty(classification, surface, owner, property) {
+  assertMutation(classification, surface)
+  return privateReflect.deleteProperty(owner, property)
+}
+
+function codedError(code, message) {
+  const error = new Error(message)
+  privateReflect.defineProperty(error, 'code', {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: code,
+  })
+  return error
+}
+
+export function installProjectedProcessCwd(processObject, cwd) {
+  defineWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'process.cwd', processObject, 'cwd', {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: () => cwd,
+  })
+}
+
+export function installProcessControlGuards(processObject, properties) {
+  for (let index = 0; index < properties.length; index += 1) {
+    const property = properties[index]
+    const descriptor = objectGetOwnPropertyDescriptor(processObject, property)
+    defineWorkerRealmProperty(
+      WORKER_REALM_MUTATION.STABLE,
+      'process.exit/abort/kill/chdir',
+      processObject,
+      property,
+      {
+      configurable: false,
+      enumerable: descriptor?.enumerable ?? true,
+      writable: false,
+      value: () => {
+        throw codedError(PROCESS_CONTROL_ERROR_CODE, `process.${property} is forbidden inside the REPL kernel`)
+      },
+      },
+    )
+  }
+}
+
+/** Stable facts consumed by the conformance test and runtime documentation. */
+export function workerRealmSurfaceFacts(processObject) {
+  const descriptor = (owner, name) => {
+    const value = objectGetOwnPropertyDescriptor(owner, name)
+    return value === undefined ? undefined : {
+      configurable: value.configurable,
+      enumerable: value.enumerable,
+      writable: value.writable,
+      own: true,
+    }
+  }
+  const controls = []
+  for (const name of ['exit', 'abort', 'kill', 'chdir']) controls.push([name, descriptor(processObject, name)])
+  return {
+    cwd: descriptor(processObject, 'cwd'),
+    controls,
+    stdoutWrite: descriptor(processObject.stdout, 'write'),
+    stderrWrite: descriptor(processObject.stderr, 'write'),
+    stdoutWriteOwn: objectHasOwn(processObject.stdout, 'write'),
+    stderrWriteOwn: objectHasOwn(processObject.stderr, 'write'),
+  }
+}

package/internal/worker-repl-realm.js

@@ -1,13 +1,16 @@
 import { createContext, runInContext, runInThisContext } from 'node:vm'
 import { types } from 'node:util'
 import { protectNextAsyncLocalStorageRun } from './async-local-storage-intrinsics.js'
+import {
+  WORKER_REALM_MUTATION,
+  defineWorkerRealmProperty,
+  deleteWorkerRealmProperty,
+} from './worker-realm-surfaces.js'
 
 export const WORKER_REPL_OPTIONS = Object.freeze({ useGlobal: true })
 const NativeMap = Map
 const ownKeys = Reflect.ownKeys
-const deleteProperty = Reflect.deleteProperty
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
-const defineProperty = Object.defineProperty
 const createObject = Object.create
 const hasOwn = Object.hasOwn
 const sameValue = Object.is
@@ -54,13 +57,16 @@ export function restoreWorkerReplGlobals(baseline, globalObject = globalThis) {
   const keys = ownKeys(globalObject)
   for (let index = 0; index < keys.length; index += 1) {
     const key = keys[index]
-    if (typeof key === 'string' && !mapHas(baseline, key) && !deleteProperty(globalObject, key)) {
+    if (typeof key === 'string' && !mapHas(baseline, key)
+      && !deleteWorkerRealmProperty(WORKER_REALM_MUTATION.RESTORE, undefined, globalObject, key)) {
       throw new Error(`worker REPL added a non-configurable global ${String(key)}`)
     }
   }
   mapForEach(baseline, (descriptor, key) => {
     if (!descriptorsEqual(getOwnPropertyDescriptor(globalObject, key), descriptor)) {
-      defineProperty(globalObject, key, detachedDescriptor(descriptor))
+      defineWorkerRealmProperty(
+        WORKER_REALM_MUTATION.RESTORE, undefined, globalObject, key, detachedDescriptor(descriptor),
+      )
     }
   })
   return globalObject

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.4.2",
+  "version": "0.4.3",
+  "icon": "assets/ptc-plus-icon.svg",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -25,6 +26,7 @@
     "src",
     "internal",
     "docs",
+    "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",
@@ -61,7 +63,7 @@
     "@codemirror/language": "^6.12.4",
     "@codemirror/state": "^6.7.4",
     "@codemirror/view": "^6.43.11",
-    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/schemastery": "^3.18.3",
     "@jridgewell/trace-mapping": "^0.3.31",
     "@lezer/highlight": "^1.2.3",
     "acorn": "^8.15.0",
@@ -87,17 +89,24 @@
     "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: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:layout": "node scripts/client-binding-layout.mjs",
     "prepack": "npm run build:check",
     "hooks:install": "node scripts/review-findings.mjs install-hook",
     "review:new": "node scripts/review-findings.mjs create",
+    "review:plan:new": "node scripts/review-findings.mjs plan-create",
+    "review:plan": "node scripts/review-findings.mjs plan",
+    "review:status": "node scripts/review-findings.mjs status",
+    "review:lane": "node scripts/review-findings.mjs lane-verdict",
+    "review:finalize": "node scripts/review-findings.mjs finalize",
+    "review:clear": "node scripts/review-findings.mjs review-clear",
     "review:validate": "node scripts/review-findings.mjs validate",
     "review:gate": "node scripts/review-findings.mjs gate",
     "session:migrate": "node scripts/migrate-session-log.mjs",
     "coverage": "node scripts/coverage.mjs",
     "coverage:focus": "node scripts/coverage.mjs --focus",
-    "verify": "npm run review:validate && 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": "npm run review:validate && 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",
     "check": "node scripts/review-findings.mjs check",
     "test:expensive": "node scripts/expensive-headless-acceptance.mjs",
     "test:ab": "node scripts/ab-headless-trajectories.mjs"
@@ -157,6 +166,8 @@
     "@deepseek-ai/dsh-commands": "next",
     "@deepseek-ai/dsh-home-paths": "next",
     "@deepseek-ai/dsh-llm": "next",
+    "@deepseek-ai/dsh-session-format-catalog": "next",
+    "@deepseek-ai/dsh-session-format-v0-to-v1": "next",
     "@deepseek-ai/dsh-session-persistence-jsonl": "next",
     "@deepseek-ai/dsh-settings": "next",
     "@deepseek-ai/dsh-skill-filesystem": "next",
@@ -164,15 +175,36 @@
     "@deepseek-ai/dsh-tools": "next",
     "@deepseek-ai/dsh-typert-protocol": "next",
     "@deepseek-ai/dsh-typert-registry": "next",
+    "@deepseek-ai/dsh-util-workspace-path": "next",
+    "@shikijs/langs": "^4.3.1",
     "@testing-library/react": "^16.3.3",
+    "anser": "^2.3.5",
     "c8": "^12.0.0",
+    "clsx": "^2.0.0",
     "convert-source-map": "^2.0.0",
+    "diff": "^9.0.0",
     "esbuild": "0.28.2",
+    "immer": "^10.1.1",
     "jsdom": "^29.1.1",
+    "katex": "^0.16.47",
+    "mdast-util-from-markdown": "^2.0.3",
+    "mdast-util-gfm": "^3.1.0",
+    "mdast-util-math": "^3.0.0",
+    "micromark-core-commonmark": "^2.0.3",
+    "micromark-extension-gfm": "^3.0.0",
+    "micromark-extension-math": "^3.1.0",
+    "micromark-factory-space": "^2.0.1",
+    "micromark-util-character": "^2.1.1",
+    "micromark-util-classify-character": "^2.0.1",
+    "micromark-util-sanitize-uri": "^2.0.1",
+    "micromark-util-symbol": "^2.0.1",
     "playwright": "^1.63.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
+    "shiki": "^4.3.1",
+    "simple-icons": "16.31.0",
     "vitest": "^5.0.0",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "zustand": "~4.4.7"
   }
 }

package/src/client-activity.js

@@ -105,7 +105,7 @@ function isLine(value) {
 }
 
 function isSafeSequence(value) {
-  return Number.isSafeInteger(value) && value >= 0
+  return Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0)
 }
 
 function isValidPosition(value) {
@@ -187,6 +187,7 @@ function isValidValueWire(value) {
     nodeCount: value.nodes.length,
     discovered: new Set(),
     edges: 0,
+    arraySlots: 0,
     textBytes: 0,
   }
   if (!isValidValueAtom(value.root, state)) return false
@@ -196,6 +197,8 @@ function isValidValueWire(value) {
       if (!hasExactOrderedFields(node, VALUE_ARRAY_FIELDS)
         || !Number.isSafeInteger(node.length) || node.length < 0 || node.length > MAX_ARRAY_LENGTH
         || !Array.isArray(node.entries)) return false
+      state.arraySlots += node.length
+      if (state.arraySlots > MAX_ARRAY_LENGTH) return false
       let previous = -1
       for (const entry of node.entries) {
         if (!Array.isArray(entry) || entry.length !== 2 || !Number.isSafeInteger(entry[0])