teapot-coding-agent 0.21.0 → 0.22.1

package/dist/agent/agent.js

@@ -10,7 +10,7 @@ import { promises as fs, existsSync, readFileSync, readdirSync, statSync } from
 import path from "node:path";
 import { EventLog, readEvents } from "../log/events.js";
 import { chat, chatStream } from "./llm.js";
-import { executeTool, toolSpecs, currentSkills } from "./tools.js";
+import { executeTool, toolSpecs, currentSkills, safeJoin, isContextOverflow } from "./tools.js";
 import { bus } from "../bus.js";
 /**
  * SYSTEM_TEMPLATE must stay byte-identical across every request of a session:
@@ -171,6 +171,7 @@ export class Agent {
             onIdlePark: (reason) => this.parkForTool(reason),
             onIdleUnpark: () => this.unparkFromTool(),
             onBackgroundExit: (info) => void this.onBackgroundJobExit(info),
+            onFileRead: (p) => this.trackFileRead(p),
         };
         // the session id IS the directory name — one directory per incarnation
         this.mainSession = path.basename(opts.sessionDir);
@@ -265,6 +266,11 @@ export class Agent {
      *    agent learns exit code + output tail WITHOUT having to poll
      *    bash_output blindly. Failed jobs say so loudly so the model reacts.
      */
+    /** recently read workspace files (most recent first) — post-compact restore */
+    recentReads = [];
+    trackFileRead(p) {
+        this.recentReads = [p, ...this.recentReads.filter((x) => x !== p)].slice(0, 5);
+    }
     onBackgroundJobExit(info) {
         const ok = info.code === 0;
         const one = info.cmd.replace(/\s+/g, " ").slice(0, 80);
@@ -1182,6 +1188,25 @@ export class Agent {
                         detail: "stopped before any output arrived",
                     });
                 }
+                // Provider context overflow → compact ONCE and retry the turn
+                // (OpenCode-style overflow recovery). even with autoCompact off, an
+                // actual overflow is proof the estimate missed; a second overflow is
+                // returned as a real error instead of looping.
+                if (isContextOverflow(err) && !this.stopRequested) {
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "overflow-recovery",
+                        detail: String(err.message).slice(0, 200),
+                    });
+                    const before = this.stats.compactions;
+                    await this.maybeCompact(true);
+                    if (this.stats.compactions > before) {
+                        await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                            event: "overflow-recovered",
+                        });
+                        guard--; // the retry does not count against this round's cap
+                        continue;
+                    }
+                }
                 throw err;
             }
             if (res.usage) {
@@ -1619,10 +1644,30 @@ export class Agent {
                 await this.setGoalStatus("done");
             }
         }
+        // Capture the last few conversation turns BEFORE the final marker so the
+        // parent gets real substance (findings, file paths, numbers), not just
+        // whatever the model typed into the finish() summary argument.
+        const recent = [];
+        for (let i = this.messages.length - 1; i >= 0 && recent.length < 6; i--) {
+            const m = this.messages[i];
+            if (m.role === "user")
+                continue; // prompts/noise — keep agent output only
+            if (m.role === "assistant" && !(m.content ?? "").trim())
+                continue;
+            const who = m.role === "tool" ? "tool" : m.role;
+            let line = `[${who}] ${(m.content ?? "").trim()}`;
+            if (m.role === "tool") {
+                // tool results are prefixed "(failed)" by the logger when they fail —
+                // the raw content is what matters here, and cap hard: these can be huge
+                line = `[${who}] ${(m.content ?? "").trim().slice(0, 1200)}`;
+            }
+            recent.unshift(line.slice(0, 1500));
+        }
         await this.log.append("message", this.currentSession, this.currentBranch, {
             role: "assistant",
             final: true,
             content: String(args.summary ?? ""),
+            ...(recent.length ? { recentContext: recent } : {}),
         });
     }
     async maybeRequestProgress() {
@@ -1772,14 +1817,33 @@ export class Agent {
                 break;
         }
         const PRUNE_MIN = 3_000;
+        // Tool-kind aware pruning (Claude Code MicroCompact style): high-volume,
+        // REPRODUCIBLE results (file reads, shell, grep) are safe to clip because
+        // the model can re-issue them; one-shot results (spawned agent reports,
+        // web fetches) are kept — re-fetching is impossible or expensive.
+        const PRUNABLE_TOOLS = new Set([
+            "bash", "read_file", "list_dir", "grep", "glob", "write_file", "edit_file", "apply_patch",
+            "bash_output",
+        ]);
         let saved = 0;
         let count = 0;
+        // callId → tool name, from the assistant turn that issued each call
+        // (a tool result's PREVIOUS message is not reliably its caller when
+        // parallel calls interleave)
+        const callerTool = new Map();
+        for (const m of this.messages) {
+            for (const t of m.tool_calls ?? [])
+                callerTool.set(t.id, t.function.name);
+        }
         for (let i = 0; i < boundary; i++) {
             const m = this.messages[i];
-            if (m.role === "tool" && (m.content?.length ?? 0) > PRUNE_MIN) {
+            const toolName = m.tool_call_id ? callerTool.get(m.tool_call_id) ?? "" : "";
+            if (m.role === "tool" &&
+                PRUNABLE_TOOLS.has(toolName) &&
+                (m.content?.length ?? 0) > PRUNE_MIN) {
                 const len = m.content.length;
                 saved += len - 400;
-                m.content = m.content.slice(0, 400) + `\n…[pruned ${len} bytes of tool output]`;
+                m.content = m.content.slice(0, 400) + `\n…[pruned ${len} bytes of ${toolName || "tool"} output]`;
                 count++;
             }
         }
@@ -1883,6 +1947,31 @@ export class Agent {
         const after = this.estimateTokens();
         this.stats.compactions++;
         this.compactedAtLen = this.messages.length;
+        // Post-compact file restore (Claude Code style): re-attach the most
+        // recently read files so the model doesn't burn its first turns re-reading
+        // exactly what it had in context a moment ago. Budget: 3 files × 400 lines.
+        if (this.recentReads.length && mode === "summarize") {
+            const restored = [];
+            for (const rel of this.recentReads.slice(0, 3)) {
+                try {
+                    const abs = safeJoin(this.opts.workspace, rel);
+                    const text = await fs.readFile(abs, "utf8");
+                    const head = text.split("\n").slice(0, 400).join("\n");
+                    restored.push(`--- ${rel}${text.length > head.length ? " (first 400 lines)" : ""} ---\n${head}`);
+                }
+                catch {
+                    /* file vanished since the read — skip */
+                }
+            }
+            if (restored.length) {
+                this.messages.splice(1, 0, {
+                    role: "user",
+                    content: `[harness] These files were recently read and are re-attached for continuity ` +
+                        `(they may have changed — re-read if precision matters):\n\n${restored.join("\n\n")}`,
+                });
+                this.recentReads = this.recentReads.slice(0, restored.length); // keep order, drop misses
+            }
+        }
         // the operator can inspect WHAT was remembered — a dedicated typed event
         // (not an agent message) keeps it out of the model's own voice
         await this.log.append("compaction", this.currentSession, this.currentBranch, {
@@ -1915,21 +2004,44 @@ export class Agent {
             .join("\n\n")
             .slice(-120_000);
         const fn = this.opts.chatFn ?? chat;
+        // Structured sections (Claude Code style): fixed headings survive MULTIPLE
+        // successive compactions far better than free-form prose — each pass knows
+        // where "pending tasks" vs "user messages" live, so nothing silently
+        // merges away. The <analysis> scratchpad gives the model a thinking space;
+        // it is stripped from the stored summary (formatCompactSummary).
         const res = await fn(this.opts.llm, [
             {
                 role: "system",
-                content: "You compress a coding agent's conversation into dense notes for it to continue working. " +
-                    "Preserve: current goal state, key decisions AND the reasoning behind them, files created/changed, " +
-                    "important command results, open problems, and the next step. Be terse bullet points, no prose flourishes. " +
-                    'Finish with a section "## Durable lessons" listing reusable insights worth keeping forever ' +
-                    "(gotchas, user preferences, what worked) — or omit the section if there are none.",
+                content: "You compress a coding agent's conversation into dense notes for it to continue working.\n\n" +
+                    "First think inside an <analysis> block: what mattered, what changed, what is unresolved.\n" +
+                    "Then output ONLY the following sections, each starting with its exact heading:\n\n" +
+                    "## Primary request and intent\n" +
+                    "## Key technical concepts\n" +
+                    "## Files and code sections\n" +
+                    "## Errors and fixes\n" +
+                    "## Problem solving\n" +
+                    "## All user messages\n" + // verbatim-ish: intent survives repeated compaction
+                    "## Pending tasks\n" +
+                    "## Current work\n" +
+                    "## Next step\n" +
+                    "## Durable lessons\n\n" +
+                    "Rules: be terse bullet points, no prose flourishes. Quote file paths and key numbers exactly. " +
+                    "All user messages are listed nearly verbatim — they carry intent that must survive every future compaction. " +
+                    'Durable lessons lists reusable insights worth keeping forever (gotchas, preferences, what worked); omit the section if empty. ' +
+                    "The <analysis> block is discarded before your notes are stored, so think freely there.",
             },
             { role: "user", content: `Conversation:\n\n${transcript}\n\nWrite the continuation notes now.` },
         ], [], undefined, // never abortable by stop(): losing the summary would lose history
         onDelta
             ? (s) => onDelta(s.text)
             : undefined);
-        return res.message.content ?? "";
+        return this.formatCompactSummary(res.message.content ?? "");
+    }
+    /** strip the <analysis> scratchpad — it improves thinking but must not
+        consume post-compact context tokens */
+    formatCompactSummary(raw) {
+        const m = raw.match(/<analysis>[\s\S]*?<\/analysis>\s*/);
+        return m ? raw.slice(m[0].length).trim() : raw.trim();
     }
     /**
      * Extract the "## Durable lessons" block from a compaction summary and

package/dist/agent/tools.js

@@ -103,6 +103,12 @@ function startBackgroundShell(cmd, ctx) {
     map.set(id, sh);
     return id;
 }
+/** Heuristic: did this provider error mean "prompt exceeded the context window"?
+ *  Wording varies by provider (OpenRouter/OpenAI/Anthropic/local servers). */
+export function isContextOverflow(err) {
+    const msg = String(err?.message ?? "").toLowerCase();
+    return (/context (length|window|limit)|too many tokens|prompt is too long|max.{0,12}tokens.{0,20}(exceed|surpass)|request too large|payload too large|exceeds.{0,20}limit/.test(msg) || /\b(400|413)\b.*token/.test(msg));
+}
 /** Run a command in its own process group; kill the whole group on timeout. */
 function runShell(cmd, ctx, timeoutMs) {
     return new Promise((resolve) => {
@@ -515,6 +521,7 @@ export const TOOLS = [
         async run(args, ctx) {
             const p = safeJoin(ctx.cwd, str(args.path));
             const text = await readText(p);
+            ctx.onFileRead?.(str(args.path));
             const lines = text.split("\n");
             // grep mode
             if (typeof args.pattern === "string" && args.pattern !== "") {

package/dist/master.js

@@ -666,8 +666,18 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             return;
         // forward outcomes so the parent hears the result without polling
         if (e.type === "message" && e.data.final) {
-            const summary = String(e.data.content ?? "").trim();
-            parent.enqueuePrompt(`[harness] Sub-agent ${ac.id} finished. Final report:\n${summary.slice(0, 2000) || "(no summary)"}`, "harness");
+            const d = e.data;
+            const summary = String(d.content ?? "").trim();
+            // the finish() summary alone is often thin — the agent's last few real
+            // conversation turns (findings, paths, numbers) carry the substance.
+            // Include them so the parent can act without re-reading the child log.
+            let report = summary;
+            if (Array.isArray(d.recentContext) && d.recentContext.length) {
+                report +=
+                    "\n\n[Last conversation turns before finishing]\n" +
+                        d.recentContext.map((r) => r).join("\n\n");
+            }
+            parent.enqueuePrompt(`[harness] Sub-agent ${ac.id} finished. Final report:\n${report.slice(0, 6000) || "(no summary)"}`, "harness");
         }
         else if (e.type === "error") {
             parent.enqueuePrompt(`[harness] Sub-agent ${ac.id} hit an error: ${String(e.data.message ?? "").slice(0, 500)}`, "harness");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",