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

package/dist/index.js

@@ -1,16 +1,42 @@
 #!/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";
 import { accessSync } from "fs";
-import { readFile as readFile2, readdir as readdir2, stat as stat2, mkdir as mkdir2, appendFile } from "fs/promises";
 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),
@@ -47,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;
     }
@@ -60,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() {
@@ -70,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();
@@ -89,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) => {
@@ -97,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();
@@ -105,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();
@@ -123,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 {
@@ -140,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
@@ -183,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).
@@ -267,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\`
@@ -280,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**:
@@ -553,7 +596,7 @@ var ClaudeDriver = class {
     }
     return events;
   }
-  encodeStdinMessage(text, sessionId) {
+  encodeStdinMessage(text, sessionId, _opts) {
     return JSON.stringify({
       type: "user",
       message: {
@@ -808,7 +851,7 @@ var CodexDriver = class {
     }
     return events;
   }
-  encodeStdinMessage(_text, _sessionId) {
+  encodeStdinMessage(_text, _sessionId, _opts) {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
@@ -878,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;
@@ -902,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) {
@@ -912,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;
@@ -989,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 {
@@ -1021,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) {
@@ -1031,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) {
@@ -1097,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,
@@ -1108,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);
@@ -1139,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);
@@ -1152,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)) {
@@ -1161,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);
           }
@@ -1171,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");
               });
@@ -1191,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 {
@@ -1204,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(
@@ -1213,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);
@@ -1238,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;
     }
@@ -1251,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");
@@ -1289,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;
@@ -1300,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);
@@ -1314,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() {
@@ -1330,16 +1627,16 @@ Note: While you are busy, you may receive [System notification: ...] messages ab
   getRunningAgentIds() {
     return [...this.agents.keys()];
   }
-  getDataDir() {
-    return this.dataDir;
-  }
   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;
   }
@@ -1354,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()) {
@@ -1391,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 {
@@ -1411,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;
@@ -1420,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);
@@ -1446,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 };
     }
@@ -1473,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();
@@ -1508,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);
@@ -1519,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);
@@ -1562,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 {
@@ -1580,33 +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 });
-        writeFile(
-          path3.join(this.dataDir, agentId, "session-meta.json"),
-          JSON.stringify({ sessionId: event.sessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
-        ).catch(() => {
-        });
+        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);
@@ -1615,35 +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 });
-          writeFile(
-            path3.join(this.dataDir, agentId, "session-meta.json"),
-            JSON.stringify({ sessionId: event.sessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
-          ).catch(() => {
-          });
+          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);
@@ -1654,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:
+
+${formatIncomingMessage(messages[0])}
 
-${formatted}
+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");
     }
   }
@@ -1694,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);
@@ -1761,53 +2113,12 @@ 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
 var require2 = createRequire(import.meta.url);
 var DAEMON_VERSION = require2("../package.json").version;
-var LOG_DIR = path4.join(os2.homedir(), ".slock", "logs");
-var LOG_FILE = path4.join(LOG_DIR, "daemon.log");
-var MAX_LOG_BYTES = 5 * 1024 * 1024;
-async function initLogFile() {
-  try {
-    await mkdir2(LOG_DIR, { recursive: true });
-    try {
-      const s = await stat2(LOG_FILE);
-      if (s.size > MAX_LOG_BYTES) {
-        const content = await readFile2(LOG_FILE, "utf-8");
-        const trimmed = content.slice(Math.floor(content.length / 2));
-        await appendFile(LOG_FILE, "");
-        const { writeFile: writeFile2 } = await import("fs/promises");
-        await writeFile2(LOG_FILE, trimmed);
-      }
-    } catch {
-    }
-  } catch {
-  }
-}
-function logLine(level, ...args2) {
-  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${args2.map(String).join(" ")}
-`;
-  appendFile(LOG_FILE, line).catch(() => {
-  });
-}
-var _origLog = console.log.bind(console);
-var _origErr = console.error.bind(console);
-var _origWarn = console.warn.bind(console);
-console.log = (...args2) => {
-  _origLog(...args2);
-  logLine("INFO", ...args2);
-};
-console.error = (...args2) => {
-  _origErr(...args2);
-  logLine("ERROR", ...args2);
-};
-console.warn = (...args2) => {
-  _origWarn(...args2);
-  logLine("WARN", ...args2);
-};
 function formatChannelTarget(msg) {
   return msg.message.channel_type === "dm" ? `dm:@${msg.message.channel_name}` : `#${msg.message.channel_name}`;
 }
@@ -1829,8 +2140,6 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
     case "machine:workspace:delete":
       return `(directory=${msg.directoryName})`;
-    case "machine:feedback:collect":
-      return `(reportId=${msg.reportId}, agents=${msg.agents.length})`;
     default:
       return "";
   }
@@ -1858,134 +2167,14 @@ 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;
-async function collectAndUploadAgent(opts) {
-  const { agentId, reportAgentId, uploadUrl, authToken, timeRangeHours, includeSessionFiles, includeDaemonLogs, includeWorkspaceSnapshot, dataDir } = opts;
-  const sinceMs = Date.now() - timeRangeHours * 60 * 60 * 1e3;
-  let bytesUploaded = 0;
-  let anyUploadFailed = false;
-  try {
-    const agentDir = path4.join(dataDir, agentId);
-    let sessionId = opts.sessionId;
-    try {
-      const meta = JSON.parse(await readFile2(path4.join(agentDir, "session-meta.json"), "utf-8"));
-      if (meta.sessionId) sessionId = meta.sessionId;
-    } catch {
-    }
-    const filesToUpload = [];
-    if (includeSessionFiles && sessionId) {
-      const claudeProjectsDir = path4.join(os2.homedir(), ".claude", "projects");
-      try {
-        const projectDirs = await readdir2(claudeProjectsDir, { withFileTypes: true });
-        for (const pd of projectDirs) {
-          if (!pd.isDirectory()) continue;
-          const pdPath = path4.join(claudeProjectsDir, pd.name);
-          const files = await readdir2(pdPath, { withFileTypes: true });
-          for (const f of files) {
-            if (!f.isFile() || !f.name.endsWith(".jsonl")) continue;
-            if (!f.name.startsWith(sessionId)) continue;
-            const filePath = path4.join(pdPath, f.name);
-            const raw = await readFile2(filePath, "utf-8");
-            const filteredLines = raw.split("\n").filter((line) => {
-              if (!line.trim()) return false;
-              try {
-                const obj = JSON.parse(line);
-                if (!obj.timestamp) return true;
-                return new Date(obj.timestamp).getTime() >= sinceMs;
-              } catch {
-                return false;
-              }
-            }).join("\n");
-            if (!filteredLines.trim()) continue;
-            filesToUpload.push({ filename: f.name, data: Buffer.from(filteredLines), kind: "session_jsonl" });
-          }
-        }
-      } catch {
-      }
-    }
-    if (includeDaemonLogs) {
-      try {
-        const raw = await readFile2(LOG_FILE, "utf-8");
-        const filtered = raw.split("\n").filter((line) => {
-          if (!line.trim()) return false;
-          const ts = line.slice(0, 24);
-          return new Date(ts).getTime() >= sinceMs;
-        }).join("\n");
-        if (filtered.trim()) {
-          filesToUpload.push({ filename: "daemon.log", data: Buffer.from(filtered), kind: "daemon_log" });
-        }
-      } catch {
-      }
-    }
-    if (includeWorkspaceSnapshot) {
-      try {
-        const agentStat = await stat2(agentDir);
-        if (agentStat.isDirectory()) {
-          const files = await readdir2(agentDir, { withFileTypes: true });
-          for (const f of files) {
-            if (!f.isFile()) continue;
-            if (f.name === "session-meta.json") continue;
-            const filePath = path4.join(agentDir, f.name);
-            const s = await stat2(filePath);
-            if (s.size > 1024 * 1024) continue;
-            const data = await readFile2(filePath);
-            filesToUpload.push({ filename: f.name, data, kind: "runtime_log" });
-          }
-        }
-      } catch {
-      }
-    }
-    const manifest = {
-      reportAgentId,
-      agentId,
-      sessionId,
-      runtime: opts.runtime,
-      daemonVersion: DAEMON_VERSION,
-      hostname: os2.hostname(),
-      os: `${os2.platform()} ${os2.arch()}`,
-      collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      timeRangeHours,
-      includeSessionFiles,
-      includeDaemonLogs,
-      includeWorkspaceSnapshot,
-      artifactCount: filesToUpload.length
-    };
-    filesToUpload.unshift({ filename: "manifest.json", data: Buffer.from(JSON.stringify(manifest, null, 2)), kind: "manifest" });
-    for (const file of filesToUpload) {
-      const formData = new FormData();
-      formData.append("reportAgentId", reportAgentId);
-      formData.append("kind", file.kind);
-      formData.append("filename", file.filename);
-      formData.append("file", new Blob([new Uint8Array(file.data)]), file.filename);
-      const resp = await fetch(uploadUrl, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${authToken}` },
-        body: formData
-      });
-      if (resp.ok) {
-        bytesUploaded += file.data.length;
-      } else {
-        console.warn(`[Feedback] Upload failed for ${file.filename}: ${resp.status}`);
-        anyUploadFailed = true;
-      }
-    }
-    if (anyUploadFailed) {
-      return { reportAgentId, status: "error", daemonVersion: DAEMON_VERSION, error: "One or more files failed to upload", bytesUploaded };
-    }
-    return { reportAgentId, status: "collected", daemonVersion: DAEMON_VERSION, bytesUploaded };
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    console.error(`[Feedback] Collection failed for agent ${agentId}:`, error);
-    return { reportAgentId, status: "error", daemonVersion: DAEMON_VERSION, error };
-  }
-}
 var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
   connection.send(msg);
 }, apiKey);
@@ -1994,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;
@@ -2046,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 });
         });
@@ -2065,42 +2254,11 @@ connection = new DaemonConnection({
       case "ping":
         connection.send({ type: "pong" });
         break;
-      case "machine:feedback:collect": {
-        const { reportId, agents, timeRangeHours, includeSessionFiles, includeDaemonLogs, includeWorkspaceSnapshot, uploadUrl, authToken } = msg;
-        console.log(`[Daemon] Collecting feedback for report ${reportId} (${agents.length} agents)`);
-        const dataDir = agentManager.getDataDir();
-        Promise.all(agents.map(
-          (agent) => collectAndUploadAgent({
-            agentId: agent.agentId,
-            reportAgentId: agent.reportAgentId,
-            runtime: agent.runtime,
-            sessionId: agent.sessionId,
-            uploadUrl,
-            authToken,
-            timeRangeHours,
-            includeSessionFiles,
-            includeDaemonLogs,
-            includeWorkspaceSnapshot: includeWorkspaceSnapshot ?? false,
-            dataDir
-          })
-        )).then((agentResults) => {
-          connection.send({ type: "machine:feedback:result", reportId, agentResults });
-        }).catch((err) => {
-          console.error(`[Daemon] Feedback collection failed for report ${reportId}:`, err);
-          const agentResults = agents.map((a) => ({
-            reportAgentId: a.reportAgentId,
-            status: "error",
-            error: err instanceof Error ? err.message : String(err)
-          }));
-          connection.send({ type: "machine:feedback:result", reportId, agentResults });
-        });
-        break;
-      }
     }
   },
   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"],
@@ -2112,24 +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");
   }
 });
-initLogFile().catch(() => {
-});
-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);