@athenaintel/react 0.41.2 → 0.42.1

package/dist/index.cjs

@@ -38,10 +38,13 @@ const statewireLifecycle = require("./runtime/statewire-lifecycle.cjs");
 const statewireThreadList = require("./threads/statewire-thread-list.cjs");
 const WaitingOnYouBanner = require("./chat/WaitingOnYouBanner.cjs");
 const wakeMarker = require("./chat-ui/messages/wake-marker.cjs");
+const offlineHistory = require("./offline/offline-history.cjs");
+const chatOutbox = require("./offline/chat-outbox.cjs");
 const tiptapText = require("./chat/tiptap-text.cjs");
 const athenaCitationLinks = require("./chat/athena-citation-links.cjs");
 const tooltipIconButton = require("./chat/tooltip-icon-button.cjs");
 const toolUis = require("./tools/tool-uis.cjs");
+const subagentTaskToolUi = require("./tools/subagent-task-tool-ui.cjs");
 const primitives = require("./tools/primitives.cjs");
 const miscToolUis = require("./tools/misc-tool-uis.cjs");
 const toolIcons = require("./tools/tool-icons.cjs");
@@ -133,6 +136,8 @@ const toolMetadata = require("./agent-runtime/src/tool-metadata.cjs");
 const githubWakeEvent = require("./agent-runtime/src/github-wake-event.cjs");
 const threadExtras = require("./agent-runtime/src/thread-extras.cjs");
 const toolAppearance = require("./tools/tool-appearance.cjs");
+const subagents = require("./agent-runtime/src/subagents.cjs");
+const chatOutboxSignals = require("./agent-runtime/src/chat-outbox-signals.cjs");
 exports.ATHENA_REACT_SDK_VERSION = version.ATHENA_REACT_SDK_VERSION;
 exports.athenaDiagnostics = athenaDiagnostics.athenaDiagnostics;
 exports.installAthenaDiagnosticsGlobal = athenaDiagnostics.installAthenaDiagnosticsGlobal;
@@ -196,6 +201,7 @@ exports.workedDurationMs = turnTiming.workedDurationMs;
 exports.defaultGetToolGroupKey = toolkitMap.defaultGetToolGroupKey;
 exports.StatewireApprovalCard = StatewireApprovalCard.StatewireApprovalCard;
 exports.useStatewireApprovalRequest = useStatewireApprovalRequest.useStatewireApprovalRequest;
+exports.useStatewireApprovalWait = useStatewireApprovalRequest.useStatewireApprovalWait;
 exports.useAthenaRunLive = useAthenaRunLive.useAthenaRunLive;
 exports.StatewireHistoryEdge = statewireHistoryEdge.StatewireHistoryEdge;
 exports.ThreadLoadingOverlay = threadLoadingOverlay.ThreadLoadingOverlay;
@@ -219,6 +225,15 @@ exports.WaitingOnYouBanner = WaitingOnYouBanner.WaitingOnYouBanner;
 exports.WaitingOnYouBannerView = WaitingOnYouBanner.WaitingOnYouBannerView;
 exports.WakeMarkerCard = wakeMarker.WakeMarkerCard;
 exports.WakeMarkerMessage = wakeMarker.WakeMarkerMessage;
+exports.OFFLINE_SNAPSHOT_READ_WAIT_MS = offlineHistory.OFFLINE_SNAPSHOT_READ_WAIT_MS;
+exports.OfflineSnapshotBanner = offlineHistory.OfflineSnapshotBanner;
+exports.formatOfflineSnapshotTime = offlineHistory.formatOfflineSnapshotTime;
+exports.useAthenaOfflineSnapshotAt = offlineHistory.useAthenaOfflineSnapshotAt;
+exports.clearChatOutbox = chatOutbox.clearChatOutbox;
+exports.clearUnopenableChatOutbox = chatOutbox.clearUnopenableChatOutbox;
+exports.countChatOutboxMessages = chatOutbox.countChatOutboxMessages;
+exports.listChatOutboxMessages = chatOutbox.listChatOutboxMessages;
+exports.subscribeChatOutbox = chatOutbox.subscribeChatOutbox;
 exports.TiptapText = tiptapText.TiptapText;
 exports.isAthenaCitationUrl = athenaCitationLinks.isAthenaCitationUrl;
 exports.parseAthenaCitationLink = athenaCitationLinks.parseAthenaCitationLink;
@@ -244,6 +259,7 @@ exports.UpdateSheetRangeToolUI = toolUis.UpdateSheetRangeToolUI;
 exports.WebSearchToolUI = toolUis.WebSearchToolUI;
 exports.createAssetToolUI = toolUis.createAssetToolUI;
 exports.resetAssetAutoOpen = toolUis.resetAssetAutoOpen;
+exports.SubagentTaskToolUI = subagentTaskToolUi.SubagentTaskToolUI;
 exports.CopyToolSpecButton = primitives.CopyToolSpecButton;
 exports.ExpandableSection = primitives.ExpandableSection;
 exports.ToolCard = primitives.ToolCard;
@@ -534,4 +550,6 @@ exports.isGithubWakeMessage = githubWakeEvent.isGithubWakeMessage;
 exports.readGithubWakeEvent = githubWakeEvent.readGithubWakeEvent;
 exports.hasStatewireThreadExtras = threadExtras.hasStatewireThreadExtras;
 exports.useToolAppearance = toolAppearance.useToolAppearance;
+exports.useTurnToolCallsAwaitingApproval = subagents.useTurnToolCallsAwaitingApproval;
+exports.windowInFrontSignal = chatOutboxSignals.windowInFrontSignal;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -25,6 +25,9 @@ export { StatewireApprovalCard } from './chat/StatewireApprovalCard';
 export type { StatewireApprovalCardProps, StatewireApprovalEditorContext, StatewireApprovalRequestContext, } from './chat/StatewireApprovalCard';
 export { useStatewireApprovalRequest } from './chat/use-statewire-approval-request';
 export type { StatewireApprovalRequest, StatewireInterruptPredicate, UseStatewireApprovalRequestOptions, } from './chat/use-statewire-approval-request';
+export { useStatewireApprovalWait } from './chat/use-statewire-approval-request';
+export type { StatewireApprovalWait } from './chat/use-statewire-approval-request';
+export { useTurnToolCallsAwaitingApproval } from './agent-runtime/src/index';
 export { useAthenaRunLive } from './chat/use-athena-run-live';
 export { StatewireHistoryEdge } from './chat-ui/thread/statewire-history-edge';
 export type { StatewireHistoryEdgeProps } from './chat-ui/thread/statewire-history-edge';
@@ -37,8 +40,8 @@ export { StatewireConnectionBanner, StatewireErrorBanner, } from './chat/statewi
 export type { StatewireErrorBannerProps } from './chat/statewire-banners';
 export { RUN_START_REFUSAL_FALLBACK_MESSAGE, StatewireRunRefusalNotice, } from './chat/StatewireRunRefusalNotice';
 export type { StatewireRunRefusalNoticeProps } from './chat/StatewireRunRefusalNotice';
-export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, readRunStartRefusal, } from '@athenaintel/agent-runtime';
-export type { RunStartRefusal } from '@athenaintel/agent-runtime';
+export { COLLAB_AGENT_CHANNEL_SESSION_MISMATCH, readRunStartRefusal, } from './agent-runtime/src/index';
+export type { RunStartRefusal } from './agent-runtime/src/index';
 export { StatewireClientToolBridge } from './chat/StatewireClientToolBridge';
 export { collectStatewireClientTools, statewireClientToolWireEntries, } from './chat/statewire-client-tools';
 export type { StatewireClientTool } from './chat/statewire-client-tools';
@@ -51,6 +54,11 @@ export { WaitingOnYouBanner, WaitingOnYouBannerView } from './chat/WaitingOnYouB
 export type { WaitingOnYouBannerProps, WaitingOnYouBannerViewProps, } from './chat/WaitingOnYouBanner';
 export { WakeMarkerCard, WakeMarkerMessage } from './chat-ui/messages/wake-marker';
 export type { WakeMarkerCardProps } from './chat-ui/messages/wake-marker';
+export { formatOfflineSnapshotTime, OFFLINE_SNAPSHOT_READ_WAIT_MS, OfflineSnapshotBanner, useAthenaOfflineSnapshotAt, } from './offline/offline-history';
+export type { AthenaOfflineHistory, OfflineSnapshotBannerProps, } from './offline/offline-history';
+export { type AthenaChatOutbox, clearChatOutbox, clearUnopenableChatOutbox, type ChatOutboxMessageSummary, countChatOutboxMessages, listChatOutboxMessages, subscribeChatOutbox, } from './offline/chat-outbox';
+/** For an `AthenaChatOutbox` host: the key purposes, and the desktop's "window in front" signal. */
+export { type ChatOutboxKeyPurpose, windowInFrontSignal } from './agent-runtime/src/index';
 export { asHitlApproval, hasStatewireThreadExtras, HITL_PENDING_RESUME_GRACE_MS, isPendingInterrupt, readInterruptMessage, } from './chat/statewire-approval';
 export type { HitlApprovalPayload } from './chat/statewire-approval';
 export { TiptapText } from './chat/tiptap-text';
@@ -60,12 +68,13 @@ export { TooltipIconButton } from './chat/tooltip-icon-button';
 export type { TooltipIconButtonProps } from './chat/tooltip-icon-button';
 export { TOOL_UI_REGISTRY } from './tools/tool-uis';
 export { WebSearchToolUI, BrowseToolUI, OpenBrowserToolUI, EmailSearchToolUI, CreateDocumentToolUI, CreateSheetToolUI, CreatePresentationToolUI, CreateNotebookToolUI, RunPythonCodeToolUI, OpenAssetToolUI, CreateEmailDraftToolUI, UpdateSheetRangeToolUI, DescribeDatabaseToolUI, ListDatabaseTablesToolUI, GetDatabaseTableSchemaToolUI, RunSqlToolUI, createAssetToolUI, resetAssetAutoOpen, } from './tools/tool-uis';
+export { SubagentTaskToolUI } from './tools/subagent-task-tool-ui';
 export { CopyToolSpecButton, ExpandableSection, formatToolName, normalizeResult, ToolCard, truncate, } from './tools/primitives';
 export type { ToolStatus } from './tools/primitives';
 export { InstallPackageToolUI } from './tools/misc-tool-uis';
 export { TOOL_ICONS, toolIcon } from './tools/tool-icons';
-export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultSuccess, resultMessage, toolActiveLabel, toolCompletedLabel, } from '@athenaintel/agent-runtime';
-export type { ToolDisplayMeta, ToolIconKey, ToolResultClassification, } from '@athenaintel/agent-runtime';
+export { classifyToolResult, describeToolArgs, getToolDisplayMeta, isToolResultSuccess, resultMessage, toolActiveLabel, toolCompletedLabel, } from './agent-runtime/src/index';
+export type { ToolDisplayMeta, ToolIconKey, ToolResultClassification, } from './agent-runtime/src/index';
 export { HiddenWriteTodosToolUI, PlanStepMarker, WriteTodosToolUI, parseTodoPlan, } from './tools/write-todos-tool-ui';
 export { useLatestTodoPlan } from './tools/todo-plan-store';
 export type { LatestTodoPlan } from './tools/todo-plan-store';
@@ -143,8 +152,8 @@ export type { SessionStatusChip, SessionStatusTone, SessionsColumn, SessionsColu
 export type { ThreadReadStateTarget } from './threads/use-thread-read-state';
 export { groupSessions, orderedPullRequests, pullRequestChip, pullRequestChipState, sessionIndicator, sessionListGroupOf, sessionOriginBadge, sessionOriginLabel, sessionSecondaryLine, WEB_APP_ORIGIN_LABEL, } from './threads/session-list-model';
 export type { PullRequestChip, PullRequestChipState, SessionIndicator, SessionLineTone, SessionListGroup, SessionListSection, SessionOriginBadges, SessionSecondaryLine, } from './threads/session-list-model';
-export { deriveConversationAttention, githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent, } from '@athenaintel/agent-runtime';
-export type { ConversationAttention, ConversationAttentionSource, ConversationPullRequest, ConversationSummary, ConversationWake, GithubWakeEvent, } from '@athenaintel/agent-runtime';
+export { deriveConversationAttention, githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent, } from './agent-runtime/src/index';
+export type { ConversationAttention, ConversationAttentionSource, ConversationPullRequest, ConversationSummary, ConversationWake, GithubWakeEvent, } from './agent-runtime/src/index';
 export type { ThreadFavoriteResponse, ThreadInboxDismissResponse, ThreadListFilterBody, ThreadListResponse, ThreadPullRequest, ThreadRenameResponse, ThreadSummary, ThreadWake, } from './threads/api';
 export { useRefreshThreadList } from './threads/statewire-thread-list';
 export { useAthenaThreadId, AthenaThreadIdContext, useAthenaStatewireThreadId, } from './threads/thread-id-context';

package/dist/index.js

@@ -20,7 +20,7 @@ import { splitTurnSegments } from "./chat/super-grouping/turn-segments.js";
 import { formatWorkDuration, readTurnTiming, workedDurationMs } from "./chat/super-grouping/turn-timing.js";
 import { defaultGetToolGroupKey } from "./chat/super-grouping/toolkit-map.js";
 import { StatewireApprovalCard } from "./chat/StatewireApprovalCard.js";
-import { useStatewireApprovalRequest } from "./chat/use-statewire-approval-request.js";
+import { useStatewireApprovalRequest, useStatewireApprovalWait } from "./chat/use-statewire-approval-request.js";
 import { useAthenaRunLive } from "./chat/use-athena-run-live.js";
 import { StatewireHistoryEdge } from "./chat-ui/thread/statewire-history-edge.js";
 import { ThreadLoadingOverlay } from "./chat-ui/thread/thread-loading-overlay.js";
@@ -36,10 +36,13 @@ import { athenaStatewireErrorNotice } from "./runtime/statewire-lifecycle.js";
 import { threadSummaryFromConversation, useAthenaStatewireThreadList, useRefreshThreadList } from "./threads/statewire-thread-list.js";
 import { WaitingOnYouBanner, WaitingOnYouBannerView } from "./chat/WaitingOnYouBanner.js";
 import { WakeMarkerCard, WakeMarkerMessage } from "./chat-ui/messages/wake-marker.js";
+import { OFFLINE_SNAPSHOT_READ_WAIT_MS, OfflineSnapshotBanner, formatOfflineSnapshotTime, useAthenaOfflineSnapshotAt } from "./offline/offline-history.js";
+import { clearChatOutbox, clearUnopenableChatOutbox, countChatOutboxMessages, listChatOutboxMessages, subscribeChatOutbox } from "./offline/chat-outbox.js";
 import { TiptapText } from "./chat/tiptap-text.js";
 import { isAthenaCitationUrl, parseAthenaCitationLink, useAthenaCitationLinkHandler, useAthenaLinkClickHandler } from "./chat/athena-citation-links.js";
 import { TooltipIconButton } from "./chat/tooltip-icon-button.js";
 import { BrowseToolUI, CreateDocumentToolUI, CreateEmailDraftToolUI, CreateNotebookToolUI, CreatePresentationToolUI, CreateSheetToolUI, DescribeDatabaseToolUI, EmailSearchToolUI, GetDatabaseTableSchemaToolUI, ListDatabaseTablesToolUI, OpenAssetToolUI, OpenBrowserToolUI, RunPythonCodeToolUI, RunSqlToolUI, TOOL_UI_REGISTRY, UpdateSheetRangeToolUI, WebSearchToolUI, createAssetToolUI, resetAssetAutoOpen } from "./tools/tool-uis.js";
+import { SubagentTaskToolUI } from "./tools/subagent-task-tool-ui.js";
 import { CopyToolSpecButton, ExpandableSection, ToolCard, normalizeResult, truncate } from "./tools/primitives.js";
 import { InstallPackageToolUI } from "./tools/misc-tool-uis.js";
 import { TOOL_ICONS, toolIcon } from "./tools/tool-icons.js";
@@ -131,6 +134,8 @@ import { describeToolArgs, formatToolName, getToolDisplayMeta, toolActiveLabel,
 import { githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent } from "./agent-runtime/src/github-wake-event.js";
 import { hasStatewireThreadExtras } from "./agent-runtime/src/thread-extras.js";
 import { useToolAppearance } from "./tools/tool-appearance.js";
+import { useTurnToolCallsAwaitingApproval } from "./agent-runtime/src/subagents.js";
+import { windowInFrontSignal } from "./agent-runtime/src/chat-outbox-signals.js";
 export {
   ATHENA_REACT_SDK_VERSION,
   ATHENA_REPO_SEARCH_PATH,
@@ -206,6 +211,8 @@ export {
   MODEL_PROVIDER_LABELS,
   NestedPtcComponentsProvider,
   NestedPtcMessages,
+  OFFLINE_SNAPSHOT_READ_WAIT_MS,
+  OfflineSnapshotBanner,
   OpenAssetToolUI,
   OpenBrowserToolUI,
   OwnerDocumentProvider,
@@ -249,6 +256,7 @@ export {
   StatewireHistoryEdge,
   StatewireQueuedMessages,
   StatewireRunRefusalNotice,
+  SubagentTaskToolUI,
   SuperGroupingCard,
   SuperGroupingFinalText,
   SuperGroupingProvider,
@@ -319,6 +327,8 @@ export {
   channelLabel,
   classifyToolResult,
   clearAutoOpenedAssets,
+  clearChatOutbox,
+  clearUnopenableChatOutbox,
   cn,
   collectAssetTitles,
   collectStatewireClientTools,
@@ -332,6 +342,7 @@ export {
   conversationDisplayTitle,
   conversationSummaryFromIndexEntry,
   countActivityTools,
+  countChatOutboxMessages,
   createAssetToolUI,
   createAthenaSpacesUrl,
   createAttachmentStore,
@@ -366,6 +377,7 @@ export {
   finalLiveDesktopCloseNotice,
   formatA1Cell,
   formatA1Range,
+  formatOfflineSnapshotTime,
   formatRecordingClock,
   formatTestRecordingCounts,
   formatToolName,
@@ -401,6 +413,7 @@ export {
   isThreadFavoriteUnavailableError,
   isThreadRenameUnavailableError,
   isToolResultSuccess,
+  listChatOutboxMessages,
   listThreads,
   liveDesktopViewerUrl,
   matchesSessionsQuery,
@@ -458,6 +471,7 @@ export {
   splitSheetPrefix,
   splitTurnSegments,
   statewireClientToolWireEntries,
+  subscribeChatOutbox,
   summarizeToolCall,
   taskProgress,
   themeToStyleVars,
@@ -488,6 +502,7 @@ export {
   useAthenaInboxUnreadCount,
   useAthenaLinkClickHandler,
   useAthenaModelCatalog,
+  useAthenaOfflineSnapshotAt,
   useAthenaRepoSearch,
   useAthenaRunLive,
   useAthenaSessionAttention,
@@ -522,10 +537,13 @@ export {
   useSessionWorkbench,
   useSessionWorkbenchWorkspace,
   useStatewireApprovalRequest,
+  useStatewireApprovalWait,
   useStatewireConversationHistory,
   useStatewireHistory,
   useStatewireToolOutputs,
   useToolAppearance,
+  useTurnToolCallsAwaitingApproval,
+  windowInFrontSignal,
   withCaptureGateBypass,
   workedDurationMs,
   workspaceComputers,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/offline/chat-outbox.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const chatOutboxStore = require("../agent-runtime/src/chat-outbox-store.cjs");
+const chatOutbox = require("../agent-runtime/src/chat-outbox.cjs");
+const ownerStores = /* @__PURE__ */ new Map();
+function keylessHost(ownerId) {
+  return { ownerId, getKey: async () => null };
+}
+function ownerStore(ownerId, host) {
+  let owner = ownerStores.get(ownerId);
+  if (!owner) {
+    const current = { current: host ?? keylessHost(ownerId) };
+    owner = {
+      host: current,
+      store: chatOutboxStore.createIndexedDbChatOutboxStore({
+        ownerId,
+        getKey: (_ownerId, purpose) => current.current.getKey(purpose)
+      })
+    };
+    ownerStores.set(ownerId, owner);
+  }
+  if (host) owner.host.current = host;
+  return owner.store;
+}
+function chatOutboxStoreFor(host) {
+  return ownerStore(host.ownerId, host);
+}
+function countChatOutboxMessages(ownerId) {
+  return ownerStore(ownerId).count();
+}
+function subscribeChatOutbox(ownerId, listener) {
+  return ownerStore(ownerId).subscribe(listener);
+}
+async function listChatOutboxMessages(ownerId, now = Date.now()) {
+  const records = await ownerStore(ownerId).listAll();
+  return records.map(({ entry, claim, failure, memoryOnly }) => ({
+    id: entry.id,
+    threadId: entry.threadId,
+    text: entry.text,
+    newChat: entry.newChat,
+    status: failure ? "failed" : claim && now - claim.at < chatOutbox.CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > chatOutbox.CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
+    inMemory: memoryOnly === true
+  }));
+}
+function clearChatOutbox(ownerId) {
+  return ownerStore(ownerId).clear();
+}
+function clearUnopenableChatOutbox(ownerId) {
+  return chatOutboxStore.createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+}
+exports.chatOutboxStoreFor = chatOutboxStoreFor;
+exports.clearChatOutbox = clearChatOutbox;
+exports.clearUnopenableChatOutbox = clearUnopenableChatOutbox;
+exports.countChatOutboxMessages = countChatOutboxMessages;
+exports.listChatOutboxMessages = listChatOutboxMessages;
+exports.subscribeChatOutbox = subscribeChatOutbox;
+//# sourceMappingURL=chat-outbox.cjs.map

package/dist/offline/chat-outbox.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox.cjs","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  CHAT_OUTBOX_CLAIM_LEASE_MS,\n  type ChatOutboxKeyPurpose,\n  type ChatOutboxSignal,\n  type ChatOutboxStore,\n  createIndexedDbChatOutboxStore,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike\n *   the chat history's, this key guards the only copy of what someone wrote: a host must never\n *   replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\ninterface OwnerStore {\n  store: ChatOutboxStore;\n  /** The latest host for this owner: the store asks it for the key. */\n  host: { current: AthenaChatOutbox };\n}\n\n// process-local: one store per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one change bus and one memory of the messages this device could\n// not keep: a thread switch or a closed tab never loses them, and a sign-out counts them.\nconst ownerStores = new Map<string, OwnerStore>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction ownerStore(ownerId: string, host?: AthenaChatOutbox): ChatOutboxStore {\n  let owner = ownerStores.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    owner = {\n      host: current,\n      store: createIndexedDbChatOutboxStore({\n        ownerId,\n        getKey: (_ownerId, purpose) => current.current.getKey(purpose),\n      }),\n    };\n    ownerStores.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner.store;\n}\n\n/** The page's chat outbox store for `host`'s owner, made on first use. */\nexport function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore {\n  return ownerStore(host.ownerId, host);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without opening them. Rejects when the\n * device's records cannot be counted at all.\n */\nexport function countChatOutboxMessages(ownerId: string): Promise<number> {\n  return ownerStore(ownerId).count();\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStore(ownerId).subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its\n   * conversation now (a window's claim on it still holds), waiting for the person (it waited more\n   * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const records = await ownerStore(ownerId).listAll();\n  return records.map(({ entry, claim, failure, memoryOnly }) => ({\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: failure\n      ? 'failed'\n      : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory: memoryOnly === true,\n  }));\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport function clearChatOutbox(ownerId: string): Promise<void> {\n  return ownerStore(ownerId).clear();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();\n}\n"],"names":["createIndexedDbChatOutboxStore","CHAT_OUTBOX_CLAIM_LEASE_MS","CHAT_OUTBOX_ASK_AFTER_MS"],"mappings":";;;;AAiDA,MAAM,kCAAkB,IAAA;AAGxB,SAAS,YAAY,SAAmC;AACtD,SAAO,EAAE,SAAS,QAAQ,YAAY,KAAA;AACxC;AAEA,SAAS,WAAW,SAAiB,MAA0C;AAC7E,MAAI,QAAQ,YAAY,IAAI,OAAO;AACnC,MAAI,CAAC,OAAO;AACV,UAAM,UAAU,EAAE,SAAS,QAAQ,YAAY,OAAO,EAAA;AACtD,YAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAOA,gBAAAA,+BAA+B;AAAA,QACpC;AAAA,QACA,QAAQ,CAAC,UAAU,YAAY,QAAQ,QAAQ,OAAO,OAAO;AAAA,MAAA,CAC9D;AAAA,IAAA;AAEH,gBAAY,IAAI,SAAS,KAAK;AAAA,EAChC;AACA,MAAI,KAAM,OAAM,KAAK,UAAU;AAC/B,SAAO,MAAM;AACf;AAGO,SAAS,mBAAmB,MAAyC;AAC1E,SAAO,WAAW,KAAK,SAAS,IAAI;AACtC;AAOO,SAAS,wBAAwB,SAAkC;AACxE,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,oBAAoB,SAAiB,UAAkC;AACrF,SAAO,WAAW,OAAO,EAAE,UAAU,QAAQ;AAC/C;AA0BA,eAAsB,uBACpB,SACA,MAAc,KAAK,OACkB;AACrC,QAAM,UAAU,MAAM,WAAW,OAAO,EAAE,QAAA;AAC1C,SAAO,QAAQ,IAAI,CAAC,EAAE,OAAO,OAAO,SAAS,kBAAkB;AAAA,IAC7D,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,QAAQ,UACJ,WACA,SAAS,MAAM,MAAM,KAAKC,WAAAA,6BACxB,YACA,MAAM,MAAM,WAAWC,WAAAA,2BACrB,QACA;AAAA,IACR,UAAU,eAAe;AAAA,EAAA,EACzB;AACJ;AAGO,SAAS,gBAAgB,SAAgC;AAC9D,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,0BAA0B,SAAgC;AACxE,SAAOF,gBAAAA,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;;;;;;;"}

package/dist/offline/chat-outbox.d.ts

@@ -0,0 +1,80 @@
+import { type ChatOutboxKeyPurpose, type ChatOutboxSignal, type ChatOutboxStore } from '../agent-runtime/src/index';
+/**
+ * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's
+ * key, and are sent once Athena is back while the app is in front, after a countdown the person
+ * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).
+ * Without it a send goes to the transport as before.
+ *
+ * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's
+ *   messages are never shown or sent: each owner's are sealed under their own key.
+ * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,
+ *   never made for this), `write` keeps a new message (only while the deployment lets devices keep
+ *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike
+ *   the chat history's, this key guards the only copy of what someone wrote: a host must never
+ *   replace or drop it except at a sign-out the person chose.
+ * - `reachability` says Athena can be reached: the host's own model (the device online AND agora
+ *   answering a health read, as Midas's main process decides it), by default the browser being
+ *   online. Either way a conversation whose own channel keeps failing to connect counts as out of
+ *   reach too.
+ * - `foreground` says the app is in front; by default a visible document. A desktop host passes
+ *   `windowInFrontSignal()` (visible and focused).
+ * - `openThread` opens another of the person's conversations the tray lists as holding waiting
+ *   messages (`newChat`: one that never started). Without it, a provider with a thread list
+ *   switches to it; otherwise the tray names it without Open.
+ */
+export interface AthenaChatOutbox {
+    ownerId: string;
+    getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;
+    reachability?: ChatOutboxSignal;
+    foreground?: ChatOutboxSignal;
+    openThread?: (target: {
+        threadId: string;
+        newChat: boolean;
+    }) => void;
+}
+/** The page's chat outbox store for `host`'s owner, made on first use. */
+export declare function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore;
+/**
+ * How many messages wait for `ownerId` (kept on the device, including records this build cannot
+ * open, and waiting in this page's memory), counted without opening them. Rejects when the
+ * device's records cannot be counted at all.
+ */
+export declare function countChatOutboxMessages(ownerId: string): Promise<number>;
+/**
+ * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's
+ * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many
+ * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.
+ */
+export declare function subscribeChatOutbox(ownerId: string, listener: () => void): () => void;
+/** A message waiting in an owner's outbox, as a host lists it (its "Waiting to sync" list). */
+export interface ChatOutboxMessageSummary {
+    id: string;
+    threadId: string;
+    /** The text as it will be sent. */
+    text: string;
+    /** Typed into a chat that had never started. */
+    newChat: boolean;
+    /**
+     * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its
+     * conversation now (a window's claim on it still holds), waiting for the person (it waited more
+     * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).
+     */
+    status: 'waiting' | 'sending' | 'ask' | 'failed';
+    /** Kept only in this page's memory: this device could not keep it. */
+    inMemory: boolean;
+}
+/**
+ * The messages waiting for `ownerId` that this page can open (oldest first), each with where it
+ * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.
+ * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with
+ * `countChatOutboxMessages`.
+ */
+export declare function listChatOutboxMessages(ownerId: string, now?: number): Promise<ChatOutboxMessageSummary[]>;
+/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */
+export declare function clearChatOutbox(ownerId: string): Promise<void>;
+/**
+ * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's
+ * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the
+ * page could delete the records), so nothing can ever open them and they must not be counted.
+ */
+export declare function clearUnopenableChatOutbox(ownerId: string): Promise<void>;

package/dist/offline/chat-outbox.js

@@ -0,0 +1,57 @@
+import { createIndexedDbChatOutboxStore } from "../agent-runtime/src/chat-outbox-store.js";
+import { CHAT_OUTBOX_CLAIM_LEASE_MS, CHAT_OUTBOX_ASK_AFTER_MS } from "../agent-runtime/src/chat-outbox.js";
+const ownerStores = /* @__PURE__ */ new Map();
+function keylessHost(ownerId) {
+  return { ownerId, getKey: async () => null };
+}
+function ownerStore(ownerId, host) {
+  let owner = ownerStores.get(ownerId);
+  if (!owner) {
+    const current = { current: host ?? keylessHost(ownerId) };
+    owner = {
+      host: current,
+      store: createIndexedDbChatOutboxStore({
+        ownerId,
+        getKey: (_ownerId, purpose) => current.current.getKey(purpose)
+      })
+    };
+    ownerStores.set(ownerId, owner);
+  }
+  if (host) owner.host.current = host;
+  return owner.store;
+}
+function chatOutboxStoreFor(host) {
+  return ownerStore(host.ownerId, host);
+}
+function countChatOutboxMessages(ownerId) {
+  return ownerStore(ownerId).count();
+}
+function subscribeChatOutbox(ownerId, listener) {
+  return ownerStore(ownerId).subscribe(listener);
+}
+async function listChatOutboxMessages(ownerId, now = Date.now()) {
+  const records = await ownerStore(ownerId).listAll();
+  return records.map(({ entry, claim, failure, memoryOnly }) => ({
+    id: entry.id,
+    threadId: entry.threadId,
+    text: entry.text,
+    newChat: entry.newChat,
+    status: failure ? "failed" : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS ? "sending" : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS ? "ask" : "waiting",
+    inMemory: memoryOnly === true
+  }));
+}
+function clearChatOutbox(ownerId) {
+  return ownerStore(ownerId).clear();
+}
+function clearUnopenableChatOutbox(ownerId) {
+  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();
+}
+export {
+  chatOutboxStoreFor,
+  clearChatOutbox,
+  clearUnopenableChatOutbox,
+  countChatOutboxMessages,
+  listChatOutboxMessages,
+  subscribeChatOutbox
+};
+//# sourceMappingURL=chat-outbox.js.map

package/dist/offline/chat-outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-outbox.js","sources":["../../src/offline/chat-outbox.ts"],"sourcesContent":["import {\n  CHAT_OUTBOX_ASK_AFTER_MS,\n  CHAT_OUTBOX_CLAIM_LEASE_MS,\n  type ChatOutboxKeyPurpose,\n  type ChatOutboxSignal,\n  type ChatOutboxStore,\n  createIndexedDbChatOutboxStore,\n} from '@athenaintel/agent-runtime';\n\n/**\n * Opt-in: messages typed while Athena can't be reached wait on this device, sealed with the host's\n * key, and are sent once Athena is back while the app is in front, after a countdown the person\n * can cancel (`@athenaintel/agent-runtime`'s chat outbox, shown at the top of the queue tray).\n * Without it a send goes to the transport as before.\n *\n * - `ownerId` names whose they are (the signed-in person, with the environment). Another owner's\n *   messages are never shown or sent: each owner's are sealed under their own key.\n * - `getKey(purpose)` returns the AES-GCM key: `read` opens what is kept (the key if one exists,\n *   never made for this), `write` keeps a new message (only while the deployment lets devices keep\n *   copies). `null` keeps a new message in memory only, for as long as the page stays open. Unlike\n *   the chat history's, this key guards the only copy of what someone wrote: a host must never\n *   replace or drop it except at a sign-out the person chose.\n * - `reachability` says Athena can be reached: the host's own model (the device online AND agora\n *   answering a health read, as Midas's main process decides it), by default the browser being\n *   online. Either way a conversation whose own channel keeps failing to connect counts as out of\n *   reach too.\n * - `foreground` says the app is in front; by default a visible document. A desktop host passes\n *   `windowInFrontSignal()` (visible and focused).\n * - `openThread` opens another of the person's conversations the tray lists as holding waiting\n *   messages (`newChat`: one that never started). Without it, a provider with a thread list\n *   switches to it; otherwise the tray names it without Open.\n */\nexport interface AthenaChatOutbox {\n  ownerId: string;\n  getKey: (purpose: ChatOutboxKeyPurpose) => Promise<CryptoKey | null>;\n  reachability?: ChatOutboxSignal;\n  foreground?: ChatOutboxSignal;\n  openThread?: (target: { threadId: string; newChat: boolean }) => void;\n}\n\ninterface OwnerStore {\n  store: ChatOutboxStore;\n  /** The latest host for this owner: the store asks it for the key. */\n  host: { current: AthenaChatOutbox };\n}\n\n// process-local: one store per owner in this page, so every provider of the person (a chat in a\n// tab, another in a pane) shares one change bus and one memory of the messages this device could\n// not keep: a thread switch or a closed tab never loses them, and a sign-out counts them.\nconst ownerStores = new Map<string, OwnerStore>();\n\n/** A host that has no key to give (counting and deleting never need one). */\nfunction keylessHost(ownerId: string): AthenaChatOutbox {\n  return { ownerId, getKey: async () => null };\n}\n\nfunction ownerStore(ownerId: string, host?: AthenaChatOutbox): ChatOutboxStore {\n  let owner = ownerStores.get(ownerId);\n  if (!owner) {\n    const current = { current: host ?? keylessHost(ownerId) };\n    owner = {\n      host: current,\n      store: createIndexedDbChatOutboxStore({\n        ownerId,\n        getKey: (_ownerId, purpose) => current.current.getKey(purpose),\n      }),\n    };\n    ownerStores.set(ownerId, owner);\n  }\n  if (host) owner.host.current = host;\n  return owner.store;\n}\n\n/** The page's chat outbox store for `host`'s owner, made on first use. */\nexport function chatOutboxStoreFor(host: AthenaChatOutbox): ChatOutboxStore {\n  return ownerStore(host.ownerId, host);\n}\n\n/**\n * How many messages wait for `ownerId` (kept on the device, including records this build cannot\n * open, and waiting in this page's memory), counted without opening them. Rejects when the\n * device's records cannot be counted at all.\n */\nexport function countChatOutboxMessages(ownerId: string): Promise<number> {\n  return ownerStore(ownerId).count();\n}\n\n/**\n * Calls `listener` after any change to `ownerId`'s waiting messages, this window's or another's\n * (one kept, handed to its conversation, cancelled, failed or retried), so a host can show how many\n * wait (`countChatOutboxMessages`) without asking on a timer. Returns what stops it.\n */\nexport function subscribeChatOutbox(ownerId: string, listener: () => void): () => void {\n  return ownerStore(ownerId).subscribe(listener);\n}\n\n/** A message waiting in an owner's outbox, as a host lists it (its \"Waiting to sync\" list). */\nexport interface ChatOutboxMessageSummary {\n  id: string;\n  threadId: string;\n  /** The text as it will be sent. */\n  text: string;\n  /** Typed into a chat that had never started. */\n  newChat: boolean;\n  /**\n   * Where it stands, as the queue tray shows it: waiting to be sent, being handed to its\n   * conversation now (a window's claim on it still holds), waiting for the person (it waited more\n   * than a day: Send, Edit or Discard), or failed (Retry or Discard; never retried on its own).\n   */\n  status: 'waiting' | 'sending' | 'ask' | 'failed';\n  /** Kept only in this page's memory: this device could not keep it. */\n  inMemory: boolean;\n}\n\n/**\n * The messages waiting for `ownerId` that this page can open (oldest first), each with where it\n * stands, for a host's list of what waits to sync; the tray in the conversation acts on them.\n * Records this page cannot open (no key here, a newer build's) are left out, so a host counts with\n * `countChatOutboxMessages`.\n */\nexport async function listChatOutboxMessages(\n  ownerId: string,\n  now: number = Date.now(),\n): Promise<ChatOutboxMessageSummary[]> {\n  const records = await ownerStore(ownerId).listAll();\n  return records.map(({ entry, claim, failure, memoryOnly }) => ({\n    id: entry.id,\n    threadId: entry.threadId,\n    text: entry.text,\n    newChat: entry.newChat,\n    status: failure\n      ? 'failed'\n      : claim && now - claim.at < CHAT_OUTBOX_CLAIM_LEASE_MS\n        ? 'sending'\n        : now - entry.queuedAt > CHAT_OUTBOX_ASK_AFTER_MS\n          ? 'ask'\n          : 'waiting',\n    inMemory: memoryOnly === true,\n  }));\n}\n\n/** A sign-out the person chose: every message waiting for `ownerId` goes, on the device and in memory. */\nexport function clearChatOutbox(ownerId: string): Promise<void> {\n  return ownerStore(ownerId).clear();\n}\n\n/**\n * Deletes the records kept on this device for `ownerId`, never the messages waiting in this page's\n * memory: for a host whose key for them no longer exists (a chosen sign-out deleted it before the\n * page could delete the records), so nothing can ever open them and they must not be counted.\n */\nexport function clearUnopenableChatOutbox(ownerId: string): Promise<void> {\n  return createIndexedDbChatOutboxStore({ ownerId, getKey: async () => null }).clear();\n}\n"],"names":[],"mappings":";;AAiDA,MAAM,kCAAkB,IAAA;AAGxB,SAAS,YAAY,SAAmC;AACtD,SAAO,EAAE,SAAS,QAAQ,YAAY,KAAA;AACxC;AAEA,SAAS,WAAW,SAAiB,MAA0C;AAC7E,MAAI,QAAQ,YAAY,IAAI,OAAO;AACnC,MAAI,CAAC,OAAO;AACV,UAAM,UAAU,EAAE,SAAS,QAAQ,YAAY,OAAO,EAAA;AACtD,YAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAO,+BAA+B;AAAA,QACpC;AAAA,QACA,QAAQ,CAAC,UAAU,YAAY,QAAQ,QAAQ,OAAO,OAAO;AAAA,MAAA,CAC9D;AAAA,IAAA;AAEH,gBAAY,IAAI,SAAS,KAAK;AAAA,EAChC;AACA,MAAI,KAAM,OAAM,KAAK,UAAU;AAC/B,SAAO,MAAM;AACf;AAGO,SAAS,mBAAmB,MAAyC;AAC1E,SAAO,WAAW,KAAK,SAAS,IAAI;AACtC;AAOO,SAAS,wBAAwB,SAAkC;AACxE,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,oBAAoB,SAAiB,UAAkC;AACrF,SAAO,WAAW,OAAO,EAAE,UAAU,QAAQ;AAC/C;AA0BA,eAAsB,uBACpB,SACA,MAAc,KAAK,OACkB;AACrC,QAAM,UAAU,MAAM,WAAW,OAAO,EAAE,QAAA;AAC1C,SAAO,QAAQ,IAAI,CAAC,EAAE,OAAO,OAAO,SAAS,kBAAkB;AAAA,IAC7D,IAAI,MAAM;AAAA,IACV,UAAU,MAAM;AAAA,IAChB,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,QAAQ,UACJ,WACA,SAAS,MAAM,MAAM,KAAK,6BACxB,YACA,MAAM,MAAM,WAAW,2BACrB,QACA;AAAA,IACR,UAAU,eAAe;AAAA,EAAA,EACzB;AACJ;AAGO,SAAS,gBAAgB,SAAgC;AAC9D,SAAO,WAAW,OAAO,EAAE,MAAA;AAC7B;AAOO,SAAS,0BAA0B,SAAgC;AACxE,SAAO,+BAA+B,EAAE,SAAS,QAAQ,YAAY,KAAA,CAAM,EAAE,MAAA;AAC/E;"}

package/dist/offline/offline-history.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const lucideReact = require("lucide-react");
+const react = require("react");
+const threadIdContext = require("../threads/thread-id-context.cjs");
+const cnfast = require("cnfast");
+const OFFLINE_SNAPSHOT_READ_WAIT_MS = 1500;
+function useKeptSnapshotsGate({
+  cache,
+  ownerId,
+  isOffline,
+  waitMs = OFFLINE_SNAPSHOT_READ_WAIT_MS
+}) {
+  const [readFor, setReadFor] = react.useState(void 0);
+  react.useEffect(() => {
+    if (!cache) return;
+    let live = true;
+    const settle = () => {
+      if (live) setReadFor(ownerId);
+    };
+    const timer = setTimeout(settle, waitMs);
+    const done = () => {
+      clearTimeout(timer);
+      settle();
+    };
+    void cache.setOwner(ownerId).then(done, done);
+    return () => {
+      live = false;
+      clearTimeout(timer);
+    };
+  }, [cache, ownerId, waitMs]);
+  const [mountedOffline] = react.useState(() => cache !== null && isOffline());
+  return mountedOffline && ownerId !== null && readFor !== ownerId;
+}
+const AthenaOfflineSnapshotsContext = react.createContext(null);
+const noSubscription = () => () => void 0;
+const serverSnapshot = () => null;
+function useAthenaOfflineSnapshotAt(threadId) {
+  const snapshots = react.useContext(AthenaOfflineSnapshotsContext);
+  return react.useSyncExternalStore(
+    snapshots ? (listener) => snapshots.subscribeOfflineSeeds(listener) : noSubscription,
+    () => snapshots && threadId ? snapshots.offlineSeedAt(threadId) : null,
+    serverSnapshot
+  );
+}
+function formatOfflineSnapshotTime(at) {
+  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium", timeStyle: "short" }).format(at);
+}
+const OfflineSnapshotBanner = ({ className }) => {
+  const at = useAthenaOfflineSnapshotAt(threadIdContext.useAthenaThreadId());
+  if (at === null) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      role: "status",
+      className: cnfast.cn(
+        "mx-auto flex w-full max-w-(--thread-max-width) items-center gap-2 rounded-md border px-3 py-2 text-xs",
+        "border-border bg-muted text-muted-foreground"
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CloudOffIcon, { className: "size-3.5 shrink-0", "aria-hidden": true }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+          "Offline · this conversation as of ",
+          formatOfflineSnapshotTime(at)
+        ] })
+      ]
+    }
+  ) });
+};
+exports.AthenaOfflineSnapshotsContext = AthenaOfflineSnapshotsContext;
+exports.OFFLINE_SNAPSHOT_READ_WAIT_MS = OFFLINE_SNAPSHOT_READ_WAIT_MS;
+exports.OfflineSnapshotBanner = OfflineSnapshotBanner;
+exports.formatOfflineSnapshotTime = formatOfflineSnapshotTime;
+exports.useAthenaOfflineSnapshotAt = useAthenaOfflineSnapshotAt;
+exports.useKeptSnapshotsGate = useKeptSnapshotsGate;
+//# sourceMappingURL=offline-history.cjs.map

package/dist/offline/offline-history.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-history.cjs","sources":["../../src/offline/offline-history.tsx"],"sourcesContent":["import type { DurableThreadSnapshotCache } from '@athenaintel/agent-runtime';\nimport { CloudOffIcon } from 'lucide-react';\nimport {\n  createContext,\n  type FC,\n  useContext,\n  useEffect,\n  useState,\n  useSyncExternalStore,\n} from 'react';\nimport { cn } from '../lib/utils';\nimport { useAthenaThreadId } from '../threads/thread-id-context';\n\n/**\n * Opt-in: keep the chat's recent conversations, and the session list, on this device, sealed with\n * the host's key, so a reload paints them at once and they can be read while Athena can't be\n * reached (`AthenaProvider`'s `offlineHistory`). Without it nothing is stored, as before.\n *\n * - `ownerId` names whose they are (the signed-in person). Changing it drops what the previous\n *   owner kept, in memory and on the device (the session list's cached pages too); nothing kept\n *   under one owner is ever shown to another. Passing no `offlineHistory` any more (a deployment\n *   that now keeps nothing on devices) drops it all the same.\n * - `getKey` returns the AES-GCM key that seals them, for that owner, or `null` to keep nothing\n *   (no key, a deployment that keeps nothing on devices). Midas's comes from its main process,\n *   kept with the OS keychain and handed to the page only for the signed-in person.\n * - `isOffline` says Athena can't be reached (the browser's own offline when omitted): then a\n *   conversation opens on its last resting transcript this device holds, up to 30 days old, marked\n *   \"as of\" when it was captured; a chat that mounts offline waits (at most\n *   {@link OFFLINE_SNAPSHOT_READ_WAIT_MS}) for what the device kept to be read.\n */\nexport interface AthenaOfflineHistory {\n  ownerId: string;\n  getKey: () => Promise<CryptoKey | null>;\n  isOffline?: () => boolean;\n}\n\n/**\n * How long a chat that mounts offline waits for what this device kept before it mounts without:\n * the host's key and IndexedDB answer in milliseconds unless something is stuck.\n */\nexport const OFFLINE_SNAPSHOT_READ_WAIT_MS = 1_500;\n\n/**\n * Binds `cache` to `ownerId`, and says whether a chat that mounted offline still waits for what\n * this device kept for that owner to be read (at most `waitMs`). The runtime takes a thread's seed\n * once, as it mounts, and offline that seed is all a thread can show; online it never waits, the\n * attach delivers the thread.\n */\nexport function useKeptSnapshotsGate({\n  cache,\n  ownerId,\n  isOffline,\n  waitMs = OFFLINE_SNAPSHOT_READ_WAIT_MS,\n}: {\n  cache: Pick<DurableThreadSnapshotCache, 'setOwner'> | null;\n  ownerId: string | null;\n  isOffline: () => boolean;\n  waitMs?: number;\n}): boolean {\n  const [readFor, setReadFor] = useState<string | null | undefined>(undefined);\n  useEffect(() => {\n    if (!cache) return;\n    let live = true;\n    const settle = () => {\n      if (live) setReadFor(ownerId);\n    };\n    const timer = setTimeout(settle, waitMs);\n    const done = () => {\n      clearTimeout(timer);\n      settle();\n    };\n    void cache.setOwner(ownerId).then(done, done);\n    return () => {\n      live = false;\n      clearTimeout(timer);\n    };\n  }, [cache, ownerId, waitMs]);\n  const [mountedOffline] = useState(() => cache !== null && isOffline());\n  return mountedOffline && ownerId !== null && readFor !== ownerId;\n}\n\n/** The provider's offline snapshots: when a thread on screen was captured, if it opened offline. */\nexport type AthenaOfflineSnapshots = Pick<\n  DurableThreadSnapshotCache,\n  'offlineSeedAt' | 'subscribeOfflineSeeds'\n>;\n\nexport const AthenaOfflineSnapshotsContext = createContext<AthenaOfflineSnapshots | null>(null);\n\nconst noSubscription = (): (() => void) => () => undefined;\nconst serverSnapshot = (): number | null => null;\n\n/**\n * When the transcript `threadId` shows was captured, if it opened from this device while Athena\n * could not be reached; `null` once the thread's own state arrives, outside an `offlineHistory`\n * provider, or for a new chat.\n */\nexport function useAthenaOfflineSnapshotAt(threadId: string | undefined): number | null {\n  const snapshots = useContext(AthenaOfflineSnapshotsContext);\n  return useSyncExternalStore(\n    snapshots ? (listener) => snapshots.subscribeOfflineSeeds(listener) : noSubscription,\n    () => (snapshots && threadId ? snapshots.offlineSeedAt(threadId) : null),\n    serverSnapshot,\n  );\n}\n\nexport function formatOfflineSnapshotTime(at: number): string {\n  return new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' }).format(at);\n}\n\nexport interface OfflineSnapshotBannerProps {\n  /** Applied to the outer wrapper (host padding); the banner itself is width-capped inside it. */\n  className?: string;\n}\n\n/**\n * Above a conversation that opened from this device while Athena can't be reached: what is shown\n * is the conversation as it was then, not live. Renders nothing otherwise.\n */\nexport const OfflineSnapshotBanner: FC<OfflineSnapshotBannerProps> = ({ className }) => {\n  const at = useAthenaOfflineSnapshotAt(useAthenaThreadId());\n  if (at === null) return null;\n  return (\n    <div className={className}>\n      <div\n        role=\"status\"\n        className={cn(\n          'mx-auto flex w-full max-w-(--thread-max-width) items-center gap-2 rounded-md border px-3 py-2 text-xs',\n          'border-border bg-muted text-muted-foreground',\n        )}\n      >\n        <CloudOffIcon className=\"size-3.5 shrink-0\" aria-hidden />\n        <span>Offline · this conversation as of {formatOfflineSnapshotTime(at)}</span>\n      </div>\n    </div>\n  );\n};\n"],"names":["useState","useEffect","createContext","useContext","useSyncExternalStore","useAthenaThreadId","jsx","jsxs","cn","CloudOffIcon"],"mappings":";;;;;;;AAwCO,MAAM,gCAAgC;AAQtC,SAAS,qBAAqB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA,SAAS;AACX,GAKY;AACV,QAAM,CAAC,SAAS,UAAU,IAAIA,MAAAA,SAAoC,MAAS;AAC3EC,QAAAA,UAAU,MAAM;AACd,QAAI,CAAC,MAAO;AACZ,QAAI,OAAO;AACX,UAAM,SAAS,MAAM;AACnB,UAAI,iBAAiB,OAAO;AAAA,IAC9B;AACA,UAAM,QAAQ,WAAW,QAAQ,MAAM;AACvC,UAAM,OAAO,MAAM;AACjB,mBAAa,KAAK;AAClB,aAAA;AAAA,IACF;AACA,SAAK,MAAM,SAAS,OAAO,EAAE,KAAK,MAAM,IAAI;AAC5C,WAAO,MAAM;AACX,aAAO;AACP,mBAAa,KAAK;AAAA,IACpB;AAAA,EACF,GAAG,CAAC,OAAO,SAAS,MAAM,CAAC;AAC3B,QAAM,CAAC,cAAc,IAAID,MAAAA,SAAS,MAAM,UAAU,QAAQ,WAAW;AACrE,SAAO,kBAAkB,YAAY,QAAQ,YAAY;AAC3D;AAQO,MAAM,gCAAgCE,MAAAA,cAA6C,IAAI;AAE9F,MAAM,iBAAiB,MAAoB,MAAM;AACjD,MAAM,iBAAiB,MAAqB;AAOrC,SAAS,2BAA2B,UAA6C;AACtF,QAAM,YAAYC,MAAAA,WAAW,6BAA6B;AAC1D,SAAOC,MAAAA;AAAAA,IACL,YAAY,CAAC,aAAa,UAAU,sBAAsB,QAAQ,IAAI;AAAA,IACtE,MAAO,aAAa,WAAW,UAAU,cAAc,QAAQ,IAAI;AAAA,IACnE;AAAA,EAAA;AAEJ;AAEO,SAAS,0BAA0B,IAAoB;AAC5D,SAAO,IAAI,KAAK,eAAe,QAAW,EAAE,WAAW,UAAU,WAAW,QAAA,CAAS,EAAE,OAAO,EAAE;AAClG;AAWO,MAAM,wBAAwD,CAAC,EAAE,gBAAgB;AACtF,QAAM,KAAK,2BAA2BC,gBAAAA,mBAAmB;AACzD,MAAI,OAAO,KAAM,QAAO;AACxB,SACEC,2BAAAA,IAAC,SAAI,WACH,UAAAC,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC,MAAK;AAAA,MACL,WAAWC,OAAAA;AAAAA,QACT;AAAA,QACA;AAAA,MAAA;AAAA,MAGF,UAAA;AAAA,QAAAF,2BAAAA,IAACG,YAAAA,cAAA,EAAa,WAAU,qBAAoB,eAAW,MAAC;AAAA,wCACvD,QAAA,EAAK,UAAA;AAAA,UAAA;AAAA,UAAmC,0BAA0B,EAAE;AAAA,QAAA,EAAA,CAAE;AAAA,MAAA;AAAA,IAAA;AAAA,EAAA,GAE3E;AAEJ;;;;;;;"}

package/dist/offline/offline-history.d.ts

@@ -0,0 +1,60 @@
+import type { DurableThreadSnapshotCache } from '../agent-runtime/src/index';
+import { type FC } from 'react';
+/**
+ * Opt-in: keep the chat's recent conversations, and the session list, on this device, sealed with
+ * the host's key, so a reload paints them at once and they can be read while Athena can't be
+ * reached (`AthenaProvider`'s `offlineHistory`). Without it nothing is stored, as before.
+ *
+ * - `ownerId` names whose they are (the signed-in person). Changing it drops what the previous
+ *   owner kept, in memory and on the device (the session list's cached pages too); nothing kept
+ *   under one owner is ever shown to another. Passing no `offlineHistory` any more (a deployment
+ *   that now keeps nothing on devices) drops it all the same.
+ * - `getKey` returns the AES-GCM key that seals them, for that owner, or `null` to keep nothing
+ *   (no key, a deployment that keeps nothing on devices). Midas's comes from its main process,
+ *   kept with the OS keychain and handed to the page only for the signed-in person.
+ * - `isOffline` says Athena can't be reached (the browser's own offline when omitted): then a
+ *   conversation opens on its last resting transcript this device holds, up to 30 days old, marked
+ *   "as of" when it was captured; a chat that mounts offline waits (at most
+ *   {@link OFFLINE_SNAPSHOT_READ_WAIT_MS}) for what the device kept to be read.
+ */
+export interface AthenaOfflineHistory {
+    ownerId: string;
+    getKey: () => Promise<CryptoKey | null>;
+    isOffline?: () => boolean;
+}
+/**
+ * How long a chat that mounts offline waits for what this device kept before it mounts without:
+ * the host's key and IndexedDB answer in milliseconds unless something is stuck.
+ */
+export declare const OFFLINE_SNAPSHOT_READ_WAIT_MS = 1500;
+/**
+ * Binds `cache` to `ownerId`, and says whether a chat that mounted offline still waits for what
+ * this device kept for that owner to be read (at most `waitMs`). The runtime takes a thread's seed
+ * once, as it mounts, and offline that seed is all a thread can show; online it never waits, the
+ * attach delivers the thread.
+ */
+export declare function useKeptSnapshotsGate({ cache, ownerId, isOffline, waitMs, }: {
+    cache: Pick<DurableThreadSnapshotCache, 'setOwner'> | null;
+    ownerId: string | null;
+    isOffline: () => boolean;
+    waitMs?: number;
+}): boolean;
+/** The provider's offline snapshots: when a thread on screen was captured, if it opened offline. */
+export type AthenaOfflineSnapshots = Pick<DurableThreadSnapshotCache, 'offlineSeedAt' | 'subscribeOfflineSeeds'>;
+export declare const AthenaOfflineSnapshotsContext: import("react").Context<AthenaOfflineSnapshots | null>;
+/**
+ * When the transcript `threadId` shows was captured, if it opened from this device while Athena
+ * could not be reached; `null` once the thread's own state arrives, outside an `offlineHistory`
+ * provider, or for a new chat.
+ */
+export declare function useAthenaOfflineSnapshotAt(threadId: string | undefined): number | null;
+export declare function formatOfflineSnapshotTime(at: number): string;
+export interface OfflineSnapshotBannerProps {
+    /** Applied to the outer wrapper (host padding); the banner itself is width-capped inside it. */
+    className?: string;
+}
+/**
+ * Above a conversation that opened from this device while Athena can't be reached: what is shown
+ * is the conversation as it was then, not live. Renders nothing otherwise.
+ */
+export declare const OfflineSnapshotBanner: FC<OfflineSnapshotBannerProps>;