agent-sh 0.9.0 → 0.10.1

package/dist/agent/conversation-state.js

@@ -1,24 +1,82 @@
-import { getSettings } from "../settings.js";
 import { toNuclearEntries, formatNuclearLine, isReadOnly, READ_ONLY_TOOLS, WRITE_TOOLS, } from "./nuclear-form.js";
+// ── Search helpers ────────────────────────────────────────────────
+function buildSearchRegex(query) {
+    try {
+        return new RegExp(query, "i");
+    }
+    catch {
+        const words = query.split(/\s+/).filter((w) => w.length > 0);
+        const escaped = words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        const lookaheads = escaped.map((w) => `(?=.*${w})`).join("");
+        return new RegExp(lookaheads, "i");
+    }
+}
+function firstMatchExcerpt(text, regex) {
+    const idx = text.search(regex);
+    if (idx === -1)
+        return null;
+    const lineStart = text.lastIndexOf("\n", idx) + 1;
+    const lineEnd = text.indexOf("\n", idx);
+    const line = text.slice(lineStart, lineEnd === -1 ? text.length : lineEnd).trim();
+    if (line.length > 120) {
+        const matchInLine = idx - lineStart;
+        const start = Math.max(0, matchInLine - 40);
+        const end = Math.min(line.length, matchInLine + 80);
+        return (start > 0 ? "\u2026" : "") + line.slice(start, end) + (end < line.length ? "\u2026" : "");
+    }
+    return line;
+}
+function recencyWeight(idx, total) {
+    return Math.max(0.1, 1 - idx / total);
+}
+/**
+ * Conversation state with eager nucleation — shell-history shaped.
+ *
+ * Every add nucleates into a one-line NuclearEntry and flushes to disk.
+ * Compaction evicts turns, replacing them with their nuclear one-liners
+ * in context; the originals stay searchable via `conversation_recall`
+ * and survive restarts in `~/.agent-sh/history`.
+ *
+ * Nucleation and history I/O go through advisable handlers — extensions
+ * swap strategies without touching this class. When no handlers are
+ * provided (subagents, tests), both become no-ops and this becomes a
+ * plain message buffer.
+ */
 export class ConversationState {
-    // ── Tier 1: Active context ────────────────────────────────────
     messages = [];
-    // ── Tier 2: Nuclear memory ────────────────────────────────────
+    messagesDirty = true;
+    cachedMessagesJson = null;
+    // tool_call_ids whose results came back with isError=true.
+    toolErrors = new Set();
     nuclearEntries = [];
+    nuclearBySeq = new Map();
     recallArchive = new Map();
-    // ── Tier 3 reference ──────────────────────────────────────────
-    historyFile;
-    // ── Shared state ──────────────────────────────────────────────
+    instanceId;
+    handlers;
     nextSeq = 1;
-    constructor(historyFile) {
-        this.historyFile = historyFile ?? null;
+    lastApiTokenCount = null;
+    lastApiMessageCount = 0;
+    constructor(handlers, instanceId = "0000") {
+        this.handlers = handlers ?? null;
+        this.instanceId = instanceId;
     }
-    get instanceId() {
-        return this.historyFile?.instanceId ?? "0000";
+    /** Get JSON.stringify of messages, cached until next mutation. */
+    getMessagesJson() {
+        if (this.messagesDirty || this.cachedMessagesJson === null) {
+            this.cachedMessagesJson = JSON.stringify(this.messages);
+            this.messagesDirty = false;
+        }
+        return this.cachedMessagesJson;
+    }
+    invalidateMessagesCache() {
+        this.messagesDirty = true;
+        this.cachedMessagesJson = null;
     }
-    // ── Message API (unchanged) ───────────────────────────────────
+    // ── Message API (with eager nucleation) ───────────────────────
     addUserMessage(text) {
         this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
+        this.eagerNucleateUser(text);
     }
     addAssistantMessage(content, toolCalls) {
         if (toolCalls?.length) {
@@ -35,204 +93,327 @@ export class ConversationState {
         else {
             this.messages.push({ role: "assistant", content: content ?? "" });
         }
+        this.invalidateMessagesCache();
     }
-    addToolResult(toolCallId, content) {
-        this.messages.push({
-            role: "tool",
-            tool_call_id: toolCallId,
-            content,
-        });
+    addToolResult(toolCallId, content, isError = false) {
+        this.messages.push({ role: "tool", tool_call_id: toolCallId, content });
+        if (isError)
+            this.toolErrors.add(toolCallId);
+        this.invalidateMessagesCache();
     }
     /** Add tool results as a user message (for inline tool protocol). */
     addToolResultInline(content) {
         this.messages.push({ role: "user", content });
+        this.invalidateMessagesCache();
     }
     addSystemNote(text) {
         this.messages.push({ role: "user", content: text });
+        this.invalidateMessagesCache();
     }
     getMessages() {
         return this.messages;
     }
+    /**
+     * Replace the messages array wholesale — the write side for custom
+     * compaction strategies. Invalidates API token baseline since the
+     * new array's token count is unknown.
+     */
+    replaceMessages(messages) {
+        this.messages = messages;
+        this.pruneToolErrors();
+        this.invalidateMessagesCache();
+        this.lastApiTokenCount = null;
+        this.lastApiMessageCount = 0;
+    }
+    pruneToolErrors() {
+        if (this.toolErrors.size === 0)
+            return;
+        const live = new Set();
+        for (const msg of this.messages) {
+            if (msg.role === "tool" && typeof msg.tool_call_id === "string") {
+                live.add(msg.tool_call_id);
+            }
+        }
+        for (const id of this.toolErrors) {
+            if (!live.has(id))
+                this.toolErrors.delete(id);
+        }
+    }
+    // ── Eager nucleation (via advisable handlers) ─────────────────
+    eagerNucleateUser(text) {
+        if (!this.handlers)
+            return;
+        const seq = this.nextSeq++;
+        const entry = this.handlers.call("conversation:nucleate-user", text, this.instanceId, seq);
+        this.recordNuclearEntry(entry, [{ role: "user", content: text }]);
+        this.appendToHistory([entry]);
+    }
+    /** Nucleate an agent text response. Called by agent-loop when the loop finishes without tool calls. */
+    eagerNucleateAgent(text) {
+        if (!text || !this.handlers)
+            return;
+        const seq = this.nextSeq++;
+        const entry = this.handlers.call("conversation:nucleate-agent", text, this.instanceId, seq);
+        this.recordNuclearEntry(entry, [{ role: "assistant", content: text }]);
+        this.appendToHistory([entry]);
+    }
+    /** Nucleate tool call results. One entry per tool call, enriched with result. */
+    eagerNucleateTools(results) {
+        if (!this.handlers || results.length === 0)
+            return;
+        const entries = [];
+        for (const r of results) {
+            const seq = this.nextSeq++;
+            const entry = this.handlers.call("conversation:nucleate-tool", r.toolName, r.args, r.content, r.isError, this.instanceId, seq);
+            entries.push(entry);
+            this.recordNuclearEntry(entry, [
+                { role: "assistant", content: null, tool_calls: [{ id: `seq_${seq}`, type: "function", function: { name: r.toolName, arguments: JSON.stringify(r.args) } }] },
+                { role: "tool", tool_call_id: `seq_${seq}`, content: r.content },
+            ]);
+        }
+        this.appendToHistory(entries);
+    }
+    /** Track an entry in memory (nuclear list + recall archive). */
+    recordNuclearEntry(entry, originalMessages) {
+        this.nuclearEntries.push(entry);
+        this.nuclearBySeq.set(entry.seq, entry);
+        this.recallArchive.set(entry.seq, originalMessages);
+    }
+    appendToHistory(entries) {
+        if (!this.handlers || entries.length === 0)
+            return;
+        this.handlers.call("history:append", entries);
+    }
     // ── Token estimation ──────────────────────────────────────────
+    updateApiTokenCount(promptTokens) {
+        this.lastApiTokenCount = promptTokens;
+        this.lastApiMessageCount = this.messages.length;
+    }
+    estimatePromptTokens() {
+        if (this.lastApiTokenCount === null)
+            return this.estimateTokens();
+        const trailing = this.messages.length - this.lastApiMessageCount;
+        if (trailing <= 0)
+            return this.lastApiTokenCount;
+        const trailingMessages = this.messages.slice(this.lastApiMessageCount);
+        return this.lastApiTokenCount + Math.ceil(JSON.stringify(trailingMessages).length / 4);
+    }
     estimateTokens() {
-        return Math.ceil(JSON.stringify(this.messages).length / 4);
+        return Math.ceil(this.getMessagesJson().length / 4);
     }
-    // ── Tier 1 → Tier 2: Compaction ───────────────────────────────
+    // ── Compaction (uses pre-computed nuclear entries) ─────────────
     /**
-     * Priority-based compaction. Evicts lowest-priority turns, replacing
-     * them with nuclear one-liner summaries that stay in the conversation.
-     * Read-only tool results are dropped entirely.
+     * Two-tier pin compaction: evict lowest-priority turns (replaced by
+     * their nuclear one-liners), slim the window before the last verbatim
+     * turn, drop read-only tool results entirely. Extensions replace the
+     * whole strategy by advising `conversation:compact` and skipping next.
      */
-    compact(targetTokens, recentTurnsToKeep = 10, force = false) {
-        const before = this.estimateTokens();
-        if (!force && before <= targetTokens)
+    compact(maxPromptTokens, recentTurnsToKeep = 10, force = false) {
+        const promptEstimate = this.estimatePromptTokens();
+        const convEstimate = this.estimateTokens();
+        const overhead = promptEstimate - convEstimate;
+        const convTarget = Math.max(0, maxPromptTokens - overhead);
+        const before = promptEstimate;
+        if (!force && convEstimate <= convTarget)
             return null;
         const turns = this.parseTurns();
-        if (turns.length <= 2)
+        // With force, allow compacting down to 1 turn (the current response).
+        // Without force, keep at least 2 turns (user + agent) to avoid
+        // annihilating a young conversation.
+        if (turns.length <= (force ? 1 : 2))
             return null;
-        // Assign priorities
-        const pinnedCount = Math.min(recentTurnsToKeep, turns.length - 1);
-        for (const turn of turns) {
-            turn.priority = this.inferPriority(turn.messages);
+        // Cap the pinned window so enough turns remain evictable.
+        const maxPinnedFraction = force ? 0.4 : 0.6;
+        const maxPinned = Math.max(2, Math.floor(turns.length * maxPinnedFraction));
+        // Ensure at least 1 turn is evictable when force is true, even in
+        // very short conversations (e.g. 3 turns with heavy tool output).
+        const maxPinnedForced = force ? Math.min(maxPinned, turns.length - 2) : maxPinned;
+        const pinnedCount = Math.min(recentTurnsToKeep, turns.length - 1, Math.max(1, maxPinnedForced));
+        for (let i = 0; i < turns.length; i++) {
+            turns[i].priority = this.inferPriority(turns[i].messages);
         }
+        // Two-tier pin: last turn verbatim, next (pinnedCount-1) slimmed.
+        const verbatimCount = 1;
+        const slimmedCount = Math.max(0, pinnedCount - verbatimCount);
+        const slimStart = turns.length - pinnedCount;
+        const slimEnd = slimStart + slimmedCount;
+        const slimmedIndices = new Set();
+        for (let i = slimStart; i < slimEnd; i++)
+            slimmedIndices.add(i);
         turns[0].priority = 4 /* Priority.PINNED */;
-        for (let i = turns.length - pinnedCount; i < turns.length; i++) {
+        for (let i = turns.length - verbatimCount; i < turns.length; i++)
+            turns[i].priority = 4 /* Priority.PINNED */;
+        for (const i of slimmedIndices)
             turns[i].priority = 4 /* Priority.PINNED */;
-        }
-        // Sort candidates: lowest priority first, then oldest
         const candidates = turns
             .map((t, idx) => ({ turn: t, idx }))
             .filter((c) => c.turn.priority !== 4 /* Priority.PINNED */)
-            .sort((a, b) => a.turn.priority - b.turn.priority || a.idx - b.idx);
-        // Evict until under budget
+            .sort((a, b) => {
+            const effA = a.turn.priority * recencyWeight(a.idx, turns.length);
+            const effB = b.turn.priority * recencyWeight(b.idx, turns.length);
+            return effA - effB || a.idx - b.idx;
+        });
         const evictedIndices = new Set();
-        let currentTokens = this.estimateTokens();
+        let currentTokens = convEstimate;
         for (const c of candidates) {
-            if (currentTokens <= targetTokens)
+            if (currentTokens <= convTarget)
                 break;
             const turnTokens = Math.ceil(JSON.stringify(c.turn.messages).length / 4);
             evictedIndices.add(c.idx);
             currentTokens -= turnTokens;
-            // Generate nuclear entries from this turn
-            const entries = toNuclearEntries(c.turn.messages, this.nextSeq, this.instanceId);
-            this.nextSeq += entries.length;
-            for (const entry of entries) {
+            // Fallback for turn messages that missed eager nucleation (e.g.
+            // injected system notes). Entries already nucleated live in
+            // nuclearEntries under their original seqs.
+            const turnEntries = toNuclearEntries(c.turn.messages, this.nextSeq, this.instanceId);
+            this.nextSeq += turnEntries.length;
+            for (const entry of turnEntries) {
                 if (isReadOnly(entry)) {
-                    // Read-only: archive only (dropped from conversation), agent can re-read
                     this.recallArchive.set(entry.seq, c.turn.messages);
                 }
                 else {
-                    // State-changing: keep nuclear one-liner in conversation + archive
                     this.nuclearEntries.push(entry);
+                    this.nuclearBySeq.set(entry.seq, entry);
                     this.recallArchive.set(entry.seq, c.turn.messages);
                 }
             }
         }
         if (evictedIndices.size === 0)
             return null;
-        // Rebuild: first turn + nuclear summary block + remaining turns
         const rebuilt = [];
         let insertedNuclearBlock = false;
+        this.nuclearBlockIdx = -1;
         for (let i = 0; i < turns.length; i++) {
             if (evictedIndices.has(i)) {
                 if (!insertedNuclearBlock) {
-                    rebuilt.push(this.buildNuclearBlock());
+                    const block = this.buildNuclearBlock();
+                    this.nuclearBlockIdx = rebuilt.length;
+                    rebuilt.push(block);
                     insertedNuclearBlock = true;
                 }
             }
+            else if (slimmedIndices.has(i)) {
+                rebuilt.push(...this.slimTurn(turns[i].messages));
+            }
             else {
                 rebuilt.push(...turns[i].messages);
             }
         }
-        // If no nuclear block was inserted but we have entries from prior compactions,
-        // update the existing nuclear block
         if (!insertedNuclearBlock && this.nuclearEntries.length > 0) {
             this.updateNuclearBlockInMessages(rebuilt);
         }
         this.messages = rebuilt;
-        return { before, after: this.estimateTokens() };
-    }
-    // ── Tier 2 → Tier 3: Flush ───────────────────────────────────
-    /**
-     * Flush oldest nuclear entries to the history file when the
-     * in-context nuclear block grows too large.
-     */
-    async flush() {
-        const maxEntries = getSettings().nuclearMaxEntries;
-        if (this.nuclearEntries.length <= maxEntries)
-            return;
-        const flushCount = this.nuclearEntries.length - maxEntries;
-        const toFlush = this.nuclearEntries.slice(0, flushCount);
-        // Write to history file
-        if (this.historyFile) {
-            await this.historyFile.append(toFlush);
-        }
-        // Remove flushed entries from memory
-        for (const entry of toFlush) {
-            this.recallArchive.delete(entry.seq);
-        }
-        this.nuclearEntries = this.nuclearEntries.slice(flushCount);
-        // Update the nuclear block in messages
-        this.updateNuclearBlockInMessages(this.messages);
+        this.pruneToolErrors();
+        this.invalidateMessagesCache();
+        // Preserve system+tools+dynamic overhead so estimatePromptTokens() stays
+        // full-prompt-accurate until the next API call refines it. Nulling here
+        // caused /context to under-report by ~overhead tokens after every compact.
+        const after = overhead + this.estimateTokens();
+        this.lastApiTokenCount = after;
+        this.lastApiMessageCount = this.messages.length;
+        return {
+            before,
+            after,
+            evictedCount: evictedIndices.size,
+        };
     }
     // ── Startup: Load prior history ───────────────────────────────
     /**
-     * Inject prior session history from the history file as a context note.
+     * Inject prior session history as a context preamble. The preamble
+     * layout goes through the `conversation:format-prior-history` handler,
+     * so extensions can swap the flat list for grouped/richer rendering.
      */
     loadPriorHistory(entries) {
-        if (entries.length === 0)
+        if (entries.length === 0 || !this.handlers)
             return;
-        // Update nextSeq to avoid collisions
         const maxSeq = Math.max(...entries.map((e) => e.seq));
         if (maxSeq >= this.nextSeq)
             this.nextSeq = maxSeq + 1;
-        const lines = entries.map(formatNuclearLine);
-        this.messages.push({
-            role: "user",
-            content: `[Prior session history — loaded from ~/.agent-sh/history]\n${lines.join("\n")}`,
-        });
+        const content = this.handlers.call("conversation:format-prior-history", entries);
+        if (!content)
+            return;
+        this.messages.push({ role: "user", content });
+        this.invalidateMessagesCache();
     }
     // ── Conversation recall ───────────────────────────────────────
-    /** Search Tier 2 archive + Tier 3 history file. */
     async search(query) {
         if (!query.trim())
             return "No query provided.";
-        const parts = [];
-        // Search Tier 2 (in-memory archive)
-        const archiveResults = this.searchArchive(query);
-        if (archiveResults)
-            parts.push(archiveResults);
-        // Search Tier 3 (history file)
-        if (this.historyFile) {
-            const fileResults = await this.historyFile.search(query);
-            if (fileResults.length > 0) {
-                parts.push(`History file matches (${fileResults.length}):`);
-                for (const r of fileResults.slice(0, 20)) {
-                    parts.push(`  ${r.line}`);
-                }
+        const regex = buildSearchRegex(query);
+        const seenSeqs = new Set();
+        const hits = [];
+        for (const [seq, msgs] of this.recallArchive) {
+            const text = this.turnToText(msgs);
+            const excerpt = firstMatchExcerpt(text, regex);
+            if (excerpt) {
+                seenSeqs.add(seq);
+                const entry = this.nuclearBySeq.get(seq);
+                const header = entry ? formatNuclearLine(entry) : `#${seq}`;
+                hits.push(`${header}\n  ${excerpt}`);
             }
         }
-        if (parts.length === 0)
+        const fileResults = this.handlers
+            ? (await this.handlers.call("history:search", query))
+            : undefined;
+        if (fileResults) {
+            for (const r of fileResults) {
+                if (seenSeqs.has(r.entry.seq))
+                    continue;
+                seenSeqs.add(r.entry.seq);
+                const excerpt = r.entry.body ? firstMatchExcerpt(r.entry.body, regex) : null;
+                hits.push(excerpt ? `${r.line}\n  ${excerpt}` : r.line);
+            }
+        }
+        if (hits.length === 0)
             return `No results found for "${query}".`;
-        return parts.join("\n\n");
+        const total = hits.length;
+        const summary = `Found ${total} match${total === 1 ? "" : "es"} for "${query}"`;
+        return `${summary}\n\n${hits.slice(0, 30).join("\n\n")}`;
     }
-    /** Expand full content of a nuclear entry by seq number. */
     async expand(seq) {
-        // Check Tier 2 archive first
         const archived = this.recallArchive.get(seq);
         if (archived) {
-            const entry = this.nuclearEntries.find((e) => e.seq === seq);
+            const entry = this.nuclearBySeq.get(seq);
             const header = entry ? formatNuclearLine(entry) : `#${seq}`;
             return `${header}\n\n${this.turnToText(archived)}`;
         }
-        return `Entry #${seq}: not found in recall archive (may have been flushed to history file).`;
+        if (this.handlers) {
+            const entry = (await this.handlers.call("history:find-by-seq", seq));
+            if (entry?.body)
+                return `${formatNuclearLine(entry)}\n\n${entry.body}`;
+        }
+        return `Entry #${seq}: no expanded content available.`;
     }
-    /** Browse nuclear entries (Tier 2) + recent history (Tier 3). */
     async browse() {
         const parts = [];
         if (this.nuclearEntries.length > 0) {
             parts.push("In-context nuclear entries:");
-            for (const e of this.nuclearEntries) {
+            for (const e of this.nuclearEntries)
                 parts.push(`  ${formatNuclearLine(e)}`);
-            }
         }
-        if (this.historyFile) {
-            const recent = await this.historyFile.readRecent(25);
-            if (recent.length > 0) {
-                parts.push("\nRecent history file entries:");
-                for (const e of recent) {
-                    parts.push(`  ${formatNuclearLine(e)}`);
-                }
-            }
+        const recent = this.handlers
+            ? (await this.handlers.call("history:read-recent", 25))
+            : undefined;
+        if (recent && recent.length > 0) {
+            parts.push("\nRecent history file entries:");
+            for (const e of recent)
+                parts.push(`  ${formatNuclearLine(e)}`);
         }
         if (parts.length === 0)
             return "No conversation history.";
         return parts.join("\n");
     }
     // ── Stats ─────────────────────────────────────────────────────
+    getNuclearEntries() {
+        return this.nuclearEntries;
+    }
     getNuclearEntryCount() {
         return this.nuclearEntries.length;
     }
+    getNuclearSummary() {
+        if (this.nuclearEntries.length === 0)
+            return null;
+        return this.nuclearEntries.map(formatNuclearLine).join("\n");
+    }
     getRecallArchiveSize() {
         return this.recallArchive.size;
     }
@@ -240,7 +421,11 @@ export class ConversationState {
     clear() {
         this.messages = [];
         this.nuclearEntries = [];
+        this.nuclearBySeq.clear();
         this.recallArchive.clear();
+        this.invalidateMessagesCache();
+        this.lastApiTokenCount = null;
+        this.lastApiMessageCount = 0;
     }
     // ── Internal: Nuclear block management ────────────────────────
     buildNuclearBlock() {
@@ -250,20 +435,32 @@ export class ConversationState {
             content: `[Conversation history — use conversation_recall to expand any entry]\n${lines.join("\n")}`,
         };
     }
+    /** Index of the nuclear block in messages[], or -1 if not present. */
+    nuclearBlockIdx = -1;
     updateNuclearBlockInMessages(messages) {
         if (this.nuclearEntries.length === 0)
             return;
         const marker = "[Conversation history — use conversation_recall";
+        const newBlock = this.buildNuclearBlock();
+        // Verify the cached index still points at the nuclear block; stale if
+        // messages[] was mutated elsewhere since compaction.
+        if (this.nuclearBlockIdx >= 0 && this.nuclearBlockIdx < messages.length) {
+            const slot = messages[this.nuclearBlockIdx];
+            if (slot.role === "user" && typeof slot.content === "string" && slot.content.startsWith(marker)) {
+                messages[this.nuclearBlockIdx] = newBlock;
+                return;
+            }
+            this.nuclearBlockIdx = -1;
+        }
         for (let i = 0; i < messages.length; i++) {
             const msg = messages[i];
             if (msg.role === "user" && typeof msg.content === "string" && msg.content.startsWith(marker)) {
-                messages[i] = this.buildNuclearBlock();
+                this.nuclearBlockIdx = i;
+                messages[i] = newBlock;
                 return;
             }
         }
-        // No existing block found — insert after the first turn
         if (messages.length > 0) {
-            // Find end of first turn (next user message or end)
             let insertIdx = 1;
             for (let i = 1; i < messages.length; i++) {
                 if (messages[i].role === "user") {
@@ -272,8 +469,50 @@ export class ConversationState {
                 }
                 insertIdx = i + 1;
             }
-            messages.splice(insertIdx, 0, this.buildNuclearBlock());
+            messages.splice(insertIdx, 0, newBlock);
+            this.nuclearBlockIdx = insertIdx;
+        }
+    }
+    // ── Internal: Two-tier pin for recent turns ────────────────────
+    slimTurn(messages) {
+        const MAX_RESULT_LEN = 1500;
+        const result = [];
+        const readOnlyToolIds = new Set();
+        for (const msg of messages) {
+            if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
+                const kept = msg.tool_calls.filter((tc) => {
+                    if (!("function" in tc))
+                        return true;
+                    if (READ_ONLY_TOOLS.has(tc.function.name)) {
+                        readOnlyToolIds.add(tc.id);
+                        return false;
+                    }
+                    return true;
+                });
+                if (kept.length === 0) {
+                    const { tool_calls: _, ...rest } = msg;
+                    result.push(rest);
+                }
+                else {
+                    result.push({ ...msg, tool_calls: kept });
+                }
+                continue;
+            }
+            if (msg.role === "tool") {
+                if (readOnlyToolIds.has(msg.tool_call_id))
+                    continue;
+                const content = typeof msg.content === "string" ? msg.content : "";
+                if (content.length > MAX_RESULT_LEN) {
+                    result.push({ ...msg, content: content.slice(0, MAX_RESULT_LEN) + "\n... [truncated by compact]" });
+                }
+                else {
+                    result.push(msg);
+                }
+                continue;
+            }
+            result.push(msg);
         }
+        return result;
     }
     // ── Internal: Turn parsing and priority ───────────────────────
     parseTurns() {
@@ -286,9 +525,8 @@ export class ConversationState {
             }
             current.push(msg);
         }
-        if (current.length > 0) {
+        if (current.length > 0)
             turns.push({ messages: current, priority: 2 /* Priority.MEDIUM */ });
-        }
         return turns;
     }
     inferPriority(messages) {
@@ -301,8 +539,11 @@ export class ConversationState {
                 return 3 /* Priority.HIGH */;
             if (msg.role === "tool") {
                 hasToolResult = true;
+                // Structured flag is primary; the "Error:" prefix check covers
+                // callers that didn't thread isError (extensions, legacy paths).
+                const id = typeof msg.tool_call_id === "string" ? msg.tool_call_id : "";
                 const content = typeof msg.content === "string" ? msg.content : "";
-                if (content.startsWith("Error:") || content.includes("error")) {
+                if (this.toolErrors.has(id) || content.startsWith("Error:")) {
                     hasError = true;
                 }
             }
@@ -311,10 +552,9 @@ export class ConversationState {
                     const fn = "function" in tc ? tc.function : undefined;
                     if (!fn)
                         continue;
-                    const name = fn.name;
-                    if (WRITE_TOOLS.has(name))
+                    if (WRITE_TOOLS.has(fn.name))
                         hasWriteTool = true;
-                    if (!READ_ONLY_TOOLS.has(name))
+                    if (!READ_ONLY_TOOLS.has(fn.name))
                         allReadOnly = false;
                 }
             }
@@ -329,31 +569,6 @@ export class ConversationState {
             return 1 /* Priority.LOW */;
         return 2 /* Priority.MEDIUM */;
     }
-    // ── Internal: Search helpers ──────────────────────────────────
-    searchArchive(query) {
-        if (this.recallArchive.size === 0)
-            return null;
-        let regex;
-        try {
-            regex = new RegExp(query, "i");
-        }
-        catch {
-            const words = query.split(/\s+/).filter((w) => w.length > 0);
-            const pattern = words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-            regex = new RegExp(pattern, "i");
-        }
-        const matches = [];
-        for (const [seq, msgs] of this.recallArchive) {
-            const text = this.turnToText(msgs);
-            if (regex.test(text)) {
-                const entry = this.nuclearEntries.find((e) => e.seq === seq);
-                matches.push(entry ? formatNuclearLine(entry) : `#${seq}`);
-            }
-        }
-        if (matches.length === 0)
-            return null;
-        return `Recall archive matches (${matches.length}):\n${matches.map((m) => `  ${m}`).join("\n")}`;
-    }
     turnToText(messages) {
         const lines = [];
         for (const msg of messages) {
@@ -361,20 +576,18 @@ export class ConversationState {
                 lines.push(`[user] ${typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)}`);
             }
             else if (msg.role === "assistant") {
-                if (typeof msg.content === "string" && msg.content) {
+                if (typeof msg.content === "string" && msg.content)
                     lines.push(`[assistant] ${msg.content}`);
-                }
                 if ("tool_calls" in msg && msg.tool_calls) {
                     for (const tc of msg.tool_calls) {
-                        if ("function" in tc) {
-                            lines.push(`[tool_call] ${tc.function.name}(${tc.function.arguments.slice(0, 200)})`);
-                        }
+                        if ("function" in tc)
+                            lines.push(`[tool_call] ${tc.function.name}(${tc.function.arguments})`);
                     }
                 }
             }
             else if (msg.role === "tool") {
                 const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-                lines.push(`[tool_result] ${content.slice(0, 500)}`);
+                lines.push(`[tool_result] ${content}`);
             }
         }
         return lines.join("\n");