@slock-ai/daemon 0.23.0 → 0.25.0

package/dist/chat-bridge.js

@@ -229,58 +229,26 @@ 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 POLL_INTERVAL_MS = 25e3;
-      const MAX_WAIT_MS = 27e4;
-      const startTime = Date.now();
-      while (true) {
-        const elapsed = Date.now() - startTime;
-        const remaining = MAX_WAIT_MS - elapsed;
-        if (!block || remaining <= 0) {
-          const params2 = new URLSearchParams();
-          if (block) {
-            params2.set("block", "true");
-            params2.set("timeout", "1000");
-          }
-          const res2 = await fetch(
-            `${serverUrl}/internal/agent/${agentId}/receive?${params2}`,
-            { method: "GET", headers: commonHeaders }
-          );
-          if (!res2.ok) {
-            const errData = await res2.json().catch(() => ({}));
-            return { content: [{ type: "text", text: `Error: ${errData.error || res2.statusText}` }] };
-          }
-          const data2 = await res2.json();
-          if (data2.messages?.length > 0) {
-            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." }]
-          };
-        }
-        const thisPoll = Math.min(POLL_INTERVAL_MS, remaining);
-        const params = new URLSearchParams();
-        params.set("block", "true");
-        params.set("timeout", String(thisPoll));
-        const res = await fetch(
-          `${serverUrl}/internal/agent/${agentId}/receive?${params}`,
-          { 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) }] };
-        }
+      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}` }]

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. Stop and wait. New messages will be delivered to you automatically via stdin.`,
     `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. **Complete ALL your work before stopping.** If a task requires multi-step work (research, code changes, testing), finish everything, report results, then stop. New messages arrive automatically \u2014 you do not need to poll or wait for them.`
   ];
   let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
 
@@ -120,7 +120,7 @@ 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.
+1. **${t("check_messages")}** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
 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.
@@ -130,6 +130,7 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 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.
+11. **${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 +334,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.
+- \`check_messages\` returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
   }
   if (config.description) {
     prompt += `
@@ -485,6 +485,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";
@@ -716,11 +717,10 @@ var CodexDriver = class {
     return buildBaseSystemPrompt(config, {
       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."
+        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
       ],
       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. Complete all your work, then stop \u2014 new messages will wake you up."
       ],
       includeStdinNotificationSection: false
     });
@@ -735,6 +735,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 +802,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 +870,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. Complete ALL your work before stopping.
+
+IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. New messages will be delivered to you automatically via stdin.`;
         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 +886,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 stop. New messages will be delivered to you automatically.`;
         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. Nothing to do \u2014 just stop. New messages will be delivered to you automatically via stdin.`;
         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);
@@ -910,12 +914,14 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         process: proc,
         driver,
         inbox: [],
-        pendingReceive: null,
         config,
         sessionId: config.sessionId || null,
-        isInReceiveMessage: false,
+        isIdle: false,
         notificationTimer: null,
-        pendingNotificationCount: 0
+        pendingNotificationCount: 0,
+        activityHeartbeat: null,
+        lastActivity: "",
+        lastActivityDetail: ""
       };
       this.agents.set(agentId, agentProcess);
       this.agentsStarting.delete(agentId);
@@ -943,31 +949,30 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         if (this.agents.has(agentId)) {
           const ap = this.agents.get(agentId);
           if (ap.process !== proc) return;
-          if (ap.pendingReceive) {
-            clearTimeout(ap.pendingReceive.timer);
-            ap.pendingReceive.resolve([]);
-          }
           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;
@@ -977,18 +982,17 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     this.idleAgentConfigs.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) return;
-    if (ap.pendingReceive) {
-      clearTimeout(ap.pendingReceive.timer);
-      ap.pendingReceive.resolve([]);
-    }
     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,15 +1027,14 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       }
       return;
     }
-    if (ap.pendingReceive) {
-      clearTimeout(ap.pendingReceive.timer);
-      ap.pendingReceive.resolve([message]);
-      ap.pendingReceive = null;
-    } else {
-      ap.inbox.push(message);
+    if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+      ap.isIdle = false;
+      this.broadcastActivity(agentId, "working", "Message received");
+      this.deliverMessageViaStdin(agentId, ap, message);
+      return;
     }
+    ap.inbox.push(message);
     if (!ap.driver.supportsStdinNotification) return;
-    if (ap.isInReceiveMessage) return;
     if (!ap.sessionId) return;
     ap.pendingNotificationCount++;
     if (!ap.notificationTimer) {
@@ -1169,11 +1172,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,76 +1211,48 @@ 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";
-        if (ap) ap.isInReceiveMessage = false;
+        const extra = text ? [{ kind: "thinking", text }] : [];
+        this.broadcastActivity(agentId, "thinking", "", extra);
+        if (ap) ap.isIdle = 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";
-        if (ap) ap.isInReceiveMessage = false;
+        this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }]);
+        if (ap) ap.isIdle = 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;
-              }
-            }
-          } 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);
-          if (ap) ap.isInReceiveMessage = false;
-        }
+        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.isIdle = false;
         break;
       }
       case "turn_end":
-        activity = "online";
         if (ap) {
-          ap.isInReceiveMessage = false;
           if (event.sessionId) ap.sessionId = event.sessionId;
+          if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
+            const nextMessage = ap.inbox.shift();
+            this.broadcastActivity(agentId, "working", "Message received");
+            this.deliverMessageViaStdin(agentId, ap, nextMessage);
+          } else {
+            ap.isIdle = true;
+            this.broadcastActivity(agentId, "online", "Idle");
+          }
         }
         if (event.sessionId) {
           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) {
@@ -1261,15 +1262,32 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     ap.pendingNotificationCount = 0;
     ap.notificationTimer = null;
     if (count === 0) return;
-    if (ap.isInReceiveMessage) return;
+    if (ap.isIdle) 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) {
       ap.process.stdin?.write(encoded + "\n");
     }
   }
+  /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
+  deliverMessageViaStdin(agentId, ap, message) {
+    const channelLabel = message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
+    const senderPrefix = message.sender_type === "agent" ? "(agent) " : "";
+    const time = message.timestamp ? ` (${toLocalTime(message.timestamp)})` : "";
+    const formatted = `[${channelLabel}]${time} ${senderPrefix}@${message.sender_name}: ${message.content}`;
+    const prompt = `New message received:
+
+${formatted}
+
+Respond as appropriate. Complete all your work before stopping.`;
+    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId);
+    if (encoded) {
+      console.log(`[Agent ${agentId}] Delivering message via stdin from @${message.sender_name}`);
+      ap.process.stdin?.write(encoded + "\n");
+    }
+  }
   /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
   async listDirectoryChildren(dir, rootDir) {
     let entries;

package/package.json

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