micro-models-agent 0.51.1 → 0.51.2

package/dist/modules/context/fact-extractor.js

@@ -1,162 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-/**
- * Regex-based fact extraction from tool/assistant messages. Owns the file /
- * deleted / decision / error fact lists that survive compaction. Extracted
- * from ContextManager so the ~115-line regex logic has one home (rule #2).
- */
-export class FactExtractor {
-    fileFacts = [];
-    deletedFacts = [];
-    decisionFacts = [];
-    errorFacts = [];
-    readFacts = [];
-    static MAX_FACTS = 20;
-    get errorCount() {
-        return this.errorFacts.length;
-    }
-    /** Scan a batch of compacted turns and fold their facts into the lists. */
-    extract(turns) {
-        // Absolute Windows paths ("E:\proj\src\a.ts") need an optional drive prefix;
-        // without it the colon breaks the match and the fact is silently dropped.
-        const DRIVE = "(?:[a-zA-Z]:[\\\\/])?";
-        const createdPatterns = [
-            new RegExp(`(?:Created|Updated|Written|Moved|Replaced in) ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`Файл (?:создан|обновлён|записан|перемещён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`file (?:created|updated|written|moved):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        const deletedPatterns = [
-            new RegExp(`Deleted ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`(?:Удалён|Файл удалён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        // read_file output header — locale-independent prefix `── path (ext, …`
-        // (en: "lines", ru: "строк"). The path is already prefixed with the same
-        // box-drawing marker in both locales, so the pattern needs no localization.
-        const readPatterns = [new RegExp(`── (${DRIVE}[\\w./\\\\-]+\\.[a-z]+) \\(`, "gi")];
-        const newFiles = [];
-        const newDeleted = [];
-        const newDecisions = [];
-        const newErrors = [];
-        const newReads = [];
-        // Track the LAST tool event per path so a delete followed by a re-create
-        // (or vice versa) in the same window resolves to its final state instead of
-        // being both filtered out of [Files:] and reported as [Deleted:].
-        const lastEvent = new Map();
-        for (const msg of turns) {
-            const content = getMessageText(msg.content);
-            // The system prompt is never a fact source — the memory module embeds
-            // errors.md (with historical "Tool X failed Nx" entries from PAST days)
-            // there, and extracting that text as current [Errors:] misleads the model
-            // into thinking IT is failing (observed: ses_msvuao0h — a stale
-            // "edit_file failed 3x" from 2026-08-15 landed in every compaction
-            // summary as if it were the live session's failure).
-            if (msg.role === "system")
-                continue;
-            // Never feed a previous <system-summary> block into new facts — that is
-            // the source of recursive summary nesting (summary inside summary).
-            if (msg.role === "user" &&
-                (content.startsWith("<system-summary>") || content.includes("[Compressed:"))) {
-                continue;
-            }
-            if (msg.role === "tool") {
-                for (const pattern of createdPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newFiles.push(match[1]);
-                        lastEvent.set(match[1], "file");
-                    }
-                }
-                for (const pattern of deletedPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newDeleted.push(match[1]);
-                        lastEvent.set(match[1], "deleted");
-                    }
-                }
-                for (const pattern of readPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newReads.push(match[1]);
-                    }
-                }
-                if (content.includes("Plan:") && content.includes("[")) {
-                    const planLine = content.split("\n").find((line) => line.includes("Plan:"));
-                    if (planLine)
-                        newDecisions.push(planLine.trim());
-                }
-            }
-            if (msg.role === "assistant") {
-                if (content.includes("decided:") || content.includes("decision:")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("decided:") || l.includes("decision:"));
-                    if (line)
-                        newDecisions.push(line.trim().slice(0, 200));
-                }
-            }
-            if (msg.role === "tool" || msg.role === "assistant") {
-                if (content.includes("Error:") ||
-                    content.includes("failed") ||
-                    content.includes("Ошибка:") ||
-                    content.includes("не удалось")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("Error:") ||
-                        l.includes("failed") ||
-                        l.includes("Ошибка:") ||
-                        l.includes("не удалось"));
-                    if (line)
-                        newErrors.push(line.trim().slice(0, 250));
-                }
-            }
-        }
-        // Deduplicate and cap facts to prevent unbounded growth. Files that were
-        // DELETED leave the "known files" list — a deleted file must not keep
-        // being reported as existing (observed: deleted .js files listed in
-        // every [Files: ...] block for the whole session). A path that is deleted
-        // then RE-CREATED (delete_file A → write_file A) is un-deleted: the last
-        // event in the window wins, so it returns to [Files:] and leaves [Deleted:].
-        const dedup = (arr) => [...new Set(arr)];
-        const finalFiles = dedup(newFiles.filter((p) => lastEvent.get(p) === "file"));
-        const finalDeleted = dedup(newDeleted.filter((p) => lastEvent.get(p) === "deleted"));
-        this.fileFacts = dedup([...this.fileFacts, ...finalFiles].filter((p) => !finalDeleted.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.deletedFacts = dedup([...this.deletedFacts, ...finalDeleted].filter((p) => !finalFiles.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-FactExtractor.MAX_FACTS);
-        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-FactExtractor.MAX_FACTS);
-        this.readFacts = dedup([...this.readFacts, ...newReads]).slice(-FactExtractor.MAX_FACTS);
-    }
-    /** `[Files: a; b]` line for a compaction summary, or null. */
-    filesLine() {
-        const deletedSet = new Set(this.deletedFacts);
-        const liveFiles = this.fileFacts.filter((p) => !deletedSet.has(p));
-        if (liveFiles.length === 0)
-            return null;
-        return `[Files: ${liveFiles.slice(-15).join("; ")}]`;
-    }
-    /** `[Deleted: c]` line, or null. */
-    deletedLine() {
-        if (this.deletedFacts.length === 0)
-            return null;
-        return `[Deleted: ${this.deletedFacts.slice(-10).join("; ")}]`;
-    }
-    /** `[Decisions: d]` line, or null. */
-    decisionsLine() {
-        if (this.decisionFacts.length === 0)
-            return null;
-        return `[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`;
-    }
-    /** `[Errors: e]` line, or null. */
-    errorsLine() {
-        if (this.errorFacts.length === 0)
-            return null;
-        return `[Errors: ${this.errorFacts.slice(-3).join("; ")}]`;
-    }
-    /**
-     * `[Read: p1; p2]` line — files already inspected via read_file. Lets the
-     * model re-orient after compaction without rescanning the whole project: it
-     * knows which files were already read and only re-reads what changed
-     * (observed: post-compaction the model re-read the same files it had already
-     * inspected, because "already read" never survived compaction).
-     */
-    readLine() {
-        if (this.readFacts.length === 0)
-            return null;
-        return `[Read: ${this.readFacts.slice(-12).join("; ")}]`;
-    }
-}

package/dist/modules/context/history.js

@@ -1,15 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-export class SessionHistoryWriter {
-    historyPath;
-    constructor(sessionsDir, sessionId) {
-        const sessionDir = join(sessionsDir, sessionId);
-        if (!existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
-        }
-        this.historyPath = join(sessionDir, 'history.jsonl');
-    }
-    append(msg) {
-        appendFileSync(this.historyPath, JSON.stringify(msg) + '\n', 'utf-8');
-    }
-}

package/dist/modules/context/index.js

@@ -1 +0,0 @@
-export { ContextManager } from "./manager";

package/dist/modules/context/manager.js

@@ -1,423 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-import { FactExtractor } from "./fact-extractor";
-const COMPACTION_INTERVAL = 15;
-const KEEP_LAST_N = 6;
-function summarizeArgs(args) {
-    if (!args)
-        return "";
-    if (typeof args === "string")
-        return args.slice(0, 80);
-    try {
-        const keys = Object.keys(args);
-        return keys.slice(0, 3).join(", ");
-    }
-    catch {
-        return String(args).slice(0, 80);
-    }
-}
-function truncate(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max - 3) + "...";
-}
-function looksLikeErrorPaste(text) {
-    // Error markers.
-    if (/(?:^|\s)ERROR|Error:|error TS\d+|Transform failed|\[plugin:|SyntaxError|Cannot find|Uncaught|exception/i.test(text)) {
-        return true;
-    }
-    // Structural signals of pasted compiler/runtime output: source frames
-    // ("270|  }_s(...)"), path:line:col references, and stack-trace lines.
-    if (/(?:^|\n)\s*\d+\s*\|/.test(text))
-        return true;
-    if (/[\w./\\-]+\.[a-z]{1,6}:\d+:\d+/.test(text))
-        return true;
-    if (/(?:^|\n)\s*at\s+\S+/.test(text))
-        return true;
-    return false;
-}
-export function extractTriedAndFailed(messages) {
-    const failures = new Map();
-    for (const msg of messages) {
-        if (msg.role === "tool" && msg.name && msg.success === false) {
-            const key = `${msg.name}:${summarizeArgs(msg.arguments)}`;
-            const existing = failures.get(key);
-            const errorText = truncate(typeof msg.content === "string" ? msg.content : getMessageText(msg.content), 100);
-            if (existing) {
-                existing.count++;
-            }
-            else {
-                failures.set(key, {
-                    tool: msg.name,
-                    args: summarizeArgs(msg.arguments),
-                    error: errorText,
-                    count: 1,
-                });
-            }
-        }
-    }
-    return Array.from(failures.values()).filter((f) => f.count >= 2);
-}
-export class ContextManager {
-    contextWindow;
-    messages = [];
-    compactedBlock = null;
-    iterationsSinceCompaction = 0;
-    compactionCount = 0;
-    peakTokens = 0;
-    budget;
-    compactionThreshold;
-    facts = new FactExtractor();
-    /** Latest real user instruction (skips <system-summary> blocks). */
-    lastUserTask = "";
-    /** First real user instruction of the session — survives resetUserTurn(). */
-    sessionMission = "";
-    /** Latest user message that looks like a pasted error/log (never a task). */
-    lastUserFeedback = "";
-    tokenCounter;
-    pendingImageParts = [];
-    toolTokens = 0;
-    onCompact = null;
-    /**
-     * Optional short line appended to the compaction summary so the model knows
-     * an active plan exists with progress. Wired from bootstrap to the execution
-     * module — without it, a 9B model re-creates a plan from scratch right after
-     * compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) was discarded for a
-     * fresh plan_xzq9xe the same iteration the old plan was still visible).
-     */
-    planSummaryProvider = null;
-    constructor(contextWindow, contextBudget, tokenCounter) {
-        this.contextWindow = contextWindow;
-        this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
-        this.budget = this.calculateBudget(contextWindow, contextBudget);
-        this.tokenCounter = tokenCounter ?? null;
-    }
-    /**
-     * Provide a short "current plan" line for the compaction summary, or null
-     * when no plan is active. Injected once at bootstrap (not per-turn state).
-     */
-    setPlanSummaryProvider(fn) {
-        this.planSummaryProvider = fn;
-    }
-    calculateBudget(window, contextBudget) {
-        if (contextBudget) {
-            const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
-            const responseReserve = Math.floor(window * contextBudget.responseReserve);
-            const history = Math.max(0, window - systemPrompt - responseReserve);
-            return { systemPrompt, responseReserve, history };
-        }
-        // Fallback for backwards compatibility (tests, subagents without explicit budget)
-        return {
-            systemPrompt: Math.floor(window * 0.25),
-            responseReserve: Math.floor(window * 0.12),
-            history: Math.floor(window * 0.63),
-        };
-    }
-    getBudget() {
-        return { ...this.budget };
-    }
-    getCompactionCount() {
-        return this.compactionCount;
-    }
-    getIterationsSinceCompaction() {
-        return this.iterationsSinceCompaction;
-    }
-    noteIteration() {
-        this.iterationsSinceCompaction++;
-    }
-    /**
-     * Start a fresh user turn. The 15-iteration compaction interval must not
-     * leak across user messages — otherwise a turn that ends at iteration 14
-     * forces a compaction on the very first iteration of the next user message
-     * (observed: compaction fired on iteration 8 of a new turn, deleting the
-     * user's freshly-sent task alongside 40+ old turns). Facts are kept.
-     */
-    resetUserTurn() {
-        this.iterationsSinceCompaction = 0;
-        // A new user message begins a new turn — drop the previous turn's task
-        // so the fresh instruction becomes the one preserved at compaction. The
-        // session mission survives: an error/log paste in the new turn must not
-        // erase the original goal.
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-    }
-    getQuality() {
-        const usedTokens = this.getEstimatedTokens();
-        const tokenLoad = Math.max(0, 1 - usedTokens / this.budget.history);
-        // Recoverable penalty: each compaction loses some information, but the
-        // penalty is CAPPED so cumulative compactions can never permanently pin
-        // quality below the forced-compaction trigger (40%). Before this cap, a
-        // session with ~7+ compactions clamped the term to 0 forever; combined
-        // with heavy token load + error density, quality stuck below 40 and a
-        // compaction fired on EVERY iteration (observed: 56 compactions in 28 min).
-        const COMPACTION_PENALTY_FLOOR = 0.5;
-        const compactionLoss = Math.max(COMPACTION_PENALTY_FLOOR, 1 - this.compactionCount * 0.15);
-        const msgCount = this.messages.length || 1;
-        const errorDensity = Math.max(0, 1 - Math.min(1, this.facts.errorCount / msgCount));
-        const freshness = Math.max(0, 1 - this.iterationsSinceCompaction / COMPACTION_INTERVAL);
-        const score = tokenLoad * 0.4 + compactionLoss * 0.25 + errorDensity * 0.2 + freshness * 0.15;
-        return Math.round(Math.min(100, Math.max(0, score * 100)));
-    }
-    addMessage(msg) {
-        // Track the task the agent is working on so it survives compaction. The
-        // user's real instruction is the FIRST non-system-summary user message of
-        // the turn; everything after it (tool results, retry nudges) are injected
-        // `user` envelopes that must not overwrite it (observed: after compaction
-        // the model had forgotten "удали /bicycles, почини стили" and re-read
-        // files aimlessly for 40+ iterations).
-        if (msg.role === "user") {
-            const text = typeof msg.content === "string" ? msg.content : getMessageText(msg.content);
-            if (text.trim() && !text.startsWith("<system-summary>") && !text.includes("[Compressed:")) {
-                if (looksLikeErrorPaste(text) && (this.lastUserTask || this.sessionMission)) {
-                    this.lastUserFeedback = text.trim().slice(0, 400);
-                }
-                else if (!this.lastUserTask && !this.lastUserFeedback) {
-                    // No new task inside a turn that already captured an error/log paste:
-                    // the paste's follow-up messages are tool-result continuations, not a
-                    // fresh instruction, so the session mission must win at compaction.
-                    this.lastUserTask = text.trim();
-                    if (!this.sessionMission)
-                        this.sessionMission = text.trim();
-                }
-            }
-        }
-        // Auto-attach pending images to the next user message
-        if (msg.role === "user" && this.pendingImageParts.length > 0) {
-            const textPart = {
-                type: "text",
-                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
-            };
-            msg = {
-                ...msg,
-                content: [textPart, ...this.pendingImageParts],
-            };
-            this.pendingImageParts = [];
-        }
-        this.messages.push(msg);
-        const tokens = this.getEstimatedTokens();
-        if (tokens > this.peakTokens)
-            this.peakTokens = tokens;
-    }
-    /**
-     * Queue an image part to be attached to the next user message.
-     */
-    addPendingImage(part) {
-        this.pendingImageParts.push(part);
-    }
-    /**
-     * Check if there are pending images waiting to be attached.
-     */
-    hasPendingImages() {
-        return this.pendingImageParts.length > 0;
-    }
-    /**
-     * Get pending image parts without clearing them.
-     */
-    getPendingImages() {
-        return [...this.pendingImageParts];
-    }
-    /**
-     * Clear pending images (e.g., if user sends a text-only message).
-     */
-    clearPendingImages() {
-        this.pendingImageParts = [];
-    }
-    getMessageCount() {
-        return this.messages.length;
-    }
-    estimateMessageTokens(m) {
-        const text = getMessageText(m.content);
-        if (this.tokenCounter) {
-            let t = this.tokenCounter.count(text);
-            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
-            if (Array.isArray(m.content)) {
-                for (const part of m.content) {
-                    if (part.type === "image_url" && part.image_url?.url) {
-                        const b64Len = part.image_url.url.includes(",")
-                            ? (part.image_url.url.split(",")[1]?.length ?? 0)
-                            : part.image_url.url.length;
-                        // ~130 tokens per 512 bytes of base64
-                        t += Math.ceil(b64Len / 512) * 130;
-                    }
-                }
-            }
-            if (m.tool_calls) {
-                for (const tc of m.tool_calls) {
-                    t += this.tokenCounter.count(tc.id);
-                    t += this.tokenCounter.count(tc.function.name);
-                    t += this.tokenCounter.count(tc.function.arguments);
-                    t += 4;
-                }
-            }
-            return t;
-        }
-        let t = Math.ceil(text.length / 2);
-        if (Array.isArray(m.content)) {
-            for (const part of m.content) {
-                if (part.type === "image_url" && part.image_url?.url) {
-                    const b64Len = part.image_url.url.includes(",")
-                        ? (part.image_url.url.split(",")[1]?.length ?? 0)
-                        : part.image_url.url.length;
-                    t += Math.ceil(b64Len / 512) * 130;
-                }
-            }
-        }
-        if (m.tool_calls) {
-            for (const tc of m.tool_calls) {
-                t += Math.ceil(tc.id.length / 2);
-                t += Math.ceil(tc.function.name.length / 2);
-                t += Math.ceil(tc.function.arguments.length / 2);
-                t += 4;
-            }
-        }
-        return t;
-    }
-    needsCompaction() {
-        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
-            return true;
-        const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
-        return totalTokens > this.budget.history * this.compactionThreshold;
-    }
-    compact() {
-        // Capture the pre-compaction state BEFORE any counters reset or rise —
-        // qualityBefore must reflect the context the model actually saw.
-        const tokensBefore = this.getEstimatedTokens();
-        const qualityBefore = this.getQuality();
-        const messagesBefore = this.messages.length;
-        // Reset the counter even when nothing to compact — otherwise
-        // needsCompaction() returns true forever after 15 iterations with few messages.
-        this.iterationsSinceCompaction = 0;
-        if (this.messages.length <= KEEP_LAST_N * 2)
-            return null;
-        this.compactionCount++;
-        const cutoff = this.messages.length - KEEP_LAST_N * 2;
-        const oldTurns = this.messages.slice(0, cutoff);
-        const recentTurns = this.messages.slice(cutoff);
-        this.facts.extract(oldTurns);
-        const parts = [];
-        parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        // Carry the user's actual instruction forward — the model must never lose
-        // the task it is working on just because 40 turns got compacted away. The
-        // per-turn task falls back to the session mission (first real instruction)
-        // so a pasted error/log in the current turn cannot erase the goal.
-        const task = (this.lastUserTask || this.sessionMission).slice(0, 400);
-        if (task)
-            parts.push(`[Task: ${task}]`);
-        if (this.lastUserFeedback && !task.startsWith(this.lastUserFeedback)) {
-            parts.push(`[User feedback: ${this.lastUserFeedback}]`);
-        }
-        // Orient the model after compaction: an active plan must not be re-created
-        // from scratch (see planSummaryProvider doc).
-        const planLine = this.planSummaryProvider?.();
-        if (planLine)
-            parts.push(`[Plan: ${planLine}]`);
-        const filesLine = this.facts.filesLine();
-        if (filesLine)
-            parts.push(filesLine);
-        const deletedLine = this.facts.deletedLine();
-        if (deletedLine)
-            parts.push(deletedLine);
-        const readLine = this.facts.readLine();
-        if (readLine)
-            parts.push(readLine);
-        const decisionsLine = this.facts.decisionsLine();
-        if (decisionsLine)
-            parts.push(decisionsLine);
-        const errorsLine = this.facts.errorsLine();
-        if (errorsLine)
-            parts.push(errorsLine);
-        const triedAndFailed = extractTriedAndFailed(oldTurns);
-        if (triedAndFailed.length > 0) {
-            const lines = triedAndFailed.map((t) => `- ${t.tool}(${t.args}): ${t.error} (failed ${t.count}x)`);
-            parts.push(`[Already tried & failed — do NOT repeat:]\n${lines.join("\n")}`);
-        }
-        this.compactedBlock = parts.join(" ");
-        const summary = {
-            role: "user",
-            content: `<system-summary>${this.compactedBlock}</system-summary>`,
-        };
-        const firstSystem = this.messages.find((m) => m.role === "system");
-        // Filter out stale system-summary messages from recent turns to prevent nesting
-        const freshRecent = recentTurns.filter((m) => {
-            if (m.role !== "user")
-                return true;
-            const text = getMessageText(m.content);
-            return !text.startsWith("<system-summary>");
-        });
-        this.messages = [...(firstSystem ? [firstSystem] : []), summary, ...freshRecent];
-        this.iterationsSinceCompaction = 0;
-        if (this.onCompact) {
-            this.onCompact(summary);
-        }
-        return {
-            removedTurns: oldTurns.length,
-            keptTurns: freshRecent.length,
-            tokensBefore,
-            tokensAfter: this.getEstimatedTokens(),
-            qualityBefore,
-            qualityAfter: this.getQuality(),
-            messagesBefore,
-            messagesAfter: this.messages.length,
-            summary: this.compactedBlock ?? "",
-        };
-    }
-    /**
-     * Snapshot of the current context state — used to log the initial context
-     * structure at session start and per-iteration context stats.
-     */
-    getSnapshot() {
-        return {
-            window: this.contextWindow,
-            budget: { ...this.budget },
-            tokens: this.getEstimatedTokens(),
-            toolTokens: this.toolTokens,
-            messageCount: this.messages.length,
-            quality: this.getQuality(),
-            compactionCount: this.compactionCount,
-            iterationsSinceCompaction: this.iterationsSinceCompaction,
-        };
-    }
-    /**
-     * Replace the system prompt in place (keeps it first) or prepend a new one.
-     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
-     */
-    updateSystemPrompt(content) {
-        const idx = this.messages.findIndex((m) => m.role === "system");
-        if (idx >= 0) {
-            this.messages[idx] = { ...this.messages[idx], content };
-        }
-        else {
-            this.messages.unshift({ role: "system", content });
-        }
-    }
-    getActiveHistory() {
-        return [...this.messages];
-    }
-    /**
-     * Reset everything that belongs to the current conversation turn.
-     * Fact lists (FactExtractor) intentionally survive clear() — they are
-     * session-scoped compaction state, not per-turn.
-     */
-    clear() {
-        this.messages = [];
-        this.compactedBlock = null;
-        this.iterationsSinceCompaction = 0;
-        this.compactionCount = 0;
-        this.peakTokens = 0;
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-        this.sessionMission = "";
-    }
-    getEstimatedTokens() {
-        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) + this.toolTokens);
-    }
-    setToolTokens(tokens) {
-        this.toolTokens = tokens;
-    }
-    resize(contextWindow, contextBudget, tokenCounter) {
-        this.contextWindow = contextWindow;
-        this.budget = this.calculateBudget(contextWindow, contextBudget);
-        if (tokenCounter !== undefined) {
-            this.tokenCounter = tokenCounter ?? null;
-        }
-    }
-}