teapot-coding-agent 0.18.2 → 0.19.1

package/dist/agent/agent.js

@@ -107,6 +107,8 @@ export class Agent {
     lastUsage;
     /** messages.length right after the last successful compaction */
     compactedAtLen = 0;
+    /** live compaction phase for UI progress ("summarizing"/"harvesting") */
+    compactPhase = "";
     /** set by ask_user: the loop is parked until the operator replies */
     awaitingUser = false;
     /** real assistant output since the last progress report (chars / turns) */
@@ -122,6 +124,7 @@ export class Agent {
             continueDelayMs: 15_000,
             autoCompact: true,
             maxConsecutiveToolErrors: 5,
+            maxTurnsPerRound: 200,
             contextTokenBudget: 96_000,
             contextWindowTokens: 0,
             restoreSession: true,
@@ -675,6 +678,9 @@ export class Agent {
                 // mislabeling every inferred-window model "manual override"
                 compactAtIsManual: this.compactBudgetIsManual,
                 window: this.opts.contextWindowTokens || 0,
+                // live compaction phase ("summarizing"/"harvesting"/"done") — lets any
+                // client show progress even if it missed the bus event
+                ...(this.compactPhase ? { compacting: this.compactPhase } : {}),
             },
             pendingPrompts: this.pendingPrompts.length,
             todo: this.todo.slice(0, 32_000), // match set_todo's cap — no silent truncation
@@ -833,7 +839,37 @@ export class Agent {
     async loop() {
         while (!this.stopRequested) {
             try {
-                const finished = await this.runTurnsUntilIdle();
+                const turnsAtStart = this.stats.turns;
+                let finished = await this.runTurnsUntilIdle();
+                // the round ended on the per-round turn cap (not finish/stop): tell
+                // the model to report and wrap up, then fall through to auto-continue
+                // — a soft checkpoint instead of the old hard runaway error
+                const cap = Math.max(0, this.opts.maxTurnsPerRound ?? 200);
+                if (!finished &&
+                    cap > 0 &&
+                    this.stats.turns - turnsAtStart >= cap &&
+                    !this.stopRequested &&
+                    !this.awaitingUser &&
+                    !this.pendingPrompts.length // real user input outranks the wrap-up nudge
+                ) {
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "round-turn-cap",
+                        turns: cap,
+                    });
+                    await this.maybeRequestProgress();
+                    const nudge = `[harness] This round ran ${cap} turns, so it ends here. ` +
+                        "Report progress via report_progress now; then either call finish() if the goal is met, " +
+                        "or state exactly where you will resume. Work CONTINUES in the next round automatically.";
+                    this.messages.push({ role: "user", content: nudge });
+                    await this.log.append("prompt", this.currentSession, this.currentBranch, {
+                        source: "harness",
+                        text: nudge,
+                    });
+                    // the wrap-up nudge IS this round's continuation prompt — starting
+                    // another round on top of it would stack a generic auto-continue
+                    // nudge too, so go straight to the next round instead
+                    continue;
+                }
                 if (this.stopRequested)
                     break;
                 // fresh user input arrived while we were finishing up — another round now
@@ -935,7 +971,12 @@ export class Agent {
      */
     async runTurnsUntilIdle() {
         let finished = false;
-        for (let guard = 0; guard < 200; guard++) {
+        // maxTurnsPerRound is a SOFT cap (0 disables): reaching it nudges the
+        // model to wrap up instead of hard-failing the round — long autonomous
+        // stretches are normal here, and a throw used to leave status=error with
+        // no auto-recovery even though autoContinue would happily keep going.
+        const cap = Math.max(0, this.opts.maxTurnsPerRound ?? 200);
+        for (let guard = 0; cap === 0 || guard < cap; guard++) {
             if (this.stopRequested)
                 return finished;
             // deliver prompts queued while the previous turn was running
@@ -1244,7 +1285,9 @@ export class Agent {
             if (finished)
                 return true;
         }
-        throw new Error("runaway detection: too many turns in one round (>200)");
+        // cap reached — loop() logs the note, asks for a progress report and
+        // nudges the model; this round simply ends (no hard error)
+        return finished;
     }
     buildMessages() {
         // deliberately static: [system] + append-only history keeps prefix caches hot
@@ -1330,20 +1373,48 @@ export class Agent {
             text: request,
         });
         this.messages.push({ role: "user", content: request });
-        const res = await this.llmCall(this.buildMessages(), []); // no tools: pure report
-        await this.recordProgress(JSON.stringify({ freeform: res.message.content }));
-        // The report's content is ALREADY shown by the progress embed — logging a
-        // plain assistant message with the same text made the timeline show every
-        // requested report twice. Keep logging it (session restores replay the
-        // exchange faithfully and rebuildMessages needs it) but mark it as an echo;
-        // the web UI filters marked rows out.
+        // Give the model the report_progress TOOL here. The old no-tools call
+        // made the model answer in plain text while its own mental "did I report?"
+        // ledger stayed unsolved — it then re-sent a voluntary report_progress
+        // right after, and the timeline showed every requested report TWICE.
+        const res = await this.llmCall(this.buildMessages(), allToolSpecs());
+        const calls = res.message.tool_calls ?? [];
+        // the assistant turn MUST enter history before its tool answers, or the
+        // sequence [user, tool] is invalid and every later request 400s
+        this.messages.push(res.message);
         await this.log.append("message", this.currentSession, this.currentBranch, {
             role: "assistant",
             content: res.message.content ?? "",
             reasoning: res.reasoning,
+            ...(calls.length ? { toolCalls: calls.map((c) => ({ id: c.id, name: c.function.name })) } : {}),
             progressEcho: true,
         });
-        this.messages.push(res.message);
+        let reported = calls.some((c) => c.function.name === "report_progress");
+        for (const call of calls) {
+            if (call.function.name === "report_progress") {
+                await this.recordProgress(call.function.arguments);
+            }
+            this.messages.push({ role: "tool", tool_call_id: call.id, content: "progress recorded" });
+            // log both sides so restores replay the exact exchange (meta-style)
+            await this.log.append("tool_call", this.currentSession, this.currentBranch, {
+                callId: call.id,
+                name: call.function.name,
+                args: safeParse(call.function.arguments),
+                argsRaw: call.function.arguments,
+            });
+            await this.log.append("tool_result", this.currentSession, this.currentBranch, {
+                callId: call.id,
+                name: call.function.name,
+                ok: true,
+                durationMs: 0,
+                result: "progress recorded",
+            });
+        }
+        if (!reported && !(res.message.content ?? "").trim()) {
+            // degenerate: neither a tool call nor prose — record a stub so the
+            // operator sees SOMETHING at the requested moment
+            await this.recordProgress(JSON.stringify({ freeform: "(no report produced)" }));
+        }
     }
     /* ---------- context compaction ---------- */
     /**
@@ -1480,15 +1551,34 @@ export class Agent {
         }
         cut = this.safeCut(cut);
         if (cut <= 0)
-            return; // nothing safely compactable (should not happen)
+            return; // nothing safely compactable (phase never armed yet)
         const old = this.messages.slice(0, cut);
         const oldCount = old.length;
         let summary = "";
         let mode = "summarize";
         let summarizedCount = oldCount;
         let droppedCount = 0;
+        // progress is visible: announce the phase up front, then stream the
+        // summarizer's output as it generates (a long summarize used to look like
+        // the agent silently hung — hundreds of thousands of tokens take a while)
+        bus.emit("update", {
+            kind: "compaction-progress",
+            agentId: this.opts.id,
+            phase: "summarizing",
+            summarized: oldCount,
+        });
+        this.compactPhase = "summarizing";
         try {
-            summary = await this.summarize(old);
+            summary = await this.summarize(old, (text) => {
+                bus.emit("update", {
+                    kind: "llm-delta",
+                    agentId: this.opts.id,
+                    text: `[compact] ${text}`,
+                    reasoning: "",
+                });
+            });
+            this.compactPhase = "harvesting";
+            bus.emit("update", { kind: "compaction-progress", agentId: this.opts.id, phase: "harvesting" });
             if (summary)
                 await this.harvestLessons(summary); // durable knowledge → memory.md
         }
@@ -1502,8 +1592,11 @@ export class Agent {
             mode = "truncate";
             summarizedCount = 0;
             const halfCut = this.safeCut(Math.floor(oldCount / 2));
-            if (halfCut <= 0)
+            if (halfCut <= 0) {
+                this.compactPhase = "";
+                bus.emit("update", { kind: "compaction-progress", agentId: this.opts.id, phase: "done" });
                 return;
+            }
             droppedCount = halfCut;
             this.messages = this.messages.slice(halfCut);
         }
@@ -1539,9 +1632,11 @@ export class Agent {
             dropped: droppedCount,
             mode,
         });
+        this.compactPhase = "";
+        bus.emit("update", { kind: "compaction-progress", agentId: this.opts.id, phase: "done" });
     }
     /** Ask the model for dense continuation notes over the compacted range. */
-    async summarize(old) {
+    async summarize(old, onDelta) {
         const transcript = old
             .map((m) => {
             const who = m.role === "tool" ? "tool" : m.role;
@@ -1561,7 +1656,10 @@ export class Agent {
                     "(gotchas, user preferences, what worked) — or omit the section if there are none.",
             },
             { role: "user", content: `Conversation:\n\n${transcript}\n\nWrite the continuation notes now.` },
-        ], [], undefined);
+        ], [], undefined, // never abortable by stop(): losing the summary would lose history
+        onDelta
+            ? (s) => onDelta(s.text)
+            : undefined);
         return res.message.content ?? "";
     }
     /**
@@ -1961,6 +2059,30 @@ function rebuildMessagesFrom(list) {
             openCalls.delete(String(d.callId ?? ""));
             flushUsers();
         }
+        else if (e.type === "compaction") {
+            // A compaction REPLACED everything before this point with a summary.
+            // Replaying the raw prefix as well resurrected the full pre-compact
+            // history after every restart/fork (one live session came back at
+            // ~580k tokens after a 580k→207k compaction): the model re-read weeks
+            // of settled work it was told had been summarized, and its behavior
+            // fell apart. Mirror the runtime transform instead — the summary note
+            // becomes the history's head. Compactions only run at turn boundaries
+            // (serialized on the run chain), so no tool batch can be split here.
+            if (d.mode === "truncate") {
+                // `dropped` IS the number of leading messages the live pass removed
+                msgs.splice(0, Math.min(msgs.length, Number(d.dropped ?? 0)));
+            }
+            else {
+                const summarized = Math.min(msgs.length, Number(d.summarized ?? 0) || msgs.length);
+                const sum = typeof d.summary === "string" ? d.summary : "";
+                msgs.splice(0, summarized, {
+                    role: "user",
+                    content: `[harness] Context was compacted: ${summarized} earlier messages were summarized. ` +
+                        "Goal and notes are managed by the harness (AGENTS.md / memory.md are injected into your prompt when present).\n\n" +
+                        `## Summary of earlier conversation\n${sum || "(summary unavailable)"}`,
+                });
+            }
+        }
         else if (e.type === "progress") {
             // progress events may follow an assistant report_progress call that
             // has no logged tool result — patch it in when present

package/dist/config-schema.js

@@ -41,6 +41,9 @@ export const ConfigPatchSchema = z.object({
     contextTokenBudget: z.number().int().min(1_000).nullable().optional(),
     contextWindowTokens: z.number().int().min(1_000).optional(),
     maxSpawnDepth: z.number().int().min(0).max(8).optional(),
+    // soft cap on LLM turns in one round; reaching it nudges the model to wrap
+    // up (not an error) — 0 disables the cap
+    maxTurnsPerRound: z.number().int().min(0).optional(),
     tasks: z.array(TaskSchema).optional(),
 });
 /** Format a ZodError into a compact operator-readable message. */

package/dist/master.js

@@ -166,6 +166,8 @@ function printAgentEvent(e) {
                 line = `${c("33", "⟲ restore")} branch ${d.branch}, ${d.messages} messages`;
             else if (d.event === "model-changed")
                 line = `${c("33", "🧦 model")} → ${d.model} (${d.provider})`;
+            else if (d.event === "round-turn-cap")
+                line = `${c("33", "⏸ round cap")} ${d.turns} turns — nudging report + wrap-up, next round continues`;
             break;
         }
         default:
@@ -226,6 +228,8 @@ export class Master {
         }
         if (patch.maxSpawnDepth !== undefined)
             this.config.maxSpawnDepth = patch.maxSpawnDepth;
+        if (patch.maxTurnsPerRound !== undefined)
+            this.config.maxTurnsPerRound = patch.maxTurnsPerRound;
         if (patch.tasks) {
             this.config.tasks = patch.tasks;
             // rebuild schedule table live
@@ -375,6 +379,7 @@ export class Master {
             sessionDir,
             progressIntervalMs: this.config.progressIntervalMs,
             ...(this.config.progressMinChars ? { progressMinChars: this.config.progressMinChars } : {}),
+            ...(this.config.maxTurnsPerRound !== undefined ? { maxTurnsPerRound: this.config.maxTurnsPerRound } : {}),
             autoContinue: ac.autoContinue ?? true,
             ...(this.config.contextTokenBudget ? { contextTokenBudget: this.config.contextTokenBudget } : {}),
             ...(ac.contextWindowTokens || this.config.contextWindowTokens || inferredWindow

package/package.json

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