dsh-code 0.7.0 → 0.8.0

package/src/render/status.ts

@@ -11,7 +11,7 @@
  */
 
 import { visibleColumns } from './markdown.ts'
-import type { ContextSegments, TranscriptStats } from './projection.ts'
+import type { TranscriptStats } from './projection.ts'
 import { singleLineText, truncateColumns } from './text.ts'
 
 /**
@@ -79,14 +79,9 @@ export type StatusTone =
   | 'success'
   | 'warn'
   | 'error'
-  // Context-bar segment tones, one DeepSeek blue shade per content type
-  // (dark → light: system/prompt/assistant/thinking/tools). Only the
-  // context bar emits them; the footer maps each to an existing theme color.
-  | 'ctxSystem'
-  | 'ctxPrompt'
-  | 'ctxAssistant'
-  | 'ctxThinking'
-  | 'ctxTools'
+  // Context-bar fill: one DeepSeek blue for the whole occupied run (the free
+  // track uses the dim 'label' tone). Only the context bar emits it.
+  | 'ctxFill'
 
 /** One colored run inside the status bar. */
 export interface StatusSpan {
@@ -114,11 +109,9 @@ export interface StatusRow {
 }
 
 /**
- * The footer layout: two stacked physical rows. Row 1 is the identity/state
- * row (busy dot, model, cwd, branch, plan, turns, tokens, title; goal,
- * sandbox, and permission badges). Row 2 is the run-meters row (mode, the
- * context progress bar, cache, and duration figures) and degrades to empty
- * before any row-1 content is touched.
+ * The footer layout: two stacked physical rows. Row 1 keeps the primary
+ * controls in model, cwd, mode, branch, context, permission order. Row 2
+ * carries every secondary session/run figure and degrades independently.
  */
 export interface StatusLayout {
   row1: StatusRow
@@ -145,94 +138,21 @@ export const CONTEXT_WARN_PERCENT = 90
  * the warning stays visible even at 100%+ occupancy. */
 const CONTEXT_MIN_FREE = 5
 
-/** One content-type segment of the context bar (pure data; colors live in app.ts). */
-export interface ContextSegmentSpec {
-  key: keyof ContextSegments
-  /** Tone the footer maps to a DeepSeek blue shade. */
-  tone: StatusTone
-  /** Labels longest → shortest; the first one fitting the segment width wins. */
-  labels: readonly string[]
-}
-
-/** The five content types in conversation order, dark → light blue. */
-export const CONTEXT_SEGMENTS: readonly ContextSegmentSpec[] = [
-  { key: 'system', tone: 'ctxSystem', labels: ['system', 'sys', 's'] },
-  { key: 'prompt', tone: 'ctxPrompt', labels: ['prompt', 'pr', 'p'] },
-  { key: 'assistant', tone: 'ctxAssistant', labels: ['assistant', 'ast', 'a'] },
-  { key: 'thinking', tone: 'ctxThinking', labels: ['think', 'th', 't'] },
-  { key: 'tools', tone: 'ctxTools', labels: ['tools', 'tl', 'x'] },
-] as const
-
-/** First label whose visible width fits the segment; empty only when none do. */
-function chooseContextLabel(labels: readonly string[], width: number): string {
-  for (const label of labels) {
-    if (visibleColumns(label) <= width) return label
-  }
-  return ''
-}
-
-/** Center a label inside its segment width; the padding spaces carry the tone. */
-function centerInSegment(text: string, width: number): string {
-  const textWidth = visibleColumns(text)
-  const left = Math.floor((width - textWidth) / 2)
-  return ' '.repeat(Math.max(0, left)) + text + ' '.repeat(Math.max(0, width - textWidth - left))
-}
-
-/**
- * Largest-remainder allocation: distribute `columns` across `values`
- * proportionally, handing each leftover column to the largest remainder.
- */
-function allocateProportionally(values: readonly number[], columns: number): number[] {
-  if (columns <= 0) return values.map(() => 0)
-  const total = values.reduce((sum, value) => sum + value, 0)
-  if (total <= 0) return values.map(() => 0)
-  const raw = values.map(value => value / total * columns)
-  const allocated = raw.map(Math.floor)
-  let remaining = columns - allocated.reduce((sum, value) => sum + value, 0)
-  const remainders = raw
-    .map((value, index) => ({ index, remainder: value - Math.floor(value) }))
-    .sort((left, right) => right.remainder - left.remainder)
-  for (const slot of remainders) {
-    if (remaining <= 0) break
-    allocated[slot.index] = (allocated[slot.index] ?? 0) + 1
-    remaining -= 1
-  }
-  return allocated
-}
-
-/** Bar column widths: every non-zero segment keeps at least one column before
- * the remaining columns share by token proportion. */
-function allocateBarColumns(values: readonly number[], width: number): number[] {
-  const visible = values
-    .map((value, index) => (value > 0 ? index : -1))
-    .filter(index => index >= 0)
-  if (visible.length === 0 || visible.length >= width) {
-    return allocateProportionally(values, width)
-  }
-  const minimum = values.map(() => 0)
-  for (const index of visible) minimum[index] = 1
-  const remaining = allocateProportionally(values, width - visible.length)
-  return minimum.map((min, index) => min + (remaining[index] ?? 0))
-}
-
 /**
- * Render context occupancy as a segmented bar: one DeepSeek-blue run per
- * content type (system/prompt/assistant/thinking/tools), column widths
- * proportional to their estimated token share, each with a centered label
- * that shortens to fit (system→sys→s). The remaining free tail is a dim
- * track whose right edge carries the usage readout (`12.3K/1.0M 25%`,
- * shrinking to the bare percent as the tail narrows). The readout flips to
- * amber once occupancy reaches the warning threshold; the segment blues stay
- * untouched so the composition remains readable at full context. The used
- * total comes from the reported `lastPromptTokens`, never from the estimates.
- * @param segments - estimated used tokens per content type.
+ * Render context occupancy as ONE stepless bar: a solid DeepSeek-blue fill
+ * run, a dim dotted free track, and the usage readout riding the track's
+ * right edge (`12.3K/1.0M 25%`, shrinking to the bare percent as the track
+ * narrows). No per-content-type segmentation. Column split is deterministic:
+ * the free share is `Math.round(free/window*width)` clamped to at least
+ * CONTEXT_MIN_FREE columns and at most the full width; the fill takes every
+ * remaining column, so a given occupancy always renders the identical bar.
+ * The readout flips to amber once occupancy reaches the warning threshold.
  * @param usedTokens - reported used tokens (drives the readout and percent).
  * @param contextWindow - route capacity.
  * @param width - total bar interior columns.
  * @returns tone-split spans for the footer to paint.
  */
 export function contextBar(
-  segments: ContextSegments,
   usedTokens: number,
   contextWindow: number,
   width: number,
@@ -255,26 +175,10 @@ export function contextBar(
       ? percentText
       : ''
 
-  const values = CONTEXT_SEGMENTS.map(segment => segments[segment.key])
-  const estimated = values.reduce((sum, value) => sum + value, 0)
-  // No estimate yet (a resumed session before any text-bearing event): treat
-  // the whole reported used context as one prompt segment instead of an
-  // empty bar.
-  const allocation = allocateBarColumns(
-    estimated > 0 ? values : [0, used, 0, 0, 0],
-    usedColumns,
-  )
   const spans: StatusSpan[] = []
-  for (let index = 0; index < CONTEXT_SEGMENTS.length; index += 1) {
-    const columns = allocation[index] ?? 0
-    if (columns <= 0) continue
-    spans.push({
-      text: centerInSegment(chooseContextLabel(CONTEXT_SEGMENTS[index].labels, columns), columns),
-      tone: CONTEXT_SEGMENTS[index].tone,
-    })
-  }
+  if (usedColumns > 0) spans.push({ text: '█'.repeat(usedColumns), tone: 'ctxFill' })
   const pad = freeColumns - visibleColumns(readout)
-  if (pad > 0) spans.push({ text: '▱'.repeat(pad), tone: 'label' })
+  if (pad > 0) spans.push({ text: '░'.repeat(pad), tone: 'label' })
   if (readout !== '') spans.push({ text: readout, tone: readoutTone })
   return spans
 }
@@ -315,18 +219,18 @@ export interface StatusItemInfo {
 export const STATUS_ITEMS: readonly StatusItemInfo[] = [
   { id: 'model', label: 'model', description: 'provider/model serving this session', side: 'left' },
   { id: 'cwd', label: 'cwd', description: 'working-directory basename', side: 'left' },
+  { id: 'mode', label: 'mode', description: 'agent preset composing the session', side: 'left' },
   { id: 'branch', label: 'branch', description: 'git branch inside a repository', side: 'left' },
+  { id: 'context', label: 'context', description: 'context-window occupancy meter', side: 'left' },
+  { id: 'permission', label: 'permission', description: 'permission preset badge with cycle hint', side: 'right' },
   { id: 'plan', label: 'plan', description: 'plan-mode state mark', side: 'left' },
-  { id: 'mode', label: 'mode', description: 'agent preset composing the session', side: 'left' },
   { id: 'turns', label: 'turns', description: 'turn and step counters', side: 'left' },
   { id: 'durations', label: 'durations', description: 'llm/ttft/decode/tool wall time', side: 'left' },
   { id: 'cache', label: 'cache', description: 'cache-hit share of billed input', side: 'left' },
-  { id: 'context', label: 'context', description: 'context-window occupancy meter', side: 'left' },
   { id: 'tokens', label: 'tokens', description: 'cumulative input/output tokens', side: 'left' },
   { id: 'title', label: 'title', description: 'session title or short id', side: 'left' },
-  { id: 'goal', label: 'goal', description: 'live goal phase and round progress', side: 'right' },
-  { id: 'sandbox', label: 'sandbox', description: 'divergent sandbox-mode override', side: 'right' },
-  { id: 'permission', label: 'permission', description: 'permission preset badge with cycle hint', side: 'right' },
+  { id: 'goal', label: 'goal', description: 'live goal phase and round progress', side: 'left' },
+  { id: 'sandbox', label: 'sandbox', description: 'divergent sandbox-mode override', side: 'left' },
 ]
 
 /**
@@ -360,28 +264,33 @@ export function parseStatuslineItems(value: unknown): readonly StatusItemId[] {
 const LEFT_RIGHT_GAP = 2
 /** Column held back so Ink/yoga measurement drift can never force a wrap. */
 const WIDTH_SAFETY = 1
+/**
+ * Extra left padding on the secondary row so its content aligns with the
+ * model name's left edge on the primary row (padding 2 + busy dot 2). The
+ * layout subtracts it from row 2's budget so the indent can never wrap it.
+ */
+export const STATUS_ROW2_INDENT = 2
 /** Column budget for the session title before it ellipsizes. */
 const TITLE_BUDGET = 48
 
 /**
- * Row 1 drop ranks (lowest drops first): the session title, then the token
- * figures, then turn/step counts, then the goal and divergent-sandbox badges,
- * with the permission badge last. The identity cluster never drops — it
- * ellipsizes instead.
+ * Primary-row drop ranks: context drops before permission; the identity
+ * cluster never drops and ellipsizes only after the right badge is gone.
+ * Secondary-row groups reuse the remaining ranks independently.
  */
 const RANK_TITLE = 10
 const RANK_TOKENS = 50
 const RANK_COUNTS = 90
+const RANK_CONTEXT = 90
 const RANK_SANDBOX = 92
 const RANK_GOAL = 95
 const RANK_BADGE = 100
 const RANK_IDENTITY = Number.POSITIVE_INFINITY
 
-/** Row 2 drop ranks: duration figures go first, then cache, then the context bar, and mode survives longest. */
+/** Row 2 drop ranks: title and durations go first; state and counts survive longest. */
 const RANK2_DURATIONS = 40
 const RANK2_CACHE = 50
-const RANK2_CONTEXT = 60
-const RANK2_MODE = 70
+const RANK2_PLAN = 70
 
 /** Identity facts the runner resolves once at mount; empty strings drop out. */
 export interface StatusFacts {
@@ -403,7 +312,7 @@ export interface StatusFacts {
   goal: { phase: string; rounds: number; max: number } | undefined
   /** Whether plan mode is active (folded from 'plan/mode'). */
   plan: boolean
-  /** Active permission preset (folded from 'permission/preset'), empty when unknown. */
+  /** Active or pending permission preset; empty only when the service is unavailable. */
   permission: string
 }
 
@@ -479,9 +388,13 @@ function buildCandidates(
   }
   const cwd = safe(facts.cwd)
   if (cwd !== '' && enabled.has('cwd')) push({ text: cwd, tone: 'path' })
+  const mode = safe(facts.mode ?? '')
+  if (mode !== '' && enabled.has('mode')) {
+    push({ text: '/mode ', tone: 'label' })
+    identity.push({ text: mode, tone: 'accent' })
+  }
   const branch = safe(facts.branch)
   if (branch !== '' && enabled.has('branch')) push({ text: '⑂ ' + branch, tone: 'branch' })
-  if (facts.plan && enabled.has('plan')) push({ text: '⧉ plan', tone: 'accent' })
 
   const left: { group: StatusGroup; rank: number; id: string }[] = [
     { group: { spans: identity }, rank: RANK_IDENTITY, id: 'identity' },
@@ -489,14 +402,8 @@ function buildCandidates(
   const right: { span: StatusSpan; rank: number; id: string }[] = []
   const row2: { group: StatusGroup; rank: number; id: string }[] = []
 
-  // Row 2 anchor: the agent preset composing the session.
-  const mode = safe(facts.mode ?? '')
-  if (mode !== '' && enabled.has('mode')) {
-    row2.push({
-      group: { spans: [{ text: 'mode ', tone: 'label' }, { text: mode, tone: 'accent' }] },
-      rank: RANK2_MODE,
-      id: 'mode',
-    })
+  if (facts.plan && enabled.has('plan')) {
+    row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
   }
 
   if (stats.turns > 0 || stats.steps > 0) {
@@ -509,7 +416,7 @@ function buildCandidates(
       }
       pair('turns', String(stats.turns))
       pair('steps', String(stats.steps))
-      left.push({ group: { spans: counts }, rank: RANK_COUNTS, id: 'turns' })
+      row2.push({ group: { spans: counts }, rank: RANK_COUNTS, id: 'turns' })
     }
     if (enabled.has('durations')) {
       // Model round-trip, first-token latency, decode rate, and tool wall
@@ -549,14 +456,14 @@ function buildCandidates(
   // is the most recent reported prompt size against the advertised route
   // capacity (the same figures the old bracket bar showed).
   if (stats.contextWindow > 0 && stats.lastPromptTokens > 0 && enabled.has('context')) {
-    row2.push({
+    left.push({
       group: {
         spans: [
           { text: 'context ', tone: 'label' },
-          ...contextBar(stats.contextSegments, stats.lastPromptTokens, stats.contextWindow, CONTEXT_BAR_WIDTH),
+          ...contextBar(stats.lastPromptTokens, stats.contextWindow, CONTEXT_BAR_WIDTH),
         ],
       },
-      rank: RANK2_CONTEXT,
+      rank: RANK_CONTEXT,
       id: 'context',
     })
   }
@@ -568,7 +475,7 @@ function buildCandidates(
     }
     pair('in', formatTokens(stats.usage.inputTokens))
     pair('out', formatTokens(stats.usage.outputTokens))
-    left.push({ group: { spans: tokens }, rank: RANK_TOKENS, id: 'tokens' })
+    row2.push({ group: { spans: tokens }, rank: RANK_TOKENS, id: 'tokens' })
   }
 
   // The session title replaces the bare short id whenever one has landed
@@ -577,28 +484,28 @@ function buildCandidates(
   const rawLabel = facts.title !== undefined && facts.title !== '' ? facts.title : facts.sessionId
   const label = truncateColumns(safe(rawLabel), TITLE_BUDGET)
   if (label !== '' && enabled.has('title')) {
-    left.push({ group: { spans: [{ text: label, tone: 'meta' }] }, rank: RANK_TITLE, id: 'title' })
+    row2.push({ group: { spans: [{ text: label, tone: 'meta' }] }, rank: RANK_TITLE, id: 'title' })
   }
 
-  // Goal badge on the right (Codex goal indicator): round progress while
-  // active, the phase otherwise.
+  // Secondary state rides row 2; permission alone remains right-pinned on row 1.
   if (facts.goal !== undefined && enabled.has('goal')) {
-    right.push({
-      span: {
-        text: facts.goal.phase === 'active'
-          ? '◎ round ' + facts.goal.rounds + '/' + facts.goal.max
-          : '◎ ' + safe(facts.goal.phase),
-        tone: 'accent',
+    row2.push({
+      group: {
+        spans: [{
+          text: facts.goal.phase === 'active'
+            ? '◎ round ' + facts.goal.rounds + '/' + facts.goal.max
+            : '◎ ' + safe(facts.goal.phase),
+          tone: 'accent',
+        }],
       },
       rank: RANK_GOAL,
       id: 'goal',
     })
   }
-  // The sandbox override stays implicit when it merely echoes the preset —
-  // the badge exists to surface a divergence, not to duplicate the label.
+  // The sandbox override stays implicit when it merely echoes the preset.
   const sandbox = safe(facts.sandbox ?? '')
   if (sandbox !== '' && sandbox.toLowerCase() !== facts.permission.toLowerCase() && enabled.has('sandbox')) {
-    right.push({ span: { text: 'sandbox ' + sandbox, tone: 'warn' }, rank: RANK_SANDBOX, id: 'sandbox' })
+    row2.push({ group: { spans: [{ text: 'sandbox ' + sandbox, tone: 'warn' }] }, rank: RANK_SANDBOX, id: 'sandbox' })
   }
   const permission = safe(facts.permission)
   let badge = -1
@@ -610,12 +517,10 @@ function buildCandidates(
 }
 
 /**
- * Compose the two-row footer layout under a column budget. Row 1 (identity
- * and state badges) degrades in a fixed order — cycle hint, then title, token
- * figures, turn/step counts, goal, divergent sandbox, permission badge — and
- * only then ellipsizes the identity cluster, so the row never wraps. Row 2
- * (mode, context bar, cache, duration figures) fits its own budget and
- * degrades to empty before any row-1 content is touched.
+ * Compose the two-row footer layout under a column budget. Row 1 keeps model,
+ * cwd, mode, branch, context, then the right-pinned permission badge and cycle
+ * hint. It drops hint, context, and permission before ellipsizing identity.
+ * Row 2 fits all secondary figures and state within its own budget.
  * @param facts - identity facts resolved by the runner.
  * @param stats - session figures folded from the durable log.
  * @param columns - usable columns for each row (before their left padding).
@@ -711,13 +616,14 @@ export function layoutStatusBar(
     }
   }
 
-  // Row 2 fits its own budget; the lowest-rank group drops first until the
-  // row fits or nothing is left. An empty row2 is a valid state — the footer
-  // degrades back to a single status row.
+  // Row 2 fits its own budget minus the model-name indent; the lowest-rank
+  // group drops first until the row fits or nothing is left. An empty row2 is
+  // a valid state — the footer degrades back to a single status row.
   const row2Kept = [...orderedRow2]
+  const row2Budget = Math.max(1, budget - STATUS_ROW2_INDENT)
   const row2Width = (): number =>
     joinWidth(row2Kept.map(entry => spansWidth(entry.group.spans)), groupSeparator)
-  while (row2Width() > budget && row2Kept.length > 0) {
+  while (row2Width() > row2Budget && row2Kept.length > 0) {
     let dropIndex = 0
     let dropRank = Number.POSITIVE_INFINITY
     for (let index = 0; index < row2Kept.length; index += 1) {

package/src/render/text.ts

@@ -3,8 +3,11 @@
  * tool payloads, skill descriptions). Control characters — including ANSI
  * CSI/OSC escape sequences — would otherwise pass through Ink into the
  * terminal, letting output rewrite the screen or inject prompts. Newlines
- * and tabs survive; everything else in C0/C1 plus DEL becomes a visible
- * `\xNN` escape.
+ * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+ * escape, and bidi overrides / invisible format controls / Unicode line and
+ * paragraph separators become a visible `\uXXXX` escape (terminal emulators
+ * that render bidirectional text would otherwise reorder the displayed
+ * glyphs and let a command read as something it is not).
  *
  * @module @deepseek-ai/dsh-code/render/text
  */
@@ -13,14 +16,27 @@
 const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu
 
 /**
- * Escape control characters so externally sourced text cannot drive the
- * terminal.
+ * Bidi overrides and isolates (U+202A-202E, U+2066-2069), the Arabic Letter
+ * Mark (U+061C), directional and zero-width format characters (U+200B,
+ * U+200E/200F, U+2060-2064, U+FEFF), and Unicode line/paragraph separators
+ * (U+2028/2029). Terminal emulators with bidi support (Windows Terminal,
+ * iTerm2, kitty, WezTerm) reorder or hide these, so they must never reach
+ * the terminal raw.
+ */
+const INVISIBLE_ESCAPE = /[\u061c\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu
+
+/**
+ * Escape control and deceptive characters so externally sourced text cannot
+ * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+ * invisible-format, and separator controls render as a literal `\uXXXX`
+ * escape. Newlines and tabs survive (budgeted callers normalize tabs).
  * @param text - raw text from a session event, tool payload, or catalog.
- * @returns text with every control character (except `\n`, `\t`) rendered
- * as a literal `\xNN` escape.
+ * @returns display-safe text with every injectable character made visible.
  */
 export function displayText(text: string): string {
-  return text.replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+  return text
+    .replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+    .replace(INVISIBLE_ESCAPE, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
 }
 
 /** Collapse external text to one terminal-safe logical row. */
@@ -84,7 +100,10 @@ function previousCharacter(text: string, end: number): { char: string; start: nu
  * Keep only the newest display-safe text that fits a terminal rectangle.
  * The scan walks backward and stops as soon as the suffix is full, so a long
  * reasoning stream does not rescan its entire accumulated prefix per chunk.
- * Explicit newlines and terminal wrapping both consume rows.
+ * Explicit newlines and terminal wrapping both consume rows; tabs expand to
+ * two spaces so terminal tab stops (which render at contextual column 8
+ * boundaries, not at the budgeted cell count) cannot inflate the physical
+ * row count of the live region.
  * @param text - raw externally sourced text.
  * @param columns - available terminal columns.
  * @param rows - available terminal rows.
@@ -109,7 +128,7 @@ export function displayTail(text: string, columns: number, rows: number): Displa
       continue
     }
 
-    const safe = displayText(previous.char)
+    const safe = previous.char === '\t' ? '  ' : displayText(previous.char)
     const width = cellWidth(safe)
     if (used > 0 && used + width > columnLimit) {
       if (row >= rowLimit) break

package/src/render/tool-detail.ts

@@ -17,6 +17,9 @@ const MAX_READ_LINES = 120
 const MAX_SOURCES = 10
 const MAX_RAW_CHARS = 6000
 const MAX_LINE_COLUMNS = 240
+/** Hard caps on adversarial `tool/result.meta` before any row is built. */
+const MAX_DIFFS = 8
+const MAX_DIFF_TEXT_CHARS = 24_000
 
 /** One rendered diff row: removed, added, or shared context. */
 export interface DiffLine {
@@ -77,15 +80,32 @@ function toLines(text: string): string[] {
  * Render one change as removed-then-added rows, hunked by common prefix and
  * suffix. A null before-image (file create) renders as pure additions. The
  * budget caps emitted rows and reports the cut, so a whole-file overwrite
- * never floods the transcript.
+ * never floods the transcript. Inputs are hard-capped before line splitting
+ * and the row list is built incrementally up to the budget — a crafted or
+ * replayed giant diff cannot force a full intermediate rows array.
  * @param oldText - prior content, or null for a create.
  * @param newText - content after the change.
  * @param budget - maximum rows to emit.
  * @returns the bounded rows and whether they were cut.
  */
 export function diffRows(oldText: string | null, newText: string, budget: number): { lines: readonly DiffLine[]; truncated: boolean } {
-  const oldLines = oldText === null ? [] : toLines(oldText)
-  const newLines = toLines(newText)
+  const oldRaw = oldText ?? ''
+  const newRaw = newText
+  let inputTruncated = false
+  let oldSource = oldRaw
+  let newSource = newRaw
+  // Bound the working arrays before `toLines` allocates them: keep a
+  // combined-characters share of each side proportional to its input size.
+  const combined = oldRaw.length + newRaw.length
+  if (combined > MAX_DIFF_TEXT_CHARS) {
+    inputTruncated = true
+    const oldShare = Math.min(oldRaw.length, Math.floor(MAX_DIFF_TEXT_CHARS * oldRaw.length / combined))
+    const newShare = Math.min(newRaw.length, MAX_DIFF_TEXT_CHARS - oldShare)
+    oldSource = oldRaw.slice(0, oldShare)
+    newSource = newRaw.slice(0, newShare)
+  }
+  const oldLines = oldText === null ? [] : toLines(oldSource)
+  const newLines = toLines(newSource)
   let prefix = 0
   while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) prefix += 1
   let suffix = 0
@@ -93,14 +113,20 @@ export function diffRows(oldText: string | null, newText: string, budget: number
     suffix < oldLines.length - prefix && suffix < newLines.length - prefix
     && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
   ) suffix += 1
-  const removed = oldLines.slice(prefix, oldLines.length - suffix)
-  const added = newLines.slice(prefix, newLines.length - suffix)
-  const rows: DiffLine[] = [
-    ...removed.map((text): DiffLine => ({ mark: '-', text: clipLine(text) })),
-    ...added.map((text): DiffLine => ({ mark: '+', text: clipLine(text) })),
-  ]
-  if (rows.length <= budget) return { lines: rows, truncated: false }
-  return { lines: rows.slice(0, budget), truncated: true }
+  const removedCount = oldLines.length - prefix - suffix
+  const addedCount = newLines.length - prefix - suffix
+  const truncated = inputTruncated || removedCount + addedCount > budget
+  // Build at most `budget` rows directly; never materialize the full hunk.
+  const rows: DiffLine[] = []
+  const removedLimit = Math.min(removedCount, Math.max(0, budget))
+  for (let index = 0; index < removedLimit; index += 1) {
+    rows.push({ mark: '-', text: clipLine(oldLines[prefix + index] ?? '') })
+  }
+  const addedLimit = Math.min(addedCount, Math.max(0, budget - removedLimit))
+  for (let index = 0; index < addedLimit; index += 1) {
+    rows.push({ mark: '+', text: clipLine(newLines[prefix + index] ?? '') })
+  }
+  return { lines: rows, truncated }
 }
 
 /** Whether `value` is a valid upstream FileDiff (defensive narrowing). */
@@ -140,45 +166,60 @@ export function toolResultDetail(meta: unknown, rawText: string): ToolDetail | u
     const record = meta as Record<string, unknown>
 
     const diffs = record['diffs']
-    if (Array.isArray(diffs) && diffs.length > 0 && diffs.every(isFileDiff)) {
-      const budget = Math.max(8, Math.floor(MAX_DIFF_LINES / diffs.length))
-      return {
-        kind: 'diff',
-        diffs: diffs.map(diff => ({
-          path: diff.path,
-          ...diffRows(diff.oldText, diff.newText, budget),
-        })),
+    // Validate and process only the capped prefix: an adversarial meta with
+    // thousands of diffs never runs `.every` over the full array.
+    if (Array.isArray(diffs) && diffs.length > 0) {
+      const capped = diffs.slice(0, MAX_DIFFS)
+      if (capped.every(isFileDiff)) {
+        const budget = Math.max(8, Math.floor(MAX_DIFF_LINES / capped.length))
+        // Diffs dropped beyond the cap must not vanish silently: the last
+        // kept diff reports the cut exactly like a hunk cut does.
+        const dropped = diffs.length > capped.length
+        const rendered = capped.map((diff, index) => {
+          const rows = diffRows(diff.oldText, diff.newText, budget)
+          return dropped && index === capped.length - 1
+            ? { path: diff.path, ...rows, truncated: true }
+            : { path: diff.path, ...rows }
+        })
+        return { kind: 'diff', diffs: rendered }
       }
     }
 
     const { path, offset, lines, totalLines } = record
     if (typeof path === 'string' && Number.isInteger(offset) && (offset as number) >= 1
       && Number.isInteger(totalLines) && (totalLines as number) >= 0
-      && Array.isArray(lines) && lines.every(isReadLine)) {
-      const window = lines as { number: number; text: string }[]
-      const truncated = window.length > MAX_READ_LINES
-      return {
-        kind: 'read',
-        path,
-        offset: offset as number,
-        lines: (truncated ? window.slice(0, MAX_READ_LINES) : window)
-          .map(line => ({ number: line.number, text: clipLine(line.text) })),
-        totalLines: totalLines as number,
-        truncated,
+      && Array.isArray(lines)) {
+      // Validate the bounded window only: lines beyond the display cap are
+      // dropped anyway, so a giant persisted window cannot force a full-array
+      // validation pass before the slice.
+      const window = lines.slice(0, MAX_READ_LINES)
+      if (window.every(isReadLine)) {
+        const truncated = lines.length > MAX_READ_LINES
+        return {
+          kind: 'read',
+          path,
+          offset: offset as number,
+          lines: window.map(line => ({ number: line.number, text: clipLine(line.text) })),
+          totalLines: totalLines as number,
+          truncated,
+        }
       }
     }
 
     const sources = record['sources']
-    if (Array.isArray(sources) && sources.every(isWebSource)) {
-      const truncated = sources.length > MAX_SOURCES
-      return {
-        kind: 'web-search',
-        sources: (truncated ? sources.slice(0, MAX_SOURCES) : sources).map(source => ({
-          url: source.url,
-          title: typeof source.title === 'string' ? source.title : undefined,
-          snippet: typeof source.snippet === 'string' ? clipLine(source.snippet) : '',
-        })),
-        truncated,
+    if (Array.isArray(sources)) {
+      const capped = sources.slice(0, MAX_SOURCES)
+      if (capped.every(isWebSource)) {
+        const truncated = sources.length > MAX_SOURCES
+        return {
+          kind: 'web-search',
+          sources: capped.map(source => ({
+            url: source.url,
+            title: typeof source.title === 'string' ? source.title : undefined,
+            snippet: typeof source.snippet === 'string' ? clipLine(source.snippet) : '',
+          })),
+          truncated,
+        }
       }
     }