agent-sh 0.14.8 → 0.14.9

package/dist/agent/conversation-state.js

@@ -1,788 +0,0 @@
-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);
-}
-// Head+tail because the start (command, opening lines) and end (final
-// result, exit code) are the informative parts of shell/file output.
-function slimToolContent(content, maxLen) {
-    const exitMatch = content.match(/exit code:?\s*(\d+)/i);
-    const exitSuffix = exitMatch ? ` (exit ${exitMatch[1]})` : "";
-    const lines = content.split("\n");
-    if (lines.length > 6) {
-        const head = lines.slice(0, 3).join("\n");
-        const tail = lines.slice(-2).join("\n");
-        return `${head}\n... [${lines.length - 5} lines trimmed by compact]\n${tail}${exitSuffix}`;
-    }
-    return `${content.slice(0, maxLen)}\n... [${content.length - maxLen} chars trimmed by compact]${exitSuffix}`;
-}
-/**
- * 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 {
-    messages = [];
-    messagesDirty = true;
-    cachedMessagesJson = null;
-    // tool_call_ids whose results came back with isError=true.
-    toolErrors = new Set();
-    nuclearEntries = [];
-    nuclearBySeq = new Map();
-    recallArchive = new Map();
-    instanceId;
-    handlers;
-    nextSeq = 1;
-    lastApiTokenCount = null;
-    lastApiMessageCount = 0;
-    // Buffered when addSystemNote/appendUserMessage fires mid-tool-pair;
-    // flushed once the trailing tool_result lands. Splicing into the gap
-    // breaks reasoning_content pairing and is rejected by strict providers.
-    pendingMessages = [];
-    constructor(handlers, instanceId = "0000") {
-        this.handlers = handlers ?? null;
-        this.instanceId = instanceId;
-    }
-    /** 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 (with eager nucleation) ───────────────────────
-    addUserMessage(text) {
-        this.messages.push({ role: "user", content: text });
-        this.invalidateMessagesCache();
-        this.eagerNucleateUser(text);
-    }
-    addAssistantMessage(content, toolCalls, extras) {
-        const hasToolCalls = !!toolCalls?.length;
-        // Promote reasoning into content on reasoning-only turns; strict
-        // providers (DeepSeek native) reject content="" with no tool_calls.
-        if (!content && !hasToolCalls) {
-            const r = (extras?.reasoning_content ?? extras?.reasoning);
-            if (typeof r === "string" && r)
-                content = r;
-        }
-        if (!content && !hasToolCalls)
-            return;
-        const base = {
-            role: "assistant",
-            content: hasToolCalls ? (content ?? null) : content,
-        };
-        if (hasToolCalls) {
-            base.tool_calls = toolCalls.map((tc) => ({
-                id: tc.id,
-                type: "function",
-                function: tc.function,
-            }));
-        }
-        if (extras)
-            Object.assign(base, extras);
-        this.messages.push(base);
-        this.invalidateMessagesCache();
-    }
-    addToolResult(toolCallId, content, isError = false) {
-        if (typeof content === "string") {
-            this.messages.push({ role: "tool", tool_call_id: toolCallId, content });
-        }
-        else {
-            // Assembles OpenAI vision content parts for multimodal tool results.
-            // This format (array of text + image_url blocks on a tool message) is
-            // supported by OpenAI and most OpenAI-compatible providers. Providers
-            // that don't support it should not declare image modalities, so this
-            // path is only reached for providers known to handle it.
-            const parts = [];
-            for (const img of content) {
-                parts.push({ type: "image_url", image_url: { url: `data:${img.mimeType};base64,${img.data}` } });
-            }
-            const label = isError ? `Error: [${content.length} image(s)]` : `[${content.length} image(s)]`;
-            parts.unshift({ type: "text", text: label });
-            this.messages.push({ role: "tool", tool_call_id: toolCallId, content: parts });
-        }
-        if (isError)
-            this.toolErrors.add(toolCallId);
-        this.invalidateMessagesCache();
-        this.flushPendingMessages();
-    }
-    /** Add tool results as a user message (for inline tool protocol). */
-    addToolResultInline(content) {
-        this.messages.push({ role: "user", content });
-        this.invalidateMessagesCache();
-        this.flushPendingMessages();
-    }
-    /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
-    addSystemNote(text) {
-        if (this.hasOpenToolCalls()) {
-            this.pendingMessages.push({ kind: "system", text });
-            return;
-        }
-        this.messages.push({ role: "user", content: text });
-        this.invalidateMessagesCache();
-    }
-    appendUserMessage(text) {
-        if (this.hasOpenToolCalls()) {
-            this.pendingMessages.push({ kind: "user", text });
-            return;
-        }
-        this.addUserMessage(text);
-    }
-    hasOpenToolCalls() {
-        for (let i = this.messages.length - 1; i >= 0; i--) {
-            const msg = this.messages[i];
-            if (msg.role === "tool")
-                continue;
-            if (msg.role !== "assistant")
-                return false;
-            if (!("tool_calls" in msg) || !msg.tool_calls)
-                return false;
-            const answered = new Set();
-            for (let j = i + 1; j < this.messages.length; j++) {
-                const m = this.messages[j];
-                if (m.role !== "tool")
-                    break;
-                answered.add(m.tool_call_id);
-            }
-            return msg.tool_calls.some((tc) => !answered.has(tc.id));
-        }
-        return false;
-    }
-    flushPendingMessages() {
-        if (this.pendingMessages.length === 0)
-            return;
-        if (this.hasOpenToolCalls())
-            return;
-        const pending = this.pendingMessages;
-        this.pendingMessages = [];
-        for (const m of pending) {
-            if (m.kind === "user") {
-                this.addUserMessage(m.text);
-            }
-            else {
-                this.messages.push({ role: "user", content: m.text });
-            }
-        }
-        this.invalidateMessagesCache();
-    }
-    getMessages() {
-        return this.normalizeReasoningConsistency(this.stubDanglingToolCalls(this.dropOrphanToolMessages(this.messages)));
-    }
-    /** Drop tool messages with no matching preceding tool_call — strict
-     *  providers (DeepSeek) 400, and compaction can leave such orphans. */
-    dropOrphanToolMessages(messages) {
-        const knownIds = new Set();
-        const result = [];
-        for (const msg of messages) {
-            if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
-                for (const tc of msg.tool_calls)
-                    knownIds.add(tc.id);
-            }
-            if (msg.role === "tool" && !knownIds.has(msg.tool_call_id)) {
-                continue;
-            }
-            result.push(msg);
-        }
-        return result;
-    }
-    /**
-     * If a stream was interrupted mid-tool-execution, an assistant message
-     * with tool_calls can land in history without matching tool results.
-     * Strict providers (DeepSeek) 400 on this. Stub each missing result
-     * with a [cancelled] marker so the protocol stays valid.
-     */
-    stubDanglingToolCalls(messages) {
-        const result = [];
-        let i = 0;
-        while (i < messages.length) {
-            const msg = messages[i];
-            result.push(msg);
-            i++;
-            if (msg.role !== "assistant" || !("tool_calls" in msg) || !msg.tool_calls)
-                continue;
-            const seen = new Set();
-            while (i < messages.length && messages[i].role === "tool") {
-                const t = messages[i];
-                seen.add(t.tool_call_id);
-                result.push(t);
-                i++;
-            }
-            for (const tc of msg.tool_calls) {
-                if (!seen.has(tc.id)) {
-                    result.push({ role: "tool", tool_call_id: tc.id, content: "[cancelled]" });
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * DeepSeek 400s if any assistant in a thinking-mode conversation is
-     * missing reasoning_content. Cross-alias here (OpenRouter streams as
-     * `reasoning`, DeepSeek input expects `reasoning_content`) and stub
-     * gaps (text-only turns, pre-fix messages) with empty string.
-     */
-    normalizeReasoningConsistency(messages) {
-        const needsNormalize = messages.some((m) => m.role === "assistant" && (m.reasoning !== undefined ||
-            m.reasoning_content !== undefined ||
-            m.reasoning_details !== undefined));
-        if (!needsNormalize)
-            return messages;
-        return messages.map((m) => {
-            if (m.role !== "assistant")
-                return m;
-            const a = m;
-            if (a.reasoning_content !== undefined)
-                return m;
-            return { ...m, reasoning_content: a.reasoning ?? "" };
-        });
-    }
-    /**
-     * 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;
-        this.flushPendingMessages();
-    }
-    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 text = typeof r.content === "string" ? r.content : `[${r.content.length} image(s)]`;
-            const entry = this.handlers.call("conversation:nucleate-tool", r.toolName, r.args, text, 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: text },
-            ]);
-        }
-        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);
-    }
-    /** Bump and return the global sequence counter. For extensions that
-     *  synthesize their own NuclearEntries (e.g. compaction summaries that
-     *  should land in the same sequence space as kernel-produced entries). */
-    allocateSeq() {
-        return this.nextSeq++;
-    }
-    /** Clear nuclear bookkeeping and reset the seq counter. For extensions
-     *  that swap sessions (multi-session history adapters) so the in-memory
-     *  nuclear list, recall archive, and seq counter don't carry over from
-     *  the previous session's tree. */
-    resetForSession(nextSeq) {
-        this.nuclearEntries = [];
-        this.nuclearBySeq.clear();
-        this.recallArchive.clear();
-        this.nextSeq = nextSeq;
-    }
-    // ── 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(this.getMessagesJson().length / 4);
-    }
-    // ── Compaction (uses pre-computed nuclear entries) ─────────────
-    /**
-     * 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(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();
-        // 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;
-        // 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 - verbatimCount; i < turns.length; i++)
-            turns[i].priority = 4 /* Priority.PINNED */;
-        for (const i of slimmedIndices)
-            turns[i].priority = 4 /* Priority.PINNED */;
-        const candidates = turns
-            .map((t, idx) => ({ turn: t, idx }))
-            .filter((c) => c.turn.priority !== 4 /* Priority.PINNED */)
-            .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 = convEstimate;
-        for (const c of candidates) {
-            if (currentTokens <= convTarget)
-                break;
-            const turnTokens = Math.ceil(JSON.stringify(c.turn.messages).length / 4);
-            evictedIndices.add(c.idx);
-            currentTokens -= turnTokens;
-            // 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)) {
-                    this.recallArchive.set(entry.seq, c.turn.messages);
-                }
-                else {
-                    this.nuclearEntries.push(entry);
-                    this.nuclearBySeq.set(entry.seq, entry);
-                    this.recallArchive.set(entry.seq, c.turn.messages);
-                }
-            }
-        }
-        if (evictedIndices.size === 0)
-            return null;
-        const rebuilt = [];
-        let insertedNuclearBlock = false;
-        this.nuclearBlockIdx = -1;
-        for (let i = 0; i < turns.length; i++) {
-            if (evictedIndices.has(i)) {
-                if (!insertedNuclearBlock) {
-                    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 (!insertedNuclearBlock && this.nuclearEntries.length > 0) {
-            this.updateNuclearBlockInMessages(rebuilt);
-        }
-        this.messages = rebuilt;
-        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 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 || !this.handlers)
-            return;
-        const maxSeq = Math.max(...entries.map((e) => e.seq));
-        if (maxSeq >= this.nextSeq)
-            this.nextSeq = maxSeq + 1;
-        const content = this.handlers.call("conversation:format-prior-history", entries);
-        if (!content)
-            return;
-        this.messages.push({ role: "user", content });
-        this.invalidateMessagesCache();
-    }
-    // ── Conversation recall ───────────────────────────────────────
-    async search(query) {
-        if (!query.trim())
-            return "No query provided.";
-        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}`);
-            }
-        }
-        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}".`;
-        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")}`;
-    }
-    async expand(seq) {
-        const archived = this.recallArchive.get(seq);
-        if (archived) {
-            const entry = this.nuclearBySeq.get(seq);
-            const header = entry ? formatNuclearLine(entry) : `#${seq}`;
-            return `${header}\n\n${this.turnToText(archived)}`;
-        }
-        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.`;
-    }
-    async browse() {
-        const parts = [];
-        if (this.nuclearEntries.length > 0) {
-            parts.push("In-context nuclear entries:");
-            for (const e of this.nuclearEntries)
-                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;
-    }
-    // ── Clear ─────────────────────────────────────────────────────
-    clear() {
-        this.messages = [];
-        this.nuclearEntries = [];
-        this.nuclearBySeq.clear();
-        this.recallArchive.clear();
-        this.pendingMessages = [];
-        this.invalidateMessagesCache();
-        this.lastApiTokenCount = null;
-        this.lastApiMessageCount = 0;
-    }
-    // ── Internal: Nuclear block management ────────────────────────
-    buildNuclearBlock() {
-        const lines = this.nuclearEntries.map(formatNuclearLine);
-        return {
-            role: "user",
-            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)) {
-                this.nuclearBlockIdx = i;
-                messages[i] = newBlock;
-                return;
-            }
-        }
-        if (messages.length > 0) {
-            let insertIdx = 1;
-            for (let i = 1; i < messages.length; i++) {
-                if (messages[i].role === "user") {
-                    insertIdx = i;
-                    break;
-                }
-                insertIdx = i + 1;
-            }
-            messages.splice(insertIdx, 0, newBlock);
-            this.nuclearBlockIdx = insertIdx;
-        }
-    }
-    // ── Internal: Two-tier pin for recent turns ────────────────────
-    slimTurn(messages) {
-        const MAX_RESULT_LEN = 1500;
-        const MAX_ASSISTANT_LEN = 1500;
-        const result = [];
-        const droppedToolIds = 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)) {
-                        droppedToolIds.add(tc.id);
-                        return false;
-                    }
-                    return true;
-                });
-                if (kept.length === 0) {
-                    // No content + no tool_calls is malformed (DeepSeek 400); drop the husk.
-                    const text = typeof msg.content === "string" ? msg.content.trim() : "";
-                    if (!text)
-                        continue;
-                    const { tool_calls: _, ...rest } = msg;
-                    result.push(rest);
-                }
-                else {
-                    result.push({ ...msg, tool_calls: kept });
-                }
-                continue;
-            }
-            if (msg.role === "tool") {
-                if (droppedToolIds.has(msg.tool_call_id))
-                    continue;
-                const content = typeof msg.content === "string" ? msg.content : "";
-                if (content.length > MAX_RESULT_LEN) {
-                    result.push({ ...msg, content: slimToolContent(content, MAX_RESULT_LEN) });
-                }
-                else {
-                    result.push(msg);
-                }
-                continue;
-            }
-            if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.length > MAX_ASSISTANT_LEN) {
-                const head = msg.content.slice(0, Math.floor(MAX_ASSISTANT_LEN * 0.6));
-                const tail = msg.content.slice(-Math.floor(MAX_ASSISTANT_LEN * 0.2));
-                const trimmed = msg.content.length - head.length - tail.length;
-                result.push({ ...msg, content: `${head}\n... [${trimmed} chars trimmed by compact]\n${tail}` });
-                continue;
-            }
-            result.push(msg);
-        }
-        return result;
-    }
-    // ── Internal: Turn parsing and priority ───────────────────────
-    parseTurns() {
-        const turns = [];
-        let current = [];
-        for (const msg of this.messages) {
-            if (msg.role === "user" && current.length > 0) {
-                turns.push({ messages: current, priority: 2 /* Priority.MEDIUM */ });
-                current = [];
-            }
-            current.push(msg);
-        }
-        if (current.length > 0)
-            turns.push({ messages: current, priority: 2 /* Priority.MEDIUM */ });
-        return turns;
-    }
-    inferPriority(messages) {
-        let hasError = false;
-        let hasWriteTool = false;
-        let allReadOnly = true;
-        let hasToolResult = false;
-        for (const msg of messages) {
-            if (msg.role === "user")
-                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 (this.toolErrors.has(id) || content.startsWith("Error:")) {
-                    hasError = true;
-                }
-            }
-            if (msg.role === "assistant" && "tool_calls" in msg && msg.tool_calls) {
-                for (const tc of msg.tool_calls) {
-                    const fn = "function" in tc ? tc.function : undefined;
-                    if (!fn)
-                        continue;
-                    if (WRITE_TOOLS.has(fn.name))
-                        hasWriteTool = true;
-                    if (!READ_ONLY_TOOLS.has(fn.name))
-                        allReadOnly = false;
-                }
-            }
-        }
-        if (hasError)
-            return 3 /* Priority.HIGH */;
-        if (hasWriteTool)
-            return 2 /* Priority.MEDIUM */;
-        if (hasToolResult && allReadOnly)
-            return 0 /* Priority.LOWEST */;
-        if (hasToolResult)
-            return 1 /* Priority.LOW */;
-        return 2 /* Priority.MEDIUM */;
-    }
-    turnToText(messages) {
-        const lines = [];
-        for (const msg of messages) {
-            if (msg.role === "user") {
-                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)
-                    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})`);
-                    }
-                }
-            }
-            else if (msg.role === "tool") {
-                const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-                lines.push(`[tool_result] ${content}`);
-            }
-        }
-        return lines.join("\n");
-    }
-}