teapot-coding-agent 0.37.103 → 0.37.104

package/dist/agent/agent.js

@@ -78,6 +78,11 @@ const SUMMARY_CLOSE = "\n</conversation_checkpoint>";
 const AUDIT_READ_ONLY_TOOLS = new Set(["read_file", "list_dir", "grep", "bash"]);
 const SYSTEM_TEMPLATE = `You are a coding agent working autonomously inside a workspace.
 
+Start any session with three cheap calls, in this order: get_goal() (what am I
+actually doing), get_todo() (what the operator is tracking), list_skills() (what
+playbooks already exist). They cost about a line each and decide what to do next;
+skipping them is how work already done gets done again.
+
 Most session state is not injected into prompts — fetch it with tools instead:
 - get_goal() → current objective + status. Call at session start, after a
   compaction notice, or whenever you lose the thread.
@@ -85,6 +90,9 @@ Most session state is not injected into prompts — fetch it with tools instead:
 - finish(goalComplete=true, summary) → goal fully achieved.
 - ask_user(question, options?) → park the loop and wait for the operator's
   decision (plan confirmation, ambiguity). One concrete question at a time.
+  Which one ends the turn: finish() closes the round, ask_user() parks it until
+  the operator answers, and report_progress() does NOT end it — that output goes
+  to the operator's progress panel and you carry on working.
 - read_memory(query?) / add_memory(text) / forget_memory(query) / set_memory(content)
   → your durable notes (memory.md). add_memory appends and cannot lose earlier
   notes; forget_memory removes the lines matching a substring, so a stale note can
@@ -117,17 +125,19 @@ Most session state is not injected into prompts — fetch it with tools instead:
   valid string), and it took longer to repair than doing the edits one by one.
   A genuine bulk transform across many files (a rename, an import change) IS a
   job for a script — then keep the pattern specific and read the diff.
-- **NEVER \`sleep\` to wait for anything.** Not alone, not as "a quick poll".
-  A bash call with a sleep inside is one opaque command: the operator cannot
-  interrupt it, cannot see whether anything is happening, and the whole turn is
-  spent doing nothing. Two interruptible shapes instead:
+- **Never wait with a bare sleep.** A bash call with a sleep inside is one opaque
+  command: the operator cannot interrupt it, cannot see whether anything is
+  happening, and the whole turn is spent doing nothing. A fixed nap also cannot
+  tell "finished 5 minutes ago" from "still running", which is how a turn gets
+  wasted twice. Two interruptible shapes instead:
     · long single-purpose work (CI, a release, a tarball appearing, a dev
       server, a watcher) → bash(background=true). It returns a job id at once
       and you are NOTIFIED when it exits, so keep working and let it report.
-    · waiting on a condition you are actively watching → poll with a bounded
-      deadline in ONE call, then stop.
-  A fixed wait also cannot tell "finished 5 minutes ago" from "still running",
-  which is how a turn gets wasted twice.
+    · waiting on a condition you are actively watching → poll for the CONDITION
+      with a bounded deadline in ONE call, then stop. Polling is not a nap: it
+      re-checks and returns as soon as the condition holds.
+  The line is fixed-vs-condition, not short-vs-long: a bounded poll that returns
+  on the condition is fine, a sleep that always burns the same wall-clock is not.
 - When a loaded skill matches your task, follow its playbook.
 - Turn proven procedures into skills: once something non-trivial worked well,
   save_skill(name, description, content, files=[{name, content}]) so future
@@ -149,6 +159,11 @@ 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.
+- **Two failures on the same cause is the signal to change approach, not to try
+  a third time.** Reread the error, list what you have already ruled out, and
+  then either fix the actual cause or ask_user with what you know: two concrete
+  options and the evidence for each. Grinding a third variation of a failing idea
+  is the costliest loop there is, because it looks like progress.
 - When the operator asks you to remember something, WRITE it with add_memory.
   Write the KIND of thing that stays true and saves work later: a decision and
   why, a gotcha that cost time, a command that works here, where you left off.
@@ -164,6 +179,8 @@ Most session state is not injected into prompts — fetch it with tools instead:
   read_memory(query), open at most one or two of the notes that match, and stop.
   If nothing is relevant, carry on — do not keep searching, and do not read the
   whole file "just in case". An unread note is an unwritten note.`;
+/** how much of memory.md a no-query read_memory() may dump into the transcript */
+export const MEMORY_DUMP_LIMIT = 8_000;
 export const PLACEHOLDER_TEXT = /^\(.*\)$/;
 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 {
@@ -1660,7 +1677,16 @@ export class Agent {
                 return "next";
             }
             if (!query) {
-                await this.answerMeta(call, mem.trim());
+                /**
+                 * No query means "give me everything", and everything is now tens of KB — memory.md is capped at
+                 * 32_000 chars and a long-lived session fills it. Dumping that into the transcript costs more than
+                 * the answer is worth, and the prompt already carries a digest, so cap it and say how to narrow.
+                 */
+                const body = mem.trim();
+                await this.answerMeta(call, body.length <= MEMORY_DUMP_LIMIT
+                    ? body
+                    : `${body.slice(0, MEMORY_DUMP_LIMIT)}\n… (truncated — ${body.length} chars in memory.md; ` +
+                        `pass a query to read a specific part)`);
                 return "next";
             }
             const needle = query.toLowerCase();

package/dist/agent/tools.js

@@ -1459,12 +1459,8 @@ export const TOOLS = [
                 const id = startBackgroundShell(str(args.command), ctx);
                 return {
                     ok: true,
-                    result: `started in background (job ${id}). It runs while you work — you will be notified ` +
-                        `here when it exits (exit code + output tail), and the round WAITS for that rather ` +
-                        `than ending. Do NOT poll bash_output: each poll is a whole turn, and the report ` +
-                        `already carries the tail. Call bash_output only when you need output BEYOND the ` +
-                        `tail (a long build's earlier lines), or to kill it. ` +
-                        `Full output: bash_output(job_id="${id}"). Kill: bash_output(job_id="${id}", action="kill").`,
+                    result: `started in background (job ${id}) — you are notified when it exits (code + output tail); ` +
+                        `do NOT poll it. Output: bash_output(job_id="${id}"). Stop: bash_output(job_id="${id}", action="kill").`,
                 };
             }
             const explicit = args.timeout_ms !== undefined && args.timeout_ms !== null;

package/package.json

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