@slock-ai/daemon 0.42.0 → 0.44.2

package/dist/{chunk-RNEIFBXW.js → chunk-NM2MFLQ7.js}

@@ -4,8 +4,8 @@ import {
 } from "./chunk-JG7ONJZ6.js";
 
 // src/core.ts
-import path12 from "path";
-import os5 from "os";
+import path13 from "path";
+import os6 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
@@ -545,8 +545,57 @@ var RUNTIMES = [
   { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
   { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
   { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
-  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true }
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true },
+  { id: "opencode", displayName: "OpenCode", binary: "opencode", supported: true }
 ];
+var RUNTIME_MODELS = {
+  claude: [
+    { id: "sonnet", label: "Sonnet" },
+    { id: "opus", label: "Opus" },
+    { id: "haiku", label: "Haiku" }
+  ],
+  codex: [
+    { id: "gpt-5.5", label: "GPT-5.5" },
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+    { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark" },
+    { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5-codex", label: "GPT-5 Codex" },
+    { id: "gpt-5", label: "GPT-5" }
+  ],
+  copilot: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "claude-4-sonnet", label: "Claude 4 Sonnet" },
+    { id: "claude-4.5-sonnet", label: "Claude 4.5 Sonnet" }
+  ],
+  cursor: [
+    { id: "composer-2-fast", label: "Composer 2 Fast" },
+    { id: "composer-2", label: "Composer 2" },
+    { id: "auto", label: "Auto" }
+  ],
+  gemini: [
+    { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)" },
+    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+  ],
+  opencode: [
+    { id: "opencode/gpt-5-nano", label: "GPT-5 Nano (OpenCode)" },
+    { id: "opencode/big-pickle", label: "Big Pickle (OpenCode)" },
+    { id: "opencode/hy3-preview-free", label: "HY3 Preview Free (OpenCode)" },
+    { id: "opencode/minimax-m2.5-free", label: "MiniMax M2.5 Free (OpenCode)" },
+    { id: "opencode/nemotron-3-super-free", label: "Nemotron 3 Super Free (OpenCode)" }
+  ],
+  // Kimi CLI resolves model keys from each user's local config, so the safest
+  // built-in option is to defer to whatever default model the CLI already uses.
+  kimi: [
+    { id: "default", label: "Configured Default" }
+  ]
+};
 var PLAN_CONFIG = {
   free: {
     displayName: "Hobby",
@@ -584,8 +633,8 @@ var DISPLAY_PLAN_CONFIG = {
 // src/agentProcessManager.ts
 import { mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
-import path10 from "path";
-import os3 from "os";
+import path11 from "path";
+import os4 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
@@ -631,6 +680,9 @@ function buildPrompt(config, variant, opts) {
   const taskCreateCmd = isCli ? "`slock task create`" : `\`${t("create_tasks")}\``;
   const taskUpdateCmd = isCli ? "`slock task update`" : `\`${t("update_task_status")}\``;
   const serverInfoCmd = isCli ? "`slock server info`" : `\`${t("list_server")}\``;
+  const scheduleReminderCmd = isCli ? "`slock reminder schedule`" : `\`${t("schedule_reminder")}\``;
+  const listRemindersCmd = isCli ? "`slock reminder list`" : `\`${t("list_reminders")}\``;
+  const cancelReminderCmd = isCli ? "`slock reminder cancel`" : `\`${t("cancel_reminder")}\``;
   const messageDeliveryText = opts.includeStdinNotificationSection ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
   const criticalRules = isCli ? [
     "- Always communicate through `slock` CLI commands. This is your only output channel.",
@@ -681,15 +733,11 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 14. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`slock message send\`.
 15. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
 16. **\`slock profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
-17. **\`slock profile update\`** \u2014 Update your own profile. Currently this only supports \`--avatar-file\`.
+17. **\`slock profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--display-name <name>\`, and \`--description <text>\`. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
 18. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
 19. **\`slock reminder list\`** \u2014 List your reminders.
 20. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
 
-When a user asks you to remind them later, at a specific time, or on a recurring schedule, prefer the reminder commands instead of relying on MEMORY or manual follow-up.
-Do not use runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders; use \`slock reminder schedule\` so reminders stay anchored, observable, and cancelable in Slock.
-For agent-created reminders, first resolve the anchor message from the current conversation and pass its \`msgId\` explicitly. If you cannot resolve a message id, do not create the reminder.
-
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints JSON to stderr:
 - failure \u2192 stderr \`{"ok":false,"code":"...","message":"..."}\` with non-zero exit
 
@@ -712,7 +760,15 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 10. **\`${t("unclaim_task")}\`** \u2014 Release your claim on a task.
 11. **${taskUpdateCmd}** \u2014 Change a task's status (e.g. to in_review or done).
 12. **\`${t("upload_file")}\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to ${sendCmd}.
-13. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.`;
+13. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+14. **${scheduleReminderCmd}** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+15. **${listRemindersCmd}** \u2014 List your reminders.
+16. **${cancelReminderCmd}** \u2014 Cancel one of your reminders by ID.`;
+  const reminderSection = `### Reminders
+
+Use reminders for follow-up that depends on future state you cannot resolve now, whether user-requested or self-driven. A reminder is an author-owned, persistent, observable, and cancelable wake-up signal anchored to a Slock message or thread; when it fires, it wakes the author who scheduled it, not other people. If anchored to a message or thread, the receipt/fire system message is visible in that surface, but wake ownership does not transfer. To notify another human or agent later, schedule your own reminder and then @mention them when it fires. Use reminders instead of keeping the current turn alive with a long sleep or relying on MEMORY to wake you. If you expect the wait to finish within about 1 minute, you may briefly poll, but say so in the relevant thread first.
+Use ${scheduleReminderCmd} rather than runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders, so reminders stay anchored, observable, and cancelable in Slock.
+Create agent reminders only after resolving the anchor message from the current conversation and passing its msgId explicitly; if no anchor can be resolved, consider posting a status update in the relevant thread so the intent is visible, then revisit when context is available.`;
   const sendingMessagesSection = isCli ? `### Sending messages
 
 - **Reply to a channel**: \`slock message send --target "#channel-name" <<'EOF'\` followed by the message body and \`EOF\`
@@ -782,6 +838,11 @@ To jump directly to a specific hit with nearby context, use \`slock message read
 Use ${readCmd} with the \`channel\` parameter set to \`"#channel-name"\`, \`"dm:@peer-name"\`, or a thread target like \`"#channel:shortid"\`.
 
 To jump directly to a specific hit with nearby context, pass \`around\` set to a message ID or seq number.`;
+  const historicalReferenceSection = isCli ? `### Historical references
+
+When a user refers to prior Slock discussion and the relevant context is not already available, first use \`slock message search\` and \`slock message read\` to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.` : `### Historical references
+
+When a user refers to prior Slock discussion and the relevant context is not already available, first use \`${t("search_messages")}\` and ${readCmd} to find the original thread, decision, or owner before answering. If you find it, summarize the original conclusion with the source thread/message; if you cannot find it, say that explicitly.`;
   const tasksSection = isCli ? `### Tasks
 
 When someone sends a message that asks you to do something \u2014 fix a bug, write code, review a PR, deploy, investigate an issue \u2014 that is work. Claim it before you start.
@@ -931,6 +992,8 @@ Header fields:
 
 ${sendingMessagesSection}
 
+${reminderSection}
+
 ${threadsSection}
 
 ${discoverySection}
@@ -939,6 +1002,8 @@ ${channelAwarenessSection}
 
 ${readingHistorySection}
 
+${historicalReferenceSection}
+
 ${tasksSection}
 
 ### Splitting tasks for parallel execution
@@ -996,7 +1061,7 @@ When writing a URL next to non-ASCII punctuation (Chinese, Japanese, etc.), alwa
 
 ## Workspace & Memory
 
-Your working directory (cwd) is your **persistent workspace**. Everything you write here survives across sessions.
+Your working directory (cwd) is your **persistent, agent-owned workspace**; files you create here survive across sessions. Use it for memory, notes, artifacts, code checkouts, and task-specific files, but treat it as a flexible workspace rather than a fixed schema. Keep **MEMORY.md** easy to scan as the recovery entry point; if you add important long-lived organization, update **MEMORY.md** or a note index so future sessions can find it. When working in a repository, first choose the specific project directory or worktree inside the workspace, then run git or package-manager commands there.
 
 ### MEMORY.md \u2014 Your Memory Index (CRITICAL)
 
@@ -1263,8 +1328,25 @@ function probeClaude(deps = {}) {
 }
 var ClaudeDriver = class {
   id = "claude";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "gated",
+    inFlightWake: "queue"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
+  usesSlockCliForCommunication = true;
   // Claude Code supports same-turn steering, but raw stdin injection at an
   // arbitrary busy instant can collide with active signed thinking blocks. The
   // daemon therefore gates busy delivery on Claude stream-json boundaries.
@@ -1566,8 +1648,25 @@ function joinReasoningText(item) {
 }
 var CodexDriver = class {
   id = "codex";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ params: { model: modelId } })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp_chat_";
+  usesSlockCliForCommunication = true;
   busyDeliveryMode = "direct";
   supportsNativeStandingPrompt = true;
   probe() {
@@ -1962,7 +2061,7 @@ function detectCodexModels(home = os.homedir()) {
       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 });
+      models.push({ id: slug, label, verified: "launchable" });
     }
   } catch {
     return null;
@@ -1984,6 +2083,23 @@ import path5 from "path";
 import { writeFileSync as writeFileSync3 } from "fs";
 var CopilotDriver = class {
   id = "copilot";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "";
   busyDeliveryMode = "none";
@@ -2117,11 +2233,28 @@ var CopilotDriver = class {
 };
 
 // src/drivers/cursor.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn4, spawnSync } from "child_process";
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import path6 from "path";
 var CursorDriver = class {
   id = "cursor";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "mcp__chat__";
   busyDeliveryMode = "none";
@@ -2234,14 +2367,83 @@ var CursorDriver = class {
       messageNotificationStyle: "poll"
     });
   }
+  async detectModels() {
+    return detectCursorModels();
+  }
 };
+function parseCursorModelsOutput(output) {
+  const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+  const models = [];
+  let defaultModel;
+  for (const rawLine of stripAnsi(output).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || /^available models$/i.test(line) || /^tip:/i.test(line)) continue;
+    if (/^no models available/i.test(line) || /^failed to load models:/i.test(line)) continue;
+    let modelLine = line;
+    const markerMatch = modelLine.match(/\s+\(([^)]+)\)$/);
+    const markers = markerMatch?.[1]?.split(",").map((part) => part.trim().toLowerCase()) ?? [];
+    if (markers.length > 0 && markers.every((part) => part === "current" || part === "default")) {
+      const markerStart = markerMatch?.index ?? modelLine.length;
+      modelLine = modelLine.slice(0, markerStart).trim();
+    }
+    const match = modelLine.match(/^(\S+)(?:\s+-\s+(.+))?$/);
+    if (!match) continue;
+    const id = match[1]?.trim();
+    if (!id || id.startsWith("-")) continue;
+    const label = match[2]?.trim() || id;
+    models.push({ id, label, verified: "launchable" });
+    if (markers.includes("default")) defaultModel = id;
+  }
+  if (models.length === 0) return null;
+  return { models, default: defaultModel };
+}
+function detectCursorModels(runCommand = runCursorModelsCommand) {
+  const result = runCommand();
+  if (result.error || result.status !== 0) return null;
+  return parseCursorModelsOutput(String(result.stdout || ""));
+}
+function runCursorModelsCommand() {
+  return spawnSync("cursor-agent", ["models"], {
+    env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+    encoding: "utf8",
+    timeout: 5e3
+  });
+}
 
 // src/drivers/gemini.ts
 import { spawn as spawn5 } from "child_process";
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import path7 from "path";
+function buildGeminiSpawnEnv(ctx) {
+  return {
+    ...process.env,
+    FORCE_COLOR: "0",
+    NO_COLOR: "1",
+    // Gemini CLI's trusted-workspace gate breaks our managed headless flow
+    // unless we explicitly trust the daemon-owned agent workspace.
+    GEMINI_CLI_TRUST_WORKSPACE: "true",
+    ...ctx.config.envVars || {}
+  };
+}
 var GeminiDriver = class {
   id = "gemini";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "";
   busyDeliveryMode = "none";
@@ -2279,7 +2481,7 @@ var GeminiDriver = class {
     if (ctx.config.sessionId) {
       args.push("--resume", ctx.config.sessionId);
     }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", ...ctx.config.envVars || {} };
+    const spawnEnv = buildGeminiSpawnEnv(ctx);
     const proc = spawn5("gemini", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
@@ -2371,6 +2573,22 @@ function parseToolArguments(raw) {
 }
 var KimiDriver = class {
   id = "kimi";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
   busyDeliveryMode = "direct";
@@ -2571,7 +2789,7 @@ function detectKimiModels(home = os2.homedir()) {
     let key = match[1].trim();
     if (key.startsWith('"') && key.endsWith('"')) key = key.slice(1, -1);
     if (!key) continue;
-    models.push({ id: key, label: key });
+    models.push({ id: key, label: key, verified: "launchable" });
   }
   void sectionRe;
   if (models.length === 0) return null;
@@ -2581,6 +2799,314 @@ function detectKimiModels(home = os2.homedir()) {
   return { models, default: defaultModel };
 }
 
+// src/drivers/opencode.ts
+import { spawn as spawn7 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import os3 from "os";
+import path9 from "path";
+var CHAT_MCP_SERVER_NAME = "chat";
+var CHAT_MCP_TOOL_PREFIX = `${CHAT_MCP_SERVER_NAME}_`;
+var SLOCK_AGENT_NAME = "slock";
+var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
+var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
+var MIN_SUPPORTED_OPENCODE_VERSION = "1.14.30";
+function buildChatBridgeCommand(ctx) {
+  const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+  return [
+    isTsSource ? "npx" : "node",
+    ...isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath],
+    "--agent-id",
+    ctx.agentId,
+    "--server-url",
+    ctx.config.serverUrl,
+    "--auth-token",
+    ctx.config.authToken || ctx.daemonApiKey,
+    "--runtime",
+    "opencode",
+    ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
+    "--runtime-actions-only"
+  ];
+}
+function parseOpenCodeConfigContent(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function parseUserOpenCodeConfig(ctx) {
+  const raw = ctx.config.envVars?.OPENCODE_CONFIG_CONTENT;
+  return parseOpenCodeConfigContent(raw);
+}
+function readLocalOpenCodeConfig(home = os3.homedir()) {
+  const configPath = path9.join(home, ".config", "opencode", "opencode.json");
+  try {
+    return parseOpenCodeConfigContent(readFileSync3(configPath, "utf8"));
+  } catch {
+  }
+  return {};
+}
+function recordField(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseSemver(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isSupportedOpenCodeVersion(version) {
+  if (!version) return true;
+  const actual = parseSemver(version);
+  const minimum = parseSemver(MIN_SUPPORTED_OPENCODE_VERSION);
+  if (!actual || !minimum) return true;
+  for (let i = 0; i < 3; i += 1) {
+    if (actual[i] > minimum[i]) return true;
+    if (actual[i] < minimum[i]) return false;
+  }
+  return true;
+}
+function unsupportedOpenCodeVersionMessage(version) {
+  if (!version || isSupportedOpenCodeVersion(version)) return null;
+  return `OpenCode CLI ${version} is unsupported; requires OpenCode >= ${MIN_SUPPORTED_OPENCODE_VERSION}. Upgrade opencode before starting this runtime.`;
+}
+function mergeOpenCodeConfigs(localConfig, envConfig) {
+  return {
+    ...localConfig,
+    ...envConfig,
+    provider: {
+      ...recordField(localConfig.provider),
+      ...recordField(envConfig.provider)
+    },
+    agent: {
+      ...recordField(localConfig.agent),
+      ...recordField(envConfig.agent)
+    },
+    mcp: {
+      ...recordField(localConfig.mcp),
+      ...recordField(envConfig.mcp)
+    }
+  };
+}
+function buildOpenCodeConfig(ctx, home = os3.homedir()) {
+  const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
+  const userAgents = recordField(userConfig.agent);
+  const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
+  return {
+    ...userConfig,
+    $schema: "https://opencode.ai/config.json",
+    agent: {
+      ...userAgents,
+      [SLOCK_AGENT_NAME]: {
+        ...userSlockAgent,
+        description: "Slock agent runtime",
+        prompt: ctx.standingPrompt
+      }
+    },
+    mcp: {
+      ...recordField(userConfig.mcp),
+      [CHAT_MCP_SERVER_NAME]: {
+        type: "local",
+        command: buildChatBridgeCommand(ctx),
+        enabled: true
+      }
+    }
+  };
+}
+function buildOpenCodeLaunchOptions(ctx, home = os3.homedir()) {
+  const slock = prepareCliTransport(ctx, { NO_COLOR: "1" });
+  const config = buildOpenCodeConfig(ctx, home);
+  const env = {
+    ...slock.spawnEnv,
+    OPENCODE_CONFIG_CONTENT: JSON.stringify(config)
+  };
+  const args = [
+    "run",
+    "--format",
+    "json",
+    "--dangerously-skip-permissions",
+    "--pure",
+    "--dir",
+    ctx.workingDirectory
+  ];
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  args.push("--agent", SLOCK_AGENT_NAME);
+  if (ctx.config.sessionId) {
+    args.push("--session", ctx.config.sessionId);
+  }
+  const turnPrompt = ctx.prompt === ctx.standingPrompt ? NO_MESSAGE_PROMPT : ctx.prompt;
+  args.push("--", turnPrompt);
+  return { args, env, config };
+}
+function detectOpenCodeModels(home = os3.homedir()) {
+  const models = (RUNTIME_MODELS.opencode || []).map((model) => ({
+    ...model,
+    verified: "suggestion_only"
+  }));
+  const providers = recordField(readLocalOpenCodeConfig(home).provider);
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    const providerModels = recordField(recordField(providerConfig).models);
+    for (const [modelId, modelConfig] of Object.entries(providerModels)) {
+      const fullId = `${providerId}/${modelId}`;
+      if (models.some((model2) => model2.id === fullId)) continue;
+      const model = recordField(modelConfig);
+      const name = typeof model.name === "string" && model.name.length > 0 ? model.name : fullId;
+      models.push({ id: fullId, label: name, verified: "launchable" });
+    }
+  }
+  return models.length > 0 ? { models } : null;
+}
+function isSystemFirstMessageTask(message) {
+  return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX);
+}
+function buildOpenCodeSystemPrompt(config) {
+  return buildCliTransportSystemPrompt(config, {
+    toolPrefix: CHAT_MCP_TOOL_PREFIX,
+    extraCriticalRules: [
+      "- Runtime Profile migration completion is the only exception to CLI-only operation: when a migration notice tells you to acknowledge with `runtime_profile_migration_done`, call the `chat_runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
+    ],
+    postStartupNotes: [
+      "**OpenCode runtime note:** Slock launches you as a per-turn process. Complete the current wake using `slock` CLI commands, then stop; the daemon will restart you when new messages arrive."
+    ],
+    includeStdinNotificationSection: false,
+    messageNotificationStyle: "poll"
+  });
+}
+var OpenCodeDriver = class {
+  id = "opencode";
+  lifecycle = {
+    kind: "per_turn",
+    start: "defer_until_concrete_message",
+    exit: "terminate_on_turn_end",
+    inFlightWake: "coalesce_into_pending"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildOpenCodeLaunchOptions(launchCtx, opts?.home);
+      return {
+        args: launch.args,
+        env: launch.env,
+        config: launch.config
+      };
+    }
+  };
+  supportsStdinNotification = false;
+  mcpToolPrefix = CHAT_MCP_TOOL_PREFIX;
+  busyDeliveryMode = "none";
+  terminateProcessOnTurnEnd = true;
+  deferSpawnUntilMessage = true;
+  usesSlockCliForCommunication = true;
+  shouldDeferWakeMessage(message) {
+    return isSystemFirstMessageTask(message);
+  }
+  sessionId = null;
+  sessionAnnounced = false;
+  probe() {
+    if (!resolveCommandOnPath("opencode")) return { available: false };
+    const version = readCommandVersion("opencode") || void 0;
+    const unsupportedMessage = unsupportedOpenCodeVersionMessage(version);
+    if (unsupportedMessage) {
+      return {
+        available: false,
+        version: `${version} (requires >= ${MIN_SUPPORTED_OPENCODE_VERSION})`
+      };
+    }
+    return { available: true, version };
+  }
+  async detectModels() {
+    return detectOpenCodeModels();
+  }
+  spawn(ctx) {
+    this.sessionId = ctx.config.sessionId || null;
+    this.sessionAnnounced = false;
+    const unsupportedMessage = unsupportedOpenCodeVersionMessage(readCommandVersion("opencode"));
+    if (unsupportedMessage) {
+      throw new Error(unsupportedMessage);
+    }
+    const launch = buildOpenCodeLaunchOptions(ctx);
+    const proc = spawn7("opencode", launch.args, {
+      cwd: ctx.workingDirectory,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: launch.env,
+      shell: process.platform === "win32"
+    });
+    proc.stdin?.end();
+    return { process: proc };
+  }
+  parseLine(line) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return [];
+    }
+    const events = [];
+    if (event.sessionID && event.sessionID !== this.sessionId) {
+      this.sessionId = event.sessionID;
+    }
+    if (!this.sessionAnnounced && this.sessionId) {
+      events.push({ kind: "session_init", sessionId: this.sessionId });
+      this.sessionAnnounced = true;
+    }
+    switch (event.type) {
+      case "step_start":
+        events.push({ kind: "thinking", text: "" });
+        break;
+      case "text":
+        if (typeof event.part?.text === "string" && event.part.text.length > 0) {
+          events.push({ kind: "text", text: event.part.text });
+        }
+        break;
+      case "tool_use":
+        events.push({
+          kind: "tool_call",
+          name: event.part?.tool || "unknown_tool",
+          input: event.part?.state?.input
+        });
+        break;
+      case "step_finish":
+        if (event.part?.reason !== "tool-calls") {
+          events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        }
+        break;
+      case "error": {
+        const message = event.error?.data?.message || event.error?.message || (event.error?.name ? `${event.error.name} (no message)` : null) || "Unknown OpenCode error";
+        events.push({ kind: "error", message });
+        events.push({ kind: "turn_end", sessionId: this.sessionId || void 0 });
+        break;
+      }
+    }
+    return events;
+  }
+  encodeStdinMessage(_text, _sessionId, _opts) {
+    return null;
+  }
+  buildSystemPrompt(config, _agentId) {
+    return buildOpenCodeSystemPrompt(config);
+  }
+};
+
 // src/drivers/index.ts
 var driverFactories = {
   claude: () => new ClaudeDriver(),
@@ -2588,7 +3114,8 @@ var driverFactories = {
   copilot: () => new CopilotDriver(),
   cursor: () => new CursorDriver(),
   gemini: () => new GeminiDriver(),
-  kimi: () => new KimiDriver()
+  kimi: () => new KimiDriver(),
+  opencode: () => new OpenCodeDriver()
 };
 function getDriver(runtimeId) {
   const createDriver = driverFactories[runtimeId];
@@ -2601,7 +3128,7 @@ function getDriver(runtimeId) {
 
 // src/workspaces.ts
 import { readdir, rm, stat } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -2609,7 +3136,7 @@ function resolveWorkspaceDirectoryPath(dataDir, directoryName) {
   if (!isValidWorkspaceDirectoryName(directoryName)) {
     return null;
   }
-  return path9.join(dataDir, directoryName);
+  return path10.join(dataDir, directoryName);
 }
 function emptyWorkspaceDirectorySummary(latestMtime = /* @__PURE__ */ new Date(0)) {
   return {
@@ -2658,7 +3185,7 @@ async function summarizeWorkspaceDirectory(dirPath) {
     return summary;
   }
   const childSummaries = await Promise.all(
-    entries.map((entry) => summarizeWorkspaceEntry(path9.join(dirPath, entry.name), entry))
+    entries.map((entry) => summarizeWorkspaceEntry(path10.join(dirPath, entry.name), entry))
   );
   for (const childSummary of childSummaries) {
     summary = mergeWorkspaceDirectorySummaries(summary, childSummary);
@@ -2677,7 +3204,7 @@ async function scanWorkspaceDirectories(dataDir) {
       if (!entry.isDirectory()) {
         return null;
       }
-      const dirPath = path9.join(dataDir, entry.name);
+      const dirPath = path10.join(dataDir, entry.name);
       try {
         const summary = await summarizeWorkspaceDirectory(dirPath);
         return {
@@ -2709,7 +3236,23 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path10.join(os3.homedir(), ".slock", "agents");
+var DATA_DIR = path11.join(os4.homedir(), ".slock", "agents");
+var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 1;
+var DEFAULT_AGENT_START_INTERVAL_MS = 500;
+function readPositiveIntegerEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.floor(parsed);
+}
+function readNonNegativeIntegerEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return fallback;
+  return Math.floor(parsed);
+}
 function toLocalTime(iso) {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return iso;
@@ -2750,12 +3293,12 @@ function findSessionJsonl(root, predicate) {
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isFile() || !predicate(entry.name)) continue;
-      return path10.join(dir, entry.name);
+      return path11.join(dir, entry.name);
     }
     for (const entry of entries) {
       if (++visited > maxEntries) return null;
       if (!entry.isDirectory()) continue;
-      const found = visit(path10.join(dir, entry.name), depth - 1);
+      const found = visit(path11.join(dir, entry.name), depth - 1);
       if (found) return found;
     }
     return null;
@@ -2768,9 +3311,9 @@ function safeSessionFilename(value) {
 }
 function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
   try {
-    const dir = path10.join(fallbackDir, ".slock", "runtime-sessions");
+    const dir = path11.join(fallbackDir, ".slock", "runtime-sessions");
     mkdirSync4(dir, { recursive: true });
-    const filePath = path10.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    const filePath = path11.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
     writeFileSync7(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
@@ -2789,8 +3332,8 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
     return null;
   }
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os3.homedir(), fallbackDir) {
-  const directPath = path10.isAbsolute(sessionId) ? sessionId : null;
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os4.homedir(), fallbackDir) {
+  const directPath = path11.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
       if (statSync(directPath).isFile()) {
@@ -2799,7 +3342,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os3.homedir(), f
     } catch {
     }
   }
-  const resolvedPath = runtime === "claude" ? findSessionJsonl(path10.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path10.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
+  const resolvedPath = runtime === "claude" ? findSessionJsonl(path11.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`) : runtime === "codex" ? findSessionJsonl(path11.join(homeDir, ".codex", "sessions"), (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId)) : null;
   if (!resolvedPath && fallbackDir) {
     const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
     if (fallback) return fallback;
@@ -2830,12 +3373,38 @@ function formatThreadContextMessage(message) {
   const senderType = formatVisibleActorType(message.sender_type);
   return `- [msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}`;
 }
-function formatIncomingMessage(message) {
+function mcpToolName(driver, name) {
+  return `${driver?.mcpToolPrefix ?? ""}${name}`;
+}
+function communicationCommand(driver, name) {
+  if (!driver?.usesSlockCliForCommunication) {
+    return mcpToolName(driver, name);
+  }
+  switch (name) {
+    case "send_message":
+      return "slock message send";
+    case "read_history":
+      return "slock message read";
+    case "check_messages":
+      return "slock message check";
+    case "claim_tasks":
+      return "slock task claim";
+    default:
+      return `slock ${name.replace(/_/g, " ")}`;
+  }
+}
+function dynamicReplyInstruction(driver) {
+  return driver?.usesSlockCliForCommunication ? "reply using `slock message send --target <exact target>`" : `reply with ${communicationCommand(driver, "send_message")}`;
+}
+function dynamicClaimInstruction(driver) {
+  return driver?.usesSlockCliForCommunication ? "claim the relevant task with `slock task claim`" : `claim the relevant task with ${communicationCommand(driver, "claim_tasks")}`;
+}
+function formatIncomingMessage(message, driver) {
   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}")`,
+    `suggested next step: ${driver?.usesSlockCliForCommunication ? `slock message read --channel "${message.thread_join_context.suggested_read_history_target}"` : `${communicationCommand(driver, "read_history")}(channel="${message.thread_join_context.suggested_read_history_target}")`}`,
     "",
     "Parent message:",
     formatThreadContextMessage(message.thread_join_context.parent_message),
@@ -3369,9 +3938,20 @@ function classifyTerminalFailure(ap) {
   return null;
 }
 function isMissingResumeSession(ap) {
-  if (ap.driver.id !== "claude") return false;
   if (!ap.sessionId) return false;
-  return /No conversation found with session ID/i.test(ap.lastRuntimeError || "");
+  const candidates = [
+    ap.lastRuntimeError,
+    ...ap.recentStderr
+  ].filter((value) => !!value);
+  if (ap.driver.id === "claude") {
+    return candidates.some((text) => /No conversation found with session ID/i.test(text));
+  }
+  if (ap.driver.id === "opencode") {
+    return candidates.some(
+      (text) => /Session not found/i.test(text) && text.includes(ap.sessionId)
+    );
+  }
+  return false;
 }
 function getMessageDeliveryText(driver) {
   return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
@@ -3396,6 +3976,15 @@ var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
   // Prevent concurrent starts of same agent
+  queuedAgentStarts = /* @__PURE__ */ new Map();
+  agentStartQueue = [];
+  activeAgentStartPermits = /* @__PURE__ */ new Set();
+  activeAgentStartCount = 0;
+  agentStartPumpTimer = null;
+  lastAgentStartAt = 0;
+  lastAgentStartAgentId = null;
+  maxConcurrentAgentStarts;
+  agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
@@ -3416,12 +4005,141 @@ var AgentProcessManager = class _AgentProcessManager {
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
     this.dataDir = opts.dataDir || DATA_DIR;
-    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os3.homedir();
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os4.homedir();
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
     this.tracer = opts.tracer ?? noopTracer;
+    this.maxConcurrentAgentStarts = Math.max(
+      1,
+      Math.floor(
+        opts.runtimeStartScheduler?.maxConcurrentStarts ?? readPositiveIntegerEnv("SLOCK_DAEMON_MAX_CONCURRENT_AGENT_STARTS", DEFAULT_MAX_CONCURRENT_AGENT_STARTS)
+      )
+    );
+    this.agentStartIntervalMs = Math.max(
+      0,
+      Math.floor(
+        opts.runtimeStartScheduler?.minStartIntervalMs ?? readNonNegativeIntegerEnv("SLOCK_DAEMON_AGENT_START_INTERVAL_MS", DEFAULT_AGENT_START_INTERVAL_MS)
+      )
+    );
   }
   async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+    if (this.agents.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      return;
+    }
+    if (this.agentsStarting.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      return;
+    }
+    if (this.queuedAgentStarts.has(agentId)) {
+      logger.info(`[Agent ${agentId}] Start ignored (startup already queued)`);
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const item = {
+        agentId,
+        config,
+        wakeMessage,
+        unreadSummary,
+        resumePrompt,
+        launchId,
+        resolve,
+        reject
+      };
+      this.agentStartQueue.push(item);
+      this.queuedAgentStarts.set(agentId, item);
+      logger.info(
+        `[Agent ${agentId}] Start queued (queue=${this.agentStartQueue.length}, active=${this.activeAgentStartCount}, max=${this.maxConcurrentAgentStarts}, interval=${this.agentStartIntervalMs}ms)`
+      );
+      this.pumpAgentStartQueue();
+    });
+  }
+  pumpAgentStartQueue() {
+    if (this.agentStartPumpTimer) return;
+    if (this.agentStartQueue.length === 0) return;
+    if (this.activeAgentStartCount >= this.maxConcurrentAgentStarts) return;
+    const next = this.agentStartQueue[0];
+    const shouldRateLimit = next ? next.agentId !== this.lastAgentStartAgentId : true;
+    const elapsed = Date.now() - this.lastAgentStartAt;
+    const waitMs = shouldRateLimit ? Math.max(0, this.agentStartIntervalMs - elapsed) : 0;
+    if (waitMs > 0) {
+      this.agentStartPumpTimer = setTimeout(() => {
+        this.agentStartPumpTimer = null;
+        this.pumpAgentStartQueue();
+      }, waitMs);
+      return;
+    }
+    const item = this.agentStartQueue.shift();
+    if (!item) return;
+    if (this.queuedAgentStarts.get(item.agentId) !== item) {
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.queuedAgentStarts.delete(item.agentId);
+    if (this.agents.has(item.agentId) || this.agentsStarting.has(item.agentId)) {
+      logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
+      item.resolve();
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.activeAgentStartCount++;
+    this.activeAgentStartPermits.add(item.agentId);
+    this.lastAgentStartAt = Date.now();
+    this.lastAgentStartAgentId = item.agentId;
+    logger.info(
+      `[Agent ${item.agentId}] Dequeued start (remaining=${this.agentStartQueue.length}, active=${this.activeAgentStartCount})`
+    );
+    this.startAgentNow(
+      item.agentId,
+      item.config,
+      item.wakeMessage,
+      item.unreadSummary,
+      item.resumePrompt,
+      item.launchId
+    ).then(item.resolve, (err) => {
+      this.releaseAgentStartPermit(item.agentId, "start failed");
+      item.reject(err);
+    });
+  }
+  releaseAgentStartPermit(agentId, reason) {
+    if (!this.activeAgentStartPermits.delete(agentId)) return false;
+    this.activeAgentStartCount = Math.max(0, this.activeAgentStartCount - 1);
+    logger.info(
+      `[Agent ${agentId}] Start permit released (${reason}) (active=${this.activeAgentStartCount}, queue=${this.agentStartQueue.length})`
+    );
+    this.pumpAgentStartQueue();
+    return true;
+  }
+  cancelQueuedAgentStart(agentId, reason) {
+    const item = this.queuedAgentStarts.get(agentId);
+    if (!item) return false;
+    this.queuedAgentStarts.delete(agentId);
+    this.agentStartQueue = this.agentStartQueue.filter((candidate) => candidate !== item);
+    this.startingInboxes.delete(agentId);
+    if (this.agentStartQueue.length === 0 && this.agentStartPumpTimer) {
+      clearTimeout(this.agentStartPumpTimer);
+      this.agentStartPumpTimer = null;
+    }
+    logger.info(`[Agent ${agentId}] Queued start cancelled (${reason})`);
+    item.resolve();
+    return true;
+  }
+  cancelAllQueuedAgentStarts(reason) {
+    for (const item of this.agentStartQueue) {
+      if (this.queuedAgentStarts.get(item.agentId) === item) {
+        logger.info(`[Agent ${item.agentId}] Queued start cancelled (${reason})`);
+        item.resolve();
+      }
+    }
+    this.agentStartQueue = [];
+    this.queuedAgentStarts.clear();
+    this.startingInboxes.clear();
+    if (this.agentStartPumpTimer) {
+      clearTimeout(this.agentStartPumpTimer);
+      this.agentStartPumpTimer = null;
+    }
+  }
+  async startAgentNow(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
     if (this.agents.has(agentId)) {
       logger.info(`[Agent ${agentId}] Start ignored (already running)`);
       return;
@@ -3433,26 +4151,26 @@ var AgentProcessManager = class _AgentProcessManager {
     this.agentsStarting.add(agentId);
     try {
       const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path10.join(this.dataDir, agentId);
+      const agentDataDir = path11.join(this.dataDir, agentId);
       await mkdir(agentDataDir, { recursive: true });
       const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      const memoryMdPath = path10.join(agentDataDir, "MEMORY.md");
+      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
       try {
         await access(memoryMdPath);
       } catch {
         const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
         await writeFile(memoryMdPath, initialMemoryMd);
       }
-      const notesDir = path10.join(agentDataDir, "notes");
+      const notesDir = path11.join(agentDataDir, "notes");
       await mkdir(notesDir, { recursive: true });
       if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
         const seedFiles = buildOnboardingSeedFiles();
         for (const { relativePath, content } of seedFiles) {
-          const fullPath = path10.join(agentDataDir, relativePath);
+          const fullPath = path11.join(agentDataDir, relativePath);
           try {
             await access(fullPath);
           } catch {
-            await mkdir(path10.dirname(fullPath), { recursive: true });
+            await mkdir(path11.dirname(fullPath), { recursive: true });
             await writeFile(fullPath, content);
           }
         }
@@ -3470,7 +4188,7 @@ var AgentProcessManager = class _AgentProcessManager {
         const channelLabel = formatChannelLabel(wakeMessage);
         prompt = runtimeProfileControlPrompt ?? `New message received:
 
-${formatIncomingMessage(wakeMessage)}`;
+${formatIncomingMessage(wakeMessage, driver)}`;
         if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
           const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
           if (otherUnread.length > 0) {
@@ -3483,13 +4201,13 @@ You also have unread messages in other channels:`;
             }
             prompt += `
 
-Use read_history to catch up, or respond to the message above first.`;
+Use ${communicationCommand(driver, "read_history")} to catch up, or respond to the message above first.`;
           }
         }
         if (!runtimeProfileControlPrompt) {
           prompt += `
 
-Respond as appropriate \u2014 reply using send_message, or take action as needed. Complete ALL your work before stopping.
+Respond as appropriate \u2014 ${dynamicReplyInstruction(driver)}, or take action as needed. Complete ALL your work before stopping.
 
 IMPORTANT: If the message requires multi-step work (e.g. research, code changes, testing), complete ALL steps before stopping. Sending a progress update does NOT mean your task is done \u2014 only stop when you have NO more work to do. ${getMessageDeliveryText(driver)}`;
           prompt += getBusyDeliveryNote(driver);
@@ -3502,7 +4220,7 @@ IMPORTANT: If the message requires multi-step work (e.g. research, code changes,
         }
         prompt += `
 
-Use read_history to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call check_messages in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: reply with send_message and claim the relevant task before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
+Use ${communicationCommand(driver, "read_history")} to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call ${communicationCommand(driver, "check_messages")} in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: ${dynamicReplyInstruction(driver)} and ${dynamicClaimInstruction(driver)} before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
       } else if (isResume) {
         prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver)}`;
         prompt += getBusyDeliveryNote(driver);
@@ -3510,6 +4228,25 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : standingPrompt;
       }
       const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
+      const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
+      if (canDeferEmptyStart) {
+        const pendingMessages = this.startingInboxes.get(agentId) || [];
+        this.startingInboxes.delete(agentId);
+        this.agentsStarting.delete(agentId);
+        this.idleAgentConfigs.set(agentId, {
+          config: effectiveConfig,
+          sessionId: effectiveConfig.sessionId || null,
+          launchId: launchId || null
+        });
+        this.sendAgentStatus(agentId, "active", launchId || null);
+        this.broadcastActivity(agentId, "online", "Process idle");
+        logger.info(`[Agent ${agentId}] Deferred ${driver.id} spawn until first concrete message`);
+        this.releaseAgentStartPermit(agentId, "spawn deferred");
+        for (const message of pendingMessages) {
+          this.deliverMessage(agentId, message);
+        }
+        return;
+      }
       const { process: proc } = driver.spawn({
         agentId,
         config: effectiveConfig,
@@ -3528,6 +4265,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         config: runtimeConfig,
         sessionId: runtimeConfig.sessionId || null,
         launchId: launchId || null,
+        startupWakeMessage: wakeMessage,
+        startupUnreadSummary: unreadSummary,
+        startupResumePrompt: resumePrompt,
         isIdle: false,
         notificationTimer: null,
         pendingNotificationCount: 0,
@@ -3539,12 +4279,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         runtimeTraceSpan: null,
         lastActivity: "",
         lastActivityDetail: "",
+        activityClientSeq: 0,
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
         spawnError: null,
         exitCode: null,
         exitSignal: null,
+        expectedTerminationReason: null,
         pendingTrajectory: null,
         gatedSteering: createGatedSteeringState()
       };
@@ -3603,6 +4345,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         if (this.agents.has(agentId)) {
           const ap = this.agents.get(agentId);
           if (ap.process !== proc) return;
+          this.releaseAgentStartPermit(agentId, "process closed");
           if (ap.notificationTimer) {
             clearTimeout(ap.notificationTimer);
           }
@@ -3614,20 +4357,60 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           }
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
-          const terminalFailureDetail = classifyTerminalFailure(ap);
-          this.endRuntimeTrace(ap, finalCode === 0 ? "ok" : "error", {
-            outcome: finalCode === 0 ? "process-exit" : "process-crash",
+          const expectedTermination = Boolean(ap.expectedTerminationReason);
+          const processEndedCleanly = finalCode === 0 || expectedTermination && !ap.lastRuntimeError;
+          const terminalFailureDetail = processEndedCleanly ? null : classifyTerminalFailure(ap);
+          const missingResumeSession = isMissingResumeSession(ap);
+          const summary = summarizeCrash(finalCode, finalSignal);
+          this.endRuntimeTrace(ap, processEndedCleanly ? "ok" : "error", {
+            outcome: processEndedCleanly ? "process-exit" : "process-crash",
+            expectedTerminationReason: ap.expectedTerminationReason || void 0,
             exitCode: finalCode,
             exitSignal: finalSignal
           });
-          if (finalCode === 0) {
+          if (processEndedCleanly) {
             this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from process exit)");
           } else {
             this.clearCompactionWatchdog(ap);
           }
           this.agents.delete(agentId);
-          if (finalCode === 0) {
-            const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
+          if (missingResumeSession) {
+            const staleSessionId = ap.sessionId;
+            const runtimeLabel = ap.driver.id === "opencode" ? "OpenCode" : "Claude";
+            const restartConfig = { ...ap.config, sessionId: null };
+            logger.warn(
+              `[Agent ${agentId}] Stored ${runtimeLabel} session ${staleSessionId} is unavailable locally; falling back to cold start`
+            );
+            this.broadcastActivity(
+              agentId,
+              "working",
+              `Stored ${runtimeLabel} session missing; cold-starting a new session\u2026`,
+              [{ kind: "text", text: `Stored ${runtimeLabel} session ${staleSessionId} was not found locally. Falling back to a cold start.` }]
+            );
+            this.startAgent(
+              agentId,
+              restartConfig,
+              ap.startupWakeMessage,
+              ap.startupUnreadSummary,
+              ap.startupResumePrompt,
+              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})`, [], ap.launchId);
+            });
+            return;
+          }
+          if (processEndedCleanly) {
+            let queuedWakeMessage;
+            if (!ap.driver.supportsStdinNotification) {
+              while (ap.inbox.length > 0) {
+                const candidate = ap.inbox.shift();
+                if (this.shouldDeferWakeMessage(agentId, ap.driver, candidate)) continue;
+                queuedWakeMessage = candidate;
+                break;
+              }
+            }
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
             if (queuedWakeMessage) {
               logger.info(`[Agent ${agentId}] Turn completed; restarting immediately for queued message`);
@@ -3662,26 +4445,6 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           } else {
             this.idleAgentConfigs.delete(agentId);
             const reason = formatCrashReason(finalCode, finalSignal, ap);
-            const summary = summarizeCrash(finalCode, finalSignal);
-            if (isMissingResumeSession(ap)) {
-              const staleSessionId = ap.sessionId;
-              const restartConfig = { ...ap.config, sessionId: null };
-              logger.warn(
-                `[Agent ${agentId}] Stored Claude session ${staleSessionId} is unavailable locally; falling back to cold start`
-              );
-              this.broadcastActivity(
-                agentId,
-                "working",
-                "Stored Claude session missing; cold-starting a new session\u2026",
-                [{ kind: "text", text: `Stored Claude session ${staleSessionId} was not found locally. Falling back to a cold start.` }]
-              );
-              this.startAgent(agentId, restartConfig, 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})`, [], ap.launchId);
-              });
-              return;
-            }
             logger.error(`[Agent ${agentId}] Process crashed (${reason}) \u2014 marking inactive`);
             this.sendAgentStatus(agentId, "inactive", ap.launchId);
             if (terminalFailureDetail) {
@@ -3747,6 +4510,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     return leftKeys.every((key) => left?.[key] === right?.[key]);
   }
   async stopAgent(agentId, { wait = false, silent = false } = {}) {
+    this.cancelQueuedAgentStart(agentId, "stop requested");
     this.idleAgentConfigs.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) {
@@ -3755,6 +4519,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       return;
     }
+    this.releaseAgentStartPermit(agentId, "stop requested");
     if (ap.notificationTimer) {
       clearTimeout(ap.notificationTimer);
     }
@@ -3796,7 +4561,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   deliverMessage(agentId, message) {
     const ap = this.agents.get(agentId);
     if (!ap) {
-      if (this.agentsStarting.has(agentId)) {
+      if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
         const pending = this.startingInboxes.get(agentId) || [];
         pending.push(message);
         this.startingInboxes.set(agentId, pending);
@@ -3804,6 +4569,10 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
+        const driver = this.driverResolver(cached.config.runtime || "claude");
+        if (this.shouldDeferWakeMessage(agentId, driver, message)) {
+          return;
+        }
         logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
         this.idleAgentConfigs.delete(agentId);
         this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).catch((err) => {
@@ -3812,6 +4581,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
       return;
     }
+    if (this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
+      return;
+    }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       const nextMessages = ap.inbox.splice(0, ap.inbox.length);
       nextMessages.push(message);
@@ -3840,7 +4612,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
   }
   async resetWorkspace(agentId) {
-    const agentDataDir = path10.join(this.dataDir, agentId);
+    const agentDataDir = path11.join(this.dataDir, agentId);
     try {
       await rm2(agentDataDir, { recursive: true, force: true });
       logger.info(`[Agent ${agentId}] Workspace reset complete (${agentDataDir})`);
@@ -3849,6 +4621,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
   }
   async stopAll() {
+    this.cancelAllQueuedAgentStarts("daemon shutdown");
     this.idleAgentConfigs.clear();
     const ids = [...this.agents.keys()];
     await Promise.all(ids.map((id) => this.stopAgent(id, { wait: true, silent: true })));
@@ -3856,6 +4629,11 @@ Use read_history to catch up on the channels listed above, then stop. Read each
   getRunningAgentIds() {
     return [...this.agents.keys()];
   }
+  shouldDeferWakeMessage(agentId, driver, message) {
+    if (!driver.shouldDeferWakeMessage?.(message)) return false;
+    logger.info(`[Agent ${agentId}] Deferred non-concrete wake message for ${driver.id}`);
+    return true;
+  }
   getAgentSessionId(agentId) {
     return this.agents.get(agentId)?.sessionId ?? null;
   }
@@ -3870,7 +4648,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     return result;
   }
   buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
-    const workspacePath = path10.join(this.dataDir, agentId);
+    const workspacePath = path11.join(this.dataDir, agentId);
     return {
       agentId,
       launchId,
@@ -4019,7 +4797,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 = path10.join(this.dataDir, agentId);
+    const agentDir = path11.join(this.dataDir, agentId);
     try {
       await stat2(agentDir);
     } catch {
@@ -4027,8 +4805,8 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
     let targetDir = agentDir;
     if (dirPath) {
-      const resolved = path10.resolve(agentDir, dirPath);
-      if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
+      const resolved = path11.resolve(agentDir, dirPath);
+      if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
         return [];
       }
       targetDir = resolved;
@@ -4036,9 +4814,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 = path10.join(this.dataDir, agentId);
-    const resolved = path10.resolve(agentDir, filePath);
-    if (!resolved.startsWith(agentDir + path10.sep) && resolved !== agentDir) {
+    const agentDir = path11.join(this.dataDir, agentId);
+    const resolved = path11.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path11.sep) && resolved !== agentDir) {
       throw new Error("Access denied");
     }
     const info = await stat2(resolved);
@@ -4062,7 +4840,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       ".sh",
       ".py"
     ]);
-    const ext = path10.extname(resolved).toLowerCase();
+    const ext = path11.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
@@ -4088,14 +4866,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 = os3.homedir();
-    const workspaceDir = path10.join(this.dataDir, agentId);
+    const home = os4.homedir();
+    const workspaceDir = path11.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(path10.join(home, p)))
+      paths.global.map((p) => this.scanSkillsDir(path11.join(home, p)))
     );
     const workspaceResults = await Promise.all(
-      paths.workspace.map((p) => this.scanSkillsDir(path10.join(workspaceDir, p)))
+      paths.workspace.map((p) => this.scanSkillsDir(path11.join(workspaceDir, p)))
     );
     const dedup = (skills) => {
       const seen = /* @__PURE__ */ new Set();
@@ -4124,7 +4902,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 = path10.join(dir, entry.name, "SKILL.md");
+        const skillMd = path11.join(dir, entry.name, "SKILL.md");
         try {
           const content = await readFile(skillMd, "utf-8");
           const skill = this.parseSkillMd(entry.name, content);
@@ -4135,7 +4913,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(path10.join(dir, entry.name), "utf-8");
+          const content = await readFile(path11.join(dir, entry.name), "utf-8");
           const skill = this.parseSkillMd(cmdName, content);
           skill.sourcePath = dir;
           skills.push(skill);
@@ -4178,13 +4956,15 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (!hasToolStart) {
       entries.push({ kind: "status", activity, detail });
     }
+    if (ap) ap.activityClientSeq += 1;
     this.sendToServer({
       type: "agent:activity",
       agentId,
       activity,
       detail,
       entries,
-      launchId: launchIdOverride || ap?.launchId || void 0
+      launchId: launchIdOverride || ap?.launchId || void 0,
+      clientSeq: ap?.activityClientSeq
     });
     if (ap) {
       ap.lastActivity = activity;
@@ -4196,12 +4976,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
             this.recordRuntimeTraceEvent(agentId, ap, "activity.heartbeat.sent", {
               activity: ap.lastActivity
             });
+            ap.activityClientSeq += 1;
             this.sendToServer({
               type: "agent:activity",
               agentId,
               activity: ap.lastActivity,
               detail: ap.lastActivityDetail,
-              launchId: launchIdOverride || ap.launchId || void 0
+              launchId: launchIdOverride || ap.launchId || void 0,
+              clientSeq: ap.activityClientSeq
             });
           }, ACTIVITY_HEARTBEAT_MS);
         }
@@ -4213,6 +4995,42 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       }
     }
   }
+  /**
+   * Respond to a server-issued `agent:activity_probe`. Echoes the
+   * agent's current `lastActivity` back through the existing
+   * `agent:activity` upstream channel with the matching `probeId`.
+   *
+   * Why this exists: the server's stale-activity sweep used to
+   * synthesize `online` whenever a transient state went 90s without
+   * an update. That invented state without consulting ground truth
+   * and produced "agent shows green/idle but is actually working" UI
+   * staleness (#engineering:72283cf7 task #340 RCA).
+   *
+   * The new flow: server sends `agent:activity_probe` for stale
+   * agents, daemon replies here with the *real* current activity, and
+   * the server only falls back to synth-online if the probe times out
+   * (5s). The body is intentionally minimal — no entries, no
+   * heartbeat side-effects, no state mutation. We just echo what we
+   * already know.
+   *
+   * If the agent is no longer running locally (`ap` undefined), we
+   * report `offline` so the server stops believing the agent is busy.
+   */
+  respondToActivityProbe(agentId, probeId) {
+    const ap = this.agents.get(agentId);
+    const activity = ap?.lastActivity || "offline";
+    const detail = ap?.lastActivityDetail || (ap ? "" : "Agent not running");
+    if (ap) ap.activityClientSeq += 1;
+    this.sendToServer({
+      type: "agent:activity",
+      agentId,
+      activity,
+      detail,
+      launchId: ap?.launchId || void 0,
+      probeId,
+      clientSeq: ap?.activityClientSeq
+    });
+  }
   flushPendingTrajectory(agentId) {
     const ap = this.agents.get(agentId);
     const pending = ap?.pendingTrajectory;
@@ -4350,7 +5168,9 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     logger.info(
       `[Agent ${agentId}] Claude gated steering flush reason=${reason} messages=${nextMessages.length}`
     );
-    this.broadcastActivity(agentId, "working", "Message received");
+    if (reason === "turn_end") {
+      this.broadcastActivity(agentId, "working", "Message received");
+    }
     if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, reason === "turn_end" ? "idle" : "busy")) {
       return true;
     }
@@ -4502,6 +5322,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from turn end)");
         this.flushPendingTrajectory(agentId);
         if (ap) {
+          this.releaseAgentStartPermit(agentId, "initial turn ended");
           this.clearGatedInFlightBatch(agentId, ap, "turn_end");
           if (event.sessionId) ap.sessionId = event.sessionId;
           ap.gatedSteering.outstandingToolUses = 0;
@@ -4527,6 +5348,16 @@ Use read_history to catch up on the channels listed above, then stop. Read each
             this.broadcastActivity(agentId, "online", "Idle");
           }
           this.endRuntimeTrace(ap, "ok", { outcome: "turn-completed" });
+          if (ap.driver.terminateProcessOnTurnEnd) {
+            ap.expectedTerminationReason = "turn_end";
+            logger.info(`[Agent ${agentId}] Turn completed; terminating ${ap.driver.id} process`);
+            try {
+              ap.process.kill("SIGTERM");
+            } catch (err) {
+              const reason = err instanceof Error ? err.message : String(err);
+              logger.warn(`[Agent ${agentId}] Failed to terminate ${ap.driver.id} after turn_end: ${reason}`);
+            }
+          }
         }
         if (event.sessionId) {
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
@@ -4588,7 +5419,6 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     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");
       if (this.deliverMessagesViaStdin(agentId, ap, queuedMessages, "busy")) {
         return;
       }
@@ -4607,11 +5437,11 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (messages.length === 0) return true;
     const prompt = formatRuntimeProfileControlPrompt(messages) ?? (messages.length === 1 ? `New message received:
 
-${formatIncomingMessage(messages[0])}
+${formatIncomingMessage(messages[0], ap.driver)}
 
 Respond as appropriate. Complete all your work before stopping.` : `New messages received:
 
-${messages.map((message) => formatIncomingMessage(message)).join("\n")}
+${messages.map((message) => formatIncomingMessage(message, ap.driver)).join("\n")}
 
 Respond as appropriate. Complete all your work before stopping.`);
     const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
@@ -4649,8 +5479,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 = path10.join(dir, entry.name);
-      const relativePath = path10.relative(rootDir, fullPath);
+      const fullPath = path11.join(dir, entry.name);
+      const relativePath = path11.relative(rootDir, fullPath);
       let info;
       try {
         info = await stat2(fullPath);
@@ -4881,10 +5711,10 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
-import os4 from "os";
-import path11 from "path";
-var DEFAULT_MACHINE_STATE_ROOT = path11.join(os4.homedir(), ".slock", "machines");
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import os5 from "os";
+import path12 from "path";
+var DEFAULT_MACHINE_STATE_ROOT = path12.join(os5.homedir(), ".slock", "machines");
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -4903,11 +5733,11 @@ function getDaemonMachineLockId(apiKey) {
   return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
 }
 function ownerPath(lockDir) {
-  return path11.join(lockDir, "owner.json");
+  return path12.join(lockDir, "owner.json");
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync3(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync4(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
@@ -4933,8 +5763,8 @@ function acquireDaemonMachineLock(options) {
   const rootDir = options.rootDir ?? DEFAULT_MACHINE_STATE_ROOT;
   const fingerprint = apiKeyFingerprint(options.apiKey);
   const lockId = getDaemonMachineLockId(options.apiKey);
-  const machineDir = path11.join(rootDir, lockId);
-  const lockDir = path11.join(machineDir, "daemon.lock");
+  const machineDir = path12.join(rootDir, lockId);
+  const lockDir = path12.join(machineDir, "daemon.lock");
   const token = randomUUID2();
   mkdirSync5(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
@@ -4943,7 +5773,7 @@ function acquireDaemonMachineLock(options) {
       const owner = {
         pid: process.pid,
         token,
-        hostname: os4.hostname(),
+        hostname: os5.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
@@ -5006,23 +5836,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path12.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path12.resolve(dirname, "chat-bridge.js");
+  const dirname = path13.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path13.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path12.resolve(dirname, "chat-bridge.ts");
+    return path13.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path12.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path12.resolve(thisDir, "cli", "index.js");
+  const thisDir = path13.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path13.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path12.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path13.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -5031,9 +5861,14 @@ function detectRuntimes() {
   const ids = [];
   const versions = {};
   for (const runtime of RUNTIMES) {
+    const driver = getDriver(runtime.id);
     try {
-      const probe = getDriver(runtime.id).probe?.();
-      if (probe?.available) {
+      if (driver.probe) {
+        const probe = driver.probe();
+        if (!probe.available) {
+          if (probe.version) versions[runtime.id] = probe.version;
+          continue;
+        }
         ids.push(runtime.id);
         if (probe.version) versions[runtime.id] = probe.version;
         continue;
@@ -5077,6 +5912,8 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId}, path=${msg.path})`;
     case "agent:skills:list":
       return `(agent=${msg.agentId}, runtime=${msg.runtime || "auto"})`;
+    case "agent:activity_probe":
+      return `(agent=${msg.agentId}, probe=${msg.probeId.slice(0, 8)}, purpose=${msg.purpose})`;
     case "machine:workspace:delete":
       return `(directory=${msg.directoryName})`;
     case "machine:runtime_models:detect":
@@ -5134,7 +5971,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path12.join(path12.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path13.join(path13.dirname(this.options.dataDir), "machines");
     return DEFAULT_MACHINE_STATE_ROOT;
   }
   start() {
@@ -5264,6 +6101,9 @@ var DaemonCore = class {
           this.connection.send({ type: "agent:skills:list_result", agentId: msg.agentId, global: [], workspace: [] });
         });
         break;
+      case "agent:activity_probe":
+        this.agentManager.respondToActivityProbe(msg.agentId, msg.probeId);
+        break;
       case "machine:workspace:scan":
         logger.info("[Daemon] Scanning all workspace directories");
         this.agentManager.scanAllWorkspaces().then((directories) => {
@@ -5281,7 +6121,12 @@ var DaemonCore = class {
         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 });
+            const verified = driver.model.detectedModelsVerifiedAs;
+            const models = result.models.map((model) => ({
+              ...model,
+              verified: model.verified ?? verified
+            }));
+            this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, models, default: result.default });
           } else {
             this.connection.send({ type: "machine:runtime_models:result", requestId: msg.requestId, error: "unsupported" });
           }
@@ -5325,8 +6170,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os5.hostname(),
-      os: this.options.osDescription ?? `${os5.platform()} ${os5.arch()}`,
+      hostname: this.options.hostname ?? os6.hostname(),
+      os: this.options.osDescription ?? `${os6.platform()} ${os6.arch()}`,
       daemonVersion: this.daemonVersion
     });
     for (const agentId of this.agentManager.getRunningAgentIds()) {