teapot-coding-agent 0.26.2 → 0.26.4

package/dist/agent/agent.js

@@ -88,6 +88,35 @@ Most session state is not injected into prompts — fetch it with tools instead:
   panel) — do NOT also repeat the same content as a chat message; end the
   turn right after the call (a short "reported." is fine).
 - Be frugal: prefer small precise edits, avoid runaway loops.`;
+/**
+ * A message whose ENTIRE text is parenthesised is an acknowledgement, not work.
+ *
+ * #94: the first version of this listed three literals — `(tool call)`,
+ * `(no content)`, `(no output)` — and caught 2 of the 10 forms actually reaching
+ * a parent. Measured across every session log, the rest are harness
+ * acknowledgements written by `answerMeta` and the meta-tool handlers:
+ *
+ *     (goal complete)  (round ended)  (tool try)  (no sub-agents)
+ *     (tool_call)      (nothing running to stop)  (no result recorded)
+ *     (todo.md is empty …)  (decisions.md is empty …)
+ *
+ * So it matches the SHAPE — a whole line wrapped in parentheses — rather than an
+ * enumeration that is stale the moment another ack is added.
+ *
+ * The trade: a genuine message that happens to be entirely parenthesised would
+ * also be dropped. That is vanishingly rare in this feed, and the alternative —
+ * an enumeration — was measured to be wrong 80% of the time. If it ever matters,
+ * the ack should be marked structurally rather than by its punctuation.
+ */ export const PLACEHOLDER_TEXT = /^\(.*\)$/;
+/**
+ * Harness acknowledgements — meta-lines about the run itself rather than the
+ * work ("decision recorded to decisions.md", "progress recorded", …).
+ *
+ * #94: these are addressed to the OPERATOR, not to whoever reads the next
+ * agent's report, and they consumed slots in a six-deep window that the parent
+ * reads as its only account of the work.
+ */
+export const HARNESS_ACK = /^(decision recorded|progress recorded|goal saved|feedback saved|memory saved|todo saved|no skills yet|skills created|read_memory|memory|\(tool call\)|\(no content\)|\(no output\)|true|false|null|none)\b/i;
 export class Agent {
     log;
     toolCtx;
@@ -1000,6 +1029,29 @@ export class Agent {
             // Bounded like the rest of the snapshot, and ids are opaque, so this
             // cannot carry prompt text.
             pendingPromptIds: this.pendingPrompts.map((p) => p.id).filter((x) => !!x).slice(0, 64),
+            // #87: the QUEUE itself, not just its ids. The UI's echo rows are
+            // memory-only (like liveByAgent and timelineCache), so after a reload the
+            // queue survives on the server while the UI has nothing to render — the
+            // queued message then appears only as its log row, i.e. already sent.
+            //
+            // Ids alone cannot fix that: they identify a prompt, they do not carry its
+            // text, so the UI cannot rebuild an echo from them. This is the queue the
+            // operator is looking at, already on screen in the ⏳ badge, so shipping it
+            // is not new exposure — it is the same data in a shape the timeline can
+            // use.
+            //
+            // `at` is the enqueue time so the echo keeps a stable position and id
+            // across rebuilds; `sent` mirrors the echo flag the UI already tracks.
+            pendingPromptQueue: this.pendingPrompts
+                .filter((p) => !!p.id)
+                .slice(0, 64)
+                .map((p, i) => ({
+                id: p.id,
+                text: p.text.slice(0, 8000),
+                source: p.source,
+                at: Date.now() - (this.pendingPrompts.length - i),
+                ...(p.images?.length ? { images: p.images.slice(0, 8) } : {}),
+            })),
             todo: this.todo.slice(0, 32_000), // match set_todo's cap — no silent truncation
             parent: this.opts.parent,
             awaiting: this.awaitingUser,
@@ -1234,6 +1286,8 @@ export class Agent {
     }
     /** monotonic counter: a start() bumps it, so a pending stop status write loses */
     stopSeq = 0;
+    /** #95: set when this round already injected a harness progress request */
+    progressRequestedThisRound = false;
     setStatus(s, reason = "") {
         // Update the field FIRST. log.append fires onEvent synchronously, and the
         // master's child-event hook wakes parked wait_children callers — those
@@ -1331,6 +1385,22 @@ export class Agent {
                 await this.sleepInterruptible(this.opts.continueDelayMs);
                 if (this.stopRequested)
                     break;
+                // #95: do NOT pair this with a progress request. Both fire at the turn
+                // boundary and both inject a user message, so the model received two
+                // harness instructions back to back — "Continue working toward the
+                // current goal" immediately followed by "Please give a brief progress
+                // report now", which reads as the harness talking to itself.
+                //
+                // The progress request already re-enters the loop, so it IS the
+                // continuation: suppressing the nudge when one is pending costs nothing
+                // and leaves exactly one instruction per boundary.
+                if (this.progressRequestedThisRound) {
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "auto-continue-suppressed",
+                        detail: "a progress report was already requested this round (#95)",
+                    });
+                    break;
+                }
                 const isSub = !!this.opts.parent;
                 const nudge = isSub
                     ? `[harness] Auto-nudge. Re-anchor on YOUR task — and only that:\n\n${this.goal.text.slice(0, 1500)}\n\nThe inherited conversation is reference only; other agents own any older tasks in it. If your task is complete, call finish() now instead of continuing. If blocked, explain why briefly and finish().`
@@ -1454,6 +1524,11 @@ export class Agent {
             // skills may have been created last turn — refresh the prompt listing
             await this.refreshSkills();
             // periodic progress report at turn boundary (no mid-turn interruption)
+            // #95: the flag is per-TURN, not per-round. `maybeRequestProgress` sits
+            // inside the turn loop and auto-continue is checked after the round
+            // ends, so the flag has to mean "this boundary already carried an
+            // instruction" — reset here, set below if the request fires.
+            this.progressRequestedThisRound = false;
             await this.maybeRequestProgress();
             // keep the context window bounded before spending tokens on a turn
             await this.maybeCompact();
@@ -2098,10 +2173,29 @@ export class Agent {
             const m = this.messages[i];
             if (m.role === "user")
                 continue; // prompts/noise — keep agent output only
-            if (m.role === "assistant" && !(m.content ?? "").trim())
+            const text = String(m.content ?? "").trim();
+            // #94: a message whose text is a PLACEHOLDER carries no information.
+            //
+            // `llm.ts` rewrites any assistant/tool message that has no usable text to
+            // the literal "(tool call)" or "(no content)". Those are display
+            // artifacts, and the parent's report was landing them verbatim — in the
+            // real log, TWO of the six entries in an accepted report were literally
+            // "[assistant] (tool call)", so half of what the parent was told about the
+            // work was a placeholder.
+            //
+            // A tool CALL is real work, but it is represented in the tool RESULT that
+            // follows, so dropping the placeholder loses nothing.
+            if (!text || PLACEHOLDER_TEXT.test(text))
+                continue;
+            // #94: a window this small must not be spent on BOOKKEEPING. The real log
+            // showed a 6-slot window where two 23-char "(tool call)" placeholders and a
+            // 40-char "decision recorded to decisions.md" took half the slots, pushing
+            // out the reasoning a parent would need to judge the work. Harness
+            // acknowledgements carry no findings, so they cost a slot for nothing.
+            if (HARNESS_ACK.test(text))
                 continue;
             const who = m.role === "tool" ? "tool" : m.role;
-            let line = `[${who}] ${(m.content ?? "").trim()}`;
+            let line = `[${who}] ${text}`;
             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
@@ -2247,6 +2341,9 @@ export class Agent {
             this.turnsSinceProgress >= this.opts.progressMaxQuietTurns;
         if (!elapsedOk || !activityOk)
             return; // stalling provider → don't waste a turn asking
+        // #95: remember that this boundary already carries an instruction, so the
+        // auto-continue nudge can stand down instead of pairing with it.
+        this.progressRequestedThisRound = true;
         this.lastProgressAt = Date.now();
         this.activityChars = 0;
         this.turnsSinceProgress = 0;

package/dist/agent/tools.js

@@ -414,7 +414,51 @@ function clipText(s, max) {
     const n = Math.max(1000, Math.min(max, 80_000));
     return s.length <= n ? s : `${s.slice(0, n)}\n… [truncated, ${s.length} chars total]`;
 }
+/**
+ * Patterns that backtrack catastrophically (#93).
+ *
+ * A nested quantifier — a quantified group whose body is itself quantified, or
+ * alternation that can match the same text more than one way — makes the engine
+ * explore exponentially many splits. Measured on this codebase: `(a+)+b` against
+ * 28 characters of "a" took 3.8s, roughly DOUBLING per character added, and a
+ * 40-character line would run for days.
+ *
+ * There is no timeout on this path: `ctx.defaultTimeoutMs` guards `bash` only,
+ * so the scan is a synchronous `re.test(line)` with nothing able to interrupt it.
+ * The agent process blocks and takes the UI and every other agent with it.
+ *
+ * A model is poorly placed to reason about backtracking cost and nothing tells it
+ * not to try, so the pattern is checked rather than trusted. This rejects the
+ * SHAPE rather than trying to bound the runtime, because a synchronous regex
+ * cannot be abandoned once `test` starts — the only reliable protection is to
+ * never compile one.
+ */
+const BACKTRACKING_PATTERNS = [
+    // (a+)+  (a*)*  (a+)*  (a?)* … — a quantifier wrapping another quantifier
+    { re: /\([^()]*[+*}][^()]*\)\s*[+*{]/, why: "a quantifier nested inside another quantifier" },
+    // (a|a)+ — alternation whose branches can match the SAME text. Distinct
+    // branches like (foo|bar)+ are fine and common, so this only fires when two
+    // branches are literally identical, which is the shape that explodes.
+    { re: /\(([^()|]*)\|\1\)\s*[+*{]/, why: "an alternation with identical branches inside a quantifier" },
+    // (.*)*  (.+)+ — a wildcard quantified inside a quantifier
+    { re: /\(\s*[.][*+]\s*\)\s*[+*{]/, why: "a wildcard quantified inside a quantifier" },
+];
+/** Above this, the O(lines x pattern) scan itself becomes the cost. */
+const MAX_PATTERN_LENGTH = 1000;
+/**
+ * Compile a model-supplied regex, refusing ones that can backtrack
+ * catastrophically.
+ *
+ * Returns an error STRING rather than a RegExp so every existing call site —
+ * which already handles that shape for an invalid pattern — needs no change.
+ */
 function compileRegex(pattern, ignoreCase) {
+    if (pattern.length > MAX_PATTERN_LENGTH)
+        return `pattern too long (${pattern.length} chars, max ${MAX_PATTERN_LENGTH}) — narrow it, or grep for a literal substring instead`;
+    for (const { re, why } of BACKTRACKING_PATTERNS) {
+        if (re.test(pattern))
+            return `pattern rejected: ${why} — that shape backtracks exponentially and would freeze the agent (e.g. "(a+)+b" against 28 characters takes 3.8s). Use a literal search, or simplify the pattern.`;
+    }
     try {
         return new RegExp(pattern, ignoreCase ? "i" : "");
     }

package/dist/server/api.js

@@ -1027,6 +1027,15 @@ export function buildApp(master) {
             return c.json({ error: "eventId and text required" }, 400);
         try {
             const r = await a.editPromptAt(body.eventId, body.text, body.tail === "summarize" ? "summarize" : "discard");
+            // #96: the UI button is labelled "fork & RESEND", but nothing resent.
+            // `editPromptAt` rewrites history and returns, leaving the agent idle —
+            // so the edited prompt sat in the timeline looking sent while the model
+            // had never seen it, and the operator had to notice and press start.
+            //
+            // start() here rather than in the client: the route already knows the edit
+            // succeeded, and a client that failed to call it would leave the agent
+            // silently idle with no error anywhere.
+            a.start("edited prompt resent");
             return c.json({ ok: true, ...r });
         }
         catch (err) {

package/package.json

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