@athenaintel/react 0.42.2 → 0.48.0

package/dist/agent-runtime/src/offline-status.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const UNCONFIRMED_EDITS_STALL_MS = 15e3;
+const AVAILABLE_AGAIN = "It’s available again when you’re back online.";
+const NEEDS_CONNECTION = {
+  label: "Needs a connection",
+  detail: `This needs Athena. ${AVAILABLE_AGAIN}`
+};
+function attachmentNeedsConnection({
+  kind,
+  messagesWait
+}) {
+  const attaching = `Attaching ${"a file"} needs Athena. ${AVAILABLE_AGAIN}`;
+  return messagesWait ? `You can still send your message: it goes when Athena is back. ${attaching}` : attaching;
+}
+function heldExtras(withQuote) {
+  return withQuote ? "an attachment or a quote" : "an attachment";
+}
+function attachedMessageNeedsConnection({
+  withQuote = false
+} = {}) {
+  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${withQuote ? "it" : "the attachment"} to send the text.`;
+}
+function attachedMessageBehindWaiting({
+  withQuote = false
+} = {}) {
+  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(
+    withQuote
+  )} can’t wait behind them, so send it once they’ve gone.`;
+}
+exports.NEEDS_CONNECTION = NEEDS_CONNECTION;
+exports.UNCONFIRMED_EDITS_STALL_MS = UNCONFIRMED_EDITS_STALL_MS;
+exports.attachedMessageBehindWaiting = attachedMessageBehindWaiting;
+exports.attachedMessageNeedsConnection = attachedMessageNeedsConnection;
+exports.attachmentNeedsConnection = attachmentNeedsConnection;
+//# sourceMappingURL=offline-status.cjs.map

package/dist/agent-runtime/src/offline-status.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-status.cjs","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return {\n        label: `Saved on ${device}`,\n        detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n      };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":";;AAyPO,MAAM,6BAA6B;AA+B1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;;;;;;"}

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

@@ -41,7 +41,20 @@ export type DocumentSyncState =
 /** Some changes overlap with Athena's version: the person chooses. */
  | 'needs-review'
 /** The document can no longer take these edits (access or state changed): kept, not sent. */
- | 'view-only';
+ | 'view-only'
+/**
+ * Athena answers but isn't taking this document's changes for now: it holds the document while it
+ * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`
+ * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:
+ * that is `on-device` or `in-memory`.
+ */
+ | 'delayed';
+/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */
+export type SavingDelayCause = 
+/** Athena holds the document while it repairs it, and takes no changes to it until then. */
+'repairing'
+/** Athena hasn't confirmed the latest changes for longer than usual. */
+ | 'unconfirmed';
 /** How a sentence names the device the person is on. */
 export type DeviceNoun = 'this browser' | 'this Mac' | 'this computer' | 'this phone' | 'this tablet' | 'this device';
 /**
@@ -77,16 +90,85 @@ export declare function connectionCopy({ state, device, waiting, keeping, }: {
     waiting?: number;
     keeping?: OfflineKeeping;
 }): StatusCopy | null;
-/** The chip in a document's header, and the line it explains itself with. */
-export declare function documentSyncCopy({ state, device, }: {
+/**
+ * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`
+ * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only
+ * while the tab or app stays open (default `device`); every other state ignores both.
+ */
+export declare function documentSyncCopy({ state, device, delay, keeping, }: {
     state: DocumentSyncState;
     device: DeviceNoun;
+    delay?: SavingDelayCause;
+    keeping?: Exclude<OfflineKeeping, 'none'>;
 }): LabelCopy;
+/**
+ * How long a document's edits may wait unconfirmed on a connection that is up before its saving
+ * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window
+ * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's
+ * `room-sync-store.test.ts` holds equal).
+ */
+export declare const UNCONFIRMED_EDITS_STALL_MS = 15000;
+/**
+ * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena
+ * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes
+ * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its
+ * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every
+ * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing
+ * and saving, so a room that refuses writes never spins and being offline is never a delay.
+ */
+export declare function savingDelayCause({ reachable, connected, writesRefused, unconfirmedStalled, }: {
+    /** Athena answers (the app's reachability, never the socket alone). */
+    reachable: boolean;
+    /** The document's room is connected. */
+    connected: boolean;
+    /** Keryx's document status says the room takes no writes for now. */
+    writesRefused: boolean;
+    /** Local edits have waited unconfirmed past the stall window on this connection. */
+    unconfirmedStalled: boolean;
+}): SavingDelayCause | null;
 /**
  * The reason on a control that needs Athena (share, run, upload, invite…),
  * shown disabled while Athena can't be reached rather than failing when used.
  */
 export declare const NEEDS_CONNECTION: LabelCopy;
+/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */
+export type AttachmentKind = 'photo' | 'file';
+/**
+ * What a composer says when a photo or file is picked, pasted or dropped while
+ * Athena can't be reached. It isn't attached: only Athena can take the upload.
+ * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat
+ * keeps an outbox), the message itself still goes, so that comes first. Where
+ * nothing waits (the Chrome side panel, a launcher that keeps its draft), it
+ * says only when attaching works again, as `NEEDS_CONNECTION` does.
+ */
+export declare function attachmentNeedsConnection({ kind, messagesWait, }: {
+    kind: AttachmentKind;
+    messagesWait: boolean;
+}): string;
+/**
+ * What a composer says when a message is sent while Athena can't be reached
+ * with an attachment that never reached Athena (or, `withQuote`, a quote the
+ * chat can't keep waiting). Its text could wait in the chat outbox; the
+ * attachment can't, so the draft stays as it is.
+ */
+export declare function attachedMessageNeedsConnection({ withQuote, }?: {
+    withQuote?: boolean;
+}): string;
+/**
+ * What a composer says when a message with an attachment (or, `withQuote`, a
+ * quote) is sent while messages written when Athena couldn't be reached still
+ * wait to go: those go first, and this one can't wait behind them.
+ */
+export declare function attachedMessageBehindWaiting({ withQuote, }?: {
+    withQuote?: boolean;
+}): string;
+/**
+ * The reason on New Presentation while Athena can't be reached, in a workspace
+ * whose new presentations start from its design system's template: a
+ * presentation made offline starts blank, and only Athena can copy the
+ * template, so none is made until it can.
+ */
+export declare const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy;
 /**
  * Whether an item opens without a connection on this device, for lists.
  * `canKeep` says whether opening it online would keep a copy here (the
@@ -155,3 +237,36 @@ export declare const WAITING_SECTION_TITLES: {
     readonly messages: 'Messages';
     readonly recordings: 'Recordings';
 };
+/**
+ * What the person can do with an item Athena didn't take (`not-synced`) in the
+ * "Waiting to sync" list: send it again, or delete the copy on the device. That
+ * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)
+ * and never deletes it as a side effect of anything else.
+ */
+export declare function notSyncedActions({ device }: {
+    device: DeviceNoun;
+}): {
+    retry: string;
+    remove: string;
+};
+/** One of `notSyncedActions`, or showing where the item is kept on the device. */
+export type NotSyncedAction = 'retry' | 'reveal' | 'remove';
+/**
+ * What the person hears when the device couldn't do what they asked for an
+ * item Athena didn't take (its files, not Athena, failed).
+ */
+export declare function notSyncedActionFailed({ action, device, }: {
+    action: NotSyncedAction;
+    device: DeviceNoun;
+}): string;
+/**
+ * The question before deleting such an item's copy on the device, naming the
+ * item: the destructive choice is never the default.
+ */
+export declare function deleteFromDeviceConfirm({ name, device, }: {
+    name: string;
+    device: DeviceNoun;
+}): StatusCopy & {
+    confirm: string;
+    cancel: string;
+};

package/dist/agent-runtime/src/offline-status.js

@@ -0,0 +1,36 @@
+const UNCONFIRMED_EDITS_STALL_MS = 15e3;
+const AVAILABLE_AGAIN = "It’s available again when you’re back online.";
+const NEEDS_CONNECTION = {
+  label: "Needs a connection",
+  detail: `This needs Athena. ${AVAILABLE_AGAIN}`
+};
+function attachmentNeedsConnection({
+  kind,
+  messagesWait
+}) {
+  const attaching = `Attaching ${"a file"} needs Athena. ${AVAILABLE_AGAIN}`;
+  return messagesWait ? `You can still send your message: it goes when Athena is back. ${attaching}` : attaching;
+}
+function heldExtras(withQuote) {
+  return withQuote ? "an attachment or a quote" : "an attachment";
+}
+function attachedMessageNeedsConnection({
+  withQuote = false
+} = {}) {
+  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${withQuote ? "it" : "the attachment"} to send the text.`;
+}
+function attachedMessageBehindWaiting({
+  withQuote = false
+} = {}) {
+  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(
+    withQuote
+  )} can’t wait behind them, so send it once they’ve gone.`;
+}
+export {
+  NEEDS_CONNECTION,
+  UNCONFIRMED_EDITS_STALL_MS,
+  attachedMessageBehindWaiting,
+  attachedMessageNeedsConnection,
+  attachmentNeedsConnection
+};
+//# sourceMappingURL=offline-status.js.map

package/dist/agent-runtime/src/offline-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-status.js","sources":["../../../../agent-runtime/src/offline-status.ts"],"sourcesContent":["/**\n * Athena's offline language: the one set of states and words every app uses to\n * say where the person stands when the network, or Athena, is out of reach —\n * Olympus, the desktop app, the phone app, the Chrome extension and the Office\n * add-in.\n *\n * The rule the words follow: say what still works before what doesn't. Work\n * done while Athena can't be reached is kept on the device and syncs when\n * Athena is back, so every message leads with that promise. Nothing here is\n * shown while Athena answers and nothing waits; the \"back\" messages are brief.\n *\n * Pure strings and small functions, no UI library: each app draws them its own\n * way (a banner, a header chip, a tooltip, a sheet). Reachability itself is\n * each app's own (the browser's or OS's online flag AND agora answering its\n * health read); this module only names the result.\n */\n\n/** Where the app stands with Athena. */\nexport type ConnectionState =\n  /** Athena answers. Nothing is shown. */\n  | 'online'\n  /** The device has no network. */\n  | 'offline'\n  /** The network is up but Athena doesn't answer. */\n  | 'unreachable'\n  /** Athena answers again and what waited is being sent. */\n  | 'reconnecting'\n  /** Just back, and everything that waited was sent. Shown briefly. */\n  | 'synced';\n\n/** Where one document's edits stand, for the chip in its header. */\nexport type DocumentSyncState =\n  /** In Athena. */\n  | 'saved'\n  /** Being sent to Athena. */\n  | 'saving'\n  /** Kept on this device while Athena can't be reached; syncs when it is back. */\n  | 'on-device'\n  /** Kept only while this tab or app stays open (no device storage); syncs when Athena is back. */\n  | 'in-memory'\n  /** Sending what was kept on this device. */\n  | 'syncing'\n  /** Some changes overlap with Athena's version: the person chooses. */\n  | 'needs-review'\n  /** The document can no longer take these edits (access or state changed): kept, not sent. */\n  | 'view-only'\n  /**\n   * Athena answers but isn't taking this document's changes for now: it holds the document while it\n   * repairs it, or hasn't confirmed the latest changes for longer than usual (`SavingDelayCause`\n   * says which). Kept, and saved once Athena takes them. Never said while Athena can't be reached:\n   * that is `on-device` or `in-memory`.\n   */\n  | 'delayed';\n\n/** Why a document's saving is delayed while Athena answers (`DocumentSyncState` `delayed`). */\nexport type SavingDelayCause =\n  /** Athena holds the document while it repairs it, and takes no changes to it until then. */\n  | 'repairing'\n  /** Athena hasn't confirmed the latest changes for longer than usual. */\n  | 'unconfirmed';\n\n/** How a sentence names the device the person is on. */\nexport type DeviceNoun =\n  | 'this browser'\n  | 'this Mac'\n  | 'this computer'\n  | 'this phone'\n  | 'this tablet'\n  | 'this device';\n\n/**\n * What the app really keeps of work done while Athena can't be reached, so the\n * words never promise more: `device` (stored on the device, survives closing),\n * `memory` (kept only while this tab or app stays open: a tenant that turns\n * device copies off, or storage the app can't open), `none` (a surface that\n * keeps no work offline at all, like the Chrome side panel).\n */\nexport type OfflineKeeping = 'device' | 'memory' | 'none';\n\n/** A title and the one line under it (a banner, a sheet, a tooltip's heading). */\nexport interface StatusCopy {\n  title: string;\n  detail: string;\n}\n\n/** A short label for a chip or a disabled control, and its one-line explanation. */\nexport interface LabelCopy {\n  label: string;\n  detail: string;\n}\n\nfunction plural(count: number, one: string, many: string): string {\n  return `${count} ${count === 1 ? one : many}`;\n}\n\n/** What a tab or an app is called when work lasts only while it stays open. */\nfunction openContainer(device: DeviceNoun): string {\n  return device === 'this browser' ? 'this tab' : 'the app';\n}\n\n/** The promise after \"You're offline\" / \"Can't reach Athena\", honest to what is kept. */\nfunction keepingPromise({\n  keeping,\n  device,\n  when,\n}: {\n  keeping: OfflineKeeping;\n  device: DeviceNoun;\n  when: string;\n}): string {\n  switch (keeping) {\n    case 'device':\n      return `You can keep working. Changes are saved on ${device} and sync ${when}.`;\n    case 'memory':\n      return `You can keep working, but changes are kept only until you close ${openContainer(device)}. They sync ${when}.`;\n    case 'none':\n      return `You’re still signed in. This reconnects ${when}.`;\n  }\n}\n\n/**\n * The app-wide status line, or `null` while Athena answers and nothing waits.\n * `waiting` counts changes not in Athena yet: while `reconnecting` they are\n * being sent; while `online` they wait for something else (a copy that sends\n * when it is next opened), and the line stays until they are gone.\n * `keeping` is what the app really keeps offline (default `device`). A surface\n * that keeps nothing (`none`) has nothing to sync, so its way back is only\n * \"Back online\", never \"Syncing…\" or \"All changes synced\".\n */\nexport function connectionCopy({\n  state,\n  device,\n  waiting = 0,\n  keeping = 'device',\n}: {\n  state: ConnectionState;\n  device: DeviceNoun;\n  waiting?: number;\n  keeping?: OfflineKeeping;\n}): StatusCopy | null {\n  switch (state) {\n    case 'online':\n      return waiting > 0\n        ? {\n            title: 'Not synced yet',\n            detail: `${plural(waiting, 'change', 'changes')} on ${device} ${waiting === 1 ? 'hasn’t' : 'haven’t'} synced yet.`,\n          }\n        : null;\n    case 'offline':\n      return {\n        title: 'You’re offline',\n        detail: keepingPromise({ keeping, device, when: 'when you’re back online' }),\n      };\n    case 'unreachable':\n      return {\n        title: 'Can’t reach Athena',\n        detail: keepingPromise({ keeping, device, when: 'when Athena is back' }),\n      };\n    case 'reconnecting':\n      if (keeping === 'none') return { title: 'Back online', detail: '' };\n      return {\n        title: 'Back online',\n        detail:\n          waiting > 0 ? `Syncing ${plural(waiting, 'change', 'changes')}…` : 'Syncing…',\n      };\n    case 'synced':\n      return keeping === 'none'\n        ? { title: 'Back online', detail: '' }\n        : { title: 'All changes synced', detail: '' };\n  }\n}\n\n/**\n * The line under \"Saving delayed\": why saving waits, and what is kept meanwhile, never promising\n * more than the app keeps.\n */\nfunction savingDelayedDetail({\n  delay,\n  keeping,\n  device,\n}: {\n  delay: SavingDelayCause;\n  keeping: Exclude<OfflineKeeping, 'none'>;\n  device: DeviceNoun;\n}): string {\n  if (delay === 'repairing') {\n    return keeping === 'memory'\n      ? `You can keep working, but your changes are kept only until you close ${openContainer(device)}. They save once Athena finishes repairing this document.`\n      : `You can keep working. Your changes are kept on ${device} and save once Athena finishes repairing this document.`;\n  }\n  return keeping === 'memory'\n    ? `Athena is taking longer than usual to save your latest changes. They’re kept only until you close ${openContainer(device)}, so keep it open.`\n    : `Athena is taking longer than usual to save your latest changes. They’re kept on ${device} in the meantime.`;\n}\n\n/**\n * The chip in a document's header, and the line it explains itself with. For `delayed`, `delay`\n * says why (default `unconfirmed`) and `keeping` whether the changes are kept on the device or only\n * while the tab or app stays open (default `device`); every other state ignores both.\n */\nexport function documentSyncCopy({\n  state,\n  device,\n  delay = 'unconfirmed',\n  keeping = 'device',\n}: {\n  state: DocumentSyncState;\n  device: DeviceNoun;\n  delay?: SavingDelayCause;\n  keeping?: Exclude<OfflineKeeping, 'none'>;\n}): LabelCopy {\n  switch (state) {\n    case 'saved':\n      return { label: 'Saved', detail: 'Saved to Athena.' };\n    case 'saving':\n      return { label: 'Saving…', detail: 'Saving to Athena.' };\n    case 'on-device':\n      return {\n        label: `Saved on ${device}`,\n        detail: `Saved on ${device}. Your changes sync when Athena is back.`,\n      };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Your changes are kept only until you close ${openContainer(device)}, and save when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending the changes saved on ${device}.` };\n    case 'needs-review':\n      return {\n        label: 'Review changes',\n        detail: 'Some of your changes overlap with changes made in Athena. Choose what to keep.',\n      };\n    case 'view-only':\n      return {\n        label: 'View only',\n        detail: `You can’t edit this anymore. Your changes stay on ${device}.`,\n      };\n    case 'delayed':\n      return { label: 'Saving delayed', detail: savingDelayedDetail({ delay, keeping, device }) };\n  }\n}\n\n/**\n * How long a document's edits may wait unconfirmed on a connection that is up before its saving\n * reads as delayed (`delayed`, `unconfirmed`), and before its room asks Keryx why: the stall window\n * every editor shares (`ACK_STALL_MS` in `@athenaintel/asset-host/local-updates`, which Olympus's\n * `room-sync-store.test.ts` holds equal).\n */\nexport const UNCONFIRMED_EDITS_STALL_MS = 15_000;\n\n/**\n * Whether a document's saving is delayed, and why (`DocumentSyncState` `delayed`): only while Athena\n * answers and the document's room is connected; `repairing` when Keryx refuses the room's writes\n * (quarantined while it is repaired: said at once, before anything waits), `unconfirmed` once its\n * edits have stayed unconfirmed past {@link UNCONFIRMED_EDITS_STALL_MS}; `null` otherwise. Every\n * app's chip asks it after a hold and after edits kept without a connection, and ahead of syncing\n * and saving, so a room that refuses writes never spins and being offline is never a delay.\n */\nexport function savingDelayCause({\n  reachable,\n  connected,\n  writesRefused,\n  unconfirmedStalled,\n}: {\n  /** Athena answers (the app's reachability, never the socket alone). */\n  reachable: boolean;\n  /** The document's room is connected. */\n  connected: boolean;\n  /** Keryx's document status says the room takes no writes for now. */\n  writesRefused: boolean;\n  /** Local edits have waited unconfirmed past the stall window on this connection. */\n  unconfirmedStalled: boolean;\n}): SavingDelayCause | null {\n  if (!reachable || !connected) return null;\n  if (writesRefused) return 'repairing';\n  return unconfirmedStalled ? 'unconfirmed' : null;\n}\n\n/** When something that needs Athena works again (the second half of `NEEDS_CONNECTION`'s line). */\nconst AVAILABLE_AGAIN = 'It’s available again when you’re back online.';\n\n/**\n * The reason on a control that needs Athena (share, run, upload, invite…),\n * shown disabled while Athena can't be reached rather than failing when used.\n */\nexport const NEEDS_CONNECTION: LabelCopy = {\n  label: 'Needs a connection',\n  detail: `This needs Athena. ${AVAILABLE_AGAIN}`,\n};\n\n/** What a composer was given to attach: a photo (from the phone's library or camera) or any file. */\nexport type AttachmentKind = 'photo' | 'file';\n\n/**\n * What a composer says when a photo or file is picked, pasted or dropped while\n * Athena can't be reached. It isn't attached: only Athena can take the upload.\n * In a chat whose messages wait to be sent meanwhile (`messagesWait`: the chat\n * keeps an outbox), the message itself still goes, so that comes first. Where\n * nothing waits (the Chrome side panel, a launcher that keeps its draft), it\n * says only when attaching works again, as `NEEDS_CONNECTION` does.\n */\nexport function attachmentNeedsConnection({\n  kind,\n  messagesWait,\n}: {\n  kind: AttachmentKind;\n  messagesWait: boolean;\n}): string {\n  const attaching = `Attaching ${kind === 'photo' ? 'a photo' : 'a file'} needs Athena. ${AVAILABLE_AGAIN}`;\n  return messagesWait\n    ? `You can still send your message: it goes when Athena is back. ${attaching}`\n    : attaching;\n}\n\n/** What a sent message carries besides its text that can't wait for Athena. */\nfunction heldExtras(withQuote: boolean): string {\n  return withQuote ? 'an attachment or a quote' : 'an attachment';\n}\n\n/**\n * What a composer says when a message is sent while Athena can't be reached\n * with an attachment that never reached Athena (or, `withQuote`, a quote the\n * chat can't keep waiting). Its text could wait in the chat outbox; the\n * attachment can't, so the draft stays as it is.\n */\nexport function attachedMessageNeedsConnection({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Your text can wait and go when Athena is back, but ${heldExtras(withQuote)} can’t. Remove ${\n    withQuote ? 'it' : 'the attachment'\n  } to send the text.`;\n}\n\n/**\n * What a composer says when a message with an attachment (or, `withQuote`, a\n * quote) is sent while messages written when Athena couldn't be reached still\n * wait to go: those go first, and this one can't wait behind them.\n */\nexport function attachedMessageBehindWaiting({\n  withQuote = false,\n}: {\n  withQuote?: boolean;\n} = {}): string {\n  return `Messages you wrote while Athena couldn’t be reached go first. A message with ${heldExtras(\n    withQuote\n  )} can’t wait behind them, so send it once they’ve gone.`;\n}\n\n/**\n * The reason on New Presentation while Athena can't be reached, in a workspace\n * whose new presentations start from its design system's template: a\n * presentation made offline starts blank, and only Athena can copy the\n * template, so none is made until it can.\n */\nexport const NEW_PRESENTATION_NEEDS_TEMPLATE: LabelCopy = {\n  label: 'Needs a connection',\n  detail:\n    'New presentations in this workspace start from its design template, which needs Athena. You can make one when you’re back online.',\n};\n\n/**\n * Whether an item opens without a connection on this device, for lists.\n * `canKeep` says whether opening it online would keep a copy here (the\n * deployment allows device copies and the item's type is one that is kept):\n * only then is the person told to open it once.\n */\nexport function offlineAvailabilityCopy({\n  available,\n  canKeep,\n  device,\n}: {\n  available: boolean;\n  canKeep: boolean;\n  device: DeviceNoun;\n}): LabelCopy {\n  if (available) {\n    return { label: 'Available offline', detail: `Opens without a connection on ${device}.` };\n  }\n  return canKeep\n    ? {\n        label: 'Not available offline',\n        detail: `Open it once while online to keep it on ${device}.`,\n      }\n    : { label: 'Not available offline', detail: 'This opens only with a connection.' };\n}\n\n/**\n * The one-time explainer shown the first time the person goes offline, on a\n * surface that keeps work there (`keeping` `device`). A surface that keeps\n * nothing (`none`: the Chrome side panel, the Office task pane) shows no\n * explainer; its status line already says all that holds.\n */\nexport function firstOfflineExplainer({ device }: { device: DeviceNoun }): StatusCopy & {\n  action: string;\n} {\n  return {\n    title: 'You can keep working offline',\n    detail: `Documents you’ve opened recently keep working on ${device}. Your changes sync when you’re back online.`,\n    action: 'Got it',\n  };\n}\n\n/**\n * The summary heading of the one \"Waiting to sync\" list, from what waits on\n * the device; `null` when nothing does.\n */\nexport function waitingSummary({\n  changes = 0,\n  messages = 0,\n  recordings = 0,\n}: {\n  changes?: number;\n  messages?: number;\n  recordings?: number;\n}): string | null {\n  const parts = [\n    changes > 0 ? plural(changes, 'change', 'changes') : null,\n    messages > 0 ? plural(messages, 'message', 'messages') : null,\n    recordings > 0 ? plural(recordings, 'recording', 'recordings') : null,\n  ].filter((part): part is string => part !== null);\n  return parts.length === 0 ? null : `Waiting to sync: ${parts.join(', ')}`;\n}\n\n/**\n * Where one item in the \"Waiting to sync\" list stands: a change, a message or a\n * recording made while Athena couldn't be reached.\n */\nexport type WaitingItemState =\n  /** Saved on the device; it syncs when Athena is back. */\n  | 'waiting'\n  /** Being sent to Athena now. */\n  | 'syncing'\n  /**\n   * Kept only while this tab or app stays open: it couldn't be saved on the\n   * device (the organization keeps nothing on devices, or storage failed).\n   */\n  | 'in-memory'\n  /**\n   * Saved on the device in something that isn't open (a document closed before\n   * its edits synced, one made offline): it syncs when it is next opened with a\n   * connection (opening it offline sends nothing).\n   */\n  | 'when-opened'\n  /** Made in another workspace: it syncs once that workspace is open again, with a connection. */\n  | 'other-workspace'\n  /** It doesn't go on its own: the person chooses (a message that waited more than a day). */\n  | 'needs-you'\n  /** Athena didn't take it: the app adds why, and what the person can do about it. */\n  | 'not-synced';\n\n/** The state of one item in the \"Waiting to sync\" list, and the line that explains it. */\nexport function waitingItemCopy({\n  state,\n  device,\n}: {\n  state: WaitingItemState;\n  device: DeviceNoun;\n}): LabelCopy {\n  switch (state) {\n    case 'waiting':\n      return {\n        label: 'Waiting to sync',\n        detail: `Saved on ${device}. It syncs when Athena is back.`,\n      };\n    case 'syncing':\n      return { label: 'Syncing…', detail: `Sending what was saved on ${device}.` };\n    case 'in-memory':\n      return {\n        label: 'Not saved yet',\n        detail: `Kept only until you close ${openContainer(device)}. It syncs when Athena is back.`,\n      };\n    case 'when-opened':\n      return {\n        label: 'Not synced yet',\n        detail: `Saved on ${device}. It syncs when you next open it with a connection.`,\n      };\n    case 'other-workspace':\n      return {\n        label: 'Waiting for its workspace',\n        detail: 'It syncs once you’re in the workspace it was made in, with a connection.',\n      };\n    case 'needs-you':\n      return { label: 'Waiting for you', detail: 'Open it to choose what happens to it.' };\n    case 'not-synced':\n      return { label: 'Couldn’t sync', detail: 'Athena didn’t take it.' };\n  }\n}\n\n/** The headings of the \"Waiting to sync\" list, one per kind of item. */\nexport const WAITING_SECTION_TITLES = {\n  changes: 'Changes',\n  messages: 'Messages',\n  recordings: 'Recordings',\n} as const;\n\n/**\n * What the person can do with an item Athena didn't take (`not-synced`) in the\n * \"Waiting to sync\" list: send it again, or delete the copy on the device. That\n * copy is the item's only one, so the app asks first (`deleteFromDeviceConfirm`)\n * and never deletes it as a side effect of anything else.\n */\nexport function notSyncedActions({ device }: { device: DeviceNoun }): {\n  retry: string;\n  remove: string;\n} {\n  return { retry: 'Try again', remove: `Delete from ${device}` };\n}\n\n/** One of `notSyncedActions`, or showing where the item is kept on the device. */\nexport type NotSyncedAction = 'retry' | 'reveal' | 'remove';\n\n/**\n * What the person hears when the device couldn't do what they asked for an\n * item Athena didn't take (its files, not Athena, failed).\n */\nexport function notSyncedActionFailed({\n  action,\n  device,\n}: {\n  action: NotSyncedAction;\n  device: DeviceNoun;\n}): string {\n  switch (action) {\n    case 'retry':\n      return 'Couldn’t send it again. Try again in a moment.';\n    case 'reveal':\n      return `Couldn’t show where it’s kept on ${device}.`;\n    case 'remove':\n      return `Couldn’t delete it from ${device}.`;\n  }\n}\n\n/**\n * The question before deleting such an item's copy on the device, naming the\n * item: the destructive choice is never the default.\n */\nexport function deleteFromDeviceConfirm({\n  name,\n  device,\n}: {\n  name: string;\n  device: DeviceNoun;\n}): StatusCopy & { confirm: string; cancel: string } {\n  return {\n    title: `Delete “${name}” from ${device}?`,\n    detail: 'Athena didn’t take it, so this is its only copy. Deleting it can’t be undone.',\n    confirm: 'Delete',\n    cancel: 'Cancel',\n  };\n}\n"],"names":[],"mappings":"AAyPO,MAAM,6BAA6B;AA+B1C,MAAM,kBAAkB;AAMjB,MAAM,mBAA8B;AAAA,EACzC,OAAO;AAAA,EACP,QAAQ,sBAAsB,eAAe;AAC/C;AAaO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AACF,GAGW;AACT,QAAM,YAAY,aAA4C,QAAQ,kBAAkB,eAAe;AACvG,SAAO,eACH,iEAAiE,SAAS,KAC1E;AACN;AAGA,SAAS,WAAW,WAA4B;AAC9C,SAAO,YAAY,6BAA6B;AAClD;AAQO,SAAS,+BAA+B;AAAA,EAC7C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,sDAAsD,WAAW,SAAS,CAAC,kBAChF,YAAY,OAAO,gBACrB;AACF;AAOO,SAAS,6BAA6B;AAAA,EAC3C,YAAY;AACd,IAEI,IAAY;AACd,SAAO,gFAAgF;AAAA,IACrF;AAAA,EAAA,CACD;AACH;"}

package/dist/agent-runtime/src/queue.cjs

@@ -10,9 +10,6 @@ function queueEntryText(parts) {
 function isQueueEntryUnsettled(entry) {
   return entry.meta === void 0;
 }
-function readPrioritizedQueueIds(raw) {
-  return Array.isArray(raw) ? raw.filter((id) => typeof id === "string") : [];
-}
 function queueLaneFlags(status) {
   return {
     isRunning: status === "running",
@@ -26,10 +23,6 @@ function buildStatewireQueueRows(options) {
     ...queue.map((item) => ({ item, lane: "queue" }))
   ];
 }
-function showQueueRowSendNow(options) {
-  const { lane, index, isRunning, isContinuable } = options;
-  return lane === "queue" && (isContinuable || isRunning && index === 0);
-}
 function showQueueRowSteer(options) {
   return options.lane === "queue" && options.isRunning;
 }
@@ -85,8 +78,6 @@ exports.isFailedSendEntryRace = isFailedSendEntryRace;
 exports.isQueueEntryUnsettled = isQueueEntryUnsettled;
 exports.queueEntryText = queueEntryText;
 exports.queueLaneFlags = queueLaneFlags;
-exports.readPrioritizedQueueIds = readPrioritizedQueueIds;
-exports.showQueueRowSendNow = showQueueRowSendNow;
 exports.showQueueRowSteer = showQueueRowSteer;
 exports.userStopBlocksQueueAutoContinue = userStopBlocksQueueAutoContinue;
 //# sourceMappingURL=queue.cjs.map

package/dist/agent-runtime/src/queue.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"queue.cjs","sources":["../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_COMPOSER_MARKDOWN_KEY } from './composer-markdown';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\n/**\n * Whether a row offers \"Steer\" (`run/steer-live`): queue-lane rows while a run\n * is live. Steer folds the entry into the RUNNING turn at its next model call\n * — after the in-flight tool chain, never mid-tool — and the run goes on with\n * it in context (ChatGPT's and Codex's Steer, versus Queue). Nothing is\n * cancelled and no second run starts, so every queued row qualifies, not just\n * the head. At rest there is no turn to steer: Send now already dispatches.\n */\nexport function showQueueRowSteer(options: {\n  lane: 'queue' | 'steer';\n  isRunning: boolean;\n}): boolean {\n  return options.lane === 'queue' && options.isRunning;\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n  /**\n   * The edited message's metadata, replacing the entry's (the host replaces\n   * the queued message whole). Omitted, the entry's metadata is kept, minus a\n   * composer markdown that described the old text.\n   */\n  metadata?: Readonly<Record<string, unknown>> | undefined;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  const textChanged: boolean = text !== queueEntryText(item.parts);\n  const previous: Readonly<Record<string, unknown>> | undefined = nonEmpty(item.metadata);\n  const next: Readonly<Record<string, unknown>> | undefined = nonEmpty(\n    options.metadata !== undefined\n      ? options.metadata\n      : textChanged\n        ? withoutComposerMarkdown(item.metadata)\n        : item.metadata,\n  );\n  if (\n    !text.trim() ||\n    runId === null ||\n    (!textChanged && stableJson(next ?? null) === stableJson(previous ?? null))\n  ) {\n    return null;\n  }\n  // An entry that had metadata and keeps none sends an empty object: the\n  // optimistic lane keeps an entry's metadata when the command carries none,\n  // and would go on showing the old composer markdown until the host answers.\n  const metadata: Readonly<Record<string, unknown>> | undefined =\n    next ?? (previous === undefined ? undefined : {});\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(metadata === undefined ? {} : { metadata: { ...metadata } }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/** `metadata` unless it is empty. */\nfunction nonEmpty(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  return metadata !== undefined && Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\n/** JSON with object keys sorted, so equal metadata compares equal whatever its key order. */\nfunction stableJson(value: unknown): string {\n  const sorted = (entry: unknown): unknown =>\n    Array.isArray(entry)\n      ? entry.map(sorted)\n      : typeof entry === 'object' && entry !== null\n        ? Object.fromEntries(\n            Object.keys(entry)\n              .sort()\n              .map((key) => [key, sorted((entry as Record<string, unknown>)[key])]),\n          )\n        : entry;\n  return JSON.stringify(sorted(value));\n}\n\n/** Entry metadata without a composer markdown, `undefined` when nothing is left. */\nfunction withoutComposerMarkdown(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  if (metadata === undefined || !(DEEP_AGENT_COMPOSER_MARKDOWN_KEY in metadata)) return metadata;\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _stale, ...rest } = metadata;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":["DEEP_AGENT_COMPOSER_MARKDOWN_KEY","ATHENA_RUN_MARKER_CANCELLED","isServerUpdateStopSource"],"mappings":"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"}
+{"version":3,"file":"queue.cjs","sources":["../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_COMPOSER_MARKDOWN_KEY } from './composer-markdown';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\n/**\n * Whether a row offers \"Steer\" (`run/steer-live`): queue-lane rows while a run\n * is live. Steer folds the entry into the RUNNING turn at its next model call\n * — after the in-flight tool chain, never mid-tool — and the run goes on with\n * it in context (ChatGPT's and Codex's Steer, versus Queue). Nothing is\n * cancelled and no second run starts, so every queued row qualifies, not just\n * the head. At rest there is no turn to steer: Send now already dispatches.\n */\nexport function showQueueRowSteer(options: {\n  lane: 'queue' | 'steer';\n  isRunning: boolean;\n}): boolean {\n  return options.lane === 'queue' && options.isRunning;\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n  /**\n   * The edited message's metadata, replacing the entry's (the host replaces\n   * the queued message whole). Omitted, the entry's metadata is kept, minus a\n   * composer markdown that described the old text.\n   */\n  metadata?: Readonly<Record<string, unknown>> | undefined;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  const textChanged: boolean = text !== queueEntryText(item.parts);\n  const previous: Readonly<Record<string, unknown>> | undefined = nonEmpty(item.metadata);\n  const next: Readonly<Record<string, unknown>> | undefined = nonEmpty(\n    options.metadata !== undefined\n      ? options.metadata\n      : textChanged\n        ? withoutComposerMarkdown(item.metadata)\n        : item.metadata,\n  );\n  if (\n    !text.trim() ||\n    runId === null ||\n    (!textChanged && stableJson(next ?? null) === stableJson(previous ?? null))\n  ) {\n    return null;\n  }\n  // An entry that had metadata and keeps none sends an empty object: the\n  // optimistic lane keeps an entry's metadata when the command carries none,\n  // and would go on showing the old composer markdown until the host answers.\n  const metadata: Readonly<Record<string, unknown>> | undefined =\n    next ?? (previous === undefined ? undefined : {});\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(metadata === undefined ? {} : { metadata: { ...metadata } }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/** `metadata` unless it is empty. */\nfunction nonEmpty(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  return metadata !== undefined && Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\n/** JSON with object keys sorted, so equal metadata compares equal whatever its key order. */\nfunction stableJson(value: unknown): string {\n  const sorted = (entry: unknown): unknown =>\n    Array.isArray(entry)\n      ? entry.map(sorted)\n      : typeof entry === 'object' && entry !== null\n        ? Object.fromEntries(\n            Object.keys(entry)\n              .sort()\n              .map((key) => [key, sorted((entry as Record<string, unknown>)[key])]),\n          )\n        : entry;\n  return JSON.stringify(sorted(value));\n}\n\n/** Entry metadata without a composer markdown, `undefined` when nothing is left. */\nfunction withoutComposerMarkdown(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  if (metadata === undefined || !(DEEP_AGENT_COMPOSER_MARKDOWN_KEY in metadata)) return metadata;\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _stale, ...rest } = metadata;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":["DEEP_AGENT_COMPOSER_MARKDOWN_KEY","ATHENA_RUN_MARKER_CANCELLED","isServerUpdateStopSource"],"mappings":"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"}

package/dist/agent-runtime/src/queue.js

@@ -8,9 +8,6 @@ function queueEntryText(parts) {
 function isQueueEntryUnsettled(entry) {
   return entry.meta === void 0;
 }
-function readPrioritizedQueueIds(raw) {
-  return Array.isArray(raw) ? raw.filter((id) => typeof id === "string") : [];
-}
 function queueLaneFlags(status) {
   return {
     isRunning: status === "running",
@@ -24,10 +21,6 @@ function buildStatewireQueueRows(options) {
     ...queue.map((item) => ({ item, lane: "queue" }))
   ];
 }
-function showQueueRowSendNow(options) {
-  const { lane, index, isRunning, isContinuable } = options;
-  return lane === "queue" && (isContinuable || isRunning && index === 0);
-}
 function showQueueRowSteer(options) {
   return options.lane === "queue" && options.isRunning;
 }
@@ -84,8 +77,6 @@ export {
   isQueueEntryUnsettled,
   queueEntryText,
   queueLaneFlags,
-  readPrioritizedQueueIds,
-  showQueueRowSendNow,
   showQueueRowSteer,
   userStopBlocksQueueAutoContinue
 };

package/dist/agent-runtime/src/queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"queue.js","sources":["../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_COMPOSER_MARKDOWN_KEY } from './composer-markdown';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\n/**\n * Whether a row offers \"Steer\" (`run/steer-live`): queue-lane rows while a run\n * is live. Steer folds the entry into the RUNNING turn at its next model call\n * — after the in-flight tool chain, never mid-tool — and the run goes on with\n * it in context (ChatGPT's and Codex's Steer, versus Queue). Nothing is\n * cancelled and no second run starts, so every queued row qualifies, not just\n * the head. At rest there is no turn to steer: Send now already dispatches.\n */\nexport function showQueueRowSteer(options: {\n  lane: 'queue' | 'steer';\n  isRunning: boolean;\n}): boolean {\n  return options.lane === 'queue' && options.isRunning;\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n  /**\n   * The edited message's metadata, replacing the entry's (the host replaces\n   * the queued message whole). Omitted, the entry's metadata is kept, minus a\n   * composer markdown that described the old text.\n   */\n  metadata?: Readonly<Record<string, unknown>> | undefined;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  const textChanged: boolean = text !== queueEntryText(item.parts);\n  const previous: Readonly<Record<string, unknown>> | undefined = nonEmpty(item.metadata);\n  const next: Readonly<Record<string, unknown>> | undefined = nonEmpty(\n    options.metadata !== undefined\n      ? options.metadata\n      : textChanged\n        ? withoutComposerMarkdown(item.metadata)\n        : item.metadata,\n  );\n  if (\n    !text.trim() ||\n    runId === null ||\n    (!textChanged && stableJson(next ?? null) === stableJson(previous ?? null))\n  ) {\n    return null;\n  }\n  // An entry that had metadata and keeps none sends an empty object: the\n  // optimistic lane keeps an entry's metadata when the command carries none,\n  // and would go on showing the old composer markdown until the host answers.\n  const metadata: Readonly<Record<string, unknown>> | undefined =\n    next ?? (previous === undefined ? undefined : {});\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(metadata === undefined ? {} : { metadata: { ...metadata } }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/** `metadata` unless it is empty. */\nfunction nonEmpty(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  return metadata !== undefined && Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\n/** JSON with object keys sorted, so equal metadata compares equal whatever its key order. */\nfunction stableJson(value: unknown): string {\n  const sorted = (entry: unknown): unknown =>\n    Array.isArray(entry)\n      ? entry.map(sorted)\n      : typeof entry === 'object' && entry !== null\n        ? Object.fromEntries(\n            Object.keys(entry)\n              .sort()\n              .map((key) => [key, sorted((entry as Record<string, unknown>)[key])]),\n          )\n        : entry;\n  return JSON.stringify(sorted(value));\n}\n\n/** Entry metadata without a composer markdown, `undefined` when nothing is left. */\nfunction withoutComposerMarkdown(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  if (metadata === undefined || !(DEEP_AGENT_COMPOSER_MARKDOWN_KEY in metadata)) return metadata;\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _stale, ...rest } = metadata;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"queue.js","sources":["../../../../agent-runtime/src/queue.ts"],"sourcesContent":["/**\n * Derivations for the server-owned statewire queue and steer lanes, shared by\n * every queued-messages tray (Olympus, the React SDK, the Chrome extension).\n *\n * The queue is SERVER-owned: statewire surfaces it on the runs projection.\n * \"Send now\" moves an item into the steer lane (`run/steer` — the host stops\n * the run and dispatches it once the run settles; on a stopped/errored thread\n * the same move dispatches immediately as a stop-/error-continue run) and\n * remove issues `run/dequeue`. While the thread rests stopped/errored,\n * stranded steer-lane entries list ahead of the queue — they dispatch first,\n * as one batch, so they carry Remove but no per-row Send now.\n *\n * Pure helpers only: the host component reads `useStatewireRuns()` and\n * `useDeepAgentThreadStatus()` itself (both mockable per surface) and passes\n * the values in.\n */\n\nimport type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_COMPOSER_MARKDOWN_KEY } from './composer-markdown';\nimport { ATHENA_RUN_MARKER_CANCELLED, isServerUpdateStopSource } from './messages';\nimport type { DeepAgentThreadStatus } from './thread-status';\n\n/** The text content of a queued entry (non-text parts render as fallbacks). */\nexport function queueEntryText(\n  parts: readonly { type: string; text?: string }[],\n): string {\n  return parts\n    .flatMap((part) =>\n      part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],\n    )\n    .join('\\n\\n');\n}\n\n/**\n * Whether a lane entry is still awaiting its send's settle: the host stamps\n * `meta` on every entry it admits (`_op_meta` — submitter and contextSync\n * snapshot), so a meta-less entry is this client's own optimistic fold. The\n * send is still in flight and can still be refused (billing gate, auth,\n * reconnect), which the tray must not render as an accepted queue position.\n */\nexport function isQueueEntryUnsettled(entry: StatewireThread.RunsQueueEntry): boolean {\n  return entry.meta === undefined;\n}\n\n/**\n * The ids of queued entries the user prioritized (⚡ — `run/prioritize`), as\n * the host records them in its durable `prioritizedQueueIds` state. A\n * prioritized entry heads the queue lane and the live run ends at its next\n * model-call boundary to deliver it, so trays render these rows lit and offer\n * \"Remove priority\" instead of \"Prioritize\". Tolerates the key being absent\n * (a thread that never prioritized, a pre-feature host) and ignores anything\n * that is not a string id.\n */\nexport function readPrioritizedQueueIds(raw: unknown): readonly string[] {\n  return Array.isArray(raw)\n    ? raw.filter((id): id is string => typeof id === 'string')\n    : [];\n}\n\nexport interface QueueLaneFlags {\n  isRunning: boolean;\n  /** A stopped/errored thread can continue with its queued work. */\n  isContinuable: boolean;\n}\n\n/** The thread-status split every queue tray keys its affordances on. */\nexport function queueLaneFlags(status: DeepAgentThreadStatus): QueueLaneFlags {\n  return {\n    isRunning: status === 'running',\n    isContinuable: status === 'stopped' || status === 'error',\n  };\n}\n\nexport interface StatewireQueueRow {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n}\n\n/**\n * The rows a queue tray renders, in dispatch order: stranded steer-lane\n * entries first (only while the thread rests continuable — during a run they\n * already render in the message list), then the queue lane.\n */\nexport function buildStatewireQueueRows(options: {\n  queue: readonly StatewireThread.RunsQueueEntry[];\n  steerQueue: readonly StatewireThread.RunsQueueEntry[];\n  isContinuable: boolean;\n}): StatewireQueueRow[] {\n  const { queue, steerQueue, isContinuable } = options;\n  return [\n    ...(isContinuable\n      ? steerQueue.map((item) => ({ item, lane: 'steer' as const }))\n      : []),\n    ...queue.map((item) => ({ item, lane: 'queue' as const })),\n  ];\n}\n\n/**\n * Whether a row offers \"Send now\": queue-lane rows only (steer entries already\n * dispatch first), every row while the thread rests continuable, and only the\n * head row while a run is live (later rows would jump the queue order).\n */\nexport function showQueueRowSendNow(options: {\n  lane: 'queue' | 'steer';\n  index: number;\n  isRunning: boolean;\n  isContinuable: boolean;\n}): boolean {\n  const { lane, index, isRunning, isContinuable } = options;\n  return lane === 'queue' && (isContinuable || (isRunning && index === 0));\n}\n\n/**\n * Whether a row offers \"Steer\" (`run/steer-live`): queue-lane rows while a run\n * is live. Steer folds the entry into the RUNNING turn at its next model call\n * — after the in-flight tool chain, never mid-tool — and the run goes on with\n * it in context (ChatGPT's and Codex's Steer, versus Queue). Nothing is\n * cancelled and no second run starts, so every queued row qualifies, not just\n * the head. At rest there is no turn to steer: Send now already dispatches.\n */\nexport function showQueueRowSteer(options: {\n  lane: 'queue' | 'steer';\n  isRunning: boolean;\n}): boolean {\n  return options.lane === 'queue' && options.isRunning;\n}\n\nexport type QueueEditCommand =\n  | { type: 'run/steer'; runId: string; message: StatewireThread.UserMessage }\n  | { type: 'run/enqueue'; runId: string; message: StatewireThread.UserMessage };\n\n/**\n * Re-send a queued entry under its own id on its own lane with edited text:\n * the host replaces the queued message's content in place, leaving its queue\n * position and lane untouched (a same-id send never dispatches). The built-in\n * queue client has no update command, so this goes straight to the runs\n * protocol. Returns `null` when there is nothing to send — blank or unchanged\n * text, or no live run entry to address.\n */\nexport function buildQueueEditCommand(options: {\n  item: StatewireThread.RunsQueueEntry;\n  lane: 'queue' | 'steer';\n  runId: string | null;\n  text: string;\n  /**\n   * The edited message's metadata, replacing the entry's (the host replaces\n   * the queued message whole). Omitted, the entry's metadata is kept, minus a\n   * composer markdown that described the old text.\n   */\n  metadata?: Readonly<Record<string, unknown>> | undefined;\n}): QueueEditCommand | null {\n  const { item, lane, runId, text } = options;\n  const textChanged: boolean = text !== queueEntryText(item.parts);\n  const previous: Readonly<Record<string, unknown>> | undefined = nonEmpty(item.metadata);\n  const next: Readonly<Record<string, unknown>> | undefined = nonEmpty(\n    options.metadata !== undefined\n      ? options.metadata\n      : textChanged\n        ? withoutComposerMarkdown(item.metadata)\n        : item.metadata,\n  );\n  if (\n    !text.trim() ||\n    runId === null ||\n    (!textChanged && stableJson(next ?? null) === stableJson(previous ?? null))\n  ) {\n    return null;\n  }\n  // An entry that had metadata and keeps none sends an empty object: the\n  // optimistic lane keeps an entry's metadata when the command carries none,\n  // and would go on showing the old composer markdown until the host answers.\n  const metadata: Readonly<Record<string, unknown>> | undefined =\n    next ?? (previous === undefined ? undefined : {});\n  const message: StatewireThread.UserMessage = {\n    id: item.id,\n    role: 'user',\n    parts: [{ type: 'text', text }, ...item.parts.filter((part) => part.type !== 'text')],\n    ...(metadata === undefined ? {} : { metadata: { ...metadata } }),\n  };\n  return lane === 'steer'\n    ? { type: 'run/steer', runId, message }\n    : { type: 'run/enqueue', runId, message };\n}\n\n/** `metadata` unless it is empty. */\nfunction nonEmpty(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  return metadata !== undefined && Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\n/** JSON with object keys sorted, so equal metadata compares equal whatever its key order. */\nfunction stableJson(value: unknown): string {\n  const sorted = (entry: unknown): unknown =>\n    Array.isArray(entry)\n      ? entry.map(sorted)\n      : typeof entry === 'object' && entry !== null\n        ? Object.fromEntries(\n            Object.keys(entry)\n              .sort()\n              .map((key) => [key, sorted((entry as Record<string, unknown>)[key])]),\n          )\n        : entry;\n  return JSON.stringify(sorted(value));\n}\n\n/** Entry metadata without a composer markdown, `undefined` when nothing is left. */\nfunction withoutComposerMarkdown(\n  metadata: Readonly<Record<string, unknown>> | undefined,\n): Readonly<Record<string, unknown>> | undefined {\n  if (metadata === undefined || !(DEEP_AGENT_COMPOSER_MARKDOWN_KEY in metadata)) return metadata;\n  const { [DEEP_AGENT_COMPOSER_MARKDOWN_KEY]: _stale, ...rest } = metadata;\n  return Object.keys(rest).length > 0 ? rest : undefined;\n}\n\n/**\n * Grace between observing a stranded settle and auto-promoting the queue\n * head — long enough for the host's own settle bookkeeping (or a status flap\n * during reconnect) to resolve first, short enough to read as \"it just\n * continued\" rather than \"it hung\".\n */\nexport const QUEUE_AUTO_CONTINUE_DELAY_MS = 2_000;\n\n/** Whether the last cancellation marker records a user or client stop. */\nexport function userStopBlocksQueueAutoContinue(options: {\n  marker: string | undefined;\n  source: string | undefined;\n}): boolean {\n  return (\n    options.marker === ATHENA_RUN_MARKER_CANCELLED && !isServerUpdateStopSource(options.source)\n  );\n}\n\n/** `fate (cause)[: message]` — the detail a failed-send row carries. */\nexport function describeQueueSendFailure(\n  failure: StatewireThread.RunsFailedEntry['sendFailure'],\n): string {\n  const message =\n    'message' in failure && failure.message !== undefined ? `: ${failure.message}` : '';\n  return `${failure.fate} (${failure.cause})${message}`;\n}\n\n/**\n * Whether a `retryFailed` / `discardFailed` throw is the covered drop race:\n * statewire drops a failed entry on its own as soon as a canonical update\n * shows the message landed, and acting on a just-dropped entry throws. Both\n * the session record (\"unknown failed command\") and the adapter's projection\n * (\"unknown failed entry\") use this prefix. Nothing is lost in that race — the\n * message already made it and the row is about to disappear — so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return error instanceof Error && error.message.startsWith('statewire: unknown failed');\n}\n"],"names":[],"mappings":";;AAuBO,SAAS,eACd,OACQ;AACR,SAAO,MACJ;AAAA,IAAQ,CAAC,SACR,KAAK,SAAS,UAAU,OAAO,KAAK,SAAS,WAAW,CAAC,KAAK,IAAI,IAAI,CAAA;AAAA,EAAC,EAExE,KAAK,MAAM;AAChB;AASO,SAAS,sBAAsB,OAAgD;AACpF,SAAO,MAAM,SAAS;AACxB;AAwBO,SAAS,eAAe,QAA+C;AAC5E,SAAO;AAAA,IACL,WAAW,WAAW;AAAA,IACtB,eAAe,WAAW,aAAa,WAAW;AAAA,EAAA;AAEtD;AAYO,SAAS,wBAAwB,SAIhB;AACtB,QAAM,EAAE,OAAO,YAAY,cAAA,IAAkB;AAC7C,SAAO;AAAA,IACL,GAAI,gBACA,WAAW,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB,IAC3D,CAAA;AAAA,IACJ,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,MAAM,MAAM,UAAmB;AAAA,EAAA;AAE7D;AAyBO,SAAS,kBAAkB,SAGtB;AACV,SAAO,QAAQ,SAAS,WAAW,QAAQ;AAC7C;AAcO,SAAS,sBAAsB,SAWV;AAC1B,QAAM,EAAE,MAAM,MAAM,OAAO,SAAS;AACpC,QAAM,cAAuB,SAAS,eAAe,KAAK,KAAK;AAC/D,QAAM,WAA0D,SAAS,KAAK,QAAQ;AACtF,QAAM,OAAsD;AAAA,IAC1D,QAAQ,aAAa,SACjB,QAAQ,WACR,cACE,wBAAwB,KAAK,QAAQ,IACrC,KAAK;AAAA,EAAA;AAEb,MACE,CAAC,KAAK,KAAA,KACN,UAAU,QACT,CAAC,eAAe,WAAW,QAAQ,IAAI,MAAM,WAAW,YAAY,IAAI,GACzE;AACA,WAAO;AAAA,EACT;AAIA,QAAM,WACJ,SAAS,aAAa,SAAY,SAAY,CAAA;AAChD,QAAM,UAAuC;AAAA,IAC3C,IAAI,KAAK;AAAA,IACT,MAAM;AAAA,IACN,OAAO,CAAC,EAAE,MAAM,QAAQ,QAAQ,GAAG,KAAK,MAAM,OAAO,CAAC,SAAS,KAAK,SAAS,MAAM,CAAC;AAAA,IACpF,GAAI,aAAa,SAAY,CAAA,IAAK,EAAE,UAAU,EAAE,GAAG,SAAA,EAAS;AAAA,EAAE;AAEhE,SAAO,SAAS,UACZ,EAAE,MAAM,aAAa,OAAO,QAAA,IAC5B,EAAE,MAAM,eAAe,OAAO,QAAA;AACpC;AAGA,SAAS,SACP,UAC+C;AAC/C,SAAO,aAAa,UAAa,OAAO,KAAK,QAAQ,EAAE,SAAS,IAAI,WAAW;AACjF;AAGA,SAAS,WAAW,OAAwB;AAC1C,QAAM,SAAS,CAAC,UACd,MAAM,QAAQ,KAAK,IACf,MAAM,IAAI,MAAM,IAChB,OAAO,UAAU,YAAY,UAAU,OACrC,OAAO;AAAA,IACL,OAAO,KAAK,KAAK,EACd,KAAA,EACA,IAAI,CAAC,QAAQ,CAAC,KAAK,OAAQ,MAAkC,GAAG,CAAC,CAAC,CAAC;AAAA,EAAA,IAExE;AACR,SAAO,KAAK,UAAU,OAAO,KAAK,CAAC;AACrC;AAGA,SAAS,wBACP,UAC+C;AAC/C,MAAI,aAAa,UAAa,EAAE,oCAAoC,UAAW,QAAO;AACtF,QAAM,EAAE,CAAC,gCAAgC,GAAG,QAAQ,GAAG,SAAS;AAChE,SAAO,OAAO,KAAK,IAAI,EAAE,SAAS,IAAI,OAAO;AAC/C;AAQO,MAAM,+BAA+B;AAGrC,SAAS,gCAAgC,SAGpC;AACV,SACE,QAAQ,WAAW,+BAA+B,CAAC,yBAAyB,QAAQ,MAAM;AAE9F;AAGO,SAAS,yBACd,SACQ;AACR,QAAM,UACJ,aAAa,WAAW,QAAQ,YAAY,SAAY,KAAK,QAAQ,OAAO,KAAK;AACnF,SAAO,GAAG,QAAQ,IAAI,KAAK,QAAQ,KAAK,IAAI,OAAO;AACrD;AAWO,SAAS,sBAAsB,OAAyB;AAC7D,SAAO,iBAAiB,SAAS,MAAM,QAAQ,WAAW,2BAA2B;AACvF;"}

package/dist/agent-runtime/src/quota-safe-local-storage-session.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const tap = require("@assistant-ui/tap");
 const storage = require("statewire/storage");
-const react = require("react");
+const require$$0 = require("react");
 const sessionLaneScope = require("./session-lane-scope.cjs");
 const statewireTransport = require("./statewire-transport.cjs");
 const SESSION_PREFIX = "aui:statewire-session:";
@@ -321,7 +321,7 @@ const useQuotaSafeLocalStorageSession = ({
   const sessionKey = key(threadId);
   const storageKey = SESSION_PREFIX + sessionKey;
   const lockName = SESSION_LOCK_PREFIX + sessionKey;
-  const mountedScope = react.useRef({
+  const mountedScope = require$$0.useRef({
     threadId,
     laneKey: sessionKey
   });
@@ -330,9 +330,9 @@ const useQuotaSafeLocalStorageSession = ({
       "statewire: principal changed; remount the account's thread/session"
     );
   }
-  const latestOnDegraded = react.useRef(onStorageDegraded);
+  const latestOnDegraded = require$$0.useRef(onStorageDegraded);
   latestOnDegraded.current = onStorageDegraded;
-  const reportDegradation = react.useMemo(() => {
+  const reportDegradation = require$$0.useMemo(() => {
     const reported = /* @__PURE__ */ new Set();
     return (degradation) => {
       const handler = latestOnDegraded.current;
@@ -354,13 +354,13 @@ const useQuotaSafeLocalStorageSession = ({
   }, []);
   const shared = sharedBackend({ storage: storage$1, locks });
   shared.listeners.add(reportDegradation);
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     shared.listeners.add(reportDegradation);
     return () => {
       shared.listeners.delete(reportDegradation);
     };
   }, [shared, reportDegradation]);
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     const { mounted } = shared;
     mounted.set(storageKey, (mounted.get(storageKey) ?? 0) + 1);
     retireExpiredSessionRecords({
@@ -376,7 +376,7 @@ const useQuotaSafeLocalStorageSession = ({
       else mounted.set(storageKey, count);
     };
   }, [shared, storageKey, ttl, reportDegradation]);
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     let release;
     let disposed = false;
     Promise.resolve(
@@ -398,7 +398,7 @@ const useQuotaSafeLocalStorageSession = ({
       release == null ? void 0 : release();
     };
   }, [locks, storageKey, reportDegradation]);
-  const migrate = react.useCallback(
+  const migrate = require$$0.useCallback(
     (record, current) => {
       const migrated = parkIncompatibleSessionCommands(record, current);
       if (migrated.parked === 0) return migrated.record;
@@ -426,7 +426,7 @@ const useQuotaSafeLocalStorageSession = ({
       onError: (error) => reportDegradation({ operation: "session", key: storageKey, error })
     })
   );
-  return react.useMemo(
+  return require$$0.useMemo(
     () => ({
       ...sessionStorage,
       lock: async (fn) => {