@athenaintel/react 0.57.1 → 0.59.0

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 and stops the live run\n * (`run/send` `preempt` — the run settles and the steer lane dispatches next;\n * on a stopped/errored thread the same move dispatches immediately as a\n * stop-/error-continue run) and 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 type { StatewireClient } from '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 a backend delivery prioritized, as the host\n * records them in its durable `prioritizedQueueIds` state. A prioritized entry\n * heads the queue lane and the live run ends at its next model-call boundary\n * to deliver it, so trays render these rows lit. Tolerates the key being\n * absent and ignores anything 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/send` `steer`): queue-lane rows while a\n * run 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/send';\n  runId: string;\n  behavior: 'steer' | 'queue';\n  message: StatewireThread.UserMessage;\n};\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 { type: 'run/send', runId, behavior: lane, 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(failure: StatewireClient.SendFailure): 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 drop race: the held\n * failed send left the outbox (another tab retried or discarded it, or its\n * retry is already in flight) between the render and the click. The lookup\n * (\"unknown failed entry\") and the outbox verbs (\"outbox: no entry …\",\n * \"outbox: … is in flight\") report it. Nothing is lost in that race, so a tray\n * swallows it (keeping telemetry) instead of crashing the click handler.\n */\nexport function isFailedSendEntryRace(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    (error.message.startsWith('statewire: unknown failed') ||\n      error.message.startsWith('outbox: no entry') ||\n      /^outbox: .* is in flight$/.test(error.message))\n  );\n}\n"],"names":[],"mappings":"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"}

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

@@ -4,13 +4,54 @@ const tap = require("@assistant-ui/tap");
 const storage = require("statewire/storage");
 const require$$0 = require("react");
 const sessionLaneScope = require("./session-lane-scope.cjs");
+const runSend = require("./run-send.cjs");
 const statewireTransport = require("./statewire-transport.cjs");
 const SESSION_PREFIX = "aui:statewire-session:";
 const SESSION_LOCK_PREFIX = "aui:statewire-session-lock:";
 const SESSION_ACTIVE_PREFIX = "aui:statewire-session-active:";
+const TAB_LOCK_PREFIX = "statewire-tab:";
+const NOTIFY_LOCK_PREFIX = "statewire-notify:";
 const DAY_MS = 24 * 60 * 60 * 1e3;
-const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3]);
+const LOCAL_SESSION_RECORD_BYTES = 512 * 1024;
+const READABLE_STORAGE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 6]);
 const browserGlobals = globalThis;
+function sessionPrincipal(subject) {
+  return `user:${subject}`;
+}
+function localStorageSessionKey({
+  namespace,
+  principal,
+  threadId
+}) {
+  return storage.sessionNamespace(namespace, principal) + threadId;
+}
+function adoptUnscopedLocalStorageSessions({
+  namespace,
+  principal,
+  unscopedPrefix,
+  threadId,
+  storage: storage2 = browserGlobals.localStorage
+}) {
+  if (!storage2) return 0;
+  const from = SESSION_PREFIX + unscopedPrefix;
+  let moved = 0;
+  try {
+    const keys = threadId === void 0 ? Array.from({ length: storage2.length }, (_, index) => storage2.key(index)).filter(
+      (key) => (key == null ? void 0 : key.startsWith(from)) === true
+    ) : [from + threadId];
+    for (const key of keys) {
+      const raw = storage2.getItem(key);
+      if (raw === null) continue;
+      const target = SESSION_PREFIX + localStorageSessionKey({ namespace, principal, threadId: key.slice(from.length) });
+      if (target === key || storage2.getItem(target) !== null) continue;
+      storage2.setItem(target, raw);
+      storage2.removeItem(key);
+      moved += 1;
+    }
+  } catch {
+  }
+  return moved;
+}
 function readPersistedFailedSendStamps(sessionKey) {
   const storage2 = browserGlobals.localStorage;
   if (!storage2) return null;
@@ -30,9 +71,12 @@ function readFailedSendStampsFromRecord(record) {
   const lanes = record.lanes && typeof record.lanes === "object" ? record.lanes : {};
   const failed = [
     ...Array.isArray(record.failed) ? record.failed : [],
-    ...Object.values(lanes).flatMap(
-      (lane) => Array.isArray(lane == null ? void 0 : lane.failed) ? lane.failed : []
-    )
+    ...Object.values(lanes).flatMap((lane) => [
+      ...Array.isArray(lane == null ? void 0 : lane.failed) ? lane.failed : [],
+      ...Array.isArray(lane == null ? void 0 : lane.inbox) ? lane.inbox.filter(
+        (entry) => (entry == null ? void 0 : entry.failure) !== void 0
+      ) : []
+    ])
   ];
   for (const entry of failed) {
     const failed2 = entry;
@@ -62,42 +106,73 @@ const replayableOnCurrentWire = (protocol, command, current) => command.produced
   { ...command, produced: { ...command.produced, wire: current.wire } },
   current
 );
+function upgradeLegacyAthenaStatement(protocol, command, current) {
+  if (protocol !== statewireTransport.DEEP_AGENT_STATEWIRE_PROTOCOL || current.protocols === "*") return void 0;
+  const produced = command.produced;
+  if (produced === void 0 || produced.protocols === "*") return void 0;
+  const athena = produced.protocols.find((p) => p.name === protocol);
+  const offer = current.protocols.find((p) => p.name === protocol);
+  if ((athena == null ? void 0 : athena.version) !== statewireTransport.DEEP_AGENT_LEGACY_STATEWIRE_PROTOCOL_VERSION || offer === void 0 || inRange(athena.version, offer))
+    return void 0;
+  const upgraded = runSend.upgradeLegacyRunCommand(command);
+  if (upgraded === null && command.method in runSend.LEGACY_RUN_SEND_BEHAVIORS) return null;
+  return {
+    ...command,
+    ...upgraded ?? {},
+    produced: {
+      ...produced,
+      protocols: produced.protocols.map((p) => p.name === protocol ? offer : p)
+    }
+  };
+}
 function parkIncompatibleSessionCommands(record, current, now = Date.now()) {
   let parked = 0;
   let restamped = 0;
   const lanes = {};
+  const park = (command) => ({
+    id: command.id,
+    method: command.method,
+    params: command.params,
+    ...command.meta !== void 0 && { meta: command.meta },
+    ts: now,
+    ...command.seq !== void 0 && { seq: command.seq },
+    ...command.localMeta !== void 0 && { localMeta: command.localMeta },
+    failure: { fate: "lost", cause: "session-lost" }
+  });
   for (const [protocol, lane] of Object.entries(record.lanes)) {
-    const kept = [];
-    const failed = [];
+    const inbox = [];
     let laneRestamped = 0;
-    for (const command of lane.commands) {
-      if (storedCommandCompatible(protocol, command, current)) {
-        kept.push(command);
-        continue;
+    const sort = (stored) => stored.flatMap((original) => {
+      const upgraded = upgradeLegacyAthenaStatement(protocol, original, current);
+      if (upgraded === null) {
+        inbox.push(park(original));
+        return [];
+      }
+      const command = upgraded ?? original;
+      if (upgraded !== void 0 && storedCommandCompatible(protocol, command, current)) {
+        laneRestamped += 1;
+        return [command];
       }
+      if (storedCommandCompatible(protocol, command, current))
+        return [command];
       if (replayableOnCurrentWire(protocol, command, current)) {
-        kept.push({ ...command, produced: current });
         laneRestamped += 1;
-        continue;
+        return [{ ...command, produced: current }];
       }
-      failed.push({
-        protocol,
-        produced: current,
-        command: command.method,
-        params: command.params,
-        ...command.meta !== void 0 && { meta: command.meta },
-        failure: { fate: "lost", cause: "session-lost" },
-        ts: now,
-        seq: command.seq
-      });
-    }
-    parked += failed.length;
+      inbox.push(park(command));
+      return [];
+    });
+    const commands = sort(lane.commands);
+    const outbox = lane.outbox === void 0 ? void 0 : sort(lane.outbox);
+    parked += inbox.length;
     restamped += laneRestamped;
-    lanes[protocol] = failed.length === 0 && laneRestamped === 0 ? lane : {
-      ...lane,
-      commands: kept,
-      ...(failed.length > 0 || lane.failed !== void 0) && {
-        failed: [...lane.failed ?? [], ...failed]
+    const { outbox: _outbox, ...rest } = lane;
+    lanes[protocol] = inbox.length === 0 && laneRestamped === 0 ? lane : {
+      ...rest,
+      commands,
+      ...outbox !== void 0 && outbox.length > 0 && { outbox },
+      ...(inbox.length > 0 || lane.inbox !== void 0) && {
+        inbox: [...lane.inbox ?? [], ...inbox]
       }
     };
   }
@@ -110,21 +185,12 @@ function isStorageQuotaError(error) {
     message
   );
 }
-function asStatewireQuotaError(error) {
-  if (error instanceof Error && error.name === "QuotaExceededError")
-    return error;
-  const normalized = new Error(
-    error instanceof Error ? error.message : "storage quota exceeded"
-  );
-  normalized.name = "QuotaExceededError";
-  return normalized;
-}
-function unreadableRecord(raw) {
+function unreadableRecord(key, raw) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
-  } catch (error) {
-    return error instanceof Error ? error : new Error("stored session record is not JSON");
+  } catch {
+    return void 0;
   }
   if (typeof parsed !== "object" || parsed === null) {
     return new Error("stored session record is not an object");
@@ -135,6 +201,10 @@ function unreadableRecord(raw) {
       `stored session record uses storage version ${String(version)}`
     );
   }
+  const owner = parsed.principal;
+  if (version === 6 && typeof owner === "string" && !key.includes(`:${encodeURIComponent(owner)}:`)) {
+    return new Error("stored session record belongs to another principal");
+  }
   return void 0;
 }
 function browserBackend({
@@ -165,24 +235,48 @@ function browserBackend({
           );
         }
       );
+    },
+    subscribe: (listener) => {
+      var _a;
+      const onStorage = (event) => {
+        if (event.key !== null) listener(event.key);
+      };
+      (_a = browserGlobals.addEventListener) == null ? void 0 : _a.call(browserGlobals, "storage", onStorage);
+      return () => {
+        var _a2;
+        return (_a2 = browserGlobals.removeEventListener) == null ? void 0 : _a2.call(browserGlobals, "storage", onStorage);
+      };
     }
   };
 }
 function quotaTolerantBackend({
   inner,
-  onDegraded
+  onDegraded,
+  onQuota
 }) {
-  const quotaSurfaced = /* @__PURE__ */ new Set();
+  const reclaimed = /* @__PURE__ */ new Set();
   const overlay = /* @__PURE__ */ new Map();
   const shielded = /* @__PURE__ */ new Set();
   const checked = /* @__PURE__ */ new Map();
   const readable = (key, raw) => {
     const previous = checked.get(key);
     if (previous !== void 0 && previous.raw === raw) return previous.verdict;
-    const verdict = unreadableRecord(raw);
+    const verdict = unreadableRecord(key, raw);
     checked.set(key, { raw, verdict });
     return verdict;
   };
+  const writeThrough = (key) => {
+    const value = overlay.get(key);
+    if (value === void 0 || shielded.has(key)) return;
+    try {
+      inner.setItem(key, value);
+    } catch (error) {
+      onDegraded({ operation: "setItem", key, error });
+      return;
+    }
+    if (overlay.get(key) === value) overlay.delete(key);
+    reclaimed.delete(key);
+  };
   return {
     getItem: (key) => {
       const shadowed = overlay.get(key);
@@ -211,13 +305,17 @@ function quotaTolerantBackend({
       try {
         inner.setItem(key, value);
         overlay.delete(key);
-        quotaSurfaced.delete(key);
+        reclaimed.delete(key);
       } catch (error) {
-        if (isStorageQuotaError(error) && !quotaSurfaced.has(key)) {
-          quotaSurfaced.add(key);
-          throw asStatewireQuotaError(error);
-        }
         overlay.set(key, value);
+        if (isStorageQuotaError(error) && onQuota && !reclaimed.has(key)) {
+          reclaimed.add(key);
+          onQuota(key).then(
+            () => writeThrough(key),
+            (reclaimError) => onDegraded({ operation: "withUnused", key, error: reclaimError })
+          );
+          return;
+        }
         onDegraded({ operation: "setItem", key, error });
       }
     },
@@ -245,10 +343,12 @@ function quotaTolerantBackend({
       } catch (error) {
         onDegraded({ operation: "withUnused", key, error });
       }
-    }
+    },
+    ...inner.subscribe !== void 0 && { subscribe: inner.subscribe }
   };
 }
-function savedAtOf(raw) {
+const asList = (value) => Array.isArray(value) ? value : [];
+function retentionView(raw) {
   if (raw === null) return void 0;
   let parsed;
   try {
@@ -257,23 +357,61 @@ function savedAtOf(raw) {
     return void 0;
   }
   if (typeof parsed !== "object" || parsed === null) return void 0;
-  const { savedAt, updatedAt } = parsed;
-  const stamp = savedAt ?? updatedAt;
-  return typeof stamp === "number" && Number.isFinite(stamp) ? stamp : void 0;
+  const record = parsed;
+  const stamp = record.savedAt ?? record.updatedAt;
+  const lanes = typeof record.lanes === "object" && record.lanes !== null ? Object.values(record.lanes) : [];
+  const holdsSends = asList(record.commands).length > 0 || asList(record.failed).length > 0 || lanes.some((lane) => {
+    if (typeof lane !== "object" || lane === null) return false;
+    const fields = lane;
+    return [
+      "commands",
+      "outbox",
+      "inbox",
+      "removed",
+      "verdicts",
+      "failed"
+    ].some((field) => asList(fields[field]).length > 0);
+  });
+  return {
+    savedAt: typeof stamp === "number" && Number.isFinite(stamp) ? stamp : void 0,
+    holdsSends
+  };
+}
+function persistedSessionHoldsSends(sessionKey) {
+  var _a;
+  const storage2 = browserGlobals.localStorage;
+  if (!storage2) return false;
+  let raw;
+  try {
+    raw = storage2.getItem(SESSION_PREFIX + sessionKey);
+  } catch {
+    return false;
+  }
+  return ((_a = retentionView(raw)) == null ? void 0 : _a.holdsSends) ?? false;
 }
 async function retireExpiredSessionRecords({
   backend,
   mounted,
   maxAgeMs,
+  quota = false,
   now = Date.now()
 }) {
+  const empty = [];
   for (const key of backend.getAllKeys()) {
     if (!key.startsWith(SESSION_PREFIX) || mounted.has(key)) continue;
-    const savedAt = savedAtOf(backend.getItem(key));
-    if (savedAt === void 0 || now - savedAt <= maxAgeMs) continue;
+    const view = retentionView(backend.getItem(key));
+    if ((view == null ? void 0 : view.savedAt) === void 0 || view.holdsSends) continue;
+    empty.push({ key, savedAt: view.savedAt });
+  }
+  empty.sort((a, b) => b.savedAt - a.savedAt);
+  const quotaStart = Math.floor(empty.length / 2);
+  for (const [index, { key, savedAt }] of empty.entries()) {
+    const expired = now - savedAt > maxAgeMs;
+    if (!expired && !(quota && index >= quotaStart)) continue;
     await backend.withUnused(key, async () => {
-      if (mounted.has(key) || savedAtOf(backend.getItem(key)) !== savedAt)
-        return;
+      if (mounted.has(key)) return;
+      const again = retentionView(backend.getItem(key));
+      if ((again == null ? void 0 : again.savedAt) !== savedAt || again.holdsSends) return;
       backend.removeItem(key);
     });
   }
@@ -286,26 +424,63 @@ function sharedBackend({
   let shared = sharedBackends.get(storage2);
   if (shared === void 0) {
     const listeners = /* @__PURE__ */ new Set();
+    const mounted = /* @__PURE__ */ new Map();
+    const maxAgeMs = /* @__PURE__ */ new Map();
+    const inner = browserBackend({ storage: storage2, locks });
     shared = {
       listeners,
-      mounted: /* @__PURE__ */ new Map(),
+      mounted,
+      maxAgeMs,
       backend: quotaTolerantBackend({
-        inner: browserBackend({ storage: storage2, locks }),
+        inner,
         onDegraded: (degradation) => {
           for (const listener of listeners) listener(degradation);
-        }
+        },
+        onQuota: () => retireExpiredSessionRecords({
+          backend: inner,
+          mounted,
+          maxAgeMs: Math.max(7 * DAY_MS, ...maxAgeMs.values()),
+          quota: true
+        })
       })
     };
     sharedBackends.set(storage2, shared);
   }
   return shared;
 }
+async function underLock({
+  locks,
+  name,
+  fn,
+  onRefused
+}) {
+  let granted = false;
+  try {
+    return await locks.request(name, async () => {
+      granted = true;
+      return fn();
+    });
+  } catch (error) {
+    if (granted) throw error;
+    onRefused(error);
+    return fn();
+  }
+}
+function newTabId() {
+  var _a, _b;
+  const host = globalThis;
+  return ((_b = (_a = host.crypto) == null ? void 0 : _a.randomUUID) == null ? void 0 : _b.call(_a)) ?? `tab-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
 const useQuotaSafeLocalStorageSession = ({
   threadId,
-  key = (id) => id,
+  namespace,
+  principal,
+  unscopedPrefix,
   ttl = 7 * DAY_MS,
   max = 50,
-  onStorageDegraded
+  recordBytes = LOCAL_SESSION_RECORD_BYTES,
+  onStorageDegraded,
+  onEvict
 }) => {
   var _a;
   const storage$1 = browserGlobals.localStorage;
@@ -318,18 +493,31 @@ const useQuotaSafeLocalStorageSession = ({
     throw new Error(
       "statewire: QuotaSafeLocalStorageSession requires the Web Locks API (navigator.locks)"
     );
-  const sessionKey = key(threadId);
+  const sessionKey = localStorageSessionKey({ namespace, principal, threadId });
   const storageKey = SESSION_PREFIX + sessionKey;
   const lockName = SESSION_LOCK_PREFIX + sessionKey;
   const mountedScope = require$$0.useRef({
     threadId,
     laneKey: sessionKey
   });
-  if (!sessionLaneScope.isSameSessionLaneScope({ scope: mountedScope.current, key })) {
+  if (!sessionLaneScope.isSameSessionLaneScope({
+    scope: mountedScope.current,
+    key: (id) => localStorageSessionKey({ namespace, principal, threadId: id })
+  })) {
     throw new Error(
       "statewire: principal changed; remount the account's thread/session"
     );
   }
+  require$$0.useMemo(() => {
+    if (unscopedPrefix === void 0) return;
+    adoptUnscopedLocalStorageSessions({
+      namespace,
+      principal,
+      unscopedPrefix,
+      threadId,
+      storage: storage$1
+    });
+  }, [namespace, principal, unscopedPrefix, threadId, storage$1]);
   const latestOnDegraded = require$$0.useRef(onStorageDegraded);
   latestOnDegraded.current = onStorageDegraded;
   const reportDegradation = require$$0.useMemo(() => {
@@ -352,6 +540,18 @@ const useQuotaSafeLocalStorageSession = ({
       );
     };
   }, []);
+  const latestOnEvict = require$$0.useRef(onEvict);
+  latestOnEvict.current = onEvict;
+  const reportEvict = require$$0.useCallback(
+    (event) => {
+      var _a2;
+      try {
+        (_a2 = latestOnEvict.current) == null ? void 0 : _a2.call(latestOnEvict, event);
+      } catch {
+      }
+    },
+    []
+  );
   const shared = sharedBackend({ storage: storage$1, locks });
   shared.listeners.add(reportDegradation);
   require$$0.useEffect(() => {
@@ -361,8 +561,9 @@ const useQuotaSafeLocalStorageSession = ({
     };
   }, [shared, reportDegradation]);
   require$$0.useEffect(() => {
-    const { mounted } = shared;
+    const { mounted, maxAgeMs } = shared;
     mounted.set(storageKey, (mounted.get(storageKey) ?? 0) + 1);
+    maxAgeMs.set(storageKey, ttl);
     retireExpiredSessionRecords({
       backend: shared.backend,
       mounted,
@@ -372,10 +573,23 @@ const useQuotaSafeLocalStorageSession = ({
     );
     return () => {
       const count = (mounted.get(storageKey) ?? 1) - 1;
-      if (count === 0) mounted.delete(storageKey);
-      else mounted.set(storageKey, count);
+      if (count === 0) {
+        mounted.delete(storageKey);
+        maxAgeMs.delete(storageKey);
+      } else mounted.set(storageKey, count);
     };
   }, [shared, storageKey, ttl, reportDegradation]);
+  const [tabId] = require$$0.useState(newTabId);
+  require$$0.useEffect(() => {
+    let release;
+    const held = new Promise((resolve) => {
+      release = resolve;
+    });
+    Promise.resolve(locks.request(TAB_LOCK_PREFIX + tabId, () => held)).catch(
+      (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+    );
+    return () => release == null ? void 0 : release();
+  }, [locks, tabId, storageKey, reportDegradation]);
   require$$0.useEffect(() => {
     let release;
     let disposed = false;
@@ -416,31 +630,42 @@ const useQuotaSafeLocalStorageSession = ({
   const sessionStorage = tap.useResource(
     storage.KeyValueSessionStorage({
       backend: shared.backend,
-      key: sessionKey,
-      namespace: SESSION_PREFIX,
+      key: threadId,
+      namespace: SESSION_PREFIX + namespace,
+      principal,
       protocol: statewireTransport.DEEP_AGENT_STATEWIRE_PROTOCOL,
       migrate,
+      // statewire 0.27.1 retires a record past maxAgeMs even while it holds
+      // sends: kept failures with their full params were what filled the
+      // origin (#52031).
       retention: { maxAgeMs: ttl, maxEntries: max },
+      limits: { recordBytes },
       // A failure statewire raises itself (a structurally invalid stored
       // record) still stops the session; it is at least reported the same way.
-      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error })
+      onError: (error) => reportDegradation({ operation: "session", key: storageKey, error }),
+      onEvict: reportEvict
     })
   );
   return require$$0.useMemo(
     () => ({
       ...sessionStorage,
-      lock: async (fn) => {
-        let granted = false;
-        try {
-          return await locks.request(lockName, async () => {
-            granted = true;
-            return fn();
-          });
-        } catch (error) {
-          if (granted) throw error;
-          reportDegradation({ operation: "lock", key: storageKey, error });
-          return fn();
-        }
+      lock: (fn) => underLock({
+        locks,
+        name: lockName,
+        fn,
+        onRefused: (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+      }),
+      notifyLock: (fn) => underLock({
+        locks,
+        name: NOTIFY_LOCK_PREFIX + storageKey,
+        fn,
+        onRefused: (error) => reportDegradation({ operation: "lock", key: storageKey, error })
+      }),
+      owner: {
+        id: tabId,
+        whenGone: (id, signal) => Promise.resolve(
+          locks.request(TAB_LOCK_PREFIX + id, { signal }, () => void 0)
+        )
       },
       subscribe: (listener) => {
         var _a2;
@@ -454,18 +679,23 @@ const useQuotaSafeLocalStorageSession = ({
         };
       }
     }),
-    [sessionStorage, locks, storageKey, lockName, reportDegradation]
+    [sessionStorage, locks, storageKey, lockName, tabId, reportDegradation]
   );
 };
 const QuotaSafeLocalStorageSession = tap.resource(
   useQuotaSafeLocalStorageSession
 );
+exports.LOCAL_SESSION_RECORD_BYTES = LOCAL_SESSION_RECORD_BYTES;
 exports.QuotaSafeLocalStorageSession = QuotaSafeLocalStorageSession;
 exports.STORED_STATEMENT_WIRE_FLOOR = STORED_STATEMENT_WIRE_FLOOR;
+exports.adoptUnscopedLocalStorageSessions = adoptUnscopedLocalStorageSessions;
 exports.isStorageQuotaError = isStorageQuotaError;
+exports.localStorageSessionKey = localStorageSessionKey;
 exports.parkIncompatibleSessionCommands = parkIncompatibleSessionCommands;
+exports.persistedSessionHoldsSends = persistedSessionHoldsSends;
 exports.quotaTolerantBackend = quotaTolerantBackend;
 exports.readFailedSendStampsFromRecord = readFailedSendStampsFromRecord;
 exports.readPersistedFailedSendStamps = readPersistedFailedSendStamps;
 exports.retireExpiredSessionRecords = retireExpiredSessionRecords;
+exports.sessionPrincipal = sessionPrincipal;
 //# sourceMappingURL=quota-safe-local-storage-session.cjs.map