dsh-code 1.0.1 → 1.0.2

package/src/attachments.ts

@@ -108,11 +108,16 @@ export async function inspectImagePaths(
 export async function saveImagePaths(
   paths: readonly string[],
   attachments: AttachmentStore | undefined,
+  signal?: AbortSignal,
 ): Promise<readonly ImageBlock[]> {
   if (paths.length === 0) return []
   if (attachments === undefined) throw new Error('image attachments are unavailable in this profile')
+  const checkCancelled = (): void => {
+    if (signal?.aborted === true) throw new Error('image submission cancelled')
+  }
   const inputs: SaveImageAttachment[] = []
   for (const path of paths) {
+    checkCancelled()
     let data: Uint8Array
     try {
       data = await readFile(path)
@@ -123,6 +128,8 @@ export async function saveImagePaths(
     if (mediaType === undefined) throw new Error(`unsupported image file "${path}" (expected PNG, JPEG, WebP, or GIF)`)
     inputs.push({ data, mediaType, name: basename(path) })
   }
+  checkCancelled()
   const refs = await attachments.saveImages(inputs)
+  checkCancelled()
   return refs.map(attachment => ({ type: 'image', attachment }))
 }

package/src/index.ts

@@ -1405,7 +1405,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       copyTextValue: copyText,
       loadMentions: (query: string, signal?: AbortSignal) => mentions.candidates(query, signal),
       inspectImages: paths => inspectImagePaths(paths, ctx.get('attachments'), session?.header.cwd ?? cwd),
-      prepareImages: paths => saveImagePaths(paths, ctx.get('attachments')),
+      prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get('attachments'), signal),
       cyclePermission,
       setPermission: setPermissionAction,
       selectModel,

package/src/internals.ts

@@ -8,7 +8,16 @@
 
 import { render } from 'ink'
 import type { ReactElement } from 'react'
-import { BRACKETED_PASTE_DISABLE, BRACKETED_PASTE_ENABLE, KEYBOARD_ENHANCE_DISABLE, KEYBOARD_ENHANCE_ENABLE } from './keyboard.ts'
+import {
+  BRACKETED_PASTE_DISABLE,
+  BRACKETED_PASTE_ENABLE,
+  KEYBOARD_ENHANCE_DISABLE,
+  KEYBOARD_ENHANCE_ENABLE,
+  TERMINAL_FOCUS_REPORT_DISABLE,
+  TERMINAL_FOCUS_REPORT_ENABLE,
+  isVsCodeTerminalEnv,
+  shouldEnableKeyboardEnhancement,
+} from './keyboard.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -29,11 +38,16 @@ export const internals: {
   stderr: { write(chunk: string): unknown }
 } = {
   mount: (element: ReactElement): TuiMount => {
-    // Codex keyboard_modes parity: push the kitty keyboard protocol so
-    // modified controls remain distinguishable, and enable bracketed paste so
-    // pasted newlines insert instead of submitting. Both are inert in
-    // terminals without support.
-    process.stdout.write(KEYBOARD_ENHANCE_ENABLE + BRACKETED_PASTE_ENABLE)
+    // VS Code's integrated terminal can route Tab to the workbench when Kitty
+    // enhancement is enabled. Keep bracketed paste everywhere, but only push
+    // the keyboard protocol on terminals that can safely own those key events.
+    const keyboardEnhanced = shouldEnableKeyboardEnhancement()
+    const focusReporting = isVsCodeTerminalEnv()
+    process.stdout.write(
+      (keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : '')
+      + BRACKETED_PASTE_ENABLE
+      + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''),
+    )
     // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
     // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
     // normalized control byte first, unmount only its renderer, and leave the
@@ -45,9 +59,12 @@ export const internals: {
       },
       unmount(): void {
         instance.unmount()
-        // Pop the stack so the parent shell does not inherit enhanced key
-        // reporting (Codex resets even harder on forced exit).
-        process.stdout.write(KEYBOARD_ENHANCE_DISABLE + BRACKETED_PASTE_DISABLE)
+        // Pop only a stack this mount pushed, then disable bracketed paste.
+        process.stdout.write(
+          (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
+          + BRACKETED_PASTE_DISABLE
+          + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
+        )
       },
     }
   },

package/src/keyboard.ts

@@ -20,13 +20,56 @@
 export const KEYBOARD_ENHANCE_ENABLE = '\x1b[>4;0m\x1b[>5u'
 
 /** Pop the enhancement stack and reset modifyOtherKeys (exit path). */
-export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
-
-/** Enable bracketed paste reporting. */
-export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
+
+/** Explicit environment overrides for terminal keyboard enhancement. */
+export const DSH_DISABLE_KEYBOARD_ENHANCEMENT = 'DSH_DISABLE_KEYBOARD_ENHANCEMENT'
+export const DSH_ENABLE_KEYBOARD_ENHANCEMENT = 'DSH_ENABLE_KEYBOARD_ENHANCEMENT'
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined
+  const normalized = value.trim().toLowerCase()
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') return true
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') return false
+  return undefined
+}
+
+/** True when the process is running inside the VS Code integrated terminal. */
+export function isVsCodeTerminalEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.TERM_PROGRAM?.trim().toLowerCase() === 'vscode' || env.VSCODE_INJECTION === '1'
+}
+
+/** Whether to push Kitty keyboard enhancement for the current terminal. */
+export function shouldEnableKeyboardEnhancement(env: NodeJS.ProcessEnv = process.env): boolean {
+  const explicitDisable = parseBooleanEnv(env[DSH_DISABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitDisable === true) return false
+  const explicitEnable = parseBooleanEnv(env[DSH_ENABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitEnable !== undefined) return explicitEnable
+  return !isVsCodeTerminalEnv(env)
+}
 
-/** Disable bracketed paste reporting. */
-export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+/** Enable bracketed paste reporting. */
+export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+
+/** Disable bracketed paste reporting. */
+export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+
+/** Enable terminal focus-in/focus-out reporting (xterm focus protocol). */
+export const TERMINAL_FOCUS_REPORT_ENABLE = '\x1b[?1004h'
+
+/** Disable terminal focus-in/focus-out reporting. */
+export const TERMINAL_FOCUS_REPORT_DISABLE = '\x1b[?1004l'
+
+/**
+ * Remove xterm focus reports from one input chunk and update the caller's
+ * focus state. Focus reports are terminal protocol, not composer text.
+ */
+export function stripTerminalFocusEvents(chunk: string, onFocus: (focused: boolean) => void): string {
+  return chunk.replace(/\x1b\[(I|O)/gu, (_whole, event: string) => {
+    onFocus(event === 'I')
+    return ''
+  })
+}
 
 /** Bracketed paste markers as Ink delivers them (it strips the leading ESC). */
 export const PASTE_START_MARKER = '[200~'
@@ -123,4 +166,85 @@ export function normalizeKeyboardChunk(chunk: string): string {
     })
     return legacy ?? whole
   })
-}
+}
+
+/** Editor actions Ink cannot distinguish reliably when terminal bytes batch. */
+export type RawEditorToken =
+  | { readonly kind: 'text'; readonly text: string }
+  | { readonly kind: 'home' | 'end' | 'delete-backward' | 'delete-word-backward' | 'delete-forward' | 'delete-word-forward' }
+
+const HOME_SEQUENCES = ['\x1b[H', '\x1b[1~', '\x1b[7~', '\x1bOH'] as const
+const END_SEQUENCES = ['\x1b[F', '\x1b[4~', '\x1b[8~', '\x1bOF'] as const
+
+/** Parse one CSI functional-key sequence at `offset`. */
+function functionalToken(chunk: string, offset: number): { token: RawEditorToken; length: number } | undefined {
+  const tail = chunk.slice(offset)
+  for (const sequence of HOME_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'home' }, length: sequence.length }
+  }
+  for (const sequence of END_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'end' }, length: sequence.length }
+  }
+  const modifiedHome = /^\x1b\[1;(\d+)H/u.exec(tail)
+  if (modifiedHome !== null) return { token: { kind: 'home' }, length: modifiedHome[0].length }
+  const modifiedEnd = /^\x1b\[1;(\d+)F/u.exec(tail)
+  if (modifiedEnd !== null) return { token: { kind: 'end' }, length: modifiedEnd[0].length }
+  const modifiedDelete = /^\x1b\[3(?:;(\d+))?~/u.exec(tail)
+  if (modifiedDelete !== null) {
+    const modifiers = Number.parseInt(modifiedDelete[1] ?? '1', 10) - 1
+    const byWord = (modifiers & 2) !== 0 || (modifiers & 4) !== 0
+    return {
+      token: { kind: byWord ? 'delete-word-forward' : 'delete-forward' },
+      length: modifiedDelete[0].length,
+    }
+  }
+  return undefined
+}
+
+/**
+ * Tokenize a stdin chunk containing at least one editor-only key. Ink calls
+ * `useInput` once for a pasted/batched chunk, so preserving each action here
+ * prevents repeated Backspace/Home/End/Delete presses from collapsing into
+ * one blurred key event. Unknown escape sequences return undefined and stay
+ * under Ink's ownership.
+ */
+export function tokenizeRawEditorChunk(chunk: string): readonly RawEditorToken[] | undefined {
+  const tokens: RawEditorToken[] = []
+  let text = ''
+  let special = false
+  const flushText = (): void => {
+    if (text === '') return
+    tokens.push({ kind: 'text', text })
+    text = ''
+  }
+  for (let offset = 0; offset < chunk.length;) {
+    if (chunk.startsWith('\x1b\x7f', offset) || chunk.startsWith('\x1b\b', offset)) {
+      flushText()
+      tokens.push({ kind: 'delete-word-backward' })
+      special = true
+      offset += 2
+      continue
+    }
+    const functional = functionalToken(chunk, offset)
+    if (functional !== undefined) {
+      flushText()
+      tokens.push(functional.token)
+      special = true
+      offset += functional.length
+      continue
+    }
+    const char = chunk[offset]!
+    if (char === '\x7f' || char === '\b') {
+      flushText()
+      tokens.push({ kind: 'delete-backward' })
+      special = true
+      offset += 1
+      continue
+    }
+    if (char === '\x1b') return undefined
+    text += char
+    offset += 1
+  }
+  flushText()
+  return special ? tokens : undefined
+}

package/src/mentions.ts

@@ -75,6 +75,11 @@ interface FileReferenceServiceLike {
 /** Menu cap on file rows; the service owns ranking and default rows. */
 const MAX_FILE_ROWS = 20
 
+/** Whether a mention token is already navigating a filesystem path. */
+export function isPathLikeMentionQuery(query: string): boolean {
+  return /[\\/]/u.test(query)
+}
+
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
   /** Ranked menu candidates for the typed `@` query. */
@@ -136,7 +141,7 @@ export function createMentions(ctx: Context, agent: Agent | undefined, cwd: stri
           : agent === undefined
             ? preSessionFiles(needle, signal).catch(() => [] as readonly ServiceFileCandidate[])
             : Promise.resolve([] as readonly ServiceFileCandidate[]),
-        sessionCapable && needle !== '' && agent !== undefined
+        sessionCapable && needle !== '' && !isPathLikeMentionQuery(needle) && agent !== undefined
           ? resolver!.listCandidates(agent, needle, 10, signal).catch(() => [] as readonly SessionReferenceCandidate[])
           : Promise.resolve([] as readonly SessionReferenceCandidate[]),
       ])

package/src/render/animations.ts

@@ -1,9 +1,8 @@
 /**
- * Terminal animation frame tables derived from the web design language:
- * the StateDot "ongoing" pixel chase (3×3 ring, 125ms flat-hold brightness
- * steps, 1s cycle) becomes the full-ring clockwise braille chase in
- * {@link BUSY_CHASE_FRAMES}, and the streaming caret blink is the
- * Claude-Code convention.
+ * Terminal animation helpers derived from the web design language:
+ * thinking uses Codex's slow shimmer sweep, the busy composer marker uses the
+ * original braille chase, and the streaming caret blink is the Claude-Code
+ * convention.
  *
  * The DeepSeek model-switch easter egg ports Codex's effort-ignition "Wave"
  * style (`codex-rs/tui/src/bottom_pane/effort_ignition_styles.rs`): switching
@@ -19,18 +18,66 @@
 
 import type { RgbTriple } from '../theme.ts'
 
-/**
- * The web StateDot "ongoing" chase in terminal form: three cells of the 3×3
- * ring trail clockwise around the eight outer positions, one braille glyph
- * per step — 8 frames × 125ms = the web's 1s cycle.
- */
-export const BUSY_CHASE_FRAMES = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'] as const
-
-/** Chase frame for a monotonic tick (the busy composer/Deep-diving marker). */
-export function busyChaseFrame(tick: number): string {
-  return BUSY_CHASE_FRAMES[tick % BUSY_CHASE_FRAMES.length] ?? BUSY_CHASE_FRAMES[0]
-}
-
+/** Cadence for the original busy braille chase (8 frames × 125ms = 1s). */
+export const BUSY_CHASE_TICK_MS = 125
+
+/** Original terminal StateDot chase frames. */
+export const BUSY_CHASE_FRAMES = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'] as const
+
+/** Chase frame for a monotonic tick. */
+export function busyChaseFrame(tick: number): string {
+  return BUSY_CHASE_FRAMES[tick % BUSY_CHASE_FRAMES.length] ?? BUSY_CHASE_FRAMES[0]
+}
+
+/** Clock cadence for the Codex-style Deep diving shimmer. */
+export const DEEP_DIVING_SHIMMER_TICK_MS = 33
+
+/** Codex shimmer timing and geometry. */
+export const DEEP_DIVING_SHIMMER_DURATION_MS = 2_000
+export const DEEP_DIVING_SHIMMER_PADDING = 10
+export const DEEP_DIVING_SHIMMER_HALF_WIDTH = 5
+export const DEEP_DIVING_SPARK_BREATH_DURATION_MS = 2_000
+
+/**
+ * Codex's 2-second shimmer sweep, expressed in terminal ticks. The sweep has
+ * ten virtual columns of padding on either side and a five-column cosine
+ * highlight band, so the text changes gently rather than cycling rapidly.
+ */
+export function deepDivingShimmerIntensity(index: number, tick: number, graphemeCount: number): number {
+  if (graphemeCount <= 0) return 0
+  const period = graphemeCount + DEEP_DIVING_SHIMMER_PADDING * 2
+  const elapsed = ((tick * DEEP_DIVING_SHIMMER_TICK_MS) % DEEP_DIVING_SHIMMER_DURATION_MS + DEEP_DIVING_SHIMMER_DURATION_MS) % DEEP_DIVING_SHIMMER_DURATION_MS
+  const position = elapsed / DEEP_DIVING_SHIMMER_DURATION_MS * period
+  const distance = Math.abs(index + DEEP_DIVING_SHIMMER_PADDING - position)
+  if (distance > DEEP_DIVING_SHIMMER_HALF_WIDTH) return 0
+  const angle = Math.PI * distance / DEEP_DIVING_SHIMMER_HALF_WIDTH
+  return 0.5 * (1 + Math.cos(angle))
+}
+
+/** Blue RGB color for one grapheme in the Codex-style shimmer. */
+export function deepDivingGradientColor(
+  index: number,
+  tick: number,
+  graphemeCount: number,
+  base: RgbTriple,
+  highlight: RgbTriple,
+): RgbTriple {
+  return blendRgb(highlight, base, deepDivingShimmerIntensity(index, tick, graphemeCount))
+}
+
+/** Smooth breathing intensity for the always-visible Deep diving sparkle. */
+export function deepDivingSparkIntensity(tick: number): number {
+  const elapsed = ((tick * DEEP_DIVING_SHIMMER_TICK_MS) % DEEP_DIVING_SPARK_BREATH_DURATION_MS
+    + DEEP_DIVING_SPARK_BREATH_DURATION_MS) % DEEP_DIVING_SPARK_BREATH_DURATION_MS
+  const phase = elapsed / DEEP_DIVING_SPARK_BREATH_DURATION_MS
+  return 0.2 + 0.8 * (0.5 + 0.5 * Math.cos(Math.PI * 2 * phase))
+}
+
+/** Blue RGB color for the breathing Deep diving sparkle. */
+export function deepDivingSparkColor(tick: number, base: RgbTriple, highlight: RgbTriple): RgbTriple {
+  return blendRgb(highlight, base, deepDivingSparkIntensity(tick))
+}
+
 /** Caret visibility: half the ticks on, half off (530ms blink). */
 export function caretVisible(tick: number): boolean {
   return tick % 2 === 0

package/src/render/editor.ts

@@ -8,9 +8,8 @@
  * grapheme boundaries) so the React state stays two primitives
  * (value, cursor) and every operation here stays pure and testable.
  *
- * Word motion deviates from Codex's UAX#29 segmentation in one deliberate
- * way: a run of same-class characters is ONE piece, so a CJK run moves as a
- * single word (two hanzi are one Alt+B step, not two).
+ * Word motion follows Codex's piece semantics: whitespace separates runs,
+ * punctuation runs stay atomic, and each Han grapheme is its own boundary.
  *
  * @module @deepseek-ai/dsh-code/render/editor
  */
@@ -203,6 +202,31 @@ export interface CaretSite {
   column: number
 }
 
+/** Text slices for rendering one physical row with at most one caret. */
+export interface EditorRowParts {
+  readonly before: string
+  readonly caret: string
+  readonly after: string
+  readonly hasCaret: boolean
+}
+
+/** Split one row around the authoritative caret; every other row stays whole. */
+export function editorRowParts(
+  row: EditorRowModel,
+  rowIndex: number,
+  caretRow: number,
+  cursor: number,
+  caretEnabled = true,
+): EditorRowParts {
+  if (!caretEnabled || rowIndex !== caretRow) return { before: '', caret: '', after: row.text, hasCaret: false }
+  const at = row.offsets.indexOf(cursor)
+  if (at < 0) return { before: '', caret: '', after: row.text, hasCaret: false }
+  const before = at > 0 ? row.text.slice(0, row.cuts[at]!) : ''
+  const caret = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at]!, row.cuts[at + 1]!) : ' '
+  const after = at < row.cuts.length - 1 ? row.text.slice(row.cuts[at + 1]!) : ''
+  return { before, caret, after, hasCaret: true }
+}
+
 /** Map a cursor offset to its caret site on the wrapped rows. */
 export function caretSite(model: EditorModel, offset: number): CaretSite {
   const target = Math.max(0, Math.min(model.length, offset))
@@ -223,7 +247,9 @@ export function caretSite(model: EditorModel, offset: number): CaretSite {
 export function moveCursorVertically(model: EditorModel, offset: number, preferredColumn: number, delta: number): number {
   const site = caretSite(model, offset)
   const target = site.row + delta
-  if (target < 0 || target >= model.rows.length || delta === 0) return offset
+  if (delta === 0) return offset
+  if (target < 0) return 0
+  if (target >= model.rows.length) return model.length
   const row = model.rows[target]!
   const wanted = Math.max(0, Math.min(preferredColumn, row.columns[row.columns.length - 1]!))
   let best = 0
@@ -247,22 +273,26 @@ const WORD_SEPARATORS = new Set('`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?')
 
 type PieceClass = 'space' | 'punct' | 'word'
 
+const HAN_GRAPHEME = /^\p{Script=Han}(?:\p{Mark}|\uFE0F)*$/u
+const UNICODE_PUNCTUATION = /^\p{P}+$/u
+
 function classifyGrapheme(text: string): PieceClass {
   if (/^\s$/u.test(text)) return 'space'
-  return WORD_SEPARATORS.has(text) ? 'punct' : 'word'
+  return WORD_SEPARATORS.has(text) || UNICODE_PUNCTUATION.test(text) ? 'punct' : 'word'
 }
 
-/** Maximal same-class runs of graphemes as [start, end) spans. */
-function pieceRuns(value: string): readonly { start: number; end: number; class: PieceClass }[] {
-  const runs: { start: number; end: number; class: PieceClass }[] = []
-  let current: { start: number; end: number; class: PieceClass } | undefined
+/** Maximal same-class runs; Han graphemes deliberately stay one run each. */
+function pieceRuns(value: string): readonly { start: number; end: number; class: PieceClass; atomic: boolean }[] {
+  const runs: { start: number; end: number; class: PieceClass; atomic: boolean }[] = []
+  let current: { start: number; end: number; class: PieceClass; atomic: boolean } | undefined
   for (const span of splitGraphemes(value)) {
     const klass = span.text === '\n' ? 'space' : classifyGrapheme(span.text)
-    if (current !== undefined && current.class === klass) {
+    const atomic = klass === 'word' && HAN_GRAPHEME.test(span.text)
+    if (current !== undefined && current.class === klass && !current.atomic && !atomic) {
       current.end = span.end
       continue
     }
-    current = { start: span.start, end: span.end, class: klass }
+    current = { start: span.start, end: span.end, class: klass, atomic }
     runs.push(current)
   }
   return runs
@@ -273,11 +303,11 @@ function pieceRuns(value: string): readonly { start: number; end: number; class:
  * START of the trailing non-space piece (extending over separator pieces).
  */
 export function moveWordLeft(value: string, offset: number): number {
-  const cursor = Math.max(0, Math.min(value.length, offset))
+  const cursor = clampCursor(value, offset)
   const runs = pieceRuns(value)
-  // Index of the last run that ends at or before the cursor.
-  let index = runs.length - 1
-  while (index >= 0 && runs[index]!.end > cursor) index -= 1
+  // The last run with content before the cursor includes the current word's
+  // left-hand fragment, instead of skipping the whole containing run.
+  let index = runs.findLastIndex(run => run.start < cursor)
   if (index < 0) return 0
   if (runs[index]!.class === 'space') {
     index -= 1
@@ -293,10 +323,11 @@ export function moveWordLeft(value: string, offset: number): number {
  * the leading non-space piece (extending over separator pieces).
  */
 export function moveWordRight(value: string, offset: number): number {
-  const cursor = Math.max(0, Math.min(value.length, offset))
+  const cursor = clampCursor(value, offset)
   const runs = pieceRuns(value)
-  let index = 0
-  while (index < runs.length && runs[index]!.start < cursor) index += 1
+  // The first run with content after the cursor includes the current word's
+  // right-hand fragment, instead of jumping straight to the following word.
+  let index = runs.findIndex(run => run.end > cursor)
   if (index >= runs.length) return value.length
   if (runs[index]!.class === 'space') {
     index += 1
@@ -377,6 +408,75 @@ export function insertText(value: string, cursor: number, text: string): EditRes
   return { value: value.slice(0, cursor) + safe + value.slice(cursor), cursor: cursor + safe.length, killed: undefined }
 }
 
+/** Ctrl+A: current logical line start, then the previous line start on repeat. */
+export function moveToLineStart(value: string, cursor: number, crossOnRepeat: boolean): number {
+  const site = clampCursor(value, cursor)
+  const bounds = lineBounds(value, site)
+  if (!crossOnRepeat || site !== bounds.start || bounds.start === 0) return bounds.start
+  return lineBounds(value, bounds.start - 1).start
+}
+
+/** Ctrl+E: current logical line end, then the next line end on repeat. */
+export function moveToLineEnd(value: string, cursor: number, crossOnRepeat: boolean): number {
+  const site = clampCursor(value, cursor)
+  const bounds = lineBounds(value, site)
+  if (!crossOnRepeat || site !== bounds.end || bounds.end >= value.length) return bounds.end
+  return lineBounds(value, bounds.end + 1).end
+}
+
+/** One stable text range captured before an asynchronous draft operation. */
+export interface DraftRange {
+  readonly start: number
+  readonly end: number
+}
+
+/**
+ * Remap a captured range when all intervening edits are wholly before or
+ * wholly after it. An edit overlapping either boundary invalidates the
+ * anchor instead of guessing and inserting content at a surprising place.
+ */
+export function remapStableRange(original: string, current: string, range: DraftRange): DraftRange | undefined {
+  const start = Math.max(0, Math.min(original.length, range.start))
+  const end = Math.max(start, Math.min(original.length, range.end))
+  if (original === current) return { start, end }
+  let prefix = 0
+  const shared = Math.min(original.length, current.length)
+  while (prefix < shared && original[prefix] === current[prefix]) prefix += 1
+  let suffix = 0
+  while (suffix < original.length - prefix
+    && suffix < current.length - prefix
+    && original[original.length - 1 - suffix] === current[current.length - 1 - suffix]) suffix += 1
+  const oldChangedEnd = original.length - suffix
+  if (prefix >= end) return { start, end }
+  if (oldChangedEnd <= start) {
+    const delta = current.length - original.length
+    return { start: start + delta, end: end + delta }
+  }
+  return undefined
+}
+
+/** Replace a current range while preserving a cursor moved after capture. */
+export function replaceRangePreservingCursor(
+  value: string,
+  cursor: number,
+  range: DraftRange,
+  replacement: string,
+): EditResult {
+  const start = Math.max(0, Math.min(value.length, range.start))
+  const end = Math.max(start, Math.min(value.length, range.end))
+  const site = clampCursor(value, cursor)
+  const nextCursor = site <= start
+    ? site
+    : site >= end
+      ? site + replacement.length - (end - start)
+      : start + replacement.length
+  return {
+    value: value.slice(0, start) + replacement + value.slice(end),
+    cursor: nextCursor,
+    killed: undefined,
+  }
+}
+
 /**
  * Composer editor row budget: the editor itself never grows past this many
  * physical rows; deeper drafts scroll internally to keep the caret visible.
@@ -387,12 +487,12 @@ export function composerMaxRows(terminalRows: number): number {
 }
 
 /**
- * Codex `should_handle_navigation`: Up/Down walk history only from an empty
- * draft, or from a boundary of a draft that still exactly matches the last
- * recalled entry. Any interior cursor position keeps vertical caret movement.
+ * History navigation starts with Up on an empty draft, or after visual
+ * movement has reached the directional text edge of an unchanged recalled
+ * entry. Every other position remains under textarea movement.
  */
-export function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null): boolean {
-  if (value === '') return true
-  if (cursor !== 0 && cursor !== value.length) return false
-  return lastRecalled === value
+export function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean {
+  if (value === '') return direction < 0
+  if (lastRecalled !== value) return false
+  return direction < 0 ? cursor === 0 : cursor === value.length
 }

package/src/render/lines.ts

@@ -236,6 +236,18 @@ function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLi
   }
 }
 
+/** Default compact tool-card window used while the Ctrl+R fold is closed. */
+const DEFAULT_TOOL_ROWS = 3
+
+/** Keep the invocation visible while making hidden tool output discoverable. */
+function compactToolLines(lines: readonly StyledLine[], columns: number): readonly StyledLine[] {
+  if (lines.length <= DEFAULT_TOOL_ROWS) return lines
+  return [
+    ...lines.slice(0, DEFAULT_TOOL_ROWS - 1),
+    ...textLines('    … output hidden · Ctrl+R', columns, 'dim').slice(0, 1),
+  ]
+}
+
 /**
  * Convert one durable transcript entry to its complete scrollable row model.
  * The source entry stays intact; only the caller's visible slice is rendered.
@@ -247,6 +259,7 @@ export function transcriptEntryLines(
   columns: number,
   showReasoning = true,
   reasoningToggleHint = true,
+  showToolDetails = showReasoning,
 ): readonly StyledLine[] {
   const width = Math.max(1, Math.floor(columns))
   switch (entry.kind) {
@@ -278,7 +291,7 @@ export function transcriptEntryLines(
       const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
       const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
       const summaryStyle: LineStyle = entry.state === 'error' ? 'error' : 'dim'
-      return [
+      const lines = [
         // The invocation row hangs wrapped previews under the call badge.
         ...hangingStyledLines([
           // Global call ordinal — the same number an error line references.
@@ -295,6 +308,7 @@ export function transcriptEntryLines(
         )),
         ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
       ]
+      return showToolDetails ? lines : compactToolLines(lines, width)
     }
     case 'command': {
       const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
@@ -338,5 +352,5 @@ export function transcriptEntryLines(
 
 /** Settled-history variant carrying the Ctrl+R reasoning fold. */
 export function settledEntryLines(entry: TranscriptEntry, columns: number, showReasoning: boolean): readonly StyledLine[] {
-  return transcriptEntryLines(entry, columns, showReasoning, false)
+  return transcriptEntryLines(entry, columns, showReasoning, false, showReasoning)
 }