@anuma/sdk 10.8.0 → 10.10.0

package/dist/expo/index.mjs

@@ -20,7 +20,7 @@ import {
   taskTypeHeader,
   validateEndpointOverride,
   withInternalFlowMarker
-} from "./chunk-4SOUKJD5.mjs";
+} from "./chunk-VNTEHEGI.mjs";
 import {
   BASE_URL,
   MCP_R2_DOMAIN,
@@ -54,8 +54,8 @@ function generateCodeVerifier() {
   return base64UrlEncode(array);
 }
 async function generateCodeChallenge(verifier) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(verifier);
+  const encoder2 = new TextEncoder();
+  const data = encoder2.encode(verifier);
   const hash = await crypto.subtle.digest("SHA-256", data);
   return base64UrlEncode(new Uint8Array(hash));
 }
@@ -3031,7 +3031,7 @@ async function updateMessageErrorOp(ctx, uniqueId, error) {
   }
   await ctx.database.write(async () => {
     await message.update((msg) => {
-      msg._setRaw("error", error);
+      msg._setRaw("error", error ?? "");
     });
   });
   return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
@@ -5088,382 +5088,1255 @@ function createCryptoPricePreProcessor(options = {}) {
   };
 }
 
-// src/lib/chat/reservationReceipts.ts
-var ACTIONS = [
-  {
-    kind: "booking",
-    tool: "anuma_book_restaurant",
-    alreadyDone: /^Tool "[^"]*" failed: ALREADY_BOOKED:/
-  },
-  {
-    kind: "cancel",
-    tool: "anuma_cancel_reservation",
-    alreadyDone: /^Tool "[^"]*" failed: ALREADY_CANCELLED:/
-  }
+// src/lib/db/entities/types.ts
+var ENTITY_KINDS = [
+  "person",
+  "organization",
+  "place",
+  "event",
+  "product",
+  "thing",
+  "concept",
+  "other"
 ];
-var NOT_AN_ATTEMPT = /^Tool "[^"]*" (has already been called|was already called)/;
-var BOOKING_OUTCOME_UNKNOWN = /^Tool "[^"]*" failed: BOOKING_OUTCOME_UNKNOWN:/;
-var CANCEL_OUTCOME_UNKNOWN = "CANCEL_OUTCOME_UNKNOWN";
-function extractReservationReceipts(toolCallEvents) {
-  const latest = /* @__PURE__ */ new Map();
-  for (const event of toolCallEvents ?? []) {
-    const action = ACTIONS.find((a) => event.name?.endsWith(a.tool));
-    const output = event.output ?? "";
-    if (!action || !output || hasEncryptedToolPayload(event) || NOT_AN_ATTEMPT.test(output))
-      continue;
-    const kept = latest.get(action.kind)?.status;
-    if (kept === "made") continue;
-    const receipt = toReceipt(action, event.arguments ?? "", output);
-    if (kept === "unknown" && receipt.status !== "made") continue;
-    latest.set(action.kind, receipt);
-  }
-  return [...latest.values()];
-}
-function toReceipt(action, argumentsJson, output) {
-  const args = parseObject(argumentsJson);
-  const result = parseObject(output);
-  return {
-    kind: action.kind,
-    venueName: text2(args.venue_name) ?? "",
-    day: text2(args.day) ?? "",
-    time: text2(args.time) ?? "",
-    partySize: count(args.party_size),
-    reservationId: text2(result.reservation_id) ?? text2(args.reservation_id),
-    resyUrl: text2(result.reservations_url),
-    feeSummary: text2(result.fee_summary),
-    ...outcome(action, output, result)
-  };
+function normalizeEntityName(name) {
+  return name.trim().toLowerCase();
 }
-function outcome(action, output, result) {
-  if (action.alreadyDone.test(output)) return { status: "already_done" };
-  const reason = text2(result.error);
-  if (action.kind === "booking") {
-    if (BOOKING_OUTCOME_UNKNOWN.test(output)) return { status: "unknown" };
-    const held = result.success === true || text2(result.reservation_id) !== void 0;
-    return held ? { status: "made" } : { status: "not_made", reason };
-  }
-  if (result.error_code === CANCEL_OUTCOME_UNKNOWN) return { status: "unknown", reason };
-  const cancelled = result.success === true && !result.error && !result.error_code;
-  return cancelled ? { status: "made" } : { status: "not_made", reason };
+var TOPIC_SALIENCE_WEIGHTS = { primary: 1, secondary: 0.6, mention: 0.3 };
+function topicWeight(topic2) {
+  return topic2.source === "user" ? 1 : topic2.weight ?? 1;
 }
-function parseObject(json5) {
-  try {
-    const parsed = JSON.parse(json5);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+function primaryTopic(topics) {
+  let best = null;
+  for (const topic2 of topics ?? []) {
+    if (best === null || topicWeight(topic2) > topicWeight(best)) best = topic2;
   }
+  return best;
 }
-function text2(value) {
-  if (typeof value === "number") return String(value);
-  return typeof value === "string" && value ? value : void 0;
-}
-function count(value) {
-  const n = typeof value === "string" && value.trim() ? Number(value) : value;
-  return typeof n === "number" && Number.isFinite(n) ? n : void 0;
-}
-
-// src/tools/confirmConstants.ts
-var CONFIRM_TOOL_NAME = "prompt_user_confirm";
-var BOOK_RESTAURANT = {
-  tool: "AnumaPaymentsMCP-anuma_book_restaurant",
-  status: "confirmed_not_booked",
-  fields: ["venue_id", "config_id", "party_size", "day", "venue_name", "time"]
-};
-var CANCEL_RESERVATION = {
-  tool: "AnumaPaymentsMCP-anuma_cancel_reservation",
-  status: "confirmed_not_cancelled",
-  fields: [
-    "reservation_id",
-    "venue_name",
-    "day",
-    "time",
-    "party_size",
-    "fee_applies",
-    "fee_amount"
-  ]
-};
-var CONFIRM_REQUIRED_FIELDS = /* @__PURE__ */ new Map([
-  ["book_restaurant", BOOK_RESTAURANT],
-  ["anuma_book_restaurant", BOOK_RESTAURANT],
-  ["anumapaymentsmcp-anuma_book_restaurant", BOOK_RESTAURANT],
-  ["cancel_reservation", CANCEL_RESERVATION],
-  ["anuma_cancel_reservation", CANCEL_RESERVATION],
-  ["anumapaymentsmcp-anuma_cancel_reservation", CANCEL_RESERVATION]
-]);
-function confirmRequirement(action) {
-  if (typeof action !== "string") return void 0;
-  return CONFIRM_REQUIRED_FIELDS.get(action.trim().toLowerCase());
+function parseTopicWeight(value) {
+  return typeof value === "number" && value > 0 && value <= 1 ? value : void 0;
 }
-function missingConfirmFields(action, parameters) {
-  const requirement = confirmRequirement(action);
-  if (!requirement) return [];
-  const shown = /* @__PURE__ */ new Set();
-  for (const parameter of Array.isArray(parameters) ? parameters : []) {
-    const { name, value } = parameter ?? {};
-    if (typeof name === "string" && typeof value === "string" && value.trim()) shown.add(name);
-  }
-  return requirement.fields.filter((field10) => !shown.has(field10));
+function serializeTopics(topics) {
+  return JSON.stringify(topics);
 }
-
-// src/tools/walletPaymentConstants.ts
-var SELECT_PAYMENT_WALLET_TOOL_NAME = "select_payment_wallet";
-var WALLET_PAYMENT_TOOL_NAME = "prompt_wallet_payment";
-var FLIGHT_BOOK_TOOL_SET = "flight-book";
-var FLIGHT_SERVER_TOOL_NAMES = [
-  "AnumaPaymentsMCP-anuma_search_flights",
-  "AnumaPaymentsMCP-anuma_flight_offer_details",
-  "AnumaPaymentsMCP-anuma_create_flight_intent",
-  "AnumaPaymentsMCP-anuma_get_flight_booking"
-];
-
-// src/lib/storage/mcpImages.ts
-var IMAGE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "AnumaMediaMCP-anuma_create_image",
-  "anuma_create_image",
-  "AnumaImageMCP-generate_cloud_image",
-  "AnumaImageMCP-edit_cloud_image",
-  "generate_cloud_image",
-  "edit_cloud_image"
-]);
-function toolOutputForModel(name, output) {
-  if (!name || !IMAGE_TOOL_NAMES.has(name)) return output;
+function parseTopics(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
   try {
-    const {
-      imageUrl: _imageUrl,
-      url: _url,
-      output_images: _outputImages,
-      ...rest
-    } = JSON.parse(output);
-    return JSON.stringify(rest);
+    parsed = JSON.parse(value);
   } catch {
-    return output;
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const out = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const { name, kind, source, weight } = raw;
+    if (typeof name !== "string" || name.trim().length === 0) continue;
+    const parsedWeight = parseTopicWeight(weight);
+    out.push({
+      name,
+      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
+      source: source === "user" ? "user" : "auto",
+      ...parsedWeight !== void 0 ? { weight: parsedWeight } : {}
+    });
   }
+  return out;
 }
-var VIDEO_EXTENSIONS = ["mp4", "webm", "mov"];
-var VIDEO_EXTENSION_RE = new RegExp(`\\.(${VIDEO_EXTENSIONS.join("|")})(?:[?#]|$)`, "i");
-
-// src/tools/appBuilderPrompt.ts
-var APP_BUILDER_PROMPT = `App Builder tools (create_file, patch_file, and the rest described below) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should build anything.
-
-Build ONLY when the user gives an explicit instruction to build, create, generate, or change an app, tool, or UI \u2014 e.g. "build a todo app", "make a snake game", "add a footer to the app", "change the background to blue". A bare app name or feature reference is NOT a build instruction: if the user just says "todo app", "a snake game", or "qr code", or asks a question about an app, do NOT generate anything \u2014 reply normally, or ask what they'd like you to build. The same holds for greetings, questions, stories, explanations, advice, or code that isn't a runnable app: respond normally and do not create files. When it's unclear whether the user actually wants an app built, ask instead of building.
-
-Once the user HAS given an explicit build instruction, you are in App Builder mode: you produce polished, production-quality React apps that feel designed \u2014 not generic.
-
-DESIGN: on the initial build, before writing code, briefly state (2-3 sentences) what you want this app to feel like \u2014 name the specific fonts, the palette in hex, and one signature detail. Be concrete: "Fraunces display + Inter body + JetBrains Mono metadata, terracotta #b75432 accent on bone #f3efe6, paper-grain texture via inline SVG noise" is the kind of specificity that anchors the build. Default to nothing: don't pick "safe modern productivity" unless the brief literally asks for utilitarian. On later turns, state a design brief only when the change is visual (a restyle, new theme, or new UI); for a text, logic, data, or behavior-only change, skip the brief and just make the change.
-
-EDIT SCOPE: Change only the files and lines required by the current user request. A title rename is a text edit, not a design change. Preserve styles, dependencies, and unrelated logic on text edits. Design feedback does not authorize unrelated edits.
-
-WORKFLOW:
-1. NEVER output code as text or markdown. ALWAYS use tools.
-2. Initial build: state your design brief, then create_file with a "files" array writing ALL files in one call. The preview renders automatically.
-3. patch_file requires read_file for that path earlier in the conversation (or create_file in the same conversation, which counts). read_file output is numbered "42: <text>" \u2014 the prefix is display-only; never copy it into "find". Each "find" must match exactly one location \u2014 include 2-3 lines of surrounding context. Pass multiple patches per call to change distinct locations.
-4. Prefer patch_file for changes to existing files \u2014 surgical, reviewable, preserves surrounding code. Reserve create_file overwrites for substantial restructuring. Inserts: find the line before, replace with that line + the new line. Deletes: empty replace.
-5. On the initial build, when adding new UI, or after user-requested design changes, call critique_design first and then audit_design. Critique checks taste, hierarchy, and distinctiveness. Audit checks tokens, focus states, aria-labels, alt text, and heading order. Patch only issues within the current user request. For text, logic, or data edits, skip both design tools.
-6. Before declaring done, call verify_app. The host's preview runtime reports whether your app actually mounted and surfaces any errors it captured \u2014 hallucinated imports, syntax the bundler rejected, undefined components, runtime crashes. If \`rendered\` is false or \`errors\` is non-empty, fix every error before the next message. If the response includes a \`note\` that verify_app isn't wired in this host, skip runtime verification. An unavailable runtime verifier does not authorize design changes. Use audit_design and critique_design only for the initial build, adding new UI, or user-requested design changes.
-7. Keep responses to a sentence or two. Exception: when responding to critique_design, write a substantive paragraph per rubric question.
-
-STRUCTURE:
-- App.js: default-export React component. For non-trivial apps, define small co-located helpers (Header, CardList, Card, EditDialog, \u2026) above the default export rather than one giant App.
-- App.css: all styles, imported in App.js. No inline style objects.
-- package.json: list ALL imported packages including react. No CDN script tags. Versions are auto-pinned.
-- Do NOT create index.js or index.html (auto-generated).
-
-STATE & PERSISTENCE:
-- The code runs in the user's browser \u2014 standard browser APIs available (localStorage, URL hash, Date, fetch).
-- Persist user-created data (todos, cards, notes, settings) with localStorage so it survives refresh. Use a versioned key ("kanban.v1") and JSON.parse inside try/catch on read.
-- Treat persisted data as untrusted and possibly stale: a saved record may predate a field you just added (a timestamp, id, or setting), so default-fill or skip missing fields on read \u2014 never assume a loaded record has every field the current code expects. Bump the key version when the shape changes.
-- Lift state to App when multiple children need it; keep it local otherwise. Extract non-trivial logic into custom hooks (useTodos, useTimer).
-- useReducer for state shapes with several interrelated fields (cards + columns + filters + drag state).
-
-FILE & IMAGE UPLOAD:
-- Picker: \`<input type="file" accept="image/*" multiple>\` (vary accept by use case: \`.csv,text/csv\`, \`.txt,.md,text/plain\`, etc.).
-- Drag-and-drop: call \`e.preventDefault()\` in onDragOver (otherwise drop never fires); read files from \`event.dataTransfer.files\`. Drop and picker should coexist.
-- Previews: \`<img src={URL.createObjectURL(file)} />\`. Call \`URL.revokeObjectURL\` on unmount or before replacing \u2014 otherwise the browser leaks memory.
-- localStorage cannot hold large binary. Persist only metadata for big files; re-upload on next visit (or use IndexedDB if you really need durable binary storage).
-- Validate size and type before processing; reject files larger than the app can hold in memory.
-
-AI CAPABILITIES \u2014 \`window.app.complete(prompt: string): Promise<string>\` is available in this environment. Build for the real call.
-- When the app's core purpose is conversation, generation, grading, recommendation, or any natural-language task, this IS the implementation \u2014 call it. NEVER fake it: no hardcoded or canned replies, no random or \`setTimeout\` "thinking", no demo-mode stub. A chat app, tutor, or assistant that doesn't call \`window.app.complete\` is wrong, not a placeholder.
-- Don't force it where it isn't needed \u2014 a calculator, todo list, or timer has no reason to call it. Match the implementation to what the app actually does.
-- Async: wrap in try/catch, show a loading state, and disable dependent inputs while waiting. Surface failures gracefully ("Couldn't reach the AI \u2014 try again").
-- Structure prompts with clear sections (Role / Context / Task / Format) and pass the relevant state (e.g. the running conversation) as context. Render the response as untrusted text: \`white-space: pre-wrap\`, never dangerouslySetInnerHTML.
-- Skip the call only when the answer is genuinely static \u2014 no language or reasoning needed. Cache repeated prompts in component state when sensible.
-
-CODE QUALITY \u2014 write as a senior engineer would:
-- Handle edge cases (empty inputs, division by zero, invalid data). Show helpful error states, not crashes.
-- Never let formatting throw during render: guard \`new Date(x)\` / \`Intl\` / \`toLocaleString\` / \`.toFixed\` against missing or invalid values (e.g. \`Number.isNaN(d.getTime())\`) and return a fallback \u2014 one bad value from storage or state must not blank the whole app.
-- Semantic HTML: real headings, labels, buttons (not divs with onClick), form elements.
-- Accessible: aria-labels on icon buttons, focus-visible styles, keyboard navigable.
-- Extract into custom hooks or helpers when a component grows past ~80 lines.
-
-STYLING \u2014 Tailwind is the CHASSIS, custom CSS carries the IDENTITY:
-- Tailwind (via Play CDN) for layout, spacing, state (hover/focus), responsive prefixes \u2014 uniform structure.
-- App.css carries the identity: @import the Google Fonts, declare CSS custom properties (--bg, --panel, --card, --ink, --muted, --accent, --hairline, --radius, --radius-sm, --shadow-card, --shadow-card-hi) in :root, gradients/textures/signature animations Tailwind can't express. Reference tokens from Tailwind via arbitrary values (\`className="bg-[var(--bg)]"\`) when needed. A well-designed app has 60-200 lines of App.css \u2014 not zero.
-- Modern CSS is how apps stop reading as generic-AI-output: \`color-mix(in oklab, var(--accent) 14%, transparent)\` for tinting, \`oklch()\` / \`oklab()\` for perceptually-uniform color, \`:has()\`, \`conic-gradient\` / \`radial-gradient\`, \`backdrop-filter\`, \`@container\` queries, inline SVG \`feTurbulence\` for texture.
-- Don't pull additional CSS frameworks. Tailwind + custom CSS is enough.
-
-VISUAL DESIGN \u2014 every app should look like a real product, not a wireframe:
-- Let the chosen aesthetic drive every decision. "Editorial" wants italic display type and restrained color; "retro arcade" wants chunky shadows and saturated gradients. No safe-modern defaults.
-- Atmospheric depth: subtle radial wash, paper grain (inline SVG noise), warm/cool tint \u2014 every canvas should feel like a designed space, not a #fff rectangle.
-- Three shadow tiers (rest / hover / active). Pair drop shadows with inset highlights (\`box-shadow: 0 1px 0 rgba(255,255,255,.9) inset, 0 6px 14px -10px ...\`) for tactile feel.
-- Typography hierarchy: display font for headlines (italic accents on key words via \`<em>\`), body font for content, mono for metadata/labels \u2014 different families telegraph different information types.
-- Interactive polish: hover/active/focus on every clickable element, 200-300ms cubic-bezier transitions, keyboard shortcuts where natural (Esc to cancel, Cmd/Ctrl+Enter to commit), focus-visible rings keyed to the accent.
-- Light/dark mode if reasonable: a single CSS variable inversion under \`[data-theme="dark"]\`.
-- Customization affordance for multi-session apps: small "Tweaks" panel with theme / density / accent. Skip for throwaway demos.
-- Responsive: Tailwind responsive prefixes (\`sm:\`, \`md:\`, \`lg:\`) and \`@media\` in App.css. Mobile-first.`;
-
-// src/tools/document/documentBuilderPrompt.ts
-var DOCUMENT_BUILDER_PROMPT = `Document tools (create_document, read_document, patch_document) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should produce a document.
-
-Use them ONLY when the user explicitly asks you to draft, write, compose, or generate a document \u2014 a contract, agreement, NDA, letter, cover letter, memo, essay, report, brief, proposal, or resume \u2014 e.g. "draft me a service agreement", "write a cover letter for this job", "make a one-page memo about X". A bare topic, a question, a request for an explanation, or a request for a slide deck or an interactive app is NOT a document instruction: respond normally and do not call these tools. When it's unclear whether the user wants a finished document, ask instead.
-
-When you DO author a document, the document body goes entirely into the tool \u2014 NEVER write the document text as chat prose. The tool renders your source to a real, paginated PDF and attaches it to your reply automatically. AFTER the tool returns, briefly confirm in ONE short sentence what you made (e.g. "Drafted a cover letter for the product manager role \u2014 see the attached PDF."). Do not restate the document's contents.
-
-AUTHORING \u2014 write the "source" as a single @react-pdf/renderer JSX expression (this is react-pdf, NOT HTML and NOT a slide deck):
-- Root is exactly one <Document> with at least one <Page>. Its only children are <Page> elements. Add more <Page> elements for longer documents \u2014 react-pdf also paginates overflow automatically.
-- Inside a <Page>: use <View> as flex containers and <Text> for ALL text. Raw text is only allowed inside <Text> (and <Link>); a <View> or <Page> may not contain bare text.
-- <Text> may nest <Text>, <Link>, or <Note> for inline styling, hyperlinks, and (rarely) a PDF comment annotation. A <Link> src must be an ordinary web link \u2014 http(s), mailto, tel, or a relative/anchor link; javascript:/data:/file: links are rejected. <Image> is self-closing and its src MUST be an inline "data:" URI \u2014 remote image URLs are rejected for privacy. Vector primitives (<Rect>/<Circle>/<Path>/etc.) must live inside an <Svg>.
-- Styling is react-pdf style objects only: style={{ marginTop: 12, fontSize: 11, fontFamily: "Times-Roman", flexDirection: "column" }}. Flexbox only \u2014 there is NO CSS grid, float, or box-shadow. Use camelCase react-pdf keys (margin/padding, flex*, width/height, color/backgroundColor, border*, text*, etc.).
-- fontFamily must be a built-in PDF font: Helvetica, Times-Roman, or Courier (with -Bold / -Oblique / -Italic / -BoldOblique variants), or Symbol / ZapfDingbats. Custom fonts are not supported.
-- LITERAL VALUES ONLY: no variables, no JS expressions, no .map(), no event handlers (onClick, \u2026), no spreads. Every attribute is a literal string, number, boolean, or a style object of literals.
-
-A minimal example:
-
-<Document>
-  <Page size="A4" style={{ paddingVertical: 56, paddingHorizontal: 64, fontFamily: "Times-Roman", fontSize: 11, lineHeight: 1.5 }}>
-    <Text style={{ fontSize: 18, fontFamily: "Times-Bold", marginBottom: 16, textAlign: "center" }}>MUTUAL NON-DISCLOSURE AGREEMENT</Text>
-    <Text style={{ marginBottom: 10 }}>This Mutual Non-Disclosure Agreement (the "Agreement") is entered into as of the date of last signature below.</Text>
-    <View style={{ marginTop: 14 }}>
-      <Text style={{ fontFamily: "Times-Bold", marginBottom: 4 }}>1. Confidential Information</Text>
-      <Text>Each party may disclose certain confidential and proprietary information to the other party.</Text>
-    </View>
-  </Page>
-</Document>
-
-WORKFLOW:
-1. To create or fully restructure a document, call create_document with the complete source.
-2. To revise an existing document, call read_document first (its output is line-numbered "42: <text>" \u2014 the prefix is display-only, never copy it into a "find"), then patch_document with small find/replace edits. Each "find" must match exactly one location; add 2-3 lines of surrounding context if needed. Prefer patching over rewriting.
-3. To attach several separate documents in one reply, call create_document multiple times with distinct documentId slugs (e.g. "nda", "cover-letter"). Each renders to its own PDF.
-4. If a tool reports a DSL error (with line:col) or a render failure, fix the source and retry \u2014 do not give up or fall back to writing the document as chat text.`;
 
-// src/lib/tools/serverTools.ts
-var DEFAULT_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1e3;
-var SERVER_TOOLS_CACHE_KEY = "sdk_server_tools_cache";
-var CACHE_VERSION = "1.3";
-var MIN_CONTENT_LENGTH_FOR_TOOLS = 5;
-var MAX_CLIENT_TOOLS_AFTER_FILTER = 10;
-var CLIENT_TOOLS_MIN_SIMILARITY = 0.53;
-var CLIENT_TOOLS_RELEVANCE_RATIO = 0.75;
-function isNewToolFormat(tool) {
-  return "schema" in tool && tool.schema !== void 0;
-}
-function isNewResponseFormat(response) {
-  return "checksum" in response && "tools" in response && typeof response.checksum === "string";
-}
-function convertServerToolsResponse(response) {
-  let toolsMap;
-  let checksum;
-  if (isNewResponseFormat(response)) {
-    toolsMap = response.tools;
-    checksum = response.checksum;
-  } else {
-    toolsMap = response;
-  }
-  const tools = Object.values(toolsMap).map((tool) => {
-    if (isNewToolFormat(tool)) {
-      return {
-        type: "function",
-        name: tool.schema.name,
-        description: tool.schema.description,
-        parameters: tool.schema.parameters,
-        ...tool.embedding && { embedding: tool.embedding }
-      };
-    }
-    return {
-      type: "function",
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    };
-  });
-  return { tools, checksum };
+// src/lib/memory/store/remoteTopics.ts
+function topic(value) {
+  const t = value;
+  if (!t || typeof t.name !== "string" || !t.name || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
+    throw new Error("Invalid nearby topic");
+  return t;
 }
-function toCompletionsFormat(tool) {
+function createRemoteTopicPersistence(request) {
   return {
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
+    topics: async () => {
+      const out = [];
+      let cursor;
+      do {
+        const page = await request(
+          "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
+          {}
+        );
+        if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
+          throw new Error("Invalid nearby topic page");
+        out.push(...page.items.map(topic));
+        cursor = page.next_cursor;
+      } while (cursor);
+      return out;
+    },
+    putTopic: async (value, expectedVersion) => {
+      if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
+        throw new Error("Expected topic version must be a nonnegative integer");
+      return topic(
+        await request("/topics", {
+          method: "PUT",
+          body: JSON.stringify({ topic: value, expected_version: expectedVersion })
+        })
+      );
+    },
+    importTopics: async (topics, signal) => {
+      for (let i = 0; i < topics.length; i += 50) {
+        signal?.throwIfAborted();
+        await request(
+          "/topics/import",
+          {
+            method: "POST",
+            body: JSON.stringify({ topics: topics.slice(i, i + 50) })
+          },
+          signal
+        );
+      }
+      signal?.throwIfAborted();
     }
   };
 }
-function toResponsesFormat(tool) {
-  return {
-    type: "function",
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters
-  };
-}
-function getCachedServerTools() {
-  if (typeof localStorage === "undefined") return null;
+async function createRemoteTopic(persistence, name) {
+  const canonical = normalizeEntityName(name);
+  if (!canonical) return null;
+  const existing = (await persistence.topics()).find((t) => t.name === canonical);
+  if (existing && !existing.is_deleted) return canonical;
   try {
-    const cached = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
-    if (!cached) return null;
-    const parsed = JSON.parse(cached);
-    if (parsed.version !== CACHE_VERSION) {
-      removeLocalStorageCache();
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
+    await persistence.putTopic(
+      { name: canonical, is_deleted: false, ...existing?.kind && { kind: existing.kind } },
+      existing?.version ?? 0
+    );
+  } catch (error) {
+    if (!(error instanceof RemoteMemoryError) || error.code !== "version_conflict") throw error;
+    const current = (await persistence.topics()).find((t) => t.name === canonical);
+    if (!current || current.is_deleted) throw error;
   }
+  return canonical;
 }
-function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
-  if (!cache) return true;
-  return Date.now() - cache.timestamp > expirationMs;
-}
-function buildCacheEntry(tools, checksum, etag) {
+
+// src/lib/memory/store/remoteWork.ts
+function createRemoteWorkPersistence(request) {
   return {
-    tools,
-    timestamp: Date.now(),
-    version: CACHE_VERSION,
-    ...checksum && { checksum },
-    ...etag && { etag }
+    claimWork: async (kind, processorVersion, token) => {
+      const result = await request("/work/claim", {
+        method: "POST",
+        body: JSON.stringify({
+          kind,
+          processor_version: processorVersion,
+          ...token && { token }
+        })
+      });
+      if (!result || typeof result !== "object") throw new Error("Invalid nearby work lease");
+      const lease = result.lease;
+      if (lease === void 0) return null;
+      if (!lease || lease.kind !== kind || typeof lease.token !== "string" || !lease.token || lease.processor_version !== processorVersion || typeof lease.expires_at !== "string" || !Number.isFinite(Date.parse(lease.expires_at)))
+        throw new Error("Invalid nearby work lease");
+      return lease;
+    },
+    releaseWork: async (kind, token) => {
+      await request("/work/release", { method: "POST", body: JSON.stringify({ kind, token }) });
+    }
   };
 }
-function writeLocalStorageCache(entry) {
-  if (typeof localStorage === "undefined") return;
+async function withRemoteWorkLease(persistence, kind, processorVersion, task) {
+  const lease = await persistence.claimWork(kind, processorVersion);
+  if (!lease) return null;
+  const controller = new AbortController();
+  const leaseLostError = new RemoteMemoryError("Maintenance lease lost", 409, "work_lease_expired");
+  const cancelled = new Promise((_resolve, reject) => {
+    controller.signal.addEventListener("abort", () => reject(leaseLostError), {
+      once: true
+    });
+  });
+  let renewing;
+  const timer = setInterval(() => {
+    if (renewing || controller.signal.aborted) return;
+    renewing = persistence.claimWork(kind, processorVersion, lease.token).then((renewed) => {
+      if (!renewed) controller.abort(leaseLostError);
+    }).catch((error) => getLogger().warn("[memory/work] Lease renewal failed:", error)).finally(() => {
+      renewing = void 0;
+    });
+  }, 3e4);
   try {
-    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(entry));
+    const result = await Promise.race([task(lease.token, controller.signal), cancelled]);
+    await renewing;
+    return controller.signal.aborted ? null : result;
   } catch (error) {
-    getLogger().warn("[serverTools] Failed to cache tools:", error);
+    if (controller.signal.aborted || isRemoteWorkLeaseExpired(error)) return null;
+    throw error;
+  } finally {
+    clearInterval(timer);
+    await renewing;
+    await persistence.releaseWork(kind, lease.token).catch((error) => getLogger().warn("[memory/work] Lease release failed:", error));
   }
 }
-function removeLocalStorageCache() {
-  if (typeof localStorage === "undefined") return;
-  localStorage.removeItem(SERVER_TOOLS_CACHE_KEY);
-}
-var localStorageToolsCache = {
-  get: getCachedServerTools,
-  set: writeLocalStorageCache,
-  clear: removeLocalStorageCache
-};
-function clearServerToolsCache(cache = localStorageToolsCache) {
-  return cache.clear?.();
-}
-function getToolsChecksum2(cache = localStorageToolsCache) {
-  const cached = cache.get();
-  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
+function isRemoteWorkLeaseExpired(error) {
+  return error instanceof RemoteMemoryError && error.code === "work_lease_expired";
 }
-function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
-  if (!responseChecksum) {
-    return false;
+
+// src/lib/memory/store/remotePersistence.ts
+var RemoteMemoryError = class extends Error {
+  constructor(message, status, code, retryAfterMs, rateLimitBucket) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfterMs = retryAfterMs;
+    this.rateLimitBucket = rateLimitBucket;
+    this.name = "RemoteMemoryError";
   }
-  const decide = (cachedChecksum2) => !cachedChecksum2 || cachedChecksum2 !== responseChecksum;
+};
+var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var memoryFields = {
+  memory_id: true,
+  content: true,
+  scope: true,
+  created_at: true,
+  updated_at: true,
+  is_deleted: true,
+  embedding: true,
+  embedding_model: true,
+  kind: true,
+  kind_value: true,
+  level: true,
+  folder_id: true,
+  source_chunk_ids: true,
+  proof_count: true,
+  source: true,
+  event_time_start: true,
+  event_time_end: true,
+  event_time_kind: true,
+  topics_user_managed: true,
+  topics: true,
+  topics_updated_at: true,
+  media: true,
+  topics_extracted_at: true,
+  topics_extracted_version: true,
+  superseded_by: true,
+  superseded_at: true,
+  last_observed_at: true,
+  fact_type: true,
+  archived_at: true,
+  trust_tier: true,
+  visibility: true,
+  twin_opt_in: true,
+  published_at: true,
+  geohash: true
+};
+var candidateListLimits = [
+  ["scopes", 20],
+  ["fact_types", 20],
+  ["memory_ids", 1e3],
+  ["force_ids", 100]
+];
+var queryListLimits = [
+  ["scopes", 20],
+  ["fact_types", 20],
+  ["visibility", 20],
+  ["memory_ids", 1e3],
+  ["topics", 100]
+];
+var queryFields = [
+  "include_deleted",
+  "include_archived",
+  "include_quarantined",
+  "include_superseded",
+  "archived_only",
+  "scopes",
+  "fact_types",
+  "visibility",
+  "memory_ids",
+  "topics",
+  "updated_after",
+  "topics_due",
+  "topics_extracted",
+  "event_time_overlaps",
+  "order",
+  "cursor",
+  "limit",
+  "include_embeddings"
+];
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function memoryRecord(value) {
+  if (!record(value) || !record(value.memory) || typeof value.memory.memory_id !== "string" || typeof value.memory.content !== "string" || typeof value.memory.scope !== "string" || typeof value.memory.created_at !== "number" || typeof value.memory.updated_at !== "number" || typeof value.memory.is_deleted !== "boolean" || !Number.isSafeInteger(value.version) || value.version < 1 || typeof value.server_updated_at !== "string" || value.score !== void 0 && (typeof value.score !== "number" || !Number.isFinite(value.score))) {
+    throw new Error("Invalid nearby private-memory response");
+  }
+  return value;
+}
+function createNearbyRequest(options, apiPath = "/api/private-memories") {
+  const base = new URL(options.baseUrl);
+  if (!/^https?:$/.test(base.protocol) || base.username || base.password || base.search || base.hash) {
+    throw new Error(
+      "baseUrl must be an HTTP(S) origin or base path without credentials, query or fragment"
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("timeoutMs must be a positive number");
+  const root = base.href.replace(/\/$/, "") + apiPath;
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const cooldowns = /* @__PURE__ */ new Map();
+  const memoryBudget = (path, method) => {
+    if (method === "PUT")
+      return path === "/topics" ? "private-memory-import" : "private-memory-write";
+    if (method === "POST" && ["/import", "/memories/batch", "/topics/import"].includes(path))
+      return "private-memory-import";
+    return "private-memory-read";
+  };
+  const request = async (path, init = {}, signal) => {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const forwardAbort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) forwardAbort();
+    else signal?.addEventListener("abort", forwardAbort, { once: true });
+    let rejectAborted;
+    const aborted2 = new Promise((_, reject) => {
+      rejectAborted = () => reject(
+        controller.signal.reason instanceof Error ? controller.signal.reason : new Error("Nearby request aborted")
+      );
+      if (controller.signal.aborted) rejectAborted();
+      else controller.signal.addEventListener("abort", rejectAborted, { once: true });
+    });
+    aborted2.catch(() => void 0);
+    try {
+      const token = await Promise.race([options.getToken(), aborted2]);
+      if (controller.signal.aborted) await aborted2;
+      if (!token) throw new RemoteMemoryError("Authentication required", 401);
+      const pathname = path.split("?")[0];
+      const route = `${init.method ?? "GET"} ${pathname}`;
+      const budgets = ["*", route];
+      if (apiPath === "/api/private-memories")
+        budgets.push("private-memory-ip", memoryBudget(pathname, init.method ?? "GET"));
+      for (const bucket of budgets) {
+        const cooldown = cooldowns.get(bucket);
+        if (!cooldown) continue;
+        const remaining = cooldown.until - Date.now();
+        if (remaining > 0)
+          throw new RemoteMemoryError(
+            cooldown.error.message,
+            429,
+            cooldown.error.code,
+            remaining,
+            cooldown.error.rateLimitBucket
+          );
+        cooldowns.delete(bucket);
+      }
+      const response = await fetcher(root + path, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...init.body ? { "Content-Type": "application/json" } : {}
+        },
+        redirect: "error",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => null);
+        const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After"));
+        const error = new RemoteMemoryError(
+          record(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
+          response.status,
+          record(body) && typeof body.code === "string" ? body.code : void 0,
+          retryAfter ?? void 0,
+          record(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
+        );
+        if (response.status === 429 && retryAfter !== null && retryAfter > 0 && (!error.code || error.code === "rate_limited")) {
+          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
+          cooldowns.set(bucket, { until: Date.now() + retryAfter, error });
+        }
+        throw error;
+      }
+      if (response.status === 204) return null;
+      return await response.json();
+    } catch (error) {
+      if (timedOut) throw new RemoteMemoryError("Nearby request timed out", 408, "timeout");
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", forwardAbort);
+      if (rejectAborted) controller.signal.removeEventListener("abort", rejectAborted);
+    }
+  };
+  return request;
+}
+async function createRemoteMemoryPersistence(options) {
+  if (!options.keyId || options.keyId.length > 256)
+    throw new Error("A canonical keyId is required");
+  const request = createNearbyRequest(options);
+  const account = await request("/account", {}, options.signal);
+  if (!record(account) || account.state !== "active") {
+    throw new RemoteMemoryError(
+      "Complete and verify migration before using remote memories",
+      409,
+      "memory_not_active"
+    );
+  }
+  if (account.key_id !== options.keyId) {
+    throw new RemoteMemoryError(
+      "The canonical memory key does not match this account",
+      409,
+      "key_mismatch"
+    );
+  }
+  const snapshots = /* @__PURE__ */ new WeakMap();
+  const decode = async (value) => {
+    const item = memoryRecord(value);
+    const decrypt = async (ciphertext) => {
+      if (!ciphertextPattern.test(ciphertext))
+        throw new Error("Nearby returned unencrypted memory content");
+      const plaintext = await options.decrypt(ciphertext);
+      if (plaintext === ciphertext) throw new Error("Memory decryption failed");
+      return plaintext;
+    };
+    const decoded = {
+      ...item,
+      memory: {
+        ...item.memory,
+        content: item.memory.is_deleted && item.memory.content === "" ? "" : await decrypt(item.memory.content),
+        ...item.memory.kind_value !== void 0 && {
+          kind_value: await decrypt(item.memory.kind_value)
+        }
+      }
+    };
+    return remember(decoded, item);
+  };
+  const remember = (decoded, item) => {
+    snapshots.set(decoded, {
+      id: item.memory.memory_id,
+      version: item.version,
+      content: decoded.memory.content,
+      kindValue: decoded.memory.kind_value,
+      encryptedContent: item.memory.content,
+      encryptedKindValue: item.memory.kind_value
+    });
+    return decoded;
+  };
+  const decodeAll = async (values) => {
+    const records = values.map(memoryRecord);
+    const settled = await Promise.allSettled(records.map(decode));
+    const items = [];
+    const failed = [];
+    settled.forEach((result, i) => {
+      if (result.status === "fulfilled") items.push(result.value);
+      else
+        failed.push({
+          memory_id: records[i].memory.memory_id,
+          version: records[i].version,
+          error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+        });
+    });
+    return { items, failed };
+  };
+  const decodeCommitted = async (value, write) => {
+    const item = memoryRecord(value);
+    if (item.memory.memory_id !== write.body.memory.memory_id || item.memory.content !== write.body.memory.content || item.memory.kind_value !== write.body.memory.kind_value)
+      return decode(item);
+    return remember(
+      {
+        ...item,
+        memory: {
+          ...item.memory,
+          content: write.content,
+          ...write.kindValue !== void 0 && { kind_value: write.kindValue }
+        }
+      },
+      item
+    );
+  };
+  const encryptField2 = async (plaintext) => {
+    const ciphertext = await options.encrypt(plaintext);
+    if (ciphertext === plaintext || !ciphertextPattern.test(ciphertext))
+      throw new Error("Field encryption must return SDK ciphertext; refusing to upload plaintext");
+    return ciphertext;
+  };
+  const memoryPath = (id2) => {
+    if (!id2 || id2.length > 128) throw new Error("memory_id must be 1\u2013128 characters");
+    return "/memories/" + encodeURIComponent(id2);
+  };
+  const prepareWrite = async (memory, expectedVersion, signal) => {
+    const unknown = Object.keys(memory).filter(
+      (key3) => !Object.prototype.hasOwnProperty.call(memoryFields, key3)
+    );
+    if (unknown.length) {
+      throw new RemoteMemoryError(
+        `Unknown private-memory fields (${unknown.join(", ")}); refusing to forward them`,
+        400,
+        "unknown_field"
+      );
+    }
+    memory = { ...memory, ...memory.embedding && { embedding: [...memory.embedding] } };
+    const path = memoryPath(memory.memory_id);
+    const snapshot = typeof expectedVersion === "number" ? void 0 : snapshots.get(expectedVersion);
+    if (typeof expectedVersion !== "number" && (!snapshot || snapshot.id !== memory.memory_id || snapshot.version !== expectedVersion.version))
+      throw new Error(
+        "Expected snapshot must be an unmodified version from this persistence instance"
+      );
+    expectedVersion = typeof expectedVersion === "number" ? expectedVersion : snapshot.version;
+    if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
+      throw new Error("expectedVersion must be a nonnegative integer");
+    const conflict2 = () => new RemoteMemoryError("The memory changed since it was read", 409, "version_conflict");
+    let existing;
+    if (expectedVersion !== 0 && !snapshot) {
+      try {
+        existing = memoryRecord(await request(path, {}, signal));
+      } catch (error) {
+        if (error instanceof RemoteMemoryError && error.status === 404) throw conflict2();
+        throw error;
+      }
+    }
+    if (existing && existing.version !== expectedVersion) throw conflict2();
+    const decoded = existing ? await decode(existing).catch(() => void 0) : void 0;
+    const reusableContent = snapshot?.encryptedContent ?? existing?.memory.content;
+    const content = reusableContent && (snapshot?.content ?? decoded?.memory.content) === memory.content ? reusableContent : await encryptField2(memory.content);
+    const kindValue = memory.kind_value === void 0 ? void 0 : (snapshot?.kindValue ?? decoded?.memory.kind_value) === memory.kind_value ? snapshot?.encryptedKindValue ?? existing.memory.kind_value : await encryptField2(memory.kind_value);
+    return {
+      body: {
+        expected_version: expectedVersion,
+        memory: { ...memory, content, ...kindValue !== void 0 && { kind_value: kindValue } }
+      },
+      content: memory.content,
+      kindValue: memory.kind_value
+    };
+  };
+  const fetchCandidates = async (embedding2, candidateOptions, withCounts) => {
+    const limit = candidateOptions.limit ?? 100;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      throw new Error("Candidate limit must be 1\u2013100");
+    for (const [key3, max] of candidateListLimits) {
+      const values = candidateOptions[key3];
+      if (values && values.length > max)
+        throw new Error(`Candidate ${key3} accepts at most ${max} entries (got ${values.length})`);
+    }
+    const result = await request(
+      "/candidates",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          embedding: embedding2,
+          limit,
+          force_ids: candidateOptions.force_ids ?? [],
+          ...withCounts && { with_counts: true },
+          ...Object.fromEntries(
+            [
+              "scopes",
+              "memory_ids",
+              "embedding_model",
+              "strict_model",
+              "include_deleted",
+              "deleted_only"
+            ].filter(
+              (key3) => candidateOptions[key3] !== void 0
+            ).map((key3) => [key3, candidateOptions[key3]])
+          ),
+          ...candidateOptions.fact_types !== void 0 && {
+            fact_types: candidateOptions.fact_types
+          },
+          ...candidateOptions.include_archived !== void 0 && {
+            include_archived: candidateOptions.include_archived
+          },
+          ...candidateOptions.include_quarantined !== void 0 && {
+            include_quarantined: candidateOptions.include_quarantined
+          },
+          ...candidateOptions.include_superseded !== void 0 && {
+            include_superseded: candidateOptions.include_superseded
+          }
+        })
+      },
+      candidateOptions.signal
+    );
+    if (!record(result) || !Array.isArray(result.items))
+      throw new Error("Invalid nearby candidate response");
+    return result;
+  };
+  const fetchQueryPage = async (queryOptions) => {
+    const { signal, ...query } = queryOptions;
+    if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
+      throw new Error("Page limit must be 1\u2013200");
+    for (const [key3, max] of queryListLimits) {
+      const values = query[key3];
+      if (values && values.length > max)
+        throw new Error(`Query ${key3} accepts at most ${max} entries (got ${values.length})`);
+    }
+    const page = await request(
+      "/memories/query",
+      {
+        method: "POST",
+        body: JSON.stringify(
+          Object.fromEntries(
+            queryFields.filter((key3) => query[key3] !== void 0).map((key3) => [key3, query[key3]])
+          )
+        )
+      },
+      signal
+    );
+    if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
+      throw new Error("Invalid nearby private-memory page");
+    return page;
+  };
+  const candidateSet = async (embedding2, candidateOptions = {}) => {
+    const result = await fetchCandidates(embedding2, candidateOptions, true);
+    if (!Number.isSafeInteger(result.total_count) || result.total_count < 0 || !Number.isSafeInteger(result.unavailable_count) || result.unavailable_count < 0)
+      throw new Error("Invalid nearby candidate response");
+    return {
+      ...await decodeAll(result.items),
+      total_count: result.total_count,
+      unavailable_count: result.unavailable_count
+    };
+  };
+  return {
+    ...createRemoteTopicPersistence(request),
+    ...createRemoteWorkPersistence(request),
+    supportsRealtimeChanges: account.realtime_changes === true,
+    counts: async () => {
+      const result = await request("/counts", {});
+      if (!record(result) || ["live", "archived", "quarantined"].some(
+        (key3) => !Number.isSafeInteger(result[key3]) || result[key3] < 0
+      ))
+        throw new Error("Invalid nearby memory counts");
+      return {
+        live: result.live,
+        archived: result.archived,
+        quarantined: result.quarantined
+      };
+    },
+    temporal: async (window2, limit = 100) => {
+      if (!Number.isFinite(window2.start) || !Number.isFinite(window2.end) || window2.end <= window2.start || !Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("Temporal window must have end > start and limit must be 1\u2013100");
+      const result = await request("/temporal", {
+        method: "POST",
+        body: JSON.stringify({ ...window2, limit })
+      });
+      if (!record(result) || !Array.isArray(result.items) || result.items.some(
+        (item) => !record(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
+      ))
+        throw new Error("Invalid nearby temporal candidates");
+      return result.items.map((item) => item.memory_id);
+    },
+    get: async (id2, signal) => {
+      try {
+        return await decode(await request(memoryPath(id2), {}, signal));
+      } catch (error) {
+        if (error instanceof RemoteMemoryError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    list: async (listOptions = {}) => {
+      const { signal, ...query } = listOptions;
+      if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) {
+        throw new Error("Page limit must be 1\u2013200");
+      }
+      const params = new URLSearchParams();
+      for (const key3 of [
+        "cursor",
+        "limit",
+        "include_deleted",
+        "include_archived",
+        "include_quarantined",
+        "include_superseded",
+        "include_embeddings"
+      ]) {
+        if (query[key3] !== void 0) params.set(key3, String(query[key3]));
+      }
+      const page = await request("/memories?" + params.toString(), {}, signal);
+      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
+        throw new Error("Invalid nearby private-memory page");
+      }
+      return {
+        ...await decodeAll(page.items),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
+      };
+    },
+    put: async (memory, expectedVersion, signal) => {
+      const write = await prepareWrite(memory, expectedVersion, signal);
+      return decodeCommitted(
+        await request(
+          memoryPath(write.body.memory.memory_id),
+          {
+            method: "PUT",
+            body: JSON.stringify({ key_id: options.keyId, ...write.body })
+          },
+          signal
+        ),
+        write
+      );
+    },
+    putMany: async (writes, signal, leaseToken) => {
+      if (writes.length < 1 || writes.length > 50 || new Set(writes.map((w) => w.memory.memory_id)).size !== writes.length)
+        throw new Error("Batch must contain 1\u201350 distinct memory ids");
+      const prepared = await Promise.all(
+        writes.map((w) => prepareWrite(w.memory, w.expectedVersion, signal))
+      );
+      const result = await request(
+        "/memories/batch",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            key_id: options.keyId,
+            writes: prepared.map((w) => w.body),
+            ...leaseToken && { lease_token: leaseToken }
+          })
+        },
+        signal
+      );
+      if (!record(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
+        throw new Error("Invalid nearby batch response");
+      return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
+    },
+    query: async (queryOptions = {}) => {
+      const page = await fetchQueryPage(queryOptions);
+      return {
+        ...await decodeAll(page.items),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor },
+        ...page.changes_cursor !== void 0 && { changes_cursor: page.changes_cursor }
+      };
+    },
+    queryMetadata: async (queryOptions = {}) => {
+      const page = await fetchQueryPage(queryOptions);
+      return {
+        items: page.items.map((item) => {
+          const {
+            memory: { content: _content, kind_value: _kindValue, ...memory },
+            version,
+            server_updated_at
+          } = memoryRecord(item);
+          return { memory, version, server_updated_at };
+        }),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
+      };
+    },
+    candidateSet,
+    candidates: async (embedding2, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding2, candidateOptions, false)).items)
+  };
+}
+
+// src/lib/chat/inbox.ts
+var ENVELOPE_ALG = "ECDH-ES+HKDF-SHA256+A256GCM";
+var HKDF_INFO_PREFIX = "anuma-inbox-v1:";
+var encoder = new TextEncoder();
+function toBase64Url(bytes4) {
+  let binary = "";
+  for (const byte of bytes4) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]*$/.test(value)) {
+    throw new Error("Inbox envelope field is not base64url");
+  }
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+function isInboxItem(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.id === "string" && typeof v.sealed === "string";
+}
+function createVaultInbox(options) {
+  const request = createNearbyRequest(options, "/api/private-chats");
+  return {
+    putPublicKey: async (publicKey) => {
+      await request("/public-key", {
+        method: "PUT",
+        body: JSON.stringify({ public_key: publicKey })
+      });
+    },
+    list: async () => {
+      const body = await request("/inbox");
+      return Array.isArray(body?.items) ? body.items.filter(isInboxItem) : [];
+    },
+    remove: async (id2) => {
+      await request(`/inbox/${encodeURIComponent(id2)}`, { method: "DELETE" });
+    }
+  };
+}
+async function exportInboxPublicKey(publicKey) {
+  return toBase64Url(new Uint8Array(await crypto.subtle.exportKey("raw", publicKey)));
+}
+async function openInboxItem(item, keyPair) {
+  const envelope = JSON.parse(item.sealed);
+  if (envelope.v !== 1 || envelope.alg !== ENVELOPE_ALG) {
+    throw new Error("Unsupported inbox envelope");
+  }
+  const epk = fromBase64Url(envelope.epk);
+  const iv = fromBase64Url(envelope.iv);
+  const ciphertext = fromBase64Url(envelope.ct);
+  if (epk.length !== 65 || iv.length !== 12) throw new Error("Malformed inbox envelope");
+  const ephemeral = await crypto.subtle.importKey(
+    "raw",
+    epk,
+    { name: "ECDH", namedCurve: "P-256" },
+    false,
+    []
+  );
+  const shared = await crypto.subtle.deriveBits(
+    { name: "ECDH", public: ephemeral },
+    keyPair.privateKey,
+    256
+  );
+  const recipient = new Uint8Array(await crypto.subtle.exportKey("raw", keyPair.publicKey));
+  const salt = new Uint8Array(epk.length + recipient.length);
+  salt.set(epk);
+  salt.set(recipient, epk.length);
+  const ikm = await crypto.subtle.importKey("raw", shared, "HKDF", false, ["deriveKey"]);
+  const key3 = await crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info: encoder.encode(HKDF_INFO_PREFIX + item.id) },
+    ikm,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["decrypt"]
+  );
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, additionalData: encoder.encode(item.id) },
+    key3,
+    ciphertext
+  );
+  const opened = JSON.parse(new TextDecoder().decode(plaintext));
+  if (opened.v !== 1 || opened.inference_id !== item.id || !opened.response) {
+    throw new Error("Inbox item does not match its id");
+  }
+  return opened;
+}
+function inboxReplaces(row, opened) {
+  if (row.error) return true;
+  return row.wasStopped === true && opened.status === "completed";
+}
+async function clearTurnErrors(backend, answer) {
+  const parentId = answer.parentMessageId;
+  if (parentId) {
+    const [parent] = await backend.getMessagesByIds([parentId]);
+    if (parent?.error) await backend.updateMessageError(parentId, null);
+  }
+  if (!answer.error) return answer;
+  return await backend.updateMessageError(answer.uniqueId, null) ?? answer;
+}
+async function deliverInboxAnswers(options) {
+  const { inbox, keyPair, backend, store } = options;
+  const results = [];
+  for (const item of await inbox.list()) {
+    let opened;
+    try {
+      opened = await openInboxItem(item, keyPair);
+    } catch (err) {
+      results.push({
+        id: item.id,
+        conversationId: null,
+        status: "unreadable",
+        assistantMessage: null,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    const base = { id: item.id, conversationId: opened.conversation_id };
+    try {
+      const messageId = opened.assistant_message_id ?? `msg_bg_${opened.inference_id}`;
+      const [found] = await backend.getMessagesByIds([messageId]);
+      const existing = found && inboxReplaces(found, opened) ? void 0 : found;
+      if (!found) {
+        const parent = opened.parent_message_id;
+        const ownsTurn = parent ? (await backend.getMessagesByIds([parent])).length > 0 : await backend.getConversation(opened.conversation_id) !== null;
+        if (!ownsTurn) {
+          results.push({ ...base, status: "elsewhere", assistantMessage: null });
+          continue;
+        }
+      }
+      const stored2 = existing ?? await store(opened, messageId);
+      await inbox.remove(item.id);
+      results.push({
+        ...base,
+        status: existing ? "delivered" : "stored",
+        assistantMessage: stored2
+      });
+    } catch (err) {
+      results.push({
+        ...base,
+        status: "retry",
+        assistantMessage: null,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+
+// src/lib/chat/reservationReceipts.ts
+var ACTIONS = [
+  {
+    kind: "booking",
+    tool: "anuma_book_restaurant",
+    alreadyDone: /^Tool "[^"]*" failed: ALREADY_BOOKED:/
+  },
+  {
+    kind: "cancel",
+    tool: "anuma_cancel_reservation",
+    alreadyDone: /^Tool "[^"]*" failed: ALREADY_CANCELLED:/
+  }
+];
+var NOT_AN_ATTEMPT = /^Tool "[^"]*" (has already been called|was already called)/;
+var BOOKING_OUTCOME_UNKNOWN = /^Tool "[^"]*" failed: BOOKING_OUTCOME_UNKNOWN:/;
+var CANCEL_OUTCOME_UNKNOWN = "CANCEL_OUTCOME_UNKNOWN";
+function extractReservationReceipts(toolCallEvents) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of toolCallEvents ?? []) {
+    const action = ACTIONS.find((a) => event.name?.endsWith(a.tool));
+    const output = event.output ?? "";
+    if (!action || !output || hasEncryptedToolPayload(event) || NOT_AN_ATTEMPT.test(output))
+      continue;
+    const kept = latest.get(action.kind)?.status;
+    if (kept === "made") continue;
+    const receipt = toReceipt(action, event.arguments ?? "", output);
+    if (kept === "unknown" && receipt.status !== "made") continue;
+    latest.set(action.kind, receipt);
+  }
+  return [...latest.values()];
+}
+function toReceipt(action, argumentsJson, output) {
+  const args = parseObject(argumentsJson);
+  const result = parseObject(output);
+  return {
+    kind: action.kind,
+    venueName: text2(args.venue_name) ?? "",
+    day: text2(args.day) ?? "",
+    time: text2(args.time) ?? "",
+    partySize: count(args.party_size),
+    reservationId: text2(result.reservation_id) ?? text2(args.reservation_id),
+    resyUrl: text2(result.reservations_url),
+    feeSummary: text2(result.fee_summary),
+    ...outcome(action, output, result)
+  };
+}
+function outcome(action, output, result) {
+  if (action.alreadyDone.test(output)) return { status: "already_done" };
+  const reason = text2(result.error);
+  if (action.kind === "booking") {
+    if (BOOKING_OUTCOME_UNKNOWN.test(output)) return { status: "unknown" };
+    const held = result.success === true || text2(result.reservation_id) !== void 0;
+    return held ? { status: "made" } : { status: "not_made", reason };
+  }
+  if (result.error_code === CANCEL_OUTCOME_UNKNOWN) return { status: "unknown", reason };
+  const cancelled = result.success === true && !result.error && !result.error_code;
+  return cancelled ? { status: "made" } : { status: "not_made", reason };
+}
+function parseObject(json5) {
+  try {
+    const parsed = JSON.parse(json5);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function text2(value) {
+  if (typeof value === "number") return String(value);
+  return typeof value === "string" && value ? value : void 0;
+}
+function count(value) {
+  const n = typeof value === "string" && value.trim() ? Number(value) : value;
+  return typeof n === "number" && Number.isFinite(n) ? n : void 0;
+}
+
+// src/tools/confirmConstants.ts
+var CONFIRM_TOOL_NAME = "prompt_user_confirm";
+var BOOK_RESTAURANT = {
+  tool: "AnumaPaymentsMCP-anuma_book_restaurant",
+  status: "confirmed_not_booked",
+  fields: ["venue_id", "config_id", "party_size", "day", "venue_name", "time"]
+};
+var CANCEL_RESERVATION = {
+  tool: "AnumaPaymentsMCP-anuma_cancel_reservation",
+  status: "confirmed_not_cancelled",
+  fields: [
+    "reservation_id",
+    "venue_name",
+    "day",
+    "time",
+    "party_size",
+    "fee_applies",
+    "fee_amount"
+  ]
+};
+var CONFIRM_REQUIRED_FIELDS = /* @__PURE__ */ new Map([
+  ["book_restaurant", BOOK_RESTAURANT],
+  ["anuma_book_restaurant", BOOK_RESTAURANT],
+  ["anumapaymentsmcp-anuma_book_restaurant", BOOK_RESTAURANT],
+  ["cancel_reservation", CANCEL_RESERVATION],
+  ["anuma_cancel_reservation", CANCEL_RESERVATION],
+  ["anumapaymentsmcp-anuma_cancel_reservation", CANCEL_RESERVATION]
+]);
+function confirmRequirement(action) {
+  if (typeof action !== "string") return void 0;
+  return CONFIRM_REQUIRED_FIELDS.get(action.trim().toLowerCase());
+}
+function missingConfirmFields(action, parameters) {
+  const requirement = confirmRequirement(action);
+  if (!requirement) return [];
+  const shown = /* @__PURE__ */ new Set();
+  for (const parameter of Array.isArray(parameters) ? parameters : []) {
+    const { name, value } = parameter ?? {};
+    if (typeof name === "string" && typeof value === "string" && value.trim()) shown.add(name);
+  }
+  return requirement.fields.filter((field10) => !shown.has(field10));
+}
+
+// src/tools/walletPaymentConstants.ts
+var SELECT_PAYMENT_WALLET_TOOL_NAME = "select_payment_wallet";
+var WALLET_PAYMENT_TOOL_NAME = "prompt_wallet_payment";
+var FLIGHT_BOOK_TOOL_SET = "flight-book";
+var FLIGHT_SERVER_TOOL_NAMES = [
+  "AnumaPaymentsMCP-anuma_search_flights",
+  "AnumaPaymentsMCP-anuma_flight_offer_details",
+  "AnumaPaymentsMCP-anuma_create_flight_intent",
+  "AnumaPaymentsMCP-anuma_get_flight_booking"
+];
+
+// src/lib/storage/mcpImages.ts
+var IMAGE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "AnumaMediaMCP-anuma_create_image",
+  "anuma_create_image",
+  "AnumaImageMCP-generate_cloud_image",
+  "AnumaImageMCP-edit_cloud_image",
+  "generate_cloud_image",
+  "edit_cloud_image"
+]);
+function toolOutputForModel(name, output) {
+  if (!name || !IMAGE_TOOL_NAMES.has(name)) return output;
+  try {
+    const {
+      imageUrl: _imageUrl,
+      url: _url,
+      output_images: _outputImages,
+      ...rest
+    } = JSON.parse(output);
+    return JSON.stringify(rest);
+  } catch {
+    return output;
+  }
+}
+var VIDEO_EXTENSIONS = ["mp4", "webm", "mov"];
+var VIDEO_EXTENSION_RE = new RegExp(`\\.(${VIDEO_EXTENSIONS.join("|")})(?:[?#]|$)`, "i");
+
+// src/tools/appBuilderPrompt.ts
+var APP_BUILDER_PROMPT = `App Builder tools (create_file, patch_file, and the rest described below) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should build anything.
+
+Build ONLY when the user gives an explicit instruction to build, create, generate, or change an app, tool, or UI \u2014 e.g. "build a todo app", "make a snake game", "add a footer to the app", "change the background to blue". A bare app name or feature reference is NOT a build instruction: if the user just says "todo app", "a snake game", or "qr code", or asks a question about an app, do NOT generate anything \u2014 reply normally, or ask what they'd like you to build. The same holds for greetings, questions, stories, explanations, advice, or code that isn't a runnable app: respond normally and do not create files. When it's unclear whether the user actually wants an app built, ask instead of building.
+
+Once the user HAS given an explicit build instruction, you are in App Builder mode: you produce polished, production-quality React apps that feel designed \u2014 not generic.
+
+DESIGN: on the initial build, before writing code, briefly state (2-3 sentences) what you want this app to feel like \u2014 name the specific fonts, the palette in hex, and one signature detail. Be concrete: "Fraunces display + Inter body + JetBrains Mono metadata, terracotta #b75432 accent on bone #f3efe6, paper-grain texture via inline SVG noise" is the kind of specificity that anchors the build. Default to nothing: don't pick "safe modern productivity" unless the brief literally asks for utilitarian. On later turns, state a design brief only when the change is visual (a restyle, new theme, or new UI); for a text, logic, data, or behavior-only change, skip the brief and just make the change.
+
+EDIT SCOPE: Change only the files and lines required by the current user request. A title rename is a text edit, not a design change. Preserve styles, dependencies, and unrelated logic on text edits. Design feedback does not authorize unrelated edits.
+
+WORKFLOW:
+1. NEVER output code as text or markdown. ALWAYS use tools.
+2. Initial build: state your design brief, then create_file with a "files" array writing ALL files in one call. The preview renders automatically.
+3. patch_file requires read_file for that path earlier in the conversation (or create_file in the same conversation, which counts). read_file output is numbered "42: <text>" \u2014 the prefix is display-only; never copy it into "find". Each "find" must match exactly one location \u2014 include 2-3 lines of surrounding context. Pass multiple patches per call to change distinct locations.
+4. Prefer patch_file for changes to existing files \u2014 surgical, reviewable, preserves surrounding code. Reserve create_file overwrites for substantial restructuring. Inserts: find the line before, replace with that line + the new line. Deletes: empty replace.
+5. On the initial build, when adding new UI, or after user-requested design changes, call critique_design first and then audit_design. Critique checks taste, hierarchy, and distinctiveness. Audit checks tokens, focus states, aria-labels, alt text, and heading order. Patch only issues within the current user request. For text, logic, or data edits, skip both design tools.
+6. Before declaring done, call verify_app. The host's preview runtime reports whether your app actually mounted and surfaces any errors it captured \u2014 hallucinated imports, syntax the bundler rejected, undefined components, runtime crashes. If \`rendered\` is false or \`errors\` is non-empty, fix every error before the next message. If the response includes a \`note\` that verify_app isn't wired in this host, skip runtime verification. An unavailable runtime verifier does not authorize design changes. Use audit_design and critique_design only for the initial build, adding new UI, or user-requested design changes.
+7. Keep responses to a sentence or two. Exception: when responding to critique_design, write a substantive paragraph per rubric question.
+
+STRUCTURE:
+- App.js: default-export React component. For non-trivial apps, define small co-located helpers (Header, CardList, Card, EditDialog, \u2026) above the default export rather than one giant App.
+- App.css: all styles, imported in App.js. No inline style objects.
+- package.json: list ALL imported packages including react. No CDN script tags. Versions are auto-pinned.
+- Do NOT create index.js or index.html (auto-generated).
+
+STATE & PERSISTENCE:
+- The code runs in the user's browser \u2014 standard browser APIs available (localStorage, URL hash, Date, fetch).
+- Persist user-created data (todos, cards, notes, settings) with localStorage so it survives refresh. Use a versioned key ("kanban.v1") and JSON.parse inside try/catch on read.
+- Treat persisted data as untrusted and possibly stale: a saved record may predate a field you just added (a timestamp, id, or setting), so default-fill or skip missing fields on read \u2014 never assume a loaded record has every field the current code expects. Bump the key version when the shape changes.
+- Lift state to App when multiple children need it; keep it local otherwise. Extract non-trivial logic into custom hooks (useTodos, useTimer).
+- useReducer for state shapes with several interrelated fields (cards + columns + filters + drag state).
+
+FILE & IMAGE UPLOAD:
+- Picker: \`<input type="file" accept="image/*" multiple>\` (vary accept by use case: \`.csv,text/csv\`, \`.txt,.md,text/plain\`, etc.).
+- Drag-and-drop: call \`e.preventDefault()\` in onDragOver (otherwise drop never fires); read files from \`event.dataTransfer.files\`. Drop and picker should coexist.
+- Previews: \`<img src={URL.createObjectURL(file)} />\`. Call \`URL.revokeObjectURL\` on unmount or before replacing \u2014 otherwise the browser leaks memory.
+- localStorage cannot hold large binary. Persist only metadata for big files; re-upload on next visit (or use IndexedDB if you really need durable binary storage).
+- Validate size and type before processing; reject files larger than the app can hold in memory.
+
+AI CAPABILITIES \u2014 \`window.app.complete(prompt: string): Promise<string>\` is available in this environment. Build for the real call.
+- When the app's core purpose is conversation, generation, grading, recommendation, or any natural-language task, this IS the implementation \u2014 call it. NEVER fake it: no hardcoded or canned replies, no random or \`setTimeout\` "thinking", no demo-mode stub. A chat app, tutor, or assistant that doesn't call \`window.app.complete\` is wrong, not a placeholder.
+- Don't force it where it isn't needed \u2014 a calculator, todo list, or timer has no reason to call it. Match the implementation to what the app actually does.
+- Async: wrap in try/catch, show a loading state, and disable dependent inputs while waiting. Surface failures gracefully ("Couldn't reach the AI \u2014 try again").
+- Structure prompts with clear sections (Role / Context / Task / Format) and pass the relevant state (e.g. the running conversation) as context. Render the response as untrusted text: \`white-space: pre-wrap\`, never dangerouslySetInnerHTML.
+- Skip the call only when the answer is genuinely static \u2014 no language or reasoning needed. Cache repeated prompts in component state when sensible.
+
+CODE QUALITY \u2014 write as a senior engineer would:
+- Handle edge cases (empty inputs, division by zero, invalid data). Show helpful error states, not crashes.
+- Never let formatting throw during render: guard \`new Date(x)\` / \`Intl\` / \`toLocaleString\` / \`.toFixed\` against missing or invalid values (e.g. \`Number.isNaN(d.getTime())\`) and return a fallback \u2014 one bad value from storage or state must not blank the whole app.
+- Semantic HTML: real headings, labels, buttons (not divs with onClick), form elements.
+- Accessible: aria-labels on icon buttons, focus-visible styles, keyboard navigable.
+- Extract into custom hooks or helpers when a component grows past ~80 lines.
+
+STYLING \u2014 Tailwind is the CHASSIS, custom CSS carries the IDENTITY:
+- Tailwind (via Play CDN) for layout, spacing, state (hover/focus), responsive prefixes \u2014 uniform structure.
+- App.css carries the identity: @import the Google Fonts, declare CSS custom properties (--bg, --panel, --card, --ink, --muted, --accent, --hairline, --radius, --radius-sm, --shadow-card, --shadow-card-hi) in :root, gradients/textures/signature animations Tailwind can't express. Reference tokens from Tailwind via arbitrary values (\`className="bg-[var(--bg)]"\`) when needed. A well-designed app has 60-200 lines of App.css \u2014 not zero.
+- Modern CSS is how apps stop reading as generic-AI-output: \`color-mix(in oklab, var(--accent) 14%, transparent)\` for tinting, \`oklch()\` / \`oklab()\` for perceptually-uniform color, \`:has()\`, \`conic-gradient\` / \`radial-gradient\`, \`backdrop-filter\`, \`@container\` queries, inline SVG \`feTurbulence\` for texture.
+- Don't pull additional CSS frameworks. Tailwind + custom CSS is enough.
+
+VISUAL DESIGN \u2014 every app should look like a real product, not a wireframe:
+- Let the chosen aesthetic drive every decision. "Editorial" wants italic display type and restrained color; "retro arcade" wants chunky shadows and saturated gradients. No safe-modern defaults.
+- Atmospheric depth: subtle radial wash, paper grain (inline SVG noise), warm/cool tint \u2014 every canvas should feel like a designed space, not a #fff rectangle.
+- Three shadow tiers (rest / hover / active). Pair drop shadows with inset highlights (\`box-shadow: 0 1px 0 rgba(255,255,255,.9) inset, 0 6px 14px -10px ...\`) for tactile feel.
+- Typography hierarchy: display font for headlines (italic accents on key words via \`<em>\`), body font for content, mono for metadata/labels \u2014 different families telegraph different information types.
+- Interactive polish: hover/active/focus on every clickable element, 200-300ms cubic-bezier transitions, keyboard shortcuts where natural (Esc to cancel, Cmd/Ctrl+Enter to commit), focus-visible rings keyed to the accent.
+- Light/dark mode if reasonable: a single CSS variable inversion under \`[data-theme="dark"]\`.
+- Customization affordance for multi-session apps: small "Tweaks" panel with theme / density / accent. Skip for throwaway demos.
+- Responsive: Tailwind responsive prefixes (\`sm:\`, \`md:\`, \`lg:\`) and \`@media\` in App.css. Mobile-first.`;
+
+// src/tools/document/documentBuilderPrompt.ts
+var DOCUMENT_BUILDER_PROMPT = `Document tools (create_document, read_document, patch_document) are available this turn, but they are OPTIONAL \u2014 having them does not mean you should produce a document.
+
+Use them ONLY when the user explicitly asks you to draft, write, compose, or generate a document \u2014 a contract, agreement, NDA, letter, cover letter, memo, essay, report, brief, proposal, or resume \u2014 e.g. "draft me a service agreement", "write a cover letter for this job", "make a one-page memo about X". A bare topic, a question, a request for an explanation, or a request for a slide deck or an interactive app is NOT a document instruction: respond normally and do not call these tools. When it's unclear whether the user wants a finished document, ask instead.
+
+When you DO author a document, the document body goes entirely into the tool \u2014 NEVER write the document text as chat prose. The tool renders your source to a real, paginated PDF and attaches it to your reply automatically. AFTER the tool returns, briefly confirm in ONE short sentence what you made (e.g. "Drafted a cover letter for the product manager role \u2014 see the attached PDF."). Do not restate the document's contents.
+
+AUTHORING \u2014 write the "source" as a single @react-pdf/renderer JSX expression (this is react-pdf, NOT HTML and NOT a slide deck):
+- Root is exactly one <Document> with at least one <Page>. Its only children are <Page> elements. Add more <Page> elements for longer documents \u2014 react-pdf also paginates overflow automatically.
+- Inside a <Page>: use <View> as flex containers and <Text> for ALL text. Raw text is only allowed inside <Text> (and <Link>); a <View> or <Page> may not contain bare text.
+- <Text> may nest <Text>, <Link>, or <Note> for inline styling, hyperlinks, and (rarely) a PDF comment annotation. A <Link> src must be an ordinary web link \u2014 http(s), mailto, tel, or a relative/anchor link; javascript:/data:/file: links are rejected. <Image> is self-closing and its src MUST be an inline "data:" URI \u2014 remote image URLs are rejected for privacy. Vector primitives (<Rect>/<Circle>/<Path>/etc.) must live inside an <Svg>.
+- Styling is react-pdf style objects only: style={{ marginTop: 12, fontSize: 11, fontFamily: "Times-Roman", flexDirection: "column" }}. Flexbox only \u2014 there is NO CSS grid, float, or box-shadow. Use camelCase react-pdf keys (margin/padding, flex*, width/height, color/backgroundColor, border*, text*, etc.).
+- fontFamily must be a built-in PDF font: Helvetica, Times-Roman, or Courier (with -Bold / -Oblique / -Italic / -BoldOblique variants), or Symbol / ZapfDingbats. Custom fonts are not supported.
+- LITERAL VALUES ONLY: no variables, no JS expressions, no .map(), no event handlers (onClick, \u2026), no spreads. Every attribute is a literal string, number, boolean, or a style object of literals.
+
+A minimal example:
+
+<Document>
+  <Page size="A4" style={{ paddingVertical: 56, paddingHorizontal: 64, fontFamily: "Times-Roman", fontSize: 11, lineHeight: 1.5 }}>
+    <Text style={{ fontSize: 18, fontFamily: "Times-Bold", marginBottom: 16, textAlign: "center" }}>MUTUAL NON-DISCLOSURE AGREEMENT</Text>
+    <Text style={{ marginBottom: 10 }}>This Mutual Non-Disclosure Agreement (the "Agreement") is entered into as of the date of last signature below.</Text>
+    <View style={{ marginTop: 14 }}>
+      <Text style={{ fontFamily: "Times-Bold", marginBottom: 4 }}>1. Confidential Information</Text>
+      <Text>Each party may disclose certain confidential and proprietary information to the other party.</Text>
+    </View>
+  </Page>
+</Document>
+
+WORKFLOW:
+1. To create or fully restructure a document, call create_document with the complete source.
+2. To revise an existing document, call read_document first (its output is line-numbered "42: <text>" \u2014 the prefix is display-only, never copy it into a "find"), then patch_document with small find/replace edits. Each "find" must match exactly one location; add 2-3 lines of surrounding context if needed. Prefer patching over rewriting.
+3. To attach several separate documents in one reply, call create_document multiple times with distinct documentId slugs (e.g. "nda", "cover-letter"). Each renders to its own PDF.
+4. If a tool reports a DSL error (with line:col) or a render failure, fix the source and retry \u2014 do not give up or fall back to writing the document as chat text.`;
+
+// src/lib/tools/serverTools.ts
+var DEFAULT_CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1e3;
+var SERVER_TOOLS_CACHE_KEY = "sdk_server_tools_cache";
+var CACHE_VERSION = "1.3";
+var MIN_CONTENT_LENGTH_FOR_TOOLS = 5;
+var MAX_CLIENT_TOOLS_AFTER_FILTER = 10;
+var CLIENT_TOOLS_MIN_SIMILARITY = 0.53;
+var CLIENT_TOOLS_RELEVANCE_RATIO = 0.75;
+function isNewToolFormat(tool) {
+  return "schema" in tool && tool.schema !== void 0;
+}
+function isNewResponseFormat(response) {
+  return "checksum" in response && "tools" in response && typeof response.checksum === "string";
+}
+function convertServerToolsResponse(response) {
+  let toolsMap;
+  let checksum;
+  if (isNewResponseFormat(response)) {
+    toolsMap = response.tools;
+    checksum = response.checksum;
+  } else {
+    toolsMap = response;
+  }
+  const tools = Object.values(toolsMap).map((tool) => {
+    if (isNewToolFormat(tool)) {
+      return {
+        type: "function",
+        name: tool.schema.name,
+        description: tool.schema.description,
+        parameters: tool.schema.parameters,
+        ...tool.embedding && { embedding: tool.embedding }
+      };
+    }
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    };
+  });
+  return { tools, checksum };
+}
+function toCompletionsFormat(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  };
+}
+function toResponsesFormat(tool) {
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+}
+function getCachedServerTools() {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const cached = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
+    if (!cached) return null;
+    const parsed = JSON.parse(cached);
+    if (parsed.version !== CACHE_VERSION) {
+      removeLocalStorageCache();
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isCacheExpired(cache, expirationMs = DEFAULT_CACHE_EXPIRATION_MS) {
+  if (!cache) return true;
+  return Date.now() - cache.timestamp > expirationMs;
+}
+function buildCacheEntry(tools, checksum, etag) {
+  return {
+    tools,
+    timestamp: Date.now(),
+    version: CACHE_VERSION,
+    ...checksum && { checksum },
+    ...etag && { etag }
+  };
+}
+function writeLocalStorageCache(entry) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(SERVER_TOOLS_CACHE_KEY, JSON.stringify(entry));
+  } catch (error) {
+    getLogger().warn("[serverTools] Failed to cache tools:", error);
+  }
+}
+function removeLocalStorageCache() {
+  if (typeof localStorage === "undefined") return;
+  localStorage.removeItem(SERVER_TOOLS_CACHE_KEY);
+}
+var localStorageToolsCache = {
+  get: getCachedServerTools,
+  set: writeLocalStorageCache,
+  clear: removeLocalStorageCache
+};
+function clearServerToolsCache(cache = localStorageToolsCache) {
+  return cache.clear?.();
+}
+function getToolsChecksum2(cache = localStorageToolsCache) {
+  const cached = cache.get();
+  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
+}
+function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
+  if (!responseChecksum) {
+    return false;
+  }
+  const decide = (cachedChecksum2) => !cachedChecksum2 || cachedChecksum2 !== responseChecksum;
   const cachedChecksum = getToolsChecksum2(cache);
   return cachedChecksum instanceof Promise ? cachedChecksum.then(decide) : decide(cachedChecksum);
 }
@@ -6438,6 +7311,13 @@ function createErrorResult(message, onError) {
 function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
+var ProviderStreamError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "ProviderStreamError";
+    this.code = code;
+  }
+};
 function getInStreamErrorMessage(chunk) {
   if (!chunk || typeof chunk !== "object") return null;
   const obj = chunk;
@@ -6724,7 +7604,7 @@ var CompletionsStrategy = class {
   processStreamChunk(chunk, accumulator) {
     const result = { content: null, thinking: null };
     const inStreamErr = getInStreamErrorMessage(chunk);
-    if (inStreamErr) throw new Error(inStreamErr);
+    if (inStreamErr) throw new ProviderStreamError(inStreamErr);
     const rawChunk = chunk;
     const typedChunk = rawChunk.response && rawChunk.type === "response" ? rawChunk.response : chunk;
     if (typedChunk.id && !accumulator.responseId) {
@@ -7575,7 +8455,7 @@ var ResponsesStrategy = class {
     const result = { content: null, thinking: null };
     const typedChunk = chunk;
     const inStreamErr = getInStreamErrorMessage(chunk);
-    if (inStreamErr) throw new Error(inStreamErr);
+    if (inStreamErr) throw new ProviderStreamError(inStreamErr);
     if (typedChunk.type === "response.failed") {
       const resp = typedChunk.response;
       const err = resp?.error;
@@ -7592,9 +8472,12 @@ var ResponsesStrategy = class {
           }
         }
         const label = code ? `[${code}] ` : "";
-        throw new Error(`${label}${message || "Upstream request failed"}`);
+        throw new ProviderStreamError(
+          `${label}${message || "Upstream request failed"}`,
+          code || void 0
+        );
       }
-      throw new Error("Upstream request failed (response.failed)");
+      throw new ProviderStreamError("Upstream request failed (response.failed)");
     }
     if (typedChunk.type === "response" && typedChunk.response) {
       const resp = typedChunk.response;
@@ -8218,13 +9101,6 @@ function isRetriableStreamError(err) {
   if (msg.includes("connection refused") || msg.includes("connect error")) return true;
   return false;
 }
-var ProviderStreamError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.name = "ProviderStreamError";
-    this.code = code;
-  }
-};
 function extractProviderStreamError(chunk) {
   if (!chunk || typeof chunk !== "object") return null;
   const errField = chunk.error;
@@ -8605,6 +9481,7 @@ async function runToolLoop(options) {
     thinking: redactor.deAnonymize(acc.thinking)
   }) : strategy.buildFinalResponse(acc);
   const finalContentText = (acc) => redactor ? redactor.deAnonymize(acc.content) : acc.content;
+  let streamingAccumulator = null;
   try {
     let sseError = null;
     let apiTools = toolsToApiFormat(tools, resolved);
@@ -8756,6 +9633,7 @@ async function runToolLoop(options) {
         }
       });
       accumulator = createStreamAccumulator(model || void 0);
+      streamingAccumulator = accumulator;
       contentSmoother = new StreamSmoother((text16) => {
         if (emitData) emitData(text16);
       }, smoothing);
@@ -9266,6 +10144,7 @@ Executing tool: ${toolInfo}
           }
         });
         currentAccumulator = createStreamAccumulator(model || void 0);
+        streamingAccumulator = currentAccumulator;
         contContentSmoother = new StreamSmoother((text16) => {
           if (emitData) emitData(text16);
         }, smoothing);
@@ -9463,7 +10342,7 @@ Executing tool: ${toolInfo}
     const statusCode = err instanceof Error && "statusCode" in err ? err.statusCode : void 0;
     const connectionLost = !(err instanceof ProviderStreamError) && !(err instanceof SseError);
     return {
-      data: null,
+      data: connectionLost && streamingAccumulator ? buildResponseFinal(streamingAccumulator) : null,
       error: errorMsg,
       statusCode,
       ...connectionLost ? { connectionLost: true } : {}
@@ -9480,6 +10359,33 @@ function streamReplayPath(inferenceId) {
 function streamCancelPath(inferenceId) {
   return `${streamReplayPath(inferenceId)}/cancel`;
 }
+var ACTIVE_STREAMS_PATH = "/api/v1/chat/streams/active";
+function toActiveStream(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  const text16 = (key3) => typeof v[key3] === "string" && v[key3] ? v[key3] : null;
+  const inferenceId = text16("inference_id");
+  if (!inferenceId || v.api_type !== "responses" && v.api_type !== "completions") return null;
+  return {
+    inferenceId,
+    assistantMessageId: text16("assistant_message_id"),
+    conversationId: text16("conversation_id"),
+    parentMessageId: text16("parent_message_id"),
+    apiType: v.api_type,
+    model: text16("model") ?? void 0,
+    startedAt: text16("started_at") ?? ""
+  };
+}
+async function listActiveStreams(options) {
+  const query = options.conversationId ? `?conversation_id=${encodeURIComponent(options.conversationId)}` : "";
+  const response = await (options.fetch ?? globalThis.fetch)(
+    `${options.baseUrl ?? BASE_URL}${ACTIVE_STREAMS_PATH}${query}`,
+    { headers: { Authorization: `Bearer ${options.token}` } }
+  );
+  if (!response.ok) throw new Error(`Active streams request failed (${response.status})`);
+  const body = await response.json();
+  return Array.isArray(body.streams) ? body.streams.map(toActiveStream).filter((s) => s !== null) : [];
+}
 var StreamExpiredError = class extends Error {
   constructor(inferenceId, message) {
     super(message ?? `The resumable stream "${inferenceId}" has expired or no longer exists`);
@@ -9923,118 +10829,19 @@ var xhrTransport = (options) => {
   return { stream: createStream() };
 };
 
-// src/lib/db/chat/summaryOperations.ts
-import { Q as Q3 } from "@nozbe/watermelondb";
-function createSummaryContext(database, encryption = {}) {
-  return {
-    ...encryption,
-    database,
-    summariesCollection: database.get("conversation_summaries")
-  };
-}
-function modelToStored(record2, summary) {
-  return {
-    uniqueId: record2.id,
-    conversationId: record2.conversationId,
-    summary,
-    summarizedUpTo: record2.summarizedUpTo,
-    tokenCount: record2.tokenCount,
-    createdAt: record2.createdAt,
-    updatedAt: record2.updatedAt
-  };
-}
-async function getConversationSummaryOp(ctx, conversationId) {
-  const results = await ctx.summariesCollection.query(Q3.where("conversation_id", conversationId)).fetch();
-  if (results.length === 0) return null;
-  const record2 = results[0];
-  const stored2 = modelToStored(record2, record2.summary);
-  if (ctx.walletAddress && isEncrypted(stored2.summary)) {
-    if (ctx.signMessage) {
-      try {
-        await requestEncryptionKey(ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
-      } catch (error) {
-        getLogger().warn("Failed to request the encryption key for the summary:", error);
-      }
-    }
-    stored2.summary = await decryptField(stored2.summary, ctx.walletAddress);
-  } else if (ctx.walletAddress && ctx.signMessage && stored2.summary) {
-    try {
-      const encryptedSummary = await encryptField(
-        stored2.summary,
-        ctx.walletAddress,
-        ctx.signMessage,
-        ctx.embeddedWalletSigner
-      );
-      await ctx.database.write(async () => {
-        const current = await ctx.summariesCollection.query(Q3.where("id", record2.id)).fetch();
-        if (current[0]?.summary === stored2.summary) {
-          await current[0].update((rec) => {
-            rec.summary = encryptedSummary;
-          });
-        }
-      });
-    } catch (error) {
-      getLogger().warn("Failed to encrypt the legacy summary:", error);
-    }
+// src/lib/chatStore/types.ts
+var ChatStoreError = class extends Error {
+  constructor(message, status, code, retryAfterMs) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "ChatStoreError";
   }
-  return stored2;
-}
-async function upsertConversationSummaryOp(ctx, conversationId, summary, summarizedUpTo, tokenCount) {
-  const revision2 = getConversationRevision(ctx.database, conversationId);
-  let record2;
-  const encryptedSummary = ctx.walletAddress ? await encryptField(summary, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner) : summary;
-  await ctx.database.write(async () => {
-    assertConversationRevision(ctx.database, conversationId, revision2);
-    const existing = await ctx.summariesCollection.query(Q3.where("conversation_id", conversationId)).fetch();
-    if (existing.length > 0) {
-      record2 = await existing[0].update((rec) => {
-        rec.summary = encryptedSummary;
-        rec.summarizedUpTo = summarizedUpTo;
-        rec.tokenCount = tokenCount;
-      });
-    } else {
-      record2 = await ctx.summariesCollection.create((rec) => {
-        rec.conversationId = conversationId;
-        rec.summary = encryptedSummary;
-        rec.summarizedUpTo = summarizedUpTo;
-        rec.tokenCount = tokenCount;
-      });
-    }
-  });
-  return modelToStored(record2, summary);
-}
-async function deleteConversationSummaryOp(ctx, conversationId) {
-  await ctx.database.write(async () => {
-    const existing = await ctx.summariesCollection.query(Q3.where("conversation_id", conversationId)).fetch();
-    for (const record2 of existing) {
-      await record2.destroyPermanently();
-    }
-  });
-}
-
-// src/lib/db/conversationMemory/models.ts
-import { Model as Model3 } from "@nozbe/watermelondb";
-import { date as date2, field as field2, readonly, text as text3 } from "@nozbe/watermelondb/decorators";
-var ConversationMemory = class extends Model3 {
 };
-ConversationMemory.table = "conversation_memory";
-ConversationMemory.associations = {};
-__decorateClass([
-  text3("conversation_id")
-], ConversationMemory.prototype, "conversationId", 2);
-__decorateClass([
-  text3("memory_id")
-], ConversationMemory.prototype, "memoryId", 2);
-__decorateClass([
-  field2("score")
-], ConversationMemory.prototype, "score", 2);
-__decorateClass([
-  readonly,
-  date2("created_at")
-], ConversationMemory.prototype, "createdAt", 2);
 
 // src/lib/db/conversationMemory/operations.ts
-import { Q as Q4 } from "@nozbe/watermelondb";
+import { Q as Q3 } from "@nozbe/watermelondb";
 var MAX_PER_CONVERSATION = 200;
 function conversationMemoryToStored(row) {
   return {
@@ -10049,7 +10856,7 @@ async function addConversationMemoriesOp(ctx, conversationId, items) {
   if (!conversationId || items.length === 0) return;
   const now = Date.now();
   await ctx.database.write(async () => {
-    const existing = await ctx.conversationMemoryCollection.query(Q4.where("conversation_id", conversationId), Q4.sortBy("created_at", Q4.asc)).fetch();
+    const existing = await ctx.conversationMemoryCollection.query(Q3.where("conversation_id", conversationId), Q3.sortBy("created_at", Q3.asc)).fetch();
     const seen = new Set(existing.map((r) => r.memoryId));
     const batchSeen = /* @__PURE__ */ new Set();
     const deduped = [];
@@ -10086,7 +10893,7 @@ async function recordConversationMemoriesOp(ctx, conversationId, items, now = Da
   if (!conversationId || turn.size === 0) return;
   const kept = new Map([...turn].slice(-MAX_PER_CONVERSATION));
   await ctx.database.write(async () => {
-    const existing = await ctx.conversationMemoryCollection.query(Q4.where("conversation_id", conversationId), Q4.sortBy("created_at", Q4.asc)).fetch();
+    const existing = await ctx.conversationMemoryCollection.query(Q3.where("conversation_id", conversationId), Q3.sortBy("created_at", Q3.asc)).fetch();
     const earlier = existing.filter((r) => !turn.has(r.memoryId));
     const linked = new Set(existing.map((r) => r.memoryId));
     await ctx.database.batch(
@@ -10111,13 +10918,13 @@ async function recordConversationMemoriesOp(ctx, conversationId, items, now = Da
 }
 async function getConversationMemoriesOp(ctx, conversationId) {
   if (!conversationId) return [];
-  const rows = await ctx.conversationMemoryCollection.query(Q4.where("conversation_id", conversationId), Q4.sortBy("created_at", Q4.asc)).fetch();
+  const rows = await ctx.conversationMemoryCollection.query(Q3.where("conversation_id", conversationId), Q3.sortBy("created_at", Q3.asc)).fetch();
   return rows.map(conversationMemoryToStored);
 }
 async function clearConversationMemoriesOp(ctx, conversationId) {
   if (!conversationId) return;
   await ctx.database.write(async () => {
-    const rows = await ctx.conversationMemoryCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+    const rows = await ctx.conversationMemoryCollection.query(Q3.where("conversation_id", conversationId)).fetch();
     if (rows.length === 0) return;
     await ctx.database.batch(...rows.map((r) => r.prepareDestroyPermanently()));
   });
@@ -10132,15 +10939,37 @@ var maxChunks = 16;
 var droppable = ["thoughtProcess", "thinking", "sources", "toolCallEvents"];
 var messageMetadata = /* @__PURE__ */ new Set(["conversationId", "uniqueId", "vector", "chunks"]);
 var alwaysStored = /* @__PURE__ */ new Set(["role", "content", "responseDuration"]);
+var maxBubbles = 3;
+var maxTurnIdBytes = 128;
+var maxBubbleBytes = 16384;
+var anumaOrigins = /* @__PURE__ */ new Set(["intro", "reply"]);
 function plain(value) {
   return JSON.parse(JSON.stringify(value ?? {}));
 }
-function text4(value) {
+function text3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function number(value) {
   return typeof value === "number" ? value : void 0;
 }
+function readAnumaTurn(value) {
+  if (!isObject(value)) return void 0;
+  const { turnId, bubbles, origin } = value;
+  if (typeof turnId !== "string" || turnId.length === 0 || new TextEncoder().encode(turnId).length > maxTurnIdBytes)
+    return void 0;
+  if (bubbles !== void 0 && (!Array.isArray(bubbles) || bubbles.length < 1 || bubbles.length > maxBubbles || !bubbles.every((b) => typeof b === "string") || bubbles.reduce((sum, b) => sum + new TextEncoder().encode(b).length, 0) > maxBubbleBytes))
+    return void 0;
+  if (origin !== void 0 && (typeof origin !== "string" || !anumaOrigins.has(origin)))
+    return void 0;
+  return {
+    turnId,
+    ...bubbles !== void 0 ? { bubbles: [...bubbles] } : {},
+    ...origin !== void 0 ? { origin } : {}
+  };
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function conversationSortKey(data, createdAt) {
   const pinnedAt = number(data.pinnedAt);
   if (pinnedAt) return PINNED_SORT_BASE + pinnedAt;
@@ -10161,12 +10990,12 @@ function conversationContext(data) {
 }
 function toConversation(record2) {
   const pinnedAt = number(record2.data.pinnedAt);
-  const projectId = text4(record2.data.projectId);
+  const projectId = text3(record2.data.projectId);
   const context = conversationContext(record2.data);
   return {
     uniqueId: record2.id,
     conversationId: record2.id,
-    title: text4(record2.data.title) ?? "",
+    title: text3(record2.data.title) ?? "",
     ...projectId ? { projectId } : {},
     createdAt: new Date(record2.createdAt),
     updatedAt: new Date(record2.updatedAt),
@@ -10175,18 +11004,28 @@ function toConversation(record2) {
     ...context ? { context } : {}
   };
 }
+function anumaTurnData(value) {
+  if (value === void 0) return void 0;
+  const turn = readAnumaTurn(value);
+  if (!turn) throw new ChatStoreError("Invalid Anuma turn", 0, "invalid_record");
+  return turn;
+}
 function messageData(options) {
-  return plain(
-    Object.fromEntries(
+  const anuma = anumaTurnData(options.anuma);
+  return plain({
+    ...Object.fromEntries(
       Object.entries(options).filter(
-        ([key3, value]) => !messageMetadata.has(key3) && (!!value || alwaysStored.has(key3))
+        ([key3, value]) => key3 !== "anuma" && !messageMetadata.has(key3) && (!!value || alwaysStored.has(key3))
       )
-    )
-  );
+    ),
+    ...anuma ? { anuma } : {}
+  });
 }
 function toMessage(record2) {
-  const { chunkOffsets: _offsets, truncated: _truncated, ...fields } = record2.data;
+  const { chunkOffsets: _offsets, truncated: _truncated, anuma: rawAnuma, ...fields } = record2.data;
+  const anuma = readAnumaTurn(rawAnuma);
   return {
+    ...anuma ? { anuma } : {},
     ...fields,
     uniqueId: record2.id,
     messageId: record2.sortKey,
@@ -10200,948 +11039,422 @@ function chunkOffsets(record2) {
   return Array.isArray(offsets) ? offsets : void 0;
 }
 function toSkeletons(records) {
-  const roleById = new Map(records.map((r) => [r.id, text4(r.data.role)]));
-  return records.map((r) => {
-    const parentMessageId = text4(r.data.parentMessageId);
-    const model = text4(r.data.model);
-    const artifact = r.data.role === "user" && !!parentMessageId && roleById.get(parentMessageId) === "user";
-    return {
-      uniqueId: r.id,
-      messageId: r.sortKey,
-      conversationId: r.conversationId,
-      role: text4(r.data.role) ?? "",
-      createdAt: new Date(r.createdAt),
-      ...parentMessageId ? { parentMessageId } : {},
-      ...model ? { model } : {},
-      ...artifact ? { content: text4(r.data.content) ?? "" } : {}
-    };
-  });
-}
-function toSummary(record2) {
-  return {
-    uniqueId: record2.id,
-    conversationId: record2.id,
-    summary: text4(record2.data.summary) ?? "",
-    summarizedUpTo: text4(record2.data.summarizedUpTo) ?? "",
-    tokenCount: number(record2.data.tokenCount) ?? 0,
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt)
-  };
-}
-function links(data) {
-  return Array.isArray(data.links) ? data.links : [];
-}
-function applyLinkOps(data, ops) {
-  let current = links(data);
-  for (const op of ops) {
-    if ("clear" in op) {
-      current = [];
-      continue;
-    }
-    const byId = new Map(current.map((l) => [l.memoryId, l]));
-    const turn = /* @__PURE__ */ new Set();
-    op.add.forEach((item, i) => {
-      if (!item.memoryId || turn.has(item.memoryId)) return;
-      turn.add(item.memoryId);
-      const known = byId.get(item.memoryId);
-      if (known && known.createdAt >= op.at + i) return;
-      byId.set(item.memoryId, { memoryId: item.memoryId, score: item.score, createdAt: op.at + i });
-    });
-    current = [...byId.values()].sort((a, b) => a.createdAt - b.createdAt).slice(-MAX_PER_CONVERSATION);
-  }
-  return plain({ links: current });
-}
-function toLinks(record2) {
-  return links(record2.data).map((l) => ({
-    uniqueId: `${record2.id}:${l.memoryId}`,
-    conversationId: record2.id,
-    memoryId: l.memoryId,
-    score: l.score,
-    createdAt: new Date(l.createdAt)
-  }));
-}
-function bytes(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).length;
-}
-function fitRecord(record2) {
-  if (record2.kind !== "message" || bytes(record2) <= recordBudgetBytes) return record2;
-  const data = { ...record2.data };
-  const truncated = [];
-  for (const field10 of droppable) {
-    if (bytes({ ...record2, data }) <= recordBudgetBytes) break;
-    if (data[field10] === void 0) continue;
-    delete data[field10];
-    truncated.push(field10);
-  }
-  const content = text4(data.content) ?? "";
-  const over = bytes({ ...record2, data }) - recordBudgetBytes;
-  if (over > 0) {
-    const encoded = new TextEncoder().encode(content);
-    data.content = new TextDecoder().decode(encoded.slice(0, Math.max(0, encoded.length - over - 64))).replace(/�$/, "");
-    truncated.push("content");
-  }
-  return { ...record2, data: { ...data, truncated } };
-}
-function acceptedVector(vector2) {
-  if (!vector2 || !acceptedDims.has(vector2.length)) return void 0;
-  if (!vector2.every(Number.isFinite) || !vector2.slice(0, storedDims).some((x) => x !== 0))
-    return void 0;
-  return [...vector2];
-}
-function normalized(vector2) {
-  const norm = Math.hypot(...vector2) || 1;
-  return vector2.map((x) => x / norm);
-}
-function fitChunks(chunks3) {
-  const usable = chunks3.map((c) => ({ ...c, vector: acceptedVector(c.vector) }));
-  if (usable.length === 0 || usable.some((c) => !c.vector)) return void 0;
-  if (usable.length <= maxChunks) return usable;
-  const out = [];
-  for (let g = 0; g < maxChunks; g++) {
-    const group = usable.slice(
-      Math.floor(g * usable.length / maxChunks),
-      Math.floor((g + 1) * usable.length / maxChunks)
-    );
-    const dims = group[0].vector.length;
-    const mean = new Array(dims).fill(0);
-    for (const c of group) {
-      const unit = normalized(c.vector);
-      for (let d = 0; d < dims; d++) mean[d] += unit[d];
-    }
-    out.push({
-      vector: normalized(mean),
-      startOffset: group[0].startOffset,
-      endOffset: group[group.length - 1].endOffset
-    });
-  }
-  return out;
-}
-
-// src/lib/chatStore/chatImports.ts
-var importBatch = 100;
-var importChunks = 200;
-var importPlaintextBytes = 39e5;
-function ms(date10, fallback = 1) {
-  const value = date10?.getTime();
-  return value && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
-}
-function bytes2(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).length;
-}
-function conversationRecord(conversation, messages) {
-  const createdAt = ms(conversation.createdAt);
-  const data = plain({
-    ...contextFields(conversation.context),
-    title: conversation.title,
-    projectId: conversation.projectId || void 0,
-    pinnedAt: conversation.pinnedAt ? ms(conversation.pinnedAt) : void 0,
-    lastActivityAt: Math.max(
-      ms(conversation.updatedAt, createdAt),
-      ...messages.map((m) => ms(m.createdAt))
-    )
-  });
-  return {
-    record: {
-      kind: "conversation",
-      id: conversation.conversationId,
-      conversationId: "",
-      sortKey: conversationSortKey(data, createdAt),
-      createdAt,
-      updatedAt: ms(conversation.updatedAt, createdAt),
-      isDeleted: false,
-      data
-    }
-  };
-}
-function messageRecord(message) {
-  const {
-    uniqueId: _uniqueId,
-    messageId: _messageId,
-    createdAt: _createdAt,
-    updatedAt: _updatedAt,
-    decryptionStatus: _status,
-    chunks: chunks3,
-    vector: vector2,
-    ...fields
-  } = message;
-  const fitted = chunks3?.length ? fitChunks(chunks3) : void 0;
-  const single = fitted ? void 0 : acceptedVector(vector2);
-  const embeddings2 = fitted?.map((c) => c.vector) ?? (single ? [single] : void 0);
-  const record2 = fitRecord({
-    kind: "message",
-    id: message.uniqueId,
-    conversationId: message.conversationId,
-    sortKey: message.messageId,
-    createdAt: ms(message.createdAt),
-    updatedAt: ms(message.updatedAt, ms(message.createdAt)),
-    isDeleted: false,
-    data: {
-      ...messageData(fields),
-      ...fitted ? { chunkOffsets: fitted.map((c) => [c.startOffset, c.endOffset]) } : {}
-    }
-  });
-  return {
-    record: record2,
-    ...embeddings2 ? { embeddings: embeddings2 } : {},
-    ...embeddings2 && message.embeddingModel ? { embeddingModel: message.embeddingModel } : {}
-  };
-}
-function batches(records) {
-  const out = [];
-  let batch = [];
-  let chunks3 = 0;
-  let size = 0;
-  for (const item of records) {
-    const vectors = item.embeddings?.length ?? 0;
-    const itemSize = bytes2(item.record);
-    if (batch.length > 0 && (batch.length >= importBatch || chunks3 + vectors > importChunks || size + itemSize > importPlaintextBytes)) {
-      out.push(batch);
-      batch = [];
-      chunks3 = 0;
-      size = 0;
-    }
-    batch.push(item);
-    chunks3 += vectors;
-    size += itemSize;
-  }
-  if (batch.length) out.push(batch);
-  return out;
-}
-
-// src/lib/db/entities/types.ts
-var ENTITY_KINDS = [
-  "person",
-  "organization",
-  "place",
-  "event",
-  "product",
-  "thing",
-  "concept",
-  "other"
-];
-function normalizeEntityName(name) {
-  return name.trim().toLowerCase();
+  const roleById = new Map(records.map((r) => [r.id, text3(r.data.role)]));
+  return records.map((r) => {
+    const parentMessageId = text3(r.data.parentMessageId);
+    const model = text3(r.data.model);
+    const artifact = r.data.role === "user" && !!parentMessageId && roleById.get(parentMessageId) === "user";
+    return {
+      uniqueId: r.id,
+      messageId: r.sortKey,
+      conversationId: r.conversationId,
+      role: text3(r.data.role) ?? "",
+      createdAt: new Date(r.createdAt),
+      ...parentMessageId ? { parentMessageId } : {},
+      ...model ? { model } : {},
+      ...artifact ? { content: text3(r.data.content) ?? "" } : {}
+    };
+  });
 }
-var TOPIC_SALIENCE_WEIGHTS = { primary: 1, secondary: 0.6, mention: 0.3 };
-function topicWeight(topic2) {
-  return topic2.source === "user" ? 1 : topic2.weight ?? 1;
+function toSummary(record2) {
+  return {
+    uniqueId: record2.id,
+    conversationId: record2.id,
+    summary: text3(record2.data.summary) ?? "",
+    summarizedUpTo: text3(record2.data.summarizedUpTo) ?? "",
+    tokenCount: number(record2.data.tokenCount) ?? 0,
+    createdAt: new Date(record2.createdAt),
+    updatedAt: new Date(record2.updatedAt)
+  };
 }
-function primaryTopic(topics) {
-  let best = null;
-  for (const topic2 of topics ?? []) {
-    if (best === null || topicWeight(topic2) > topicWeight(best)) best = topic2;
+function links(data) {
+  return Array.isArray(data.links) ? data.links : [];
+}
+function applyLinkOps(data, ops) {
+  let current = links(data);
+  for (const op of ops) {
+    if ("clear" in op) {
+      current = [];
+      continue;
+    }
+    const byId = new Map(current.map((l) => [l.memoryId, l]));
+    const turn = /* @__PURE__ */ new Set();
+    op.add.forEach((item, i) => {
+      if (!item.memoryId || turn.has(item.memoryId)) return;
+      turn.add(item.memoryId);
+      const known = byId.get(item.memoryId);
+      if (known && known.createdAt >= op.at + i) return;
+      byId.set(item.memoryId, { memoryId: item.memoryId, score: item.score, createdAt: op.at + i });
+    });
+    current = [...byId.values()].sort((a, b) => a.createdAt - b.createdAt).slice(-MAX_PER_CONVERSATION);
   }
-  return best;
+  return plain({ links: current });
 }
-function parseTopicWeight(value) {
-  return typeof value === "number" && value > 0 && value <= 1 ? value : void 0;
+function toLinks(record2) {
+  return links(record2.data).map((l) => ({
+    uniqueId: `${record2.id}:${l.memoryId}`,
+    conversationId: record2.id,
+    memoryId: l.memoryId,
+    score: l.score,
+    createdAt: new Date(l.createdAt)
+  }));
 }
-function serializeTopics(topics) {
-  return JSON.stringify(topics);
+function bytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
 }
-function parseTopics(value) {
-  if (typeof value !== "string" || value.length === 0) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return null;
+function fitRecord(record2) {
+  if (record2.kind !== "message" || bytes(record2) <= recordBudgetBytes) return record2;
+  const data = { ...record2.data };
+  const truncated = [];
+  for (const field10 of droppable) {
+    if (bytes({ ...record2, data }) <= recordBudgetBytes) break;
+    if (data[field10] === void 0) continue;
+    delete data[field10];
+    truncated.push(field10);
   }
-  if (!Array.isArray(parsed)) return null;
-  const out = [];
-  for (const raw of parsed) {
-    if (typeof raw !== "object" || raw === null) continue;
-    const { name, kind, source, weight } = raw;
-    if (typeof name !== "string" || name.trim().length === 0) continue;
-    const parsedWeight = parseTopicWeight(weight);
-    out.push({
-      name,
-      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
-      source: source === "user" ? "user" : "auto",
-      ...parsedWeight !== void 0 ? { weight: parsedWeight } : {}
-    });
+  const content = text3(data.content) ?? "";
+  const over = bytes({ ...record2, data }) - recordBudgetBytes;
+  if (over > 0) {
+    const encoded = new TextEncoder().encode(content);
+    data.content = new TextDecoder().decode(encoded.slice(0, Math.max(0, encoded.length - over - 64))).replace(/�$/, "");
+    truncated.push("content");
   }
-  return out;
+  return { ...record2, data: { ...data, truncated } };
 }
-
-// src/lib/memory/store/remoteTopics.ts
-function topic(value) {
-  const t = value;
-  if (!t || typeof t.name !== "string" || !t.name || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
-    throw new Error("Invalid nearby topic");
-  return t;
+function acceptedVector(vector2) {
+  if (!vector2 || !acceptedDims.has(vector2.length)) return void 0;
+  if (!vector2.every(Number.isFinite) || !vector2.slice(0, storedDims).some((x) => x !== 0))
+    return void 0;
+  return [...vector2];
 }
-function createRemoteTopicPersistence(request) {
-  return {
-    topics: async () => {
-      const out = [];
-      let cursor;
-      do {
-        const page = await request(
-          "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
-          {}
-        );
-        if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
-          throw new Error("Invalid nearby topic page");
-        out.push(...page.items.map(topic));
-        cursor = page.next_cursor;
-      } while (cursor);
-      return out;
-    },
-    putTopic: async (value, expectedVersion) => {
-      if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
-        throw new Error("Expected topic version must be a nonnegative integer");
-      return topic(
-        await request("/topics", {
-          method: "PUT",
-          body: JSON.stringify({ topic: value, expected_version: expectedVersion })
-        })
-      );
-    },
-    importTopics: async (topics, signal) => {
-      for (let i = 0; i < topics.length; i += 50) {
-        signal?.throwIfAborted();
-        await request(
-          "/topics/import",
-          {
-            method: "POST",
-            body: JSON.stringify({ topics: topics.slice(i, i + 50) })
-          },
-          signal
-        );
-      }
-      signal?.throwIfAborted();
-    }
-  };
+function normalized(vector2) {
+  const norm = Math.hypot(...vector2) || 1;
+  return vector2.map((x) => x / norm);
 }
-async function createRemoteTopic(persistence, name) {
-  const canonical = normalizeEntityName(name);
-  if (!canonical) return null;
-  const existing = (await persistence.topics()).find((t) => t.name === canonical);
-  if (existing && !existing.is_deleted) return canonical;
-  try {
-    await persistence.putTopic(
-      { name: canonical, is_deleted: false, ...existing?.kind && { kind: existing.kind } },
-      existing?.version ?? 0
+function fitChunks(chunks3) {
+  const usable = chunks3.map((c) => ({ ...c, vector: acceptedVector(c.vector) }));
+  if (usable.length === 0 || usable.some((c) => !c.vector)) return void 0;
+  if (usable.length <= maxChunks) return usable;
+  const out = [];
+  for (let g = 0; g < maxChunks; g++) {
+    const group = usable.slice(
+      Math.floor(g * usable.length / maxChunks),
+      Math.floor((g + 1) * usable.length / maxChunks)
     );
-  } catch (error) {
-    if (!(error instanceof RemoteMemoryError) || error.code !== "version_conflict") throw error;
-    const current = (await persistence.topics()).find((t) => t.name === canonical);
-    if (!current || current.is_deleted) throw error;
-  }
-  return canonical;
-}
-
-// src/lib/memory/store/remoteWork.ts
-function createRemoteWorkPersistence(request) {
-  return {
-    claimWork: async (kind, processorVersion, token) => {
-      const result = await request("/work/claim", {
-        method: "POST",
-        body: JSON.stringify({
-          kind,
-          processor_version: processorVersion,
-          ...token && { token }
-        })
-      });
-      if (!result || typeof result !== "object") throw new Error("Invalid nearby work lease");
-      const lease = result.lease;
-      if (lease === void 0) return null;
-      if (!lease || lease.kind !== kind || typeof lease.token !== "string" || !lease.token || lease.processor_version !== processorVersion || typeof lease.expires_at !== "string" || !Number.isFinite(Date.parse(lease.expires_at)))
-        throw new Error("Invalid nearby work lease");
-      return lease;
-    },
-    releaseWork: async (kind, token) => {
-      await request("/work/release", { method: "POST", body: JSON.stringify({ kind, token }) });
+    const dims = group[0].vector.length;
+    const mean = new Array(dims).fill(0);
+    for (const c of group) {
+      const unit = normalized(c.vector);
+      for (let d = 0; d < dims; d++) mean[d] += unit[d];
     }
-  };
-}
-async function withRemoteWorkLease(persistence, kind, processorVersion, task) {
-  const lease = await persistence.claimWork(kind, processorVersion);
-  if (!lease) return null;
-  const controller = new AbortController();
-  const leaseLostError = new RemoteMemoryError("Maintenance lease lost", 409, "work_lease_expired");
-  const cancelled = new Promise((_resolve, reject) => {
-    controller.signal.addEventListener("abort", () => reject(leaseLostError), {
-      once: true
-    });
-  });
-  let renewing;
-  const timer = setInterval(() => {
-    if (renewing || controller.signal.aborted) return;
-    renewing = persistence.claimWork(kind, processorVersion, lease.token).then((renewed) => {
-      if (!renewed) controller.abort(leaseLostError);
-    }).catch((error) => getLogger().warn("[memory/work] Lease renewal failed:", error)).finally(() => {
-      renewing = void 0;
+    out.push({
+      vector: normalized(mean),
+      startOffset: group[0].startOffset,
+      endOffset: group[group.length - 1].endOffset
     });
-  }, 3e4);
-  try {
-    const result = await Promise.race([task(lease.token, controller.signal), cancelled]);
-    await renewing;
-    return controller.signal.aborted ? null : result;
-  } catch (error) {
-    if (controller.signal.aborted || isRemoteWorkLeaseExpired(error)) return null;
-    throw error;
-  } finally {
-    clearInterval(timer);
-    await renewing;
-    await persistence.releaseWork(kind, lease.token).catch((error) => getLogger().warn("[memory/work] Lease release failed:", error));
   }
-}
-function isRemoteWorkLeaseExpired(error) {
-  return error instanceof RemoteMemoryError && error.code === "work_lease_expired";
+  return out;
 }
 
-// src/lib/memory/store/remotePersistence.ts
-var RemoteMemoryError = class extends Error {
-  constructor(message, status, code, retryAfterMs, rateLimitBucket) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.retryAfterMs = retryAfterMs;
-    this.rateLimitBucket = rateLimitBucket;
-    this.name = "RemoteMemoryError";
-  }
-};
-var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
-var memoryFields = {
-  memory_id: true,
-  content: true,
-  scope: true,
-  created_at: true,
-  updated_at: true,
-  is_deleted: true,
-  embedding: true,
-  embedding_model: true,
-  kind: true,
-  kind_value: true,
-  level: true,
-  folder_id: true,
-  source_chunk_ids: true,
-  proof_count: true,
-  source: true,
-  event_time_start: true,
-  event_time_end: true,
-  event_time_kind: true,
-  topics_user_managed: true,
-  topics: true,
-  topics_updated_at: true,
-  media: true,
-  topics_extracted_at: true,
-  topics_extracted_version: true,
-  superseded_by: true,
-  superseded_at: true,
-  last_observed_at: true,
-  fact_type: true,
-  archived_at: true,
-  trust_tier: true,
-  visibility: true,
-  twin_opt_in: true,
-  published_at: true,
-  geohash: true
-};
-var candidateListLimits = [
-  ["scopes", 20],
-  ["fact_types", 20],
-  ["memory_ids", 1e3],
-  ["force_ids", 100]
-];
-var queryListLimits = [
-  ["scopes", 20],
-  ["fact_types", 20],
-  ["visibility", 20],
-  ["memory_ids", 1e3],
-  ["topics", 100]
-];
-var queryFields = [
-  "include_deleted",
-  "include_archived",
-  "include_quarantined",
-  "include_superseded",
-  "archived_only",
-  "scopes",
-  "fact_types",
-  "visibility",
-  "memory_ids",
-  "topics",
-  "updated_after",
-  "topics_due",
-  "topics_extracted",
-  "event_time_overlaps",
-  "order",
-  "cursor",
-  "limit",
-  "include_embeddings"
-];
-function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// src/lib/chatStore/anuma.ts
+var ANUMA_CONVERSATION_ID = "anuma-1on1";
+var maxAttempts = 3;
+function anumaTurnContent(bubbles) {
+  return bubbles.join("\n\n");
 }
-function memoryRecord(value) {
-  if (!record(value) || !record(value.memory) || typeof value.memory.memory_id !== "string" || typeof value.memory.content !== "string" || typeof value.memory.scope !== "string" || typeof value.memory.created_at !== "number" || typeof value.memory.updated_at !== "number" || typeof value.memory.is_deleted !== "boolean" || !Number.isSafeInteger(value.version) || value.version < 1 || typeof value.server_updated_at !== "string" || value.score !== void 0 && (typeof value.score !== "number" || !Number.isFinite(value.score))) {
-    throw new Error("Invalid nearby private-memory response");
-  }
-  return value;
+function anumaLastReadSortKey(conversation) {
+  const record2 = conversation && "record" in conversation ? conversation.record : conversation;
+  const state = record2?.data.anuma;
+  if (!isObject(state)) return 0;
+  const sortKey = state.lastReadSortKey;
+  return Number.isSafeInteger(sortKey) && sortKey > 0 ? sortKey : 0;
 }
-function createNearbyRequest(options, apiPath = "/api/private-memories") {
-  const base = new URL(options.baseUrl);
-  if (!/^https?:$/.test(base.protocol) || base.username || base.password || base.search || base.hash) {
-    throw new Error(
-      "baseUrl must be an HTTP(S) origin or base path without credentials, query or fragment"
-    );
-  }
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-    throw new Error("timeoutMs must be a positive number");
-  const root = base.href.replace(/\/$/, "") + apiPath;
-  const fetcher = options.fetch ?? globalThis.fetch;
-  const cooldowns = /* @__PURE__ */ new Map();
-  const memoryBudget = (path, method) => {
-    if (method === "PUT")
-      return path === "/topics" ? "private-memory-import" : "private-memory-write";
-    if (method === "POST" && ["/import", "/memories/batch", "/topics/import"].includes(path))
-      return "private-memory-import";
-    return "private-memory-read";
-  };
-  const request = async (path, init = {}, signal) => {
-    const controller = new AbortController();
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      controller.abort();
-    }, timeoutMs);
-    const forwardAbort = () => controller.abort(signal?.reason);
-    if (signal?.aborted) forwardAbort();
-    else signal?.addEventListener("abort", forwardAbort, { once: true });
-    let rejectAborted;
-    const aborted2 = new Promise((_, reject) => {
-      rejectAborted = () => reject(
-        controller.signal.reason instanceof Error ? controller.signal.reason : new Error("Nearby request aborted")
-      );
-      if (controller.signal.aborted) rejectAborted();
-      else controller.signal.addEventListener("abort", rejectAborted, { once: true });
-    });
-    aborted2.catch(() => void 0);
-    try {
-      const token = await Promise.race([options.getToken(), aborted2]);
-      if (controller.signal.aborted) await aborted2;
-      if (!token) throw new RemoteMemoryError("Authentication required", 401);
-      const pathname = path.split("?")[0];
-      const route = `${init.method ?? "GET"} ${pathname}`;
-      const budgets = ["*", route];
-      if (apiPath === "/api/private-memories")
-        budgets.push("private-memory-ip", memoryBudget(pathname, init.method ?? "GET"));
-      for (const bucket of budgets) {
-        const cooldown = cooldowns.get(bucket);
-        if (!cooldown) continue;
-        const remaining = cooldown.until - Date.now();
-        if (remaining > 0)
-          throw new RemoteMemoryError(
-            cooldown.error.message,
-            429,
-            cooldown.error.code,
-            remaining,
-            cooldown.error.rateLimitBucket
-          );
-        cooldowns.delete(bucket);
-      }
-      const response = await fetcher(root + path, {
-        ...init,
-        headers: {
-          Authorization: `Bearer ${token}`,
-          ...init.body ? { "Content-Type": "application/json" } : {}
-        },
-        redirect: "error",
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const body = await response.json().catch(() => null);
-        const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After"));
-        const error = new RemoteMemoryError(
-          record(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
-          response.status,
-          record(body) && typeof body.code === "string" ? body.code : void 0,
-          retryAfter ?? void 0,
-          record(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
-        );
-        if (response.status === 429 && retryAfter !== null && retryAfter > 0 && (!error.code || error.code === "rate_limited")) {
-          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
-          cooldowns.set(bucket, { until: Date.now() + retryAfter, error });
-        }
-        throw error;
-      }
-      if (response.status === 204) return null;
-      return await response.json();
-    } catch (error) {
-      if (timedOut) throw new RemoteMemoryError("Nearby request timed out", 408, "timeout");
-      throw error;
-    } finally {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", forwardAbort);
-      if (rejectAborted) controller.signal.removeEventListener("abort", rejectAborted);
-    }
-  };
-  return request;
+function conflict(error) {
+  return error instanceof ChatStoreError && error.code === "version_conflict";
 }
-async function createRemoteMemoryPersistence(options) {
-  if (!options.keyId || options.keyId.length > 256)
-    throw new Error("A canonical keyId is required");
-  const request = createNearbyRequest(options);
-  const account = await request("/account", {}, options.signal);
-  if (!record(account) || account.state !== "active") {
-    throw new RemoteMemoryError(
-      "Complete and verify migration before using remote memories",
-      409,
-      "memory_not_active"
-    );
-  }
-  if (account.key_id !== options.keyId) {
-    throw new RemoteMemoryError(
-      "The canonical memory key does not match this account",
-      409,
-      "key_mismatch"
-    );
-  }
-  const snapshots = /* @__PURE__ */ new WeakMap();
-  const decode = async (value) => {
-    const item = memoryRecord(value);
-    const decrypt = async (ciphertext) => {
-      if (!ciphertextPattern.test(ciphertext))
-        throw new Error("Nearby returned unencrypted memory content");
-      const plaintext = await options.decrypt(ciphertext);
-      if (plaintext === ciphertext) throw new Error("Memory decryption failed");
-      return plaintext;
-    };
-    const decoded = {
-      ...item,
-      memory: {
-        ...item.memory,
-        content: item.memory.is_deleted && item.memory.content === "" ? "" : await decrypt(item.memory.content),
-        ...item.memory.kind_value !== void 0 && {
-          kind_value: await decrypt(item.memory.kind_value)
-        }
-      }
-    };
-    return remember(decoded, item);
-  };
-  const remember = (decoded, item) => {
-    snapshots.set(decoded, {
-      id: item.memory.memory_id,
-      version: item.version,
-      content: decoded.memory.content,
-      kindValue: decoded.memory.kind_value,
-      encryptedContent: item.memory.content,
-      encryptedKindValue: item.memory.kind_value
-    });
-    return decoded;
-  };
-  const decodeAll = async (values) => {
-    const records = values.map(memoryRecord);
-    const settled = await Promise.allSettled(records.map(decode));
-    const items = [];
-    const failed = [];
-    settled.forEach((result, i) => {
-      if (result.status === "fulfilled") items.push(result.value);
-      else
-        failed.push({
-          memory_id: records[i].memory.memory_id,
-          version: records[i].version,
-          error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
-        });
-    });
-    return { items, failed };
-  };
-  const decodeCommitted = async (value, write) => {
-    const item = memoryRecord(value);
-    if (item.memory.memory_id !== write.body.memory.memory_id || item.memory.content !== write.body.memory.content || item.memory.kind_value !== write.body.memory.kind_value)
-      return decode(item);
-    return remember(
-      {
-        ...item,
-        memory: {
-          ...item.memory,
-          content: write.content,
-          ...write.kindValue !== void 0 && { kind_value: write.kindValue }
+function live(snapshot) {
+  if (snapshot?.record.isDeleted)
+    throw new ChatStoreError("Anuma conversation was deleted", 409, "conversation_deleted");
+  return snapshot;
+}
+async function ensureAnumaConversation(store, options = {}) {
+  const existing = live(await store.get("conversation", ANUMA_CONVERSATION_ID, options.signal));
+  if (existing) return existing;
+  const at = (options.now ?? Date.now)();
+  const data = plain({ title: "Anuma", lastActivityAt: at, anuma: { lastReadSortKey: 0 } });
+  try {
+    const [created] = await store.putMany(
+      [
+        {
+          expectedVersion: 0,
+          record: {
+            kind: "conversation",
+            id: ANUMA_CONVERSATION_ID,
+            conversationId: "",
+            sortKey: conversationSortKey(data, at),
+            createdAt: at,
+            updatedAt: at,
+            isDeleted: false,
+            data
+          }
         }
-      },
-      item
-    );
-  };
-  const encryptField2 = async (plaintext) => {
-    const ciphertext = await options.encrypt(plaintext);
-    if (ciphertext === plaintext || !ciphertextPattern.test(ciphertext))
-      throw new Error("Field encryption must return SDK ciphertext; refusing to upload plaintext");
-    return ciphertext;
-  };
-  const memoryPath = (id2) => {
-    if (!id2 || id2.length > 128) throw new Error("memory_id must be 1\u2013128 characters");
-    return "/memories/" + encodeURIComponent(id2);
-  };
-  const prepareWrite = async (memory, expectedVersion, signal) => {
-    const unknown = Object.keys(memory).filter(
-      (key3) => !Object.prototype.hasOwnProperty.call(memoryFields, key3)
+      ],
+      options.signal
     );
-    if (unknown.length) {
-      throw new RemoteMemoryError(
-        `Unknown private-memory fields (${unknown.join(", ")}); refusing to forward them`,
-        400,
-        "unknown_field"
+    return created;
+  } catch (error) {
+    if (!conflict(error)) throw error;
+    const winner = live(await store.get("conversation", ANUMA_CONVERSATION_ID, options.signal));
+    if (!winner) throw error;
+    return winner;
+  }
+}
+async function markAnumaRead(store, sortKey, options = {}) {
+  if (!Number.isSafeInteger(sortKey) || sortKey < 0)
+    throw new ChatStoreError("Invalid Anuma read marker", 0, "invalid_record");
+  const now = options.now ?? Date.now;
+  for (let attempt = 1; ; attempt++) {
+    const current = await ensureAnumaConversation(store, options);
+    const read = anumaLastReadSortKey(current);
+    if (sortKey <= read) return current;
+    const record2 = current.record;
+    const state = isObject(record2.data.anuma) ? record2.data.anuma : {};
+    const data = plain({ ...record2.data, anuma: { ...state, lastReadSortKey: sortKey } });
+    try {
+      const [written] = await store.putMany(
+        [
+          {
+            expectedVersion: current.version,
+            record: {
+              ...record2,
+              data,
+              sortKey: conversationSortKey(data, record2.createdAt),
+              updatedAt: Math.max(record2.updatedAt, now())
+            }
+          }
+        ],
+        options.signal
       );
+      return written;
+    } catch (error) {
+      if (!conflict(error) || attempt >= maxAttempts) throw error;
     }
-    memory = { ...memory, ...memory.embedding && { embedding: [...memory.embedding] } };
-    const path = memoryPath(memory.memory_id);
-    const snapshot = typeof expectedVersion === "number" ? void 0 : snapshots.get(expectedVersion);
-    if (typeof expectedVersion !== "number" && (!snapshot || snapshot.id !== memory.memory_id || snapshot.version !== expectedVersion.version))
-      throw new Error(
-        "Expected snapshot must be an unmodified version from this persistence instance"
-      );
-    expectedVersion = typeof expectedVersion === "number" ? expectedVersion : snapshot.version;
-    if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
-      throw new Error("expectedVersion must be a nonnegative integer");
-    const conflict = () => new RemoteMemoryError("The memory changed since it was read", 409, "version_conflict");
-    let existing;
-    if (expectedVersion !== 0 && !snapshot) {
+  }
+}
+function countUnreadAnumaTurns(messages, lastReadSortKey) {
+  const answered = Math.max(
+    0,
+    ...messages.filter((m) => m.role === "user").map((m) => m.messageId)
+  );
+  const floor = Math.max(lastReadSortKey, answered);
+  const turns = /* @__PURE__ */ new Set();
+  for (const m of messages) {
+    if (m.role !== "assistant" || m.messageId <= floor) continue;
+    turns.add(m.anuma?.turnId ? `turn:${m.anuma.turnId}` : `message:${m.uniqueId}`);
+  }
+  return turns.size;
+}
+
+// src/lib/db/chat/summaryOperations.ts
+import { Q as Q4 } from "@nozbe/watermelondb";
+function createSummaryContext(database, encryption = {}) {
+  return {
+    ...encryption,
+    database,
+    summariesCollection: database.get("conversation_summaries")
+  };
+}
+function modelToStored(record2, summary) {
+  return {
+    uniqueId: record2.id,
+    conversationId: record2.conversationId,
+    summary,
+    summarizedUpTo: record2.summarizedUpTo,
+    tokenCount: record2.tokenCount,
+    createdAt: record2.createdAt,
+    updatedAt: record2.updatedAt
+  };
+}
+async function getConversationSummaryOp(ctx, conversationId) {
+  const results = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+  if (results.length === 0) return null;
+  const record2 = results[0];
+  const stored2 = modelToStored(record2, record2.summary);
+  if (ctx.walletAddress && isEncrypted(stored2.summary)) {
+    if (ctx.signMessage) {
       try {
-        existing = memoryRecord(await request(path, {}, signal));
+        await requestEncryptionKey(ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
       } catch (error) {
-        if (error instanceof RemoteMemoryError && error.status === 404) throw conflict();
-        throw error;
+        getLogger().warn("Failed to request the encryption key for the summary:", error);
       }
     }
-    if (existing && existing.version !== expectedVersion) throw conflict();
-    const decoded = existing ? await decode(existing).catch(() => void 0) : void 0;
-    const reusableContent = snapshot?.encryptedContent ?? existing?.memory.content;
-    const content = reusableContent && (snapshot?.content ?? decoded?.memory.content) === memory.content ? reusableContent : await encryptField2(memory.content);
-    const kindValue = memory.kind_value === void 0 ? void 0 : (snapshot?.kindValue ?? decoded?.memory.kind_value) === memory.kind_value ? snapshot?.encryptedKindValue ?? existing.memory.kind_value : await encryptField2(memory.kind_value);
-    return {
-      body: {
-        expected_version: expectedVersion,
-        memory: { ...memory, content, ...kindValue !== void 0 && { kind_value: kindValue } }
-      },
-      content: memory.content,
-      kindValue: memory.kind_value
-    };
-  };
-  const fetchCandidates = async (embedding2, candidateOptions, withCounts) => {
-    const limit = candidateOptions.limit ?? 100;
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
-      throw new Error("Candidate limit must be 1\u2013100");
-    for (const [key3, max] of candidateListLimits) {
-      const values = candidateOptions[key3];
-      if (values && values.length > max)
-        throw new Error(`Candidate ${key3} accepts at most ${max} entries (got ${values.length})`);
+    stored2.summary = await decryptField(stored2.summary, ctx.walletAddress);
+  } else if (ctx.walletAddress && ctx.signMessage && stored2.summary) {
+    try {
+      const encryptedSummary = await encryptField(
+        stored2.summary,
+        ctx.walletAddress,
+        ctx.signMessage,
+        ctx.embeddedWalletSigner
+      );
+      await ctx.database.write(async () => {
+        const current = await ctx.summariesCollection.query(Q4.where("id", record2.id)).fetch();
+        if (current[0]?.summary === stored2.summary) {
+          await current[0].update((rec) => {
+            rec.summary = encryptedSummary;
+          });
+        }
+      });
+    } catch (error) {
+      getLogger().warn("Failed to encrypt the legacy summary:", error);
     }
-    const result = await request(
-      "/candidates",
-      {
-        method: "POST",
-        body: JSON.stringify({
-          embedding: embedding2,
-          limit,
-          force_ids: candidateOptions.force_ids ?? [],
-          ...withCounts && { with_counts: true },
-          ...Object.fromEntries(
-            [
-              "scopes",
-              "memory_ids",
-              "embedding_model",
-              "strict_model",
-              "include_deleted",
-              "deleted_only"
-            ].filter(
-              (key3) => candidateOptions[key3] !== void 0
-            ).map((key3) => [key3, candidateOptions[key3]])
-          ),
-          ...candidateOptions.fact_types !== void 0 && {
-            fact_types: candidateOptions.fact_types
-          },
-          ...candidateOptions.include_archived !== void 0 && {
-            include_archived: candidateOptions.include_archived
-          },
-          ...candidateOptions.include_quarantined !== void 0 && {
-            include_quarantined: candidateOptions.include_quarantined
-          },
-          ...candidateOptions.include_superseded !== void 0 && {
-            include_superseded: candidateOptions.include_superseded
-          }
-        })
-      },
-      candidateOptions.signal
-    );
-    if (!record(result) || !Array.isArray(result.items))
-      throw new Error("Invalid nearby candidate response");
-    return result;
-  };
-  const fetchQueryPage = async (queryOptions) => {
-    const { signal, ...query } = queryOptions;
-    if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
-      throw new Error("Page limit must be 1\u2013200");
-    for (const [key3, max] of queryListLimits) {
-      const values = query[key3];
-      if (values && values.length > max)
-        throw new Error(`Query ${key3} accepts at most ${max} entries (got ${values.length})`);
+  }
+  return stored2;
+}
+async function upsertConversationSummaryOp(ctx, conversationId, summary, summarizedUpTo, tokenCount) {
+  const revision2 = getConversationRevision(ctx.database, conversationId);
+  let record2;
+  const encryptedSummary = ctx.walletAddress ? await encryptField(summary, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner) : summary;
+  await ctx.database.write(async () => {
+    assertConversationRevision(ctx.database, conversationId, revision2);
+    const existing = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+    if (existing.length > 0) {
+      record2 = await existing[0].update((rec) => {
+        rec.summary = encryptedSummary;
+        rec.summarizedUpTo = summarizedUpTo;
+        rec.tokenCount = tokenCount;
+      });
+    } else {
+      record2 = await ctx.summariesCollection.create((rec) => {
+        rec.conversationId = conversationId;
+        rec.summary = encryptedSummary;
+        rec.summarizedUpTo = summarizedUpTo;
+        rec.tokenCount = tokenCount;
+      });
+    }
+  });
+  return modelToStored(record2, summary);
+}
+async function deleteConversationSummaryOp(ctx, conversationId) {
+  await ctx.database.write(async () => {
+    const existing = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
+    for (const record2 of existing) {
+      await record2.destroyPermanently();
+    }
+  });
+}
+
+// src/lib/db/conversationMemory/models.ts
+import { Model as Model3 } from "@nozbe/watermelondb";
+import { date as date2, field as field2, readonly, text as text4 } from "@nozbe/watermelondb/decorators";
+var ConversationMemory = class extends Model3 {
+};
+ConversationMemory.table = "conversation_memory";
+ConversationMemory.associations = {};
+__decorateClass([
+  text4("conversation_id")
+], ConversationMemory.prototype, "conversationId", 2);
+__decorateClass([
+  text4("memory_id")
+], ConversationMemory.prototype, "memoryId", 2);
+__decorateClass([
+  field2("score")
+], ConversationMemory.prototype, "score", 2);
+__decorateClass([
+  readonly,
+  date2("created_at")
+], ConversationMemory.prototype, "createdAt", 2);
+
+// src/lib/chatStore/chatImports.ts
+var importBatch = 100;
+var importChunks = 200;
+var importPlaintextBytes = 39e5;
+function ms(date10, fallback = 1) {
+  const value = date10?.getTime();
+  return value && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}
+function bytes2(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+function conversationRecord(conversation, messages) {
+  const createdAt = ms(conversation.createdAt);
+  const data = plain({
+    ...contextFields(conversation.context),
+    title: conversation.title,
+    projectId: conversation.projectId || void 0,
+    pinnedAt: conversation.pinnedAt ? ms(conversation.pinnedAt) : void 0,
+    lastActivityAt: Math.max(
+      ms(conversation.updatedAt, createdAt),
+      ...messages.map((m) => ms(m.createdAt))
+    )
+  });
+  return {
+    record: {
+      kind: "conversation",
+      id: conversation.conversationId,
+      conversationId: "",
+      sortKey: conversationSortKey(data, createdAt),
+      createdAt,
+      updatedAt: ms(conversation.updatedAt, createdAt),
+      isDeleted: false,
+      data
     }
-    const page = await request(
-      "/memories/query",
-      {
-        method: "POST",
-        body: JSON.stringify(
-          Object.fromEntries(
-            queryFields.filter((key3) => query[key3] !== void 0).map((key3) => [key3, query[key3]])
-          )
-        )
-      },
-      signal
-    );
-    if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
-      throw new Error("Invalid nearby private-memory page");
-    return page;
-  };
-  const candidateSet = async (embedding2, candidateOptions = {}) => {
-    const result = await fetchCandidates(embedding2, candidateOptions, true);
-    if (!Number.isSafeInteger(result.total_count) || result.total_count < 0 || !Number.isSafeInteger(result.unavailable_count) || result.unavailable_count < 0)
-      throw new Error("Invalid nearby candidate response");
-    return {
-      ...await decodeAll(result.items),
-      total_count: result.total_count,
-      unavailable_count: result.unavailable_count
-    };
   };
+}
+function messageRecord(message) {
+  const {
+    uniqueId: _uniqueId,
+    messageId: _messageId,
+    createdAt: _createdAt,
+    updatedAt: _updatedAt,
+    decryptionStatus: _status,
+    chunks: chunks3,
+    vector: vector2,
+    ...fields
+  } = message;
+  const fitted = chunks3?.length ? fitChunks(chunks3) : void 0;
+  const single = fitted ? void 0 : acceptedVector(vector2);
+  const embeddings2 = fitted?.map((c) => c.vector) ?? (single ? [single] : void 0);
+  const record2 = fitRecord({
+    kind: "message",
+    id: message.uniqueId,
+    conversationId: message.conversationId,
+    sortKey: message.messageId,
+    createdAt: ms(message.createdAt),
+    updatedAt: ms(message.updatedAt, ms(message.createdAt)),
+    isDeleted: false,
+    data: {
+      ...messageData(fields),
+      ...fitted ? { chunkOffsets: fitted.map((c) => [c.startOffset, c.endOffset]) } : {}
+    }
+  });
   return {
-    ...createRemoteTopicPersistence(request),
-    ...createRemoteWorkPersistence(request),
-    supportsRealtimeChanges: account.realtime_changes === true,
-    counts: async () => {
-      const result = await request("/counts", {});
-      if (!record(result) || ["live", "archived", "quarantined"].some(
-        (key3) => !Number.isSafeInteger(result[key3]) || result[key3] < 0
-      ))
-        throw new Error("Invalid nearby memory counts");
-      return {
-        live: result.live,
-        archived: result.archived,
-        quarantined: result.quarantined
-      };
-    },
-    temporal: async (window2, limit = 100) => {
-      if (!Number.isFinite(window2.start) || !Number.isFinite(window2.end) || window2.end <= window2.start || !Number.isInteger(limit) || limit < 1 || limit > 100)
-        throw new Error("Temporal window must have end > start and limit must be 1\u2013100");
-      const result = await request("/temporal", {
-        method: "POST",
-        body: JSON.stringify({ ...window2, limit })
-      });
-      if (!record(result) || !Array.isArray(result.items) || result.items.some(
-        (item) => !record(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
-      ))
-        throw new Error("Invalid nearby temporal candidates");
-      return result.items.map((item) => item.memory_id);
-    },
-    get: async (id2, signal) => {
-      try {
-        return await decode(await request(memoryPath(id2), {}, signal));
-      } catch (error) {
-        if (error instanceof RemoteMemoryError && error.status === 404) return null;
-        throw error;
-      }
-    },
-    list: async (listOptions = {}) => {
-      const { signal, ...query } = listOptions;
-      if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) {
-        throw new Error("Page limit must be 1\u2013200");
-      }
-      const params = new URLSearchParams();
-      for (const key3 of [
-        "cursor",
-        "limit",
-        "include_deleted",
-        "include_archived",
-        "include_quarantined",
-        "include_superseded",
-        "include_embeddings"
-      ]) {
-        if (query[key3] !== void 0) params.set(key3, String(query[key3]));
-      }
-      const page = await request("/memories?" + params.toString(), {}, signal);
-      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
-        throw new Error("Invalid nearby private-memory page");
-      }
-      return {
-        ...await decodeAll(page.items),
-        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
-      };
-    },
-    put: async (memory, expectedVersion, signal) => {
-      const write = await prepareWrite(memory, expectedVersion, signal);
-      return decodeCommitted(
-        await request(
-          memoryPath(write.body.memory.memory_id),
-          {
-            method: "PUT",
-            body: JSON.stringify({ key_id: options.keyId, ...write.body })
-          },
-          signal
-        ),
-        write
-      );
-    },
-    putMany: async (writes, signal, leaseToken) => {
-      if (writes.length < 1 || writes.length > 50 || new Set(writes.map((w) => w.memory.memory_id)).size !== writes.length)
-        throw new Error("Batch must contain 1\u201350 distinct memory ids");
-      const prepared = await Promise.all(
-        writes.map((w) => prepareWrite(w.memory, w.expectedVersion, signal))
-      );
-      const result = await request(
-        "/memories/batch",
-        {
-          method: "POST",
-          body: JSON.stringify({
-            key_id: options.keyId,
-            writes: prepared.map((w) => w.body),
-            ...leaseToken && { lease_token: leaseToken }
-          })
-        },
-        signal
-      );
-      if (!record(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
-        throw new Error("Invalid nearby batch response");
-      return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
-    },
-    query: async (queryOptions = {}) => {
-      const page = await fetchQueryPage(queryOptions);
-      return {
-        ...await decodeAll(page.items),
-        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor },
-        ...page.changes_cursor !== void 0 && { changes_cursor: page.changes_cursor }
-      };
-    },
-    queryMetadata: async (queryOptions = {}) => {
-      const page = await fetchQueryPage(queryOptions);
-      return {
-        items: page.items.map((item) => {
-          const {
-            memory: { content: _content, kind_value: _kindValue, ...memory },
-            version,
-            server_updated_at
-          } = memoryRecord(item);
-          return { memory, version, server_updated_at };
-        }),
-        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
-      };
-    },
-    candidateSet,
-    candidates: async (embedding2, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding2, candidateOptions, false)).items)
+    record: record2,
+    ...embeddings2 ? { embeddings: embeddings2 } : {},
+    ...embeddings2 && message.embeddingModel ? { embeddingModel: message.embeddingModel } : {}
   };
 }
-
-// src/lib/chatStore/types.ts
-var ChatStoreError = class extends Error {
-  constructor(message, status, code, retryAfterMs) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.retryAfterMs = retryAfterMs;
-    this.name = "ChatStoreError";
+function batches(records) {
+  const out = [];
+  let batch = [];
+  let chunks3 = 0;
+  let size = 0;
+  for (const item of records) {
+    const vectors = item.embeddings?.length ?? 0;
+    const itemSize = bytes2(item.record);
+    if (batch.length > 0 && (batch.length >= importBatch || chunks3 + vectors > importChunks || size + itemSize > importPlaintextBytes)) {
+      out.push(batch);
+      batch = [];
+      chunks3 = 0;
+      size = 0;
+    }
+    batch.push(item);
+    chunks3 += vectors;
+    size += itemSize;
   }
-};
+  if (batch.length) out.push(batch);
+  return out;
+}
 
 // src/lib/chatStore/remote.ts
 var kinds = /* @__PURE__ */ new Set(["conversation", "message", "summary", "project", "memory_links", "setting"]);
@@ -11867,10 +12180,10 @@ async function deletedSinceUpload(store, journal, local, signal) {
   const present = /* @__PURE__ */ new Set([...local.records.map((r) => key(r.record)), ...local.skipped.keys()]);
   const gone = [...journal.keys].filter((k) => !present.has(k));
   if (gone.length === 0) return [];
-  const live = (await store.getMany(gone.map(ref2), signal)).filter((s) => !s.record.isDeleted);
-  const tombstoning = new Set(live.map((s) => key(s.record)));
+  const live2 = (await store.getMany(gone.map(ref2), signal)).filter((s) => !s.record.isDeleted);
+  const tombstoning = new Set(live2.map((s) => key(s.record)));
   await journal.drop(gone.filter((k) => !tombstoning.has(k)));
-  return live.map(({ record: record2, version }) => {
+  return live2.map(({ record: record2, version }) => {
     const empty = emptied[record2.kind];
     return {
       record: {
@@ -12530,12 +12843,13 @@ var resumableFields = [
   "error",
   "thoughtProcess",
   "thinking",
-  "toolCallEvents"
+  "toolCallEvents",
+  "anuma"
 ];
 function resumedFields(options) {
   return plain(
     Object.fromEntries(
-      resumableFields.filter((f) => options[f] !== void 0).map((f) => [f, options[f]])
+      resumableFields.filter((f) => options[f] !== void 0).map((f) => [f, f === "anuma" ? anumaTurnData(options.anuma) : options[f]])
     )
   );
 }
@@ -13189,7 +13503,7 @@ function createVaultChatBackend(options) {
     },
     async getConversations(query) {
       await available2();
-      return all("conversation").map(toConversation).filter(
+      return all("conversation").filter((record2) => record2.id !== ANUMA_CONVERSATION_ID).map(toConversation).filter(
         (c) => query?.projectId === void 0 || (query.projectId === null ? !c.projectId : c.projectId === query.projectId)
       ).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
@@ -13232,6 +13546,7 @@ function createVaultChatBackend(options) {
       return !!record2 && !record2.isDeleted;
     },
     async deleteConversation(conversationId) {
+      if (conversationId === ANUMA_CONVERSATION_ID) return false;
       const record2 = await conversation(conversationId);
       if (!record2 || record2.isDeleted) return false;
       for (const [k, patch] of pending)
@@ -16238,7 +16553,7 @@ async function countActiveVaultMemoriesOp(ctx) {
   return ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx)).fetchCount();
 }
 async function getVaultMemoryCountsOp(ctx) {
-  const [live, archived, quarantined] = await Promise.all([
+  const [live2, archived, quarantined] = await Promise.all([
     countActiveVaultMemoriesOp(ctx),
     ctx.vaultMemoryCollection.query(
       ...baseVaultConditions(ctx, { includeArchived: true }),
@@ -16249,7 +16564,7 @@ async function getVaultMemoryCountsOp(ctx) {
       Q6.where("trust_tier", "quarantined")
     ).fetchCount()
   ]);
-  return { live, archived, quarantined };
+  return { live: live2, archived, quarantined };
 }
 async function getActiveVaultMemoryIdsOp(ctx, ids) {
   if (ids.length === 0) return /* @__PURE__ */ new Set();
@@ -17534,12 +17849,12 @@ var WalletPoller = class {
    * @param maxAttempts - Maximum polling attempts before giving up (default: 60)
    * @returns Stop function to cancel polling
    */
-  startPolling(checkWallet, onWalletReady, intervalMs = DEFAULT_INTERVAL_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
+  startPolling(checkWallet, onWalletReady, intervalMs = DEFAULT_INTERVAL_MS, maxAttempts2 = DEFAULT_MAX_ATTEMPTS) {
     this.stop();
     this.attempts = 0;
     const poll = async () => {
       this.attempts++;
-      if (this.attempts > maxAttempts) {
+      if (this.attempts > maxAttempts2) {
         this.stop();
         return;
       }
@@ -20513,7 +20828,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     content: m.content,
     similarity: m.similarity
   }));
-  const { consolidateMemory: doConsolidate } = await import("./consolidate-7QUL3TOE.mjs");
+  const { consolidateMemory: doConsolidate } = await import("./consolidate-QBV3DDHU.mjs");
   const decision = await doConsolidate(trimmed, candidates, consolidateOptions);
   if (decision.action === "create") return decision.fallbackReason ? null : { create: true };
   if (decision.action === "supersede" && decision.content) {
@@ -24900,13 +25215,13 @@ function createRemoteMemoryStore(options) {
     });
     return run;
   };
-  const live = async (id2) => {
+  const live2 = async (id2) => {
     const record2 = await persistence.get(id2);
     return record2 && !record2.memory.is_deleted ? record2 : null;
   };
   const mutateLocked = async (id2, change, edit, writeOptions) => {
     writeOptions?.signal?.throwIfAborted();
-    const record2 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live(id2);
+    const record2 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live2(id2);
     if (!record2) return null;
     if (record2.memory.is_deleted) return null;
     if (writeOptions?.canWrite && !await writeOptions.canWrite())
@@ -25704,7 +26019,7 @@ function createRemoteMemoryStore(options) {
       }, clear);
       return snapshot.then((topics) => structuredClone(topics));
     },
-    get: async (id2) => asStored(await live(id2)),
+    get: async (id2) => asStored(await live2(id2)),
     listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
       (record2) => stored(record2.memory)
     ),
@@ -25789,7 +26104,7 @@ function createRemoteMemoryStore(options) {
       return serialized(
         first,
         () => serialized(second, async () => {
-          const [old, next] = await Promise.all([live(id2), live(supersededById)]);
+          const [old, next] = await Promise.all([live2(id2), live2(supersededById)]);
           if (!old || !next || old.memory.superseded_by || next.memory.superseded_by) return false;
           if (old.memory.kind !== void 0 && old.memory.kind !== null) return false;
           const saved = await persistence.putMany([
@@ -25810,7 +26125,7 @@ function createRemoteMemoryStore(options) {
       (memory) => memory.archived_at === void 0 || memory.archived_at === null ? { ...memory, archived_at: Date.now() } : null
     ),
     restore: (id2) => serialized(id2, async () => {
-      const record2 = await live(id2);
+      const record2 = await live2(id2);
       if (!record2) return false;
       if (record2.memory.archived_at === void 0 || record2.memory.archived_at === null)
         return true;
@@ -29885,6 +30200,8 @@ function useChat(options) {
       const requestId = ++requestIdRef.current;
       const superseded = () => requestIdRef.current !== requestId;
       pendingResumeRef.current = null;
+      let liveRound = null;
+      const deferredErrors = [];
       setIsLoading(true);
       try {
         const tokenGetterValidation = validateTokenGetter(getToken);
@@ -29940,7 +30257,7 @@ function useChat(options) {
           };
           messagesWithContext = [toolGuidanceMessage, ...messagesWithContext];
         }
-        const result = await runToolLoop({
+        const loopResult = await runToolLoop({
           messages: messagesWithContext,
           model,
           token,
@@ -29964,12 +30281,13 @@ function useChat(options) {
           transport: xhrTransport,
           onStreamMeta: (meta) => {
             const resolvedApiType = resolveApiType(requestApiType ?? defaultApiType, model);
-            pendingResumeRef.current = {
+            liveRound = {
               inferenceId: meta.inferenceId,
               apiType: resolvedApiType,
               model,
               conversationId
             };
+            pendingResumeRef.current = liveRound;
             if (onStreamMetaConsumer) {
               try {
                 onStreamMetaConsumer({
@@ -29992,16 +30310,28 @@ function useChat(options) {
             if (globalOnThinking) globalOnThinking(chunk);
           },
           onFinish,
-          onError,
+          onError: resumable ? (error) => deferredErrors.push(error) : onError,
           onToolCall,
           onServerToolCall,
           onToolCallArgumentsDelta,
-          onStepFinish,
+          onStepFinish: (event) => {
+            liveRound = null;
+            onStepFinish?.(event);
+          },
           preProcessors,
           hooks,
           piiRedaction: requestPiiRedaction ?? resolvedPiiRedaction,
           onPiiRedacted
         });
+        const result = resumable && loopResult.error !== null && loopResult.connectionLost && liveRound ? {
+          data: loopResult.data,
+          error: "Request detached",
+          detached: true,
+          resume: liveRound
+        } : loopResult;
+        if (!("detached" in result && result.detached)) {
+          deferredErrors.forEach((error) => onError?.(error));
+        }
         if (superseded()) {
         } else if ("detached" in result && result.detached && result.resume) {
           pendingResumeRef.current = result.resume;
@@ -30045,13 +30375,25 @@ function useChat(options) {
       onStreamMetaConsumer
     ]
   );
+  const getActiveStreams = useCallback3(
+    async (conversationId) => {
+      const getterValidation = validateTokenGetter(getToken);
+      if (!getterValidation.valid) throw new Error(getterValidation.message);
+      const token = await getToken();
+      const tokenValidation = validateToken(token);
+      if (!tokenValidation.valid) throw new Error(tokenValidation.message);
+      return listActiveStreams({ token, baseUrl, conversationId });
+    },
+    [getToken, baseUrl]
+  );
   return {
     isLoading,
     sendMessage,
     stop,
     cancel,
     detach,
-    resumeStream: resumeStream2
+    resumeStream: resumeStream2,
+    getActiveStreams
   };
 }
 
@@ -31107,6 +31449,7 @@ function useChatStorage(options) {
     resumable = false,
     onCancelResult,
     onStreamMeta,
+    inbox,
     onToolSelection,
     piiRedaction,
     onPiiRedacted,
@@ -31574,13 +31917,19 @@ function useChatStorage(options) {
     },
     [vaultCtx, memoryStore]
   );
+  const activeReplyIdRef = useRef4(void 0);
+  const handleStreamMeta = useCallback5(
+    (meta) => onStreamMeta?.({ ...meta, assistantMessageId: activeReplyIdRef.current }),
+    [onStreamMeta]
+  );
   const {
     isLoading,
     sendMessage: baseSendMessage,
     stop: baseStop,
     cancel: baseCancel,
     detach,
-    resumeStream: baseResumeStream
+    resumeStream: baseResumeStream,
+    getActiveStreams
   } = useChat({
     getToken,
     baseUrl,
@@ -31594,7 +31943,7 @@ function useChatStorage(options) {
     smoothing,
     resumable,
     onCancelResult,
-    onStreamMeta,
+    onStreamMeta: onStreamMeta ? handleStreamMeta : void 0,
     piiRedaction: resolvedPiiRedaction,
     onPiiRedacted,
     onServerToolCall,
@@ -31810,10 +32159,13 @@ function useChatStorage(options) {
   getTokenRef.current = getToken;
   const finalizeResumedRow = useCallback5(
     async (ctx, data, wasStopped, responseDuration, viaQueue = false) => {
-      const { content, thinking } = extractAssistantText(data);
-      let parentMessageId = ctx.userMessageUniqueId;
+      const extracted2 = extractAssistantText(data);
+      const restore = ctx.restoreText ?? ((text16) => text16);
+      const content = restore(extracted2.content);
+      const thinking = extracted2.thinking ? restore(extracted2.thinking) : extracted2.thinking;
+      let parentMessageId = ctx.parentless ? void 0 : ctx.userMessageUniqueId;
       let knownIds = ctx.knownToolCallEventIds;
-      if (ctx.convId && (!knownIds || !parentMessageId)) {
+      if (ctx.convId && (!knownIds || !parentMessageId && !ctx.parentless)) {
         let storedMessages = null;
         try {
           storedMessages = await getMessages(ctx.convId);
@@ -31831,7 +32183,7 @@ function useChatStorage(options) {
               }
             }
           }
-          if (!parentMessageId) {
+          if (!parentMessageId && !ctx.parentless) {
             for (let i = storedMessages.length - 1; i >= 0; i--) {
               if (storedMessages[i].uniqueId !== ctx.assistantUniqueId) {
                 parentMessageId = storedMessages[i].uniqueId;
@@ -31870,7 +32222,15 @@ function useChatStorage(options) {
         toolCallEvents: currentTurnToolCallEvents && currentTurnToolCallEvents.length > 0 ? currentTurnToolCallEvents : void 0,
         uniqueId: ctx.assistantUniqueId
       };
-      if (!viaQueue) return backend.upsertMessage(rowOpts);
+      if (wasStopped) {
+        try {
+          const [current] = await backend.getMessagesByIds([rowOpts.uniqueId]);
+          if (current && !current.wasStopped && !current.error) return current;
+        } catch (err) {
+          getLogger().warn("[useChatStorage] Could not check for a stored answer:", err);
+        }
+      }
+      if (!viaQueue) return clearTurnErrors(backend, await backend.upsertMessage(rowOpts));
       const { result } = await writeOrQueue(
         "createMessage",
         rowOpts,
@@ -32485,6 +32845,7 @@ function useChatStorage(options) {
         } catch {
         }
       }
+      activeReplyIdRef.current = resumable ? effectiveAssistantUniqueId : void 0;
       const result = await baseSendMessage({
         messages: messagesToSend,
         model,
@@ -32510,15 +32871,23 @@ function useChatStorage(options) {
         imageModel,
         conversationId: convId,
         piiRedaction: callPiiRedaction,
-        headers
+        headers: resumable && effectiveAssistantUniqueId ? {
+          ...headers,
+          "X-Parent-Message-ID": storedUserMessage.uniqueId,
+          "X-Assistant-Message-ID": effectiveAssistantUniqueId
+        } : headers
       });
+      if (activeReplyIdRef.current === effectiveAssistantUniqueId) {
+        activeReplyIdRef.current = void 0;
+      }
       const responseDuration = (Date.now() - startTime) / 1e3;
       const detachedResult = result;
       if (detachedResult.detached) {
         recordToolSetTurn(database, convId, matchedToolSets);
         const rowId = effectiveAssistantUniqueId ?? `msg_${uuidv78()}`;
+        const resume = detachedResult.resume ? { ...detachedResult.resume, assistantMessageId: rowId } : null;
         pendingResumeRef.current = {
-          handle: detachedResult.resume ?? null,
+          handle: resume,
           convId,
           userMessageUniqueId: storedUserMessage.uniqueId,
           userMessageQueueId: userMsgQueueId,
@@ -32536,7 +32905,7 @@ function useChatStorage(options) {
           data: detachedResult.data ?? null,
           error: "Request detached",
           detached: true,
-          resume: detachedResult.resume ?? null,
+          resume,
           assistantUniqueId: rowId,
           userMessage: storedUserMessage
         };
@@ -32776,7 +33145,7 @@ function useChatStorage(options) {
         handle: handleOverride,
         convId: handleOverride.conversationId ?? currentConversationId ?? "",
         userMessageUniqueId: "",
-        assistantUniqueId: `msg_resume_${handleOverride.inferenceId}`,
+        assistantUniqueId: handleOverride.assistantMessageId ?? `msg_resume_${handleOverride.inferenceId}`,
         model: handleOverride.model,
         imageModel: void 0,
         sources: void 0,
@@ -32900,6 +33269,10 @@ function useChatStorage(options) {
       retirementStopRequestedRef.current = true;
       return;
     }
+    const replaying = activeResumeRef.current;
+    if (replaying && !replaying.headless && replaying.context.handle) {
+      baseCancel(replaying.context.handle);
+    }
     const pending = pendingResumeRef.current;
     if (pending && pending.assistantUniqueId && !isResumingRef.current) {
       const finalize = pending;
@@ -32924,13 +33297,90 @@ function useChatStorage(options) {
       })();
     }
     baseStop();
-  }, [baseStop, finalizeResumedRow]);
+  }, [baseStop, baseCancel, finalizeResumedRow]);
+  const watchStream = useCallback5(
+    (stream) => baseResumeStream({
+      inferenceId: stream.inferenceId,
+      apiType: stream.apiType,
+      model: stream.model,
+      conversationId: stream.conversationId ?? void 0
+    }),
+    [baseResumeStream]
+  );
+  const registeredInboxKeyRef = useRef4(null);
+  const deliverInbox = useCallback5(async () => {
+    if (!inbox || !walletAddress || !signMessage) return [];
+    const keyPair = await getKeyPair(walletAddress, signMessage, embeddedWalletSigner);
+    const publicKey = await exportInboxPublicKey(keyPair.publicKey);
+    const registered = registeredInboxKeyRef.current;
+    if (registered?.inbox !== inbox || registered.publicKey !== publicKey) {
+      await inbox.putPublicKey(publicKey);
+      registeredInboxKeyRef.current = { inbox, publicKey };
+    }
+    const results = await deliverInboxAnswers({
+      inbox,
+      keyPair,
+      backend,
+      store: async (opened, messageId) => {
+        const { redactor } = resolveCallPii(
+          void 0,
+          piiRedaction,
+          () => getConversationRedactor(opened.conversation_id, nerDetectorRef.current)
+        );
+        const stored2 = await finalizeResumedRow(
+          {
+            handle: null,
+            convId: opened.conversation_id,
+            userMessageUniqueId: opened.parent_message_id ?? "",
+            parentless: opened.parent_message_id === null,
+            restoreText: redactor ? (text16) => redactor.deAnonymize(text16) : void 0,
+            assistantUniqueId: messageId,
+            model: opened.model,
+            imageModel: void 0,
+            sources: void 0,
+            thoughtProcess: void 0,
+            startTime: Date.now(),
+            partialData: null
+          },
+          opened.response,
+          opened.status === "tool_request",
+          0
+        );
+        void embedMessageAsync(stored2, (text16) => redactor ? redactor.maskText(text16) : text16);
+        return stored2;
+      }
+    });
+    const pending = pendingResumeRef.current;
+    const answered = results.some(
+      (r) => (r.status === "stored" || r.status === "delivered") && r.assistantMessage?.uniqueId === pending?.assistantUniqueId
+    );
+    if (pending && answered) pendingResumeRef.current = null;
+    return results;
+  }, [
+    inbox,
+    walletAddress,
+    signMessage,
+    embeddedWalletSigner,
+    backend,
+    piiRedaction,
+    getConversationRedactor,
+    finalizeResumedRow,
+    embedMessageAsync
+  ]);
+  const detachWithReplyId = useCallback5(() => {
+    const handle = detach();
+    const replyId = activeReplyIdRef.current;
+    return handle && replyId ? { ...handle, assistantMessageId: replyId } : handle;
+  }, [detach]);
   return {
     isLoading,
     sendMessage,
     stop,
-    detach,
+    detach: detachWithReplyId,
     resumeStream: resumeStream2,
+    getActiveStreams,
+    watchStream,
+    deliverInbox,
     conversationId: currentConversationId,
     setConversationId: setCurrentConversationId,
     createConversation,
@@ -32956,6 +33406,7 @@ function useChatStorage(options) {
   };
 }
 export {
+  ANUMA_CONVERSATION_ID,
   CHUNKS_DISCARDED_ORIGIN,
   Conversation as ChatConversation,
   Message as ChatMessage,
@@ -33015,6 +33466,8 @@ export {
   WALLET_PAYMENT_TOOL_NAME,
   WalletPoller,
   addConversationMemoriesOp,
+  anumaLastReadSortKey,
+  anumaTurnContent,
   archiveVaultMemoryOp,
   assembleMemoryContext,
   attachFileContextToLastUserMessage,
@@ -33048,6 +33501,7 @@ export {
   consoleLogger,
   conversationMemoryToStored,
   cosineInt8,
+  countUnreadAnumaTurns,
   createAutoExtractor,
   createChunkVectorCache,
   createCryptoPricePreProcessor,
@@ -33075,6 +33529,7 @@ export {
   createVaultChatBackend,
   createVaultEmbeddingCache,
   createVaultFolderOp,
+  createVaultInbox,
   createVaultMemoriesBatchOp,
   createVaultMemoryOp,
   createWalletPaymentTool,
@@ -33096,8 +33551,10 @@ export {
   embedMessage,
   encodeChunkVector,
   encryptToolCallEventsOp,
+  ensureAnumaConversation,
   ensureDefaultFoldersOp,
   exchangeNotionCode,
+  exportInboxPublicKey,
   extractAndLinkEntitiesForMemoriesOp,
   extractAndRetain,
   extractEntitiesForMemories,
@@ -33134,8 +33591,10 @@ export {
   isEncrypted,
   isPiiRedactor,
   isRerankerAvailable,
+  listActiveStreams,
   loadSettings,
   localChatBackend,
+  markAnumaRead,
   maskScopedEmbeddingCache,
   maxVaultAttachmentBytes,
   memoryCipher,
@@ -33145,12 +33604,14 @@ export {
   moveMemoriesToFolderOp,
   noopLogger,
   onKeyAvailable,
+  openInboxItem,
   parseMedia,
   preEmbedVaultMemories,
   primaryTopic,
   quantizeEmbedding,
   queueManager,
   rankProfileCandidates,
+  readAnumaTurn,
   recall,
   reencryptMemoryField,
   reflect,