teapot-coding-agent 0.26.3 → 0.26.5

package/dist/agent/agent.js

@@ -89,14 +89,25 @@ Most session state is not injected into prompts — fetch it with tools instead:
   turn right after the call (a short "reported." is fine).
 - Be frugal: prefer small precise edits, avoid runaway loops.`;
 /**
- * Placeholder text a provider adapter substitutes for a message with no usable
- * content (`llm.ts`).
+ * A message whose ENTIRE text is parenthesised is an acknowledgement, not work.
  *
- * #94: these are DISPLAY ARTIFACTS. They were reaching the parent inside a
- * sub-agent's final report, where they occupied two of six entries while saying
- * nothing — the parent was told "[assistant] (tool call)" as if it were content.
- */
-export const PLACEHOLDER_TEXT = /^\((tool call|no content|no output)\)$/i;
+ * #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", …).
@@ -525,6 +536,43 @@ export class Agent {
     async load() {
         await this.ensureReady();
     }
+    /**
+     * Answer tool_calls in a RESTORED history that have no tool_result (#54).
+     *
+     * The ordinary backstop (`answerUnansweredToolCalls`) works on an assistant
+     * turn inside a live loop. After a restart there is no loop: the call is in
+     * the log, the process that was running it is gone, and nothing else will ever
+     * write its result.
+     */
+    async answerUnansweredRestoredCalls() {
+        const seen = new Set();
+        for (const ev of await readEvents(this.log.filePath)) {
+            const d = (ev.data ?? {});
+            const id = d.callId ? String(d.callId) : null;
+            if (!id)
+                continue;
+            if (ev.type === "tool_call")
+                seen.add(id);
+            else if (ev.type === "tool_result")
+                seen.delete(id);
+        }
+        for (const id of seen) {
+            await this.log.append("tool_result", this.currentSession, this.currentBranch, {
+                callId: id,
+                name: "unknown",
+                ok: false,
+                durationMs: 0,
+                result: "not completed — the agent restarted while this tool was running",
+                synthesized: true,
+            });
+        }
+        if (seen.size)
+            await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                event: "unfinished-tools-closed",
+                count: seen.size,
+                detail: "a restart left these tool calls without a result; they are marked not completed (#54)",
+            });
+    }
     /** harness-managed files inside the session directory */
     get goalFile() {
         return path.join(this.opts.sessionDir, "goal.md");
@@ -694,6 +742,24 @@ export class Agent {
             // seen and acted on that output, and the pruned form keeps the head plus
             // a marker, exactly as it did live.
             this.maybePrune();
+            // #54: answer tool_calls the log says are still open.
+            //
+            // The restore path rebuilds `msgs` straight from the log, so a call whose
+            // process died mid-command comes back as an assistant turn with
+            // `tool_calls` and NO matching `tool_result`. Nothing ever answers it —
+            // not `stop()` (there is no turn to stop) and not `dispose()` (the process
+            // is already gone). The row then renders as still running for good.
+            //
+            // Measured across every session log: 43,483 tool_calls, and 4 unanswered —
+            // every one a `bash`, each followed immediately by
+            // `session-restored` / `idle->stopped disposed`. The shape is a restart
+            // (or a crash) landing while a long command was in flight, which is
+            // precisely when a human is most likely to notice "it never finished".
+            //
+            // So close them ON RESTORE, before the restored history is used. This is
+            // the same backstop as the mid-turn paths, reached from the one place
+            // those could not: after the process is gone.
+            await this.answerUnansweredRestoredCalls();
             await this.log.append("system_note", this.currentSession, this.currentBranch, {
                 event: "session-restored",
                 branch: last.branch,
@@ -1018,6 +1084,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,
@@ -1252,6 +1341,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
@@ -1349,6 +1440,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().`
@@ -1472,6 +1579,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();
@@ -2284,6 +2396,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.3",
+  "version": "0.26.5",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",