@slock-ai/daemon 0.57.0 → 0.57.1

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

@@ -2235,6 +2235,412 @@ function reduceApmGatedFlushReadiness(state, input) {
   };
 }
 
+// src/agentInboxStateMachine.ts
+var DEFAULT_HELD_CONTEXT_LIMIT = 3;
+function planAgentInboxSideEffect(input) {
+  const heldContextLimit = input.heldContextLimit ?? DEFAULT_HELD_CONTEXT_LIMIT;
+  const trace = [
+    {
+      step: "input",
+      data: compactTraceData({
+        action: input.action,
+        target: input.target,
+        continueAnyway: input.continueAnyway,
+        pendingCount: input.pendingMessages.length,
+        recentCount: input.recentMessages.length,
+        existingSeenUpToSeq: input.existingSeenUpToSeq,
+        modelSeenSeq: input.modelSeenSeq
+      })
+    }
+  ];
+  if (input.continueAnyway) {
+    appendTrace(trace, "continue_anyway_bypass");
+    return forwardPlan(input, {
+      action: input.action,
+      decision: "bypass",
+      target: input.target,
+      inboxTrustState: "trusted",
+      reason: "continue_anyway"
+    }, trace);
+  }
+  if (input.pendingMessages.length > 0) {
+    appendTrace(trace, "pending_messages_found", { pendingCount: input.pendingMessages.length });
+    const pending = sortInboxMessagesBySeq(normalizeInboxVisibleMessages(input.pendingMessages, input.target));
+    const boundary2 = resolveFreshnessBoundary(pending);
+    if (!boundary2.ok) {
+      appendTrace(trace, "pending_context_missing_boundary");
+      return forwardWithoutDecision(input, trace);
+    }
+    const alreadySeenPending = [];
+    const unconsumedMessages = [];
+    for (const message of pending) {
+      if (isMessageModelSeen(input, message)) {
+        alreadySeenPending.push(message);
+      } else {
+        unconsumedMessages.push(message);
+      }
+    }
+    appendTrace(trace, "pending_context_classified", {
+      pendingCount: pending.length,
+      unseenCount: unconsumedMessages.length
+    });
+    if (unconsumedMessages.length === 0) {
+      const contiguousBoundary = maxKnownContiguousBoundary(input);
+      const canAdvanceBoundary = typeof contiguousBoundary === "number" && contiguousBoundary >= boundary2.seenUpToSeq;
+      appendTrace(trace, "pending_context_already_seen", { boundarySeq: boundary2.seenUpToSeq });
+      return forwardPlan(input, {
+        action: input.action,
+        decision: "forward",
+        target: input.target,
+        inboxTrustState: "trusted",
+        reason: "exact_target_pending_already_seen",
+        pendingCount: pending.length,
+        pendingMaxSeq: boundary2.seenUpToSeq,
+        modelSeenSeq: contiguousBoundary,
+        heldMessageCount: 0,
+        omittedMessageCount: 0
+      }, trace, {
+        forwardSeenUpToSeq: input.action === "send" && canAdvanceBoundary ? boundary2.seenUpToSeq : void 0,
+        consumeEffect: {
+          type: "consume_visible_messages",
+          target: input.target,
+          messages: exactSeenConsumeMessages(input, pending),
+          boundarySeq: canAdvanceBoundary ? boundary2.seenUpToSeq : void 0,
+          source: "side_effect_preflight_context"
+        }
+      });
+    }
+    const heldBoundary = resolveFreshnessBoundary(unconsumedMessages);
+    if (heldBoundary.ok) {
+      const heldMessages = latestVisibleMessages(unconsumedMessages, heldContextLimit);
+      const omittedMessageCount = Math.max(0, unconsumedMessages.length - heldMessages.length);
+      const context = {
+        heldMessages,
+        newMessageCount: unconsumedMessages.length,
+        shownMessageCount: heldMessages.length,
+        omittedMessageCount,
+        seenUpToSeq: heldBoundary.seenUpToSeq
+      };
+      appendTrace(trace, "held_context_built", {
+        boundarySeq: boundary2.seenUpToSeq,
+        heldBoundarySeq: heldBoundary.seenUpToSeq,
+        heldCount: context.shownMessageCount,
+        omittedCount: context.omittedMessageCount
+      });
+      return heldPlan(input, {
+        decision: {
+          action: input.action,
+          decision: "local_hold",
+          target: input.target,
+          inboxTrustState: "trusted",
+          reason: "exact_target_pending",
+          pendingCount: input.pendingMessages.length,
+          pendingMaxSeq: heldBoundary.seenUpToSeq,
+          modelSeenSeq: input.modelSeenSeq,
+          heldMessageCount: context.shownMessageCount,
+          omittedMessageCount: context.omittedMessageCount
+        },
+        context,
+        consumeMessages: sortInboxMessagesBySeq([
+          ...exactSeenConsumeMessages(input, alreadySeenPending),
+          ...context.heldMessages
+        ]),
+        consumeBoundarySeq: heldBoundary.seenUpToSeq
+      }, trace);
+    }
+    appendTrace(trace, "pending_unseen_context_missing_boundary");
+    return forwardWithoutDecision(input, trace);
+  }
+  const boundary = Math.max(input.existingSeenUpToSeq ?? 0, input.modelSeenSeq ?? 0);
+  appendTrace(trace, "model_boundary_checked", { boundary });
+  if (boundary > 0) {
+    appendTrace(trace, "model_boundary_selected", { boundary });
+    return forwardPlan(input, {
+      action: input.action,
+      decision: "forward",
+      target: input.target,
+      inboxTrustState: "trusted",
+      reason: "model_seen_boundary",
+      pendingCount: 0,
+      modelSeenSeq: boundary
+    }, trace, { forwardSeenUpToSeq: input.action === "send" ? boundary : void 0 });
+  }
+  if (input.recentMessages.length > 0) {
+    return planFirstTouchRecentContext(input, heldContextLimit, trace);
+  }
+  appendTrace(trace, "no_context_available");
+  return forwardPlan(input, {
+    action: input.action,
+    decision: "forward",
+    target: input.target,
+    inboxTrustState: "trusted",
+    reason: "no_exact_target_pending_or_recent_context",
+    pendingCount: 0,
+    modelSeenSeq: 0
+  }, trace);
+}
+function normalizeInboxVisibleMessage(message, target) {
+  const targetFields = target ? parseTargetFields(target) : {};
+  const normalized = {
+    ...targetFields,
+    ...message,
+    message_id: message.message_id ?? message.id,
+    timestamp: message.timestamp ?? message.createdAt,
+    sender_type: message.sender_type ?? message.senderType,
+    sender_name: message.sender_name ?? message.senderName,
+    sender_description: message.sender_description ?? message.senderDescription ?? null
+  };
+  const senderId = messageSenderId(message);
+  if (senderId) normalized.sender_id = senderId;
+  return normalized;
+}
+function normalizeInboxVisibleMessages(messages, target) {
+  return messages.map((message) => normalizeInboxVisibleMessage(message, target));
+}
+function maxInboxMessageSeq(messages) {
+  let maxSeq = 0;
+  for (const message of messages) {
+    const seq = Math.floor(messageSeq(message));
+    if (Number.isFinite(seq) && seq > 0) maxSeq = Math.max(maxSeq, seq);
+  }
+  return maxSeq > 0 ? maxSeq : void 0;
+}
+function maxKnownContiguousBoundary(input) {
+  const boundary = Math.max(input.existingSeenUpToSeq ?? 0, input.modelSeenSeq ?? 0);
+  return boundary > 0 ? boundary : void 0;
+}
+function exactSeenConsumeMessages(input, messages) {
+  const boundary = maxKnownContiguousBoundary(input);
+  return messages.map((message) => {
+    const seq = Math.floor(messageSeq(message));
+    if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= seq) {
+      return message;
+    }
+    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 : void 0;
+    return id ? { ...message, seq: void 0 } : message;
+  });
+}
+function sortInboxMessagesBySeq(messages) {
+  return [...messages].sort((a, b) => messageSeq(a) - messageSeq(b));
+}
+function planFirstTouchRecentContext(input, heldContextLimit, trace) {
+  const recent = sortInboxMessagesBySeq(normalizeInboxVisibleMessages(input.recentMessages, input.target));
+  const unconsumedMessages = recent.filter((message) => !isMessageModelSeen(input, message));
+  appendTrace(trace, "recent_context_loaded", {
+    recentCount: recent.length,
+    unseenCount: unconsumedMessages.length
+  });
+  const boundary = resolveFreshnessBoundary(recent);
+  if (!boundary.ok) {
+    appendTrace(trace, "recent_context_missing_boundary");
+    return forwardPlan(input, {
+      action: input.action,
+      decision: "forward",
+      target: input.target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_recent_context_without_seq_boundary",
+      pendingCount: 0,
+      modelSeenSeq: 0
+    }, trace);
+  }
+  appendTrace(trace, "recent_boundary_resolved", { boundarySeq: boundary.seenUpToSeq });
+  if (unconsumedMessages.length === 0) {
+    appendTrace(trace, "recent_context_already_seen");
+    return forwardPlan(input, {
+      action: input.action,
+      decision: "forward",
+      target: input.target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_recent_context_already_seen",
+      pendingCount: 0,
+      pendingMaxSeq: boundary.seenUpToSeq,
+      modelSeenSeq: boundary.seenUpToSeq,
+      heldMessageCount: 0,
+      omittedMessageCount: 0
+    }, trace, {
+      forwardSeenUpToSeq: input.action === "send" ? boundary.seenUpToSeq : void 0,
+      consumeEffect: {
+        type: "consume_visible_messages",
+        target: input.target,
+        messages: recent,
+        boundarySeq: boundary.seenUpToSeq,
+        source: "side_effect_preflight_context"
+      }
+    });
+  }
+  const heldBoundary = resolveFreshnessBoundary(unconsumedMessages);
+  if (!heldBoundary.ok) {
+    appendTrace(trace, "unseen_context_missing_boundary");
+    return forwardPlan(input, {
+      action: input.action,
+      decision: "forward",
+      target: input.target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_unseen_context_without_seq_boundary",
+      pendingCount: 0,
+      modelSeenSeq: 0
+    }, trace);
+  }
+  appendTrace(trace, "unseen_boundary_resolved", { boundarySeq: heldBoundary.seenUpToSeq });
+  const heldMessages = latestVisibleMessages(unconsumedMessages, heldContextLimit);
+  const omittedMessageCount = Math.max(0, unconsumedMessages.length - heldMessages.length);
+  appendTrace(trace, "unseen_hold_selected", {
+    heldCount: heldMessages.length,
+    omittedCount: omittedMessageCount,
+    consumeBoundarySeq: boundary.seenUpToSeq
+  });
+  return heldPlan(input, {
+    decision: {
+      action: input.action,
+      decision: "syncing_hold",
+      target: input.target,
+      inboxTrustState: "untrusted",
+      reason: "target_first_touch_recent_context",
+      pendingCount: 0,
+      pendingMaxSeq: heldBoundary.seenUpToSeq,
+      modelSeenSeq: 0,
+      heldMessageCount: heldMessages.length,
+      omittedMessageCount
+    },
+    context: {
+      heldMessages,
+      newMessageCount: unconsumedMessages.length,
+      shownMessageCount: heldMessages.length,
+      omittedMessageCount,
+      seenUpToSeq: boundary.seenUpToSeq
+    },
+    consumeMessages: recent,
+    consumeBoundarySeq: boundary.seenUpToSeq
+  }, trace);
+}
+function heldPlan(input, held, trace) {
+  const producerFactId = buildApmFreshnessDecisionProducerFactId(input.agentId, held.decision);
+  const decision = { ...held.decision, producerFactId };
+  appendTrace(trace, "plan_built", {
+    outcome: "held",
+    decision: decision.decision,
+    effectCount: 2,
+    localResponseState: "held",
+    seenUpToSeq: held.context.seenUpToSeq
+  });
+  return {
+    outcome: "held",
+    target: input.target,
+    effects: [
+      {
+        type: "consume_visible_messages",
+        target: input.target,
+        messages: held.consumeMessages,
+        boundarySeq: held.consumeBoundarySeq,
+        source: "side_effect_preflight_context"
+      },
+      { type: "record_freshness_decision", decision }
+    ],
+    trace,
+    localResponse: projectApmHeldFreshnessEnvelope({
+      producerFactId,
+      action: input.action,
+      heldMessages: held.context.heldMessages,
+      newMessageCount: held.context.newMessageCount,
+      omittedMessageCount: held.context.omittedMessageCount,
+      seenUpToSeq: held.context.seenUpToSeq
+    }).body
+  };
+}
+function forwardPlan(input, decision, trace, options = {}) {
+  appendTrace(trace, "plan_built", {
+    outcome: "forward",
+    decision: decision.decision,
+    effectCount: options.consumeEffect ? 2 : 1,
+    forwardSeenUpToSeq: options.forwardSeenUpToSeq
+  });
+  return {
+    outcome: "forward",
+    target: input.target,
+    forwardSeenUpToSeq: options.forwardSeenUpToSeq,
+    effects: [
+      ...options.consumeEffect ? [options.consumeEffect] : [],
+      { type: "record_freshness_decision", decision }
+    ],
+    trace
+  };
+}
+function forwardWithoutDecision(input, trace) {
+  appendTrace(trace, "plan_built", {
+    outcome: "forward",
+    decision: "none",
+    effectCount: 0
+  });
+  return {
+    outcome: "forward",
+    target: input.target,
+    effects: [],
+    trace
+  };
+}
+function resolveFreshnessBoundary(messages) {
+  const seenUpToSeq = maxInboxMessageSeq(messages);
+  return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
+}
+function latestVisibleMessages(messages, limit) {
+  const sorted = sortInboxMessagesBySeq(messages);
+  return sorted.slice(Math.max(0, sorted.length - limit));
+}
+function isMessageModelSeen(input, message) {
+  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;
+}
+function messageSeq(message) {
+  return Number(message.seq ?? 0);
+}
+function messageSenderId(message) {
+  if (typeof message.sender_id === "string" && message.sender_id.length > 0) return message.sender_id;
+  if (typeof message.senderId === "string" && message.senderId.length > 0) return message.senderId;
+  return void 0;
+}
+function appendTrace(trace, step, data) {
+  const compacted = compactTraceData(data);
+  trace.push(Object.keys(compacted).length > 0 ? { step, data: compacted } : { step });
+}
+function compactTraceData(data) {
+  const compacted = {};
+  if (!data) return compacted;
+  for (const [key, value] of Object.entries(data)) {
+    if (value !== void 0) compacted[key] = value;
+  }
+  return compacted;
+}
+function parseTargetFields(target) {
+  if (target.startsWith("dm:@")) {
+    const rest = target.slice("dm:@".length);
+    const [peer, threadId] = rest.split(":", 2);
+    if (threadId) {
+      return {
+        channel_type: "thread",
+        channel_name: threadId,
+        parent_channel_type: "dm",
+        parent_channel_name: peer
+      };
+    }
+    return { channel_type: "dm", channel_name: peer };
+  }
+  if (target.startsWith("#")) {
+    const rest = target.slice(1);
+    const [channel, threadId] = rest.split(":", 2);
+    if (threadId) {
+      return {
+        channel_type: "thread",
+        channel_name: threadId,
+        parent_channel_type: "channel",
+        parent_channel_name: channel
+      };
+    }
+    return { channel_type: "channel", channel_name: channel };
+  }
+  return {};
+}
+
 // src/agentInboxProjection.ts
 function projectAgentInboxSnapshot(messages) {
   const buckets = /* @__PURE__ */ new Map();
@@ -2264,16 +2670,16 @@ function projectBucket(target, messages) {
     channelType: latest.channel_type,
     pendingCount: messages.length,
     firstPendingMsgId: messageId(first),
-    firstPendingSeq: messageSeq(first),
+    firstPendingSeq: messageSeq2(first),
     latestMsgId: messageId(latest),
-    latestSeq: messageSeq(latest),
+    latestSeq: messageSeq2(latest),
     latestSenderName: latest.sender_name ?? latest.senderName,
     latestSenderType: normalizeSenderType(latest.sender_type ?? latest.senderType),
     flags: [...flags].sort()
   });
 }
 function compareInboxMessages(a, b) {
-  return (messageSeq(a) ?? 0) - (messageSeq(b) ?? 0) || (messageId(a) ?? "").localeCompare(messageId(b) ?? "");
+  return (messageSeq2(a) ?? 0) - (messageSeq2(b) ?? 0) || (messageId(a) ?? "").localeCompare(messageId(b) ?? "");
 }
 function formatInboxMessageTarget(message) {
   if (message.channel_type === "thread" && message.parent_channel_name && message.channel_name) {
@@ -2289,7 +2695,7 @@ function messageId(message) {
   if (!message) return void 0;
   return nonEmptyString(message.message_id) ?? nonEmptyString(message.id);
 }
-function messageSeq(message) {
+function messageSeq2(message) {
   if (!message || typeof message.seq !== "number" || !Number.isFinite(message.seq) || message.seq <= 0) return void 0;
   return Math.floor(message.seq);
 }
@@ -2814,42 +3220,9 @@ async function readRequestBody(req) {
   }
   return Buffer.concat(chunks);
 }
-function messageSeq2(message) {
+function messageSeq3(message) {
   return Number(message.seq ?? 0);
 }
-function maxMessageSeq(messages) {
-  let maxSeq = 0;
-  for (const message of messages) {
-    const seq = Math.floor(messageSeq2(message));
-    if (Number.isFinite(seq) && seq > 0) maxSeq = Math.max(maxSeq, seq);
-  }
-  return maxSeq > 0 ? maxSeq : void 0;
-}
-function messageSenderId(message) {
-  if (typeof message.sender_id === "string" && message.sender_id.length > 0) return message.sender_id;
-  if (typeof message.senderId === "string" && message.senderId.length > 0) return message.senderId;
-  return void 0;
-}
-function isSelfAuthoredMessage(registration, message) {
-  return messageSenderId(message) === registration.agentId;
-}
-function isMessageModelSeen(coordinator, target, message) {
-  const seq = Math.floor(messageSeq2(message));
-  const boundary = coordinator.getBoundary(target);
-  if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= seq) return true;
-  return coordinator.isMessageModelSeen?.({ target, message }) === true;
-}
-function resolveFreshnessBoundary(messages) {
-  const seenUpToSeq = maxMessageSeq(messages);
-  return typeof seenUpToSeq === "number" ? { ok: true, seenUpToSeq } : { ok: false, reason: "missing_seq_boundary" };
-}
-function sortBySeq(messages) {
-  return [...messages].sort((a, b) => messageSeq2(a) - messageSeq2(b));
-}
-function latestVisibleMessages(messages, limit) {
-  const sorted = sortBySeq(messages);
-  return sorted.slice(Math.max(0, sorted.length - limit));
-}
 function localAgentApiInboxResponse(registration) {
   const coordinator = registration.inboxCoordinator;
   if (!coordinator) return void 0;
@@ -2897,9 +3270,9 @@ function localAgentApiEventsResponse(registration, target) {
     return { status: 400, body: parsedQuery.error };
   }
   if (pending.length === 0) return void 0;
-  const normalized = sortBySeq(normalizeVisibleMessages(pending));
+  const normalized = sortInboxMessagesBySeq(normalizeInboxVisibleMessages(pending));
   const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
-    const seq = messageSeq2(message);
+    const seq = messageSeq3(message);
     return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
   }) : normalized;
   const events = filtered.slice(0, parsedQuery.limit);
@@ -2908,7 +3281,7 @@ function localAgentApiEventsResponse(registration, target) {
   const lastSeenMsgId = newestEvent?.message_id ?? newestEvent?.id ?? null;
   const lastSeenSeq = newestEvent?.seq ?? parsedQuery.sinceSeq;
   if (events.length > 0) {
-    coordinator.consumeVisibleMessages({ messages: events, source: "agent_api_events" });
+    coordinator.consumeVisibleMessages({ messages: events, source: "agent_api_events_local" });
   }
   coordinator.recordDrainOutcome?.({
     source: "daemon_pending",
@@ -2930,30 +3303,6 @@ function localAgentApiEventsResponse(registration, target) {
     }
   };
 }
-function localHeldContext(input) {
-  if (input.messages.length === 0) return { ok: false, reason: "empty_context" };
-  const normalized = sortBySeq(normalizeVisibleMessages(input.messages, input.target));
-  const heldMessages = latestVisibleMessages(normalized, LOCAL_HELD_CONTEXT_LIMIT);
-  const omittedMessageCount = Math.max(0, normalized.length - heldMessages.length);
-  const boundary = resolveFreshnessBoundary(normalized);
-  if (!boundary.ok) return boundary;
-  input.coordinator.consumeVisibleMessages({
-    target: input.target,
-    messages: heldMessages,
-    boundarySeq: boundary.seenUpToSeq,
-    source: input.source
-  });
-  return {
-    ok: true,
-    context: {
-      heldMessages,
-      newMessageCount: normalized.length,
-      shownMessageCount: heldMessages.length,
-      omittedMessageCount,
-      seenUpToSeq: boundary.seenUpToSeq
-    }
-  };
-}
 function recordFreshnessDecision(coordinator, decision) {
   coordinator?.recordFreshnessDecision?.(decision);
 }
@@ -2967,53 +3316,6 @@ function sideEffectTarget(action, body) {
   const field = action === "send" ? body.target : body.channel;
   return typeof field === "string" && field.length > 0 ? field : void 0;
 }
-function parseTargetFields(target) {
-  if (target.startsWith("dm:@")) {
-    const rest = target.slice("dm:@".length);
-    const [peer, threadId] = rest.split(":", 2);
-    if (threadId) {
-      return {
-        channel_type: "thread",
-        channel_name: threadId,
-        parent_channel_type: "dm",
-        parent_channel_name: peer
-      };
-    }
-    return { channel_type: "dm", channel_name: peer };
-  }
-  if (target.startsWith("#")) {
-    const rest = target.slice(1);
-    const [channel, threadId] = rest.split(":", 2);
-    if (threadId) {
-      return {
-        channel_type: "thread",
-        channel_name: threadId,
-        parent_channel_type: "channel",
-        parent_channel_name: channel
-      };
-    }
-    return { channel_type: "channel", channel_name: channel };
-  }
-  return {};
-}
-function normalizeVisibleMessage(message, target) {
-  const targetFields = target ? parseTargetFields(target) : {};
-  const normalized = {
-    ...targetFields,
-    ...message,
-    message_id: message.message_id ?? message.id,
-    timestamp: message.timestamp ?? message.createdAt,
-    sender_type: message.sender_type ?? message.senderType,
-    sender_name: message.sender_name ?? message.senderName,
-    sender_description: message.sender_description ?? message.senderDescription ?? null
-  };
-  const senderId = messageSenderId(message);
-  if (senderId) normalized.sender_id = senderId;
-  return normalized;
-}
-function normalizeVisibleMessages(messages, target) {
-  return messages.map((message) => normalizeVisibleMessage(message, target));
-}
 async function loadRecentTargetMessages(registration, headers, target) {
   const historyUrl = new URL2("/internal/agent-api/history", registration.serverUrl);
   historyUrl.searchParams.set("channel", target);
@@ -3024,7 +3326,21 @@ async function loadRecentTargetMessages(registration, headers, target) {
   const res = await fetch(historyUrl, { method: "GET", headers: historyHeaders });
   if (!res.ok) return [];
   const parsed = await res.json().catch(() => null);
-  return Array.isArray(parsed?.messages) ? normalizeVisibleMessages(parsed.messages, target) : [];
+  return Array.isArray(parsed?.messages) ? normalizeInboxVisibleMessages(parsed.messages, target) : [];
+}
+function applyAgentInboxStateMachineEffects(coordinator, effects) {
+  for (const effect of effects) {
+    if (effect.type === "record_freshness_decision") {
+      recordFreshnessDecision(coordinator, effect.decision);
+      continue;
+    }
+    coordinator.consumeVisibleMessages({
+      target: effect.target,
+      messages: effect.messages,
+      boundarySeq: effect.boundarySeq,
+      source: effect.source
+    });
+  }
 }
 async function prepareAgentApiSideEffectForward(registration, headers, rawBody, action) {
   let body;
@@ -3038,166 +3354,28 @@ async function prepareAgentApiSideEffectForward(registration, headers, rawBody,
   if (!target || !coordinator) {
     return { bodyText: JSON.stringify(body), target };
   }
-  if (action === "send" && body.continueAnyway === true) {
-    recordFreshnessDecision(coordinator, {
-      action,
-      decision: "bypass",
-      target,
-      inboxTrustState: "trusted",
-      reason: "continue_anyway"
-    });
-    return { bodyText: JSON.stringify(body), target };
-  }
   const pending = coordinator.getPendingMessages(target);
-  if (pending.length > 0) {
-    const modelSeenSeq = coordinator.getBoundary(target);
-    const contextResult = localHeldContext({
-      target,
-      messages: pending,
-      coordinator,
-      source: "side_effect_preflight_context"
-    });
-    if (contextResult.ok) {
-      const { context } = contextResult;
-      const decision = {
-        action,
-        decision: "local_hold",
-        target,
-        inboxTrustState: "trusted",
-        reason: "exact_target_pending",
-        pendingCount: pending.length,
-        pendingMaxSeq: context.seenUpToSeq,
-        modelSeenSeq,
-        heldMessageCount: context.shownMessageCount,
-        omittedMessageCount: context.omittedMessageCount
-      };
-      const producerFactId = buildApmFreshnessDecisionProducerFactId(registration.agentId, decision);
-      const localResponse = projectApmHeldFreshnessEnvelope({
-        producerFactId,
-        action,
-        heldMessages: context.heldMessages,
-        newMessageCount: context.newMessageCount,
-        omittedMessageCount: context.omittedMessageCount,
-        seenUpToSeq: context.seenUpToSeq
-      }).body;
-      recordFreshnessDecision(coordinator, { ...decision, producerFactId });
-      return {
-        bodyText: JSON.stringify(body),
-        target,
-        localResponse
-      };
-    }
-    return {
-      bodyText: JSON.stringify(body),
-      target
-    };
-  }
   const existingBoundary = typeof body.seenUpToSeq === "number" && Number.isFinite(body.seenUpToSeq) ? Math.max(0, Math.floor(body.seenUpToSeq)) : void 0;
-  const loadedBoundary = coordinator.getBoundary(target);
-  const boundary = Math.max(existingBoundary ?? 0, loadedBoundary ?? 0);
-  if (boundary > 0) {
-    if (action === "send") body.seenUpToSeq = boundary;
-    recordFreshnessDecision(coordinator, {
-      action,
-      decision: "forward",
-      target,
-      inboxTrustState: "trusted",
-      reason: "model_seen_boundary",
-      pendingCount: 0,
-      modelSeenSeq: boundary
-    });
-    return { bodyText: JSON.stringify(body), target };
-  }
-  const recent = await loadRecentTargetMessages(registration, headers, target);
-  if (recent.length > 0) {
-    const unconsumedCounterparty = recent.filter(
-      (message) => !isSelfAuthoredMessage(registration, message) && !isMessageModelSeen(coordinator, target, message)
-    );
-    const boundary2 = resolveFreshnessBoundary(recent);
-    if (!boundary2.ok) {
-      recordFreshnessDecision(coordinator, {
-        action,
-        decision: "forward",
-        target,
-        inboxTrustState: "untrusted",
-        reason: "target_first_touch_recent_context_without_seq_boundary",
-        pendingCount: 0,
-        modelSeenSeq: 0
-      });
-      return { bodyText: JSON.stringify(body), target };
-    }
-    if (unconsumedCounterparty.length === 0) {
-      const { seenUpToSeq: seenUpToSeq2 } = boundary2;
-      if (action === "send") body.seenUpToSeq = seenUpToSeq2;
-      coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq2, source: "side_effect_preflight_context" });
-      recordFreshnessDecision(coordinator, {
-        action,
-        decision: "forward",
-        target,
-        inboxTrustState: "untrusted",
-        reason: "target_first_touch_recent_context_already_seen",
-        pendingCount: 0,
-        pendingMaxSeq: seenUpToSeq2,
-        modelSeenSeq: seenUpToSeq2,
-        heldMessageCount: 0,
-        omittedMessageCount: 0
-      });
-      return { bodyText: JSON.stringify(body), target };
-    }
-    const heldBoundary = resolveFreshnessBoundary(unconsumedCounterparty);
-    if (!heldBoundary.ok) {
-      recordFreshnessDecision(coordinator, {
-        action,
-        decision: "forward",
-        target,
-        inboxTrustState: "untrusted",
-        reason: "target_first_touch_counterparty_context_without_seq_boundary",
-        pendingCount: 0,
-        modelSeenSeq: 0
-      });
-      return { bodyText: JSON.stringify(body), target };
-    }
-    const heldMessages = latestVisibleMessages(unconsumedCounterparty, LOCAL_HELD_CONTEXT_LIMIT);
-    const omittedMessageCount = Math.max(0, unconsumedCounterparty.length - heldMessages.length);
-    const { seenUpToSeq } = boundary2;
-    coordinator.consumeVisibleMessages({ target, messages: recent, boundarySeq: seenUpToSeq, source: "side_effect_preflight_context" });
-    const decision = {
-      action,
-      decision: "syncing_hold",
-      target,
-      inboxTrustState: "untrusted",
-      reason: "target_first_touch_recent_context",
-      pendingCount: 0,
-      pendingMaxSeq: heldBoundary.seenUpToSeq,
-      modelSeenSeq: 0,
-      heldMessageCount: heldMessages.length,
-      omittedMessageCount
-    };
-    const producerFactId = buildApmFreshnessDecisionProducerFactId(registration.agentId, decision);
-    recordFreshnessDecision(coordinator, { ...decision, producerFactId });
-    return {
-      bodyText: JSON.stringify(body),
-      target,
-      localResponse: projectApmHeldFreshnessEnvelope({
-        producerFactId,
-        action,
-        heldMessages,
-        newMessageCount: unconsumedCounterparty.length,
-        omittedMessageCount,
-        seenUpToSeq
-      }).body
-    };
-  }
-  recordFreshnessDecision(coordinator, {
+  const continueAnyway = action === "send" && body.continueAnyway === true;
+  const shouldLoadRecent = pending.length === 0 && !continueAnyway && Math.max(existingBoundary ?? 0, coordinator.getBoundary(target) ?? 0) <= 0;
+  const recent = shouldLoadRecent ? await loadRecentTargetMessages(registration, headers, target) : [];
+  const plan = planAgentInboxSideEffect({
+    agentId: registration.agentId,
     action,
-    decision: "forward",
     target,
-    inboxTrustState: "trusted",
-    reason: "no_exact_target_pending_or_recent_context",
-    pendingCount: 0,
-    modelSeenSeq: 0
+    continueAnyway,
+    existingSeenUpToSeq: existingBoundary,
+    modelSeenSeq: coordinator.getBoundary(target),
+    pendingMessages: pending,
+    recentMessages: recent,
+    isMessageModelSeen: (messageInput) => coordinator.isMessageModelSeen?.(messageInput) === true,
+    heldContextLimit: LOCAL_HELD_CONTEXT_LIMIT
   });
-  return { bodyText: JSON.stringify(body), target };
+  applyAgentInboxStateMachineEffects(coordinator, plan.effects);
+  if (typeof plan.forwardSeenUpToSeq === "number") {
+    if (action === "send") body.seenUpToSeq = plan.forwardSeenUpToSeq;
+  }
+  return { bodyText: JSON.stringify(body), target, localResponse: plan.localResponse };
 }
 function shouldBufferJsonResponse(upstream, pathname, registration) {
   if (!registration.inboxCoordinator) return false;
@@ -3217,27 +3395,26 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
   if (targetUrl.pathname === "/internal/agent-api/send" && parsed.state === "held" && Array.isArray(parsed.heldMessages)) {
     coordinator.consumeVisibleMessages({
       target: sendTarget,
-      messages: normalizeVisibleMessages(parsed.heldMessages, sendTarget),
+      messages: normalizeInboxVisibleMessages(parsed.heldMessages, sendTarget),
       boundarySeq: typeof parsed.seenUpToSeq === "number" ? parsed.seenUpToSeq : void 0,
       source: "server_held_context"
     });
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/send" && parsed.state === "sent") {
-    const messageSeq3 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
-    if (sendTarget && messageSeq3 && messageSeq3 > 0) {
+    const messageSeq4 = typeof parsed.messageSeq === "number" && Number.isFinite(parsed.messageSeq) ? Math.floor(parsed.messageSeq) : void 0;
+    if (sendTarget && messageSeq4 && messageSeq4 > 0) {
       coordinator.consumeVisibleMessages({
         target: sendTarget,
-        messages: normalizeVisibleMessages([{ seq: messageSeq3, id: parsed.messageId }], sendTarget),
-        boundarySeq: messageSeq3,
+        messages: normalizeInboxVisibleMessages([{ id: parsed.messageId }], sendTarget),
         source: "agent_api_send_commit"
       });
     }
     return;
   }
   if (targetUrl.pathname === "/internal/agent-api/events" && Array.isArray(parsed.events)) {
-    const messages = normalizeVisibleMessages(parsed.events);
-    coordinator.consumeVisibleMessages({ messages, source: "agent_api_events" });
+    const messages = normalizeInboxVisibleMessages(parsed.events);
+    coordinator.consumeVisibleMessages({ messages, source: "agent_api_events_server" });
     coordinator.recordDrainOutcome?.({
       source: "server_events",
       sinceCursorKind: parseAgentApiEventsQuery(targetUrl).sinceCursorKind,
@@ -3249,8 +3426,8 @@ function consumeVisibleResponse(registration, targetUrl, sendTarget, responseTex
   }
   if (targetUrl.pathname === "/internal/agent-api/history" && Array.isArray(parsed.messages)) {
     const target = targetUrl.searchParams.get("channel") ?? void 0;
-    const messages = normalizeVisibleMessages(parsed.messages, target);
-    coordinator.consumeVisibleMessages({ target, messages, boundarySeq: maxMessageSeq(messages), source: "agent_api_history" });
+    const messages = normalizeInboxVisibleMessages(parsed.messages, target);
+    coordinator.consumeVisibleMessages({ target, messages, boundarySeq: maxInboxMessageSeq(messages), source: "agent_api_history" });
   }
 }
 async function registerAgentCredentialProxy(input) {
@@ -7204,9 +7381,26 @@ var RuntimeProgressState = class {
 };
 
 // src/runtimeNotificationState.ts
+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}`);
+  }
+  if (keys.length === 0) return "";
+  keys.sort();
+  return keys.join(",");
+}
 var RuntimeNotificationState = class {
   timerValue = null;
   pendingCountValue = 0;
+  lastNoticeFingerprint = null;
+  lastNoticeSessionId = null;
   get pendingCount() {
     return this.pendingCountValue;
   }
@@ -7237,6 +7431,25 @@ var RuntimeNotificationState = class {
   clear() {
     this.clearPending();
     this.clearTimer();
+    this.clearNoticeFingerprint();
+  }
+  /**
+   * True iff this exact unread-set was already successfully written in THIS
+   * session (per-(agent,session) scope — never suppress across a session
+   * change). Empty fingerprint always returns false (fail toward sending).
+   */
+  isDuplicateNotice(fingerprint, sessionId) {
+    if (fingerprint.length === 0) return false;
+    return this.lastNoticeFingerprint === fingerprint && this.lastNoticeSessionId === sessionId;
+  }
+  /** Register a fingerprint as written — call ONLY after a successful stdin write. */
+  recordNoticeWritten(fingerprint, sessionId) {
+    this.lastNoticeFingerprint = fingerprint;
+    this.lastNoticeSessionId = sessionId;
+  }
+  clearNoticeFingerprint() {
+    this.lastNoticeFingerprint = null;
+    this.lastNoticeSessionId = null;
   }
   schedule(callback, delayMs) {
     if (this.timerValue) return false;
@@ -7368,34 +7581,24 @@ function toLocalTime(iso) {
 function formatChannelLabel(message) {
   return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
 }
-function formatMessageTarget(message) {
-  if (message.channel_type === "thread" && message.parent_channel_name) {
-    const shortId = getMessageShortId(message.channel_name);
-    if (message.parent_channel_type === "dm") {
-      return `dm:@${message.parent_channel_name}:${shortId}`;
+function computeTarget(channelType, channelName, parentChannelName, parentChannelType) {
+  if (channelType === "thread" && parentChannelName) {
+    const shortId = getMessageShortId(String(channelName ?? ""));
+    if (parentChannelType === "dm") {
+      return `dm:@${parentChannelName}:${shortId}`;
     }
-    return `#${message.parent_channel_name}:${shortId}`;
+    return `#${parentChannelName}:${shortId}`;
   }
-  if (message.channel_type === "dm") {
-    return `dm:@${message.channel_name}`;
+  if (channelType === "dm") {
+    return `dm:@${channelName}`;
   }
-  return `#${message.channel_name}`;
+  return `#${channelName}`;
+}
+function formatMessageTarget(message) {
+  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
 }
 function formatVisibleMessageTarget(message) {
-  if (message.channel_type === "thread" && message.parent_channel_name && message.channel_name) {
-    const shortId = getMessageShortId(String(message.channel_name));
-    if (message.parent_channel_type === "dm") {
-      return `dm:@${message.parent_channel_name}:${shortId}`;
-    }
-    return `#${message.parent_channel_name}:${shortId}`;
-  }
-  if (message.channel_type === "dm" && message.channel_name) {
-    return `dm:@${message.channel_name}`;
-  }
-  if (message.channel_name) {
-    return `#${message.channel_name}`;
-  }
-  return null;
+  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
 }
 function getMessageShortId(messageId2) {
   return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
@@ -7617,6 +7820,8 @@ var TRAJECTORY_COALESCE_MS = 350;
 var ACTIVITY_HEARTBEAT_MS = 6e4;
 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 COMPACTION_STALE_MS = 5 * 6e4;
 var RUNTIME_PROGRESS_STALE_MS = 15 * 6e4;
 var DEFAULT_RUNTIME_START_TIMEOUT_MS = 2 * 6e4;
@@ -8030,6 +8235,14 @@ function createRuntimeTraceCounters() {
     thinkingEvents: 0
   };
 }
+function createRuntimeErrorDeliveryBackoffState() {
+  return {
+    attempts: 0,
+    untilMs: 0,
+    timer: null,
+    reason: null
+  };
+}
 function cleanupAgentCredentialProxy(agentId, launchId) {
   unregisterAgentCredentialProxyForLaunch({ agentId, launchId });
 }
@@ -8474,6 +8687,10 @@ var AgentProcessManager = class _AgentProcessManager {
   defaultAgentEnvVarsProvider;
   tracer;
   stdinNotificationRetryMs;
+  runtimeErrorDeliveryBackoffBaseMs;
+  runtimeErrorDeliveryBackoffMaxMs;
+  runtimeErrorDeliveryBackoffJitterRatio;
+  runtimeErrorDeliveryBackoffFailPointForTesting;
   cliTransportTraceDir = null;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   runtimeExitTraceAttrs = /* @__PURE__ */ new WeakMap();
@@ -8497,6 +8714,19 @@ var AgentProcessManager = class _AgentProcessManager {
       0,
       Math.floor(opts.stdinNotificationRetryMs ?? STDIN_NOTIFICATION_RETRY_DELAY_MS)
     );
+    this.runtimeErrorDeliveryBackoffBaseMs = Math.max(
+      0,
+      Math.floor(opts.runtimeErrorDeliveryBackoff?.baseMs ?? RUNTIME_ERROR_DELIVERY_BACKOFF_BASE_MS)
+    );
+    this.runtimeErrorDeliveryBackoffMaxMs = Math.max(
+      this.runtimeErrorDeliveryBackoffBaseMs,
+      Math.floor(opts.runtimeErrorDeliveryBackoff?.maxMs ?? RUNTIME_ERROR_DELIVERY_BACKOFF_MAX_MS)
+    );
+    this.runtimeErrorDeliveryBackoffJitterRatio = Math.max(
+      0,
+      Math.min(1, opts.runtimeErrorDeliveryBackoff?.jitterRatio ?? 0.1)
+    );
+    this.runtimeErrorDeliveryBackoffFailPointForTesting = opts.runtimeErrorDeliveryBackoff?.failPointForTesting ?? null;
     this.maxConcurrentAgentStarts = Math.max(
       1,
       Math.floor(
@@ -8550,6 +8780,183 @@ var AgentProcessManager = class _AgentProcessManager {
       this.sendStdinNotification(agentId);
     }, delayMs);
   }
+  clearRuntimeErrorDeliveryBackoff(ap) {
+    if (ap.runtimeErrorDeliveryBackoff.timer) {
+      clearTimeout(ap.runtimeErrorDeliveryBackoff.timer);
+    }
+    ap.runtimeErrorDeliveryBackoff = createRuntimeErrorDeliveryBackoffState();
+  }
+  clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, eventKind) {
+    if (ap.runtimeErrorDeliveryBackoff.attempts === 0 && ap.runtimeErrorDeliveryBackoff.untilMs === 0) return;
+    const attempts = ap.runtimeErrorDeliveryBackoff.attempts;
+    const reason = ap.runtimeErrorDeliveryBackoff.reason;
+    this.clearRuntimeErrorDeliveryBackoff(ap);
+    this.recordDaemonTrace("daemon.agent.runtime_error_delivery_backoff.reset", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      reason: reason || void 0,
+      attempts,
+      reset_source: eventKind
+    });
+  }
+  runtimeErrorDeliveryBackoffRemainingMs(ap) {
+    return Math.max(0, ap.runtimeErrorDeliveryBackoff.untilMs - Date.now());
+  }
+  scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap) {
+    const delayMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
+    if (delayMs <= 0 || ap.runtimeErrorDeliveryBackoff.timer) return false;
+    ap.runtimeErrorDeliveryBackoff.timer = setTimeout(() => {
+      ap.runtimeErrorDeliveryBackoff.timer = null;
+      this.flushRuntimeErrorDeliveryBackoff(agentId);
+    }, delayMs);
+    ap.runtimeErrorDeliveryBackoff.timer.unref?.();
+    return true;
+  }
+  recoverableRuntimeDeliveryBackoffReason(message, terminalFailure, stickyTerminalFailure, reasonOverride) {
+    if (stickyTerminalFailure || terminalFailure?.actionRequired) return null;
+    if (reasonOverride !== void 0) return reasonOverride;
+    if (terminalFailure) return "recoverable_terminal_runtime_error";
+    const runtimeErrorClass = buildRuntimeErrorDiagnosticEnvelope(message).spanAttrs.runtime_error_class;
+    switch (runtimeErrorClass) {
+      case "RateLimitError":
+        return "rate_limited";
+      case "ProviderServerError":
+        return "provider_server_error";
+      case "ProviderConnectionError":
+        return "provider_connection_error";
+      case "ProviderStreamError":
+        return "provider_stream_error";
+      default:
+        return null;
+    }
+  }
+  noteRuntimeErrorDeliveryBackoff(agentId, ap, message, terminalFailure, stickyTerminalFailure, reasonOverride) {
+    const reason = this.recoverableRuntimeDeliveryBackoffReason(message, terminalFailure, stickyTerminalFailure, reasonOverride);
+    if (!reason) return false;
+    const attempts = ap.runtimeErrorDeliveryBackoff.attempts + 1;
+    const exponentialDelayMs = this.runtimeErrorDeliveryBackoffBaseMs * 2 ** Math.max(0, attempts - 1);
+    const cappedDelayMs = Math.min(this.runtimeErrorDeliveryBackoffMaxMs, exponentialDelayMs);
+    const jitterMs = Math.floor(cappedDelayMs * this.runtimeErrorDeliveryBackoffJitterRatio * Math.random());
+    const delayMs = Math.min(this.runtimeErrorDeliveryBackoffMaxMs, cappedDelayMs + jitterMs);
+    if (ap.runtimeErrorDeliveryBackoff.timer) {
+      clearTimeout(ap.runtimeErrorDeliveryBackoff.timer);
+      ap.runtimeErrorDeliveryBackoff.timer = null;
+    }
+    ap.runtimeErrorDeliveryBackoff.attempts = attempts;
+    ap.runtimeErrorDeliveryBackoff.reason = reason;
+    ap.runtimeErrorDeliveryBackoff.untilMs = Date.now() + delayMs;
+    if (ap.inbox.length > 0) {
+      this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
+    }
+    this.recordDaemonTrace("daemon.agent.runtime_error_delivery_backoff", {
+      agentId,
+      runtime: ap.config.runtime,
+      model: ap.config.model,
+      launchId: ap.launchId || void 0,
+      reason,
+      attempts,
+      delay_ms: delayMs,
+      until_ms: ap.runtimeErrorDeliveryBackoff.untilMs,
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount
+    });
+    return true;
+  }
+  queueDeliveryForRuntimeErrorBackoff(agentId, ap, message) {
+    const remainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
+    if (remainingMs <= 0) return false;
+    ap.inbox.push(message);
+    if (!ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
+      ap.notifications.add();
+    }
+    const scheduled = this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
+    this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+      outcome: "queued_runtime_error_backoff",
+      accepted: true,
+      process_present: true,
+      runtime: ap.config.runtime,
+      session_id_present: Boolean(ap.sessionId),
+      launchId: ap.launchId || void 0,
+      is_idle: ap.isIdle,
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount,
+      runtime_error_backoff_remaining_ms: remainingMs,
+      runtime_error_backoff_attempts: ap.runtimeErrorDeliveryBackoff.attempts,
+      runtime_error_backoff_reason: ap.runtimeErrorDeliveryBackoff.reason || void 0,
+      runtime_error_backoff_timer_scheduled: scheduled || ap.runtimeErrorDeliveryBackoff.timer !== null
+    }));
+    return true;
+  }
+  flushRuntimeErrorDeliveryBackoff(agentId) {
+    const ap = this.agents.get(agentId);
+    if (!ap) return false;
+    const remainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
+    if (remainingMs > 0) {
+      this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
+      return false;
+    }
+    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.clearPending();
+      ap.notifications.clearTimer();
+      this.commitApmIdleState(agentId, ap, false);
+      this.startRuntimeTrace(agentId, ap, "runtime-error-backoff-idle-delivery", messages);
+      this.broadcastActivity(agentId, "working", "Message received");
+      const accepted2 = this.deliverInboxUpdateViaStdin(
+        agentId,
+        ap,
+        messages,
+        "idle",
+        "runtime_error_backoff_idle_delivery"
+      );
+      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: accepted2 ? "written" : "not_written",
+        inbox_count: ap.inbox.length,
+        messages_count: messages.length
+      });
+      return accepted2;
+    }
+    if (!ap.driver.supportsStdinNotification || !ap.sessionId) {
+      this.recordDaemonTrace("daemon.agent.runtime_error_delivery_backoff.flush", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        reason,
+        outcome: "queued_without_stdin",
+        inbox_count: ap.inbox.length,
+        session_id_present: Boolean(ap.sessionId),
+        supports_stdin_notification: ap.driver.supportsStdinNotification
+      });
+      return false;
+    }
+    if (ap.notifications.pendingCount === 0) {
+      ap.notifications.add(ap.inbox.length);
+    }
+    const accepted = this.sendStdinNotification(agentId);
+    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: "busy",
+      outcome: accepted ? "written" : "not_written",
+      inbox_count: ap.inbox.length,
+      pending_notification_count: ap.notifications.pendingCount
+    });
+    return accepted;
+  }
   allPendingVisibleMessages(agentId) {
     const collect = (messages) => (messages ?? []).filter((message) => typeof message.seq === "number" && message.seq > 0);
     return [
@@ -8596,10 +9003,13 @@ var AgentProcessManager = class _AgentProcessManager {
     if (byTarget.size === 0) return;
     const boundaryMap = this.visibleBoundaryMap(agentId);
     const visibleIds = this.visibleMessageIdMap(agentId);
+    const advancesBoundary = input.source === "spawn_wake_message" || input.source === "agent_api_events_local" || input.source.startsWith("stdin_");
     for (const [target, bucket] of byTarget) {
-      const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
-      const previous = boundaryMap.get(target) ?? 0;
-      boundaryMap.set(target, Math.max(previous, highWaterSeq));
+      if (advancesBoundary) {
+        const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
+        const previous = boundaryMap.get(target) ?? 0;
+        boundaryMap.set(target, Math.max(previous, highWaterSeq));
+      }
       if (bucket.ids.size > 0) {
         let targetIds = visibleIds.get(target);
         if (!targetIds) {
@@ -8663,6 +9073,7 @@ var AgentProcessManager = class _AgentProcessManager {
       active.notifications.remove(removedActive);
       if (active.inbox.length === 0) {
         active.notifications.clear();
+        this.clearRuntimeErrorDeliveryBackoff(active);
       }
     }
     const removedCount = removedActive + removedStarting;
@@ -9177,6 +9588,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         recentStdout: [],
         recentStderr: [],
         lastRuntimeError: null,
+        runtimeErrorDeliveryBackoff: createRuntimeErrorDeliveryBackoffState(),
         spawnError: null,
         exitCode: null,
         exitSignal: null,
@@ -9279,6 +9691,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           const ap = this.agents.get(agentId);
           if (ap.runtime !== runtime) return;
           ap.notifications.clearTimer();
+          this.clearRuntimeErrorDeliveryBackoff(ap);
           if (ap.pendingTrajectory?.timer) {
             clearTimeout(ap.pendingTrajectory.timer);
           }
@@ -9396,6 +9809,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               logger.warn(`[Agent ${agentId}] Recoverable provider stream failure (${reason}) \u2014 keeping agent wakeable`);
               this.sendAgentStatus(agentId, "active", ap.launchId);
             } else if (startupTimeoutTermination) {
+              this.cacheStartupTimeoutRetryConfig(agentId, ap);
               logger.warn(`[Agent ${agentId}] Startup timeout cleanup completed (${reason})`);
             } else {
               this.idleAgentConfigs.delete(agentId);
@@ -9466,6 +9880,23 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     this.agents.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
   }
+  cacheStartupTimeoutRetryConfig(agentId, ap) {
+    const retryConfig = {
+      ...stripManagedRunnerCredential(ap.config),
+      sessionId: ap.sessionId
+    };
+    this.idleAgentConfigs.set(agentId, {
+      config: retryConfig,
+      sessionId: ap.sessionId,
+      launchId: ap.launchId
+    });
+    this.recordDaemonTrace("daemon.agent.startup_timeout.retry_config_cached", {
+      agentId,
+      launchId: ap.launchId || void 0,
+      runtime: ap.config.runtime,
+      session_id_present: Boolean(ap.sessionId)
+    });
+  }
   async buildSpawnConfig(agentId, config) {
     const baseConfig = config.serverUrl === this.serverUrl ? config : { ...config, serverUrl: this.serverUrl };
     const runnerConfig = await this.ensureManagedRunnerCredential(agentId, baseConfig);
@@ -9693,6 +10124,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       return;
     }
     ap.notifications.clearTimer();
+    this.clearRuntimeErrorDeliveryBackoff(ap);
     if (ap.activityHeartbeat) {
       clearInterval(ap.activityHeartbeat);
     }
@@ -9747,6 +10179,14 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       this.deliveryTraceContexts.set(message, traceContext);
     }
     const transientDelivery = this.isTransientDelivery(message);
+    if (!transientDelivery && this.isVisibleMessageModelSeen(agentId, formatMessageTarget(message), message)) {
+      this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
+        outcome: "dropped_already_consumed",
+        accepted: true,
+        process_present: Boolean(this.agents.get(agentId))
+      }));
+      return true;
+    }
     const ap = this.agents.get(agentId);
     if (!ap) {
       if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
@@ -9890,6 +10330,9 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         return true;
       }
     }
+    if (!transientDelivery && this.queueDeliveryForRuntimeErrorBackoff(agentId, ap, message)) {
+      return true;
+    }
     if (ap.isIdle && ap.driver.supportsStdinNotification && ap.sessionId) {
       if (transientDelivery) {
         this.commitApmIdleState(agentId, ap, false);
@@ -10942,6 +11385,19 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
           return written;
         }
       case "deliver_stdin": {
+        const runtimeErrorBackoffRemainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
+        if (runtimeErrorBackoffRemainingMs > 0) {
+          const scheduled = this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
+          this.recordApmGatedSteeringEffectTrace(agentId, ap, effect, {
+            outcome: "suppressed_runtime_error_backoff",
+            runtime_error_backoff_remaining_ms: runtimeErrorBackoffRemainingMs,
+            runtime_error_backoff_attempts: ap.runtimeErrorDeliveryBackoff.attempts,
+            runtime_error_backoff_reason: ap.runtimeErrorDeliveryBackoff.reason || void 0,
+            runtime_error_backoff_timer_scheduled: scheduled || ap.runtimeErrorDeliveryBackoff.timer !== null,
+            delivered_messages_count: 0
+          });
+          return false;
+        }
         const messages = [...ap.inbox];
         ap.notifications.clear();
         if (messages.length === 0) {
@@ -11051,7 +11507,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     logger.warn(`[Agent ${agentId}] ${ap.driver.id} did not emit a startup runtime event within ${timeoutMs}ms; terminating process`);
     this.broadcastActivity(agentId, "error", detail, [{ kind: "text", text: `Error: ${detail}` }], ap.launchId);
     this.sendAgentStatus(agentId, "inactive", ap.launchId);
-    this.idleAgentConfigs.delete(agentId);
+    this.cacheStartupTimeoutRetryConfig(agentId, ap);
     try {
       this.runtimeExitTraceAttrs.set(ap.runtime, {
         stop_source: "startup_timeout",
@@ -11182,6 +11638,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       }
       if (event.kind === "internal_progress") {
         ap.runtimeProgress.noteInternalProgress();
+        this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
         this.recordRuntimeTraceEvent(agentId, ap, "runtime.progress.internal_observed", {
           turn_outcome: "held",
           turn_subtype: "runtime_progress",
@@ -11206,6 +11663,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "thinking", event.text);
         if (ap) {
+          this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "thinking" });
         }
@@ -11215,6 +11673,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.completeCompactionIfActive(agentId, "Context compaction finished (inferred from resumed output)");
         this.queueTrajectoryText(agentId, "text", event.text);
         if (ap) {
+          this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedAssistantContinuation(ap.gatedSteering);
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "text" });
         }
@@ -11225,6 +11684,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
         this.flushPendingTrajectory(agentId);
         const invocation = normalizeToolDisplayInvocation(event.name, event.input);
         if (ap) {
+          this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedToolUse(ap.gatedSteering, { kind: "tool_call" });
           this.recordRuntimeTraceEvent(agentId, ap, "tool.call.started", { tool: invocation.toolName });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, {
@@ -11244,6 +11704,7 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
       case "tool_output": {
         const invocation = normalizeToolDisplayInvocation(event.name, {});
         if (ap) {
+          this.clearRuntimeErrorDeliveryBackoffAfterProgress(agentId, ap, event.kind);
           const reduction = reduceApmGatedToolUse(ap.gatedSteering, { kind: "tool_output" });
           this.recordRuntimeTraceEvent(agentId, ap, "tool.output.observed", { tool: invocation.toolName });
           this.recordRuntimeTraceEvent(agentId, ap, "runtime.continuation.expected");
@@ -11303,6 +11764,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               this.commitApmIdleState(agentId, ap, true);
               if (stickyTerminalFailure) {
                 this.broadcastActivity(agentId, "error", stickyTerminalFailure.detail);
+              } else if (ap.lastRuntimeError && ap.runtimeErrorDeliveryBackoff.attempts > 0) {
+                this.broadcastActivity(agentId, "error", ap.lastRuntimeError);
               } else {
                 this.broadcastActivity(agentId, "online", "Idle");
               }
@@ -11352,12 +11815,19 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             visibleErrorMessage = formatRuntimeLoginRequiredMessage(ap.driver.id);
           }
           const shouldDisableToolBoundaryFlush = ap.runtime.descriptor.busyDelivery === "gated" && this.isThinkingBlockMutationError(event.message);
-          const terminalFailure = classifyTerminalFailure(ap);
+          const backoffFailPoint = this.runtimeErrorDeliveryBackoffFailPointForTesting?.({
+            agentId,
+            message: event.message
+          }) ?? null;
+          const terminalFailure = backoffFailPoint && Object.prototype.hasOwnProperty.call(backoffFailPoint, "terminalFailure") ? backoffFailPoint.terminalFailure ?? null : classifyTerminalFailure(ap);
+          const stickyTerminalFailure = backoffFailPoint && Object.prototype.hasOwnProperty.call(backoffFailPoint, "stickyTerminalFailure") ? backoffFailPoint.stickyTerminalFailure ?? null : classifyStickyTerminalFailure(ap);
+          const backoffReasonOverride = backoffFailPoint && Object.prototype.hasOwnProperty.call(backoffFailPoint, "reason") ? backoffFailPoint.reason ?? null : void 0;
           const reduction = reduceApmGatedError(ap.gatedSteering, {
             disableToolBoundaryFlush: shouldDisableToolBoundaryFlush,
             terminalWakeable: Boolean(ap.driver.supportsStdinNotification && terminalFailure && !terminalFailure.actionRequired)
           });
           this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "error" });
+          this.noteRuntimeErrorDeliveryBackoff(agentId, ap, event.message, terminalFailure, stickyTerminalFailure, backoffReasonOverride);
           if (reduction.shouldDisableToolBoundaryFlush) {
             this.recordGatedSteeringEvent(agentId, ap, "disabled", {
               reason: "thinking_block_mutation_error",
@@ -11378,7 +11848,6 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
             ...this.finalizeRuntimeProfileTurnControl(agentId, ap, "runtime_error")
           });
           if (ap.driver.supportsStdinNotification && terminalFailure) {
-            const stickyTerminalFailure = classifyStickyTerminalFailure(ap);
             if (terminalFailure.actionRequired) {
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} auth requires user action; terminating runtime process`);
               try {
@@ -11396,7 +11865,8 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
               this.sendAgentStatus(agentId, "inactive", ap.launchId);
               logger.warn(`[Agent ${agentId}] ${ap.driver.id} terminal runtime error requires explicit recovery`);
             } else {
-              ap.notifications.clear();
+              ap.notifications.clearPending();
+              ap.notifications.clearTimer();
               logger.info(`[Agent ${agentId}] Marked ${ap.driver.id} wakeable after terminal runtime error`);
             }
           }
@@ -11507,6 +11977,27 @@ Use ${communicationCommand(driver, "read_history")} to catch up on the channels
     if (count === 0) return false;
     if (ap.isIdle) return false;
     if (!ap.sessionId) return false;
+    const runtimeErrorBackoffRemainingMs = this.runtimeErrorDeliveryBackoffRemainingMs(ap);
+    if (runtimeErrorBackoffRemainingMs > 0) {
+      ap.notifications.add(count);
+      const scheduled = this.scheduleRuntimeErrorDeliveryBackoffFlush(agentId, ap);
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_runtime_error_backoff",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true,
+        runtime_error_backoff_remaining_ms: runtimeErrorBackoffRemainingMs,
+        runtime_error_backoff_attempts: ap.runtimeErrorDeliveryBackoff.attempts,
+        runtime_error_backoff_reason: ap.runtimeErrorDeliveryBackoff.reason || void 0,
+        runtime_error_backoff_timer_scheduled: scheduled || ap.runtimeErrorDeliveryBackoff.timer !== null
+      });
+      return false;
+    }
     if (ap.gatedSteering.compacting) {
       this.recordRuntimeTraceEvent(agentId, ap, "runtime.compaction_boundary.delivery_suppressed", {
         pendingNotificationCount: count,
@@ -11522,6 +12013,22 @@ 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));
+    const noticeFingerprint = computeInboxNoticeFingerprint(changedMessages);
+    if (ap.notifications.isDuplicateNotice(noticeFingerprint, ap.sessionId)) {
+      this.recordDaemonTrace("daemon.agent.stdin_notification", {
+        agentId,
+        runtime: ap.config.runtime,
+        model: ap.config.model,
+        launchId: ap.launchId || void 0,
+        outcome: "suppressed_duplicate",
+        mode: "busy",
+        pending_notification_count: count,
+        inbox_count: ap.inbox.length,
+        session_id_present: true
+      });
+      logger.info(`[Agent ${agentId}] Suppressing duplicate stdin inbox notice (unread-set unchanged since last write); pending=${ap.inbox.length}`);
+      return false;
+    }
     const inboxRows = projectAgentInboxSnapshot(changedMessages);
     const notification = `[Slock inbox notice:
 ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
@@ -11559,6 +12066,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
         inbox_target_count: inboxRows.length,
         session_id_present: true
       });
+      ap.notifications.recordNoticeWritten(noticeFingerprint, ap.sessionId);
       return true;
     } else {
       ap.notifications.add(count);
@@ -11855,6 +12363,8 @@ var DaemonConnection = class {
   lastDroppedSendLogAt = 0;
   lastInboundAt = null;
   lastInboundMessageKind = null;
+  pendingActivityByAgent = /* @__PURE__ */ new Map();
+  latestObservedLaunchIdByAgent = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
     this.clock = options.clock ?? systemClock;
@@ -11868,6 +12378,7 @@ var DaemonConnection = class {
   }
   disconnect() {
     this.shouldConnect = false;
+    this.pendingActivityByAgent.clear();
     this.clearWatchdog();
     if (this.reconnectTimer) {
       this.clock.clearTimeout(this.reconnectTimer);
@@ -11881,9 +12392,15 @@ var DaemonConnection = class {
   }
   send(msg) {
     if (this.ws?.readyState === WebSocket.OPEN) {
+      this.observeLaunchIdentity(msg);
+      if (msg.type === "agent:activity") {
+        this.pendingActivityByAgent.delete(msg.agentId);
+      }
       this.ws.send(JSON.stringify(msg));
       return;
     }
+    this.observeLaunchIdentity(msg);
+    this.queueReplayableMessage(msg);
     const now = this.clock.now();
     if (now - this.lastDroppedSendLogAt > 5e3) {
       this.lastDroppedSendLogAt = now;
@@ -11926,6 +12443,7 @@ var DaemonConnection = class {
         reconnect_attempt: priorReconnectAttempt,
         inbound_watchdog_ms: this.options.inboundWatchdogMs ?? INBOUND_WATCHDOG_MS
       });
+      this.flushPendingActivity(ws);
       this.options.onConnect();
     });
     ws.on("message", (data) => {
@@ -12023,6 +12541,65 @@ var DaemonConnection = class {
     this.lastInboundAt = this.clock.now();
     this.lastInboundMessageKind = messageKind;
   }
+  queueReplayableMessage(msg) {
+    if (msg.type !== "agent:activity") return;
+    const latestLaunchId = this.latestObservedLaunchIdByAgent.get(msg.agentId);
+    if (msg.launchId && latestLaunchId && msg.launchId !== latestLaunchId) {
+      this.trace("daemon.connection.pending_activity_invalidated", {
+        reason: "launch_changed",
+        message_type: msg.type,
+        agentId: msg.agentId,
+        stale_launch_id_present: true,
+        next_launch_id_present: true
+      });
+      return;
+    }
+    this.pendingActivityByAgent.set(msg.agentId, msg);
+  }
+  observeLaunchIdentity(msg) {
+    const identity = this.agentLaunchIdentity(msg);
+    if (!identity?.launchId) return;
+    if (msg.type !== "agent:activity") {
+      this.latestObservedLaunchIdByAgent.set(identity.agentId, identity.launchId);
+    }
+    const pending = this.pendingActivityByAgent.get(identity.agentId);
+    if (!pending || pending.launchId === identity.launchId) return;
+    this.pendingActivityByAgent.delete(identity.agentId);
+    this.trace("daemon.connection.pending_activity_invalidated", {
+      reason: "launch_changed",
+      message_type: msg.type,
+      agentId: identity.agentId,
+      stale_launch_id_present: Boolean(pending.launchId),
+      next_launch_id_present: true
+    });
+  }
+  agentLaunchIdentity(msg) {
+    switch (msg.type) {
+      case "agent:activity":
+      case "agent:status":
+      case "agent:session":
+      case "agent:runtime_profile":
+      case "agent:runtime_profile:migration:ack":
+      case "agent:runtime_profile:migration_done":
+      case "agent:runtime_profile:daemon_release_notice:ack":
+        return { agentId: msg.agentId, launchId: msg.launchId };
+      default:
+        return null;
+    }
+  }
+  flushPendingActivity(ws) {
+    if (this.pendingActivityByAgent.size === 0) return;
+    if (this.ws !== ws || ws.readyState !== WebSocket.OPEN) return;
+    const pending = [...this.pendingActivityByAgent.values()];
+    this.pendingActivityByAgent.clear();
+    for (const msg of pending) {
+      ws.send(JSON.stringify(msg));
+    }
+    this.trace("daemon.connection.outbound_replayed", {
+      message_type: "agent:activity",
+      message_count: pending.length
+    });
+  }
   lastInboundAgeBucket() {
     return durationMsBucket(this.lastInboundAt == null ? null : this.clock.now() - this.lastInboundAt);
   }