@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/scripts/daemon/lib/session-router.test.mjs

@@ -1,554 +0,0 @@
-/**
- * session-router.test.mjs — node:test coverage for the session router.
- *
- * No real subprocess spawns, no real disk writes outside os.tmpdir().
- * Each test creates its own registry path under tmpdir and cleans up.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-import {
-  routingKey,
-  createRouter,
-  createRouterSync,
-  decideRoute,
-  routerItemFromDaemonItem,
-  claimSession,
-  releaseSession,
-  isSessionInFlight,
-  _resetInFlightForTests,
-} from "./session-router.mjs";
-
-function tmpRegistryPath(suffix = "") {
-  const name = `session-router-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${suffix}.json`;
-  return join(tmpdir(), name);
-}
-
-async function safeUnlink(path) {
-  try {
-    await fsp.unlink(path);
-  } catch {
-    /* ignore */
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 1. routingKey — one assertion per row of memo §4.2.
-// ---------------------------------------------------------------------------
-
-test("routingKey — slack threaded message", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "C0123ABC",
-    thread_ts: "1777283277.000100",
-  });
-  assert.equal(k, "slack:C0123ABC:1777283277.000100");
-});
-
-test("routingKey — slack DM (no thread)", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "D099N1JGKRQ",
-  });
-  assert.equal(k, "slack:D099N1JGKRQ");
-});
-
-test("routingKey — slack channel non-DM (no thread)", () => {
-  const k = routingKey({
-    source: "slack",
-    channel: "C0123ABC",
-    ts: "1777283277.000200",
-  });
-  assert.equal(k, "slack:C0123ABC:1777283277.000200");
-});
-
-test("routingKey — gmail", () => {
-  const k = routingKey({ source: "gmail", thread_id: "1818abc" });
-  assert.equal(k, "gmail:1818abc");
-});
-
-test("routingKey — calendar", () => {
-  const k = routingKey({ source: "calendar", event_id: "evt_42" });
-  assert.equal(k, "calendar:evt_42");
-});
-
-test("routingKey — internal queue item", () => {
-  const k = routingKey({ source: "internal", id: "ar-20260427-001" });
-  assert.equal(k, "internal:ar-20260427-001");
-});
-
-test("routingKey — backlog with topic_slug", () => {
-  const k = routingKey({
-    source: "backlog",
-    topic_slug: "session-router-step2",
-    id: "as-20260427-x",
-  });
-  assert.equal(k, "backlog:session-router-step2");
-});
-
-test("routingKey — backlog without topic_slug falls back to internal:<id>", () => {
-  const k = routingKey({ source: "backlog", id: "as-20260427-fallback" });
-  assert.equal(k, "internal:as-20260427-fallback");
-});
-
-// ---------------------------------------------------------------------------
-// 2. route() — missing key returns EPHEMERAL.
-// ---------------------------------------------------------------------------
-
-test("route — missing key returns EPHEMERAL", async (t) => {
-  const path = tmpRegistryPath("-missing");
-  t.after(() => safeUnlink(path));
-  const router = await createRouter({ registryPath: path });
-  const decision = router.route("slack:CNEVERSEEN:0");
-  assert.deepEqual(decision, { decision: "EPHEMERAL", resumeId: null });
-});
-
-// ---------------------------------------------------------------------------
-// 3. route() — past-TTL entry returns EPHEMERAL_REPLACE.
-// ---------------------------------------------------------------------------
-
-test("route — past-TTL entry returns EPHEMERAL_REPLACE", async (t) => {
-  const path = tmpRegistryPath("-ttl");
-  t.after(() => safeUnlink(path));
-  let clock = 1_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 60,
-    now: () => clock,
-  });
-  await router.touch("slack:DAAA:1", { claudeSessionId: "cli-1", model: "sonnet" });
-  // Advance clock past TTL.
-  clock += 61 * 1000;
-  const decision = router.route("slack:DAAA:1");
-  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
-  assert.equal(decision.resumeId, null);
-});
-
-// ---------------------------------------------------------------------------
-// 4. route() — live, fresh, exit_code 0 returns RESUME with the stored id.
-// ---------------------------------------------------------------------------
-
-test("route — live fresh entry returns RESUME with stored claude_session_id", async (t) => {
-  const path = tmpRegistryPath("-resume");
-  t.after(() => safeUnlink(path));
-  let clock = 2_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 600,
-    now: () => clock,
-  });
-  await router.touch("slack:DRESUME:1", {
-    claudeSessionId: "cli-resume-xyz",
-    model: "sonnet",
-  });
-  clock += 30_000; // 30s — well within TTL.
-  const decision = router.route("slack:DRESUME:1");
-  assert.equal(decision.decision, "RESUME");
-  assert.equal(decision.resumeId, "cli-resume-xyz");
-});
-
-// ---------------------------------------------------------------------------
-// 5. route() — non-zero last_exit_code returns EPHEMERAL_REPLACE.
-// ---------------------------------------------------------------------------
-
-test("route — non-zero last_exit_code returns EPHEMERAL_REPLACE", async (t) => {
-  const path = tmpRegistryPath("-exitcode");
-  t.after(() => safeUnlink(path));
-  let clock = 3_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 600,
-    now: () => clock,
-  });
-  await router.touch("slack:DEXIT:1", {
-    claudeSessionId: "cli-exit",
-    model: "sonnet",
-  });
-  await router.recordExit("slack:DEXIT:1", 1);
-  clock += 5_000;
-  const decision = router.route("slack:DEXIT:1");
-  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
-  assert.equal(decision.resumeId, null);
-});
-
-// ---------------------------------------------------------------------------
-// 6. touch() — LRU cap enforced; oldest entry evicted on overflow.
-// ---------------------------------------------------------------------------
-
-test("touch — LRU cap evicts oldest when at capacity", async (t) => {
-  const path = tmpRegistryPath("-lru");
-  t.after(() => safeUnlink(path));
-  let clock = 4_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    maxLiveSessions: 3,
-    now: () => clock,
-  });
-  for (let i = 1; i <= 3; i++) {
-    await router.touch(`slack:DLRU${i}`, {
-      claudeSessionId: `cli-${i}`,
-      model: "sonnet",
-    });
-    clock += 1000;
-  }
-  // At cap. Add a fourth.
-  await router.touch("slack:DLRU4", {
-    claudeSessionId: "cli-4",
-    model: "sonnet",
-  });
-  const snap = router._readForTests();
-  assert.equal(snap.lru.length, 3, "lru should still hold 3 keys");
-  assert.ok(!("slack:DLRU1" in snap.sessions), "oldest (DLRU1) evicted");
-  assert.ok("slack:DLRU2" in snap.sessions);
-  assert.ok("slack:DLRU3" in snap.sessions);
-  assert.ok("slack:DLRU4" in snap.sessions);
-});
-
-// ---------------------------------------------------------------------------
-// 7. recordExit() — non-zero code flips status to "killed".
-// ---------------------------------------------------------------------------
-
-test("recordExit — non-zero code flips status to killed", async (t) => {
-  const path = tmpRegistryPath("-killed");
-  t.after(() => safeUnlink(path));
-  const router = await createRouter({ registryPath: path });
-  await router.touch("slack:DKILL:1", {
-    claudeSessionId: "cli-kill",
-    model: "sonnet",
-  });
-  await router.recordExit("slack:DKILL:1", 137);
-  const snap = router._readForTests();
-  assert.equal(snap.sessions["slack:DKILL:1"].status, "killed");
-  assert.equal(snap.sessions["slack:DKILL:1"].last_exit_code, 137);
-});
-
-// ---------------------------------------------------------------------------
-// 8. evictExpired() — removes only stale entries, returns count.
-// ---------------------------------------------------------------------------
-
-test("evictExpired — removes only stale entries and returns count", async (t) => {
-  const path = tmpRegistryPath("-evict");
-  t.after(() => safeUnlink(path));
-  let clock = 5_000_000_000_000;
-  const router = await createRouter({
-    registryPath: path,
-    ttlSeconds: 60,
-    now: () => clock,
-  });
-  await router.touch("slack:DEVICT:OLD", {
-    claudeSessionId: "cli-old",
-    model: "sonnet",
-  });
-  // Advance past TTL.
-  clock += 120_000;
-  await router.touch("slack:DEVICT:NEW", {
-    claudeSessionId: "cli-new",
-    model: "sonnet",
-  });
-  // Now: OLD is stale (last_used_at = clock - 120s, ttl = 60s),
-  //      NEW is fresh.
-  const evicted = await router.evictExpired();
-  assert.equal(evicted, 1, "one entry should have been evicted");
-  const snap = router._readForTests();
-  assert.ok(!("slack:DEVICT:OLD" in snap.sessions));
-  assert.ok("slack:DEVICT:NEW" in snap.sessions);
-});
-
-// ---------------------------------------------------------------------------
-// 9. Registry round-trip — touch two keys, re-create router, state restored.
-// ---------------------------------------------------------------------------
-
-test("registry round-trip — second router instance reads persisted state", async (t) => {
-  const path = tmpRegistryPath("-roundtrip");
-  t.after(() => safeUnlink(path));
-  let clock = 6_000_000_000_000;
-
-  const r1 = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    now: () => clock,
-  });
-  await r1.touch("gmail:thread-A", {
-    claudeSessionId: "cli-A",
-    model: "sonnet",
-  });
-  clock += 1000;
-  await r1.touch("gmail:thread-B", {
-    claudeSessionId: "cli-B",
-    model: "opus",
-  });
-
-  // Fresh router instance against the same path.
-  const r2 = await createRouter({
-    registryPath: path,
-    ttlSeconds: 3600,
-    now: () => clock,
-  });
-  const snap = r2._readForTests();
-  assert.equal(Object.keys(snap.sessions).length, 2);
-  assert.equal(snap.sessions["gmail:thread-A"].claude_session_id, "cli-A");
-  assert.equal(snap.sessions["gmail:thread-B"].claude_session_id, "cli-B");
-  assert.equal(snap.sessions["gmail:thread-B"].model, "opus");
-  // Both keys present in the LRU array.
-  assert.ok(snap.lru.includes("gmail:thread-A"));
-  assert.ok(snap.lru.includes("gmail:thread-B"));
-
-  // route() should return RESUME for the persisted entry.
-  const dec = r2.route("gmail:thread-A");
-  assert.equal(dec.decision, "RESUME");
-  assert.equal(dec.resumeId, "cli-A");
-});
-
-// ---------------------------------------------------------------------------
-// 4. Conversation-shaped services (design §3 R10 / §5.6).
-//
-// `cohort` fell through to the throw, so every turn in the agent's own
-// workspace was keyed by nothing and spawned cold. telegram / whatsapp /
-// orgmail were in the same position.
-// ---------------------------------------------------------------------------
-
-test("routingKey — cohort channel with no thread is keyed by the room", () => {
-  assert.equal(routingKey({ source: "cohort", channel: "chan-abc" }), "cohort:chan-abc");
-});
-
-test("routingKey — cohort thread narrows the key, so two threads never share a session", () => {
-  const a = routingKey({ source: "cohort", channel: "chan-abc", thread_root_id: "msg-1" });
-  const b = routingKey({ source: "cohort", channel: "chan-abc", thread_root_id: "msg-2" });
-  assert.equal(a, "cohort:chan-abc:msg-1");
-  assert.notEqual(a, b);
-});
-
-test("routingKey — telegram / whatsapp / orgmail share the shape", () => {
-  assert.equal(routingKey({ source: "telegram", channel: "12345" }), "telegram:12345");
-  assert.equal(routingKey({ source: "whatsapp", channel: "4471@s.whatsapp.net" }), "whatsapp:4471@s.whatsapp.net");
-  assert.equal(routingKey({ source: "orgmail", channel: "mb-1", thread_id: "t-9" }), "orgmail:mb-1:t-9");
-});
-
-test("routingKey — a cohort item with no channel throws rather than colliding on a blank key", () => {
-  assert.throws(() => routingKey({ source: "cohort" }), /missing channel/);
-});
-
-// ---------------------------------------------------------------------------
-// 5. routerItemFromDaemonItem — ONE translation, both callers.
-// ---------------------------------------------------------------------------
-
-test("routerItemFromDaemonItem — a cohort item keys on channel_id, never the label", () => {
-  const out = routerItemFromDaemonItem({
-    service: "cohort",
-    channel: "task/Ship the thing",   // the DISPLAY label
-    channel_id: "chan-real",
-    thread_id: "root-7",
-  });
-  assert.deepEqual(out, { source: "cohort", channel: "chan-real", thread_root_id: "root-7" });
-  assert.equal(routingKey(out), "cohort:chan-real:root-7");
-});
-
-test("routerItemFromDaemonItem — a cohort item with only a label has no session to continue", () => {
-  assert.equal(routerItemFromDaemonItem({ service: "cohort", channel: "doc/Pricing memo" }), null);
-});
-
-test("routerItemFromDaemonItem — slack / gmail / calendar are unchanged", () => {
-  assert.deepEqual(routerItemFromDaemonItem({ service: "slack", channel: "C1", thread_id: "1.2", ts: "3.4" }),
-    { source: "slack", channel: "C1", thread_ts: "1.2", ts: "3.4" });
-  assert.deepEqual(routerItemFromDaemonItem({ service: "gmail", thread_id: "t1" }), { source: "gmail", thread_id: "t1" });
-  assert.deepEqual(routerItemFromDaemonItem({ service: "calendar", event_id: "e1" }), { source: "calendar", event_id: "e1" });
-});
-
-test("routerItemFromDaemonItem — an unknown service is not keyed", () => {
-  assert.equal(routerItemFromDaemonItem({ service: "carrier-pigeon", channel_id: "x" }), null);
-  assert.equal(routerItemFromDaemonItem(null), null);
-});
-
-// ---------------------------------------------------------------------------
-// 6. decideRoute — the pure rule both IO shells share.
-// ---------------------------------------------------------------------------
-
-test("decideRoute — the memo §4.4 table", () => {
-  const live = { claude_session_id: "S1", last_used_at: 1000, status: "live", last_exit_code: 0 };
-  assert.deepEqual(decideRoute(undefined, { now: 1000, ttlSeconds: 30 }), { decision: "EPHEMERAL", resumeId: null });
-  assert.deepEqual(decideRoute(live, { now: 1000, ttlSeconds: 30 }), { decision: "RESUME", resumeId: "S1" });
-  assert.equal(decideRoute(live, { now: 1000 + 31_000, ttlSeconds: 30 }).decision, "EPHEMERAL_REPLACE");
-  assert.equal(decideRoute({ ...live, status: "killed" }, { now: 1000, ttlSeconds: 30 }).decision, "EPHEMERAL_REPLACE");
-  assert.equal(decideRoute({ ...live, last_exit_code: 1 }, { now: 1000, ttlSeconds: 30 }).decision, "EPHEMERAL_REPLACE");
-});
-
-// ---------------------------------------------------------------------------
-// 7. createRouterSync — the dispatcher's face of the SAME registry.
-// ---------------------------------------------------------------------------
-
-test("createRouterSync — a cold key is EPHEMERAL; a touched key then RESUMEs", async () => {
-  const path = tmpRegistryPath("-sync");
-  try {
-    const r = createRouterSync({ registryPath: path });
-    assert.equal(r.route("cohort:c1").decision, "EPHEMERAL");
-    r.touch("cohort:c1", { claudeSessionId: "S-live", daemonSessionId: "s-1", model: "sonnet" });
-    const again = r.route("cohort:c1");
-    assert.equal(again.decision, "RESUME");
-    assert.equal(again.resumeId, "S-live");
-  } finally {
-    await safeUnlink(path);
-  }
-});
-
-test("createRouterSync — the SYNC and ASYNC routers read the same file", async () => {
-  const path = tmpRegistryPath("-shared");
-  try {
-    const sync = createRouterSync({ registryPath: path });
-    sync.touch("cohort:c2", { claudeSessionId: "S-shared" });
-    const async_ = await createRouter({ registryPath: path });
-    const d = async_.route("cohort:c2");
-    assert.equal(d.decision, "RESUME");
-    assert.equal(d.resumeId, "S-shared", "one registry, or the dispatcher and the responder key two sessions per room");
-  } finally {
-    await safeUnlink(path);
-  }
-});
-
-test("createRouterSync — a non-zero exit stops the next turn resuming into a broken session", async () => {
-  const path = tmpRegistryPath("-exit");
-  try {
-    const r = createRouterSync({ registryPath: path });
-    r.touch("cohort:c3", { claudeSessionId: "S-bad" });
-    r.recordExit("cohort:c3", 1);
-    assert.equal(r.route("cohort:c3").decision, "EPHEMERAL_REPLACE");
-  } finally {
-    await safeUnlink(path);
-  }
-});
-
-test("createRouterSync — an unreadable registry routes cold rather than throwing", () => {
-  const r = createRouterSync({ registryPath: join(tmpdir(), "definitely", "not", "a", "path", "registry.json") });
-  assert.equal(r.route("cohort:c4").decision, "EPHEMERAL");
-  assert.equal(r.recordExit("cohort:c4", 0), false);
-});
-
-test("createRouterSync — a corrupt registry routes cold rather than throwing", async () => {
-  const path = tmpRegistryPath("-corrupt");
-  try {
-    await fsp.writeFile(path, "{ this is not json", "utf-8");
-    const r = createRouterSync({ registryPath: path });
-    assert.equal(r.route("cohort:c5").decision, "EPHEMERAL");
-  } finally {
-    await safeUnlink(path);
-  }
-});
-
-test("createRouterSync — the LRU cap is enforced", async () => {
-  const path = tmpRegistryPath("-lru");
-  try {
-    const r = createRouterSync({ registryPath: path, maxLiveSessions: 2 });
-    r.touch("cohort:a", { claudeSessionId: "A" });
-    r.touch("cohort:b", { claudeSessionId: "B" });
-    r.touch("cohort:c", { claudeSessionId: "C" });
-    assert.equal(r.route("cohort:a").decision, "EPHEMERAL", "oldest evicted");
-    assert.equal(r.route("cohort:c").decision, "RESUME");
-  } finally {
-    await safeUnlink(path);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// TWO SHELLS, ONE FILE
-//
-// The dispatcher writes this registry through createRouterSync and the
-// responder through createRouter. The async shell used to read the file once
-// and keep the object for the daemon's life, so its `touch()` wrote a stale
-// snapshot back — and the LRU sweep at the end of `touch()` deletes every key
-// absent from that snapshot, which means one ordinary quick reply erased the
-// dispatcher's live rows. The converse was worse than a lost row: the cached
-// shell could answer RESUME for a session the other shell had already recorded
-// as killed, handing a 60-second --print reply the transcript of a long
-// agentic session.
-// ---------------------------------------------------------------------------
-
-test("an async touch() does not delete rows the SYNC shell wrote", async (t) => {
-  const path = tmpRegistryPath("-two-shells");
-  t.after(() => safeUnlink(path));
-
-  const async_ = await createRouter({ registryPath: path });
-  const sync = createRouterSync({ registryPath: path });
-
-  await async_.touch("slack:D1", { claudeSessionId: "S-QUICK" });
-  sync.touch("cohort:C-eng", { claudeSessionId: "S-LONG" });
-
-  // One perfectly ordinary quick reply on the other key.
-  await async_.touch("slack:D1", { claudeSessionId: "S-QUICK" });
-
-  const onDisk = JSON.parse(await fsp.readFile(path, "utf-8"));
-  assert.deepEqual(
-    Object.keys(onDisk.sessions).sort(),
-    ["cohort:C-eng", "slack:D1"],
-    "the async shell must merge onto what is on disk, not overwrite it with a snapshot",
-  );
-  assert.equal(sync.route("cohort:C-eng").decision, "RESUME", "§5.6 continuity survives an interleaved quick reply");
-});
-
-test("an async route() sees an exit the SYNC shell recorded — no resume into a killed session", async (t) => {
-  const path = tmpRegistryPath("-two-shells-exit");
-  t.after(() => safeUnlink(path));
-
-  const async_ = await createRouter({ registryPath: path });
-  const sync = createRouterSync({ registryPath: path });
-
-  sync.touch("cohort:C-eng", { claudeSessionId: "S-LONG" });
-  assert.equal(async_.route("cohort:C-eng").decision, "RESUME", "a live row resumes from either shell");
-
-  sync.recordExit("cohort:C-eng", 137);
-  const after = async_.route("cohort:C-eng");
-  assert.equal(after.decision, "EPHEMERAL_REPLACE", "a killed session must not be resumed by the other shell");
-  assert.equal(after.resumeId, null);
-});
-
-test("an async recordExit() is visible to the sync shell, and vice versa", async (t) => {
-  const path = tmpRegistryPath("-two-shells-sym");
-  t.after(() => safeUnlink(path));
-
-  const async_ = await createRouter({ registryPath: path });
-  const sync = createRouterSync({ registryPath: path });
-
-  sync.touch("cohort:C-x", { claudeSessionId: "S-1" });
-  await async_.recordExit("cohort:C-x", 1);
-  assert.equal(sync.route("cohort:C-x").decision, "EPHEMERAL_REPLACE");
-});
-
-
-// ---------------------------------------------------------------------------
-// the in-flight lease — one CLI process per session id
-// ---------------------------------------------------------------------------
-
-test("claimSession is exclusive, and releaseSession is idempotent", () => {
-  _resetInFlightForTests();
-  assert.equal(claimSession("cohort:C-eng"), true);
-  assert.equal(claimSession("cohort:C-eng"), false, "a second claim on a live key is refused");
-  assert.equal(isSessionInFlight("cohort:C-eng"), true);
-  releaseSession("cohort:C-eng");
-  releaseSession("cohort:C-eng");
-  assert.equal(isSessionInFlight("cohort:C-eng"), false);
-  assert.equal(claimSession("cohort:C-eng"), true);
-  _resetInFlightForTests();
-  assert.equal(claimSession(""), false, "an empty key is not a key");
-});
-
-test("neither shell resumes a key that already has a process on it", async (t) => {
-  const path = tmpRegistryPath("-inflight");
-  t.after(() => { _resetInFlightForTests(); return safeUnlink(path); });
-  _resetInFlightForTests();
-
-  const sync = createRouterSync({ registryPath: path });
-  const async_ = await createRouter({ registryPath: path });
-  sync.touch("cohort:C-busy", { claudeSessionId: "S-LIVE" });
-
-  assert.equal(sync.route("cohort:C-busy").decision, "RESUME", "idle: the row is resumable");
-  claimSession("cohort:C-busy");
-  assert.deepEqual(sync.route("cohort:C-busy"), { decision: "EPHEMERAL", resumeId: null });
-  assert.deepEqual(async_.route("cohort:C-busy"), { decision: "EPHEMERAL", resumeId: null },
-    "a 60-second quick reply must not be handed a running agentic session's transcript");
-
-  releaseSession("cohort:C-busy");
-  assert.equal(sync.route("cohort:C-busy").decision, "RESUME", "continuity returns when the room goes quiet");
-});