@blackbelt-technology/pi-agent-dashboard 0.4.1 → 0.4.2

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

@@ -0,0 +1,123 @@
+/**
+ * Unit tests for the in-memory pending-attach registry.
+ * See change: add-folder-task-checker-and-spawn-attach.
+ */
+import { describe, it, expect, vi } from "vitest";
+import {
+  createPendingAttachRegistry,
+  PENDING_ATTACH_QUEUE_CAP,
+  PENDING_ATTACH_TTL_MS,
+} from "../pending-attach-registry.js";
+
+function fakeNow() {
+  let t = 1_000_000;
+  return {
+    now: () => t,
+    advance(ms: number) {
+      t += ms;
+    },
+  };
+}
+
+describe("pending-attach-registry", () => {
+  it("FIFO enqueue + consume returns names in order", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    expect(reg.enqueue("/p", "a")).toBe(true);
+    expect(reg.enqueue("/p", "b")).toBe(true);
+    expect(reg.enqueue("/p", "c")).toBe(true);
+    expect(reg.size("/p")).toBe(3);
+    expect(reg.consume("/p")).toBe("a");
+    expect(reg.consume("/p")).toBe("b");
+    expect(reg.consume("/p")).toBe("c");
+    expect(reg.consume("/p")).toBeNull();
+    expect(reg.size("/p")).toBe(0);
+  });
+
+  it("empty queue consume returns null", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    expect(reg.consume("/never-enqueued")).toBeNull();
+  });
+
+  it("isolated per cwd", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    reg.enqueue("/a", "x");
+    reg.enqueue("/b", "y");
+    expect(reg.consume("/a")).toBe("x");
+    expect(reg.consume("/b")).toBe("y");
+  });
+
+  it("normalizes cwd: trailing slash collapses", () => {
+    // We exercise the default stripTrailingSep behaviour by using identity
+    // realpath to keep the test platform-agnostic.
+    const reg = createPendingAttachRegistry({ normalize: (s) => s.replace(/[/\\]+$/, ""), warn: () => {} });
+    reg.enqueue("/p/", "a");
+    expect(reg.size("/p")).toBe(1);
+    expect(reg.consume("/p")).toBe("a");
+  });
+
+  it("normalizes cwd: realpath equivalence", () => {
+    const reg = createPendingAttachRegistry({
+      normalize: (s) => (s === "/symlink" ? "/real" : s),
+      warn: () => {},
+    });
+    reg.enqueue("/symlink", "a");
+    expect(reg.size("/real")).toBe(1);
+    expect(reg.consume("/real")).toBe("a");
+  });
+
+  it(`drops at queue cap (${PENDING_ATTACH_QUEUE_CAP}) and warns`, () => {
+    const warn = vi.fn();
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn });
+    for (let i = 0; i < PENDING_ATTACH_QUEUE_CAP; i++) {
+      expect(reg.enqueue("/p", `c${i}`)).toBe(true);
+    }
+    expect(reg.size("/p")).toBe(PENDING_ATTACH_QUEUE_CAP);
+    expect(warn).not.toHaveBeenCalled();
+    expect(reg.enqueue("/p", "overflow")).toBe(false);
+    expect(reg.size("/p")).toBe(PENDING_ATTACH_QUEUE_CAP);
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]![0]).toMatch(/cap reached/);
+    expect(warn.mock.calls[0]![0]).toMatch(/overflow/);
+  });
+
+  it("expires entries older than 60 s on read", () => {
+    const clock = fakeNow();
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, now: clock.now, warn: () => {} });
+    reg.enqueue("/p", "a");
+    clock.advance(PENDING_ATTACH_TTL_MS + 1);
+    expect(reg.size("/p")).toBe(0);
+    expect(reg.consume("/p")).toBeNull();
+  });
+
+  it("expires entries older than 60 s on write", () => {
+    const clock = fakeNow();
+    const warn = vi.fn();
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, now: clock.now, warn });
+    reg.enqueue("/p", "a");
+    clock.advance(PENDING_ATTACH_TTL_MS + 1);
+    // A new enqueue should drop the stale entry first, then push the new one.
+    reg.enqueue("/p", "b");
+    expect(reg.size("/p")).toBe(1);
+    expect(reg.consume("/p")).toBe("b");
+    expect(warn).toHaveBeenCalled();
+    expect(warn.mock.calls.some((c) => /stale intent/.test(String(c[0])))).toBe(true);
+  });
+
+  it("rejects empty changeName", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    expect(reg.enqueue("/p", "")).toBe(false);
+    expect(reg.size("/p")).toBe(0);
+  });
+
+  it("partial expiry preserves fresh entries", () => {
+    const clock = fakeNow();
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, now: clock.now, warn: () => {} });
+    reg.enqueue("/p", "old");
+    clock.advance(PENDING_ATTACH_TTL_MS / 2);
+    reg.enqueue("/p", "new");
+    clock.advance(PENDING_ATTACH_TTL_MS / 2 + 1);
+    // "old" is now stale; "new" is fresh.
+    expect(reg.consume("/p")).toBe("new");
+    expect(reg.consume("/p")).toBeNull();
+  });
+});

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

@@ -0,0 +1,138 @@
+/**
+ * Unit tests for pending-resume-intent-registry.
+ *
+ * Uses an injectable `now()` to simulate the passage of time without
+ * fake-timer infrastructure — keeps the tests synchronous and free of
+ * implicit microtask ordering.
+ *
+ * See changes: preserve-session-order-on-reboot,
+ *              differentiate-resume-intent-by-trigger.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  createPendingResumeIntentRegistry,
+  PENDING_RESUME_INTENT_TTL_MS,
+} from "../pending-resume-intent-registry.js";
+
+function makeClock(start = 1_000_000) {
+  let t = start;
+  return {
+    now: () => t,
+    advance: (ms: number) => { t += ms; },
+  };
+}
+
+describe("pending-resume-intent-registry", () => {
+  it("record(\"front\") then consume returns \"front\"", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now });
+    r.record("a", "front");
+    expect(r.consume("a")).toBe("front");
+  });
+
+  it("record(\"keep\") then consume returns \"keep\"", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now });
+    r.record("a", "keep");
+    expect(r.consume("a")).toBe("keep");
+  });
+
+  it("consume clears the entry (second consume returns null)", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now });
+    r.record("a", "front");
+    r.consume("a");
+    expect(r.consume("a")).toBeNull();
+  });
+
+  it("consume on an unknown id returns null (no error)", () => {
+    const r = createPendingResumeIntentRegistry();
+    expect(r.consume("unknown")).toBeNull();
+  });
+
+  it("record is idempotent — same id stored once", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now });
+    r.record("a", "front");
+    r.record("a", "front");
+    r.record("a", "front");
+    expect(r.size()).toBe(1);
+    expect(r.consume("a")).toBe("front");
+    expect(r.consume("a")).toBeNull();
+  });
+
+  it("re-record overwrites the prior intent (last-write-wins: front → keep)", () => {
+    const r = createPendingResumeIntentRegistry();
+    r.record("a", "front");
+    r.record("a", "keep");
+    expect(r.consume("a")).toBe("keep");
+  });
+
+  it("re-record overwrites the prior intent (last-write-wins: keep → front)", () => {
+    const r = createPendingResumeIntentRegistry();
+    r.record("a", "keep");
+    r.record("a", "front");
+    expect(r.consume("a")).toBe("front");
+  });
+
+  it("re-record refreshes the timestamp (resists expiry)", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now, ttlMs: 100 });
+    r.record("a", "front");
+    clock.advance(80);
+    r.record("a", "front"); // refresh — would expire at t=180 from this point
+    clock.advance(80); // total 160ms from first record, but only 80 since refresh
+    expect(r.consume("a")).toBe("front");
+  });
+
+  it("consume returns null after TTL even without explicit consume", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now, ttlMs: 100 });
+    r.record("a", "front");
+    clock.advance(101);
+    expect(r.consume("a")).toBeNull();
+  });
+
+  it("expired entry is dropped from storage", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now, ttlMs: 100 });
+    r.record("a", "front");
+    clock.advance(101);
+    r.consume("a"); // returns null, drops the stale entry
+    expect(r.size()).toBe(0);
+  });
+
+  it("size() prunes stale entries lazily", () => {
+    const clock = makeClock();
+    const r = createPendingResumeIntentRegistry({ now: clock.now, ttlMs: 100 });
+    r.record("a", "front");
+    r.record("b", "keep");
+    clock.advance(50);
+    r.record("c", "front");
+    expect(r.size()).toBe(3);
+    clock.advance(60); // a + b stale (110ms total), c still fresh (60ms)
+    expect(r.size()).toBe(1);
+  });
+
+  it("multiple ids carry independent intents", () => {
+    const r = createPendingResumeIntentRegistry();
+    r.record("a", "front");
+    r.record("b", "keep");
+    r.record("c", "front");
+    expect(r.consume("b")).toBe("keep");
+    expect(r.consume("a")).toBe("front");
+    expect(r.consume("c")).toBe("front");
+    expect(r.size()).toBe(0);
+  });
+
+  it("empty/falsy sessionId is rejected on record and on consume", () => {
+    const r = createPendingResumeIntentRegistry();
+    r.record("", "front");
+    expect(r.size()).toBe(0);
+    expect(r.consume("")).toBeNull();
+  });
+
+  it("default TTL is 60s (sanity check exported constant)", () => {
+    expect(PENDING_RESUME_INTENT_TTL_MS).toBe(60_000);
+  });
+});

package/packages/server/src/__tests__/pi-core-checker.test.ts

@@ -5,20 +5,23 @@ import fs from "node:fs";
 import { PiCoreChecker, CORE_PACKAGE_NAMES, _internal } from "../pi-core-checker.js";
 
 describe("PiCoreChecker._internal.looksLikePiEcosystem", () => {
-	it("matches known core packages", () => {
+	it("matches every known core package", () => {
 		for (const name of CORE_PACKAGE_NAMES) {
 			expect(_internal.looksLikePiEcosystem(name)).toBe(true);
 		}
 	});
 
-	it("matches bare pi- packages", () => {
-		expect(_internal.looksLikePiEcosystem("pi-web-access")).toBe(true);
-		expect(_internal.looksLikePiEcosystem("pi-agent-browser")).toBe(true);
+	it("rejects pi-* prefixed packages that are NOT in the whitelist (no heuristic)", () => {
+		// These were previously matched by the dropped pi-* heuristic.
+		expect(_internal.looksLikePiEcosystem("pi-web-access")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("pi-agent-browser")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("pi-flows")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("pi-anthropic-messages")).toBe(false);
 	});
 
-	it("matches scoped pi- packages", () => {
-		expect(_internal.looksLikePiEcosystem("@tintinweb/pi-subagents")).toBe(true);
-		expect(_internal.looksLikePiEcosystem("@benvargas/pi-claude-code-use")).toBe(true);
+	it("rejects scoped pi-* packages that are NOT in the whitelist", () => {
+		expect(_internal.looksLikePiEcosystem("@tintinweb/pi-subagents")).toBe(false);
+		expect(_internal.looksLikePiEcosystem("@benvargas/pi-claude-code-use")).toBe(false);
 	});
 
 	it("rejects non-pi packages", () => {
@@ -42,19 +45,20 @@ describe("PiCoreChecker.getStatus", () => {
 		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name, version }));
 	}
 
-	it("discovers global pi packages via npm list", async () => {
+	it("discovers global pi packages via npm list (whitelist only)", async () => {
 		const checker = new PiCoreChecker({
 			npmList: async () =>
 				JSON.stringify({
 					dependencies: {
 						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
-						"pi-web-access": { version: "0.10.6" },
-						react: { version: "19.0.0" }, // must be ignored
+						"@blackbelt-technology/pi-agent-dashboard": { version: "0.4.0" },
+						"pi-web-access": { version: "0.10.6" }, // NOT in whitelist → ignored
+						react: { version: "19.0.0" }, // ignored
 					},
 				}),
 			fetchLatest: async (name) => {
 				if (name === "@mariozechner/pi-coding-agent") return "0.67.6";
-				if (name === "pi-web-access") return "0.10.6";
+				if (name === "@blackbelt-technology/pi-agent-dashboard") return "0.4.1";
 				return null;
 			},
 			managedDir: tmpManagedDir,
@@ -63,6 +67,8 @@ describe("PiCoreChecker.getStatus", () => {
 		const status = await checker.getStatus();
 
 		expect(status.packages.length).toBe(2);
+		expect(status.packages.find((p) => p.name === "pi-web-access")).toBeUndefined();
+
 		const pi = status.packages.find((p) => p.name === "@mariozechner/pi-coding-agent")!;
 		expect(pi.displayName).toBe("pi (core agent)");
 		expect(pi.currentVersion).toBe("0.67.1");
@@ -70,12 +76,30 @@ describe("PiCoreChecker.getStatus", () => {
 		expect(pi.updateAvailable).toBe(true);
 		expect(pi.installSource).toBe("global");
 
-		const web = status.packages.find((p) => p.name === "pi-web-access")!;
-		expect(web.displayName).toBe("pi-web-access");
-		expect(web.updateAvailable).toBe(false);
-		expect(web.installSource).toBe("global");
+		const dash = status.packages.find((p) => p.name === "@blackbelt-technology/pi-agent-dashboard")!;
+		expect(dash.displayName).toBe("pi-dashboard");
+		expect(dash.updateAvailable).toBe(true);
 
-		expect(status.updatesAvailable).toBe(1);
+		expect(status.updatesAvailable).toBe(2);
+	});
+
+	it("recommended-extension packages installed globally are NOT in core discovery", async () => {
+		// Regression test for the dropped pi-* heuristic. These rows must
+		// surface only via /api/packages/installed.
+		const checker = new PiCoreChecker({
+			npmList: async () =>
+				JSON.stringify({
+					dependencies: {
+						"pi-agent-browser": { version: "0.1.0" },
+						"pi-web-access": { version: "0.10.6" },
+						"@tintinweb/pi-subagents": { version: "0.6.1" },
+					},
+				}),
+			fetchLatest: async () => null,
+			managedDir: path.join(tmpManagedDir, "nope"),
+		});
+		const status = await checker.getStatus();
+		expect(status.packages).toEqual([]);
 	});
 
 	it("discovers managed packages and prefers them over global duplicates", async () => {
@@ -98,6 +122,20 @@ describe("PiCoreChecker.getStatus", () => {
 		expect(status.packages[0].installSource).toBe("managed");
 	});
 
+	it("managed scan ignores non-whitelisted packages", async () => {
+		// Even if a pi-* prefixed package sits in ~/.pi-dashboard/node_modules,
+		// it must not appear in core discovery.
+		writeManagedPackage(tmpManagedDir, "pi-web-access", "0.10.6");
+
+		const checker = new PiCoreChecker({
+			npmList: async () => JSON.stringify({ dependencies: {} }),
+			fetchLatest: async () => null,
+			managedDir: tmpManagedDir,
+		});
+		const status = await checker.getStatus();
+		expect(status.packages).toEqual([]);
+	});
+
 	it("returns empty list when managed dir missing and npm list fails", async () => {
 		const checker = new PiCoreChecker({
 			npmList: async () => {
@@ -116,16 +154,18 @@ describe("PiCoreChecker.getStatus", () => {
 			npmList: async () => {
 				const err = new Error("npm warn") as Error & { stdout: string };
 				err.stdout = JSON.stringify({
-					dependencies: { "pi-web-access": { version: "0.10.6" } },
+					dependencies: {
+						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
+					},
 				});
 				throw err;
 			},
-			fetchLatest: async () => "0.10.6",
+			fetchLatest: async () => "0.67.6",
 			managedDir: path.join(tmpManagedDir, "nope"),
 		});
 		const status = await checker.getStatus();
 		expect(status.packages.length).toBe(1);
-		expect(status.packages[0].name).toBe("pi-web-access");
+		expect(status.packages[0].name).toBe("@mariozechner/pi-coding-agent");
 	});
 
 	it("caches results within 5 minutes", async () => {
@@ -133,9 +173,11 @@ describe("PiCoreChecker.getStatus", () => {
 		const checker = new PiCoreChecker({
 			npmList: async () => {
 				calls++;
-				return JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } });
+				return JSON.stringify({
+					dependencies: { "@mariozechner/pi-coding-agent": { version: "0.67.1" } },
+				});
 			},
-			fetchLatest: async () => "0.10.6",
+			fetchLatest: async () => "0.67.6",
 			managedDir: path.join(tmpManagedDir, "nope"),
 		});
 		await checker.getStatus();
@@ -148,9 +190,11 @@ describe("PiCoreChecker.getStatus", () => {
 		const checker = new PiCoreChecker({
 			npmList: async () => {
 				calls++;
-				return JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } });
+				return JSON.stringify({
+					dependencies: { "@mariozechner/pi-coding-agent": { version: "0.67.1" } },
+				});
 			},
-			fetchLatest: async () => "0.10.6",
+			fetchLatest: async () => "0.67.6",
 			managedDir: path.join(tmpManagedDir, "nope"),
 		});
 		await checker.getStatus();
@@ -161,7 +205,9 @@ describe("PiCoreChecker.getStatus", () => {
 	it("treats fetch failure as latestVersion=null, updateAvailable=false", async () => {
 		const checker = new PiCoreChecker({
 			npmList: async () =>
-				JSON.stringify({ dependencies: { "pi-web-access": { version: "0.10.6" } } }),
+				JSON.stringify({
+					dependencies: { "@mariozechner/pi-coding-agent": { version: "0.67.1" } },
+				}),
 			fetchLatest: async () => {
 				throw new Error("network down");
 			},
@@ -173,14 +219,13 @@ describe("PiCoreChecker.getStatus", () => {
 		expect(status.packages[0].updateAvailable).toBe(false);
 	});
 
-	it("sorts known core packages first", async () => {
+	it("sorts known core packages in CORE_PACKAGE_NAMES order", async () => {
 		const checker = new PiCoreChecker({
 			npmList: async () =>
 				JSON.stringify({
 					dependencies: {
-						"pi-web-access": { version: "0.10.6" },
+						"@blackbelt-technology/pi-agent-dashboard": { version: "0.4.0" },
 						"@mariozechner/pi-coding-agent": { version: "0.67.1" },
-						"pi-agent-browser": { version: "0.1.0" },
 					},
 				}),
 			fetchLatest: async () => null,
@@ -188,8 +233,6 @@ describe("PiCoreChecker.getStatus", () => {
 		});
 		const status = await checker.getStatus();
 		expect(status.packages[0].name).toBe("@mariozechner/pi-coding-agent");
-		// remaining are alphabetical
-		expect(status.packages[1].name).toBe("pi-agent-browser");
-		expect(status.packages[2].name).toBe("pi-web-access");
+		expect(status.packages[1].name).toBe("@blackbelt-technology/pi-agent-dashboard");
 	});
 });

package/packages/server/src/__tests__/pi-gateway-consume-pending-attach.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Verifies the consume-on-register flow: when `applyAttachProposal` runs with
+ * a pending intent's name, it (a) updates the session, (b) sends rename to
+ * the bridge if `attachRenameTarget` returned a name, and (c) broadcasts
+ * `session_updated`. Mirrors what `pi-gateway.onSessionRegistered` does in
+ * `event-wiring.ts`.
+ *
+ * See change: add-folder-task-checker-and-spawn-attach.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { applyAttachProposal } from "../browser-handlers/session-meta-handler.js";
+import { createPendingAttachRegistry } from "../pending-attach-registry.js";
+
+function makeCtx(initial?: { name?: string }) {
+  const session = { id: "s99", cwd: "/p", name: initial?.name ?? "", attachedProposal: null };
+  const updates: any[] = [];
+  const broadcasts: any[] = [];
+  const piSent: any[] = [];
+  const ctx = {
+    sessionManager: {
+      get: () => session,
+      update: (id: string, u: any) => {
+        updates.push({ id, u });
+        Object.assign(session, u);
+      },
+    },
+    piGateway: {
+      sendToSession: (id: string, msg: any) => { piSent.push({ id, msg }); return true; },
+    },
+    broadcast: (msg: any) => { broadcasts.push(msg); },
+  } as any;
+  return { ctx, updates, broadcasts, piSent, session };
+}
+
+describe("consume-on-register flow", () => {
+  it("end-to-end: enqueue → consume → applyAttachProposal updates + broadcasts", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    reg.enqueue("/p", "add-foo");
+
+    // Simulate session_register arriving for cwd /p with sessionId s99.
+    const consumed = reg.consume("/p");
+    expect(consumed).toBe("add-foo");
+
+    const { ctx, updates, broadcasts, piSent } = makeCtx({ name: "" });
+    applyAttachProposal("s99", consumed!, ctx);
+
+    expect(updates).toHaveLength(1);
+    expect(updates[0]!.id).toBe("s99");
+    expect(updates[0]!.u.attachedProposal).toBe("add-foo");
+    // Empty/witness name → auto-rename fires.
+    expect(updates[0]!.u.name).toBe("add-foo");
+    expect(piSent).toHaveLength(1);
+    expect(piSent[0]!.msg).toMatchObject({ type: "rename_session", sessionId: "s99", name: "add-foo" });
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0]!).toMatchObject({
+      type: "session_updated",
+      sessionId: "s99",
+      updates: { attachedProposal: "add-foo", name: "add-foo" },
+    });
+  });
+
+  it("no intent in queue → no-op (regression: register without intent must not attach)", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    expect(reg.consume("/p")).toBeNull();
+    // Caller short-circuits and never calls applyAttachProposal — verified by
+    // event-wiring.ts conditional. This test just pins the contract that
+    // consume returns null for an empty queue, which is what the wiring relies
+    // on to skip the call.
+  });
+
+  it("cwd normalization between enqueue and consume", () => {
+    const reg = createPendingAttachRegistry({
+      normalize: (s) => s.replace(/[/\\]+$/, ""),
+      warn: () => {},
+    });
+    reg.enqueue("/proj/", "add-bar");
+    // Bridge sends back cwd without trailing slash.
+    expect(reg.consume("/proj")).toBe("add-bar");
+  });
+
+  it("only one intent consumed per register call", () => {
+    const reg = createPendingAttachRegistry({ normalize: (s) => s, warn: () => {} });
+    reg.enqueue("/p", "a");
+    reg.enqueue("/p", "b");
+    expect(reg.consume("/p")).toBe("a");
+    expect(reg.size("/p")).toBe(1);
+    expect(reg.consume("/p")).toBe("b");
+  });
+
+  it("session with explicit user-set name keeps it (idempotent rename short-circuits)", () => {
+    const { ctx, updates, piSent } = makeCtx({ name: "my-custom-name" });
+    applyAttachProposal("s99", "add-foo", ctx);
+    expect(updates[0]!.u.attachedProposal).toBe("add-foo");
+    // attachRenameTarget returns undefined when name is non-empty/non-witness.
+    expect("name" in updates[0]!.u).toBe(false);
+    expect(piSent).toHaveLength(0);
+  });
+
+  it("calling applyAttachProposal twice with same name is idempotent", () => {
+    const { ctx, updates, piSent } = makeCtx({ name: "" });
+    applyAttachProposal("s99", "add-foo", ctx);
+    applyAttachProposal("s99", "add-foo", ctx);
+    // First call sets name="add-foo"; second call sees name===attachedProposal
+    // (witness equality holds) and the rename helper returns the same target —
+    // safe to re-emit, but the session state is unchanged.
+    expect(updates).toHaveLength(2);
+    // Both broadcasts include attachedProposal:"add-foo"; second is a no-op
+    // from a state perspective.
+    expect(updates.every((u) => u.u.attachedProposal === "add-foo")).toBe(true);
+    expect(piSent.length).toBeGreaterThanOrEqual(1);
+  });
+});