@slock-ai/daemon 0.34.0 → 0.36.1-alpha.0

package/dist/{chunk-ZXIMDHR7.js → chunk-7RQ2H2AM.js}

@@ -1,15 +1,37 @@
 import {
-  buildWebSocketOptions
-} from "./chunk-GX2DVINN.js";
+  buildWebSocketOptions,
+  logger
+} from "./chunk-E6OOH3IC.js";
 
 // src/core.ts
-import path6 from "path";
-import os2 from "os";
+import path10 from "path";
+import os4 from "os";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
 
+// ../shared/src/testing/failpoints.ts
+var NoopFailpointRegistry = class {
+  get enabled() {
+    return false;
+  }
+  isEnabled() {
+    return false;
+  }
+  configure() {
+  }
+  clear() {
+  }
+  getTrace() {
+    return [];
+  }
+  hit(_key, _context, fallback) {
+    return fallback ? fallback() : void 0;
+  }
+};
+var noopFailpointRegistry = new NoopFailpointRegistry();
+
 // ../shared/src/serverPermissions.ts
 var EMPTY_SERVER_CAPABILITIES = Object.freeze({
   manageServer: false,
@@ -38,7 +60,7 @@ var SERVER_CAPABILITY_MATRIX = {
     manageAgents: true,
     manageMachines: true,
     manageMembers: true,
-    changeMemberRoles: false,
+    changeMemberRoles: true,
     manageBilling: false,
     joinPublicChannels: true
   }),
@@ -58,8 +80,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,13 +121,13 @@ 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 path9 from "path";
+import os3 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
 import { writeFileSync } from "fs";
-import path from "path";
+import path2 from "path";
 
 // src/drivers/systemPrompt.ts
 function toolRef(prefix, name) {
@@ -145,8 +169,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 +190,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
 
@@ -295,6 +319,8 @@ Keep the user informed. They cannot see your internal reasoning, so:
 
 Use plain-text @mentions (e.g. \`@alice\`) and #channel references (e.g. \`#general\`, \`#1\`) \u2014 no HTML tags.
 
+When referring to a task in message content, use the explicit form \`task #123\`. Do not use bare \`#123\` for task references \u2014 bare \`#123\` is ambiguous with PR, issue, and release references.
+
 When referencing a channel or mentioning someone, write them as plain text without backticks. Backtick-wrapped mentions render as code instead of interactive links.
 
 ### Formatting \u2014 URLs in non-English text
@@ -403,11 +429,83 @@ ${config.description}. This may evolve.`;
   return prompt;
 }
 
+// src/drivers/probe.ts
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+function normalizeExecOutput(raw) {
+  return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
+}
+function resolveCommandOnPath(command, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
+  const locator = platform === "win32" ? "where" : "which";
+  try {
+    const output = normalizeExecOutput(execFileSyncFn(locator, [command], {
+      stdio: ["ignore", "pipe", "ignore"],
+      env
+    }));
+    const resolved = output.trim().split(/\r?\n/)[0];
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}
+function firstExistingPath(candidates, deps = {}) {
+  const exists = deps.existsSyncFn ?? existsSync;
+  for (const candidate of candidates) {
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
+function readCommandVersion(command, args = [], deps = {}) {
+  const env = deps.env ?? process.env;
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
+  try {
+    const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      timeout: 5e3
+    }));
+    return output.trim().split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+function resolveHomePath(relativePath, deps = {}) {
+  const homeDir = deps.homeDir ?? deps.env?.HOME ?? process.env.HOME ?? "";
+  return path.join(homeDir, relativePath);
+}
+
 // src/drivers/claude.ts
+var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path2.join("Applications", "Claude Code URL Handler.app", "Contents", "MacOS", "claude");
+var CLAUDE_DESKTOP_CLI_SYSTEM_PATH = "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude";
+function resolveClaudeCommand(deps = {}) {
+  const pathCommand = resolveCommandOnPath("claude", deps);
+  if (pathCommand) return pathCommand;
+  if ((deps.platform ?? process.platform) !== "darwin") return null;
+  return firstExistingPath([
+    resolveHomePath(CLAUDE_DESKTOP_CLI_RELATIVE_PATH, deps),
+    CLAUDE_DESKTOP_CLI_SYSTEM_PATH
+  ], deps);
+}
+function probeClaude(deps = {}) {
+  const command = resolveClaudeCommand(deps);
+  if (!command) return { available: false };
+  return {
+    available: true,
+    version: readCommandVersion(command, [], deps) ?? void 0
+  };
+}
 var ClaudeDriver = class {
   id = "claude";
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
+  busyDeliveryMode = "notification";
+  probe() {
+    return probeClaude();
+  }
   spawn(ctx) {
     const mcpArgs = [
       ctx.chatBridgePath,
@@ -429,7 +527,7 @@ var ClaudeDriver = class {
     });
     let mcpConfigArg;
     if (process.platform === "win32") {
-      const mcpConfigPath = path.join(ctx.workingDirectory, ".slock-claude-mcp.json");
+      const mcpConfigPath = path2.join(ctx.workingDirectory, ".slock-claude-mcp.json");
       writeFileSync(mcpConfigPath, mcpConfig, "utf8");
       mcpConfigArg = mcpConfigPath;
     } else {
@@ -455,7 +553,7 @@ var ClaudeDriver = class {
     }
     const spawnEnv = { ...process.env, FORCE_COLOR: "0", ...ctx.config.envVars || {} };
     delete spawnEnv.CLAUDECODE;
-    const proc = spawn("claude", args, {
+    const proc = spawn(resolveClaudeCommand() ?? "claude", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -630,11 +728,23 @@ var ClaudeDriver = class {
 
 // src/drivers/codex.ts
 import { spawn as spawn2, execSync } from "child_process";
-import { existsSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import os from "os";
+import path3 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;
+  const gitDir = path3.join(workingDirectory, ".git");
+  if (existsSync2(gitDir)) return;
   execSync("git init", { cwd: workingDirectory, stdio: "pipe" });
   execSync("git add -A && git commit --allow-empty -m 'init'", {
     cwd: workingDirectory,
@@ -648,22 +758,48 @@ function ensureGitRepo(workingDirectory) {
     }
   });
 }
-function resolveCodexSpawn(commandArgs) {
-  if (process.platform !== "win32") {
-    return { command: "codex", args: commandArgs };
+var CODEX_DESKTOP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
+function resolveCodexCommand(deps = {}) {
+  const pathCommand = resolveCommandOnPath("codex", deps);
+  if (pathCommand) return pathCommand;
+  if ((deps.platform ?? process.platform) !== "darwin") return null;
+  return firstExistingPath([CODEX_DESKTOP_BUNDLE_PATH], deps);
+}
+function probeCodex(deps = {}) {
+  if ((deps.platform ?? process.platform) === "win32") {
+    try {
+      const resolved = resolveCodexSpawn([], deps);
+      return {
+        available: true,
+        version: readCommandVersion(resolved.command, resolved.args, deps) ?? void 0
+      };
+    } catch {
+      return { available: false };
+    }
+  }
+  const command = resolveCodexCommand(deps);
+  if (!command) return { available: false };
+  return {
+    available: true,
+    version: readCommandVersion(command, [], deps) ?? void 0
+  };
+}
+function resolveCodexSpawn(commandArgs, deps = {}) {
+  if ((deps.platform ?? process.platform) !== "win32") {
+    return { command: resolveCodexCommand(deps) ?? "codex", args: commandArgs };
   }
   let codexEntry = null;
   try {
     const globalRoot = execSync("npm root -g", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const candidate = path2.join(globalRoot, "@openai", "codex", "bin", "codex.js");
-    if (existsSync(candidate)) codexEntry = candidate;
+    const candidate = path3.join(globalRoot, "@openai", "codex", "bin", "codex.js");
+    if (existsSync2(candidate)) codexEntry = candidate;
   } catch {
   }
   if (!codexEntry) {
     try {
       const cmdPath = execSync("where codex", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim().split(/\r?\n/)[0];
-      const candidate = path2.join(path2.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
-      if (existsSync(candidate)) codexEntry = candidate;
+      const candidate = path3.join(path3.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
+      if (existsSync2(candidate)) codexEntry = candidate;
     } catch {
     }
   }
@@ -692,7 +828,10 @@ var CodexDriver = class {
   id = "codex";
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp_chat_";
-  deliverMessageDirectlyWhileBusy = true;
+  busyDeliveryMode = "direct";
+  probe() {
+    return probeCodex();
+  }
   process = null;
   requestId = 0;
   threadId = null;
@@ -931,7 +1070,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 +1214,564 @@ var CodexDriver = class {
       params
     }) + "\n");
   }
+  async detectModels() {
+    return detectCodexModels();
+  }
+};
+function detectCodexModels(home = os.homedir()) {
+  const cachePath = path3.join(home, ".codex", "models_cache.json");
+  const configPath = path3.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/copilot.ts
+import { spawn as spawn3 } from "child_process";
+import path4 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 = path4.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 existsSync3 } from "fs";
+import path5 from "path";
+var CursorDriver = class {
+  id = "cursor";
+  supportsStdinNotification = false;
+  mcpToolPrefix = "mcp__chat__";
+  busyDeliveryMode = "none";
+  spawn(ctx) {
+    const cursorDir = path5.join(ctx.workingDirectory, ".cursor");
+    if (!existsSync3(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 = path5.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 existsSync4 } from "fs";
+import path6 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 = path6.join(ctx.workingDirectory, ".gemini");
+    if (!existsSync4(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 = path6.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 spawn3 } from "child_process";
-import { existsSync as existsSync2, writeFileSync as writeFileSync2 } from "fs";
-import path3 from "path";
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import os2 from "os";
+import path7 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 +1788,7 @@ var KimiDriver = class {
   id = "kimi";
   supportsStdinNotification = true;
   mcpToolPrefix = "";
-  deliverMessageDirectlyWhileBusy = true;
+  busyDeliveryMode = "direct";
   sessionId = null;
   sessionAnnounced = false;
   promptRequestId = null;
@@ -1107,20 +1800,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 = path7.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path7.join(ctx.workingDirectory, KIMI_AGENT_FILE);
+    const mcpConfigPath = path7.join(ctx.workingDirectory, KIMI_MCP_FILE);
+    if (!isResume || !existsSync5(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 +1835,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 +1990,43 @@ var KimiDriver = class {
       return "";
     }
   }
+  async detectModels() {
+    return detectKimiModels();
+  }
 };
+function detectKimiModels(home = os2.homedir()) {
+  const configPath = path7.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) {
@@ -1314,52 +2038,9 @@ function getDriver(runtimeId) {
   return driver;
 }
 
-// src/logger.ts
-var listeners = /* @__PURE__ */ new Set();
-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}`;
-}
-function emit(event) {
-  for (const listener of listeners) {
-    listener(event);
-  }
-}
-function subscribeDaemonLogs(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-var logger = {
-  info(msg) {
-    const line = format("INFO", msg);
-    console.log(line);
-    emit({ level: "INFO", line, message: msg });
-  },
-  warn(msg) {
-    const line = format("WARN", msg);
-    console.warn(line);
-    emit({ level: "WARN", line, message: msg });
-  },
-  error(msg, err) {
-    const line = format("ERROR", msg);
-    if (err) {
-      console.error(line, err);
-    } else {
-      console.error(line);
-    }
-    emit({ level: "ERROR", line, message: msg, error: err });
-  }
-};
-
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path4 from "path";
+import path8 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -1367,7 +2048,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path4.join(dataDir, directoryName);
+  return path8.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -1416,7 +2097,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(path8.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -1435,7 +2116,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path4.join(dataDir, entry.name);
+      const dirPath = path8.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -1467,7 +2148,7 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path5.join(os.homedir(), ".slock", "agents");
+var DATA_DIR = path9.join(os3.homedir(), ".slock", "agents");
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -1479,7 +2160,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 +2171,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();
@@ -1561,6 +2274,19 @@ function summarizeCrash(code, signal) {
   if (typeof code === "number") return `exit code ${code}`;
   return "unknown exit";
 }
+function classifyTerminalFailure(ap) {
+  const candidates = [
+    ap.lastRuntimeError,
+    ...ap.recentStderr
+  ].filter((value) => !!value);
+  for (const text of candidates) {
+    const lower = text.toLowerCase();
+    if (lower.includes("usage limit") || lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("budget limit exceeded") || lower.includes("usage not included in your plan") || lower.includes("modelnotfounderror") || lower.includes("requested entity was not found") || lower.includes("model deprecated") || lower.includes("model not found")) {
+      return text;
+    }
+  }
+  return null;
+}
 function isMissingResumeSession(ap) {
   if (ap.driver.id !== "claude") return false;
   if (!ap.sessionId) return false;
@@ -1571,7 +2297,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 +2335,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 = path9.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
-      const memoryMdPath = path5.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path9.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
@@ -1629,7 +2355,7 @@ ${config.description || "No role defined yet."}
 `;
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      await mkdir(path5.join(agentDataDir, "notes"), { recursive: true });
+      await mkdir(path9.join(agentDataDir, "notes"), { recursive: true });
       const isResume = !!config.sessionId;
       let prompt;
       if (isResume && resumePrompt) {
@@ -1766,6 +2492,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           this.agents.delete(agentId);
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
+          const terminalFailureDetail = classifyTerminalFailure(ap);
           if (finalCode === 0) {
             const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
@@ -1818,13 +2545,23 @@ Use read_history to catch up on the channels listed above, then stop. Read each
               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})`);
+                this.broadcastActivity(agentId, "offline", `Crashed (${summary})`, [], ap.launchId);
               });
               return;
             }
             logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
             this.sendAgentStatus(agentId, "inactive", ap.launchId);
-            this.broadcastActivity(agentId, "offline", `Crashed (${summary})`);
+            if (terminalFailureDetail) {
+              this.broadcastActivity(
+                agentId,
+                "error",
+                terminalFailureDetail,
+                [{ kind: "text", text: `Error: ${terminalFailureDetail}` }],
+                ap.launchId
+              );
+            } else {
+              this.broadcastActivity(agentId, "offline", `Crashed (${summary})`, [], ap.launchId);
+            }
           }
         }
       });
@@ -1958,7 +2695,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 = path9.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -1996,7 +2733,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 = path9.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -2004,8 +2741,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 = path9.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path9.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -2013,9 +2750,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 = path9.join(this.dataDir, agentId);
+    const resolved = path9.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path9.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
@@ -2039,7 +2776,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 = path9.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -2065,14 +2802,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 = path9.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(path9.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path5.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path9.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -2101,7 +2838,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 = path9.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -2112,7 +2849,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(path9.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -2148,14 +2885,21 @@ Use read_history to catch up on the channels listed above, then stop. Read each
    * Broadcast an activity change — emits a single agent:activity event that carries
    * both the status (for the dot indicator) and trajectory entries (for the activity log).
    */
-  broadcastActivity(agentId, activity, detail, extraTrajectory = []) {
+  broadcastActivity(agentId, activity, detail, extraTrajectory = [], launchIdOverride) {
     const ap = this.agents.get(agentId);
     const entries = [...extraTrajectory];
     const hasToolStart = entries.some((e) => e.kind === "tool_start");
     if (!hasToolStart) {
       entries.push({ kind: "status", activity, detail });
     }
-    this.sendToServer({ type: "agent:activity", agentId, activity, detail, entries, launchId: ap?.launchId || void 0 });
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity,
+      detail,
+      entries,
+      launchId: launchIdOverride || ap?.launchId || void 0
+    });
     if (ap) {
       ap.lastActivity = activity;
       ap.lastActivityDetail = detail;
@@ -2167,7 +2911,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
               agentId,
               activity: ap.lastActivity,
               detail: ap.lastActivityDetail,
-              launchId: ap.launchId || void 0
+              launchId: launchIdOverride || ap.launchId || void 0
             });
           }, ACTIVITY_HEARTBEAT_MS);
         }
@@ -2287,7 +3031,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 +3094,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 = path9.join(dir, entry.name);
+      const relativePath = path9.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -2522,13 +3266,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 = path10.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path10.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path6.resolve(dirname, "chat-bridge.ts");
+    return path10.resolve(dirname, "chat-bridge.ts");
   }
 }
 function detectRuntimes() {
@@ -2536,6 +3280,15 @@ function detectRuntimes() {
   const versions = {};
   const cmd = process.platform === "win32" ? "where" : "which";
   for (const runtime of RUNTIMES) {
+    try {
+      const probe = getDriver(runtime.id).probe?.();
+      if (probe?.available) {
+        ids.push(runtime.id);
+        if (probe.version) versions[runtime.id] = probe.version;
+        continue;
+      }
+    } catch {
+    }
     try {
       execSync2(`${cmd} ${runtime.binary}`, { stdio: "pipe" });
       ids.push(runtime.id);
@@ -2570,6 +3323,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 +3443,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 +3472,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()) {
@@ -2725,7 +3495,6 @@ var DaemonCore = class {
 };
 
 export {
-  subscribeDaemonLogs,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,