@slock-ai/daemon 0.43.0 → 0.46.0

package/dist/{chunk-37O7EHYE.js → chunk-Q4XUZB34.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
 
@@ -1301,6 +1363,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 +1389,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 +1518,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 +1705,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 +1720,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 +1767,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 +1795,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 +2194,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 +2208,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 +2216,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 +2230,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 +2380,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 +2514,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,23 +2670,56 @@ 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 { 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";
@@ -2447,6 +2735,22 @@ function parseToolArguments(raw) {
 }
 var KimiDriver = class {
   id = "kimi";
+  lifecycle = {
+    kind: "persistent",
+    stdin: "direct",
+    inFlightWake: "steer"
+  };
+  communication = {
+    chat: "mcp_chat_bridge",
+    runtimeControl: "mcp_runtime_actions"
+  };
+  session = {
+    recovery: "resume_or_fresh"
+  };
+  model = {
+    detectedModelsVerifiedAs: "launchable",
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+  };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
   busyDeliveryMode = "direct";
@@ -2631,11 +2935,11 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os2.homedir()) {
+function detectKimiModels(home = os3.homedir()) {
   const configPath = path8.join(home, ".kimi", "config.toml");
   let raw;
   try {
-    raw = readFileSync2(configPath, "utf8");
+    raw = readFileSync3(configPath, "utf8");
   } catch {
     return null;
   }
@@ -2647,7 +2951,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 +2962,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}_`;
@@ -2700,10 +3004,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 +3053,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 +3078,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 +3105,42 @@ 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: line,
+      verified: "launchable"
+    });
   }
   return models.length > 0 ? { models } : null;
 }
+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 +3159,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 +3416,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 +3488,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 +3497,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 +3543,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 +3643,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 +4158,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 = [
@@ -3783,6 +4206,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 +4227,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,59 +4235,286 @@ 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)
+      )
+    );
+  }
+  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;
     }
-    this.agentsStarting.add(agentId);
-    try {
-      const driver = this.driverResolver(config.runtime || "claude");
-      const agentDataDir = path11.join(this.dataDir, agentId);
-      await mkdir(agentDataDir, { recursive: true });
-      const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
-      try {
-        await access(memoryMdPath);
-      } catch {
-        const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
-        await writeFile(memoryMdPath, initialMemoryMd);
-      }
-      const notesDir = path11.join(agentDataDir, "notes");
-      await mkdir(notesDir, { recursive: true });
-      if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
-        const seedFiles = buildOnboardingSeedFiles();
-        for (const { relativePath, content } of seedFiles) {
-          const fullPath = path11.join(agentDataDir, relativePath);
-          try {
-            await access(fullPath);
-          } catch {
-            await mkdir(path11.dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, content);
-          }
-        }
-      }
-      const isResume = !!runtimeConfig.sessionId;
-      const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
-      let prompt;
-      if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
-        prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
-      } else if (isResume && resumePrompt) {
-        prompt = resumePrompt;
-        prompt += getBusyDeliveryNote(driver);
-      } else if (wakeMessage) {
-        const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
-        const channelLabel = formatChannelLabel(wakeMessage);
-        prompt = runtimeProfileControlPrompt ?? `New message received:
+    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);
+      await mkdir(agentDataDir, { recursive: true });
+      const runtimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
+      const memoryMdPath = path11.join(agentDataDir, "MEMORY.md");
+      try {
+        await access(memoryMdPath);
+      } catch {
+        const initialMemoryMd = buildInitialMemoryMd(runtimeConfig);
+        await writeFile(memoryMdPath, initialMemoryMd);
+      }
+      const notesDir = path11.join(agentDataDir, "notes");
+      await mkdir(notesDir, { recursive: true });
+      if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
+        const seedFiles = buildOnboardingSeedFiles();
+        for (const { relativePath, content } of seedFiles) {
+          const fullPath = path11.join(agentDataDir, relativePath);
+          try {
+            await access(fullPath);
+          } catch {
+            await mkdir(path11.dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, content);
+          }
+        }
+      }
+      const isResume = !!runtimeConfig.sessionId;
+      const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
+      let prompt;
+      if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
+        prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
+      } else if (isResume && resumePrompt) {
+        prompt = resumePrompt;
+        prompt += getBusyDeliveryNote(driver);
+      } else if (wakeMessage) {
+        const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
+        const channelLabel = formatChannelLabel(wakeMessage);
+        prompt = runtimeProfileControlPrompt ?? `New message received:
 
 ${formatIncomingMessage(wakeMessage, driver)}`;
         if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
@@ -3877,6 +4536,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 +4569,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 +4591,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 +4618,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtimeTraceSpan: null,
         lastActivity: "",
         lastActivityDetail: "",
+        activityClientSeq: 0,
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
@@ -3959,7 +4631,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 +4675,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 +4690,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 +4765,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 +4871,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 +4979,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 +5135,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 +5157,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 +5179,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 +5231,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 +5252,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 +5320,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 +5345,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 +5378,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 +5455,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 +5489,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 +5579,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 +5599,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 +5618,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 +5719,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 +5752,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;
   }
@@ -4844,6 +5868,48 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.broadcastActivity(agentId, "error", `Runtime stalled: no runtime events for ${staleForMinutes}m`);
     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();
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
+      ageMs: staleForMs,
+      staleForMinutes,
+      lastActivity: ap.lastActivity,
+      pendingMessages: ap.inbox.length,
+      recovery: "terminate_for_queued_message"
+    });
+    this.endRuntimeTrace(ap, "error", {
+      outcome: "runtime-stalled",
+      ageMs: staleForMs,
+      lastActivity: ap.lastActivity,
+      pendingMessages: ap.inbox.length,
+      recovery: "terminate_for_queued_message"
+    });
+    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 */
   handleParsedEvent(agentId, event, driver) {
     const ap = this.agents.get(agentId);
@@ -4967,7 +6033,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 +6076,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 +6131,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 +6207,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 +6272,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 +6293,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 +6329,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 +6346,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 +6399,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 +6423,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 +6438,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 +6457,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 +6550,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 +6576,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 +6612,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 +6654,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 +7087,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 +7214,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 +7240,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 +7261,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 +7272,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 +7323,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 +7348,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 +7374,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 +7411,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 +7500,8 @@ var DaemonCore = class {
             agentId: msg.agentId,
             requestId: msg.requestId,
             content: null,
-            binary: false
+            binary: false,
+            size: 0
           });
         });
         break;
@@ -5721,6 +7513,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 +7533,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 +7577,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 +7639,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?.();
   }
 };