@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/org/activity.test.mjs

@@ -1,134 +0,0 @@
-/**
- * activity.test.mjs — peer-activity lookup over the status-bearing directory.
- *
- * Hermetic: injects a fake org client (isEnabled + fetchDirectory) returning a
- * directory whose entries carry status snapshots. Asserts teamActivity summarizes
- * peers, whatIsDoing resolves by id/name, fail-open when disabled/unreachable, and
- * peers without a snapshot still render.
- *
- * Run: node --test lib/org/activity.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { teamActivity, whatIsDoing, _internals } from "./activity.mjs";
-
-const NOW = Date.parse("2026-06-12T12:00:00Z");
-const FRESH = "2026-06-12T11:59:50Z"; // 10s ago → online
-const STALE = "2026-06-12T11:50:00Z"; // 10m ago → not online
-
-function snap(over = {}) {
-  return {
-    state: "busy", activity: "session: inbox", subAgentsRunning: 1,
-    session: { id: "s1", taskClass: "inbox" }, machine: { loadavg: [1, 1, 1], memUsedPct: 40 },
-    claudeAuth: "ok", alerts: [], ts: FRESH, ...over,
-  };
-}
-
-function fakeClient(directory, enabled = true) {
-  return {
-    isEnabled: () => enabled,
-    fetchDirectory: async () => directory,
-  };
-}
-
-const cfg = { org: { cohort: { enabled: true, base: "https://x", token: "t" } } };
-
-// ---------------------------------------------------------------------------
-
-test("teamActivity summarizes peers from the directory", async () => {
-  const directory = [
-    { id: "robin-ai", name: "Robin", title: "Engineer", status: snap() },
-    { id: "sam-ai", name: "Sam", title: "CFO", status: snap({ state: "idle", activity: "idle", subAgentsRunning: 0, ts: FRESH }) },
-  ];
-  const team = await teamActivity({ cfg, client: fakeClient(directory), now: NOW });
-  assert.equal(team.enabled, true);
-  assert.equal(team.peers.length, 2);
-  const robin = team.peers.find((p) => p.id === "robin-ai");
-  assert.equal(robin.state, "busy");
-  assert.equal(robin.activity, "session: inbox");
-  assert.equal(robin.online, true);
-  assert.match(team.summary, /Robin/);
-  assert.match(team.summary, /Sam/);
-});
-
-test("teamActivity: a peer with no snapshot renders as unknown / no status", async () => {
-  const directory = [{ id: "mia-ai", name: "Mia", title: "Legal" }]; // no status
-  const team = await teamActivity({ cfg, client: fakeClient(directory), now: NOW });
-  const mia = team.peers[0];
-  assert.equal(mia.state, "unknown");
-  assert.equal(mia.activity, "no status reported");
-  assert.equal(mia.online, false);
-});
-
-test("teamActivity: stale snapshot → offline-ish (not online), lastSeen rendered", async () => {
-  const directory = [{ id: "old-ai", name: "Old", status: snap({ ts: STALE }) }];
-  const team = await teamActivity({ cfg, client: fakeClient(directory), now: NOW });
-  assert.equal(team.peers[0].online, false);
-  assert.match(team.peers[0].lastSeen, /m ago|h ago/);
-});
-
-test("teamActivity: a critical alert surfaces in the peer line", async () => {
-  const directory = [{ id: "down-ai", name: "Down", status: snap({ state: "error", claudeAuth: "relogin_required", alerts: [{ id: "claude_relogin_required", severity: "critical", kind: "auth", detail: "claude re-login required" }] }) }];
-  const team = await teamActivity({ cfg, client: fakeClient(directory), now: NOW });
-  assert.match(team.summary, /ALERT/);
-  assert.match(team.summary, /re-login/);
-});
-
-test("teamActivity: disabled org → fail-open empty result, never throws", async () => {
-  const team = await teamActivity({ cfg, client: fakeClient([], false), now: NOW });
-  assert.equal(team.enabled, false);
-  assert.deepEqual(team.peers, []);
-  assert.match(team.summary, /disabled/);
-});
-
-test("teamActivity: unreachable directory (throwing fetch) → empty peers, no throw", async () => {
-  const client = { isEnabled: () => true, fetchDirectory: async () => { throw new Error("ECONNREFUSED"); } };
-  let team;
-  await assert.doesNotReject(async () => { team = await teamActivity({ cfg, client, now: NOW }); });
-  assert.equal(team.enabled, true);
-  assert.deepEqual(team.peers, []);
-});
-
-test("teamActivity: excludeId omits self", async () => {
-  const directory = [
-    { id: "self-ai", name: "Self", status: snap() },
-    { id: "peer-ai", name: "Peer", status: snap() },
-  ];
-  const team = await teamActivity({ cfg, client: fakeClient(directory), now: NOW, excludeId: "self-ai" });
-  assert.deepEqual(team.peers.map((p) => p.id), ["peer-ai"]);
-});
-
-test("whatIsDoing resolves by id, then by name/title fragment", async () => {
-  const directory = [
-    { id: "robin-ai", name: "Robin", title: "Senior Engineer", status: snap({ activity: "writing tests" }) },
-  ];
-  const opts = { cfg, client: fakeClient(directory), now: NOW };
-
-  const byId = await whatIsDoing("robin-ai", opts);
-  assert.equal(byId.found, true);
-  assert.match(byId.line, /writing tests/);
-
-  const byName = await whatIsDoing("robin", opts);
-  assert.equal(byName.found, true);
-
-  const byTitle = await whatIsDoing("engineer", opts);
-  assert.equal(byTitle.found, true);
-
-  const miss = await whatIsDoing("nobody", opts);
-  assert.equal(miss.found, false);
-});
-
-test("normalizePeer is a pure mapper tolerant of shapes", () => {
-  const row = _internals.normalizePeer({ id: "X-AI", displayName: "Ex", status: snap({ subAgentsRunning: 3 }) }, { now: NOW });
-  assert.equal(row.id, "x-ai");
-  assert.equal(row.name, "Ex");
-  assert.equal(row.subAgentsRunning, 3);
-  assert.equal(row.online, true);
-  // garbage → safe defaults
-  const empty = _internals.normalizePeer(null, { now: NOW });
-  assert.equal(empty.state, "unknown");
-  assert.equal(empty.online, false);
-});

package/lib/org/approvals.test.mjs

@@ -1,216 +0,0 @@
-/**
- * approvals.test.mjs — action-class gate, sha256 payload binding, agent-mediated
- * delivery, and the bounded long-poll awaitDecision / gateActionClass blocking
- * helper. Injected fetchImpl + deliverFn; no network, no real channels.
- * Run: node --test lib/org/approvals.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { createHash } from "node:crypto";
-
-import {
-  GATED_CLASSES,
-  classesForAction,
-  classifyAction,
-  hashPayload,
-  buildApprovalAsk,
-  requestApproval,
-  awaitDecision,
-  gateActionClass,
-} from "./approvals.mjs";
-
-const BASE = "https://org.cohortapp.com";
-const CFG = { org: { cohort: { enabled: true, base: BASE, token: "tok", orgId: "alex-ai" } } };
-const OFF = { org: { cohort: { enabled: false } } };
-
-delete process.env.COHORT_API_TOKEN;
-delete process.env.COHORT_TOKEN;
-
-/** Fake fetch capturing POST bodies and returning canned res frames / read payloads. */
-function fakeFetch(responder) {
-  const calls = [];
-  const impl = async (url, init) => {
-    calls.push({ url, init, headers: (init && init.headers) || {}, body: init && init.body ? JSON.parse(init.body) : null });
-    const r = responder ? responder(url, init, calls.length - 1) : null;
-    const status = r && typeof r.status === "number" ? r.status : 200;
-    const ok = r && typeof r.ok === "boolean" ? r.ok : status >= 200 && status < 300;
-    const body = r ? r.body : { ok: true, result: null };
-    return { ok, status, headers: { get: () => undefined }, json: async () => body };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-// --- classification --------------------------------------------------------
-
-test("classesForAction: explicit class tags win; gated-by-risk derivation; non-gated empty", () => {
-  assert.deepEqual(classesForAction({ classes: ["financial"] }), ["financial"]);
-  assert.deepEqual(classesForAction({ action_class: "external" }), ["external"]);
-  // high-risk + escalation, no explicit tag, keyword "delete prod" → irreversible
-  const d = classesForAction({ risk: "high", approval: "principal_escalation", notes: "delete production data" });
-  assert.ok(d.includes("irreversible"));
-  // low-risk autonomous action is not gated
-  assert.deepEqual(classesForAction({ risk: "low", approval: "autonomous" }), []);
-});
-
-test("classifyAction: explicit classification short-circuits; unknown fails closed", () => {
-  assert.deepEqual(classifyAction({ action: "x", classification: "financial" }), { gated: true, classes: ["financial"], source: "explicit" });
-  const unknown = classifyAction({ action: "never-seen", policy: {} });
-  assert.equal(unknown.gated, true);
-  assert.equal(unknown.source, "unknown-fail-closed");
-  const seen = classifyAction({ action: "send_slack", policy: { send_slack: { risk: "low", approval: "autonomous" } } });
-  assert.equal(seen.gated, false);
-});
-
-test("GATED_CLASSES are the three action classes", () => {
-  assert.deepEqual([...GATED_CLASSES].sort(), ["external", "financial", "irreversible"]);
-});
-
-// --- payload binding -------------------------------------------------------
-
-test("hashPayload: stable sha256 over canonical JSON (key order independent)", () => {
-  const a = hashPayload({ amount: 100, to: "bob" });
-  const b = hashPayload({ to: "bob", amount: 100 });
-  assert.equal(a, b);
-  assert.equal(a, createHash("sha256").update(JSON.stringify({ amount: 100, to: "bob" })).digest("hex"));
-});
-
-// --- requestApproval: binds the hash + posts approval.request ---------------
-
-test("requestApproval: binds payload hash and POSTs approval.request with it", async () => {
-  const payload = { action: "wire", amount: 5000, to: "vendor" };
-  const expected = hashPayload(payload);
-  const f = fakeFetch((url) => {
-    if (url.endsWith("/v1/approval.request")) return { body: { ok: true, result: { id: "ap-x", status: "pending" } } };
-    return { body: { ok: true, result: null } };
-  });
-  const r = await requestApproval({
-    cfg: CFG,
-    action: "wire_funds",
-    classification: "financial",
-    payload,
-    approver: { slackId: "U123" },
-    deliverFn: async () => ({ ok: true, channel: "slack:U123", reason: "delivered" }),
-    fetchImpl: f,
-  });
-  assert.equal(r.gated, true);
-  assert.deepEqual(r.classes, ["financial"]);
-  assert.equal(r.requested, true);
-  assert.equal(r.payloadHash, expected);
-  // the request body carried the exact payload_hash ("approved exactly this")
-  const reqCall = f.calls.find((c) => c.url.endsWith("/v1/approval.request"));
-  assert.equal(reqCall.body.payload_hash, expected);
-  assert.equal(reqCall.body.kind, "spend");
-  // agent-mediated delivery fired
-  assert.equal(r.delivery.ok, true);
-});
-
-test("requestApproval: NON-gated action makes no server call and no delivery", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const r = await requestApproval({
-    cfg: CFG,
-    action: "send_slack",
-    classification: [],         // explicitly not a gated class
-    payload: { msg: "hi" },
-    fetchImpl: f,
-  });
-  assert.equal(r.gated, false);
-  assert.equal(r.requested, false);
-  assert.equal(f.calls.length, 0);
-});
-
-test("requestApproval: org disabled → gated decision + hash, but no call", async () => {
-  const r = await requestApproval({ cfg: OFF, action: "x", classification: "irreversible", payload: { a: 1 } });
-  assert.equal(r.gated, true);
-  assert.equal(r.requested, false);
-  assert.ok(r.payloadHash);
-});
-
-test("buildApprovalAsk: human-readable approve/deny affordance referencing the id", () => {
-  const ask = buildApprovalAsk({ id: "ap-1", action: "wire_funds", classes: ["financial"], requester: "alex" });
-  assert.match(ask, /Approval needed/);
-  assert.match(ask, /approve ap-1/);
-  assert.match(ask, /deny ap-1/);
-  assert.match(ask, /financial/);
-});
-
-// --- awaitDecision: resolves on approval -----------------------------------
-
-test("awaitDecision: resolves decided=true when approval.wait returns approved", async () => {
-  const f = fakeFetch(() => ({ body: { id: "ap-1", status: "approved", resolved_by_agent: "human-1" } }));
-  const dec = await awaitDecision("ap-1", 10000, { cfg: CFG, fetchImpl: f });
-  assert.equal(dec.decided, true);
-  assert.equal(dec.status, "approved");
-  assert.match(f.calls[0].url, /\/v1\/approval\.wait\?id=ap-1/);
-});
-
-test("awaitDecision: denied is decided; pending past deadline is not decided", async () => {
-  const denied = fakeFetch(() => ({ body: { id: "ap-1", status: "denied" } }));
-  const d1 = await awaitDecision("ap-1", 5000, { cfg: CFG, fetchImpl: denied });
-  assert.equal(d1.decided, true);
-  assert.equal(d1.status, "denied");
-
-  // pending forever: a fixed clock makes now() === deadline after the first poll,
-  // so the do/while runs exactly once and then exits not-decided.
-  let t = 1000;
-  const clock = () => t;
-  const pending = fakeFetch(() => { t += 100000; return { body: { id: "ap-1", status: "pending" } }; });
-  const d2 = await awaitDecision("ap-1", 5000, { cfg: CFG, fetchImpl: pending, nowMs: clock });
-  assert.equal(d2.decided, false);
-  assert.equal(d2.status, "pending");
-});
-
-// --- gateActionClass: blocks then unblocks ---------------------------------
-
-test("gateActionClass: non-gated → approved immediately, no server call", async () => {
-  const f = fakeFetch(() => ({ body: { ok: true, result: null } }));
-  const g = await gateActionClass({ cfg: CFG, action: "send_slack", classification: [], payload: {}, fetchImpl: f });
-  assert.equal(g.approved, true);
-  assert.equal(g.reason, "not-gated");
-  assert.equal(f.calls.length, 0);
-});
-
-test("gateActionClass: gated action BLOCKS then UNBLOCKS on human approval", async () => {
-  const payload = { action: "merge", repo: "core", pr: 42 };
-  const expectHash = hashPayload(payload);
-  // request → pending; wait → approved (the human approved exactly this payload).
-  const f = fakeFetch((url) => {
-    if (url.includes("/v1/approval.request")) return { body: { ok: true, result: { id: "ap-m", status: "pending" } } };
-    if (url.includes("/v1/approval.wait")) return { body: { id: "ap-m", status: "approved" } };
-    return { body: { ok: true, result: null } };
-  });
-  const g = await gateActionClass({
-    cfg: CFG,
-    action: "merge_pr",
-    classification: "irreversible",
-    payload,
-    approver: { slackId: "U1" },
-    deliverFn: async () => ({ ok: true }),
-    timeoutMs: 10000,
-    fetchImpl: f,
-  });
-  assert.equal(g.approved, true);
-  assert.equal(g.reason, "approved");
-  assert.deepEqual(g.classes, ["irreversible"]);
-  // the executor can verify it runs EXACTLY the approved payload
-  assert.equal(g.payloadHash, expectHash);
-});
-
-test("gateActionClass: denied → not approved with reason 'denied'", async () => {
-  const f = fakeFetch((url) => {
-    if (url.includes("/v1/approval.request")) return { body: { ok: true, result: { id: "ap-d", status: "pending" } } };
-    if (url.includes("/v1/approval.wait")) return { body: { id: "ap-d", status: "denied" } };
-    return { body: { ok: true, result: null } };
-  });
-  const g = await gateActionClass({ cfg: CFG, action: "x", classification: "external", payload: { a: 1 }, timeoutMs: 5000, fetchImpl: f });
-  assert.equal(g.approved, false);
-  assert.equal(g.reason, "denied");
-});
-
-test("gateActionClass: org disabled → not approved, reason org-disabled (never silently passes)", async () => {
-  const g = await gateActionClass({ cfg: OFF, action: "x", classification: "financial", payload: { a: 1 } });
-  assert.equal(g.approved, false);
-  assert.equal(g.reason, "org-disabled");
-});

package/lib/org/awareness.test.mjs

@@ -1,159 +0,0 @@
-/**
- * awareness.test.mjs — pure situational-awareness helpers over a cached org
- * context. Fixture-driven; every helper is fail-open (null / [] when data absent).
- * Run: node --test lib/org/awareness.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { ownerOf, escalateTo, whoReportsToMe, colleaguesInTeam, relevantDecisions } from "./awareness.mjs";
-import { persistOrgContext } from "./bootstrap-context.mjs";
-
-const CTX = {
-  profile: {
-    slug: "robin",
-    displayName: "Robin Vega",
-    escalationPath: "CTO, then CEO for irreversible spend",
-    supervisor: { slug: "layla", displayName: "Layla Al-Masri", role: { title: "CTO" } },
-    reportingLine: { manager: { slug: "layla", displayName: "Layla Al-Masri" } },
-    reports: [
-      { member: { slug: "kai", displayName: "Kai Tan" }, style: "SOLID" },
-      { member: { slug: "noa", displayName: "Noa Levi" }, style: "DOTTED" },
-    ],
-  },
-  chart: {
-    nodes: [
-      { slug: "robin", displayName: "Robin Vega", role: { title: "VP Eng" }, team: { slug: "platform", name: "Platform Engineering", shortLabel: "PLT" } },
-      { slug: "kai", displayName: "Kai Tan", role: { title: "Staff Eng" }, team: { slug: "platform", name: "Platform Engineering", shortLabel: "PLT" } },
-      { slug: "mara", displayName: "Mara Cole", role: { title: "AE" }, team: { slug: "revenue", name: "Revenue", shortLabel: "REV" } },
-    ],
-    edges: [
-      { kind: "reporting", from: "robin", to: "kai", type: "SOLID" },
-      { kind: "reporting", from: "robin", to: "noa", type: "DOTTED" },
-      { kind: "reporting", from: "layla", to: "robin", type: "SOLID" },
-    ],
-  },
-  relationships: {
-    member: { slug: "robin" },
-    reportingLine: { manager: { slug: "layla", displayName: "Layla Al-Masri" } },
-    reports: [{ member: { slug: "kai", displayName: "Kai Tan" }, style: "SOLID" }],
-    governance: [],
-  },
-  strategy: {
-    streams: [
-      { code: "S1", name: "Platform Reliability", mission: "Keep the lights on", raci: [
-        { role: "Accountable", member: { slug: "robin", displayName: "Robin Vega" } },
-        { role: "Responsible", member: { slug: "kai", displayName: "Kai Tan" } },
-      ] },
-      { code: "S2", name: "Revenue Growth", mission: "Grow ARR", raci: [
-        { role: "Accountable", member: { slug: "mara", displayName: "Mara Cole" } },
-      ] },
-    ],
-  },
-  hierarchy: { members: [{ slug: "robin" }, { slug: "kai" }], reporting: [{ from: "layla", to: "robin" }] },
-  decisions: [
-    { id: "D1", title: "Adopt Postgres for the ledger", rationale: "ACID + maturity", scope: "data", status: "adopted" },
-    { id: "D2", title: "Standardise on Slack", rationale: "comms", scope: "ops", tags: ["comms"] },
-  ],
-  policy: { bundleId: "p1" },
-  board: [],
-};
-
-// --- ownerOf ----------------------------------------------------------------
-
-test("ownerOf: matches a strategy stream and returns its Accountable owner", () => {
-  const o = ownerOf(CTX, "reliability");
-  assert.equal(o.owner.slug, "robin");
-  assert.equal(o.role, "Accountable");
-  assert.equal(o.stream.code, "S1");
-  const rev = ownerOf(CTX, "Revenue");
-  assert.equal(rev.owner.slug, "mara");
-});
-
-test("ownerOf: no match / no strategy / blank scope → null", () => {
-  assert.equal(ownerOf(CTX, "nonexistent-scope"), null);
-  assert.equal(ownerOf({}, "reliability"), null);
-  assert.equal(ownerOf(CTX, ""), null);
-  assert.equal(ownerOf(null, "x"), null);
-});
-
-// --- escalateTo -------------------------------------------------------------
-
-test("escalateTo: surfaces escalationPath + supervisor manager", () => {
-  const e = escalateTo(CTX);
-  assert.match(e.escalationPath, /CTO/);
-  assert.equal(e.manager.slug, "layla");
-});
-
-test("escalateTo: falls back to reporting-line manager; null when nothing", () => {
-  const e = escalateTo({ profile: { reportingLine: { manager: { slug: "boss", displayName: "Boss" } } } });
-  assert.equal(e.escalationPath, null);
-  assert.equal(e.manager.slug, "boss");
-  assert.equal(escalateTo({}), null);
-  assert.equal(escalateTo(null), null);
-});
-
-// --- whoReportsToMe ---------------------------------------------------------
-
-test("whoReportsToMe: prefers the self profile's reports", () => {
-  const reports = whoReportsToMe(CTX, "robin");
-  assert.deepEqual(reports.map((r) => r.slug).sort(), ["kai", "noa"]);
-  assert.equal(reports.find((r) => r.slug === "noa").style, "DOTTED");
-});
-
-test("whoReportsToMe: derives from chart edges for a non-self manager", () => {
-  // Querying for "layla" (not the profile member) → derive from chart edges.
-  const reports = whoReportsToMe(CTX, "layla");
-  assert.deepEqual(reports.map((r) => r.slug), ["robin"]);
-});
-
-test("whoReportsToMe: no data → []", () => {
-  assert.deepEqual(whoReportsToMe({}, "x"), []);
-  assert.deepEqual(whoReportsToMe(null), []);
-});
-
-// --- colleaguesInTeam -------------------------------------------------------
-
-test("colleaguesInTeam: filters chart nodes by team slug/name/shortLabel", () => {
-  assert.deepEqual(colleaguesInTeam(CTX, "platform").map((m) => m.slug).sort(), ["kai", "robin"]);
-  assert.deepEqual(colleaguesInTeam(CTX, "Platform Engineering").map((m) => m.slug).sort(), ["kai", "robin"]);
-  assert.deepEqual(colleaguesInTeam(CTX, "REV").map((m) => m.slug), ["mara"]);
-});
-
-test("colleaguesInTeam: falls back to hierarchy members; [] when absent", () => {
-  const ctx = { hierarchy: { members: [{ slug: "x", displayName: "X", team: { slug: "ops", name: "Ops" } }] } };
-  assert.deepEqual(colleaguesInTeam(ctx, "ops").map((m) => m.slug), ["x"]);
-  assert.deepEqual(colleaguesInTeam(CTX, "no-such-team"), []);
-  assert.deepEqual(colleaguesInTeam({}, "platform"), []);
-  assert.deepEqual(colleaguesInTeam(CTX, ""), []);
-});
-
-// --- relevantDecisions ------------------------------------------------------
-
-test("relevantDecisions: filters by topic across title/rationale/scope/tags", () => {
-  assert.deepEqual(relevantDecisions(CTX, "postgres").map((d) => d.id), ["D1"]);
-  assert.deepEqual(relevantDecisions(CTX, "comms").map((d) => d.id), ["D2"]);
-  assert.deepEqual(relevantDecisions(CTX, "data").map((d) => d.id), ["D1"]);
-});
-
-test("relevantDecisions: blank topic returns all; no data → []", () => {
-  assert.equal(relevantDecisions(CTX, "").length, 2);
-  assert.deepEqual(relevantDecisions(CTX, "zzz"), []);
-  assert.deepEqual(relevantDecisions({}, "x"), []);
-});
-
-// --- loads from disk (agentRoot string arg) ---------------------------------
-
-test("awareness helpers accept an agentRoot string (loads config/org-context.json)", () => {
-  const root = mkdtempSync(join(tmpdir(), "maestro-aware-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  persistOrgContext(root, CTX);
-  assert.equal(ownerOf(root, "reliability").owner.slug, "robin");
-  assert.deepEqual(whoReportsToMe(root, "robin").map((r) => r.slug).sort(), ["kai", "noa"]);
-  assert.equal(escalateTo(root).manager.slug, "layla");
-});

package/lib/org/board-mine-cache.test.mjs

@@ -1,53 +0,0 @@
-/**
- * board-mine-cache.test.mjs — the pure half of the daemon's 5-minute
- * state/org/board-mine.json cache.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { shouldRefresh, render, renderRefresh, cacheTs, REFRESH_INTERVAL_MS, BOARD_MINE_REL } from "./board-mine-cache.mjs";
-
-const NOW = Date.parse("2026-09-08T12:00:00Z");
-
-test("shouldRefresh: never written → yes; younger than 5 min → no; 5 min or older → yes; a future ts → yes", () => {
-  assert.equal(shouldRefresh(null, NOW), true);
-  assert.equal(shouldRefresh(undefined, NOW), true);
-  assert.equal(shouldRefresh("garbage", NOW), true);
-  assert.equal(shouldRefresh("2026-09-08T11:56:00Z", NOW), false);
-  assert.equal(shouldRefresh(NOW - REFRESH_INTERVAL_MS + 1, NOW), false);
-  assert.equal(shouldRefresh("2026-09-08T11:55:00Z", NOW), true);
-  assert.equal(shouldRefresh(NOW - REFRESH_INTERVAL_MS, NOW), true);
-  assert.equal(shouldRefresh("2026-09-08T12:30:00Z", NOW), true, "a clock that went backwards must not freeze the cache");
-  assert.equal(shouldRefresh("2026-09-08T11:59:30Z", NOW, 10_000), true, "interval is a parameter");
-  assert.equal(REFRESH_INTERVAL_MS, 300_000);
-  assert.equal(BOARD_MINE_REL, "state/org/board-mine.json");
-});
-
-test("render: {ts, items} with only object items kept; a non-array answer renders as empty", () => {
-  const doc = render([{ itemId: "i1", title: "Do X" }, null, "junk", [1], { itemId: "i2" }], NOW);
-  assert.deepEqual(doc, { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i1", title: "Do X" }, { itemId: "i2" }] });
-  assert.deepEqual(render(undefined, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [] });
-  assert.deepEqual(render({ items: [{ itemId: "x" }] }, NOW).items, [], "an object is not the items array (listMine already unwraps)");
-});
-
-test("cacheTs reads ts, tolerates the earlier fetchedAt spelling, and is null for a bare array or junk", () => {
-  assert.equal(cacheTs({ ts: "2026-09-08T11:59:00Z", items: [] }), "2026-09-08T11:59:00Z");
-  assert.equal(cacheTs({ fetchedAt: "2026-09-08T11:59:00Z", items: [] }), "2026-09-08T11:59:00Z");
-  assert.equal(cacheTs([{ itemId: "x" }]), null);
-  assert.equal(cacheTs(null), null);
-  assert.equal(cacheTs({ items: [] }), null);
-});
-
-test("renderRefresh: a successful read renders fresh items; a FAILED read keeps the previous items, marks stale and remembers when they were fetched", () => {
-  const prev = { ts: "2026-09-08T11:55:00.000Z", items: [{ itemId: "i1" }] };
-  assert.deepEqual(renderRefresh({ ok: true, items: [{ itemId: "i2" }] }, prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i2" }] });
-  assert.deepEqual(renderRefresh([{ itemId: "i3" }], prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i3" }] }, "a bare array (the old listMine shape) is a success");
-  assert.deepEqual(renderRefresh({ ok: true, items: [] }, prev, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [] }, "an empty board is a real answer, not a failure");
-  const failed = renderRefresh({ ok: false, items: [], error: "http 503" }, prev, NOW);
-  assert.deepEqual(failed, { ts: "2026-09-08T12:00:00.000Z", items: [{ itemId: "i1" }], stale: true, itemsAt: "2026-09-08T11:55:00.000Z", error: "http 503" });
-  const failedAgain = renderRefresh({ ok: false, items: [] }, failed, NOW + 300_000);
-  assert.equal(failedAgain.itemsAt, "2026-09-08T11:55:00.000Z", "a second failure keeps the ORIGINAL fetch time, not the last stale write");
-  assert.deepEqual(failedAgain.items, [{ itemId: "i1" }]);
-  assert.deepEqual(renderRefresh({ ok: false, items: [] }, null, NOW), { ts: "2026-09-08T12:00:00.000Z", items: [], stale: true, itemsAt: null }, "nothing previous → empty and stale");
-  assert.deepEqual(renderRefresh(null, prev, NOW).items, [{ itemId: "i1" }], "a null result is a failure");
-});