@athenaintel/react 0.48.0 → 0.50.0

package/dist/agent-runtime/src/runtime.d.ts

@@ -10,7 +10,7 @@ export { pickThreadConfigCustom, type ThreadConfigPatch, } from "./config-mutati
 export { type ConversationIndexEntry, conversationIndexFingerprint, useConversationIndex, } from "./conversation-index";
 export { type ConversationListPage, type ConversationSummary, mergeConversationIndexIntoPage, } from "./conversation-list";
 export { isLegacyThreadReadOnlyRejection, isStatewireChannelTeardown, isStatewireRewindAnchorRejection, statewireRejectionDetailMessage, statewireRejectionPayload, } from "./errors";
-export { asHitlApproval, findAbandonedInterrupt, HITL_PENDING_RESUME_GRACE_MS, type HitlApprovalPayload, hitlResumeApprove, hitlResumeReject, interruptResumeDecline, isApprovalCardInterrupt, readAbandonedInputRequests, readInterruptMessage, useApprovalResumeLock, } from "./interrupts";
+export { asHitlApproval, findAbandonedInterrupt, HITL_PENDING_RESUME_GRACE_MS, type HitlApprovalPayload, hitlResumeApprove, hitlResumeReject, interruptResumeDecline, isApprovalCardInterrupt, pendingActionRequests, readAbandonedInputRequests, readInterruptMessage, toolCallIdsAwaitingApproval, useApprovalResumeLock, } from "./interrupts";
 export { type DeepAgentMessageWindowDeclaration } from "./message-window";
 export { ATHENA_RUN_MARKER_KEY, isQueuedLaneMessage, } from "./messages";
 export { isDeepAgentHostState } from "./protocol";
@@ -32,9 +32,10 @@ export { DeepAgentChatOutboxContext, useChatOutboxReachable, useChatOutboxSnapsh
 export { type DeepAgentConfigWriteResult, isConfigWriteForbiddenRejection, useDeepAgentConfig, } from "./use-deep-agent-config";
 export { useDeepAgentMessageEditSubmit } from "./use-deep-agent-edit-submit";
 export { type DeepAgentThreadElement, logUnhandledStatewireError, useDeepAgentRuntime, } from "./use-deep-agent-runtime";
-export { describeVoiceFailure, describeVoiceLiveElsewhere, type DeepAgentVoiceSurface, useDeepAgentVoice, type UseDeepAgentVoiceReturn, useVoiceElapsed, useVoiceMovedNotice, VOICE_CONTINUE_BY_VOICE_LABEL, VOICE_MOVE_CALL_HERE_LABEL, VOICE_MOVE_HERE_ACTION, } from "./use-deep-agent-voice";
+export { describeVoiceFailure, describeVoiceLiveElsewhere, type DeepAgentVoiceCallMove, type DeepAgentVoiceSurface, playVoiceMoveEarcon, useDeepAgentVoice, type UseDeepAgentVoiceReturn, useVoiceElapsed, useVoiceMovedNotice, VOICE_CONTINUE_BY_VOICE_LABEL, VOICE_MOVE_CALL_HERE_LABEL, VOICE_MOVE_EARCON_MS, VOICE_MOVE_HERE_ACTION, voiceMoveEarconDataUri, } from "./use-deep-agent-voice";
 export { useDeepAgentWindowSync } from "./use-deep-agent-window-sync";
 export { describeVoiceUpdateToolCall, isVoiceDelegationMessage, VOICE_LIVE_TYPED_HINT, VOICE_UPDATE_TOOL_NAME, voiceProvenanceLabel, voiceUpdateStatusLabel, } from "./voice-presentation";
+export { CALL_RECAP_APPROVAL_LABEL, CALL_RECAP_TITLE, type CallRecap, type CallRecapApproval, type CallRecapAsset, type CallRecapItem, type CallRecapLink, type CallRecapMessage, type CallRecapOpenToolCall, type CallRecapPart, callRecapAfter, callRecapHasItems, callRecapItems, isCallUserMessage, mayHaveLiveCall, VOICE_TYPED_ID_PREFIX, } from "./call-recap";
 export { type ResumeExtras } from "./interrupts";
 export { resumeValueApproves } from "./interrupts";
 export { statewireAnswerDescriptors } from "./decision-checks";

package/dist/agent-runtime/src/send-recovery.cjs

@@ -4,12 +4,16 @@ const statewireState = require("./statewire-state.cjs");
 const AUTO_RETRY_FATES = /* @__PURE__ */ new Set(["lost", "aborted"]);
 const MAX_AUTO_RETRIES_PER_MESSAGE = 3;
 const MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1e3;
+const MAX_BEFORE_RETRY_HOLDS = 10;
 function shouldAutoRetryFailedSend(failure) {
   return failure !== void 0 && AUTO_RETRY_FATES.has(failure.fate);
 }
 function awaitsLostPredecessor(entry) {
   return entry.sendFailure.fate === "aborted" && entry.sendFailure.predecessorLost === true;
 }
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
 function commandMessageId(update) {
   var _a, _b;
   const first = (_a = update.params) == null ? void 0 : _a[0];
@@ -28,14 +32,16 @@ function createDeepAgentSendRecovery(options) {
   const surfacedDeferrals = /* @__PURE__ */ new Set();
   const inFlight = /* @__PURE__ */ new Set();
   const deferred = /* @__PURE__ */ new Set();
+  const holds = /* @__PURE__ */ new Map();
+  let holding = false;
   const record = (event, data) => {
     var _a, _b;
     (_b = (_a = options.diagnostics) == null ? void 0 : _a.call(options)) == null ? void 0 : _b.record(event, data);
   };
   const sweep = () => {
-    var _a;
+    var _a, _b;
     sweepScheduled = false;
-    if (disposed || !hydrated || !armed) return;
+    if (disposed || holding || !hydrated || !armed) return;
     const lane = options.lane();
     if (lane === null) return;
     armed = false;
@@ -75,6 +81,29 @@ function createDeepAgentSendRecovery(options) {
         if (isLost) lostPredecessorPending = true;
         continue;
       }
+      let before;
+      try {
+        before = (_b = options.beforeRetry) == null ? void 0 : _b.call(options, entry.id);
+      } catch {
+        record("send-recovery/before-retry-failed", { messageId: entry.id });
+      }
+      if (isThenable(before)) {
+        const held = (holds.get(entry.id) ?? 0) + 1;
+        if (held <= MAX_BEFORE_RETRY_HOLDS) {
+          holds.set(entry.id, held);
+          holding = true;
+          armed = true;
+          record("send-recovery/held", { messageId: entry.id, holds: held });
+          const resume = () => {
+            holding = false;
+            armed = true;
+            scheduleSweep();
+          };
+          before.then(resume, resume);
+          return;
+        }
+        record("send-recovery/held-too-long", { messageId: entry.id });
+      }
       try {
         lane.retryFailed(entry.id);
         attempts.set(entry.id, attempt);
@@ -87,12 +116,16 @@ function createDeepAgentSendRecovery(options) {
         });
       } catch {
         record("send-recovery/raced", { messageId: entry.id });
+        try {
+          if (typeof before === "function") before();
+        } catch {
+        }
       }
     }
     if (deferred.size > 0) armed = true;
   };
   const scheduleSweep = () => {
-    if (disposed || sweepScheduled || !hydrated || !armed) return;
+    if (disposed || sweepScheduled || holding || !hydrated || !armed) return;
     sweepScheduled = true;
     schedule(sweep);
   };
@@ -123,6 +156,7 @@ function createDeepAgentSendRecovery(options) {
     }
   };
 }
+exports.MAX_BEFORE_RETRY_HOLDS = MAX_BEFORE_RETRY_HOLDS;
 exports.createDeepAgentSendRecovery = createDeepAgentSendRecovery;
 exports.shouldAutoRetryFailedSend = shouldAutoRetryFailedSend;
 //# sourceMappingURL=send-recovery.cjs.map

package/dist/agent-runtime/src/send-recovery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"send-recovery.cjs","sources":["../../../../agent-runtime/src/send-recovery.ts"],"sourcesContent":["import type {\n  StatewireDiagnosticsCommandUpdate,\n  StatewireDiagnosticsRecorder,\n} from './statewire-diagnostics';\nimport { isDeepAgentStateHydrated } from './statewire-state';\nimport type { StatewireFailedSendEntry, StatewireFailedSendLane } from './thread-extras';\n\n/**\n * Transport-level send durability for the deep-agent thread (the successor to\n * Olympus' localStorage outbox, #29368 → #31504).\n *\n * The durable journal itself is the statewire session record: every command is\n * persisted through the mounted session storage from `send()` until the server\n * durably admits or judges it, and a reload resends survivors on the SAME lane\n * seq (exactly-once — the server absorbs replayed seqs at or below its\n * watermark). What the record cannot recover on its own is a send the client\n * had to settle without a server verdict — a proven session loss or a record\n * reset settles it `lost`/`aborted` and RETAINS it in the record's failed lane\n * (message-carrying sends only), where the vendor drops it as soon as a\n * canonical snapshot shows the message landed (`failureCovered`).\n *\n * This controller turns that persisted failed lane back into live sends: once\n * the thread snapshot has hydrated (so covered entries are already gone), every\n * failed send the server NEVER judged is re-dispatched through the thread's own\n * `retryFailed` — same client-minted message id, re-anchored against the\n * current thread — which the host dedupes by id (a still-queued id re-places,\n * a durable one rejects `duplicate-id`). Server-judged fates (`rejected`,\n * `failed`, `crashed`, `expired`) are the user's decision and stay in the\n * manual retry/discard affordance.\n *\n * Ordering: an `aborted` send stamped `predecessorLost` was never attempted\n * because an earlier send of the same batch WAS attempted and settled `lost`\n * — it may or may not have run. Re-dispatching the successor first could land\n * it ahead of a predecessor that later turns out to have landed too, so the\n * successor is held until every preceding `lost` predecessor has settled: it\n * was covered by a snapshot, its retry was judged by the server, or the user\n * discarded it.\n */\n\n/** Fates the server never saw: the send died client-side (unmount, stream\n * gone, session lost) and is safe to re-dispatch under its original message\n * id. The complement — rejected/failed/crashed/expired — is server-judged. */\nconst AUTO_RETRY_FATES: ReadonlySet<string> = new Set(['lost', 'aborted']);\n\n/** A failed send is re-dispatched at most this many times per attach; a\n * persistent failure (repeated session losses) stays in the manual lane. */\nconst MAX_AUTO_RETRIES_PER_MESSAGE = 3;\n\n/** Persisted failures older than this stay manual: auto-sending a message the\n * user abandoned a day ago is worse than surfacing it for a decision. Mirrors\n * the retired outbox's retention window. */\nconst MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1000;\n\nexport interface DeepAgentSendRecoveryOptions {\n  /**\n   * Reads the thread's failed-send lane. `null` while it is unavailable (the\n   * client has not mounted yet, or its extras are not a statewire thread) —\n   * the controller stays armed and retries on the next state change.\n   */\n  lane: () => StatewireFailedSendLane | null;\n  /**\n   * Persisted failure stamps (message id → epoch ms of the original send) for\n   * the freshness gate. `null`/absent means no persistence is readable — every\n   * lane entry then counts as fresh (an in-memory failed lane can only hold\n   * failures from this page session).\n   */\n  failureStamps?: (() => ReadonlyMap<string, number> | null) | undefined;\n  /** Transport lifecycle recorder; read per event so a late-mounted recorder still sees retries. */\n  diagnostics?: (() => StatewireDiagnosticsRecorder | undefined) | undefined;\n  /** Injectable clock (tests). */\n  now?: () => number;\n  /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches\n   * from inside a statewire flush or a React render. */\n  schedule?: (task: () => void) => void;\n}\n\nexport interface DeepAgentSendRecovery {\n  /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */\n  observeStateChange(state: unknown): void;\n  /** Feed every command-lifecycle update; a never-server-judged settle arms a sweep. */\n  observeCommand(update: StatewireDiagnosticsCommandUpdate): void;\n  /** Feed client notifications too: failed history can publish after the\n   * command settles, without any change to the canonical thread snapshot. */\n  observeFailedLaneChange(): void;\n  dispose(): void;\n}\n\n/** Whether a settle failure is a client-side death the recovery re-dispatches\n * (the server never judged the command). Exported for host-side telemetry. */\nexport function shouldAutoRetryFailedSend(failure: { fate: string } | undefined): boolean {\n  return failure !== undefined && AUTO_RETRY_FATES.has(failure.fate);\n}\n\n/** Whether a failed entry must wait for a lost predecessor to settle first. */\nfunction awaitsLostPredecessor(entry: StatewireFailedSendEntry): boolean {\n  return entry.sendFailure.fate === 'aborted' && entry.sendFailure.predecessorLost === true;\n}\n\n/** The client-minted message id a run send carries, off a command update's params. */\nfunction commandMessageId(update: StatewireDiagnosticsCommandUpdate): string | null {\n  const first = update.params?.[0] as { message?: { id?: unknown } } | undefined;\n  const id = first?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\nexport function createDeepAgentSendRecovery(\n  options: DeepAgentSendRecoveryOptions\n): DeepAgentSendRecovery {\n  const now = options.now ?? Date.now;\n  const schedule = options.schedule ?? ((task: () => void) => queueMicrotask(task));\n\n  let disposed = false;\n  let hydrated = false;\n  /** Work may exist: set at hydration and on retryable settles, cleared by a\n   * sweep that could actually read the lane. */\n  let armed = false;\n  let sweepScheduled = false;\n  /** Retry budget per message id, for this controller's attach lifetime. */\n  const attempts = new Map<string, number>();\n  /** Message ids already diagnosed as stale/exhausted, so the lane re-scan\n   * stays quiet about them. */\n  const surfacedSkips = new Set<string>();\n  /** Message ids whose deferral behind a lost predecessor was diagnosed once. */\n  const surfacedDeferrals = new Set<string>();\n  /** Re-dispatched sends still awaiting the server's verdict: a successor\n   * stamped `predecessorLost` waits while any of these is pending. */\n  const inFlight = new Set<string>();\n  /** Successors held back by the last sweep; a non-empty set keeps the\n   * controller armed so the next settle or state change re-sweeps. */\n  const deferred = new Set<string>();\n\n  const record = (event: string, data?: Record<string, unknown>): void => {\n    options.diagnostics?.()?.record(event, data);\n  };\n\n  const sweep = (): void => {\n    sweepScheduled = false;\n    if (disposed || !hydrated || !armed) return;\n    const lane = options.lane();\n    // No readable lane yet: stay armed so the next state change re-sweeps.\n    if (lane === null) return;\n    armed = false;\n    deferred.clear();\n    const stamps = options.failureStamps?.() ?? null;\n    // A `lost` entry earlier in lane order that this sweep leaves unsettled\n    // (skipped as stale/exhausted, or re-dispatched and now in flight).\n    let lostPredecessorPending = false;\n    for (const entry of lane.failed) {\n      if (!shouldAutoRetryFailedSend(entry.sendFailure)) continue;\n      // Shared retry/discard may still be waiting for the storage lock. The\n      // visible lane can keep this entry until then; do not spend another\n      // attempt on a send whose previous retry is still awaiting a verdict.\n      if (inFlight.has(entry.id)) {\n        if (entry.sendFailure.fate === 'lost') lostPredecessorPending = true;\n        continue;\n      }\n      if (awaitsLostPredecessor(entry) && (lostPredecessorPending || inFlight.size > 0)) {\n        deferred.add(entry.id);\n        if (!surfacedDeferrals.has(entry.id)) {\n          surfacedDeferrals.add(entry.id);\n          record('send-recovery/deferred', { messageId: entry.id });\n        }\n        continue;\n      }\n      const isLost = entry.sendFailure.fate === 'lost';\n      const stamp = stamps?.get(entry.id);\n      if (stamp !== undefined && now() - stamp > MAX_AUTO_RETRY_AGE_MS) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/stale', { messageId: entry.id, ageMs: Math.round(now() - stamp) });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      const attempt = (attempts.get(entry.id) ?? 0) + 1;\n      if (attempt > MAX_AUTO_RETRIES_PER_MESSAGE) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/exhausted', { messageId: entry.id });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      try {\n        lane.retryFailed(entry.id);\n        attempts.set(entry.id, attempt);\n        inFlight.add(entry.id);\n        if (isLost) lostPredecessorPending = true;\n        record('send-recovery/retry', {\n          messageId: entry.id,\n          fate: entry.sendFailure.fate,\n          attempt,\n        });\n      } catch {\n        // The entry settled or was covered between the lane read and the\n        // retry (the vendor drops covered failures against every snapshot);\n        // nothing was dispatched.\n        record('send-recovery/raced', { messageId: entry.id });\n      }\n    }\n    // Held successors must be revisited once their predecessors settle.\n    if (deferred.size > 0) armed = true;\n  };\n\n  const scheduleSweep = (): void => {\n    if (disposed || sweepScheduled || !hydrated || !armed) return;\n    sweepScheduled = true;\n    schedule(sweep);\n  };\n\n  return {\n    observeStateChange(state) {\n      if (disposed) return;\n      if (!hydrated && isDeepAgentStateHydrated(state)) {\n        // First real snapshot: the vendor's failureCovered pass has had its\n        // chance to drop entries whose message actually landed, so whatever\n        // remains provably never reached the thread.\n        hydrated = true;\n        armed = true;\n      }\n      scheduleSweep();\n    },\n    observeCommand(update) {\n      if (disposed || update.status !== 'settled') return;\n      const messageId = commandMessageId(update);\n      if (messageId !== null) inFlight.delete(messageId);\n      // A never-server-judged settle means new work; any settle while\n      // successors are held may be the predecessor they wait on.\n      if (!shouldAutoRetryFailedSend(update.failure) && deferred.size === 0) return;\n      armed = true;\n      scheduleSweep();\n    },\n    observeFailedLaneChange() {\n      if (disposed) return;\n      armed = true;\n      scheduleSweep();\n    },\n    dispose() {\n      disposed = true;\n    },\n  };\n}\n"],"names":["isDeepAgentStateHydrated"],"mappings":"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"}
+{"version":3,"file":"send-recovery.cjs","sources":["../../../../agent-runtime/src/send-recovery.ts"],"sourcesContent":["import type {\n  StatewireDiagnosticsCommandUpdate,\n  StatewireDiagnosticsRecorder,\n} from './statewire-diagnostics';\nimport { isDeepAgentStateHydrated } from './statewire-state';\nimport type { StatewireFailedSendEntry, StatewireFailedSendLane } from './thread-extras';\n\n/**\n * Transport-level send durability for the deep-agent thread (the successor to\n * Olympus' localStorage outbox, #29368 → #31504).\n *\n * The durable journal itself is the statewire session record: every command is\n * persisted through the mounted session storage from `send()` until the server\n * durably admits or judges it, and a reload resends survivors on the SAME lane\n * seq (exactly-once — the server absorbs replayed seqs at or below its\n * watermark). What the record cannot recover on its own is a send the client\n * had to settle without a server verdict — a proven session loss or a record\n * reset settles it `lost`/`aborted` and RETAINS it in the record's failed lane\n * (message-carrying sends only), where the vendor drops it as soon as a\n * canonical snapshot shows the message landed (`failureCovered`).\n *\n * This controller turns that persisted failed lane back into live sends: once\n * the thread snapshot has hydrated (so covered entries are already gone), every\n * failed send the server NEVER judged is re-dispatched through the thread's own\n * `retryFailed` — same client-minted message id, re-anchored against the\n * current thread — which the host dedupes by id (a still-queued id re-places,\n * a durable one rejects `duplicate-id`). Server-judged fates (`rejected`,\n * `failed`, `crashed`, `expired`) are the user's decision and stay in the\n * manual retry/discard affordance.\n *\n * Ordering: an `aborted` send stamped `predecessorLost` was never attempted\n * because an earlier send of the same batch WAS attempted and settled `lost`\n * — it may or may not have run. Re-dispatching the successor first could land\n * it ahead of a predecessor that later turns out to have landed too, so the\n * successor is held until every preceding `lost` predecessor has settled: it\n * was covered by a snapshot, its retry was judged by the server, or the user\n * discarded it.\n */\n\n/** Fates the server never saw: the send died client-side (unmount, stream\n * gone, session lost) and is safe to re-dispatch under its original message\n * id. The complement — rejected/failed/crashed/expired — is server-judged. */\nconst AUTO_RETRY_FATES: ReadonlySet<string> = new Set(['lost', 'aborted']);\n\n/** A failed send is re-dispatched at most this many times per attach; a\n * persistent failure (repeated session losses) stays in the manual lane. */\nconst MAX_AUTO_RETRIES_PER_MESSAGE = 3;\n\n/** Persisted failures older than this stay manual: auto-sending a message the\n * user abandoned a day ago is worse than surfacing it for a decision. Mirrors\n * the retired outbox's retention window. */\nconst MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1000;\n\n/** How many times a host may hold one message's retry (`beforeRetry`\n * returning a promise) before the sweep sends it regardless: a hold is the\n * host's own bounded wait, never a reason to keep a message back for good. */\nexport const MAX_BEFORE_RETRY_HOLDS = 10;\n\nexport interface DeepAgentSendRecoveryOptions {\n  /**\n   * Reads the thread's failed-send lane. `null` while it is unavailable (the\n   * client has not mounted yet, or its extras are not a statewire thread) —\n   * the controller stays armed and retries on the next state change.\n   */\n  lane: () => StatewireFailedSendLane | null;\n  /**\n   * Persisted failure stamps (message id → epoch ms of the original send) for\n   * the freshness gate. `null`/absent means no persistence is readable — every\n   * lane entry then counts as fresh (an in-memory failed lane can only hold\n   * failures from this page session).\n   */\n  failureStamps?: (() => ReadonlyMap<string, number> | null) | undefined;\n  /** Transport lifecycle recorder; read per event so a late-mounted recorder still sees retries. */\n  diagnostics?: (() => StatewireDiagnosticsRecorder | undefined) | undefined;\n  /** Injectable clock (tests). */\n  now?: () => number;\n  /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches\n   * from inside a statewire flush or a React render. */\n  schedule?: (task: () => void) => void;\n  /**\n   * Called right before a failed send is dispatched again, with its message\n   * id, so a host can put back the per-send context that message was sent\n   * with (Olympus stages the agents it named) before its command leaves.\n   *\n   * Returning a promise holds the retry: the host can't put that context back\n   * yet (every send of the conversation rides one ambient context, and a send\n   * with another context is still on its way). The sweep then stops at this\n   * message, so nothing behind it overtakes it, and asks again once the\n   * promise settles; past {@link MAX_BEFORE_RETRY_HOLDS} holds it sends the\n   * message regardless. A hook that throws never holds a retry back. A\n   * function returned is called when the message does not go after all (the\n   * retry raced its leaving the lane), so the host lets go of what it put back.\n   */\n  beforeRetry?: ((messageId: string) => void | PromiseLike<void> | (() => void)) | undefined;\n}\n\nexport interface DeepAgentSendRecovery {\n  /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */\n  observeStateChange(state: unknown): void;\n  /** Feed every command-lifecycle update; a never-server-judged settle arms a sweep. */\n  observeCommand(update: StatewireDiagnosticsCommandUpdate): void;\n  /** Feed client notifications too: failed history can publish after the\n   * command settles, without any change to the canonical thread snapshot. */\n  observeFailedLaneChange(): void;\n  dispose(): void;\n}\n\n/** Whether a settle failure is a client-side death the recovery re-dispatches\n * (the server never judged the command). Exported for host-side telemetry. */\nexport function shouldAutoRetryFailedSend(failure: { fate: string } | undefined): boolean {\n  return failure !== undefined && AUTO_RETRY_FATES.has(failure.fate);\n}\n\n/** Whether a failed entry must wait for a lost predecessor to settle first. */\nfunction awaitsLostPredecessor(entry: StatewireFailedSendEntry): boolean {\n  return entry.sendFailure.fate === 'aborted' && entry.sendFailure.predecessorLost === true;\n}\n\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { then?: unknown }).then === 'function'\n  );\n}\n\n/** The client-minted message id a run send carries, off a command update's params. */\nfunction commandMessageId(update: StatewireDiagnosticsCommandUpdate): string | null {\n  const first = update.params?.[0] as { message?: { id?: unknown } } | undefined;\n  const id = first?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\nexport function createDeepAgentSendRecovery(\n  options: DeepAgentSendRecoveryOptions\n): DeepAgentSendRecovery {\n  const now = options.now ?? Date.now;\n  const schedule = options.schedule ?? ((task: () => void) => queueMicrotask(task));\n\n  let disposed = false;\n  let hydrated = false;\n  /** Work may exist: set at hydration and on retryable settles, cleared by a\n   * sweep that could actually read the lane. */\n  let armed = false;\n  let sweepScheduled = false;\n  /** Retry budget per message id, for this controller's attach lifetime. */\n  const attempts = new Map<string, number>();\n  /** Message ids already diagnosed as stale/exhausted, so the lane re-scan\n   * stays quiet about them. */\n  const surfacedSkips = new Set<string>();\n  /** Message ids whose deferral behind a lost predecessor was diagnosed once. */\n  const surfacedDeferrals = new Set<string>();\n  /** Re-dispatched sends still awaiting the server's verdict: a successor\n   * stamped `predecessorLost` waits while any of these is pending. */\n  const inFlight = new Set<string>();\n  /** Successors held back by the last sweep; a non-empty set keeps the\n   * controller armed so the next settle or state change re-sweeps. */\n  const deferred = new Set<string>();\n  /** How many times the host held each message's retry (`beforeRetry`'s promise). */\n  const holds = new Map<string, number>();\n  /** A host's hold in progress: no sweep runs until it settles. */\n  let holding = false;\n\n  const record = (event: string, data?: Record<string, unknown>): void => {\n    options.diagnostics?.()?.record(event, data);\n  };\n\n  const sweep = (): void => {\n    sweepScheduled = false;\n    // A host's hold re-sweeps once it settles; until then nothing is retried.\n    if (disposed || holding || !hydrated || !armed) return;\n    const lane = options.lane();\n    // No readable lane yet: stay armed so the next state change re-sweeps.\n    if (lane === null) return;\n    armed = false;\n    deferred.clear();\n    const stamps = options.failureStamps?.() ?? null;\n    // A `lost` entry earlier in lane order that this sweep leaves unsettled\n    // (skipped as stale/exhausted, or re-dispatched and now in flight).\n    let lostPredecessorPending = false;\n    for (const entry of lane.failed) {\n      if (!shouldAutoRetryFailedSend(entry.sendFailure)) continue;\n      // Shared retry/discard may still be waiting for the storage lock. The\n      // visible lane can keep this entry until then; do not spend another\n      // attempt on a send whose previous retry is still awaiting a verdict.\n      if (inFlight.has(entry.id)) {\n        if (entry.sendFailure.fate === 'lost') lostPredecessorPending = true;\n        continue;\n      }\n      if (awaitsLostPredecessor(entry) && (lostPredecessorPending || inFlight.size > 0)) {\n        deferred.add(entry.id);\n        if (!surfacedDeferrals.has(entry.id)) {\n          surfacedDeferrals.add(entry.id);\n          record('send-recovery/deferred', { messageId: entry.id });\n        }\n        continue;\n      }\n      const isLost = entry.sendFailure.fate === 'lost';\n      const stamp = stamps?.get(entry.id);\n      if (stamp !== undefined && now() - stamp > MAX_AUTO_RETRY_AGE_MS) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/stale', { messageId: entry.id, ageMs: Math.round(now() - stamp) });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      const attempt = (attempts.get(entry.id) ?? 0) + 1;\n      if (attempt > MAX_AUTO_RETRIES_PER_MESSAGE) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/exhausted', { messageId: entry.id });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      let before: ReturnType<NonNullable<DeepAgentSendRecoveryOptions['beforeRetry']>> | undefined;\n      try {\n        before = options.beforeRetry?.(entry.id);\n      } catch {\n        // A host's own context step failing never holds the retry back.\n        record('send-recovery/before-retry-failed', { messageId: entry.id });\n      }\n      if (isThenable(before)) {\n        const held = (holds.get(entry.id) ?? 0) + 1;\n        if (held <= MAX_BEFORE_RETRY_HOLDS) {\n          // The host can't put this message's context back yet: it waits, and\n          // so does everything behind it (nothing overtakes it); the sweep asks\n          // again once the hold settles.\n          holds.set(entry.id, held);\n          holding = true;\n          armed = true;\n          record('send-recovery/held', { messageId: entry.id, holds: held });\n          const resume = (): void => {\n            holding = false;\n            armed = true;\n            scheduleSweep();\n          };\n          before.then(resume, resume);\n          return;\n        }\n        record('send-recovery/held-too-long', { messageId: entry.id });\n      }\n      try {\n        lane.retryFailed(entry.id);\n        attempts.set(entry.id, attempt);\n        inFlight.add(entry.id);\n        if (isLost) lostPredecessorPending = true;\n        record('send-recovery/retry', {\n          messageId: entry.id,\n          fate: entry.sendFailure.fate,\n          attempt,\n        });\n      } catch {\n        // The entry settled or was covered between the lane read and the\n        // retry (the vendor drops covered failures against every snapshot);\n        // nothing was dispatched, so the host lets go of what it put back.\n        record('send-recovery/raced', { messageId: entry.id });\n        try {\n          if (typeof before === 'function') before();\n        } catch {\n          // The host's own step failing never stops the sweep.\n        }\n      }\n    }\n    // Held successors must be revisited once their predecessors settle.\n    if (deferred.size > 0) armed = true;\n  };\n\n  const scheduleSweep = (): void => {\n    if (disposed || sweepScheduled || holding || !hydrated || !armed) return;\n    sweepScheduled = true;\n    schedule(sweep);\n  };\n\n  return {\n    observeStateChange(state) {\n      if (disposed) return;\n      if (!hydrated && isDeepAgentStateHydrated(state)) {\n        // First real snapshot: the vendor's failureCovered pass has had its\n        // chance to drop entries whose message actually landed, so whatever\n        // remains provably never reached the thread.\n        hydrated = true;\n        armed = true;\n      }\n      scheduleSweep();\n    },\n    observeCommand(update) {\n      if (disposed || update.status !== 'settled') return;\n      const messageId = commandMessageId(update);\n      if (messageId !== null) inFlight.delete(messageId);\n      // A never-server-judged settle means new work; any settle while\n      // successors are held may be the predecessor they wait on.\n      if (!shouldAutoRetryFailedSend(update.failure) && deferred.size === 0) return;\n      armed = true;\n      scheduleSweep();\n    },\n    observeFailedLaneChange() {\n      if (disposed) return;\n      armed = true;\n      scheduleSweep();\n    },\n    dispose() {\n      disposed = true;\n    },\n  };\n}\n"],"names":["isDeepAgentStateHydrated"],"mappings":"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"}

package/dist/agent-runtime/src/send-recovery.d.ts

@@ -1,5 +1,9 @@
 import type { StatewireDiagnosticsCommandUpdate, StatewireDiagnosticsRecorder } from './statewire-diagnostics';
 import type { StatewireFailedSendLane } from './thread-extras';
+/** How many times a host may hold one message's retry (`beforeRetry`
+ * returning a promise) before the sweep sends it regardless: a hold is the
+ * host's own bounded wait, never a reason to keep a message back for good. */
+export declare const MAX_BEFORE_RETRY_HOLDS = 10;
 export interface DeepAgentSendRecoveryOptions {
     /**
      * Reads the thread's failed-send lane. `null` while it is unavailable (the
@@ -21,6 +25,21 @@ export interface DeepAgentSendRecoveryOptions {
     /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches
      * from inside a statewire flush or a React render. */
     schedule?: (task: () => void) => void;
+    /**
+     * Called right before a failed send is dispatched again, with its message
+     * id, so a host can put back the per-send context that message was sent
+     * with (Olympus stages the agents it named) before its command leaves.
+     *
+     * Returning a promise holds the retry: the host can't put that context back
+     * yet (every send of the conversation rides one ambient context, and a send
+     * with another context is still on its way). The sweep then stops at this
+     * message, so nothing behind it overtakes it, and asks again once the
+     * promise settles; past {@link MAX_BEFORE_RETRY_HOLDS} holds it sends the
+     * message regardless. A hook that throws never holds a retry back. A
+     * function returned is called when the message does not go after all (the
+     * retry raced its leaving the lane), so the host lets go of what it put back.
+     */
+    beforeRetry?: ((messageId: string) => void | PromiseLike<void> | (() => void)) | undefined;
 }
 export interface DeepAgentSendRecovery {
     /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */

package/dist/agent-runtime/src/send-recovery.js

@@ -2,12 +2,16 @@ import { isDeepAgentStateHydrated } from "./statewire-state.js";
 const AUTO_RETRY_FATES = /* @__PURE__ */ new Set(["lost", "aborted"]);
 const MAX_AUTO_RETRIES_PER_MESSAGE = 3;
 const MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1e3;
+const MAX_BEFORE_RETRY_HOLDS = 10;
 function shouldAutoRetryFailedSend(failure) {
   return failure !== void 0 && AUTO_RETRY_FATES.has(failure.fate);
 }
 function awaitsLostPredecessor(entry) {
   return entry.sendFailure.fate === "aborted" && entry.sendFailure.predecessorLost === true;
 }
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
 function commandMessageId(update) {
   var _a, _b;
   const first = (_a = update.params) == null ? void 0 : _a[0];
@@ -26,14 +30,16 @@ function createDeepAgentSendRecovery(options) {
   const surfacedDeferrals = /* @__PURE__ */ new Set();
   const inFlight = /* @__PURE__ */ new Set();
   const deferred = /* @__PURE__ */ new Set();
+  const holds = /* @__PURE__ */ new Map();
+  let holding = false;
   const record = (event, data) => {
     var _a, _b;
     (_b = (_a = options.diagnostics) == null ? void 0 : _a.call(options)) == null ? void 0 : _b.record(event, data);
   };
   const sweep = () => {
-    var _a;
+    var _a, _b;
     sweepScheduled = false;
-    if (disposed || !hydrated || !armed) return;
+    if (disposed || holding || !hydrated || !armed) return;
     const lane = options.lane();
     if (lane === null) return;
     armed = false;
@@ -73,6 +79,29 @@ function createDeepAgentSendRecovery(options) {
         if (isLost) lostPredecessorPending = true;
         continue;
       }
+      let before;
+      try {
+        before = (_b = options.beforeRetry) == null ? void 0 : _b.call(options, entry.id);
+      } catch {
+        record("send-recovery/before-retry-failed", { messageId: entry.id });
+      }
+      if (isThenable(before)) {
+        const held = (holds.get(entry.id) ?? 0) + 1;
+        if (held <= MAX_BEFORE_RETRY_HOLDS) {
+          holds.set(entry.id, held);
+          holding = true;
+          armed = true;
+          record("send-recovery/held", { messageId: entry.id, holds: held });
+          const resume = () => {
+            holding = false;
+            armed = true;
+            scheduleSweep();
+          };
+          before.then(resume, resume);
+          return;
+        }
+        record("send-recovery/held-too-long", { messageId: entry.id });
+      }
       try {
         lane.retryFailed(entry.id);
         attempts.set(entry.id, attempt);
@@ -85,12 +114,16 @@ function createDeepAgentSendRecovery(options) {
         });
       } catch {
         record("send-recovery/raced", { messageId: entry.id });
+        try {
+          if (typeof before === "function") before();
+        } catch {
+        }
       }
     }
     if (deferred.size > 0) armed = true;
   };
   const scheduleSweep = () => {
-    if (disposed || sweepScheduled || !hydrated || !armed) return;
+    if (disposed || sweepScheduled || holding || !hydrated || !armed) return;
     sweepScheduled = true;
     schedule(sweep);
   };
@@ -122,6 +155,7 @@ function createDeepAgentSendRecovery(options) {
   };
 }
 export {
+  MAX_BEFORE_RETRY_HOLDS,
   createDeepAgentSendRecovery,
   shouldAutoRetryFailedSend
 };

package/dist/agent-runtime/src/send-recovery.js.map

@@ -1 +1 @@
-{"version":3,"file":"send-recovery.js","sources":["../../../../agent-runtime/src/send-recovery.ts"],"sourcesContent":["import type {\n  StatewireDiagnosticsCommandUpdate,\n  StatewireDiagnosticsRecorder,\n} from './statewire-diagnostics';\nimport { isDeepAgentStateHydrated } from './statewire-state';\nimport type { StatewireFailedSendEntry, StatewireFailedSendLane } from './thread-extras';\n\n/**\n * Transport-level send durability for the deep-agent thread (the successor to\n * Olympus' localStorage outbox, #29368 → #31504).\n *\n * The durable journal itself is the statewire session record: every command is\n * persisted through the mounted session storage from `send()` until the server\n * durably admits or judges it, and a reload resends survivors on the SAME lane\n * seq (exactly-once — the server absorbs replayed seqs at or below its\n * watermark). What the record cannot recover on its own is a send the client\n * had to settle without a server verdict — a proven session loss or a record\n * reset settles it `lost`/`aborted` and RETAINS it in the record's failed lane\n * (message-carrying sends only), where the vendor drops it as soon as a\n * canonical snapshot shows the message landed (`failureCovered`).\n *\n * This controller turns that persisted failed lane back into live sends: once\n * the thread snapshot has hydrated (so covered entries are already gone), every\n * failed send the server NEVER judged is re-dispatched through the thread's own\n * `retryFailed` — same client-minted message id, re-anchored against the\n * current thread — which the host dedupes by id (a still-queued id re-places,\n * a durable one rejects `duplicate-id`). Server-judged fates (`rejected`,\n * `failed`, `crashed`, `expired`) are the user's decision and stay in the\n * manual retry/discard affordance.\n *\n * Ordering: an `aborted` send stamped `predecessorLost` was never attempted\n * because an earlier send of the same batch WAS attempted and settled `lost`\n * — it may or may not have run. Re-dispatching the successor first could land\n * it ahead of a predecessor that later turns out to have landed too, so the\n * successor is held until every preceding `lost` predecessor has settled: it\n * was covered by a snapshot, its retry was judged by the server, or the user\n * discarded it.\n */\n\n/** Fates the server never saw: the send died client-side (unmount, stream\n * gone, session lost) and is safe to re-dispatch under its original message\n * id. The complement — rejected/failed/crashed/expired — is server-judged. */\nconst AUTO_RETRY_FATES: ReadonlySet<string> = new Set(['lost', 'aborted']);\n\n/** A failed send is re-dispatched at most this many times per attach; a\n * persistent failure (repeated session losses) stays in the manual lane. */\nconst MAX_AUTO_RETRIES_PER_MESSAGE = 3;\n\n/** Persisted failures older than this stay manual: auto-sending a message the\n * user abandoned a day ago is worse than surfacing it for a decision. Mirrors\n * the retired outbox's retention window. */\nconst MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1000;\n\nexport interface DeepAgentSendRecoveryOptions {\n  /**\n   * Reads the thread's failed-send lane. `null` while it is unavailable (the\n   * client has not mounted yet, or its extras are not a statewire thread) —\n   * the controller stays armed and retries on the next state change.\n   */\n  lane: () => StatewireFailedSendLane | null;\n  /**\n   * Persisted failure stamps (message id → epoch ms of the original send) for\n   * the freshness gate. `null`/absent means no persistence is readable — every\n   * lane entry then counts as fresh (an in-memory failed lane can only hold\n   * failures from this page session).\n   */\n  failureStamps?: (() => ReadonlyMap<string, number> | null) | undefined;\n  /** Transport lifecycle recorder; read per event so a late-mounted recorder still sees retries. */\n  diagnostics?: (() => StatewireDiagnosticsRecorder | undefined) | undefined;\n  /** Injectable clock (tests). */\n  now?: () => number;\n  /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches\n   * from inside a statewire flush or a React render. */\n  schedule?: (task: () => void) => void;\n}\n\nexport interface DeepAgentSendRecovery {\n  /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */\n  observeStateChange(state: unknown): void;\n  /** Feed every command-lifecycle update; a never-server-judged settle arms a sweep. */\n  observeCommand(update: StatewireDiagnosticsCommandUpdate): void;\n  /** Feed client notifications too: failed history can publish after the\n   * command settles, without any change to the canonical thread snapshot. */\n  observeFailedLaneChange(): void;\n  dispose(): void;\n}\n\n/** Whether a settle failure is a client-side death the recovery re-dispatches\n * (the server never judged the command). Exported for host-side telemetry. */\nexport function shouldAutoRetryFailedSend(failure: { fate: string } | undefined): boolean {\n  return failure !== undefined && AUTO_RETRY_FATES.has(failure.fate);\n}\n\n/** Whether a failed entry must wait for a lost predecessor to settle first. */\nfunction awaitsLostPredecessor(entry: StatewireFailedSendEntry): boolean {\n  return entry.sendFailure.fate === 'aborted' && entry.sendFailure.predecessorLost === true;\n}\n\n/** The client-minted message id a run send carries, off a command update's params. */\nfunction commandMessageId(update: StatewireDiagnosticsCommandUpdate): string | null {\n  const first = update.params?.[0] as { message?: { id?: unknown } } | undefined;\n  const id = first?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\nexport function createDeepAgentSendRecovery(\n  options: DeepAgentSendRecoveryOptions\n): DeepAgentSendRecovery {\n  const now = options.now ?? Date.now;\n  const schedule = options.schedule ?? ((task: () => void) => queueMicrotask(task));\n\n  let disposed = false;\n  let hydrated = false;\n  /** Work may exist: set at hydration and on retryable settles, cleared by a\n   * sweep that could actually read the lane. */\n  let armed = false;\n  let sweepScheduled = false;\n  /** Retry budget per message id, for this controller's attach lifetime. */\n  const attempts = new Map<string, number>();\n  /** Message ids already diagnosed as stale/exhausted, so the lane re-scan\n   * stays quiet about them. */\n  const surfacedSkips = new Set<string>();\n  /** Message ids whose deferral behind a lost predecessor was diagnosed once. */\n  const surfacedDeferrals = new Set<string>();\n  /** Re-dispatched sends still awaiting the server's verdict: a successor\n   * stamped `predecessorLost` waits while any of these is pending. */\n  const inFlight = new Set<string>();\n  /** Successors held back by the last sweep; a non-empty set keeps the\n   * controller armed so the next settle or state change re-sweeps. */\n  const deferred = new Set<string>();\n\n  const record = (event: string, data?: Record<string, unknown>): void => {\n    options.diagnostics?.()?.record(event, data);\n  };\n\n  const sweep = (): void => {\n    sweepScheduled = false;\n    if (disposed || !hydrated || !armed) return;\n    const lane = options.lane();\n    // No readable lane yet: stay armed so the next state change re-sweeps.\n    if (lane === null) return;\n    armed = false;\n    deferred.clear();\n    const stamps = options.failureStamps?.() ?? null;\n    // A `lost` entry earlier in lane order that this sweep leaves unsettled\n    // (skipped as stale/exhausted, or re-dispatched and now in flight).\n    let lostPredecessorPending = false;\n    for (const entry of lane.failed) {\n      if (!shouldAutoRetryFailedSend(entry.sendFailure)) continue;\n      // Shared retry/discard may still be waiting for the storage lock. The\n      // visible lane can keep this entry until then; do not spend another\n      // attempt on a send whose previous retry is still awaiting a verdict.\n      if (inFlight.has(entry.id)) {\n        if (entry.sendFailure.fate === 'lost') lostPredecessorPending = true;\n        continue;\n      }\n      if (awaitsLostPredecessor(entry) && (lostPredecessorPending || inFlight.size > 0)) {\n        deferred.add(entry.id);\n        if (!surfacedDeferrals.has(entry.id)) {\n          surfacedDeferrals.add(entry.id);\n          record('send-recovery/deferred', { messageId: entry.id });\n        }\n        continue;\n      }\n      const isLost = entry.sendFailure.fate === 'lost';\n      const stamp = stamps?.get(entry.id);\n      if (stamp !== undefined && now() - stamp > MAX_AUTO_RETRY_AGE_MS) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/stale', { messageId: entry.id, ageMs: Math.round(now() - stamp) });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      const attempt = (attempts.get(entry.id) ?? 0) + 1;\n      if (attempt > MAX_AUTO_RETRIES_PER_MESSAGE) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/exhausted', { messageId: entry.id });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      try {\n        lane.retryFailed(entry.id);\n        attempts.set(entry.id, attempt);\n        inFlight.add(entry.id);\n        if (isLost) lostPredecessorPending = true;\n        record('send-recovery/retry', {\n          messageId: entry.id,\n          fate: entry.sendFailure.fate,\n          attempt,\n        });\n      } catch {\n        // The entry settled or was covered between the lane read and the\n        // retry (the vendor drops covered failures against every snapshot);\n        // nothing was dispatched.\n        record('send-recovery/raced', { messageId: entry.id });\n      }\n    }\n    // Held successors must be revisited once their predecessors settle.\n    if (deferred.size > 0) armed = true;\n  };\n\n  const scheduleSweep = (): void => {\n    if (disposed || sweepScheduled || !hydrated || !armed) return;\n    sweepScheduled = true;\n    schedule(sweep);\n  };\n\n  return {\n    observeStateChange(state) {\n      if (disposed) return;\n      if (!hydrated && isDeepAgentStateHydrated(state)) {\n        // First real snapshot: the vendor's failureCovered pass has had its\n        // chance to drop entries whose message actually landed, so whatever\n        // remains provably never reached the thread.\n        hydrated = true;\n        armed = true;\n      }\n      scheduleSweep();\n    },\n    observeCommand(update) {\n      if (disposed || update.status !== 'settled') return;\n      const messageId = commandMessageId(update);\n      if (messageId !== null) inFlight.delete(messageId);\n      // A never-server-judged settle means new work; any settle while\n      // successors are held may be the predecessor they wait on.\n      if (!shouldAutoRetryFailedSend(update.failure) && deferred.size === 0) return;\n      armed = true;\n      scheduleSweep();\n    },\n    observeFailedLaneChange() {\n      if (disposed) return;\n      armed = true;\n      scheduleSweep();\n    },\n    dispose() {\n      disposed = true;\n    },\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"send-recovery.js","sources":["../../../../agent-runtime/src/send-recovery.ts"],"sourcesContent":["import type {\n  StatewireDiagnosticsCommandUpdate,\n  StatewireDiagnosticsRecorder,\n} from './statewire-diagnostics';\nimport { isDeepAgentStateHydrated } from './statewire-state';\nimport type { StatewireFailedSendEntry, StatewireFailedSendLane } from './thread-extras';\n\n/**\n * Transport-level send durability for the deep-agent thread (the successor to\n * Olympus' localStorage outbox, #29368 → #31504).\n *\n * The durable journal itself is the statewire session record: every command is\n * persisted through the mounted session storage from `send()` until the server\n * durably admits or judges it, and a reload resends survivors on the SAME lane\n * seq (exactly-once — the server absorbs replayed seqs at or below its\n * watermark). What the record cannot recover on its own is a send the client\n * had to settle without a server verdict — a proven session loss or a record\n * reset settles it `lost`/`aborted` and RETAINS it in the record's failed lane\n * (message-carrying sends only), where the vendor drops it as soon as a\n * canonical snapshot shows the message landed (`failureCovered`).\n *\n * This controller turns that persisted failed lane back into live sends: once\n * the thread snapshot has hydrated (so covered entries are already gone), every\n * failed send the server NEVER judged is re-dispatched through the thread's own\n * `retryFailed` — same client-minted message id, re-anchored against the\n * current thread — which the host dedupes by id (a still-queued id re-places,\n * a durable one rejects `duplicate-id`). Server-judged fates (`rejected`,\n * `failed`, `crashed`, `expired`) are the user's decision and stay in the\n * manual retry/discard affordance.\n *\n * Ordering: an `aborted` send stamped `predecessorLost` was never attempted\n * because an earlier send of the same batch WAS attempted and settled `lost`\n * — it may or may not have run. Re-dispatching the successor first could land\n * it ahead of a predecessor that later turns out to have landed too, so the\n * successor is held until every preceding `lost` predecessor has settled: it\n * was covered by a snapshot, its retry was judged by the server, or the user\n * discarded it.\n */\n\n/** Fates the server never saw: the send died client-side (unmount, stream\n * gone, session lost) and is safe to re-dispatch under its original message\n * id. The complement — rejected/failed/crashed/expired — is server-judged. */\nconst AUTO_RETRY_FATES: ReadonlySet<string> = new Set(['lost', 'aborted']);\n\n/** A failed send is re-dispatched at most this many times per attach; a\n * persistent failure (repeated session losses) stays in the manual lane. */\nconst MAX_AUTO_RETRIES_PER_MESSAGE = 3;\n\n/** Persisted failures older than this stay manual: auto-sending a message the\n * user abandoned a day ago is worse than surfacing it for a decision. Mirrors\n * the retired outbox's retention window. */\nconst MAX_AUTO_RETRY_AGE_MS = 24 * 60 * 60 * 1000;\n\n/** How many times a host may hold one message's retry (`beforeRetry`\n * returning a promise) before the sweep sends it regardless: a hold is the\n * host's own bounded wait, never a reason to keep a message back for good. */\nexport const MAX_BEFORE_RETRY_HOLDS = 10;\n\nexport interface DeepAgentSendRecoveryOptions {\n  /**\n   * Reads the thread's failed-send lane. `null` while it is unavailable (the\n   * client has not mounted yet, or its extras are not a statewire thread) —\n   * the controller stays armed and retries on the next state change.\n   */\n  lane: () => StatewireFailedSendLane | null;\n  /**\n   * Persisted failure stamps (message id → epoch ms of the original send) for\n   * the freshness gate. `null`/absent means no persistence is readable — every\n   * lane entry then counts as fresh (an in-memory failed lane can only hold\n   * failures from this page session).\n   */\n  failureStamps?: (() => ReadonlyMap<string, number> | null) | undefined;\n  /** Transport lifecycle recorder; read per event so a late-mounted recorder still sees retries. */\n  diagnostics?: (() => StatewireDiagnosticsRecorder | undefined) | undefined;\n  /** Injectable clock (tests). */\n  now?: () => number;\n  /** Sweep scheduler; defaults to `queueMicrotask` so a sweep never dispatches\n   * from inside a statewire flush or a React render. */\n  schedule?: (task: () => void) => void;\n  /**\n   * Called right before a failed send is dispatched again, with its message\n   * id, so a host can put back the per-send context that message was sent\n   * with (Olympus stages the agents it named) before its command leaves.\n   *\n   * Returning a promise holds the retry: the host can't put that context back\n   * yet (every send of the conversation rides one ambient context, and a send\n   * with another context is still on its way). The sweep then stops at this\n   * message, so nothing behind it overtakes it, and asks again once the\n   * promise settles; past {@link MAX_BEFORE_RETRY_HOLDS} holds it sends the\n   * message regardless. A hook that throws never holds a retry back. A\n   * function returned is called when the message does not go after all (the\n   * retry raced its leaving the lane), so the host lets go of what it put back.\n   */\n  beforeRetry?: ((messageId: string) => void | PromiseLike<void> | (() => void)) | undefined;\n}\n\nexport interface DeepAgentSendRecovery {\n  /** Feed every (normalized) statewire state change; hydration arms the mount sweep. */\n  observeStateChange(state: unknown): void;\n  /** Feed every command-lifecycle update; a never-server-judged settle arms a sweep. */\n  observeCommand(update: StatewireDiagnosticsCommandUpdate): void;\n  /** Feed client notifications too: failed history can publish after the\n   * command settles, without any change to the canonical thread snapshot. */\n  observeFailedLaneChange(): void;\n  dispose(): void;\n}\n\n/** Whether a settle failure is a client-side death the recovery re-dispatches\n * (the server never judged the command). Exported for host-side telemetry. */\nexport function shouldAutoRetryFailedSend(failure: { fate: string } | undefined): boolean {\n  return failure !== undefined && AUTO_RETRY_FATES.has(failure.fate);\n}\n\n/** Whether a failed entry must wait for a lost predecessor to settle first. */\nfunction awaitsLostPredecessor(entry: StatewireFailedSendEntry): boolean {\n  return entry.sendFailure.fate === 'aborted' && entry.sendFailure.predecessorLost === true;\n}\n\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { then?: unknown }).then === 'function'\n  );\n}\n\n/** The client-minted message id a run send carries, off a command update's params. */\nfunction commandMessageId(update: StatewireDiagnosticsCommandUpdate): string | null {\n  const first = update.params?.[0] as { message?: { id?: unknown } } | undefined;\n  const id = first?.message?.id;\n  return typeof id === 'string' ? id : null;\n}\n\nexport function createDeepAgentSendRecovery(\n  options: DeepAgentSendRecoveryOptions\n): DeepAgentSendRecovery {\n  const now = options.now ?? Date.now;\n  const schedule = options.schedule ?? ((task: () => void) => queueMicrotask(task));\n\n  let disposed = false;\n  let hydrated = false;\n  /** Work may exist: set at hydration and on retryable settles, cleared by a\n   * sweep that could actually read the lane. */\n  let armed = false;\n  let sweepScheduled = false;\n  /** Retry budget per message id, for this controller's attach lifetime. */\n  const attempts = new Map<string, number>();\n  /** Message ids already diagnosed as stale/exhausted, so the lane re-scan\n   * stays quiet about them. */\n  const surfacedSkips = new Set<string>();\n  /** Message ids whose deferral behind a lost predecessor was diagnosed once. */\n  const surfacedDeferrals = new Set<string>();\n  /** Re-dispatched sends still awaiting the server's verdict: a successor\n   * stamped `predecessorLost` waits while any of these is pending. */\n  const inFlight = new Set<string>();\n  /** Successors held back by the last sweep; a non-empty set keeps the\n   * controller armed so the next settle or state change re-sweeps. */\n  const deferred = new Set<string>();\n  /** How many times the host held each message's retry (`beforeRetry`'s promise). */\n  const holds = new Map<string, number>();\n  /** A host's hold in progress: no sweep runs until it settles. */\n  let holding = false;\n\n  const record = (event: string, data?: Record<string, unknown>): void => {\n    options.diagnostics?.()?.record(event, data);\n  };\n\n  const sweep = (): void => {\n    sweepScheduled = false;\n    // A host's hold re-sweeps once it settles; until then nothing is retried.\n    if (disposed || holding || !hydrated || !armed) return;\n    const lane = options.lane();\n    // No readable lane yet: stay armed so the next state change re-sweeps.\n    if (lane === null) return;\n    armed = false;\n    deferred.clear();\n    const stamps = options.failureStamps?.() ?? null;\n    // A `lost` entry earlier in lane order that this sweep leaves unsettled\n    // (skipped as stale/exhausted, or re-dispatched and now in flight).\n    let lostPredecessorPending = false;\n    for (const entry of lane.failed) {\n      if (!shouldAutoRetryFailedSend(entry.sendFailure)) continue;\n      // Shared retry/discard may still be waiting for the storage lock. The\n      // visible lane can keep this entry until then; do not spend another\n      // attempt on a send whose previous retry is still awaiting a verdict.\n      if (inFlight.has(entry.id)) {\n        if (entry.sendFailure.fate === 'lost') lostPredecessorPending = true;\n        continue;\n      }\n      if (awaitsLostPredecessor(entry) && (lostPredecessorPending || inFlight.size > 0)) {\n        deferred.add(entry.id);\n        if (!surfacedDeferrals.has(entry.id)) {\n          surfacedDeferrals.add(entry.id);\n          record('send-recovery/deferred', { messageId: entry.id });\n        }\n        continue;\n      }\n      const isLost = entry.sendFailure.fate === 'lost';\n      const stamp = stamps?.get(entry.id);\n      if (stamp !== undefined && now() - stamp > MAX_AUTO_RETRY_AGE_MS) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/stale', { messageId: entry.id, ageMs: Math.round(now() - stamp) });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      const attempt = (attempts.get(entry.id) ?? 0) + 1;\n      if (attempt > MAX_AUTO_RETRIES_PER_MESSAGE) {\n        if (!surfacedSkips.has(entry.id)) {\n          surfacedSkips.add(entry.id);\n          record('send-recovery/exhausted', { messageId: entry.id });\n        }\n        if (isLost) lostPredecessorPending = true;\n        continue;\n      }\n      let before: ReturnType<NonNullable<DeepAgentSendRecoveryOptions['beforeRetry']>> | undefined;\n      try {\n        before = options.beforeRetry?.(entry.id);\n      } catch {\n        // A host's own context step failing never holds the retry back.\n        record('send-recovery/before-retry-failed', { messageId: entry.id });\n      }\n      if (isThenable(before)) {\n        const held = (holds.get(entry.id) ?? 0) + 1;\n        if (held <= MAX_BEFORE_RETRY_HOLDS) {\n          // The host can't put this message's context back yet: it waits, and\n          // so does everything behind it (nothing overtakes it); the sweep asks\n          // again once the hold settles.\n          holds.set(entry.id, held);\n          holding = true;\n          armed = true;\n          record('send-recovery/held', { messageId: entry.id, holds: held });\n          const resume = (): void => {\n            holding = false;\n            armed = true;\n            scheduleSweep();\n          };\n          before.then(resume, resume);\n          return;\n        }\n        record('send-recovery/held-too-long', { messageId: entry.id });\n      }\n      try {\n        lane.retryFailed(entry.id);\n        attempts.set(entry.id, attempt);\n        inFlight.add(entry.id);\n        if (isLost) lostPredecessorPending = true;\n        record('send-recovery/retry', {\n          messageId: entry.id,\n          fate: entry.sendFailure.fate,\n          attempt,\n        });\n      } catch {\n        // The entry settled or was covered between the lane read and the\n        // retry (the vendor drops covered failures against every snapshot);\n        // nothing was dispatched, so the host lets go of what it put back.\n        record('send-recovery/raced', { messageId: entry.id });\n        try {\n          if (typeof before === 'function') before();\n        } catch {\n          // The host's own step failing never stops the sweep.\n        }\n      }\n    }\n    // Held successors must be revisited once their predecessors settle.\n    if (deferred.size > 0) armed = true;\n  };\n\n  const scheduleSweep = (): void => {\n    if (disposed || sweepScheduled || holding || !hydrated || !armed) return;\n    sweepScheduled = true;\n    schedule(sweep);\n  };\n\n  return {\n    observeStateChange(state) {\n      if (disposed) return;\n      if (!hydrated && isDeepAgentStateHydrated(state)) {\n        // First real snapshot: the vendor's failureCovered pass has had its\n        // chance to drop entries whose message actually landed, so whatever\n        // remains provably never reached the thread.\n        hydrated = true;\n        armed = true;\n      }\n      scheduleSweep();\n    },\n    observeCommand(update) {\n      if (disposed || update.status !== 'settled') return;\n      const messageId = commandMessageId(update);\n      if (messageId !== null) inFlight.delete(messageId);\n      // A never-server-judged settle means new work; any settle while\n      // successors are held may be the predecessor they wait on.\n      if (!shouldAutoRetryFailedSend(update.failure) && deferred.size === 0) return;\n      armed = true;\n      scheduleSweep();\n    },\n    observeFailedLaneChange() {\n      if (disposed) return;\n      armed = true;\n      scheduleSweep();\n    },\n    dispose() {\n      disposed = true;\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/thread-handoff-flow-machine.d.ts

@@ -72,19 +72,19 @@ export declare const threadHandoffFlowMachine: import("xstate").StateMachine<Han
         } | {
             kind: "office_invitation";
             host: "excel" | "powerpoint" | "word";
+        } | {
+            kind: "chrome";
         } | {
             kind: "spaces";
             url: string;
+        } | {
+            kind: "next";
         } | {
             kind: "desktop";
             scheme_url: string;
             download_url: string;
             deployment_url: string;
             protocol_version: 1;
-        } | {
-            kind: "chrome";
-        } | {
-            kind: "next";
         };
     }, {
         run: ThreadHandoffRun;
@@ -132,19 +132,19 @@ export declare const threadHandoffFlowMachine: import("xstate").StateMachine<Han
         } | {
             kind: "office_invitation";
             host: "excel" | "powerpoint" | "word";
+        } | {
+            kind: "chrome";
         } | {
             kind: "spaces";
             url: string;
+        } | {
+            kind: "next";
         } | {
             kind: "desktop";
             scheme_url: string;
             download_url: string;
             deployment_url: string;
             protocol_version: 1;
-        } | {
-            kind: "chrome";
-        } | {
-            kind: "next";
         };
     }, {
         run: ThreadHandoffRun;

package/dist/agent-runtime/src/thread-handoff-protocol.d.ts

@@ -94,6 +94,54 @@ export declare const destinationReadinessSchema: z.ZodObject<{
     marketplace_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type DestinationReadiness = z.infer<typeof destinationReadinessSchema>;
+/**
+ * How recently one of the person's four apps was seen, from a real signal: the desktop app and
+ * Chrome by their device tunnel, the phone by its foreground ping (or its push token), Spaces by
+ * workspace awareness. `live` is open right now; `recent` within minutes; `seen` longer ago;
+ * `not_seen` no evidence; `unknown` no signal to judge by; `unsupported` not in this environment.
+ */
+export declare const surfaceLivenessStateSchema: z.ZodEnum<{
+    live: "live";
+    not_seen: "not_seen";
+    recent: "recent";
+    seen: "seen";
+    unknown: "unknown";
+    unsupported: "unsupported";
+}>;
+export type SurfaceLivenessState = z.infer<typeof surfaceLivenessStateSchema>;
+/** The signal a liveness row rests on. */
+export declare const surfaceLivenessBasisSchema: z.ZodEnum<{
+    awareness: "awareness";
+    device_tunnel: "device_tunnel";
+    foreground: "foreground";
+    push_token: "push_token";
+}>;
+export type SurfaceLivenessBasis = z.infer<typeof surfaceLivenessBasisSchema>;
+export declare const surfaceLivenessSchema: z.ZodObject<{
+    surface: z.ZodEnum<{
+        chrome: "chrome";
+        desktop: "desktop";
+        mobile: "mobile";
+        spaces: "spaces";
+    }>;
+    state: z.ZodEnum<{
+        live: "live";
+        not_seen: "not_seen";
+        recent: "recent";
+        seen: "seen";
+        unknown: "unknown";
+        unsupported: "unsupported";
+    }>;
+    basis: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        awareness: "awareness";
+        device_tunnel: "device_tunnel";
+        foreground: "foreground";
+        push_token: "push_token";
+    }>>>;
+    last_seen_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SurfaceLiveness = z.infer<typeof surfaceLivenessSchema>;
 export declare const handoffReadinessResponseSchema: z.ZodObject<{
     environment: z.ZodEnum<{
         localhost: "localhost";
@@ -122,11 +170,44 @@ export declare const handoffReadinessResponseSchema: z.ZodObject<{
     supports_office_invitations: z.ZodOptional<z.ZodBoolean>;
     supports_desktop_source: z.ZodOptional<z.ZodBoolean>;
     supports_surface_destinations: z.ZodOptional<z.ZodBoolean>;
+    supports_surface_liveness: z.ZodOptional<z.ZodBoolean>;
+    surfaces: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodUnknown>, z.ZodTransform<{
+        surface: "chrome" | "desktop" | "mobile" | "spaces";
+        state: "live" | "not_seen" | "recent" | "seen" | "unknown" | "unsupported";
+        basis?: "awareness" | "device_tunnel" | "foreground" | "push_token" | null | undefined;
+        last_seen_at?: string | null | undefined;
+        label?: string | null | undefined;
+    }[], unknown[]>>>>;
 }, z.core.$strip>;
 export type HandoffReadinessResponse = z.infer<typeof handoffReadinessResponseSchema>;
 export declare const supportsDesktopHandoffSource: (readiness: HandoffReadinessResponse | null | undefined) => boolean;
 /** Whether the server can broker the four-surface destinations; absent means an older agora. */
 export declare const supportsSurfaceHandoffDestinations: (readiness: HandoffReadinessResponse | null | undefined) => boolean;
+/** Whether the server reports where the person's apps were last seen; absent means an older agora. */
+export declare const supportsSurfaceLiveness: (readiness: HandoffReadinessResponse | null | undefined) => boolean;
+/** Index liveness rows by surface; `null` where the server sent none (or can't report liveness). */
+export declare const surfaceLivenessBySurface: (readiness: HandoffReadinessResponse | null | undefined) => Record<PickupSurface, SurfaceLiveness | null>;
+/** "just now", "4 min ago", "3 hr ago", "yesterday", "5 days ago". */
+export declare const livenessAgo: ({ at, now }: {
+    at: number;
+    now: number;
+}) => string;
+export type SurfaceLivenessTone = 'live' | 'recent' | 'idle';
+/** What a "Continue on…" row says about where that app was last seen, and how warm it is. */
+export interface SurfaceLivenessPresentation {
+    text: string;
+    tone: SurfaceLivenessTone;
+}
+/**
+ * The one wording every picker shows for a surface's liveness ("Open now on your Mac", "Chrome is
+ * running", "Your phone was active 2 min ago"). `null` when there is nothing real to say (no row,
+ * an older server, `unknown`, `unsupported`): the row then keeps the text it shows today.
+ */
+export declare const presentSurfaceLiveness: ({ surface, liveness, now, }: {
+    surface: PickupSurface;
+    liveness: SurfaceLiveness | null | undefined;
+    now?: number;
+}) => SurfaceLivenessPresentation | null;
 export declare const threadHandoffViewSchema: z.ZodObject<{
     handoff_id: z.ZodString;
     thread_id: z.ZodString;
@@ -368,11 +449,29 @@ export interface CreateThreadHandoffInput {
     officeLaunchMode?: OfficeLaunchMode;
     /** An observed workspace precondition, never an authorization grant. */
     expectedWorkspaceId?: string;
-    /** The composer's unsent text; the destination prefills it and never sends it. */
+    /**
+     * The composer's unsent text; the destination prefills it and never sends
+     * it. Blank (the composer is empty) clears an open ticket's draft; omitted
+     * leaves it. See {@link handoffDraftToCarry}.
+     */
     draft?: string;
     /** `voice` offers "Continue by voice" on the destination. Omitted means text. */
     mode?: HandoffMode;
 }
+/**
+ * The draft a create carries, the one rule every source follows. An Office
+ * pane never gets one: it neither prefills nor continues by voice. Anywhere
+ * else a surface that read its composer sends what it holds, within the
+ * server's bound, and a blank composer as `''`: agora reuses an open ticket
+ * for the same thread, destination and mode, and an empty draft clears the
+ * one that ticket stored, so text the person deleted never comes back at the
+ * destination. `undefined` or `null` (the surface could not read a composer)
+ * sends none and leaves an open ticket's draft as it was.
+ */
+export declare function handoffDraftToCarry({ destination, draft, }: {
+    destination: ThreadHandoffDestination;
+    draft: string | null | undefined;
+}): string | undefined;
 /** A phone invites the computer's pane; other sources keep their existing launch. */
 export declare function resolveOfficeHandoffLaunchMode({ source, destination, officeLaunchMode, }: CreateThreadHandoffInput): OfficeLaunchMode | undefined;
 /** The same request body for every host's authenticated HTTP adapter. */
@@ -599,6 +698,19 @@ export interface ThreadHandoffTransport {
 export declare const HANDOFF_DESTINATION_LABELS: Record<HandoffDestination, string>;
 /** Picker labels for every destination a "Continue on…" row can name. */
 export declare const THREAD_HANDOFF_DESTINATION_LABELS: Record<ThreadHandoffDestination, string>;
+/**
+ * How a landing names the surface a conversation came from ("Continued from …"), and every other
+ * "from …" an app says about another (a device's "Athena is using Mail, from your phone").
+ */
+export declare const HANDOFF_ORIGIN_LABELS: {
+    readonly spaces: 'Spaces';
+    readonly mobile: 'your phone';
+    readonly chrome: 'Chrome';
+    readonly desktop: 'Athena Desktop';
+    readonly word: 'Word';
+    readonly powerpoint: 'PowerPoint';
+    readonly excel: 'Excel';
+};
 /** "Pick up your conversation from your phone?" — a destination's offer, before any claim. */
 export declare const pickUpOfferLabel: (source: string) => string;
 /** "Continued from your phone" — the divider a destination shows where it picked up. */

package/dist/agent-runtime/src/thread-handoff.d.ts

@@ -1,3 +1,3 @@
 /** Backward-compatible entrypoint. Use the protocol entrypoint without QR rendering. */
-export { type CreateThreadHandoffInput, type CreateThreadHandoffResponse, type DestinationReadiness, HANDOFF_DESTINATIONS, HANDOFF_DESTINATION_LABELS, HANDOFF_URL_PARAM, type HandoffDestination, type HandoffDestinationPresentation, type HandoffEnvironment, HandoffGoneError, type HandoffLaunch, type HandoffOutcome, HandoffPermanentError, type HandoffReadinessResponse, type HandoffReadinessState, type HandoffSource, type HandoffState, type HandoffTransportErrorKind, MOBILE_APP_SCHEME, type MobileHandoffLaunch, type MobileLaunchMode, OFFICE_HANDOFF_DESTINATIONS, type OfficeHandoffDestination, type OfficeHandoffLaunch, type OfficeInvitationLaunch, type OfficeLaunchMode, SERVER_HANDOFF_DESTINATIONS, type ServerHandoffDestination, type ThreadHandoffTransport, type ThreadHandoffView, type WaitForHandoffOutcomeOptions, buildMobileHandoffSchemeUrl, chromeHandoffLaunchSchema, classifyHandoffTransportError, createThreadHandoffResponseSchema, describeHandoffTransportError, destinationReadinessSchema, handoffEnvironmentSchema, handoffHttpError, handoffLaunchSchema, handoffReadinessResponseSchema, handoffReadinessStateSchema, handoffStateSchema, isHandoffGoneError, isHandoffPermanentError, isOfficeHandoffDestination, isRetryableHandoffHttpStatus, isServerHandoffDestination, isTerminalHandoffState, mobileHandoffLaunchSchema, officeHandoffLaunchSchema, officeInvitationLaunchSchema, officeLaunchModeSchema, parseHandoffIdParam, presentHandoffDestination, readinessByDestination, resolveOfficeHandoffLaunchMode, selectMobileLaunchMode, supportsDesktopHandoffSource, threadHandoffCreateBody, threadHandoffViewSchema, waitForHandoffOutcome, type ClaimThreadHandoffResponse, claimThreadHandoffResponseSchema, clampHandoffDraft, continuedFromLabel, pickUpFromLabel, pickUpOfferLabel, type DesktopThreadHandoffLaunch, desktopThreadHandoffLaunchSchema, driverSurfaceForChannel, drivingOnLabel, type HandoffLanding, handoffLandingFromView, isPickupSurface, MAX_HANDOFF_DRAFT_LENGTH, nextHandoffLaunchSchema, parseThreadHandoffCreateResponse, pendingThreadHandoffResponseSchema, pickedUpOnLabel, PICKUP_SURFACES, type PickupSurface, shouldOfferPendingHandoff, SPACES_HANDOFF_URL_PARAM, type SpacesHandoffLaunch, spacesHandoffLaunchSchema, SURFACE_HANDOFF_DESTINATIONS, type SurfaceHandoffDestination, supportsSurfaceHandoffDestinations, THREAD_HANDOFF_DESTINATION_LABELS, THREAD_HANDOFF_DESTINATIONS, threadHandoffClaimBody, threadHandoffCreateRequest, type ThreadHandoffDestination, type ThreadHandoffReceiverTransport, MAX_PENDING_EXCLUDE, pendingExcludeIds, pickupExcludeIds, pendingHandoffPath, type HandoffMode, handoffModeSchema, isVoiceHandoffDestination, } from './thread-handoff-protocol';
+export { type CreateThreadHandoffInput, type CreateThreadHandoffResponse, type DestinationReadiness, HANDOFF_DESTINATIONS, HANDOFF_DESTINATION_LABELS, HANDOFF_URL_PARAM, type HandoffDestination, type HandoffDestinationPresentation, type HandoffEnvironment, HandoffGoneError, type HandoffLaunch, type HandoffOutcome, HandoffPermanentError, type HandoffReadinessResponse, type HandoffReadinessState, type HandoffSource, type HandoffState, type HandoffTransportErrorKind, MOBILE_APP_SCHEME, type MobileHandoffLaunch, type MobileLaunchMode, OFFICE_HANDOFF_DESTINATIONS, type OfficeHandoffDestination, type OfficeHandoffLaunch, type OfficeInvitationLaunch, type OfficeLaunchMode, SERVER_HANDOFF_DESTINATIONS, type ServerHandoffDestination, type ThreadHandoffTransport, type ThreadHandoffView, type WaitForHandoffOutcomeOptions, buildMobileHandoffSchemeUrl, chromeHandoffLaunchSchema, classifyHandoffTransportError, createThreadHandoffResponseSchema, describeHandoffTransportError, destinationReadinessSchema, handoffEnvironmentSchema, handoffHttpError, handoffLaunchSchema, handoffReadinessResponseSchema, handoffReadinessStateSchema, handoffStateSchema, isHandoffGoneError, isHandoffPermanentError, isOfficeHandoffDestination, isRetryableHandoffHttpStatus, isServerHandoffDestination, isTerminalHandoffState, mobileHandoffLaunchSchema, officeHandoffLaunchSchema, officeInvitationLaunchSchema, officeLaunchModeSchema, parseHandoffIdParam, presentHandoffDestination, readinessByDestination, resolveOfficeHandoffLaunchMode, selectMobileLaunchMode, supportsDesktopHandoffSource, threadHandoffCreateBody, threadHandoffViewSchema, waitForHandoffOutcome, type ClaimThreadHandoffResponse, claimThreadHandoffResponseSchema, clampHandoffDraft, handoffDraftToCarry, continuedFromLabel, pickUpFromLabel, pickUpOfferLabel, type DesktopThreadHandoffLaunch, desktopThreadHandoffLaunchSchema, driverSurfaceForChannel, drivingOnLabel, type HandoffLanding, handoffLandingFromView, isPickupSurface, MAX_HANDOFF_DRAFT_LENGTH, nextHandoffLaunchSchema, parseThreadHandoffCreateResponse, pendingThreadHandoffResponseSchema, pickedUpOnLabel, PICKUP_SURFACES, type PickupSurface, shouldOfferPendingHandoff, SPACES_HANDOFF_URL_PARAM, type SpacesHandoffLaunch, spacesHandoffLaunchSchema, SURFACE_HANDOFF_DESTINATIONS, type SurfaceHandoffDestination, supportsSurfaceHandoffDestinations, THREAD_HANDOFF_DESTINATION_LABELS, THREAD_HANDOFF_DESTINATIONS, threadHandoffClaimBody, threadHandoffCreateRequest, type ThreadHandoffDestination, type ThreadHandoffReceiverTransport, MAX_PENDING_EXCLUDE, pendingExcludeIds, pickupExcludeIds, pendingHandoffPath, type HandoffMode, handoffModeSchema, isVoiceHandoffDestination, livenessAgo, presentSurfaceLiveness, type SurfaceLiveness, type SurfaceLivenessBasis, surfaceLivenessBasisSchema, surfaceLivenessBySurface, type SurfaceLivenessPresentation, surfaceLivenessSchema, type SurfaceLivenessState, surfaceLivenessStateSchema, type SurfaceLivenessTone, supportsSurfaceLiveness, } from './thread-handoff-protocol';
 export { buildHandoffQrSvg } from './thread-handoff-qr';

package/dist/agent-runtime/src/use-conversation-list.cjs

@@ -7,7 +7,7 @@ const DEFAULT_PAGE_SIZE = 20;
 const DEFAULT_STALE_TIME_MS = 3e4;
 const DEFAULT_GC_TIME_MS = 10 * 60 * 1e3;
 function useConversationList(options) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const {
     filter,
     pageSize = DEFAULT_PAGE_SIZE,
@@ -133,10 +133,11 @@ function useConversationList(options) {
   return {
     conversations,
     totalCount: ((_b = firstPage.data) == null ? void 0 : _b.totalCount) ?? null,
+    homeAgentApplied: ((_c = firstPage.data) == null ? void 0 : _c.homeAgentApplied) === true,
     isLoading: firstPage.isLoading,
     isFetching: firstPage.isFetching || history.isFetching,
     hasResolvedFirstPage: firstPage.data !== void 0,
-    hasNextPage: hasLoadedHistory ? history.hasNextPage ?? false : ((_c = firstPage.data) == null ? void 0 : _c.hasMore) ?? false,
+    hasNextPage: hasLoadedHistory ? history.hasNextPage ?? false : ((_d = firstPage.data) == null ? void 0 : _d.hasMore) ?? false,
     isFetchingNextPage: history.isFetchingNextPage || !hasLoadedHistory && history.isFetching,
     isFetchNextPageError: history.isError,
     fetchNextPage,