dsh-ptc-plus 0.2.4 → 0.3.2

package/internal/config-spec.js

@@ -20,14 +20,104 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '',
     descriptionEn: '',
   },
+  {
+    key: 'enhancedToolView',
+    type: 'boolean',
+    default: true,
+    label: '使用 PTC Plus 增强工具卡片',
+    labelEn: 'Use enhanced PTC Plus tool cards',
+    description: '开启时使用增强工具卡片；关闭后使用 DSH 原生工具卡片。',
+    descriptionEn: 'Uses enhanced tool cards when enabled and DSH native tool cards when disabled.',
+  },
+  {
+    key: 'autoDescribeRunCode',
+    type: 'boolean',
+    default: true,
+    label: '允许执行缺少摘要的 run_code',
+    labelEn: 'Allow run_code execution without a summary',
+    description: '允许 run_code 缺少外层 description；关闭后恢复 DSH 校验。模型请求和原始调用参数保持不变。',
+    descriptionEn: 'Allows run_code to omit its outer description; disabling restores DSH validation. Model requests and original call arguments remain unchanged.',
+  },
+  {
+    key: 'canonicalizeToolCalls',
+    type: 'boolean',
+    default: true,
+    label: '修复可识别的顶层 native 工具误调用',
+    labelEn: 'Repair recognizable top-level native tool mis-calls',
+    description: '仅当当前 schema 能唯一确认目标工具且参数有效时，才把顶层 native 工具误调用修复为对应的 run_code 调用。',
+    descriptionEn: 'Repairs a top-level native tool mis-call as the corresponding run_code call only when the current schema uniquely identifies the tool and validates its arguments.',
+  },
   {
     key: 'cordisToolsEnabled',
     type: 'boolean',
     default: false,
-    label: '在 PTC 模式中启用 Cordis 工具',
-    labelEn: 'Enable Cordis tools in PTC mode',
-    description: '即时为 PTC agent 加入或移除官方 Cordis 工具。',
-    descriptionEn: 'Adds or removes the official Cordis tools for the PTC agent immediately.',
+    label: '在 PTC 模式中启用官方 Cordis 工具',
+    labelEn: 'Enable official Cordis tools in PTC mode',
+    description: '开启后，PTC agent 可使用官方 Cordis 工具、配套指引和开发 Skill；关闭后移除这些能力。Cordis 工具以 DSH 进程权限运行。',
+    descriptionEn: 'When enabled, PTC agents can use the official Cordis tools, guidance, and development Skill; disabling removes them. Cordis tools run with the DSH process permissions.',
+  },
+  {
+    key: 'looseTopLevelRedeclarations',
+    type: 'boolean',
+    default: true,
+    label: '允许顶层变量重声明',
+    labelEn: 'Allow top-level variable redeclarations',
+    description: '允许顶层 const 或 let 声明替换已有变量；关闭后，重声明会在执行前被拒绝。',
+    descriptionEn: 'Allows top-level const or let declarations to replace existing variables; disabling rejects redeclarations before execution.',
+  },
+  {
+    key: 'looseTopLevelFunctionClassRedeclarations',
+    type: 'boolean',
+    default: false,
+    label: '允许顶层函数/类重声明',
+    labelEn: 'Allow top-level function/class redeclarations',
+    description: '允许顶层 function 或 class 声明替换已有的可写 binding；不可写或保留 binding 仍会在执行前被拒绝。',
+    descriptionEn: 'Allows top-level function or class declarations to replace existing writable bindings; immutable and reserved bindings are still rejected before execution.',
+  },
+  {
+    key: 'autoRewriteImports',
+    type: 'boolean',
+    default: true,
+    label: '支持静态 import 声明',
+    labelEn: 'Support static import declarations',
+    description: '允许在 run_code 中使用静态 import，并保留模块解析和只读 binding 语义。',
+    descriptionEn: 'Allows static import declarations in run_code while preserving module resolution and read-only binding semantics.',
+  },
+  {
+    key: 'autoStripExports',
+    type: 'boolean',
+    default: true,
+    label: '支持顶层 export 修饰符',
+    labelEn: 'Support top-level export modifiers',
+    description: '允许在 run_code 中使用顶层 export，并保留对应的本地声明或模块副作用。',
+    descriptionEn: 'Allows top-level export syntax in run_code while preserving the corresponding local declaration or module side effect.',
+  },
+  {
+    key: 'autoSplitRedeclarations',
+    type: 'boolean',
+    default: true,
+    label: '支持混合解构重声明',
+    labelEn: 'Support mixed destructuring redeclarations',
+    description: '允许顶层解构声明同时包含新变量和已有变量。',
+    descriptionEn: 'Allows top-level destructuring declarations to contain both new and existing variables.',
+  },
+  {
+    key: 'durableReplay',
+    type: 'boolean',
+    default: true,
+    label: '启用持久 REPL 恢复',
+    labelEn: 'Enable durable REPL recovery',
+    description: 'worker 重启后从 session journal 重建可恢复的 REPL 状态。',
+    descriptionEn: 'Rebuilds recoverable REPL state from the session journal after a worker restart.',
+  },
+  {
+    key: 'tipsEnabled',
+    type: 'boolean',
+    default: true,
+    label: '启用失败恢复提示',
+    labelEn: 'Enable failure recovery tips',
+    description: '在符合条件的失败后显示有冷却间隔的恢复提示。',
+    descriptionEn: 'Shows recovery tips with a cooldown after qualifying failures.',
   },
   {
     key: 'computeMs',
@@ -35,10 +125,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 60_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '单 cell 最大 CPU 时间 (ms)',
-    labelEn: 'Max CPU time per cell (ms)',
-    description: '同步计算超过该预算的 cell 会被中断。',
-    descriptionEn: 'Cells whose synchronous computation exceeds this budget are interrupted.',
+    label: '单 cell CPU 时间上限 (ms)',
+    labelEn: 'CPU time limit per cell (ms)',
+    description: '同步计算超过该上限时中断当前 cell。',
+    descriptionEn: 'Interrupts the current cell when synchronous computation exceeds this limit.',
   },
   {
     key: 'maxWallMs',
@@ -46,32 +136,43 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 600_000,
     min: 1,
     max: MAX_TIMER_DELAY_MS,
-    label: '单 cell 最大墙钟时间 (ms)',
-    labelEn: 'Max wall-clock time per cell (ms)',
-    description: '完整 cell 执行（含异步等待）的最长耗时。',
-    descriptionEn: 'The longest a full cell execution may take, including async waits.',
+    label: '单 cell 总耗时上限 (ms)',
+    labelEn: 'Elapsed time limit per cell (ms)',
+    description: '限制完整 cell 执行的耗时，包括异步等待。',
+    descriptionEn: 'Limits the complete cell execution time, including asynchronous waits.',
   },
   {
-    key: 'maxOutputBytes',
+    key: 'maxOldGenerationSizeMb',
     type: 'integer',
-    default: 64 * 1024 * 1024,
+    default: 512,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '最大输出字节',
-    labelEn: 'Max output bytes',
-    description: '限制单个 cell 的输出和结果数据总大小。',
-    descriptionEn: 'Caps the combined size of one cell output and result data.',
+    label: '每个 worker 旧生代内存上限 (MiB)',
+    labelEn: 'Old-generation memory limit per worker (MiB)',
+    description: '限制每个 worker 的 V8 旧生代；活动 worker 存在时不能修改。',
+    descriptionEn: 'Limits the V8 old generation for each worker; this setting cannot change while a worker is active.',
   },
   {
-    key: 'maxOldGenerationSizeMb',
+    key: 'maxNestedRunCodeDepth',
     type: 'integer',
-    default: 512,
+    default: 8,
+    min: 1,
+    max: Number.MAX_SAFE_INTEGER,
+    label: 'code.run 嵌套层数上限',
+    labelEn: 'code.run nesting depth limit',
+    description: '限制单个顶层 cell 中 code.run 的最大嵌套层数。',
+    descriptionEn: 'Limits the maximum code.run nesting depth within one top-level cell.',
+  },
+  {
+    key: 'maxOutputBytes',
+    type: 'integer',
+    default: 64 * 1024 * 1024,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: 'worker 旧生代内存上限 (MiB)',
-    labelEn: 'Worker old-generation memory cap (MiB)',
-    description: '每个 worker 的 V8 旧生代上限；活动 worker 存在时修改会被拒绝。',
-    descriptionEn: 'Per-worker V8 old-generation limit; changes are rejected while an active worker exists.',
+    label: '单 cell 输出上限 (bytes)',
+    labelEn: 'Output limit per cell (bytes)',
+    description: '限制单个 cell 的日志和返回结果的合计大小。',
+    descriptionEn: 'Limits the combined size of one cell\'s logs and returned result.',
   },
   {
     key: 'maxValueNodes',
@@ -79,10 +180,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 100_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: 'Value Graph 最大节点数',
-    labelEn: 'Max Value Graph nodes',
-    description: '限制单次返回值的节点数。',
-    descriptionEn: 'Caps the node count of a single returned value.',
+    label: '返回值节点数上限',
+    labelEn: 'Returned-value node limit',
+    description: '限制单次返回值的 Value Graph 节点数。',
+    descriptionEn: 'Limits the Value Graph node count for one returned value.',
   },
   {
     key: 'maxValueEdges',
@@ -90,10 +191,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 1_000_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: 'Value Graph 最大边数',
-    labelEn: 'Max Value Graph edges',
-    description: '限制单次返回值的引用关系数。',
-    descriptionEn: 'Caps the reference-edge count of a single returned value.',
+    label: '返回值引用边数上限',
+    labelEn: 'Returned-value reference-edge limit',
+    description: '限制单次返回值的 Value Graph 引用边数。',
+    descriptionEn: 'Limits the Value Graph reference-edge count for one returned value.',
   },
   {
     key: 'maxValueArrayLength',
@@ -101,10 +202,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 1_000_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '数组最大声明长度',
-    labelEn: 'Max declared array length',
-    description: '限制返回数组的最大长度。',
-    descriptionEn: 'Caps the maximum length of a returned array.',
+    label: '返回数组长度上限',
+    labelEn: 'Returned-array length limit',
+    description: '限制返回数组的最大声明长度。',
+    descriptionEn: 'Limits the maximum declared length of a returned array.',
   },
   {
     key: 'maxValueBigIntDigits',
@@ -112,84 +213,10 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 100_000,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: 'BigInt 最大十进制位数',
-    labelEn: 'Max BigInt decimal digits',
+    label: '返回值 BigInt 十进制位数上限',
+    labelEn: 'Returned-value BigInt decimal-digit limit',
     description: '限制返回值中 BigInt 的十进制位数。',
-    descriptionEn: 'Caps the decimal digits of BigInt values in a returned value.',
-  },
-  {
-    key: 'maxNestedRunCodeDepth',
-    type: 'integer',
-    default: 8,
-    min: 1,
-    max: Number.MAX_SAFE_INTEGER,
-    label: 'code.run 最大递归深度',
-    labelEn: 'Max code.run recursion depth',
-    description: '限制 code.run 的嵌套层数。',
-    descriptionEn: 'Caps how deeply code.run may nest.',
-  },
-  {
-    key: 'canonicalizeToolCalls',
-    type: 'boolean',
-    default: true,
-    label: '规范顶层 native 误调',
-    labelEn: 'Canonicalize top-level native mis-calls',
-    description: '修正可以明确识别的顶层 native 误调。',
-    descriptionEn: 'Repairs top-level native mis-calls that can be identified unambiguously.',
-  },
-  {
-    key: 'looseTopLevelRedeclarations',
-    type: 'boolean',
-    default: true,
-    label: '宽松顶层重声明',
-    labelEn: 'Loose top-level redeclarations',
-    description: '允许顶层 const/let 重声明已有变量。',
-    descriptionEn: 'Allows top-level const/let to redeclare existing variables.',
-  },
-  {
-    key: 'durableReplay',
-    type: 'boolean',
-    default: true,
-    label: '持久重放',
-    labelEn: 'Durable replay',
-    description: 'worker 重启后恢复可以重建的 REPL 状态。',
-    descriptionEn: 'Rebuilds recoverable REPL state after a worker restart.',
-  },
-  {
-    key: 'autoRewriteImports',
-    type: 'boolean',
-    default: true,
-    label: '自动改写 import',
-    labelEn: 'Auto-rewrite import',
-    description: '允许在 run_code 中使用静态 import。',
-    descriptionEn: 'Allows static import declarations inside run_code.',
-  },
-  {
-    key: 'autoStripExports',
-    type: 'boolean',
-    default: true,
-    label: '自动剥离 export',
-    labelEn: 'Auto-strip export',
-    description: '允许在 run_code 中使用顶层 export。',
-    descriptionEn: 'Allows top-level export modifiers inside run_code.',
-  },
-  {
-    key: 'autoSplitRedeclarations',
-    type: 'boolean',
-    default: true,
-    label: '自动拆分混合重声明',
-    labelEn: 'Auto-split mixed redeclarations',
-    description: '允许顶层解构声明同时包含新旧变量。',
-    descriptionEn: 'Allows top-level destructuring declarations that mix new and existing variables.',
-  },
-  {
-    key: 'tipsEnabled',
-    type: 'boolean',
-    default: true,
-    label: '启用恢复提示',
-    labelEn: 'Enable recovery tips',
-    description: '在符合条件的失败后显示恢复提示。',
-    descriptionEn: 'Shows recovery tips after qualifying failures.',
+    descriptionEn: 'Limits the decimal-digit count of BigInt values in one returned value.',
   },
   {
     key: 'tipCooldownMessages',
@@ -197,8 +224,8 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 3,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '恢复提示冷却步数',
-    labelEn: 'Recovery tip cooldown (messages)',
+    label: '同类恢复提示间隔 (messages)',
+    labelEn: 'Same-kind recovery tip interval (messages)',
     description: '同类恢复提示之间的最小间隔。',
     descriptionEn: 'The minimum gap between recovery tips of the same kind.',
   },
@@ -208,13 +235,61 @@ export const CONFIG_FIELDS = Object.freeze([
     default: 2,
     min: 1,
     max: Number.MAX_SAFE_INTEGER,
-    label: '恢复提示升级失败次数',
-    labelEn: 'Recovery tip escalation failures',
+    label: '详细恢复提示阈值 (failures)',
+    labelEn: 'Detailed recovery tip threshold (failures)',
     description: '连续失败达到此次数后显示更详细的恢复提示。',
     descriptionEn: 'After this many consecutive failures, a more detailed recovery tip is shown.',
   },
 ])
 
+/** Presentation groups keep high-attention decisions separate from advanced policy and limits. */
+export const CONFIG_GROUPS = Object.freeze([
+  {
+    key: 'core',
+    label: '常用与兼容性',
+    labelEn: 'Common and compatibility',
+    fields: Object.freeze(['enabled', 'enhancedToolView', 'autoDescribeRunCode', 'canonicalizeToolCalls']),
+  },
+  {
+    key: 'optional',
+    label: '可选能力',
+    labelEn: 'Optional capabilities',
+    fields: Object.freeze(['cordisToolsEnabled']),
+  },
+  {
+    key: 'advanced',
+    label: '高级行为',
+    labelEn: 'Advanced behavior',
+    fields: Object.freeze([
+      'looseTopLevelRedeclarations',
+      'looseTopLevelFunctionClassRedeclarations',
+      'autoRewriteImports',
+      'autoStripExports',
+      'autoSplitRedeclarations',
+      'durableReplay',
+      'tipsEnabled',
+    ]),
+  },
+  {
+    key: 'limits',
+    label: '资源限制',
+    labelEn: 'Resource limits',
+    fields: Object.freeze([
+      'computeMs',
+      'maxWallMs',
+      'maxOldGenerationSizeMb',
+      'maxNestedRunCodeDepth',
+      'maxOutputBytes',
+      'maxValueNodes',
+      'maxValueEdges',
+      'maxValueArrayLength',
+      'maxValueBigIntDigits',
+      'tipCooldownMessages',
+      'tipEscalationFailures',
+    ]),
+  },
+])
+
 /** Resolved defaults, derived once from the field definitions. */
 export const CONFIG_DEFAULTS = Object.freeze(
   Object.fromEntries(CONFIG_FIELDS.map(field => [field.key, field.default])),

package/internal/direct-surface-owner.js

@@ -6,6 +6,11 @@ import { projectProgramSdk } from './sdk-projection.js'
 import { EDIT_RUN_CODE } from './edit-transport-owner.js'
 import { RUN_CODE } from './runtime-bridge-owner.js'
 import { isRecord } from './record-utils.js'
+import { missingDescriptionPath } from './failure-reporting.js'
+import {
+  generatedRunCodeExecutionArguments,
+  generatedRunCodeDescriptionMeta,
+} from './run-code-description.js'
 
 const RUN_CODE_TOOL_DESCRIPTION = 'Evaluate the next TypeScript cell in this session-bound persistent REPL. Earlier top-level bindings remain available, so this call extends the current environment instead of creating a fresh one. Use `code` for the async-function body and `description` for its short UI summary. Successful image-bearing subtool results are attached after the cell.'
 const RUN_CODE_CODE_DESCRIPTION = 'Code for the next REPL cell, parsed as the body of an async TypeScript function.'
@@ -147,6 +152,7 @@ export function createDirectSurfaceOwner({
   const sessions = new Map()
   const cordisRecovery = createCordisRecoveryPolicy(runtimeConfig.cordisToolsEnabled)
   let currentCanonicalizeToolCalls = canonicalizeToolCalls
+  let currentAutoDescribeRunCode = runtimeConfig.autoDescribeRunCode
   const tipConfig = {
     enabled: runtimeConfig.tipsEnabled,
     cooldownMessages: runtimeConfig.tipCooldownMessages,
@@ -187,9 +193,9 @@ export function createDirectSurfaceOwner({
     return undefined
   }
 
-  const rememberRequest = (id, signal, presentation, nativeSchemas) => {
+  const rememberRequest = (id, signal, presentation, nativeSchemas, autoDescribeRunCode) => {
     const owner = sessionOwner(id)
-    const request = { presentation, nativeSchemas, owner }
+    const request = { presentation, nativeSchemas, autoDescribeRunCode, owner }
     owner.latestRequest = request
     if (signal !== undefined) canonicalRequests.set(signal, request)
   }
@@ -211,12 +217,15 @@ export function createDirectSurfaceOwner({
   return Object.freeze({
     reconfigure(nextConfig) {
       currentCanonicalizeToolCalls = nextConfig.canonicalizeToolCalls
+      currentAutoDescribeRunCode = nextConfig.autoDescribeRunCode
       cordisRecovery.reconfigure(nextConfig.cordisToolsEnabled)
       tipConfig.enabled = nextConfig.tipsEnabled
       tipConfig.cooldownMessages = nextConfig.tipCooldownMessages
       tipConfig.escalationFailures = nextConfig.tipEscalationFailures
     },
     async assemble(initialAssembly, context, next) {
+      // Keep schema projection and later execution on one configuration snapshot.
+      const autoDescribeRunCode = currentAutoDescribeRunCode
       const agent = context?.agent
       const id = sessionId(agent)
       const initialState = presentationState(initialAssembly)
@@ -252,7 +261,7 @@ export function createDirectSurfaceOwner({
           throw new Error(`ptc-plus: ${presentation} agent composition assembled without run_code`)
         }
         if (id !== undefined) {
-          rememberRequest(id, requestSignal, 'native', new Map())
+          rememberRequest(id, requestSignal, 'native', new Map(), autoDescribeRunCode)
         }
         return assembly
       }
@@ -300,14 +309,16 @@ export function createDirectSurfaceOwner({
               && schema.name !== RUN_CODE && schema.name !== EDIT_RUN_CODE)
             .map(schema => [schema.name, schema]))
           : new Map()
-        rememberRequest(id, requestSignal, presentation, nativeSchemas)
+        rememberRequest(id, requestSignal, presentation, nativeSchemas, autoDescribeRunCode)
       }
 
       return {
         ...assembly,
         tools: sessionPtcProjection
           ? directTools
-          : directTools.map(tool => tool?.name === RUN_CODE ? adaptRunCodeSchema(tool) : tool),
+          : directTools.map(tool => tool?.name === RUN_CODE
+            ? adaptRunCodeSchema(tool)
+            : tool),
         sections,
         contexts,
       }
@@ -343,6 +354,46 @@ export function createDirectSurfaceOwner({
       if (policy?.presentation !== 'ptc') return undefined
       return rejection(`tool ${exec.name} is not a direct PTC tool; use run_code or edit_run_code directly, and call native tools from inside run_code`)
     },
+    executionArguments(exec) {
+      const id = sessionId(exec.agent)
+      const policy = executionPolicy(id, exec.callId)
+        ?? requestPolicy(exec?.signal, id)
+      const originalArguments = exec.arguments
+      if (exec.name !== RUN_CODE || exec.parent !== undefined
+        || policy?.autoDescribeRunCode !== true || policy.presentation === 'native'
+        || !isRecord(originalArguments) || Object.hasOwn(originalArguments, 'description')
+        || typeof originalArguments.code !== 'string') {
+        return originalArguments
+      }
+      return generatedRunCodeExecutionArguments(originalArguments)
+    },
+    argumentDiagnostic(exec, result) {
+      // DSH uses success-result identity to avoid re-running output projectors
+      // after this middleware's settlement scope has ended.
+      if (exec?.name !== RUN_CODE || result?.isError !== true) return result
+      const meta = generatedRunCodeDescriptionMeta(exec.arguments, result.meta)
+      const diagnosed = meta === result.meta
+        ? result
+        : { ...result, ...(meta === undefined ? {} : { meta }) }
+      const missingPath = missingDescriptionPath(diagnosed.error)
+      if (missingPath === undefined) return diagnosed
+      const id = sessionId(exec.agent)
+      const policy = executionPolicy(id, exec.callId)
+        ?? requestPolicy(exec?.signal, id)
+      const outer = missingPath === 'description'
+        && policy?.autoDescribeRunCode !== true
+        && !(isRecord(exec.arguments) && typeof exec.arguments.description === 'string')
+      const context = {
+        name: 'tools:ptc-plus-run-code-arguments',
+        text: outer
+          ? 'The run_code outer transport arguments are invalid at JSON path $.description. Add a sibling string `description` field to run_code; a description nested inside a native-tool argument does not satisfy this outer requirement.'
+          : `A nested native-tool argument is missing required property "${missingPath}". Add a string description at that path in the native-tool arguments; the outer run_code description does not satisfy this nested requirement.`,
+      }
+      return {
+        ...diagnosed,
+        additionalContexts: [...diagnosed.additionalContexts ?? [], context],
+      }
+    },
     handleResult(exec) {
       const id = sessionId(exec.agent)
       if (id === undefined || typeof exec.callId !== 'string') return

package/internal/edit-transport-owner.js

@@ -20,6 +20,10 @@ import {
 import { editTargetForCall, projectSessionLog } from './session-log-view.js'
 import { RUN_CODE } from './runtime-bridge-owner.js'
 import { isRecord } from './record-utils.js'
+import {
+  validatedReplMemorySnapshot,
+  withReplMemorySnapshot,
+} from './repl-memory-projection.js'
 
 export const EDIT_RUN_CODE = 'edit_run_code'
 
@@ -52,6 +56,7 @@ function derivedEditResult(inner) {
 export function createEditTransportOwner(ctx, {
   durableReplay,
   executeTentative,
+  presentationGeneration,
   sessionId,
   toolSchemasForAgent,
 }) {
@@ -91,7 +96,9 @@ export function createEditTransportOwner(ctx, {
     if (derived.recoveryBoundaries !== undefined) {
       meta[RECOVERY_BOUNDARY_KEY] = normalizeRecoveryBoundaries(derived.recoveryBoundaries)
     }
-    return meta
+    return derived.replMemory === undefined
+      ? meta
+      : withReplMemorySnapshot(meta, derived.replMemory, presentationGeneration)
   }
   definition.output = {
     schema: {
@@ -140,7 +147,7 @@ export function createEditTransportOwner(ctx, {
     if (typeof ctx.tools.execute !== 'function') {
       throw new Error('ptc-plus: DSH tools.execute is required for derived edit execution')
     }
-    const persistedCallSeq = currentDurableReplay ? persistedTargetCallSeq : undefined
+    const persistedCallSeq = persistedTargetCallSeq
     const id = sessionId(agent)
     let claims = editClaims.get(id)
     if (claims === undefined) {
@@ -178,12 +185,14 @@ export function createEditTransportOwner(ctx, {
         && Object.hasOwn(inner.meta, RECOVERY_BOUNDARY_KEY)
         ? normalizeRecoveryBoundaries(inner.meta[RECOVERY_BOUNDARY_KEY])
         : undefined
+      const replMemory = validatedReplMemorySnapshot(inner?.meta, presentationGeneration)
       const value = derivedEditResult(inner)
       const derived = {
         targetCallSeq: target.callSeq,
         journal,
         rewrites,
         recoveryBoundaries,
+        replMemory,
         code: edited.code,
         description: edited.description,
       }

package/internal/failure-reporting.js

@@ -64,6 +64,21 @@ export function oneLineMessage(error) {
   return firstLine(messageOf(error), 'Unknown error').replace(/\s+\(\d+:\d+\)$/, '')
 }
 
+/** Return DSH's reported missing-description property path when it is actionable. */
+export function missingDescriptionPath(error) {
+  const violations = messageOf(error).matchAll(/missing required property ["']([^"']+)["']/g)
+  for (const match of violations) {
+    const path = match[1]
+    if (path === 'description' || path.endsWith('.description')) return path
+  }
+  return undefined
+}
+
+/** Identify DSH's stable missing-description validation fact without parsing arbitrary errors. */
+export function hasMissingDescriptionError(error) {
+  return missingDescriptionPath(error) !== undefined
+}
+
 /** Keep only the newest log entries so an output-limit error cannot flood the model. */
 export function limitLogs(logs) {
   let bytes = 0

package/internal/kernel-worker.js

@@ -366,6 +366,7 @@ async function runCell(message) {
   pendingVolatileReason = undefined
   activeExecution = execution
   const cellGlobals = []
+  const committedRedeclarations = new Set()
 
   try {
     let completion
@@ -376,6 +377,13 @@ async function runCell(message) {
           value: CellReturn,
         })
         cellGlobals.push(message.returnSignal)
+        Object.defineProperty(context, message.commitSignal, {
+          configurable: true,
+          value(name) {
+            committedRedeclarations.add(name)
+          },
+        })
+        cellGlobals.push(message.commitSignal)
         for (const load of message.moduleLoads ?? []) {
           let namespace
           try {
@@ -421,6 +429,7 @@ async function runCell(message) {
         ...(position === undefined ? {} : { position }),
         ...(detail.cause === undefined ? {} : { cause: detail.cause }),
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       })
       return
     }
@@ -437,6 +446,7 @@ async function runCell(message) {
         hasValue: completion.hasValue,
         ...(encodedValue === undefined ? {} : { value: encodedValue }),
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       }
     } catch (error) {
       const detail = messageOf(error)
@@ -446,6 +456,7 @@ async function runCell(message) {
         logs: execution.logs,
         invalidOutput: detail,
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       }
     }
     channel.postMessage(response)