teapot-coding-agent 0.24.1 → 0.24.3

package/dist/agent/agent.js

@@ -346,10 +346,23 @@ export class Agent {
         return this.manualCompactBudget;
     }
     /**
-     * Long-parking tools (wait_children) flip the visible status to idle so the
-     * operator isn't staring at a running spinner for minutes. The run chain is
-     * still parked inside the tool — but any prompt/stop wakes it immediately.
+     * Is this agent doing work that `stop()` would actually stop?
+     *
+     * `status` cannot answer this on its own. Three states count as live:
+     *   - `running`: the obvious one;
+     *   - a PARKED TOOL: `parkForTool()` flips the visible status to "idle" so a
+     *     multi-minute `wait_children` doesn't look like a running spinner, but
+     *     the loop is very much alive inside the tool;
+     *   - QUEUED PROMPTS: prompts handed to a stopped agent are accepted and held,
+     *     and a later `start()` will consume them.
+     *
+     * Anything keying "should this button stop or start?" off `status` alone
+     * therefore offers **start** on a working agent, and the user cannot stop it
+     * (#59) — the same trap #38 documented for editing history.
      */
+    isLive() {
+        return this.status === "running" || this.parkedByTool || this.pendingPrompts.length > 0;
+    }
     /**
      * A background shell (bash background=true) finished. Two channels:
      * 1. a system_note row in the timeline — the operator sees the outcome
@@ -614,6 +627,15 @@ export class Agent {
         if (msgs.length > 0) {
             this.messages = msgs;
             this.currentBranch = last.branch;
+            // #50: re-apply pruning to the restored history. `maybePrune` clips
+            // oversized tool output IN PLACE, so a live session keeps its clipped
+            // text while the log still holds the full result — a restart therefore
+            // handed the provider a strictly LARGER prompt than the one that had just
+            // succeeded, which is a size regression that only shows up after a
+            // reload. It is a size fix, not a semantic one: the model has already
+            // seen and acted on that output, and the pruned form keeps the head plus
+            // a marker, exactly as it did live.
+            this.maybePrune();
             await this.log.append("system_note", this.currentSession, this.currentBranch, {
                 event: "session-restored",
                 branch: last.branch,
@@ -876,6 +898,17 @@ export class Agent {
             id: this.opts.id,
             status: this.status,
             statusReason: this.statusReason,
+            /**
+             * Is there work in flight that `stop` would actually stop?
+             *
+             * `status` alone is not enough to answer that, and the UI needs it: a
+             * parked tool (`wait_children`) rewrites the status to "idle" while the
+             * loop is very much alive, so a client keying "stop vs start" off
+             * `status === "running"` offered **start** on a running agent and the
+             * user could not stop it (#59). This is the same "running is not the
+             * only live state" fact #38 had to be taught about editing.
+             */
+            live: this.isLive(),
             workspace: this.workspace,
             workspaceMissing: this.workspaceMissing,
             session: this.currentSession,
@@ -2171,6 +2204,20 @@ export class Agent {
             phase: "summarizing",
             summarized: oldCount,
         });
+        // #56: the START belongs on the timeline too. Only the right panel showed
+        // compaction, and it reports the *outcome*; a long summarize (hundreds of
+        // thousands of tokens) looks exactly like a hung agent on the timeline,
+        // because the first `context-compacted` event is only appended once the
+        // whole pass is over. Log the announcement as a visible system_note so
+        // the operator sees WHERE the conversation was rewritten, even if the
+        // pass later fails — `before`/`oldCount` are known at this point, and the
+        // completion divider still carries the authoritative after-figures.
+        await this.log.append("system_note", this.currentSession, this.currentBranch, {
+            event: "context-compaction-started",
+            tokensBefore: before,
+            messages: oldCount,
+            reason: force ? "manual" : "auto",
+        });
         this.compactPhase = "summarizing";
         try {
             summary = await this.summarize(old, (text) => {

package/dist/agent/llm.js

@@ -128,6 +128,75 @@ function sanitize(messages) {
         return { ...m };
     });
 }
+/**
+ * Why did the response carry no usable message?
+ *
+ * #50 — this used to be a bare "LLM API returned no choices", which is what
+ * made the report undiagnosable: an empty `choices` array, a 200 carrying an
+ * `error` object, a `delta`-shaped body, and an SSE stream that the SDK
+ * handed back as a plain String all produce the identical line, and none of
+ * them is a useful thing to read in a log.
+ *
+ * The leading text is kept stable at "LLM API returned no choices" so any
+ * existing matching (and the retry notes operators have learned to read)
+ * still works; the diagnosis follows after a colon.
+ */
+function noChoicesDetail(res) {
+    const base = "LLM API returned no choices";
+    // a gateway that answers 200 with an error object instead of failing: the
+    // actionable message is right there and used to be thrown away
+    const err = res?.error;
+    if (err && typeof err === "object") {
+        const msg = typeof err.message === "string" ? err.message : JSON.stringify(err);
+        const code = err.code ?? err.type;
+        return `${base}: provider returned an error in a 200 response${code ? ` (${String(code)})` : ""} — ${String(msg).slice(0, 300)}`;
+    }
+    // the SDK returned raw text — e.g. an SSE body served to a non-streaming
+    // request. JSON.parse succeeds for a real object, so a failure here means we
+    // were handed something that is not a completion at all.
+    if (typeof res === "string") {
+        const head = res.slice(0, 160).replace(/\s+/g, " ").trim();
+        return `${base}: response was not a completion object (${res.length} bytes of ${res.trimStart().startsWith("data:") || res.trimStart().startsWith("event:") ? "SSE" : "text"})${head ? ` — ${head}` : ""}`;
+    }
+    const choices = res?.choices;
+    if (Array.isArray(choices)) {
+        const first = choices[0];
+        if (!first)
+            return `${base}: the provider returned an empty choices array (0 candidates)`;
+        if (first.delta && !first.message) {
+            return `${base}: the provider returned a streaming delta on a non-streaming request (finish_reason=${String(first.finish_reason)})`;
+        }
+        if (first.message === null) {
+            return `${base}: the provider returned a choice with a null message (finish_reason=${String(first.finish_reason)})`;
+        }
+        return `${base}: the provider returned a choice with no message field (finish_reason=${String(first.finish_reason)})`;
+    }
+    return `${base}: the response had no choices array (${safeShape(res)})`;
+}
+/** a short type summary of an unexpected response, for the log line */
+function safeShape(res) {
+    try {
+        const o = res;
+        if (!o || typeof o !== "object")
+            return `got ${typeof res}`;
+        return `keys: ${Object.keys(o).slice(0, 8).join(", ") || "(none)"}`;
+    }
+    catch {
+        return "unreadable response";
+    }
+}
+/**
+ * HTTP statuses that mean "this request shape is not supported here", so
+ * re-issuing it without `stream: true` is a genuinely different request.
+ *
+ * Deliberately an allow-list rather than the whole 4xx range. 408/425/429 are
+ * TRANSIENT: replaying them immediately against an already-saturated provider
+ * just doubles the request count without changing anything. 401/403 mean the
+ * credentials are wrong, which is not fixed by dropping `stream` either — they
+ * are excluded on purpose, since a fallback there would replace one honest
+ * auth error with the same one and a wasted round trip.
+ */
+const STREAM_REJECTED_STATUS = new Set([400, 404, 405, 406, 415, 422, 501]);
 export async function chat(cfg, messages, tools, signal, onDelta) {
     try {
         const res = await client(cfg).chat.completions.create({
@@ -136,10 +205,14 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
             ...(tools.length ? { tools } : {}),
             ...effortForRequest(cfg),
         }, { signal });
-        const raw = res.choices?.[0];
+        // #50: a gateway may answer with `null` (or any non-object) on some proxy
+        // error paths, so the guard is on `rm`, not on `res` being truthy —
+        // reading `res.choices` unguarded threw a bare TypeError that named neither
+        // the provider nor the shape.
+        const raw = res?.choices?.[0];
         const rm = raw?.message;
         if (!rm)
-            throw new Error("LLM API returned no choices");
+            throw new Error(noChoicesDetail(res));
         // normalize: providers attach extra fields (reasoning, refusal, ...) and
         // nullable content — keep only what our protocol understands
         const message = {
@@ -198,6 +271,13 @@ export async function chat(cfg, messages, tools, signal, onDelta) {
     }
     catch (err) {
         const e = err;
+        // #50: our own shape-diagnosis already reads as a full sentence and names
+        // the response it saw. It carries no HTTP status (the request SUCCEEDED —
+        // that is the whole problem), so the generic wrapper below would have
+        // relabelled it "LLM API error ?: …", hiding both the diagnosis and the
+        // fact that no status was ever involved.
+        if (String(err.message ?? "").startsWith("LLM API returned no choices"))
+            throw err;
         if (e.status === undefined && !String(err.message).includes("provider returned"))
             throw err; // not an API error (abort, bug, ...)
         const detail = e.error?.message ?? e.message ?? "unknown provider error";
@@ -284,14 +364,58 @@ export async function chatStream(cfg, messages, tools, signal, onDelta) {
                         function: { name: c.name, arguments: c.args || "{}" },
                     }];
             });
-        if (!message.content && !message.tool_calls)
-            throw new Error("LLM API error: empty completion");
+        if (!message.content && !message.tool_calls) {
+            // #50: a stream that opened, produced NOTHING, and closed cleanly. The
+            // throw carries a marker so the handler below can tell this apart from a
+            // request the provider actively rejected: this one is a broken/flaky
+            // proxy, and re-issuing it without `stream` is a genuinely different
+            // request that usually succeeds. Throwing a bare Error would make the two
+            // indistinguishable and cost us that safety net.
+            const e = new Error("LLM API error: empty completion");
+            e.emptyStream = true;
+            throw e;
+        }
         return { message, reasoning: reasoning || undefined, usage };
     }
     catch (err) {
-        // provider may not support streaming at all — one clean fallback
-        if (!gotChunk && !signal?.aborted)
+        // #50 — a provider that doesn't support streaming at all still gets ONE
+        // clean fallback, but ONLY when the streaming attempt produced nothing for
+        // a reason that could plausibly be the stream itself.
+        //
+        // The old condition was `!gotChunk && !signal?.aborted`, which also matched
+        // a request that FAILED — a gateway answering 200 with an SSE `error`
+        // frame, or a context-length rejection. In those cases the fallback
+        // re-issued the same oversized request in a different shape, and the
+        // resulting "LLM API returned no choices" replaced the real diagnosis.
+        // That is why a restored 1500-message session reported "no choices" three
+        // times and then errored: the genuine "context length exceeded" was
+        // discarded on the first attempt and could never be recognised by
+        // isContextOverflow(), so the compact-and-retry recovery never ran.
+        //
+        // Two exclusions, and the second one matters as much as the first:
+        //
+        //  1. A status that means the REQUEST ITSELF was rejected. Only then is
+        //     re-issuing it without `stream` a different request rather than the
+        //     same failing one. `400`/`404`/`405`/`422` are the shapes a provider
+        //     uses to say "no streaming here" — deliberately NOT the whole 4xx
+        //     range, because 408/425/429 are transient: replaying those against an
+        //     already-saturated provider just doubles the request count.
+        //  2. A THROWN error, as opposed to a request that simply produced no
+        //     chunks. A 200 that streams zero chunks and closes cleanly is a
+        //     broken/flaky proxy, and that is precisely the case the non-streaming
+        //     retry rescues. Requiring a 4xx here would have deleted that safety
+        //     net — a regression this file's own tests caught.
+        //
+        // So the fallback runs when the request was rejected outright, OR when it
+        // completed without error and without a single chunk. Everything else —
+        // 5xx, an error frame, a mid-stream failure — is the ANSWER, rethrown
+        // untouched so overflow recovery can see it.
+        const status = err?.status;
+        const rejectedByProvider = typeof status === "number" && STREAM_REJECTED_STATUS.has(status);
+        const emptyStream = err?.emptyStream === true;
+        if (!gotChunk && !signal?.aborted && (rejectedByProvider || emptyStream)) {
             return chat(cfg, messages, tools, signal, onDelta);
+        }
         // user interrupt: hand back whatever streamed so far so the harness can
         // keep the partial output visible instead of losing it
         if (signal?.aborted && (text || reasoning)) {

package/dist/agent/tools.js

@@ -182,7 +182,13 @@ function startBackgroundShell(cmd, ctx) {
  *  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));
+    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) ||
+        // #50: some gateways answer an over-long request with HTTP 200 and put the
+        // real diagnosis in the body, which llm.ts now surfaces after the "no
+        // choices" prefix. Without this the compact-and-retry recovery never
+        // recognised it and the turn simply failed.
+        /no choices:[\s\S]{0,300}context (length|window|limit)/.test(msg));
 }
 /** Any background shell still running for this workspace? The auto-continue
  *  loop consults this before nudging a finished round: an agent that parked
@@ -709,10 +715,43 @@ export function hashLine(content) {
 }
 /** `LINE:HASH| content` for each line, 1-indexed */
 export function renderHashlines(lines, startLine = 1) {
-    return lines
+    // same trailing-newline rule as renderGutter (#7): a file ending in "\n"
+    // splits into a final "" that is not a line, and an anchor for it is a lie
+    // the model can copy into an edit that then never verifies
+    const body = lines.length && lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+    return body
         .map((l, i) => `${startLine + i}:${hashLine(l)}| ${l}`)
         .join("\n");
 }
+/**
+ * Width of the `N| ` gutter for a page, so every line in it lines up.
+ *
+ * #7: the prefix had no padding, so the gutter silently widened at line 1000
+ * and the whole block jumped sideways mid-file — the exact "unfriendly line
+ * numbers" complaint. Padding to the widest number IN THE PAGE is enough: a
+ * page is a bounded window, and aligning to the file's total length would
+ * push every line of a 20-line read of a 500k-line file 6 characters right.
+ */
+export function gutterWidth(startLine, count) {
+    return String(Math.max(0, startLine - 1) + count).length;
+}
+/**
+ * The default `N| ` display, with a stable gutter width and no phantom line.
+ *
+ * #7, second half: the prefix was added AFTER `text.split("\n")`, so a file
+ * ending in a newline produced a final numbered row for a line that does not
+ * exist. A model that copies the tail verbatim then hands `edit_file` an
+ * old_text with a phantom line in it, and the edit fails for no visible reason.
+ * A trailing empty element is dropped, which is what the reader means.
+ */
+export function renderGutter(lines, startLine = 1) {
+    // a trailing newline splits into a final "" — not a line of the file
+    const body = lines.length && lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+    if (!body.length)
+        return "";
+    const w = gutterWidth(startLine, body.length);
+    return body.map((l, i) => `${String(startLine + i).padStart(w)}| ${l}`).join("\n");
+}
 /** parse a `LINE:HASH` anchor; returns null when the text is not an anchor */
 export function parseAnchor(anchor) {
     const m = /^\s*(\d+):([0-9a-z]{4,8}| {4})\s*$/.exec(anchor);
@@ -913,7 +952,7 @@ export const TOOLS = [
                 }
                 const parts = regions.map(([s, e]) => idMode === "hash"
                     ? renderHashlines(lines.slice(s, e + 1), s + 1)
-                    : lines.slice(s, e + 1).map((l, k) => `${s + k + 1}| ${l}`).join("\n"));
+                    : renderGutter(lines.slice(s, e + 1), s + 1));
                 let result = parts.join("\n--\n");
                 if (idxs.length > page.length || off > 0)
                     result += `\n(${off + 1}–${off + page.length} of ${idxs.length} matches)`;
@@ -924,8 +963,11 @@ export const TOOLS = [
             off = off < 0 ? Math.max(0, lines.length + off) : Math.max(0, off - 1);
             const lim = num(args.limit, 2000);
             const pageLines = lines.slice(off, off + lim);
-            const slice = idMode === "hash" ? renderHashlines(pageLines, off + 1) : pageLines.map((l, i) => `${off + i + 1}| ${l}`).join("\n");
-            const more = off + lim < lines.length ? `\n... (${lines.length - off - lim} more lines)` : "";
+            const slice = idMode === "hash" ? renderHashlines(pageLines, off + 1) : renderGutter(pageLines, off + 1);
+            // the phantom trailing line is dropped for the count too, or a file that
+            // ends in a newline always reports one line more than it has
+            const total = lines.length && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+            const more = off + lim < total ? `\n... (${total - off - lim} more lines)` : "";
             return { ok: true, result: slice + more };
         },
     },
@@ -1090,12 +1132,27 @@ export const TOOLS = [
             // already proved which lines it means, so a block whose content occurs
             // twice must still edit the anchored occurrence rather than fail the
             // uniqueness check (#4).
+            // The hashline path splits on "\n" to index by resolved line number, which
+            // leaves a trailing "\r" on every line of a CRLF file. Rejoining with
+            // "\n" then DROPS all of them, so a single edit silently rewrote a
+            // Windows file's line endings: the replaced line arrived with the model's
+            // "\n" while every untouched line kept its "\r\n". The file still parsed
+            // and the edit "succeeded", so nothing reported it — but the next
+            // checkout diff shows the whole file changed, and tools that normalise on
+            // EOL (git, prettier, formatters) now rewrite it.
+            //
+            // So the EOL is detected ONCE from the untouched text and re-applied to
+            // the replacement, which also keeps a CRLF file CRLF when the model sends
+            // LF-separated new_text (the overwhelmingly common case — models never
+            // emit \r).
+            const eol = text.includes("\r\n") ? "\r\n" : "\n";
             const out = hashSpan
                 ? text
                     .split("\n")
                     .slice(0, hashSpan.start)
-                    .concat(newText.split("\n"), text.split("\n").slice(hashSpan.end))
+                    .concat(newText.replace(/\r\n/g, "\n").split("\n"), text.split("\n").slice(hashSpan.end))
                     .join("\n")
+                    .replace(/(?<!\r)\n/g, eol)
                 : replaceAll
                     ? text.split(oldText).join(newText)
                     : text.replace(oldText, newText);

package/dist/log/events.js

@@ -238,3 +238,50 @@ async function readWindow(fh, size, bytes) {
     }
     return { events, bytes: buf.length };
 }
+/**
+ * Keep one branch's rows out of a timeline, optionally including the history it
+ * inherited before it forked.
+ *
+ * #38. A fork is a new timeline, but the agent's CONTEXT on it still includes
+ * everything before the fork point — `rebuildMessagesFrom` walks the parent
+ * chain across branch boundaries precisely so a restarted fork keeps its
+ * history. Filtering the view by strict equality therefore showed *less* than
+ * the model actually reasons over, which is why a filtered fork looked like
+ * data loss even though nothing was missing from the log.
+ *
+ * `includeInherited` walks the parent links out of the branch's own events and
+ * keeps everything they reach, so the view matches the model's context. Strict
+ * remains the default: a caller that genuinely wants only a branch's own rows
+ * (counting, auditing) should not be handed inherited history silently.
+ *
+ * Pure and exported so the rule can be tested without an HTTP server.
+ */
+export function filterByBranch(events, branch, includeInherited = false) {
+    if (!includeInherited)
+        return events.filter((e) => e.branch === branch);
+    const byId = new Map(events.map((e) => [e.id, e]));
+    // every event belonging to the branch, plus everything reachable by `parent`
+    const wanted = new Set();
+    // A WORKLIST, not a loop over the growing set: iterating `wanted` while
+    // adding to it inside the same pass re-visits nodes and, on a parent cycle,
+    // never terminates.
+    const queue = [];
+    for (const e of events) {
+        if (e.branch !== branch)
+            continue;
+        if (wanted.has(e.id))
+            continue;
+        wanted.add(e.id);
+        queue.push(e.id);
+    }
+    while (queue.length) {
+        const cur = byId.get(queue.pop());
+        // walk up through the fork boundary — a fork's parent is the last event of
+        // the SOURCE branch, and that branch's history is inherited too
+        if (cur?.parent && !wanted.has(cur.parent)) {
+            wanted.add(cur.parent);
+            queue.push(cur.parent);
+        }
+    }
+    return events.filter((e) => wanted.has(e.id));
+}

package/dist/server/api.js

@@ -51,7 +51,7 @@ async function listModels(baseUrl, apiKey) {
 }
 import path from "node:path";
 import { bus } from "../bus.js";
-import { readEvents, readEventsTail } from "../log/events.js";
+import { readEvents, readEventsTail, filterByBranch } from "../log/events.js";
 /** media categories the file tree can preview inline */
 const IMAGE_EXT = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "avif"]);
 const VIDEO_EXT = new Set(["mp4", "webm", "mov", "mkv", "avi", "m4v"]);
@@ -976,7 +976,7 @@ export function buildApp(master) {
         }
         let events = await readEventsCached(filePath);
         if (branch)
-            events = events.filter((e) => e.branch === branch);
+            events = filterByBranch(events, branch, c.req.query("lineage") === "true");
         // cursor pagination for older pages: everything strictly BEFORE this id
         if (before) {
             const idx = events.findIndex((e) => e.id === before);

package/package.json

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