@circuitwall/jarela 2.4.0 → 2.5.0

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 {

package/lib/tools/packages/default-packages.test.ts

@@ -14,6 +14,7 @@ const {
   registerDefaultPackages,
   _resetDefaultPackages,
 } = await import("./default-packages");
+const { registeredTools, registeredCategory, registeredCapability } = await import("../runtime/registry");
 
 const { setPackageDisabled, listDisabledPackages } = await import(
   "@/lib/stores/disabled-packages"
@@ -52,6 +53,26 @@ describe("default LangChain packages", () => {
     expect(listDefaultPackages().every((p) => p.installed === false)).toBe(true);
   });
 
+  it("registers workspace packages with their declared categories and capabilities", () => {
+    const previousPackagesDir = process.env.JARELA_PACKAGES_DIR;
+    process.env.JARELA_PACKAGES_DIR = "";
+    try {
+      registerDefaultPackages();
+
+      expect(listDefaultPackages().every((p) => p.installed)).toBe(true);
+      const tools = registeredTools();
+      expect(tools.length).toBeGreaterThan(0);
+      for (const tool of tools) {
+        expect(registeredCategory(tool.name)).toBeDefined();
+        expect(["read", "write", "execute"]).toContain(registeredCapability(tool.name));
+      }
+    } finally {
+      _resetDefaultPackages();
+      if (previousPackagesDir === undefined) delete process.env.JARELA_PACKAGES_DIR;
+      else process.env.JARELA_PACKAGES_DIR = previousPackagesDir;
+    }
+  });
+
   it("findDefaultPackage returns the descriptor for a known id", () => {
     const d = findDefaultPackage("github");
     expect(d).not.toBeNull();

package/lib/tools/packages/optional-package.test.ts

@@ -0,0 +1,72 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { isOptionalPackageInstalled, loadOptionalPackage } from "./optional-package";
+
+describe("optional package resolution", () => {
+  let managedDir: string;
+  let originalPackagesDir: string | undefined;
+
+  beforeEach(() => {
+    originalPackagesDir = process.env.JARELA_PACKAGES_DIR;
+    managedDir = mkdtempSync(join(tmpdir(), "jarela-optional-packages-"));
+    process.env.JARELA_PACKAGES_DIR = managedDir;
+  });
+
+  afterEach(() => {
+    if (originalPackagesDir === undefined) delete process.env.JARELA_PACKAGES_DIR;
+    else process.env.JARELA_PACKAGES_DIR = originalPackagesDir;
+    rmSync(managedDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("prefers a package installed in the managed packages directory", () => {
+    const packageDir = join(managedDir, "node_modules", "fake-optional-package");
+    mkdirSync(packageDir, { recursive: true });
+    writeFileSync(join(packageDir, "package.json"), JSON.stringify({
+      name: "fake-optional-package",
+      version: "1.0.0",
+      main: "index.cjs",
+    }));
+    writeFileSync(join(packageDir, "index.cjs"), 'module.exports = { source: "managed" };');
+
+    expect(loadOptionalPackage("fake-optional-package")).toEqual({ source: "managed" });
+  });
+
+  it.each([
+    "@circuitwall/atlassian-langchain",
+    "@circuitwall/github-langchain",
+    "@circuitwall/icloud-langchain",
+    "@circuitwall/jira-align-langchain",
+    "@circuitwall/ms-todo-langchain",
+  ])("falls back to the app workspace for %s", (packageName) => {
+    delete process.env.JARELA_PACKAGES_DIR;
+    expect(loadOptionalPackage(packageName)).not.toBeNull();
+    expect(isOptionalPackageInstalled(packageName)).toBe(true);
+  });
+
+  it("exposes exports from the workspace fallback", () => {
+    delete process.env.JARELA_PACKAGES_DIR;
+    const loaded = loadOptionalPackage<{ githubFetch?: unknown }>("@circuitwall/github-langchain");
+
+    expect(loaded).not.toBeNull();
+    expect(typeof loaded?.githubFetch).toBe("function");
+  });
+
+  it("treats an absent optional package as a normal miss", () => {
+    const error = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    expect(loadOptionalPackage("@circuitwall/not-installed")).toBeNull();
+    expect(error).not.toHaveBeenCalled();
+  });
+
+  it("does not treat unrelated app dependencies as installed optional packages", () => {
+    expect(loadOptionalPackage("@langchain/core")).toBeNull();
+  });
+
+  it("honors an explicit managed directory even when a workspace package exists", () => {
+    expect(loadOptionalPackage("@circuitwall/github-langchain")).toBeNull();
+    expect(isOptionalPackageInstalled("@circuitwall/github-langchain")).toBe(false);
+  });
+});

package/lib/tools/packages/optional-package.ts

@@ -22,12 +22,40 @@ function managedPackagePath(packageName: string): string {
   return join(getPackagesDir(), "node_modules", packageName);
 }
 
+interface ResolvedOptionalPackage {
+  req: OptionalRequire;
+  path: string;
+}
+
+function resolveOptionalPackage(packageName: string): ResolvedOptionalPackage | null {
+  const managedReq = createRuntimeRequire(join(getPackagesDir(), "_anchor"));
+  try {
+    return {
+      req: managedReq,
+      path: managedReq.resolve(managedPackagePath(packageName)),
+    };
+  } catch {
+    // Workspace builds expose bundled @circuitwall packages from the app root.
+  }
+
+  if (process.env.JARELA_PACKAGES_DIR?.trim()) return null;
+  if (!packageName.startsWith("@circuitwall/")) return null;
+
+  const appReq = createRuntimeRequire(join(process.cwd(), "package.json"));
+  try {
+    return { req: appReq, path: appReq.resolve(packageName) };
+  } catch {
+    return null;
+  }
+}
+
 export function loadOptionalPackage<T extends AnyModule>(packageName: string): T | null {
   const override = testOverrides.get(packageName);
   if (override) return override as T;
+  const resolved = resolveOptionalPackage(packageName);
+  if (!resolved) return null;
   try {
-    const req = createRuntimeRequire(join(getPackagesDir(), "_anchor"));
-    return req(managedPackagePath(packageName)) as T;
+    return resolved.req(resolved.path) as T;
   } catch (err) {
     // Keep the optional boundary non-fatal, but leave the actual load failure
     // visible so missing peer dependencies are diagnosable from server logs.
@@ -68,9 +96,10 @@ export function optionalFunction<T extends (...args: any[]) => any>(
 }
 
 export function isOptionalPackageInstalled(packageName: string): boolean {
+  const resolved = resolveOptionalPackage(packageName);
+  if (!resolved) return false;
   try {
-    const req = createRuntimeRequire(join(getPackagesDir(), "_anchor"));
-    req(managedPackagePath(packageName));
+    resolved.req(resolved.path);
     return true;
   } catch (err) {
     console.error(`[optional-package] failed to load ${packageName}: ${err instanceof Error ? err.message : String(err)}`);

package/lib/ui/navigate.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { parseHref } from "./navigate";
+
+describe("parseHref legacy Knowledge routes", () => {
+  it.each([
+    "/?tab=documents",
+    "/?tab=memory",
+    "/?tab=tools&item=documents",
+    "/?tab=tools&item=memory",
+  ])("routes %s to Knowledge", (href) => {
+    expect(parseHref(href)).toMatchObject({ tab: "memory", item: undefined, external: false });
+  });
+});

package/lib/ui/navigate.ts

@@ -40,8 +40,16 @@ export function parseHref(input: string | null | undefined): ParsedHref {
 
   const params = new URLSearchParams(queryStr);
   const tabRaw = params.get("tab");
-  const tab = TABS.includes(tabRaw as Tab) ? (tabRaw as Tab) : undefined;
-  const item = params.get("item") ?? undefined;
+  let tab = TABS.includes(tabRaw as Tab) ? (tabRaw as Tab) : undefined;
+  let item = params.get("item") ?? undefined;
+  if (
+    tab === "documents" ||
+    tab === "memory" ||
+    (tab === "tools" && (item === "memory" || item === "documents"))
+  ) {
+    tab = "memory";
+    item = undefined;
+  }
   const thread = params.get("thread") ?? undefined;
   const agent = params.get("agent") ?? undefined;
   return { tab, item, thread, agent, hash, external: false };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@circuitwall/jarela",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Jarela — local chat interface for LangGraph agents (multi-provider, single-process, SQLite-backed).",
   "license": "Apache-2.0",
   "author": "Andrew Ge Wu",