@slock-ai/daemon 0.40.2 → 0.41.1-alpha.0

package/dist/{chunk-PB75DRIF.js → chunk-JAB3HALZ.js}

@@ -4,12 +4,115 @@ import {
 } from "./chunk-JG7ONJZ6.js";
 
 // src/core.ts
-import path11 from "path";
-import os4 from "os";
+import path12 from "path";
+import os5 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
 
+// ../shared/src/tracing/index.ts
+var DEFAULT_TRACE_FLAGS = "00";
+var TRACEPARENT_VERSION = "00";
+var TRACE_ID_HEX_LENGTH = 32;
+var SPAN_ID_HEX_LENGTH = 16;
+var TRACE_FLAGS_HEX_LENGTH = 2;
+var TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
+var SPAN_ID_PATTERN = /^[0-9a-f]{16}$/;
+var TRACE_FLAGS_PATTERN = /^[0-9a-f]{2}$/;
+var TRACEPARENT_PATTERN = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+function isTraceId(value) {
+  return TRACE_ID_PATTERN.test(value) && value !== "0".repeat(TRACE_ID_HEX_LENGTH);
+}
+function isSpanId(value) {
+  return SPAN_ID_PATTERN.test(value) && value !== "0".repeat(SPAN_ID_HEX_LENGTH);
+}
+function isTraceFlags(value) {
+  return TRACE_FLAGS_PATTERN.test(value);
+}
+function assertTraceContext(context) {
+  if (!isTraceId(context.traceId)) {
+    throw new Error(`Invalid traceId: expected ${TRACE_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isSpanId(context.spanId)) {
+    throw new Error(`Invalid spanId: expected ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (context.parentSpanId !== null && !isSpanId(context.parentSpanId)) {
+    throw new Error(`Invalid parentSpanId: expected null or ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isTraceFlags(context.traceFlags)) {
+    throw new Error(`Invalid traceFlags: expected ${TRACE_FLAGS_HEX_LENGTH} lowercase hex chars`);
+  }
+}
+function formatTraceparent(context) {
+  assertTraceContext(context);
+  return `${TRACEPARENT_VERSION}-${context.traceId}-${context.spanId}-${context.traceFlags}`;
+}
+function parseTraceparent(value) {
+  if (!value) return null;
+  const match = TRACEPARENT_PATTERN.exec(value);
+  if (!match) return null;
+  const [, version, traceId, spanId, traceFlags] = match;
+  if (version !== TRACEPARENT_VERSION) return null;
+  if (!isTraceId(traceId) || !isSpanId(spanId) || !isTraceFlags(traceFlags)) return null;
+  return {
+    traceId,
+    spanId,
+    parentSpanId: null,
+    traceFlags
+  };
+}
+function createTraceContext({
+  parent = null,
+  traceId,
+  spanId,
+  traceFlags,
+  traceIdGenerator = generateTraceId,
+  spanIdGenerator = generateSpanId
+} = {}) {
+  const context = {
+    traceId: traceId ?? parent?.traceId ?? traceIdGenerator(),
+    spanId: spanId ?? spanIdGenerator(),
+    parentSpanId: parent?.spanId ?? null,
+    traceFlags: traceFlags ?? parent?.traceFlags ?? DEFAULT_TRACE_FLAGS
+  };
+  assertTraceContext(context);
+  return context;
+}
+var NoopTracer = class {
+  startSpan(_name, options) {
+    return new NoopActiveSpan(createTraceContext({ parent: options.parent ?? null }));
+  }
+};
+var NoopActiveSpan = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  addEvent() {
+  }
+  end() {
+  }
+};
+var noopTracer = new NoopTracer();
+function generateTraceId() {
+  return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
+}
+function generateSpanId() {
+  return randomNonZeroHex(SPAN_ID_HEX_LENGTH);
+}
+function randomNonZeroHex(length) {
+  let value = randomHex(length);
+  while (value === "0".repeat(length)) {
+    value = randomHex(length);
+  }
+  return value;
+}
+function randomHex(length) {
+  const bytes = new Uint8Array(length / 2);
+  globalThis.crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
 // ../shared/src/toolDisplay.ts
 var TOOL_DISPLAY_METADATA = {
   send_message: { logLabel: "Sending message", activityLabel: "Sending message\u2026", summaryKind: "message_target" },
@@ -272,6 +375,10 @@ function resolveSlockCliInvocation(toolName, input) {
       return { toolName: "search_messages", input: { query: readOptionValue(rest, "--query") } };
     case "server info":
       return { toolName: "list_server", input: {} };
+    case "channel members":
+      return { toolName: "list_channel_members", input: { channel: rest[0] } };
+    case "channel leave":
+      return { toolName: "leave_channel", input: { target: readOptionValue(rest, "--target") } };
     case "task list":
       return { toolName: "list_tasks", input: { channel: readOptionValue(rest, "--channel") } };
     case "task create":
@@ -481,6 +588,7 @@ import os3 from "os";
 
 // src/drivers/claude.ts
 import { spawn } from "child_process";
+import { writeFileSync as writeFileSync2 } from "fs";
 import path3 from "path";
 
 // src/drivers/cliTransport.ts
@@ -533,20 +641,23 @@ Use the \`slock\` CLI for chat / task / attachment operations. The daemon inject
 1. **\`slock message check\`** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
 2. **\`slock message send\`** \u2014 Send a message to a channel or DM.
 3. **\`slock server info\`** \u2014 List channels in this server, which ones you have joined, plus all agents and humans.
-4. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
-5. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
-6. **\`slock task list\`** \u2014 View a channel's task board.
-7. **\`slock task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-8. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
-9. **\`slock task unclaim\`** \u2014 Release your claim on a task.
-10. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
-11. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to \`slock message send\`.
-12. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
-13. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-14. **\`slock reminder list\`** \u2014 List your reminders.
-15. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
+4. **\`slock channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
+5. **\`slock thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
+6. **\`slock message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
+7. **\`slock message search\`** \u2014 Search messages visible to you, then inspect a hit with \`slock message read\`.
+8. **\`slock task list\`** \u2014 View a channel's task board.
+9. **\`slock task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+10. **\`slock task claim\`** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
+11. **\`slock task unclaim\`** \u2014 Release your claim on a task.
+12. **\`slock task update\`** \u2014 Change a task's status (e.g. to in_review or done).
+13. **\`slock attachment upload\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to \`slock message send\`.
+14. **\`slock attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
+15. **\`slock reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
+16. **\`slock reminder list\`** \u2014 List your reminders.
+17. **\`slock reminder cancel\`** \u2014 Cancel one of your reminders by ID.
 
 When a user asks you to remind them later, at a specific time, or on a recurring schedule, prefer the reminder commands instead of relying on MEMORY or manual follow-up.
+Do not use runtime-native wake or cron tools such as ScheduleWakeup or CronCreate for user-visible reminders; use \`slock reminder schedule\` so reminders stay anchored, observable, and cancelable in Slock.
 For agent-created reminders, first resolve the anchor message from the current conversation and pass its \`msgId\` explicitly. If you cannot resolve a message id, do not create the reminder.
 
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints JSON to stderr:
@@ -562,15 +673,16 @@ You have MCP tools from the "chat" server. Use ONLY these for communication:
 1. **${checkCmd}** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
 2. **${sendCmd}** \u2014 Send a message to a channel or DM.
 3. **${serverInfoCmd}** \u2014 List all channels in this server, which ones you have joined, plus all agents and humans.
-4. **${readCmd}** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
-5. **\`${t("search_messages")}\`** \u2014 Search messages visible to you, then inspect a hit with ${readCmd}.
-6. **\`${t("list_tasks")}\`** \u2014 View a channel's task board.
-7. **${taskCreateCmd}** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-8. **${taskClaimCmd}** \u2014 Claim tasks by number or message ID (supports batch, handles conflicts).
-9. **\`${t("unclaim_task")}\`** \u2014 Release your claim on a task.
-10. **${taskUpdateCmd}** \u2014 Change a task's status (e.g. to in_review or done).
-11. **\`${t("upload_file")}\`** \u2014 Upload a file to attach to a message. Returns an attachment ID to pass to ${sendCmd}.
-12. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.`;
+4. **\`${t("leave_channel")}\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
+5. **${readCmd}** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
+6. **\`${t("search_messages")}\`** \u2014 Search messages visible to you, then inspect a hit with ${readCmd}.
+7. **\`${t("list_tasks")}\`** \u2014 View a channel's task board.
+8. **${taskCreateCmd}** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+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}.
+13. **\`${t("view_file")}\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.`;
   const sendingMessagesSection = isCli ? `### Sending messages
 
 - **Reply to a channel**: \`slock message send --target "#channel-name" <<'EOF'\` followed by the message body and \`EOF\`
@@ -602,6 +714,7 @@ Threads are sub-conversations attached to a specific message. They let you discu
 - **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, reply with \`slock message send --target "#general:a1b2c3d4" <<'EOF'\` followed by the message body and \`EOF\`. The thread will be auto-created if it doesn't exist yet.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
 - You can read thread history: \`slock message read --channel "#general:a1b2c3d4"\`
+- You can stop receiving ordinary delivery for a thread with \`slock thread unfollow --target "#general:a1b2c3d4"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.` : `### Threads
 
 Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
@@ -615,10 +728,10 @@ 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\`, but you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel.` : `### 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\`, 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
 
 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.`;
+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")}\`.`;
   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:
@@ -962,6 +1075,7 @@ exec ${shellSingleQuote(process.execPath)} ${shellSingleQuote(ctx.slockCliPath)}
     ...ctx.config.envVars || {},
     ...extraEnv,
     SLOCK_AGENT_ID: ctx.agentId,
+    ...ctx.launchId ? { SLOCK_AGENT_LAUNCH_ID: ctx.launchId } : {},
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     SLOCK_AGENT_TOKEN_FILE: tokenFile,
     PATH: `${slockDir}${path.delimiter}${process.env.PATH ?? ""}`
@@ -983,7 +1097,7 @@ function normalizeExecOutput(raw) {
   return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
 }
 function resolveCommandOnWindows(command, env, execFileSyncFn) {
-  const script = "$cmd = Get-Command -Name $args[0] -ErrorAction Stop | Select-Object -First 1; if ($cmd.Path) { $cmd.Path } elseif ($cmd.Source) { $cmd.Source } elseif ($cmd.Definition) { $cmd.Definition }";
+  const script = "& {$cmd = Get-Command -Name $args[0] -ErrorAction Stop | Select-Object -First 1; if ($cmd.Path) { $cmd.Path } elseif ($cmd.Source) { $cmd.Source } elseif ($cmd.Definition) { $cmd.Definition } }";
   try {
     const output = normalizeExecOutput(execFileSyncFn("powershell.exe", [
       "-NoProfile",
@@ -1049,9 +1163,12 @@ function resolveHomePath(relativePath, deps = {}) {
 // src/drivers/claude.ts
 var CLAUDE_DESKTOP_CLI_RELATIVE_PATH = path3.join("Applications", "Claude Code URL Handler.app", "Contents", "MacOS", "claude");
 var CLAUDE_DESKTOP_CLI_SYSTEM_PATH = "/Applications/Claude Code URL Handler.app/Contents/MacOS/claude";
+var CLAUDE_SYSTEM_PROMPT_FILE = "claude-system-prompt.md";
+var CLAUDE_MCP_CONFIG_FILE = "claude-mcp-config.json";
 var CLAUDE_DISALLOWED_TOOLS = [
   "EnterPlanMode",
   "ExitPlanMode",
+  "ScheduleWakeup",
   "CronCreate",
   "CronList",
   "CronDelete"
@@ -1077,12 +1194,15 @@ var ClaudeDriver = class {
   id = "claude";
   supportsStdinNotification = true;
   mcpToolPrefix = "mcp__chat__";
-  busyDeliveryMode = "notification";
+  // 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.
+  busyDeliveryMode = "gated";
   supportsNativeStandingPrompt = true;
   probe() {
     return probeClaude();
   }
-  buildClaudeArgs(config, standingPrompt) {
+  buildClaudeArgs(config, standingPrompt, opts = {}) {
     const args = [
       "--allow-dangerously-skip-permissions",
       "--dangerously-skip-permissions",
@@ -1091,13 +1211,16 @@ var ClaudeDriver = class {
       "stream-json",
       "--input-format",
       "stream-json",
-      "--append-system-prompt",
-      standingPrompt,
       "--model",
       config.model || "sonnet",
       "--disallowed-tools",
       CLAUDE_DISALLOWED_TOOLS
     ];
+    if (opts.standingPromptFilePath) {
+      args.push("--append-system-prompt-file", opts.standingPromptFilePath);
+    } else {
+      args.push("--append-system-prompt", standingPrompt);
+    }
     if (config.sessionId) {
       args.push("--resume", config.sessionId);
     }
@@ -1121,16 +1244,27 @@ var ClaudeDriver = class {
             ctx.config.authToken || ctx.daemonApiKey,
             "--runtime",
             this.id,
+            ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
             "--deprecated-shim"
           ]
         }
       }
     });
   }
+  writeClaudeLaunchFiles(ctx, slockDir) {
+    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.buildDeprecatedShimMcpConfig(ctx), { mode: 384 });
+    return { systemPromptPath, mcpConfigPath };
+  }
   spawn(ctx) {
-    const { tokenFile, spawnEnv } = prepareCliTransport(ctx);
-    const args = this.buildClaudeArgs(ctx.config, ctx.standingPrompt);
-    args.push("--mcp-config", this.buildDeprecatedShimMcpConfig(ctx));
+    const { slockDir, tokenFile, spawnEnv } = prepareCliTransport(ctx);
+    const { systemPromptPath, mcpConfigPath } = this.writeClaudeLaunchFiles(ctx, slockDir);
+    const args = this.buildClaudeArgs(ctx.config, ctx.standingPrompt, {
+      standingPromptFilePath: systemPromptPath
+    });
+    args.push("--mcp-config", mcpConfigPath);
     delete spawnEnv.CLAUDECODE;
     logger.info(
       `[Agent ${ctx.agentId}] transport=cli cli=${ctx.slockCliPath} token_file=${tokenFile}`
@@ -1200,6 +1334,17 @@ var ClaudeDriver = class {
         }
         break;
       }
+      case "user": {
+        const content = event.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              events.push({ kind: "tool_output", name: block.name || block.tool_use_id || "tool_result" });
+            }
+          }
+        }
+        break;
+      }
       case "result": {
         const subtype = typeof event.subtype === "string" ? event.subtype : "success";
         const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
@@ -1244,9 +1389,12 @@ var ClaudeDriver = class {
     return buildCliTransportSystemPrompt(config, {
       toolPrefix: "mcp__chat__",
       extraCriticalRules: [],
-      postStartupNotes: [],
+      postStartupNotes: [
+        "**Claude runtime note:** Slock preserves Claude Code same-turn steering through a gated stream-json delivery path. Busy messages are buffered and delivered at Claude-observed safe boundaries; if no earlier safe boundary is available, they are delivered after the current turn ends.",
+        "For long tool runs, you can also use `slock message check` at natural breakpoints to pull pending messages explicitly."
+      ],
       includeStdinNotificationSection: true,
-      messageNotificationStyle: "poll"
+      messageNotificationStyle: "direct"
     });
   }
 };
@@ -1364,6 +1512,7 @@ var CodexDriver = class {
       ctx.config.authToken || ctx.daemonApiKey,
       "--runtime",
       this.id,
+      ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
       "--deprecated-shim"
     ] : [
       ctx.chatBridgePath,
@@ -1375,6 +1524,7 @@ var CodexDriver = class {
       ctx.config.authToken || ctx.daemonApiKey,
       "--runtime",
       this.id,
+      ...ctx.launchId ? ["--launch-id", ctx.launchId] : [],
       "--deprecated-shim"
     ];
     return [
@@ -1574,6 +1724,9 @@ var CodexDriver = class {
             if (isStarted && typeof item.command === "string") {
               events.push({ kind: "tool_call", name: "shell", input: { command: item.command } });
             }
+            if (isCompleted) {
+              events.push({ kind: "tool_output", name: "shell" });
+            }
             break;
           case "contextCompaction":
             if (isStarted) {
@@ -1599,6 +1752,10 @@ var CodexDriver = class {
               const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
               events.push({ kind: "tool_call", name: toolName, input: item.arguments });
             }
+            if (isCompleted) {
+              const toolName = item.server === "chat" ? `${this.mcpToolPrefix}${item.tool}` : `${this.mcpToolPrefix.replace(/_$/, "")}_${item.server}_${item.tool}`;
+              events.push({ kind: "tool_output", name: toolName });
+            }
             break;
           case "collabAgentToolCall":
             if (isStarted) {
@@ -1749,7 +1906,7 @@ function detectCodexModels(home = os.homedir()) {
 // src/drivers/copilot.ts
 import { spawn as spawn3 } from "child_process";
 import path5 from "path";
-import { writeFileSync as writeFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3 } from "fs";
 var CopilotDriver = class {
   id = "copilot";
   supportsStdinNotification = false;
@@ -1764,7 +1921,7 @@ var CopilotDriver = class {
     const mcpCommand = isTsSource ? "npx" : "node";
     const mcpArgs = isTsSource ? ["tsx", ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey] : [ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey];
     const mcpConfigPath = path5.join(ctx.workingDirectory, ".slock-copilot-mcp.json");
-    writeFileSync2(mcpConfigPath, JSON.stringify({
+    writeFileSync3(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
           command: mcpCommand,
@@ -1886,7 +2043,7 @@ var CopilotDriver = class {
 
 // src/drivers/cursor.ts
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import path6 from "path";
 var CursorDriver = class {
   id = "cursor";
@@ -1902,7 +2059,7 @@ var CursorDriver = class {
     const mcpCommand = isTsSource ? "npx" : "node";
     const mcpArgs = isTsSource ? ["tsx", ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey] : [ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey];
     const mcpConfigPath = path6.join(cursorDir, "mcp.json");
-    writeFileSync3(mcpConfigPath, JSON.stringify({
+    writeFileSync4(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
           command: mcpCommand,
@@ -2006,7 +2163,7 @@ var CursorDriver = class {
 
 // src/drivers/gemini.ts
 import { spawn as spawn5 } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import path7 from "path";
 var GeminiDriver = class {
   id = "gemini";
@@ -2026,7 +2183,7 @@ var GeminiDriver = class {
     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");
-    writeFileSync4(settingsPath, JSON.stringify({
+    writeFileSync5(settingsPath, JSON.stringify({
       mcpServers: {
         chat: {
           command: mcpCommand,
@@ -2122,7 +2279,7 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync6 } from "fs";
 import os2 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
@@ -2145,6 +2302,21 @@ var KimiDriver = class {
   sessionId = null;
   sessionAnnounced = false;
   promptRequestId = null;
+  buildChatBridgeArgs(ctx) {
+    const isTsSource = ctx.chatBridgePath.endsWith(".ts");
+    return [
+      ...isTsSource ? ["tsx", ctx.chatBridgePath] : [ctx.chatBridgePath],
+      "--agent-id",
+      ctx.agentId,
+      "--server-url",
+      ctx.config.serverUrl,
+      "--auth-token",
+      ctx.config.authToken || ctx.daemonApiKey,
+      "--runtime",
+      "kimi",
+      ...ctx.launchId ? ["--launch-id", ctx.launchId] : []
+    ];
+  }
   spawn(ctx) {
     const isResume = !!ctx.config.sessionId;
     this.sessionId = ctx.config.sessionId || randomUUID();
@@ -2152,21 +2324,21 @@ var KimiDriver = class {
     this.promptRequestId = randomUUID();
     const isTsSource = ctx.chatBridgePath.endsWith(".ts");
     const command = isTsSource ? "npx" : "node";
-    const bridgeArgs = isTsSource ? ["tsx", ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey] : [ctx.chatBridgePath, "--agent-id", ctx.agentId, "--server-url", ctx.config.serverUrl, "--auth-token", ctx.config.authToken || ctx.daemonApiKey];
+    const bridgeArgs = this.buildChatBridgeArgs(ctx);
     const systemPromptPath = path8.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
     const agentFilePath = path8.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     const mcpConfigPath = path8.join(ctx.workingDirectory, KIMI_MCP_FILE);
     if (!isResume || !existsSync5(systemPromptPath)) {
-      writeFileSync5(systemPromptPath, ctx.prompt, "utf8");
+      writeFileSync6(systemPromptPath, ctx.prompt, "utf8");
     }
-    writeFileSync5(agentFilePath, [
+    writeFileSync6(agentFilePath, [
       "version: 1",
       "agent:",
       "  extend: default",
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
-    writeFileSync5(mcpConfigPath, JSON.stringify({
+    writeFileSync6(mcpConfigPath, JSON.stringify({
       mcpServers: {
         chat: {
           command,
@@ -2539,10 +2711,13 @@ function buildUnreadSummary(messages, excludeChannel) {
 var MAX_TRAJECTORY_TEXT = 2e3;
 var TRAJECTORY_COALESCE_MS = 350;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
+var COMPACTION_STALE_MS = 5 * 6e4;
+var RUNTIME_PROGRESS_STALE_MS = 15 * 6e4;
 var MAX_STDOUT_LINES = 8;
 var MAX_STDOUT_LINE_LENGTH = 240;
 var MAX_STDERR_LINES = 8;
 var MAX_STDERR_LINE_LENGTH = 240;
+var MAX_GATED_STEERING_EVENTS = 12;
 var ONBOARDING_MEMORY_SEED_ENV = "SLOCK_ONBOARDING_MEMORY_SEED";
 var FIRST_CINDY_SEED_MODE = "first-cindy";
 function getOnboardingSeedMode(config) {
@@ -2853,6 +3028,31 @@ Success = user starts useful collaboration and setup progresses,
 not finishing a long onboarding conversation in one channel.
 `;
 }
+function createGatedSteeringState() {
+  return {
+    phase: "idle",
+    outstandingToolUses: 0,
+    compacting: false,
+    toolBoundaryFlushDisabled: process.env.SLOCK_CLAUDE_GATED_STEERING_TOOL_BOUNDARY === "0",
+    lastFlushReason: null,
+    recentEvents: [],
+    inFlightBatch: null
+  };
+}
+var RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX = "runtime-profile-migration-";
+var RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX = "runtime-profile-daemon-release-";
+function runtimeProfileNotificationFromMessage(message) {
+  if (message.message_id?.startsWith(RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX)) {
+    return { kind: "migration", key: message.message_id.slice(RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX.length) };
+  }
+  if (message.message_id?.startsWith(RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX)) {
+    return { kind: "daemon_release_notice", key: message.message_id.slice(RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX.length) };
+  }
+  return null;
+}
+function runtimeProfileNotificationTitle(kind) {
+  return kind === "migration" ? "Runtime Profile migration" : "Runtime Profile notice";
+}
 function pushRecentLines(lines, chunk, maxLines, maxLineLength) {
   const next = [...lines];
   for (const rawLine of chunk.split(/\r?\n/)) {
@@ -2924,6 +3124,9 @@ function getBusyDeliveryNote(driver) {
   if (driver.busyDeliveryMode === "direct") {
     return "\n\nNote: While you are busy, new messages may be delivered directly into your active turn. Handle them when appropriate and keep working.";
   }
+  if (driver.busyDeliveryMode === "gated") {
+    return "\n\nNote: While you are busy, new messages may be delivered at runtime-observed safe boundaries in your active turn. If no safe boundary is available, they will be delivered after the current turn ends.";
+  }
   return "\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call check_messages to check for messages.";
 }
 var NATIVE_STANDING_PROMPT_STARTUP_INPUT = "Your system prompt contains your standing instructions. Follow it now and begin listening for messages.";
@@ -2942,6 +3145,7 @@ var AgentProcessManager = class _AgentProcessManager {
   dataDir;
   driverResolver;
   defaultAgentEnvVarsProvider;
+  tracer;
   constructor(chatBridgePath, sendToServer, daemonApiKey, opts) {
     this.chatBridgePath = chatBridgePath;
     this.slockCliPath = opts.slockCliPath ?? "";
@@ -2951,6 +3155,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.dataDir = opts.dataDir || DATA_DIR;
     this.driverResolver = opts.driverResolver || getDriver;
     this.defaultAgentEnvVarsProvider = opts.defaultAgentEnvVarsProvider || null;
+    this.tracer = opts.tracer ?? noopTracer;
   }
   async startAgent(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId) {
     if (this.agents.has(agentId)) {
@@ -3043,7 +3248,8 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         workingDirectory: agentDataDir,
         chatBridgePath: this.chatBridgePath,
         slockCliPath: this.slockCliPath,
-        daemonApiKey: this.daemonApiKey
+        daemonApiKey: this.daemonApiKey,
+        launchId: launchId || null
       });
       const agentProcess = {
         process: proc,
@@ -3056,6 +3262,11 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         notificationTimer: null,
         pendingNotificationCount: 0,
         activityHeartbeat: null,
+        compactionWatchdog: null,
+        compactionStartedAt: null,
+        lastRuntimeEventAt: Date.now(),
+        runtimeProgressStaleSince: null,
+        runtimeTraceSpan: null,
         lastActivity: "",
         lastActivityDetail: "",
         recentStdout: [],
@@ -3064,11 +3275,16 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         spawnError: null,
         exitCode: null,
         exitSignal: null,
-        pendingTrajectory: null
+        pendingTrajectory: null,
+        gatedSteering: createGatedSteeringState()
       };
       this.startingInboxes.delete(agentId);
       this.agents.set(agentId, agentProcess);
+      this.startRuntimeTrace(agentId, agentProcess, "spawn");
       this.agentsStarting.delete(agentId);
+      if (wakeMessage) {
+        this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
+      }
       let buffer = "";
       proc.stdout?.on("data", (chunk) => {
         const chunkText = chunk.toString();
@@ -3123,10 +3339,20 @@ Use read_history to catch up on the channels listed above, then stop. Read each
           if (ap.activityHeartbeat) {
             clearInterval(ap.activityHeartbeat);
           }
-          this.agents.delete(agentId);
           const finalCode = ap.exitCode ?? code;
           const finalSignal = ap.exitSignal ?? signal;
           const terminalFailureDetail = classifyTerminalFailure(ap);
+          this.endRuntimeTrace(ap, finalCode === 0 ? "ok" : "error", {
+            outcome: finalCode === 0 ? "process-exit" : "process-crash",
+            exitCode: finalCode,
+            exitSignal: finalSignal
+          });
+          if (finalCode === 0) {
+            this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from process exit)");
+          } else {
+            this.clearCompactionWatchdog(ap);
+          }
+          this.agents.delete(agentId);
           if (finalCode === 0) {
             const queuedWakeMessage = !ap.driver.supportsStdinNotification ? ap.inbox.shift() : void 0;
             const unreadSummary2 = queuedWakeMessage ? buildUnreadSummary(ap.inbox, formatChannelLabel(queuedWakeMessage)) : void 0;
@@ -3262,6 +3488,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (ap.activityHeartbeat) {
       clearInterval(ap.activityHeartbeat);
     }
+    this.clearCompactionWatchdog(ap);
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
     if (!silent) {
@@ -3315,6 +3542,7 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       const nextMessages = ap.inbox.splice(0, ap.inbox.length);
       nextMessages.push(message);
       ap.isIdle = false;
+      this.startRuntimeTrace(agentId, ap, "stdin-idle-delivery");
       this.broadcastActivity(agentId, "working", "Message received");
       this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle");
       return;
@@ -3322,6 +3550,14 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     ap.inbox.push(message);
     if (!ap.driver.supportsStdinNotification) return;
     if (!ap.sessionId) return;
+    if (ap.driver.busyDeliveryMode === "gated") {
+      ap.pendingNotificationCount++;
+      this.recordGatedSteeringEvent(agentId, ap, "buffer", {
+        reason: "busy_message",
+        pendingMessages: ap.inbox.length
+      });
+      return;
+    }
     ap.pendingNotificationCount++;
     if (!ap.notificationTimer) {
       ap.notificationTimer = setTimeout(() => {
@@ -3359,6 +3595,127 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     }
     return result;
   }
+  buildRuntimeProfileReport(agentId, config, sessionId, launchId) {
+    const workspacePath = path10.join(this.dataDir, agentId);
+    return {
+      agentId,
+      launchId,
+      facts: {
+        runtime: config.runtime,
+        model: config.model,
+        reasoningEffort: config.reasoningEffort,
+        executionMode: config.executionMode || "byoc",
+        workspacePathRef: {
+          label: "workspace",
+          path: workspacePath,
+          reachable: true
+        },
+        sessionRef: sessionId ? {
+          label: sessionId,
+          path: sessionId,
+          runtime: config.runtime,
+          reachable: true
+        } : null
+      }
+    };
+  }
+  getAgentRuntimeProfileReport(agentId) {
+    const running = this.agents.get(agentId);
+    if (running) {
+      return this.buildRuntimeProfileReport(agentId, running.config, running.sessionId, running.launchId);
+    }
+    const idle = this.idleAgentConfigs.get(agentId);
+    if (idle) {
+      return this.buildRuntimeProfileReport(agentId, idle.config, idle.sessionId, idle.launchId);
+    }
+    return null;
+  }
+  getAgentRuntimeProfileReports() {
+    const reports = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const agentId of this.agents.keys()) {
+      const report = this.getAgentRuntimeProfileReport(agentId);
+      if (report) {
+        reports.push(report);
+        seen.add(agentId);
+      }
+    }
+    for (const agentId of this.idleAgentConfigs.keys()) {
+      if (seen.has(agentId)) continue;
+      const report = this.getAgentRuntimeProfileReport(agentId);
+      if (report) reports.push(report);
+    }
+    return reports;
+  }
+  deliverRuntimeProfileNotification(agentId, key, kind, content) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const message = {
+      channel_id: "system",
+      channel_name: "system",
+      channel_type: "dm",
+      sender_id: "system",
+      sender_name: "system",
+      sender_type: "system",
+      content,
+      timestamp: now,
+      message_id: `${kind === "migration" ? RUNTIME_PROFILE_MIGRATION_MESSAGE_PREFIX : RUNTIME_PROFILE_DAEMON_NOTICE_MESSAGE_PREFIX}${key}`
+    };
+    const ap = this.agents.get(agentId);
+    if (ap?.sessionId && ap.driver.supportsStdinNotification && ap.isIdle) {
+      ap.isIdle = false;
+      this.startRuntimeTrace(agentId, ap, "runtime-profile");
+      this.deliverMessagesViaStdin(agentId, ap, [message], "idle");
+      return;
+    }
+    if (ap?.sessionId && ap.driver.busyDeliveryMode === "direct") {
+      this.deliverMessagesViaStdin(agentId, ap, [message], "busy");
+      return;
+    }
+    const cached = this.idleAgentConfigs.get(agentId);
+    if (cached) {
+      logger.info(`[Agent ${agentId}] Starting from idle state for runtime profile ${kind} ${key}`);
+      this.idleAgentConfigs.delete(agentId);
+      this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).catch((err) => {
+        logger.error(`[Agent ${agentId}] Failed to auto-restart for runtime profile notification`, err);
+        this.idleAgentConfigs.set(agentId, cached);
+      });
+      return;
+    }
+    logger.warn(`[Agent ${agentId}] Runtime profile ${kind} ${key} has no runtime injection path yet; leaving unacked for retry`);
+  }
+  ackInjectedRuntimeProfileMessages(agentId, messages, launchId) {
+    for (const message of messages) {
+      const notification = runtimeProfileNotificationFromMessage(message);
+      if (!notification) continue;
+      const title = runtimeProfileNotificationTitle(notification.kind);
+      this.broadcastActivity(agentId, "working", title, [{ kind: "system", title, text: message.content }], launchId);
+      if (notification.kind === "migration") {
+        this.sendToServer({
+          type: "agent:runtime_profile:migration:ack",
+          agentId,
+          migrationKey: notification.key,
+          launchId: launchId || void 0
+        });
+      } else {
+        this.sendToServer({
+          type: "agent:runtime_profile:daemon_release_notice:ack",
+          agentId,
+          noticeKey: notification.key,
+          launchId: launchId || void 0
+        });
+      }
+    }
+  }
+  sendRuntimeProfileReport(agentId) {
+    const report = this.getAgentRuntimeProfileReport(agentId);
+    if (!report) return;
+    this.sendToServer({
+      type: "agent:runtime_profile",
+      agentId: report.agentId,
+      facts: report.facts,
+      launchId: report.launchId || void 0
+    });
+  }
   // Machine-level workspace scanning
   async scanAllWorkspaces() {
     return scanWorkspaceDirectories(this.dataDir);
@@ -3541,6 +3898,10 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       if (activity === "working" || activity === "thinking") {
         if (!ap.activityHeartbeat) {
           ap.activityHeartbeat = setInterval(() => {
+            if (this.markRuntimeProgressStaleIfNeeded(agentId, ap)) return;
+            this.recordRuntimeTraceEvent(agentId, ap, "activity.heartbeat.sent", {
+              activity: ap.lastActivity
+            });
             this.sendToServer({
               type: "agent:activity",
               agentId,
@@ -3596,27 +3957,202 @@ Use read_history to catch up on the channels listed above, then stop. Read each
       timer: setTimeout(() => this.flushPendingTrajectory(agentId), TRAJECTORY_COALESCE_MS)
     };
   }
+  clearCompactionWatchdog(ap) {
+    if (ap.compactionWatchdog) {
+      clearTimeout(ap.compactionWatchdog);
+      ap.compactionWatchdog = null;
+    }
+    ap.compactionStartedAt = null;
+  }
+  startCompactionWatchdog(agentId, ap) {
+    this.clearCompactionWatchdog(ap);
+    const startedAt = Date.now();
+    ap.compactionStartedAt = startedAt;
+    ap.compactionWatchdog = setTimeout(() => {
+      this.markCompactionStale(agentId, startedAt);
+    }, COMPACTION_STALE_MS);
+  }
+  markCompactionStale(agentId, startedAt) {
+    const ap = this.agents.get(agentId);
+    if (!ap || ap.compactionStartedAt !== startedAt) return;
+    ap.compactionWatchdog = null;
+    this.broadcastActivity(agentId, "working", "Context compaction still running; no finish event observed");
+  }
+  finishCompactionIfActive(agentId, detail = "Context compaction finished") {
+    const ap = this.agents.get(agentId);
+    if (!ap || !ap.compactionStartedAt) return;
+    this.clearCompactionWatchdog(ap);
+    this.broadcastActivity(agentId, "working", detail, [{ kind: "compaction_finished" }]);
+  }
+  startRuntimeTrace(agentId, ap, reason) {
+    if (ap.runtimeTraceSpan) return ap.runtimeTraceSpan;
+    const span = this.tracer.startSpan("daemon.runtime.turn", {
+      surface: "daemon",
+      kind: "internal",
+      attrs: {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        reason,
+        hasSession: Boolean(ap.sessionId)
+      }
+    });
+    span.addEvent("daemon.turn.started", { reason });
+    ap.runtimeTraceSpan = span;
+    return span;
+  }
+  endRuntimeTrace(ap, status, attrs) {
+    if (!ap.runtimeTraceSpan) return;
+    ap.runtimeTraceSpan.end(status, attrs ? { attrs } : void 0);
+    ap.runtimeTraceSpan = null;
+  }
+  recordRuntimeTraceEvent(agentId, ap, name, attrs) {
+    this.startRuntimeTrace(agentId, ap, "runtime-progress").addEvent(name, attrs);
+  }
+  noteRuntimeProgress(ap) {
+    ap.lastRuntimeEventAt = Date.now();
+    ap.runtimeProgressStaleSince = null;
+  }
+  recordGatedSteeringEvent(agentId, ap, event, attrs = {}) {
+    if (ap.driver.busyDeliveryMode !== "gated") return;
+    const summary = `${event}:${ap.gatedSteering.phase}:tools=${ap.gatedSteering.outstandingToolUses}:compact=${ap.gatedSteering.compacting}`;
+    ap.gatedSteering.recentEvents.push(summary);
+    ap.gatedSteering.recentEvents = ap.gatedSteering.recentEvents.slice(-MAX_GATED_STEERING_EVENTS);
+    this.recordRuntimeTraceEvent(agentId, ap, `runtime.gated_steering.${event}`, {
+      phase: ap.gatedSteering.phase,
+      outstandingToolUses: ap.gatedSteering.outstandingToolUses,
+      compacting: ap.gatedSteering.compacting,
+      toolBoundaryFlushDisabled: ap.gatedSteering.toolBoundaryFlushDisabled,
+      pendingMessages: ap.inbox.length,
+      ...attrs
+    });
+  }
+  setGatedSteeringPhase(agentId, ap, phase, attrs = {}) {
+    if (!ap || ap.driver.busyDeliveryMode !== "gated") return;
+    ap.gatedSteering.phase = phase;
+    this.recordGatedSteeringEvent(agentId, ap, "phase", attrs);
+  }
+  tryFlushGatedSteering(agentId, ap, reason) {
+    if (ap.driver.busyDeliveryMode !== "gated") return false;
+    if (!ap.sessionId || ap.inbox.length === 0) return false;
+    if (reason === "tool_batch_complete") {
+      if (ap.gatedSteering.toolBoundaryFlushDisabled) return false;
+      if (ap.gatedSteering.compacting || ap.gatedSteering.outstandingToolUses > 0) return false;
+    }
+    const pendingMessages = ap.inbox.length;
+    const pendingNotificationCount = ap.pendingNotificationCount;
+    const nextMessages = ap.inbox.splice(0, ap.inbox.length);
+    ap.pendingNotificationCount = 0;
+    ap.gatedSteering.lastFlushReason = reason;
+    if (reason === "tool_batch_complete") {
+      ap.gatedSteering.inFlightBatch = {
+        reason,
+        messages: nextMessages
+      };
+    } else {
+      ap.gatedSteering.inFlightBatch = null;
+    }
+    this.recordGatedSteeringEvent(agentId, ap, "flush", { reason, messageCount: nextMessages.length });
+    logger.info(
+      `[Agent ${agentId}] Claude gated steering flush reason=${reason} messages=${nextMessages.length}`
+    );
+    this.broadcastActivity(agentId, "working", "Message received");
+    if (this.deliverMessagesViaStdin(agentId, ap, nextMessages, reason === "turn_end" ? "idle" : "busy")) {
+      return true;
+    }
+    if (reason === "tool_batch_complete") {
+      ap.gatedSteering.inFlightBatch = null;
+    }
+    ap.pendingNotificationCount += pendingNotificationCount || pendingMessages;
+    return false;
+  }
+  clearGatedInFlightBatch(agentId, ap, reason) {
+    if (ap.driver.busyDeliveryMode !== "gated" || !ap.gatedSteering.inFlightBatch) return;
+    const messageCount = ap.gatedSteering.inFlightBatch.messages.length;
+    ap.gatedSteering.inFlightBatch = null;
+    this.recordGatedSteeringEvent(agentId, ap, "ack", { reason, messageCount });
+  }
+  requeueGatedInFlightBatch(agentId, ap, reason) {
+    if (ap.driver.busyDeliveryMode !== "gated" || !ap.gatedSteering.inFlightBatch) return;
+    const batch = ap.gatedSteering.inFlightBatch;
+    ap.gatedSteering.inFlightBatch = null;
+    ap.inbox.unshift(...batch.messages);
+    ap.pendingNotificationCount += batch.messages.length;
+    this.recordGatedSteeringEvent(agentId, ap, "requeue", {
+      reason,
+      originalFlushReason: batch.reason,
+      messageCount: batch.messages.length
+    });
+  }
+  isThinkingBlockMutationError(message) {
+    return /thinking.*redacted_thinking|redacted_thinking.*thinking/i.test(message) && /cannot be modified/i.test(message);
+  }
+  markRuntimeProgressStaleIfNeeded(agentId, ap) {
+    if (ap.lastActivity !== "working" && ap.lastActivity !== "thinking") return false;
+    if (ap.runtimeProgressStaleSince) return true;
+    const staleForMs = Date.now() - ap.lastRuntimeEventAt;
+    if (staleForMs < RUNTIME_PROGRESS_STALE_MS) return false;
+    ap.runtimeProgressStaleSince = Date.now();
+    const staleForMinutes = Math.max(1, Math.floor(staleForMs / 6e4));
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.stalled", {
+      ageMs: staleForMs,
+      staleForMinutes,
+      lastActivity: ap.lastActivity
+    });
+    this.endRuntimeTrace(ap, "error", {
+      outcome: "runtime-stalled",
+      ageMs: staleForMs,
+      lastActivity: ap.lastActivity
+    });
+    this.broadcastActivity(agentId, "error", `Runtime stalled: no runtime events for ${staleForMinutes}m`);
+    return true;
+  }
   /** Handle a single ParsedEvent from any runtime driver */
   handleParsedEvent(agentId, event, driver) {
     const ap = this.agents.get(agentId);
+    if (ap) {
+      const wasStalled = Boolean(ap.runtimeProgressStaleSince);
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", { kind: event.kind });
+      if (wasStalled) {
+        this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
+      }
+      this.noteRuntimeProgress(ap);
+    }
     switch (event.kind) {
       case "session_init":
         if (ap) ap.sessionId = event.sessionId;
         this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
+        this.sendRuntimeProfileReport(agentId);
         break;
       case "thinking": {
+        this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "thinking", event.text);
         if (ap) ap.isIdle = false;
+        if (ap) this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
+        this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "thinking" });
         break;
       }
       case "text": {
+        this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "text", event.text);
         if (ap) ap.isIdle = false;
+        if (ap) this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
+        this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "text" });
         break;
       }
       case "tool_call": {
+        this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from resumed tool use)");
         this.flushPendingTrajectory(agentId);
         const invocation = normalizeToolDisplayInvocation(event.name, event.input);
+        if (ap) {
+          ap.gatedSteering.outstandingToolUses++;
+          this.clearGatedInFlightBatch(agentId, ap, "non_error_progress");
+          this.recordRuntimeTraceEvent(agentId, ap, "tool.call.started", { tool: invocation.toolName });
+          this.setGatedSteeringPhase(agentId, ap, "tool_wait", {
+            event: "tool_call",
+            tool: invocation.toolName
+          });
+        }
         const inputSummary = summarizeToolInput(invocation.toolName, invocation.input);
         const detail = getToolActivityLabel(invocation.toolName);
         this.broadcastActivity(agentId, "working", detail, [{
@@ -3627,22 +4163,66 @@ Use read_history to catch up on the channels listed above, then stop. Read each
         if (ap) ap.isIdle = false;
         break;
       }
+      case "tool_output": {
+        const invocation = normalizeToolDisplayInvocation(event.name, {});
+        if (ap) {
+          const hadOutstandingToolUse = ap.gatedSteering.outstandingToolUses > 0;
+          ap.gatedSteering.outstandingToolUses = Math.max(0, ap.gatedSteering.outstandingToolUses - 1);
+          this.recordRuntimeTraceEvent(agentId, ap, "tool.output.observed", { tool: invocation.toolName });
+          this.recordRuntimeTraceEvent(agentId, ap, "runtime.continuation.expected");
+          this.setGatedSteeringPhase(agentId, ap, "tool_boundary", {
+            event: "tool_output",
+            tool: invocation.toolName
+          });
+          ap.isIdle = false;
+          if (hadOutstandingToolUse && ap.gatedSteering.outstandingToolUses === 0) {
+            this.tryFlushGatedSteering(agentId, ap, "tool_batch_complete");
+          }
+        }
+        break;
+      }
       case "compaction_started":
         this.flushPendingTrajectory(agentId);
+        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.context_compaction.started");
+        if (ap) this.startCompactionWatchdog(agentId, ap);
         this.broadcastActivity(agentId, "working", "Compacting context", [{ kind: "compaction_started" }]);
-        if (ap) ap.isIdle = false;
+        if (ap) {
+          ap.gatedSteering.compacting = true;
+          this.setGatedSteeringPhase(agentId, ap, "compacting", { event: "compaction_started" });
+          ap.isIdle = false;
+        }
         break;
       case "compaction_finished":
         this.flushPendingTrajectory(agentId);
+        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.context_compaction.finished");
+        if (ap) this.clearCompactionWatchdog(ap);
         this.broadcastActivity(agentId, "working", "Context compaction finished", [{ kind: "compaction_finished" }]);
-        if (ap) ap.isIdle = false;
+        if (ap) {
+          ap.gatedSteering.compacting = false;
+          this.setGatedSteeringPhase(agentId, ap, "assistant_continuation", { event: "compaction_finished" });
+          ap.isIdle = false;
+        }
         break;
       case "turn_end":
+        if (ap) this.recordRuntimeTraceEvent(agentId, ap, "runtime.turn.completed");
+        this.finishCompactionIfActive(agentId, "Context compaction finished (inferred from turn end)");
         this.flushPendingTrajectory(agentId);
         if (ap) {
+          this.clearGatedInFlightBatch(agentId, ap, "turn_end");
           if (event.sessionId) ap.sessionId = event.sessionId;
+          ap.gatedSteering.outstandingToolUses = 0;
+          ap.gatedSteering.compacting = false;
+          this.setGatedSteeringPhase(agentId, ap, "idle", { event: "turn_end" });
           if (ap.inbox.length > 0 && ap.driver.supportsStdinNotification && ap.sessionId) {
             const nextMessages = ap.inbox.splice(0, ap.inbox.length);
+            ap.pendingNotificationCount = 0;
+            if (ap.driver.busyDeliveryMode === "gated") {
+              ap.gatedSteering.lastFlushReason = "turn_end";
+              this.recordGatedSteeringEvent(agentId, ap, "flush", {
+                reason: "turn_end",
+                messageCount: nextMessages.length
+              });
+            }
             this.broadcastActivity(agentId, "working", "Message received");
             if (!this.deliverMessagesViaStdin(agentId, ap, nextMessages, "idle")) {
               ap.isIdle = true;
@@ -3652,14 +4232,34 @@ Use read_history to catch up on the channels listed above, then stop. Read each
             ap.isIdle = true;
             this.broadcastActivity(agentId, "online", "Idle");
           }
+          this.endRuntimeTrace(ap, "ok", { outcome: "turn-completed" });
         }
         if (event.sessionId) {
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.sessionId, launchId: ap?.launchId || void 0 });
+          this.sendRuntimeProfileReport(agentId);
         }
         break;
       case "error": {
+        this.finishCompactionIfActive(agentId, "Context compaction interrupted by runtime error");
         this.flushPendingTrajectory(agentId);
         if (ap) ap.lastRuntimeError = event.message;
+        if (ap) {
+          this.setGatedSteeringPhase(agentId, ap, "error", { event: "error" });
+          if (ap.driver.busyDeliveryMode === "gated" && this.isThinkingBlockMutationError(event.message)) {
+            this.requeueGatedInFlightBatch(agentId, ap, "thinking_block_mutation_error");
+            ap.gatedSteering.toolBoundaryFlushDisabled = true;
+            this.recordGatedSteeringEvent(agentId, ap, "disabled", {
+              reason: "thinking_block_mutation_error",
+              lastFlushReason: ap.gatedSteering.lastFlushReason,
+              recentEvents: ap.gatedSteering.recentEvents.join(" | ")
+            });
+            logger.warn(
+              `[Agent ${agentId}] Disabled Claude tool-boundary gated steering after thinking-block mutation error; lastFlushReason=${ap.gatedSteering.lastFlushReason || "none"}`
+            );
+          }
+          this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", { message: event.message });
+          this.endRuntimeTrace(ap, "error", { outcome: "runtime-error", errorMessage: event.message });
+        }
         this.broadcastActivity(agentId, "error", event.message, [
           { kind: "text", text: `Error: ${event.message}` }
         ]);
@@ -3680,6 +4280,17 @@ Use read_history to catch up on the channels listed above, then stop. Read each
     if (count === 0) return;
     if (ap.isIdle) return;
     if (!ap.sessionId) return;
+    if (ap.driver.busyDeliveryMode === "gated") {
+      this.recordGatedSteeringEvent(agentId, ap, "suppress", {
+        reason: "timer_notification_not_safe_boundary",
+        pendingNotificationCount: count
+      });
+      ap.pendingNotificationCount += count;
+      logger.info(
+        `[Agent ${agentId}] Suppressing raw busy stdin notification until Claude gated steering boundary; pending=${ap.inbox.length}`
+      );
+      return;
+    }
     if (ap.driver.busyDeliveryMode === "direct" && ap.inbox.length > 0) {
       const queuedMessages = ap.inbox.splice(0, ap.inbox.length);
       console.log(`[Agent ${agentId}] Delivering queued message via stdin while busy`);
@@ -3725,6 +4336,7 @@ Respond as appropriate. Complete all your work before stopping.`;
       `[Agent ${agentId}] Delivering ${mode} ${messages.length === 1 ? "message" : `${messages.length} messages`} via stdin from ${senders}`
     );
     ap.process.stdin?.write(encoded + "\n");
+    this.ackInjectedRuntimeProfileMessages(agentId, messages, ap.launchId);
     return true;
   }
   /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
@@ -3973,6 +4585,112 @@ var ReminderCache = class {
   }
 };
 
+// src/machineLock.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import os4 from "os";
+import path11 from "path";
+var DEFAULT_MACHINE_STATE_ROOT = path11.join(os4.homedir(), ".slock", "machines");
+var INCOMPLETE_LOCK_STALE_MS = 3e4;
+var DaemonMachineLockConflictError = class extends Error {
+  code = "DAEMON_MACHINE_LOCK_HELD";
+  constructor(lockDir, owner) {
+    const ownerText = owner ? `pid=${owner.pid}, startedAt=${owner.startedAt}, host=${owner.hostname}` : "unknown owner";
+    super(
+      `Another Slock daemon is already running for this machine key (${ownerText}). Lock: ${lockDir}. Stop the existing daemon first, or use a different machine key/state directory.`
+    );
+    this.name = "DaemonMachineLockConflictError";
+  }
+};
+function apiKeyFingerprint(apiKey) {
+  return createHash("sha256").update(apiKey).digest("hex");
+}
+function getDaemonMachineLockId(apiKey) {
+  return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
+}
+function ownerPath(lockDir) {
+  return path11.join(lockDir, "owner.json");
+}
+function readOwner(lockDir) {
+  try {
+    return JSON.parse(readFileSync3(ownerPath(lockDir), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function lockAgeMs(lockDir) {
+  try {
+    return Date.now() - statSync(lockDir).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = typeof err === "object" && err && "code" in err ? err.code : void 0;
+    return code !== "ESRCH";
+  }
+}
+function acquireDaemonMachineLock(options) {
+  const rootDir = options.rootDir ?? DEFAULT_MACHINE_STATE_ROOT;
+  const fingerprint = apiKeyFingerprint(options.apiKey);
+  const lockId = getDaemonMachineLockId(options.apiKey);
+  const machineDir = path11.join(rootDir, lockId);
+  const lockDir = path11.join(machineDir, "daemon.lock");
+  const token = randomUUID2();
+  mkdirSync4(machineDir, { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      mkdirSync4(lockDir);
+      const owner = {
+        pid: process.pid,
+        token,
+        hostname: os4.hostname(),
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        serverUrl: options.serverUrl,
+        apiKeyFingerprint: fingerprint.slice(0, 16)
+      };
+      try {
+        writeFileSync7(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+`, { mode: 384 });
+      } catch (err) {
+        rmSync(lockDir, { recursive: true, force: true });
+        throw err;
+      }
+      return {
+        lockId,
+        machineDir,
+        lockDir,
+        release: () => {
+          const currentOwner = readOwner(lockDir);
+          if (currentOwner?.pid === process.pid && currentOwner.token === token) {
+            rmSync(lockDir, { recursive: true, force: true });
+          }
+        }
+      };
+    } catch (err) {
+      const code = typeof err === "object" && err && "code" in err ? err.code : void 0;
+      if (code !== "EEXIST") throw err;
+      const owner = readOwner(lockDir);
+      if (owner?.pid && isProcessAlive(owner.pid)) {
+        throw new DaemonMachineLockConflictError(lockDir, owner);
+      }
+      if (!owner) {
+        const ageMs = lockAgeMs(lockDir);
+        if (ageMs === null || ageMs < INCOMPLETE_LOCK_STALE_MS) {
+          throw new DaemonMachineLockConflictError(lockDir, null);
+        }
+      }
+      rmSync(lockDir, { recursive: true, force: true });
+    }
+  }
+  throw new DaemonMachineLockConflictError(lockDir, readOwner(lockDir));
+}
+
 // src/core.ts
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
@@ -3994,23 +4712,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path11.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path11.resolve(dirname, "chat-bridge.js");
+  const dirname = path12.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path12.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path11.resolve(dirname, "chat-bridge.ts");
+    return path12.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path11.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path11.resolve(thisDir, "cli", "index.js");
+  const thisDir = path12.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path12.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path11.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path12.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -4055,6 +4773,10 @@ function summarizeIncomingMessage(msg) {
       return `(agent=${msg.agentId})`;
     case "agent:deliver":
       return `(agent=${msg.agentId}, seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`;
+    case "agent:runtime_profile:migration":
+      return `(agent=${msg.agentId}, migration=${msg.migrationKey})`;
+    case "agent:runtime_profile:daemon_release_notice":
+      return `(agent=${msg.agentId}, notice=${msg.noticeKey})`;
     case "agent:workspace:list":
       return `(agent=${msg.agentId}, dir=${msg.dirPath || "."})`;
     case "agent:workspace:read":
@@ -4084,12 +4806,15 @@ var DaemonCore = class {
   agentManager;
   connection;
   reminderCache;
+  tracer;
+  machineLock = 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.tracer = options.tracer ?? noopTracer;
     this.reminderCache = new ReminderCache({
       clock: options.reminderClock,
       onFire: (job) => this.onReminderFire(job)
@@ -4113,15 +4838,39 @@ var DaemonCore = class {
     });
     this.connection = connection;
   }
+  resolveMachineStateRoot() {
+    if (this.options.machineStateDir) return this.options.machineStateDir;
+    if (this.options.dataDir) return path12.join(path12.dirname(this.options.dataDir), "machines");
+    return DEFAULT_MACHINE_STATE_ROOT;
+  }
   start() {
     logger.info("[Slock Daemon] Starting...");
-    this.connection.connect();
+    if (!this.machineLock) {
+      this.machineLock = acquireDaemonMachineLock({
+        apiKey: this.options.apiKey,
+        serverUrl: this.options.serverUrl,
+        rootDir: this.resolveMachineStateRoot()
+      });
+      logger.info(`[Slock Daemon] Acquired machine lock: ${this.machineLock.lockDir}`);
+    }
+    try {
+      this.connection.connect();
+    } catch (err) {
+      this.machineLock.release();
+      this.machineLock = null;
+      throw err;
+    }
   }
   async stop() {
     logger.info("[Slock Daemon] Shutting down...");
     this.reminderCache.clear();
-    await this.agentManager.stopAll();
-    this.connection.disconnect();
+    try {
+      await this.agentManager.stopAll();
+    } finally {
+      this.connection.disconnect();
+      this.machineLock?.release();
+      this.machineLock = null;
+    }
   }
   get connected() {
     return this.connection.connected;
@@ -4150,10 +4899,44 @@ var DaemonCore = class {
         logger.info(`[Agent ${msg.agentId}] Workspace reset requested`);
         this.agentManager.resetWorkspace(msg.agentId);
         break;
-      case "agent:deliver":
+      case "agent:deliver": {
+        const parent = parseTraceparent(msg.traceparent);
+        const span = this.tracer.startSpan("daemon.agent.delivery", {
+          parent,
+          surface: "daemon",
+          kind: "consumer",
+          attrs: {
+            agentId: msg.agentId,
+            seq: msg.seq
+          }
+        });
         logger.info(`[Agent ${msg.agentId}] Delivery received (seq=${msg.seq}, from=@${msg.message.sender_name}, target=${formatChannelTarget(msg)})`);
-        this.agentManager.deliverMessage(msg.agentId, msg.message);
-        this.connection.send({ type: "agent:deliver:ack", agentId: msg.agentId, seq: msg.seq });
+        try {
+          span.addEvent("daemon.receive", { seq: msg.seq });
+          this.agentManager.deliverMessage(msg.agentId, msg.message);
+          span.addEvent("daemon.deliver_to_agent_manager");
+          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)
+          });
+          span.end("ok", { attrs: { outcome: "ack-sent", ackSeq } });
+        } catch (err) {
+          span.end("error", { attrs: { errorMessage: err instanceof Error ? err.message : String(err) } });
+          throw err;
+        }
+        break;
+      }
+      case "agent:runtime_profile:migration":
+        logger.info(`[Agent ${msg.agentId}] Runtime profile migration received (${msg.migrationKey})`);
+        this.agentManager.deliverRuntimeProfileNotification(msg.agentId, msg.migrationKey, "migration", msg.message);
+        break;
+      case "agent:runtime_profile:daemon_release_notice":
+        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);
         break;
       case "agent:workspace:list":
         this.agentManager.getFileTree(msg.agentId, msg.dirPath).then((files) => {
@@ -4248,8 +5031,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os4.hostname(),
-      os: this.options.osDescription ?? `${os4.platform()} ${os4.arch()}`,
+      hostname: this.options.hostname ?? os5.hostname(),
+      os: this.options.osDescription ?? `${os5.platform()} ${os5.arch()}`,
       daemonVersion: this.daemonVersion
     });
     for (const agentId of this.agentManager.getRunningAgentIds()) {
@@ -4262,6 +5045,14 @@ var DaemonCore = class {
     for (const { agentId, sessionId, launchId } of this.agentManager.getIdleAgentSessionIds()) {
       this.connection.send({ type: "agent:session", agentId, sessionId, launchId: launchId || void 0 });
     }
+    for (const report of this.agentManager.getAgentRuntimeProfileReports()) {
+      this.connection.send({
+        type: "agent:runtime_profile",
+        agentId: report.agentId,
+        facts: report.facts,
+        launchId: report.launchId || void 0
+      });
+    }
     const agentsForSnapshot = new Set(this.agentManager.getRunningAgentIds());
     for (const { agentId } of this.agentManager.getIdleAgentSessionIds()) {
       agentsForSnapshot.add(agentId);