ethagent 1.1.1 → 2.0.0

package/src/chat/chatScreenUtils.ts

@@ -52,26 +52,37 @@ export function buildBaseMessages(
 
 export function sessionMessagesToRows(messages: SessionMessage[], nextRowId: () => string): MessageRow[] {
   const restored: MessageRow[] = []
+  const toolCallByUseId = new Map<string, Extract<MessageRow, { role: 'tool_call' }>>()
   for (const msg of messages) {
     if (msg.role === 'user') restored.push({ role: 'user', id: nextRowId(), content: msg.content })
     else if (msg.role === 'assistant') restored.push({ role: 'assistant', id: nextRowId(), content: msg.content })
     else if (msg.role === 'tool_use') {
-      restored.push({
-        role: 'tool_use',
+      const row: Extract<MessageRow, { role: 'tool_call' }> = {
+        role: 'tool_call',
         id: nextRowId(),
         name: msg.name,
         summary: msg.name,
         input: summarizeToolInput(msg.input),
-      })
+      }
+      restored.push(row)
+      toolCallByUseId.set(msg.toolUseId, row)
     } else if (msg.role === 'tool_result') {
-      restored.push({
-        role: 'tool_result',
-        id: nextRowId(),
-        name: msg.name,
-        summary: msg.isError ? `${msg.name} failed` : `${msg.name} completed`,
-        content: toolResultContentForRow(msg.name, msg.content, msg.isError),
-        isError: msg.isError,
-      })
+      const isError = Boolean(msg.isError)
+      const summary = isError ? `${msg.name} failed` : `${msg.name} completed`
+      const content = toolResultContentForRow(msg.name, msg.content, msg.isError)
+      const existing = toolCallByUseId.get(msg.toolUseId)
+      if (existing) {
+        existing.result = { content, summary, isError }
+        existing.name = msg.name
+      } else {
+        restored.push({
+          role: 'tool_call',
+          id: nextRowId(),
+          name: msg.name,
+          summary: msg.name,
+          result: { content, summary, isError },
+        })
+      }
     }
   }
   return restored

package/src/chat/chatSessionState.ts

@@ -49,7 +49,7 @@ export function resolveModelSelection(
         model: selection.model,
         baseUrl,
       },
-      notice: `local Hugging Face model ready. now using ${formatModelDisplayName('llamacpp', selection.model, { maxLength: 64 })}.`,
+      notice: `Local Hugging Face model ready. Now using ${formatModelDisplayName('llamacpp', selection.model, { maxLength: 64 })}.`,
       tone: 'info',
     }
   }
@@ -69,7 +69,7 @@ export function resolveModelSelection(
   return {
     kind: 'switch',
     config: nextConfig,
-    notice: `${selection.keyJustSet ? `${selection.provider} key saved.` : `${selection.provider} ready.`} now using ${nextConfig.provider} · ${formatModelDisplayName(nextConfig.provider, nextConfig.model, { maxLength: 64 })}.`,
+    notice: `${selection.keyJustSet ? `${selection.provider} key saved.` : `${selection.provider} ready.`} Now using ${nextConfig.provider} · ${formatModelDisplayName(nextConfig.provider, nextConfig.model, { maxLength: 64 })}.`,
     tone: 'dim',
   }
 }

package/src/chat/chatTurnOrchestrator.ts

@@ -60,18 +60,6 @@ export type StreamingTurnResult = {
   cancelled: boolean
 }
 
-/**
- * runStreamingTurn - the UI adapter over runRuntimeTurn.
- *
- * Responsibilities (UI-only; logic lives in runtime/turn.ts):
- *   - translate runtime events into Ink MessageRow updates,
- *   - flush streaming text to rows on a debounce,
- *   - persist SessionMessages on commit boundaries,
- *   - drive the tool batch (permission prompts, row pushes, persistence),
- *   - surface plan-mode output to the caller,
- *   - return a summary of what happened (finishedNormally / cancelled)
- *     for the caller to act on.
- */
 export async function runStreamingTurn(
   context: TurnOrchestratorContext,
 ): Promise<StreamingTurnResult> {
@@ -86,7 +74,6 @@ export async function runStreamingTurn(
     nowIso,
     getConfig,
     getCwd,
-    getSessionMessages,
     setActiveCheckpoint,
     setStreaming,
     updateRows,
@@ -135,8 +122,6 @@ export async function runStreamingTurn(
     ]
   }
 
-  // Per-iteration UI scratch. These are reset each time the runtime loop
-  // re-enters streaming (new provider call = new assistant row, new accumulator).
   let accumulated = ''
   let thinkingContent = ''
   let thinkingRowId: string | null = null
@@ -207,9 +192,6 @@ export async function runStreamingTurn(
     flushStreamRows(true)
     updateRows(prev => {
       let next = finalizeStreamingRowsById(prev, assistantId, thinkingRowId, accumulated, thinkingContent)
-      // If we emitted tool_uses, strip the empty assistant text row - tool_use
-      // rows replace it. If the assistant emitted no text at all (pure tool
-      // turn), drop the empty row.
       if (assistantId && (hasPendingToolUse || accumulated.length === 0)) {
         next = next.filter(r => r.id !== assistantId)
       }
@@ -235,13 +217,6 @@ export async function runStreamingTurn(
     name: string
     input: Record<string, unknown>
   }>) => {
-    // Persist the assistant tool_use blocks into the session before execution
-    // so microcompact / rebuild has them on the next provider call. The actual
-    // Message[] sent to the provider is rebuilt from session messages.
-    // (This mirrors the pre-Wave-2 behavior, just routed from the event loop.)
-    // NOTE: some provider loops keep tool_use blocks inside the assistant
-    // message; ethagent stores them as discrete tool_use SessionMessages via
-    // runPendingToolUses, which keeps the microcompact model simpler.
     const step = await runPendingToolUses({
       pendingToolUses,
       nextRowId,
@@ -351,10 +326,6 @@ export async function runStreamingTurn(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Event handling: per-event UI translation
-// ---------------------------------------------------------------------------
-
 type EventHandlerContext = {
   ensureAssistantRow: () => string
   flushStreamRows: (immediate?: boolean) => void
@@ -391,10 +362,6 @@ function isCancelledEvent(ev: TurnEvent): boolean {
 async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<void> {
   switch (ev.type) {
     case 'iteration_start': {
-      // Reset per-iteration scratch so each provider call gets a fresh
-      // assistant row, accumulator, and hasPendingToolUse flag. Iteration 0
-      // is the initial stream - resetting before anything runs is a no-op,
-      // which is fine.
       ctx.resetIteration()
       return
     }
@@ -433,7 +400,6 @@ async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<voi
       return
     }
     case 'retry': {
-      ctx.pushNote(formatRetryStatus(ev), 'dim')
       return
     }
     case 'tool_use_stop': {
@@ -442,8 +408,6 @@ async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<voi
       return
     }
     case 'assistant_message_committed': {
-      // End of a streaming round with no tool_use - finalize rows, persist
-      // the assistant text, and hand it to the plan hook if in plan mode.
       ctx.finalizeStreamingRows()
       if (ev.text) {
         await ctx.persistTurnMessage({
@@ -458,22 +422,14 @@ async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<voi
       return
     }
     case 'tool_executed': {
-      // Row + session persistence happened inside runPendingToolUses; the
-      // event is informational for observers that need it (tests, future
-      // instrumentation). No UI side-effect here.
       return
     }
     case 'local_tool_recovery': {
-      // The runtime recovered tool calls from local model text output.
-      // Discard the streamed assistant rows that contained the JSON blob
-      // so they are not persisted or displayed as prose.
       ctx.discardStreamingRows()
       ctx.markPendingToolUse()
       return
     }
     case 'continuation_nudge': {
-      // Clean break between provider calls. Corrective nudges suppress the
-      // unverified assistant row so it cannot become durable context.
       if (
         ev.reason === 'tool_state_claim' ||
         ev.reason === 'tool_capability' ||
@@ -501,9 +457,6 @@ async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<voi
       return
     }
     case 'done': {
-      // If we ended mid-iteration (no assistant_message_committed yet) the
-      // finalize call from error/cancelled already ran. If we ended after a
-      // tool_executed batch, finalize here so the UI settles.
       ctx.finalizeStreamingRows()
       if (ev.finishedNormally) ctx.onFinishedNormally()
       return
@@ -514,21 +467,6 @@ async function handleEvent(ev: TurnEvent, ctx: EventHandlerContext): Promise<voi
   }
 }
 
-function formatRetryStatus(ev: Extract<TurnEvent, { type: 'retry' }>): string {
-  const totalAttempts = ev.maxRetries + 1
-  const reason = ev.status !== undefined ? `HTTP ${ev.status}` : ev.code ?? ev.reason
-  return `provider retry ${ev.nextAttempt}/${totalAttempts} in ${formatRetryDelay(ev.delayMs)} (${reason})`
-}
-
-function formatRetryDelay(delayMs: number): string {
-  if (delayMs < 1000) return `${Math.max(0, Math.round(delayMs))}ms`
-  const seconds = delayMs / 1000
-  if (seconds < 10) return `${seconds.toFixed(1).replace(/\.0$/, '')}s`
-  if (seconds < 60) return `${Math.round(seconds)}s`
-  const minutes = seconds / 60
-  return `${minutes.toFixed(minutes < 10 ? 1 : 0).replace(/\.0$/, '')}m`
-}
-
 function updateStreamingRows(
   rows: MessageRow[],
   assistantId: string | null,
@@ -592,10 +530,6 @@ function findRowIndexById(rows: MessageRow[], id: string): number {
   return -1
 }
 
-// ---------------------------------------------------------------------------
-// File-mention context (unchanged from pre-Wave-2 - pure helper)
-// ---------------------------------------------------------------------------
-
 async function buildFileMentionContextMessages(
   userText: string,
   cwd: string,
@@ -641,23 +575,24 @@ export async function buildIdentityContinuityContextMessages(
 
   try {
     const privateFiles = await readContinuityFiles(identity)
+    const parts: string[] = [
+      '<identity_continuity_files>',
+      'The active identity continuity files have been loaded automatically for this turn.',
+      'SOUL.md is private owner continuity and is the authoritative persona, voice, and standing-behavior layer for this active identity.',
+      'MEMORY.md is private owner continuity for durable preferences, facts, and project context.',
+      'Apply SOUL.md and MEMORY.md over generic ethagent identity/style unless they conflict with safety, tool correctness, developer instructions, or the user\'s latest explicit request. Do not quote private continuity unless necessary.',
+      '<SOUL.md visibility="private">',
+      privateFiles['SOUL.md'].trimEnd(),
+      '</SOUL.md>',
+      '',
+      '<MEMORY.md visibility="private">',
+      privateFiles['MEMORY.md'].trimEnd(),
+      '</MEMORY.md>',
+      '</identity_continuity_files>',
+    ]
     return [{
       role: 'system',
-      content: [
-        '<identity_continuity_files>',
-        'The active identity continuity files have been loaded automatically for this turn.',
-        'SOUL.md is private owner continuity and is the authoritative persona, voice, and standing-behavior layer for this active identity.',
-        'MEMORY.md is private owner continuity for durable preferences, facts, and project context.',
-        'Apply SOUL.md and MEMORY.md over generic ethagent identity/style unless they conflict with safety, tool correctness, developer instructions, or the user\'s latest explicit request. Do not quote private continuity unless necessary.',
-        '<SOUL.md visibility="private">',
-        privateFiles['SOUL.md'].trimEnd(),
-        '</SOUL.md>',
-        '',
-        '<MEMORY.md visibility="private">',
-        privateFiles['MEMORY.md'].trimEnd(),
-        '</MEMORY.md>',
-        '</identity_continuity_files>',
-      ].join('\n'),
+      content: parts.join('\n'),
     }]
   } catch (err: unknown) {
     return [{

package/src/chat/commands.ts

@@ -210,7 +210,7 @@ const COMMANDS: CommandSpec[] = [
       }
       await saveConfig(next)
       ctx.onReplaceConfig(next)
-      return { kind: 'note', text: `now using ${next.provider} · ${formatModelDisplayName(next.provider, name, { maxLength: 64 })}.` }
+      return { kind: 'note', text: `Now using ${next.provider} · ${formatModelDisplayName(next.provider, name, { maxLength: 64 })}.` }
     },
   },
   {

package/src/chat/textCursor.ts

@@ -119,7 +119,7 @@ export function moveVerticalVisualCursor(
   }
 }
 
-export function cursorOnLastLine(value: string, offset: number): TextCursor {
+export function cursorOnLastLine(value: string, _offset: number): TextCursor {
   const lines = getLogicalLines(value)
   const lastLine = Math.max(0, lines.length - 1)
   return normalizeCursor(value, offsetFromPosition(lines, lastLine, 0))

package/src/chat/transcriptViewport.ts

@@ -1,5 +1,4 @@
 import type { MessageRow } from './MessageList.js'
-import { hidesSuccessfulToolResultContent } from './toolResultDisplay.js'
 
 export type TranscriptAnchor = {
   rowId: string
@@ -219,12 +218,8 @@ export function estimateMessageRowHeight(row: MessageRow, columns = 80): number
       return row.expanded
         ? 3 + wrappedLineCount([row.content, row.liveTail ?? ''].filter(Boolean).join('\n'), contentWidth)
         : 3 + wrappedLineCount(reasoningPreview(row), contentWidth)
-    case 'tool_use':
-      return 3 + (row.input ? wrappedLineCount(row.input, contentWidth) : 0)
-    case 'tool_result':
-      return hidesSuccessfulToolResultContent(row.name, row.isError)
-        ? 3
-        : 3 + wrappedLineCount(row.content, contentWidth)
+    case 'tool_call':
+      return 1
     case 'note':
       return 1 + wrappedLineCount(row.content, contentWidth)
     case 'progress':

package/src/cli/ResetConfirmView.tsx

@@ -47,7 +47,7 @@ export const ResetConfirmView: React.FC<{
 
 const Section: React.FC<{ title: string; lines: string[] }> = ({ title, lines }) => (
   <Box flexDirection="column" marginBottom={1}>
-    <Text color={theme.accentMint}>{title}</Text>
+    <Text color={theme.accentPeriwinkle}>{title}</Text>
     {lines.map(line => (
       <Text key={line} color={theme.textSubtle}>- {line}</Text>
     ))}

package/src/cli/main.tsx

@@ -103,13 +103,19 @@ const AppRoot: React.FC<{ setExitCode: (code: number) => void; currentVersion: s
 
   useAppInput((input, key) => {
     if (phase.kind === 'ready') return
-    if (key.ctrl && (input === 'c' || input === 'd')) exit()
+    if (key.ctrl && (input === 'c' || input === 'd')) {
+      if (phase.kind === 'setup') {
+        setPhase({ kind: 'cancelled' })
+      } else {
+        exit()
+      }
+    }
   })
 
   if (phase.kind === 'loading') {
     return (
       <Box padding={1}>
-        <Spinner label="Starting ethagent..." showElapsed={false} />
+        <Spinner label="starting ethagent..." showElapsed={false} />
       </Box>
     )
   }
@@ -131,7 +137,7 @@ const AppRoot: React.FC<{ setExitCode: (code: number) => void; currentVersion: s
   if (phase.kind === 'error') {
     return (
       <Box padding={1}>
-        <Text color="#e87070">Error: {phase.message}</Text>
+        <Text color={theme.accentError}>Error: {phase.message}</Text>
       </Box>
     )
   }

package/src/cli/preview.tsx

@@ -2,17 +2,12 @@ import React from 'react'
 import { Box, render } from 'ink'
 import { BrandSplash } from '../ui/BrandSplash.js'
 
-/**
- * `ethagent preview` — renders the brand splash with only the tagline
- * in the top border, no technical details at the bottom, and exits.
- */
 export async function runPreviewCommand(): Promise<number> {
   const instance = render(
     <Box flexDirection="column" marginY={1}>
       <BrandSplash />
     </Box>,
   )
-  // Give Ink one tick to paint, then unmount cleanly.
   await new Promise<void>(resolve => setTimeout(resolve, 50))
   instance.unmount()
   return 0

package/src/cli/updateNotice.ts

@@ -12,8 +12,10 @@ export function compareVersions(left: string, right: string): number {
   const b = parseVersion(right)
   if (!a || !b) return 0
   for (let i = 0; i < 3; i++) {
-    if (a[i] > b[i]) return 1
-    if (a[i] < b[i]) return -1
+    const av = a[i as 0 | 1 | 2]
+    const bv = b[i as 0 | 1 | 2]
+    if (av > bv) return 1
+    if (av < bv) return -1
   }
   return 0
 }
@@ -24,7 +26,7 @@ export function isNewerVersion(candidate: string, current: string): boolean {
 
 export function formatUpdateNotice(currentVersion: string, latestVersion: string): string | null {
   if (!isNewerVersion(latestVersion, currentVersion)) return null
-  return `update available: ethagent ${currentVersion} -> ${latestVersion}; run npm i -g ethagent`
+  return `✨ update available: ethagent ${currentVersion} -> ${latestVersion} · run npm i -g ethagent@latest`
 }
 
 export async function checkForUpdates(

package/src/identity/continuity/editor.ts

@@ -1,12 +1,10 @@
-import fs from 'node:fs'
-import path from 'node:path'
 import { spawn } from 'node:child_process'
 
-export type EditorOpenResult =
+type EditorOpenResult =
   | { ok: true; method: string; waited: boolean }
   | { ok: false; error: string }
 
-export type EditorCommand = {
+type EditorCommand = {
   cmd: string
   args: string[]
   method: string
@@ -14,59 +12,10 @@ export type EditorCommand = {
   shell?: boolean
 }
 
-export type EditorResolutionOptions = {
-  platform?: NodeJS.Platform
-  commandExists?: (command: string) => string | null
-}
-
-const IDE_CANDIDATES = ['code', 'cursor', 'windsurf'] as const
-
-export function openFileInEditor(file: string, env: NodeJS.ProcessEnv = process.env): Promise<EditorOpenResult> {
-  const command = resolveEditorCommand(file, env)
-  if (command) return openEditorCommand(command)
-  return openDefaultEditor(file)
-}
-
-export function resolveEditorCommand(
-  file: string,
-  env: NodeJS.ProcessEnv = process.env,
-  options: EditorResolutionOptions = {},
-): EditorCommand | null {
-  const platform = options.platform ?? process.platform
-  const commandExists = options.commandExists ?? (command => findExecutable(command, env, platform))
-
-  const ethagentEditor = env.ETHAGENT_EDITOR?.trim()
-  if (ethagentEditor) return configuredCommand(ethagentEditor, file, true, platform)
-
-  for (const candidate of IDE_CANDIDATES) {
-    const executable = commandExists(candidate)
-    if (executable) {
-      return {
-        cmd: executable,
-        args: [file],
-        method: candidate,
-        waited: false,
-        shell: platform === 'win32' && /\.(?:cmd|bat)$/i.test(executable),
-      }
-    }
-  }
-
-  const configured = env.VISUAL?.trim() || env.EDITOR?.trim()
-  if (configured) return configuredCommand(configured, file, true, platform)
-
-  return defaultEditorCommand(file, platform)
-}
-
-function configuredCommand(commandLine: string, file: string, waited: boolean, platform: NodeJS.Platform): EditorCommand | null {
-  const [cmd, ...args] = splitCommand(commandLine)
-  if (!cmd) return null
-  return {
-    cmd,
-    args: [...args, file],
-    method: path.basename(cmd),
-    waited,
-    shell: platform === 'win32' && /\.(?:cmd|bat)$/i.test(cmd),
-  }
+export function openFileInEditor(file: string): Promise<EditorOpenResult> {
+  const command = defaultEditorCommand(file)
+  if (!command) return Promise.resolve({ ok: false, error: 'no default open command for this platform' })
+  return openEditorCommand(command)
 }
 
 function openEditorCommand(command: EditorCommand): Promise<EditorOpenResult> {
@@ -93,57 +42,8 @@ function openEditorCommand(command: EditorCommand): Promise<EditorOpenResult> {
   })
 }
 
-function openDefaultEditor(file: string): Promise<EditorOpenResult> {
-  const command = defaultEditorCommand(file)
-  if (!command) return Promise.resolve({ ok: false, error: 'no default editor command for this platform' })
-  return openEditorCommand(command)
-}
-
-function defaultEditorCommand(file: string, platform: NodeJS.Platform = process.platform): EditorCommand | null {
+export function defaultEditorCommand(file: string, platform: NodeJS.Platform = process.platform): EditorCommand | null {
   if (platform === 'win32') return { cmd: 'cmd', args: ['/c', 'start', '', file], method: 'cmd', waited: false }
   if (platform === 'darwin') return { cmd: 'open', args: [file], method: 'open', waited: false }
   return { cmd: 'xdg-open', args: [file], method: 'xdg-open', waited: false }
 }
-
-function splitCommand(commandLine: string): string[] {
-  return commandLine.match(/"[^"]+"|'[^']+'|\S+/g)?.map(part => {
-    if ((part.startsWith('"') && part.endsWith('"')) || (part.startsWith("'") && part.endsWith("'"))) {
-      return part.slice(1, -1)
-    }
-    return part
-  }) ?? []
-}
-
-function findExecutable(command: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | null {
-  const hasPathSeparator = command.includes('/') || command.includes('\\')
-  if (hasPathSeparator || path.isAbsolute(command)) {
-    return canAccessExecutable(command) ? command : null
-  }
-
-  const pathValue = env.PATH ?? ''
-  const pathParts = pathValue.split(path.delimiter).filter(Boolean)
-  const extensions = platform === 'win32'
-    ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
-    : ['']
-
-  for (const dir of pathParts) {
-    for (const ext of extensions) {
-      const candidate = path.join(dir, platform === 'win32' && path.extname(command) === '' ? `${command}${ext.toLowerCase()}` : command)
-      if (canAccessExecutable(candidate)) return candidate
-      if (platform === 'win32') {
-        const upperCandidate = path.join(dir, path.extname(command) === '' ? `${command}${ext.toUpperCase()}` : command)
-        if (canAccessExecutable(upperCandidate)) return upperCandidate
-      }
-    }
-  }
-  return null
-}
-
-function canAccessExecutable(file: string): boolean {
-  try {
-    fs.accessSync(file, fs.constants.X_OK)
-    return true
-  } catch {
-    return false
-  }
-}