@blackbelt-technology/pi-agent-dashboard 0.5.2 → 0.5.4

package/packages/server/src/__tests__/preferences-store.test.ts

@@ -174,4 +174,200 @@ describe("preferences-store", () => {
     expect(data.hiddenSessions).toBeUndefined();
     store.dispose();
   });
+
+  // ── folder-workspaces ──────────────────────────────────
+
+  describe("workspaces", () => {
+    it("defaults to empty workspaces[] when field absent", () => {
+      fs.writeFileSync(filePath, JSON.stringify({
+        pinnedDirectories: [A_PATH], sessionOrder: {},
+      }));
+      const store = createPreferencesStore(filePath);
+      expect(store.getWorkspaces()).toEqual([]);
+      store.dispose();
+    });
+
+    it("loads workspaces from disk preserving order, ids, name, collapsed, folders", () => {
+      fs.writeFileSync(filePath, JSON.stringify({
+        pinnedDirectories: [], sessionOrder: {},
+        workspaces: [
+          { id: "ws_1", name: "a", collapsed: false, folders: [A_PATH] },
+          { id: "ws_2", name: "b", collapsed: true, folders: [] },
+        ],
+      }));
+      const store = createPreferencesStore(filePath);
+      const got = store.getWorkspaces();
+      expect(got).toHaveLength(2);
+      expect(got[0]).toMatchObject({ id: "ws_1", name: "a", collapsed: false, folders: [A_PATH] });
+      expect(got[1]).toMatchObject({ id: "ws_2", name: "b", collapsed: true, folders: [] });
+      store.dispose();
+    });
+
+    it("createWorkspace generates ws_<uuid> id and trims name; rejects empty", () => {
+      const store = createPreferencesStore(filePath);
+      expect(store.createWorkspace("")).toBeNull();
+      expect(store.createWorkspace("   ")).toBeNull();
+      const w = store.createWorkspace("  client-work  ");
+      expect(w).not.toBeNull();
+      expect(w!.id).toMatch(/^ws_[0-9a-f-]{36}$/);
+      expect(w!.name).toBe("client-work");
+      expect(w!.collapsed).toBe(false);
+      expect(w!.folders).toEqual([]);
+      store.dispose();
+    });
+
+    it("createWorkspace rejects names longer than 80 chars", () => {
+      const store = createPreferencesStore(filePath);
+      expect(store.createWorkspace("x".repeat(81))).toBeNull();
+      expect(store.createWorkspace("x".repeat(80))).not.toBeNull();
+      store.dispose();
+    });
+
+    it("allows duplicate workspace names", () => {
+      const store = createPreferencesStore(filePath);
+      const a = store.createWorkspace("scratch");
+      const b = store.createWorkspace("scratch");
+      expect(a).not.toBeNull();
+      expect(b).not.toBeNull();
+      expect(a!.id).not.toBe(b!.id);
+      expect(store.getWorkspaces()).toHaveLength(2);
+      store.dispose();
+    });
+
+    it("renameWorkspace returns false on unknown id and on empty name", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("a")!;
+      expect(store.renameWorkspace("missing", "x")).toBe(false);
+      expect(store.renameWorkspace(w.id, "")).toBe(false);
+      expect(store.renameWorkspace(w.id, "a")).toBe(false); // same value, no-op
+      expect(store.renameWorkspace(w.id, "b")).toBe(true);
+      expect(store.getWorkspaces()[0].name).toBe("b");
+      store.dispose();
+    });
+
+    it("deleteWorkspace removes record and leaves pinnedDirectories alone", () => {
+      const store = createPreferencesStore(filePath);
+      store.pinDirectory(A_PATH);
+      const w = store.createWorkspace("w")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      expect(store.deleteWorkspace("missing")).toBe(false);
+      expect(store.deleteWorkspace(w.id)).toBe(true);
+      expect(store.getWorkspaces()).toEqual([]);
+      expect(store.getPinnedDirectories()).toEqual([A_PATH]);
+      store.dispose();
+    });
+
+    it("setWorkspaceCollapsed toggles flag; no-op on same value or unknown id", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("w")!;
+      expect(store.setWorkspaceCollapsed("missing", true)).toBe(false);
+      expect(store.setWorkspaceCollapsed(w.id, false)).toBe(false); // already false
+      expect(store.setWorkspaceCollapsed(w.id, true)).toBe(true);
+      expect(store.getWorkspaces()[0].collapsed).toBe(true);
+      store.dispose();
+    });
+
+    it("addFolderToWorkspace appends and is idempotent on duplicate", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("w")!;
+      expect(store.addFolderToWorkspace(w.id, A_PATH)).toBe(true);
+      expect(store.addFolderToWorkspace(w.id, A_PATH)).toBe(false); // idempotent
+      expect(store.getWorkspaces()[0].folders).toEqual([A_PATH]);
+      store.dispose();
+    });
+
+    it("single-membership: adding folder to workspace B detaches it from workspace A", () => {
+      const store = createPreferencesStore(filePath);
+      const a = store.createWorkspace("a")!;
+      const b = store.createWorkspace("b")!;
+      store.addFolderToWorkspace(a.id, A_PATH);
+      store.addFolderToWorkspace(b.id, A_PATH);
+      const ws = store.getWorkspaces();
+      expect(ws.find((w) => w.id === a.id)!.folders).toEqual([]);
+      expect(ws.find((w) => w.id === b.id)!.folders).toEqual([A_PATH]);
+      store.dispose();
+    });
+
+    it("adding folder does NOT touch pinnedDirectories", () => {
+      const store = createPreferencesStore(filePath);
+      store.pinDirectory(A_PATH);
+      const w = store.createWorkspace("w")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      expect(store.getPinnedDirectories()).toEqual([A_PATH]);
+      expect(store.getWorkspaces()[0].folders).toEqual([A_PATH]);
+      store.dispose();
+    });
+
+    it("removeFolderFromWorkspace does NOT touch pinnedDirectories", () => {
+      const store = createPreferencesStore(filePath);
+      store.pinDirectory(A_PATH);
+      const w = store.createWorkspace("w")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      expect(store.removeFolderFromWorkspace(w.id, A_PATH)).toBe(true);
+      expect(store.removeFolderFromWorkspace(w.id, A_PATH)).toBe(false); // not member
+      expect(store.getPinnedDirectories()).toEqual([A_PATH]);
+      expect(store.getWorkspaces()[0].folders).toEqual([]);
+      store.dispose();
+    });
+
+    it("reorderWorkspaceFolders rejects mismatched set", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("w")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      store.addFolderToWorkspace(w.id, B_PATH);
+      expect(store.reorderWorkspaceFolders(w.id, [A_PATH])).toBe(false); // missing B
+      expect(store.reorderWorkspaceFolders(w.id, [A_PATH, B_PATH, X_PATH])).toBe(false); // extra
+      expect(store.reorderWorkspaceFolders(w.id, [B_PATH, A_PATH])).toBe(true);
+      expect(store.getWorkspaces()[0].folders).toEqual([B_PATH, A_PATH]);
+      store.dispose();
+    });
+
+    it("reorderWorkspaces rejects mismatched id set", () => {
+      const store = createPreferencesStore(filePath);
+      const a = store.createWorkspace("a")!;
+      const b = store.createWorkspace("b")!;
+      expect(store.reorderWorkspaces([a.id])).toBe(false);
+      expect(store.reorderWorkspaces([a.id, b.id, "ghost"])).toBe(false);
+      expect(store.reorderWorkspaces([b.id, a.id])).toBe(true);
+      expect(store.getWorkspaces().map((w) => w.id)).toEqual([b.id, a.id]);
+      store.dispose();
+    });
+
+    it("workspaces persist round-trip through file with debounced write", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("persisted")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      store.setWorkspaceCollapsed(w.id, true);
+      store.flush();
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      expect(data.workspaces).toHaveLength(1);
+      expect(data.workspaces[0]).toMatchObject({
+        id: w.id, name: "persisted", collapsed: true, folders: [A_PATH],
+      });
+      store.dispose();
+    });
+
+    it("mutation triggers debounced save", () => {
+      const store = createPreferencesStore(filePath);
+      store.createWorkspace("x");
+      expect(fs.existsSync(filePath)).toBe(false);
+      vi.advanceTimersByTime(1000);
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      expect(data.workspaces).toHaveLength(1);
+      store.dispose();
+    });
+
+    it("getWorkspaces returns defensive clones — callers cannot mutate internal state", () => {
+      const store = createPreferencesStore(filePath);
+      const w = store.createWorkspace("w")!;
+      store.addFolderToWorkspace(w.id, A_PATH);
+      const snap = store.getWorkspaces();
+      snap[0].folders.push("/poisoned");
+      snap[0].name = "poisoned";
+      const fresh = store.getWorkspaces();
+      expect(fresh[0].folders).toEqual([A_PATH]);
+      expect(fresh[0].name).toBe("w");
+      store.dispose();
+    });
+  });
 });

package/packages/server/src/__tests__/reattach-placement.test.ts

@@ -28,6 +28,15 @@ function makePrefs(): PreferencesStore {
     pinDirectory: () => {},
     unpinDirectory: () => {},
     reorderPinnedDirs: () => {},
+    getWorkspaces: () => [],
+    createWorkspace: () => null,
+    renameWorkspace: () => false,
+    deleteWorkspace: () => false,
+    setWorkspaceCollapsed: () => false,
+    addFolderToWorkspace: () => false,
+    removeFolderFromWorkspace: () => false,
+    reorderWorkspaceFolders: () => false,
+    reorderWorkspaces: () => false,
     flush: () => {},
     dispose: () => {},
   };

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

@@ -49,9 +49,9 @@ describe("parseSourceKey", () => {
 	});
 
 	it("parses scoped npm: sources", () => {
-		expect(parseSourceKey("npm:@tintinweb/pi-subagents")).toEqual({
+		expect(parseSourceKey("npm:@scope/example-pkg")).toEqual({
 			kind: "npm",
-			name: "@tintinweb/pi-subagents",
+			name: "@scope/example-pkg",
 		});
 	});
 

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

@@ -0,0 +1,203 @@
+import { describe, it, expect, afterEach } from "vitest";
+import http from "node:http";
+import {
+  parseModuleNotFoundError,
+  isModuleNotFoundError,
+  detectInstallLayout,
+  suggestedReinstallCommand,
+  buildRecoveryHtml,
+  startRecoveryServer,
+} from "../recovery-server.js";
+
+describe("parseModuleNotFoundError", () => {
+  it("extracts a bare-module name from ERR_MODULE_NOT_FOUND", () => {
+    const e = Object.assign(new Error("Cannot find module 'fastify'"), {
+      code: "ERR_MODULE_NOT_FOUND",
+    });
+    expect(parseModuleNotFoundError(e)).toBe("fastify");
+  });
+
+  it("extracts an absolute path from ERR_MODULE_NOT_FOUND", () => {
+    const e = Object.assign(
+      new Error("Cannot find module '/abs/path/foo.cjs' imported from /bar"),
+      { code: "ERR_MODULE_NOT_FOUND" },
+    );
+    expect(parseModuleNotFoundError(e)).toBe("/abs/path/foo.cjs");
+  });
+
+  it("handles 'Cannot find package' phrasing", () => {
+    const e = Object.assign(new Error("Cannot find package 'toad-cache'"), {
+      code: "ERR_MODULE_NOT_FOUND",
+    });
+    expect(parseModuleNotFoundError(e)).toBe("toad-cache");
+  });
+
+  it("handles legacy MODULE_NOT_FOUND", () => {
+    const e = Object.assign(new Error("Cannot find module 'foo'"), {
+      code: "MODULE_NOT_FOUND",
+    });
+    expect(parseModuleNotFoundError(e)).toBe("foo");
+  });
+
+  it("returns null for non-module errors", () => {
+    expect(parseModuleNotFoundError(new Error("nope"))).toBeNull();
+    expect(parseModuleNotFoundError(null)).toBeNull();
+    expect(parseModuleNotFoundError(undefined)).toBeNull();
+  });
+});
+
+describe("isModuleNotFoundError", () => {
+  it("recognizes ERR_MODULE_NOT_FOUND", () => {
+    const e = Object.assign(new Error("Cannot find module 'x'"), { code: "ERR_MODULE_NOT_FOUND" });
+    expect(isModuleNotFoundError(e)).toBe(true);
+  });
+
+  it("recognizes phrase-only matches (no code)", () => {
+    expect(isModuleNotFoundError(new Error("Cannot find module 'x'"))).toBe(true);
+    expect(isModuleNotFoundError(new Error("Cannot find package 'x'"))).toBe(true);
+  });
+
+  it("rejects unrelated errors", () => {
+    expect(isModuleNotFoundError(new Error("EADDRINUSE"))).toBe(false);
+    expect(isModuleNotFoundError(null)).toBe(false);
+  });
+});
+
+describe("detectInstallLayout", () => {
+  it("detects npm-global layout", () => {
+    expect(
+      detectInstallLayout("/usr/local/lib/node_modules/@blackbelt-technology/pi-agent-dashboard/packages/server/src/cli.ts"),
+    ).toBe("npm-global");
+  });
+
+  it("detects monorepo layout", () => {
+    expect(detectInstallLayout("/Users/x/repo/packages/server/src/cli.ts")).toBe("monorepo");
+  });
+
+  it("returns unknown for unrecognized paths", () => {
+    expect(detectInstallLayout("/tmp/foo.js")).toBe("unknown");
+  });
+});
+
+describe("suggestedReinstallCommand", () => {
+  it("returns npm -g for npm-global", () => {
+    expect(suggestedReinstallCommand("npm-global")).toMatch(/npm install -g/);
+  });
+  it("returns repo-root install for monorepo", () => {
+    expect(suggestedReinstallCommand("monorepo")).toMatch(/repo root/);
+  });
+});
+
+describe("buildRecoveryHtml", () => {
+  it("includes the missing-module identifier and error stack", () => {
+    const html = buildRecoveryHtml({
+      port: 8000,
+      error: Object.assign(new Error("Cannot find module 'fastify'"), { stack: "STACK_TRACE_HERE" }),
+      missingModule: "fastify",
+      suggestedFix: "npm install -g foo",
+    });
+    expect(html).toContain("fastify");
+    expect(html).toContain("STACK_TRACE_HERE");
+    expect(html).toContain("npm install -g foo");
+    expect(html).toContain("Recovery Mode");
+  });
+
+  it("escapes HTML in error messages to prevent XSS", () => {
+    const html = buildRecoveryHtml({
+      port: 8000,
+      error: new Error("<script>alert('x')</script>"),
+      missingModule: "<img onerror=1>",
+    });
+    expect(html).not.toContain("<script>alert");
+    expect(html).toContain("&lt;script&gt;");
+    expect(html).toContain("&lt;img");
+  });
+
+  it("handles missing optional fields gracefully", () => {
+    const html = buildRecoveryHtml({
+      port: 8000,
+      error: new Error("oops"),
+    });
+    expect(html).toContain("(unknown)");
+  });
+});
+
+// Pick an ephemeral port (0 → OS assigns) and verify the live HTTP server.
+async function withRecoveryServer<T>(
+  fn: (port: number) => Promise<T>,
+): Promise<T> {
+  // Probe an open port via a throwaway server.
+  const probe = http.createServer();
+  await new Promise<void>((r) => probe.listen(0, () => r()));
+  const port = (probe.address() as { port: number }).port;
+  await new Promise<void>((r) => probe.close(() => r()));
+
+  // Capture & swallow noisy console.error during the test
+  const origErr = console.error;
+  console.error = () => {};
+
+  // Start in the background — startRecoveryServer resolves once `listen`
+  // succeeds (server keeps running on its own).
+  await startRecoveryServer({
+    port,
+    error: new Error("Cannot find module 'fastify'"),
+    missingModule: "fastify",
+  });
+
+  try {
+    return await fn(port);
+  } finally {
+    console.error = origErr;
+    // No clean shutdown API — the test will leak the server until vitest
+    // tears the worker down. Acceptable for unit tests.
+  }
+}
+
+async function fetchText(url: string): Promise<{ status: number; body: string; contentType: string }> {
+  return new Promise((resolve, reject) => {
+    http
+      .get(url, (res) => {
+        const chunks: Buffer[] = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () =>
+          resolve({
+            status: res.statusCode ?? 0,
+            body: Buffer.concat(chunks).toString("utf8"),
+            contentType: res.headers["content-type"] ?? "",
+          }),
+        );
+      })
+      .on("error", reject);
+  });
+}
+
+describe("startRecoveryServer (integration)", () => {
+  it("serves the recovery HTML at /", async () => {
+    await withRecoveryServer(async (port) => {
+      const res = await fetchText(`http://127.0.0.1:${port}/`);
+      expect(res.status).toBe(200);
+      expect(res.contentType).toMatch(/text\/html/);
+      expect(res.body).toContain("Recovery Mode");
+      expect(res.body).toContain("fastify");
+    });
+  });
+
+  it("returns recovery-mode JSON at /api/health", async () => {
+    await withRecoveryServer(async (port) => {
+      const res = await fetchText(`http://127.0.0.1:${port}/api/health`);
+      expect(res.status).toBe(200);
+      const parsed = JSON.parse(res.body);
+      expect(parsed.ok).toBe(false);
+      expect(parsed.mode).toBe("recovery");
+      expect(parsed.missingModule).toBe("fastify");
+    });
+  });
+
+  it("falls through to recovery HTML for unknown routes", async () => {
+    await withRecoveryServer(async (port) => {
+      const res = await fetchText(`http://127.0.0.1:${port}/some/unknown/path`);
+      expect(res.status).toBe(200);
+      expect(res.body).toContain("Recovery Mode");
+    });
+  });
+});

package/packages/server/src/__tests__/session-action-handler-clear-queue.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for pi-native queue control handlers. See change: add-followup-edit-and-steer-cancel.
+ */
+import { describe, it, expect, vi } from "vitest";
+import {
+  handleClearSteeringQueue,
+  handleClearFollowupSlot,
+  handleEditFollowupSlot,
+  handlePromoteFollowupEntry,
+  handleRemoveFollowupEntry,
+  handleEditFollowupEntry,
+} from "../browser-handlers/session-action-handler.js";
+
+function makeCtx(sessionExists: boolean) {
+  const sendToSession = vi.fn();
+  return {
+    sendToSession,
+    ctx: {
+      sessionManager: {
+        get: vi.fn().mockReturnValue(sessionExists ? { id: "s1", cwd: "/p" } : undefined),
+      },
+      piGateway: { sendToSession },
+    } as never,
+  };
+}
+
+describe("handleClearSteeringQueue", () => {
+  it("forwards clear_steering_queue to the bridge when session exists", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handleClearSteeringQueue({ type: "clear_steering_queue", sessionId: "s1" }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", { type: "clear_steering_queue", sessionId: "s1" });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handleClearSteeringQueue({ type: "clear_steering_queue", sessionId: "missing" }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("handleClearFollowupSlot", () => {
+  it("forwards clear_followup_slot to the bridge when session exists", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handleClearFollowupSlot({ type: "clear_followup_slot", sessionId: "s1" }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", { type: "clear_followup_slot", sessionId: "s1" });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handleClearFollowupSlot({ type: "clear_followup_slot", sessionId: "missing" }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("handleEditFollowupSlot", () => {
+  it("forwards edit_followup_slot with text + images to the bridge", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handleEditFollowupSlot({ type: "edit_followup_slot", sessionId: "s1", text: "revised", images: undefined }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "edit_followup_slot",
+      sessionId: "s1",
+      text: "revised",
+      images: undefined,
+    });
+  });
+
+  it("preserves images array when provided", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    const images = [{ type: "image" as const, data: "AAA", mimeType: "image/png" }];
+    handleEditFollowupSlot({ type: "edit_followup_slot", sessionId: "s1", text: "with image", images }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "edit_followup_slot",
+      sessionId: "s1",
+      text: "with image",
+      images,
+    });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handleEditFollowupSlot({ type: "edit_followup_slot", sessionId: "missing", text: "hi" }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("handlePromoteFollowupEntry (v2)", () => {
+  it("forwards promote_followup_entry with index", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handlePromoteFollowupEntry({ type: "promote_followup_entry", sessionId: "s1", index: 2 }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "promote_followup_entry",
+      sessionId: "s1",
+      index: 2,
+    });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handlePromoteFollowupEntry({ type: "promote_followup_entry", sessionId: "missing", index: 0 }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("handleRemoveFollowupEntry (v2)", () => {
+  it("forwards remove_followup_entry with index", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handleRemoveFollowupEntry({ type: "remove_followup_entry", sessionId: "s1", index: 1 }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "remove_followup_entry",
+      sessionId: "s1",
+      index: 1,
+    });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handleRemoveFollowupEntry({ type: "remove_followup_entry", sessionId: "missing", index: 0 }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("handleEditFollowupEntry (v2)", () => {
+  it("forwards edit_followup_entry with index + text", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    handleEditFollowupEntry({ type: "edit_followup_entry", sessionId: "s1", index: 1, text: "updated" }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "edit_followup_entry",
+      sessionId: "s1",
+      index: 1,
+      text: "updated",
+      images: undefined,
+    });
+  });
+
+  it("preserves images when provided", () => {
+    const { sendToSession, ctx } = makeCtx(true);
+    const images = [{ type: "image" as const, data: "AAA", mimeType: "image/png" }];
+    handleEditFollowupEntry({ type: "edit_followup_entry", sessionId: "s1", index: 0, text: "img", images }, ctx);
+    expect(sendToSession).toHaveBeenCalledWith("s1", {
+      type: "edit_followup_entry",
+      sessionId: "s1",
+      index: 0,
+      text: "img",
+      images,
+    });
+  });
+
+  it("drops silently when session is unknown", () => {
+    const { sendToSession, ctx } = makeCtx(false);
+    handleEditFollowupEntry({ type: "edit_followup_entry", sessionId: "missing", index: 0, text: "x" }, ctx);
+    expect(sendToSession).not.toHaveBeenCalled();
+  });
+});

package/packages/server/src/__tests__/session-action-handler-headless-reload.test.ts

@@ -464,4 +464,47 @@ describe("handleSendPrompt — interception wiring", () => {
     expect(spawnPiSession).not.toHaveBeenCalled();
     expect(ctx.piGateway.sendToSession).toHaveBeenCalled();
   });
+
+  it("forwards delivery field to bridge unchanged", async () => {
+    const { ctx } = makeCtx({
+      pidBySession: { S1: undefined },
+      sessions: {
+        S1: { id: "S1", cwd: "/p", sessionFile: "/p/s.jsonl", status: "active" },
+      },
+    });
+
+    await handleSendPrompt(
+      {
+        type: "send_prompt",
+        sessionId: "S1",
+        text: "steer this",
+        delivery: "steer",
+      } as any,
+      ctx,
+    );
+
+    expect(ctx.piGateway.sendToSession).toHaveBeenCalledWith(
+      "S1",
+      expect.objectContaining({ delivery: "steer" }),
+    );
+  });
+
+  it("forwards undefined delivery as undefined (JSON.stringify strips on wire)", async () => {
+    const { ctx } = makeCtx({
+      pidBySession: { S1: undefined },
+      sessions: {
+        S1: { id: "S1", cwd: "/p", sessionFile: "/p/s.jsonl", status: "active" },
+      },
+    });
+
+    await handleSendPrompt(
+      { type: "send_prompt", sessionId: "S1", text: "no delivery" } as any,
+      ctx,
+    );
+
+    expect(ctx.piGateway.sendToSession).toHaveBeenCalledWith(
+      "S1",
+      expect.objectContaining({ delivery: undefined }),
+    );
+  });
 });

package/packages/server/src/__tests__/session-order-manager.test.ts

@@ -12,6 +12,15 @@ function createMockPreferencesStore(initialOrder: Record<string, string[]> = {})
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/session-order-reboot.test.ts

@@ -34,6 +34,15 @@ function makePrefs(): PreferencesStore {
     pinDirectory: () => {},
     unpinDirectory: () => {},
     reorderPinnedDirs: () => {},
+    getWorkspaces: () => [],
+    createWorkspace: () => null,
+    renameWorkspace: () => false,
+    deleteWorkspace: () => false,
+    setWorkspaceCollapsed: () => false,
+    addFolderToWorkspace: () => false,
+    removeFolderFromWorkspace: () => false,
+    reorderWorkspaceFolders: () => false,
+    reorderWorkspaces: () => false,
     flush: () => {},
     dispose: () => {},
   };

package/packages/server/src/__tests__/session-ordering-integration.test.ts

@@ -16,6 +16,15 @@ function createMockPreferencesStore(): PreferencesStore {
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };