dsh-code 1.0.2 → 1.0.4

package/src/render/markdown.ts

@@ -9,6 +9,8 @@
  * @module @deepseek-ai/dsh-code/render/markdown
  */
 
+import { graphemeWidth, splitGraphemes, stringWidth } from './width.ts'
+
 /** Style classes the renderer emits; the app maps them to colors/props. */
 export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'accentBold' | 'dim' | 'strike'
 
@@ -30,14 +32,9 @@ function seg(text: string, style: MdStyle = 'plain'): MdSegment {
   return { text, style }
 }
 
-/** Visible width of a run in columns (CJK counts double). */
+/** Visible width of a run in columns (grapheme-cluster and emoji aware). */
 export function visibleColumns(text: string): number {
-  let columns = 0
-  for (const char of text) {
-    const code = char.codePointAt(0) ?? 0
-    columns += code > 0x2e7f ? 2 : 1
-  }
-  return columns
+  return stringWidth(text)
 }
 
 interface WrapUnit {
@@ -63,15 +60,17 @@ function wrapUnits(segments: readonly MdSegment[]): readonly WrapUnit[] {
       if (word !== '') units.push({ text: word, style: segment.style })
       word = ''
     }
-    for (const char of segment.text) {
-      if (char === ' ') {
+    // Grapheme clusters keep ZWJ families, flags, and combining sequences
+    // whole; a cluster wider than one cell is its own break opportunity.
+    for (const cluster of splitGraphemes(segment.text)) {
+      if (cluster === ' ') {
         flushWord()
-        units.push({ text: char, style: segment.style })
-      } else if (visibleColumns(char) > 1) {
+        units.push({ text: cluster, style: segment.style })
+      } else if (graphemeWidth(cluster) > 1) {
         flushWord()
-        units.push({ text: char, style: segment.style })
+        units.push({ text: cluster, style: segment.style })
       } else {
-        word += char
+        word += cluster
       }
     }
     flushWord()
@@ -102,7 +101,7 @@ function wrapSegments(segments: readonly MdSegment[], width: number): readonly (
   const append = (unit: WrapUnit): void => {
     const columns = visibleColumns(unit.text)
     if (used === 0 && columns > limit) {
-      for (const char of unit.text) appendAtom({ text: char, style: unit.style })
+      for (const cluster of splitGraphemes(unit.text)) appendAtom({ text: cluster, style: unit.style })
       return
     }
     if (used + columns <= limit || current.length === 0) {
@@ -124,7 +123,7 @@ function wrapSegments(segments: readonly MdSegment[], width: number): readonly (
     }
     flush()
     if (columns > limit) {
-      for (const char of unit.text) appendAtom({ text: char, style: unit.style })
+      for (const cluster of splitGraphemes(unit.text)) appendAtom({ text: cluster, style: unit.style })
     } else {
       appendAtom(unit)
     }
@@ -339,12 +338,12 @@ function hardWrapSegments(segments: readonly MdSegment[], width: number): readon
     used = 0
   }
   for (const segment of segments) {
-    for (const char of segment.text) {
-      const cells = visibleColumns(char)
+    for (const cluster of splitGraphemes(segment.text)) {
+      const cells = graphemeWidth(cluster)
       if (used > 0 && used + cells > width) flush()
       const previous = current.at(-1)
-      if (previous?.style === segment.style) previous.text += char
-      else current.push({ text: char, style: segment.style })
+      if (previous?.style === segment.style) previous.text += cluster
+      else current.push({ text: cluster, style: segment.style })
       used += cells
     }
   }

package/src/render/projection.ts

@@ -9,6 +9,7 @@
 
 import { boundContextSummary, type ContentBlock, type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
+import { graphemeWidth, splitGraphemes } from './width.ts'
 // Type-only imports merge the plugin-owned SessionEventMap variants
 // (agent/inbox/spliced, command/*, compaction/*, goal/change, llm/retry*,
 // plan/mode, permission/preset, sandbox/mode, session/title) into the union
@@ -158,6 +159,8 @@ export interface RetryEntry {
   kind: 'retry'
   /** Correlation id shared with the matching `llm/retry-started`. */
   retryId: string
+  /** Retry policy mode from the event: `always` has no attempt cap. */
+  mode: 'normal' | 'always'
   /** Attempt ordinal and its cap. */
   attempt: number
   max: number
@@ -165,7 +168,11 @@ export interface RetryEntry {
   code: string
   /** Backoff wait before the next attempt, in ms. */
   delayMs: number
-  /** `running` while the backoff waits, `done` once the attempt started. */
+  /**
+   * `running` while the backoff waits, `done` once the attempt started — or
+   * when the turn ended first (the turn-end sweep finalizes orphans so they
+   * never pin the settled boundary).
+   */
   state: 'running' | 'done'
 }
 
@@ -327,6 +334,25 @@ function textOf(content: readonly ContentBlock[]): string {
   return content.filter(block => block.type === 'text').map(block => block.text).join('')
 }
 
+/**
+ * Snapshot-isolate one anchors block (Maps and their nested Sets): a view
+ * already handed to the renderer must never observe a later fold through a
+ * shared container. The collections are small and turn-bounded, so cloning
+ * per event is cheap next to the entries copy the reducer already makes.
+ */
+function cloneViewAnchors(anchors: TranscriptView['anchors']): TranscriptView['anchors'] {
+  return {
+    stepStart: new Map(anchors.stepStart),
+    toolStart: new Map(anchors.toolStart),
+    firstChunkAt: new Map(anchors.firstChunkAt),
+    compactionTokens: new Map(anchors.compactionTokens),
+    lastPruneTokens: anchors.lastPruneTokens,
+    turnFiles: new Map([...anchors.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
+    turnSteps: new Map(anchors.turnSteps),
+    turnTools: new Map([...anchors.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
+  }
+}
+
 /** Durable image references in their model-visible order. */
 function imagesOf(content: readonly ContentBlock[]): readonly ImageBlock['attachment'][] {
   return content.filter((block): block is ImageBlock => block.type === 'image').map(block => block.attachment)
@@ -336,13 +362,13 @@ function imagesOf(content: readonly ContentBlock[]): readonly ImageBlock['attach
 export function imageLabels(images: readonly ImageBlock['attachment'][] | undefined): string {
   if (images === undefined || images.length === 0) return ''
   return images.map((image, index) => {
-    const rawName = image.name?.trim() || `image ${index + 1}`
-    const name = rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`
-    const original = image.originalDimensions
-    const dimensions = original === undefined
-      ? `${image.width}×${image.height}`
-      : `${image.width}×${image.height} · original ${original.width}×${original.height}`
-    return `[image: ${name} · ${dimensions} · ${image.bytes} B]`
+    const rawName = image.name?.trim() || `image ${index + 1}`
+    const name = rawName.length <= 80 ? rawName : `${rawName.slice(0, 79)}…`
+    const original = image.originalDimensions
+    const dimensions = original === undefined
+      ? `${image.width}×${image.height}`
+      : `${image.width}×${image.height} · original ${original.width}×${original.height}`
+    return `[image: ${name} · ${dimensions} · ${image.bytes} B]`
   }).join('\n')
 }
 
@@ -368,8 +394,8 @@ function reasoningOf(content: readonly ContentBlock[]): string {
 function estimateTokens(text: string): number {
   let wide = 0
   let narrow = 0
-  for (const char of text) {
-    if ((char.codePointAt(0) ?? 0) > 0x2e7f) wide += 1
+  for (const cluster of splitGraphemes(text)) {
+    if (graphemeWidth(cluster) > 1) wide += 1
     else narrow += 1
   }
   return wide + Math.ceil(narrow / 4)
@@ -409,6 +435,10 @@ function pendingText(content: readonly ContentBlock[]): string {
  * @returns the view after the event; the input view is never mutated.
  */
 export function projectEvent(view: TranscriptView, event: SessionEvent): TranscriptView {
+  // Fold against a private anchors block so the documented contract holds —
+  // "the input view is never mutated" — even for the in-place anchor sweeps
+  // below; without this, every handed-out view shared live Maps.
+  view = { ...view, anchors: cloneViewAnchors(view.anchors) }
   switch (event.type) {
     case 'user/message': {
       // A queued row retires when its durable user message lands (the agent
@@ -466,10 +496,16 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const { target, start, removedCount = 0, inserted } = event.data
       const ids = view.pending[target]
       const removed = ids.slice(start, start + removedCount)
+      // In-place upstream semantics: the kernel's authoritative fold is
+      // `inbox.splice(start, removedCount, ...inserted)` — inserted ids land
+      // AT the splice position (prepend/replace shapes), never at the tail.
+      // A tail append diverged the id order, so later coordinate-based events
+      // (next-turn head claims, positioned remove/replace) tombstoned the
+      // wrong pending row.
       const nextIds = [
         ...ids.slice(0, start),
-        ...ids.slice(start + removedCount),
         ...inserted.map(message => message.id),
+        ...ids.slice(start + removedCount),
       ]
       let entries = view.entries
       if (removed.length > 0) {
@@ -713,8 +749,26 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         for (const callId of turnToolSet) view.anchors.toolStart.delete(callId)
         view.anchors.turnTools.delete(event.data.turn)
       }
+      // Orphaned retry/command rows can never be resolved after the turn
+      // ends: an aborted retry backoff returns upstream without its
+      // `llm/retry-started`, and crash repair synthesizes only tool/step/
+      // turn closers. Left `running` they pin the settled boundary forever,
+      // so the turn end finalizes them exactly like the anchor sweep above.
+      let orphans = false
+      const swept = view.entries.map((entry) => {
+        if (entry.kind === 'retry' && entry.state === 'running') {
+          orphans = true
+          return { ...entry, state: 'done' as const }
+        }
+        if (entry.kind === 'command' && entry.state === 'running') {
+          orphans = true
+          return { ...entry, state: 'error' as const, summary: 'interrupted before the turn ended' }
+        }
+        return entry
+      })
+      const entries = orphans ? swept : view.entries
       if (appended.length === 0) {
-        return { ...view, busy: false, busySince: 0, streaming: '', streamingReasoning: '' }
+        return { ...view, busy: false, busySince: 0, streaming: '', streamingReasoning: '', entries }
       }
       return {
         ...view,
@@ -722,7 +776,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         busySince: 0,
         streaming: '',
         streamingReasoning: '',
-        entries: [...view.entries, ...appended],
+        entries: [...entries, ...appended],
       }
     }
     case 'llm/retry': {
@@ -734,6 +788,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         entries: [...view.entries, {
           kind: 'retry',
           retryId: data.retryId,
+          mode: data.mode,
           attempt: data.retry,
           max: 'maxRetries' in data ? data.maxRetries : data.retry,
           code: data.failure.code,
@@ -994,6 +1049,31 @@ function indexList(map: Map<string, number[]>, id: string): number[] {
   return list
 }
 
+/**
+ * Finalize replay rows the ended turn left `running`, mirroring the reducer's
+ * turn-end orphan sweep: an orphaned retry settles `done`, an orphaned command
+ * settles `error` with an interruption note. Only the id-indexed rows are
+ * visited, so the sweep stays O(retries+commands of the log), never a scan.
+ */
+function finalizeReplayOrphans(acc: ReplayAccumulator): void {
+  for (const list of acc.retryIndex.values()) {
+    for (const index of list) {
+      const entry = acc.entries[index]
+      if (entry !== undefined && entry.kind === 'retry' && entry.state === 'running') {
+        acc.entries[index] = { ...entry, state: 'done' }
+      }
+    }
+  }
+  for (const list of acc.commandIndex.values()) {
+    for (const index of list) {
+      const entry = acc.entries[index]
+      if (entry !== undefined && entry.kind === 'command' && entry.state === 'running') {
+        acc.entries[index] = { ...entry, state: 'error', summary: 'interrupted before the turn ended' }
+      }
+    }
+  }
+}
+
 /**
  * Apply an id-keyed update to every row that registered the id, mirroring the
  * copy-on-write reducer's full-array map semantics (all matching rows update,
@@ -1035,8 +1115,11 @@ function retireReplayEntry(acc: ReplayAccumulator, index: number): void {
  * to a sequential fold; only the `entries` container operations are mutable.
  *
  * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ * @returns whether the event changed the accumulated state — the live store
+ * stays silent and keeps its snapshot identity for ignored events, exactly
+ * like the copy-on-write reducer returning its input view unchanged.
  */
-export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): void {
+export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): boolean {
   switch (event.type) {
     case 'user/message': {
       const message = event.data
@@ -1066,7 +1149,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
             prompt: acc.stats.contextSegments.prompt + estimateTokens(text),
           },
         }
-        return
+        return true
       }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
@@ -1080,7 +1163,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           system: acc.stats.contextSegments.system + estimateTokens(summary),
         },
       }
-      return
+      return true
     }
     case 'agent/inbox/spliced': {
       const { target, start, removedCount = 0, inserted } = event.data
@@ -1099,14 +1182,18 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           }
         }
       }
+      // Mirror the reducer's in-place order: inserted ids join at the splice
+      // position (upstream `splice(start, removedCount, ...inserted)`), never
+      // at the tail — the id list must stay coordinate-compatible with every
+      // later inbox event.
+      ids.splice(start, 0, ...inserted.map(message => message.id))
       for (const message of inserted) {
         const images = imagesOf(message.content)
         appendReplayEntry(acc, { kind: 'pending', messageId: message.id, target, text: pendingText(message.content), ...(images.length === 0 ? {} : { images }) })
         indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1)
-        ids.push(message.id)
         acc.ops += 1
       }
-      return
+      return true
     }
     case 'assistant/chunk': {
       const chunk = event.data.chunk
@@ -1125,13 +1212,13 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       }
       if (chunk.type === 'text-delta') {
         acc.streaming = appendStreamingTail(acc.streaming, chunk.text)
-        return
+        return true
       }
       if (chunk.type === 'reasoning-delta') {
         acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text)
-        return
+        return true
       }
-      return
+      return false
     }
     case 'assistant/message': {
       const key = `${event.data.turn}:${event.data.step}`
@@ -1165,7 +1252,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           assistant: acc.stats.contextSegments.assistant + estimateTokens(text),
         },
       }
-      return
+      return true
     }
     case 'tool/call': {
       const data = event.data
@@ -1195,7 +1282,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
             + (typeof data.arguments === 'string' ? estimateTokens(data.arguments) : 0),
         },
       }
-      return
+      return true
     }
     case 'tool/result': {
       const block = event.data.message.content[0]
@@ -1231,18 +1318,18 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           tools: acc.stats.contextSegments.tools + estimateTokens(rawText),
         },
       }
-      return
+      return true
     }
     case 'todo/write':
       acc.todos = event.data.todos
-      return
+      return true
     case 'turn/start': {
       const wasBusy = acc.busy
       acc.busy = true
       acc.busySince = wasBusy ? acc.busySince : event.time
       acc.todos = []
       acc.stats = { ...acc.stats, turns: acc.stats.turns + 1 }
-      return
+      return true
     }
     case 'step/start': {
       const key = `${event.data.turn}:${event.data.step}`
@@ -1256,7 +1343,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       acc.streaming = ''
       acc.streamingReasoning = ''
       acc.stats = { ...acc.stats, steps: acc.stats.steps + 1 }
-      return
+      return true
     }
     case 'turn/end': {
       const reason = event.data.reason
@@ -1294,10 +1381,11 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         for (const callId of turnToolSet) acc.toolStart.delete(callId)
         acc.turnTools.delete(event.data.turn)
       }
+      finalizeReplayOrphans(acc)
       acc.busy = false
       acc.busySince = 0
       for (const entry of appended) appendReplayEntry(acc, entry)
-      return
+      return true
     }
     case 'llm/retry': {
       const data = event.data
@@ -1306,6 +1394,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       appendReplayEntry(acc, {
         kind: 'retry',
         retryId: data.retryId,
+        mode: data.mode,
         attempt: data.retry,
         max: 'maxRetries' in data ? data.maxRetries : data.retry,
         code: data.failure.code,
@@ -1313,23 +1402,23 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         state: 'running',
       })
       indexList(acc.retryIndex, data.retryId).push(acc.entries.length - 1)
-      return
+      return true
     }
     case 'llm/retry-started': {
       const data = event.data
       updateReplayById<RetryEntry>(acc, acc.retryIndex, data.retryId, entry => entry.retryId === data.retryId, entry => ({ ...entry, state: 'done' as const }))
-      return
+      return true
     }
     case 'sandbox/mode':
       acc.sandbox = event.data.mode
-      return
+      return true
     case 'goal/change': {
       const data = event.data
       const clip = (text: string): string => (text.length > 60 ? `${text.slice(0, 59)}…` : text)
       if (data.operation === 'clear') {
         acc.goal = undefined
         appendReplayEntry(acc, { kind: 'turn-marker', text: '◎ goal cleared' })
-        return
+        return true
       }
       const goal: GoalFold = {
         objective: data.goal.objective,
@@ -1351,31 +1440,31 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
                 : undefined
       acc.goal = goal
       if (line !== undefined) appendReplayEntry(acc, { kind: 'turn-marker', text: line })
-      return
+      return true
     }
     case 'session/title':
       acc.title = event.data.title
-      return
+      return true
     case 'compaction/summary':
       if (acc.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
         const oldest = acc.compactionTokens.keys().next().value
         if (oldest !== undefined) acc.compactionTokens.delete(oldest)
       }
       acc.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount)
-      return
+      return true
     case 'compaction/prune':
       acc.lastPruneTokens = event.data.shadowedTokenCount
-      return
+      return true
     case 'compaction/end': {
       const ok = event.data.error === undefined
       const tokens = acc.compactionTokens.get(event.data.compactionId) ?? acc.lastPruneTokens
       acc.compactionTokens.delete(event.data.compactionId)
       appendReplayEntry(acc, { kind: 'compaction', ok, tokens, error: event.data.error ?? '' })
-      return
+      return true
     }
     case 'request/context':
       acc.stats = { ...acc.stats, contextWindow: event.data.contextWindow ?? acc.stats.contextWindow }
-      return
+      return true
     case 'request/header': {
       const config = event.data.header.config
       acc.model = `${config.provider}/${config.model}`
@@ -1387,14 +1476,14 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           system: estimateTokens(event.data.header.system ?? ''),
         },
       }
-      return
+      return true
     }
     case 'plan/mode':
       acc.plan = event.data.active
-      return
+      return true
     case 'permission/preset':
       acc.permission = event.data.preset
-      return
+      return true
     case 'command/run': {
       const data = event.data
       appendReplayEntry(acc, {
@@ -1406,7 +1495,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         summary: '',
       })
       indexList(acc.commandIndex, data.commandId).push(acc.entries.length - 1)
-      return
+      return true
     }
     case 'command/done': {
       const data = event.data
@@ -1416,10 +1505,10 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         summary: boundContextSummary(data.text ?? ''),
       })
       updateReplayById<CommandEntry>(acc, acc.commandIndex, data.commandId, entry => entry.commandId === data.commandId, update)
-      return
+      return true
     }
     default:
-      return
+      return false
   }
 }
 
@@ -1431,8 +1520,27 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
  * @internal Test-instrumentation path; `projectEvents` is the public entry.
  */
 export function finishReplay(acc: ReplayAccumulator): TranscriptView {
+  return materializeReplayView(acc, false)
+}
+
+/**
+ * Materialize the accumulated fold as a fresh immutable snapshot for the
+ * live store. Unlike {@link finishReplay} — the one-shot replay entry, which
+ * hands the accumulator's own arrays through because the accumulator is
+ * discarded — every array a renderer can hold is copied here, so later
+ * folds never mutate a snapshot already handed out. Same fields, same
+ * tombstone compaction.
+ *
+ * @internal Live-store path; `projectEvents` is the public entry.
+ */
+export function snapshotReplayView(acc: ReplayAccumulator): TranscriptView {
+  return materializeReplayView(acc, true)
+}
+
+/** Field-for-field materialization; `copy` selects snapshot array isolation. */
+function materializeReplayView(acc: ReplayAccumulator, copy: boolean): TranscriptView {
   const entries: readonly TranscriptEntry[] = acc.removedCount === 0
-    ? acc.entries as TranscriptEntry[]
+    ? (copy ? [...acc.entries] : acc.entries) as TranscriptEntry[]
     : acc.entries.filter((entry): entry is TranscriptEntry => entry !== undefined)
   if (acc.removedCount > 0) acc.ops += acc.entries.length
   return {
@@ -1451,15 +1559,17 @@ export function finishReplay(acc: ReplayAccumulator): TranscriptView {
     goal: acc.goal,
     pending: { 'next-turn': [...acc.pendingTurn], 'next-step': [...acc.pendingStep] },
     stats: acc.stats,
+    // Handed-out views get their own anchors snapshot: the accumulator keeps
+    // folding its live containers, and no consumer may observe that.
     anchors: {
-      stepStart: acc.stepStart,
-      toolStart: acc.toolStart,
-      firstChunkAt: acc.firstChunkAt,
-      compactionTokens: acc.compactionTokens,
+      stepStart: new Map(acc.stepStart),
+      toolStart: new Map(acc.toolStart),
+      firstChunkAt: new Map(acc.firstChunkAt),
+      compactionTokens: new Map(acc.compactionTokens),
       lastPruneTokens: acc.lastPruneTokens,
-      turnFiles: acc.turnFiles,
-      turnSteps: acc.turnSteps,
-      turnTools: acc.turnTools,
+      turnFiles: new Map([...acc.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
+      turnSteps: new Map(acc.turnSteps),
+      turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
     },
   }
 }