teapot-coding-agent 0.14.4 → 0.14.6

package/dist/agent/agent.js

@@ -51,7 +51,10 @@ Session state is not injected into prompts — fetch it with tools instead:
   save_skill(name, description, content, files=[{name, content}]) so future
   sessions can load_skill them — helper scripts go through files and are made
   executable automatically.
-- When you make meaningful progress, call report_progress.
+- When you make meaningful progress, call report_progress. Its output is
+  shown to the operator directly (rendered as markdown in the progress
+  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.`;
 export class Agent {
     log;
@@ -619,11 +622,18 @@ export class Agent {
                     this.goal.status !== "active" ||
                     !this.goal.text.trim())
                     break;
-                // auto-continue: wait quietly, then nudge with a fresh round
+                // auto-continue: wait quietly, then nudge with a fresh round.
+                // Sub-agents get a SCOPE-ANCHORED nudge instead of a generic one:
+                // "Continue working toward the current goal" made a forked sub-agent
+                // re-read its inherited context and drift into one of the parent's
+                // older tasks — it would keep going forever without ever finish()ing.
                 await this.sleepInterruptible(this.opts.continueDelayMs);
                 if (this.stopRequested)
                     break;
-                const nudge = "Continue working toward the current goal. If you are blocked, explain why briefly.";
+                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().`
+                    : "Continue working toward the current goal. If you are blocked, explain why briefly.";
                 await this.log.append("prompt", this.currentSession, this.currentBranch, {
                     source: "harness",
                     text: nudge,
@@ -819,11 +829,15 @@ export class Agent {
                     const a = safeParse(call.function.arguments);
                     const question = String(a.question ?? "").slice(0, 2000);
                     const options = Array.isArray(a.options) ? a.options.map(String).slice(0, 6) : [];
+                    // the callId lets the UI tell "still open" from "already answered"
+                    // (a settled tool_result for this id exists) and disable re-answering
                     await this.log.append("question", this.currentSession, this.currentBranch, {
                         question,
                         options,
+                        callId: call.id,
                     });
-                    await this.answerMeta(call, "question shown to the operator — the loop is parked until they reply");
+                    await this.answerMeta(call, "question shown to the operator — the loop is parked until they reply. " +
+                        "Their reply (possibly free text, not one of the options) arrives as your next user message.");
                     this.awaitingUser = true;
                     this.setStatus("waiting", question.slice(0, 80));
                     // control flow: park the loop; the operator's next prompt resumes it
@@ -993,10 +1007,16 @@ export class Agent {
         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.
         await this.log.append("message", this.currentSession, this.currentBranch, {
             role: "assistant",
             content: res.message.content ?? "",
             reasoning: res.reasoning,
+            progressEcho: true,
         });
         this.messages.push(res.message);
     }

package/dist/agent/tools.js

@@ -809,9 +809,13 @@ export const TOOLS = [
             // park VISIBLY: the UI shows idle ("waiting on sub-agents") instead of a
             // running spinner, and any user prompt / stop wakes us instantly
             ctx.onIdlePark?.(`waiting on sub-agent${ids?.length === 1 ? ` ${ids[0]}` : "s"}`);
+            // the child's report is about to land in our mailbox — a progress report
+            // right after it would be pure noise, so re-arm the gate here
+            ctx.onProgressGateReset?.();
             try {
                 const r = await sa.wait(ids, ms);
                 ctx.onIdleUnpark?.();
+                ctx.onProgressGateReset?.(); // also after: waiting itself isn't "activity"
                 return { ok: true, result: r.note };
             }
             catch (e) {

package/dist/master.js

@@ -483,10 +483,25 @@ export class Master {
             child.importMessages(parent.exportMessages());
         }
         await child.setGoal(`${directive}${o.task}`.slice(0, 2000));
+        // SCOPE GUARD: a forked child inherits the parent's whole conversation as
+        // reference context — without an explicit boundary, models have been seen
+        // "continuing" some EARLIER task that appears in that history instead of
+        // the task they were actually spawned for. State the boundary twice
+        // (goal + first prompt) so it survives goal-driven auto-continue.
         await child.enqueuePrompt((o.context === "fork"
-            ? `[harness] You are sub-agent ${id}, spawned by @${parentId} with the conversation above. `
-            : `[harness] You are sub-agent ${id}, spawned by @${parentId}. `) +
-            `Work solely on this task:\n\n${directive}${o.task}`, "harness");
+            ? `[harness] You are sub-agent ${id}, spawned by @${parentId}.
+
+The conversation above is REFERENCE CONTEXT ONLY — background on why this work is needed.
+It contains older tasks and discussions that are NOT yours. Do not resume, continue, or
+finish any of them; other agents own those. If you find yourself working on anything other
+than the task below, STOP and return to it.
+
+YOUR ONE AND ONLY TASK — everything else in the inherited context is out of scope:
+
+${directive}${o.task}
+
+When this task is done (or truly blocked), call finish() with a summary for @${parentId}.`
+            : `[harness] You are sub-agent ${id}, spawned by @${parentId}. Work solely on this task:\n\n${directive}${o.task}\n\nWhen it is done (or truly blocked), call finish() with a summary for @${parentId}.`), "harness");
         child.start(`spawned by ${parentId}`);
         console.log(`[teapot] sub-agent ${id} spawned by ${parentId} (context: ${o.context ?? "none"}${persona ? `, persona: ${persona}` : ""})`);
         return { id };

package/dist/server/api.js

@@ -322,6 +322,57 @@ export function buildApp(master) {
             return c.json({ error: err.message }, 400);
         }
     });
+    // write a file from the web UI's file-tree editor (human action, not an
+    // agent tool — allowed even for read-only personas, never notifies the
+    // agent). Optional baseContent enables optimistic-concurrency checking.
+    app.put("/api/agents/:id/file", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const rel = c.req.query("path") ?? "";
+        if (!rel.trim())
+            return c.json({ error: "path required" }, 400);
+        const body = await c.req.json().catch(() => null);
+        if (body === null || typeof body.content !== "string")
+            return c.json({ error: "content required" }, 400);
+        let abs;
+        try {
+            abs = safeJoin(a.workspace, rel);
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+        try {
+            let existing = null;
+            try {
+                existing = await fs.readFile(abs);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+            // refuse to clobber binary files (same 8KB NUL probe as GET)
+            if (existing && existing.subarray(0, 8192).includes(0))
+                return c.json({ error: "binary file — edit refused" }, 400);
+            // conflict check: the editor sends what it loaded; if disk moved on,
+            // bounce with the fresh content instead of silently overwriting
+            if (typeof body.baseContent === "string" &&
+                existing &&
+                existing.subarray(0, 100_000).toString("utf8") !== body.baseContent) {
+                return c.json({
+                    error: "file changed on disk",
+                    current: existing.subarray(0, 100_000).toString("utf8"),
+                }, 409);
+            }
+            await fs.mkdir(path.dirname(abs), { recursive: true });
+            const content = Buffer.from(body.content, "utf8");
+            await fs.writeFile(abs, content);
+            return c.json({ ok: true, path: rel, size: content.length });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
     // ---- config (view/edit from the web UI) ----
     app.get("/api/config", (c) => {
         const mask = (p) => Object.fromEntries(Object.entries(p ?? {}).map(([k, v]) => [

package/package.json

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