@slock-ai/daemon 0.24.0 → 0.26.0

package/dist/chat-bridge.js

@@ -256,62 +256,6 @@ server.tool(
     }
   }
 );
-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;
-      const startTime = Date.now();
-      while (true) {
-        const elapsed = Date.now() - startTime;
-        const remaining = MAX_WAIT_MS - elapsed;
-        if (remaining <= 0) {
-          const params2 = new URLSearchParams();
-          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 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) }] };
-        }
-      }
-    } catch (err) {
-      return {
-        content: [{ type: "text", text: `Error: ${err.message}` }]
-      };
-    }
-  }
-);
 function formatMessages(messages) {
   return messages.map((m) => {
     const target = formatTarget(m);

package/dist/index.js

@@ -98,17 +98,19 @@ function toolRef(prefix, name) {
 }
 function buildBaseSystemPrompt(config, opts) {
   const t = (name) => toolRef(opts.toolPrefix, name);
+  const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
   const criticalRules = [
     `- Do NOT output text directly. ALL communication goes through ${t("send_message")}.`,
     ...opts.extraCriticalRules,
-    `- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.`
+    `- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.`,
+    `- NEVER start working on a task without claiming it first via ${t("claim_tasks")}. If the claim fails, do NOT work on it.`
   ];
   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("wait_for_message")}() to start listening.`,
+    `1. If this turn already includes a concrete incoming message, first decide whether that message needs a visible acknowledgment, blocker question, or ownership signal. If it does, send it early with ${t("send_message")} before deep context gathering.`,
+    `2. Read MEMORY.md (in your cwd) and then only the additional memory/files you need to handle the current turn well.`,
+    `3. If there is no concrete incoming message to handle, stop and wait. ${messageDeliveryText}`,
     `4. When you receive a message, process it and reply with ${t("send_message")}.`,
-    `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.`
+    `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,18 +122,17 @@ 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("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.
+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.
+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.
+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")}
@@ -218,7 +219,7 @@ Each channel has a task board with two independent dimensions: **status** (progr
 - **Unclaim**: \`unclaim_task(channel="#channel-name", task_number=3)\` \u2014 remove your assignment. Does not change progress status.
 - **Update status**: \`update_task_status(channel="#channel-name", task_number=3, status="in_review")\` \u2014 move a task to a new status. Valid transitions: todo\u2192in_progress, in_progress\u2192in_review, in_progress\u2192done, in_review\u2192done, in_review\u2192in_progress.
 
-**CRITICAL: You MUST claim a task before starting work on it.** Never begin working on a task without claiming it first. The claim mechanism prevents multiple agents from doing the same work. If your claim fails (someone else claimed it), move on to another task.
+**CRITICAL: You MUST claim a task before starting ANY work on it.** Call \`${t("claim_tasks")}\` first. If the claim fails (someone else already claimed it), you MUST NOT work on that task \u2014 move on to another one. This is the only way to prevent duplicate work across agents. No exceptions.
 
 **IMPORTANT: When you finish a task, use \`update_task_status(..., status="in_review")\`.** This gives humans a chance to validate your work before it's marked as done. Only set status to \`done\` directly for trivial tasks that don't need review.
 
@@ -251,7 +252,7 @@ Keep the user informed. They cannot see your internal reasoning, so:
 
 - **Don't interrupt ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person \u2014 not at you. Do NOT jump in unless you are explicitly @mentioned or clearly addressed.
 - **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work \u2014 let them respond to questions about it.
-- **Claim before you start.** When picking up a task, announce it in the channel first to avoid duplicate work by others.
+- **Claim before you start.** Always call \`${t("claim_tasks")}\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
 
 ### Formatting \u2014 No HTML
 
@@ -340,7 +341,7 @@ While you are busy (executing tools, thinking, etc.), new messages may arrive. W
 How to handle these:
 - 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.`;
+- \`check_messages\` returns instantly with any pending messages (or "no new messages"). It is always safe to call.`;
   }
   if (config.description) {
     prompt += `
@@ -718,11 +719,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 wait_for_message 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 wait_for_message 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
     });
@@ -803,8 +803,23 @@ function toLocalTime(iso) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
+function formatChannelLabel(message) {
+  return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
+}
+function buildUnreadSummary(messages, excludeChannel) {
+  const summary = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const label = formatChannelLabel(message);
+    if (excludeChannel && label === excludeChannel) continue;
+    summary.set(label, (summary.get(label) || 0) + 1);
+  }
+  return summary.size > 0 ? Object.fromEntries(summary) : void 0;
+}
 var MAX_TRAJECTORY_TEXT = 2e3;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
+function getMessageDeliveryText(supportsStdinNotification) {
+  return supportsStdinNotification ? "New messages will be delivered to you automatically via stdin." : "The daemon will automatically restart you when new messages arrive.";
+}
 var AgentProcessManager = class {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
@@ -814,17 +829,21 @@ var AgentProcessManager = class {
   chatBridgePath;
   sendToServer;
   daemonApiKey;
-  constructor(chatBridgePath2, sendToServer, daemonApiKey) {
+  dataDir;
+  driverResolver;
+  constructor(chatBridgePath2, sendToServer, daemonApiKey, opts = {}) {
     this.chatBridgePath = chatBridgePath2;
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
+    this.dataDir = opts.dataDir || DATA_DIR;
+    this.driverResolver = opts.driverResolver || getDriver;
   }
   async startAgent(agentId, config, wakeMessage, unreadSummary) {
     if (this.agents.has(agentId) || this.agentsStarting.has(agentId)) return;
     this.agentsStarting.add(agentId);
     try {
-      const driver = getDriver(config.runtime || "claude");
-      const agentDataDir = path3.join(DATA_DIR, agentId);
+      const driver = this.driverResolver(config.runtime || "claude");
+      const agentDataDir = path3.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const memoryMdPath = path3.join(agentDataDir, "MEMORY.md");
       try {
@@ -872,9 +891,9 @@ 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 wait_for_message 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 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.`;
+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. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
@@ -888,14 +907,14 @@ Note: While you are busy, you may receive [System notification: ...] messages. F
         }
         prompt += `
 
-Use read_history to catch up on important channels, then call wait_for_message to listen for new messages.`;
+Use read_history to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call check_messages in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: reply with send_message and claim the relevant task before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
 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}wait_for_message to listen for new messages.`;
+        prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver.supportsStdinNotification)}`;
         if (driver.supportsStdinNotification) {
           prompt += `
 
@@ -916,10 +935,9 @@ 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,
         activityHeartbeat: null,
@@ -952,10 +970,6 @@ 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);
           }
@@ -964,6 +978,26 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           }
           this.agents.delete(agentId);
           if (code === 0) {
+            const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
+            const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
+            if (queuedWakeMessage) {
+              const nextConfig = { ...ap.config, sessionId: ap.sessionId };
+              this.idleAgentConfigs.set(agentId, {
+                config: nextConfig,
+                sessionId: ap.sessionId
+              });
+              this.broadcastActivity(agentId, "working", "Message received");
+              this.idleAgentConfigs.delete(agentId);
+              this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2).catch((err) => {
+                console.error(`[Agent ${agentId}] Failed to continue with queued message:`, err);
+                this.idleAgentConfigs.set(agentId, {
+                  config: nextConfig,
+                  sessionId: ap.sessionId
+                });
+                this.broadcastActivity(agentId, "online", "Process idle");
+              });
+              return;
+            }
             this.idleAgentConfigs.set(agentId, {
               config: { ...ap.config, sessionId: ap.sessionId },
               sessionId: ap.sessionId
@@ -989,10 +1023,6 @@ 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);
     }
@@ -1038,19 +1068,14 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       }
       return;
     }
-    if (ap.isInReceiveMessage) {
-      ap.isInReceiveMessage = false;
+    if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+      ap.isIdle = false;
       this.broadcastActivity(agentId, "working", "Message received");
+      this.deliverMessageViaStdin(agentId, ap, message);
+      return;
     }
-    if (ap.pendingReceive) {
-      clearTimeout(ap.pendingReceive.timer);
-      ap.pendingReceive.resolve([message]);
-      ap.pendingReceive = null;
-    } else {
-      ap.inbox.push(message);
-    }
+    ap.inbox.push(message);
     if (!ap.driver.supportsStdinNotification) return;
-    if (ap.isInReceiveMessage) return;
     if (!ap.sessionId) return;
     ap.pendingNotificationCount++;
     if (!ap.notificationTimer) {
@@ -1060,7 +1085,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path3.join(DATA_DIR, agentId);
+    const agentDataDir = path3.join(this.dataDir, agentId);
     try {
       await rm(agentDataDir, { recursive: true, force: true });
       console.log(`[Agent ${agentId}] Workspace deleted: ${agentDataDir}`);
@@ -1081,7 +1106,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const results = [];
     let entries;
     try {
-      entries = await readdir(DATA_DIR, { withFileTypes: true });
+      entries = await readdir(this.dataDir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -1124,7 +1149,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
       return false;
     }
-    const targetDir = path3.join(DATA_DIR, directoryName);
+    const targetDir = path3.join(this.dataDir, directoryName);
     try {
       await rm(targetDir, { recursive: true, force: true });
       console.log(`[Workspace] Deleted directory: ${targetDir}`);
@@ -1136,7 +1161,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path3.join(DATA_DIR, agentId);
+    const agentDir = path3.join(this.dataDir, agentId);
     try {
       await stat(agentDir);
     } catch {
@@ -1153,7 +1178,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path3.join(DATA_DIR, agentId);
+    const agentDir = path3.join(this.dataDir, agentId);
     const resolved = path3.resolve(agentDir, filePath);
     if (!resolved.startsWith(agentDir + path3.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
@@ -1229,40 +1254,34 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         const text = event.text.length > MAX_TRAJECTORY_TEXT ? event.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : event.text;
         const extra = text ? [{ kind: "thinking", text }] : [];
         this.broadcastActivity(agentId, "thinking", "", extra);
-        if (ap) ap.isInReceiveMessage = false;
+        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;
         this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }]);
-        if (ap) ap.isInReceiveMessage = false;
+        if (ap) ap.isIdle = false;
         break;
       }
       case "tool_call": {
         const toolName = event.name;
         const inputSummary = driver.summarizeToolInput(toolName, event.input);
-        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 {
-          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;
-        }
+        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":
-        this.broadcastActivity(agentId, "online", "Turn complete");
         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 });
@@ -1284,7 +1303,7 @@ 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 check_messages to read ${count > 1 ? "them" : "it"} when you're ready.]`;
     console.log(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
@@ -1293,6 +1312,23 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       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.24.0",
+  "version": "0.26.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -32,6 +32,7 @@
     "dev": "tsx watch src/index.ts",
     "start": "tsx src/index.ts",
     "build": "tsup",
+    "test": "node --import tsx --test src/**/*.test.ts",
     "typecheck": "tsc --noEmit",
     "release:patch": "npm version patch --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",
     "release:minor": "npm version minor --no-git-tag-version && cd ../.. && pnpm install --lockfile-only && git add packages/daemon/package.json pnpm-lock.yaml && git commit -m \"chore: bump @slock-ai/daemon to v$(node -p \"require('./packages/daemon/package.json').version\")\" && git tag daemon-v$(node -p \"require('./packages/daemon/package.json').version\") && git push && git push --tags",