@slock-ai/daemon 0.48.0 → 0.48.1

package/dist/chat-bridge.js

@@ -169,16 +169,64 @@ function formatHistoryMessageLine(message) {
 }
 
 // src/chatBridgeSendRequest.ts
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
+var DEFAULT_SEND_RETRY_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+var ambiguousSendKeys = /* @__PURE__ */ new Map();
+function pruneExpiredAmbiguousSendKeys(nowMs) {
+  for (const [fingerprint, entry] of ambiguousSendKeys) {
+    if (entry.expiresAt <= nowMs) {
+      ambiguousSendKeys.delete(fingerprint);
+    }
+  }
+}
+function resolveIdempotencyKey(opts) {
+  if (opts.idempotencyKey) return opts.idempotencyKey;
+  if (!opts.retryFingerprint) return randomUUID();
+  pruneExpiredAmbiguousSendKeys(opts.nowMs);
+  const existing = ambiguousSendKeys.get(opts.retryFingerprint);
+  if (existing && existing.expiresAt > opts.nowMs) {
+    return existing.idempotencyKey;
+  }
+  return randomUUID();
+}
+function rememberAmbiguousSendKey(retryFingerprint, idempotencyKey, nowMs, ttlMs) {
+  if (!retryFingerprint) return;
+  pruneExpiredAmbiguousSendKeys(nowMs);
+  ambiguousSendKeys.set(retryFingerprint, {
+    idempotencyKey,
+    expiresAt: nowMs + ttlMs
+  });
+}
+function clearAmbiguousSendKey(retryFingerprint) {
+  if (!retryFingerprint) return;
+  ambiguousSendKeys.delete(retryFingerprint);
+}
+function buildSendRetryFingerprint(input) {
+  const attachmentIds = input.attachmentIds ?? [];
+  const hash = createHash("sha256").update(JSON.stringify({
+    target: input.target,
+    content: input.content,
+    attachmentIds
+  })).digest("hex");
+  return `send_message:${hash}`;
+}
 async function executeRetrySafeSendRequest(url, buildInit, {
   fetchImpl,
   target,
   timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   now = () => Date.now(),
   warn = (message) => logger.warn(message),
-  idempotencyKey = randomUUID()
+  idempotencyKey: explicitIdempotencyKey,
+  retryFingerprint,
+  retryFingerprintTtlMs = DEFAULT_SEND_RETRY_FINGERPRINT_TTL_MS
 }) {
   let lastError;
+  const idempotencyKey = resolveIdempotencyKey({
+    idempotencyKey: explicitIdempotencyKey,
+    retryFingerprint,
+    retryFingerprintTtlMs,
+    nowMs: now()
+  });
   for (let attempt = 1; attempt <= 2; attempt += 1) {
     try {
       const result = await executeJsonRequest(
@@ -193,6 +241,7 @@ async function executeRetrySafeSendRequest(url, buildInit, {
           warn
         }
       );
+      clearAmbiguousSendKey(retryFingerprint);
       return {
         ...result,
         idempotencyKey,
@@ -206,6 +255,7 @@ async function executeRetrySafeSendRequest(url, buildInit, {
       );
     }
   }
+  rememberAmbiguousSendKey(retryFingerprint, idempotencyKey, now(), retryFingerprintTtlMs);
   throw lastError;
 }
 function describeRetryReason(error) {
@@ -578,7 +628,12 @@ if (!deprecatedShimMode && !runtimeActionsOnlyMode) {
           }),
           {
             target,
-            fetchImpl: bridgeFetch
+            fetchImpl: bridgeFetch,
+            retryFingerprint: buildSendRetryFingerprint({
+              target,
+              content,
+              attachmentIds: attachment_ids
+            })
           }
         );
         if (!res.ok) {

package/dist/{chunk-EDE2E6QR.js → chunk-RDRY2MW2.js}

@@ -4410,6 +4410,17 @@ Success = user starts useful collaboration and setup progresses,
 not finishing a long onboarding conversation in one channel.
 `;
 }
+function createRuntimeTraceCounters() {
+  return {
+    events: 0,
+    toolCalls: 0,
+    toolOutputs: 0,
+    compactionStarts: 0,
+    compactionFinishes: 0,
+    textEvents: 0,
+    thinkingEvents: 0
+  };
+}
 function createGatedSteeringState() {
   return {
     phase: "idle",
@@ -4588,10 +4599,113 @@ function buildRuntimeStallDiagnostic(ap, staleForMs, staleForMinutes) {
       outstandingToolUses: ap.gatedSteering.outstandingToolUses,
       compacting: ap.gatedSteering.compacting,
       recentStderrCount: ap.recentStderr.length,
-      recentStdoutCount: ap.recentStdout.length
+      recentStdoutCount: ap.recentStdout.length,
+      ...runtimeTraceCounterAttrs(ap)
     }
   };
 }
+function bucketBytes(value) {
+  const bytes = typeof value === "string" ? Buffer.byteLength(value, "utf8") : Math.max(0, Math.floor(value ?? 0));
+  if (bytes === 0) return "0";
+  if (bytes < 1024) return "<1KB";
+  if (bytes < 10 * 1024) return "1KB-10KB";
+  if (bytes < 100 * 1024) return "10KB-100KB";
+  if (bytes < 1024 * 1024) return "100KB-1MB";
+  return "1MB+";
+}
+function attachmentBytesBucket(bytes, knownCount) {
+  return knownCount > 0 ? bucketBytes(bytes) : "unknown";
+}
+function summarizeMessageInputBytes(messages) {
+  if (!messages || messages.length === 0) {
+    return {
+      runtime_input_messages_count: 0,
+      runtime_input_messages_content_bytes_bucket: "0",
+      runtime_input_attachments_count: 0,
+      runtime_input_image_attachments_count: 0,
+      runtime_input_attachments_size_known_count: 0,
+      runtime_input_attachments_bytes_bucket: "0",
+      runtime_input_image_attachments_size_known_count: 0,
+      runtime_input_image_attachments_bytes_bucket: "0",
+      runtime_input_largest_attachment_bytes_bucket: "0",
+      runtime_input_thread_context_messages_count: 0,
+      runtime_input_thread_context_content_bytes_bucket: "0"
+    };
+  }
+  let contentBytes = 0;
+  let attachmentCount = 0;
+  let imageAttachmentCount = 0;
+  let attachmentSizeKnownCount = 0;
+  let attachmentBytes = 0;
+  let imageAttachmentSizeKnownCount = 0;
+  let imageAttachmentBytes = 0;
+  let largestAttachmentBytes = 0;
+  let threadContextMessages = 0;
+  let threadContextContentBytes = 0;
+  for (const message of messages) {
+    contentBytes += Buffer.byteLength(message.content || "", "utf8");
+    for (const attachment of message.attachments || []) {
+      attachmentCount++;
+      if (typeof attachment.sizeBytes === "number" && Number.isFinite(attachment.sizeBytes) && attachment.sizeBytes >= 0) {
+        attachmentSizeKnownCount++;
+        attachmentBytes += attachment.sizeBytes;
+        largestAttachmentBytes = Math.max(largestAttachmentBytes, attachment.sizeBytes);
+      }
+      if (attachment.mimeType?.startsWith("image/")) {
+        imageAttachmentCount++;
+        if (typeof attachment.sizeBytes === "number" && Number.isFinite(attachment.sizeBytes) && attachment.sizeBytes >= 0) {
+          imageAttachmentSizeKnownCount++;
+          imageAttachmentBytes += attachment.sizeBytes;
+        }
+      }
+    }
+    const joinContext = message.thread_join_context;
+    if (joinContext) {
+      const contextMessages = [joinContext.parent_message, ...joinContext.recent_messages];
+      threadContextMessages += contextMessages.length;
+      for (const contextMessage of contextMessages) {
+        threadContextContentBytes += Buffer.byteLength(contextMessage.content || "", "utf8");
+      }
+    }
+  }
+  return {
+    runtime_input_messages_count: messages.length,
+    runtime_input_messages_content_bytes_bucket: bucketBytes(contentBytes),
+    runtime_input_attachments_count: attachmentCount,
+    runtime_input_image_attachments_count: imageAttachmentCount,
+    runtime_input_attachments_size_known_count: attachmentSizeKnownCount,
+    runtime_input_attachments_bytes_bucket: attachmentCount > 0 ? attachmentBytesBucket(attachmentBytes, attachmentSizeKnownCount) : "0",
+    runtime_input_image_attachments_size_known_count: imageAttachmentSizeKnownCount,
+    runtime_input_image_attachments_bytes_bucket: imageAttachmentCount > 0 ? attachmentBytesBucket(imageAttachmentBytes, imageAttachmentSizeKnownCount) : "0",
+    runtime_input_largest_attachment_bytes_bucket: attachmentCount > 0 ? attachmentBytesBucket(largestAttachmentBytes, attachmentSizeKnownCount) : "0",
+    runtime_input_thread_context_messages_count: threadContextMessages,
+    runtime_input_thread_context_content_bytes_bucket: bucketBytes(threadContextContentBytes)
+  };
+}
+function buildRuntimeInputTraceAttrs(opts) {
+  return {
+    runtime_input_source: opts.source,
+    runtime_input_prompt_bytes_bucket: bucketBytes(opts.prompt),
+    runtime_input_standing_prompt_bytes_bucket: bucketBytes(opts.standingPrompt),
+    runtime_input_resume_prompt_present: Boolean(opts.resumePrompt),
+    runtime_input_resume_prompt_bytes_bucket: bucketBytes(opts.resumePrompt),
+    runtime_input_session_present: opts.sessionIdPresent,
+    runtime_input_native_standing_prompt_present: opts.nativeStandingPrompt,
+    runtime_input_unread_channels_count: opts.unreadSummary ? Object.keys(opts.unreadSummary).length : 0,
+    ...summarizeMessageInputBytes(opts.messages)
+  };
+}
+function runtimeTraceCounterAttrs(ap) {
+  return {
+    runtime_events_count: ap.runtimeTraceCounters.events,
+    runtime_tool_calls_count: ap.runtimeTraceCounters.toolCalls,
+    runtime_tool_outputs_count: ap.runtimeTraceCounters.toolOutputs,
+    runtime_compaction_starts_count: ap.runtimeTraceCounters.compactionStarts,
+    runtime_compaction_finishes_count: ap.runtimeTraceCounters.compactionFinishes,
+    runtime_text_events_count: ap.runtimeTraceCounters.textEvents,
+    runtime_thinking_events_count: ap.runtimeTraceCounters.thinkingEvents
+  };
+}
 function getMessageDeliveryText(driver) {
   return driver.supportsStdinNotification ? "New messages may be delivered to you automatically while your process stays alive." : "The daemon will automatically restart you when new messages arrive.";
 }
@@ -4916,17 +5030,21 @@ var AgentProcessManager = class _AgentProcessManager {
       const isResume = !!runtimeConfig.sessionId;
       const standingPrompt = driver.buildSystemPrompt(runtimeConfig, agentId);
       let prompt;
+      let promptSource;
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
+        promptSource = "runtime_profile_control";
       } else if (isResume && resumePrompt) {
         prompt = resumePrompt;
         prompt += getBusyDeliveryNote(driver);
+        promptSource = "resume_prompt";
       } else if (wakeMessage) {
         const runtimeProfileControlPrompt = formatRuntimeProfileControlPrompt([wakeMessage]);
         const channelLabel = formatChannelLabel(wakeMessage);
         prompt = runtimeProfileControlPrompt ?? `New message received:
 
 ${formatIncomingMessage(wakeMessage, driver)}`;
+        promptSource = runtimeProfileControlPrompt ? "runtime_profile_control_message" : "wake_message";
         if (!runtimeProfileControlPrompt && unreadSummary && Object.keys(unreadSummary).length > 0) {
           const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
           if (otherUnread.length > 0) {
@@ -4960,12 +5078,25 @@ IMPORTANT: If the message requires multi-step work (e.g. research, code changes,
         prompt += `
 
 Use ${communicationCommand(driver, "read_history")} to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call ${communicationCommand(driver, "check_messages")} in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: ${dynamicReplyInstruction(driver)} and ${dynamicClaimInstruction(driver)} before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
+        promptSource = "resume_unread_summary";
       } else if (isResume) {
         prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver)}`;
         prompt += getBusyDeliveryNote(driver);
+        promptSource = "resume_empty";
       } else {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : standingPrompt;
+        promptSource = "cold_start";
       }
+      const runtimeInputTraceAttrs = buildRuntimeInputTraceAttrs({
+        source: promptSource,
+        prompt,
+        standingPrompt,
+        resumePrompt,
+        messages: wakeMessage ? [wakeMessage] : void 0,
+        unreadSummary,
+        sessionIdPresent: isResume,
+        nativeStandingPrompt: Boolean(driver.supportsNativeStandingPrompt)
+      });
       const effectiveConfig = await this.buildSpawnConfig(agentId, runtimeConfig);
       const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
       if (canDeferEmptyStart) {
@@ -5026,6 +5157,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         lastRuntimeEventAt: Date.now(),
         runtimeProgressStaleSince: null,
         runtimeTraceSpan: null,
+        runtimeTraceCounters: createRuntimeTraceCounters(),
         lastActivity: "",
         lastActivityDetail: "",
         activityClientSeq: 0,
@@ -5047,7 +5179,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         sessionId: effectiveConfig.sessionId || null,
         launchId: launchId || null
       });
-      this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0);
+      this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0, runtimeInputTraceAttrs);
       this.agentsStarting.delete(agentId);
       if (config.runtimeProfileControl) {
         this.ackInjectedRuntimeProfileControl(agentId, config.runtimeProfileControl, agentProcess.launchId);
@@ -5141,6 +5273,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             expectedTerminationReason: ap.expectedTerminationReason || void 0,
             exitCode: finalCode,
             exitSignal: finalSignal,
+            ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "process_exit")
           });
           if (processEndedCleanly) {
@@ -5993,6 +6126,12 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   /**
    * Broadcast an activity change — emits a single agent:activity event that carries
    * both the status (for the dot indicator) and trajectory entries (for the activity log).
+   *
+   * TODO(lifecycle-v2/daemon-protocol): split this legacy frame into
+   * structured lifecycle producers. Runtime progress, transient heartbeat,
+   * provider/runtime error, process exit, and user-visible activity entries
+   * should carry explicit reason/correlation/window attrs so the server no
+   * longer infers lifecycle semantics from generic activity strings.
    */
   broadcastActivity(agentId, activity, detail, extraTrajectory = [], launchIdOverride) {
     const ap = this.agents.get(agentId);
@@ -6218,8 +6357,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       runtime_profile_turn_outcome: control.kind === "migration" ? control.migrationDoneToolObserved ? "migration_done_observed" : "missing_migration_done" : "notice_only"
     };
   }
-  startRuntimeTrace(agentId, ap, reason, messages) {
+  startRuntimeTrace(agentId, ap, reason, messages, inputTraceAttrs = {}) {
     if (ap.runtimeTraceSpan) return ap.runtimeTraceSpan;
+    ap.runtimeTraceCounters = createRuntimeTraceCounters();
     const messageControl = this.runtimeProfileTurnControlFromMessages(messages);
     if (messageControl) {
       this.activateRuntimeProfileTurnControl(ap, messageControl);
@@ -6234,12 +6374,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         reason,
         hasSession: Boolean(ap.sessionId),
         ...this.messagesTraceAttrs(messages),
+        ...inputTraceAttrs,
         ...this.runtimeProfileTurnControlTraceAttrs(ap.runtimeProfileTurnControl)
       }
     });
     span.addEvent("daemon.turn.started", {
       reason,
       ...this.messagesTraceAttrs(messages),
+      ...inputTraceAttrs,
       ...this.runtimeProfileTurnControlTraceAttrs(ap.runtimeProfileTurnControl)
     });
     ap.runtimeTraceSpan = span;
@@ -6348,6 +6490,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       lastActivity: ap.lastActivity,
       lastActivityDetailPresent: Boolean(ap.lastActivityDetail),
       lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
+      ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
     this.broadcastActivity(agentId, "error", diagnostic.detail);
@@ -6380,6 +6523,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       lastActivityDetailKind: classifyActivityDetailForTrace(ap.lastActivityDetail),
       pendingMessages: ap.inbox.length,
       recovery: "terminate_for_queued_message",
+      ...runtimeTraceCounterAttrs(ap),
       ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_stalled")
     });
     ap.expectedTerminationReason = "stalled_recovery";
@@ -6407,6 +6551,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     const ap = this.agents.get(agentId);
     if (ap) {
       const wasStalled = Boolean(ap.runtimeProgressStaleSince);
+      this.noteRuntimeTraceCounter(ap, event);
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.event.received", { kind: event.kind });
       if (wasStalled) {
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.observed", { afterStall: true });
@@ -6534,6 +6679,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           }
           this.endRuntimeTrace(ap, "ok", {
             outcome: "turn-completed",
+            ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "turn_end")
           });
           if (ap.driver.terminateProcessOnTurnEnd) {
@@ -6575,10 +6721,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               `[Agent ${agentId}] Disabled Claude tool-boundary gated steering after thinking-block mutation error; lastFlushReason=${ap.gatedSteering.lastFlushReason || "none"}`
             );
           }
-          this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", runtimeErrorDiagnostics.eventAttrs);
+          this.recordRuntimeTraceEvent(agentId, ap, "runtime.error", {
+            ...runtimeErrorDiagnostics.eventAttrs,
+            ...runtimeTraceCounterAttrs(ap)
+          });
           this.endRuntimeTrace(ap, "error", {
             outcome: "runtime-error",
             ...runtimeErrorDiagnostics.spanAttrs,
+            ...runtimeTraceCounterAttrs(ap),
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
           if (ap.driver.supportsStdinNotification && classifyTerminalFailure(ap)) {
@@ -6601,6 +6751,29 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
   sendAgentStatus(agentId, status, launchId) {
     this.sendToServer({ type: "agent:status", agentId, status, launchId: launchId || void 0 });
   }
+  noteRuntimeTraceCounter(ap, event) {
+    ap.runtimeTraceCounters.events++;
+    switch (event.kind) {
+      case "tool_call":
+        ap.runtimeTraceCounters.toolCalls++;
+        break;
+      case "tool_output":
+        ap.runtimeTraceCounters.toolOutputs++;
+        break;
+      case "compaction_started":
+        ap.runtimeTraceCounters.compactionStarts++;
+        break;
+      case "compaction_finished":
+        ap.runtimeTraceCounters.compactionFinishes++;
+        break;
+      case "text":
+        ap.runtimeTraceCounters.textEvents++;
+        break;
+      case "thinking":
+        ap.runtimeTraceCounters.thinkingEvents++;
+        break;
+    }
+  }
   /** Send a batched notification to the agent via stdin about pending messages */
   sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
@@ -6703,6 +6876,14 @@ ${messages.map((message) => formatIncomingMessage(message, ap.driver)).join("\n"
 
 Respond as appropriate. Complete all your work before stopping.
 ${RESPONSE_TARGET_HINT}`);
+    const inputTraceAttrs = buildRuntimeInputTraceAttrs({
+      source: `stdin_${mode}_delivery`,
+      prompt,
+      messages,
+      sessionIdPresent: Boolean(ap.sessionId),
+      nativeStandingPrompt: Boolean(ap.driver.supportsNativeStandingPrompt)
+    });
+    this.recordRuntimeTraceEvent(agentId, ap, "runtime.input.prepared", inputTraceAttrs);
     const encoded = ap.driver.encodeStdinMessage(prompt, ap.sessionId, { mode });
     if (!encoded) {
       ap.inbox.unshift(...messages);
@@ -6714,6 +6895,7 @@ ${RESPONSE_TARGET_HINT}`);
       );
       this.recordDaemonTrace("daemon.agent.stdin_delivery", {
         ...traceAttrs,
+        ...inputTraceAttrs,
         outcome: "encode_failed",
         requeued_messages_count: messages.length
       }, "error");
@@ -6730,6 +6912,7 @@ ${RESPONSE_TARGET_HINT}`);
     this.ackInjectedRuntimeProfileMessages(agentId, messages, ap.launchId);
     this.recordDaemonTrace("daemon.agent.stdin_delivery", {
       ...traceAttrs,
+      ...inputTraceAttrs,
       outcome: "written",
       stdin_write_attempted: true
     });

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-EDE2E6QR.js";
+} from "./chunk-RDRY2MW2.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-B7XIMLOT.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-EDE2E6QR.js";
+} from "./chunk-RDRY2MW2.js";
 import "./chunk-B7XIMLOT.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.48.0",
+  "version": "0.48.1",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"