@slock-ai/daemon 0.30.0 → 0.30.1-alpha.0

package/dist/chat-bridge.js

@@ -470,7 +470,7 @@ ${formatted}`
 );
 server.tool(
   "create_tasks",
-  "Create one or more new tasks in a channel. Each task becomes a message in the chat flow with an assigned task number. Returns task numbers and message IDs. After creating, claim the task before starting work on it. Do not use this to convert an existing message \u2014 use claim_tasks with message_ids instead.",
+  "Create one or more new task-messages in a top-level channel or DM. This is a convenience helper for creating a brand-new message and publishing it as a task-message in the chat flow. Thread messages cannot become tasks. It does not claim the task for you; if you want to own it, still call claim_tasks afterward. It is not a separate task board outside the chat flow. Typical uses are breaking down a larger task into parallel subtasks or batch-creating new work for others to claim. Do not use this to convert an existing message \u2014 use claim_tasks with message_ids instead. If the work already exists as a task, either claim that task or leave it alone; do not create a second task/message for the same work.",
   {
     channel: z.string().describe("The channel to create tasks in \u2014 e.g. '#engineering'"),
     tasks: z.array(
@@ -519,13 +519,13 @@ server.tool(
   "claim_tasks",
   `Claim tasks so you are assigned to work on them. Two modes:
 1. By task number: claim existing tasks shown in list_tasks. Use task_numbers=[1, 3].
-2. By message ID: convert a regular message into a task and claim it. Use message_ids=["a1b2c3d4"]. The message ID is the 8-character msg= value from received messages or read_history.
+2. By message ID: convert a regular top-level message into a task and claim it. Use message_ids=["a1b2c3d4"]. The message ID is the 8-character msg= value from received messages or read_history.
 
-If a task is in "todo" status, claiming auto-advances it to "in_progress". If another agent already claimed it, the claim fails \u2014 do not work on that task, move on. Always claim before starting any work to prevent duplicate effort.`,
+Thread messages cannot be claimed or converted into tasks. If a task is in "todo" status, claiming auto-advances it to "in_progress". If another agent already claimed it, the claim fails \u2014 do not work on that task, move on. Always claim before starting any work to prevent duplicate effort.`,
   {
     channel: z.string().describe("The channel \u2014 e.g. '#engineering'"),
     task_numbers: z.array(z.number()).optional().describe("Task numbers to claim (from list_tasks output, e.g. [1, 3])"),
-    message_ids: z.array(z.string()).optional().describe("Message IDs or short ID prefixes (the 8-char msg= value, e.g. ['a1b2c3d4']). Converts the message to a task and claims it.")
+    message_ids: z.array(z.string()).optional().describe("Message IDs or short ID prefixes (the 8-char msg= value, e.g. ['a1b2c3d4']). Converts a regular top-level message to a task and claims it. Thread messages are not allowed.")
   },
   async ({ channel, task_numbers, message_ids }) => {
     try {

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path4 from "path";
+import path5 from "path";
 import os2 from "os";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
@@ -10,6 +10,33 @@ import { fileURLToPath } from "url";
 
 // src/connection.ts
 import WebSocket from "ws";
+
+// src/logger.ts
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  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 format(level, msg) {
+  return `${timestamp()} [${level}] ${msg}`;
+}
+var logger = {
+  info(msg) {
+    console.log(format("INFO", msg));
+  },
+  warn(msg) {
+    console.warn(format("WARN", msg));
+  },
+  error(msg, err) {
+    if (err) {
+      console.error(format("ERROR", msg), err);
+    } else {
+      console.error(format("ERROR", msg));
+    }
+  }
+};
+
+// src/connection.ts
 var systemClock = {
   now: () => Date.now(),
   setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -46,7 +73,7 @@ var DaemonConnection = class {
       this.reconnectTimer = null;
     }
     if (this.ws) {
-      console.log("[Daemon] Disconnect requested");
+      logger.info("[Daemon] Disconnect requested");
       this.ws.close();
       this.ws = null;
     }
@@ -59,7 +86,7 @@ var DaemonConnection = class {
     const now = this.clock.now();
     if (now - this.lastDroppedSendLogAt > 5e3) {
       this.lastDroppedSendLogAt = now;
-      console.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
+      logger.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
     }
   }
   get connected() {
@@ -69,13 +96,13 @@ var DaemonConnection = class {
     if (!this.shouldConnect) return;
     if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return;
     const wsUrl = this.options.serverUrl.replace(/^http/, "ws") + `/daemon/connect?key=${this.options.apiKey}`;
-    console.log(`[Daemon] Connecting to ${this.options.serverUrl}...`);
+    logger.info(`[Daemon] Connecting to ${this.options.serverUrl}...`);
     const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl) : new WebSocket(wsUrl);
     this.ws = ws;
     ws.on("open", () => {
       if (this.ws !== ws) return;
       if (!this.shouldConnect) return;
-      console.log("[Daemon] Connected to server");
+      logger.info("[Daemon] Connected to server");
       this.reconnectAttempt = 0;
       this.reconnectDelay = this.options.minReconnectDelayMs ?? 1e3;
       this.resetWatchdog();
@@ -88,7 +115,7 @@ var DaemonConnection = class {
         const msg = JSON.parse(data.toString());
         this.options.onMessage(msg);
       } catch (err) {
-        console.error("[Daemon] Invalid message from server:", err);
+        logger.error("[Daemon] Invalid message from server", err);
       }
     });
     ws.on("close", (code, reasonBuffer) => {
@@ -96,7 +123,7 @@ var DaemonConnection = class {
       this.ws = null;
       this.clearWatchdog();
       const reason = reasonBuffer.toString("utf8");
-      console.log(
+      logger.warn(
         `[Daemon] Disconnected from server (code=${code}, reason=${JSON.stringify(reason)}, reconnecting=${this.shouldConnect})`
       );
       this.options.onDisconnect();
@@ -104,14 +131,14 @@ var DaemonConnection = class {
     });
     ws.on("error", (err) => {
       if (this.ws !== ws) return;
-      console.error("[Daemon] WebSocket error:", err.message);
+      logger.error(`[Daemon] WebSocket error: ${err.message}`);
     });
   }
   scheduleReconnect() {
     if (!this.shouldConnect) return;
     if (this.reconnectTimer) return;
     this.reconnectAttempt += 1;
-    console.log(`[Daemon] Reconnecting to server in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempt})`);
+    logger.info(`[Daemon] Reconnecting to server in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempt})`);
     this.reconnectTimer = this.clock.setTimeout(() => {
       this.reconnectTimer = null;
       this.doConnect();
@@ -122,7 +149,7 @@ var DaemonConnection = class {
     this.clearWatchdog();
     const ms = this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS;
     this.watchdogTimer = this.clock.setTimeout(() => {
-      console.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
+      logger.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
       try {
         this.ws?.terminate();
       } catch {
@@ -139,7 +166,7 @@ var DaemonConnection = class {
 
 // src/agentProcessManager.ts
 import { mkdir, writeFile, access, readdir, stat, readFile, rm } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import os from "os";
 
 // src/drivers/claude.ts
@@ -182,7 +209,7 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 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).
+6. **${t("create_tasks")}** \u2014 Create new task-messages in a channel (supports batch; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
 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).
@@ -266,6 +293,8 @@ When someone sends a message that asks you to do something \u2014 fix a bug, wri
 - A regular message (no task suffix): \`@Alice: Can someone look into the login bug?\`
 - A system notification about task changes: \`\u{1F4CB} Alice converted a message to task #3 "Fix the login bug"\`
 
+Only top-level channel / DM messages can become tasks. Messages inside threads are discussion context: reply there, but do not claim or convert them as tasks.
+
 \`read_history\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
 
 **Status flow:** \`todo\` \u2192 \`in_progress\` \u2192 \`in_review\` \u2192 \`done\`
@@ -279,6 +308,21 @@ When someone sends a message that asks you to do something \u2014 fix a bug, wri
 4. When done, set status to \`in_review\` so a human can validate
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
+**What \`${t("create_tasks")}\` really means:**
+- Tasks live in the same chat flow as messages. A task is just a message with task metadata, not a separate source of truth.
+- \`${t("create_tasks")}\` is a convenience helper for a specific sequence: create a brand-new message, then publish that new message as a task-message.
+- \`${t("create_tasks")}\` does NOT claim the new task for you. If you want to own it, still call \`${t("claim_tasks")}\` afterward.
+- Typical uses for \`${t("create_tasks")}\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
+- If someone already sent the small work item as a message, you usually do NOT need \`${t("create_tasks")}\` \u2014 just claim that existing message/task.
+- If the work already exists as a message, do NOT use \`${t("create_tasks")}\` for it. Reuse the existing message via \`${t("claim_tasks")}\` with \`message_ids\`.
+
+**Creating new tasks:**
+- The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
+- If a message already shows a \`[task #N ...]\` suffix, do NOT create a second message/task for the same work. Claim \`#N\` if it is yours to take; otherwise move on.
+- Before calling \`${t("create_tasks")}\`, first check whether the work already exists as a message-backed task on the task board or is already being handled by someone else.
+- Do NOT create a second task that merely restates an existing request, message, or task. Reuse the existing task/thread instead.
+- Use \`${t("create_tasks")}\` only for genuinely new subtasks or follow-up work that does not already have a canonical task.
+
 ### Splitting tasks for parallel execution
 
 When you need to break down a large task into subtasks, structure them so agents can work **in parallel**:
@@ -552,7 +596,7 @@ var ClaudeDriver = class {
     }
     return events;
   }
-  encodeStdinMessage(text, sessionId) {
+  encodeStdinMessage(text, sessionId, _opts) {
     return JSON.stringify({
       type: "user",
       message: {
@@ -807,7 +851,7 @@ var CodexDriver = class {
     }
     return events;
   }
-  encodeStdinMessage(_text, _sessionId) {
+  encodeStdinMessage(_text, _sessionId, _opts) {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
@@ -877,21 +921,247 @@ var CodexDriver = class {
   }
 };
 
+// src/drivers/kimi.ts
+import { randomUUID } from "crypto";
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
+import path3 from "path";
+var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
+var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
+var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
+var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+function parseToolArguments(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+var KimiDriver = class {
+  id = "kimi";
+  supportsStdinNotification = true;
+  mcpToolPrefix = "";
+  deliverMessageDirectlyWhileBusy = true;
+  sessionId = null;
+  sessionAnnounced = false;
+  promptRequestId = null;
+  spawn(ctx) {
+    const isResume = !!ctx.config.sessionId;
+    this.sessionId = ctx.config.sessionId || randomUUID();
+    this.sessionAnnounced = false;
+    this.promptRequestId = randomUUID();
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const command = isTsSource ? "npx" : "node";
+    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey] : [ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey];
+    const systemPromptPath = path3.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path3.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const mcpConfigPath = path3.join(ctx.workingDirectory, KIMI_MCP_FILE);
+    if (!isResume || !existsSync2(systemPromptPath)) {
+      writeFileSync2(systemPromptPath, ctx.prompt, "utf8");
+    }
+    writeFileSync2(agentFilePath, [
+      "version: 1",
+      "agent:",
+      "  extend: default",
+      `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
+      ""
+    ].join("\n"), "utf8");
+    writeFileSync2(mcpConfigPath, JSON.stringify({
+      mcpServers: {
+        chat: {
+          command,
+          args: bridgeArgs
+        }
+      }
+    }), "utf8");
+    const args2 = [
+      "--wire",
+      "--yolo",
+      "--agent-file",
+      agentFilePath,
+      "--mcp-config-file",
+      mcpConfigPath,
+      "--session",
+      this.sessionId
+    ];
+    if (ctx.config.model && ctx.config.model !== "default") {
+      args2.push("--model", ctx.config.model);
+    }
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
+    const proc = spawn3("kimi", args2, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell: process.platform === "win32"
+    });
+    proc.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id: randomUUID(),
+      method: "initialize",
+      params: {
+        protocol_version: KIMI_WIRE_PROTOCOL_VERSION,
+        client: { name: "slock-daemon", version: "1.0.0" },
+        capabilities: {
+          supports_question: false,
+          supports_plan_mode: false
+        }
+      }
+    }) + "\n");
+    proc.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      id: this.promptRequestId,
+      method: "prompt",
+      params: {
+        user_input: isResume ? ctx.prompt : "Your system prompt contains your standing instructions. Follow it now and begin listening for messages."
+      }
+    }) + "\n");
+    return { process: proc };
+  }
+  parseLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    if ("method" in message && message.method === "event") {
+      const eventType = message.params?.type;
+      const payload = message.params?.payload || {};
+      switch (eventType) {
+        case "StepBegin":
+          events.push({ kind: "thinking", text: "" });
+          break;
+        case "ContentPart":
+          if (payload.type === "think" && payload.think) {
+            events.push({ kind: "thinking", text: payload.think });
+          } else if (payload.type === "text" && payload.text) {
+            events.push({ kind: "text", text: payload.text });
+          }
+          break;
+        case "ToolCall":
+          events.push({
+            kind: "tool_call",
+            name: payload.function?.name || "unknown_tool",
+            input: parseToolArguments(payload.function?.arguments)
+          });
+          break;
+        case "TurnEnd":
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+          break;
+        case "StepInterrupted":
+          events.push({ kind: "error", message: "Turn interrupted" });
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+          break;
+      }
+      return events;
+    }
+    if ("error" in message) {
+      events.push({ kind: "error", message: message.error?.message || "Unknown Kimi error" });
+      events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, opts) {
+    const mode = opts?.mode || "busy";
+    if (mode === "idle") {
+      return JSON.stringify({
+        jsonrpc: "2.0",
+        id: randomUUID(),
+        method: "prompt",
+        params: {
+          user_input: _text
+        }
+      });
+    }
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      id: randomUUID(),
+      method: "steer",
+      params: {
+        user_input: _text
+      }
+    });
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildBaseSystemPrompt(config, {
+      toolPrefix: "",
+      extraCriticalRules: [
+        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
+      ],
+      postStartupNotes: [],
+      includeStdinNotificationSection: true
+    });
+  }
+  toolDisplayName(name) {
+    if (name === "list_tasks") return "Viewing task board\u2026";
+    if (name === "create_tasks") return "Creating tasks\u2026";
+    if (name === "claim_tasks") return "Claiming tasks\u2026";
+    if (name === "unclaim_task") return "Unclaiming task\u2026";
+    if (name === "update_task_status") return "Updating task\u2026";
+    if (name === "send_message" || name === "receive_message" || name === "read_history" || name === "list_server") return "";
+    if (name === "Shell") return "Running command\u2026";
+    if (name === "ReadFile") return "Reading file\u2026";
+    if (name === "WriteFile" || name === "StrReplaceFile") return "Editing file\u2026";
+    if (name === "Glob" || name === "Grep") return "Searching code\u2026";
+    if (name === "SearchWeb") return "Searching web\u2026";
+    if (name === "FetchURL") return "Fetching web\u2026";
+    if (name === "SetTodoList") return "Updating tasks\u2026";
+    return `Using ${name.length > 20 ? name.slice(0, 20) + "\u2026" : name}\u2026`;
+  }
+  summarizeToolInput(name, input) {
+    if (!input || typeof input !== "object") return "";
+    try {
+      if (name === "Shell") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "ReadFile" || name === "WriteFile" || name === "StrReplaceFile") {
+        return input.path || "";
+      }
+      if (name === "Glob" || name === "Grep") return input.pattern || input.query || "";
+      if (name === "SearchWeb") return input.query || "";
+      if (name === "FetchURL") return input.url || "";
+      if (name === "send_message") return input.target || input.channel || "";
+      if (name === "read_history") return input.target || input.channel || "";
+      if (name === "list_tasks") return input.channel || "";
+      if (name === "create_tasks") return input.channel || "";
+      if (name === "claim_tasks") {
+        const nums = input.task_numbers;
+        return input.channel ? `${input.channel} #t${Array.isArray(nums) ? nums.join(",#t") : nums}` : "";
+      }
+      if (name === "unclaim_task" || name === "update_task_status") {
+        return input.channel ? `${input.channel} #t${input.task_number}` : "";
+      }
+      return "";
+    } catch {
+      return "";
+    }
+  }
+};
+
 // src/drivers/index.ts
-var drivers = {
-  claude: new ClaudeDriver(),
-  codex: new CodexDriver()
+var driverFactories = {
+  claude: () => new ClaudeDriver(),
+  codex: () => new CodexDriver(),
+  kimi: () => new KimiDriver()
 };
 function getDriver(runtimeId) {
-  const driver = drivers[runtimeId];
+  const createDriver = driverFactories[runtimeId];
+  const driver = createDriver?.();
   if (!driver) {
-    throw new Error(`Unknown runtime: ${runtimeId}. Available: ${Object.keys(drivers).join(", ")}`);
+    throw new Error(`Unknown runtime: ${runtimeId}. Available: ${Object.keys(driverFactories).join(", ")}`);
   }
   return driver;
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path3.join(os.homedir(), ".slock", "agents");
+var DATA_DIR = path4.join(os.homedir(), ".slock", "agents");
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -901,6 +1171,28 @@ function toLocalTime(iso) {
 function formatChannelLabel(message) {
   return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
 }
+function formatMessageTarget(message) {
+  if (message.channel_type === "thread" && message.parent_channel_name) {
+    const shortId = message.channel_name.startsWith("thread-") ? message.channel_name.slice(7) : message.channel_name;
+    if (message.parent_channel_type === "dm") {
+      return `dm:@${message.parent_channel_name}:${shortId}`;
+    }
+    return `#${message.parent_channel_name}:${shortId}`;
+  }
+  if (message.channel_type === "dm") {
+    return `dm:@${message.channel_name}`;
+  }
+  return `#${message.channel_name}`;
+}
+function formatIncomingMessage(message) {
+  const target = formatMessageTarget(message);
+  const msgId = message.message_id ? message.message_id.slice(0, 8) : "-";
+  const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
+  const senderType = message.sender_type === "agent" ? " type=agent" : "";
+  const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} image${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to see]` : "";
+  const taskSuffix = message.task_status ? ` [task #${message.task_number} status=${message.task_status}${message.task_assignee_id ? ` assignee=${message.task_assignee_type}:${message.task_assignee_id}` : ""}]` : "";
+  return `[target=${target} msg=${msgId} time=${time}${senderType}] @${message.sender_name}: ${message.content}${attachSuffix}${taskSuffix}`;
+}
 function buildUnreadSummary(messages, excludeChannel) {
   const summary = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -911,6 +1203,7 @@ function buildUnreadSummary(messages, excludeChannel) {
   return summary.size > 0 ? Object.fromEntries(summary) : void 0;
 }
 var MAX_TRAJECTORY_TEXT = 2e3;
+var TRAJECTORY_COALESCE_MS = 350;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
 var MAX_STDOUT_LINES = 8;
 var MAX_STDOUT_LINE_LENGTH = 240;
@@ -988,21 +1281,21 @@ var AgentProcessManager = class _AgentProcessManager {
     this.dataDir = opts.dataDir || DATA_DIR;
     this.driverResolver = opts.driverResolver || getDriver;
   }
-  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt) {
+  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
     if (this.agents.has(agentId)) {
-      console.log(`[Agent ${agentId}] Start ignored (already running)`);
+      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
       return;
     }
     if (this.agentsStarting.has(agentId)) {
-      console.log(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
       return;
     }
     this.agentsStarting.add(agentId);
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path3.join(this.dataDir, agentId);
+      const agentDataDir = path4.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path3.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path4.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
@@ -1020,7 +1313,7 @@ ${config.description || "No role defined yet."}
 `;
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      await mkdir(path3.join(agentDataDir, "notes"), { recursive: true });
+      await mkdir(path4.join(agentDataDir, "notes"), { recursive: true });
       const isResume = !!config.sessionId;
       let prompt;
       if (isResume && resumePrompt) {
@@ -1030,14 +1323,11 @@ ${config.description || "No role defined yet."}
 
 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 && wakeMessage) {
-        const channelLabel = wakeMessage.channel_type === "dm" ? `DM:@${wakeMessage.channel_name}` : `#${wakeMessage.channel_name}`;
-        const senderPrefix = wakeMessage.sender_type === "agent" ? "(agent) " : "";
-        const time = wakeMessage.timestamp ? ` (${toLocalTime(wakeMessage.timestamp)})` : "";
-        const formatted = `[${channelLabel}]${time} ${senderPrefix}@${wakeMessage.sender_name}: ${wakeMessage.content}`;
+      } else if (wakeMessage) {
+        const channelLabel = formatChannelLabel(wakeMessage);
         prompt = `New message received:
 
-${formatted}`;
+${formatIncomingMessage(wakeMessage)}`;
         if (unreadSummary && Object.keys(unreadSummary).length > 0) {
           const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
           if (otherUnread.length > 0) {
@@ -1096,6 +1386,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         inbox: this.startingInboxes.get(agentId) || [],
         config,
         sessionId: config.sessionId || null,
+        launchId: launchId || null,
         isIdle: false,
         notificationTimer: null,
         pendingNotificationCount: 0,
@@ -1107,7 +1398,8 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         lastRuntimeError: null,
         spawnError: null,
         exitCode: null,
-        exitSignal: null
+        exitSignal: null,
+        pendingTrajectory: null
       };
       this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
@@ -1138,12 +1430,12 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         if (current) {
           current.recentStderr = pushRecentStderr(current.recentStderr, text);
         }
-        console.error(`[Agent ${agentId} stderr]: ${text}`);
+        logger.error(`[Agent ${agentId} stderr]: ${text}`);
       });
       proc.on("error", (err) => {
         const current = this.agents.get(agentId);
         if (current) current.spawnError = err.message;
-        console.error(`[Agent ${agentId}] Process error: ${err.message}`);
+        logger.error(`[Agent ${agentId}] Process error: ${err.message}`);
       });
       proc.on("exit", (code, signal) => {
         const current = this.agents.get(agentId);
@@ -1151,7 +1443,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           current.exitCode = code;
           current.exitSignal = signal;
         }
-        console.log(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
+        logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
       });
       proc.on("close", (code, signal) => {
         if (this.agents.has(agentId)) {
@@ -1160,6 +1452,9 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
           if (ap.notificationTimer) {
             clearTimeout(ap.notificationTimer);
           }
+          if (ap.pendingTrajectory?.timer) {
+            clearTimeout(ap.pendingTrajectory.timer);
+          }
           if (ap.activityHeartbeat) {
             clearInterval(ap.activityHeartbeat);
           }
@@ -1170,19 +1465,21 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
             const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
             if (queuedWakeMessage) {
-              console.log(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
+              logger.info(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
               const nextConfig = { ...ap.config, sessionId: ap.sessionId };
               this.idleAgentConfigs.set(agentId, {
                 config: nextConfig,
-                sessionId: ap.sessionId
+                sessionId: ap.sessionId,
+                launchId: ap.launchId
               });
               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.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2, void 0, ap.launchId || void 0).catch((err) => {
+                logger.error(`[Agent ${agentId}] Failed to continue with queued message`, err);
                 this.idleAgentConfigs.set(agentId, {
                   config: nextConfig,
-                  sessionId: ap.sessionId
+                  sessionId: ap.sessionId,
+                  launchId: ap.launchId
                 });
                 this.broadcastActivity(agentId, "online", "Process idle");
               });
@@ -1190,10 +1487,11 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
             }
             this.idleAgentConfigs.set(agentId, {
               config: { ...ap.config, sessionId: ap.sessionId },
-              sessionId: ap.sessionId
+              sessionId: ap.sessionId,
+              launchId: ap.launchId
             });
             if (!ap.driver.supportsStdinNotification) {
-              console.log(`[Agent ${agentId}] Turn completed; cached idle state for future restart`);
+              logger.info(`[Agent ${agentId}] Turn completed; cached idle state for future restart`);
             }
             this.broadcastActivity(agentId, "online", "Process idle");
           } else {
@@ -1203,7 +1501,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
             if (isMissingResumeSession(ap)) {
               const staleSessionId = ap.sessionId;
               const restartConfig = { ...ap.config, sessionId: null };
-              console.warn(
+              logger.warn(
                 `[Agent ${agentId}] Stored Claude session ${staleSessionId} is unavailable locally; falling back to cold start`
               );
               this.broadcastActivity(
@@ -1212,20 +1510,20 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
                 "Stored Claude session missing; cold-starting a new session\u2026",
                 [{ kind: "text", text: `Stored Claude session ${staleSessionId} was not found locally. Falling back to a cold start.` }]
               );
-              this.startAgent(agentId, restartConfig).catch((err) => {
-                console.error(`[Agent ${agentId}] Cold start recovery failed:`, err);
-                this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
+              this.startAgent(agentId, restartConfig, void 0, void 0, void 0, ap.launchId || void 0).catch((err) => {
+                logger.error(`[Agent ${agentId}] Cold start recovery failed`, err);
+                this.sendAgentStatus(agentId, "inactive", ap.launchId);
                 this.broadcastActivity(agentId, "offline", `Crashed (${summary})`);
               });
               return;
             }
-            console.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
-            this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
+            logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
+            this.sendAgentStatus(agentId, "inactive", ap.launchId);
             this.broadcastActivity(agentId, "offline", `Crashed (${summary})`);
           }
         }
       });
-      this.sendToServer({ type: "agent:status", agentId, status: "active" });
+      this.sendAgentStatus(agentId, "active", launchId || null);
       this.broadcastActivity(agentId, "working", "Starting\u2026");
     } catch (err) {
       this.agentsStarting.delete(agentId);
@@ -1237,7 +1535,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const ap = this.agents.get(agentId);
     if (!ap) {
       if (!silent) {
-        console.log(`[Agent ${agentId}] Stop requested but no running process was found`);
+        logger.info(`[Agent ${agentId}] Stop requested but no running process was found`);
       }
       return;
     }
@@ -1250,15 +1548,15 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
     if (!silent) {
-      this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
+      this.sendAgentStatus(agentId, "inactive", ap.launchId);
       this.broadcastActivity(agentId, "offline", "Stopped");
-      console.log(`[Agent ${agentId}] Stopped by request`);
+      logger.info(`[Agent ${agentId}] Stopped by request`);
     }
     if (wait) {
       await new Promise((resolve) => {
         const forceKillTimer = setTimeout(() => {
           if (!silent) {
-            console.warn(`[Agent ${agentId}] Stop timed out; force killing`);
+            logger.warn(`[Agent ${agentId}] Stop timed out; force killing`);
           }
           try {
             ap.process.kill("SIGKILL");
@@ -1288,10 +1586,10 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
-        console.log(`[Agent ${agentId}] Starting from idle state for new message`);
+        logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
         this.idleAgentConfigs.delete(agentId);
-        this.startAgent(agentId, cached.config, message).catch((err) => {
-          console.error(`[Agent ${agentId}] Failed to auto-restart:`, err);
+        this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).catch((err) => {
+          logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
         });
       }
       return;
@@ -1299,7 +1597,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       ap.isIdle = false;
       this.broadcastActivity(agentId, "working", "Message received");
-      this.deliverMessageViaStdin(agentId, ap, message);
+      this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
       return;
     }
     ap.inbox.push(message);
@@ -1313,12 +1611,12 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path3.join(this.dataDir, agentId);
+    const agentDataDir = path4.join(this.dataDir, agentId);
     try {
       await rm(agentDataDir, { recursive: true, force: true });
-      console.log(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
+      logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
     } catch (err) {
-      console.error(`[Agent ${agentId}] Workspace reset failed:`, err);
+      logger.error(`[Agent ${agentId}] Workspace reset failed`, err);
     }
   }
   async stopAll() {
@@ -1332,10 +1630,13 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   getAgentSessionId(agentId) {
     return this.agents.get(agentId)?.sessionId ?? null;
   }
+  getAgentLaunchId(agentId) {
+    return this.agents.get(agentId)?.launchId ?? null;
+  }
   getIdleAgentSessionIds() {
     const result = [];
-    for (const [agentId, { sessionId }] of this.idleAgentConfigs) {
-      if (sessionId) result.push({ agentId, sessionId });
+    for (const [agentId, { sessionId, launchId }] of this.idleAgentConfigs) {
+      if (sessionId) result.push({ agentId, sessionId, launchId });
     }
     return result;
   }
@@ -1350,14 +1651,14 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dirPath = path3.join(this.dataDir, entry.name);
+      const dirPath = path4.join(this.dataDir, entry.name);
       try {
         const dirContents = await readdir(dirPath, { withFileTypes: true });
         let totalSize = 0;
         let latestMtime = /* @__PURE__ */ new Date(0);
         let fileCount = 0;
         for (const item of dirContents) {
-          const itemPath = path3.join(dirPath, item.name);
+          const itemPath = path4.join(dirPath, item.name);
           try {
             const info = await stat(itemPath);
             if (item.isFile()) {
@@ -1387,19 +1688,19 @@ 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(this.dataDir, directoryName);
+    const targetDir = path4.join(this.dataDir, directoryName);
     try {
       await rm(targetDir, { recursive: true, force: true });
-      console.log(`[Workspace] Deleted directory: ${targetDir}`);
+      logger.info(`[Workspace] Deleted directory: ${targetDir}`);
       return true;
     } catch (err) {
-      console.error(`[Workspace] Failed to delete directory ${targetDir}:`, err);
+      logger.error(`[Workspace] Failed to delete directory ${targetDir}`, err);
       return false;
     }
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path3.join(this.dataDir, agentId);
+    const agentDir = path4.join(this.dataDir, agentId);
     try {
       await stat(agentDir);
     } catch {
@@ -1407,8 +1708,8 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path3.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path3.sep) && resolved !== agentDir) {
+      const resolved = path4.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path4.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -1416,9 +1717,9 @@ 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(this.dataDir, agentId);
-    const resolved = path3.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path3.sep) && resolved !== agentDir) {
+    const agentDir = path4.join(this.dataDir, agentId);
+    const resolved = path4.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path4.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat(resolved);
@@ -1442,7 +1743,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       ".sh",
       ".py"
     ]);
-    const ext = path3.extname(resolved).toLowerCase();
+    const ext = path4.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -1469,13 +1770,13 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
     const home = os.homedir();
-    const workspaceDir = path3.join(this.dataDir, agentId);
+    const workspaceDir = path4.join(this.dataDir, agentId);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalResults = await Promise.all(
-      paths.global.map((p) => this.scanSkillsDir(path3.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path4.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path3.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path4.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -1504,7 +1805,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path3.join(dir, entry.name, "SKILL.md");
+        const skillMd = path4.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -1515,7 +1816,7 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path3.join(dir, entry.name), "utf-8");
+          const content = await readFile(path4.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -1558,14 +1859,20 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (!hasToolStart) {
       entries.push({ kind: "status", activity, detail });
     }
-    this.sendToServer({ type: "agent:activity", agentId, activity, detail, entries });
+    this.sendToServer({ type: "agent:activity", agentId, activity, detail, entries, launchId: ap?.launchId || void 0 });
     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 });
+            this.sendToServer({
+              type: "agent:activity",
+              agentId,
+              activity: ap.lastActivity,
+              detail: ap.lastActivityDetail,
+              launchId: ap.launchId || void 0
+            });
           }, ACTIVITY_HEARTBEAT_MS);
         }
       } else {
@@ -1576,28 +1883,64 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
       }
     }
   }
+  flushPendingTrajectory(agentId) {
+    const ap = this.agents.get(agentId);
+    const pending = ap?.pendingTrajectory;
+    if (!ap || !pending) return;
+    if (pending.timer) clearTimeout(pending.timer);
+    ap.pendingTrajectory = null;
+    const text = pending.text.length > MAX_TRAJECTORY_TEXT ? pending.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : pending.text;
+    if (!text) return;
+    if (pending.kind === "thinking") {
+      this.broadcastActivity(agentId, "thinking", "", [{ kind: "thinking", text }]);
+    } else {
+      this.broadcastActivity(agentId, "thinking", "", [{ kind: "text", text }]);
+    }
+  }
+  queueTrajectoryText(agentId, kind, text) {
+    const ap = this.agents.get(agentId);
+    if (!ap) return;
+    if (!text) {
+      this.broadcastActivity(agentId, "thinking", "");
+      return;
+    }
+    const pending = ap.pendingTrajectory;
+    if (pending && pending.kind === kind) {
+      pending.text += text;
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.timer = setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS);
+      return;
+    }
+    this.flushPendingTrajectory(agentId);
+    if (ap.lastActivity !== "thinking" || ap.lastActivityDetail !== "") {
+      this.broadcastActivity(agentId, "thinking", "");
+    }
+    ap.pendingTrajectory = {
+      kind,
+      text,
+      timer: setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS)
+    };
+  }
   /** Handle a single ParsedEvent from any runtime driver */
   handleParsedEvent(agentId, event, driver) {
     const ap = this.agents.get(agentId);
     switch (event.kind) {
       case "session_init":
         if (ap) ap.sessionId = event.sessionId;
-        this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+        this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
         break;
       case "thinking": {
-        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);
+        this.queueTrajectoryText(agentId, "thinking", event.text);
         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 }]);
+        this.queueTrajectoryText(agentId, "text", event.text);
         if (ap) ap.isIdle = false;
         break;
       }
       case "tool_call": {
+        this.flushPendingTrajectory(agentId);
         const toolName = event.name;
         const inputSummary = driver.summarizeToolInput(toolName, event.input);
         const detail = toolName === `${driver.mcpToolPrefix}check_messages` ? "Checking messages\u2026" : toolName === `${driver.mcpToolPrefix}send_message` ? "Sending message\u2026" : driver.toolDisplayName(toolName);
@@ -1606,30 +1949,42 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
         break;
       }
       case "turn_end":
+        this.flushPendingTrajectory(agentId);
         if (ap) {
           if (event.sessionId) ap.sessionId = event.sessionId;
           if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
-            const nextMessage = ap.inbox.shift();
+            const nextMessages = ap.inbox.splice(0, ap.inbox.length);
             this.broadcastActivity(agentId, "working", "Message received");
-            this.deliverMessageViaStdin(agentId, ap, nextMessage);
+            this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
           } else {
             ap.isIdle = true;
             this.broadcastActivity(agentId, "online", "Idle");
           }
         }
         if (event.sessionId) {
-          this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId });
+          this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
         }
         break;
       case "error": {
+        this.flushPendingTrajectory(agentId);
         if (ap) ap.lastRuntimeError = event.message;
         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}` }] });
+        this.sendToServer({
+          type: "agent:activity",
+          agentId,
+          activity: currentActivity,
+          detail: currentDetail,
+          entries: [{ kind: "text", text: `Error: ${event.message}` }],
+          launchId: ap?.launchId || void 0
+        });
         break;
       }
     }
   }
+  sendAgentStatus(agentId, status, launchId) {
+    this.sendToServer({ type: "agent:status", agentId, status, launchId: launchId || void 0 });
+  }
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
@@ -1640,27 +1995,38 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
     if (count === 0) return;
     if (ap.isIdle) return;
     if (!ap.sessionId) return;
+    if (ap.driver.deliverMessageDirectlyWhileBusy && ap.inbox.length > 0) {
+      const queuedMessages = ap.inbox.splice(0, ap.inbox.length);
+      console.log(`[Agent ${agentId}] Delivering queued message via stdin while busy`);
+      this.broadcastActivity(agentId, "working", "Message received");
+      this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy");
+      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)`);
-    const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId);
+    logger.info(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
+    const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     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:
+  deliverMessagesViaStdin(agentId, ap, messages, mode) {
+    if (messages.length === 0) return;
+    const prompt = messages.length === 1 ? `New message received:
 
-${formatted}
+${formatIncomingMessage(messages[0])}
+
+Respond as appropriate. Complete all your work before stopping.` : `New messages received:
+
+${messages.map((message) => formatIncomingMessage(message)).join("\n")}
 
 Respond as appropriate. Complete all your work before stopping.`;
-    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId);
+    const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
     if (encoded) {
-      console.log(`[Agent ${agentId}] Delivering message via stdin from @${message.sender_name}`);
+      const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
+      logger.info(
+        `[Agent ${agentId}] Delivering ${mode} ${messages.length === 1 ? "message" : `${messages.length} messages`} via stdin from ${senders}`
+      );
       ap.process.stdin?.write(encoded + "\n");
     }
   }
@@ -1680,8 +2046,8 @@ Respond as appropriate. Complete all your work before stopping.`;
     const nodes = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const fullPath = path3.join(dir, entry.name);
-      const relativePath = path3.relative(rootDir, fullPath);
+      const fullPath = path4.join(dir, entry.name);
+      const relativePath = path4.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat(fullPath);
@@ -1747,7 +2113,7 @@ var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
   { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: false },
-  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: false }
+  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true }
 ];
 
 // src/index.ts
@@ -1801,12 +2167,12 @@ if (!serverUrl || !apiKey) {
   console.error("Usage: slock-daemon --server-url <url> --api-key <key>");
   process.exit(1);
 }
-var __dirname = path4.dirname(fileURLToPath(import.meta.url));
-var chatBridgePath = path4.resolve(__dirname, "chat-bridge.js");
+var __dirname = path5.dirname(fileURLToPath(import.meta.url));
+var chatBridgePath = path5.resolve(__dirname, "chat-bridge.js");
 try {
   accessSync(chatBridgePath);
 } catch {
-  chatBridgePath = path4.resolve(__dirname, "chat-bridge.ts");
+  chatBridgePath = path5.resolve(__dirname, "chat-bridge.ts");
 }
 var connection;
 var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
@@ -1817,27 +2183,27 @@ connection = new DaemonConnection({
   apiKey,
   onMessage: (msg) => {
     const summary = summarizeIncomingMessage(msg);
-    console.log(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
+    logger.info(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
     switch (msg.type) {
       case "agent:start":
-        console.log(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
-        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary, msg.resumePrompt).catch((err) => {
+        logger.info(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
+        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary, msg.resumePrompt, msg.launchId).catch((err) => {
           const reason = err instanceof Error ? err.message : String(err);
-          console.error(`[Agent ${msg.agentId}] Start failed (${reason})`);
-          connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive" });
-          connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: `Start failed: ${reason}` });
+          logger.error(`[Agent ${msg.agentId}] Start failed (${reason})`);
+          connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive", launchId: msg.launchId });
+          connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: `Start failed: ${reason}`, launchId: msg.launchId });
         });
         break;
       case "agent:stop":
-        console.log(`[Agent ${msg.agentId}] Stop requested`);
+        logger.info(`[Agent ${msg.agentId}] Stop requested`);
         agentManager.stopAgent(msg.agentId);
         break;
       case "agent:reset-workspace":
-        console.log(`[Agent ${msg.agentId}] Workspace reset requested`);
+        logger.info(`[Agent ${msg.agentId}] Workspace reset requested`);
         agentManager.resetWorkspace(msg.agentId);
         break;
       case "agent:deliver":
-        console.log(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
+        logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
         agentManager.deliverMessage(msg.agentId, msg.message);
         connection.send({ type: "agent:deliver:ack", agentId: msg.agentId, seq: msg.seq });
         break;
@@ -1869,18 +2235,18 @@ connection = new DaemonConnection({
         agentManager.listSkills(msg.agentId, msg.runtime).then(({ global, workspace }) => {
           connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global, workspace });
         }).catch((err) => {
-          console.error(`[Daemon] Failed to list skills for ${msg.agentId}:`, err);
+          logger.error(`[Daemon] Failed to list skills for ${msg.agentId}`, err);
           connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
         });
         break;
       case "machine:workspace:scan":
-        console.log("[Daemon] Scanning all workspace directories");
+        logger.info("[Daemon] Scanning all workspace directories");
         agentManager.scanAllWorkspaces().then((directories) => {
           connection.send({ type: "machine:workspace:scan_result", directories });
         });
         break;
       case "machine:workspace:delete":
-        console.log(`[Daemon] Deleting workspace directory: ${msg.directoryName}`);
+        logger.info(`[Daemon] Deleting workspace directory: ${msg.directoryName}`);
         agentManager.deleteWorkspaceDirectory(msg.directoryName).then((success) => {
           connection.send({ type: "machine:workspace:delete_result", directoryName: msg.directoryName, success });
         });
@@ -1892,7 +2258,7 @@ connection = new DaemonConnection({
   },
   onConnect: () => {
     const runtimes = detectRuntimes();
-    console.log(`[Daemon] Detected runtimes: ${runtimes.join(", ") || "none"}`);
+    logger.info(`[Daemon] Detected runtimes: ${runtimes.join(", ") || "none"}`);
     connection.send({
       type: "ready",
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
@@ -1904,22 +2270,23 @@ connection = new DaemonConnection({
     });
     for (const agentId of agentManager.getRunningAgentIds()) {
       const sessionId = agentManager.getAgentSessionId(agentId);
+      const launchId = agentManager.getAgentLaunchId(agentId);
       if (sessionId) {
-        connection.send({ type: "agent:session", agentId, sessionId });
+        connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
       }
     }
-    for (const { agentId, sessionId } of agentManager.getIdleAgentSessionIds()) {
-      connection.send({ type: "agent:session", agentId, sessionId });
+    for (const { agentId, sessionId, launchId } of agentManager.getIdleAgentSessionIds()) {
+      connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
     }
   },
   onDisconnect: () => {
-    console.log("[Daemon] Lost connection \u2014 agents continue running locally");
+    logger.warn("[Daemon] Lost connection \u2014 agents continue running locally");
   }
 });
-console.log("[Slock Daemon] Starting...");
+logger.info("[Slock Daemon] Starting...");
 connection.connect();
 var shutdown = async () => {
-  console.log("[Slock Daemon] Shutting down...");
+  logger.info("[Slock Daemon] Shutting down...");
   await agentManager.stopAll();
   connection.disconnect();
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.30.0",
+  "version": "0.30.1-alpha.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"
@@ -17,12 +17,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "ws": "^8.19.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "ws": "^8.20.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.5.0",
     "@types/ws": "^8.18.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",