@slock-ai/daemon 0.57.1 → 0.57.2

package/dist/{chunk-6RZCYFJP.js → chunk-EKSATDT3.js}

@@ -351,40 +351,127 @@ var NoopActiveSpan = class {
   }
 };
 var noopTracer = new NoopTracer();
-function createScopedTracer(tracer, scopeAttrs) {
+function projectTraceScopeAttrs(scope) {
+  const attrs = {};
+  addOptionalStringAttr(attrs, "daemon_version", scope.resource?.daemonVersion);
+  addPresenceAttr(attrs, "daemon_version_present", scope.resource?.daemonVersion);
+  addOptionalStringAttr(attrs, "computer_version", scope.resource?.computerVersion);
+  addPresenceAttr(attrs, "computer_version_present", scope.resource?.computerVersion);
+  addOptionalStringAttr(attrs, "deployment_environment", scope.resource?.deploymentEnvironment);
+  addOptionalStringAttr(attrs, "service_revision", scope.resource?.serviceRevision);
+  addOptionalStringAttr(attrs, "request_id", scope.request?.requestId);
+  addPresenceAttr(attrs, "request_id_present", scope.request?.requestId);
+  addOptionalStringAttr(attrs, "route_pattern", scope.request?.routePattern);
+  addOptionalStringAttr(attrs, "method", scope.request?.method);
+  addOptionalStringAttr(attrs, "caller_kind", scope.request?.callerKind);
+  if (typeof scope.request?.userIdPresent === "boolean") {
+    attrs.user_id_present = scope.request.userIdPresent;
+  }
+  addOptionalStringAttr(attrs, "server_id", scope.actor?.serverId);
+  addPresenceAttr(attrs, "server_id_present", scope.actor?.serverId, scope.actor?.serverIdPresent);
+  addOptionalStringAttr(attrs, "machine_id", scope.actor?.machineId);
+  addPresenceAttr(attrs, "machine_id_present", scope.actor?.machineId, scope.actor?.machineIdPresent);
+  addOptionalStringAttr(attrs, "agent_id", scope.actor?.agentId);
+  addPresenceAttr(attrs, "agent_id_present", scope.actor?.agentId, scope.actor?.agentIdPresent);
+  addOptionalStringAttr(attrs, "launch_id", scope.actor?.launchId);
+  addPresenceAttr(attrs, "launch_id_present", scope.actor?.launchId, scope.actor?.launchIdPresent);
+  addOptionalStringAttr(attrs, "session_id", scope.actor?.sessionId);
+  addPresenceAttr(attrs, "session_id_present", scope.actor?.sessionId, scope.actor?.sessionIdPresent);
+  return attrs;
+}
+function createTraceScopeTracer(tracer, scope, options = {}) {
+  const scopedTracer = createScopedTracer(tracer, projectTraceScopeAttrs(scope), {
+    attrPrecedence: options.scopeAttrPrecedence
+  });
+  return options.spanAttrContracts ? createSpanAttrContractTracer(scopedTracer, options.spanAttrContracts) : scopedTracer;
+}
+function createScopedTracer(tracer, scopeAttrs, options = {}) {
   if (!Object.keys(scopeAttrs).length) return tracer;
-  return new ScopedTracer(tracer, scopeAttrs);
+  return new ScopedTracer(tracer, scopeAttrs, options.attrPrecedence ?? "scope");
 }
 var ScopedTracer = class {
-  constructor(tracer, scopeAttrs) {
+  constructor(tracer, scopeAttrs, attrPrecedence) {
     this.tracer = tracer;
     this.scopeAttrs = scopeAttrs;
+    this.attrPrecedence = attrPrecedence;
   }
   startSpan(name, options) {
     const span = this.tracer.startSpan(name, {
       ...options,
-      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+      attrs: this.mergeScopeAttrs(options.attrs)
     });
-    return new ScopedActiveSpan(span, this.scopeAttrs);
+    return new ScopedActiveSpan(span, this.scopeAttrs, this.attrPrecedence);
+  }
+  mergeScopeAttrs(attrs) {
+    return this.attrPrecedence === "caller" ? mergeAttrs(this.scopeAttrs, attrs) : mergeAttrs(attrs, this.scopeAttrs);
   }
 };
 var ScopedActiveSpan = class {
-  constructor(span, scopeAttrs) {
+  constructor(span, scopeAttrs, attrPrecedence) {
     this.span = span;
     this.scopeAttrs = scopeAttrs;
+    this.attrPrecedence = attrPrecedence;
     this.context = span.context;
   }
   context;
   addEvent(name, attrs) {
-    this.span.addEvent(name, mergeAttrs(attrs, this.scopeAttrs));
+    this.span.addEvent(name, this.mergeScopeAttrs(attrs));
   }
   end(status, options) {
     this.span.end(status, options ? {
       ...options,
-      attrs: mergeAttrs(options.attrs, this.scopeAttrs)
+      attrs: this.mergeScopeAttrs(options.attrs)
     } : void 0);
   }
+  mergeScopeAttrs(attrs) {
+    return this.attrPrecedence === "caller" ? mergeAttrs(this.scopeAttrs, attrs) : mergeAttrs(attrs, this.scopeAttrs);
+  }
+};
+function createSpanAttrContractTracer(tracer, contracts) {
+  if (!Object.keys(contracts).length) return tracer;
+  return new SpanAttrContractTracer(tracer, contracts);
+}
+var SpanAttrContractTracer = class {
+  constructor(tracer, contracts) {
+    this.tracer = tracer;
+    this.contracts = contracts;
+  }
+  startSpan(name, options) {
+    const contract = this.contracts[name];
+    if (!contract) return this.tracer.startSpan(name, options);
+    const span = this.tracer.startSpan(name, {
+      ...options,
+      attrs: filterTraceAttrs(options.attrs, contract.spanAttrs)
+    });
+    return new SpanAttrContractActiveSpan(span, contract);
+  }
 };
+var SpanAttrContractActiveSpan = class {
+  constructor(span, contract) {
+    this.span = span;
+    this.contract = contract;
+    this.context = span.context;
+  }
+  context;
+  addEvent(name, attrs) {
+    this.span.addEvent(name, filterTraceAttrs(attrs, this.contract.eventAttrs?.[name]));
+  }
+  end(status, options) {
+    this.span.end(status, options ? {
+      ...options,
+      attrs: filterTraceAttrs(options.attrs, this.contract.endAttrs)
+    } : void 0);
+  }
+};
+function filterTraceAttrs(attrs, allowedKeys) {
+  if (!attrs || !allowedKeys) return attrs;
+  const allowed = new Set(allowedKeys);
+  const filtered = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (allowed.has(key)) filtered[key] = value;
+  }
+  return Object.keys(filtered).length ? filtered : void 0;
+}
 var BasicTracer = class {
   sink;
   clock;
@@ -482,6 +569,14 @@ function mergeAttrs(base, extra) {
   if (!extra) return base;
   return { ...base, ...extra };
 }
+function addOptionalStringAttr(attrs, key, value) {
+  const normalized = value?.trim();
+  if (!normalized) return;
+  attrs[key] = normalized;
+}
+function addPresenceAttr(attrs, key, value, explicitPresent) {
+  attrs[key] = typeof explicitPresent === "boolean" ? explicitPresent : Boolean(value?.trim());
+}
 function generateTraceId() {
   return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
 }
@@ -1046,6 +1141,9 @@ var SERVER_CAPABILITY_MATRIX = {
 
 // ../shared/src/index.ts
 var RUNTIME_CONFIG_VERSION = 1;
+var EXTERNAL_AGENT_RUNTIME_ID = "external";
+var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
+var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
@@ -1058,6 +1156,9 @@ var RUNTIMES = [
   { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 var RUNTIME_MODELS = {
+  [EXTERNAL_AGENT_RUNTIME_ID]: [
+    { id: EXTERNAL_AGENT_RUNTIME_MODEL, label: EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME }
+  ],
   claude: [
     { id: "opus", label: "Claude Opus" },
     { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
@@ -7381,16 +7482,19 @@ var RuntimeProgressState = class {
 };
 
 // src/runtimeNotificationState.ts
+function inboxNoticeMessageIdentity(message) {
+  const seq = typeof message.seq === "number" && Number.isFinite(message.seq) && message.seq > 0 ? Math.floor(message.seq) : null;
+  if (seq !== null) {
+    return `s:${seq}`;
+  }
+  const id = typeof message.message_id === "string" && message.message_id.length > 0 ? message.message_id : typeof message.id === "string" && message.id.length > 0 ? message.id : "";
+  return id.length > 0 ? `m:${id}` : "";
+}
 function computeInboxNoticeFingerprint(messages) {
   const keys = [];
   for (const m of messages) {
-    const seq = typeof m.seq === "number" && Number.isFinite(m.seq) && m.seq > 0 ? Math.floor(m.seq) : null;
-    if (seq !== null) {
-      keys.push(`s:${seq}`);
-      continue;
-    }
-    const id = typeof m.message_id === "string" && m.message_id.length > 0 ? m.message_id : typeof m.id === "string" && m.id.length > 0 ? m.id : "";
-    if (id.length > 0) keys.push(`m:${id}`);
+    const key = inboxNoticeMessageIdentity(m);
+    if (key.length > 0) keys.push(key);
   }
   if (keys.length === 0) return "";
   keys.sort();
@@ -7401,6 +7505,10 @@ var RuntimeNotificationState = class {
   pendingCountValue = 0;
   lastNoticeFingerprint = null;
   lastNoticeSessionId = null;
+  lastEncodeFailedFingerprint = null;
+  lastEncodeFailedSessionId = null;
+  contributedSessionId = null;
+  contributedIdentities = /* @__PURE__ */ new Set();
   get pendingCount() {
     return this.pendingCountValue;
   }
@@ -7443,13 +7551,63 @@ var RuntimeNotificationState = class {
     return this.lastNoticeFingerprint === fingerprint && this.lastNoticeSessionId === sessionId;
   }
   /** Register a fingerprint as written — call ONLY after a successful stdin write. */
-  recordNoticeWritten(fingerprint, sessionId) {
+  recordNoticeWritten(fingerprint, sessionId, messages = []) {
     this.lastNoticeFingerprint = fingerprint;
     this.lastNoticeSessionId = sessionId;
+    this.lastEncodeFailedFingerprint = null;
+    this.lastEncodeFailedSessionId = null;
+    this.ensureContributionSession(sessionId);
+    for (const message of messages) {
+      const identity = inboxNoticeMessageIdentity(message);
+      if (identity.length > 0) {
+        this.contributedIdentities.add(identity);
+      }
+    }
+  }
+  hasContributedMessage(message, sessionId) {
+    if (this.contributedSessionId !== sessionId) return false;
+    const identity = inboxNoticeMessageIdentity(message);
+    return identity.length > 0 && this.contributedIdentities.has(identity);
+  }
+  filterUncontributedMessages(messages, sessionId) {
+    if (this.contributedSessionId !== sessionId || this.contributedIdentities.size === 0) {
+      return [...messages];
+    }
+    return messages.filter((message) => {
+      const identity = inboxNoticeMessageIdentity(message);
+      return identity.length === 0 || !this.contributedIdentities.has(identity);
+    });
+  }
+  pruneContributedToPending(messages, sessionId) {
+    this.ensureContributionSession(sessionId);
+    if (this.contributedIdentities.size === 0) return;
+    const pending = /* @__PURE__ */ new Set();
+    for (const message of messages) {
+      const identity = inboxNoticeMessageIdentity(message);
+      if (identity.length > 0) pending.add(identity);
+    }
+    for (const identity of this.contributedIdentities) {
+      if (!pending.has(identity)) {
+        this.contributedIdentities.delete(identity);
+      }
+    }
+  }
+  isDuplicateEncodeFailedNotice(fingerprint, sessionId) {
+    if (fingerprint.length === 0) return false;
+    return this.lastEncodeFailedFingerprint === fingerprint && this.lastEncodeFailedSessionId === sessionId;
+  }
+  recordNoticeEncodeFailed(fingerprint, sessionId) {
+    if (fingerprint.length === 0) return;
+    this.lastEncodeFailedFingerprint = fingerprint;
+    this.lastEncodeFailedSessionId = sessionId;
   }
   clearNoticeFingerprint() {
     this.lastNoticeFingerprint = null;
     this.lastNoticeSessionId = null;
+    this.lastEncodeFailedFingerprint = null;
+    this.lastEncodeFailedSessionId = null;
+    this.contributedSessionId = null;
+    this.contributedIdentities.clear();
   }
   schedule(callback, delayMs) {
     if (this.timerValue) return false;
@@ -7462,6 +7620,11 @@ var RuntimeNotificationState = class {
     this.clearTimer();
     return count;
   }
+  ensureContributionSession(sessionId) {
+    if (this.contributedSessionId === sessionId) return;
+    this.contributedSessionId = sessionId;
+    this.contributedIdentities.clear();
+  }
 };
 
 // src/agentProcessManager.ts
@@ -8605,6 +8768,7 @@ var RUNTIME_TELEMETRY_RESERVED_ATTR_KEYS = /* @__PURE__ */ new Set([
   "sessionId",
   "turnId",
   "runtimeResultId",
+  "runtimeResultIdSource",
   "daemonVersion",
   "daemon_version",
   "daemon_version_present",
@@ -8780,13 +8944,33 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
+  flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, source) {
+    if (ap.notifications.pendingCount === 0) return false;
+    if (ap.isIdle) return false;
+    if (!ap.sessionId) return false;
+    if (!ap.driver.supportsStdinNotification) return false;
+    if (ap.runtime.descriptor.busyDelivery !== "direct") return false;
+    if (ap.gatedSteering.compacting) return false;
+    this.recordDaemonTrace("daemon.agent.stdin_notification.retry_signal", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      source,
+      mode: "busy",
+      pending_notification_count: ap.notifications.pendingCount,
+      inbox_count: ap.inbox.length,
+      session_id_present: true
+    });
+    return this.sendStdinNotification(agentId, { forceUnsupportedRetry: true });
+  }
   clearRuntimeErrorDeliveryBackoff(ap) {
     if (ap.runtimeErrorDeliveryBackoff.timer) {
       clearTimeout(ap.runtimeErrorDeliveryBackoff.timer);
     }
     ap.runtimeErrorDeliveryBackoff = createRuntimeErrorDeliveryBackoffState();
   }
-  clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, eventKind) {
+  clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, resetSource) {
     if (ap.runtimeErrorDeliveryBackoff.attempts === 0 && ap.runtimeErrorDeliveryBackoff.untilMs === 0) return;
     const attempts = ap.runtimeErrorDeliveryBackoff.attempts;
     const reason = ap.runtimeErrorDeliveryBackoff.reason;
@@ -8798,9 +8982,12 @@ var AgentProcessManager = class _AgentProcessManager {
       launchId: ap.launchId || void 0,
       reason: reason || void 0,
       attempts,
-      reset_source: eventKind
+      reset_source: resetSource
     });
   }
+  clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, eventKind) {
+    this.clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, eventKind);
+  }
   runtimeErrorDeliveryBackoffRemainingMs(ap) {
     return Math.max(0, ap.runtimeErrorDeliveryBackoff.untilMs - Date.now());
   }
@@ -8828,8 +9015,10 @@ var AgentProcessManager = class _AgentProcessManager {
         return "provider_connection_error";
       case "ProviderStreamError":
         return "provider_stream_error";
-      default:
+      case "TimeoutError":
         return null;
+      default:
+        return "runtime_error";
     }
   }
   noteRuntimeErrorDeliveryBackoff(agentId, ap, message, terminalFailure, stickyTerminalFailure, reasonOverride) {
@@ -8900,9 +9089,24 @@ var AgentProcessManager = class _AgentProcessManager {
     if (ap.inbox.length === 0) return false;
     const reason = ap.runtimeErrorDeliveryBackoff.reason || "runtime_error_backoff";
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
-      const messages = [...ap.inbox];
+      ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+      const messages = ap.notifications.filterUncontributedMessages(ap.inbox, ap.sessionId);
       ap.notifications.clearPending();
       ap.notifications.clearTimer();
+      if (messages.length === 0) {
+        this.recordDaemonTrace("daemon.agent.runtime_error_delivery_backoff.flush", {
+          agentId,
+          runtime: ap.config.runtime,
+          model: ap.config.model,
+          launchId: ap.launchId || void 0,
+          reason,
+          mode: "idle",
+          outcome: "suppressed_already_contributed",
+          inbox_count: ap.inbox.length,
+          messages_count: 0
+        });
+        return false;
+      }
       this.commitApmIdleState(agentId, ap, false);
       this.startRuntimeTrace(agentId, ap, "runtime-error-backoff-idle-delivery", messages);
       this.broadcastActivity(agentId, "working", "Message received");
@@ -9583,6 +9787,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         runtimeProgress: new RuntimeProgressState(Date.now()),
         runtimeTraceSpan: null,
         runtimeTraceCounters: createRuntimeTraceCounters(),
+        runtimeTelemetryResultSeq: 0,
         lastActivity: "",
         lastActivityDetail: "",
         recentStdout: [],
@@ -10135,6 +10340,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.agents.delete(agentId);
     if (!silent) {
       this.activityClientSeqByAgent.delete(agentId);
+      this.agentVisibleBoundaries.delete(agentId);
+      this.agentVisibleMessageIds.delete(agentId);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
       stop_source: silent ? "daemon_internal" : "explicit_request",
@@ -10358,6 +10565,25 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }));
         return true;
       }
+      ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+      const noticeFingerprint = computeInboxNoticeFingerprint([message]);
+      const messageAlreadyPending = noticeFingerprint.length > 0 && ap.inbox.some((pending) => computeInboxNoticeFingerprint([pending]) === noticeFingerprint);
+      const messageAlreadyContributed = ap.notifications.hasContributedMessage(message, ap.sessionId);
+      if (messageAlreadyPending && (messageAlreadyContributed || ap.notifications.isDuplicateNotice(noticeFingerprint, ap.sessionId))) {
+        this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+          outcome: "suppressed_duplicate_stdin_idle_delivery",
+          accepted: true,
+          process_present: true,
+          runtime: ap.config.runtime,
+          session_id_present: true,
+          launchId: ap.launchId || void 0,
+          is_idle: ap.isIdle,
+          inbox_count: ap.inbox.length,
+          pending_notification_count: ap.notifications.pendingCount
+        }));
+        logger.info(`[Agent ${agentId}] Suppressing duplicate idle stdin inbox update (unread-set unchanged since last write); pending=${ap.inbox.length}`);
+        return true;
+      }
       ap.inbox.push(message);
       const nextMessages = [...ap.inbox];
       this.commitApmIdleState(agentId, ap, false);
@@ -11226,6 +11452,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       if (row.flags.includes("task")) taskTargetCount += 1;
     }
     return {
+      target_count: rows.length,
+      changed_target_count: rows.length,
       inbox_target_count: rows.length,
       pending_message_count: pendingMessageCount,
       max_pending_per_target: maxPendingCount,
@@ -11399,7 +11627,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return false;
         }
         const messages = [...ap.inbox];
-        ap.notifications.clear();
+        ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+        ap.notifications.clearPending();
+        ap.notifications.clearTimer();
         if (messages.length === 0) {
           this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
             outcome: "empty",
@@ -11415,12 +11645,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             messageCount: messages.length
           });
         }
-        this.broadcastActivity(agentId, "working", "Message received");
         const runtimeProfileMessages = messages.filter((message) => runtimeProfileNotificationFromMessage(message));
-        const ordinaryMessages = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessageCandidates = messages.filter((message) => !runtimeProfileNotificationFromMessage(message));
+        const ordinaryMessages = ap.notifications.filterUncontributedMessages(
+          ordinaryMessageCandidates,
+          ap.sessionId
+        );
+        if (runtimeProfileMessages.length === 0 && ordinaryMessages.length === 0) {
+          this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+            outcome: "suppressed_already_contributed",
+            delivered_messages_count: 0
+          });
+          return false;
+        }
+        this.broadcastActivity(agentId, "working", "Message received");
         let accepted = true;
         if (runtimeProfileMessages.length > 0) {
-          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessages);
+          ap.inbox.splice(0, ap.inbox.length, ...ordinaryMessageCandidates);
           accepted = this.deliverMessagesViaStdin(agentId, ap, runtimeProfileMessages, effect.stdinMode);
         }
         if (ordinaryMessages.length > 0) {
@@ -11434,7 +11675,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         }
         this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
           outcome: accepted ? "written" : "not_written",
-          delivered_messages_count: messages.length
+          delivered_messages_count: runtimeProfileMessages.length + ordinaryMessages.length
         });
         return accepted;
       }
@@ -11666,6 +11907,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "thinking" });
+          this.flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, event.kind);
         }
         break;
       }
@@ -11676,6 +11918,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "text" });
+          this.flushPendingDirectStdinNotificationOnRuntimeProgress(agentId, ap, event.kind);
         }
         break;
       }
@@ -11748,6 +11991,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         if (ap) {
           if (event.sessionId) ap.sessionId = event.sessionId;
           const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
+          if (!stickyTerminalFailure && ap.runtimeErrorDeliveryBackoff.reason === "runtime_error") {
+            this.clearRuntimeErrorDeliveryBackoffWithTrace(agentId, ap, "turn_end_unclassified_runtime_error");
+          }
           const reduction = reduceApmGatedTurnEnd(ap.gatedSteering, {
             inboxLength: stickyTerminalFailure ? 0 : ap.inbox.length,
             supportsStdinNotification: ap.driver.supportsStdinNotification,
@@ -11879,7 +12125,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   recordRuntimeTelemetry(agentId, ap, event) {
-    const sessionId = ap.driver.currentSessionId ?? event.sessionId;
+    const sessionId = ap.driver.currentSessionId ?? event.sessionId ?? ap.sessionId ?? ap.config.sessionId;
+    const resultIdentity = this.runtimeTelemetryResultIdentity(agentId, ap, event);
     const payloadAttrs = sanitizeRuntimeTelemetryPayloadAttrs(event.attrs);
     const versionAttrs = this.runtimeTelemetryVersionAttrs();
     const telemetryAttrs = {
@@ -11889,7 +12136,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       ...event.usageKind ? { usageKind: event.usageKind } : {},
       ...sessionId ? { sessionId } : {},
       ...event.turnId ? { turnId: event.turnId } : {},
-      ...event.runtimeResultId ? { runtimeResultId: event.runtimeResultId } : {}
+      ...resultIdentity
     };
     const attrs = {
       agentId,
@@ -11902,6 +12149,16 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     ap.runtimeTraceSpan?.addEvent(`runtime.telemetry.${event.name}`, telemetryAttrs);
     this.recordDaemonTrace(`daemon.runtime.telemetry.${event.name}`, attrs);
   }
+  runtimeTelemetryResultIdentity(agentId, ap, event) {
+    if (event.runtimeResultId) return { runtimeResultId: event.runtimeResultId };
+    if (event.name !== "token_usage" || event.source !== "claude_result_usage") return {};
+    const sequence = ++ap.runtimeTelemetryResultSeq;
+    const scope = ap.launchId || agentId;
+    return {
+      runtimeResultId: `${scope}:claude_result_usage:${sequence}`,
+      runtimeResultIdSource: "daemon_sequence"
+    };
+  }
   runtimeTelemetryVersionAttrs() {
     return {
       ...this.daemonVersion ? {
@@ -11970,7 +12227,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
   }
   /** Send a batched notification to the agent via stdin about pending messages */
-  sendStdinNotification(agentId) {
+  sendStdinNotification(agentId, options = {}) {
     const ap = this.agents.get(agentId);
     if (!ap) return false;
     const count = ap.notifications.takePendingAndClearTimer();
@@ -12012,7 +12269,24 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     }
     const inboxCount = ap.inbox.length;
     if (inboxCount === 0) return false;
-    const changedMessages = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    ap.notifications.pruneContributedToPending(ap.inbox, ap.sessionId);
+    const changedMessageCandidates = ap.inbox.slice(Math.max(0, ap.inbox.length - count));
+    const changedMessages = ap.notifications.filterUncontributedMessages(changedMessageCandidates, ap.sessionId);
+    if (changedMessages.length === 0) {
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_already_contributed",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true
+      });
+      logger.info(`[Agent ${agentId}] Suppressing stdin inbox notice because all candidate messages already contributed; pending=${ap.inbox.length}`);
+      return false;
+    }
     const noticeFingerprint = computeInboxNoticeFingerprint(changedMessages);
     if (ap.notifications.isDuplicateNotice(noticeFingerprint, ap.sessionId)) {
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
@@ -12029,6 +12303,22 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       logger.info(`[Agent ${agentId}] Suppressing duplicate stdin inbox notice (unread-set unchanged since last write); pending=${ap.inbox.length}`);
       return false;
     }
+    if (!options.forceUnsupportedRetry && ap.notifications.isDuplicateEncodeFailedNotice(noticeFingerprint, ap.sessionId)) {
+      ap.notifications.add(count);
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_duplicate_encode_failed",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true
+      });
+      logger.info(`[Agent ${agentId}] Suppressing duplicate unsupported stdin inbox notice (unread-set unchanged since last encode failure); pending=${ap.inbox.length}`);
+      return false;
+    }
     const inboxRows = projectAgentInboxSnapshot(changedMessages);
     const notification = `[Slock inbox notice:
 ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
@@ -12051,6 +12341,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         model: ap.config.model,
         launchId: ap.launchId || void 0,
         mode: "busy",
+        source: "busy_stdin_notification",
         notification_byte_count: notificationByteCount,
         ...projectionAttrs
       });
@@ -12066,12 +12357,15 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         inbox_target_count: inboxRows.length,
         session_id_present: true
       });
-      ap.notifications.recordNoticeWritten(noticeFingerprint, ap.sessionId);
+      ap.notifications.recordNoticeWritten(noticeFingerprint, ap.sessionId, changedMessages);
       return true;
     } else {
       ap.notifications.add(count);
-      const retryScheduled = ap.runtime.descriptor.busyDelivery === "direct" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
+      const retryScheduled = ap.runtime.descriptor.busyDelivery === "direct" && sendResult.reason !== "unsupported" ? this.scheduleStdinNotification(agentId, ap, this.stdinNotificationRetryMs) : false;
       const outcome = runtimeSendFailureOutcome(sendResult);
+      if (outcome === "encode_failed") {
+        ap.notifications.recordNoticeEncodeFailed(noticeFingerprint, ap.sessionId);
+      }
       this.recordDaemonTrace("daemon.agent.stdin_notification", {
         agentId,
         runtime: ap.config.runtime,
@@ -12113,6 +12407,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       model: ap.config.model,
       launchId: ap.launchId || void 0,
       mode,
+      source,
       notification_byte_count: Buffer.byteLength(renderedInput, "utf8"),
       cursors_advanced: "none",
       ...projectionAttrs
@@ -12191,6 +12486,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       stdin_write_attempted: true,
       cursors_advanced: "none"
     });
+    ap.notifications.recordNoticeWritten(computeInboxNoticeFingerprint(messages), ap.sessionId, messages);
     return true;
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
@@ -12407,7 +12703,7 @@ var DaemonConnection = class {
       logger.warn(`[Daemon] Dropping outbound message while disconnected: ${msg.type}`);
     }
     this.trace("daemon.connection.outbound_dropped", {
-      message_type: msg.type,
+      outbound_message_kind: msg.type,
       ws_ready_state: this.ws?.readyState ?? null
     });
   }
@@ -12456,7 +12752,7 @@ var DaemonConnection = class {
         this.resetWatchdog();
         if (messageKind !== "ping") {
           this.trace("daemon.connection.inbound_received", {
-            message_type: messageKind,
+            inbound_message_kind: messageKind,
             last_inbound_age_ms_bucket: "0"
           });
         }
@@ -12547,7 +12843,7 @@ var DaemonConnection = class {
     if (msg.launchId && latestLaunchId && msg.launchId !== latestLaunchId) {
       this.trace("daemon.connection.pending_activity_invalidated", {
         reason: "launch_changed",
-        message_type: msg.type,
+        outbound_message_kind: msg.type,
         agentId: msg.agentId,
         stale_launch_id_present: true,
         next_launch_id_present: true
@@ -12567,7 +12863,7 @@ var DaemonConnection = class {
     this.pendingActivityByAgent.delete(identity.agentId);
     this.trace("daemon.connection.pending_activity_invalidated", {
       reason: "launch_changed",
-      message_type: msg.type,
+      outbound_message_kind: msg.type,
       agentId: identity.agentId,
       stale_launch_id_present: Boolean(pending.launchId),
       next_launch_id_present: true
@@ -12596,7 +12892,7 @@ var DaemonConnection = class {
       ws.send(JSON.stringify(msg));
     }
     this.trace("daemon.connection.outbound_replayed", {
-      message_type: "agent:activity",
+      outbound_message_kind: "agent:activity",
       message_count: pending.length
     });
   }
@@ -13422,6 +13718,51 @@ var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
 var RUNNER_CREDENTIAL_MINT_MAX_ATTEMPTS2 = 3;
 var RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2 = 250;
+var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
+  "daemon.lifecycle.start": {
+    spanAttrs: ["machine_dir_present", "local_trace_enabled"],
+    eventAttrs: {
+      "daemon.machine_lock.acquired": ["machine_dir_present"]
+    }
+  },
+  "daemon.lifecycle.stop": {
+    spanAttrs: ["machine_lock_present"]
+  },
+  "daemon.runner_credential_mint.retry": {
+    spanAttrs: ["agentId", "runtime", "attempt", "max_attempts", "status", "code", "reason", "retryable"]
+  },
+  "daemon.runner_credential_mint.failed": {
+    spanAttrs: ["agentId", "runtime", "status", "code", "reason", "retryable", "max_attempts"]
+  },
+  "daemon.agent.spawn.failed": {
+    spanAttrs: ["agentId", "launchId", "runtime", "model", "failure_reason", "failure_detail", "session_id_present"]
+  },
+  "daemon.agent.delivery": {
+    spanAttrs: ["agentId", "deliveryId", "delivery_correlation_id", "messageId", "message_id_present", "seq"],
+    eventAttrs: {
+      "daemon.receive": ["seq", "deliveryId"],
+      "daemon.deliver_to_agent_manager": ["accepted"],
+      "daemon.ack.sent": ["seq"]
+    },
+    endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class"]
+  },
+  "daemon.runtime_profile.control.received": {
+    spanAttrs: ["agentId", "control_kind", "key_present", "launchId"],
+    endAttrs: ["outcome", "error_class"]
+  },
+  "daemon.computer_control.received": {
+    spanAttrs: ["action", "handled"]
+  },
+  "daemon.ready.sent": {
+    spanAttrs: ["runtimes_count", "running_agents_count", "idle_agents_count", "runtime_profile_reports_count"]
+  },
+  "daemon.runtime_profile.report.sent": {
+    spanAttrs: ["agentId", "launchId", "runtime", "report_source", "model_present", "session_ref_present", "workspace_ref_present"]
+  },
+  "daemon.connection.local_disconnect_observed": {
+    spanAttrs: ["running_agents_count", "idle_agents_count"]
+  }
+};
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
@@ -13629,6 +13970,8 @@ var DaemonCore = class {
   tracer;
   injectedTracer;
   machineLock = null;
+  observedServerId = null;
+  observedMachineId = null;
   localTraceSink = null;
   traceBundleUploader = null;
   constructor(options) {
@@ -13679,6 +14022,7 @@ var DaemonCore = class {
     return process.env.SLOCK_DAEMON_LOCAL_TRACE !== "0";
   }
   resolveTraceJitter() {
+    if (process.env.SLOCK_DAEMON_TRACE_JITTER_DISABLED === "1") return NO_JITTER;
     const lockId = this.machineLock?.lockId;
     return lockId ? computeTraceJitter(lockId) : NO_JITTER;
   }
@@ -13710,7 +14054,7 @@ var DaemonCore = class {
       workerUrl,
       tracer: this.tracer,
       currentFileProvider: () => this.localTraceSink?.getCurrentFile() ?? null,
-      lockId: this.machineLock?.lockId
+      jitter: this.resolveTraceJitter()
     });
     this.traceBundleUploader.start();
   }
@@ -13789,22 +14133,29 @@ var DaemonCore = class {
     span.end(status);
   }
   withDaemonTraceScope(tracer) {
-    return createScopedTracer(tracer, this.daemonTraceScopeAttrs());
+    return {
+      startSpan: (name, options) => createTraceScopeTracer(tracer, this.daemonTraceScope(), {
+        spanAttrContracts: DAEMON_CORE_TRACE_ATTR_CONTRACTS
+      }).startSpan(name, options)
+    };
   }
-  daemonTraceScopeAttrs() {
+  daemonTraceScope() {
     return {
-      daemonVersion: this.daemonVersion,
-      daemon_version: this.daemonVersion,
-      daemon_version_present: Boolean(this.daemonVersion),
-      ...this.computerVersion ? {
-        computerVersion: this.computerVersion,
-        computer_version: this.computerVersion,
-        computer_version_present: true
-      } : {
-        computer_version_present: false
+      resource: {
+        daemonVersion: this.daemonVersion,
+        computerVersion: this.computerVersion
+      },
+      actor: {
+        serverId: this.observedServerId,
+        machineId: this.observedMachineId
       }
     };
   }
+  observeRuntimeContext(config) {
+    const ctx = config.runtimeContext;
+    if (ctx?.serverId) this.observedServerId = ctx.serverId;
+    if (ctx?.machineId) this.observedMachineId = ctx.machineId;
+  }
   async requestRunnerCredentialOnce(agentId, config) {
     const url = new URL(`/internal/computer/runners/${encodeURIComponent(agentId)}/credentials`, this.options.serverUrl);
     const res = await daemonFetch(url, {
@@ -13896,6 +14247,7 @@ var DaemonCore = class {
     );
   }
   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(
@@ -13913,6 +14265,7 @@ var DaemonCore = class {
     logger.info(`[Daemon] Received ${msg.type}${summary ? ` ${summary}` : ""}`);
     switch (msg.type) {
       case "agent:start":
+        this.observeRuntimeContext(msg.config);
         logger.info(`[Agent ${msg.agentId}] Start requested (runtime=${msg.config.runtime}, model=${msg.config.model}, session=${msg.config.sessionId || "new"}${msg.wakeMessage ? ", wake=true" : ""})`);
         this.startAgentFromMessage(msg).catch((err) => {
           const classification = classifySpawnFailure(err);

package/dist/cli/index.js

@@ -860,11 +860,17 @@ async function runDeviceCodeLogin(options) {
   const pollIntervalMs = options.pollIntervalOverrideMs ?? serverIntervalMs;
   const deadlineMs = Date.now() + Math.max(1, authorizeBody.expiresIn ?? 600) * 1e3;
   while (Date.now() < deadlineMs) {
-    const tokenRes = await httpFetch(`${base}/api/auth/device/token`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ deviceCode: authorizeBody.deviceCode })
-    });
+    let tokenRes;
+    try {
+      tokenRes = await httpFetch(`${base}/api/auth/device/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceCode: authorizeBody.deviceCode })
+      });
+    } catch {
+      await delay(pollIntervalMs);
+      continue;
+    }
     if (tokenRes.ok) {
       const tokenBody = await tokenRes.json();
       if (!tokenBody.accessToken || !tokenBody.refreshToken || !tokenBody.userId) {
@@ -15249,6 +15255,12 @@ var SERVER_CAPABILITY_MATRIX = {
 };
 
 // ../shared/src/index.ts
+var EXTERNAL_AGENT_RUNTIME_ID = "external";
+var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
+var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
+function isExternalAgentRuntime(runtime) {
+  return runtime === EXTERNAL_AGENT_RUNTIME_ID;
+}
 var RUNTIMES = [
   { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
   { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
@@ -15261,8 +15273,71 @@ var RUNTIMES = [
   { id: "pi", displayName: "Pi", binary: "pi", supported: true }
 ];
 function getRuntimeDisplayName(id) {
+  if (isExternalAgentRuntime(id)) return EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME;
   return RUNTIMES.find((r) => r.id === id)?.displayName ?? id;
 }
+var RUNTIME_MODELS = {
+  [EXTERNAL_AGENT_RUNTIME_ID]: [
+    { id: EXTERNAL_AGENT_RUNTIME_MODEL, label: EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME }
+  ],
+  claude: [
+    { id: "opus", label: "Claude Opus" },
+    { id: "claude-opus-4-8", label: "Claude Opus 4.8" },
+    { id: "claude-opus-4-7", label: "Claude Opus 4.7" },
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "sonnet", label: "Claude Sonnet" },
+    { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+    { id: "haiku", label: "Claude Haiku" },
+    { id: "claude-haiku-4-5", label: "Claude Haiku 4.5" }
+  ],
+  codex: [
+    { id: "gpt-5.5", label: "GPT-5.5" },
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+    { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark" },
+    { id: "gpt-5.2-codex", label: "GPT-5.2 Codex" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "gpt-5.1-codex-max", label: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.1-codex", label: "GPT-5.1 Codex" },
+    { id: "gpt-5-codex", label: "GPT-5 Codex" },
+    { id: "gpt-5", label: "GPT-5" }
+  ],
+  antigravity: [
+    { id: "default", label: "AGY configured default", verified: "suggestion_only" }
+  ],
+  copilot: [
+    { id: "gpt-5.4", label: "GPT-5.4" },
+    { id: "gpt-5.2", label: "GPT-5.2" },
+    { id: "claude-4-sonnet", label: "Claude 4 Sonnet" },
+    { id: "claude-4.5-sonnet", label: "Claude 4.5 Sonnet" }
+  ],
+  cursor: [
+    { id: "composer-2-fast", label: "Composer 2 Fast" },
+    { id: "composer-2", label: "Composer 2" },
+    { id: "auto", label: "Auto" }
+  ],
+  gemini: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" },
+    { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro (Preview)" },
+    { id: "gemini-3-flash-preview", label: "Gemini 3 Flash (Preview)" },
+    { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" }
+  ],
+  opencode: [
+    { id: "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" }
+  ],
+  pi: [
+    { id: "default", label: "Configured Default / Auto", verified: "suggestion_only" }
+  ],
+  // Kimi CLI resolves model keys from each user's local config, so the safest
+  // built-in option is to defer to whatever default model the CLI already uses.
+  kimi: [
+    { id: "default", label: "Configured Default" }
+  ]
+};
 var PLAN_CONFIG = {
   free: {
     displayName: "Hobby",

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   subscribeDaemonLogs
-} from "./chunk-6RZCYFJP.js";
+} from "./chunk-EKSATDT3.js";
 export {
   DAEMON_CLI_USAGE,
   DaemonCore,

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-6RZCYFJP.js";
+} from "./chunk-EKSATDT3.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

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