dsh-ptc-plus 0.5.1 → 0.5.3

package/internal/session-state.js

@@ -94,6 +94,33 @@ export class BindingCatalog {
     }
   }
 
+  /**
+   * Catalog after installing recorded values.
+   *
+   * A restored node is not compiled: its source may be dead (it can reference a
+   * binding a recorded rewind ended), so there is no preparation to take
+   * declarations from. The journal records the names and values but not their
+   * declaration kind, so a restored binding is catalogued as reassignable. That is
+   * deliberately permissive: refusing a later `let`-style redeclaration would break
+   * continuation, while accepting one only widens what the session may do with a
+   * binding whose original declaration the log cannot describe.
+   */
+  restore(names) {
+    if (!Array.isArray(names) || names.length === 0) return this
+    const entries = new Map(this.#entries)
+    for (const name of names) {
+      if (typeof name !== 'string' || entries.has(name)) continue
+      entries.set(name, { kind: 'let', writable: true })
+    }
+    return new BindingCatalog({
+      entries,
+      namespaces: this.#namespaces,
+      userBindingAncestry: this.#userBindingAncestry,
+      rootCandidates: this.#rootCandidates,
+      dynamicOrigins: this.#dynamicOrigins,
+    })
+  }
+
   advance(prepared, source = undefined, committedRedeclarations = undefined, rootBindingFacts = undefined) {
     const semantics = normalizeLanguageSemantics(prepared.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS)
     if (semantics === LEGACY_LANGUAGE_SEMANTICS) {

package/internal/stateful-root-compiler.js

@@ -1,4 +1,5 @@
 /** Compile each cell into a private native frame backed by session identities. */
+import { boundedLiteralEvidence } from './bounded-literal.js'
 import { adaptRootModuleImports } from './managed-module-operations.js'
 import { parse } from '@babel/parser'
 import { createHash } from 'node:crypto'
@@ -321,11 +322,21 @@ export function compileStatefulRoot(program, {
       return remember(text, [{ generatedStart: 6, generatedEnd: 6 + source.length,
         originalStart: original.start, originalEnd: original.end }])
     }
+    const firstDeclaration = declarations.length
     const target = record(names[0], 'variable', node, bindings[0], `:${declarator.start}`)
     for (const binding of bindings.slice(1)) {
       record(binding.name, 'variable', node, binding, `:${declarator.start}`)
       declarations.at(-1).commitDependency = target
     }
+    // A single `const name = { … }` initializer proves its own size from the
+    // source, so settlement may record that value without walking an object the
+    // codec cannot size. A destructuring pattern has no one initializer to prove.
+    if (declarator.id.type === 'Identifier' && supplied === undefined && declarator.init !== null) {
+      const evidence = boundedLiteralEvidence(declarator.init)
+      if (evidence !== undefined) {
+        for (const declaration of declarations.slice(firstDeclaration)) declaration.boundedLiteral = evidence
+      }
+    }
     if (declarator.init === null && supplied === undefined) {
       return emptyCompletion(`${runtime}.declare(${JSON.stringify(names[0])}, ${JSON.stringify(target)})`)
     }

package/internal/stateful-root-runtime.js

@@ -333,6 +333,23 @@ export function createStatefulRootRuntime({ readAmbient, typeofAmbient, writeAmb
       const entry = mapGet(entries, name)
       return entry?.source === 'local' && entry.object !== true && entry.read === undefined ? { value: entry.value } : undefined
     },
+    /**
+     * Install a recorded binding without running the cell that produced it.
+     *
+     * A volatile cell cannot be replayed: re-executing its source would
+     * redispatch the ambient effects that made it volatile. Recovery therefore
+     * installs the value the journal recorded, as the committed local
+     * declaration the original cell's own commit produced. Returns false when
+     * the store cannot publish a session identity for the name, so the caller
+     * reports that binding instead of claiming it was restored.
+     */
+    restoreValue(name, value) {
+      const entry = storeValue(name, value, { declaration: true })
+      if (entry === undefined) return false
+      publish(name, () => read(name), next => write(name, next))
+      changed(name, 'local')
+      return true
+    },
     has: name => mapHas(entries, name) && mapGet(entries, name).object !== true && mapGet(entries, name).deleted !== true,
     facts() {
       const facts = []

package/internal/user-binding-console.js

@@ -55,6 +55,12 @@ export class UserBindingConsole {
   async reconfigure(options) {
     // Reconfiguration releases the current environments; the owner stays usable so
     // a later run can start again.
+    if (this.options.workerReclaimMs !== options.workerReclaimMs && Number.isSafeInteger(options.workerReclaimMs)) {
+      // A bound change needs no new worker: the close path reads the transport.
+      for (const environment of this.environments.values()) {
+        environment.worker.reclaimBoundMs = options.workerReclaimMs
+      }
+    }
     if (['maxWallMs', 'maxOutputBytes', 'maxOldGenerationSizeMb'].some(key => this.options[key] !== options[key])) {
       for (const capability of [...this.environments.keys()]) this.release(capability, 'reconfigured')
       const failures = await this.owner.releaseAll()
@@ -88,6 +94,7 @@ export class UserBindingConsole {
         workerData: { source, cwd: this.options.cwd, maxOutputBytes: this.options.maxOutputBytes },
         env: normalizeWorkerEnvironment(process.env),
         resourceLimits: { maxOldGenerationSizeMb: this.options.maxOldGenerationSizeMb },
+        reclaimBoundMs: this.options.workerReclaimMs,
         protocol: 'parent-port',
       })
       const worker = started.transport

package/internal/user-bindings-owner.js

@@ -1,5 +1,12 @@
 import { PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
+import { sessionExecutionAvailable } from './host-tool-sdk.js'
 import { bindingToggleMessage } from './binding-toggle-receipt.js'
+import {
+  bindingAdoptionMessage,
+  clearedBindingAdoption,
+  declinedBindingEntries,
+  withBindingAdoption,
+} from './binding-adoption.js'
 import { RPC_CONTRACTS } from './rpc-contract.js'
 import { randomUUID } from 'node:crypto'
 import { dirname } from 'node:path'
@@ -26,6 +33,7 @@ import {
   createUserBindingsSnapshot,
   normalizeUserBindingEntry,
   normalizeUserBindingsDocument,
+  selectUserBindingsSnapshot,
   storedUserBindingsDocument,
 } from './user-bindings.js'
 
@@ -78,6 +86,40 @@ function parseAuthoringCommand(rawInput) {
   return { kind: 'help' }
 }
 
+/**
+ * The adoption subcommands of `/binding`. They state which supplied entries this
+ * session uses; authoring and adoption share one command because both answer
+ * questions about the same global catalog, and a second command would suggest
+ * they were separate features.
+ */
+function parseAdoptionCommand(rawInput) {
+  const input = typeof rawInput === 'string' ? rawInput.trim() : ''
+  if (input === 'status') return { kind: 'status' }
+  if (input === 'reset') return { kind: 'reset' }
+  const decision = /^(use|skip)\s+(\S+)$/.exec(input)
+  if (decision === null) return undefined
+  return { kind: decision[1] === 'use' ? 'use' : 'skip', id: decision[2] }
+}
+
+function adoptionStatusText(catalog, adoption) {
+  const declined = declinedBindingEntries(adoption)
+  const supplied = catalog.entries
+  const listed = supplied.map(entry => `${entry.id} (${entry.name}): ${declined.has(entry.id)
+    ? 'not used by this session' : 'used by this session'}`)
+  const unavailable = [...declined].filter(id => !supplied.some(entry => entry.id === id))
+  return [
+    'Global binding catalog supply and this session\'s adoption of it. Adoption decides which supplied entries this session uses; it does not report whether the worker installed them.',
+    ...(listed.length === 0 ? ['The global catalog supplies no enabled entries.'] : listed),
+    ...(unavailable.length === 0 ? [] : [`Declined but not supplied by the global catalog, therefore not used and not revivable here: ${JSON.stringify(unavailable)}`]),
+  ].join('\n')
+}
+
+function adoptionReceipt(adoption) {
+  return `Session binding adoption recorded. This session declines ${JSON.stringify([...declinedBindingEntries(adoption)])}. `
+    + 'The global catalog and other sessions are unchanged, and adoption can only withdraw a supplied entry. '
+    + 'Whether the worker installed the entries this session still uses is reported with the next accepted cell, not by this receipt.'
+}
+
 function authoringTask(command, current) {
   if (command.kind === 'new') {
     return `Create a Global User Binding draft for this requirement:\n\n${command.requirement}`
@@ -111,6 +153,7 @@ function runCandidate(source, invocation, options, signal, owner) {
       workerData: { source, invocation, valueLimits: options.valueLimits, cwd: options.cwd },
       env: normalizeWorkerEnvironment(process.env),
       resourceLimits: { maxOldGenerationSizeMb: options.maxOldGenerationSizeMb },
+      reclaimBoundMs: options.workerReclaimMs,
     })
     const worker = started.transport
     const outputLimitError = () => Object.assign(
@@ -183,6 +226,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
     maxWallMs: options.maxWallMs,
     maxOutputBytes: options.maxOutputBytes,
     maxOldGenerationSizeMb: options.maxOldGenerationSizeMb,
+    workerReclaimMs: options.workerReclaimMs,
     valueLimits: options.valueLimits,
   }
   let disposed = false
@@ -263,6 +307,48 @@ export function createUserBindingsOwner(ctx, options = {}) {
   const requireEnabled = () => {
     if (!enabled) throw new Error('Global User Bindings are disabled')
   }
+  // Adoption is read from the session's own recorded decision, never from a
+  // second in-memory map: the log is the owner, so a restart reconstructs the
+  // same environment without a migration step.
+  const adoptionForAgent = (agent) => {
+    if (typeof options.bindingAdoptionForAgent !== 'function' || agent === undefined || agent === null) return undefined
+    return options.bindingAdoptionForAgent(agent)
+  }
+  /**
+   * Supply minus this session's declines. The catalog decides which entries
+   * exist; adoption only withdraws one, so no entry can appear here that the
+   * global configuration did not supply.
+   */
+  const adoptedCatalog = (snapshot, adoption) => {
+    const declined = declinedBindingEntries(adoption)
+    if (declined.size === 0) return snapshot
+    const kept = snapshot.entries.filter(entry => !declined.has(entry.id))
+    if (kept.length === snapshot.entries.length) return snapshot
+    return selectUserBindingsSnapshot(snapshot, kept.map(entry => entry.id))
+  }
+  const recordAdoption = (agent, adoption) => {
+    const session = agent?.session
+    if (session === undefined || typeof session.append !== 'function') {
+      throw new Error('binding adoption requires a live session')
+    }
+    if (session.append('user/message', bindingAdoptionMessage(adoption), { surfaceOp: 'append' }) === undefined) {
+      throw new Error('the session did not record the binding adoption decision')
+    }
+    return { kind: 'success', text: adoptionReceipt(adoption) }
+  }
+  const stateAdoption = async (agent, command) => {
+    requireEnabled()
+    // Status and validation read the full supplied catalog: an adopted subset
+    // cannot prove what it was derived from.
+    const catalog = await store.snapshot()
+    const current = adoptionForAgent(agent)
+    if (command.kind === 'status') return { kind: 'success', text: adoptionStatusText(catalog, current) }
+    if (command.kind === 'reset') return recordAdoption(agent, clearedBindingAdoption())
+    if (!catalog.entries.some(entry => entry.id === command.id)) {
+      throw new Error(`the global binding catalog does not supply entry ${JSON.stringify(command.id)}; this session can decline a supplied entry but cannot add or revive one`)
+    }
+    return recordAdoption(agent, withBindingAdoption(current, command.id, command.kind === 'use'))
+  }
   const draftFor = (capability) => {
     if (typeof capability !== 'string' || capability === '') {
       throw new TypeError('draft capability must be a non-empty string')
@@ -480,7 +566,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
     const requireCurrentAgent = () => {
       if (!agentIsCurrent(agent, sessionId, agentGeneration)
         || commandRegistrations.get(sessionId)?.agent !== agent
-        || ctx.tools.get('run_code', agent) === undefined) {
+        || !sessionExecutionAvailable(ctx.tools, agent)) {
         throw new Error('this binding authoring Agent is no longer active')
       }
     }
@@ -615,6 +701,14 @@ export function createUserBindingsOwner(ctx, options = {}) {
 
   const commandHandler = async ({ agent, rawInput, signal, commandId }) => {
     signal?.throwIfAborted?.()
+    const adoption = parseAdoptionCommand(rawInput)
+    if (adoption !== undefined) {
+      try {
+        return await stateAdoption(agent, adoption)
+      } catch (error) {
+        return { kind: 'error', text: error instanceof Error ? error.message : String(error) }
+      }
+    }
     const command = parseAuthoringCommand(rawInput)
     if (command.kind === 'help') return { kind: 'error', text: `Usage: ${COMMAND_USAGE}` }
     try {
@@ -658,14 +752,14 @@ export function createUserBindingsOwner(ctx, options = {}) {
         // still claiming one.
         if (disposed || !enabled || lifecycleGeneration !== registration.generation
           || !agentIsCurrent(agent, sessionId, agentGeneration)
-          || ctx.tools.get('run_code', agent) === undefined
+          || !sessionExecutionAvailable(ctx.tools, agent)
           || commandRegistrations.get(sessionId) !== registration) {
           throw new Error('Global User Bindings binding command registration is no longer eligible')
         }
         registerOwned(commandCtx, commandCtx.commands, {
           name: 'binding',
-          description: 'Create or revise a Global User Binding draft with the current agent',
-          input: { hint: 'new <requirement> | edit <id> <requirement>' },
+          description: 'Author a Global User Binding draft, or state which supplied entries this session uses',
+          input: { hint: 'new <requirement> | edit <id> <requirement> | status | use <id> | skip <id> | reset' },
           handler: commandHandler,
         }, 'binding command')
       })
@@ -710,13 +804,13 @@ export function createUserBindingsOwner(ctx, options = {}) {
     }
     if (!agentIsCurrent(agent, sessionId, agentGeneration)) return
     const eligible = enabled && draftProjectionAvailable && !disposed
-      && ctx.tools.get('run_code', agent) !== undefined
+      && sessionExecutionAvailable(ctx.tools, agent)
     const current = commandRegistrations.get(sessionId)
     if (eligible && current?.agent === agent) return
     if (current !== undefined) await removeCommandFor(sessionId, current)
     if (!agentIsCurrent(agent, sessionId, agentGeneration)) return
     const stillEligible = enabled && draftProjectionAvailable && !disposed
-      && ctx.tools.get('run_code', agent) !== undefined
+      && sessionExecutionAvailable(ctx.tools, agent)
     if (stillEligible) {
       registerCommandFor(agent)
       return
@@ -916,6 +1010,17 @@ export function createUserBindingsOwner(ctx, options = {}) {
     async snapshot() {
       return enabled ? store.snapshot() : undefined
     },
+    /**
+     * The catalog entries one session's worker should receive. Without a stated
+     * adoption this is exactly the supplied catalog, so 0.5.2 behavior is
+     * unchanged for every session that never declines an entry.
+     */
+    async snapshotForAgent(agent) {
+      if (!enabled) return undefined
+      const snapshot = await store.snapshot()
+      const adoption = adoptionForAgent(agent)
+      return adoption === undefined ? snapshot : adoptedCatalog(snapshot, adoption)
+    },
     async list() {
       requireEnabled()
       return store.list()
@@ -975,6 +1080,7 @@ export function createUserBindingsOwner(ctx, options = {}) {
         maxWallMs: nextConfig.maxWallMs,
         maxOutputBytes: nextConfig.maxOutputBytes,
         maxOldGenerationSizeMb: nextConfig.maxOldGenerationSizeMb,
+        workerReclaimMs: nextConfig.workerReclaimMs,
         valueLimits: valueLimitsFromConfig(nextConfig),
       }
       if (nextEnabled === previousEnabled) {

package/internal/user-bindings.js

@@ -268,7 +268,7 @@ export function userBindingsDeclaration(snapshot) {
   return normalized.entries.map(entry => entry.declaration).join('\n\n')
 }
 
-export function userBindingsConfiguredContext(snapshot) {
+export function userBindingsConfiguredContext(snapshot, { entryLabel = 'Binding' } = {}) {
   const entries = normalizeUserBindingsSnapshot(snapshot).entries
     .filter(entry => {
       const { includeDeclaration, instructions } = bindingModelPreferences(entry.modelContext)
@@ -279,7 +279,7 @@ export function userBindingsConfiguredContext(snapshot) {
   const content = entries.map(entry => {
     const { includeDeclaration, instructions } = bindingModelPreferences(entry.modelContext)
     return [
-      `Binding: ${entry.name}`,
+      `${entryLabel}: ${entry.name}`,
       instructions,
       includeDeclaration ? `\`\`\`ts\n${entry.declaration}\n\`\`\`` : '',
     ].filter(Boolean).join('\n\n')

package/internal/validated-parse-repair.js

@@ -31,7 +31,7 @@ function startsInsideSurrogatePair(source, index) {
   return current >= 0xdc00 && current <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff
 }
 
-function boundedUniqueSuffix(source) {
+export function boundedUniqueSuffix(source) {
   const first = Math.max(0, source.length - MAX_PARSE_REPAIR_ANCHOR_CODE_UNITS)
   for (let start = source.length - 1; start >= first; start -= 1) {
     if (startsInsideSurrogatePair(source, start)) continue
@@ -81,6 +81,11 @@ export function validatedEofClosureRepair({ source, position, prepare, targetCal
   const candidate = candidates[0]
   return Object.freeze({
     ...candidate,
+    // The diagnostic names the target cell instead of embedding the whole
+    // invocation: the JSON form is hundreds of characters the model has to copy
+    // before it can act, while the delimiter and the target are the two facts it
+    // needs.
+    targetCallSeq,
     invocation: renderInvocation(candidate.arguments),
   })
 }

package/internal/worker-client.js

@@ -1,4 +1,4 @@
-import { mkdtemp, rm } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm } from 'node:fs/promises'
 import { randomBytes } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { isAbsolute, join } from 'node:path'
@@ -46,7 +46,15 @@ export class WorkerClient {
     return lastLine === undefined ? undefined : lastLine.slice(0, 300)
   }
 
-  async ensure(maxOldGenerationSizeMb) {
+  /**
+   * Start the session worker once and reuse it.
+   *
+   * `bounds` carries the startup bound for a worker that does not exist yet and
+   * the close bound this worker starts with; a later close reads the bound the
+   * owning kernel sets from its current configuration. It may be a getter, which
+   * is read after the scratch wait because a settings change can land there.
+   */
+  async ensure(maxOldGenerationSizeMb, bounds = {}) {
     if (this.pendingOutputFailure !== undefined) {
       const message = this.pendingOutputFailure
       this.pendingOutputFailure = undefined
@@ -61,7 +69,14 @@ export class WorkerClient {
       if (!isAbsolute(scratchRoot)) {
         throw new Error(`ptc-plus: host temporary directory must be absolute, got ${JSON.stringify(scratchRoot)}`)
       }
-      this.scratchReady = mkdtemp(join(scratchRoot, 'dsh-ptc-plus-'))
+      this.scratchReady = mkdtemp(join(scratchRoot, 'dsh-ptc-plus-')).catch(async error => {
+        // A host that points TMPDIR at a directory it has not created yet (macOS CI)
+        // fails mkdtemp with ENOENT; create the root once and retry instead of
+        // failing the cell with a worker-exit error.
+        if (error?.code !== 'ENOENT') throw error
+        await mkdir(scratchRoot, { recursive: true })
+        return mkdtemp(join(scratchRoot, 'dsh-ptc-plus-'))
+      })
     }
     this.workerLimit = maxOldGenerationSizeMb
     let scratchDirectory
@@ -79,13 +94,21 @@ export class WorkerClient {
     /* c8 ignore next */
     if (this.worker !== undefined) return this.workerReady
     const environment = normalizeWorkerEnvironment(process.env)
+    // A settings change can land while the scratch directory is being created,
+    // so the bounds are read here rather than at the call.
+    const resolvedBounds = typeof bounds === 'function' ? bounds() : bounds
     let worker
     try {
       const started = this.owner.start({
         helper: KERNEL_HELPER,
         entry: this.workerUrl,
-        workerData: { cwd: this.cwd, compilerCache: this.compilerCache?.() },
+        workerData: {
+          cwd: this.cwd,
+          compilerCache: this.compilerCache?.(),
+          startupProbeMs: resolvedBounds.startupProbeMs,
+        },
         resourceLimits: { maxOldGenerationSizeMb: this.workerLimit },
+        reclaimBoundMs: resolvedBounds.reclaimBoundMs,
         env: {
           ...environment,
           TEMP: scratchDirectory,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "icon": "assets/ptc-plus-icon.svg",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
@@ -69,9 +69,15 @@
     "@deepseek-ai/dsh-skill-filesystem": "*",
     "@deepseek-ai/dsh-spill-policy": "*",
     "@deepseek-ai/dsh-tool-cordis": "*",
+    "@deepseek-ai/dsh-tool-executor-ptc": "*",
     "@deepseek-ai/dsh-tools": "*",
     "@deepseek-ai/dsh-typert-protocol": "*"
   },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-tool-executor-ptc": {
+      "optional": true
+    }
+  },
   "scripts": {
     "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",
@@ -88,8 +94,9 @@
     "test:client:fallback": "node scripts/client-fallback-smoke.mjs",
     "test:client:layout": "node scripts/client-binding-layout.mjs",
     "readme:screenshots": "node scripts/readme-screenshots.mjs",
-    "host:baseline:update": "node scripts/dsh-dependency-baseline.mjs update",
-    "host:baseline:verify": "node scripts/dsh-dependency-baseline.mjs verify",
+    "host:channels:update": "node scripts/host-channel-manifest.mjs update",
+    "host:channels:graph": "node scripts/host-channel-manifest.mjs graph",
+    "host:channels:verify": "node scripts/host-channel-manifest.mjs verify",
     "test:host-contract": "node scripts/dsh-host-contract-suite.mjs",
     "prepack": "npm run build:check",
     "hooks:install": "node scripts/review-findings.mjs install-hook",
@@ -107,14 +114,17 @@
     "coverage:focus": "node scripts/coverage.mjs --focus",
     "test:backend:focus": "node scripts/test-suite-files.mjs --focus",
     "test:backend": "node scripts/test-suite-files.mjs",
+    "test:backend:fast": "node scripts/test-suite-files.mjs --fast",
     "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 && node scripts/deterministic-test-groups.mjs",
-    "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 && node scripts/deterministic-test-groups.mjs --ci",
+    "verify": "npm run review:validate && npm run host:channels:verify && npm run host:shape-check && 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 && node scripts/deterministic-test-groups.mjs",
+    "verify:check": "npm run review:validate && npm run host:channels:verify && npm run host:shape-check && npm run semantic:check && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node scripts/deterministic-test-groups.mjs --check",
+    "verify:ci": "npm run review:validate && npm run host:channels:verify && npm run host:shape-check && 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 scripts/deterministic-test-groups.mjs --ci",
     "check": "node scripts/review-findings.mjs check",
     "verify:docs": "node scripts/review-findings.mjs docs",
     "test:expensive": "node scripts/expensive-headless-acceptance.mjs",
     "test:ab": "node scripts/ab-headless-trajectories.mjs",
-    "test:package:consumer": "node scripts/npm-consumer-smoke.mjs"
+    "test:package:consumer": "node scripts/npm-consumer-smoke.mjs",
+    "host:shape-check": "node scripts/check-host-version-literals.mjs"
   },
   "keywords": [
     "deepseek-harness",

package/src/client-activity.js

@@ -249,12 +249,30 @@ function isValidModuleSemantics(value, version) {
     && (legacy || IMPORT_EXPRESSION_BOUNDARIES.has(value.importExpressionBoundary))
 }
 
+/**
+ * The retention window keeps everything recovery reads and replaces one payload
+ * with the digest of exactly the bytes it used to carry, so a recorded call keeps
+ * the Value V1 wire of its arguments or the digest of that wire, and a derived run
+ * keeps its source or the digest of that source. `normalizeCalls` and
+ * `normalizeDerivedRelation` accept exactly one of the two shapes and reject a
+ * record that claims both, so this boundary reports which shape it read.
+ */
+function payloadShape(value, textField, digestField, bytesField) {
+  if (Object.hasOwn(value, textField)) {
+    return Object.hasOwn(value, digestField) || Object.hasOwn(value, bytesField) ? undefined : 'text'
+  }
+  return typeof value[digestField] === 'string' && /^[a-f0-9]{64}$/u.test(value[digestField])
+    && isSafeSequence(value[bytesField]) ? 'digest' : undefined
+}
+
 function isValidCall(value) {
   if (!isRecord(value) || (value.ok !== true && value.ok !== false)) return false
   const fields = value.ok ? CALL_SUCCESS_FIELDS : CALL_ERROR_FIELDS
-  if (!hasExactFields(value, fields) || typeof value.global !== 'string'
-    || typeof value.member !== 'string' || !isValidValueWire(value.args)
+  const argsShape = payloadShape(value, 'args', 'argsDigest', 'argsBytes')
+  if (argsShape === undefined || !hasClosedFields(value, fields)
+    || typeof value.global !== 'string' || typeof value.member !== 'string'
     || !isSafeSequence(value.settle)) return false
+  if (argsShape === 'text' && !isValidValueWire(value.args)) return false
   return value.ok ? isValidValueWire(value.value) : typeof value.error === 'string'
 }
 
@@ -389,8 +407,10 @@ function isValidEditTarget(value) {
 
 function isValidDerivedRun(value) {
   try {
-    return hasExactFields(value, DERIVED_RUN_FIELDS)
-      && typeof value.code === 'string' && typeof value.description === 'string'
+    if (!isRecord(value) || !hasClosedFields(value, DERIVED_RUN_FIELDS)
+      || typeof value.description !== 'string') return false
+    const codeShape = payloadShape(value, 'code', 'codeDigest', 'codeBytes')
+    return codeShape === 'digest' || (codeShape === 'text' && typeof value.code === 'string')
   } catch {
     return false
   }