@slock-ai/daemon 0.43.0 → 0.46.0-play.20260508161002

package/dist/{chunk-37O7EHYE.js → chunk-MEY33LAG.js}

@@ -1,11 +1,14 @@
 import {
+  DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   buildWebSocketOptions,
+  executeJsonRequest,
+  executeResponseRequest,
   logger
-} from "./chunk-JG7ONJZ6.js";
+} from "./chunk-Z3PCMYZO.js";
 
 // src/core.ts
-import path13 from "path";
-import os6 from "os";
+import path15 from "path";
+import os7 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
@@ -94,6 +97,103 @@ var NoopActiveSpan = class {
   }
 };
 var noopTracer = new NoopTracer();
+var BasicTracer = class {
+  sink;
+  clock;
+  traceIdGenerator;
+  spanIdGenerator;
+  constructor({
+    sink,
+    clock = () => Date.now(),
+    traceIdGenerator = generateTraceId,
+    spanIdGenerator = generateSpanId
+  }) {
+    this.sink = sink;
+    this.clock = clock;
+    this.traceIdGenerator = traceIdGenerator;
+    this.spanIdGenerator = spanIdGenerator;
+  }
+  startSpan(name, options) {
+    const startTimeMs = options.startTimeMs ?? this.clock();
+    const context = createTraceContext({
+      parent: options.parent ?? null,
+      traceIdGenerator: this.traceIdGenerator,
+      spanIdGenerator: this.spanIdGenerator
+    });
+    return new RecordingActiveSpan({
+      context,
+      name,
+      surface: options.surface,
+      kind: options.kind ?? "internal",
+      attrs: options.attrs,
+      startTimeMs,
+      clock: this.clock,
+      sink: this.sink
+    });
+  }
+};
+var RecordingActiveSpan = class {
+  context;
+  name;
+  surface;
+  kind;
+  startTimeMs;
+  clock;
+  sink;
+  events = [];
+  attrs;
+  ended = false;
+  constructor({
+    context,
+    name,
+    surface,
+    kind,
+    attrs,
+    startTimeMs,
+    clock,
+    sink
+  }) {
+    this.context = context;
+    this.name = name;
+    this.surface = surface;
+    this.kind = kind;
+    this.attrs = attrs;
+    this.startTimeMs = startTimeMs;
+    this.clock = clock;
+    this.sink = sink;
+  }
+  addEvent(name, attrs) {
+    if (this.ended) return;
+    this.events.push({
+      name,
+      timeMs: this.clock(),
+      ...attrs ? { attrs } : {}
+    });
+  }
+  end(status = "ok", options = {}) {
+    if (this.ended) return;
+    this.ended = true;
+    const endTimeMs = this.clock();
+    const attrs = mergeAttrs(this.attrs, options.attrs);
+    this.sink.record({
+      context: this.context,
+      name: this.name,
+      surface: this.surface,
+      kind: this.kind,
+      status,
+      startTimeMs: this.startTimeMs,
+      endTimeMs,
+      durationMs: Math.max(0, endTimeMs - this.startTimeMs),
+      ...attrs ? { attrs } : {},
+      events: [...this.events]
+    });
+  }
+};
+function mergeAttrs(base, extra) {
+  if (!base) return extra;
+  if (!extra) return base;
+  return { ...base, ...extra };
+}
 function generateTraceId() {
   return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
 }
@@ -473,6 +573,9 @@ function summarizeToolInput(toolName, input) {
   }
 }
 
+// ../shared/src/attachmentPreview.ts
+var CSV_PREVIEW_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+
 // ../shared/src/testing/failpoints.ts
 var NoopFailpointRegistry = class {
   get enabled() {
@@ -548,54 +651,6 @@ var RUNTIMES = [
   { 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",
@@ -631,14 +686,15 @@ var DISPLAY_PLAN_CONFIG = {
 };
 
 // src/agentProcessManager.ts
-import { mkdirSync as mkdirSync4, readdirSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync4, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2 } from "fs/promises";
 import path11 from "path";
-import os4 from "os";
+import os5 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
-import { writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import os from "os";
 import path3 from "path";
 
 // src/drivers/cliTransport.ts
@@ -735,8 +791,11 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 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. 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.
+19. **\`slock reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
+20. **\`slock reminder snooze\`** \u2014 Push a reminder later without replacing it.
+21. **\`slock reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
+22. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+23. **\`slock reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
 
 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
@@ -759,22 +818,23 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 9. **${taskClaimCmd}** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
 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}.
+12. **\`${t("upload_file")}\`** \u2014 Upload a file up to 50MB to attach to a message. Returns an attachment ID to pass to ${sendCmd}. Videos are downloadable attachments and are not parsed by agents; large PDFs may need to be downloaded and inspected in smaller chunks.
 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.
+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, snoozable, updatable, 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.
+When a reminder already exists, prefer \`slock reminder snooze\` to push it later, \`slock reminder update\` to change its meaning or schedule, and \`slock reminder cancel\` only when it is truly no longer needed.
+Use ${scheduleReminderCmd} rather than runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders, so reminders stay author-owned, persistent, observable, snoozable, updatable, 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\`
-- **Reply to a DM**: \`slock message send --target "dm:@peer-name" <<'EOF'\` followed by the message body and \`EOF\`
+- **Reply to a DM**: \`slock message send --target dm:@peer-name <<'EOF'\` followed by the message body and \`EOF\`
 - **Reply in a thread**: \`slock message send --target "#channel:shortid" <<'EOF'\` followed by the message body and \`EOF\`
-- **Start a NEW DM**: \`slock message send --target "dm:@person-name" <<'EOF'\` followed by the message body and \`EOF\`
+- **Start a NEW DM**: \`slock message send --target dm:@person-name <<'EOF'\` followed by the message body and \`EOF\`
 
 Message content is always read from stdin. Use a heredoc so quotes, backticks, code blocks, and newlines are not interpreted by the shell:
 \`\`\`bash
@@ -814,10 +874,12 @@ Threads are sub-conversations attached to a specific message. They let you discu
   const discoverySection = isCli ? `### Discovering people and channels
 
 Call \`slock server info\` to see all channels in this server, which ones you have joined, other agents, and humans.
-Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`slock message read\` and \`slock channel members\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use \`slock channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`slock thread unfollow --target "#channel-name:shortid"\`.` : `### Discovering people and channels
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`slock message read\` and \`slock channel members\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use \`slock channel leave --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`slock thread unfollow --target "#channel-name:shortid"\`.
+Private channels are membership-gated. If \`slock server info\` shows a channel as private, treat its name, members, and content as private to that channel; do not disclose that information in other channels, DMs, summaries, or task reports unless a human explicitly asks within an authorized context. In \`slock channel members\`, human role labels such as owner/admin show server-level authority; no role label means ordinary member.` : `### Discovering people and channels
 
 Call ${serverInfoCmd} to see all channels in this server, which ones you have joined, other agents, and humans.
-Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with ${readCmd}, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use \`${t("leave_channel")}\`.`;
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with ${readCmd}, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use \`${t("leave_channel")}\`.
+Private channels are membership-gated. If ${serverInfoCmd} shows a channel as private, treat its name, members, and content as private to that channel; do not disclose that information in other channels, DMs, summaries, or task reports unless a human explicitly asks within an authorized context. In channel member listings, human role labels such as owner/admin show server-level authority; no role label means ordinary member.`;
   const channelAwarenessSection = isCli ? `### Channel awareness
 
 Each channel has a **name** and optionally a **description** that define its purpose (visible via \`slock server info\`). Respect them:
@@ -831,7 +893,7 @@ Each channel has a **name** and optionally a **description** that define its pur
 - If unsure where something belongs, call ${serverInfoCmd} to review channel descriptions.`;
   const readingHistorySection = isCli ? `### Reading history
 
-\`slock message read --channel "#channel-name"\` or \`slock message read --channel "dm:@peer-name"\` or \`slock message read --channel "#channel:shortid"\`
+\`slock message read --channel "#channel-name"\` or \`slock message read --channel dm:@peer-name\` or \`slock message read --channel "#channel:shortid"\`
 
 To jump directly to a specific hit with nearby context, use \`slock message read --channel "..." --around "messageId"\` or \`slock message read --channel "..." --around 12345\`.` : `### Reading history
 
@@ -923,7 +985,7 @@ ${readCmd} shows messages in their current state. If a message was later convert
 - Reuse existing tasks and threads instead of creating duplicates.
 - Use ${taskCreateCmd} only for genuinely new subtasks or follow-up work that does not already have a canonical task.`;
   const claimForEtiquette = isCli ? "`slock task claim`" : taskClaimCmd;
-  let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
+  let prompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration, serving as a shared message service for humans and agents who may be running on different computers.
 
 ## Who you are
 
@@ -1031,6 +1093,17 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.
+- For long answers where users need the conclusion first but details still matter, put the conclusion and next action outside any collapse, then use sanitized HTML details blocks for optional depth:
+
+\`\`\`html
+<details>
+<summary>Evidence, logs, or edge cases</summary>
+
+Detailed notes go here.
+</details>
+\`\`\`
+
+  Do not hide the main recommendation, blocker, or required action inside \`<details>\`; only fold supporting evidence, logs, alternatives, or extended rationale.
 
 ### Conversation etiquette
 
@@ -1301,6 +1374,7 @@ var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path3.join("Applications", "Claude Code U
 var CLAUDE_DESKTOP_CLI_SYSTEM_PATH = "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude";
 var CLAUDE_SYSTEM_PROMPT_FILE = "claude-system-prompt.md";
 var CLAUDE_MCP_CONFIG_FILE = "claude-mcp-config.json";
+var SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME = "chat";
 var CLAUDE_DISALLOWED_TOOLS = [
   "EnterPlanMode",
   "ExitPlanMode",
@@ -1326,10 +1400,101 @@ function probeClaude(deps = {}) {
     version: readCommandVersion(command, [], deps) ?? void 0
   };
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function expandClaudeMcpConfigVariables(raw, vars) {
+  let expanded = raw;
+  for (const [name, value] of Object.entries(vars)) {
+    expanded = expanded.replaceAll(`\${${name}}`, value);
+  }
+  return expanded;
+}
+function readClaudeMcpServers(configPath, vars = {}) {
+  try {
+    const parsed = JSON.parse(
+      expandClaudeMcpConfigVariables(readFileSync(configPath, "utf8"), vars)
+    );
+    if (!isRecord(parsed) || !isRecord(parsed.mcpServers)) return null;
+    return parsed.mcpServers;
+  } catch (err) {
+    logger.warn(
+      `[Claude] failed to read MCP config ${configPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+function resolveClaudeConfigDir(ctx, home) {
+  const configured = ctx.config.envVars?.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR;
+  return configured && path3.isAbsolute(configured) ? configured : path3.join(home, ".claude");
+}
+function collectClaudeMcpConfigFiles(ctx, home) {
+  const files = [];
+  const pushIfFile = (candidate) => {
+    try {
+      if (existsSync2(candidate) && statSync(candidate).isFile()) {
+        files.push({ path: candidate });
+      }
+    } catch {
+    }
+  };
+  pushIfFile(path3.join(home, ".claude.json"));
+  pushIfFile(path3.join(ctx.workingDirectory, ".mcp.json"));
+  const pluginRoot = path3.join(resolveClaudeConfigDir(ctx, home), "plugins");
+  try {
+    for (const entry of readdirSync(pluginRoot)) {
+      const pluginPath = path3.join(pluginRoot, entry);
+      const configPath = path3.join(pluginPath, ".mcp.json");
+      try {
+        if (existsSync2(configPath) && statSync(configPath).isFile()) {
+          files.push({
+            path: configPath,
+            vars: { CLAUDE_PLUGIN_ROOT: pluginPath }
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function buildClaudeUserMcpServers(ctx, home) {
+  const servers = /* @__PURE__ */ Object.create(null);
+  for (const configFile of collectClaudeMcpConfigFiles(ctx, home)) {
+    const mcpServers = readClaudeMcpServers(configFile.path, configFile.vars);
+    if (!mcpServers) continue;
+    for (const [name, server] of Object.entries(mcpServers)) {
+      if (!isRecord(server)) {
+        logger.warn(`[Claude] ignoring invalid MCP server "${name}" in ${configFile.path}`);
+        continue;
+      }
+      servers[name] = server;
+    }
+  }
+  return servers;
+}
 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.
@@ -1364,36 +1529,46 @@ var ClaudeDriver = class {
     }
     return args;
   }
-  buildRuntimeActionsMcpConfig(ctx) {
+  buildRuntimeActionsMcpServer(ctx) {
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const command = isTsSource ? "npx" : "node";
     const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
+    return {
+      command,
+      args: [
+        ...bridgeArgs,
+        "--agent-id",
+        ctx.agentId,
+        "--server-url",
+        ctx.config.serverUrl,
+        "--auth-token",
+        ctx.config.authToken || ctx.daemonApiKey,
+        "--runtime",
+        this.id,
+        ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
+        "--runtime-actions-only"
+      ]
+    };
+  }
+  buildRuntimeActionsMcpConfig(ctx, home = os.homedir()) {
+    const userMcpServers = buildClaudeUserMcpServers(ctx, home);
+    if (Object.prototype.hasOwnProperty.call(userMcpServers, SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME)) {
+      logger.warn(
+        `[Agent ${ctx.agentId}] Claude user MCP server "${SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME}" is reserved by Slock runtime actions and will be ignored`
+      );
+    }
     return JSON.stringify({
       mcpServers: {
-        chat: {
-          command,
-          args: [
-            ...bridgeArgs,
-            "--agent-id",
-            ctx.agentId,
-            "--server-url",
-            ctx.config.serverUrl,
-            "--auth-token",
-            ctx.config.authToken || ctx.daemonApiKey,
-            "--runtime",
-            this.id,
-            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
-            "--runtime-actions-only"
-          ]
-        }
+        ...userMcpServers,
+        [SLOCK_RUNTIME_ACTIONS_MCP_SERVER_NAME]: this.buildRuntimeActionsMcpServer(ctx)
       }
     });
   }
-  writeClaudeLaunchFiles(ctx, slockDir) {
+  writeClaudeLaunchFiles(ctx, slockDir, home = os.homedir()) {
     const systemPromptPath = path3.join(slockDir, CLAUDE_SYSTEM_PROMPT_FILE);
     const mcpConfigPath = path3.join(slockDir, CLAUDE_MCP_CONFIG_FILE);
     writeFileSync2(systemPromptPath, ctx.standingPrompt, { mode: 384 });
-    writeFileSync2(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx), { mode: 384 });
+    writeFileSync2(mcpConfigPath, this.buildRuntimeActionsMcpConfig(ctx, home), { mode: 384 });
     return { systemPromptPath, mcpConfigPath };
   }
   spawn(ctx) {
@@ -1541,8 +1716,8 @@ var ClaudeDriver = class {
 
 // src/drivers/codex.ts
 import { spawn as spawn2, execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import os from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import os2 from "os";
 import path4 from "path";
 function getCodexNotificationErrorMessage(params) {
   const topLevelMessage = params?.message;
@@ -1556,7 +1731,7 @@ function getCodexNotificationErrorMessage(params) {
   return null;
 }
 function ensureGitRepoForCodex(workingDirectory, deps = {}) {
-  const existsSyncFn = deps.existsSyncFn ?? existsSync2;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   const execSyncFn = deps.execSyncFn ?? execSync;
   const gitDir = path4.join(workingDirectory, ".git");
   if (existsSyncFn(gitDir)) return;
@@ -1603,14 +1778,14 @@ function resolveCodexSpawn(commandArgs, deps = {}) {
   try {
     const globalRoot = execSync("npm root -g", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const candidate = path4.join(globalRoot, "@openai", "codex", "bin", "codex.js");
-    if (existsSync2(candidate)) codexEntry = candidate;
+    if (existsSync3(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 = path4.join(path4.dirname(cmdPath), "node_modules", "@openai", "codex", "bin", "codex.js");
-      if (existsSync2(candidate)) codexEntry = candidate;
+      if (existsSync3(candidate)) codexEntry = candidate;
     } catch {
     }
   }
@@ -1631,8 +1806,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() {
@@ -2013,12 +2205,12 @@ var CodexDriver = class {
     return detectCodexModels();
   }
 };
-function detectCodexModels(home = os.homedir()) {
+function detectCodexModels(home = os2.homedir()) {
   const cachePath = path4.join(home, ".codex", "models_cache.json");
   const configPath = path4.join(home, ".codex", "config.toml");
   let models = [];
   try {
-    const raw = readFileSync(cachePath, "utf8");
+    const raw = readFileSync2(cachePath, "utf8");
     const parsed = JSON.parse(raw);
     const entries = Array.isArray(parsed?.models) ? parsed.models : [];
     for (const entry of entries) {
@@ -2027,7 +2219,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;
@@ -2035,7 +2227,7 @@ function detectCodexModels(home = os.homedir()) {
   if (models.length === 0) return null;
   let defaultModel;
   try {
-    const raw = readFileSync(configPath, "utf8");
+    const raw = readFileSync2(configPath, "utf8");
     const match = raw.match(/^\s*model\s*=\s*"([^"]+)"/m);
     if (match) defaultModel = match[1];
   } catch {
@@ -2049,6 +2241,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";
@@ -2182,17 +2391,34 @@ var CopilotDriver = class {
 };
 
 // src/drivers/cursor.ts
-import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { spawn as spawn4, spawnSync } from "child_process";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync4 } 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";
   spawn(ctx) {
     const cursorDir = path6.join(ctx.workingDirectory, ".cursor");
-    if (!existsSync3(cursorDir)) {
+    if (!existsSync4(cursorDir)) {
       mkdirSync2(cursorDir, { recursive: true });
     }
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
@@ -2299,49 +2525,89 @@ 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 { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } 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 || {}
-  };
+function buildGeminiSpawnEnv(ctx, platform = process.platform) {
+  const { spawnEnv } = prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
+  if (!Object.prototype.hasOwnProperty.call(ctx.config.envVars ?? {}, "GEMINI_CLI_TRUST_WORKSPACE")) {
+    spawnEnv.GEMINI_CLI_TRUST_WORKSPACE = "true";
+  }
+  return spawnEnv;
 }
 var GeminiDriver = class {
   id = "gemini";
+  lifecycle = {
+    kind: "per_turn",
+    start: "immediate",
+    exit: "natural",
+    inFlightWake: "spawn_new"
+  };
+  communication = {
+    chat: "slock_cli",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "suggestion_only",
+    toLaunchSpec: (modelId) => modelId && modelId !== "default" ? { args: ["--model", modelId] } : { args: [] }
+  };
   supportsStdinNotification = false;
   mcpToolPrefix = "";
   busyDeliveryMode = "none";
+  usesSlockCliForCommunication = true;
   sessionId = null;
   sessionAnnounced = false;
   spawn(ctx) {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
-    const geminiDir = path7.join(ctx.workingDirectory, ".gemini");
-    if (!existsSync4(geminiDir)) {
-      mkdirSync3(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 = path7.join(geminiDir, "settings.json");
-    writeFileSync5(settingsPath, JSON.stringify({
-      mcpServers: {
-        chat: {
-          command: mcpCommand,
-          args: mcpArgs
-        }
-      }
-    }), "utf8");
+    this.writeGeminiSettings(ctx);
     const args = [
       "--output-format",
       "stream-json",
@@ -2415,28 +2681,64 @@ var GeminiDriver = class {
     return null;
   }
   buildSystemPrompt(config, _agentId) {
-    return buildMcpSystemPrompt(config, {
+    return buildCliTransportSystemPrompt(config, {
       toolPrefix: "",
       extraCriticalRules: [
-        "- Do NOT use shell commands to send or receive messages. The MCP tools handle everything."
+        "- 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 `runtime_profile_migration_done` tool with the exact `migration_key`; do not use `slock` CLI or reply in chat as the acknowledgment."
+      ],
+      postStartupNotes: [
+        "**Gemini 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."
       ],
-      postStartupNotes: [],
       includeStdinNotificationSection: false,
       messageNotificationStyle: "poll"
     });
   }
+  writeGeminiSettings(ctx) {
+    const geminiDir = path7.join(ctx.workingDirectory, ".gemini");
+    mkdirSync3(geminiDir, { recursive: true });
+    const settingsPath = path7.join(geminiDir, "settings.json");
+    writeFileSync5(settingsPath, JSON.stringify(this.buildRuntimeActionsMcpSettings(ctx)), "utf8");
+  }
+  buildRuntimeActionsMcpSettings(ctx) {
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    const command = isTsSource ? "npx" : "node";
+    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath];
+    return {
+      mcpServers: {
+        chat: {
+          command,
+          args: [
+            ...bridgeArgs,
+            "--agent-id",
+            ctx.agentId,
+            "--server-url",
+            ctx.config.serverUrl,
+            "--auth-token",
+            ctx.config.authToken || ctx.daemonApiKey,
+            "--runtime",
+            this.id,
+            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
+            "--runtime-actions-only"
+          ]
+        }
+      }
+    };
+  }
 };
 
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync6 } from "fs";
-import os2 from "os";
+import { chmodSync, existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import os3 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -2445,8 +2747,109 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os3.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path8.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return spawnEnv;
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path8.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 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, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
   busyDeliveryMode = "direct";
@@ -2497,6 +2900,7 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -2505,16 +2909,13 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
-    }
-    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
     const proc = spawn6("kimi", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
+      env: launch.env,
       shell: process.platform === "win32"
     });
     proc.stdin?.write(JSON.stringify({
@@ -2631,14 +3032,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os2.homedir()) {
-  const configPath = path8.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync2(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os3.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -2647,7 +3043,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;
@@ -2658,9 +3054,9 @@ function detectKimiModels(home = os2.homedir()) {
 }
 
 // src/drivers/opencode.ts
-import { spawn as spawn7 } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
-import os3 from "os";
+import { spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+import os4 from "os";
 import path9 from "path";
 var CHAT_MCP_SERVER_NAME = "chat";
 var CHAT_MCP_TOOL_PREFIX = `${CHAT_MCP_SERVER_NAME}_`;
@@ -2668,6 +3064,14 @@ 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";
+var OPENCODE_PROVIDER_LABELS = {
+  opencode: "OpenCode",
+  "opencode-go": "OpenCode Go",
+  openai: "OpenAI",
+  openrouter: "OpenRouter",
+  deepseek: "DeepSeek",
+  fusecode: "FuseCode"
+};
 function buildChatBridgeCommand(ctx) {
   const isTsSource = ctx.chatBridgePath.endsWith(".ts");
   return [
@@ -2700,10 +3104,10 @@ function parseUserOpenCodeConfig(ctx) {
   const raw = ctx.config.envVars?.OPENCODE_CONFIG_CONTENT;
   return parseOpenCodeConfigContent(raw);
 }
-function readLocalOpenCodeConfig(home = os3.homedir()) {
+function readLocalOpenCodeConfig(home = os4.homedir()) {
   const configPath = path9.join(home, ".config", "opencode", "opencode.json");
   try {
-    return parseOpenCodeConfigContent(readFileSync3(configPath, "utf8"));
+    return parseOpenCodeConfigContent(readFileSync4(configPath, "utf8"));
   } catch {
   }
   return {};
@@ -2749,7 +3153,7 @@ function mergeOpenCodeConfigs(localConfig, envConfig) {
     }
   };
 }
-function buildOpenCodeConfig(ctx, home = os3.homedir()) {
+function buildOpenCodeConfig(ctx, home = os4.homedir()) {
   const userConfig = mergeOpenCodeConfigs(readLocalOpenCodeConfig(home), parseUserOpenCodeConfig(ctx));
   const userAgents = recordField(userConfig.agent);
   const userSlockAgent = recordField(userAgents[SLOCK_AGENT_NAME]);
@@ -2774,7 +3178,7 @@ function buildOpenCodeConfig(ctx, home = os3.homedir()) {
     }
   };
 }
-function buildOpenCodeLaunchOptions(ctx, home = os3.homedir()) {
+function buildOpenCodeLaunchOptions(ctx, home = os4.homedir()) {
   const slock = prepareCliTransport(ctx, { NO_COLOR: "1" });
   const config = buildOpenCodeConfig(ctx, home);
   const env = {
@@ -2801,21 +3205,92 @@ function buildOpenCodeLaunchOptions(ctx, home = os3.homedir()) {
   args.push("--", turnPrompt);
   return { args, env, config };
 }
-function detectOpenCodeModels(home = os3.homedir()) {
-  const models = [...RUNTIME_MODELS.opencode || []];
-  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 });
-    }
+function parseOpenCodeModelsOutput(output) {
+  const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+  const models = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawLine of stripAnsi(output).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("{") || line.startsWith("}") || line.startsWith('"')) continue;
+    if (/^opencode models\b/i.test(line) || /^list all available models$/i.test(line)) continue;
+    if (!line.includes("/") || /\s/.test(line) || line.startsWith("-")) continue;
+    if (seen.has(line)) continue;
+    seen.add(line);
+    models.push({
+      id: line,
+      label: formatOpenCodeModelLabel(line),
+      verified: "launchable"
+    });
   }
   return models.length > 0 ? { models } : null;
 }
+function formatOpenCodeModelLabel(modelId) {
+  const separatorIndex = modelId.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === modelId.length - 1) return modelId;
+  const providerId = modelId.slice(0, separatorIndex);
+  const modelName = modelId.slice(separatorIndex + 1);
+  const providerLabel = OPENCODE_PROVIDER_LABELS[providerId] || humanizeOpenCodeSegment(providerId);
+  const modelParts = modelName.split("/");
+  const modelLabel = humanizeOpenCodeSegment(modelParts[modelParts.length - 1] || modelName);
+  if (modelParts.length === 1) return `${modelLabel} \xB7 ${providerLabel}`;
+  const upstreamLabel = modelParts.slice(0, -1).map(humanizeOpenCodeSegment).join(" / ");
+  return `${modelLabel} \xB7 ${upstreamLabel} via ${providerLabel}`;
+}
+function humanizeOpenCodeSegment(value) {
+  return value.replace(/\[(\d+)m\]/gi, "-$1m").split(/[-_]/).filter(Boolean).map(formatOpenCodeLabelToken).join(" ");
+}
+function formatOpenCodeLabelToken(token) {
+  const normalized = token.toLowerCase();
+  const specialCases = {
+    ai: "AI",
+    api: "API",
+    b: "B",
+    chatgpt: "ChatGPT",
+    claude: "Claude",
+    codestral: "Codestral",
+    deepseek: "DeepSeek",
+    flash: "Flash",
+    free: "Free",
+    gemini: "Gemini",
+    glm: "GLM",
+    gpt: "GPT",
+    hy3: "HY3",
+    kimi: "Kimi",
+    m: "M",
+    minimax: "MiniMax",
+    nano: "Nano",
+    nemotron: "Nemotron",
+    omni: "Omni",
+    opus: "Opus",
+    pro: "Pro",
+    sonnet: "Sonnet",
+    super: "Super"
+  };
+  if (specialCases[normalized]) return specialCases[normalized];
+  if (/^v\d+(\.\d+)?$/.test(normalized)) return normalized.toUpperCase();
+  if (/^\d+m$/i.test(token)) return token.toUpperCase();
+  if (/^\d+[bk]$/i.test(token)) return token.toUpperCase();
+  if (/^m\d+(\.\d+)?$/i.test(token)) return token.toUpperCase();
+  if (/^\d/.test(token)) return token;
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+function detectOpenCodeModels(home = os4.homedir(), runCommand = runOpenCodeModelsCommand) {
+  const commandResult = runCommand(home);
+  if (commandResult.error || commandResult.status !== 0) return null;
+  return parseOpenCodeModelsOutput(commandResult.stdout);
+}
+function runOpenCodeModelsCommand(home) {
+  const result = spawnSync2("opencode", ["models"], {
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    encoding: "utf8",
+    timeout: 5e3
+  });
+  return {
+    status: result.status,
+    stdout: String(result.stdout || ""),
+    error: result.error
+  };
+}
 function isSystemFirstMessageTask(message) {
   return message.sender_id === "system" && message.channel_type === "channel" && message.channel_name === "all" && message.content.trimStart().startsWith(FIRST_MESSAGE_TASK_PREFIX);
 }
@@ -2834,6 +3309,38 @@ function buildOpenCodeSystemPrompt(config) {
 }
 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";
@@ -3059,7 +3566,53 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
 }
 
 // src/agentProcessManager.ts
-var DATA_DIR = path11.join(os4.homedir(), ".slock", "agents");
+var DATA_DIR = path11.join(os5.homedir(), ".slock", "agents");
+var DEFAULT_MAX_CONCURRENT_AGENT_STARTS = 5;
+var DEFAULT_AGENT_START_INTERVAL_MS = 500;
+var WORKSPACE_TEXT_FILE_MAX_BYTES = 1048576;
+var WORKSPACE_IMAGE_PREVIEW_MAX_BYTES = 5 * 1024 * 1024;
+var WORKSPACE_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".txt",
+  ".json",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".log",
+  ".csv",
+  ".xml",
+  ".html",
+  ".css",
+  ".sh",
+  ".py"
+]);
+var WORKSPACE_IMAGE_MIME_BY_EXTENSION = {
+  ".apng": "image/apng",
+  ".avif": "image/avif",
+  ".gif": "image/gif",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+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;
@@ -3085,6 +3638,7 @@ function formatMessageTarget(message) {
 function getMessageShortId(messageId) {
   return messageId.startsWith("thread-") ? messageId.slice(7) : messageId.slice(0, 8);
 }
+var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
 function findSessionJsonl(root, predicate) {
   let visited = 0;
   const maxEntries = 1e4;
@@ -3093,7 +3647,7 @@ function findSessionJsonl(root, predicate) {
     if (depth < 0 || visited >= maxEntries) return null;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
+      entries = readdirSync2(dir, { withFileTypes: true }).sort((a, b) => b.name.localeCompare(a.name));
     } catch {
       return null;
     }
@@ -3139,11 +3693,11 @@ function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
     return null;
   }
 }
-function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os4.homedir(), fallbackDir) {
+function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os5.homedir(), fallbackDir) {
   const directPath = path11.isAbsolute(sessionId) ? sessionId : null;
   if (directPath) {
     try {
-      if (statSync(directPath).isFile()) {
+      if (statSync2(directPath).isFile()) {
         return { label: sessionId, path: directPath, runtime, reachable: true };
       }
     } catch {
@@ -3239,6 +3793,16 @@ function formatRuntimeProfileControlPrompt(messages) {
     return null;
   }
   const body = controls.map(({ message }) => message.content).join("\n\n---\n\n");
+  const hasMigration = controls.some(({ notification }) => notification?.kind === "migration");
+  if (!hasMigration) {
+    return [
+      "Runtime Profile daemon release notice.",
+      "",
+      "Read the notice below before continuing. No chat reply or runtime control action is required for this notice \u2014 resume normal inbox processing afterward.",
+      "",
+      body
+    ].join("\n");
+  }
   return [
     "Runtime Profile control notice.",
     "",
@@ -3744,6 +4308,15 @@ function classifyTerminalFailure(ap) {
   }
   return null;
 }
+function hasDirectStdinRecoveryEvidence(ap) {
+  const candidates = [
+    ap.lastRuntimeError,
+    ...ap.recentStderr
+  ].filter((value) => !!value);
+  return candidates.some(
+    (text) => /write_stdin failed|stdin is closed|closed for this session|session.*closed/i.test(text)
+  );
+}
 function isMissingResumeSession(ap) {
   if (!ap.sessionId) return false;
   const candidates = [
@@ -3760,6 +4333,66 @@ function isMissingResumeSession(ap) {
   }
   return false;
 }
+function classifyActivityDetailForTrace(detail) {
+  if (!detail) return void 0;
+  if (detail === "Message received") return "message_received";
+  if (detail === "Starting\u2026") return "starting";
+  if (detail === "Running command\u2026") return "running_command";
+  if (detail === "Checking messages\u2026") return "checking_messages";
+  if (detail === "Compacting context") return "compacting_context";
+  if (detail === "Context compaction finished") return "compaction_finished";
+  if (detail === "Context compaction still running; no finish event observed") return "compaction_stale";
+  if (detail === "Idle" || detail === "Process idle") return "idle";
+  if (detail.startsWith("Restarting stalled ") && detail.endsWith(" runtime for queued message")) return "stalled_recovery";
+  if (detail.startsWith("Runtime stalled: no runtime events for ")) return "runtime_stalled";
+  return "other";
+}
+function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
+  const context = [];
+  if (ap.lastActivityDetail) {
+    context.push(`after ${ap.lastActivityDetail}`);
+  }
+  if (ap.driver.busyDeliveryMode === "gated") {
+    context.push(`phase=${ap.gatedSteering.phase}`);
+  }
+  if (ap.gatedSteering.outstandingToolUses > 0) {
+    context.push(`tools=${ap.gatedSteering.outstandingToolUses}`);
+  }
+  if (ap.gatedSteering.compacting) {
+    context.push("compacting");
+  }
+  if (ap.inbox.length > 0) {
+    context.push(`queued=${ap.inbox.length}`);
+  }
+  const detail = [
+    `Runtime stalled: no runtime events for ${staleForMinutes}m`,
+    context.length > 0 ? ` (${context.join(", ")})` : ""
+  ].join("");
+  return {
+    detail,
+    traceAttrs: {
+      ageMs: staleForMs,
+      staleForMinutes,
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      sessionIdPresent: Boolean(ap.sessionId),
+      inboxCount: ap.inbox.length,
+      pendingNotificationCount: ap.pendingNotificationCount,
+      processPidPresent: typeof ap.process.pid === "number",
+      busyDeliveryMode: ap.driver.busyDeliveryMode,
+      supportsStdinNotification: ap.driver.supportsStdinNotification,
+      gatedPhase: ap.driver.busyDeliveryMode === "gated" ? ap.gatedSteering.phase : void 0,
+      outstandingToolUses: ap.gatedSteering.outstandingToolUses,
+      compacting: ap.gatedSteering.compacting,
+      recentStderrCount: ap.recentStderr.length,
+      recentStdoutCount: ap.recentStdout.length
+    }
+  };
+}
 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.";
 }
@@ -3783,6 +4416,14 @@ var AgentProcessManager = class _AgentProcessManager {
   agents = /* @__PURE__ */ new Map();
   agentsStarting = /* @__PURE__ */ new Set();
   // Prevent concurrent starts of same agent
+  queuedAgentStarts = /* @__PURE__ */ new Map();
+  agentStartQueue = [];
+  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();
@@ -3796,6 +4437,7 @@ var AgentProcessManager = class _AgentProcessManager {
   driverResolver;
   defaultAgentEnvVarsProvider;
   tracer;
+  deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
@@ -3803,21 +4445,248 @@ var AgentProcessManager = class _AgentProcessManager {
     this.daemonApiKey = daemonApiKey;
     this.serverUrl = opts.serverUrl;
     this.dataDir = opts.dataDir || DATA_DIR;
-    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os4.homedir();
+    this.runtimeSessionHomeDir = opts.runtimeSessionHomeDir || os5.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;
-    }
+  setTracer(tracer) {
+    this.tracer = tracer;
+  }
+  recordDaemonTrace(name, attrs, status = "ok", parentTraceparent) {
+    const span = this.tracer.startSpan(name, {
+      parent: parseTraceparent(parentTraceparent),
+      surface: "daemon",
+      kind: "internal",
+      attrs
+    });
+    span.end(status);
+  }
+  startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+    return {
+      agentId,
+      launchId,
+      runtime: config.runtime,
+      model: config.model,
+      session_id_present: Boolean(config.sessionId),
+      launch_id_present: Boolean(launchId),
+      wake_message_present: Boolean(wakeMessage),
+      unread_channels_count: unreadSummary ? Object.keys(unreadSummary).length : 0,
+      resume_prompt_present: Boolean(resumePrompt),
+      queue_depth: this.agentStartQueue.length,
+      active_starts: this.activeAgentStartCount,
+      max_concurrent_starts: this.maxConcurrentAgentStarts,
+      min_start_interval_ms: this.agentStartIntervalMs
+    };
+  }
+  getDeliveryTraceContext(message) {
+    return this.deliveryTraceContexts.get(message) ?? {};
+  }
+  deliveryTraceAttrs(agentId, message, attrs = {}) {
+    const context = this.getDeliveryTraceContext(message);
+    const deliveryCorrelationId = context.deliveryId ?? message.message_id;
+    return {
+      agentId,
+      deliveryId: context.deliveryId,
+      delivery_correlation_id: deliveryCorrelationId,
+      channel_type: message.channel_type,
+      sender_type: message.sender_type,
+      messageId: message.message_id,
+      message_id_present: Boolean(message.message_id),
+      ...attrs
+    };
+  }
+  async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
+    this.recordDaemonTrace("daemon.agent.start.requested", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
+    if (this.agents.has(agentId)) {
+      this.recordDaemonTrace("daemon.agent.start.ignored", {
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        reason: "already_running"
+      });
+      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      return;
+    }
     if (this.agentsStarting.has(agentId)) {
+      this.recordDaemonTrace("daemon.agent.start.ignored", {
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        reason: "already_starting"
+      });
+      logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
+      return;
+    }
+    if (this.queuedAgentStarts.has(agentId)) {
+      this.recordDaemonTrace("daemon.agent.start.ignored", {
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        reason: "already_queued"
+      });
+      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);
+      this.recordDaemonTrace("daemon.agent.start.queued", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
+      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.recordDaemonTrace("daemon.agent.start.rate_limited", {
+        ...this.startQueueTraceAttrs(next.agentId, next.config, next.wakeMessage, next.unreadSummary, next.resumePrompt, next.launchId),
+        wait_ms: waitMs
+      });
+      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.recordDaemonTrace("daemon.agent.start.skipped", {
+        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+        reason: "stale_queue_item"
+      });
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.queuedAgentStarts.delete(item.agentId);
+    if (this.agents.has(item.agentId) || this.agentsStarting.has(item.agentId)) {
+      this.recordDaemonTrace("daemon.agent.start.skipped", {
+        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+        reason: "already_running_or_starting"
+      });
+      logger.info(`[Agent ${item.agentId}] Queued start skipped (already running or starting)`);
+      item.resolve();
+      this.pumpAgentStartQueue();
+      return;
+    }
+    this.activeAgentStartCount++;
+    this.lastAgentStartAt = Date.now();
+    this.lastAgentStartAgentId = item.agentId;
+    logger.info(
+      `[Agent ${item.agentId}] Dequeued start (remaining=${this.agentStartQueue.length}, active=${this.activeAgentStartCount})`
+    );
+    this.recordDaemonTrace("daemon.agent.start.dequeued", this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId));
+    this.startAgentNow(
+      item.agentId,
+      item.config,
+      item.wakeMessage,
+      item.unreadSummary,
+      item.resumePrompt,
+      item.launchId
+    ).then(() => {
+      this.releaseAgentStartSlot(item.agentId, "spawn attempted");
+      item.resolve();
+    }, (err) => {
+      this.releaseAgentStartSlot(item.agentId, "start failed");
+      item.reject(err);
+    });
+  }
+  releaseAgentStartSlot(agentId, reason) {
+    if (this.activeAgentStartCount <= 0) return;
+    this.activeAgentStartCount = Math.max(0, this.activeAgentStartCount - 1);
+    this.recordDaemonTrace("daemon.agent.start.slot_released", {
+      agentId,
+      reason,
+      active_starts: this.activeAgentStartCount,
+      queue_depth: this.agentStartQueue.length,
+      max_concurrent_starts: this.maxConcurrentAgentStarts
+    });
+    logger.info(
+      `[Agent ${agentId}] Start slot released (${reason}) (active=${this.activeAgentStartCount}, queue=${this.agentStartQueue.length})`
+    );
+    this.pumpAgentStartQueue();
+  }
+  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;
+    }
+    this.recordDaemonTrace("daemon.agent.start.cancelled", {
+      ...this.startQueueTraceAttrs(agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+      reason
+    }, "cancelled");
+    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) {
+        this.recordDaemonTrace("daemon.agent.start.cancelled", {
+          ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId),
+          reason
+        }, "cancelled");
+        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)) {
+      this.recordDaemonTrace("daemon.agent.spawn.skipped", {
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        reason: "already_running"
+      });
+      logger.info(`[Agent ${agentId}] Start ignored (already running)`);
+      return;
+    }
+    if (this.agentsStarting.has(agentId)) {
+      this.recordDaemonTrace("daemon.agent.spawn.skipped", {
+        ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+        reason: "already_starting"
+      });
       logger.info(`[Agent ${agentId}] Start ignored (startup in progress)`);
       return;
     }
     this.agentsStarting.add(agentId);
+    this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId));
     try {
       const driver = this.driverResolver(config.runtime || "claude");
       const agentDataDir = path11.join(this.dataDir, agentId);
@@ -3877,6 +4746,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up, or respond to t
           prompt += `
 
 Respond as appropriate \u2014 ${dynamicReplyInstruction(driver)}, or take action as needed. Complete ALL your work before stopping.
+${RESPONSE_TARGET_HINT}
 
 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);
@@ -3909,6 +4779,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         });
         this.sendAgentStatus(agentId, "active", launchId || null);
         this.broadcastActivity(agentId, "online", "Process idle");
+        this.recordDaemonTrace("daemon.agent.spawn.deferred", {
+          ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId),
+          pending_messages_count: pendingMessages.length,
+          reason: "defer_until_concrete_message"
+        });
         logger.info(`[Agent ${agentId}] Deferred ${driver.id} spawn until first concrete message`);
         for (const message of pendingMessages) {
           this.deliverMessage(agentId, message);
@@ -3926,6 +4801,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         daemonApiKey: this.daemonApiKey,
         launchId: launchId || null
       });
+      this.recordDaemonTrace("daemon.agent.spawn.created", {
+        ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, launchId),
+        detached: false,
+        new_session: false,
+        process_pid_present: typeof proc.pid === "number"
+      });
       const agentProcess = {
         process: proc,
         driver,
@@ -3947,6 +4828,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtimeTraceSpan: null,
         lastActivity: "",
         lastActivityDetail: "",
+        activityClientSeq: 0,
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
@@ -3959,7 +4841,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       };
       this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
-      this.startRuntimeTrace(agentId, agentProcess, "spawn");
+      this.idleAgentConfigs.set(agentId, {
+        config: { ...effectiveConfig, sessionId: effectiveConfig.sessionId || null },
+        sessionId: effectiveConfig.sessionId || null,
+        launchId: launchId || null
+      });
+      this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0);
       this.agentsStarting.delete(agentId);
       if (config.runtimeProfileControl) {
         this.ackInjectedRuntimeProfileControl(agentId, config.runtimeProfileControl, agentProcess.launchId);
@@ -3998,6 +4885,13 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       proc.on("error", (err) => {
         const current = this.agents.get(agentId);
         if (current) current.spawnError = err.message;
+        this.recordDaemonTrace("daemon.agent.process.error", {
+          agentId,
+          launchId: current?.launchId || void 0,
+          runtime: config.runtime,
+          model: config.model,
+          error_class: err.name || typeof err
+        }, "error");
         logger.error(`[Agent ${agentId}] Process error: ${err.message}`);
       });
       proc.on("exit", (code, signal) => {
@@ -4006,6 +4900,18 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           current.exitCode = code;
           current.exitSignal = signal;
         }
+        this.recordDaemonTrace("daemon.agent.process.exited", {
+          agentId,
+          launchId: current?.launchId || void 0,
+          runtime: config.runtime,
+          model: config.model,
+          exit_code: code,
+          exit_signal: signal,
+          clean_exit: code === 0,
+          runtime_trace_active: Boolean(current?.runtimeTraceSpan),
+          inbox_count: current?.inbox.length ?? 0,
+          pending_notification_count: current?.pendingNotificationCount ?? 0
+        });
         logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
       });
       proc.on("close", (code, signal) => {
@@ -4069,7 +4975,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           }
           if (processEndedCleanly) {
             let queuedWakeMessage;
-            if (!ap.driver.supportsStdinNotification) {
+            if (!ap.driver.supportsStdinNotification || ap.expectedTerminationReason === "stalled_recovery") {
               while (ap.inbox.length > 0) {
                 const candidate = ap.inbox.shift();
                 if (this.shouldDeferWakeMessage(agentId, ap.driver, candidate)) continue;
@@ -4175,7 +5081,68 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     return leftKeys.every((key) => left?.[key] === right?.[key]);
   }
+  enqueueRuntimeProfileNotification(agentId, ap, message, kind, key) {
+    ap.inbox.push(message);
+    if (ap.driver.supportsStdinNotification && ap.sessionId) {
+      ap.pendingNotificationCount++;
+      if (ap.driver.busyDeliveryMode === "gated") {
+        this.recordGatedSteeringEvent(agentId, ap, "buffer", {
+          reason: "runtime_profile",
+          kind,
+          pendingMessages: ap.inbox.length
+        });
+      } else if (!ap.notificationTimer) {
+        ap.notificationTimer = setTimeout(() => {
+          this.sendStdinNotification(agentId);
+        }, 3e3);
+      }
+    }
+    this.recordDaemonTrace("daemon.agent.runtime_profile.routed", {
+      agentId,
+      kind,
+      key_present: Boolean(key),
+      outcome: ap.sessionId ? "queued_busy" : "queued_before_session",
+      runtime: ap.config.runtime,
+      session_id_present: Boolean(ap.sessionId),
+      launchId: ap.launchId || void 0,
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.pendingNotificationCount,
+      busy_delivery_mode: ap.driver.busyDeliveryMode,
+      supports_stdin_notification: ap.driver.supportsStdinNotification
+    });
+    logger.info(
+      `[Agent ${agentId}] Queued runtime profile ${kind} ${key} for ${ap.sessionId ? "busy" : "pre-session"} ${ap.driver.id} delivery`
+    );
+  }
+  queueRuntimeProfileNotificationDuringStart(agentId, message, kind, key) {
+    const pending = this.startingInboxes.get(agentId) || [];
+    pending.push(message);
+    this.startingInboxes.set(agentId, pending);
+    const queuedStart = this.queuedAgentStarts.get(agentId);
+    this.recordDaemonTrace("daemon.agent.runtime_profile.routed", {
+      agentId,
+      kind,
+      key_present: Boolean(key),
+      outcome: "queued_during_start",
+      startup_pending: true,
+      starting_inbox_count: pending.length,
+      launchId: queuedStart?.launchId
+    });
+    logger.info(`[Agent ${agentId}] Queued runtime profile ${kind} ${key} during startup`);
+  }
+  splitRuntimeProfileControlBatch(messages) {
+    const controlMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message));
+    if (controlMessages.length === 0 || controlMessages.length === messages.length) {
+      return { nextMessages: messages, deferredMessages: [] };
+    }
+    const deferredMessages = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+    return { nextMessages: controlMessages, deferredMessages };
+  }
+  containsOrdinaryInboxMessage(messages) {
+    return messages.some((message) => !runtimeProfileNotificationFromMessage(message));
+  }
   async stopAgent(agentId, { wait = false, silent = false } = {}) {
+    this.cancelQueuedAgentStart(agentId, "stop requested");
     this.idleAgentConfigs.delete(agentId);
     const ap = this.agents.get(agentId);
     if (!ap) {
@@ -4222,51 +5189,155 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       });
     }
   }
-  deliverMessage(agentId, message) {
+  deliverMessage(agentId, message, traceContext = {}) {
+    if (traceContext.deliveryId) {
+      this.deliveryTraceContexts.set(message, traceContext);
+    }
     const ap = this.agents.get(agentId);
     if (!ap) {
-      if (this.agentsStarting.has(agentId)) {
+      if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
+        const queuedStart = this.queuedAgentStarts.get(agentId);
         const pending = this.startingInboxes.get(agentId) || [];
         pending.push(message);
         this.startingInboxes.set(agentId, pending);
-        return;
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "queued_during_start",
+          accepted: true,
+          process_present: false,
+          startup_pending: true,
+          starting_inbox_count: pending.length,
+          launchId: queuedStart?.launchId
+        }));
+        return true;
       }
       const cached = this.idleAgentConfigs.get(agentId);
       if (cached) {
         const driver = this.driverResolver(cached.config.runtime || "claude");
         if (this.shouldDeferWakeMessage(agentId, driver, message)) {
-          return;
+          this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+            outcome: "deferred_wake_message",
+            accepted: true,
+            process_present: false,
+            cached_idle_config_present: true,
+            runtime: cached.config.runtime,
+            session_id_present: Boolean(cached.sessionId),
+            launchId: cached.launchId || void 0
+          }));
+          return true;
         }
         logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
         this.idleAgentConfigs.delete(agentId);
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "auto_restart_from_idle",
+          accepted: true,
+          process_present: false,
+          cached_idle_config_present: true,
+          runtime: cached.config.runtime,
+          session_id_present: Boolean(cached.sessionId),
+          launchId: cached.launchId || void 0
+        }));
         this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).catch((err) => {
           logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
         });
+        return true;
       }
-      return;
+      logger.warn(`[Agent ${agentId}] Delivery received but no running process or cached idle config exists`);
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "rejected_no_process",
+        accepted: false,
+        process_present: false,
+        cached_idle_config_present: false
+      }), "error");
+      this.sendAgentStatus(agentId, "inactive", null);
+      this.broadcastActivity(agentId, "offline", "Process unavailable; restart required");
+      return false;
     }
     if (this.shouldDeferWakeMessage(agentId, ap.driver, message)) {
-      return;
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "deferred_wake_message",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: Boolean(ap.sessionId),
+        launchId: ap.launchId || void 0,
+        is_idle: ap.isIdle,
+        inbox_count: ap.inbox.length
+      }));
+      return true;
     }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       const nextMessages = ap.inbox.splice(0, ap.inbox.length);
       nextMessages.push(message);
       ap.isIdle = false;
-      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery");
+      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery", nextMessages);
       this.broadcastActivity(agentId, "working", "Message received");
-      this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
-      return;
+      const stdinAccepted = this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "stdin_idle_delivery",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: true,
+        launchId: ap.launchId || void 0,
+        stdin_delivery_accepted: stdinAccepted,
+        delivered_messages_count: nextMessages.length
+      }));
+      return true;
     }
     ap.inbox.push(message);
-    if (!ap.driver.supportsStdinNotification) return;
-    if (!ap.sessionId) return;
+    if (this.recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap)) {
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_stalled_recovery",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: Boolean(ap.sessionId),
+        launchId: ap.launchId || void 0,
+        inbox_count: ap.inbox.length
+      }));
+      return true;
+    }
+    if (!ap.driver.supportsStdinNotification) {
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_busy_non_stdin",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: Boolean(ap.sessionId),
+        launchId: ap.launchId || void 0,
+        inbox_count: ap.inbox.length
+      }));
+      return true;
+    }
+    if (!ap.sessionId) {
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_before_session",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: false,
+        launchId: ap.launchId || void 0,
+        inbox_count: ap.inbox.length
+      }));
+      return true;
+    }
     if (ap.driver.busyDeliveryMode === "gated") {
       ap.pendingNotificationCount++;
       this.recordGatedSteeringEvent(agentId, ap, "buffer", {
         reason: "busy_message",
         pendingMessages: ap.inbox.length
       });
-      return;
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "queued_busy_gated",
+        accepted: true,
+        process_present: true,
+        runtime: ap.config.runtime,
+        session_id_present: true,
+        launchId: ap.launchId || void 0,
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.pendingNotificationCount
+      }));
+      return true;
     }
     ap.pendingNotificationCount++;
     if (!ap.notificationTimer) {
@@ -4274,6 +5345,17 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.sendStdinNotification(agentId);
       }, 3e3);
     }
+    this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+      outcome: "queued_busy_notification",
+      accepted: true,
+      process_present: true,
+      runtime: ap.config.runtime,
+      session_id_present: true,
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.pendingNotificationCount,
+      notification_timer_present: Boolean(ap.notificationTimer)
+    }));
+    return true;
   }
   async resetWorkspace(agentId) {
     const agentDataDir = path11.join(this.dataDir, agentId);
@@ -4285,6 +5367,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   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 })));
@@ -4306,6 +5389,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   getIdleAgentSessionIds() {
     const result = [];
     for (const [agentId, { sessionId, launchId }] of this.idleAgentConfigs) {
+      if (this.agents.has(agentId)) continue;
       if (sessionId) result.push({ agentId, sessionId, launchId });
     }
     return result;
@@ -4357,7 +5441,17 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     return reports;
   }
-  deliverRuntimeProfileNotification(agentId, key, kind, content) {
+  deliverRuntimeProfileNotification(agentId, key, kind, content, traceparent) {
+    const span = this.tracer.startSpan("daemon.runtime_profile.control.inject", {
+      parent: parseTraceparent(traceparent),
+      surface: "daemon",
+      kind: "consumer",
+      attrs: {
+        agentId,
+        control_kind: kind,
+        key_present: Boolean(key)
+      }
+    });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const message = {
       channel_id: "system",
@@ -4368,18 +5462,65 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       sender_type: "system",
       content,
       timestamp: now,
-      message_id: `${kind === "migration" ? RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX : RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX}${key}`
+      message_id: `${kind === "migration" ? RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX : RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX}${key}`,
+      traceparent: formatTraceparent(span.context)
     };
     const ap = this.agents.get(agentId);
+    if (ap && !(ap.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) && !(ap.sessionId && ap.driver.busyDeliveryMode === "direct")) {
+      this.enqueueRuntimeProfileNotification(agentId, ap, message, kind, key);
+      span.end("ok", {
+        attrs: {
+          outcome: ap.sessionId ? "queued_busy" : "queued_before_session",
+          runtime: ap.config.runtime,
+          launchId: ap.launchId || void 0,
+          session_id_present: Boolean(ap.sessionId),
+          supports_stdin_notification: ap.driver.supportsStdinNotification,
+          busy_delivery_mode: ap.driver.busyDeliveryMode
+        }
+      });
+      return true;
+    }
     if (ap?.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) {
       ap.isIdle = false;
       this.startRuntimeTrace(agentId, ap, "runtime-profile");
-      this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
-      return;
+      const written = this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
+      span.end(written ? "ok" : "error", {
+        attrs: {
+          outcome: written ? "stdin_idle" : "stdin_failed",
+          runtime: ap.config.runtime,
+          launchId: ap.launchId || void 0,
+          session_id_present: true,
+          supports_stdin_notification: true,
+          busy_delivery_mode: ap.driver.busyDeliveryMode
+        }
+      });
+      return written;
     }
     if (ap?.sessionId && ap.driver.busyDeliveryMode === "direct") {
-      this.deliverMessagesViaStdin(agentId, ap, [message], "busy");
-      return;
+      const written = this.deliverMessagesViaStdin(agentId, ap, [message], "busy");
+      span.end(written ? "ok" : "error", {
+        attrs: {
+          outcome: written ? "stdin_busy" : "stdin_failed",
+          runtime: ap.config.runtime,
+          launchId: ap.launchId || void 0,
+          session_id_present: true,
+          supports_stdin_notification: ap.driver.supportsStdinNotification,
+          busy_delivery_mode: ap.driver.busyDeliveryMode
+        }
+      });
+      return written;
+    }
+    if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
+      const queuedStart = this.queuedAgentStarts.get(agentId);
+      this.queueRuntimeProfileNotificationDuringStart(agentId, message, kind, key);
+      span.end("ok", {
+        attrs: {
+          outcome: "queued_during_start",
+          startup_pending: true,
+          launchId: queuedStart?.launchId
+        }
+      });
+      return true;
     }
     const cached = this.idleAgentConfigs.get(agentId);
     if (cached) {
@@ -4389,9 +5530,19 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         logger.error(`[Agent ${agentId}] Failed to auto-restart for runtime profile notification`, err);
         this.idleAgentConfigs.set(agentId, cached);
       });
-      return;
+      span.end("ok", {
+        attrs: {
+          outcome: "restart_queued",
+          runtime: cached.config.runtime,
+          launchId: cached.launchId || void 0,
+          session_id_present: Boolean(cached.sessionId)
+        }
+      });
+      return true;
     }
     logger.warn(`[Agent ${agentId}] Runtime profile ${kind} ${key} has no runtime injection path yet; leaving unacked for retry`);
+    span.end("ok", { attrs: { outcome: "no_path" } });
+    return false;
   }
   ackInjectedRuntimeProfileMessages(agentId, messages, launchId) {
     for (const message of messages) {
@@ -4404,19 +5555,32 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           type: "agent:runtime_profile:migration:ack",
           agentId,
           migrationKey: notification.key,
-          launchId: launchId || void 0
+          launchId: launchId || void 0,
+          traceparent: message.traceparent
         });
       } else {
         this.sendToServer({
           type: "agent:runtime_profile:daemon_release_notice:ack",
           agentId,
           noticeKey: notification.key,
-          launchId: launchId || void 0
+          launchId: launchId || void 0,
+          traceparent: message.traceparent
         });
       }
     }
   }
   ackInjectedRuntimeProfileControl(agentId, control, launchId) {
+    const span = this.tracer.startSpan("daemon.runtime_profile.control.inject", {
+      surface: "daemon",
+      kind: "internal",
+      attrs: {
+        agentId,
+        control_kind: control.kind,
+        key_present: Boolean(control.key),
+        launchId: launchId || void 0,
+        source: "agent_config"
+      }
+    });
     const title = runtimeProfileNotificationTitle(control.kind);
     this.broadcastActivity(agentId, "working", title, [{ kind: "system", title, text: control.message }], launchId);
     if (control.kind === "migration") {
@@ -4424,24 +5588,41 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         type: "agent:runtime_profile:migration:ack",
         agentId,
         migrationKey: control.key,
-        launchId: launchId || void 0
+        launchId: launchId || void 0,
+        traceparent: formatTraceparent(span.context)
       });
     } else {
       this.sendToServer({
         type: "agent:runtime_profile:daemon_release_notice:ack",
         agentId,
         noticeKey: control.key,
-        launchId: launchId || void 0
+        launchId: launchId || void 0,
+        traceparent: formatTraceparent(span.context)
       });
     }
+    span.end("ok", { attrs: { outcome: "agent_config_ack_sent" } });
   }
   sendRuntimeProfileWireReport(report) {
+    const span = this.tracer.startSpan("daemon.runtime_profile.report.sent", {
+      surface: "daemon",
+      kind: "producer",
+      attrs: {
+        agentId: report.agentId,
+        launchId: report.launchId || void 0,
+        runtime: report.facts.runtime,
+        model_present: Boolean(report.facts.model),
+        session_ref_present: Boolean(report.facts.sessionRef),
+        workspace_ref_present: Boolean(report.facts.workspaceRef || report.facts.workspacePathRef)
+      }
+    });
     this.sendToServer({
       type: "agent:runtime_profile",
       agentId: report.agentId,
       facts: report.facts,
-      launchId: report.launchId || void 0
+      launchId: report.launchId || void 0,
+      traceparent: formatTraceparent(span.context)
     });
+    span.end("ok");
   }
   sendRuntimeProfileReportFor(agentId, config, sessionId, launchId) {
     this.sendRuntimeProfileWireReport(this.buildRuntimeProfileReport(agentId, config, sessionId, launchId));
@@ -4484,32 +5665,21 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const info = await stat2(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-    const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".md",
-      ".txt",
-      ".json",
-      ".js",
-      ".ts",
-      ".jsx",
-      ".tsx",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".log",
-      ".csv",
-      ".xml",
-      ".html",
-      ".css",
-      ".sh",
-      ".py"
-    ]);
     const ext = path11.extname(resolved).toLowerCase();
-    if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
-      return { content: null, binary: true };
+    if (WORKSPACE_TEXT_EXTENSIONS.has(ext) || ext === "") {
+      if (info.size > WORKSPACE_TEXT_FILE_MAX_BYTES) throw new Error("File too large");
+      const content = await readFile(resolved, "utf-8");
+      return { content, binary: false, size: info.size, encoding: "utf-8" };
+    }
+    const imageMimeType = WORKSPACE_IMAGE_MIME_BY_EXTENSION[ext];
+    if (imageMimeType) {
+      if (info.size > WORKSPACE_IMAGE_PREVIEW_MAX_BYTES) {
+        return { content: null, binary: true, size: info.size, mimeType: imageMimeType };
+      }
+      const content = await readFile(resolved, "base64");
+      return { content, binary: true, size: info.size, mimeType: imageMimeType, encoding: "base64" };
     }
-    if (info.size > 1048576) throw new Error("File too large");
-    const content = await readFile(resolved, "utf-8");
-    return { content, binary: false };
+    return { content: null, binary: true, size: info.size };
   }
   // Skill scanning
   // Per-runtime skill search paths (relative to home dir for global, workspace dir for workspace).
@@ -4529,7 +5699,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   async listSkills(agentId, runtimeHint) {
     const agent = this.agents.get(agentId);
     const runtime = runtimeHint || agent?.config.runtime || "claude";
-    const home = os4.homedir();
+    const home = os5.homedir();
     const workspaceDir = path11.join(this.dataDir, agentId);
     const paths = _AgentProcessManager.SKILL_PATHS[runtime] || _AgentProcessManager.SKILL_PATHS.claude;
     const globalResults = await Promise.all(
@@ -4619,13 +5789,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     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;
@@ -4637,12 +5809,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             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);
         }
@@ -4654,6 +5828,42 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
     }
   }
+  /**
+   * 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;
@@ -4719,7 +5929,30 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.clearCompactionWatchdog(ap);
     this.broadcastActivity(agentId, "working", detail, [{ kind: "compaction_finished" }]);
   }
-  startRuntimeTrace(agentId, ap, reason) {
+  messagesTraceAttrs(messages) {
+    if (!messages || messages.length === 0) return {};
+    const first = messages[0];
+    const context = this.getDeliveryTraceContext(first);
+    const notification = runtimeProfileNotificationFromMessage(first);
+    if (notification) {
+      return {
+        messages_count: messages.length,
+        message_id_present: Boolean(first.message_id),
+        deliveryId: context.deliveryId,
+        delivery_correlation_id: context.deliveryId,
+        control_kind: notification.kind,
+        key_present: Boolean(notification.key)
+      };
+    }
+    return {
+      messages_count: messages.length,
+      messageId: first.message_id,
+      message_id_present: Boolean(first.message_id),
+      deliveryId: context.deliveryId,
+      delivery_correlation_id: context.deliveryId ?? first.message_id
+    };
+  }
+  startRuntimeTrace(agentId, ap, reason, messages) {
     if (ap.runtimeTraceSpan) return ap.runtimeTraceSpan;
     const span = this.tracer.startSpan("daemon.runtime.turn", {
       surface: "daemon",
@@ -4729,10 +5962,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtime: ap.config.runtime,
         model: ap.config.model,
         reason,
-        hasSession: Boolean(ap.sessionId)
+        hasSession: Boolean(ap.sessionId),
+        ...this.messagesTraceAttrs(messages)
       }
     });
-    span.addEvent("daemon.turn.started", { reason });
+    span.addEvent("daemon.turn.started", { reason, ...this.messagesTraceAttrs(messages) });
     ap.runtimeTraceSpan = span;
     return span;
   }
@@ -4831,17 +6065,59 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (staleForMs < RUNTIME_PROGRESS_STALE_MS) return false;
     ap.runtimeProgressStaleSince = Date.now();
     const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
-    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
+    const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", diagnostic.traceAttrs);
+    this.endRuntimeTrace(ap, "error", {
+      outcome: "runtime-stalled",
       ageMs: staleForMs,
-      staleForMinutes,
-      lastActivity: ap.lastActivity
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail)
+    });
+    this.broadcastActivity(agentId, "error", diagnostic.detail);
+    return true;
+  }
+  recoverStaleProcessForQueuedMessageIfNeeded(agentId, ap) {
+    if (ap.inbox.length === 0) return false;
+    if (ap.expectedTerminationReason === "stalled_recovery") {
+      return true;
+    }
+    const directStdinRuntime = ap.driver.supportsStdinNotification && ap.driver.busyDeliveryMode === "direct";
+    const canRestartDirectStdinProcess = directStdinRuntime && Boolean(ap.sessionId) && (ap.gatedSteering.outstandingToolUses === 0 || hasDirectStdinRecoveryEvidence(ap));
+    const canRestartStalledProcess = !ap.driver.supportsStdinNotification || canRestartDirectStdinProcess;
+    if (!canRestartStalledProcess) return false;
+    const staleForMs = Date.now() - ap.lastRuntimeEventAt;
+    if (staleForMs < RUNTIME_PROGRESS_STALE_MS && !ap.runtimeProgressStaleSince) return false;
+    const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
+    ap.runtimeProgressStaleSince ??= Date.now();
+    const diagnostic = buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes);
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
+      ...diagnostic.traceAttrs,
+      pendingMessages: ap.inbox.length,
+      recovery: "terminate_for_queued_message"
     });
     this.endRuntimeTrace(ap, "error", {
       outcome: "runtime-stalled",
       ageMs: staleForMs,
-      lastActivity: ap.lastActivity
+      lastActivity: ap.lastActivity,
+      lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
+      lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      pendingMessages: ap.inbox.length,
+      recovery: "terminate_for_queued_message"
     });
-    this.broadcastActivity(agentId, "error", `Runtime stalled: no runtime events for ${staleForMinutes}m`);
+    ap.expectedTerminationReason = "stalled_recovery";
+    const runtimeLabel = ap.driver.id === "opencode" ? "OpenCode" : ap.driver.id;
+    logger.warn(
+      `[Agent ${agentId}] ${runtimeLabel} process stalled for ${staleForMinutes}m with ${ap.inbox.length} queued message(s); terminating for restart`
+    );
+    this.broadcastActivity(agentId, "working", `Restarting stalled ${runtimeLabel} runtime for queued message`);
+    try {
+      ap.process.kill("SIGTERM");
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.warn(`[Agent ${agentId}] Failed to terminate stalled ${runtimeLabel} process: ${reason}`);
+      return false;
+    }
     return true;
   }
   /** Handle a single ParsedEvent from any runtime driver */
@@ -4967,7 +6243,11 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             }
           } else {
             ap.isIdle = true;
-            this.broadcastActivity(agentId, "online", "Idle");
+            if (ap.lastRuntimeError) {
+              this.broadcastActivity(agentId, "error", ap.lastRuntimeError);
+            } else {
+              this.broadcastActivity(agentId, "online", "Idle");
+            }
           }
           this.endRuntimeTrace(ap, "ok", { outcome: "turn-completed" });
           if (ap.driver.terminateProcessOnTurnEnd) {
@@ -5006,6 +6286,15 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           }
           this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", { message: event.message });
           this.endRuntimeTrace(ap, "error", { outcome: "runtime-error", errorMessage: event.message });
+          if (ap.driver.supportsStdinNotification && classifyTerminalFailure(ap)) {
+            ap.isIdle = true;
+            ap.pendingNotificationCount = 0;
+            if (ap.notificationTimer) {
+              clearTimeout(ap.notificationTimer);
+              ap.notificationTimer = null;
+            }
+            logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
+          }
         }
         this.broadcastActivity(agentId, "error", event.message, [
           { kind: "text", text: `Error: ${event.message}` }
@@ -5052,20 +6341,73 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const encoded = ap.driver.encodeStdinMessage(notification, ap.sessionId, { mode: "busy" });
     if (encoded) {
       ap.process.stdin?.write(encoded + "\n");
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "written",
+        mode: "busy",
+        pending_notification_count: count,
+        session_id_present: true
+      });
+    } else {
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "encode_failed",
+        mode: "busy",
+        pending_notification_count: count,
+        session_id_present: true
+      }, "error");
     }
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
   deliverMessagesViaStdin(agentId, ap, messages, mode) {
     if (messages.length === 0) return true;
+    const split = this.splitRuntimeProfileControlBatch(messages);
+    if (split.deferredMessages.length > 0) {
+      ap.inbox.unshift(...split.deferredMessages);
+      ap.pendingNotificationCount += split.deferredMessages.length;
+      messages = split.nextMessages;
+      this.recordDaemonTrace("daemon.agent.runtime_profile.split_batch", {
+        agentId,
+        launchId: ap.launchId || void 0,
+        runtime: ap.config.runtime,
+        mode,
+        delivered_control_messages_count: messages.length,
+        deferred_messages_count: split.deferredMessages.length,
+        inbox_count: ap.inbox.length,
+        pending_notification_count: ap.pendingNotificationCount
+      });
+    }
+    const traceAttrs = {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      mode,
+      messages_count: messages.length,
+      session_id_present: Boolean(ap.sessionId),
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.pendingNotificationCount,
+      busy_delivery_mode: ap.driver.busyDeliveryMode,
+      supports_stdin_notification: ap.driver.supportsStdinNotification,
+      ...this.messagesTraceAttrs(messages)
+    };
     const prompt = formatRuntimeProfileControlPrompt(messages) ?? (messages.length === 1 ? `New message received:
 
 ${formatIncomingMessage(messages[0], ap.driver)}
 
-Respond as appropriate. Complete all your work before stopping.` : `New messages received:
+Respond as appropriate. Complete all your work before stopping.
+${RESPONSE_TARGET_HINT}` : `New messages received:
 
 ${messages.map((message) => formatIncomingMessage(message, ap.driver)).join("\n")}
 
-Respond as appropriate. Complete all your work before stopping.`);
+Respond as appropriate. Complete all your work before stopping.
+${RESPONSE_TARGET_HINT}`);
     const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
     if (!encoded) {
       ap.inbox.unshift(...messages);
@@ -5075,14 +6417,27 @@ Respond as appropriate. Complete all your work before stopping.`);
       logger.warn(
         `[Agent ${agentId}] Failed to encode ${mode} stdin delivery; re-queued ${messages.length === 1 ? "message" : `${messages.length} messages`}`
       );
+      this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+        ...traceAttrs,
+        outcome: "encode_failed",
+        requeued_messages_count: messages.length
+      }, "error");
       return false;
     }
     const senders = [...new Set(messages.map((message) => `@${message.sender_name}`))].join(", ");
     logger.info(
       `[Agent ${agentId}] Delivering ${mode} ${messages.length === 1 ? "message" : `${messages.length} messages`} via stdin from ${senders}`
     );
+    if (this.containsOrdinaryInboxMessage(messages)) {
+      ap.lastRuntimeError = null;
+    }
     ap.process.stdin?.write(encoded + "\n");
     this.ackInjectedRuntimeProfileMessages(agentId, messages, ap.launchId);
+    this.recordDaemonTrace("daemon.agent.stdin_delivery", {
+      ...traceAttrs,
+      outcome: "written",
+      stdin_write_attempted: true
+    });
     return true;
   }
   /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
@@ -5127,6 +6482,16 @@ var systemClock = {
   clearTimeout: (timer) => clearTimeout(timer)
 };
 var INBOUND_WATCHDOG_MS = 7e4;
+function durationMsBucket(ms) {
+  if (ms == null || !Number.isFinite(ms) || ms < 0) return "unknown";
+  if (ms === 0) return "0";
+  if (ms <= 1e3) return "1s";
+  if (ms <= 1e4) return "1s-10s";
+  if (ms <= 3e4) return "10s-30s";
+  if (ms <= 6e4) return "30s-60s";
+  if (ms <= 12e4) return "60s-120s";
+  return "120s+";
+}
 var DaemonConnection = class {
   ws = null;
   options;
@@ -5138,6 +6503,8 @@ var DaemonConnection = class {
   shouldConnect = true;
   reconnectAttempt = 0;
   lastDroppedSendLogAt = 0;
+  lastInboundAt = null;
+  lastInboundMessageKind = null;
   constructor(options) {
     this.options = options;
     this.clock = options.clock ?? systemClock;
@@ -5172,6 +6539,10 @@ var DaemonConnection = class {
       this.lastDroppedSendLogAt = now;
       logger.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
     }
+    this.trace("daemon.connection.outbound_dropped", {
+      message_type: msg.type,
+      ws_ready_state: this.ws?.readyState ?? null
+    });
   }
   get connected() {
     return this.ws?.readyState === WebSocket.OPEN;
@@ -5185,25 +6556,49 @@ var DaemonConnection = class {
     if (wsOptions?.agent) {
       logger.info("[Daemon] Using configured proxy for WebSocket connection");
     }
+    this.trace("daemon.connection.connecting", {
+      reconnect_attempt: this.reconnectAttempt,
+      server_url_present: Boolean(this.options.serverUrl),
+      proxy_present: Boolean(wsOptions?.agent)
+    });
     const ws = this.options.wsFactory ? this.options.wsFactory(wsUrl, wsOptions) : new WebSocket(wsUrl, wsOptions);
     this.ws = ws;
     ws.on("open", () => {
       if (this.ws !== ws) return;
       if (!this.shouldConnect) return;
       logger.info("[Daemon] Connected to server");
+      const priorReconnectAttempt = this.reconnectAttempt;
       this.reconnectAttempt = 0;
       this.reconnectDelay = this.options.minReconnectDelayMs ?? 1e3;
+      this.markInbound("websocket_open");
       this.resetWatchdog();
+      this.trace("daemon.connection.connected", {
+        reconnect_attempt: priorReconnectAttempt,
+        inbound_watchdog_ms: this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS
+      });
       this.options.onConnect();
     });
     ws.on("message", (data) => {
       if (this.ws !== ws) return;
-      this.resetWatchdog();
+      let messageKind = "unknown";
       try {
         const msg = JSON.parse(data.toString());
+        messageKind = msg.type;
+        this.markInbound(messageKind);
+        this.resetWatchdog();
+        this.trace("daemon.connection.inbound_received", {
+          message_type: messageKind,
+          last_inbound_age_ms_bucket: "0"
+        });
         this.options.onMessage(msg);
       } catch (err) {
+        this.markInbound("invalid_json");
+        this.resetWatchdog();
         logger.error("[Daemon] Invalid message from server", err);
+        this.trace("daemon.connection.invalid_message", {
+          error_class: err instanceof Error ? err.name : typeof err,
+          last_inbound_message_kind: "invalid_json"
+        }, "error");
       }
     });
     ws.on("close", (code, reasonBuffer) => {
@@ -5214,12 +6609,23 @@ var DaemonConnection = class {
       logger.warn(
         `[Daemon] Disconnected from server (code=${code}, reason=${JSON.stringify(reason)}, reconnecting=${this.shouldConnect})`
       );
+      this.trace("daemon.connection.disconnected", {
+        close_code: code,
+        close_reason_present: Boolean(reason),
+        reconnecting: this.shouldConnect,
+        reconnect_attempt: this.reconnectAttempt,
+        last_inbound_message_kind: this.lastInboundMessageKind,
+        last_inbound_age_ms_bucket: this.lastInboundAgeBucket()
+      }, this.shouldConnect ? "cancelled" : "ok");
       this.options.onDisconnect();
       this.scheduleReconnect();
     });
     ws.on("error", (err) => {
       if (this.ws !== ws) return;
       logger.error(`[Daemon] WebSocket error: ${err.message}`);
+      this.trace("daemon.connection.error", {
+        error_class: err.name || "Error"
+      }, "error");
     });
   }
   scheduleReconnect() {
@@ -5227,6 +6633,10 @@ var DaemonConnection = class {
     if (this.reconnectTimer) return;
     this.reconnectAttempt += 1;
     logger.info(`[Daemon] Reconnecting to server in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempt})`);
+    this.trace("daemon.connection.reconnect_scheduled", {
+      reconnect_attempt: this.reconnectAttempt,
+      delay_ms: this.reconnectDelay
+    });
     this.reconnectTimer = this.clock.setTimeout(() => {
       this.reconnectTimer = null;
       this.doConnect();
@@ -5238,6 +6648,13 @@ var DaemonConnection = class {
     const ms = this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS;
     this.watchdogTimer = this.clock.setTimeout(() => {
       logger.warn(`[Daemon] No inbound traffic for ${ms / 1e3}s \u2014 forcing reconnect`);
+      this.trace("daemon.connection.watchdog_timeout", {
+        inbound_watchdog_ms: ms,
+        last_inbound_message_kind: this.lastInboundMessageKind,
+        last_inbound_age_ms_bucket: this.lastInboundAgeBucket(),
+        ws_ready_state: this.ws?.readyState ?? null,
+        reconnecting: this.shouldConnect
+      }, "error");
       try {
         this.ws?.terminate();
       } catch {
@@ -5250,6 +6667,16 @@ var DaemonConnection = class {
       this.watchdogTimer = null;
     }
   }
+  markInbound(messageKind) {
+    this.lastInboundAt = this.clock.now();
+    this.lastInboundMessageKind = messageKind;
+  }
+  lastInboundAgeBucket() {
+    return durationMsBucket(this.lastInboundAt == null ? null : this.clock.now() - this.lastInboundAt);
+  }
+  trace(name, attrs, status = "ok") {
+    this.options.onTraceEvent?.(name, attrs, status);
+  }
 };
 
 // src/reminderCache.ts
@@ -5333,10 +6760,10 @@ var ReminderCache = class {
 
 // src/machineLock.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
-import os5 from "os";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
+import os6 from "os";
 import path12 from "path";
-var DEFAULT_MACHINE_STATE_ROOT = path12.join(os5.homedir(), ".slock", "machines");
+var DEFAULT_MACHINE_STATE_ROOT = path12.join(os6.homedir(), ".slock", "machines");
 var INCOMPLETE_LOCK_STALE_MS = 3e4;
 var DaemonMachineLockConflictError = class extends Error {
   code = "DAEMON_MACHINE_LOCK_HELD";
@@ -5359,14 +6786,14 @@ function ownerPath(lockDir) {
 }
 function readOwner(lockDir) {
   try {
-    return JSON.parse(readFileSync4(ownerPath(lockDir), "utf8"));
+    return JSON.parse(readFileSync5(ownerPath(lockDir), "utf8"));
   } catch {
     return null;
   }
 }
 function lockAgeMs(lockDir) {
   try {
-    return Date.now() - statSync2(lockDir).mtimeMs;
+    return Date.now() - statSync3(lockDir).mtimeMs;
   } catch {
     return null;
   }
@@ -5395,7 +6822,7 @@ function acquireDaemonMachineLock(options) {
       const owner = {
         pid: process.pid,
         token,
-        hostname: os5.hostname(),
+        hostname: os6.hostname(),
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         serverUrl: options.serverUrl,
         apiKeyFingerprint: fingerprint.slice(0, 16)
@@ -5437,6 +6864,418 @@ function acquireDaemonMachineLock(options) {
   throw new DaemonMachineLockConflictError(lockDir, readOwner(lockDir));
 }
 
+// src/localTraceSink.ts
+import { appendFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
+import path13 from "path";
+var DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 8;
+var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
+  "serverId",
+  "machineId",
+  "agentId",
+  "messageId",
+  "launchId",
+  "uploadId",
+  "bundleId",
+  "deliveryId",
+  "deliveryCorrelationId",
+  "delivery_correlation_id"
+]);
+var LocalRotatingTraceSink = class {
+  traceDir;
+  maxFileBytes;
+  maxFiles;
+  currentFile = null;
+  currentSize = 0;
+  sequence = 0;
+  constructor(options) {
+    this.traceDir = path13.join(options.machineDir, "traces");
+    this.maxFileBytes = Math.max(1024, Math.floor(options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES));
+    this.maxFiles = Math.max(1, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES));
+  }
+  record(span) {
+    try {
+      const line = `${JSON.stringify(toLocalTraceRecord(span))}
+`;
+      this.ensureFile(Buffer.byteLength(line));
+      appendFileSync(this.currentFile, line, { encoding: "utf8" });
+      this.currentSize += Buffer.byteLength(line);
+    } catch {
+    }
+  }
+  getCurrentFile() {
+    return this.currentFile;
+  }
+  ensureFile(nextBytes) {
+    mkdirSync6(this.traceDir, { recursive: true, mode: 448 });
+    if (!this.currentFile || this.currentSize + nextBytes > this.maxFileBytes) {
+      this.currentFile = path13.join(
+        this.traceDir,
+        `daemon-trace-${safeTimestamp(Date.now())}-${process.pid}-${String(this.sequence++).padStart(4, "0")}.jsonl`
+      );
+      writeFileSync9(this.currentFile, "", { flag: "a", mode: 384 });
+      this.currentSize = statSync4(this.currentFile).size;
+      this.pruneOldFiles();
+    }
+  }
+  pruneOldFiles() {
+    const files = readdirSync3(this.traceDir).filter((name) => name.startsWith("daemon-trace-") && name.endsWith(".jsonl")).sort();
+    const excess = files.length - this.maxFiles;
+    if (excess <= 0) return;
+    for (const file of files.slice(0, excess)) {
+      rmSync3(path13.join(this.traceDir, file), { force: true });
+    }
+  }
+};
+function safeTimestamp(timeMs) {
+  return new Date(timeMs).toISOString().replace(/[:.]/g, "-");
+}
+function toLocalTraceRecord(span) {
+  return {
+    type: "span",
+    schema_version: 1,
+    trace_id: span.context.traceId,
+    span_id: span.context.spanId,
+    parent_span_id: span.context.parentSpanId,
+    name: span.name,
+    surface: span.surface,
+    kind: span.kind,
+    status: span.status,
+    start_time: new Date(span.startTimeMs).toISOString(),
+    end_time: new Date(span.endTimeMs).toISOString(),
+    duration_ms: span.durationMs,
+    attrs: sanitizeAttrs(span.attrs),
+    events: span.events.map(sanitizeEvent)
+  };
+}
+function sanitizeEvent(event) {
+  return {
+    name: event.name,
+    time: new Date(event.timeMs).toISOString(),
+    attrs: sanitizeAttrs(event.attrs)
+  };
+}
+function sanitizeAttrs(attrs) {
+  if (!attrs) return void 0;
+  const sanitized = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (isDiagnosticIdAttr(key)) {
+      if (value === null || value === void 0 || value === "") continue;
+      sanitized[key] = sanitizeValue(value);
+      continue;
+    }
+    if (shouldDropAttr(key)) continue;
+    sanitized[key] = sanitizeValue(value);
+  }
+  return sanitized;
+}
+function sanitizeValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return { items_count: value.length };
+  }
+  if (typeof value === "object") {
+    return { object_present: true };
+  }
+  return String(value);
+}
+function shouldDropAttr(key) {
+  const normalized = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+  if (/(^|_)(api_key|auth_token|token|secret|password|cookie|credential)(_|$)/i.test(normalized)) {
+    return true;
+  }
+  if (/(^|_)(count|present|kind|mode|source|outcome|reason|class|status|bucket|ms|code|truncated)$/.test(normalized)) {
+    return false;
+  }
+  if (/(^|_)id$/.test(normalized)) {
+    return true;
+  }
+  return /(^|_)(prompt|content|text|message|body|request|response|command|argv|env|cwd|path|file|error|tool_args|tool_input|tool_output|stdout|stderr)(_|$)/i.test(normalized);
+}
+function isDiagnosticIdAttr(key) {
+  return DIAGNOSTIC_ID_ATTRS.has(key);
+}
+
+// src/traceBundleUpload.ts
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { gzipSync } from "zlib";
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import path14 from "path";
+
+// src/directUploadCapability.ts
+function joinUrl(base, path16) {
+  return `${base.replace(/\/+$/, "")}${path16}`;
+}
+function jsonHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+  };
+}
+async function requestDaemonScopeAttestation({
+  serverUrl,
+  apiKey,
+  scope,
+  metadata,
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const { response, data } = await executeJsonRequest(
+    joinUrl(serverUrl, "/internal/machine/scope-attestation"),
+    {
+      method: "POST",
+      headers: jsonHeaders(apiKey),
+      body: JSON.stringify({
+        scope,
+        ...metadata ? { metadata } : {}
+      })
+    },
+    {
+      toolName: "daemon_direct_upload.scope_attestation",
+      target: scope,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to request daemon scope attestation (${response.status})`);
+  }
+  return data;
+}
+async function createDirectUploadSession({
+  serverUrl,
+  apiKey,
+  workerUrl,
+  scope,
+  createPath = "/api/uploads",
+  body,
+  attestationMetadata,
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const capability = await requestDaemonScopeAttestation({
+    serverUrl,
+    apiKey,
+    scope,
+    metadata: attestationMetadata,
+    fetchImpl,
+    timeoutMs
+  });
+  const { response, data } = await executeJsonRequest(
+    joinUrl(workerUrl, createPath),
+    {
+      method: "POST",
+      headers: jsonHeaders(),
+      body: JSON.stringify({
+        ...body,
+        attestation: capability.attestation
+      })
+    },
+    {
+      toolName: "daemon_direct_upload.create",
+      target: capability.audience,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to create direct upload session (${response.status})`);
+  }
+  return { capability, response: data };
+}
+async function uploadWithSignedCapability({
+  serverUrl,
+  apiKey,
+  workerUrl,
+  scope,
+  createPath = "/api/uploads",
+  createBody,
+  attestationMetadata,
+  uploadBody,
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS
+}) {
+  const { capability, response: session } = await createDirectUploadSession({
+    serverUrl,
+    apiKey,
+    workerUrl,
+    scope,
+    createPath,
+    body: createBody,
+    attestationMetadata,
+    fetchImpl,
+    timeoutMs
+  });
+  const { response: uploadResponse } = await executeResponseRequest(
+    session.upload.url,
+    {
+      method: session.upload.method,
+      headers: session.upload.headers ?? {},
+      body: uploadBody
+    },
+    {
+      toolName: "daemon_direct_upload.put",
+      target: capability.audience,
+      timeoutMs,
+      fetchImpl
+    }
+  );
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload with signed capability (${uploadResponse.status})`);
+  }
+  return { capability, session, uploadResponse };
+}
+
+// src/traceBundleUpload.ts
+var TRACE_UPLOAD_SCOPE = "daemon-trace-bundle:create";
+var DEFAULT_UPLOAD_INTERVAL_MS = 5 * 60 * 1e3;
+var DEFAULT_MIN_FILE_AGE_MS = 60 * 1e3;
+var DEFAULT_MAX_FILES_PER_RUN = 4;
+var DaemonTraceBundleUploader = class {
+  options;
+  timer = null;
+  constructor(options) {
+    this.options = options;
+  }
+  start() {
+    if (this.timer) return;
+    void this.uploadOnce();
+    this.timer = setInterval(() => {
+      void this.uploadOnce();
+    }, this.options.intervalMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_INTERVAL_MS", DEFAULT_UPLOAD_INTERVAL_MS));
+  }
+  stop() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  async uploadOnce() {
+    const files = await this.findUploadCandidates();
+    let uploaded = 0;
+    for (const file of files.slice(0, this.options.maxFilesPerRun ?? DEFAULT_MAX_FILES_PER_RUN)) {
+      if (await this.uploadFile(file)) uploaded += 1;
+    }
+    return { attempted: files.length, uploaded };
+  }
+  async findUploadCandidates() {
+    const traceDir = path14.join(this.options.machineDir, "traces");
+    let names;
+    try {
+      names = await readdir3(traceDir);
+    } catch {
+      return [];
+    }
+    const now = Date.now();
+    const minAgeMs = this.options.minFileAgeMs ?? readPositiveIntegerEnv2("SLOCK_DAEMON_TRACE_UPLOAD_MIN_FILE_AGE_MS", DEFAULT_MIN_FILE_AGE_MS);
+    const currentFile = this.options.currentFileProvider?.();
+    const candidates = [];
+    for (const name of names.filter((entry) => entry.startsWith("daemon-trace-") && entry.endsWith(".jsonl")).sort()) {
+      const file = path14.join(traceDir, name);
+      if (currentFile && path14.resolve(file) === path14.resolve(currentFile)) continue;
+      if (await this.isUploaded(file)) continue;
+      try {
+        const info = await stat3(file);
+        if (!info.isFile() || info.size <= 0) continue;
+        if (now - info.mtimeMs < minAgeMs) continue;
+        candidates.push(file);
+      } catch {
+      }
+    }
+    return candidates;
+  }
+  async uploadFile(file) {
+    const span = this.options.tracer?.startSpan("daemon.bundle.upload", {
+      surface: "daemon",
+      kind: "producer",
+      attrs: {
+        file_present: true,
+        worker_url_present: Boolean(this.options.workerUrl)
+      }
+    });
+    try {
+      const raw = await readFile2(file);
+      if (raw.byteLength === 0) {
+        span?.end("cancelled", { attrs: { outcome: "empty" } });
+        return false;
+      }
+      const gzipped = gzipSync(raw);
+      const bundleSha256 = sha256Hex(gzipped);
+      const bundleId = randomUUID3();
+      await uploadWithSignedCapability({
+        serverUrl: this.options.serverUrl,
+        apiKey: this.options.apiKey,
+        workerUrl: this.options.workerUrl,
+        scope: TRACE_UPLOAD_SCOPE,
+        createPath: "/api/trace-bundles",
+        attestationMetadata: {
+          bundleId,
+          bundleSha256,
+          bundleSizeBytes: gzipped.byteLength
+        },
+        createBody: {
+          bundleSha256,
+          bundleSizeBytes: gzipped.byteLength
+        },
+        uploadBody: new Blob([new Uint8Array(gzipped)], { type: "application/x-ndjson" }),
+        fetchImpl: this.options.fetchImpl
+      });
+      await this.markUploaded(file, {
+        bundleId,
+        bundleSha256,
+        bundleSizeBytes: gzipped.byteLength
+      });
+      span?.end("ok", {
+        attrs: {
+          bundleId,
+          bundle_size_bytes: gzipped.byteLength
+        }
+      });
+      return true;
+    } catch (err) {
+      span?.end("error", {
+        attrs: {
+          error_class: err instanceof Error ? err.name : "Error",
+          error_message_present: err instanceof Error && Boolean(err.message)
+        }
+      });
+      return false;
+    }
+  }
+  uploadStatePath(file) {
+    const stateDir = path14.join(this.options.machineDir, "trace-uploads");
+    return path14.join(stateDir, `${path14.basename(file)}.uploaded.json`);
+  }
+  async isUploaded(file) {
+    try {
+      await stat3(this.uploadStatePath(file));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async markUploaded(file, metadata) {
+    const stateFile = this.uploadStatePath(file);
+    await mkdir2(path14.dirname(stateFile), { recursive: true, mode: 448 });
+    await writeFile2(stateFile, `${JSON.stringify({
+      file: path14.basename(file),
+      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...metadata
+    }, null, 2)}
+`, { mode: 384 });
+  }
+};
+function sha256Hex(body) {
+  return createHash2("sha256").update(body).digest("hex");
+}
+function readPositiveIntegerEnv2(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 // src/core.ts
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
@@ -5458,59 +7297,110 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path13.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path13.resolve(dirname, "chat-bridge.js");
+  const dirname = path15.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path15.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path13.resolve(dirname, "chat-bridge.ts");
+    return path15.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path13.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path13.resolve(thisDir, "cli", "index.js");
+  const thisDir = path15.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path15.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path13.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path15.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
 }
-function detectRuntimes() {
+function detectRuntimes(tracer = noopTracer) {
   const ids = [];
   const versions = {};
+  const span = tracer.startSpan("daemon.runtime.detect", {
+    surface: "daemon",
+    kind: "internal",
+    attrs: {
+      known_runtime_count: RUNTIMES.length
+    }
+  });
   for (const runtime of RUNTIMES) {
     const driver = getDriver(runtime.id);
+    let probeErrorPresent = false;
     try {
       if (driver.probe) {
         const probe = driver.probe();
         if (!probe.available) {
           if (probe.version) versions[runtime.id] = probe.version;
+          span.addEvent("daemon.runtime.detect.checked", {
+            runtime: runtime.id,
+            outcome: "unavailable",
+            version_present: Boolean(probe.version),
+            binary_path_present: false
+          });
           continue;
         }
         ids.push(runtime.id);
         if (probe.version) versions[runtime.id] = probe.version;
+        span.addEvent("daemon.runtime.detect.checked", {
+          runtime: runtime.id,
+          outcome: "available",
+          version_present: Boolean(probe.version),
+          binary_path_present: false
+        });
         continue;
       }
     } catch {
+      probeErrorPresent = true;
     }
     const detectionBinaries = [runtime.binary];
+    let detectedByPath = false;
     for (const binary of detectionBinaries) {
       const resolved = resolveCommandOnPath(binary);
       if (!resolved) continue;
       ids.push(runtime.id);
+      detectedByPath = true;
       const version = readCommandVersion(binary);
       if (version) {
         versions[runtime.id] = version;
       }
+      span.addEvent("daemon.runtime.detect.checked", {
+        runtime: runtime.id,
+        outcome: "available",
+        version_present: Boolean(version),
+        binary_path_present: true,
+        probe_error_present: probeErrorPresent
+      });
       break;
     }
+    if (!detectedByPath) {
+      span.addEvent("daemon.runtime.detect.checked", {
+        runtime: runtime.id,
+        outcome: "unavailable",
+        version_present: false,
+        binary_path_present: false,
+        probe_error_present: probeErrorPresent
+      });
+    }
   }
+  span.end("ok", {
+    attrs: {
+      detected_runtime_count: ids.length
+    }
+  });
   return { ids, versions };
 }
+function readPositiveIntegerEnv3(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 formatChannelTarget(msg) {
   return msg.message.channel_type === "dm" ? `dm:@${msg.message.channel_name}` : `#${msg.message.channel_name}`;
 }
@@ -5534,6 +7424,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":
@@ -5558,14 +7450,18 @@ var DaemonCore = class {
   connection;
   reminderCache;
   tracer;
+  injectedTracer;
   machineLock = null;
+  localTraceSink = null;
+  traceBundleUploader = null;
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
     this.chatBridgePath = options.chatBridgePath ?? resolveChatBridgePath();
     this.slockCliPath = options.slockCliPath ?? resolveSlockCliPath();
-    this.runtimeDetector = options.runtimeDetector ?? detectRuntimes;
+    this.injectedTracer = Boolean(options.tracer);
     this.tracer = options.tracer ?? noopTracer;
+    this.runtimeDetector = options.runtimeDetector ?? (() => detectRuntimes(this.tracer));
     this.reminderCache = new ReminderCache({
       clock: options.reminderClock,
       onFire: (job) => this.onReminderFire(job)
@@ -5575,7 +7471,8 @@ var DaemonCore = class {
       dataDir: options.dataDir,
       serverUrl: options.serverUrl,
       defaultAgentEnvVarsProvider: options.defaultAgentEnvVarsProvider,
-      slockCliPath: this.slockCliPath
+      slockCliPath: this.slockCliPath,
+      tracer: this.tracer
     };
     this.agentManager = options.agentManagerFactory ? options.agentManagerFactory(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager(this.chatBridgePath, (msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
@@ -5585,15 +7482,48 @@ var DaemonCore = class {
       ...options.connectionOptions,
       onMessage: (msg) => this.handleMessage(msg),
       onConnect: () => this.handleConnect(),
-      onDisconnect: () => this.handleDisconnect()
+      onDisconnect: () => this.handleDisconnect(),
+      onTraceEvent: (name, attrs, status) => this.recordDaemonTrace(name, attrs, status)
     });
     this.connection = connection;
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path13.join(path13.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path15.join(path15.dirname(this.options.dataDir), "machines");
     return DEFAULT_MACHINE_STATE_ROOT;
   }
+  shouldEnableLocalTrace() {
+    if (this.injectedTracer) return false;
+    if (!this.options.localTrace) return false;
+    return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
+  }
+  installLocalTraceSink(machineDir) {
+    if (!this.shouldEnableLocalTrace()) return;
+    this.localTraceSink = new LocalRotatingTraceSink({
+      machineDir,
+      maxFileBytes: this.options.localTraceMaxFileBytes ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILE_BYTES", 5 * 1024 * 1024),
+      maxFiles: this.options.localTraceMaxFiles ?? readPositiveIntegerEnv3("SLOCK_DAEMON_TRACE_MAX_FILES", 8)
+    });
+    this.tracer = new BasicTracer({
+      sink: this.localTraceSink
+    });
+    this.agentManager.setTracer(this.tracer);
+  }
+  installTraceBundleUploader(machineDir) {
+    if (!this.shouldEnableLocalTrace()) return;
+    if (this.traceBundleUploader) return;
+    const workerUrl = process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL;
+    if (!workerUrl) return;
+    this.traceBundleUploader = new DaemonTraceBundleUploader({
+      machineDir,
+      serverUrl: this.options.serverUrl,
+      apiKey: this.options.apiKey,
+      workerUrl,
+      tracer: this.tracer,
+      currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null
+    });
+    this.traceBundleUploader.start();
+  }
   start() {
     logger.info("[Slock Daemon] Starting...");
     if (!this.machineLock) {
@@ -5603,10 +7533,24 @@ var DaemonCore = class {
         rootDir: this.resolveMachineStateRoot()
       });
       logger.info(`[Slock Daemon] Acquired machine lock: ${this.machineLock.lockDir}`);
+      this.installLocalTraceSink(this.machineLock.machineDir);
+      this.installTraceBundleUploader(this.machineLock.machineDir);
+      const span = this.tracer.startSpan("daemon.lifecycle.start", {
+        surface: "daemon",
+        kind: "internal",
+        attrs: {
+          machine_dir_present: true,
+          local_trace_enabled: this.shouldEnableLocalTrace()
+        }
+      });
+      span.addEvent("daemon.machine_lock.acquired", { machine_dir_present: true });
+      span.end("ok");
     }
     try {
       this.connection.connect();
     } catch (err) {
+      this.traceBundleUploader?.stop();
+      this.traceBundleUploader = null;
       this.machineLock.release();
       this.machineLock = null;
       throw err;
@@ -5614,13 +7558,24 @@ var DaemonCore = class {
   }
   async stop() {
     logger.info("[Slock Daemon] Shutting down...");
+    const span = this.tracer.startSpan("daemon.lifecycle.stop", {
+      surface: "daemon",
+      kind: "internal",
+      attrs: { machine_lock_present: Boolean(this.machineLock) }
+    });
     this.reminderCache.clear();
+    this.traceBundleUploader?.stop();
+    this.traceBundleUploader = null;
     try {
       await this.agentManager.stopAll();
+      span.addEvent("daemon.agents.stopped");
     } finally {
       this.connection.disconnect();
+      span.addEvent("daemon.connection.disconnect_requested");
       this.machineLock?.release();
+      if (this.machineLock) span.addEvent("daemon.machine_lock.released");
       this.machineLock = null;
+      span.end("ok");
     }
   }
   get connected() {
@@ -5629,6 +7584,14 @@ var DaemonCore = class {
   getRunningAgentIds() {
     return this.agentManager.getRunningAgentIds();
   }
+  recordDaemonTrace(name, attrs, status = "ok") {
+    const span = this.tracer.startSpan(name, {
+      surface: "daemon",
+      kind: "internal",
+      attrs
+    });
+    span.end(status);
+  }
   handleMessage(msg) {
     const summary = summarizeIncomingMessage(msg);
     logger.info(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
@@ -5658,50 +7621,88 @@ var DaemonCore = class {
           kind: "consumer",
           attrs: {
             agentId: msg.agentId,
+            deliveryId: msg.deliveryId,
+            delivery_correlation_id: msg.deliveryId ?? msg.message.message_id,
+            messageId: msg.message.message_id,
+            message_id_present: Boolean(msg.message.message_id),
             seq: msg.seq
           }
         });
         logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
         try {
-          span.addEvent("daemon.receive", { seq: msg.seq });
-          this.agentManager.deliverMessage(msg.agentId, msg.message);
-          span.addEvent("daemon.deliver_to_agent_manager");
+          span.addEvent("daemon.receive", { seq: msg.seq, deliveryId: msg.deliveryId });
+          const accepted = this.agentManager.deliverMessage(msg.agentId, msg.message, { deliveryId: msg.deliveryId });
+          span.addEvent("daemon.deliver_to_agent_manager", { accepted });
+          if (!accepted) {
+            span.end("ok", { attrs: { outcome: "not-accepted" } });
+            break;
+          }
           const ackSeq = msg.seq > 0 ? msg.seq : msg.message.seq ?? 0;
           span.addEvent("daemon.ack.sent", { seq: ackSeq });
           this.connection.send({
             type: "agent:deliver:ack",
             agentId: msg.agentId,
             seq: ackSeq,
-            traceparent: formatTraceparent(span.context)
+            traceparent: formatTraceparent(span.context),
+            deliveryId: msg.deliveryId
           });
-          span.end("ok", { attrs: { outcome: "ack-sent", ackSeq } });
+          span.end("ok", { attrs: { outcome: "ack-sent", ackSeq, deliveryId: msg.deliveryId } });
         } catch (err) {
-          span.end("error", { attrs: { errorMessage: err instanceof Error ? err.message : String(err) } });
+          span.end("error", { attrs: { error_class: err instanceof Error ? err.name : typeof err } });
           throw err;
         }
         break;
       }
-      case "agent:runtime_profile:migration":
+      case "agent:runtime_profile:migration": {
+        const span = this.tracer.startSpan("daemon.runtime_profile.control.received", {
+          parent: parseTraceparent(msg.traceparent),
+          surface: "daemon",
+          kind: "consumer",
+          attrs: {
+            agentId: msg.agentId,
+            control_kind: "migration",
+            key_present: Boolean(msg.migrationKey),
+            launchId: msg.launchId || void 0
+          }
+        });
         logger.info(`[Agent ${msg.agentId}] Runtime profile migration received (${msg.migrationKey})`);
-        this.agentManager.deliverRuntimeProfileNotification(msg.agentId, msg.migrationKey, "migration", msg.message);
+        const accepted = this.agentManager.deliverRuntimeProfileNotification(msg.agentId, msg.migrationKey, "migration", msg.message, formatTraceparent(span.context));
+        span.end("ok", { attrs: { outcome: accepted ? "accepted" : "no_injection_path" } });
         break;
-      case "agent:runtime_profile:daemon_release_notice":
+      }
+      case "agent:runtime_profile:daemon_release_notice": {
+        const span = this.tracer.startSpan("daemon.runtime_profile.control.received", {
+          parent: parseTraceparent(msg.traceparent),
+          surface: "daemon",
+          kind: "consumer",
+          attrs: {
+            agentId: msg.agentId,
+            control_kind: "daemon_release_notice",
+            key_present: Boolean(msg.noticeKey),
+            launchId: msg.launchId || void 0
+          }
+        });
         logger.info(`[Agent ${msg.agentId}] Runtime profile daemon release notice received (${msg.noticeKey})`);
-        this.agentManager.deliverRuntimeProfileNotification(msg.agentId, msg.noticeKey, "daemon_release_notice", msg.message);
+        const accepted = this.agentManager.deliverRuntimeProfileNotification(msg.agentId, msg.noticeKey, "daemon_release_notice", msg.message, formatTraceparent(span.context));
+        span.end("ok", { attrs: { outcome: accepted ? "accepted" : "no_injection_path" } });
         break;
+      }
       case "agent:workspace:list":
         this.agentManager.getFileTree(msg.agentId, msg.dirPath).then((files) => {
           this.connection.send({ type: "agent:workspace:file_tree", agentId: msg.agentId, files, dirPath: msg.dirPath });
         });
         break;
       case "agent:workspace:read":
-        this.agentManager.readFile(msg.agentId, msg.path).then(({ content, binary }) => {
+        this.agentManager.readFile(msg.agentId, msg.path).then(({ content, binary, size, mimeType, encoding }) => {
           this.connection.send({
             type: "agent:workspace:file_content",
             agentId: msg.agentId,
             requestId: msg.requestId,
             content,
-            binary
+            binary,
+            size,
+            mimeType,
+            encoding
           });
         }).catch(() => {
           this.connection.send({
@@ -5709,7 +7710,8 @@ var DaemonCore = class {
             agentId: msg.agentId,
             requestId: msg.requestId,
             content: null,
-            binary: false
+            binary: false,
+            size: 0
           });
         });
         break;
@@ -5721,6 +7723,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) => {
@@ -5738,7 +7743,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" });
           }
@@ -5777,35 +7787,59 @@ var DaemonCore = class {
     const { ids: runtimes, versions: runtimeVersions } = this.runtimeDetector();
     const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
     logger.info(`[Daemon] Detected runtimes: ${runtimeInfo.join(", ") || "none"}`);
+    const runningAgentIds = this.agentManager.getRunningAgentIds();
+    const idleAgentSessions = this.agentManager.getIdleAgentSessionIds();
+    const runtimeProfileReports = this.agentManager.getAgentRuntimeProfileReports();
     this.connection.send({
       type: "ready",
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
-      runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os6.hostname(),
-      os: this.options.osDescription ?? `${os6.platform()} ${os6.arch()}`,
+      runningAgents: runningAgentIds,
+      hostname: this.options.hostname ?? os7.hostname(),
+      os: this.options.osDescription ?? `${os7.platform()} ${os7.arch()}`,
       daemonVersion: this.daemonVersion
     });
-    for (const agentId of this.agentManager.getRunningAgentIds()) {
+    this.recordDaemonTrace("daemon.ready.sent", {
+      runtimes_count: runtimes.length,
+      running_agents_count: runningAgentIds.length,
+      idle_agents_count: idleAgentSessions.length,
+      runtime_profile_reports_count: runtimeProfileReports.length,
+      daemon_version_present: Boolean(this.daemonVersion)
+    });
+    for (const agentId of runningAgentIds) {
       const sessionId = this.agentManager.getAgentSessionId(agentId);
       const launchId = this.agentManager.getAgentLaunchId(agentId);
       if (sessionId) {
         this.connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
       }
     }
-    for (const { agentId, sessionId, launchId } of this.agentManager.getIdleAgentSessionIds()) {
+    for (const { agentId, sessionId, launchId } of idleAgentSessions) {
       this.connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
     }
-    for (const report of this.agentManager.getAgentRuntimeProfileReports()) {
+    for (const report of runtimeProfileReports) {
+      const span = this.tracer.startSpan("daemon.runtime_profile.report.sent", {
+        surface: "daemon",
+        kind: "producer",
+        attrs: {
+          agentId: report.agentId,
+          launchId: report.launchId || void 0,
+          runtime: report.facts.runtime,
+          model_present: Boolean(report.facts.model),
+          session_ref_present: Boolean(report.facts.sessionRef),
+          workspace_ref_present: Boolean(report.facts.workspaceRef || report.facts.workspacePathRef)
+        }
+      });
       this.connection.send({
         type: "agent:runtime_profile",
         agentId: report.agentId,
         facts: report.facts,
-        launchId: report.launchId || void 0
+        launchId: report.launchId || void 0,
+        traceparent: formatTraceparent(span.context)
       });
+      span.end("ok");
     }
-    const agentsForSnapshot = new Set(this.agentManager.getRunningAgentIds());
-    for (const { agentId } of this.agentManager.getIdleAgentSessionIds()) {
+    const agentsForSnapshot = new Set(runningAgentIds);
+    for (const { agentId } of idleAgentSessions) {
       agentsForSnapshot.add(agentId);
     }
     for (const agentId of agentsForSnapshot) {
@@ -5815,6 +7849,10 @@ var DaemonCore = class {
   }
   handleDisconnect() {
     logger.warn("[Daemon] Lost connection \u2014 agents continue running locally");
+    this.recordDaemonTrace("daemon.connection.local_disconnect_observed", {
+      running_agents_count: this.agentManager.getRunningAgentIds().length,
+      idle_agents_count: this.agentManager.getIdleAgentSessionIds().length
+    }, "cancelled");
     this.options.lifecycleHooks?.onDisconnect?.();
   }
 };