ethagent 2.2.0 → 2.4.0

package/src/providers/openai-chat.ts

@@ -5,6 +5,8 @@ import { providerErrorFromResponse } from './errors.js'
 import { fetchWithRetryStreamEvents } from './retry.js'
 import { iterSseFrames } from './sse.js'
 import { messageTextContent } from '../utils/messages.js'
+import { hasImageBlocks, ImageLoadError, loadImageBlock } from '../utils/images.js'
+import { providerDisplayName } from '../models/providerDisplay.js'
 
 export type OpenAIToolDefinition = {
   type: 'function'
@@ -27,6 +29,7 @@ type Options = {
   loadApiKey?: () => Promise<string | null>
   tools?: OpenAIToolDefinition[]
   maxRetries?: number
+  hasVisionProjector?: boolean
 }
 
 type ChatChunk = {
@@ -75,6 +78,7 @@ export class OpenAIChatProvider implements Provider {
   private readonly loadApiKey?: () => Promise<string | null>
   private readonly tools: OpenAIToolDefinition[]
   private readonly maxRetries?: number
+  private readonly hasVisionProjector: boolean
 
   constructor(opts: Options) {
     this.id = opts.id
@@ -85,6 +89,7 @@ export class OpenAIChatProvider implements Provider {
     this.tools = opts.tools ?? []
     this.maxRetries = opts.maxRetries
     this.supportsTools = this.tools.length > 0
+    this.hasVisionProjector = opts.hasVisionProjector ?? false
   }
 
   async *complete(
@@ -98,6 +103,19 @@ export class OpenAIChatProvider implements Provider {
       yield { type: 'error', message: error.message }
       return
     }
+    if (hasImageBlocks(messages)) {
+      if (this.id === 'llamacpp' && !this.hasVisionProjector) {
+        const hint = localModelNameHintsVision(this.model)
+          ? '; open alt+p and run "Add Vision Encoder" on this model to enable image input'
+          : ''
+        yield { type: 'error', message: `image input is not enabled for local model "${this.model}" (no vision projector loaded)${hint}` }
+        return
+      }
+      if (this.id === 'openai' && !supportsOpenAIImages(this.model)) {
+        yield { type: 'error', message: `image input is not enabled for ${this.model}` }
+        return
+      }
+    }
 
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
@@ -105,6 +123,17 @@ export class OpenAIChatProvider implements Provider {
     }
     if (apiKey) headers.Authorization = `Bearer ${apiKey}`
 
+    let wireMessages: Array<Record<string, unknown>>
+    try {
+      wireMessages = await toWireMessages(messages)
+    } catch (err: unknown) {
+      if (err instanceof ImageLoadError) {
+        yield { type: 'error', message: err.message }
+        return
+      }
+      throw err
+    }
+
     let response: Response
     try {
       response = yield* fetchWithRetryStreamEvents(`${this.baseUrl}/chat/completions`, {
@@ -112,7 +141,7 @@ export class OpenAIChatProvider implements Provider {
         headers,
         body: JSON.stringify({
           model: this.model,
-          messages: toWireMessages(messages),
+          messages: wireMessages,
           tools: this.tools.length > 0 ? this.tools : undefined,
           tool_choice: this.tools.length > 0 ? 'auto' : undefined,
           stream: true,
@@ -220,7 +249,7 @@ export class OpenAIChatProvider implements Provider {
 
 }
 
-export function toWireMessages(messages: Message[]): Array<Record<string, unknown>> {
+export async function toWireMessages(messages: Message[]): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
 
   for (const message of messages) {
@@ -229,6 +258,26 @@ export function toWireMessages(messages: Message[]): Array<Record<string, unknow
       continue
     }
 
+    if (message.role === 'user') {
+      const toolResults = message.content.filter(isToolResultBlock)
+      if (toolResults.length > 0) {
+        for (const block of toolResults) {
+          out.push({
+            role: 'tool',
+            tool_call_id: block.toolUseId,
+            content: block.content,
+          })
+        }
+        const nonToolBlocks = message.content.filter(block => block.type !== 'tool_result')
+        if (nonToolBlocks.length > 0) {
+          out.push({ role: 'user', content: await toOpenAIUserContent(nonToolBlocks) })
+        }
+        continue
+      }
+      out.push({ role: 'user', content: await toOpenAIUserContent(message.content) })
+      continue
+    }
+
     if (message.role === 'assistant') {
       const textParts = message.content.filter(isTextBlock).map(block => block.text)
       const toolCalls = message.content.filter(isToolUseBlock).map(block => ({
@@ -265,6 +314,37 @@ export function toWireMessages(messages: Message[]): Array<Record<string, unknow
   return normalizeSystemMessages(out)
 }
 
+async function toOpenAIUserContent(blocks: MessageContentBlock[]): Promise<Array<Record<string, unknown>>> {
+  const parts: Array<Record<string, unknown>> = []
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      if (block.text.length > 0) parts.push({ type: 'text', text: block.text })
+      continue
+    }
+    if (block.type === 'image') {
+      const loaded = await loadImageBlock(block)
+      if (loaded.url) {
+        parts.push({ type: 'image_url', image_url: { url: loaded.url } })
+      } else if (loaded.dataBase64 && loaded.mimeType) {
+        parts.push({ type: 'image_url', image_url: { url: `data:${loaded.mimeType};base64,${loaded.dataBase64}` } })
+      }
+      continue
+    }
+  }
+  return parts.length > 0 ? parts : [{ type: 'text', text: '' }]
+}
+
+export function supportsOpenAIImages(model: string): boolean {
+  const normalized = model.toLowerCase()
+  if (normalized.includes('gpt-3.5')) return false
+  return /gpt-4o|gpt-4\.1|gpt-4-turbo|gpt-4-vision|gpt-5|o1|o3|o4|chatgpt-4/.test(normalized)
+}
+
+export function localModelNameHintsVision(model: string): boolean {
+  const normalized = model.toLowerCase()
+  return /llava|bakllava|qwen[-_.]?vl|qwen2[-_.]?vl|qwen2\.5[-_.]?vl|minicpm-?v|llama-3\.2.*vision|mllama|cogvlm|internvl|moondream|pixtral|phi-?3[\.-]?vision|phi-?3\.5[\.-]?vision|smolvlm/.test(normalized)
+}
+
 function normalizeSystemMessages(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
   const systemContents: string[] = []
   const nonSystem: Array<Record<string, unknown>> = []
@@ -369,7 +449,7 @@ function providerNetworkErrorMessage(
 ): string {
   const message = (err as Error).message || fallback
   if (provider !== 'llamacpp') return message
-  return `${provider} request failed at ${baseUrl}: ${message}`
+  return `${providerDisplayName(provider)} request failed at ${baseUrl}: ${message}`
 }
 
 class ContentThinkingParser {

package/src/providers/openai-responses-format.ts

@@ -1,9 +1,11 @@
 import type { Message, MessageContentBlock } from './contracts.js'
 import { messageTextContent } from '../utils/messages.js'
 import type { OpenAIToolDefinition } from './openai-chat.js'
+import { loadImageBlock } from '../utils/images.js'
 
 export type ResponsesInputContent =
   | { type: 'input_text'; text: string }
+  | { type: 'input_image'; image_url: string }
   | { type: 'output_text'; text: string }
 
 export type ResponsesInputItem =
@@ -30,13 +32,13 @@ export type ResponsesRequestBody = {
   max_output_tokens?: number
 }
 
-export function buildResponsesBody(args: {
+export async function buildResponsesBody(args: {
   model: string
   messages: Message[]
   tools: OpenAIToolDefinition[]
   maxOutputTokens?: number
-}): ResponsesRequestBody {
-  const { instructions, items } = splitMessages(args.messages)
+}): Promise<ResponsesRequestBody> {
+  const { instructions, items } = await splitMessages(args.messages)
   const body: ResponsesRequestBody = {
     model: args.model,
     input: items,
@@ -60,10 +62,10 @@ export function buildResponsesBody(args: {
   return body
 }
 
-function splitMessages(messages: Message[]): {
+async function splitMessages(messages: Message[]): Promise<{
   instructions?: string
   items: ResponsesInputItem[]
-} {
+}> {
   const instructions: string[] = []
   const items: ResponsesInputItem[] = []
 
@@ -100,12 +102,12 @@ function splitMessages(messages: Message[]): {
         }
         continue
       }
-      const text = blocks.filter(isTextBlock).map(block => block.text).join('')
-      if (text) {
+      const content = await toOpenAIResponsesUserContent(blocks)
+      if (content.length > 0) {
         items.push({
           type: 'message',
           role: 'user',
-          content: [{ type: 'input_text', text }],
+          content,
         })
       }
       continue
@@ -136,6 +138,25 @@ function splitMessages(messages: Message[]): {
   }
 }
 
+async function toOpenAIResponsesUserContent(blocks: MessageContentBlock[]): Promise<ResponsesInputContent[]> {
+  const content: ResponsesInputContent[] = []
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      if (block.text) content.push({ type: 'input_text', text: block.text })
+      continue
+    }
+    if (block.type === 'image') {
+      const loaded = await loadImageBlock(block)
+      if (loaded.url) {
+        content.push({ type: 'input_image', image_url: loaded.url })
+      } else if (loaded.dataBase64 && loaded.mimeType) {
+        content.push({ type: 'input_image', image_url: `data:${loaded.mimeType};base64,${loaded.dataBase64}` })
+      }
+    }
+  }
+  return content
+}
+
 function normalizeBlocks(content: Message['content']): MessageContentBlock[] {
   if (typeof content === 'string') {
     return content ? [{ type: 'text', text: content }] : []

package/src/providers/openai-responses.ts

@@ -5,7 +5,8 @@ import { providerErrorFromResponse } from './errors.js'
 import { fetchWithRetryStreamEvents } from './retry.js'
 import { iterSseEvents } from './sse.js'
 import { buildResponsesBody } from './openai-responses-format.js'
-import type { OpenAIToolDefinition } from './openai-chat.js'
+import { supportsOpenAIImages, type OpenAIToolDefinition } from './openai-chat.js'
+import { hasImageBlocks, ImageLoadError } from '../utils/images.js'
 
 const READ_TIMEOUT_MS = 45_000
 
@@ -64,15 +65,29 @@ export class OpenAIResponsesProvider implements Provider {
       return
     }
 
+    if (hasImageBlocks(messages) && !supportsOpenAIImages(this.model)) {
+      yield { type: 'error', message: `image input is not enabled for ${this.model}` }
+      return
+    }
+
     let attempt = 0
     while (true) {
       attempt += 1
-      const body = JSON.stringify(buildResponsesBody({
-        model: this.model,
-        messages,
-        tools: this.tools,
-        maxOutputTokens: options.maxTokens,
-      }))
+      let body: string
+      try {
+        body = JSON.stringify(await buildResponsesBody({
+          model: this.model,
+          messages,
+          tools: this.tools,
+          maxOutputTokens: options.maxTokens,
+        }))
+      } catch (err: unknown) {
+        if (err instanceof ImageLoadError) {
+          yield { type: 'error', message: err.message }
+          return
+        }
+        throw err
+      }
 
       let response: Response
       try {

package/src/providers/registry.ts

@@ -34,6 +34,7 @@ export function createProvider(config: EthagentConfig, options: { mode?: Session
         baseUrl: localProviderBaseUrlFor('llamacpp', config.baseUrl),
         apiKey: 'llamacpp',
         tools: openAITools(mode, toolContext),
+        hasVisionProjector: Boolean(config.localMmprojPath),
       })
     case 'openai':
       return createOpenAIProvider(config, openAITools(mode, toolContext))

package/src/runtime/sessionMode.ts

@@ -24,7 +24,7 @@ export function nextSessionMode(mode: SessionMode): SessionMode {
 }
 
 export function sessionModeLabel(mode: SessionMode): string {
-  return mode === 'plan' ? 'Plan mode' : mode === 'accept-edits' ? 'Accept edits on' : ''
+  return mode === 'plan' ? 'plan mode' : mode === 'accept-edits' ? 'accept edits on' : ''
 }
 
 export function modePolicy(mode: PolicyMode): ModePolicy {

package/src/runtime/systemPrompt.ts

@@ -76,7 +76,7 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
         '**DIRECT REQUESTS**: If the user asks to change directory, list files, or read a file, respond with exactly one matching native tool call. Do not substitute prose or claim the action was taken.',
         '**EVIDENCE REQUIRED**: Do not claim a path is missing, a directory does not exist, or a file is absent unless you have a `list_directory` or `read_file` result from this conversation that confirms it.',
         '**TOOL TYPING**: Tool names are NOT shell commands. NEVER pass `list_directory`, `read_file`, `edit_file`, or `change_directory` directly to `run_bash`. Call the matching native tool.',
-        'Prefer targeted `read_file` and `edit_file` calls over general `run_bash` operations when both solve the task.',
+        '**PREFER NATIVE TOOLS**: If a request can be answered by `list_directory`, `read_file`, `edit_file`, `write_file`, `delete_file`, or `change_directory`, use that tool. Treat reaching for `run_bash` as a flag that you may be doing it wrong — only proceed if the action genuinely needs a real shell.',
         ...(ctx.mode === 'plan'
           ? [
               'Only read/list tools and permission-gated private continuity reads are available in plan mode.',
@@ -99,6 +99,8 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
                   ]
                 : ['No agent identity is linked in this session. Do not attempt private identity continuity edits; ask the user to create or load an agent first.']),
               'Use `run_bash` **only** when true shell execution is necessary.',
+              '**NO BASH EXPLORATION**: Never use `run_bash` to inspect the workspace. That means no `node -e`, no heredocs (`<<EOF`, `<<\'NODE\'`), no `find`, `grep`, `cat`, `head`, `tail`, `ls`, `dir`, `type`, `tree`, or shell loops to read or walk files. Use `list_directory` for directories and `read_file` for files. `run_bash` is reserved for actions that require a real shell: running tests, builds, git operations, launching processes. If you catch yourself writing a one-liner to read or list something, stop and call the native tool instead.',
+              '**DISCOVERY BUDGET**: For exploratory or "tell me about" questions, target ≤5 tool calls total. If 5 calls of the same kind have not given you enough to answer, the question does not need more depth — answer from what you have. Do not recursively scan, walk every subdirectory, or write deeper scripts to be more thorough than the user asked for. Stop and reply.',
               'Never use `run_bash` to produce conversational text. Do not call `echo`, `printf`, or similar to emit your reply — write it as your assistant text. Bash is for actions that need a real shell, not for generating words.',
               '**CWD CONTINUITY**: The working directory below is authoritative. After `change_directory` succeeds, use the new path as the base for subsequent actions.',
               'Do not lag behind the CWD. Edit/read relative to the *current* working directory.',

package/src/runtime/toolExecution.ts

@@ -17,10 +17,7 @@ import type {
 import { setCwd as setRuntimeCwd } from './cwd.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { SessionMessage } from '../storage/sessions.js'
-import {
-  summarizeToolInput,
-  toolResultContentForRow,
-} from '../chat/chatScreenUtils.js'
+import { toolResultContentForRow, toolResultDiffForRow } from '../chat/chatScreenUtils.js'
 import type { MessageRow } from '../chat/MessageList.js'
 import { modePolicy, toPermissionMode, type SessionMode } from './sessionMode.js'
 
@@ -239,7 +236,7 @@ export async function runPendingToolUses(args: {
         id: rowId,
         name: toolUse.name,
         summary: toolUse.name,
-        input: summarizeToolInput(toolUse.input),
+        input: toolUse.input,
       },
     ])
     await args.persistTurnMessage({
@@ -282,9 +279,15 @@ async function recordToolResult(
 ): Promise<void> {
   const isError = !result.ok
   const resultContent = toolResultContentForRow(toolUse.name, result.content, isError)
+  const diff = toolResultDiffForRow(result.content, isError)
   args.updateRows(prev => prev.map(row =>
     row.role === 'tool_call' && row.id === rowId
-      ? { ...row, result: { content: resultContent, summary: result.summary, isError } }
+      ? {
+          ...row,
+          result: diff
+            ? { content: resultContent, summary: result.summary, isError, diff }
+            : { content: resultContent, summary: result.summary, isError },
+        }
       : row,
   ))
   await args.persistTurnMessage({

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({

package/src/storage/config.ts

@@ -80,6 +80,7 @@ const ConfigSchema = z.object({
   provider: z.enum(PROVIDERS),
   model: z.string().min(1),
   baseUrl: z.string().url().optional(),
+  localMmprojPath: z.string().min(1).optional(),
   firstRunAt: z.string(),
   identity: IdentitySchema.optional(),
   erc8004: z.object({

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/sessions.ts

@@ -6,13 +6,15 @@ 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,
 } from '../runtime/toolClaimGuards.js'
+import { userTextToContentBlocks } from '../utils/images.js'
 
 export type SessionMessage =
-  | { version?: 2; role: 'user'; content: string; createdAt: string; turnId?: string; synthetic?: boolean }
+  | { version?: 2; role: 'user'; content: string; providerContent?: Message['content']; createdAt: string; turnId?: string; synthetic?: boolean }
   | { version?: 2; role: 'assistant'; content: string; createdAt: string; model?: string; usage?: { in?: number; out?: number }; turnId?: string; synthetic?: boolean }
   | { version?: 2; role: 'system'; content: string; createdAt: string; turnId?: string; synthetic?: boolean }
   | { version: 2; role: 'tool_use'; toolUseId: string; name: string; input: Record<string, unknown>; createdAt: string; turnId?: string }
@@ -243,6 +245,17 @@ export type ProviderMessageProjectionOptions = {
 export const TOOL_CORRECTION_CONTEXT_MESSAGE =
   'The latest user message corrects a prior assistant claim about tool or filesystem state. Treat user correction and tool_result messages as authoritative. Ignore any recent assistant claim about files, directories, cwd, or tool execution unless it is backed by a tool_result, and retry with the appropriate tool.'
 
+function resolveUserContent(
+  message: Extract<SessionMessage, { role: 'system' | 'user' | 'assistant' }>,
+): Message['content'] {
+  if (message.role !== 'user') return message.content
+  if (message.providerContent) return message.providerContent
+  if (message.content.includes('[image:')) {
+    return userTextToContentBlocks(message.content)
+  }
+  return message.content
+}
+
 export function sessionMessagesToProviderMessages(
   messages: SessionMessage[],
   options: ProviderMessageProjectionOptions = {},
@@ -254,7 +267,7 @@ export function sessionMessagesToProviderMessages(
   for (const [index, message] of messages.entries()) {
     if (message.role === 'system' || message.role === 'user' || message.role === 'assistant') {
       if (message.role === 'assistant' && invalidatedAssistantMessages.has(index)) continue
-      out.push({ role: message.role, content: message.content })
+      out.push({ role: message.role, content: resolveUserContent(message) })
       continue
     }
     if (message.role === 'tool_use') {
@@ -282,7 +295,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 }),
+      ),
     }
   },
 }