@circuitwall/jarela 2.3.0 → 2.5.0

package/lib/proxy/dispatcher.test.ts

@@ -31,7 +31,7 @@ vi.mock("node:child_process", async () => {
 
 import { exec } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { getProxyConfigRaw } from "@/lib/stores/proxy-config";
+import { getProxyConfigRaw, type ProxyConfigRaw } from "@/lib/stores/proxy-config";
 import { extractSystemKeychainCAs } from "@/lib/proxy/keychain";
 
 const mockedGetProxyConfigRaw = vi.mocked(getProxyConfigRaw);
@@ -262,3 +262,121 @@ describe("applyProxyConfigFromDb — env override", () => {
     expect(mockedExtract).not.toHaveBeenCalled();
   });
 });
+
+describe("applyProxyConfigFromDb — manual mode", () => {
+  const originalEnv = { ...process.env };
+
+  function manual(overrides: Partial<ProxyConfigRaw> = {}): ProxyConfigRaw {
+    return {
+      mode: "manual",
+      scheme: "http",
+      host: "proxy.corp",
+      port: 3128,
+      username: null,
+      password: null,
+      no_proxy: null,
+      ca_bundle: null,
+      updated_at: "2026-05-22T00:00:00.000Z",
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    for (const key of ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "NO_PROXY", "no_proxy"]) delete process.env[key];
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(null);
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    await applyProxyConfigFromDb();
+    process.env = { ...originalEnv };
+  });
+
+  it("percent-encodes credentials in the proxy URL and redacts the password in the result", async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(manual({ username: "dom\\user", password: "p@ss:w/rd" }));
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    const r = await applyProxyConfigFromDb();
+    expect(r.source).toBe("manual");
+    expect(process.env.HTTPS_PROXY).toBe("http://dom%5Cuser:p%40ss%3Aw%2Frd@proxy.corp:3128");
+    expect(r.proxyUrl).toBe("http://dom%5Cuser:***@proxy.corp:3128/");
+    expect(r.proxyUrl).not.toContain("p%40ss");
+  });
+
+  it("brackets an IPv6 proxy host so the URL is parseable", async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(manual({ host: "fd00::1" }));
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    const r = await applyProxyConfigFromDb();
+    expect(process.env.HTTPS_PROXY).toBe("http://[fd00::1]:3128");
+    expect(r.proxyUrl).toBe("http://[fd00::1]:3128/");
+  });
+
+  it("always bypasses loopback, merged with the user's no_proxy list", async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(manual({ no_proxy: " corp.internal, .svc " }));
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    await applyProxyConfigFromDb();
+    const entries = (process.env.NO_PROXY ?? "").split(",");
+    expect(entries).toEqual(expect.arrayContaining(["corp.internal", ".svc", "localhost", "127.0.0.1", "::1"]));
+    expect(new Set(entries).size).toBe(entries.length);
+  });
+
+  it("still reaches a local server (e.g. Ollama) directly when the proxy is unreachable", async () => {
+    const { createServer } = await import("node:http");
+    const server = createServer((_req, res) => res.end("local-ok"));
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const { port } = server.address() as { port: number };
+    try {
+      // Port 9 (discard) on loopback refuses connections, so any request
+      // routed through this "proxy" fails.
+      mockedGetProxyConfigRaw.mockReturnValue(manual({ host: "127.0.0.1", port: 9 }));
+      const { applyProxyConfigFromDb } = await import("./dispatcher");
+      await applyProxyConfigFromDb();
+      for (const host of ["127.0.0.1", "localhost"]) {
+        const res = await fetch(`http://${host}:${port}/`);
+        expect(await res.text()).toBe("local-ok");
+      }
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
+  it("keeps loopback direct even when a lowercase no_proxy is inherited", async () => {
+    // undici reads lowercase no_proxy before NO_PROXY.
+    process.env.no_proxy = "corp.internal";
+    const { createServer } = await import("node:http");
+    const server = createServer((_req, res) => res.end("local-ok"));
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const { port } = server.address() as { port: number };
+    try {
+      mockedGetProxyConfigRaw.mockReturnValue(manual({ host: "127.0.0.1", port: 9 }));
+      const { applyProxyConfigFromDb } = await import("./dispatcher");
+      await applyProxyConfigFromDb();
+      const res = await fetch(`http://127.0.0.1:${port}/`);
+      expect(await res.text()).toBe("local-ok");
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
+  it("reverts to no proxy when host or port is missing", async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(manual({ port: null }));
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    const r = await applyProxyConfigFromDb();
+    expect(r.source).toBe("off");
+    expect(r.note).toMatch(/missing host\/port/);
+    expect(process.env.HTTPS_PROXY).toBeUndefined();
+  });
+
+  it("clears the proxy env when switched back to off", async () => {
+    mockedGetProxyConfigRaw.mockReturnValue(manual());
+    const { applyProxyConfigFromDb } = await import("./dispatcher");
+    await applyProxyConfigFromDb();
+    expect(process.env.HTTPS_PROXY).toBeDefined();
+    mockedGetProxyConfigRaw.mockReturnValue({ ...manual(), mode: "off" });
+    const r = await applyProxyConfigFromDb();
+    expect(r.source).toBe("off");
+    expect(process.env.HTTPS_PROXY).toBeUndefined();
+    expect(process.env.NO_PROXY).toBeUndefined();
+  });
+});

package/lib/proxy/dispatcher.ts

@@ -215,7 +215,18 @@ function buildProxyUrl(
   const auth = username
     ? `${encodeURIComponent(username)}${password ? `:${encodeURIComponent(password)}` : ""}@`
     : "";
-  return `${scheme}://${auth}${host}:${port}`;
+  const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `${scheme}://${auth}${urlHost}:${port}`;
+}
+
+// undici's EnvHttpProxyAgent has no implicit loopback exemption, so without
+// these a configured proxy would also receive local traffic (Ollama, the
+// WhatsApp bridge sidecar, the app's own loopback API).
+const LOOPBACK_NO_PROXY = ["localhost", "127.0.0.1", "::1"];
+
+function mergeNoProxy(noProxy: string | null): string {
+  const entries = (noProxy ?? "").split(/[,\s]+/).map((entry) => entry.trim()).filter(Boolean);
+  return [...new Set([...entries, ...LOOPBACK_NO_PROXY])].join(",");
 }
 
 function installProxy(url: string, noProxy: string | null, caBundle: string | null): void {
@@ -224,22 +235,24 @@ function installProxy(url: string, noProxy: string | null, caBundle: string | nu
   // We still treat the boot-time env snapshot as authoritative for the
   // "env beats DB" rule — this mutation only happens after we've
   // confirmed the user did NOT set HTTP_PROXY at launch.
+  const merged = mergeNoProxy(noProxy);
   process.env.HTTP_PROXY = url;
   process.env.HTTPS_PROXY = url;
-  if (noProxy && noProxy.trim().length > 0) {
-    process.env.NO_PROXY = noProxy.trim();
-  } else {
-    delete process.env.NO_PROXY;
-  }
+  process.env.NO_PROXY = merged;
   // ADR-0012: when the user pasted a corporate root CA, inject it on
   // both TLS legs — the proxy hop (proxyTls) for https-scheme proxies
   // signed by the corporate root, and the upstream tunnel (requestTls)
   // for proxies that MITM outbound HTTPS with the same internal CA.
   // Same blob is correct: the corporate trust chain typically signs
   // both ends.
-  const opts = caBundle
-    ? { requestTls: { ca: caBundle }, proxyTls: { ca: caBundle } }
-    : {};
+  // Pass the values explicitly too: undici prefers lowercase http_proxy /
+  // no_proxy from the environment over the uppercase ones set above.
+  const opts = {
+    httpProxy: url,
+    httpsProxy: url,
+    noProxy: merged,
+    ...(caBundle ? { requestTls: { ca: caBundle }, proxyTls: { ca: caBundle } } : {}),
+  };
   setGlobalDispatcher(new EnvHttpProxyAgent(opts));
 }
 

package/lib/stores/agent-configs.ts

@@ -253,12 +253,17 @@ function upsertAgentConfigTransaction(input: UpsertAgentInput): AgentConfigRow {
   const db = getDb();
   const existing = getAgentConfig(input.id);
   const created_at = existing?.created_at ?? t;
-  const mbti = input.adaptive_mbti ?? toMbti(existing?.adaptive_mbti) ?? "INTJ";
+  const existingMbti = toMbti(existing?.adaptive_mbti);
+  const mbti = input.adaptive_mbti ?? existingMbti ?? "INTJ";
   const preset = MBTI_PRESETS[mbti];
-  const strength = input.adaptive_persona_strength ?? preset.strength;
-  const empathy = input.adaptive_empathy ?? preset.empathy;
-  const expressiveness = input.adaptive_expressiveness ?? preset.expressiveness;
-  const verbosity = input.adaptive_verbosity ?? preset.verbosity;
+  // Omitted sliders keep their tuned values; they only fall back to the
+  // preset when the type changes or the agent is new. Otherwise every
+  // partial update (approved proposals, tool edits) reset them.
+  const keepTuned = existing !== null && existing !== undefined && mbti === existingMbti;
+  const strength = input.adaptive_persona_strength ?? (keepTuned ? existing.adaptive_persona_strength : preset.strength);
+  const empathy = input.adaptive_empathy ?? (keepTuned ? existing.adaptive_empathy : preset.empathy);
+  const expressiveness = input.adaptive_expressiveness ?? (keepTuned ? existing.adaptive_expressiveness : preset.expressiveness);
+  const verbosity = input.adaptive_verbosity ?? (keepTuned ? existing.adaptive_verbosity : preset.verbosity);
   if (input.is_default) db.prepare("UPDATE agent_configs SET is_default=0").run();
   // harness_id: explicit `undefined` means "keep existing"; explicit `null`
   // means "use the global default". Empty string is normalised to null too,

package/lib/stores/bridges.test.ts

@@ -0,0 +1,81 @@
+import { afterAll, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-bridges-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+
+const store = await import("./bridges");
+const { getDb } = await import("@/lib/db");
+
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* */ }
+});
+
+describe("bridges store", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.exec("DELETE FROM bridge_routes; DELETE FROM bridge_ignores; DELETE FROM bridges;");
+  });
+
+  it("keeps each chat's watermark monotonic and isolated from other chats", () => {
+    const b = store.createBridge({ kind: "whatsapp", name: "WA" });
+    store.createRoute({ bridge_id: b.id, remote_jid: "a@s.whatsapp.net", agent_id: "agent-1" });
+    store.createRoute({ bridge_id: b.id, remote_jid: "b@s.whatsapp.net", agent_id: "agent-2" });
+
+    store.bumpRouteLastSeenTs(b.id, "a@s.whatsapp.net", 2_000);
+    store.bumpRouteLastSeenTs(b.id, "a@s.whatsapp.net", 1_000);
+    store.bumpRouteLastSeenTs(b.id, "a@s.whatsapp.net", Number.NaN);
+    store.bumpRouteLastSeenTs(b.id, "a@s.whatsapp.net", -5);
+    store.bumpRouteLastSeenTs(b.id, "unrouted@s.whatsapp.net", 9_000);
+
+    expect(store.getRouteLastSeenTsMap(b.id)).toEqual(new Map([["a@s.whatsapp.net", 2_000]]));
+  });
+
+  it("scopes watermarks to their bridge", () => {
+    const one = store.createBridge({ kind: "whatsapp", name: "one" });
+    const two = store.createBridge({ kind: "whatsapp", name: "two" });
+    store.createRoute({ bridge_id: one.id, remote_jid: "x@s.whatsapp.net", agent_id: "agent-3" });
+    store.createRoute({ bridge_id: two.id, remote_jid: "x@s.whatsapp.net", agent_id: "agent-4" });
+    store.bumpRouteLastSeenTs(one.id, "x@s.whatsapp.net", 5_000);
+    expect(store.getRouteLastSeenTsMap(two.id).size).toBe(0);
+  });
+
+  it("deletes a bridge together with its routes and ignores", () => {
+    const b = store.createBridge({ kind: "whatsapp", name: "WA" });
+    const route = store.createRoute({ bridge_id: b.id, remote_jid: "*", agent_id: "agent-5" });
+    store.addIgnore({ bridge_id: b.id, remote_jid: "spam@s.whatsapp.net" });
+
+    expect(store.deleteBridge(b.id)).toBe(true);
+    expect(store.getRoute(route.id)).toBeNull();
+    expect(store.isIgnored(b.id, "spam@s.whatsapp.net")).toBe(false);
+    expect(store.deleteBridge(b.id)).toBe(false);
+  });
+
+  it("rejects a duplicate ignore entry and removes only the matching chat", () => {
+    const b = store.createBridge({ kind: "whatsapp", name: "WA" });
+    store.addIgnore({ bridge_id: b.id, remote_jid: "a@s.whatsapp.net", label: "A" });
+    store.addIgnore({ bridge_id: b.id, remote_jid: "b@s.whatsapp.net" });
+    expect(() => store.addIgnore({ bridge_id: b.id, remote_jid: "a@s.whatsapp.net" })).toThrow(/UNIQUE/);
+
+    expect(store.removeIgnore(b.id, "a@s.whatsapp.net")).toBe(true);
+    expect(store.removeIgnore(b.id, "a@s.whatsapp.net")).toBe(false);
+    expect(store.listIgnores(b.id).map((i) => i.remote_jid)).toEqual(["b@s.whatsapp.net"]);
+  });
+
+  it("applies partial updates without clobbering nullable fields", () => {
+    const b = store.createBridge({ kind: "whatsapp", name: "WA" });
+    store.updateBridge(b.id, { last_error: "boom", paired_id: "me" });
+    const updated = store.updateBridge(b.id, { status: "connected", forward_group_profile_updates: 0 });
+    expect(updated).toMatchObject({ last_error: "boom", paired_id: "me", status: "connected", forward_group_profile_updates: 0 });
+    expect(store.updateBridge(b.id, { last_error: null })?.last_error).toBeNull();
+    expect(store.getBridge(b.id)).toMatchObject({ last_error: null, paired_id: "me", forward_group_participants_updates: 1 });
+    expect(store.updateBridge("missing", { name: "x" })).toBeNull();
+
+    const route = store.createRoute({ bridge_id: b.id, remote_jid: "a@s.whatsapp.net", agent_id: "agent-6", label: "A", silent_mode: true });
+    expect(store.updateRoute(route.id, { respond_to: "user" })).toMatchObject({ label: "A", silent_mode: 1, respond_to: "user" });
+    expect(store.updateRoute(route.id, { silent_mode: false, label: null })).toMatchObject({ label: null, silent_mode: 0 });
+    expect(store.findRoute(b.id, "a@s.whatsapp.net")).toMatchObject({ silent_mode: 0, respond_to: "user", label: null });
+  });
+});

package/lib/stores/bridges.ts

@@ -263,14 +263,15 @@ export function bumpRouteLastSeenTs(bridgeId: string, remoteJid: string, ts: num
     .run(ts, bridgeId, remoteJid, ts);
 }
 
-// Snapshot the highest watermark across every route on a bridge. The
-// adapter uses this on reconnect to short-circuit very-old appends before
-// it has loaded individual route rows.
-export function getMaxRouteLastSeenTs(bridgeId: string): number {
-  const row = getDb()
-    .prepare("SELECT MAX(last_seen_ts) AS m FROM bridge_routes WHERE bridge_id=?")
-    .get(bridgeId) as { m: number | null } | undefined;
-  return row?.m ?? 0;
+// Per-chat watermarks for every explicitly routed chat on a bridge, loaded
+// once per upsert batch. Each chat is gated only by its own progress: a
+// bridge-wide maximum would drop chat B's offline backlog as soon as a newer
+// message from chat A had been delivered.
+export function getRouteLastSeenTsMap(bridgeId: string): Map<string, number> {
+  const rows = getDb()
+    .prepare("SELECT remote_jid, last_seen_ts FROM bridge_routes WHERE bridge_id=? AND last_seen_ts IS NOT NULL")
+    .all(bridgeId) as Array<{ remote_jid: string; last_seen_ts: number }>;
+  return new Map(rows.map((r) => [r.remote_jid, r.last_seen_ts]));
 }
 
 // ---------------------------------------------------------------------------

package/lib/stores/dashboard-metrics-cache.test.ts

@@ -0,0 +1,99 @@
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-dashboard-cache-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+const { getDb, closeDb, DB_PATH } = await import("@/lib/db");
+const { getDashboardMetrics } = await import("./dashboard-metrics");
+const { recordMessageUsage } = await import("./message-usage");
+const { getPricingTables } = await import("./pricing");
+const pricing = await import("./pricing");
+
+beforeEach(() => {
+  const db = getDb();
+  db.exec("DELETE FROM message_usage; DELETE FROM messages; DELETE FROM threads;");
+  const now = new Date().toISOString();
+  db.prepare("INSERT INTO threads(thread_id, agent_id, created_at, updated_at) VALUES (?,?,?,?)")
+    .run("t1", "a1", now, now);
+  db.prepare("INSERT INTO messages(msg_id, thread_id, role, content, created_at) VALUES (?,?,?,?,?)")
+    .run("m1", "t1", "assistant", "  legacy estimate  ", now);
+});
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+afterAll(() => {
+  closeDb();
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+describe("dashboard metrics cache", () => {
+  it("reuses a result only while the data, pricing, and window are unchanged", async () => {
+    const first = await getDashboardMetrics(30);
+    expect(await getDashboardMetrics(30)).toBe(first);
+    expect(first.summary.output_tokens_est).toBe(4);
+    expect(await getDashboardMetrics(7)).not.toBe(first);
+  });
+
+  it("invalidates immediately after local writes", async () => {
+    const first = await getDashboardMetrics();
+    getDb().prepare("UPDATE messages SET content=? WHERE msg_id=?").run("a".repeat(100), "m1");
+    const next = await getDashboardMetrics();
+    expect(next).not.toBe(first);
+    expect(next.summary.output_tokens_est).toBe(25);
+  });
+
+  it("invalidates for writes through another connection", async () => {
+    const first = await getDashboardMetrics();
+    const writer = new DatabaseSync(DB_PATH);
+    try {
+      writer.prepare("UPDATE messages SET content=? WHERE msg_id=?").run("b".repeat(80), "m1");
+      const next = await getDashboardMetrics();
+      expect(next).not.toBe(first);
+      expect(next.summary.output_tokens_est).toBe(20);
+    } finally {
+      writer.close();
+    }
+  });
+
+  it("expires after five seconds and across UTC day boundaries", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-10-18T23:59:59.000Z"));
+    const first = await getDashboardMetrics();
+    vi.setSystemTime(new Date("2026-10-19T00:00:00.000Z"));
+    const nextDay = await getDashboardMetrics();
+    expect(nextDay).not.toBe(first);
+    vi.advanceTimersByTime(5000);
+    expect(await getDashboardMetrics()).not.toBe(nextDay);
+  });
+
+  it("invalidates when pricing tables change", async () => {
+    const first = await getDashboardMetrics();
+    const tables = getPricingTables();
+    vi.spyOn(pricing, "getPricingTables").mockReturnValue({ ...tables });
+    expect(await getDashboardMetrics()).not.toBe(first);
+  });
+
+  it("preserves snapshot tokens, costs, and tool counts without needing the body", async () => {
+    getDb().prepare("UPDATE messages SET content=?, tool_events=? WHERE msg_id='m1'")
+      .run("x".repeat(100_000), JSON.stringify([
+        { id: "call1", phase: "call", name: "test", payload: {} },
+        { id: "call1", phase: "result", name: "test", payload: { ok: true } },
+      ]));
+    recordMessageUsage({
+      message_id: "m1", thread_id: "t1", agent_id: "a1", agent_name: "Synthetic",
+      provider: "synthetic", model_id: "synthetic", model_config_name: null,
+      input_tokens: 100, output_tokens: 20, input_rate_usd_per_mtok: null,
+      output_rate_usd_per_mtok: null, cost_usd: 0.5,
+    });
+    const data = await getDashboardMetrics();
+    expect(data.summary).toMatchObject({
+      input_tokens_est: 100, output_tokens_est: 20,
+      recorded_cost_usd: 0.5, tool_calls: 1, tool_successes: 1,
+    });
+    expect(data.summary.data_quality.measured_messages).toBe(1);
+  });
+});

package/lib/stores/dashboard-metrics.ts

@@ -12,6 +12,16 @@ import {
 
 const CHARS_PER_TOKEN = 4;
 const DEFAULT_WINDOW_DAYS = 30;
+const METRICS_CACHE_MS = 5_000;
+
+let metricsCache: {
+  db: ReturnType<typeof getDb>;
+  changes: number;
+  dataVersion: number;
+  tables: PricingTables;
+  createdAt: number;
+  metrics: DashboardMetrics;
+} | null = null;
 
 export interface DashboardTierTokens {
   hot_tokens: number;
@@ -256,10 +266,25 @@ export async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS): Promise<D
   const now = new Date();
   const boundedDays = Number.isFinite(days) ? Math.min(120, Math.max(7, Math.floor(days))) : DEFAULT_WINDOW_DAYS;
   const since = new Date(now.getTime() - (boundedDays * 24 * 60 * 60 * 1000)).toISOString();
+  const db = getDb();
+  const tables = getPricingTables();
+  // total_changes covers this connection; data_version covers other writers.
+  const { changes } = db.prepare("SELECT total_changes() AS changes").get() as { changes: number };
+  const { data_version: dataVersion } = db.prepare("PRAGMA data_version").get() as { data_version: number };
+  if (metricsCache?.db === db && metricsCache.changes === changes
+    && metricsCache.dataVersion === dataVersion && metricsCache.tables === tables
+    && metricsCache.metrics.days === boundedDays
+    && metricsCache.metrics.generated_at.slice(0, 10) === now.toISOString().slice(0, 10)
+    && now.getTime() - metricsCache.createdAt >= 0
+    && now.getTime() - metricsCache.createdAt < METRICS_CACHE_MS) {
+    return metricsCache.metrics;
+  }
 
-  const usageRows = getDb()
+  const usageRows = db
     .prepare(
-      `SELECT m.created_at, m.role, m.content, m.tool_events, m.thread_id, t.agent_id,
+      `SELECT m.created_at, m.role,
+              CASE WHEN mu.input_tokens IS NULL THEN m.content ELSE '' END AS content,
+              m.tool_events, m.thread_id, t.agent_id,
               a.name AS agent_name, mc.provider AS provider,
               mc.model_id AS model_id,
                   COALESCE(ta.model_config_name, a.model_config_name, dmc.name) AS model_config_name,
@@ -313,7 +338,6 @@ export async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS): Promise<D
     }
   }
 
-  const tables = getPricingTables();
   const { byProvider, generatedAt } = tables;
   const dayMap = seedDayBuckets(now, boundedDays);
   const agentMap = new Map<string, AgentBucket>();
@@ -645,7 +669,7 @@ export async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS): Promise<D
     };
   }
 
-  return {
+  const metrics: DashboardMetrics = {
     generated_at: now.toISOString(),
     days: boundedDays,
     summary: {
@@ -701,6 +725,8 @@ export async function getDashboardMetrics(days = DEFAULT_WINDOW_DAYS): Promise<D
       notes: "Dashboard cost is recalculated from captured provider token usage and the latest matching rates. The original per-turn cost snapshots remain unchanged; legacy rows use content-length token estimates.",
     },
   };
+  metricsCache = { db, changes, dataVersion, tables, createdAt: now.getTime(), metrics };
+  return metrics;
 }
 
 function seedDayBuckets(now: Date, days: number): Map<string, DayBucket> {

package/lib/stores/message-embedding-jobs.test.ts

@@ -87,6 +87,33 @@ describe("message embedding jobs", () => {
     expect(nextMessageEmbeddingDelayMs(currentTime)).toBeGreaterThan(0);
   });
 
+  it("finds the earliest pending deadline or processing lease without including terminal jobs", () => {
+    const nowMs = Date.now();
+    expect(nextMessageEmbeddingDelayMs(nowMs)).toBeNull();
+    for (const id of ["pending", "processing", "done", "no-lease"]) {
+      addMessage(id, "synthetic embedding input");
+      enqueueMessageEmbeddingJob(id, "synthetic embedding input");
+    }
+    const db = getDb();
+    db.prepare("UPDATE message_embedding_jobs SET available_at_ms=? WHERE message_id='pending'").run(nowMs + 3000);
+    db.prepare("UPDATE message_embedding_jobs SET state='processing',lease_until_ms=? WHERE message_id='processing'")
+      .run(nowMs + 1000);
+    db.exec("UPDATE message_embedding_jobs SET state='done',available_at_ms=0 WHERE message_id='done'");
+    db.exec("UPDATE message_embedding_jobs SET state='processing',lease_until_ms=NULL WHERE message_id='no-lease'");
+    expect(nextMessageEmbeddingDelayMs(nowMs)).toBe(1000);
+    db.exec("DELETE FROM message_embedding_jobs WHERE message_id='processing'");
+    expect(nextMessageEmbeddingDelayMs(nowMs)).toBe(3000);
+    db.exec("DELETE FROM message_embedding_jobs WHERE message_id='pending'");
+    expect(nextMessageEmbeddingDelayMs(nowMs)).toBeNull();
+  });
+
+  it("returns zero for an already-expired processing lease", () => {
+    addMessage("expired", "synthetic expired embedding input");
+    enqueueMessageEmbeddingJob("expired", "synthetic expired embedding input");
+    getDb().exec("UPDATE message_embedding_jobs SET state='processing',lease_until_ms=1 WHERE message_id='expired'");
+    expect(nextMessageEmbeddingDelayMs(100)).toBe(0);
+  });
+
   it("cascades pending work when its source message is deleted", () => {
     addMessage("msg-4", "message pending embedding");
     enqueueMessageEmbeddingJob("msg-4", "message pending embedding");

package/lib/stores/message-embedding-jobs.ts

@@ -102,9 +102,11 @@ export function claimMessageEmbeddingJobs(
 
 export function nextMessageEmbeddingDelayMs(nowMs = Date.now()): number | null {
   const row = getDb().prepare(
-    `SELECT MIN(CASE WHEN state='pending' THEN available_at_ms ELSE lease_until_ms END) AS next_at_ms
-     FROM message_embedding_jobs
-     WHERE state IN ('pending','processing')`,
+    `SELECT MIN(next_at_ms) AS next_at_ms FROM (
+       SELECT MIN(available_at_ms) AS next_at_ms FROM message_embedding_jobs WHERE state='pending'
+       UNION ALL
+       SELECT MIN(lease_until_ms) AS next_at_ms FROM message_embedding_jobs WHERE state='processing'
+     )`,
   ).get() as { next_at_ms?: number | null } | undefined;
   return typeof row?.next_at_ms === "number" ? Math.max(0, row.next_at_ms - nowMs) : null;
 }

package/lib/stores/message-usage.test.ts

@@ -6,7 +6,8 @@ import { tmpdir } from "node:os";
 const tmpRoot = mkdtempSync(join(tmpdir(), "jarela-test-message-usage-"));
 process.env.JARELA_DB_DIR = tmpRoot;
 
-const { recordMessageUsage, getMessageUsageByIds } = await import("./message-usage");
+const { recordMessageUsage, getMessageUsageByIds, getLatestMessageUsageForThread } = await import("./message-usage");
+const { getDb } = await import("@/lib/db");
 const getMessageUsage = (id: string) => getMessageUsageByIds([id]).get(id) ?? null;
 
 afterAll(() => {
@@ -14,6 +15,25 @@ afterAll(() => {
 });
 
 describe("message_usage snapshot store (ADR-0041)", () => {
+  it("returns the latest usage for only the requested thread", () => {
+    const db = getDb();
+    for (const [id, thread, timestamp] of [
+      ["ordered-old", "ordered-thread", "2026-10-01T00:00:00.000Z"],
+      ["ordered-other", "other-thread", "2026-10-18T00:00:00.000Z"],
+      ["ordered-new", "ordered-thread", "2026-10-10T00:00:00.000Z"],
+    ]) {
+      recordMessageUsage({
+        message_id: id, thread_id: thread, agent_id: "synthetic", agent_name: "Synthetic",
+        provider: "synthetic", model_id: "synthetic", model_config_name: null,
+        input_tokens: 1, output_tokens: 1, input_rate_usd_per_mtok: null,
+        output_rate_usd_per_mtok: null, cost_usd: 0,
+      });
+      db.prepare("UPDATE message_usage SET created_at=? WHERE message_id=?").run(timestamp, id);
+    }
+    expect(getLatestMessageUsageForThread("ordered-thread")?.message_id).toBe("ordered-new");
+    expect(getLatestMessageUsageForThread("missing-thread")).toBeNull();
+  });
+
   it("records and reads back a usage snapshot", () => {
     recordMessageUsage({
       message_id: "m1",

package/lib/stores/pricing-cache.test.ts

@@ -0,0 +1,31 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ statSync: vi.fn(), readFileSync: vi.fn() }));
+vi.mock("node:fs", () => mocks);
+vi.mock("./known-rates", () => ({ knownRateModelIds: () => [], knownRateFor: () => null }));
+const { getPricingTables } = await import("./pricing");
+
+describe("pricing snapshot read cache", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("does not read or parse the snapshot again when its mtime is unchanged", () => {
+    mocks.statSync.mockReturnValue({ mtimeMs: 100 });
+    mocks.readFileSync.mockReturnValue(JSON.stringify({ generated_at: "first", sources: [] }));
+    const first = getPricingTables();
+    expect(getPricingTables()).toBe(first);
+    expect(mocks.statSync).toHaveBeenCalledTimes(2);
+    expect(mocks.readFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  it("reloads rates when the snapshot changes", () => {
+    mocks.statSync.mockReturnValue({ mtimeMs: 200 });
+    mocks.readFileSync.mockReturnValue(JSON.stringify({ generated_at: "second", sources: [] }));
+    expect(getPricingTables().generatedAt).toBe("second");
+    mocks.statSync.mockReturnValue({ mtimeMs: 300 });
+    mocks.readFileSync.mockReturnValue(JSON.stringify({ generated_at: "third", sources: [] }));
+    expect(getPricingTables().generatedAt).toBe("third");
+    expect(mocks.readFileSync).toHaveBeenCalledTimes(2);
+  });
+});

package/lib/stores/pricing.ts

@@ -112,6 +112,9 @@ function readSnapshotSync(): { path: string; snapshot: PricingSnapshot | null; m
   try {
     const p = snapshotPath();
     const stat = statSync(p);
+    if (cached?.path === p && cached.mtimeMs === stat.mtimeMs) {
+      return { path: p, snapshot: null, mtimeMs: stat.mtimeMs };
+    }
     const raw = readFileSync(p, "utf8");
     return { path: p, snapshot: JSON.parse(raw) as PricingSnapshot, mtimeMs: stat.mtimeMs };
   } catch {