@circuitwall/jarela 2.3.0 → 2.4.0

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);

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/proxy-config.test.ts

@@ -0,0 +1,120 @@
+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-proxy-config-"));
+process.env.JARELA_DB_DIR = tmpRoot;
+
+const store = await import("./proxy-config");
+const { getDb } = await import("@/lib/db");
+const { SECRET_MASK } = await import("./integrations");
+
+afterAll(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* */ }
+});
+
+const PEM = "-----BEGIN CERTIFICATE-----\nMIIBfake\n-----END CERTIFICATE-----\n";
+
+function storedPasswordColumn(): string | null {
+  const row = getDb().prepare("SELECT password FROM proxy_config WHERE id = 1").get() as { password: string | null } | undefined;
+  return row?.password ?? null;
+}
+
+describe("proxy-config store", () => {
+  beforeEach(() => {
+    getDb().exec("DELETE FROM proxy_config");
+  });
+
+  it("returns the default off status before anything is saved", () => {
+    expect(store.getProxyConfigStatus()).toMatchObject({ mode: "off", scheme: "http", host: null, password: null });
+    expect(store.getProxyConfigRaw()).toBeNull();
+    expect(store.deleteProxyConfig()).toBe(false);
+  });
+
+  it("encrypts the password at rest, masks it in status and decrypts it for the dispatcher", () => {
+    const saved = store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, username: "u", password: "p@ss:word" });
+    expect(saved).toMatchObject({ mode: "manual", host: "proxy.corp", port: 3128, password: SECRET_MASK });
+    expect(storedPasswordColumn()).not.toContain("p@ss:word");
+    expect(store.getProxyConfigRaw()?.password).toBe("p@ss:word");
+  });
+
+  it("keeps the existing password when the UI echoes the mask back, without re-encrypting it", () => {
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, username: "u", password: "secret" });
+    const before = storedPasswordColumn();
+    store.saveProxyConfig({ mode: "manual", host: "proxy2.corp", port: 8080, username: "u", password: SECRET_MASK });
+    expect(storedPasswordColumn()).toBe(before);
+    expect(store.getProxyConfigRaw()).toMatchObject({ host: "proxy2.corp", port: 8080, password: "secret" });
+  });
+
+  it("never stores the mask itself as a password when none existed", () => {
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, password: SECRET_MASK });
+    expect(store.getProxyConfigRaw()?.password).toBeNull();
+    expect(store.getProxyConfigStatus().password).toBeNull();
+  });
+
+  it("clears the password when an empty string or null is sent", () => {
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, password: "secret" });
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, password: "" });
+    expect(store.getProxyConfigRaw()?.password).toBeNull();
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, password: "secret" });
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128, password: null });
+    expect(store.getProxyConfigRaw()?.password).toBeNull();
+  });
+
+  it("trims host, username and no_proxy and stores blanks as null", () => {
+    store.saveProxyConfig({ mode: "manual", host: "  proxy.corp  ", port: 3128, username: "   ", no_proxy: "  " });
+    expect(store.getProxyConfigRaw()).toMatchObject({ host: "proxy.corp", username: null, no_proxy: null });
+  });
+
+  it.each([
+    ["a URL with a scheme", "http://proxy.corp"],
+    ["a host with a port", "proxy.corp:8080"],
+    ["a hex-only host with a port", "dead.beef:3128"],
+    ["a host with a path", "proxy.corp/pac"],
+    ["a host with credentials", "user:pw@proxy.corp"],
+    ["a host with spaces", "proxy corp"],
+  ])("rejects %s in manual mode instead of building a broken proxy URL", (_label, host) => {
+    const result = store.saveProxyConfig({ mode: "manual", host, port: 3128 });
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toMatch(/host/i);
+    expect(store.getProxyConfigRaw()).toBeNull();
+  });
+
+  it.each([
+    ["fd00::1", "fd00::1"],
+    ["[fd00::1]", "fd00::1"],
+    ["10.0.0.5", "10.0.0.5"],
+    ["proxy-1.corp.example", "proxy-1.corp.example"],
+  ])("accepts host %s and stores it as %s", (input, stored) => {
+    const result = store.saveProxyConfig({ mode: "manual", host: input, port: 3128 });
+    expect(result).not.toHaveProperty("error");
+    expect(store.getProxyConfigRaw()?.host).toBe(stored);
+  });
+
+  it.each([0, -1, 65536, 3128.5, Number.NaN, Number.POSITIVE_INFINITY])("rejects port %s", (port) => {
+    expect(store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port })).toHaveProperty("error");
+  });
+
+  it("requires host and port only in manual mode", () => {
+    expect(store.saveProxyConfig({ mode: "manual", port: 3128 })).toHaveProperty("error");
+    expect(store.saveProxyConfig({ mode: "manual", host: "proxy.corp" })).toHaveProperty("error");
+    expect(store.saveProxyConfig({ mode: "system" })).toMatchObject({ mode: "system" });
+    expect(store.saveProxyConfig({ mode: "off" })).toMatchObject({ mode: "off" });
+  });
+
+  it("rejects an invalid mode and a non-PEM CA bundle, and clears a blank bundle", () => {
+    expect(store.saveProxyConfig({ mode: "auto" as never })).toHaveProperty("error");
+    expect(store.saveProxyConfig({ mode: "off", ca_bundle: "not a cert" })).toHaveProperty("error");
+    store.saveProxyConfig({ mode: "off", ca_bundle: PEM });
+    expect(store.getProxyConfigRaw()?.ca_bundle).toBe(PEM);
+    store.saveProxyConfig({ mode: "off", ca_bundle: "   " });
+    expect(store.getProxyConfigRaw()?.ca_bundle).toBeNull();
+  });
+
+  it("normalises an unknown persisted scheme to http", () => {
+    store.saveProxyConfig({ mode: "manual", host: "proxy.corp", port: 3128 });
+    getDb().prepare("UPDATE proxy_config SET scheme = 'socks5' WHERE id = 1").run();
+    expect(store.getProxyConfigRaw()).toMatchObject({ mode: "manual", scheme: "http" });
+  });
+});

package/lib/stores/proxy-config.ts

@@ -15,6 +15,7 @@
 // existing password" so the UI can echo back the masked form without
 // blanking the secret.
 
+import { isIPv6 } from "node:net";
 import { getDb } from "@/lib/db";
 import { decryptIfNeeded, encrypt } from "@/lib/crypto/envelope";
 import { SECRET_MASK } from "@/lib/stores/integrations";
@@ -122,11 +123,18 @@ export function saveProxyConfig(input: ProxyConfigInput): ProxyConfigStatus | {
   const scheme: ProxyScheme = input.scheme === "https" ? "https" : "http";
 
   // Manual mode requires host + port. system / off don't.
+  let host = nullable(input.host);
   if (input.mode === "manual") {
-    if (!input.host || !input.host.trim()) return { error: "host is required in manual mode" };
-    if (input.port == null || !Number.isFinite(input.port) || input.port <= 0 || input.port > 65535) {
-      return { error: "port must be between 1 and 65535" };
+    if (!host) return { error: "host is required in manual mode" };
+    const normalisedHost = normaliseProxyHost(host);
+    if (!normalisedHost) {
+      return { error: "host must be a hostname or IP address, without scheme, port, path or credentials" };
     }
+    host = normalisedHost;
+    if (input.port == null) return { error: "port must be between 1 and 65535" };
+  }
+  if (input.port != null && (!Number.isInteger(input.port) || input.port <= 0 || input.port > 65535)) {
+    return { error: "port must be between 1 and 65535" };
   }
 
   // CA bundle: empty/null clears; non-empty must look like PEM.
@@ -167,7 +175,7 @@ export function saveProxyConfig(input: ProxyConfigInput): ProxyConfigStatus | {
   ).run(
     input.mode,
     scheme,
-    nullable(input.host),
+    host,
     input.port ?? null,
     nullable(input.username),
     storedPassword,
@@ -207,6 +215,16 @@ function normaliseScheme(s: string | null | undefined): ProxyScheme {
   return s === "https" ? "https" : "http";
 }
 
+// The dispatcher builds `${scheme}://${auth}${host}:${port}`, so a pasted URL
+// or host:port would produce an unusable proxy URL. IPv6 is stored unbracketed;
+// the dispatcher adds the brackets.
+function normaliseProxyHost(host: string): string | null {
+  const unbracketed = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  if (/^[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/.test(unbracketed)) return unbracketed;
+  if (isIPv6(unbracketed)) return unbracketed;
+  return null;
+}
+
 function nullable(v: string | null | undefined): string | null {
   if (v == null) return null;
   const trimmed = v.trim();

package/lib/stores/threads.ts

@@ -157,11 +157,15 @@ export function getThreadMessageBySeq(thread_id: string, seq: number): MessageRo
   return (getDb().prepare(MSG_COLS_SQL + " WHERE thread_id=? AND rowid=?").get(thread_id, seq) as unknown as MessageRow | undefined) ?? null;
 }
 
-export function countThreadMessagesFromSeq(thread_id: string, seq: number): number {
-  const row = getDb().prepare("SELECT COUNT(*) AS n FROM messages WHERE thread_id=? AND rowid>=?").get(thread_id, seq) as { n: number } | undefined;
+
+// Rows that size compaction can prune: automation-channel rows are kept
+// (see pruneThreadMessages), so they must not count toward its trigger.
+export function countForegroundThreadMessages(thread_id: string, fromSeq = 0): number {
+  const row = getDb()
+    .prepare("SELECT COUNT(*) AS n FROM messages WHERE thread_id=? AND rowid>=? AND " + foregroundCategoryGuardSql())
+    .get(thread_id, fromSeq, ...FOREGROUND_EXCLUDED_CATEGORIES) as { n: number } | undefined;
   return row?.n ?? 0;
 }
-
 export function isValidThreadContextCursor(thread_id: string, seq: number): boolean {
   if (getThreadMessageBySeq(thread_id, seq)) return true;
   return getThread(thread_id)?.hot_since_seq === seq;
@@ -733,11 +737,11 @@ export function setThreadContextPin(thread_id: string, hot_since: string | null,
     .run(hot_since, hot_since === null ? null : hot_since_seq!, thread_id);
 }
 
-// Called by moveThreadContextBoundary whenever the user explicitly moves the
-// boundary (drag, or manual /compact) — never by the auto-detector's own
-// commit path, which calls setThreadContextPin directly. `untilMessageCount`
-// is a one-time write; the read side (lib/agents/run-thread.ts) just compares
-// against it, no per-turn write needed.
+// Armed by moveThreadContextBoundary whenever the user explicitly moves the
+// boundary (drag, or manual /compact), and by the auto-detector's hot-turn
+// cooldown when a compaction pass ends without a commit (a commit writes the
+// lock in the same transaction). `untilMessageCount` is a one-time write; the
+// read side (lib/agents/run-thread.ts) just compares against it.
 export function setAutoBoundaryLock(thread_id: string, untilMessageCount: number): void {
   getDb()
     .prepare("UPDATE threads SET auto_boundary_locked_until_msg_count=? WHERE thread_id=?")