protoagent 0.1.7 → 0.1.8

package/dist/App.js

@@ -1,11 +1,61 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * Main UI component — the heart of ProtoAgent's terminal interface.
- *
- * Renders the chat loop, tool call feedback, approval prompts,
- * and cost/usage info. All heavy logic lives in `agentic-loop.ts`;
- * this file is purely presentation + state wiring.
- */
+Main UI component — the heart of ProtoAgent's terminal interface.
+
+Renders the chat loop, tool call feedback, approval prompts,
+and cost/usage info. All heavy logic lives in `agentic-loop.ts`;
+this file is purely presentation + state wiring.
+
+Here's how the terminal UI is laid out (showcasing all options at once for demonstration, but in practice many elements are conditional on state):
+┌─────────────────────────────────────────┐
+│  ProtoAgent  (BigText logo)             │  static, rendered once (printBanner)
+│  Model: Anthropic / claude-3-5 | Sess.. │  static header (printRuntimeHeader)
+│  Debug logs: /path/to/log               │  static, if --log-level set
+├─────────────────────────────────────────┤
+│                                         │
+│  [System Prompt ▸ collapsed]            │  archived (memoized)
+│                                         │
+│  > user message                         │  archived (memoized)
+│                                         │
+│  assistant reply text                   │  archived (memoized)
+│                                         │
+│  [tool_name ▸ collapsed]                │  archived (memoized)
+│                                         │
+│  > user message                         │  archived (memoized)
+│                                         │
+├ ─ ─ ─ ─ ─ ─ ─ live boundary ─ ─ ─ ─ ─ ─ ┤
+│                                         │
+│  assistant streaming text...            │  live (re-renders, ~50ms debounce)
+│                                         │
+│  [tool_name ▸ collapsed]                │  live (re-renders on tool_result)
+│                                         │
+│  Thinking...                            │  live, only if last msg is user
+│                                         │
+│ ╭─ Approval Required ─────────────────╮ │  live, only when pending approval
+│ │  description / detail               │ │
+│ │  ○ Approve once                     │ │
+│ │  ○ Approve for session              │ │
+│ │  ○ Reject                           │ │
+│ ╰─────────────────────────────────────╯ │
+│                                         │
+│  [Error: message]                       │  live, inline thread errors
+│                                         │
+├─────────────────────────────────────────┤
+│  tokens: 1234↓ 56↑ | ctx: 12% | $0.02   │  static-ish, updates after each turn
+├─────────────────────────────────────────┤
+│  /clear — Clear conversation...         │  dynamic, shown when typing /
+│  /quit  — Exit ProtoAgent               │
+├─────────────────────────────────────────┤
+│  ⠹ Running read_file...                 │  dynamic, shown while loading
+├─────────────────────────────────────────┤
+│ ╭─────────────────────────────────────╮ │
+│ │ > [text input cursor              ] │ │  always visible when initialized
+│ ╰─────────────────────────────────────╯ │
+├─────────────────────────────────────────┤
+│  Session saved. Resume with:            │  one-shot, shown on /quit
+│  protoagent --session abc12345          │
+└─────────────────────────────────────────┘
+*/
 import { useState, useEffect, useCallback, useRef } from 'react';
 import { Box, Text, Static, useApp, useInput, useStdout } from 'ink';
 import { LeftBar } from './components/LeftBar.js';
@@ -25,14 +75,11 @@ import { generateSystemPrompt } from './system-prompt.js';
 // These functions append text to the permanent scrollback buffer via the
 // <Static> component. Ink flushes new Static items within its own render
 // cycle, so there are no timing issues with write()/log-update.
-let _staticCounter = 0;
-function makeStaticId() {
-    return `s${++_staticCounter}`;
-}
 function printBanner(addStatic) {
     const green = '\x1b[38;2;9;164;105m';
     const reset = '\x1b[0m';
     addStatic([
+        '',
         `${green}█▀█ █▀█ █▀█ ▀█▀ █▀█ ▄▀█ █▀▀ █▀▀ █▄ █ ▀█▀${reset}`,
         `${green}█▀▀ █▀▄ █▄█  █  █▄█ █▀█ █▄█ ██▄ █ ▀█  █${reset}`,
         '',
@@ -40,14 +87,17 @@ function printBanner(addStatic) {
 }
 function printRuntimeHeader(addStatic, config, session, logFilePath, dangerouslyAcceptAll) {
     const provider = getProvider(config.provider);
-    let line = `Model: ${provider?.name || config.provider} / ${config.model}`;
+    const grey = '\x1b[90m';
+    const reset = '\x1b[0m';
+    let line = `${grey}Model: ${provider?.name || config.provider} / ${config.model}`;
     if (dangerouslyAcceptAll)
         line += ' (auto-approve all)';
     if (session)
         line += ` | Session: ${session.id.slice(0, 8)}`;
+    line += reset;
     let text = `${line}\n`;
     if (logFilePath) {
-        text += `Debug logs: ${logFilePath}\n`;
+        text += `${grey}Debug logs: ${logFilePath}${reset}\n`;
     }
     text += '\n';
     addStatic(text);
@@ -111,6 +161,7 @@ const SLASH_COMMANDS = [
     { name: '/clear', description: 'Clear conversation and start fresh' },
     { name: '/help', description: 'Show all available commands' },
     { name: '/quit', description: 'Exit ProtoAgent' },
+    { name: '/exit', description: 'Alias for /quit' },
 ];
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const HELP_TEXT = [
@@ -118,6 +169,7 @@ const HELP_TEXT = [
     '  /clear  - Clear conversation and start fresh',
     '  /help   - Show this help',
     '  /quit   - Exit ProtoAgent',
+    '  /exit   - Alias for /quit',
 ].join('\n');
 function buildClient(config) {
     const provider = getProvider(config.provider);
@@ -186,7 +238,7 @@ const ApprovalPrompt = ({ request, onRespond }) => {
 const UsageDisplay = ({ usage, totalCost }) => {
     if (!usage && totalCost === 0)
         return null;
-    return (_jsxs(Box, { children: [usage && (_jsxs(Text, { dimColor: true, children: ["tokens: ", usage.inputTokens, "\u2193 ", usage.outputTokens, "\u2191 | ctx: ", usage.contextPercent.toFixed(0), "%"] })), totalCost > 0 && (_jsxs(Text, { dimColor: true, children: [" | cost: $", totalCost.toFixed(4)] }))] }));
+    return (_jsxs(Box, { marginTop: 1, children: [usage && (_jsxs(Box, { children: [_jsxs(Box, { backgroundColor: "#042f2e", paddingX: 1, children: [_jsx(Text, { color: "black", children: "tokens: " }), _jsxs(Text, { color: "black", bold: true, children: [usage.inputTokens, "\u2193 ", usage.outputTokens, "\u2191"] })] }), _jsxs(Box, { backgroundColor: "#064e3b", paddingX: 1, children: [_jsx(Text, { color: "black", children: "ctx: " }), _jsxs(Text, { color: "black", bold: true, children: [usage.contextPercent.toFixed(0), "%"] })] })] })), _jsxs(Box, { backgroundColor: "#042f2e", paddingX: 1, children: [_jsx(Text, { color: "black", children: "cost: " }), _jsxs(Text, { color: "black", bold: true, children: ["$", totalCost.toFixed(4)] })] })] }));
 };
 /** Inline setup wizard — shown when no config exists. */
 const InlineSetup = ({ onComplete }) => {
@@ -230,10 +282,18 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
     // ─── Static scrollback state ───
     // Each item appended here is rendered once by <Static> and permanently
     // flushed to the terminal scrollback by Ink, within its own render cycle.
-    // This eliminates all write()/log-update timing issues.
+    // Using <Static> items is important to avoid re-rendering issues, which hijack
+    // scrollback and copying when new AI message streams are coming in.
+    //
+    // staticCounterRef keeps ID generation local to this component instance,
+    // making it immune to Strict Mode double-invoke, HMR counter drift, and
+    // collisions if multiple App instances ever coexist.
+    const staticCounterRef = useRef(0);
     const [staticItems, setStaticItems] = useState([]);
     const addStatic = useCallback((text) => {
-        setStaticItems((prev) => [...prev, { id: makeStaticId(), text }]);
+        staticCounterRef.current += 1;
+        const id = `s${staticCounterRef.current}`;
+        setStaticItems((prev) => [...prev, { id, text }]);
     }, []);
     // Core state
     const [config, setConfig] = useState(null);
@@ -523,6 +583,19 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
                         if (event.toolCall) {
                             const toolCall = event.toolCall;
                             setActiveTool(toolCall.name);
+                            // If the model streamed some text before invoking this tool,
+                            // flush it to <Static> now. Without this, streamingText is
+                            // never cleared — the 'done' handler only flushes streaming_text
+                            // when the turn ends with plain text, not with tool calls.
+                            if (assistantMessageRef.current?.kind === 'streaming_text') {
+                                const precedingText = assistantMessageRef.current.message.content || '';
+                                if (precedingText) {
+                                    addStatic(`${normalizeTranscriptText(precedingText)}\n\n`);
+                                }
+                                setIsStreaming(false);
+                                setStreamingText('');
+                                assistantMessageRef.current = null;
+                            }
                             // Track the tool call in the ref WITHOUT triggering a render.
                             // The render will happen when tool_result arrives.
                             const existingRef = assistantMessageRef.current;
@@ -704,5 +777,5 @@ export const App = ({ dangerouslyAcceptAll = false, logLevel, sessionId, }) => {
                 } })), isStreaming && (_jsxs(Text, { wrap: "wrap", children: [clipToRows(streamingText, terminalRows), _jsx(Text, { dimColor: true, children: "\u258D" })] })), threadErrors.filter((threadError) => threadError.transient).map((threadError) => (_jsx(LeftBar, { color: "red", marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", threadError.message] }) }, `thread-error-${threadError.id}`))), pendingApproval && (_jsx(ApprovalPrompt, { request: pendingApproval.request, onRespond: (response) => {
                     pendingApproval.resolve(response);
                     setPendingApproval(null);
-                } })), _jsx(UsageDisplay, { usage: lastUsage ?? null, totalCost: totalCost }), initialized && !pendingApproval && inputText.startsWith('/') && (_jsx(CommandFilter, { inputText: inputText })), initialized && !pendingApproval && loading && !isStreaming && (_jsx(Box, { children: _jsxs(Text, { color: "green", bold: true, children: [SPINNER_FRAMES[spinnerFrame], ' ', activeTool ? `Running ${activeTool}...` : 'Working...'] }) })), initialized && !pendingApproval && (_jsx(Box, { children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: "green", bold: true, children: '>' }) }), _jsx(Box, { flexGrow: 1, minWidth: 10, children: _jsx(TextInput, { defaultValue: inputText, onChange: setInputText, placeholder: "Type your message... (/help for commands)", onSubmit: handleSubmit }, inputResetKey) })] }) })), quittingSession && (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Session saved. Resume with:" }), _jsxs(Text, { color: "green", children: ["protoagent --session ", quittingSession.id] })] }))] }));
+                } })), initialized && !pendingApproval && loading && !isStreaming && (_jsx(Box, { children: _jsxs(Text, { color: "green", bold: true, children: [SPINNER_FRAMES[spinnerFrame], ' ', activeTool ? `Running ${activeTool}...` : 'Working...'] }) })), initialized && !pendingApproval && inputText.startsWith('/') && (_jsx(CommandFilter, { inputText: inputText })), _jsx(UsageDisplay, { usage: lastUsage ?? null, totalCost: totalCost }), initialized && !pendingApproval && (_jsx(Box, { children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: "green", bold: true, children: '>' }) }), _jsx(Box, { flexGrow: 1, minWidth: 10, children: _jsx(TextInput, { defaultValue: inputText, onChange: setInputText, placeholder: "Type your message... (/help for commands)", onSubmit: handleSubmit }, inputResetKey) })] }) })), quittingSession && (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Session saved. Resume with:" }), _jsxs(Text, { color: "green", children: ["protoagent --session ", quittingSession.id] })] }))] }));
 };

package/dist/agentic-loop.js

@@ -46,21 +46,22 @@ async function sleepWithAbort(delayMs, abortSignal) {
         abortSignal.addEventListener('abort', onAbort, { once: true });
     });
 }
-function appendStreamingFragment(current, fragment) {
+/** @internal exported for unit testing only */
+export function appendStreamingFragment(current, fragment) {
     if (!fragment)
         return current;
     if (!current)
         return fragment;
+    // Some providers resend the full accumulated value instead of a delta.
+    // These two guards handle that case without corrupting normal incremental deltas.
     if (current === fragment)
         return current;
     if (fragment.startsWith(current))
         return fragment;
-    const maxOverlap = Math.min(current.length, fragment.length);
-    for (let overlap = maxOverlap; overlap > 0; overlap--) {
-        if (current.endsWith(fragment.slice(0, overlap))) {
-            return current + fragment.slice(overlap);
-        }
-    }
+    // Normal case: incremental delta, just append.
+    // The previous partial-overlap loop was removed because it caused false-positive
+    // deduplication: short JSON tokens (e.g. `", "`) would coincidentally match the
+    // tail of `current`, silently stripping characters from valid argument payloads.
     return current + fragment;
 }
 function collapseRepeatedString(value) {
@@ -347,7 +348,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                 if (chunk.usage) {
                     actualUsage = chunk.usage;
                 }
-                // Stream text content
+                // Stream text content (and return to UI for immediate display via onEvent)
                 if (delta?.content) {
                     streamedContent += delta.content;
                     assistantMessage.content = streamedContent;
@@ -355,7 +356,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                         onEvent({ type: 'text_delta', content: delta.content });
                     }
                 }
-                // Accumulate tool calls
+                // Accumulate tool calls across stream chunks
                 if (delta?.tool_calls) {
                     hasToolCalls = true;
                     for (const tc of delta.tool_calls) {

package/dist/system-prompt.js

@@ -67,7 +67,7 @@ export async function generateSystemPrompt() {
     const toolDescriptions = generateToolDescriptions();
     const skillsSection = buildSkillsCatalogSection(skills);
     return `You are ProtoAgent, a coding assistant with file system and shell command capabilities.
-Your job is to help the user complete coding tasks in their project.
+Your job is to help the user complete coding tasks in their project. You must be absolutely careful and diligent in your work, and follow all guidelines to the letter. Always prefer thoroughness and correctness over speed. Never cut corners.
 
 PROJECT CONTEXT
 
@@ -121,8 +121,11 @@ FILE OPERATIONS:
 - ALWAYS use read_file before editing to get exact content.
 - NEVER write over existing files unless explicitly asked — use edit_file instead.
 - Create parent directories before creating files in them.
-- Use bash for package management, git, building, testing, etc.
-- When running interactive commands, add flags to avoid prompts (--yes, --template, etc.)
+- INDENTATION: when writing new_string for edit_file, preserve the exact indentation of every line. Copy the indent character-for-character from the file. A single dropped space is a bug.
+- STRICT TYPO PREVENTION: You have a tendency to drop characters or misspell words (e.g., "commands" vs "comands") when generating long code blocks. Before submitting a tool call, perform a character-by-character mental audit.
+- VERIFICATION STEP: After generating a new_string, compare it against the old_string. Ensure that only the intended changes are present and that no existing words have been accidentally altered or truncated.
+- NO TRUNCATION: Never truncate code or leave "..." in your tool calls. Every string must be literal and complete.
+- IF edit_file FAILS: do NOT retry by guessing or reconstructing old_string from memory. Call read_file on the file first, then copy the exact text verbatim for old_string. The error output shows exactly which lines differ between your old_string and the file — read those carefully before retrying.
 
 IMPLEMENTATION STANDARDS:
 - **Thorough investigation**: Before implementing, understand the existing codebase, patterns, and related systems.

package/dist/tools/edit-file.js

@@ -7,9 +7,9 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { validatePath } from '../utils/path-validation.js';
+import { validatePath, getWorkingDirectory } from '../utils/path-validation.js';
 import { requestApproval } from '../utils/approval.js';
-import { assertReadBefore, recordRead } from '../utils/file-time.js';
+import { checkReadBefore, recordRead } from '../utils/file-time.js';
 export const editFileTool = {
     type: 'function',
     function: {
@@ -32,6 +32,54 @@ export const editFileTool = {
         },
     },
 };
+// ─── Path suggestion helper (mirrors read_file behaviour) ───
+async function findSimilarPaths(requestedPath) {
+    const cwd = getWorkingDirectory();
+    const segments = requestedPath.split('/').filter(Boolean);
+    const MAX_DEPTH = 6;
+    const MAX_ENTRIES = 200;
+    const MAX_SUGGESTIONS = 3;
+    const candidates = [];
+    async function walkSegments(dir, segIndex, currentPath) {
+        if (segIndex >= segments.length || segIndex >= MAX_DEPTH || candidates.length >= MAX_SUGGESTIONS)
+            return;
+        const targetSegment = segments[segIndex].toLowerCase();
+        let entries;
+        try {
+            entries = (await fs.readdir(dir, { withFileTypes: true })).slice(0, MAX_ENTRIES).map(e => e.name);
+        }
+        catch {
+            return;
+        }
+        const isLastSegment = segIndex === segments.length - 1;
+        for (const entry of entries) {
+            if (candidates.length >= MAX_SUGGESTIONS)
+                break;
+            const entryLower = entry.toLowerCase();
+            if (!entryLower.includes(targetSegment) && !targetSegment.includes(entryLower))
+                continue;
+            const entryPath = path.join(currentPath, entry);
+            const fullPath = path.join(dir, entry);
+            if (isLastSegment) {
+                try {
+                    await fs.stat(fullPath);
+                    candidates.push(entryPath);
+                }
+                catch { /* skip */ }
+            }
+            else {
+                try {
+                    const stat = await fs.stat(fullPath);
+                    if (stat.isDirectory())
+                        await walkSegments(fullPath, segIndex + 1, entryPath);
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    await walkSegments(cwd, 0, '');
+    return candidates;
+}
 /** Strategy 1: Exact verbatim match (current behavior). */
 const exactReplacer = {
     name: 'exact',
@@ -245,10 +293,26 @@ export async function editFile(filePath, oldString, newString, expectedReplaceme
     if (oldString.length === 0) {
         return 'Error: old_string cannot be empty.';
     }
-    const validated = await validatePath(filePath);
+    let validated;
+    try {
+        validated = await validatePath(filePath);
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist') || err.code === 'ENOENT') {
+            const suggestions = await findSimilarPaths(filePath);
+            let msg = `File not found: '${filePath}'.`;
+            if (suggestions.length > 0) {
+                msg += ' Did you mean one of these?\n' + suggestions.map(s => `  ${s}`).join('\n');
+            }
+            return msg;
+        }
+        throw err;
+    }
     // Staleness guard: must have read file before editing
     if (sessionId) {
-        assertReadBefore(sessionId, validated);
+        const staleError = checkReadBefore(sessionId, validated);
+        if (staleError)
+            return staleError;
     }
     const content = await fs.readFile(validated, 'utf8');
     // Use fuzzy match cascade
@@ -262,7 +326,67 @@ export async function editFile(filePath, oldString, newString, expectedReplaceme
                 return `Error: found ${count} occurrence(s) of old_string (via ${strategy.name} match), but expected ${expectedReplacements}. Be more specific or set expected_replacements=${count}.`;
             }
         }
-        return `Error: old_string not found in ${filePath}. Strategies exhausted (exact, line-trimmed, indent-flexible, whitespace-normalized, trimmed-boundary). Re-read the file and try again.`;
+        // Build a per-strategy diagnostic to help the model self-correct without
+        // requiring a full re-read. For each strategy, find the closest partial
+        // match and report ALL lines where it diverges (not just the first).
+        const searchLines = oldString.split('\n');
+        const contentLines = content.split('\n');
+        const diagnostics = [];
+        for (const strategy of STRATEGIES) {
+            // Find the window in the file that shares the most lines with oldString
+            let bestWindowStart = -1;
+            let bestMatchedLines = 0;
+            for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+                let matched = 0;
+                for (let j = 0; j < searchLines.length; j++) {
+                    const fileLine = strategy.name === 'whitespace-normalized'
+                        ? contentLines[i + j].replace(/\s+/g, ' ').trim()
+                        : contentLines[i + j].trim();
+                    const searchLine = strategy.name === 'whitespace-normalized'
+                        ? searchLines[j].replace(/\s+/g, ' ').trim()
+                        : searchLines[j].trim();
+                    if (fileLine === searchLine)
+                        matched++;
+                }
+                if (matched > bestMatchedLines) {
+                    bestMatchedLines = matched;
+                    bestWindowStart = i;
+                }
+            }
+            if (bestWindowStart >= 0 && bestMatchedLines > 0 && bestMatchedLines < searchLines.length) {
+                // Collect all diverging lines, not just the first
+                const diffLines = [];
+                const MAX_DIFFS = 6;
+                for (let j = 0; j < searchLines.length && diffLines.length < MAX_DIFFS; j++) {
+                    const fileLine = contentLines[bestWindowStart + j] ?? '(end of file)';
+                    const searchLine = searchLines[j];
+                    const fileNorm = strategy.name === 'whitespace-normalized'
+                        ? fileLine.replace(/\s+/g, ' ').trim()
+                        : fileLine.trim();
+                    const searchNorm = strategy.name === 'whitespace-normalized'
+                        ? searchLine.replace(/\s+/g, ' ').trim()
+                        : searchLine.trim();
+                    if (fileNorm !== searchNorm) {
+                        diffLines.push(`    line ${bestWindowStart + j + 1}:\n` +
+                            `      yours: ${searchLine.trim().slice(0, 120)}\n` +
+                            `      file:  ${fileLine.trim().slice(0, 120)}`);
+                    }
+                }
+                const truncNote = diffLines.length === MAX_DIFFS ? `\n    ... (more diffs not shown)` : '';
+                diagnostics.push(`  ${strategy.name}: ${bestMatchedLines}/${searchLines.length} lines match, ${searchLines.length - bestMatchedLines} differ:\n` +
+                    diffLines.join('\n') + truncNote);
+            }
+            else if (bestMatchedLines === 0) {
+                diagnostics.push(`  ${strategy.name}: no lines matched — old_string may be from a different file or heavily rewritten`);
+            }
+            else {
+                diagnostics.push(`  ${strategy.name}: no partial match found`);
+            }
+        }
+        const hint = diagnostics.length > 0
+            ? '\nDiagnostics per strategy:\n' + diagnostics.join('\n')
+            : '';
+        return `Error: old_string not found in ${filePath}.${hint}\nDo NOT retry with a guess. Call read_file on ${filePath} first to get the exact current content, then construct old_string by copying verbatim from the file.`;
     }
     const { actual, strategy, count } = match;
     // Request approval

package/dist/tools/read-file.js

@@ -108,46 +108,29 @@ export async function readFile(filePath, offset = 0, limit = 2000, sessionId) {
     const start = Math.max(0, offset);
     const maxLines = Math.max(0, limit);
     const lines = [];
-    let totalLines = 0;
     const stream = createReadStream(validated, { encoding: 'utf8' });
     const lineReader = readline.createInterface({
         input: stream,
         crlfDelay: Infinity,
     });
     try {
+        let lineIndex = 0;
         for await (const line of lineReader) {
-            if (totalLines >= start && lines.length < maxLines) {
+            if (lineIndex >= start && lines.length < maxLines) {
                 lines.push(line);
             }
-            totalLines++;
-        }
-        const stats = await fs.stat(validated);
-        if (stats.size === 0) {
-            totalLines = 0;
-        }
-        else if (lines.length === 0 && totalLines === 0) {
-            totalLines = 1;
+            lineIndex++;
         }
     }
     finally {
         lineReader.close();
         stream.destroy();
     }
-    const end = Math.min(totalLines, start + lines.length);
-    // Add line numbers (1-based)
-    const numbered = lines.map((line, i) => {
-        const lineNum = String(start + i + 1).padStart(5, ' ');
-        // Truncate very long lines
-        const truncated = line.length > 2000 ? line.slice(0, 2000) + '... (truncated)' : line;
-        return `${lineNum} | ${truncated}`;
-    });
+    // Truncate very long individual lines but don't reformat content
+    const slice = lines.map(line => line.length > 2000 ? line.slice(0, 2000) + '... (truncated)' : line);
     // Record successful read for staleness tracking
     if (sessionId) {
         recordRead(sessionId, validated);
     }
-    const rangeLabel = lines.length === 0
-        ? 'none'
-        : `${Math.min(start + 1, totalLines)}-${end}`;
-    const header = `File: ${filePath} (${totalLines} lines total, showing ${rangeLabel})`;
-    return `${header}\n${numbered.join('\n')}`;
+    return slice.join('\n');
 }

package/dist/tools/write-file.js

@@ -5,6 +5,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { validatePath } from '../utils/path-validation.js';
 import { requestApproval } from '../utils/approval.js';
+import { recordRead } from '../utils/file-time.js';
 export const writeFileTool = {
     type: 'function',
     function: {
@@ -49,5 +50,10 @@ export async function writeFile(filePath, content, sessionId) {
         await fs.rm(tmpPath, { force: true }).catch(() => undefined);
     }
     const lines = content.split('\n').length;
+    // Record the write as a read so a subsequent edit_file on this file doesn't
+    // immediately fail the staleness guard with "you must read first".
+    if (sessionId) {
+        recordRead(sessionId, validated);
+    }
     return `Successfully wrote ${lines} lines to ${filePath}`;
 }

package/dist/utils/file-time.js

@@ -13,34 +13,43 @@ export function recordRead(sessionId, absolutePath) {
     readTimes.set(`${sessionId}:${absolutePath}`, Date.now());
 }
 /**
- * Assert that a file was previously read and hasn't changed on disk since.
- * Throws if the file was never read or has been modified.
+ * Check that a file was previously read and hasn't changed on disk since.
+ * Returns an error string if the check fails, or null if all is well.
+ * Use this instead of assertReadBefore so staleness errors surface as normal
+ * tool return values rather than exceptions that get swallowed into a generic
+ * "Error executing edit_file: ..." message.
  */
-export function assertReadBefore(sessionId, absolutePath) {
+export function checkReadBefore(sessionId, absolutePath) {
     const key = `${sessionId}:${absolutePath}`;
     const lastRead = readTimes.get(key);
     if (!lastRead) {
-        throw new Error(`You must read '${absolutePath}' before editing it. Call read_file first.`);
+        return `You must read '${absolutePath}' before editing it. Call read_file first.`;
     }
     try {
         const mtime = fs.statSync(absolutePath).mtimeMs;
         if (mtime > lastRead + 100) {
-            // Clear stale entry so the error message stays accurate
+            // Clear stale entry so the error message stays accurate on retry
             readTimes.delete(key);
-            throw new Error(`'${absolutePath}' has changed on disk since you last read it. Re-read it before editing.`);
+            return `'${absolutePath}' has changed on disk since you last read it. Re-read it before editing.`;
         }
     }
     catch (err) {
         if (err.code === 'ENOENT') {
             readTimes.delete(key);
-            throw new Error(`'${absolutePath}' no longer exists on disk.`);
-        }
-        // Re-throw our own errors
-        if (err.message.includes('has changed on disk') || err.message.includes('must read')) {
-            throw err;
+            return `'${absolutePath}' no longer exists on disk.`;
         }
         // Ignore other stat errors — don't block edits on stat failures
     }
+    return null;
+}
+/**
+ * @deprecated Use checkReadBefore instead — it returns a string rather than
+ * throwing, so the error surfaces cleanly as a tool result.
+ */
+export function assertReadBefore(sessionId, absolutePath) {
+    const err = checkReadBefore(sessionId, absolutePath);
+    if (err)
+        throw new Error(err);
 }
 /**
  * Clear all read-time entries for a session (e.g. on session end).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoagent",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "files": [
     "dist",