@wenathlan/getry 2.0.154 → 2.0.158

package/tests/modelroute.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { bumprevision, fallbackroute, markprovider, resolveroute, routesfor, routevalid } from "../llm.js";
+import type { modelroute, providerconfig } from "../types.js";
+
+const now = 1_800_000_000_000;
+
+/** Builds one provider config fixture with every value user configured. */
+function provider(id: string, over: Partial<providerconfig> = {}): providerconfig {
+  return {
+    id,
+    name: `The ${id} gateway`,
+    endpoint: `https://${id}.example/v1`,
+    style: "chatcompletions",
+    models: ["model-a", "model-b"],
+    status: "available",
+    createdat: now,
+    ...over,
+  };
+}
+
+/** Builds one model route fixture. */
+function route(over: Partial<modelroute> = {}): modelroute {
+  return {
+    id: "route1",
+    kind: "draftplan",
+    providerid: "prov1",
+    model: "model-a",
+    revision: 1,
+    updatedat: now,
+    ...over,
+  };
+}
+
+describe("modelroute", () => {
+  it("resolves the provider and model for a task kind", () => {
+    const resolved = resolveroute({ routes: [route()], providers: [provider("prov1")], kind: "draftplan" });
+    expect(resolved.provider?.id).toBe("prov1");
+    expect(resolved.model).toBe("model-a");
+  });
+
+  it("reports why nothing routed for an unrouted task kind", () => {
+    const resolved = resolveroute({ routes: [route()], providers: [provider("prov1")], kind: "parsecommand" });
+    expect(resolved.provider).toBeUndefined();
+    expect(resolved.reason).toMatch(/No model route/i);
+  });
+
+  it("keeps every route of one task kind in revision order", () => {
+    const routes = [
+      route({ revision: 1 }),
+      route({ id: "route2", revision: 5 }),
+      route({ id: "route3", kind: "reflect" }),
+    ];
+    expect(routesfor(routes, "draftplan").map((entry) => entry.id)).toEqual(["route2", "route1"]);
+  });
+
+  it("refuses a route whose model stays outside the provider model list", () => {
+    const resolved = resolveroute({
+      routes: [route({ model: "model-z" })],
+      providers: [provider("prov1")],
+      kind: "draftplan",
+    });
+    expect(resolved.reason).toMatch(/outside the model list/i);
+  });
+
+  it("marks providers unavailable and available again after their calls", () => {
+    const providers = markprovider({
+      providers: [provider("prov1"), provider("prov2")],
+      providerid: "prov1",
+      available: false,
+      now,
+    });
+    expect(providers.find((candidate) => candidate.id === "prov1")?.status).toBe("unavailable");
+    expect(providers.find((candidate) => candidate.id === "prov2")?.status).toBe("available");
+    const resolved = resolveroute({ routes: [route()], providers, kind: "draftplan" });
+    expect(resolved.reason).toMatch(/unavailable/i);
+    const back = markprovider({ providers, providerid: "prov1", available: true, now: now + 1000 });
+    expect(resolveroute({ routes: [route()], providers: back, kind: "draftplan" }).provider?.id).toBe("prov1");
+    expect(back.find((candidate) => candidate.id === "prov1")?.lastcheckedat).toBe(now + 1000);
+  });
+
+  it("falls back on the user configured fallback pair when the primary provider fails", () => {
+    const routes = [route({ fallbackproviderid: "prov2", fallbackmodel: "model-b" })];
+    const providers = markprovider({
+      providers: [provider("prov1"), provider("prov2")],
+      providerid: "prov1",
+      available: false,
+      now,
+    });
+    const fallen = fallbackroute({ routes, providers, kind: "draftplan" });
+    expect(fallen.provider?.id).toBe("prov2");
+    expect(fallen.model).toBe("model-b");
+  });
+
+  it("reports why nothing fell back without a fallback pair or with an unavailable fallback provider", () => {
+    expect(fallbackroute({ routes: [route()], providers: [provider("prov1")], kind: "draftplan" }).reason).toMatch(
+      /no user configured fallback/i,
+    );
+    const routes = [route({ fallbackproviderid: "prov2", fallbackmodel: "model-b" })];
+    const providers = [provider("prov1"), provider("prov2", { status: "unavailable" })];
+    expect(fallbackroute({ routes, providers, kind: "draftplan" }).reason).toMatch(/unavailable/i);
+  });
+
+  it("validates route entries and bumps revisions for the history", () => {
+    expect(routevalid(route()).allowed).toBe(true);
+    expect(routevalid(route({ kind: " " })).allowed).toBe(false);
+    expect(routevalid(route({ model: "" })).allowed).toBe(false);
+    expect(routevalid(route({ fallbackproviderid: "prov2" })).allowed).toBe(false);
+    const bumped = bumprevision(route(), now + 5000);
+    expect(bumped.revision).toBe(2);
+    expect(bumped.updatedat).toBe(now + 5000);
+  });
+});

package/tests/promptlibrary.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import {
+  latesttemplate,
+  removetemplate,
+  rendertemplate,
+  savetemplate,
+  searchtemplates,
+  templatevariables,
+} from "../llm.js";
+import type { prompttemplate } from "../types.js";
+
+const now = 1_800_000_000_000;
+
+describe("promptlibrary", () => {
+  it("extracts the template variables of the double braced placeholders", () => {
+    expect(templatevariables("Summarize {{url}} in {{tone}} tone about {{url}}.")).toEqual(["url", "tone"]);
+    expect(templatevariables("no placeholders here")).toEqual([]);
+  });
+
+  it("renders a template with its variables substituted", () => {
+    const template: prompttemplate = {
+      id: "t1",
+      name: "pagesummary",
+      body: "Summarize {{url}} in a {{tone}} tone.",
+      variables: ["url", "tone"],
+      version: 1,
+      createdat: now,
+    };
+    const rendered = rendertemplate({ template, variables: { url: "https://example.com", tone: "plain" } });
+    expect(rendered.text).toBe("Summarize https://example.com in a plain tone.");
+  });
+
+  it("refuses the render when a declared variable stays empty", () => {
+    const template: prompttemplate = {
+      id: "t1",
+      name: "pagesummary",
+      body: "Summarize {{url}}.",
+      variables: ["url"],
+      version: 1,
+      createdat: now,
+    };
+    expect(rendertemplate({ template, variables: {} }).reason).toMatch(/stay empty/i);
+  });
+
+  it("requires the consent notice of a sensitive flow and rides it in the render", () => {
+    const template: prompttemplate = {
+      id: "t1",
+      name: "extract",
+      body: "Extract {{fields}} from the page.",
+      variables: ["fields"],
+      version: 1,
+      createdat: now,
+    };
+    expect(rendertemplate({ template, variables: { fields: "names" }, sensitive: true }).reason).toMatch(
+      /consent notice/i,
+    );
+    const rendered = rendertemplate({
+      template,
+      variables: { fields: "names" },
+      sensitive: true,
+      consentnotice: "The extraction leaves the browser only with the granted fields.",
+    });
+    expect(rendered.text).toContain("Consent notice: The extraction leaves the browser only with the granted fields.");
+  });
+
+  it("stores template versions with change notes and keeps the history", () => {
+    const first = savetemplate({
+      templates: [],
+      name: "pagesummary",
+      body: "Summarize {{url}}.",
+      notes: "first version",
+      now,
+    });
+    expect(first[0]?.version).toBe(1);
+    const second = savetemplate({
+      templates: first,
+      name: "pagesummary",
+      body: "Summarize {{url}} in {{tone}}.",
+      notes: "adds the tone",
+      now: now + 1000,
+    });
+    expect(second[0]?.version).toBe(2);
+    expect(second[1]?.version).toBe(1);
+    expect(second[0]?.variables).toEqual(["url", "tone"]);
+    expect(latesttemplate(second, "pagesummary")?.notes).toBe("adds the tone");
+    expect(latesttemplate(second, "unknown")).toBeUndefined();
+  });
+
+  it("searches the library by name, body, notes and variables", () => {
+    const templates = [
+      { id: "t1", name: "pagesummary", body: "Summarize {{url}}.", variables: ["url"], version: 1, createdat: now },
+      {
+        id: "t2",
+        name: "extract",
+        body: "Extract {{fields}}.",
+        variables: ["fields"],
+        version: 3,
+        notes: "the field extractor",
+        createdat: now + 1,
+      },
+    ];
+    expect(searchtemplates(templates, "summar").map((template) => template.name)).toEqual(["pagesummary"]);
+    expect(searchtemplates(templates, "field").map((template) => template.name)).toEqual(["extract"]);
+    expect(searchtemplates(templates, "")).toHaveLength(2);
+  });
+
+  it("removes every version of one template name", () => {
+    const stored = savetemplate({
+      templates: savetemplate({ templates: [], name: "pagesummary", body: "v1", now }),
+      name: "pagesummary",
+      body: "v2",
+      now: now + 1,
+    });
+    expect(removetemplate(stored, "pagesummary")).toEqual([]);
+  });
+});

package/tests/providercli.test.ts

@@ -0,0 +1,84 @@
+/**
+ * providercli — the provider account console smoke (the ownership move of
+ * the gateway ownership wave, step 5): the console family answers from the
+ * getry owner now, and this lane pins the load-bearing seams of the move —
+ * the help text renders, the accounts path resolver agrees with the
+ * accounts owner's own resolution, the opencode model definitions answer
+ * from the models owner with the catalog shape, and the twin deletion
+ * (getDefaultAccountManager behind the historical getAccountManager name)
+ * answers the accounts owner's real manager. No network, no browser.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import {
+  buildOpenCodeModelDefinitions,
+  getAccountManager,
+  printHelp,
+  providercli,
+  resolveAccountsPath,
+  runproviderfamily,
+} from "../providers.js";
+import { getDefaultAccountManager, resolveAccountsPath as accountsResolveAccountsPath } from "../accounts.js";
+import { MODELS_2026_CATALOG } from "../models.js";
+
+describe("providercli smoke", () => {
+  it("renders the help text", () => {
+    const logged: string[] = [];
+    const spy = vi.spyOn(console, "log").mockImplementation((...parts: unknown[]) => {
+      logged.push(parts.join(" "));
+    });
+    try {
+      printHelp();
+    } finally {
+      spy.mockRestore();
+    }
+    const text = logged.join("\n");
+    expect(text).toContain("devthink provider CLI (unified merge)");
+    expect(text).toContain("Usage:");
+    expect(text).toContain("cli.ts <command> [subcommand] [flags]");
+  });
+
+  it("resolves the accounts path the accounts owner resolves", () => {
+    expect(resolveAccountsPath()).toBe(accountsResolveAccountsPath());
+    expect(resolveAccountsPath()).toContain("antigravity-accounts.json");
+  });
+
+  it("builds the opencode model definitions with the catalog shape", () => {
+    const defs = buildOpenCodeModelDefinitions();
+    expect(defs.pluginList).toEqual(["devthink"]);
+    for (const entry of MODELS_2026_CATALOG) {
+      expect(defs.providerModels[entry.id]).toBeDefined();
+      expect(defs.providerModels[entry.id].antigravity.endpoint).toContain("cloudcode-pa.googleapis.com");
+      expect(defs.topLevelModels[`antigravity/${entry.id}`]).toBeDefined();
+    }
+    expect(Object.keys(defs.topLevelModels).length).toBeGreaterThan(MODELS_2026_CATALOG.length);
+  });
+
+  it("answers the account manager from the accounts owner (the twin deletion)", () => {
+    expect(typeof getAccountManager).toBe("function");
+    const mgr = getAccountManager({ disableBackgroundTimer: true });
+    // the twin raced the real manager on the same file; the owner answers
+    // the real class now — the singleton and the direct call agree
+    const direct = getDefaultAccountManager({ disableBackgroundTimer: true });
+    expect(mgr).toBe(direct);
+    expect(typeof mgr.listAccounts).toBe("function");
+    expect(typeof mgr.getValidAccessToken).toBe("function");
+  });
+
+  it("exposes the family entry and the providercli compat const", async () => {
+    expect(typeof runproviderfamily).toBe("function");
+    expect(typeof providercli.runCLI).toBe("function");
+    expect(typeof providercli.interactiveMenu).toBe("function");
+    // the family entry answers --help without a tty, without network
+    const logged: string[] = [];
+    const spy = vi.spyOn(console, "log").mockImplementation((...parts: unknown[]) => {
+      logged.push(parts.join(" "));
+    });
+    try {
+      await runproviderfamily(["--help"]);
+    } finally {
+      spy.mockRestore();
+    }
+    expect(logged.join("\n")).toContain("devthink provider CLI (unified merge)");
+  });
+});

package/tests/providerconstants.test.ts

@@ -0,0 +1,134 @@
+/**
+ * @file constants.test.ts
+ * @description
+ *  Tests for the constants module of maene (`../constants.js`). Confirms the
+ *  shape and presence of the headline catalog aggregates (`ALL_MODELS_2026`,
+ *  `MODEL_BY_ID`, `MODEL_ROUTING`), and verifies a few well-known model ids
+ *  from the package.json `antigravity.latest_models` manifest are present in
+ *  the flat string catalog used by per-family arrays.
+ *
+ *  Runs on the vitest runner with `node:assert/strict` assertions per the architecture skill
+ *  ("node:* first"). bun resolves `.js` specifiers to the sibling `.ts`
+ *  source automatically. Imports only leaf modules; does NOT import
+ *  `plugin.ts` or `index.ts` (they pull the optional @opencode-ai/plugin
+ *  peer SDK which may not be installed in the test environment).
+ */
+
+import assert from "node:assert/strict";
+import { it as test } from "vitest";
+/* the os leaf jitter ceiling stays devthink-owned behind the published
+ * specifier — never copied into the gateway. */
+import { JITTER_MAX_MS } from "@wenathlan/devthink/constants";
+import { OAUTH_CALLBACK_HOST, OAUTH_CALLBACK_PATH, PROJECT_FALLBACK } from "../constants.js";
+import {
+  ALL_MODELS_2026,
+  ANTIGRAVITY_MODEL_IDS_2026,
+  MODEL_BY_ID,
+  MODEL_IDS_2026_08_25,
+  MODEL_ROUTING,
+} from "../models.js";
+
+test("ALL_MODELS_2026 is a non-empty array of ModelDefinition entries", () => {
+  try {
+    assert.ok(Array.isArray(ALL_MODELS_2026), "ALL_MODELS_2026 must be an array");
+    assert.ok(ALL_MODELS_2026.length > 0, "ALL_MODELS_2026 must be non-empty");
+    // Note: the const is declared with a `readonly ModelDefinition[]` type
+    // annotation, but it is NOT wrapped in `Object.freeze(...)` at runtime.
+    // So it is not strictly frozen — it is only type-checked as readonly.
+  } catch (err) {
+    assert.fail(`constants shape check failed: ${(err as Error).message}`);
+  }
+});
+
+test("ALL_MODELS_2026 entries have the expected ModelDefinition shape", () => {
+  try {
+    for (const m of ALL_MODELS_2026) {
+      assert.equal(typeof m.id, "string", "model.id must be a string");
+      assert.ok(m.id.length > 0, "model.id must be non-empty");
+      assert.equal(typeof m.name, "string", "model.name must be a string");
+      assert.equal(typeof m.context, "number", "model.context must be a number");
+      assert.equal(typeof m.output, "number", "model.output must be a number");
+    }
+  } catch (err) {
+    assert.fail(`ALL_MODELS_2026 entry shape check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODEL_BY_ID is an object indexed by id and resolves known entries", () => {
+  try {
+    assert.equal(typeof MODEL_BY_ID, "object", "MODEL_BY_ID must be an object");
+    assert.notEqual(MODEL_BY_ID, null, "MODEL_BY_ID must not be null");
+
+    // Every ALL_MODELS_2026 id must resolve in MODEL_BY_ID.
+    for (const m of ALL_MODELS_2026) {
+      const found = (MODEL_BY_ID as Record<string, unknown>)[m.id];
+      assert.ok(found, `MODEL_BY_ID must contain id=${m.id}`);
+    }
+
+    // Specific known id present in the canonical catalog (constants.ts:934).
+    const opus = (MODEL_BY_ID as Record<string, any>)["antigravity-claude-opus-4-6-thinking"];
+    assert.ok(opus, "antigravity-claude-opus-4-6-thinking must be in MODEL_BY_ID");
+    assert.equal(opus.id, "antigravity-claude-opus-4-6-thinking");
+  } catch (err) {
+    assert.fail(`MODEL_BY_ID shape check failed: ${(err as Error).message}`);
+  }
+});
+
+test("MODEL_ROUTING exists and exposes routing for the canonical antigravity- ids", () => {
+  try {
+    assert.equal(typeof MODEL_ROUTING, "object", "MODEL_ROUTING must be an object");
+    assert.notEqual(MODEL_ROUTING, null, "MODEL_ROUTING must not be null");
+    assert.ok(Object.keys(MODEL_ROUTING).length > 0, "MODEL_ROUTING must have entries");
+
+    const known = (MODEL_ROUTING as Record<string, any>)["antigravity-gemini-3.1-pro"];
+    assert.ok(known, "antigravity-gemini-3.1-pro must have a routing entry");
+    assert.equal(typeof known.endpoint, "string", "routing.endpoint must be string");
+    assert.equal(typeof known.stream, "boolean", "routing.stream must be boolean");
+    assert.ok(known.api === "antigravity" || known.api === "gemini-cli", "routing.api must be a known provider");
+  } catch (err) {
+    assert.fail(`MODEL_ROUTING shape check failed: ${(err as Error).message}`);
+  }
+});
+
+test("flat string catalog exposes the bare ids referenced by package.json antigravity.latest_models", () => {
+  // package.json `antigravity.latest_models` includes bare ids like
+  // `gemini-3.1-pro`, `claude-opus-4-6-thinking`, `gemini-3.7-flash`,
+  // etc. Those bare ids are NOT in ALL_MODELS_2026 (which is antigravity-*
+  // prefixed plus preview ids) — they live in the per-family MODELS_2026_08_25
+  // flat string catalog, exposed via MODEL_IDS_2026_08_25.
+  try {
+    const flat = (MODEL_IDS_2026_08_25 ?? []) as readonly string[];
+    assert.ok(Array.isArray(flat), "MODEL_IDS_2026_08_25 must be an array");
+    assert.ok(flat.length > 0, "MODEL_IDS_2026_08_25 must be non-empty");
+
+    // Validate that the flat catalog exposes bare ids (not antigravity- prefixed).
+    assert.ok(flat.includes("gemini-3.1-pro"), "flat catalog must include gemini-3.1-pro");
+    assert.ok(flat.includes("claude-opus-4-6-thinking"), "flat catalog must include claude-opus-4-6-thinking");
+  } catch (err) {
+    assert.fail(`flat catalog check failed: ${(err as Error).message}`);
+  }
+});
+
+test("ANTIGRAVITY_MODEL_IDS_2026 is a non-empty array of string ids", () => {
+  try {
+    const ids = (ANTIGRAVITY_MODEL_IDS_2026 ?? []) as readonly string[];
+    assert.ok(Array.isArray(ids), "ANTIGRAVITY_MODEL_IDS_2026 must be an array");
+    assert.ok(ids.length > 0, "ANTIGRAVITY_MODEL_IDS_2026 must be non-empty");
+    for (const id of ids) {
+      assert.equal(typeof id, "string", "id must be string");
+    }
+  } catch (err) {
+    assert.fail(`ANTIGRAVITY_MODEL_IDS_2026 check failed: ${(err as Error).message}`);
+  }
+});
+
+test("misc constants: PROJECT_FALLBACK, OAUTH_CALLBACK_HOST/PATH, JITTER_MAX_MS", () => {
+  try {
+    assert.equal(PROJECT_FALLBACK, "rising-fact-p41fc", "PROJECT_FALLBACK must be the shared public project id");
+    assert.equal(OAUTH_CALLBACK_HOST, "127.0.0.1", "OAUTH_CALLBACK_HOST must be loopback");
+    assert.equal(OAUTH_CALLBACK_PATH, "/callback", "OAUTH_CALLBACK_PATH must be /callback");
+    assert.equal(JITTER_MAX_MS, 80, "JITTER_MAX_MS must be 80ms (anti-rate-limit window)");
+  } catch (err) {
+    assert.fail(`misc constants check failed: ${(err as Error).message}`);
+  }
+});

package/tests/providerfingerprint.test.ts

@@ -0,0 +1,149 @@
+/**
+ * @file fingerprint.test.ts
+ * @description
+ *  Tests for the pure hashing helpers exported from the fingerprint module
+ *  (`../fingerprint.js`). Confirms FNV-1a-32 determinism, format, and
+ *  distinctness; also smoke-tests `generateSessionId` and the 64-bit
+ *  variant for shape.
+ *
+ *  The fingerprint module uses `node:crypto` + `node:os` + `node:path`
+ *  only — safe to import. Does NOT touch the network.
+ *
+ *  Runs on the vitest runner with `node:assert/strict` assertions. Imports only leaf modules.
+ */
+
+import assert from "node:assert/strict";
+import { it as test } from "vitest";
+
+import {
+  fnv1a32,
+  fnv1a32Hex,
+  fnv1a64,
+  generateSessionUuid,
+  getJitterMs,
+  pickRandom,
+  secureRandom,
+} from "../fingerprint.js";
+
+test("fnv1a32Hex returns an 8-char hex string (32-bit hash)", () => {
+  try {
+    // v2.1.15 Phase B: the hex-string form is fnv1a32Hex (core.js owner);
+    // fnv1a32 is the numeric hash of the same bytes.
+    const h = fnv1a32Hex("hello");
+    assert.equal(typeof h, "string", "fnv1a32Hex must return a string");
+    assert.equal(h.length, 8, "fnv1a32Hex must return 8 hex chars (32 bits, padded)");
+    assert.ok(/^[0-9a-f]{8}$/.test(h), "fnv1a32Hex must match /^[0-9a-f]{8}$/");
+  } catch (err) {
+    assert.fail(`fnv1a32Hex format check failed: ${(err as Error).message}`);
+  }
+});
+
+test("fnv1a32 is deterministic: same input -> same output", () => {
+  try {
+    const a = fnv1a32("maene");
+    const b = fnv1a32("maene");
+    assert.equal(a, b, "same input must produce identical hash");
+  } catch (err) {
+    assert.fail(`fnv1a32 determinism check failed: ${(err as Error).message}`);
+  }
+});
+
+test("fnv1a32 is distinct: different inputs -> different outputs", () => {
+  try {
+    const a = fnv1a32("maene");
+    const b = fnv1a32("Maene"); // different case, different bytes -> different hash
+    const c = fnv1a32("other-input");
+    assert.notEqual(a, b, "case-different inputs must hash differently");
+    assert.notEqual(a, c, "different inputs must hash differently");
+  } catch (err) {
+    assert.fail(`fnv1a32 distinctness check failed: ${(err as Error).message}`);
+  }
+});
+
+test("fnv1a32 of empty string matches the FNV offset basis (FNV_OFFSET_BASIS)", () => {
+  // FNV-1a of empty input is the offset basis: 0x811c9dc5 = "811c9dc5".
+  try {
+    const h = fnv1a32Hex("");
+    assert.equal(h, "811c9dc5", "fnv1a32Hex('') must equal the FNV offset basis");
+  } catch (err) {
+    assert.fail(`fnv1a32 empty check failed: ${(err as Error).message}`);
+  }
+});
+
+test("fnv1a64 returns a 16-char hex string (BigInt-based)", () => {
+  try {
+    const h = fnv1a64("hello");
+    assert.equal(typeof h, "string");
+    assert.equal(h.length, 16, "fnv1a64 must return 16 hex chars (64 bits, padded)");
+    assert.ok(/^[0-9a-f]{16}$/.test(h), "fnv1a64 must match /^[0-9a-f]{16}$/");
+  } catch (err) {
+    assert.fail(`fnv1a64 format check failed: ${(err as Error).message}`);
+  }
+});
+
+test("fnv1a64 is deterministic for the same input", () => {
+  try {
+    const a = fnv1a64("maene");
+    const b = fnv1a64("maene");
+    assert.equal(a, b, "same input must produce identical 64-bit hash");
+    assert.notEqual(a, fnv1a64("other"), "different inputs must produce different hashes");
+  } catch (err) {
+    assert.fail(`fnv1a64 determinism check failed: ${(err as Error).message}`);
+  }
+});
+
+test("generateSessionUuid returns a deterministic pseudo-UUID (same dir -> same id)", () => {
+  try {
+    const a = generateSessionUuid("/home/z/maene-work/maene");
+    const b = generateSessionUuid("/home/z/maene-work/maene");
+    assert.equal(typeof a, "string");
+    assert.ok(a.length > 0, "session id must be non-empty");
+    assert.equal(a, b, "same dir must produce the same session id");
+    // Pseudo-UUID shape: 8-4-4-4-12-ish (the implementation slices a bit
+    // differently, but should contain dashes).
+    assert.ok(a.includes("-"), "session id must contain dashes");
+  } catch (err) {
+    assert.fail(`generateSessionId check failed: ${(err as Error).message}`);
+  }
+});
+
+test("generateSessionId differs across distinct directories", () => {
+  try {
+    const a = generateSessionUuid("/home/z/maene-work/maene");
+    const b = generateSessionUuid("/tmp/another-folder");
+    assert.notEqual(a, b, "different dirs must produce different session ids");
+  } catch (err) {
+    assert.fail(`generateSessionId distinctness check failed: ${(err as Error).message}`);
+  }
+});
+
+test("secureRandom returns a float in [0,1)", () => {
+  try {
+    const r = secureRandom();
+    assert.equal(typeof r, "number");
+    assert.ok(r >= 0 && r < 1, "secureRandom must be in [0,1)");
+  } catch (err) {
+    assert.fail(`secureRandom check failed: ${(err as Error).message}`);
+  }
+});
+
+test("pickRandom returns an element from the provided pool", () => {
+  try {
+    const pool = [1, 2, 3, 4, 5];
+    const v = pickRandom(pool);
+    assert.ok(pool.includes(v), "pickRandom must return an element of the pool");
+  } catch (err) {
+    assert.fail(`pickRandom check failed: ${(err as Error).message}`);
+  }
+});
+
+test("getJitterMs returns an integer in [min, max]", () => {
+  try {
+    const v = getJitterMs(0, 80);
+    assert.equal(typeof v, "number");
+    assert.ok(Number.isInteger(v), "getJitterMs must return an integer (Math.floor)");
+    assert.ok(v >= 0 && v <= 80, "getJitterMs(0,80) must be in [0,80]");
+  } catch (err) {
+    assert.fail(`getJitterMs check failed: ${(err as Error).message}`);
+  }
+});