ethagent 2.1.1 → 2.3.0

package/src/runtime/turn.ts

@@ -56,6 +56,7 @@ function normalize(event: StreamEvent): ProviderTurnEvent {
 }
 
 export const MAX_CONTINUATION_NUDGES = 3
+export const MAX_TOOL_USES_PER_TURN = 25
 
 export type ContinuationNudgeReason =
   | 'continuation'
@@ -63,6 +64,7 @@ export type ContinuationNudgeReason =
   | 'tool_state_claim'
   | 'tool_protocol_fake'
   | 'tool_delegation'
+  | 'tool_budget'
   | 'private_continuity_tool'
   | 'private_continuity_tool_repair'
   | 'reasoning_only'
@@ -82,6 +84,9 @@ const TOOL_PROTOCOL_FAKE_NUDGE_TEXT =
 const TOOL_DELEGATION_NUDGE_TEXT =
   'Do not ask the user to run native tools. You have access to the tools in this environment. Make exactly one native tool call now.'
 
+const TOOL_BUDGET_NUDGE_TEXT =
+  'You have reached the tool-call budget for this turn. Do not call any more tools. Produce your final answer now using only what you already know from earlier tool results.'
+
 const PRIVATE_CONTINUITY_NUDGE_TEXT =
   'SOUL.md and MEMORY.md are existing private identity-vault scaffold files. Do not search workspace folders, read plans/, create files, or overwrite them. If exact private text is needed for a surgical removal or targeted replacement, call read_private_continuity_file with {"file":"MEMORY.md"} or {"file":"SOUL.md"}. If the user wants private continuity changed, call propose_private_continuity_edit. For memory/preferences use {"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or memory note."}. For persona use {"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior note."}.'
 
@@ -164,6 +169,7 @@ export async function* runRuntimeTurn(
   let continuationNudges = 0
   let iterationIndex = 0
   let priorIterationHadTools = false
+  let cumulativeToolUseCount = 0
   const toolEvidenceThisTurn: ToolEvidence[] = []
 
   // eslint-disable-next-line no-constant-condition
@@ -395,6 +401,29 @@ export async function* runRuntimeTurn(
       return
     }
 
+    if (cumulativeToolUseCount + pendingToolUses.length > MAX_TOOL_USES_PER_TURN) {
+      if (continuationNudges < maxContinuationNudges) {
+        continuationNudges += 1
+        yield {
+          type: 'continuation_nudge',
+          attempt: continuationNudges,
+          reason: 'tool_budget',
+        }
+        workingMessages = [
+          ...await rebuildMessages(),
+          { role: 'user', content: TOOL_BUDGET_NUDGE_TEXT },
+        ]
+        continue
+      }
+      yield {
+        type: 'error',
+        message: `tool budget exceeded (${MAX_TOOL_USES_PER_TURN} max per turn); ask again with a narrower request`,
+      }
+      yield doneEvent(false, stopReason)
+      return
+    }
+    cumulativeToolUseCount += pendingToolUses.length
+
     const batch = await runToolBatch(pendingToolUses)
     for (const completed of batch.completedTools) {
       toolEvidenceThisTurn.push({
@@ -461,7 +490,6 @@ function nextToolResultRepairNudge(
   completedTools: ExecutedToolUse[],
 ): string | null {
   if (!provider.supportsTools) return null
-  if (provider.id !== 'llamacpp') return null
   const failedPrivateEdit = completedTools.some(completed =>
     completed.name === 'propose_private_continuity_edit'
     && !completed.result.ok

package/src/storage/rewind.ts

@@ -131,6 +131,26 @@ export async function listRewindEntries(
     .slice(offset, offset + limit)
 }
 
+export async function groupRewindEntriesByTurn(
+  workspaceRoot: string,
+  sessionId: string,
+): Promise<Map<string, RewindEntry[]>> {
+  const normalizedWorkspaceRoot = path.resolve(workspaceRoot)
+  const snapshots = await loadSnapshots()
+  const grouped = new Map<string, RewindEntry[]>()
+  for (const snapshot of snapshots) {
+    if (isIdentityMarkdownSnapshot(snapshot)) continue
+    if (!isSnapshotWithinScope(snapshot, normalizedWorkspaceRoot)) continue
+    if (snapshot.sessionId !== sessionId) continue
+    if (!snapshot.turnId) continue
+    const entry = toEntry(snapshot)
+    const bucket = grouped.get(snapshot.turnId)
+    if (bucket) bucket.push(entry)
+    else grouped.set(snapshot.turnId, [entry])
+  }
+  return grouped
+}
+
 export async function rewindWorkspaceEditsByEntryIds(
   workspaceRoot: string,
   entryIds: string[],

package/src/storage/secrets.ts

@@ -129,8 +129,11 @@ export async function getSecret(account: string): Promise<string | null> {
 }
 
 export async function setSecret(account: string, value: string): Promise<KeyBackend> {
+  if (typeof value !== 'string') {
+    throw new Error(`setSecret(${account}): value is ${typeof value}, expected string`)
+  }
   const trimmed = value.trim()
-  if (!trimmed) throw new Error('Secret value is empty')
+  if (!trimmed) throw new Error(`setSecret(${account}): value is empty`)
   const keytar = await loadKeytar()
   if (keytar) {
     await keytar.setPassword(KEYTAR_SERVICE, account, trimmed)

package/src/storage/sessions.ts

@@ -6,6 +6,7 @@ import type { Message } from '../providers/contracts.js'
 import { getCwd } from '../runtime/cwd.js'
 import type { SessionMode } from '../runtime/sessionMode.js'
 import { atomicWriteText } from './atomicWrite.js'
+import { stripFileChangeResultDiff } from '../tools/fileDiff.js'
 import {
   isUserCorrectionOfToolState,
   looksLikeToolStateClaim,
@@ -282,7 +283,7 @@ export function sessionMessagesToProviderMessages(
       content: [{
         type: 'tool_result',
         toolUseId: message.toolUseId,
-        content: message.content,
+        content: stripFileChangeResultDiff(message.content),
         isError: message.isError,
       }],
     })

package/src/tools/bashSafety.ts

@@ -98,16 +98,16 @@ export function assessBashCommand(command: string): BashSafetyAssessment {
   const triggeredChecks = RISKY_PATTERN_CHECKS.filter(check => check.pattern.test(command)).map(check => check.message)
 
   const warning = triggeredChecks.length > 0
-    ? `warning: ${triggeredChecks[0]}. reusable approval is limited for this command.`
+    ? `Warning: ${sentenceCase(triggeredChecks[0] ?? 'command is risky')}. Reusable approval is limited for this command.`
     : highRisk
-      ? `warning: ${firstToken} is a high-impact command. reusable approval is limited for this command.`
+      ? `Warning: ${sentenceCase(firstToken ?? '')} is a high-impact command. Reusable approval is limited for this command.`
       : undefined
 
   return {
     warning,
     canPersistExact: triggeredChecks.length === 0 && !nonPersistable,
     canPersistPrefix: triggeredChecks.length === 0 && !highRisk && Boolean(firstToken),
-    commandPrefix: firstToken,
+    commandPrefix: firstToken ?? '',
   }
 }
 
@@ -180,3 +180,7 @@ function normalizeCommandToken(token: string): string {
     .toLowerCase()
     .replace(/[^a-z0-9_.:-]/g, '') ?? ''
 }
+
+function sentenceCase(value: string): string {
+  return value ? value[0]!.toUpperCase() + value.slice(1) : value
+}

package/src/tools/bashTool.ts

@@ -39,7 +39,7 @@ export const bashTool: Tool<typeof schema> = {
       command: input.command,
       commandPrefix: safety.commandPrefix,
       cwd,
-      title: 'allow shell command?',
+      title: 'Allow shell command?',
       subtitle: `${input.command}\n${cwd}`,
       warning: safety.warning,
       canPersistExact: safety.canPersistExact,

package/src/tools/contracts.ts

@@ -23,6 +23,7 @@ export type PermissionRequest =
       subtitle: string
       before: string
       after: string
+      diff: string
       changeSummary: string
     }
   | {
@@ -34,6 +35,7 @@ export type PermissionRequest =
       subtitle: string
       before: string
       after: string
+      diff: string
       changeSummary: string
     }
   | {
@@ -68,6 +70,7 @@ export type PermissionRequest =
       subtitle: string
       before: string
       after: string
+      diff: string
       changeSummary: string
     }
   | {

package/src/tools/deleteFileTool.ts

@@ -3,6 +3,7 @@ import path from 'node:path'
 import { z } from 'zod'
 import { recordRewindSnapshot } from '../storage/rewind.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
 import { resolveWorkspacePath } from './readTool.js'
 
 const schema = z.object({
@@ -35,6 +36,7 @@ export const deleteFileTool: Tool<typeof schema> = {
       subtitle: prepared.fullPath,
       before: preview(prepared.before),
       after: '(deleted)',
+      diff: renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: '' }),
       changeSummary: `delete ${prepared.relativePath}`,
     }
   },
@@ -58,9 +60,12 @@ export const deleteFileTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: `deleted ${prepared.relativePath}`,
-      content: rewindWarning
-        ? `deleted ${prepared.fullPath}\nwarning: ${rewindWarning}`
-        : `deleted ${prepared.fullPath}`,
+      content: formatFileChangeResult(
+        rewindWarning
+          ? `deleted ${prepared.fullPath}\nwarning: ${rewindWarning}`
+          : `deleted ${prepared.fullPath}`,
+        renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: '' }),
+      ),
     }
   },
 }

package/src/tools/editTool.ts

@@ -5,6 +5,7 @@ import { recordRewindSnapshot } from '../storage/rewind.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Tool } from './contracts.js'
 import { applyRequestedEdit } from './editUtils.js'
+import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
 import { resolveWorkspacePath } from './readTool.js'
 
 const schema = z.object({
@@ -44,15 +45,16 @@ export const editTool: Tool<typeof schema> = {
       subtitle: fullPath,
       before: applied.previewBefore,
       after: applied.previewAfter,
+      diff: renderUnifiedFileDiff({ filePath: relativePath, before: applied.before, after: applied.after }),
       changeSummary: applied.summary,
     }
   },
   async execute(input, context) {
-    const { fullPath, applied, existedBefore, before } = await prepareEdit(input, context)
+    const { fullPath, relativePath, applied, existedBefore, before } = await prepareEdit(input, context)
     const rewindWarning = await tryRecordRewindSnapshot({
       workspaceRoot: context.workspaceRoot,
       filePath: fullPath,
-      relativePath: path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath),
+      relativePath,
       existedBefore,
       previousContent: before,
       changeSummary: applied.summary,
@@ -68,9 +70,12 @@ export const editTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: applied.summary,
-      content: rewindWarning
-        ? `updated ${fullPath}\nwarning: ${rewindWarning}`
-        : `updated ${fullPath}`,
+      content: formatFileChangeResult(
+        rewindWarning
+          ? `updated ${fullPath}\nwarning: ${rewindWarning}`
+          : `updated ${fullPath}`,
+        renderUnifiedFileDiff({ filePath: relativePath, before: applied.before, after: applied.after }),
+      ),
     }
   },
 }

package/src/tools/fileDiff.ts

@@ -0,0 +1,261 @@
+export const DEFAULT_DIFF_CONTEXT_LINES = 3
+export const DEFAULT_DIFF_MAX_CHARS = 2400
+export const FILE_DIFF_RESULT_MARKER = '\n\n<!-- ethagent:file-diff:v1 -->\n'
+
+type DiffOp =
+  | { type: 'equal'; line: string }
+  | { type: 'delete'; line: string }
+  | { type: 'insert'; line: string }
+
+type HunkRange = {
+  start: number
+  end: number
+}
+
+type RenderUnifiedFileDiffInput = {
+  filePath: string
+  before: string
+  after: string
+  contextLines?: number
+  maxChars?: number
+}
+
+const LARGE_DIFF_MATRIX_LIMIT = 500_000
+
+export function renderUnifiedFileDiff(input: RenderUnifiedFileDiffInput): string {
+  const contextLines = input.contextLines ?? DEFAULT_DIFF_CONTEXT_LINES
+  const maxChars = input.maxChars ?? DEFAULT_DIFF_MAX_CHARS
+  const header = [`--- ${input.filePath}`, `+++ ${input.filePath}`]
+
+  if (input.before === input.after) {
+    return header.concat('(no changes)').join('\n')
+  }
+
+  const beforeLines = normalizedLines(input.before)
+  const afterLines = normalizedLines(input.after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  const hunks = buildHunkRanges(ops, contextLines)
+
+  if (hunks.length === 0) {
+    return header.concat('(only line ending changes)').join('\n')
+  }
+
+  const lines = [...header]
+  for (const hunk of hunks) {
+    const oldStart = countOldLines(ops, 0, hunk.start) + 1
+    const newStart = countNewLines(ops, 0, hunk.start) + 1
+    const oldCount = countOldLines(ops, hunk.start, hunk.end)
+    const newCount = countNewLines(ops, hunk.start, hunk.end)
+    lines.push(`@@ -${formatRange(oldStart, oldCount)} +${formatRange(newStart, newCount)} @@`)
+    for (const op of ops.slice(hunk.start, hunk.end)) {
+      if (op.type === 'equal') lines.push(` ${op.line}`)
+      else if (op.type === 'delete') lines.push(`-${op.line}`)
+      else lines.push(`+${op.line}`)
+    }
+  }
+
+  return truncateDiff(lines, maxChars)
+}
+
+export function formatFileChangeResult(content: string, diff: string): string {
+  return `${content}${FILE_DIFF_RESULT_MARKER}${diff}`
+}
+
+export function splitFileChangeResult(content: string): { content: string; diff?: string } {
+  const markerIndex = content.indexOf(FILE_DIFF_RESULT_MARKER)
+  if (markerIndex === -1) return { content }
+  const diff = content.slice(markerIndex + FILE_DIFF_RESULT_MARKER.length).trimEnd()
+  return {
+    content: content.slice(0, markerIndex).trimEnd(),
+    diff: diff.length > 0 ? diff : undefined,
+  }
+}
+
+export function stripFileChangeResultDiff(content: string): string {
+  return splitFileChangeResult(content).content
+}
+
+export function computeLineDiffStats(before: string, after: string): { inserts: number; deletes: number } {
+  if (before === after) return { inserts: 0, deletes: 0 }
+  const beforeLines = normalizedLines(before)
+  const afterLines = normalizedLines(after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  let inserts = 0
+  let deletes = 0
+  for (const op of ops) {
+    if (op.type === 'insert') inserts += 1
+    else if (op.type === 'delete') deletes += 1
+  }
+  return { inserts, deletes }
+}
+
+function buildLineDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  if (beforeLines.length * afterLines.length > LARGE_DIFF_MATRIX_LIMIT) {
+    return buildPrefixSuffixDiff(beforeLines, afterLines)
+  }
+
+  const lengths = lcsLengths(beforeLines, afterLines)
+  const ops: DiffOp[] = []
+  let beforeIndex = 0
+  let afterIndex = 0
+
+  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
+    const beforeLine = beforeLines[beforeIndex]!
+    const afterLine = afterLines[afterIndex]!
+    if (beforeLine === afterLine) {
+      ops.push({ type: 'equal', line: beforeLine })
+      beforeIndex += 1
+      afterIndex += 1
+      continue
+    }
+
+    const deleteScore = lengths[beforeIndex + 1]![afterIndex]!
+    const insertScore = lengths[beforeIndex]![afterIndex + 1]!
+    const deleteRevealsMatch = beforeLines[beforeIndex + 1] === afterLine
+    const insertRevealsMatch = beforeLine === afterLines[afterIndex + 1]
+
+    if (insertRevealsMatch && insertScore >= deleteScore) {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    } else if (deleteRevealsMatch && deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else if (deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    }
+  }
+
+  while (beforeIndex < beforeLines.length) {
+    ops.push({ type: 'delete', line: beforeLines[beforeIndex]! })
+    beforeIndex += 1
+  }
+  while (afterIndex < afterLines.length) {
+    ops.push({ type: 'insert', line: afterLines[afterIndex]! })
+    afterIndex += 1
+  }
+
+  return ops
+}
+
+function buildPrefixSuffixDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  let prefixLength = 0
+  while (
+    prefixLength < beforeLines.length &&
+    prefixLength < afterLines.length &&
+    beforeLines[prefixLength] === afterLines[prefixLength]
+  ) {
+    prefixLength += 1
+  }
+
+  let beforeEnd = beforeLines.length
+  let afterEnd = afterLines.length
+  while (
+    beforeEnd > prefixLength &&
+    afterEnd > prefixLength &&
+    beforeLines[beforeEnd - 1] === afterLines[afterEnd - 1]
+  ) {
+    beforeEnd -= 1
+    afterEnd -= 1
+  }
+
+  const ops: DiffOp[] = []
+  for (let index = 0; index < prefixLength; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < beforeEnd; index += 1) {
+    ops.push({ type: 'delete', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < afterEnd; index += 1) {
+    ops.push({ type: 'insert', line: afterLines[index]! })
+  }
+  for (let index = beforeEnd; index < beforeLines.length; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  return ops
+}
+
+function lcsLengths(beforeLines: string[], afterLines: string[]): number[][] {
+  const lengths = Array.from(
+    { length: beforeLines.length + 1 },
+    () => Array<number>(afterLines.length + 1).fill(0),
+  )
+
+  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
+    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
+      lengths[beforeIndex]![afterIndex] = beforeLines[beforeIndex] === afterLines[afterIndex]
+        ? lengths[beforeIndex + 1]![afterIndex + 1]! + 1
+        : Math.max(lengths[beforeIndex + 1]![afterIndex]!, lengths[beforeIndex]![afterIndex + 1]!)
+    }
+  }
+
+  return lengths
+}
+
+function buildHunkRanges(ops: DiffOp[], contextLines: number): HunkRange[] {
+  const ranges: HunkRange[] = []
+  const context = Math.max(0, contextLines)
+
+  for (let index = 0; index < ops.length; index += 1) {
+    if (ops[index]?.type === 'equal') continue
+    const start = Math.max(0, index - context)
+    const end = Math.min(ops.length, index + context + 1)
+    const previous = ranges[ranges.length - 1]
+    if (previous && start <= previous.end) {
+      previous.end = Math.max(previous.end, end)
+    } else {
+      ranges.push({ start, end })
+    }
+  }
+
+  return ranges
+}
+
+function countOldLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'delete') count += 1
+  }
+  return count
+}
+
+function countNewLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'insert') count += 1
+  }
+  return count
+}
+
+function formatRange(start: number, count: number): string {
+  if (count === 0) return `${Math.max(0, start - 1)},0`
+  if (count === 1) return String(start)
+  return `${start},${count}`
+}
+
+function normalizedLines(value: string): string[] {
+  if (value.length === 0) return []
+  const lines = value.replace(/\r\n?/g, '\n').split('\n')
+  if (lines[lines.length - 1] === '') lines.pop()
+  return lines
+}
+
+function truncateDiff(lines: string[], maxChars: number): string {
+  const diff = lines.join('\n')
+  if (diff.length <= maxChars) return diff
+
+  const out: string[] = []
+  let length = 0
+  for (const line of lines) {
+    const nextLength = length + (out.length > 0 ? 1 : 0) + line.length
+    if (nextLength > maxChars) break
+    out.push(line)
+    length = nextLength
+  }
+  return out.join('\n')
+}

package/src/tools/privateContinuityEditTool.ts

@@ -6,6 +6,7 @@ import {
 import { recordPrivateContinuityHistorySnapshot } from '../identity/continuity/history.js'
 import { readContinuityFiles, readPublicSkillsFile } from '../identity/continuity/storage.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult } from './fileDiff.js'
 
 const schema = z.object({
   file: z.preprocess(normalizePrivateContinuityFile, z.enum(['SOUL.md', 'MEMORY.md'])),
@@ -141,7 +142,10 @@ export const privateContinuityEditTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.changeSummary,
-      content: formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+      content: formatFileChangeResult(
+        formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+        prepared.diff,
+      ),
     }
   },
 }
@@ -166,6 +170,12 @@ function normalizePrivateContinuityInput(input: Record<string, unknown>): Record
   if (normalized.appendText === undefined) {
     normalized.appendText = normalized.note ?? normalized.text ?? normalized.content
   }
+  for (const key of ['oldText', 'newText', 'appendToSection', 'appendText'] as const) {
+    const value = normalized[key]
+    if (typeof value === 'string' && value.trim() === '') {
+      normalized[key] = undefined
+    }
+  }
   return normalized
 }
 

package/src/tools/writeFileTool.ts

@@ -4,6 +4,7 @@ import { z } from 'zod'
 import { recordRewindSnapshot } from '../storage/rewind.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
 import { resolveWorkspacePath } from './readTool.js'
 
 const schema = z.object({
@@ -40,6 +41,7 @@ export const writeFileTool: Tool<typeof schema> = {
       subtitle: prepared.fullPath,
       before: previewText(prepared.before),
       after: previewText(input.content),
+      diff: renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
       changeSummary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
     }
   },
@@ -64,9 +66,12 @@ export const writeFileTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
-      content: rewindWarning
-        ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
-        : `updated ${prepared.fullPath}`,
+      content: formatFileChangeResult(
+        rewindWarning
+          ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
+          : `updated ${prepared.fullPath}`,
+        renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
+      ),
     }
   },
 }

package/src/ui/Spinner.tsx

@@ -226,6 +226,7 @@ export const Spinner: React.FC<SpinnerProps> = ({
   const stickyVerbRef = useRef<string | null>(null)
   const internalStartedAtRef = useRef<number>(Date.now())
   const [frame, setFrame] = useState(0)
+  const [shimmerPos, setShimmerPos] = useState(0)
 
   useEffect(() => {
     if (!active) {
@@ -252,19 +253,40 @@ export const Spinner: React.FC<SpinnerProps> = ({
     return () => clearInterval(timer)
   }, [active])
 
-  if (!active) return null
-
   const autoLabel = stickyVerbRef.current ?? verb ?? 'thinking'
   const text = spinnerText(label ?? `${autoLabel}…`)
+
+  useEffect(() => {
+    if (!active) return
+    const period = text.length + 12
+    const timer = setInterval(() => {
+      setShimmerPos(prev => (prev + 1) % period)
+    }, 90)
+    return () => clearInterval(timer)
+  }, [active, text.length])
+
+  if (!active) return null
+
   const glyph = FRAMES[frame] ?? 'o'
   const elapsed = showElapsed ? formatElapsedSeconds(Date.now() - (startedAt ?? internalStartedAtRef.current)) : null
   const renderedHint = [rawHint, elapsed].filter(Boolean).join(' · ')
   const hint = renderedHint ? spinnerHintText(renderedHint) : ''
 
+  const shimmerStart = shimmerPos - 1
+  const shimmerEnd = shimmerPos + 1
+  const visibleStart = Math.max(0, shimmerStart)
+  const visibleEnd = Math.min(text.length, shimmerEnd + 1)
+  const before = text.slice(0, visibleStart)
+  const shimmer = shimmerStart < text.length && shimmerEnd >= 0 ? text.slice(visibleStart, visibleEnd) : ''
+  const after = text.slice(visibleEnd)
+
   return (
     <Text>
       <Text color={color}>{glyph}</Text>
-      <Text color={theme.dim}> {text}</Text>
+      <Text> </Text>
+      {before ? <Text color={theme.accentPeriwinkle}>{before}</Text> : null}
+      {shimmer ? <Text color={theme.accentWhite} bold>{shimmer}</Text> : null}
+      {after ? <Text color={theme.accentPeriwinkle}>{after}</Text> : null}
       {hint ? <Text color={theme.dim}> · {hint}</Text> : null}
     </Text>
   )

package/src/ui/TextInput.tsx

@@ -2,11 +2,11 @@ import React, { useState, useRef, useEffect } from 'react'
 import { Box, Text, useStdout } from 'ink'
 import { theme } from './theme.js'
 import { useAppInput } from '../app/input/AppInputProvider.js'
-import { moveVerticalVisual } from '../chat/chatInputState.js'
+import { moveVerticalVisual } from '../chat/input/chatInputState.js'
 import {
   getVisualLineIndex,
   getVisualLines,
-} from '../chat/textCursor.js'
+} from '../chat/input/textCursor.js'
 
 const DEFAULT_CHROME_WIDTH = 10