feat(web): replace the @ mention with an /agent command, and stage both switches until send (#122)

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

packages/web/test/agent-handoff.test.ts

@@ -0,0 +1,139 @@
+/**
+ * agent-handoff.ts unit tests: the `/agent` picker's candidate filtering, the staged-switch
+ * send decision (`/agent` and `/model` only act on Enter — this is where "act on what, and
+ * when" is pinned down), and the re-export wiring for the origin marker blocks (their own
+ * semantics — both forms, anchoring, legacy compat — are covered by
+ * packages/core/test/markers.test.ts).
+ */
+import { describe, expect, it } from "vitest";
+import type { AgentSummary } from "@prismshadow/penguin-server/api";
+import {
+  filterAgents,
+  handoffMessage,
+  modelSwitchMessage,
+  parseHandoffMessage,
+  parseModelSwitchMessage,
+  parseScheduledMessage,
+  stagedSendRoute,
+} from "../src/features/chat/agent-handoff";
+
+const agent = (agentId: string, name?: string): AgentSummary => ({
+  agentId,
+  ...(name !== undefined ? { name } : {}),
+  activeSessionCount: 0,
+  sessionCount: 0,
+  sessionActivity: [],
+  toolCount: 0,
+  version: 1,
+  vaultKeyCount: 0,
+  scheduleCount: 0,
+  skillCount: 0,
+});
+
+const AGENTS: AgentSummary[] = [
+  agent("default_agent", "General Agent"),
+  agent("agent_creator", "Agent Creator"),
+  agent("agent_optimizer", "Agent Optimizer"),
+  agent("researcher"),
+];
+
+describe("filterAgents (the /agent picker's search box)", () => {
+  it("an empty or whitespace-only query returns all candidates", () => {
+    expect(filterAgents(AGENTS, "")).toHaveLength(4);
+    expect(filterAgents(AGENTS, "   ")).toHaveLength(4);
+  });
+
+  it("filters by agentId, case-insensitively", () => {
+    expect(filterAgents(AGENTS, "agent_").map((a) => a.agentId)).toEqual([
+      "agent_creator",
+      "agent_optimizer",
+    ]);
+    expect(filterAgents(AGENTS, "RES").map((a) => a.agentId)).toEqual(["researcher"]);
+  });
+
+  it("display names match too", () => {
+    expect(filterAgents(AGENTS, "General").map((a) => a.agentId)).toEqual(["default_agent"]);
+  });
+
+  it("matches anywhere in the id/name, not only at its start (substring rule, like the model search box)", () => {
+    expect(filterAgents(AGENTS, "creator").map((a) => a.agentId)).toEqual(["agent_creator"]);
+    expect(filterAgents(AGENTS, "optim").map((a) => a.agentId)).toEqual(["agent_optimizer"]);
+  });
+
+  it("nothing matches: the picker gets an empty list (and renders its no-match copy)", () => {
+    expect(filterAgents(AGENTS, "nobody")).toEqual([]);
+  });
+});
+
+describe("stagedSendRoute (what a staged /agent or /model chip does on send)", () => {
+  /** Defaults: an idle active session with nothing staged — the composer's ordinary state. */
+  const route = (over: Partial<Parameters<typeof stagedSendRoute>[0]> = {}) =>
+    stagedSendRoute({
+      handoffTarget: false,
+      pendingModel: false,
+      canSwitchModel: true,
+      sessionBusy: false,
+      ...over,
+    });
+
+  it("nothing staged: the message is an ordinary post", () => {
+    expect(route()).toBe("post");
+    // Even mid-run: steering and the follow-up queue are both plain posts.
+    expect(route({ sessionBusy: true })).toBe("post");
+  });
+
+  it("a staged handoff opens the new chat regardless of what this session is doing", () => {
+    // The handoff neither reads nor writes the running session — it is safe mid-run, and was
+    // already allowed there before the switches became staged.
+    expect(route({ handoffTarget: true })).toBe("handoff");
+    expect(route({ handoffTarget: true, sessionBusy: true })).toBe("handoff");
+  });
+
+  it("a staged model fork goes out only while this session is idle", () => {
+    expect(route({ pendingModel: true })).toBe("model");
+    // Running / compacting: the fork branches off a Trace still being appended to, and the run
+    // may have started from outside the composer (queued follow-up, schedule, another tab).
+    expect(route({ pendingModel: true, sessionBusy: true })).toBe("blocked");
+  });
+
+  it("blocked never degrades into a plain post: the message must not land in the session being left", () => {
+    // The distinction that matters — "blocked" is not "post". Falling through would deliver the
+    // draft to the very session the user staged a switch away from.
+    expect(route({ pendingModel: true, sessionBusy: true })).not.toBe("post");
+  });
+
+  it("where a fork is impossible at all (the draft page has no session to fork), the chip cannot block a send", () => {
+    expect(route({ pendingModel: true, canSwitchModel: false })).toBe("post");
+    expect(route({ pendingModel: true, canSwitchModel: false, sessionBusy: true })).toBe("post");
+  });
+
+  it("should both chips ever coexist, the handoff wins — it is the one that touches nothing here", () => {
+    expect(route({ handoffTarget: true, pendingModel: true })).toBe("handoff");
+    expect(route({ handoffTarget: true, pendingModel: true, sessionBusy: true })).toBe("handoff");
+  });
+});
+
+describe("origin marker blocks are re-exported from core", () => {
+  it("handoff / model-switch producers emit the square form and round-trip through the feature module", () => {
+    const handoff = handoffMessage({ agentId: "default_agent", workspace: "/data/ws" });
+    expect(handoff.startsWith("[handoff_from]\n")).toBe(true);
+    expect(parseHandoffMessage(handoff)).toEqual({
+      agentId: "default_agent",
+      workspace: "/data/ws",
+    });
+    const switched = modelSwitchMessage({ sessionId: "session-01", tracePath: "/t.jsonl" });
+    expect(switched.startsWith("[model_switch_from]\n")).toBe(true);
+    expect(parseModelSwitchMessage(switched)).toEqual({
+      sessionId: "session-01",
+      tracePath: "/t.jsonl",
+    });
+  });
+
+  it("the scheduled-task parser (server-produced block) is reachable here for the banner", () => {
+    expect(
+      parseScheduledMessage(
+        "[scheduled_task]\nschedule: daily\nfired_at: 2026-01-01T00:00:00Z\n[/scheduled_task]\n\nbody",
+      ),
+    ).toEqual({ origin: { name: "daily", firedAt: "2026-01-01T00:00:00Z" }, rest: "body" });
+  });
+});