@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.1

package/packages/server/src/__tests__/has-openspec-dir.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Unit tests for `hasOpenSpecDir` — synchronous spawn-free probe used by
+ * the WS on-connect snapshot to disambiguate "no openspec here" from
+ * "openspec here, polling pending".
+ *
+ * See change: fix-cold-boot-openspec-protocol.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { hasOpenSpecDir } from "../directory-service.js";
+
+describe("hasOpenSpecDir", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "has-openspec-dir-"));
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("returns true when <cwd>/openspec/changes exists as a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec", "changes"), { recursive: true });
+    expect(hasOpenSpecDir(tmp)).toBe(true);
+  });
+
+  it("returns false when openspec dir is absent (ENOENT)", () => {
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec exists but openspec/changes does not", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec/changes is a regular file, not a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    fs.writeFileSync(path.join(tmp, "openspec", "changes"), "not a dir");
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns false when openspec/changes is a symlink to a non-directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    const target = path.join(tmp, "target.txt");
+    fs.writeFileSync(target, "x");
+    fs.symlinkSync(target, path.join(tmp, "openspec", "changes"));
+    expect(hasOpenSpecDir(tmp)).toBe(false);
+  });
+
+  it("returns true when openspec/changes is a symlink to a directory", () => {
+    fs.mkdirSync(path.join(tmp, "openspec"));
+    const target = path.join(tmp, "target-dir");
+    fs.mkdirSync(target);
+    fs.symlinkSync(target, path.join(tmp, "openspec", "changes"));
+    expect(hasOpenSpecDir(tmp)).toBe(true);
+  });
+
+  it("returns false for a non-existent cwd", () => {
+    expect(hasOpenSpecDir("/this/path/does/not/exist/__nope__")).toBe(false);
+  });
+});

package/packages/server/src/__tests__/headless-pid-registry.test.ts

@@ -231,3 +231,86 @@ describe("HeadlessPidRegistry orphan cleanup", () => {
     killSpy.mockRestore();
   });
 });
+
+// See change: spawn-correlation-token — three-tier linking.
+describe("HeadlessPidRegistry: three-tier link", () => {
+  it("register stores the spawnToken when provided", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(100, "/p", mockProcess(), "tok_abc");
+    // No public accessor for the entry, but linkByToken proves storage.
+    expect(registry.linkByToken("tok_abc", "S1")).toBe(true);
+    expect(registry.getPid("S1")).toBe(100);
+  });
+
+  it("linkByToken returns false when token does not match", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(100, "/p", mockProcess(), "tok_abc");
+    expect(registry.linkByToken("tok_other", "S1")).toBe(false);
+    expect(registry.getPid("S1")).toBeUndefined();
+  });
+
+  it("linkByToken returns false for empty token", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(100, "/p", mockProcess(), "tok_abc");
+    expect(registry.linkByToken("", "S1")).toBe(false);
+  });
+
+  it("linkByToken does not relink an already-linked entry", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(100, "/p", mockProcess(), "tok_abc");
+    expect(registry.linkByToken("tok_abc", "S1")).toBe(true);
+    expect(registry.linkByToken("tok_abc", "S2")).toBe(false);
+    expect(registry.getPid("S1")).toBe(100);
+    expect(registry.getPid("S2")).toBeUndefined();
+  });
+
+  it("linkByPid sets sessionId on the entry with that pid", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(123, "/p", mockProcess());
+    expect(registry.linkByPid("S1", 123)).toBe(true);
+    expect(registry.getPid("S1")).toBe(123);
+  });
+
+  it("linkByPid returns false for unknown pid", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(123, "/p", mockProcess());
+    expect(registry.linkByPid("S1", 999)).toBe(false);
+  });
+
+  it("linkByPid does not relink already-linked entry", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(123, "/p", mockProcess());
+    expect(registry.linkByPid("S1", 123)).toBe(true);
+    expect(registry.linkByPid("S2", 123)).toBe(false);
+  });
+
+  it("closes the kill-fork-kills-parent race: distinct tokens for two same-cwd spawns", () => {
+    // Setup: parent S1 already linked. Concurrent fork is registered.
+    // Without token-link, cwd-FIFO would assign the fork's sessionId to
+    // parent's pid. With token-link, identity is exact.
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(1000, "/proj", mockProcess(), "tok_parent");
+    registry.register(1234, "/proj", mockProcess(), "tok_fork");
+
+    // Bridge connect order is reversed (fork's bridge connects first):
+    expect(registry.linkByToken("tok_fork", "S_fork")).toBe(true);
+    expect(registry.linkByToken("tok_parent", "S_parent")).toBe(true);
+
+    // Each session resolves to its OWN pid — no swap.
+    expect(registry.getPid("S_fork")).toBe(1234);
+    expect(registry.getPid("S_parent")).toBe(1000);
+  });
+
+  it("linkByPid fixes the kill-fork-kills-parent race even without tokens (legacy bridge)", () => {
+    const registry = createHeadlessPidRegistry({ pidFilePath: join(makeTempDir(), "pids.json") });
+    registry.register(1000, "/proj", mockProcess()); // no token (legacy)
+    registry.register(1234, "/proj", mockProcess()); // no token (legacy)
+
+    // Bridge supplies pid in session_register — link by pid is exact.
+    expect(registry.linkByPid("S_fork", 1234)).toBe(true);
+    expect(registry.linkByPid("S_parent", 1000)).toBe(true);
+
+    expect(registry.getPid("S_fork")).toBe(1234);
+    expect(registry.getPid("S_parent")).toBe(1000);
+  });
+});

package/packages/server/src/__tests__/health-shape.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Tests for /api/health response shape after Phase A additions.
+ *
+ * Asserts:
+ *  - `pid` field is present (regression pin).
+ *  - `starter` field is present, defaults to "Standalone".
+ *
+ * Note: the "Standalone default for missing DASHBOARD_STARTER" case is
+ * also covered exhaustively in packages/shared/src/__tests__/dashboard-starter.test.ts.
+ * This test pins the contract at the HTTP layer so a refactor cannot silently
+ * drop either field from the health response.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { createTestServer, type TestServerHandle } from "../test-support/test-server.js";
+
+let handle: TestServerHandle | undefined;
+
+describe("GET /api/health — Phase A shape", () => {
+  afterEach(async () => {
+    if (handle) {
+      try { await handle.stop(); } catch { /* already stopped */ }
+      handle = undefined;
+    }
+  });
+
+  it("includes pid field (regression pin)", async () => {
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    expect(typeof body.pid).toBe("number");
+    expect(body.pid).toBe(process.pid);
+  });
+
+  it("includes starter field defaulting to Standalone", async () => {
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json() as Record<string, unknown>;
+    // When bootstrapState has no starter set, defaults to "Standalone".
+    expect(body.starter).toBe("Standalone");
+  });
+});

package/packages/server/src/__tests__/idle-timer-respects-terminals.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createIdleTimer } from "../idle-timer.js";
+import type { PiGateway } from "../pi-gateway.js";
+import type { ServerConfig } from "../server.js";
+
+// See change: fix-terminal-half-height-dual-mount.
+// Pure unit tests against the idle-timer's predicate-driven gating.
+// Avoids the full-server I/O races that have the auto-shutdown.test.ts
+// suite skipped under fake timers.
+
+function makeConfig(): ServerConfig {
+  return {
+    port: 0,
+    piPort: 0,
+    dev: true,
+    autoShutdown: true,
+    shutdownIdleSeconds: 2,
+    tunnel: false,
+    pingInterval: 0,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+  } as ServerConfig;
+}
+
+function makeGateway(connectionCount = 0): PiGateway {
+  return {
+    connectionCount: () => connectionCount,
+    onEmpty: undefined,
+    onConnection: undefined,
+  } as unknown as PiGateway;
+}
+
+describe("idle-timer respects active terminals", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("does NOT shut down when one or more terminals are alive", async () => {
+    const gateway = makeGateway(0);
+    let terminalCount = 1;
+    const timer = createIdleTimer(makeConfig(), gateway, () => terminalCount > 0);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // Advance well past shutdownIdleSeconds.
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(stopFn).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    exitSpy.mockRestore();
+    timer.cancel();
+  });
+
+  it("shuts down when no pi sessions AND no terminals are alive", async () => {
+    const gateway = makeGateway(0);
+    const timer = createIdleTimer(makeConfig(), gateway, () => false);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // First tick: realIdleMs is 0 because lastConnectionTimestamp = 0.
+    // The implementation guards on realIdleMs < shutdownIdleSeconds*1000
+    // and restarts; so we need two ticks separated by enough wall time.
+    await vi.advanceTimersByTimeAsync(2000);
+    // After the first tick the timer has restarted; advance again.
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(stopFn).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    exitSpy.mockRestore();
+  });
+
+  it("re-arms (does not shut down) when terminals appear mid-countdown", async () => {
+    const gateway = makeGateway(0);
+    let terminalCount = 0;
+    const timer = createIdleTimer(makeConfig(), gateway, () => terminalCount > 0);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    // Just before the timer fires, a terminal appears.
+    await vi.advanceTimersByTimeAsync(1500);
+    terminalCount = 1;
+    // Let it fire.
+    await vi.advanceTimersByTimeAsync(1500);
+
+    expect(stopFn).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    exitSpy.mockRestore();
+    timer.cancel();
+  });
+
+  it("default predicate (no terminals) preserves legacy single-arg call site behavior", async () => {
+    // Caller may construct without the third arg; default is () => false.
+    const gateway = makeGateway(0);
+    const timer = createIdleTimer(makeConfig(), gateway);
+    const stopFn = vi.fn().mockResolvedValue(undefined);
+    timer.setStopFn(stopFn);
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(2000);
+
+    expect(stopFn).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    exitSpy.mockRestore();
+  });
+});

package/packages/server/src/__tests__/is-pi-process.test.ts

@@ -7,7 +7,7 @@ import { isPiCommandLine } from "../browser-handlers/session-action-handler.js";
 
 describe("isPiCommandLine", () => {
   it("matches a typical pi cli invocation", () => {
-    expect(isPiCommandLine("/usr/bin/node /usr/local/lib/node_modules/@mariozechner/pi-coding-agent/dist/cli.js")).toBe(true);
+    expect(isPiCommandLine("/usr/bin/node /usr/local/lib/node_modules/@earendil-works/pi-coding-agent/dist/cli.js")).toBe(true);
   });
 
   it("matches when only 'pi' appears as a word", () => {

package/packages/server/src/__tests__/openspec-connect-snapshot.test.ts

@@ -0,0 +1,92 @@
+/**
+ * On-connect snapshot semantics: emits exactly one `openspec_update`
+ * per known cwd, with correct `pending` value.
+ *
+ * See change: fix-cold-boot-openspec-protocol.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { buildOpenSpecConnectSnapshot } from "../browser-gateway.js";
+import type { OpenSpecData } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function ds(map: Record<string, OpenSpecData | undefined>) {
+  return {
+    knownDirectories: vi.fn(() => Object.keys(map)),
+    getOpenSpecData: vi.fn((cwd: string) => map[cwd]),
+  };
+}
+
+describe("buildOpenSpecConnectSnapshot", () => {
+  it("emits cached payload for cwds with initialized data (no pending field)", () => {
+    const cached: OpenSpecData = { initialized: true, changes: [{ name: "x" } as never] };
+    const msgs = buildOpenSpecConnectSnapshot(ds({ "/p": cached }), () => true);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toEqual({ type: "openspec_update", cwd: "/p", data: cached });
+  });
+
+  it("emits pending: true when openspec dir exists but cache is empty", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": { initialized: false, changes: [] } }),
+      (cwd) => cwd === "/p",
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: true, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits pending: true when openspec dir exists but cache is undefined", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": undefined }),
+      () => true,
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: true, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits pending: false when no openspec dir exists", () => {
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds({ "/p": undefined }),
+      () => false,
+    );
+    expect(msgs).toEqual([
+      {
+        type: "openspec_update",
+        cwd: "/p",
+        data: { initialized: false, pending: false, changes: [] },
+      },
+    ]);
+  });
+
+  it("emits exactly one message per known cwd, mixed states preserved", () => {
+    const cached: OpenSpecData = { initialized: true, changes: [{ name: "x" } as never] };
+    const map = { "/hot": cached, "/cold": undefined, "/none": undefined };
+    const msgs = buildOpenSpecConnectSnapshot(
+      ds(map),
+      (cwd) => cwd === "/cold",
+    );
+    expect(msgs).toHaveLength(3);
+    expect(msgs[0]).toEqual({ type: "openspec_update", cwd: "/hot", data: cached });
+    expect(msgs[1]).toEqual({
+      type: "openspec_update",
+      cwd: "/cold",
+      data: { initialized: false, pending: true, changes: [] },
+    });
+    expect(msgs[2]).toEqual({
+      type: "openspec_update",
+      cwd: "/none",
+      data: { initialized: false, pending: false, changes: [] },
+    });
+  });
+
+  it("returns empty array when there are no known directories", () => {
+    expect(buildOpenSpecConnectSnapshot(ds({}), () => true)).toEqual([]);
+  });
+});

package/packages/server/src/__tests__/package-manager-wrapper-resolve.test.ts

@@ -2,7 +2,7 @@
  * Tests for loadPiPackageManager() resolution chain in package-manager-wrapper.ts.
  *
  * Separate from package-manager-wrapper.test.ts because that file mocks
- * "@mariozechner/pi-coding-agent" so direct-import succeeds and the
+ * "@earendil-works/pi-coding-agent" so direct-import succeeds and the
  * fallback paths never execute.
  *
  * These tests exercise the managed-install and global-npm fallbacks.
@@ -15,10 +15,10 @@ import * as path from "node:path";
 // Force the direct import to fail so resolution falls through to the
 // managed-install / global-npm paths. vi.mock is hoisted; the factory
 // throws at import time which mimics pi not being an installed dependency.
-vi.mock("@mariozechner/pi-coding-agent", () => {
+vi.mock("@earendil-works/pi-coding-agent", () => {
   throw new Error("not installed as direct dependency");
 });
-vi.mock("@oh-my-pi/pi-coding-agent", () => {
+vi.mock("@mariozechner/pi-coding-agent", () => {
   throw new Error("not installed as direct dependency");
 });
 
@@ -60,7 +60,7 @@ describe("loadPiPackageManager resolution chain", () => {
       tmpHome,
       ".pi-dashboard",
       "node_modules",
-      "@mariozechner",
+      "@earendil-works",
       "pi-coding-agent",
       "dist",
     );

package/packages/server/src/__tests__/package-routes.test.ts

@@ -13,7 +13,7 @@ import {
 } from "../package-manager-wrapper.js";
 
 // Mock pi dependency (pulled transitively by package-manager-wrapper)
-vi.mock("@mariozechner/pi-coding-agent", () => ({
+vi.mock("@earendil-works/pi-coding-agent", () => ({
   DefaultPackageManager: function() { return {}; },
   SettingsManager: { create: () => ({}) },
 }));

package/packages/server/src/__tests__/pending-fork-registry.test.ts

@@ -1,6 +1,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { createPendingForkRegistry } from "../pending-fork-registry.js";
 
+// See change: spawn-correlation-token \u2014 registry is now keyed by spawnToken
+// (UUID minted by the server per spawn invocation) instead of cwd. This
+// closes the multi-fork-in-same-cwd race where the second `recordFork`
+// would overwrite the first's parentSessionId.
+
 describe("PendingForkRegistry", () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -10,60 +15,79 @@ describe("PendingForkRegistry", () => {
     vi.useRealTimers();
   });
 
-  it("records and consumes a fork", () => {
+  it("records and consumes a fork by token", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/project", "parent-1");
-    const result = reg.consumeFork("/project");
+    reg.recordFork("tok_a", "parent-1");
+    const result = reg.consumeFork("tok_a");
     expect(result).toBe("parent-1");
   });
 
   it("returns undefined when no fork pending", () => {
     const reg = createPendingForkRegistry();
-    expect(reg.consumeFork("/project")).toBeUndefined();
+    expect(reg.consumeFork("tok_unknown")).toBeUndefined();
   });
 
   it("consume clears the entry", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/project", "parent-1");
-    reg.consumeFork("/project");
-    expect(reg.consumeFork("/project")).toBeUndefined();
+    reg.recordFork("tok_a", "parent-1");
+    reg.consumeFork("tok_a");
+    expect(reg.consumeFork("tok_a")).toBeUndefined();
   });
 
   it("expires after 30 seconds", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/project", "parent-1");
+    reg.recordFork("tok_a", "parent-1");
     vi.advanceTimersByTime(30_001);
-    expect(reg.consumeFork("/project")).toBeUndefined();
+    expect(reg.consumeFork("tok_a")).toBeUndefined();
   });
 
   it("does not expire before 30 seconds", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/project", "parent-1");
+    reg.recordFork("tok_a", "parent-1");
     vi.advanceTimersByTime(29_999);
-    expect(reg.consumeFork("/project")).toBe("parent-1");
+    expect(reg.consumeFork("tok_a")).toBe("parent-1");
+  });
+
+  it("re-recording with same token replaces parent", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("tok_a", "parent-1");
+    reg.recordFork("tok_a", "parent-2");
+    expect(reg.consumeFork("tok_a")).toBe("parent-2");
   });
 
-  it("latest fork overwrites previous for same cwd", () => {
+  it("different tokens are independent", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/project", "parent-1");
-    reg.recordFork("/project", "parent-2");
-    expect(reg.consumeFork("/project")).toBe("parent-2");
+    reg.recordFork("tok_a", "parent-a");
+    reg.recordFork("tok_b", "parent-b");
+    expect(reg.consumeFork("tok_a")).toBe("parent-a");
+    expect(reg.consumeFork("tok_b")).toBe("parent-b");
   });
 
-  it("different cwds are independent", () => {
+  it("multi-fork-in-same-cwd: each fork keyed by its own token, no overwrite", () => {
+    // Regression: the prior cwd-keyed registry would overwrite the first
+    // fork's parent when a second fork issued in the same cwd recorded
+    // its intent before the first's bridge registered. Token-keying
+    // makes the two intents independent.
     const reg = createPendingForkRegistry();
-    reg.recordFork("/a", "parent-a");
-    reg.recordFork("/b", "parent-b");
-    expect(reg.consumeFork("/a")).toBe("parent-a");
-    expect(reg.consumeFork("/b")).toBe("parent-b");
+    reg.recordFork("tok_fork1", "parent-A");
+    reg.recordFork("tok_fork2", "parent-B");
+    // Bridge connect order can be reversed:
+    expect(reg.consumeFork("tok_fork2")).toBe("parent-B");
+    expect(reg.consumeFork("tok_fork1")).toBe("parent-A");
   });
 
   it("dispose clears all timers", () => {
     const reg = createPendingForkRegistry();
-    reg.recordFork("/a", "parent-a");
-    reg.recordFork("/b", "parent-b");
+    reg.recordFork("tok_a", "parent-a");
+    reg.recordFork("tok_b", "parent-b");
     reg.dispose();
-    expect(reg.consumeFork("/a")).toBeUndefined();
-    expect(reg.consumeFork("/b")).toBeUndefined();
+    expect(reg.consumeFork("tok_a")).toBeUndefined();
+    expect(reg.consumeFork("tok_b")).toBeUndefined();
+  });
+
+  it("empty token is rejected on record", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("", "parent-1");
+    expect(reg.consumeFork("")).toBeUndefined();
   });
 });