micro-models-agent 0.40.1 → 0.41.2

package/dist/modules/context/chunk-query.js

@@ -0,0 +1,100 @@
+export const DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text. Be concise. If the text does not contain the answer, say "NO_EVIDENCE".';
+export const DEFAULT_SYNTHESIS_SYSTEM_PROMPT = "You are given a query and per-chunk answers over a large text. Produce the final answer to the query, combining evidence from the chunks. If no chunk had evidence, say so.";
+/** Split text into newline-aware chunks, each <= chunkChars chars. */
+export function splitTextIntoChunks(text, chunkChars) {
+    if (chunkChars <= 0)
+        throw new Error("chunkChars must be > 0");
+    if (text.length <= chunkChars)
+        return [text];
+    const lines = text.split("\n");
+    const chunks = [];
+    let current = [];
+    let size = 0;
+    for (const line of lines) {
+        if (current.length > 0 && size + line.length + 1 > chunkChars) {
+            chunks.push(current.join("\n"));
+            current = [];
+            size = 0;
+        }
+        current.push(line);
+        size += line.length + 1;
+    }
+    if (current.length > 0)
+        chunks.push(current.join("\n"));
+    return chunks;
+}
+async function chatText(provider, messages, maxTokens, reasoningEffort) {
+    let out = "";
+    for await (const chunk of provider.chat(messages, undefined, undefined, {
+        maxTokens,
+        reasoningEffort,
+    })) {
+        if (chunk.type === "text" && chunk.content)
+            out += chunk.content;
+    }
+    return out;
+}
+/**
+ * RLM-style llm_query: answer `query` over `text` by chunking and querying the
+ * model per chunk with a fixed system prompt (KV-cache friendly), bounded
+ * concurrency, and an optional synthesis pass.
+ */
+export async function runChunkQuery(provider, text, query, opts = {}) {
+    const chunkChars = opts.chunkChars ?? 12000;
+    const maxParallel = Math.max(1, opts.maxParallel ?? 4);
+    const maxChunkTokens = opts.maxChunkTokens ?? 1024;
+    const maxSynthesisTokens = opts.maxSynthesisTokens ?? 2048;
+    const reasoningEffort = opts.reasoningEffort ?? "none";
+    const chunks = splitTextIntoChunks(text, chunkChars);
+    const answers = new Array(chunks.length);
+    const chunkSystem = opts.querySystemPrompt ?? DEFAULT_CHUNK_SYSTEM_PROMPT;
+    const logger = opts.logger;
+    if (chunks.length === 1) {
+        logger?.debug(`runChunkQuery: single chunk (${text.length} chars), no chunking needed`);
+    }
+    else {
+        logger?.debug(`runChunkQuery: ${chunks.length} chunks over ${text.length} chars (chunkChars=${chunkChars}, maxParallel=${maxParallel})`);
+    }
+    let cursor = 0;
+    let inFlight = 0;
+    let maxParallelObserved = 0;
+    const workers = Array.from({ length: Math.min(maxParallel, chunks.length) }, async () => {
+        while (cursor < chunks.length) {
+            const idx = cursor++;
+            inFlight++;
+            maxParallelObserved = Math.max(maxParallelObserved, inFlight);
+            try {
+                answers[idx] = await chatText(provider, [
+                    { role: "system", content: chunkSystem },
+                    { role: "user", content: `Query: ${query}\n\nText:\n${chunks[idx]}` },
+                ], maxChunkTokens, reasoningEffort);
+            }
+            finally {
+                inFlight--;
+            }
+        }
+    });
+    await Promise.all(workers);
+    let synthesis = "";
+    if (opts.synthesize !== false && chunks.length > 0) {
+        const joined = answers
+            .map((a, i) => `--- Chunk ${i + 1}/${chunks.length} ---\n${a}`)
+            .join("\n\n");
+        logger?.debug(`runChunkQuery: synthesis pass over ${chunks.length} answers`);
+        synthesis = await chatText(provider, [
+            {
+                role: "system",
+                content: opts.synthesisSystemPrompt ?? DEFAULT_SYNTHESIS_SYSTEM_PROMPT,
+            },
+            { role: "user", content: `Query: ${query}\n\nChunk answers:\n${joined}` },
+        ], maxSynthesisTokens, reasoningEffort);
+    }
+    logger?.debug(`runChunkQuery: done, ${chunks.length} chunks, max parallel observed ${maxParallelObserved}, synthesis ${synthesis.length} chars`);
+    return {
+        chunks: chunks.length,
+        answers,
+        synthesis,
+        totalChars: text.length,
+        maxParallelObserved,
+    };
+}

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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,15 @@
+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 +1 @@
-export { ContextManager } from './manager';
+export { ContextManager } from "./manager";

package/dist/modules/context/manager.js

@@ -1,4 +1,5 @@
 import { getMessageText } from "../../llm/provider";
+import { FactExtractor } from "./fact-extractor";
 const COMPACTION_INTERVAL = 15;
 const KEEP_LAST_N = 6;
 function summarizeArgs(args) {
@@ -19,15 +20,28 @@ function truncate(s, 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);
+            const errorText = truncate(typeof msg.content === "string" ? msg.content : getMessageText(msg.content), 100);
             if (existing) {
                 existing.count++;
             }
@@ -52,20 +66,38 @@ export class ContextManager {
     peakTokens = 0;
     budget;
     compactionThreshold;
-    fileFacts = [];
-    decisionFacts = [];
-    errorFacts = [];
-    static MAX_FACTS = 20;
+    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);
@@ -92,27 +124,67 @@ export class ContextManager {
     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);
-        const compactionLoss = Math.max(0, 1 - this.compactionCount * 0.15);
+        // 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.errorFacts.length / msgCount));
+        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;
+        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),
+                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
             };
             msg = {
                 ...msg,
@@ -206,27 +278,53 @@ export class ContextManager {
         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;
+            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.extractFacts(oldTurns);
+        this.facts.extract(oldTurns);
         const parts = [];
         parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        if (this.fileFacts.length > 0) {
-            parts.push(`[Files: ${this.fileFacts.slice(-15).join("; ")}]`);
-        }
-        if (this.decisionFacts.length > 0) {
-            parts.push(`[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`);
-        }
-        if (this.errorFacts.length > 0) {
-            parts.push(`[Errors: ${this.errorFacts.slice(-3).join("; ")}]`);
+        // 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)`);
@@ -245,69 +343,38 @@ export class ContextManager {
             const text = getMessageText(m.content);
             return !text.startsWith("<system-summary>");
         });
-        this.messages = [
-            ...(firstSystem ? [firstSystem] : []),
-            summary,
-            ...freshRecent,
-        ];
+        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 ?? "",
+        };
     }
-    extractFacts(turns) {
-        const filePatterns = [
-            /(?:Created|Updated|Written|Deleted|Moved) ([\w./\\-]+\.[a-z]+)/gi,
-            /Файл (?:создан|обновлён|записан|удалён|перемещён):? ([\w./\\-]+\.[a-z]+)/gi,
-            /file (?:created|updated|written|deleted|moved):? ([\w./\\-]+\.[a-z]+)/gi,
-        ];
-        const newFiles = [];
-        const newDecisions = [];
-        const newErrors = [];
-        for (const msg of turns) {
-            const content = getMessageText(msg.content);
-            if (msg.role === "tool") {
-                for (const pattern of filePatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newFiles.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 (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
-        const dedup = (arr) => [...new Set(arr)];
-        this.fileFacts = dedup([...this.fileFacts, ...newFiles]).slice(-ContextManager.MAX_FACTS);
-        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-ContextManager.MAX_FACTS);
-        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-ContextManager.MAX_FACTS);
+    /**
+     * 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.
@@ -325,16 +392,23 @@ export class ContextManager {
     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);
+        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) + this.toolTokens);
     }
     setToolTokens(tokens) {
         this.toolTokens = tokens;