ethagent 3.0.1 → 3.1.0

package/README.md

@@ -163,11 +163,16 @@ cd ethagent && npm install
 npm start
 ```
 
+The published CLI is source-distributed: `bin/ethagent.js` launches `src/cli/main.tsx` through `tsx`. `npm run build` is therefore a validation build; it checks the shipped TypeScript without producing a separate `dist/` directory.
+
+Repository structure and refactoring rules are documented in `ARCHITECTURE.md` and `CONTRIBUTING.md`. Stable facades keep public import paths intact while focused sibling modules hold private implementation details.
+
 | Command | What it does |
 | --- | --- |
 | `npm start` | Run from source. |
+| `npm run build` | Validate the shipped TypeScript source package. |
 | `npm test` | Test suite. |
-| `npm run typecheck` | Types. |
+| `npm run typecheck` | Run the same TypeScript check directly. |
 | `npm run contracts:test` | Foundry tests. |
 
 Foundry is only needed for `contracts/` changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethagent",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "A privacy-first AI agent with a portable Ethereum identity",
   "type": "module",
   "main": "bin/ethagent.js",
@@ -15,8 +15,10 @@
   ],
   "scripts": {
     "start": "node bin/ethagent.js",
+    "build": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
     "test": "node test/run-tests.mjs",
+    "prepack": "npm run build",
     "contracts:build": "cd contracts && forge build",
     "contracts:test": "cd contracts && forge test -vv",
     "contracts:fmt": "cd contracts && forge fmt"

package/src/app/FirstRun.tsx

@@ -26,6 +26,7 @@ import {
 import { setKey } from '../storage/secrets.js'
 import { IdentityHub, type IdentityHubResult } from '../identity/hub/IdentityHub.js'
 import { FirstRunTimeline, firstRunStageNumber, type FirstRunStepKind } from './FirstRunTimeline.js'
+import { configFromModelPickerSelection, formatGB } from './firstRunConfig.js'
 
 type Step =
   | { kind: 'detecting' }
@@ -568,27 +569,3 @@ export const FirstRun: React.FC<FirstRunProps> = ({ onComplete, onCancel }) => {
   return null
 }
 
-function configFromModelPickerSelection(selection: ModelPickerSelection, base: EthagentConfig): EthagentConfig {
-  if (selection.kind === 'llamacpp') {
-    return {
-      ...base,
-      provider: 'llamacpp',
-      model: selection.model,
-      baseUrl: defaultBaseUrlFor('llamacpp'),
-      localMmprojPath: selection.mmprojPath,
-    }
-  }
-  return {
-    ...base,
-    provider: selection.provider,
-    model: selection.model,
-    baseUrl: undefined,
-    localMmprojPath: undefined,
-  }
-}
-
-function formatGB(bytes: number): string {
-  const gb = bytes / (1024 * 1024 * 1024)
-  return gb < 10 ? `${gb.toFixed(1)}GB` : `${Math.round(gb)}GB`
-}
-

package/src/app/firstRunConfig.ts

@@ -0,0 +1,26 @@
+import { defaultBaseUrlFor, type EthagentConfig } from '../storage/config.js'
+import type { ModelPickerSelection } from '../models/ModelPicker.js'
+
+export function configFromModelPickerSelection(selection: ModelPickerSelection, base: EthagentConfig): EthagentConfig {
+  if (selection.kind === 'llamacpp') {
+    return {
+      ...base,
+      provider: 'llamacpp',
+      model: selection.model,
+      baseUrl: defaultBaseUrlFor('llamacpp'),
+      localMmprojPath: selection.mmprojPath,
+    }
+  }
+  return {
+    ...base,
+    provider: selection.provider,
+    model: selection.model,
+    baseUrl: undefined,
+    localMmprojPath: undefined,
+  }
+}
+
+export function formatGB(bytes: number): string {
+  const gb = bytes / (1024 * 1024 * 1024)
+  return gb < 10 ? `${gb.toFixed(1)}GB` : `${Math.round(gb)}GB`
+}

package/src/auth/openaiOAuth/landingPage.ts

@@ -1,22 +1,13 @@
 import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { transformSync } from 'esbuild'
 import { WALLET_CSS } from '../../identity/wallet/page/styles/index.js'
 import { glyphs } from '../../identity/wallet/page/html.js'
+import { walletPageSourceFile } from '../../identity/wallet/browserWallet/walletPageSource.js'
 import { escapeHtml } from './shared.js'
 
 export type LandingTone = 'success' | 'error' | 'cancelled'
 
-const GRAINIENT_SOURCE_FILE = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'identity',
-  'wallet',
-  'page',
-  'grainient.ts',
-)
+const GRAINIENT_SOURCE_FILE = walletPageSourceFile('page/grainient.ts')
 
 const COMPILED_GRAINIENT = compileGrainientModule()
 

package/src/chat/ChatScreen.tsx

@@ -1,6 +1,4 @@
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import os from 'node:os'
-import path from 'node:path'
 import { Box, Text, useApp } from 'ink'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Provider, Message } from '../providers/contracts.js'
@@ -23,6 +21,7 @@ import type { ModelPickerSelection } from '../models/ModelPicker.js'
 import type { ModelPickerContextFit } from '../models/modelPickerOptions.js'
 import type { CopyResult } from '../utils/clipboard.js'
 import { useKeybinding, useRegisterKeybindingContext } from '../app/keybindings/KeybindingProvider.js'
+import { TITLE_ANIMATION_FRAMES, TITLE_ANIMATION_INTERVAL_MS, TITLE_STATIC, setTerminalTitle } from '../ui/terminalTitle.js'
 import { useCancelRequest } from '../app/hooks/useCancelRequest.js'
 import { useExitOnCtrlC } from '../app/hooks/useExitOnCtrlC.js'
 import {
@@ -54,7 +53,6 @@ import type {
   PermissionRequest,
   SessionPermissionRule,
 } from '../tools/contracts.js'
-import { splitFileChangeResult } from '../tools/fileDiff.js'
 import {
   buildBaseMessages,
   sessionMessagesToRows,
@@ -73,12 +71,26 @@ import {
   restoreConversationState,
 } from './chatSessionState.js'
 import { runStreamingTurn } from './chatTurnOrchestrator.js'
-import { ensureLlamaCppRunnerReady } from '../models/llamacppPreflight.js'
 import type { PlanApprovalAction } from './views/PlanApprovalView.js'
 import type { ContextLimitAction } from './views/ContextLimitView.js'
 import type { ContinuityEditReviewAction, ContinuityEditReviewState } from './views/ContinuityEditReviewView.js'
 import { openFileInEditor } from '../identity/continuity/editor.js'
 import { EMPTY_MCP_SNAPSHOT, McpManager, type McpSnapshot } from '../mcp/manager.js'
+import { compressHome, ensureLocalProviderReady } from './chatEnvironment.js'
+import {
+  buildPlanImplementationPrompt,
+  buildPlanTransferSeedMessages,
+  chatFooterShortcutText,
+  normalizeHandoffSummary,
+} from './planImplementation.js'
+import { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
+
+export {
+  buildPlanImplementationPrompt,
+  buildPlanTransferSeedMessages,
+  chatFooterShortcutText,
+} from './planImplementation.js'
+export { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
 
 type ChatScreenProps = {
   config: EthagentConfig
@@ -113,19 +125,6 @@ const nowIso = (): string => new Date().toISOString()
 const STREAM_FLUSH_MS = 120
 const CONTEXT_CONFIRM_PERCENT = 90
 const MAX_PROMPT_HISTORY = 500
-const MAX_HANDOFF_SUMMARY_CHARS = 12_000
-
-function compressHome(cwd: string): string {
-  const home = os.homedir()
-  if (cwd === home) return '~'
-  if (cwd.startsWith(home + path.sep)) return '~' + cwd.slice(home.length).replace(/\\/g, '/')
-  return cwd.replace(/\\/g, '/')
-}
-
-async function ensureLocalProviderReady(config: EthagentConfig): Promise<{ ok: true } | { ok: false; message: string }> {
-  if (config.provider === 'llamacpp') return ensureLlamaCppRunnerReady(config)
-  return { ok: true }
-}
 
 export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, onReplaceConfig, updateNotice }) => {
   useRegisterKeybindingContext('Chat')
@@ -1475,7 +1474,22 @@ export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, o
     ],
   )
 
-  const busy = pullInFlight || Boolean(compactionUi)
+  const busy = streaming || pullInFlight || Boolean(compactionUi)
+
+  useEffect(() => {
+    if (!busy) {
+      setTerminalTitle(TITLE_STATIC)
+      return
+    }
+    let i = 0
+    setTerminalTitle(TITLE_ANIMATION_FRAMES[0])
+    const id = setInterval(() => {
+      i = (i + 1) % TITLE_ANIMATION_FRAMES.length
+      setTerminalTitle(TITLE_ANIMATION_FRAMES[i] ?? TITLE_STATIC)
+    }, TITLE_ANIMATION_INTERVAL_MS)
+    return () => clearInterval(id)
+  }, [busy])
+
   const slashSuggestions = useMemo(
     () => getSlashSuggestions(mcpManagerRef.current?.getPromptSuggestions() ?? []),
     [mcpSnapshot],
@@ -1624,113 +1638,14 @@ export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, o
   )
 }
 
-export function chatFooterShortcutText(canScrollTranscript: boolean): string {
-  return 'alt+p model · alt+i identity'
-}
-
 function formatContextLabel(usage: ContextUsage): string {
   if (!Number.isFinite(usage.usedTokens) || usage.usedTokens <= 0) return 'Estimated context: empty'
   return `Estimated context: ${usage.percent}% used`
 }
 
-export function buildPlanImplementationPrompt(plan: string): string {
-  return [
-    'Implement the approved plan below.',
-    '',
-    'Use native ethagent tools directly. Do not translate tool names into shell commands.',
-    'For workspace inspection, call list_directory and read_file directly.',
-    'For file creation or edits, call edit_file directly.',
-    'Use run_bash only for an actual shell command that cannot be performed by a narrower native tool, such as starting a local server after files exist.',
-    'Ignore any plan wording that says to execute file work as a Bash script or directly in the terminal; the native tools above are authoritative.',
-    'Read the relevant files before editing, make the required changes, and verify the result when possible.',
-    '',
-    plan,
-  ].join('\n')
-}
-
-export function buildPlanTransferSeedMessages(args: {
-  sourceSessionId: string
-  summary: string
-  plan: string
-  createdAt: string
-}): SessionMessage[] {
-  return [
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        `Planning handoff from ${args.sourceSessionId.slice(0, 8)}:`,
-        '',
-        args.summary.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        'Approved plan to implement:',
-        '',
-        args.plan.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-  ]
-}
-
 function appendPromptHistoryEntry(history: string[], value: string): string[] {
   const prompt = value.trim()
   if (!prompt) return history
   const next = history[history.length - 1] === prompt ? history : [...history, prompt]
   return next.length > MAX_PROMPT_HISTORY ? next.slice(-MAX_PROMPT_HISTORY) : next
 }
-
-function normalizeHandoffSummary(summary: string): string {
-  const trimmed = summary.trim()
-  if (trimmed.length <= MAX_HANDOFF_SUMMARY_CHARS) return trimmed
-  return [
-    trimmed.slice(0, MAX_HANDOFF_SUMMARY_CHARS - 96).trimEnd(),
-    '',
-    '[handoff truncated to keep the resumed conversation responsive]',
-  ].join('\n')
-}
-
-export function privateContinuityEditReviewFromToolResult(
-  name: string,
-  input: Record<string, unknown>,
-  result: { ok: boolean; summary: string; content: string },
-): ContinuityEditReviewState | null {
-  if (name !== 'propose_private_continuity_edit' || !result.ok) return null
-  const file = normalizePrivateContinuityFile(input.file)
-  if (!file) return null
-  const parsed = splitFileChangeResult(result.content)
-  const filePath = extractReviewFilePath(parsed.content)
-  if (!filePath) return null
-  return {
-    file,
-    filePath,
-    summary: result.summary,
-    ...(parsed.diff ? { diff: parsed.diff } : {}),
-  }
-}
-
-function normalizePrivateContinuityFile(value: unknown): ContinuityEditReviewState['file'] | null {
-  if (typeof value !== 'string') return null
-  if (/^soul\.md$/i.test(value.trim())) return 'SOUL.md'
-  if (/^memory\.md$/i.test(value.trim())) return 'MEMORY.md'
-  return null
-}
-
-function extractReviewFilePath(content: string): string | null {
-  for (const line of content.split(/\r?\n/)) {
-    const review = line.match(/^(?:[-*]\s+)?review file:\s*(.+)$/i)
-    if (review?.[1]?.trim()) return cleanReviewFilePath(review[1])
-    const updated = line.match(/^(?:[-*]\s+)?updated local private continuity file\s+(.+)$/i)
-    if (updated?.[1]?.trim()) return cleanReviewFilePath(updated[1])
-  }
-  return null
-}
-
-function cleanReviewFilePath(value: string): string {
-  return value.trim().replace(/^`+|`+$/g, '').trim()
-}

package/src/chat/MessageList.tsx

@@ -8,6 +8,18 @@ import { SyntaxLine } from './display/SyntaxText.js'
 import { formatToolCall } from './display/toolCallDisplay.js'
 import { BrandSplash } from '../ui/BrandSplash.js'
 import type { RowSlice } from './transcript/transcriptViewport.js'
+import {
+  blockContentWidth,
+  clipTextForDisplay,
+  parseInlineTokens,
+  parseMarkdownBlocks,
+  sanitizeReasoningForDisplay,
+  summarizeThinking,
+  type InlineToken,
+  type MarkdownBlock,
+} from './messageMarkdown.js'
+
+export { sanitizeReasoningForDisplay } from './messageMarkdown.js'
 
 export type ToolCallResult = {
   content: string
@@ -52,28 +64,17 @@ type MessageListProps = {
   slices: Array<RowSlice<MessageRow>>
 }
 
-export function rowsToFullSlices(rows: MessageRow[]): Array<RowSlice<MessageRow>> {
-  return rows.map(row => ({ row, clipStart: 0, clipEnd: Number.MAX_SAFE_INTEGER, rowHeight: Number.MAX_SAFE_INTEGER }))
-}
-
-type MarkdownBlock =
-  | { kind: 'heading'; level: 1 | 2 | 3 | 4 | 5 | 6; text: string }
-  | { kind: 'paragraph'; text: string }
-  | { kind: 'quote'; lines: string[] }
-  | { kind: 'list'; ordered: boolean; items: string[] }
-  | { kind: 'code'; lang: string | null; code: string; open?: boolean }
-
-type InlineToken =
-  | { kind: 'text'; text: string }
-  | { kind: 'bold'; text: string }
-  | { kind: 'italic'; text: string }
-  | { kind: 'code'; text: string }
+export {
+  rowsToFullSlices,
+  toggleInspectableRow,
+  toggleLatestReasoningRow,
+  toggleReasoningRow,
+} from './messageRows.js'
 
 const MAX_RENDERED_MESSAGE_CHARS = 12_000
 const MAX_RENDERED_REASONING_CHARS = 10_000
 const ASSISTANT_ACCENT = theme.accentPeriwinkle
 const ASSISTANT_MARKER = '• '
-const UNREADABLE_REASONING_TEXT = 'reasoning output was not readable text'
 
 const MessageListInner: React.FC<MessageListProps> = ({ slices }) => (
   <Box flexDirection="column">
@@ -89,43 +90,6 @@ const MessageListInner: React.FC<MessageListProps> = ({ slices }) => (
 
 export const MessageList = React.memo(MessageListInner)
 
-function isInspectableRole(role: MessageRow['role']): boolean {
-  return role === 'thinking'
-}
-
-export function toggleLatestReasoningRow(rows: MessageRow[]): MessageRow[] {
-  return toggleInspectableRow(rows)
-}
-
-export function toggleReasoningRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  return toggleInspectableRow(rows, rowId)
-}
-
-export function toggleInspectableRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  let index = -1
-  if (rowId) {
-    index = rows.findIndex(row => row.id === rowId && isInspectableRole(row.role))
-  }
-  if (index === -1) {
-    for (let cursor = rows.length - 1; cursor >= 0; cursor -= 1) {
-      const role = rows[cursor]?.role
-      if (role && isInspectableRole(role)) {
-        index = cursor
-        break
-      }
-    }
-  }
-  if (index === -1) return rows
-  const row = rows[index]
-  if (!row) return rows
-  if (row.role === 'thinking') {
-    const next = rows.slice()
-    next[index] = { ...row, expanded: !row.expanded }
-    return next
-  }
-  return rows
-}
-
 const RowViewInner: React.FC<{ slice: RowSlice<MessageRow>; tightTop?: boolean }> = ({ slice, tightTop }) => {
   const { row, clipStart, clipEnd, rowHeight } = slice
   if (row.role === 'user') {
@@ -669,212 +633,6 @@ const StreamCursor: React.FC<{ active: boolean }> = ({ active }) => {
   return <>{visible ? '|' : ' '}</>
 }
 
-function blockContentWidth(lines: string[]): number {
-  return Math.max(1, ...lines.map(displayWidth))
-}
-
-function displayWidth(line: string): number {
-  return (line || ' ').replace(/\t/g, '  ').length
-}
-
-function parseMarkdownBlocks(markdown: string): MarkdownBlock[] {
-  const text = markdown.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
-  if (!text.trim()) return []
-
-  const blocks: MarkdownBlock[] = []
-  const lines = text.split('\n')
-  let index = 0
-
-  while (index < lines.length) {
-    const line = lines[index] ?? ''
-    const trimmed = line.trim()
-
-    if (!trimmed) {
-      index += 1
-      continue
-    }
-
-    const fence = trimmed.match(/^```([\w+-]*)\s*$/)
-    if (fence) {
-      const lang = fence[1] && fence[1].length > 0 ? fence[1] : null
-      index += 1
-      const body: string[] = []
-      let closed = false
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (nextLine.trim().match(/^```\s*$/)) {
-          closed = true
-          index += 1
-          break
-        }
-        body.push(nextLine)
-        index += 1
-      }
-      blocks.push({ kind: 'code', lang, code: body.join('\n'), open: !closed })
-      continue
-    }
-
-    const heading = line.match(/^(#{1,6})\s+(.*)$/)
-    if (heading) {
-      const [, hashes = '#', headingText = ''] = heading
-      blocks.push({
-        kind: 'heading',
-        level: hashes.length as 1 | 2 | 3 | 4 | 5 | 6,
-        text: headingText.trim(),
-      })
-      index += 1
-      continue
-    }
-
-    if (/^>\s?/.test(trimmed)) {
-      const quoteLines: string[] = []
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (!/^>\s?/.test(nextLine.trim())) break
-        quoteLines.push(nextLine.trim().replace(/^>\s?/, ''))
-        index += 1
-      }
-      blocks.push({ kind: 'quote', lines: quoteLines })
-      continue
-    }
-
-    const ordered = trimmed.match(/^\d+\.\s+(.*)$/)
-    const unordered = trimmed.match(/^[-*+]\s+(.*)$/)
-    if (ordered || unordered) {
-      const items: string[] = []
-      const orderedList = Boolean(ordered)
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        const match = orderedList
-          ? nextLine.trim().match(/^\d+\.\s+(.*)$/)
-          : nextLine.trim().match(/^[-*+]\s+(.*)$/)
-        if (!match) break
-        items.push(match[1] ?? '')
-        index += 1
-      }
-      blocks.push({ kind: 'list', ordered: orderedList, items })
-      continue
-    }
-
-    const paragraph: string[] = []
-    while (index < lines.length) {
-      const nextLine = lines[index] ?? ''
-      const nextTrimmed = nextLine.trim()
-      if (!nextTrimmed) break
-      if (nextTrimmed.match(/^```([\w+-]*)\s*$/)) break
-      if (nextLine.match(/^(#{1,6})\s+(.*)$/)) break
-      if (/^>\s?/.test(nextTrimmed)) break
-      if (nextTrimmed.match(/^\d+\.\s+(.*)$/) || nextTrimmed.match(/^[-*+]\s+(.*)$/)) break
-      paragraph.push(nextLine)
-      index += 1
-    }
-    blocks.push({ kind: 'paragraph', text: paragraph.join('\n').trim() })
-  }
-
-  return blocks
-}
-
-function parseInlineTokens(text: string): InlineToken[] {
-  const tokens: InlineToken[] = []
-  const source = normalizeInlineDisplayText(text)
-  const pattern = /(`[^`\n]+`|\*\*[^*\n]+?\*\*|__[^_\n]+?__|\*[^*\n]+?\*|_[^_\n]+?_)/g
-  let lastIndex = 0
-  let match: RegExpExecArray | null
-
-  while ((match = pattern.exec(source)) !== null) {
-    if (match.index > lastIndex) {
-      tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex, match.index)) })
-    }
-
-    const token = match[0]
-    if ((token.startsWith('**') && token.endsWith('**')) || (token.startsWith('__') && token.endsWith('__'))) {
-      tokens.push({ kind: 'bold', text: cleanPlainInlineText(token.slice(2, -2)) })
-    } else if ((token.startsWith('*') && token.endsWith('*')) || (token.startsWith('_') && token.endsWith('_'))) {
-      tokens.push({ kind: 'italic', text: cleanPlainInlineText(token.slice(1, -1)) })
-    } else if (token.startsWith('`') && token.endsWith('`')) {
-      tokens.push({ kind: 'code', text: token.slice(1, -1) })
-    }
-
-    lastIndex = match.index + token.length
-  }
-
-  if (lastIndex < source.length || tokens.length === 0) {
-    tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex)) })
-  }
-
-  return tokens.filter(token => token.text.length > 0)
-}
-
-function normalizeInlineDisplayText(text: string): string {
-  return text
-    .replace(/\\\(/g, '')
-    .replace(/\\\)/g, '')
-    .replace(/\\\[/g, '')
-    .replace(/\\\]/g, '')
-    .replace(/\$\$([^$]+)\$\$/g, '$1')
-    .replace(/\$([^$\n]+)\$/g, '$1')
-    .replace(/\\([{}[\]()])/g, '$1')
-    .replace(/\/([{}])/g, '$1')
-}
-
-function cleanPlainInlineText(text: string): string {
-  return text.replace(/\*+/g, '')
-}
-
-function summarizeThinking(text: string): string {
-  const sample = text.length > 1000 ? text.slice(-1000) : text
-  const normalized = sample.replace(/\s+/g, ' ').trim()
-  if (!normalized) return ''
-  const prefix = text.length > sample.length ? '...' : ''
-  if (normalized.length + prefix.length <= 120) return `${prefix}${normalized}`
-  return `${prefix}${normalized.slice(Math.max(0, normalized.length - (120 - prefix.length)))}`
-}
-
-function clipTextForDisplay(text: string, maxChars: number): { text: string; omittedChars: number } {
-  if (text.length <= maxChars) return { text, omittedChars: 0 }
-  const rawStart = Math.max(0, text.length - maxChars)
-  const newline = text.indexOf('\n', rawStart)
-  const start = newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
-  return {
-    text: text.slice(start),
-    omittedChars: start,
-  }
-}
-
 function reasoningText(row: Extract<MessageRow, { role: 'thinking' }>): string {
   return row.liveTail ? row.content + row.liveTail : row.content
 }
-
-export function sanitizeReasoningForDisplay(text: string): string {
-  const normalized = text
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
-  const controlCount = countMatches(normalized, /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g)
-  const cleaned = normalized
-    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g, '')
-    .replace(/\t/g, '  ')
-  const visibleLength = cleaned.replace(/\s/g, '').length
-  if (visibleLength === 0) return ''
-  if (controlCount > 0 && controlCount / Math.max(1, text.length) > 0.05) return UNREADABLE_REASONING_TEXT
-  if (looksLikeUnreadableReasoning(cleaned)) return UNREADABLE_REASONING_TEXT
-  return cleaned
-}
-
-function looksLikeUnreadableReasoning(text: string): boolean {
-  const visible = text.replace(/\s/g, '')
-  if (visible.length < 120) return false
-  const letters = countMatches(visible, /[A-Za-z]/g)
-  const digits = countMatches(visible, /\d/g)
-  const words = text.match(/[A-Za-z]{3,}/g) ?? []
-  const wordChars = words.reduce((sum, word) => sum + word.length, 0)
-  const whitespace = countMatches(text, /\s/g)
-  const symbolDensity = (visible.length - letters - digits) / visible.length
-  const wordDensity = wordChars / visible.length
-  const whitespaceDensity = whitespace / Math.max(1, text.length)
-  return symbolDensity > 0.38 && wordDensity < 0.32 && whitespaceDensity < 0.12
-}
-
-function countMatches(text: string, pattern: RegExp): number {
-  return text.match(pattern)?.length ?? 0
-}

package/src/chat/chatEnvironment.ts

@@ -0,0 +1,16 @@
+import os from 'node:os'
+import path from 'node:path'
+import type { EthagentConfig } from '../storage/config.js'
+import { ensureLlamaCppRunnerReady } from '../models/llamacppPreflight.js'
+
+export function compressHome(cwd: string): string {
+  const home = os.homedir()
+  if (cwd === home) return '~'
+  if (cwd.startsWith(home + path.sep)) return '~' + cwd.slice(home.length).replace(/\\/g, '/')
+  return cwd.replace(/\\/g, '/')
+}
+
+export async function ensureLocalProviderReady(config: EthagentConfig): Promise<{ ok: true } | { ok: false; message: string }> {
+  if (config.provider === 'llamacpp') return ensureLlamaCppRunnerReady(config)
+  return { ok: true }
+}