@botiverse/raft-daemon 0.63.5 → 0.63.6

package/dist/{chunk-DZ25KV6L.js → chunk-DUWRNQQE.js}

@@ -11,6 +11,72 @@ function makeIsMember(members) {
   return (value) => typeof value === "string" && set.has(value);
 }
 
+// ../shared/src/generated/runtimeProviderDisplayNames.ts
+var RUNTIME_PROVIDER_DISPLAY_NAMES = {
+  "anthropic": "Anthropic",
+  "deepseek": "DeepSeek",
+  "fusecode": "FuseCode",
+  "google": "Google",
+  "openai": "OpenAI",
+  "opencode": "OpenCode",
+  "opencode-go": "OpenCode Go",
+  "openrouter": "OpenRouter"
+};
+
+// ../shared/src/runtimeProviderDisplay.ts
+function getRuntimeProviderDisplayName(providerId) {
+  return RUNTIME_PROVIDER_DISPLAY_NAMES[providerId] ?? humanizeRuntimeProviderSegment(providerId);
+}
+function formatRuntimeProviderModelLabel(modelId) {
+  const separatorIndex = modelId.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === modelId.length - 1) return modelId;
+  const providerId = modelId.slice(0, separatorIndex);
+  const modelName = modelId.slice(separatorIndex + 1);
+  const providerLabel = getRuntimeProviderDisplayName(providerId);
+  const modelParts = modelName.split("/");
+  const modelLabel = humanizeRuntimeProviderSegment(modelParts[modelParts.length - 1] || modelName);
+  if (modelParts.length === 1) return `${modelLabel} \xB7 ${providerLabel}`;
+  const upstreamLabel = modelParts.slice(0, -1).map(getRuntimeProviderDisplayName).join(" / ");
+  return `${modelLabel} \xB7 ${upstreamLabel} via ${providerLabel}`;
+}
+function humanizeRuntimeProviderSegment(value) {
+  return value.replace(/\[(\d+)m\]/gi, "-$1m").split(/[-_/]/).filter(Boolean).map(formatRuntimeProviderLabelToken).join(" ");
+}
+function formatRuntimeProviderLabelToken(token) {
+  const normalized = token.toLowerCase();
+  const specialCases = {
+    ai: "AI",
+    api: "API",
+    chatgpt: "ChatGPT",
+    claude: "Claude",
+    codestral: "Codestral",
+    deepseek: "DeepSeek",
+    flash: "Flash",
+    free: "Free",
+    gemini: "Gemini",
+    glm: "GLM",
+    gpt: "GPT",
+    hy3: "HY3",
+    kimi: "Kimi",
+    minimax: "MiniMax",
+    nano: "Nano",
+    nemotron: "Nemotron",
+    omni: "Omni",
+    opus: "Opus",
+    pro: "Pro",
+    sonnet: "Sonnet",
+    super: "Super"
+  };
+  if (specialCases[normalized]) return specialCases[normalized];
+  if (normalized === "b" || normalized === "m") return normalized.toUpperCase();
+  if (/^v\d+(\.\d+)?$/.test(normalized)) return normalized.toUpperCase();
+  if (/^\d+m$/i.test(token)) return token.toUpperCase();
+  if (/^\d+[bk]$/i.test(token)) return token.toUpperCase();
+  if (/^m\d+(\.\d+)?$/i.test(token)) return token.toUpperCase();
+  if (/^\d/.test(token)) return token;
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+
 // ../shared/src/slockRefs.ts
 var SLOCK_REF_CHANNEL_NAME_PATTERN = String.raw`[\p{L}\p{N}_-]+`;
 var SLOCK_REF_USER_NAME_PATTERN = SLOCK_REF_CHANNEL_NAME_PATTERN;
@@ -1039,11 +1105,36 @@ var integrationApproveAgentLoginOperationSchema = z.object({
   scopes: z.array(z.string().trim().min(1).max(120)).max(64),
   draftHint: draftHintSchema
 });
+var integrationAppDraftFieldsSchema = z.object({
+  name: z.string().trim().min(1).max(120).optional(),
+  description: z.string().trim().max(1e3).optional(),
+  homepageUrl: z.string().trim().max(2e3).optional(),
+  returnUrl: z.string().trim().max(2e3).optional(),
+  agentManifestUrl: z.string().trim().max(2e3).optional()
+});
+var integrationRegisterAppOperationSchema = integrationAppDraftFieldsSchema.extend({
+  type: z.literal("integration:register_app"),
+  name: z.string().trim().min(1).max(120),
+  clientKey: z.string().trim().min(1).max(120),
+  returnUrl: z.string().trim().min(1).max(2e3),
+  scopes: z.array(z.string().trim().min(1).max(120)).max(64).default([]),
+  unsafeDemoUrlOverride: z.boolean().optional(),
+  draftHint: draftHintSchema
+});
+var integrationUpdateAppRegistrationOperationSchema = integrationAppDraftFieldsSchema.extend({
+  type: z.literal("integration:update_app_registration"),
+  clientKey: z.string().trim().min(1).max(120),
+  scopes: z.array(z.string().trim().min(1).max(120)).max(64).optional(),
+  unsafeDemoUrlOverride: z.boolean().optional(),
+  draftHint: draftHintSchema
+});
 var actionCardActionSchema = z.discriminatedUnion("type", [
   channelCreateOperationSchema,
   agentCreateOperationSchema,
   channelAddMemberOperationSchema,
-  integrationApproveAgentLoginOperationSchema
+  integrationApproveAgentLoginOperationSchema,
+  integrationRegisterAppOperationSchema,
+  integrationUpdateAppRegistrationOperationSchema
 ]);
 
 // ../shared/src/agentInbox.ts
@@ -1362,9 +1453,9 @@ var RUNTIME_MODELS = {
   ],
   opencode: [
     { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
-    { id: "deepseek/deepseek-v4-pro", label: "DeepSeek V4 Pro (OpenCode)", verified: "suggestion_only" },
-    { id: "openrouter/anthropic/claude-opus-4.5", label: "Claude Opus 4.5 via OpenRouter", verified: "suggestion_only" },
-    { id: "fusecode/opus[1m]", label: "Opus 1M via FuseCode", verified: "suggestion_only" }
+    { id: "deepseek/deepseek-v4-pro", label: formatRuntimeProviderModelLabel("deepseek/deepseek-v4-pro"), verified: "suggestion_only" },
+    { id: "openrouter/anthropic/claude-opus-4.5", label: formatRuntimeProviderModelLabel("openrouter/anthropic/claude-opus-4.5"), verified: "suggestion_only" },
+    { id: "fusecode/opus[1m]", label: formatRuntimeProviderModelLabel("fusecode/opus[1m]"), verified: "suggestion_only" }
   ],
   pi: [
     { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" }
@@ -1530,6 +1621,11 @@ function runtimeConfigToLaunchFields(config) {
     ...normalized.command ? { command: normalized.command } : {}
   };
 }
+var PRO_SEAT_MONTHLY_USD = 10;
+var PRO_AGENT_SEAT_BLOCK_SIZE = 10;
+var PRO_AGENT_SEAT_FRACTION = 1 / PRO_AGENT_SEAT_BLOCK_SIZE;
+var PRO_SEAT_ANNUAL_MONTHLY_USD = 8.8;
+var PRO_PACK_AGENT_SEATS = PRO_AGENT_SEAT_BLOCK_SIZE;
 var PLAN_CONFIG = {
   free: {
     displayName: "Free",
@@ -1556,9 +1652,9 @@ var PLAN_CONFIG = {
   },
   pro: {
     displayName: "Pro",
-    limits: { maxMachines: -1, maxAgents: 10, maxChannels: -1, messageHistoryDays: -1, includedAgents: 10 },
+    limits: { maxMachines: -1, maxAgents: PRO_PACK_AGENT_SEATS, maxChannels: -1, messageHistoryDays: -1, includedAgents: PRO_PACK_AGENT_SEATS },
     comingSoon: false,
-    price: 20,
+    price: PRO_SEAT_MONTHLY_USD,
     extraAgentPrice: 0
   }
 };
@@ -1568,8 +1664,8 @@ var DISPLAY_PLAN_CONFIG = {
     displayName: "Pro",
     limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: -1, includedAgents: -1 },
     comingSoon: false,
-    price: 20,
-    priceCadence: "/ seat pack / month",
+    price: PRO_SEAT_MONTHLY_USD,
+    priceCadence: "/ seat / month",
     extraAgentPrice: 0,
     displayFeatures: [
       "Everything in Free",
@@ -1579,7 +1675,7 @@ var DISPLAY_PLAN_CONFIG = {
       "More professional features coming soon"
     ],
     displayDescription: "For builders and teams scaling agent collaboration.",
-    displayNote: "$17.60 / seat pack / month when billed yearly"
+    displayNote: `$${PRO_SEAT_ANNUAL_MONTHLY_USD.toFixed(2)} / seat / month when billed yearly. Each human uses 1 seat; each agent uses ${PRO_AGENT_SEAT_FRACTION} seat.`
   },
   enterprise: {
     displayName: "Enterprise",
@@ -3426,6 +3522,7 @@ function latestVisibleMessages(messages, limit) {
   return sorted.slice(Math.max(0, sorted.length - limit));
 }
 function isMessageModelSeen(input, message) {
+  if (messageSenderId(message) === input.agentId) return true;
   const seq = Math.floor(messageSeq(message));
   if (Number.isFinite(seq) && seq > 0 && typeof input.modelSeenSeq === "number" && input.modelSeenSeq >= seq) return true;
   return input.isMessageModelSeen?.({ target: input.target, message }) === true;
@@ -8047,14 +8144,6 @@ var SLOCK_AGENT_NAME = "slock";
 var NO_MESSAGE_PROMPT = "No new messages are pending. Stop now.";
 var FIRST_MESSAGE_TASK_PREFIX = "First message task (system-triggered):";
 var MIN_SUPPORTED_OPENCODE_VERSION = "1.14.30";
-var OPENCODE_PROVIDER_LABELS = {
-  opencode: "OpenCode",
-  "opencode-go": "OpenCode Go",
-  openai: "OpenAI",
-  openrouter: "OpenRouter",
-  deepseek: "DeepSeek",
-  fusecode: "FuseCode"
-};
 function parseOpenCodeConfigContent(raw) {
   if (!raw) return {};
   try {
@@ -8192,62 +8281,12 @@ function parseOpenCodeModelsOutput(output) {
     seen.add(line);
     models.push({
       id: line,
-      label: formatOpenCodeModelLabel(line),
+      label: formatRuntimeProviderModelLabel(line),
       verified: "launchable"
     });
   }
   return models.length > 0 ? { models } : null;
 }
-function formatOpenCodeModelLabel(modelId) {
-  const separatorIndex = modelId.indexOf("/");
-  if (separatorIndex <= 0 || separatorIndex === modelId.length - 1) return modelId;
-  const providerId = modelId.slice(0, separatorIndex);
-  const modelName = modelId.slice(separatorIndex + 1);
-  const providerLabel = OPENCODE_PROVIDER_LABELS[providerId] || humanizeOpenCodeSegment(providerId);
-  const modelParts = modelName.split("/");
-  const modelLabel = humanizeOpenCodeSegment(modelParts[modelParts.length - 1] || modelName);
-  if (modelParts.length === 1) return `${modelLabel} \xB7 ${providerLabel}`;
-  const upstreamLabel = modelParts.slice(0, -1).map(humanizeOpenCodeSegment).join(" / ");
-  return `${modelLabel} \xB7 ${upstreamLabel} via ${providerLabel}`;
-}
-function humanizeOpenCodeSegment(value) {
-  return value.replace(/\[(\d+)m\]/gi, "-$1m").split(/[-_]/).filter(Boolean).map(formatOpenCodeLabelToken).join(" ");
-}
-function formatOpenCodeLabelToken(token) {
-  const normalized = token.toLowerCase();
-  const specialCases = {
-    ai: "AI",
-    api: "API",
-    b: "B",
-    chatgpt: "ChatGPT",
-    claude: "Claude",
-    codestral: "Codestral",
-    deepseek: "DeepSeek",
-    flash: "Flash",
-    free: "Free",
-    gemini: "Gemini",
-    glm: "GLM",
-    gpt: "GPT",
-    hy3: "HY3",
-    kimi: "Kimi",
-    m: "M",
-    minimax: "MiniMax",
-    nano: "Nano",
-    nemotron: "Nemotron",
-    omni: "Omni",
-    opus: "Opus",
-    pro: "Pro",
-    sonnet: "Sonnet",
-    super: "Super"
-  };
-  if (specialCases[normalized]) return specialCases[normalized];
-  if (/^v\d+(\.\d+)?$/.test(normalized)) return normalized.toUpperCase();
-  if (/^\d+m$/i.test(token)) return token.toUpperCase();
-  if (/^\d+[bk]$/i.test(token)) return token.toUpperCase();
-  if (/^m\d+(\.\d+)?$/i.test(token)) return token.toUpperCase();
-  if (/^\d/.test(token)) return token;
-  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
-}
 function detectOpenCodeModels(home = os5.homedir(), runCommand = runOpenCodeModelsCommand) {
   const commandResult = runCommand(home);
   if (commandResult.error || commandResult.status !== 0) return null;
@@ -8530,12 +8569,6 @@ import {
 } from "@earendil-works/pi-coding-agent";
 var PI_SESSION_DIR = ".pi-sessions";
 var PI_SDK_COMPACTION_ENABLED = true;
-var PI_PROVIDER_LABELS = {
-  google: "Google",
-  openai: "OpenAI",
-  openrouter: "OpenRouter",
-  deepseek: "DeepSeek"
-};
 function createPiSdkEventMappingState(sessionId = null) {
   return {
     sessionId,
@@ -8577,7 +8610,7 @@ function detectPiModelsFromRegistry(modelRegistry) {
     seen.add(id);
     models.push({
       id,
-      label: `${model.name || humanizePiSegment(model.id)} \xB7 ${PI_PROVIDER_LABELS[model.provider] || humanizePiSegment(model.provider)}`,
+      label: `${model.name || humanizeRuntimeProviderSegment(model.id)} \xB7 ${getRuntimeProviderDisplayName(model.provider)}`,
       verified: "launchable"
     });
   }
@@ -8648,25 +8681,6 @@ async function detectPiModels(modelRegistry, traceContext = {}) {
   );
   return result;
 }
-function humanizePiSegment(value) {
-  return value.split(/[-_/]/).filter(Boolean).map(formatPiLabelToken).join(" ");
-}
-function formatPiLabelToken(token) {
-  const normalized = token.toLowerCase();
-  const specialCases = {
-    ai: "AI",
-    api: "API",
-    flash: "Flash",
-    gpt: "GPT",
-    pro: "Pro",
-    v4: "V4"
-  };
-  if (specialCases[normalized]) return specialCases[normalized];
-  if (/^v\d+(\.\d+)?$/.test(normalized)) return normalized.toUpperCase();
-  if (/^\d+[bk]$/i.test(token)) return token.toUpperCase();
-  if (/^\d/.test(token)) return token;
-  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
-}
 function piErrorMessage(error) {
   if (typeof error === "string" && error.trim()) return error.trim();
   if (error && typeof error === "object") {
@@ -9895,6 +9909,33 @@ function runnerCredentialErrorDetail(error) {
 async function waitForRunnerCredentialRetry() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS));
 }
+function probeSubprocessOsState(pid) {
+  if (typeof pid !== "number") return "unknown";
+  try {
+    const status = readFileSync6(`/proc/${pid}/status`, "utf8");
+    const match = status.match(/^State:\s+(\S)/m);
+    if (match) {
+      const code = match[1];
+      if (code === "R") return "running";
+      if (code === "S") return "sleeping";
+      if (code === "D") return "uninterruptible_sleep";
+      if (code === "Z") return "zombie";
+      if (code === "T" || code === "t") return "stopped";
+    }
+    return "unknown";
+  } catch {
+    return "gone";
+  }
+}
+function bucketMs(ms) {
+  if (ms < 1e3) return "<1s";
+  if (ms < 1e4) return "1-10s";
+  if (ms < 6e4) return "10-60s";
+  if (ms < 3e5) return "1-5m";
+  if (ms < 9e5) return "5-15m";
+  if (ms < 36e5) return "15-60m";
+  return ">60m";
+}
 function stalledRecoverySigtermTimeoutMs() {
   return readNonNegativeIntegerEnv(
     "SLOCK_DAEMON_STALLED_RECOVERY_SIGTERM_TIMEOUT_MS",
@@ -10300,6 +10341,7 @@ var STDIN_NOTIFICATION_INITIAL_DELAY_MS = 3e3;
 var STDIN_NOTIFICATION_RETRY_DELAY_MS = 15e3;
 var RUNTIME_ERROR_DELIVERY_BACKOFF_BASE_MS = 1e4;
 var RUNTIME_ERROR_DELIVERY_BACKOFF_MAX_MS = 5 * 6e4;
+var RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD = 3;
 var SPAWN_FAIL_BACKOFF_BASE_MS = 1e3;
 var SPAWN_FAIL_BACKOFF_MAX_MS = 3e4;
 var SPAWN_FAIL_BACKOFF_THRESHOLD = 3;
@@ -11209,6 +11251,7 @@ var AgentProcessManager = class _AgentProcessManager {
   agentStartIntervalMs;
   startingInboxes = /* @__PURE__ */ new Map();
   terminalRuntimeFailures = /* @__PURE__ */ new Map();
+  runtimeErrorFingerprintFences = /* @__PURE__ */ new Map();
   pendingStartRebinds = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
   idleAgentConfigs = /* @__PURE__ */ new Map();
@@ -11236,11 +11279,13 @@ var AgentProcessManager = class _AgentProcessManager {
   // BEFORE ap exists; rate-state must persist across stop/respawn so churn can't bypass).
   // Explicit stop clears (fresh launch resets dedup clock — CC1 lifecycle pattern); silent
   // stop preserves (same-launch respawn must keep counter or churn bypasses the cap).
+  pendingSpawnCause = /* @__PURE__ */ new Map();
   agentSpawnFailBackoff = /* @__PURE__ */ new Map();
   daemonVersion;
   computerVersion;
   workerUrl;
   fetchImpl;
+  serverConnected;
   constructor(sendToServer, daemonApiKey, opts) {
     this.slockCliPath = opts.slockCliPath ?? "";
     this.sendToServer = sendToServer;
@@ -11256,6 +11301,7 @@ var AgentProcessManager = class _AgentProcessManager {
     this.computerVersion = opts.computerVersion?.trim() || null;
     this.workerUrl = opts.workerUrl?.trim() || null;
     this.fetchImpl = opts.fetchImpl ?? daemonFetch;
+    this.serverConnected = opts.serverConnected ?? (() => true);
     this.stdinNotificationRetryMs = Math.max(
       0,
       Math.floor(opts.stdinNotificationRetryMs ?? STDIN_NOTIFICATION_RETRY_DELAY_MS)
@@ -11372,6 +11418,94 @@ var AgentProcessManager = class _AgentProcessManager {
     if (state.timer) clearTimeout(state.timer);
     this.agentSpawnFailBackoff.delete(agentId);
   }
+  // ----- RUNTIME-ERROR FINGERPRINT FENCE (per-agent) ---------------------
+  // The delivery backoff above is scoped to AgentProcess and is cleared when a
+  // runtime process exits. Recoverable terminal errors intentionally keep an
+  // idle restart cache so the next message can wake the agent, but that also
+  // means a deterministic same-fingerprint runtime error can close/restart
+  // forever. Keep this counter outside AgentProcess and reset only on real turn
+  // progress or explicit stop.
+  runtimeErrorFingerprintFenceResetEvent(eventKind) {
+    switch (eventKind) {
+      case "thinking":
+      case "text":
+      case "tool_call":
+      case "tool_output":
+      case "compaction_finished":
+      case "review_finished":
+      case "turn_end":
+        return true;
+      default:
+        return false;
+    }
+  }
+  resetRuntimeErrorFingerprintFence(agentId, resetSource, ap) {
+    const state = this.runtimeErrorFingerprintFences.get(agentId);
+    if (!state) return;
+    this.runtimeErrorFingerprintFences.delete(agentId);
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence.reset", {
+      agentId,
+      runtime: ap?.config.runtime,
+      model: ap?.config.model,
+      launchId: ap?.launchId || state.launchId || void 0,
+      fingerprint: state.fingerprint,
+      attempts: state.attempts,
+      reset_source: resetSource
+    });
+  }
+  formatRuntimeErrorFingerprintFenceDetail(state) {
+    return [
+      `Runtime stopped after ${state.attempts} repeated runtime errors with the same fingerprint (${state.fingerprint}).`,
+      `Last error: ${state.lastRuntimeError}`,
+      "Restart after the runtime/tooling issue is fixed."
+    ].join(" ");
+  }
+  noteRuntimeErrorFingerprintFence(agentId, ap, message, fingerprint, terminalFailure, stickyTerminalFailure) {
+    if (!fingerprint) return null;
+    if (stickyTerminalFailure || terminalFailure?.actionRequired) return null;
+    let state = this.runtimeErrorFingerprintFences.get(agentId);
+    if (!state || state.fingerprint !== fingerprint) {
+      state = {
+        fingerprint,
+        attempts: 0,
+        lastRuntimeError: message,
+        detail: "",
+        launchId: ap.launchId
+      };
+      this.runtimeErrorFingerprintFences.set(agentId, state);
+    }
+    state.attempts += 1;
+    state.lastRuntimeError = message;
+    state.launchId = ap.launchId;
+    state.detail = this.formatRuntimeErrorFingerprintFenceDetail(state);
+    const fenced = state.attempts >= RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD;
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      fingerprint,
+      attempts: state.attempts,
+      threshold: RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD,
+      fenced,
+      runtime_error_class: buildRuntimeErrorDiagnosticEnvelope(message).spanAttrs.runtime_error_class
+    }, fenced ? "error" : "ok");
+    return fenced ? state : null;
+  }
+  applyRuntimeErrorFingerprintFence(agentId, ap, state) {
+    this.recordDaemonTrace("daemon.agent.runtime_error_fingerprint_fence.tripped", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      fingerprint: state.fingerprint,
+      attempts: state.attempts,
+      threshold: RUNTIME_ERROR_FINGERPRINT_FENCE_THRESHOLD
+    }, "error");
+    this.idleAgentConfigs.delete(agentId);
+    this.sendAgentStatus(agentId, "inactive", ap.launchId);
+    this.cleanupTerminalRuntimeFailure(agentId, ap, state.detail);
+  }
   scheduleStdinNotification(agentId, ap, delayMs) {
     return ap.notifications.schedule(() => {
       this.sendStdinNotification(agentId);
@@ -11925,6 +12059,18 @@ var AgentProcessManager = class _AgentProcessManager {
     });
     span.end(status);
   }
+  processLifecycleIdentityAttrs(agentId, ap) {
+    const runtimeContext = ap.config.runtimeContext;
+    return {
+      agent_id: agentId,
+      server_id: runtimeContext?.serverId,
+      machine_id: runtimeContext?.machineId,
+      process_instance_id: ap.processInstanceId,
+      runtime: ap.config.runtime,
+      runtime_version: runtimeContext?.daemonVersion,
+      pid: typeof ap.runtime.pid === "number" ? ap.runtime.pid : void 0
+    };
+  }
   startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
     return {
       agentId,
@@ -12343,6 +12489,7 @@ var AgentProcessManager = class _AgentProcessManager {
       let prompt;
       let promptSource;
       let wakeMessageDeliveredAsInboxUpdate = false;
+      let startingInboxDeliveredAsInput = false;
       const startingInboxMessages = this.startingInboxes.get(agentId) || [];
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
@@ -12383,6 +12530,10 @@ You also have unread messages in other channels:`;
 Use the inbox/read commands at a natural breakpoint if you choose to inspect those targets.`;
           }
         }
+      } else if (startingInboxMessages.length > 0) {
+        startingInboxDeliveredAsInput = true;
+        prompt = this.formatInboxUpdateRuntimeInput(startingInboxMessages, driver);
+        promptSource = "starting_inbox_update";
       } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
         prompt = `You have unread messages from while you were offline:`;
         for (const [ch, count] of Object.entries(unreadSummary)) {
@@ -12459,6 +12610,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       };
       const initialSessionId = this.initialAgentProcessSessionId(driver, liveProcessConfig);
       const restartSessionId = initialSessionId || (driver.requiresSessionInitForDelivery ? liveProcessConfig.sessionId || null : null);
+      const processInstanceId = randomUUID5();
       agentProcess = {
         runtime,
         driver,
@@ -12488,6 +12640,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         runtimeErrorSinceProgress: false,
         runtimeErrorDeliveryBackoff: createRuntimeErrorDeliveryBackoffState(),
         spawnError: null,
+        processInstanceId,
+        spawnedAtMs: Date.now(),
         exitCode: null,
         exitSignal: null,
         stalledRecoverySigtermTimer: null,
@@ -12512,6 +12666,10 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       }
       if (wakeMessageDeliveredAsInboxUpdate) {
         this.recordInboxUpdateProjection(agentId, agentProcess, agentProcess.inbox, "spawn_wake_inbox_update", "wake", prompt);
+      } else if (startingInboxDeliveredAsInput) {
+        this.recordInboxUpdateProjection(agentId, agentProcess, startingInboxMessages, "spawn_starting_inbox_update", "wake", prompt);
+        this.consumeVisibleMessages(agentId, { messages: startingInboxMessages, source: "spawn_starting_inbox_update" });
+        this.ackInjectedRuntimeProfileMessages(agentId, startingInboxMessages, agentProcess.launchId);
       } else if (wakeMessage && !wakeMessageTransient) {
         this.consumeVisibleMessages(agentId, { messages: [wakeMessage], source: "spawn_wake_message" });
         this.ackInjectedRuntimeProfileMessages(agentId, [wakeMessage], agentProcess.launchId);
@@ -12574,6 +12732,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           current.exitCode = code;
           current.exitSignal = signal;
         }
+        const exitTraceAttrs = this.runtimeExitTraceAttrs.get(runtime);
         this.recordDaemonTrace("daemon.agent.process.exited", {
           agentId,
           launchId: current?.launchId || void 0,
@@ -12585,8 +12744,22 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           runtime_trace_active: Boolean(current?.runtimeTraceSpan),
           inbox_count: current?.inbox.length ?? 0,
           pending_notification_count: current?.notifications.pendingCount ?? 0,
-          ...this.runtimeExitTraceAttrs.get(runtime)
+          ...exitTraceAttrs
         });
+        if (agentProcess) {
+          const stopSource = exitTraceAttrs?.stop_source;
+          const exitCause = stopSource?.includes("stall") ? "stall_kill" : stopSource === "disconnect" ? "disconnect_kill" : stopSource === "daemon_exit" ? "parent_exit" : stopSource === "explicit_request" || stopSource === "daemon_internal" || code === 0 ? "expected_terminate" : "crash";
+          const staleForMs = agentProcess.runtimeProgress.ageMs();
+          this.recordDaemonTrace("daemon.runtime.process.exit", {
+            ...this.processLifecycleIdentityAttrs(agentId, agentProcess),
+            exit_code: code,
+            exit_signal: signal,
+            cause: exitCause,
+            last_event_kind: agentProcess.lastActivity || void 0,
+            last_event_age_ms_bucket: bucketMs(staleForMs),
+            uptime_ms_bucket: bucketMs(Date.now() - agentProcess.spawnedAtMs)
+          }, code === 0 ? "ok" : "error");
+        }
         logger.info(`[Agent ${agentId}] Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}`);
       });
       runtime.on("close", ({ code, signal }) => {
@@ -12650,6 +12823,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
                 text: `Stored ${runtimeLabel} session ${staleSessionId} ${reasonText}. Falling back to a cold start; earlier runtime context may not be restored.`
               }]
             );
+            this.pendingSpawnCause.set(agentId, "restart_crash");
             this.startAgent(
               agentId,
               restartConfig,
@@ -12659,6 +12833,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
               ap.launchId || void 0
             ).catch((err) => {
               logger.error(`[Agent ${agentId}] Cold start recovery failed`, err);
+              this.pendingSpawnCause.delete(agentId);
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
               this.broadcastActivity(agentId, "offline", `Crashed (${summary})`, [], ap.launchId);
             });
@@ -12685,6 +12860,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
               });
               this.broadcastActivity(agentId, "working", "Message received");
               this.idleAgentConfigs.delete(agentId);
+              if (expectedTerminationReason === "stalled_recovery") {
+                this.pendingSpawnCause.set(agentId, "restart_stall");
+              }
               this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2, void 0, ap.launchId || void 0).catch((err) => {
                 logger.error(`[Agent ${agentId}] Failed to continue with queued message`, err);
                 if (this.reportRunnerCredentialMintFailure(agentId, err, ap.launchId, "queued_continuation")) {
@@ -12769,6 +12947,16 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         new_session: false,
         process_pid_present: typeof runtime.pid === "number"
       });
+      const pendingCause = this.pendingSpawnCause.get(agentId);
+      this.pendingSpawnCause.delete(agentId);
+      const startCause = pendingCause ?? (isResume ? "session_resume" : wakeMessage ? "wake_message" : "explicit_start");
+      this.recordDaemonTrace("daemon.runtime.process.spawn", {
+        ...this.processLifecycleIdentityAttrs(agentId, agentProcess),
+        start_cause: startCause,
+        credential_type: effectiveConfig.agentCredentialKey ? "managed_runner" : "legacy_machine",
+        session_id_present: Boolean(agentProcess.sessionId),
+        launch_id_present: Boolean(agentProcess.launchId)
+      });
       this.sendAgentStatus(agentId, "active", agentProcess.launchId);
       if (pendingStartRebind && agentProcess.sessionId) {
         this.sendToServer({ type: "agent:session", agentId, sessionId: agentProcess.sessionId, launchId: agentProcess.launchId || void 0 });
@@ -13123,6 +13311,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.agentVisibleBoundaries.delete(agentId);
       this.agentVisibleMessageIds.delete(agentId);
       this.resetSpawnFailBackoff(agentId);
+      this.resetRuntimeErrorFingerprintFence(agentId, "explicit_stop", ap);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
@@ -13307,6 +13496,19 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           return false;
         });
       }
+      if (!transientDelivery && (this.queuedAgentStarts.has(agentId) || this.agentsStarting.has(agentId))) {
+        const pending = this.startingInboxes.get(agentId) || [];
+        pending.push(message);
+        this.startingInboxes.set(agentId, pending);
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: this.agentsStarting.has(agentId) ? "queued_for_starting_process" : "queued_for_queued_start",
+          accepted: true,
+          process_present: false,
+          cached_idle_config_present: false,
+          starting_inbox_count: pending.length
+        }));
+        return true;
+      }
       logger.warn(`[Agent ${agentId}] Delivery received but no running process or cached idle config exists`);
       if (transientDelivery) {
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
@@ -14307,26 +14509,18 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     if (!hasToolStart) {
       entries.push({ kind: "status", activity, detail });
     }
+    const launchId = launchIdOverride || ap?.launchId || void 0;
+    const clientSeq = ap ? this.nextActivityClientSeq(agentId) : void 0;
     this.sendToServer({
       type: "agent:activity",
       agentId,
       activity,
       detail,
       entries,
-      launchId: launchIdOverride || ap?.launchId || void 0,
-      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
-    });
-    this.recordDaemonTrace("daemon.agent.activity.produced", {
-      agentId,
-      activity,
-      detail_present: Boolean(detail),
-      entry_kinds: entries.map((e) => e.kind).join(","),
-      ap_present: Boolean(ap),
-      launch_id_present: Boolean(launchIdOverride || ap?.launchId),
-      client_seq_present: ap ? true : false,
-      session_id_present: Boolean(ap?.sessionId),
-      runtime: ap?.config.runtime
+      launchId,
+      clientSeq
     });
+    this.recordActivityProducedTrace(agentId, activity, detail, entries, ap, launchId, clientSeq);
     if (ap) {
       ap.lastActivity = activity;
       ap.lastActivityDetail = detail;
@@ -14337,14 +14531,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             this.recordRuntimeTraceEvent(agentId, ap, "activity.heartbeat.sent", {
               activity: ap.lastActivity
             });
+            const heartbeatLaunchId = launchIdOverride || ap.launchId || void 0;
+            const heartbeatClientSeq = this.nextActivityClientSeq(agentId);
             this.sendToServer({
               type: "agent:activity",
               agentId,
               activity: ap.lastActivity,
               detail: ap.lastActivityDetail,
-              launchId: launchIdOverride || ap.launchId || void 0,
-              clientSeq: this.nextActivityClientSeq(agentId)
+              launchId: heartbeatLaunchId,
+              clientSeq: heartbeatClientSeq
             });
+            this.recordActivityProducedTrace(agentId, ap.lastActivity, ap.lastActivityDetail, [], ap, heartbeatLaunchId, heartbeatClientSeq);
           }, ACTIVITY_HEARTBEAT_MS);
         }
       } else {
@@ -14355,6 +14552,29 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       }
     }
   }
+  recordActivityProducedTrace(agentId, activity, detail, entries, ap, launchId, clientSeq) {
+    const runtimeContext = ap?.config.runtimeContext;
+    this.recordDaemonTrace("daemon.agent.activity.produced", {
+      agentId,
+      agent_id: agentId,
+      server_id: runtimeContext?.serverId,
+      machine_id: runtimeContext?.machineId,
+      process_instance_id: ap?.processInstanceId,
+      activity,
+      detail_present: Boolean(detail),
+      entry_kinds: entries.map((e) => e.kind).join(","),
+      ap_present: Boolean(ap),
+      launchId,
+      launch_id: launchId,
+      launch_id_present: Boolean(launchId),
+      clientSeq,
+      client_seq: clientSeq,
+      client_seq_present: typeof clientSeq === "number",
+      correlation_id: `agent:${agentId}:daemonActivity:${launchId ?? "legacy"}:${clientSeq ?? "unsequenced"}`,
+      session_id_present: Boolean(ap?.sessionId),
+      runtime: ap?.config.runtime
+    });
+  }
   /**
    * Respond to a server-issued `agent:activity_probe`. Echoes the
    * agent's current `lastActivity` back through the existing
@@ -14380,15 +14600,18 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     const ap = this.agents.get(agentId);
     const activity = ap?.lastActivity || "offline";
     const detail = ap?.lastActivityDetail || (ap ? "" : "Agent not running");
+    const launchId = ap?.launchId || void 0;
+    const clientSeq = ap ? this.nextActivityClientSeq(agentId) : void 0;
     this.sendToServer({
       type: "agent:activity",
       agentId,
       activity,
       detail,
-      launchId: ap?.launchId || void 0,
+      launchId,
       probeId,
-      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
+      clientSeq
     });
+    this.recordActivityProducedTrace(agentId, activity, detail, [], ap, launchId, clientSeq);
   }
   flushPendingTrajectory(agentId) {
     const ap = this.agents.get(agentId);
@@ -14488,6 +14711,12 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       );
       try {
         void runtimeAtSignal.stop({ signal: "SIGKILL", reason: "stalled_recovery_sigterm_timeout" });
+        this.recordDaemonTrace("daemon.runtime.stall.recovery_action", {
+          ...this.processLifecycleIdentityAttrs(agentId, current),
+          action: "sigkill_escalation",
+          outcome: "initiated",
+          delay_ms_bucket: bucketMs(timeoutMs)
+        }, "error");
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         this.recordDaemonTrace("daemon.agent.stalled_recovery.sigkill_failed", {
@@ -14497,6 +14726,16 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           model: current.config.model,
           reason
         }, "error");
+        this.recordDaemonTrace("daemon.runtime.stall.recovery_action", {
+          ...this.processLifecycleIdentityAttrs(agentId, current),
+          action: "sigkill_escalation",
+          outcome: "kill_failed",
+          delay_ms_bucket: bucketMs(timeoutMs),
+          kill_signal_sequence: "SIGTERM,SIGKILL",
+          kill_attempts: 2,
+          subprocess_os_state: probeSubprocessOsState(current.runtime.pid),
+          daemon_child_tracking_present: this.agents.has(agentId)
+        }, "error");
         logger.warn(`[Agent ${agentId}] Failed to force kill stalled ${runtimeLabel} process: ${reason}`);
       }
     }, timeoutMs);
@@ -15036,6 +15275,23 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
+    let subprocessPidAlive;
+    if (typeof ap.runtime.pid === "number") {
+      try {
+        process.kill(ap.runtime.pid, 0);
+        subprocessPidAlive = true;
+      } catch {
+        subprocessPidAlive = false;
+      }
+    }
+    this.recordDaemonTrace("daemon.runtime.stall.detected", {
+      ...this.processLifecycleIdentityAttrs(agentId, ap),
+      last_event_kind: ap.lastActivity || void 0,
+      last_event_age_ms_bucket: bucketMs(staleForMs),
+      subprocess_pid_alive: subprocessPidAlive,
+      subprocess_socket_alive: !ap.runtime.closed,
+      daemon_connected_to_server: this.serverConnected()
+    }, "error");
     this.broadcastActivity(agentId, "error", diagnostic.detail);
     return true;
   }
@@ -15087,9 +15343,25 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.runtimeExitTraceAttrs.set(ap.runtime, projection.processExitAttrs);
       this.startStalledRecoverySigtermWatchdog(agentId, ap, runtimeLabel, ap.inbox.length, staleForMs);
       void ap.runtime.stop({ signal: "SIGTERM", reason: projection.runtimeStopReason });
+      this.recordDaemonTrace("daemon.runtime.stall.recovery_action", {
+        ...this.processLifecycleIdentityAttrs(agentId, ap),
+        action: "terminate_for_restart",
+        outcome: "initiated",
+        delay_ms_bucket: bucketMs(staleForMs)
+      });
     } catch (err) {
       this.clearStalledRecoverySigtermWatchdog(ap);
       const reason = err instanceof Error ? err.message : String(err);
+      this.recordDaemonTrace("daemon.runtime.stall.recovery_action", {
+        ...this.processLifecycleIdentityAttrs(agentId, ap),
+        action: "terminate_for_restart",
+        outcome: "kill_failed",
+        delay_ms_bucket: bucketMs(staleForMs),
+        kill_signal_sequence: "SIGTERM",
+        kill_attempts: 1,
+        subprocess_os_state: probeSubprocessOsState(ap.runtime.pid),
+        daemon_child_tracking_present: this.agents.has(agentId)
+      }, "error");
       logger.warn(`[Agent ${agentId}] Failed to terminate stalled ${runtimeLabel} process: ${reason}`);
       return false;
     }
@@ -15168,6 +15440,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         return;
       }
       this.noteRuntimeProgress(ap, event.kind);
+      if (this.runtimeErrorFingerprintFenceResetEvent(event.kind)) {
+        this.resetRuntimeErrorFingerprintFence(agentId, `runtime_progress:${event.kind}`, ap);
+      }
       recordProgressObservedAfterStall();
     } else if (event.kind !== "internal_progress") {
       this.recordDaemonTrace("daemon.agent.event.received_without_process", {
@@ -15360,6 +15635,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         let visibleErrorMessage = event.message;
         if (ap) {
           const runtimeErrorDiagnostics = buildRuntimeErrorDiagnosticEnvelope(event.message);
+          const runtimeErrorFingerprint = typeof runtimeErrorDiagnostics.spanAttrs.runtime_error_fingerprint === "string" ? runtimeErrorDiagnostics.spanAttrs.runtime_error_fingerprint : null;
           if (runtimeErrorDiagnostics.spanAttrs.runtime_error_action_required === true) {
             visibleErrorMessage = formatRuntimeLoginRequiredMessage(ap.driver.id);
           }
@@ -15376,6 +15652,17 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             terminalWakeable: Boolean(ap.driver.supportsStdinNotification && terminalFailure && !terminalFailure.actionRequired)
           });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "error" });
+          const fingerprintFence = this.noteRuntimeErrorFingerprintFence(
+            agentId,
+            ap,
+            event.message,
+            runtimeErrorFingerprint,
+            terminalFailure,
+            stickyTerminalFailure
+          );
+          if (fingerprintFence) {
+            visibleErrorMessage = fingerprintFence.detail;
+          }
           this.noteRuntimeErrorDeliveryBackoff(agentId, ap, event.message, terminalFailure, stickyTerminalFailure, backoffReasonOverride);
           if (reduction.shouldDisableToolBoundaryFlush) {
             this.recordGatedSteeringEvent(agentId, ap, "disabled", {
@@ -15396,7 +15683,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
-          if (ap.driver.supportsStdinNotification && terminalFailure) {
+          if (fingerprintFence) {
+            this.applyRuntimeErrorFingerprintFence(agentId, ap, fingerprintFence);
+          } else if (ap.driver.supportsStdinNotification && terminalFailure) {
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
               try {
@@ -16430,7 +16719,13 @@ var DIAGNOSTIC_ID_ATTRS = /* @__PURE__ */ new Set([
   "bundleId",
   "deliveryId",
   "deliveryCorrelationId",
-  "delivery_correlation_id"
+  "delivery_correlation_id",
+  "agent_id",
+  "server_id",
+  "machine_id",
+  "process_instance_id",
+  "launch_id",
+  "correlation_id"
 ]);
 var DIAGNOSTIC_ERROR_ATTRS = /* @__PURE__ */ new Set([
   "runtime_error_class",
@@ -16680,6 +16975,21 @@ 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 ALLOWED_PRODUCER_DEPLOYMENT_ENVIRONMENTS = /* @__PURE__ */ new Set([
+  "production",
+  "staging",
+  "dev",
+  "test",
+  "slockdev"
+]);
+function readProducerDeploymentEnvironment() {
+  const raw = process.env.SLOCK_DAEMON_DEPLOYMENT_ENV;
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (!ALLOWED_PRODUCER_DEPLOYMENT_ENVIRONMENTS.has(trimmed)) return void 0;
+  return trimmed;
+}
 var DaemonTraceBundleUploader = class {
   options;
   jitter;
@@ -16798,7 +17108,11 @@ var DaemonTraceBundleUploader = class {
         attestationMetadata: {
           bundleId,
           bundleSha256,
-          bundleSizeBytes: gzipped.byteLength
+          bundleSizeBytes: gzipped.byteLength,
+          ...(() => {
+            const env = readProducerDeploymentEnvironment();
+            return env ? { deploymentEnvironment: env } : {};
+          })()
         },
         createBody: {
           bundleSha256,
@@ -16891,9 +17205,10 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     eventAttrs: {
       "daemon.receive": ["seq", "deliveryId"],
       "daemon.deliver_to_agent_manager": ["accepted"],
+      "daemon.delivery.buffered_for_start": ["pending_count"],
       "daemon.ack.sent": ["seq"]
     },
-    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class"]
+    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class", "pending_count"]
   },
   "daemon.runtime_profile.control.received": {
     spanAttrs: ["agentId", "control_kind", "key_present", "launchId"],
@@ -16930,7 +17245,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["running_agents_count", "idle_agents_count"]
   },
   "daemon.agent.activity.produced": {
-    spanAttrs: ["agentId", "activity", "detail_present", "entry_kinds", "ap_present", "launch_id_present", "client_seq_present", "session_id_present", "runtime"]
+    spanAttrs: ["agentId", "agent_id", "server_id", "machine_id", "activity", "detail_present", "entry_kinds", "ap_present", "launchId", "launch_id", "launch_id_present", "clientSeq", "client_seq", "client_seq_present", "correlation_id", "session_id_present", "runtime"]
   },
   "daemon.agent.activity.skipped": {
     spanAttrs: ["agentId", "event_kind", "reason", "text_length"]
@@ -17014,7 +17329,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-KC6QHBPD.js");
+  await import("./dist-S7UP42L2.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -17177,6 +17492,8 @@ var DaemonCore = class {
   observedMachineId = null;
   localTraceSink = null;
   traceBundleUploader = null;
+  coreStartingAgentIds = /* @__PURE__ */ new Set();
+  coreStartPendingDeliveries = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
@@ -17202,7 +17519,8 @@ var DaemonCore = class {
       tracer: this.tracer,
       daemonVersion: this.daemonVersion,
       computerVersion: this.computerVersion,
-      workerUrl: traceUploadDisabled ? void 0 : process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL
+      workerUrl: traceUploadDisabled ? void 0 : process.env.SLOCK_DAEMON_TRACE_UPLOAD_URL || DEFAULT_TRACE_UPLOAD_URL,
+      serverConnected: () => connection?.connected ?? false
     };
     this.agentManager = options.agentManagerFactory ? options.agentManagerFactory((msg) => connection.send(msg), options.apiKey, agentManagerOptions) : new AgentProcessManager((msg) => connection.send(msg), options.apiKey, agentManagerOptions);
     const connectionFactory = options.connectionFactory ?? ((connOptions) => new DaemonConnection(connOptions));
@@ -17453,19 +17771,63 @@ var DaemonCore = class {
       }
     );
   }
+  sendDeliveryAck(msg, traceparent) {
+    const ackSeq = msg.seq > 0 ? msg.seq : msg.message.seq ?? 0;
+    const ack = {
+      type: "agent:deliver:ack",
+      agentId: msg.agentId,
+      seq: ackSeq,
+      deliveryId: msg.deliveryId,
+      ...traceparent ? { traceparent } : {}
+    };
+    this.connection.send(ack);
+  }
   async startAgentFromMessage(msg) {
-    this.observeRuntimeContext(msg.config);
-    const agentCredential = await this.mintRunnerCredential(msg.agentId, msg.config);
-    const config = { ...msg.config, agentCredentialKey: agentCredential.apiKey, agentCredentialId: agentCredential.credentialId };
-    await this.agentManager.startAgent(
-      msg.agentId,
-      config,
-      msg.wakeMessage,
-      msg.unreadSummary,
-      msg.resumePrompt,
-      msg.launchId,
-      msg.wakeMessageTransient ?? false
-    );
+    this.coreStartingAgentIds.add(msg.agentId);
+    let wakeDeliveryAck = null;
+    let replayDeliveries = [];
+    try {
+      this.observeRuntimeContext(msg.config);
+      const agentCredential = await this.mintRunnerCredential(msg.agentId, msg.config);
+      const config = { ...msg.config, agentCredentialKey: agentCredential.apiKey, agentCredentialId: agentCredential.credentialId };
+      const pendingDeliveries = this.coreStartPendingDeliveries.get(msg.agentId) || [];
+      this.coreStartPendingDeliveries.delete(msg.agentId);
+      let wakeMessage = msg.wakeMessage;
+      let wakeMessageTransient = msg.wakeMessageTransient ?? false;
+      replayDeliveries = [...pendingDeliveries];
+      if (!wakeMessage) {
+        const wakeIndex = replayDeliveries.findIndex((delivery) => delivery.transient !== true);
+        if (wakeIndex >= 0) {
+          const [wakeDelivery] = replayDeliveries.splice(wakeIndex, 1);
+          if (wakeDelivery) {
+            wakeDeliveryAck = wakeDelivery;
+            wakeMessage = wakeDelivery.message;
+            wakeMessageTransient = wakeDelivery.transient ?? false;
+          }
+        }
+      }
+      await this.agentManager.startAgent(
+        msg.agentId,
+        config,
+        wakeMessage,
+        msg.unreadSummary,
+        msg.resumePrompt,
+        msg.launchId,
+        wakeMessageTransient
+      );
+      this.coreStartingAgentIds.delete(msg.agentId);
+      if (wakeDeliveryAck) {
+        this.sendDeliveryAck(wakeDeliveryAck);
+      }
+      for (const delivery of replayDeliveries) {
+        this.handleMessage(delivery);
+      }
+    } catch (err) {
+      this.coreStartPendingDeliveries.delete(msg.agentId);
+      throw err;
+    } finally {
+      this.coreStartingAgentIds.delete(msg.agentId);
+    }
   }
   handleMessage(msg) {
     const summary = summarizeIncomingMessage(msg);
@@ -17520,6 +17882,14 @@ var DaemonCore = class {
         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, deliveryId: msg.deliveryId });
+          if (this.coreStartingAgentIds.has(msg.agentId)) {
+            const pending = this.coreStartPendingDeliveries.get(msg.agentId) || [];
+            pending.push(msg);
+            this.coreStartPendingDeliveries.set(msg.agentId, pending);
+            span.addEvent("daemon.delivery.buffered_for_start", { pending_count: pending.length });
+            span.end("ok", { attrs: { outcome: "buffered-for-start", pending_count: pending.length } });
+            break;
+          }
           const acceptedOrPromise = this.agentManager.deliverMessage(msg.agentId, msg.message, {
             deliveryId: msg.deliveryId,
             transient: msg.transient ?? false
@@ -17532,13 +17902,7 @@ var DaemonCore = class {
             }
             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),
-              deliveryId: msg.deliveryId
-            });
+            this.sendDeliveryAck(msg, formatTraceparent(span.context));
             span.end("ok", { attrs: { outcome: "ack-sent", ackSeq, deliveryId: msg.deliveryId } });
           }, (err) => {
             logger.error(`[Agent ${msg.agentId}] Delivery handling failed`, err);