dsh-ptc-plus 0.2.2 → 0.2.3

package/README.md

@@ -73,6 +73,8 @@ edit_run_code({ edits: [{ old_string: 'deps.length', new_string: 'deps' }] })
 
 Only the diff goes in. The full source stays out of the conversation. Exact replacements and regular expressions both have limits, so a bad pattern cannot hang.
 
+When a rejected cell has exactly one validated missing closing token at the end, its diagnostic includes the complete `edit_run_code(...)` call needed to apply that correction and rerun the cell. That generated call carries an `expected_target_call_seq` precondition, so it is rejected without execution if another cell becomes the edit target first. PTC Plus never applies the suggestion automatically; ambiguous repairs or repairs without a persistent target identity still require corrected source.
+
 ### Module syntax
 
 DSH PTC mode executes each `run_code` as an async function body, where static `import` and `export` declarations are invalid. PTC Plus adapts those forms before execution with AST analysis.

package/README.zh.md

@@ -73,6 +73,8 @@ edit_run_code({ edits: [{ old_string: 'deps.length', new_string: 'deps' }] })
 
 模型只发改动，完整源码留在对话之外。精确文本替换和正则替换都有限制，坏的正则不会卡住。
 
+当被拒 cell 的末尾可唯一验证为缺少一个闭合符时，诊断会直接给出应用该修正并重运行所需的完整 `edit_run_code(...)` 调用。生成的调用带有 `expected_target_call_seq` 前置条件；如果另一个 cell 已先成为 edit 目标，它会拒绝且不执行。PTC Plus 不会自动应用这项建议；有歧义或没有持久目标身份的修复仍需提交修正后的源码。
+
 ### 模块语法
 
 DSH 的 PTC 模式把每个 `run_code` 当作 async function body 执行，静态 `import` 和 `export` 声明在这个函数体里无效。PTC Plus 会在执行前用 AST 分析适配这些形式。

package/docs/adr/0005-temporary-rejected-cell-edit-transport.md

@@ -6,7 +6,8 @@ not achieve the intended result. PTC Plus therefore registers `edit_run_code` as
 
 ```ts
 edit_run_code({
-  edits: Array<{ old_string: string; new_string: string }>
+  edits: Array<{ old_string: string; new_string: string }>,
+  expected_target_call_seq?: number
 })
 
 edit_run_code({
@@ -15,7 +16,8 @@ edit_run_code({
     flags: string
     replacement: string
     expected_matches: number
-  }>
+  }>,
+  expected_target_call_seq?: number
 })
 ```
 
@@ -65,7 +67,11 @@ session-log projection captures the eligible target at the edit call event and a
 source only when its target sequence matches that snapshot and its journal is valid and non-noop,
 so live and recovered eligibility derive from the same persisted relation.
 
-The caller sends exactly one of `edits` or `regex_edits`. Exact edits contain at most 16 items; each
+The caller sends exactly one of `edits` or `regex_edits`, plus an optional non-negative
+`expected_target_call_seq` precondition. The precondition must equal the call sequence of the target
+captured for the persisted edit event; a mismatch returns an unedited result before derived
+dispatch. Ordinary model-authored edits omit it and retain latest-target selection. Exact edits
+contain at most 16 items; each
 non-empty `old_string` must differ from `new_string` and occur exactly once in the target. Regular
 expression edits also contain at most 16 items, use unique `gimsu` flags, reject zero-length matches,
 and require an exact `expected_matches` count. All ranges resolve against the original target and
@@ -98,6 +104,22 @@ operation and outcome; changing an aggregate runtime-context snapshot merely to
 would repeat unrelated policy context. Rewrite feedback and unrelated recovery tips retain their
 own independently justified lifecycles.
 
+A live `PTC-C001` at the exact source EOF may carry a validated one-call repair. The analyzer tries
+only the three single-token suffixes `}`, `)`, and `]` against the same binding catalog, reserved
+bindings, redeclaration mode, rewrite policy, and import state as the rejected cell. Exactly one
+candidate must complete preparation without a binding collision, and the existing exact editor
+must be able to express it from a bounded unique source suffix. The rejected call must also have a
+persistent event sequence. The diagnostic then renders those already-validated
+`edit_run_code({ edits: [...], expected_target_call_seq })` arguments on one help line. At dispatch,
+the precondition binds the proof to that rejected cell even if another matching source has become
+editable. This evidence takes precedence over the generic source-length recommendation, but remains
+conditional on
+`edit_run_code` being declared for that request. Zero or multiple candidates, non-EOF errors,
+editor budget failures, missing target identity, and candidates rejected later in preparation
+retain the generic guidance.
+The plugin never applies this repair itself: syntax/preflight acceptance does not prove model
+intent, and explicit edit dispatch preserves DSH authority and truthful history.
+
 ## Alternatives considered
 
 **Rewrite `edit_run_code` to `run_code` before persistence.** This reuses DSH's default `run_code`-only

package/docs/architecture.md

@@ -20,7 +20,7 @@ DSH 为一个 agent composition 固定选择 `native`、`code` 或 `both`。首
 
 `edit_run_code` 对其持久化 `tool/call` 事件出现时当前 open turn 最近的可编辑 cell 生效，无论该 cell 被拒绝、运行失败，还是成功执行但结果需要微调。执行通过 call event sequence 读取该快照，后续 settlement 或 handler 调度不改变目标；派生 cell 则按外层 `tool/result` event sequence 进入恢复历史，使 cold replay 保持 live kernel 的实际结算顺序。
 调查 tool 不擦除目标；edit 发起后的其他 settlement 不追溯改变其目标；一次成功 edit 生成的新 cell 成为下一次 edit 的目标。调用方必须且只能提交 `edits` 或
-`regex_edits` 之一。`internal/rejected-cell-editor.js` 统一拥有 schema、匹配、replacement 语义、预算和原子源码组装；
+`regex_edits` 之一，并可携带 `expected_target_call_seq` 作为目标前置条件；它与 call event 已捕获目标不一致时，在任何派生 dispatch 前返回未编辑结果。`internal/rejected-cell-editor.js` 统一拥有 schema、匹配、replacement 语义、预算和原子源码组装；
 所有位置都针对原始目标源码解析，全部范围不得重叠，预算通过后才以单次线性扫描物化结果。
 
 注册工具通过 DSH 公共 `tools.execute()` 将完整修改后源码派生执行为 `run_code`。外层历史仍是模型真实发出的
@@ -40,6 +40,8 @@ return 或打印需要展示的值。失败恢复先按状态分类：解析或
 `run_code` 并复用已有 binding，完整重写只保留给结构性改动或超出编辑预算的修正。能力和命令执行依赖当前 request
 与 execution world，模型必须先探查 live binding、实际 executable 和路径语义，不假设某个平台、shell 或 package runner。
 
+live `PTC-C001` 若精确落在源码 EOF，独立的 bounded analyzer 只把追加单个 `}`、`)`、`]` 的三个源码分别送入该 cell 提交时的同一 preparation context。仅当唯一候选通过、无 binding collision，现有 exact editor 能从不超过固定预算的唯一尾部物化同一源码，并且 runtime 已取得该 rejected `run_code` 的持久 call sequence 时，诊断才输出一行可直接调用的 `edit_run_code({ edits: [...], expected_target_call_seq })`。edit transport 把该 sequence 与其 call event 捕获的目标比较，目标已变化时不编辑也不派生执行。这项 validated repair 优先于长度阈值，但只证明语法/preflight 接受；插件不自动 dispatch，也不改写原始 `run_code`。非 EOF、多候选、多 token、超预算、缺少目标身份或后续 preparation 拒绝均回到原有 length-adaptive help。
+
 稳定指引保留这些跨任务不变量和失败恢复的优先动作。长 cell 失败的短提示直接作为当前 `PTC-X001` 的结构化 `help` 输出，避免一次性建议触发完整 runtime-context 快照；重复绑定失败和当前 execution world 中由诊断确认的 executable、shell 或 path 错误仍由当前 session log 派生为 `tools:ptc-plus-tip/<trigger>/<ordinal>` runtime context，分别提示能力探查或重新确认环境。投影只接受 DSH system-prompt owner 的规范快照，并按命名 section 的有效状态变化重建提示；聚合快照重复同一 section 不增加次数，正文不参与身份判断。
 相同提示受 `tipCooldownMessages` 间隔约束，连续未解决时才升级为详细版本，成功 cell 会重置未解决计数；提示不会改变
 system sections、tool schema 或 tool order，也不假设 Windows、WSL、POSIX、shell 或 package runner。

package/docs/installation.md

@@ -23,7 +23,7 @@ The optional `cordisToolsEnabled` integration requires the current DSH installat
 Use this form after the selected version is available from the npm registry:
 
 ```sh
-dsh plugin --profile <profile> add dsh-ptc-plus@0.2.1
+dsh plugin --profile <profile> add dsh-ptc-plus@0.2.3
 dsh --profile <profile> --dump-config
 ```
 
@@ -60,7 +60,7 @@ pnpm dsh --profile <profile> --dump-config
 
 ```sh
 npm pack
-dsh plugin --profile <profile> add /absolute/path/to/dsh-ptc-plus-0.2.1.tgz
+dsh plugin --profile <profile> add /absolute/path/to/dsh-ptc-plus-0.2.3.tgz
 dsh --profile <profile> --dump-config
 ```
 
@@ -79,4 +79,4 @@ dsh plugin add github:muyuanjin/dsh-ptc-plus#main
 dsh --dump-config
 ```
 
-After an npm release, the package spec may instead be `dsh-ptc-plus@0.2.1`. For a local package, use its absolute tarball path. Restart DSH Desktop after installation. Linux Desktop is not a current DSH Desktop release target; use DSH CLI/Web on Linux.
+After an npm release, the package spec may instead be `dsh-ptc-plus@0.2.3`. For a local package, use its absolute tarball path. Restart DSH Desktop after installation. Linux Desktop is not a current DSH Desktop release target; use DSH CLI/Web on Linux.

package/docs/runtime-reference.md

@@ -8,10 +8,12 @@ The default loose binding mode lets a complete top-level `const` or `let` declar
 
 Every capability namespace is leased to one cell. Captured `tools`, `capabilities`, `repl`, `code`, or member functions expire when that cell ends.
 
-For PTC mode requests using the code-only direct-tool projection, PTC Plus presents two tools in stable order: `run_code` and `edit_run_code`. The latter edits the most recent eligible cell visible when the edit call is dispatched, including a cell that completed successfully but needs a small adjustment. That target remains fixed while the call is in flight; later tool settlements cannot retarget it. The edit accepts exactly one atomic `edits` or `regex_edits` array; invalid or unavailable edits return `{ edited: false, reason }` without executing source or consuming the target.
+For PTC mode requests using the code-only direct-tool projection, PTC Plus presents two tools in stable order: `run_code` and `edit_run_code`. The latter edits the most recent eligible cell visible when the edit call is dispatched, including a cell that completed successfully but needs a small adjustment. That target remains fixed while the call is in flight; later tool settlements cannot retarget it. The edit accepts exactly one atomic `edits` or `regex_edits` array and an optional `expected_target_call_seq` precondition. Invalid, unavailable, or mismatched-target edits return `{ edited: false, reason }` without executing source or consuming the target.
 
 `edit_run_code` is a real registered tool call. Session history and later model requests retain its original name and delta arguments. The plugin executes the materialized source as a host-derived `run_code`, returns only the edit status, value, and logs to the model, and keeps the complete source plus journal in private replay metadata. It does not rewrite assistant history or emit edit-specific runtime context.
 
+When a live parse error occurs exactly at the cell EOF, PTC Plus checks the three single-closing-token corrections `}`, `)`, and `]` with the same preparation context. If exactly one correction succeeds, the existing editor can express it from a bounded unique suffix, and the rejected call has a persistent event identity, `PTC-C001` includes a directly callable `edit_run_code({ edits: [...], expected_target_call_seq })` invocation. The guard must match the target captured when the edit call is persisted, so a later editable cell suppresses execution even when the same literal replacement would match it. The plugin does not apply or execute the correction automatically; ambiguous, broader, and unbound repairs keep the ordinary length-adaptive guidance.
+
 Only values explicitly returned or printed appear in a cell result:
 
 ```ts
@@ -95,7 +97,7 @@ Rewrites are recorded as `meta.dshPtcPlusRewrites` on the tool result (parallel
 
 | Code | Meaning | State effect |
 | --- | --- | --- |
-| `PTC-C001` | The cell cannot be parsed | Not executed; REPL unchanged |
+| `PTC-C001` | The cell cannot be parsed | Not executed; REPL unchanged; a uniquely validated and target-bound single-token EOF closure includes a directly callable declared `edit_run_code` repair; otherwise retry a short corrected cell with `run_code`, use edit for a localized long-cell correction, and resend with `run_code` for broad, ambiguous, or unbound repairs |
 | `PTC-C002` | Preflight rejected a kernel-control import | Not executed; REPL unchanged |
 | `PTC-N001` | Top-level binding conflict | Not executed; REPL unchanged |
 | `PTC-O001` | Unsupported or over-budget output | Cell executed; earlier mutations may exist |

package/internal/edit-transport-owner.js

@@ -12,7 +12,11 @@ import {
   normalizeRewrites,
   validatedRewrites,
 } from './session-journal.js'
-import { editRejectedCell, editRunCodeSchema } from './rejected-cell-editor.js'
+import {
+  EXPECTED_TARGET_CALL_SEQ,
+  editRejectedCell,
+  editRunCodeSchema,
+} from './rejected-cell-editor.js'
 import { editTargetForCall, projectSessionLog } from './session-log-view.js'
 import { RUN_CODE } from './runtime-bridge-owner.js'
 import { isRecord } from './record-utils.js'
@@ -126,6 +130,13 @@ export function createEditTransportOwner(ctx, {
     }
     const edited = editRejectedCell(args, target.source)
     if (!edited.edited) return edited
+    const expectedTargetCallSeq = args[EXPECTED_TARGET_CALL_SEQ]
+    if (expectedTargetCallSeq !== undefined && expectedTargetCallSeq !== target.callSeq) {
+      return {
+        edited: false,
+        reason: `validated repair targets run_code call ${expectedTargetCallSeq}, but this edit captured call ${target.callSeq}`,
+      }
+    }
     if (typeof ctx.tools.execute !== 'function') {
       throw new Error('ptc-plus: DSH tools.execute is required for derived edit execution')
     }

package/internal/failure-reporting.js

@@ -2,6 +2,7 @@ import { diagnostic } from './diagnostic.js'
 
 export const MAX_ERROR_LOG_BYTES = 4 * 1024
 export const FAILURE_HINT_THRESHOLD = 3
+export const LONG_CELL_CODE_UNITS = 2_000
 const BINDING_FAILURE = Symbol('binding failure')
 
 export function markBindingFailure(error) {

package/internal/recovery-tips.js

@@ -1,6 +1,5 @@
 const PLATFORM_CAUSE_CODES = new Set(['EACCES', 'EINVAL', 'ENOTDIR', 'ENOENT', 'UNKNOWN'])
 const TIP_CONTEXT_PREFIX = 'tools:ptc-plus-tip/'
-export const LONG_FAILED_CELL_TIP_CODE_UNITS = 2_000
 const TIP_PREFIXES = Object.freeze({
   'repeated-binding-failure': 'The same binding failure has recurred.',
   'platform-command-failure': 'An executable, shell, or path failed in the current execution world.',

package/internal/rejected-cell-editor.js

@@ -14,6 +14,7 @@ export const EDIT_LIMITS = Object.freeze({
 
 const EDIT_RUN_CODE_EXECUTION_DESCRIPTION = 'Edit and run TypeScript cell'
 const REGEX_EDIT_RUN_CODE_EXECUTION_DESCRIPTION = 'Regex-edit and run TypeScript cell'
+export const EXPECTED_TARGET_CALL_SEQ = 'expected_target_call_seq'
 
 const REGEX_MATCH_SCRIPT = `(() => {
   const replacements = []
@@ -254,7 +255,7 @@ function assemble(source, replacements) {
 export function editRunCodeSchema() {
   return {
     name: 'edit_run_code',
-    description: 'Make a small exact or regular-expression change to the most recent eligible cell captured when this edit call is dispatched, then run the complete corrected cell. A successful edit becomes the next eligible cell. Use this only when replaying the whole cell is safe. If earlier code may already have caused an external effect, use a new run_code cell and its existing variables instead; this tool does not resume at the error location. Send exactly one atomic edits or regex_edits array. Choose edits for a few unique literal fragments; choose regex_edits when one counted pattern covers repeated fragments. Every resolved range must be non-overlapping in the original cell.',
+    description: 'Make a small exact or regular-expression change to the most recent eligible cell captured when this edit call is dispatched, then run the complete corrected cell. A successful edit becomes the next eligible cell. Use this only when replaying the whole cell is safe. If earlier code may already have caused an external effect, use a new run_code cell and its existing variables instead; this tool does not resume at the error location. Send exactly one atomic edits or regex_edits array, plus expected_target_call_seq only when a diagnostic supplies it to bind a validated repair to its rejected cell. Choose edits for a few unique literal fragments; choose regex_edits when one counted pattern covers repeated fragments. Every resolved range must be non-overlapping in the original cell.',
     parameters: {
       type: 'object',
       additionalProperties: false,
@@ -285,6 +286,10 @@ export function editRunCodeSchema() {
             required: ['pattern', 'flags', 'replacement', 'expected_matches'],
           },
         },
+        [EXPECTED_TARGET_CALL_SEQ]: {
+          type: 'integer', minimum: 0,
+          description: 'Optional target precondition copied from a validated diagnostic. The edit is rejected if the captured cell has another call sequence.',
+        },
       },
       oneOf: [{ required: ['edits'] }, { required: ['regex_edits'] }],
     },
@@ -296,32 +301,41 @@ export function editRejectedCell(value, source, timeoutMs = DEFAULT_REGEX_TIMEOU
     return rejection('edit_run_code expects an object with exactly one edits or regex_edits array')
   }
   const keys = Object.keys(value)
-  if (keys.length !== 1 || !['edits', 'regex_edits'].includes(keys[0]) || !Array.isArray(value[keys[0]])) {
+  const operationKeys = keys.filter(key => key === 'edits' || key === 'regex_edits')
+  if (operationKeys.length !== 1 || keys.length > 2
+    || keys.some(key => !['edits', 'regex_edits', EXPECTED_TARGET_CALL_SEQ].includes(key))
+    || !Array.isArray(value[operationKeys[0]])) {
     return rejection('edit_run_code expects exactly one edits or regex_edits array')
   }
+  if (Object.hasOwn(value, EXPECTED_TARGET_CALL_SEQ)
+    && (!Number.isSafeInteger(value[EXPECTED_TARGET_CALL_SEQ])
+      || value[EXPECTED_TARGET_CALL_SEQ] < 0)) {
+    return rejection('edit_run_code expected_target_call_seq must be a non-negative safe integer')
+  }
   if (source === undefined) return rejection('no run_code cell is currently eligible for safe editing')
-  const resolved = keys[0] === 'edits'
+  const operation = operationKeys[0]
+  const resolved = operation === 'edits'
     ? exactReplacements(value.edits, source)
     : regexReplacements(value.regex_edits, source, timeoutMs)
   if (resolved.error !== undefined) return rejection(resolved.error)
   const replacements = resolved.replacements.sort((left, right) => left.start - right.start)
   for (let index = 1; index < replacements.length; index += 1) {
     if (replacements[index].start < replacements[index - 1].end) {
-      return rejection(`${keys[0]}[${replacements[index].index}] overlaps ${keys[0]}[${replacements[index - 1].index}] in the target cell`)
+      return rejection(`${operation}[${replacements[index].index}] overlaps ${operation}[${replacements[index - 1].index}] in the target cell`)
     }
   }
   const preflight = preflightAssembly(source, replacements)
   if (preflight.error !== undefined) {
-    return rejection(keys[0] === 'regex_edits' ? preflight.error.replace(/^edits/, 'regex_edits') : preflight.error)
+    return rejection(operation === 'regex_edits' ? preflight.error.replace(/^edits/, 'regex_edits') : preflight.error)
   }
   const assembled = assemble(source, preflight.replacements)
   if (assembled.error !== undefined) {
-    return rejection(keys[0] === 'regex_edits' ? assembled.error.replace(/^edits/, 'regex_edits') : assembled.error)
+    return rejection(operation === 'regex_edits' ? assembled.error.replace(/^edits/, 'regex_edits') : assembled.error)
   }
   return Object.freeze({
     edited: true,
     code: assembled.code,
-    description: keys[0] === 'edits'
+    description: operation === 'edits'
       ? EDIT_RUN_CODE_EXECUTION_DESCRIPTION
       : REGEX_EDIT_RUN_CODE_EXECUTION_DESCRIPTION,
   })

package/internal/session-cell-executor.js

@@ -9,6 +9,7 @@ import { diagnostic, renderDiagnostic } from './diagnostic.js'
 import {
   firstLine,
   limitLogs,
+  LONG_CELL_CODE_UNITS,
   markBindingFailure,
   messageOf,
   oneLineMessage,
@@ -19,7 +20,7 @@ import { PreflightError, prepareProgram } from './cell-analysis.js'
 import { ModuleRewriteError } from './cell-rewriter.js'
 import { mapSourcePosition } from './source-position-map.js'
 import { durabilityState, transitionDurability } from './session-state.js'
-import { LONG_FAILED_CELL_TIP_CODE_UNITS } from './recovery-tips.js'
+import { validatedEofClosureRepair } from './validated-parse-repair.js'
 
 const OUTPUT_LIMIT_MESSAGE = bytes => `output exceeded ${bytes} bytes; reduce the returned value or keep it in a REPL binding`
 
@@ -49,7 +50,7 @@ function isBindingReferenceError(error) {
       || /Cannot access ['"][^'"]+['"] before initialization/.test(error.message))
 }
 
-function parseDiagnostic(error, source) {
+function parseCellPosition(error) {
   const cellPosition = error instanceof ModuleRewriteError ? error.cellPosition : undefined
   const line = Number.isSafeInteger(cellPosition?.line)
     ? cellPosition.line
@@ -57,16 +58,29 @@ function parseDiagnostic(error, source) {
   const column = Number.isSafeInteger(cellPosition?.column)
     ? cellPosition.column
     : Number.isSafeInteger(error?.loc?.column) ? error.loc.column + 1 : undefined
+  return line !== undefined && line >= 1 && column !== undefined
+    ? { line, column }
+    : undefined
+}
+
+function parseDiagnostic(error, source, position, repair) {
   return diagnostic({
     code: 'PTC-C001',
     severity: 'error',
     phase: 'parse',
     message: `cell could not be parsed: ${oneLineMessage(error)}`,
     stateEffect: 'unchanged',
-    ...(line !== undefined && line >= 1 && column !== undefined ? {
-      source: { cell: 'current', start: { line, column } },
-    } : {}),
-    help: ['repair the reported syntax and retry only this cell'],
+    ...(position === undefined ? {} : {
+      source: { cell: 'current', start: position },
+    }),
+    help: repair === undefined
+      ? source.length >= LONG_CELL_CODE_UNITS
+        ? ['this cell was not executed; when edit_run_code is declared for the current request and the correction is small and localized, use it to avoid resending this long source; otherwise retry only this cell with corrected source in run_code']
+        : ['this cell was not executed; correct the reported syntax and retry only this cell with run_code']
+      : [
+          `this cell was not executed; validated syntax repair: append ${JSON.stringify(repair.delimiter)} at the end of this cell`,
+          `when edit_run_code is declared for the current request, call ${repair.invocation} to apply this correction and rerun the cell; otherwise retry only this cell with the corrected source in run_code`,
+        ],
   })
 }
 
@@ -196,29 +210,41 @@ export class SessionCellExecutor {
       return result
     }
 
-    let prepared
     const catalog = kernel.bindingCatalog.inputs()
-    let looseTopLevelRedeclarations
+    const looseTopLevelRedeclarations = replayRecord === undefined
+      ? config.looseTopLevelRedeclarations
+      : replayRecord.bindingMode === 'loose'
+    const rewritesEnabled = replayRecord === undefined ? {
+      autoRewriteImports: config.autoRewriteImports,
+      autoStripExports: config.autoStripExports,
+      autoSplitRedeclarations: config.autoSplitRedeclarations,
+    } : replayRecord.rewritePolicy
+    const prepareCell = program => prepareProgram(
+      program,
+      catalog.knownBindings,
+      looseTopLevelRedeclarations,
+      request.bindingDescriptors.reservedNames,
+      rewritesEnabled,
+      catalog.importBindings,
+      catalog.importNamespaces,
+    )
+    let prepared
     try {
-      looseTopLevelRedeclarations = replayRecord === undefined
-        ? config.looseTopLevelRedeclarations
-        : replayRecord.bindingMode === 'loose'
-      prepared = prepareProgram(
-        request.program,
-        catalog.knownBindings,
-        looseTopLevelRedeclarations,
-        request.bindingDescriptors.reservedNames,
-        replayRecord === undefined ? {
-          autoRewriteImports: config.autoRewriteImports,
-          autoStripExports: config.autoStripExports,
-          autoSplitRedeclarations: config.autoSplitRedeclarations,
-        } : replayRecord.rewritePolicy,
-        catalog.importBindings,
-        catalog.importNamespaces,
-      )
+      prepared = prepareCell(request.program)
     } catch (error) {
       const result = earlyResult('exception', messageOf(error))
-      const failure = error instanceof PreflightError ? preflightDiagnostic(error) : parseDiagnostic(error, request.program)
+      const position = parseCellPosition(error)
+      const repair = error instanceof PreflightError || replayRecord !== undefined
+        ? undefined
+        : validatedEofClosureRepair({
+            source: request.program,
+            position,
+            prepare: prepareCell,
+            targetCallSeq: request.sourceCallSeq,
+          })
+      const failure = error instanceof PreflightError
+        ? preflightDiagnostic(error)
+        : parseDiagnostic(error, request.program, position, repair)
       result.error.message = renderDiagnostic(failure, request.program)
       kernel.completeJournal(request.journal, 'noop', result, undefined, [failure])
       return result
@@ -466,7 +492,7 @@ export class SessionCellExecutor {
               active.prepared.sourceMap,
             ),
         declared: message.moduleLoadFailed === true ? new Set() : active.prepared.declared,
-        longCellFailure: active.request.program.length >= LONG_FAILED_CELL_TIP_CODE_UNITS,
+        longCellFailure: active.request.program.length >= LONG_CELL_CODE_UNITS,
       })
       active.appliedBindingCatalog = message.moduleLoadFailed === true
         ? active.priorBindingCatalog

package/internal/session-runtime.js

@@ -432,14 +432,22 @@ export class SessionRuntime {
     request = { ...request, bindings: bindingDescriptors.namespaces, bindingDescriptors }
     const { id: sessionId, session, callId, persistedCallSeq, cwd } = sessionOf(sessionContext)
     let callSeq
+    let sourceCallSeq
     try {
       if (persistedCallSeq !== undefined
         && (!Number.isSafeInteger(persistedCallSeq) || persistedCallSeq < 0)) {
         throw new Error('persisted tool call sequence must be a non-negative safe integer')
       }
-      callSeq = cellConfig.durableReplay
-        ? persistedCallSeq ?? liveToolCallSeq(session, callId, 'run_code')
-        : undefined
+      if (cellConfig.durableReplay) {
+        sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
+        callSeq = persistedCallSeq ?? sourceCallSeq
+      } else {
+        try {
+          sourceCallSeq = liveToolCallSeq(session, callId, 'run_code')
+        } catch {
+          sourceCallSeq = undefined
+        }
+      }
     } catch (error) {
       return completed({ logs: [], error: { kind: 'recovery', message: `cannot identify current run_code call in session log: ${messageOf(error)}` } })
     }
@@ -471,7 +479,7 @@ export class SessionRuntime {
     const workerReservation = kernel.reserveWorkerConfiguration(cellConfig)
     let result
     try {
-      result = await kernel.run({ ...request, journal, callSeq }, cellConfig)
+      result = await kernel.run({ ...request, journal, callSeq, sourceCallSeq }, cellConfig)
     } finally {
       kernel.releaseWorkerConfiguration(workerReservation)
     }

package/internal/validated-parse-repair.js

@@ -0,0 +1,82 @@
+import { EXPECTED_TARGET_CALL_SEQ, editRejectedCell } from './rejected-cell-editor.js'
+
+const CLOSING_DELIMITERS = Object.freeze(['}', ')', ']'])
+const LINE_TERMINATORS = /\r\n|[\n\r\u2028\u2029]/gu
+export const MAX_PARSE_REPAIR_ANCHOR_CODE_UNITS = 256
+
+function sourceEndPosition(source) {
+  let line = 1
+  let lineStart = 0
+  for (const match of source.matchAll(LINE_TERMINATORS)) {
+    line += 1
+    lineStart = match.index + match[0].length
+  }
+  return { line, column: source.length - lineStart + 1 }
+}
+
+function isSourceEnd(source, position) {
+  if (!Number.isSafeInteger(position?.line) || !Number.isSafeInteger(position?.column)) return false
+  const end = sourceEndPosition(source)
+  return position.line === end.line && position.column === end.column
+}
+
+function startsInsideSurrogatePair(source, index) {
+  if (index <= 0) return false
+  const current = source.charCodeAt(index)
+  const previous = source.charCodeAt(index - 1)
+  return current >= 0xdc00 && current <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff
+}
+
+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
+    const suffix = source.slice(start)
+    if (source.indexOf(suffix) === source.lastIndexOf(suffix)) return suffix
+  }
+  return undefined
+}
+
+function repairArguments(anchor, delimiter, targetCallSeq) {
+  const edit = Object.freeze({ old_string: anchor, new_string: anchor + delimiter })
+  return Object.freeze({
+    edits: Object.freeze([edit]),
+    [EXPECTED_TARGET_CALL_SEQ]: targetCallSeq,
+  })
+}
+
+function renderInvocation(argumentsValue) {
+  const json = JSON.stringify(argumentsValue)
+    .replaceAll('\u2028', '\\u2028')
+    .replaceAll('\u2029', '\\u2029')
+  return `edit_run_code(${json})`
+}
+
+/** Returns a source-exact edit only when one bounded EOF-closing candidate is valid. */
+export function validatedEofClosureRepair({ source, position, prepare, targetCallSeq }) {
+  if (!Number.isSafeInteger(targetCallSeq) || targetCallSeq < 0
+    || !isSourceEnd(source, position)) return undefined
+  const anchor = boundedUniqueSuffix(source)
+  if (anchor === undefined) return undefined
+  const candidates = []
+  for (const delimiter of CLOSING_DELIMITERS) {
+    const code = source + delimiter
+    let prepared
+    try {
+      prepared = prepare(code)
+    } catch {
+      continue
+    }
+    if (prepared.collisions.length > 0) continue
+    const argumentsValue = repairArguments(anchor, delimiter, targetCallSeq)
+    const edited = editRejectedCell(argumentsValue, source)
+    if (!edited.edited || edited.code !== code) continue
+    candidates.push({ delimiter, arguments: argumentsValue })
+  }
+  if (candidates.length !== 1) return undefined
+  const candidate = candidates[0]
+  return Object.freeze({
+    ...candidate,
+    invocation: renderInvocation(candidate.arguments),
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",