@slock-ai/daemon 0.23.0 → 0.24.0

package/dist/chat-bridge.js

@@ -229,12 +229,38 @@ Use your Read tool to view this image.` }]
   }
 );
 server.tool(
-  "receive_message",
-  "Receive new messages. Blocks and waits for new messages (polls internally). Returns messages formatted as [#channel], [dm:@peer], or [thread:#channel:id] followed by the sender and content.",
-  {
-    block: z.boolean().default(true).describe("Whether to block (wait) for new messages")
-  },
-  async ({ block }) => {
+  "check_messages",
+  "Check for new messages without waiting. Returns immediately with any pending messages, or 'No new messages' if none. Use this freely during work \u2014 at natural breakpoints, after notifications, or whenever you want to see if anything new came in.",
+  {},
+  async () => {
+    try {
+      const res = await fetch(
+        `${serverUrl}/internal/agent/${agentId}/receive`,
+        { method: "GET", headers: commonHeaders }
+      );
+      if (!res.ok) {
+        const errData = await res.json().catch(() => ({}));
+        return { content: [{ type: "text", text: `Error: ${errData.error || res.statusText}` }] };
+      }
+      const data = await res.json();
+      if (data.messages?.length > 0) {
+        return { content: [{ type: "text", text: formatMessages(data.messages) }] };
+      }
+      return {
+        content: [{ type: "text", text: "No new messages." }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Error: ${err.message}` }]
+      };
+    }
+  }
+);
+server.tool(
+  "wait_for_message",
+  "Block and wait for new messages. ONLY call this when you have NO work left to do \u2014 all tasks complete, all replies sent, nothing pending. This blocks for up to ~4 minutes waiting for a message to arrive. If you still have work in progress, do NOT call this \u2014 finish your work first.",
+  {},
+  async () => {
     try {
       const POLL_INTERVAL_MS = 25e3;
       const MAX_WAIT_MS = 27e4;
@@ -242,12 +268,10 @@ server.tool(
       while (true) {
         const elapsed = Date.now() - startTime;
         const remaining = MAX_WAIT_MS - elapsed;
-        if (!block || remaining <= 0) {
+        if (remaining <= 0) {
           const params2 = new URLSearchParams();
-          if (block) {
-            params2.set("block", "true");
-            params2.set("timeout", "1000");
-          }
+          params2.set("block", "true");
+          params2.set("timeout", "1000");
           const res2 = await fetch(
             `${serverUrl}/internal/agent/${agentId}/receive?${params2}`,
             { method: "GET", headers: commonHeaders }
@@ -261,7 +285,7 @@ server.tool(
             return { content: [{ type: "text", text: formatMessages(data2.messages) }] };
           }
           return {
-            content: [{ type: "text", text: "No new messages. Take a rest \u2014 new messages will be delivered to you directly. Do not call receive_message or take any further action until notified." }]
+            content: [{ type: "text", text: "No new messages. Take a rest \u2014 new messages will be delivered to you directly. Do not take any further action until notified." }]
           };
         }
         const thisPoll = Math.min(POLL_INTERVAL_MS, remaining);

package/dist/index.js

@@ -106,9 +106,9 @@ function buildBaseSystemPrompt(config, opts) {
   const startupSteps = [
     `1. **Read MEMORY.md** (in your cwd). This is your memory index \u2014 it tells you what you know and where to find it.`,
     `2. Follow the instructions in MEMORY.md to read any other memory files you need (e.g. channel summaries, role definitions, user preferences).`,
-    `3. Call ${t("receive_message")}(block=true) to start listening.`,
+    `3. Call ${t("wait_for_message")}() to start listening.`,
     `4. When you receive a message, process it and reply with ${t("send_message")}.`,
-    `5. After replying, call ${t("receive_message")}(block=true) again to keep listening.`
+    `5. **Only when you have NO more work to do**, call ${t("wait_for_message")}() to wait for new messages. NEVER call wait_for_message while you still have work in progress \u2014 finish all steps first, report your results, then go back to listening.`
   ];
   let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
 
@@ -120,16 +120,18 @@ You are a **long-running, persistent agent**. You are NOT a one-shot assistant \
 
 You have MCP tools from the "chat" server. Use ONLY these for communication:
 
-1. **${t("receive_message")}** \u2014 Call with block=true to wait for messages. This is your main loop.
-2. **${t("send_message")}** \u2014 Send a message to a channel or DM.
-3. **${t("list_server")}** \u2014 List all channels in this server, which ones you have joined, plus all agents and humans.
-4. **${t("read_history")}** \u2014 Read past messages from a channel or DM.
-5. **${t("list_tasks")}** \u2014 View a channel's task board.
-6. **${t("create_tasks")}** \u2014 Create tasks on a channel's task board (supports batch).
-7. **${t("claim_tasks")}** \u2014 Claim tasks by number (supports batch, handles conflicts).
-8. **${t("unclaim_task")}** \u2014 Release your claim on a task.
-9. **${t("update_task_status")}** \u2014 Change a task's status (e.g. to in_review or done).
-10. **${t("upload_file")}** \u2014 Upload an image file to attach to a message. Returns an attachment ID to pass to send_message.
+1. **${t("wait_for_message")}** \u2014 Block and wait for new messages. ONLY use when you have NO work left to do. This is your idle loop.
+2. **${t("check_messages")}** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
+3. **${t("send_message")}** \u2014 Send a message to a channel or DM.
+4. **${t("list_server")}** \u2014 List all channels in this server, which ones you have joined, plus all agents and humans.
+5. **${t("read_history")}** \u2014 Read past messages from a channel or DM.
+6. **${t("list_tasks")}** \u2014 View a channel's task board.
+7. **${t("create_tasks")}** \u2014 Create tasks on a channel's task board (supports batch).
+8. **${t("claim_tasks")}** \u2014 Claim tasks by number (supports batch, handles conflicts).
+9. **${t("unclaim_task")}** \u2014 Release your claim on a task.
+10. **${t("update_task_status")}** \u2014 Change a task's status (e.g. to in_review or done).
+11. **${t("upload_file")}** \u2014 Upload an image file to attach to a message. Returns an attachment ID to pass to send_message.
+12. **${t("view_file")}** \u2014 Download an attached image by its attachment ID so you can view it. Use when messages contain image attachments.
 
 CRITICAL RULES:
 ${criticalRules.join("\n")}
@@ -333,13 +335,12 @@ You may develop a specialized role over time through your interactions. Embrace
 
 While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification like:
 
-\`[System notification: You have N new message(s) waiting. Call receive_message to read them when you're ready.]\`
+\`[System notification: You have N new message(s) waiting. Call check_messages to read them when you're ready.]\`
 
 How to handle these:
-- **Do NOT interrupt your current work.** Finish what you're doing first.
-- After completing your current step, call \`${t("receive_message")}(block=false)\` to check for messages.
-- Do not ignore notifications for too long \u2014 acknowledge new messages in a timely manner.
-- These notifications are batched (you won't get one per message), so the count tells you how many are waiting.`;
+- Call \`${t("check_messages")}()\` to check for new messages. You are encouraged to do this frequently \u2014 at natural breakpoints in your work, or whenever you see a notification.
+- If the new message is higher priority, you may pivot to it. If not, continue your current work.
+- **IMPORTANT: \`${t("check_messages")}\` and \`${t("wait_for_message")}\` are very different tools.** \`check_messages\` returns instantly with any pending messages (or "no new messages"). \`wait_for_message\` blocks for up to ~4 minutes \u2014 ONLY use it when you have absolutely NO work left to do.`;
   }
   if (config.description) {
     prompt += `
@@ -485,6 +486,7 @@ var ClaudeDriver = class {
     if (name === "mcp__chat__update_task_status") return "Updating task status\u2026";
     if (name === "mcp__chat__list_server") return "Listing server\u2026";
     if (name === "mcp__chat__read_history") return "Reading history\u2026";
+    if (name === "mcp__chat__check_messages") return "Checking messages\u2026";
     if (name.startsWith("mcp__chat__")) return "";
     if (name === "Read" || name === "read_file") return "Reading file\u2026";
     if (name === "Write" || name === "write_file") return "Writing file\u2026";
@@ -717,10 +719,10 @@ var CodexDriver = class {
       toolPrefix: "",
       extraCriticalRules: [
         "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything.",
-        "- ALWAYS call receive_message(block=true) after completing any task \u2014 this keeps you listening for new messages."
+        "- ALWAYS call wait_for_message after completing any task \u2014 this keeps you listening for new messages."
       ],
       postStartupNotes: [
-        "**IMPORTANT**: Your process exits after each turn completes. You will be automatically restarted when new messages arrive. Always call receive_message(block=true) as your last action \u2014 if no messages are pending, you'll sleep and be woken when one arrives."
+        "**IMPORTANT**: Your process exits after each turn completes. You will be automatically restarted when new messages arrive. Always call wait_for_message as your last action \u2014 if no messages are pending, you'll sleep and be woken when one arrives."
       ],
       includeStdinNotificationSection: false
     });
@@ -735,6 +737,7 @@ var CodexDriver = class {
     if (name === `${this.mcpToolPrefix}update_task_status`) return "Updating task status\u2026";
     if (name === `${this.mcpToolPrefix}list_server`) return "Listing server\u2026";
     if (name === `${this.mcpToolPrefix}read_history`) return "Reading history\u2026";
+    if (name === `${this.mcpToolPrefix}check_messages`) return "Checking messages\u2026";
     if (name.startsWith(this.mcpToolPrefix)) return "";
     if (name === "shell" || name === "command_execution") return "Running command\u2026";
     if (name === "file_change") return "Editing file\u2026";
@@ -801,6 +804,7 @@ function toLocalTime(iso) {
   return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
 var MAX_TRAJECTORY_TEXT = 2e3;
+var ACTIVITY_HEARTBEAT_MS = 6e4;
 var AgentProcessManager = class {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
@@ -868,11 +872,13 @@ Use read_history to catch up, or respond to the message above first.`;
         }
         prompt += `
 
-Respond as appropriate \u2014 reply using send_message, or take action as needed. Then call receive_message(block=true) to keep listening.`;
+Respond as appropriate \u2014 reply using send_message, or take action as needed. Then call wait_for_message to keep listening.
+
+IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before calling wait_for_message. Sending a progress update does NOT mean your task is done \u2014 only call wait_for_message when you have NO more work to do.`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
-Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
         }
       } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
         prompt = `You have unread messages from while you were offline:`;
@@ -882,18 +888,18 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
         }
         prompt += `
 
-Use read_history to catch up on important channels, then call receive_message(block=true) to listen for new messages.`;
+Use read_history to catch up on important channels, then call wait_for_message to listen for new messages.`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
-Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.`;
         }
       } else if (isResume) {
-        prompt = `No new messages while you were away. Call ${driver.mcpToolPrefix}receive_message(block=true) to listen for new messages.`;
+        prompt = `No new messages while you were away. Call ${driver.mcpToolPrefix}wait_for_message to listen for new messages.`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
-Note: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call receive_message to check.`;
+Note: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call check_messages to check for messages.`;
         }
       } else {
         prompt = driver.buildSystemPrompt(config, agentId);
@@ -915,7 +921,10 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         sessionId: config.sessionId || null,
         isInReceiveMessage: false,
         notificationTimer: null,
-        pendingNotificationCount: 0
+        pendingNotificationCount: 0,
+        activityHeartbeat: null,
+        lastActivity: "",
+        lastActivityDetail: ""
       };
       this.agents.set(agentId, agentProcess);
       this.agentsStarting.delete(agentId);
@@ -950,24 +959,27 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           if (ap.notificationTimer) {
             clearTimeout(ap.notificationTimer);
           }
+          if (ap.activityHeartbeat) {
+            clearInterval(ap.activityHeartbeat);
+          }
           this.agents.delete(agentId);
           if (code === 0) {
             this.idleAgentConfigs.set(agentId, {
               config: { ...ap.config, sessionId: ap.sessionId },
               sessionId: ap.sessionId
             });
-            this.sendToServer({ type: "agent:activity", agentId, activity: "online", detail: "" });
+            this.broadcastActivity(agentId, "online", "Process idle");
           } else {
             this.idleAgentConfigs.delete(agentId);
             const reason = code === null ? "killed by signal" : `exit code ${code}`;
             console.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
             this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
-            this.sendToServer({ type: "agent:activity", agentId, activity: "offline", detail: `Crashed (${reason})` });
+            this.broadcastActivity(agentId, "offline", `Crashed (${reason})`);
           }
         }
       });
       this.sendToServer({ type: "agent:status", agentId, status: "active" });
-      this.sendToServer({ type: "agent:activity", agentId, activity: "working", detail: "Starting\u2026" });
+      this.broadcastActivity(agentId, "working", "Starting\u2026");
     } catch (err) {
       this.agentsStarting.delete(agentId);
       throw err;
@@ -984,11 +996,14 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (ap.notificationTimer) {
       clearTimeout(ap.notificationTimer);
     }
+    if (ap.activityHeartbeat) {
+      clearInterval(ap.activityHeartbeat);
+    }
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
     if (!silent) {
       this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
-      this.sendToServer({ type: "agent:activity", agentId, activity: "offline", detail: "" });
+      this.broadcastActivity(agentId, "offline", "Stopped");
     }
     if (wait) {
       await new Promise((resolve) => {
@@ -1023,6 +1038,10 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       }
       return;
     }
+    if (ap.isInReceiveMessage) {
+      ap.isInReceiveMessage = false;
+      this.broadcastActivity(agentId, "working", "Message received");
+    }
     if (ap.pendingReceive) {
       clearTimeout(ap.pendingReceive.timer);
       ap.pendingReceive.resolve([message]);
@@ -1169,11 +1188,37 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     return { content, binary: false };
   }
   // Private methods
+  /**
+   * Broadcast an activity change — emits a single agent:activity event that carries
+   * both the status (for the dot indicator) and trajectory entries (for the activity log).
+   */
+  broadcastActivity(agentId, activity, detail, extraTrajectory = []) {
+    const ap = this.agents.get(agentId);
+    const entries = [...extraTrajectory];
+    const hasToolStart = entries.some((e) => e.kind === "tool_start");
+    if (!hasToolStart) {
+      entries.push({ kind: "status", activity, detail });
+    }
+    this.sendToServer({ type: "agent:activity", agentId, activity, detail, entries });
+    if (ap) {
+      ap.lastActivity = activity;
+      ap.lastActivityDetail = detail;
+      if (activity === "working" || activity === "thinking") {
+        if (!ap.activityHeartbeat) {
+          ap.activityHeartbeat = setInterval(() => {
+            this.sendToServer({ type: "agent:activity", agentId, activity: ap.lastActivity, detail: ap.lastActivityDetail });
+          }, ACTIVITY_HEARTBEAT_MS);
+        }
+      } else {
+        if (ap.activityHeartbeat) {
+          clearInterval(ap.activityHeartbeat);
+          ap.activityHeartbeat = null;
+        }
+      }
+    }
+  }
   /** Handle a single ParsedEvent from any runtime driver */
   handleParsedEvent(agentId, event, driver) {
-    const trajectory = [];
-    let activity = "";
-    let detail = "";
     const ap = this.agents.get(agentId);
     switch (event.kind) {
       case "session_init":
@@ -1182,54 +1227,39 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         break;
       case "thinking": {
         const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
-        trajectory.push({ kind: "thinking", text });
-        activity = "thinking";
+        const extra = text ? [{ kind: "thinking", text }] : [];
+        this.broadcastActivity(agentId, "thinking", "", extra);
         if (ap) ap.isInReceiveMessage = false;
         break;
       }
       case "text": {
         const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
-        trajectory.push({ kind: "text", text });
-        activity = "thinking";
+        this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }]);
         if (ap) ap.isInReceiveMessage = false;
         break;
       }
       case "tool_call": {
         const toolName = event.name;
         const inputSummary = driver.summarizeToolInput(toolName, event.input);
-        if (toolName === `${driver.mcpToolPrefix}receive_message`) {
-          const isBlocking = event.input?.block === true || event.input?.block === "true";
-          if (isBlocking) {
-            activity = "online";
-            if (ap) {
-              ap.isInReceiveMessage = true;
-              ap.pendingNotificationCount = 0;
-              if (ap.notificationTimer) {
-                clearTimeout(ap.notificationTimer);
-                ap.notificationTimer = null;
-              }
+        if (toolName === `${driver.mcpToolPrefix}wait_for_message`) {
+          this.broadcastActivity(agentId, "online", "Idle");
+          if (ap) {
+            ap.isInReceiveMessage = true;
+            ap.pendingNotificationCount = 0;
+            if (ap.notificationTimer) {
+              clearTimeout(ap.notificationTimer);
+              ap.notificationTimer = null;
             }
-          } else {
-            trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
-            activity = "working";
-            detail = "Checking messages\u2026";
-            if (ap) ap.isInReceiveMessage = false;
           }
-        } else if (toolName === `${driver.mcpToolPrefix}send_message`) {
-          trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
-          activity = "working";
-          detail = "Sending message\u2026";
-          if (ap) ap.isInReceiveMessage = false;
         } else {
-          trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
-          activity = "working";
-          detail = driver.toolDisplayName(toolName);
+          const detail = toolName === `${driver.mcpToolPrefix}check_messages` ? "Checking messages\u2026" : toolName === `${driver.mcpToolPrefix}send_message` ? "Sending message\u2026" : driver.toolDisplayName(toolName);
+          this.broadcastActivity(agentId, "working", detail, [{ kind: "tool_start", toolName, toolInput: inputSummary }]);
           if (ap) ap.isInReceiveMessage = false;
         }
         break;
       }
       case "turn_end":
-        activity = "online";
+        this.broadcastActivity(agentId, "online", "Turn complete");
         if (ap) {
           ap.isInReceiveMessage = false;
           if (event.sessionId) ap.sessionId = event.sessionId;
@@ -1238,20 +1268,13 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
         }
         break;
-      case "error":
-        trajectory.push({ kind: "text", text: `Error: ${event.message}` });
+      case "error": {
+        const currentActivity = ap?.lastActivity || "working";
+        const currentDetail = ap?.lastActivityDetail || "";
+        this.sendToServer({ type: "agent:activity", agentId, activity: currentActivity, detail: currentDetail, entries: [{ kind: "text", text: `Error: ${event.message}` }] });
         break;
-    }
-    if (activity) {
-      this.sendToServer({ type: "agent:activity", agentId, activity, detail });
-      const hasToolStart = trajectory.some((e) => e.kind === "tool_start");
-      if (!hasToolStart) {
-        trajectory.push({ kind: "status", activity, detail });
       }
     }
-    if (trajectory.length > 0) {
-      this.sendToServer({ type: "agent:trajectory", agentId, entries: trajectory });
-    }
   }
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
@@ -1263,7 +1286,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (count === 0) return;
     if (ap.isInReceiveMessage) return;
     if (!ap.sessionId) return;
-    const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call receive_message to read ${count > 1 ? "them" : "it"} when you're ready.]`;
+    const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call check_messages to read ${count > 1 ? "them" : "it"} when you're ready.]`;
     console.log(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId);
     if (encoded) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"