teapot-coding-agent 0.27.1 → 0.27.2

package/dist/agent/agent.js

@@ -439,7 +439,26 @@ export class Agent {
      * (#59) — the same trap #38 documented for editing history.
      */
     isLive() {
-        return this.status === "running" || this.parkedByTool || this.pendingPrompts.length > 0;
+        // #127: a MANUAL compaction on an idle agent was rewriting `messages` — a
+        // large, non-cancellable operation — while `isLive()` reported false, so the
+        // UI offered "start".
+        //
+        // #133: and the reverse — after a STOP with prompts still queued, `live` stayed
+        // true forever, so the controls kept offering "stop" for an agent that was
+        // already stopped, and no amount of reloading helped. Measured:
+        //
+        //   after stop : status = stopped   live = true   pendingPrompts = 1
+        //
+        // A queued prompt is not work in progress: it is waiting for the operator to
+        // press start. #9 settled that a stop must neither deliver nor silently
+        // DISCARD those prompts, so they are kept — but keeping them must not make the
+        // agent read as running. A stop outranks them.
+        if (this.stopRequested)
+            return false;
+        return (this.status === "running" ||
+            this.parkedByTool ||
+            this.pendingPrompts.length > 0 ||
+            this.compactPhase !== "");
     }
     /**
      * A background shell (bash background=true) finished. Two channels:
@@ -2927,14 +2946,40 @@ export class Agent {
     }
     /** Ask the model for dense continuation notes over the compacted range. */
     async summarize(old, onDelta) {
-        const transcript = old
+        const full = old
             .map((m) => {
             const who = m.role === "tool" ? "tool" : m.role;
             const tc = m.tool_calls?.map((t) => `\n[calls ${t.function.name}(${t.function.arguments})]`).join("");
             return `${who}: ${m.content ?? ""}${tc}`;
         })
-            .join("\n\n")
-            .slice(-120_000);
+            .join("\n\n");
+        // #127: this was a bare `.slice(-120_000)` — the TAIL only.
+        //
+        // The question the issue raises is the right one: when a compaction starts,
+        // the context window opens dramatically, and the summarizer saw only the last
+        // 120k characters of what it was asked to summarise. Anything older was not
+        // summarised and not kept — it was silently DISCARDED. So the original user
+        // requirement, which sits at the very front of the history, was the single
+        // most likely thing to be lost, and losing it is the one failure compaction
+        // cannot recover from: the summary is now the only record.
+        //
+        // Head + tail, with the seam marked so the model can tell a gap from a
+        // boundary. The head is where the goal, the constraints and the original ask
+        // live; the tail is where the recent state and any in-flight error do.
+        const BUDGET = 120_000;
+        const HEAD = Math.floor(BUDGET * 0.35);
+        const TAIL = BUDGET - HEAD;
+        let transcript;
+        if (full.length <= BUDGET) {
+            transcript = full;
+        }
+        else {
+            transcript = [
+                full.slice(0, HEAD),
+                `\n\n[... ${full.length - BUDGET} characters elided from the middle of this history ...]\n\n`,
+                full.slice(full.length - TAIL),
+            ].join("");
+        }
         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

package/package.json

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