teapot-coding-agent 0.14.6 → 0.14.8

package/dist/agent/agent.js

@@ -493,6 +493,54 @@ export class Agent {
         await fs.writeFile(this.todoFile, text, "utf8");
         await this.log.append("todo", this.currentSession, this.currentBranch, { event: "set", by });
     }
+    /**
+     * Update SPECIFIC checkbox items without rewriting the whole list — the
+     * full-replacement path made agents lazy (a mid-task progress tick meant
+     * re-emitting the entire markdown, so they skipped updates) and risky (one
+     * sloppy regeneration mangled unrelated sections). Items are matched by
+     * normalized text; unknown items are reported back instead of silently
+     * dropped. Returns a short human-readable summary for the tool result.
+     */
+    async updateTodoItems(updates, by = "agent") {
+        const norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
+        const lines = this.todo.split("\n");
+        let matched = 0;
+        const unmatched = [];
+        for (const u of updates) {
+            const target = norm(u.item);
+            // find the LAST matching checkbox line (later duplicates win)
+            let idx = -1;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const m = lines[i].match(/^(\s*[-*+] \[)([ xX])(\].*)$/);
+                if (!m)
+                    continue;
+                if (norm(m[3].slice(1)) === target) {
+                    idx = i;
+                    break;
+                }
+            }
+            if (idx === -1) {
+                unmatched.push(u.item);
+                continue;
+            }
+            lines[idx] = lines[idx].replace(/^(.* \[)[ xX](\].*)$/, (_s, a, b) => `${a}${u.done ? "x" : " "}${b}`);
+            matched++;
+        }
+        if (matched > 0) {
+            this.todo = lines.join("\n");
+            await fs.writeFile(this.todoFile, this.todo, "utf8");
+            await this.log.append("todo", this.currentSession, this.currentBranch, {
+                event: "items",
+                by,
+                matched,
+                ...(unmatched.length ? { unknown: unmatched } : {}),
+            });
+        }
+        const parts = [`${matched} item(s) updated`];
+        if (unmatched.length)
+            parts.push(`NOT FOUND in todo.md: ${unmatched.map((s) => `"${s}"`).join(", ")} — check get_todo and retry with the exact wording`);
+        return parts.join(". ");
+    }
     async setGoalStatus(status) {
         this.goal = { ...this.goal, status, updatedAt: new Date().toISOString() };
         await this.writeGoalFile();
@@ -595,15 +643,22 @@ export class Agent {
         });
     }
     setStatus(s, reason = "") {
-        if (this.status !== s) {
+        // Update the field FIRST. log.append fires onEvent synchronously, and the
+        // master's child-event hook wakes parked wait_children callers — those
+        // re-check agent.status at that instant. Updating after the append made
+        // every waiter observe the OLD status ("running"), conclude "someone is
+        // still working", and stay parked until timeout even though the child had
+        // just settled.
+        const prev = this.status;
+        this.status = s;
+        this.statusReason = reason;
+        if (prev !== s) {
             void this.log.append("state", this.currentSession, this.currentBranch, {
-                from: this.status,
+                from: prev,
                 to: s,
                 reason,
             });
         }
-        this.status = s;
-        this.statusReason = reason;
         bus.emit("update", { kind: "agent-update", agentId: this.opts.id });
     }
     /** Main auto-run loop: turn -> tools -> turn ... -> done/idle/stop. */
@@ -849,9 +904,28 @@ export class Agent {
                 }
                 if (call.function.name === "set_todo") {
                     const a = safeParse(call.function.arguments);
+                    // Preferred: surgical checkbox updates — no full rewrite, no risk
+                    // of mangling unrelated sections, cheap enough to do mid-task.
+                    const updates = Array.isArray(a.updates)
+                        ? a.updates
+                            .map((u) => {
+                            const o = (u ?? {});
+                            return { item: String(o.item ?? ""), done: o.done !== false };
+                        })
+                            .filter((u) => u.item.trim())
+                        : [];
+                    if (updates.length > 0) {
+                        const note = await this.updateTodoItems(updates, "agent");
+                        await this.answerMeta(call, `${note} (visible to the operator)`);
+                        continue;
+                    }
                     const content = String(a.content ?? "").slice(0, 32_000);
+                    if (!content.trim()) {
+                        await this.answerMeta(call, "nothing to do: pass updates:[{item,done}] to check items off, or content to replace the whole list");
+                        continue;
+                    }
                     await this.setTodo(content, "agent");
-                    await this.answerMeta(call, "task list updated (visible to the operator)");
+                    await this.answerMeta(call, "task list replaced (visible to the operator)");
                     continue;
                 }
                 if (call.function.name === "get_feedback") {
@@ -1443,11 +1517,29 @@ function allToolSpecs() {
             type: "function",
             function: {
                 name: "set_todo",
-                description: "Replace the operator-visible task list (todo.md) — e.g. check off finished items or restate what remains. Keep it terse.",
+                description: "Update the operator-visible task list (todo.md). PREFERRED: pass updates to check specific " +
+                    "items off as you finish them — cheap, surgical, no risk of mangling other sections. Only pass " +
+                    "content to rewrite the whole list when restructuring it. Call this promptly on every item you complete.",
                 parameters: {
                     type: "object",
-                    properties: { content: { type: "string" } },
-                    required: ["content"],
+                    properties: {
+                        updates: {
+                            type: "array",
+                            description: "surgical checkbox flips — match items by their exact text in todo.md",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    item: { type: "string", description: "checkbox item text (without the \"- [ ]\" marker)" },
+                                    done: { type: "boolean", description: "true = check off, false = reopen (default true)" },
+                                },
+                                required: ["item"],
+                            },
+                        },
+                        content: {
+                            type: "string",
+                            description: "full replacement markdown — only for restructures; prefer updates",
+                        },
+                    },
                 },
             },
         },

package/package.json

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