macroclaw 0.27.0 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",

package/src/app.test.ts

@@ -166,7 +166,7 @@ describe("App", () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
-      expect(claude.calls[0].prompt).toBe("hello");
+      expect(claude.calls[0].prompt).toContain("<text>hello</text>");
     });
 
     it("ignores messages from unauthorized chats", async () => {
@@ -219,7 +219,7 @@ describe("App", () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
-      expect(claude.calls[0].prompt).toBe("bg: research pricing");
+      expect(claude.calls[0].prompt).toContain("<text>bg: research pricing</text>");
     });
 
     it("sends error wrapped in response", async () => {
@@ -269,7 +269,7 @@ describe("App", () => {
       expect(bot.api.getFile).toHaveBeenCalledWith("large");
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toContain("[File:");
+      expect(claude.calls[0].prompt).toContain("<file path=");
 
       globalThis.fetch = origFetch;
     });
@@ -297,7 +297,7 @@ describe("App", () => {
       expect(bot.api.getFile).toHaveBeenCalledWith("doc-id");
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toContain("[File:");
+      expect(claude.calls[0].prompt).toContain("<file path=");
 
       globalThis.fetch = origFetch;
     });
@@ -363,7 +363,7 @@ describe("App", () => {
 
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toBe("hello from voice");
+      expect(claude.calls[0].prompt).toContain("<text>hello from voice</text>");
 
       globalThis.fetch = origFetch;
     });
@@ -532,7 +532,7 @@ describe("App", () => {
       expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Yes", callback_data: "_noop" }]] } });
       const claude = config.claude as Claude & { calls: CallInfo[] };
       expect(claude.calls).toHaveLength(1);
-      expect(claude.calls[0].prompt).toBe('[Context: button-click] User tapped "Yes"');
+      expect(claude.calls[0].prompt).toContain('<button>Yes</button>');
     });
 
     it("handles _dismiss callback by removing reply markup", async () => {
@@ -688,7 +688,7 @@ describe("App", () => {
 
       expect((config.claude as Claude & { calls: CallInfo[] }).calls).toHaveLength(0);
       const calls = (bot.api.sendMessage as any).mock.calls;
-      expect(calls[calls.length - 1][1]).toBe("Usage: /bg <prompt>");
+      expect(calls[calls.length - 1][1]).toBe("Usage: /bg &lt;prompt&gt;");
     });
 
     it("/bg with prompt spawns a background agent via sendMessage", async () => {

package/src/app.ts

@@ -43,7 +43,7 @@ export class App {
   start() {
     log.info("Starting macroclaw...");
     const scheduler = new Scheduler(this.#config.workspace, {
-      onJob: (name, prompt, model) => this.#orchestrator.handleCron(name, prompt, model),
+      onJob: (name, prompt, model, missed) => this.#orchestrator.handleCron(name, prompt, model, missed),
     });
     scheduler.start();
     this.#bot.api.setMyCommands([
@@ -78,7 +78,7 @@ export class App {
       const prompt = ctx.match?.trim();
       if (!prompt) {
         log.debug("Command /bg without prompt");
-        sendResponse(this.#bot, this.#config.authorizedChatId, "Usage: /bg <prompt>");
+        sendResponse(this.#bot, this.#config.authorizedChatId, "Usage: /bg &lt;prompt&gt;");
         return;
       }
       log.debug({ prompt }, "Command /bg spawn");

package/src/claude.ts

@@ -123,7 +123,7 @@ export class Claude {
     if (systemPrompt) args.push("--append-system-prompt", systemPrompt);
     args.push(prompt);
 
-    log.debug({ model, sessionId, promptLen: prompt.length, mode: mode.kind, hasSystemPrompt: !!systemPrompt }, "Sending to Claude");
+    log.debug({ model, sessionId, promptLen: prompt.length, mode: mode.kind, hasSystemPrompt: !!systemPrompt, prompt }, "Sending to Claude");
 
     const proc = Bun.spawn(args, { cwd: this.#workspace, env, stdout: "pipe", stderr: "pipe" });
     const startedAt = new Date();

package/src/index.ts

@@ -8,6 +8,10 @@ import { SpeechToText } from "./speech-to-text";
 export async function start(): Promise<void> {
   const log = createLogger("index");
 
+  process.on("unhandledRejection", (err) => {
+    log.error({ err }, "Unhandled rejection");
+  });
+
   const mgr = new SettingsManager();
   const settings = mgr.load();
   const { settings: resolved, overrides } = mgr.applyEnvOverrides(settings);

package/src/naming.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import { generateName } from "./naming";
+
+describe("generateName", () => {
+  test("extracts content words from English prompt", () => {
+    expect(generateName("please research the best coffee shops in Prague")).toBe("research-best-coffee-shops");
+  });
+
+  test("extracts content words from Czech prompt", () => {
+    expect(generateName("najdi nejlepsi kavárny v Praze a porovnej ceny")).toBe("najdi-nejlepsi-kavrny-praze");
+  });
+
+  test("returns 'task' for stop-words-only prompt", () => {
+    expect(generateName("please do this for me")).toBe("task");
+  });
+
+  test("returns 'task' for empty prompt", () => {
+    expect(generateName("")).toBe("task");
+  });
+
+  test("strips non-alphanumeric characters", () => {
+    expect(generateName("fix bug #123 in auth-service!")).toBe("fix-bug-123-auth");
+  });
+
+  test("respects maxWords parameter", () => {
+    expect(generateName("deploy new redis cluster with monitoring", 2)).toBe("deploy-new");
+  });
+
+  test("skips single-character words", () => {
+    expect(generateName("a b c deploy x y z")).toBe("deploy");
+  });
+
+  test("handles mixed English and Czech", () => {
+    expect(generateName("zkontroluj jestli je deploy hotovy")).toBe("zkontroluj-jestli-deploy-hotovy");
+  });
+
+  test("respects maxLength and drops words that would exceed it", () => {
+    expect(generateName("deploy infrastructure monitoring cluster", 4, 25)).toBe("deploy-infrastructure");
+  });
+
+  test("returns 'task' for very long single nonsense word", () => {
+    expect(generateName("a".repeat(500))).toBe("task");
+  });
+});

package/src/naming.ts

@@ -0,0 +1,54 @@
+/** Generates a short kebab-case name from a prompt by extracting content words. */
+
+const STOP_WORDS = new Set([
+  // English
+  "a", "about", "above", "after", "again", "all", "also", "am", "an", "and",
+  "any", "are", "as", "at", "be", "because", "been", "before", "being",
+  "between", "both", "but", "by", "can", "could", "did", "do", "does",
+  "doing", "down", "during", "each", "few", "for", "from", "further", "get",
+  "got", "had", "has", "have", "having", "he", "her", "here", "hers",
+  "herself", "him", "himself", "his", "how", "i", "if", "in", "into", "is",
+  "it", "its", "itself", "just", "know", "let", "like", "make", "may", "me",
+  "might", "more", "most", "must", "my", "myself", "need", "no", "nor", "not",
+  "now", "of", "off", "on", "once", "only", "or", "other", "our", "ours",
+  "ourselves", "out", "over", "own", "please", "really", "right", "same",
+  "shall", "she", "should", "so", "some", "such", "take", "than", "that",
+  "the", "their", "theirs", "them", "themselves", "then", "there", "these",
+  "they", "this", "those", "through", "to", "too", "under", "until", "up",
+  "us", "very", "want", "was", "we", "were", "what", "when", "where", "which",
+  "while", "who", "whom", "why", "will", "with", "would", "you", "your",
+  "yours", "yourself", "yourselves",
+  // Czech
+  "a", "aby", "aj", "ale", "ani", "ano", "asi", "az", "bez", "bude", "budem",
+  "budes", "by", "byl", "byla", "byli", "bylo", "byt", "ci", "co", "dal",
+  "dane", "do", "ho", "i", "ja", "jak", "jako", "je", "jeho", "jej", "jeji",
+  "jen", "jeste", "ji", "jich", "jim", "jine", "jiz", "jsem", "jses", "jsi",
+  "jsme", "jsou", "jste", "k", "kam", "kde", "kdo", "kdyz", "ke", "ktera",
+  "ktere", "kteri", "kterou", "ktery", "ma", "mam", "mate", "me", "mezi",
+  "mi", "mit", "mne", "mnou", "moc", "moje", "moji", "mu", "muze", "my",
+  "na", "nad", "nam", "nami", "nas", "nasi", "ne", "nebo", "nebot", "necht",
+  "nejsou", "neni", "nez", "nic", "nim", "o", "od", "on", "ona", "oni",
+  "ono", "pak", "po", "pod", "podle", "pokud", "potom", "pouze", "prave",
+  "pro", "proc", "proto", "protoze", "prvni", "pred", "presto", "pri", "sam",
+  "se", "si", "sice", "sve", "svou", "svuj", "svych", "svym", "svymi", "ta",
+  "tak", "take", "takze", "tato", "te", "tedy", "ten", "tento", "ti", "tim",
+  "to", "toho", "tohle", "tom", "tomu", "tu", "tuto", "tvuj", "ty", "tyto",
+  "u", "uz", "v", "vam", "vas", "vase", "ve", "vsak", "vse", "vsech",
+  "vsechno", "vsichni", "z", "za", "zda", "zde", "ze",
+]);
+
+export function generateName(prompt: string, maxWords = 4, maxLength = 40): string {
+  const words = prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/-/g, " ")
+    .split(/\s+/)
+    .filter((w) => w.length > 1 && !STOP_WORDS.has(w));
+  let name = "";
+  for (const word of words.slice(0, maxWords)) {
+    const candidate = name ? `${name}-${word}` : word;
+    if (candidate.length > maxLength) break;
+    name = candidate;
+  }
+  return name || "task";
+}

package/src/orchestrator.test.ts

@@ -103,7 +103,8 @@ describe("Orchestrator", () => {
       orch.handleMessage("hello");
       await waitForProcessing();
 
-      expect(claude.calls[0].prompt).toBe("hello");
+      expect(claude.calls[0].prompt).toContain('type="user-message"');
+      expect(claude.calls[0].prompt).toContain("<text>hello</text>");
     });
 
     it("prepends file references for user requests", async () => {
@@ -113,7 +114,9 @@ describe("Orchestrator", () => {
       orch.handleMessage("check this", ["/tmp/photo.jpg", "/tmp/doc.pdf"]);
       await waitForProcessing();
 
-      expect(claude.calls[0].prompt).toBe("[File: /tmp/photo.jpg]\n[File: /tmp/doc.pdf]\ncheck this");
+      expect(claude.calls[0].prompt).toContain('<file path="/tmp/photo.jpg" />');
+      expect(claude.calls[0].prompt).toContain('<file path="/tmp/doc.pdf" />');
+      expect(claude.calls[0].prompt).toContain("<text>check this</text>");
     });
 
     it("sends only file references when message is empty", async () => {
@@ -123,7 +126,8 @@ describe("Orchestrator", () => {
       orch.handleMessage("", ["/tmp/photo.jpg"]);
       await waitForProcessing();
 
-      expect(claude.calls[0].prompt).toBe("[File: /tmp/photo.jpg]");
+      expect(claude.calls[0].prompt).toContain('<file path="/tmp/photo.jpg" />');
+      expect(claude.calls[0].prompt).not.toContain("<text>");
     });
 
     it("builds button click prompt", async () => {
@@ -133,7 +137,7 @@ describe("Orchestrator", () => {
       orch.handleButton("Yes");
       await waitForProcessing();
 
-      expect(claude.calls[0].prompt).toBe('[Context: button-click] User tapped "Yes"');
+      expect(claude.calls[0].prompt).toContain('<button>Yes</button>');
     });
   });
 
@@ -338,9 +342,8 @@ describe("Orchestrator", () => {
       expect(callCount).toBe(2);
       const secondCall = claude.calls[1];
       expect(secondCall.method).toBe("forkSession");
-      expect(secondCall.prompt).toContain("[Context: previous task");
-      expect(secondCall.prompt).toContain("moved to background]");
-      expect(secondCall.prompt).toContain("second");
+      expect(secondCall.prompt).toContain("<backgrounded-event");
+      expect(secondCall.prompt).toContain("<text>second</text>");
 
       // Resolve both
       resolve2(queryResult({ action: "send", message: "second done", actionReason: "ok" }, "q2-sid"));
@@ -405,7 +408,7 @@ describe("Orchestrator", () => {
 
       expect(callCount).toBe(2);
       const userCall = claude.calls[1];
-      expect(userCall.prompt).toContain("[Context: previous task");
+      expect(userCall.prompt).toContain("<backgrounded-event");
       expect(userCall.prompt).toContain("follow up");
       expect(responses.map((r) => r.message)).toContain("forked result");
     });
@@ -451,7 +454,7 @@ describe("Orchestrator", () => {
       orch.handleButton("Yes");
       await waitForProcessing();
 
-      expect(claude.calls[0].prompt).toBe('[Context: button-click] User tapped "Yes"');
+      expect(claude.calls[0].prompt).toContain('<button>Yes</button>');
       expect(responses[0].message).toBe("button response");
     });
 
@@ -503,8 +506,8 @@ describe("Orchestrator", () => {
       await waitForProcessing();
 
       expect(claude.calls[0].method).toBe("forkSession");
-      expect(claude.calls[0].prompt).toContain("[Context: background-agent/cron-daily-check]");
-      expect(claude.calls[0].prompt).toContain("[Context: cron/daily-check] Check for updates");
+      expect(claude.calls[0].prompt).toContain('<schedule name="daily-check" />');
+      expect(claude.calls[0].prompt).toContain("<text>Check for updates</text>");
       expect(claude.calls[0].model).toBe("haiku");
     });
 
@@ -917,6 +920,154 @@ describe("Orchestrator", () => {
     });
   });
 
+  describe("health checks", () => {
+    it("runs health check after interval and reports finished agent", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery } = pendingQuery("bg-sid");
+
+      let callCount = 0;
+      const claude = mockClaude((info: CallInfo): RunningQuery<unknown> => {
+        callCount++;
+        if (callCount === 1) return bgQuery; // background agent spawn
+        if (info.prompt.includes("health-check")) {
+          return resolvedQuery({
+            finished: true,
+            output: { action: "send", message: "task complete", actionReason: "done" },
+          }, "hc-sid");
+        }
+        // Main session processes the background-agent-result
+        return resolvedQuery({ action: "send", message: "relayed", actionReason: "ok" });
+      });
+
+      const { orch } = makeOrchestrator(claude, {
+        healthCheckInterval: 50,
+        healthCheckTimeout: 5000,
+      });
+
+      orch.handleBackgroundCommand("long task");
+      await waitForProcessing(200);
+
+      // Health check should have fired, detected finished, killed original, and pushed result
+      expect(callCount).toBeGreaterThanOrEqual(2);
+      const hcCall = claude.calls.find((c: CallInfo) => c.prompt.includes("health-check"));
+      expect(hcCall).toBeDefined();
+      expect(hcCall!.model).toBe("haiku");
+    });
+
+    it("reports progress and schedules next check when not finished", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery } = pendingQuery("bg-sid");
+
+      let hcCount = 0;
+      const claude = mockClaude((info: CallInfo): RunningQuery<unknown> => {
+        if (info.prompt.includes("health-check")) {
+          hcCount++;
+          return resolvedQuery({ finished: false, progress: "still working" }, "hc-sid");
+        }
+        if (info.prompt.includes("background-agent-result")) {
+          return resolvedQuery({ action: "silent", message: "ok", actionReason: "progress" });
+        }
+        return bgQuery; // background agent spawn
+      });
+
+      const { orch } = makeOrchestrator(claude, {
+        healthCheckInterval: 50,
+        healthCheckTimeout: 5000,
+      });
+
+      orch.handleBackgroundCommand("long task");
+      // Wait for two health check cycles
+      await waitForProcessing(250);
+
+      expect(hcCount).toBeGreaterThanOrEqual(2);
+    });
+
+    it("kills unresponsive agent on health check timeout", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery } = pendingQuery("bg-sid");
+
+      const claude = mockClaude((info: CallInfo): RunningQuery<unknown> => {
+        if (info.prompt.includes("health-check")) {
+          // Never resolves — simulates unresponsive agent
+          return { sessionId: "hc-sid", startedAt: new Date(), result: new Promise(() => {}), kill: mock(async () => {}) };
+        }
+        return bgQuery;
+      });
+
+      const { orch, responses } = makeOrchestrator(claude, {
+        healthCheckInterval: 30,
+        healthCheckTimeout: 60,
+      });
+
+      orch.handleBackgroundCommand("stuck task");
+      await waitForProcessing(200);
+
+      const killMsg = responses.find((r) => r.message.includes("unresponsive"));
+      expect(killMsg).toBeDefined();
+    });
+
+    it("does not run health checks when interval is 0", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery } = pendingQuery("bg-sid");
+
+      const claude = mockClaude((): RunningQuery<unknown> => bgQuery);
+      const { orch } = makeOrchestrator(claude, { healthCheckInterval: 0 });
+
+      orch.handleBackgroundCommand("some task");
+      await waitForProcessing(100);
+
+      // Only the spawn call, no health check fork
+      expect(claude.calls).toHaveLength(1);
+    });
+
+    it("clears health check timer when session is killed", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery } = pendingQuery("bg-sid");
+
+      let hcCount = 0;
+      const claude = mockClaude((info: CallInfo): RunningQuery<unknown> => {
+        if (info.prompt.includes("health-check")) hcCount++;
+        return bgQuery;
+      });
+
+      const { orch } = makeOrchestrator(claude, { healthCheckInterval: 100 });
+
+      orch.handleBackgroundCommand("killable task");
+      await waitForProcessing();
+
+      // Get the session ID and kill it before health check fires
+      orch.handleKill("bg-sid");
+      await waitForProcessing(200);
+
+      expect(hcCount).toBe(0);
+    });
+
+    it("stops health check if session completes organically before timer", async () => {
+      saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+      const { query: bgQuery, resolve: resolveBg } = pendingQuery("bg-sid");
+
+      let hcCount = 0;
+      let callCount = 0;
+      const claude = mockClaude((info: CallInfo): RunningQuery<unknown> => {
+        callCount++;
+        if (info.prompt.includes("health-check")) { hcCount++; return pendingQuery().query; }
+        if (callCount === 1) return bgQuery;
+        return resolvedQuery({ action: "send", message: "processed", actionReason: "ok" });
+      });
+
+      const { orch } = makeOrchestrator(claude, { healthCheckInterval: 200 });
+
+      orch.handleBackgroundCommand("fast task");
+      await waitForProcessing();
+
+      // Complete before health check fires
+      resolveBg(queryResult({ action: "send", message: "done", actionReason: "done" }));
+      await waitForProcessing(350);
+
+      expect(hcCount).toBe(0);
+    });
+  });
+
   describe("onResponse error handling", () => {
     it("logs error and does not throw when onResponse callback fails", async () => {
       const claude = mockClaude({ action: "send", message: "hello", actionReason: "ok" });