@slock-ai/daemon 0.34.0 → 0.35.0

package/dist/chat-bridge.js

@@ -35,6 +35,68 @@ function bridgeFetch(url, init = {}) {
   const requestInit = dispatcher ? { ...init, dispatcher } : init;
   return fetch(url, requestInit);
 }
+function formatAttachmentSuffix(attachments) {
+  if (!attachments?.length) return "";
+  return ` [${attachments.length} attachment${attachments.length > 1 ? "s" : ""}: ${attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to download]`;
+}
+function guessMimeTypeFromFilename(filename) {
+  const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
+  const mimeMap = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".csv": "text/csv",
+    ".zip": "application/zip",
+    ".tar": "application/x-tar",
+    ".gz": "application/gzip",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  };
+  return mimeMap[ext] || "application/octet-stream";
+}
+function parseFilenameFromContentDisposition(contentDisposition) {
+  if (!contentDisposition) return null;
+  const utf8Match = contentDisposition.match(/filename\*\s*=\s*UTF-8''([^;]+)/i);
+  if (utf8Match?.[1]) return decodeURIComponent(utf8Match[1]);
+  const plainMatch = contentDisposition.match(/filename\s*=\s*"([^"]+)"/i) || contentDisposition.match(/filename\s*=\s*([^;]+)/i);
+  return plainMatch?.[1] ? plainMatch[1].trim() : null;
+}
+function extensionForContentType(contentType) {
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase();
+  const extMap = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "application/json": ".json",
+    "text/csv": ".csv",
+    "application/zip": ".zip",
+    "application/x-tar": ".tar",
+    "application/gzip": ".gz",
+    "audio/mpeg": ".mp3",
+    "audio/wav": ".wav",
+    "video/mp4": ".mp4",
+    "video/quicktime": ".mov"
+  };
+  return extMap[normalized] || ".bin";
+}
 function formatTarget(m) {
   if (m.channel_type === "thread" && m.parent_channel_name) {
     const shortId = m.channel_name.startsWith("thread-") ? m.channel_name.slice(7) : m.channel_name;
@@ -61,6 +123,11 @@ function formatSearchTarget(result) {
   }
   return `#${result.channelName}`;
 }
+function formatSenderHandle(message) {
+  const senderName = message.sender_name ?? message.senderName ?? "unknown";
+  const senderDescription = message.sender_description ?? message.senderDescription ?? null;
+  return senderDescription ? `@${senderName} \u2014 ${senderDescription}` : `@${senderName}`;
+}
 var server = new McpServer({
   name: "chat",
   version: "1.0.0"
@@ -117,9 +184,9 @@ ${formatMessages(data.recentUnread)}`;
 );
 server.tool(
   "upload_file",
-  "Upload an image file to attach to a message. Returns an attachment ID that you can pass to send_message's attachment_ids parameter. Supported formats: JPEG, PNG, GIF, WebP. Max size: 5MB.",
+  "Upload a file to attach to a message. Returns an attachment ID that you can pass to send_message's attachment_ids parameter. Images keep preview behavior; other files are sent as downloadable attachments. Max size: 5MB.",
   {
-    file_path: z.string().describe("Absolute path to the image file on your local filesystem"),
+    file_path: z.string().describe("Absolute path to the file on your local filesystem"),
     channel: z.string().describe("The channel target where this file will be used (e.g. '#general', 'dm:@richard')")
   },
   async ({ file_path, channel }) => {
@@ -136,7 +203,7 @@ server.tool(
       if (stat.size > 5 * 1024 * 1024) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 5MB.` }]
+          content: [{ type: "text", text: `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 5MB per file.` }]
         };
       }
       const listRes = await bridgeFetch(`${serverUrl}/internal/agent/${agentId}/resolve-channel`, {
@@ -156,15 +223,7 @@ server.tool(
       }
       const fileBuffer = fs.readFileSync(file_path);
       const filename = path.basename(file_path);
-      const ext = path.extname(file_path).toLowerCase();
-      const mimeMap = {
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".png": "image/png",
-        ".gif": "image/gif",
-        ".webp": "image/webp"
-      };
-      const mimeType = mimeMap[ext] || "application/octet-stream";
+      const mimeType = guessMimeTypeFromFilename(filename);
       const blob = new Blob([fileBuffer], { type: mimeType });
       const formData = new FormData();
       formData.append("file", blob, filename);
@@ -206,7 +265,7 @@ Use this ID in send_message's attachment_ids parameter to include it in a messag
 );
 server.tool(
   "view_file",
-  "Download an attached image by its attachment ID and save it locally so you can view it. Returns the local file path. Use this when you see '[use view_file to see]' in a message with images.",
+  "Download an attached file by its attachment ID and save it locally so you can inspect it. Returns the local file path.",
   {
     attachment_id: z.string().describe("The attachment UUID (from the 'id:...' shown in the message)")
   },
@@ -221,9 +280,7 @@ server.tool(
       if (existing) {
         const cachedPath = path.join(cacheDir, existing);
         return {
-          content: [{ type: "text", text: `File already cached at: ${cachedPath}
-
-Use your Read tool to view this image.` }]
+          content: [{ type: "text", text: `File already cached at: ${cachedPath}` }]
         };
       }
       const downloadHeaders = {};
@@ -241,20 +298,13 @@ Use your Read tool to view this image.` }]
         };
       }
       const contentType = res.headers.get("content-type") || "application/octet-stream";
-      const extMap = {
-        "image/jpeg": ".jpg",
-        "image/png": ".png",
-        "image/gif": ".gif",
-        "image/webp": ".webp"
-      };
-      const ext = extMap[contentType] || ".bin";
+      const filename = parseFilenameFromContentDisposition(res.headers.get("content-disposition"));
+      const ext = filename ? path.extname(filename) || extensionForContentType(contentType) : extensionForContentType(contentType);
       const filePath = path.join(cacheDir, `${attachment_id}${ext}`);
       const buffer = Buffer.from(await res.arrayBuffer());
       fs.writeFileSync(filePath, buffer);
       return {
-        content: [{ type: "text", text: `Downloaded to: ${filePath}
-
-Use your Read tool to view this image.` }]
+        content: [{ type: "text", text: `Downloaded to: ${filePath}` }]
       };
     } catch (err) {
       return {
@@ -298,11 +348,11 @@ function formatMessages(messages) {
     const target = formatTarget(m);
     const msgId = m.message_id ? m.message_id.slice(0, 8) : "-";
     const time = m.timestamp ? toLocalTime(m.timestamp) : "-";
-    const senderType = m.sender_type === "agent" ? " type=agent" : "";
+    const senderType = ` type=${m.sender_type}`;
     const renderedContent = m.content;
-    const attachSuffix = m.attachments?.length ? ` [${m.attachments.length} image${m.attachments.length > 1 ? "s" : ""}: ${m.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to see]` : "";
+    const attachSuffix = formatAttachmentSuffix(m.attachments);
     const taskSuffix = m.task_status ? ` [task #${m.task_number} status=${m.task_status}${m.task_assignee_id ? ` assignee=${m.task_assignee_type}:${m.task_assignee_id}` : ""}]` : "";
-    return `[target=${target} msg=${msgId} time=${time}${senderType}] @${m.sender_name}: ${renderedContent}${attachSuffix}${taskSuffix}`;
+    return `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(m)}: ${renderedContent}${attachSuffix}${taskSuffix}`;
   }).join("\n");
 }
 server.tool(
@@ -333,7 +383,8 @@ server.tool(
       text += "Other AI agents in this server.\n";
       if (data.agents?.length > 0) {
         for (const a of data.agents) {
-          text += `  - @${a.name} (${a.status})
+          text += a.description ? `  - @${a.name} (${a.status}) \u2014 ${a.description}
+` : `  - @${a.name} (${a.status})
 `;
         }
       } else {
@@ -343,7 +394,8 @@ server.tool(
       text += 'To start a new DM: send_message(target="dm:@name"). To reply in an existing DM: reuse the target from received messages.\n';
       if (data.humans?.length > 0) {
         for (const u of data.humans) {
-          text += `  - @${u.name}
+          text += u.description ? `  - @${u.name} \u2014 ${u.description}
+` : `  - @${u.name}
 `;
         }
       } else {
@@ -408,7 +460,7 @@ thread: ${result.parentChannelName} -> ${target}` : "";
         return [
           `[${index + 1}] msg=${result.id} seq=${result.seq} time=${toLocalTime(result.createdAt)}`,
           `target: ${target}${threadInfo}`,
-          `sender: @${result.senderName}${result.senderType === "agent" ? " (agent)" : ""}`,
+          `sender: @${result.senderName} (${result.senderType})`,
           `content: ${result.content}`,
           `match: ${result.snippet}`,
           `next: read_history(channel="${target}", around="${result.id}", limit=20)`
@@ -468,13 +520,13 @@ server.tool(
         };
       }
       const formatted = data.messages.map((m) => {
-        const senderType = m.senderType === "agent" ? " type=agent" : "";
+        const senderType = ` type=${m.senderType}`;
         const time = m.createdAt ? toLocalTime(m.createdAt) : "-";
         const msgId = m.id || "-";
         const renderedContent = m.content;
-        const attachSuffix = m.attachments?.length ? ` [${m.attachments.length} image${m.attachments.length > 1 ? "s" : ""}: ${m.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to see]` : "";
+        const attachSuffix = formatAttachmentSuffix(m.attachments);
         const taskSuffix = m.taskStatus ? ` [task #${m.taskNumber} status=${m.taskStatus}${m.taskAssigneeId ? ` assignee=${m.taskAssigneeType}:${m.taskAssigneeId}` : ""}]` : "";
-        return `[seq=${m.seq} msg=${msgId} time=${time}${senderType}] @${m.senderName}: ${renderedContent}${attachSuffix}${taskSuffix}`;
+        return `[seq=${m.seq} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(m)}: ${renderedContent}${attachSuffix}${taskSuffix}`;
       }).join("\n");
       let footer = "";
       if (data.historyLimited) {

package/dist/{chunk-ZXIMDHR7.js → chunk-OSHFDFBV.js}

@@ -3,8 +3,8 @@ import {
 } from "./chunk-GX2DVINN.js";
 
 // src/core.ts
-import path6 from "path";
-import os2 from "os";
+import path9 from "path";
+import os4 from "os";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
 import { accessSync } from "fs";
@@ -38,7 +38,7 @@ var SERVER_CAPABILITY_MATRIX = {
     manageAgents: true,
     manageMachines: true,
     manageMembers: true,
-    changeMemberRoles: false,
+    changeMemberRoles: true,
     manageBilling: false,
     joinPublicChannels: true
   }),
@@ -58,8 +58,10 @@ var SERVER_CAPABILITY_MATRIX = {
 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: true }
+  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
+  { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
+  { id: "cursor", displayName: "Cursor CLI", binary: "agent", supported: true },
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true }
 ];
 var PLAN_CONFIG = {
   free: {
@@ -97,8 +99,8 @@ var DISPLAY_PLAN_CONFIG = {
 
 // src/agentProcessManager.ts
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import path5 from "path";
-import os from "os";
+import path8 from "path";
+import os3 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
@@ -145,8 +147,8 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 8. **${t("claim_tasks")}** \u2014 Claim tasks by number (supports batch, handles conflicts).
 9. **${t("unclaim_task")}** \u2014 Release your claim on a task.
 10. **${t("update_task_status")}** \u2014 Change a task's status (e.g. to in_review or done).
-11. **${t("upload_file")}** \u2014 Upload an image file to attach to a message. Returns an attachment ID to pass to send_message.
-12. **${t("view_file")}** \u2014 Download an attached image by its attachment ID so you can view it. Use when messages contain image attachments.
+11. **${t("upload_file")}** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to send_message.
+12. **${t("view_file")}** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
 
 CRITICAL RULES:
 ${criticalRules.join("\n")}
@@ -166,18 +168,18 @@ ${opts.postStartupNotes.join("\n")}`;
 Messages you receive have a single RFC 5424-style structured data header followed by the sender and content:
 
 \`\`\`
-[target=#general msg=a1b2c3d4 time=2026-03-15T01:00:00] @richard: hello everyone
+[target=#general msg=a1b2c3d4 time=2026-03-15T01:00:00 type=human] @richard: hello everyone
 [target=#general msg=e5f6a7b8 time=2026-03-15T01:00:01 type=agent] @Alice: hi there
-[target=dm:@richard msg=c9d0e1f2 time=2026-03-15T01:00:02] @richard: hey, can you help?
-[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03] @richard: thread reply
-[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04] @richard: DM thread reply
+[target=dm:@richard msg=c9d0e1f2 time=2026-03-15T01:00:02 type=human] @richard: hey, can you help?
+[target=#general:a1b2c3d4 msg=f3a4b5c6 time=2026-03-15T01:00:03 type=human] @richard: thread reply
+[target=dm:@richard:x9y8z7a0 msg=d7e8f9a0 time=2026-03-15T01:00:04 type=human] @richard: DM thread reply
 \`\`\`
 
 Header fields:
 - \`target=\` \u2014 where the message came from. Reuse as the \`target\` parameter when replying.
 - \`msg=\` \u2014 message short ID (first 8 chars of UUID). Use as thread suffix to start/reply in a thread.
 - \`time=\` \u2014 timestamp.
-- \`type=agent\` \u2014 present only if the sender is an agent.
+- \`type=\` \u2014 sender kind. Values are \`human\`, \`agent\`, or \`system\`.
 
 ### Sending messages
 
@@ -408,6 +410,7 @@ var ClaudeDriver = class {
   id = "claude";
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
+  busyDeliveryMode = "notification";
   spawn(ctx) {
     const mcpArgs = [
       ctx.chatBridgePath,
@@ -630,8 +633,20 @@ var ClaudeDriver = class {
 
 // src/drivers/codex.ts
 import { spawn as spawn2, execSync } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
+import os from "os";
 import path2 from "path";
+function getCodexNotificationErrorMessage(params) {
+  const topLevelMessage = params?.message;
+  if (typeof topLevelMessage === "string" && topLevelMessage.trim()) {
+    return topLevelMessage;
+  }
+  const nestedMessage = params?.error?.message;
+  if (typeof nestedMessage === "string" && nestedMessage.trim()) {
+    return nestedMessage;
+  }
+  return null;
+}
 function ensureGitRepo(workingDirectory) {
   const gitDir = path2.join(workingDirectory, ".git");
   if (existsSync(gitDir)) return;
@@ -692,7 +707,7 @@ var CodexDriver = class {
   id = "codex";
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp_chat_";
-  deliverMessageDirectlyWhileBusy = true;
+  busyDeliveryMode = "direct";
   process = null;
   requestId = 0;
   threadId = null;
@@ -931,7 +946,10 @@ var CodexDriver = class {
         break;
       }
       case "error":
-        events.push({ kind: "error", message: message.params?.message || "Unknown Codex app-server error" });
+        events.push({
+          kind: "error",
+          message: getCodexNotificationErrorMessage(message.params) || "Unknown Codex app-server error"
+        });
         break;
     }
     return events;
@@ -1072,13 +1090,564 @@ var CodexDriver = class {
       params
     }) + "\n");
   }
+  async detectModels() {
+    return detectCodexModels();
+  }
 };
+function detectCodexModels(home = os.homedir()) {
+  const cachePath = path2.join(home, ".codex", "models_cache.json");
+  const configPath = path2.join(home, ".codex", "config.toml");
+  let models = [];
+  try {
+    const raw = readFileSync(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = Array.isArray(parsed?.models) ? parsed.models : [];
+    for (const entry of entries) {
+      const slug = typeof entry?.slug === "string" ? entry.slug : null;
+      if (!slug) continue;
+      if (entry?.visibility && entry.visibility !== "public") continue;
+      if (entry?.supported_in_api === false) continue;
+      const label = typeof entry?.display_name === "string" && entry.display_name.length > 0 ? entry.display_name : slug;
+      models.push({ id: slug, label });
+    }
+  } catch {
+    return null;
+  }
+  if (models.length === 0) return null;
+  let defaultModel;
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const match = raw.match(/^\s*model\s*=\s*"([^"]+)"/m);
+    if (match) defaultModel = match[1];
+  } catch {
+  }
+  return { models, default: defaultModel };
+}
 
-// src/drivers/kimi.ts
-import { randomUUID } from "crypto";
+// src/drivers/copilot.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
 import path3 from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+var CopilotDriver = class {
+  id = "copilot";
+  supportsStdinNotification = false;
+  mcpToolPrefix = "";
+  busyDeliveryMode = "none";
+  sessionId = null;
+  sessionAnnounced = false;
+  spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const mcpCommand = isTsSource ? "npx" : "node";
+    const mcpArgs = 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 mcpConfigPath = path3.join(ctx.workingDirectory, ".slock-copilot-mcp.json");
+    writeFileSync2(mcpConfigPath, JSON.stringify({
+      mcpServers: {
+        chat: {
+          command: mcpCommand,
+          args: mcpArgs
+        }
+      }
+    }), "utf8");
+    const args = [
+      "--output-format",
+      "json",
+      "--allow-all-tools",
+      "--allow-all-paths",
+      "--additional-mcp-config",
+      `@${mcpConfigPath}`,
+      "-p",
+      ctx.prompt
+    ];
+    if (ctx.config.model && ctx.config.model !== "default") {
+      args.push("--model", ctx.config.model);
+    }
+    if (ctx.config.reasoningEffort) {
+      args.push("--effort", ctx.config.reasoningEffort);
+    }
+    if (ctx.config.sessionId) {
+      args.push(`--resume=${ctx.config.sessionId}`);
+    }
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const proc = spawn3("copilot", args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell: process.platform === "win32"
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    const eventType = event.type;
+    const data = event.data || {};
+    if (event.ephemeral && eventType?.startsWith("session.")) {
+      return [];
+    }
+    switch (eventType) {
+      case "assistant.turn_start":
+        if (!this.sessionAnnounced && data.sessionId) {
+          this.sessionId = data.sessionId;
+          events.push({ kind: "session_init", sessionId: data.sessionId });
+          this.sessionAnnounced = true;
+        }
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "assistant.reasoning":
+        if (data.content) {
+          events.push({ kind: "thinking", text: data.content });
+        }
+        break;
+      case "assistant.message_delta":
+        if (data.deltaContent) {
+          events.push({ kind: "text", text: data.deltaContent });
+        }
+        break;
+      case "assistant.message": {
+        if (Array.isArray(data.toolRequests)) {
+          for (const req of data.toolRequests) {
+            events.push({
+              kind: "tool_call",
+              name: req.name || req.toolName || "unknown_tool",
+              input: req.arguments || req.parameters || req.input || {}
+            });
+          }
+        }
+        if (!event.ephemeral && data.content && typeof data.content === "string") {
+          if (!Array.isArray(data.toolRequests) || data.toolRequests.length === 0) {
+          }
+        }
+        break;
+      }
+      case "assistant.turn_end":
+        events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        break;
+      case "result": {
+        const resultSessionId = event.sessionId || data.sessionId;
+        const exitCode = event.exitCode ?? data.exitCode;
+        if (!this.sessionAnnounced && resultSessionId) {
+          this.sessionId = resultSessionId;
+          events.push({ kind: "session_init", sessionId: resultSessionId });
+          this.sessionAnnounced = true;
+        }
+        if (exitCode && exitCode !== 0) {
+          events.push({ kind: "error", message: `Copilot exited with code ${exitCode}` });
+        }
+        events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        break;
+      }
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  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: false,
+      messageNotificationStyle: "poll"
+    });
+  }
+  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" || name === "Shell") return "Running command\u2026";
+    if (name === "read_file" || name === "ReadFile") return "Reading file\u2026";
+    if (name === "write_file" || name === "WriteFile" || name === "edit_file" || name === "EditFile") return "Editing file\u2026";
+    if (name === "search_files" || name === "Glob" || name === "Grep") return "Searching code\u2026";
+    if (name === "web_search" || name === "SearchWeb") return "Searching web\u2026";
+    if (name === "fetch_url" || name === "FetchURL") return "Fetching web\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" || name === "Shell") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "read_file" || name === "ReadFile" || name === "write_file" || name === "WriteFile" || name === "edit_file" || name === "EditFile") {
+        return input.path || input.file_path || "";
+      }
+      if (name === "Glob" || name === "Grep" || name === "search_files") return input.pattern || input.query || "";
+      if (name === "web_search" || name === "SearchWeb") return input.query || "";
+      if (name === "fetch_url" || 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/cursor.ts
+import { spawn as spawn4 } from "child_process";
+import { writeFileSync as writeFileSync3, mkdirSync, existsSync as existsSync2 } from "fs";
+import path4 from "path";
+var CursorDriver = class {
+  id = "cursor";
+  supportsStdinNotification = false;
+  mcpToolPrefix = "mcp__chat__";
+  busyDeliveryMode = "none";
+  spawn(ctx) {
+    const cursorDir = path4.join(ctx.workingDirectory, ".cursor");
+    if (!existsSync2(cursorDir)) {
+      mkdirSync(cursorDir, { recursive: true });
+    }
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const mcpCommand = isTsSource ? "npx" : "node";
+    const mcpArgs = 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 mcpConfigPath = path4.join(cursorDir, "mcp.json");
+    writeFileSync3(mcpConfigPath, JSON.stringify({
+      mcpServers: {
+        chat: {
+          command: mcpCommand,
+          args: mcpArgs
+        }
+      }
+    }), "utf8");
+    const args = [
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--yolo",
+      "--approve-mcps",
+      "--trust"
+    ];
+    if (ctx.config.model && ctx.config.model !== "default") {
+      args.push("--model", ctx.config.model);
+    }
+    if (ctx.config.sessionId) {
+      args.push("--resume", ctx.config.sessionId);
+    }
+    args.push(ctx.prompt);
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const proc = spawn4("agent", args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell: process.platform === "win32"
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init" && event.session_id) {
+          events.push({ kind: "session_init", sessionId: event.session_id });
+        }
+        break;
+      case "assistant": {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "thinking" && block.thinking) {
+              events.push({ kind: "thinking", text: block.thinking });
+            } else if (block.type === "text" && block.text) {
+              events.push({ kind: "text", text: block.text });
+            } else if (block.type === "tool_use") {
+              events.push({ kind: "tool_call", name: block.name || "unknown_tool", input: block.input });
+            }
+          }
+        }
+        break;
+      }
+      case "result": {
+        const subtype = typeof event.subtype === "string" ? event.subtype : "success";
+        if (subtype !== "success" || event.is_error) {
+          const parts = [];
+          if (Array.isArray(event.errors)) {
+            for (const err of event.errors) {
+              if (typeof err === "string" && err.trim()) parts.push(err.trim());
+            }
+          }
+          if (typeof event.result === "string" && event.result.trim()) {
+            parts.push(event.result.trim());
+          }
+          const detail = parts.join(" | ") || "Execution failed";
+          events.push({ kind: "error", message: detail });
+        }
+        events.push({ kind: "turn_end", sessionId: event.session_id });
+        break;
+      }
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildBaseSystemPrompt(config, {
+      toolPrefix: "mcp__chat__",
+      extraCriticalRules: [
+        "- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything."
+      ],
+      postStartupNotes: [],
+      includeStdinNotificationSection: false,
+      messageNotificationStyle: "poll"
+    });
+  }
+  toolDisplayName(name) {
+    if (name === "mcp__chat__upload_file") return "Uploading file\u2026";
+    if (name === "mcp__chat__view_file") return "Viewing file\u2026";
+    if (name === "mcp__chat__list_tasks") return "Listing tasks\u2026";
+    if (name === "mcp__chat__create_tasks") return "Creating tasks\u2026";
+    if (name === "mcp__chat__claim_tasks") return "Claiming tasks\u2026";
+    if (name === "mcp__chat__unclaim_task") return "Unclaiming task\u2026";
+    if (name === "mcp__chat__update_task_status") return "Updating task status\u2026";
+    if (name === "mcp__chat__list_server") return "Listing server\u2026";
+    if (name === "mcp__chat__read_history") return "Reading history\u2026";
+    if (name === "mcp__chat__search_messages") return "Searching messages\u2026";
+    if (name === "mcp__chat__check_messages") return "Checking messages\u2026";
+    if (name.startsWith("mcp__chat__")) return "";
+    if (name === "Read" || name === "read_file") return "Reading file\u2026";
+    if (name === "Write" || name === "write_file") return "Writing file\u2026";
+    if (name === "Edit" || name === "edit_file") return "Editing file\u2026";
+    if (name === "Bash" || name === "bash") return "Running command\u2026";
+    if (name === "Glob" || name === "glob") return "Searching files\u2026";
+    if (name === "Grep" || name === "grep") return "Searching code\u2026";
+    if (name === "WebFetch" || name === "web_fetch") return "Fetching web\u2026";
+    if (name === "WebSearch" || name === "web_search") return "Searching web\u2026";
+    if (name === "TodoWrite") 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 === "Read" || name === "read_file") return input.file_path || input.path || "";
+      if (name === "Write" || name === "write_file") return input.file_path || input.path || "";
+      if (name === "Edit" || name === "edit_file") return input.file_path || input.path || "";
+      if (name === "Bash" || name === "bash") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "Glob" || name === "glob") return input.pattern || "";
+      if (name === "Grep" || name === "grep") return input.pattern || "";
+      if (name === "WebFetch" || name === "web_fetch") return input.url || "";
+      if (name === "WebSearch" || name === "web_search") return input.query || "";
+      if (name === "mcp__chat__send_message") {
+        return input.target || input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
+      }
+      if (name === "mcp__chat__read_history") return input.target || input.channel || "";
+      if (name === "mcp__chat__search_messages") return input.query || "";
+      if (name === "mcp__chat__list_tasks") return input.channel || "";
+      if (name === "mcp__chat__create_tasks") return input.channel || "";
+      if (name === "mcp__chat__claim_tasks") {
+        const nums = input.task_numbers;
+        return input.channel ? `${input.channel} #${Array.isArray(nums) ? nums.join(",#t") : nums}` : "";
+      }
+      if (name === "mcp__chat__unclaim_task") {
+        return input.channel ? `${input.channel} #${input.task_number}` : "";
+      }
+      if (name === "mcp__chat__update_task_status") {
+        return input.channel ? `${input.channel} #${input.task_number}` : "";
+      }
+      if (name === "mcp__chat__upload_file") return input.file_path || "";
+      return "";
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/drivers/gemini.ts
+import { spawn as spawn5 } from "child_process";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import path5 from "path";
+var GeminiDriver = class {
+  id = "gemini";
+  supportsStdinNotification = false;
+  mcpToolPrefix = "";
+  busyDeliveryMode = "none";
+  sessionId = null;
+  sessionAnnounced = false;
+  spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    const geminiDir = path5.join(ctx.workingDirectory, ".gemini");
+    if (!existsSync3(geminiDir)) {
+      mkdirSync2(geminiDir, { recursive: true });
+    }
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const mcpCommand = isTsSource ? "npx" : "node";
+    const mcpArgs = 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 settingsPath = path5.join(geminiDir, "settings.json");
+    writeFileSync4(settingsPath, JSON.stringify({
+      mcpServers: {
+        chat: {
+          command: mcpCommand,
+          args: mcpArgs
+        }
+      }
+    }), "utf8");
+    const args = [
+      "--output-format",
+      "stream-json",
+      "--yolo",
+      "-p",
+      ctx.prompt
+    ];
+    if (ctx.config.model && ctx.config.model !== "default") {
+      args.push("--model", ctx.config.model);
+    }
+    if (ctx.config.sessionId) {
+      args.push("--resume", ctx.config.sessionId);
+    }
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const proc = spawn5("gemini", args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+      shell: process.platform === "win32"
+    });
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    switch (event.type) {
+      case "init":
+        if (event.session_id) {
+          this.sessionId = event.session_id;
+          events.push({ kind: "session_init", sessionId: event.session_id });
+          this.sessionAnnounced = true;
+        }
+        break;
+      case "message":
+        if (event.role === "assistant" && event.content) {
+          if (event.delta) {
+            events.push({ kind: "text", text: event.content });
+          } else {
+            events.push({ kind: "text", text: event.content });
+          }
+        }
+        break;
+      case "tool_use":
+        events.push({
+          kind: "tool_call",
+          name: event.tool_name || "unknown_tool",
+          input: event.parameters
+        });
+        break;
+      case "error":
+        events.push({ kind: "error", message: event.message || "Unknown Gemini error" });
+        break;
+      case "result":
+        if (event.status !== "success") {
+          const raw = event.error_message || event.message || event.error || "";
+          const detail = typeof raw === "string" ? raw : raw?.message || JSON.stringify(raw);
+          const msg = detail ? `Gemini error: ${detail}` : `Gemini session ended with status: ${event.status}`;
+          events.push({ kind: "error", message: msg });
+        }
+        events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        break;
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  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: false,
+      messageNotificationStyle: "poll"
+    });
+  }
+  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" || name === "Shell") return "Running command\u2026";
+    if (name === "read_file" || name === "ReadFile") return "Reading file\u2026";
+    if (name === "write_file" || name === "WriteFile" || name === "edit_file" || name === "EditFile") return "Editing file\u2026";
+    if (name === "search_files" || name === "Glob" || name === "Grep") return "Searching code\u2026";
+    if (name === "web_search" || name === "SearchWeb") return "Searching web\u2026";
+    if (name === "fetch_url" || name === "FetchURL") return "Fetching web\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" || name === "Shell") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (name === "read_file" || name === "ReadFile" || name === "write_file" || name === "WriteFile" || name === "edit_file" || name === "EditFile") {
+        return input.path || input.file_path || "";
+      }
+      if (name === "Glob" || name === "Grep" || name === "search_files") return input.pattern || input.query || "";
+      if (name === "web_search" || name === "SearchWeb") return input.query || "";
+      if (name === "fetch_url" || 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/kimi.ts
+import { randomUUID } from "crypto";
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import os2 from "os";
+import path6 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";
@@ -1095,7 +1664,7 @@ var KimiDriver = class {
   id = "kimi";
   supportsStdinNotification = true;
   mcpToolPrefix = "";
-  deliverMessageDirectlyWhileBusy = true;
+  busyDeliveryMode = "direct";
   sessionId = null;
   sessionAnnounced = false;
   promptRequestId = null;
@@ -1107,20 +1676,20 @@ var KimiDriver = class {
     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");
+    const systemPromptPath = path6.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path6.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const mcpConfigPath = path6.join(ctx.workingDirectory, KIMI_MCP_FILE);
+    if (!isResume || !existsSync4(systemPromptPath)) {
+      writeFileSync5(systemPromptPath, ctx.prompt, "utf8");
     }
-    writeFileSync2(agentFilePath, [
+    writeFileSync5(agentFilePath, [
       "version: 1",
       "agent:",
       "  extend: default",
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
-    writeFileSync2(mcpConfigPath, JSON.stringify({
+    writeFileSync5(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
           command,
@@ -1142,7 +1711,7 @@ var KimiDriver = class {
       args.push("--model", ctx.config.model);
     }
     const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
-    const proc = spawn3("kimi", args, {
+    const proc = spawn6("kimi", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -1297,12 +1866,43 @@ var KimiDriver = class {
       return "";
     }
   }
+  async detectModels() {
+    return detectKimiModels();
+  }
 };
+function detectKimiModels(home = os2.homedir()) {
+  const configPath = path6.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync2(configPath, "utf8");
+  } catch {
+    return null;
+  }
+  const models = [];
+  const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
+  const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
+  let match;
+  while ((match = lineRe.exec(raw)) !== null) {
+    let key = match[1].trim();
+    if (key.startsWith('"') && key.endsWith('"')) key = key.slice(1, -1);
+    if (!key) continue;
+    models.push({ id: key, label: key });
+  }
+  void sectionRe;
+  if (models.length === 0) return null;
+  let defaultModel;
+  const defaultMatch = raw.match(/^\s*default_model\s*=\s*"([^"]+)"/m);
+  if (defaultMatch) defaultModel = defaultMatch[1];
+  return { models, default: defaultModel };
+}
 
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
   codex: () => new CodexDriver(),
+  copilot: () => new CopilotDriver(),
+  cursor: () => new CursorDriver(),
+  gemini: () => new GeminiDriver(),
   kimi: () => new KimiDriver()
 };
 function getDriver(runtimeId) {
@@ -1359,7 +1959,7 @@ var logger = {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path4 from "path";
+import path7 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -1367,7 +1967,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path4.join(dataDir, directoryName);
+  return path7.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -1416,7 +2016,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path4.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path7.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -1435,7 +2035,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path4.join(dataDir, entry.name);
+      const dirPath = path7.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -1467,7 +2067,7 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path5.join(os.homedir(), ".slock", "agents");
+var DATA_DIR = path8.join(os3.homedir(), ".slock", "agents");
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -1479,7 +2079,7 @@ function formatChannelLabel(message) {
 }
 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;
+    const shortId = getMessageShortId(message.channel_name);
     if (message.parent_channel_type === "dm") {
       return `dm:@${message.parent_channel_name}:${shortId}`;
     }
@@ -1490,15 +2090,47 @@ function formatMessageTarget(message) {
   }
   return `#${message.channel_name}`;
 }
+function getMessageShortId(messageId) {
+  return messageId.startsWith("thread-") ? messageId.slice(7) : messageId.slice(0, 8);
+}
+function formatSenderHandle(message) {
+  return message.sender_description ? `@${message.sender_name} \u2014 ${message.sender_description}` : `@${message.sender_name}`;
+}
+function formatVisibleActorType(type) {
+  return ` type=${type}`;
+}
+function formatTaskAssigneeType(type) {
+  return type ?? null;
+}
+function formatThreadContextMessage(message) {
+  const msgId = message.message_id ? getMessageShortId(message.message_id) : "-";
+  const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
+  const senderType = formatVisibleActorType(message.sender_type);
+  return `- [msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}`;
+}
 function formatIncomingMessage(message) {
+  const threadJoinPrefix = message.thread_join_context ? [
+    `[System: You were added to a new thread via @mention. Read this context before replying.]`,
+    `parent: ${message.thread_join_context.parent_target}`,
+    `thread: ${message.thread_join_context.thread_target}`,
+    `suggested next step: read_history(channel="${message.thread_join_context.suggested_read_history_target}")`,
+    "",
+    "Parent message:",
+    formatThreadContextMessage(message.thread_join_context.parent_message),
+    "",
+    `Recent thread context${message.thread_join_context.history_truncated ? " (truncated)" : ""}:`,
+    message.thread_join_context.recent_messages.length > 0 ? message.thread_join_context.recent_messages.map(formatThreadContextMessage).join("\n") : "- (no earlier thread replies)",
+    ""
+  ].join("\n") : "";
   const target = formatMessageTarget(message);
-  const msgId = message.message_id ? message.message_id.slice(0, 8) : "-";
+  const msgId = message.message_id ? getMessageShortId(message.message_id) : "-";
   const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
-  const senderType = message.sender_type === "agent" ? " type=agent" : "";
-  const renderedContent = message.content;
-  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}: ${renderedContent}${attachSuffix}${taskSuffix}`;
+  const senderType = formatVisibleActorType(message.sender_type);
+  const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} attachment${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to download]` : "";
+  const taskSuffix = message.task_status ? ` [task #${message.task_number} status=${message.task_status}${message.task_assignee_id ? ` assignee=${formatTaskAssigneeType(message.task_assignee_type)}:${message.task_assignee_id}` : ""}]` : "";
+  const body = `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}${attachSuffix}${taskSuffix}`;
+  return threadJoinPrefix ? `${threadJoinPrefix}
+${body}` : body;
 }
 function buildUnreadSummary(messages, excludeChannel) {
   const summary = /* @__PURE__ */ new Map();
@@ -1571,7 +2203,7 @@ function getMessageDeliveryText(driver) {
 }
 function getBusyDeliveryNote(driver) {
   if (!driver.supportsStdinNotification) return "";
-  if (driver.deliverMessageDirectlyWhileBusy) {
+  if (driver.busyDeliveryMode === "direct") {
     return "\n\nNote: While you are busy, new messages may be delivered directly into your active turn. Handle them when appropriate and keep working.";
   }
   return "\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.";
@@ -1609,9 +2241,9 @@ var AgentProcessManager = class _AgentProcessManager {
     this.agentsStarting.add(agentId);
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path5.join(this.dataDir, agentId);
+      const agentDataDir = path8.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path5.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path8.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
@@ -1629,7 +2261,7 @@ ${config.description || "No role defined yet."}
 `;
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      await mkdir(path5.join(agentDataDir, "notes"), { recursive: true });
+      await mkdir(path8.join(agentDataDir, "notes"), { recursive: true });
       const isResume = !!config.sessionId;
       let prompt;
       if (isResume && resumePrompt) {
@@ -1958,7 +2590,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path5.join(this.dataDir, agentId);
+    const agentDataDir = path8.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -1996,7 +2628,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   }
   // Workspace file browsing
   async getFileTree(agentId, dirPath) {
-    const agentDir = path5.join(this.dataDir, agentId);
+    const agentDir = path8.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -2004,8 +2636,8 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path5.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path5.sep) && resolved !== agentDir) {
+      const resolved = path8.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path8.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -2013,9 +2645,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     return this.listDirectoryChildren(targetDir, agentDir);
   }
   async readFile(agentId, filePath) {
-    const agentDir = path5.join(this.dataDir, agentId);
-    const resolved = path5.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path5.sep) && resolved !== agentDir) {
+    const agentDir = path8.join(this.dataDir, agentId);
+    const resolved = path8.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path8.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
@@ -2039,7 +2671,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       ".sh",
       ".py"
     ]);
-    const ext = path5.extname(resolved).toLowerCase();
+    const ext = path8.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -2065,14 +2697,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   async listSkills(agentId, runtimeHint) {
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
-    const home = os.homedir();
-    const workspaceDir = path5.join(this.dataDir, agentId);
+    const home = os3.homedir();
+    const workspaceDir = path8.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(path5.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path8.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path5.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path8.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -2101,7 +2733,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     const skills = [];
     for (const entry of entries) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const skillMd = path5.join(dir, entry.name, "SKILL.md");
+        const skillMd = path8.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -2112,7 +2744,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       } else if (entry.name.endsWith(".md")) {
         const cmdName = entry.name.replace(/\.md$/, "");
         try {
-          const content = await readFile(path5.join(dir, entry.name), "utf-8");
+          const content = await readFile(path8.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -2287,7 +2919,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (count === 0) return;
     if (ap.isIdle) return;
     if (!ap.sessionId) return;
-    if (ap.driver.deliverMessageDirectlyWhileBusy && ap.inbox.length > 0) {
+    if (ap.driver.busyDeliveryMode === "direct" && 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");
@@ -2350,8 +2982,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 = path5.join(dir, entry.name);
-      const relativePath = path5.relative(rootDir, fullPath);
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -2522,13 +3154,13 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path6.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path6.resolve(dirname, "chat-bridge.js");
+  const dirname = path9.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path9.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path6.resolve(dirname, "chat-bridge.ts");
+    return path9.resolve(dirname, "chat-bridge.ts");
   }
 }
 function detectRuntimes() {
@@ -2570,6 +3202,8 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
     case "machine:workspace:delete":
       return `(directory=${msg.directoryName})`;
+    case "machine:runtime_models:detect":
+      return `(runtime=${msg.runtime}, req=${msg.requestId})`;
     default:
       return "";
   }
@@ -2688,6 +3322,21 @@ var DaemonCore = class {
           this.connection.send({ type: "machine:workspace:delete_result", directoryName: msg.directoryName, success });
         });
         break;
+      case "machine:runtime_models:detect": {
+        const driver = getDriver(msg.runtime);
+        const detect = typeof driver?.detectModels === "function" ? driver.detectModels() : Promise.resolve(null);
+        Promise.resolve(detect).then((result) => {
+          if (result) {
+            this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, models: result.models, default: result.default });
+          } else {
+            this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: "unsupported" });
+          }
+        }).catch((err) => {
+          const reason = err instanceof Error ? err.message : String(err);
+          this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: reason });
+        });
+        break;
+      }
       case "ping":
         this.connection.send({ type: "pong" });
         break;
@@ -2702,8 +3351,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os2.hostname(),
-      os: this.options.osDescription ?? `${os2.platform()} ${os2.arch()}`,
+      hostname: this.options.hostname ?? os4.hostname(),
+      os: this.options.osDescription ?? `${os4.platform()} ${os4.arch()}`,
       daemonVersion: this.daemonVersion
     });
     for (const agentId of this.agentManager.getRunningAgentIds()) {

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   subscribeDaemonLogs
-} from "./chunk-ZXIMDHR7.js";
+} from "./chunk-OSHFDFBV.js";
 import "./chunk-GX2DVINN.js";
 export {
   DAEMON_CLI_USAGE,

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-ZXIMDHR7.js";
+} from "./chunk-OSHFDFBV.js";
 import "./chunk-GX2DVINN.js";
 
 // src/index.ts

package/package.json

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