dsh-ptc-plus 0.2.2 → 0.2.4

package/internal/direct-surface-owner.js

@@ -11,6 +11,7 @@ const RUN_CODE_TOOL_DESCRIPTION = 'Evaluate the next TypeScript cell in this ses
 const RUN_CODE_CODE_DESCRIPTION = 'Code for the next REPL cell, parsed as the body of an async TypeScript function.'
 const RUN_CODE_DESCRIPTION_DESCRIPTION = 'Short active-voice summary of what this cell does, 5-10 words (shown in the UI).'
 const CODE_TRANSPORT_INSTRUCTION = '`run_code` and `edit_run_code` are the only tools callable directly. Call every native tool declared by the SDK from inside a program.'
+const PTC_COLLAPSE_SECTION_NAMES = Object.freeze(['tools:ptc-only', 'tools:code-only'])
 
 function adaptRunCodeSchema(tool) {
   const parameters = tool.parameters
@@ -94,19 +95,21 @@ export function createCordisRecoveryPolicy(initiallyEnabled) {
 function presentationState(assembly) {
   const tools = Array.isArray(assembly?.tools) ? assembly.tools : []
   if (!tools.some(tool => tool?.name === RUN_CODE)) {
-    return { presentation: 'native', ownerProven: false }
+    return { presentation: 'native', ownerProven: false, collapseSectionName: undefined }
   }
-  const collapse = assembly?.sections?.find(section => section?.name === 'tools:code-only')
+  const collapse = PTC_COLLAPSE_SECTION_NAMES
+    .map(name => assembly?.sections?.find(section => section?.name === name))
+    .find(section => section !== undefined)
   if (collapse !== undefined) {
     const presentation = typeof collapse.text === 'string' && collapse.text.trim().length > 0
-      ? 'code'
+      ? 'ptc'
       : 'both'
-    return { presentation, ownerProven: true }
+    return { presentation, ownerProven: true, collapseSectionName: collapse.name }
   }
   const presentation = tools.every(tool => tool?.name === RUN_CODE || tool?.name === EDIT_RUN_CODE)
-    ? 'code'
+    ? 'ptc'
     : 'both'
-  return { presentation, ownerProven: false }
+  return { presentation, ownerProven: false, collapseSectionName: undefined }
 }
 
 async function* bindCallPolicies(source, policy, calls) {
@@ -219,10 +222,10 @@ export function createDirectSurfaceOwner({
       const initialState = presentationState(initialAssembly)
       let composition = compositions.get(agent)
       if (composition === undefined && id !== undefined
-        && (initialState.ownerProven || initialState.presentation === 'code')) {
+        && (initialState.ownerProven || initialState.presentation === 'ptc')) {
         composition = captureComposition(agent, id, initialState.presentation)
       }
-      if (composition?.presentation === 'code' && !editTransport.isInstalled(agent)) {
+      if (composition?.presentation === 'ptc' && !editTransport.isInstalled(agent)) {
         editTransport.ensureInstalled(agent)
       }
 
@@ -235,7 +238,7 @@ export function createDirectSurfaceOwner({
       if (composition === undefined && id !== undefined) {
         const state = initialState.ownerProven ? initialState : completedState
         composition = captureComposition(agent, id, state.presentation)
-        if (composition.presentation === 'code' && !editTransport.isInstalled(agent)) {
+        if (composition.presentation === 'ptc' && !editTransport.isInstalled(agent)) {
           editTransport.ensureInstalled(agent)
         }
       }
@@ -257,10 +260,10 @@ export function createDirectSurfaceOwner({
         throw new Error('ptc-plus: native agent composition assembled with run_code')
       }
       const sessionPtc = presentation !== 'native' && id !== undefined
-      const sessionCodeOnlyProjection = presentation === 'code' && id !== undefined
+      const sessionPtcProjection = presentation === 'ptc' && id !== undefined
       const runCode = tools.find(tool => tool?.name === RUN_CODE)
       let directTools = tools
-      if (sessionCodeOnlyProjection) {
+      if (sessionPtcProjection) {
         editTransport.ensureInstalled(agent)
         directTools = [adaptRunCodeSchema(runCode), editRunCodeSchema()]
       }
@@ -277,13 +280,13 @@ export function createDirectSurfaceOwner({
         : assembly.contexts
       const projectsSections = presentation !== 'native' && Array.isArray(assembly.sections)
         && assembly.sections.some(section => section?.name === 'tools:sdk'
-          || (sessionCodeOnlyProjection && section?.name === 'tools:code-only'))
+          || (sessionPtcProjection && section?.name === completedState.collapseSectionName))
       const sections = projectsSections
         ? assembly.sections.map(section => {
             if (section?.name === 'tools:sdk') {
               return { ...section, text: capabilitySdk(section.text) }
             }
-            if (sessionCodeOnlyProjection && section?.name === 'tools:code-only') {
+            if (sessionPtcProjection && section?.name === completedState.collapseSectionName) {
               return { ...section, text: CODE_TRANSPORT_INSTRUCTION }
             }
             return section
@@ -291,7 +294,7 @@ export function createDirectSurfaceOwner({
         : assembly.sections
 
       if (id !== undefined) {
-        const nativeSchemas = presentation === 'code'
+        const nativeSchemas = presentation === 'ptc'
           ? new Map(toolSchemasForAgent(agent)
             .filter(schema => typeof schema?.name === 'string'
               && schema.name !== RUN_CODE && schema.name !== EDIT_RUN_CODE)
@@ -302,7 +305,7 @@ export function createDirectSurfaceOwner({
 
       return {
         ...assembly,
-        tools: sessionCodeOnlyProjection
+        tools: sessionPtcProjection
           ? directTools
           : directTools.map(tool => tool?.name === RUN_CODE ? adaptRunCodeSchema(tool) : tool),
         sections,
@@ -313,7 +316,7 @@ export function createDirectSurfaceOwner({
       const optionSessionId = options.sessionId === undefined ? undefined : String(options.sessionId)
       const policy = requestPolicy(options?.signal, optionSessionId)
       if (policy === undefined || optionSessionId === undefined) return next()
-      const source = policy.presentation === 'code'
+      const source = policy.presentation === 'ptc'
         ? canonicalizeToolCallStream(next(), {
           tools: options.tools,
           nativeSchemas: currentCanonicalizeToolCalls ? policy.nativeSchemas : new Map(),
@@ -330,14 +333,14 @@ export function createDirectSurfaceOwner({
       const policy = executionPolicy(id, exec.callId)
         ?? requestPolicy(exec?.signal, id)
       if (exec.name === EDIT_RUN_CODE) {
-        return policy?.presentation === 'code'
+        return policy?.presentation === 'ptc'
           ? undefined
           : rejection(`tool ${EDIT_RUN_CODE} is not declared for this request`)
       }
       if (exec.name === RUN_CODE || exec.parent !== undefined) {
         return undefined
       }
-      if (policy?.presentation !== 'code') return undefined
+      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`)
     },
     handleResult(exec) {

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/settings-compat.js

@@ -0,0 +1,31 @@
+/** Install an optional settings section across current and legacy DSH settings APIs. */
+export function installSettingsSectionCompat({
+  ctx,
+  settingsModule,
+  namespace,
+  schema,
+  entry,
+  hooks,
+  onProvider,
+}) {
+  ctx.inject(['settings'], settingsContext => {
+    const provider = settingsContext.settings
+    onProvider(provider)
+    if (typeof provider?.installSection === 'function') {
+      provider.installSection(ctx, namespace, schema, entry, hooks)
+      return
+    }
+    if (typeof settingsModule?.installSettingsSection !== 'function') {
+      throw new Error('ptc-plus: incompatible settings service; expected installSection or installSettingsSection')
+    }
+    const mountedOwner = new Proxy(ctx, {
+      get(target, property) {
+        if (property === 'inject') {
+          return (_services, attach) => attach(settingsContext)
+        }
+        return Reflect.get(target, property, target)
+      },
+    })
+    settingsModule.installSettingsSection(mountedOwner, namespace, schema, entry, hooks)
+  })
+}

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.4",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -15,9 +15,11 @@
     "src",
     "internal",
     "docs",
-    "assets/dsh-ptc-plus-banner.webp",
+    "assets/dsh-ptc-plus-banner-en.webp",
+    "assets/dsh-ptc-plus-banner-zh.webp",
     "assets/ptc-plus-repair.png",
-    "assets/ptc-plus-settings.png",
+    "assets/ptc-plus-settings-en.png",
+    "assets/ptc-plus-settings-zh.png",
     "cordis.patch.yml",
     "README.md",
     "README.zh.md",
@@ -26,6 +28,9 @@
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
   },
+  "allowScripts": {
+    "esbuild": false
+  },
   "dependencies": {
     "@babel/code-frame": "^7.29.7",
     "@babel/parser": "^7.29.0",
@@ -34,10 +39,10 @@
     "acorn": "^8.15.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-settings": "next",
-    "@deepseek-ai/dsh-skill-filesystem": "next",
-    "@deepseek-ai/dsh-tool-cordis": "next",
-    "@deepseek-ai/dsh-tools": "next"
+    "@deepseek-ai/dsh-settings": "*",
+    "@deepseek-ai/dsh-skill-filesystem": "*",
+    "@deepseek-ai/dsh-tool-cordis": "*",
+    "@deepseek-ai/dsh-tools": "*"
   },
   "scripts": {
     "build": "node scripts/client-bundle.mjs build",
@@ -82,6 +87,7 @@
       ],
       "inject": [
         "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-settings-plugins",
         "@deepseek-ai/dsh-client-connection",
@@ -90,10 +96,10 @@
     }
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-settings": "next",
-    "@deepseek-ai/dsh-skill-filesystem": "next",
-    "@deepseek-ai/dsh-tool-cordis": "next",
-    "@deepseek-ai/dsh-tools": "next",
+    "@deepseek-ai/dsh-settings": "alpha",
+    "@deepseek-ai/dsh-skill-filesystem": "alpha",
+    "@deepseek-ai/dsh-tool-cordis": "alpha",
+    "@deepseek-ai/dsh-tools": "alpha",
     "esbuild": "0.28.2",
     "yaml": "^2.9.0"
   }