@circuitwall/jarela 2.3.0 → 2.5.0

package/lib/bridges/whatsapp.ts

@@ -29,12 +29,13 @@ import {
   bumpRouteLastSeenTs,
   findRoute,
   getBridge,
-  getMaxRouteLastSeenTs,
+  getRouteLastSeenTsMap,
 } from "@/lib/stores/bridges";
 import { ensureWhatsAppAuthDir, removeWhatsAppAuth } from "./modules/whatsapp/auth-state";
 import type { BridgeAdapter, ChatInfo, InboundEvent, InboundHandler, StatusHandler, InboundMessage, StatusUpdate } from "./types";
 import type { ContentPart } from "@/lib/tools/runtime/types";
 import { storeCanonicalBridgeAttachment } from "./attachment-store";
+import { whatsappChatLink } from "./whatsapp-link";
 import { errorMessage } from "@/lib/utils/error";
 
 // Baileys + qrcode are dev-time-installed peer libs. We never import their
@@ -285,12 +286,12 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
       // adapter should re-deliver to agents) and the legacy
       // `replace`/`update` events that arrive via messages.update.
       if (payload.type !== "notify" && payload.type !== "append") return;
-      // On a fresh adapter boot the watermark is whatever the last run
-      // persisted. Read it once per batch (cheap SQLite call) so we can
-      // hard-reject very old appends without doing any per-message work.
-      const watermark = payload.type === "append"
-        ? getMaxRouteLastSeenTs(this.bridge_id)
-        : 0;
+      // On a fresh adapter boot the watermarks are whatever the last run
+      // persisted. Read them once per batch (one cheap SQLite call) so old
+      // appends are rejected without per-message queries.
+      const watermarks = payload.type === "append"
+        ? getRouteLastSeenTsMap(this.bridge_id)
+        : null;
       for (const raw of payload.messages ?? []) {
         const m = raw as {
           key?: { remoteJid?: string; remoteJidAlt?: string; fromMe?: boolean; id?: string; participant?: string };
@@ -324,18 +325,20 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
         const ts = typeof m.messageTimestamp === "number"
           ? m.messageTimestamp * 1000
           : (m.messageTimestamp?.low ?? 0) * 1000 || Date.now();
-        // Watermark gate: on `append` batches, skip anything strictly
-        // older than the highest per-route watermark we've persisted. This
-        // prevents the server's reconnect replay from re-delivering
-        // messages we already routed in a previous process lifetime.
-        // `notify` events skip this check — they're live and may legitimately
-        // arrive in any order relative to the cross-route max.
-        if (payload.type === "append" && watermark > 0 && ts > 0 && ts <= watermark) {
+        // Watermark gate: on `append` batches, skip anything at or below
+        // this chat's own persisted watermark. This prevents the server's
+        // reconnect replay from re-delivering messages we already routed in
+        // a previous process lifetime. `notify` events skip this check —
+        // they're live and may legitimately arrive out of order.
+        const watermark = watermarks?.get(remote_jid) ?? 0;
+        if (watermark > 0 && ts > 0 && ts <= watermark) {
           continue;
         }
-        // In groups, pushName is typically the participant's display name,
-        // not the group subject. Avoid poisoning the group chat label.
-        this.observeChat(remote_jid, is_group ? null : (m.pushName ?? null), ts);
+        // pushName names the *sender*: in groups that's a participant, and on
+        // fromMe messages it's the user's own name. Only a counterpart's
+        // pushName in a 1:1 chat is a valid label for the chat itself.
+        const chatPushName = is_group || m.key.fromMe ? null : (m.pushName ?? null);
+        this.observeChat(remote_jid, chatPushName, ts);
 
         // Unwrap protocol envelopes (view-once, ephemeral, etc.) so we can
         // see the underlying payload uniformly, then turn it into a text
@@ -357,7 +360,7 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
         const participant_jid = is_group && m.key.participant
           ? normalizeUserJid(m.key.participant)
           : null;
-        const chat_name = this.chats.get(remote_jid)?.name ?? m.pushName ?? null;
+        const chat_name = this.chats.get(remote_jid)?.name ?? chatPushName;
         const sender = resolveWhatsAppSender({
           fromMe: m.key.fromMe === true,
           isGroup: is_group,
@@ -422,7 +425,7 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
         };
         const chatJid = pickContactChatJid(ct);
         if (!chatJid) continue;
-        const name = ct.name ?? ct.verifiedName ?? ct.notify ?? null;
+        const name = [ct.name, ct.verifiedName, ct.notify].find((n) => n?.trim()) ?? null;
         this.observeChat(chatJid, name, null);
       }
     });
@@ -457,7 +460,7 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
       for (const ct of list) {
         const chatJid = pickContactChatJid(ct);
         if (!chatJid) continue;
-        this.observeChat(chatJid, ct.name ?? ct.verifiedName ?? ct.notify ?? null, null);
+        this.observeChat(chatJid, [ct.name, ct.verifiedName, ct.notify].find((n) => n?.trim()) ?? null, null);
       }
     });
 
@@ -592,6 +595,10 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
     this.pushStatus({ status: "disconnected", qr_data_url: null, error: null });
   }
 
+  chatLink(remote_jid: string): string | null {
+    return whatsappChatLink(remote_jid);
+  }
+
   async sendText(remote_jid: string, text: string): Promise<void> {
     // Hard guard: refuse to send to any chat whose route is in silent_mode.
     // The dispatcher already short-circuits before calling sendText, but
@@ -912,8 +919,11 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
         });
         attachments.push(ref);
         const sizeKb = Math.max(1, Math.round(buf.length / 1024));
+        // Sender-supplied document names can carry newlines or brackets;
+        // describe the attachment by the store's sanitized name.
+        const shownName = oneLine(("filename" in ref && ref.filename) || filename);
         text = (text ? text + "\n" : "")
-          + `[Attached ${label}: ${filename} (${mime}, ${sizeKb} KB); retained as a Jarela file reference.]`;
+          + `[Attached ${label}: ${shownName} (${mime}, ${sizeKb} KB); retained as a Jarela file reference.]`;
       } catch (err) {
         const m = errorMessage(err);
         console.warn(`[bridge ${this.bridge_id}] failed to spill ${label} from ${remote_jid}: ${m}`);
@@ -975,8 +985,8 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
     if (inner.locationMessage) {
       const { degreesLatitude, degreesLongitude, name, address } = inner.locationMessage;
       const parts = [`lat=${degreesLatitude ?? "?"}`, `lng=${degreesLongitude ?? "?"}`];
-      if (name) parts.push(`name="${name}"`);
-      if (address) parts.push(`address="${address}"`);
+      if (name) parts.push(`name=${JSON.stringify(oneLine(name))}`);
+      if (address) parts.push(`address=${JSON.stringify(oneLine(address))}`);
       text = (text ? text + "\n" : "") + `[location: ${parts.join(" ")}]`;
     }
 
@@ -986,14 +996,14 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
     }
 
     if (inner.contactMessage) {
-      const name = inner.contactMessage.displayName ?? "unknown";
-      const vcard = inner.contactMessage.vcard ?? "";
+      const name = oneLine(inner.contactMessage.displayName ?? "") || "unknown";
+      const vcard = stripVcardBinary(inner.contactMessage.vcard ?? "");
       text = (text ? text + "\n" : "") + `[contact: ${name}]\n${vcard}`;
     }
 
     if (inner.contactsArrayMessage) {
       const names = (inner.contactsArrayMessage.contacts ?? [])
-        .map((c) => c?.displayName ?? "unknown")
+        .map((c) => oneLine(c?.displayName ?? "") || "unknown")
         .join(", ");
       text = (text ? text + "\n" : "") + `[contacts: ${names}]`;
     }
@@ -1005,8 +1015,9 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
     if (!remote_jid) return;
     const existing = this.chats.get(remote_jid);
     // Prefer the most recently-observed name (group subjects rename; users
-    // change push names). Don't overwrite a known name with null.
-    const nextName = name ?? existing?.name ?? null;
+    // change push names). Don't overwrite a known name with a missing or
+    // blank one.
+    const nextName = name?.trim() || existing?.name || null;
     const nextTs = ts && (!existing?.last_message_at || ts > existing.last_message_at)
       ? ts
       : existing?.last_message_at ?? null;
@@ -1026,6 +1037,30 @@ export class WhatsAppBridgeAdapter implements BridgeAdapter {
   get status(): StatusUpdate["status"] { return this.currentStatus; }
 }
 
+export function oneLine(value: string): string {
+  return value.replace(/[\s\u0085\u2028\u2029]+/g, " ").trim();
+}
+
+/**
+ * Phones embed contact photos and logos as base64 vCard properties, often
+ * tens of KB of noise in the agent's context. Drop those properties,
+ * including their folded continuation lines (RFC 6350 §3.2), and keep the
+ * readable fields.
+ */
+export function stripVcardBinary(vcard: string): string {
+  const out: string[] = [];
+  let skipping = false;
+  for (const line of vcard.split(/\r\n|\r|\n/)) {
+    if (/^[ \t]/.test(line)) {
+      if (!skipping) out.push(line);
+      continue;
+    }
+    skipping = /^(?:[\w-]+\.)?(?:PHOTO|LOGO|SOUND|KEY)[;:]/i.test(line);
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n").trim();
+}
+
 // Minimal pino-compatible silent logger. Baileys uses `logger.child()`
 // chaining internally, so we return ourselves for every child call.
 function makeSilentLogger(): unknown {
@@ -1070,7 +1105,7 @@ const MEDIA_TYPE_ALLOWLIST: Record<"image" | "audio" | "video" | "document", Rea
   ]),
 };
 
-function sanitizeMediaType(
+export function sanitizeMediaType(
   raw: string | undefined,
   kind: "image" | "audio" | "video" | "document",
   fallback: string,
@@ -1088,7 +1123,7 @@ function sanitizeMediaType(
  * in several envelope variants (view-once, ephemeral, V2 versions); see
  * `unwrapMessage` for how we collapse them.
  */
-type WAMessageContent = {
+export type WAMessageContent = {
   conversation?: string;
   extendedTextMessage?: { text?: string };
   stickerMessage?: { mimetype?: string; isAnimated?: boolean };
@@ -1113,7 +1148,7 @@ type WAMessageContent = {
  * payload. Bounded recursion — these envelopes never nest deeper than 2
  * levels in practice, but we cap at 5 as defence in depth.
  */
-function unwrapMessage(msg: WAMessageContent | undefined, depth = 0): WAMessageContent | undefined {
+export function unwrapMessage(msg: WAMessageContent | undefined, depth = 0): WAMessageContent | undefined {
   if (!msg || depth > 5) return msg;
   if (msg.ephemeralMessage?.message) return unwrapMessage(msg.ephemeralMessage.message, depth + 1);
   if (msg.viewOnceMessage?.message) return unwrapMessage(msg.viewOnceMessage.message, depth + 1);
@@ -1128,7 +1163,7 @@ function unwrapMessage(msg: WAMessageContent | undefined, depth = 0): WAMessageC
  * country-code + number with no separators, no leading '+'. Accepts the
  * common human formats: "+1 (555) 123-4567", "5511 99999-0000", etc.
  */
-function normalizePhoneDigits(input: string): string {
+export function normalizePhoneDigits(input: string): string {
   return input.replace(/\D+/g, "");
 }
 
@@ -1142,7 +1177,7 @@ function normalizePhoneDigits(input: string): string {
  * the `@s.whatsapp.net` form — without this normalization, every inbound
  * `@lid` message would silently fail to match its route.
  */
-function pickRoutableJid(primary: string, alt: string | undefined): string {
+export function pickRoutableJid(primary: string, alt: string | undefined): string {
   const isRoutable = (j: string | undefined) =>
     !!j && (j.endsWith("@s.whatsapp.net") || j.endsWith("@g.us"));
   if (isRoutable(primary)) return primary;
@@ -1160,6 +1195,9 @@ export function resolveWhatsAppSender(input: {
   chatName: string | null;
   participantName: string | null;
 }): { senderJid: string; senderName: string } {
+  // Platforms send blank display names ("" or whitespace) for contacts that
+  // never set one; treat those as missing so the fallbacks still apply.
+  const named = (...names: Array<string | null>) => names.find((n) => !!n && n.trim().length > 0)?.trim();
   if (input.fromMe) {
     return {
       senderJid: input.selfJid ?? "me",
@@ -1170,12 +1208,12 @@ export function resolveWhatsAppSender(input: {
     const senderJid = input.participantJid ?? input.remoteJid;
     return {
       senderJid,
-      senderName: input.participantName ?? input.pushName ?? senderJid,
+      senderName: named(input.participantName, input.pushName) ?? senderJid,
     };
   }
   return {
     senderJid: input.remoteJid,
-    senderName: input.pushName ?? input.chatName ?? input.remoteJid,
+    senderName: named(input.pushName, input.chatName) ?? input.remoteJid,
   };
 }
 
@@ -1198,7 +1236,7 @@ export function resolveWhatsAppSender(input: {
  * Returns null for JIDs that aren't routable chats (self broadcast,
  * status@broadcast, malformed ids, empty input).
  */
-function pickContactChatJid(ct: {
+export function pickContactChatJid(ct: {
   id?: string;
   phoneNumber?: string;
   lid?: string;
@@ -1220,7 +1258,7 @@ function pickContactChatJid(ct: {
  * routable user JID — `sendMessage` won't deliver to a JID with `:NN`.
  * Returns null if the input is malformed.
  */
-function normalizeUserJid(id: unknown): string | null {
+export function normalizeUserJid(id: unknown): string | null {
   if (typeof id !== "string") return null;
   // Strip any device suffix (":NN") before the '@'.
   const at = id.indexOf("@");
@@ -1234,7 +1272,7 @@ function normalizeUserJid(id: unknown): string | null {
   return `${user}@${normHost}`;
 }
 
-function humanList(items: string[], max: number): string {
+export function humanList(items: string[], max: number): string {
   const clean = items.filter((s) => s && s.trim().length > 0);
   if (clean.length === 0) return "(none)";
   if (clean.length <= max) return clean.join(", ");

package/lib/db/migrations.test.ts

@@ -18,6 +18,67 @@ afterAll(() => {
   try { rmSync(tmpRoot, { recursive: true, force: true }); } catch {}
 });
 
+describe("responsive transcript indexes (ADR-0103)", () => {
+  it("restores missing indexes on upgrade and remains idempotent", async () => {
+    const db = getDb();
+    const names = [
+      "idx_messages_thread_seq", "idx_messages_created_at",
+      "idx_threads_updated", "idx_message_usage_thread_created",
+      "idx_memory_namespace_updated", "idx_memory_updated",
+      "idx_runtime_operations_thread_state", "idx_signal_events_thread",
+      "idx_signal_events_operation", "idx_signal_deliveries_lease",
+      "idx_background_results_expiry", "idx_message_embedding_jobs_lease",
+    ];
+    for (const name of names) db.exec(`DROP INDEX IF EXISTS ${name}`);
+    const { runMigrations } = await import("./migrations");
+    runMigrations(db);
+    runMigrations(db);
+    const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index'").all()
+      .map((row) => row.name);
+    expect(indexes).toEqual(expect.arrayContaining(names));
+  });
+
+  it.each([
+    ["SELECT rowid, msg_id, content FROM messages WHERE thread_id=? ORDER BY rowid DESC LIMIT ?", ["thread", 51]],
+    ["SELECT rowid, msg_id, content FROM messages WHERE thread_id=? AND rowid<? ORDER BY rowid DESC LIMIT ?", ["thread", 100, 51]],
+    ["SELECT rowid, msg_id, content FROM messages WHERE thread_id=? AND rowid>? ORDER BY rowid ASC LIMIT ?", ["thread", 100, 50]],
+    ["SELECT content FROM messages WHERE created_at>=? ORDER BY created_at ASC", ["2026-10-01"]],
+    ["SELECT * FROM threads WHERE agent_id=? ORDER BY updated_at DESC LIMIT ?", ["agent", 50]],
+    ["SELECT * FROM threads ORDER BY updated_at DESC LIMIT ? OFFSET ?", [50, 0]],
+  ])("uses ordered indexes for %s", (query, params) => {
+    const plan = getDb().prepare(`EXPLAIN QUERY PLAN ${query}`).all(...params)
+      .map((row) => String(row.detail)).join("; ");
+    expect(plan).not.toMatch(/USE TEMP B-TREE|SCAN (?:messages|threads)(?! USING INDEX)/);
+    expect(plan).toMatch(/USING INDEX/);
+  });
+
+  it.each([
+    ["SELECT * FROM message_usage WHERE thread_id=? ORDER BY created_at DESC LIMIT 1", ["thread"], "idx_message_usage_thread_created"],
+    ["SELECT namespace,key,value FROM memory_store WHERE namespace=? ORDER BY updated_at DESC LIMIT ?", ["facts", 50], "idx_memory_namespace_updated"],
+    ["SELECT namespace,key,value FROM memory_store ORDER BY updated_at DESC LIMIT ?", [50], "idx_memory_updated"],
+    ["SELECT rowid FROM runtime_operations WHERE thread_id=? AND state='accepted'", ["thread"], "idx_runtime_operations_thread_state"],
+    ["SELECT rowid FROM signal_events WHERE thread_id=?", ["thread"], "idx_signal_events_thread"],
+    ["SELECT rowid FROM signal_events WHERE operation_id=?", ["operation"], "idx_signal_events_operation"],
+    ["SELECT key FROM background_tool_results WHERE expires_at<=?", [1000], "idx_background_results_expiry"],
+    ["SELECT event_id FROM signal_deliveries WHERE state='leased' AND lease_until<=?", [1000], "idx_signal_deliveries_lease"],
+    ["SELECT message_id FROM message_embedding_jobs WHERE state='processing' AND lease_until_ms<=?", [1000], "idx_message_embedding_jobs_lease"],
+  ])("indexes secondary lookup %s", (query, params, index) => {
+    const plan = getDb().prepare(`EXPLAIN QUERY PLAN ${query}`).all(...params)
+      .map((row) => String(row.detail)).join("; ");
+    expect(plan).not.toMatch(/USE TEMP B-TREE/);
+    expect(plan).toContain(index);
+    if (!query.includes("FROM memory_store ORDER BY")) expect(plan).toContain("SEARCH");
+  });
+
+  it("reuses the unique agent index instead of adding a redundant ordering index", () => {
+    const indexes = getDb().prepare("PRAGMA index_list(threads)").all();
+    expect(indexes).toEqual(expect.arrayContaining([
+      expect.objectContaining({ name: "idx_threads_agent_id", unique: 1 }),
+    ]));
+    expect(indexes.some((row) => row.name === "idx_threads_agent_updated")).toBe(false);
+  });
+});
+
 describe("warm summary limit migration", () => {
   it("adds the default limit to existing agents", async () => {
     const db = getDb();

package/lib/db/migrations.ts

@@ -35,6 +35,9 @@ export function runMigrations(db: DatabaseSync): void {
     -- (getMessages, getRecentMessagesWindow, getMessagesPage, clear).
     -- Without this every read full-scans the messages table.
     CREATE INDEX IF NOT EXISTS idx_messages_thread_id ON messages(thread_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_messages_thread_seq ON messages(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at);
+    CREATE INDEX IF NOT EXISTS idx_threads_updated ON threads(updated_at DESC);
     CREATE TABLE IF NOT EXISTS runtime_operations (
       id TEXT PRIMARY KEY,
       kind TEXT NOT NULL,
@@ -58,6 +61,9 @@ export function runMigrations(db: DatabaseSync): void {
       created_at INTEGER NOT NULL,
       UNIQUE(kind,operation_id,agent_id,thread_id)
     );
+    CREATE INDEX IF NOT EXISTS idx_runtime_operations_thread_state ON runtime_operations(thread_id,state);
+    CREATE INDEX IF NOT EXISTS idx_signal_events_thread ON signal_events(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_signal_events_operation ON signal_events(operation_id);
     CREATE TABLE IF NOT EXISTS signal_deliveries (
       event_id TEXT PRIMARY KEY REFERENCES signal_events(id) ON DELETE CASCADE,
       wake_eligible INTEGER NOT NULL DEFAULT 0,
@@ -72,6 +78,7 @@ export function runMigrations(db: DatabaseSync): void {
     );
     CREATE INDEX IF NOT EXISTS idx_signal_events_target ON signal_events(agent_id,thread_id,seq);
     CREATE INDEX IF NOT EXISTS idx_signal_deliveries_due ON signal_deliveries(state,available_at);
+    CREATE INDEX IF NOT EXISTS idx_signal_deliveries_lease ON signal_deliveries(state,lease_until);
     CREATE TABLE IF NOT EXISTS background_tool_results (
       key TEXT PRIMARY KEY REFERENCES runtime_operations(id) ON DELETE CASCADE,
       thread_id TEXT NOT NULL REFERENCES threads(thread_id) ON DELETE CASCADE,
@@ -83,6 +90,7 @@ export function runMigrations(db: DatabaseSync): void {
       expires_at INTEGER NOT NULL
     );
     CREATE INDEX IF NOT EXISTS idx_background_results_owner ON background_tool_results(thread_id,expires_at);
+    CREATE INDEX IF NOT EXISTS idx_background_results_expiry ON background_tool_results(expires_at);
     CREATE TABLE IF NOT EXISTS memory_store (
       namespace  TEXT NOT NULL,
       key        TEXT NOT NULL,
@@ -91,6 +99,8 @@ export function runMigrations(db: DatabaseSync): void {
       updated_at TEXT NOT NULL,
       PRIMARY KEY (namespace, key)
     );
+    CREATE INDEX IF NOT EXISTS idx_memory_namespace_updated ON memory_store(namespace,updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_memory_updated ON memory_store(updated_at DESC);
     CREATE TABLE IF NOT EXISTS model_configs (
       name       TEXT PRIMARY KEY,
       provider   TEXT NOT NULL,
@@ -660,6 +670,7 @@ function ensureMessageUsageTable(db: DatabaseSync): void {
     );
     CREATE INDEX IF NOT EXISTS idx_message_usage_created_at ON message_usage(created_at);
     CREATE INDEX IF NOT EXISTS idx_message_usage_agent_id   ON message_usage(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_message_usage_thread_created ON message_usage(thread_id,created_at DESC);
   `);
 }
 
@@ -703,6 +714,8 @@ function ensureMessageEmbeddingJobsTable(db: DatabaseSync): void {
     );
     CREATE INDEX IF NOT EXISTS idx_message_embedding_jobs_due
       ON message_embedding_jobs(state, available_at_ms, lease_until_ms);
+    CREATE INDEX IF NOT EXISTS idx_message_embedding_jobs_lease
+      ON message_embedding_jobs(state, lease_until_ms);
     INSERT OR IGNORE INTO message_embedding_jobs (message_id, created_at, updated_at)
       SELECT msg_id, created_at, created_at FROM messages WHERE embedding IS NULL;
   `);

package/lib/embeddings/performance.test.ts

@@ -0,0 +1,114 @@
+import { DatabaseSync } from "node:sqlite";
+import { performance } from "node:perf_hooks";
+import { afterAll, expect, it, vi } from "vitest";
+import { LOCAL_EMBEDDING_MODEL_ID } from "./constants";
+
+// Opt-in, local-only benchmark. No user database, credentials, or downloads.
+const state = vi.hoisted(() => ({ db: null as DatabaseSync | null }));
+vi.mock("@/lib/db", () => ({
+  getDb: () => {
+    if (!state.db) throw new Error("benchmark database not initialized");
+    return state.db;
+  },
+}));
+vi.mock("@/lib/providers", () => ({
+  getProvider: () => { throw new Error("remote providers are forbidden in this benchmark"); },
+}));
+vi.mock("@/lib/stores/model-config", () => ({
+  getModelConfig: () => null,
+  getDefaultModelConfig: () => null,
+  getModelParams: () => ({}),
+  listModelConfigs: () => [],
+}));
+
+const previousDownload = process.env.JARELA_LOCAL_EMBEDDING_DOWNLOAD;
+afterAll(() => {
+  state.db?.close();
+  if (previousDownload === undefined) delete process.env.JARELA_LOCAL_EMBEDDING_DOWNLOAD;
+  else process.env.JARELA_LOCAL_EMBEDDING_DOWNLOAD = previousDownload;
+});
+
+it.skipIf(process.env.JARELA_BENCHMARK_EMBEDDINGS !== "1")(
+  "reports local embedding and synthetic memory-search latency",
+  async () => {
+    process.env.JARELA_LOCAL_EMBEDDING_DOWNLOAD = "0";
+    const { getLocalModelStatus } = await import("./local-model");
+    expect(getLocalModelStatus().state, "Install the local model before running this offline benchmark").toBe("ready");
+    const { runMigrations } = await import("@/lib/db/migrations");
+    state.db = new DatabaseSync(":memory:");
+    runMigrations(state.db);
+    const { setLocalEmbeddingsEnabled, setEmbeddingVectorsSignature } = await import("@/lib/stores/app-settings");
+    setLocalEmbeddingsEnabled(true);
+    setEmbeddingVectorsSignature(LOCAL_EMBEDDING_MODEL_ID);
+    const { embedLocally } = await import("./local");
+    const { embedQueryOne, searchMemory, _resetEmbeddingCache, _resetEmbedCaches, reembedStaleVectors } = await import("./index");
+    const results: Array<{ operation: string; samples: number; median_ms: number; p95_ms: number }> = [];
+    async function time(operation: string, count: number, run: (index: number) => Promise<void>) {
+      const elapsed: number[] = [];
+      for (let i = 0; i < count; i++) {
+        const start = performance.now();
+        await run(i);
+        elapsed.push(performance.now() - start);
+      }
+      elapsed.sort((a, b) => a - b);
+      results.push({
+        operation, samples: count,
+        median_ms: Number(elapsed[Math.floor(elapsed.length / 2)].toFixed(3)),
+        p95_ms: Number(elapsed[Math.ceil(elapsed.length * 0.95) - 1].toFixed(3)),
+      });
+    }
+    const query = "What is the deployment rollback procedure?";
+    const validate = (vector: number[] | null) => {
+      expect(vector).toHaveLength(384);
+      expect(vector?.every(Number.isFinite)).toBe(true);
+    };
+    await time("cold pipeline + first query inference", 1, async () => {
+      validate((await embedLocally([query], "query"))[0]);
+    });
+    await time("warm pipeline, uncached short query", 10, async (i) => {
+      validate((await embedLocally([`${query} revision ${i}`], "query"))[0]);
+    });
+    await time("warm pipeline, 16 short passages", 3, async () => {
+      const vectors = await embedLocally(Array.from({ length: 16 }, (_, i) => `Deployment step ${i}: preserve backups and verify health.`), "passage");
+      expect(vectors).toHaveLength(16);
+      vectors.forEach(validate);
+    });
+    await embedQueryOne(query);
+    await time("query embedding content-cache hit", 20, async () => { validate(await embedQueryOne(query)); });
+    const vector = await embedQueryOne(query);
+    const encoded = JSON.stringify(vector);
+    const db = state.db;
+    db.prepare("INSERT INTO threads(thread_id,agent_id,created_at,updated_at) VALUES ('bench','bench',?,?)")
+      .run("2026-01-01", "2026-01-01");
+    const memory = db.prepare("INSERT INTO memory_store(namespace,key,value,created_at,updated_at,embedding) VALUES ('benchmark',?,?,?,?,?)");
+    const message = db.prepare("INSERT INTO messages(msg_id,thread_id,role,content,created_at,embedding) VALUES (?,'bench','assistant',?,?,?)");
+    const job = db.prepare("INSERT INTO message_embedding_jobs(message_id,source_hash,state,created_at,updated_at,model_signature) VALUES (?,?,'done','2026-01-01','2026-01-01',?)");
+    for (const rows of [1_000, 10_000]) {
+      db.exec("DELETE FROM memory_store WHERE namespace='benchmark'; DELETE FROM message_embedding_jobs; DELETE FROM messages; BEGIN");
+      for (let i = 0; i < rows / 2; i++) {
+        const content = `Synthetic deployment rollback procedure ${i}: restore backup, verify health, then resume traffic.`;
+        memory.run(`key-${i}`, content, "2026-01-01", "2026-01-01", encoded);
+        message.run(`msg-${i}`, content, "2026-01-01", encoded);
+        job.run(`msg-${i}`, "synthetic", LOCAL_EMBEDDING_MODEL_ID);
+      }
+      db.exec("COMMIT");
+      _resetEmbedCaches();
+      await time(`${rows} vectors: first search, cold row cache`, 1, async () => {
+        const hits = await searchMemory(query, { literal: true, limit: 10 });
+        expect(hits).toHaveLength(10);
+      });
+      await reembedStaleVectors(384);
+      await time(`${rows} vectors: warm rows + cached query`, 10, async () => {
+        expect(await searchMemory(query, { literal: true, limit: 10 })).toHaveLength(10);
+      });
+      await time(`${rows} vectors: warm rows + new query inference`, 5, async (i) => {
+        _resetEmbeddingCache();
+        expect(await searchMemory(`${query} check ${i}`, { literal: true, limit: 10 })).toHaveLength(10);
+      });
+      await reembedStaleVectors(384);
+    }
+    console.table(results);
+    console.log("Synthetic repeated 384-dimensional vectors; measures scan/sort cost, not retrieval quality. No HTTP transport or provider network latency.");
+  },
+  120_000,
+);

package/lib/pricing/snapshot.test.ts

@@ -324,3 +324,73 @@ describe("pricing snapshot refresh", () => {
     expect(modelRate?.output_per_1m_usd).toBe(0.28);
   });
 });
+
+describe("pricing snapshot edge cases", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    readFileMock.mockReset();
+    mkdirMock.mockReset();
+    writeFileMock.mockReset();
+    vi.unstubAllGlobals();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("refreshes a snapshot stamped in the future instead of trusting it forever", async () => {
+    readFileMock.mockResolvedValueOnce(JSON.stringify({
+      generated_at: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(),
+      disclaimer: "skewed",
+      ttl_days: 3,
+      sources: [],
+    }));
+    vi.stubGlobal("fetch", vi.fn(async () => new Response("input $1 / 1M tokens output $2 / 1M tokens", { status: 200 })));
+
+    const { refreshPricingSnapshot } = await import("./snapshot");
+    const res = await refreshPricingSnapshot({ providers: ["cohere"] });
+
+    expect(res).toMatchObject({ refreshed: true, reason: "stale" });
+  });
+
+  it("treats a corrupt snapshot file as missing", async () => {
+    readFileMock.mockResolvedValueOnce("{not json");
+    vi.stubGlobal("fetch", vi.fn(async () => new Response("input $1 / 1M tokens output $2 / 1M tokens", { status: 200 })));
+
+    const { refreshPricingSnapshot } = await import("./snapshot");
+    const res = await refreshPricingSnapshot({ providers: ["cohere"] });
+
+    expect(res).toMatchObject({ refreshed: true, reason: "missing" });
+  });
+
+  it("parses each source's search results independently and skips Google's own links", async () => {
+    readFileMock.mockRejectedValueOnce(new Error("ENOENT"));
+    const link = (u: string) => `<a href="/url?q=${encodeURIComponent(u)}&amp;sa=U">x</a>`;
+    const anthropicSearch = "<html>" + "x".repeat(4000)
+      + link("https://www.google.com/intl/en/policies/")
+      + Array.from({ length: 9 }, (_, i) => link(`https://a${i}.example.com/pricing`)).join("")
+      + "</html>";
+    const cohereSearch = `<html>${link("https://c.example.com/pricing")}</html>`;
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.startsWith("https://www.google.com/search")) {
+        if (url.includes("Anthropic")) return new Response(anthropicSearch, { status: 200 });
+        // Only Cohere's first query has results, so a leaked regex cursor cannot be masked by a retry.
+        return new Response(url.includes("1M") ? cohereSearch : "<html></html>", { status: 200 });
+      }
+      if (/^https:\/\/(a0|c)\.example\.com\//.test(url)) {
+        return new Response("input $3 / 1M tokens output $15 / 1M tokens", { status: 200 });
+      }
+      return new Response("not found", { status: 404 });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { refreshPricingSnapshot } = await import("./snapshot");
+    const res = await refreshPricingSnapshot({ force: true, providers: ["anthropic", "cohere"] });
+    const byId = new Map(res.snapshot.sources.map((s) => [s.id, s]));
+
+    expect(byId.get("anthropic")).toMatchObject({ ok: true, resolved_url: "https://a0.example.com/pricing" });
+    expect(byId.get("cohere")).toMatchObject({ ok: true, resolved_url: "https://c.example.com/pricing" });
+    expect(fetchMock.mock.calls.map(([u]) => String(u))).not.toContain("https://www.google.com/intl/en/policies/");
+  });
+});

package/lib/pricing/snapshot.ts

@@ -85,6 +85,7 @@ const PRICE_LINE_RE = new RegExp(
 );
 
 const GOOGLE_RESULT_RE = /href="\/url\?q=([^"&]+)[^"]*"/gi;
+const GOOGLE_OWN_HOST_RE = /^(?:www|accounts|support|maps|policies|webcache)?\.?google\.[a-z.]+$/i;
 
 type FetchAttempt = {
   url: string;
@@ -168,7 +169,8 @@ export async function refreshPricingSnapshot(opts?: { force?: boolean; ttlDays?:
   const existing = await readPricingSnapshot();
   if (!force && existing) {
     const ageDays = (Date.now() - Date.parse(existing.generated_at)) / (24 * 60 * 60 * 1000);
-    if (Number.isFinite(ageDays) && ageDays < ttlDays) {
+    // A future generated_at (clock skew, copied snapshot) must not pin the cache as fresh.
+    if (Number.isFinite(ageDays) && ageDays >= 0 && ageDays < ttlDays) {
       return { refreshed: false, reason: "fresh", snapshot: existing };
     }
   }
@@ -332,6 +334,8 @@ function parseGoogleResultLinks(html: string): string[] {
   const seen = new Set<string>();
 
   let m: RegExpExecArray | null;
+  // Shared /g regex: an early break leaves lastIndex mid-string for the next page.
+  GOOGLE_RESULT_RE.lastIndex = 0;
   while ((m = GOOGLE_RESULT_RE.exec(html)) !== null) {
     const raw = m[1] ?? "";
     let url = "";
@@ -341,7 +345,11 @@ function parseGoogleResultLinks(html: string): string[] {
       continue;
     }
     if (!/^https?:\/\//i.test(url)) continue;
-    if (/\/google\./i.test(url)) continue;
+    try {
+      if (GOOGLE_OWN_HOST_RE.test(new URL(url).hostname)) continue;
+    } catch {
+      continue;
+    }
     if (seen.has(url)) continue;
     seen.add(url);
     out.push(url);