hop2 0.11.11 → 0.11.13

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -7,7 +7,8 @@ import {
   type CSSProperties,
   type FormEvent,
   type MouseEvent as ReactMouseEvent,
-  type PointerEvent as ReactPointerEvent
+  type PointerEvent as ReactPointerEvent,
+  type ReactNode
 } from "react";
 import { Terminal } from "@xterm/xterm";
 import { FitAddon } from "@xterm/addon-fit";
@@ -38,6 +39,17 @@ const LONG_PRESS_MS = 450;
 const PREVIEW_REFRESH_MS = 5000;
 const FILTER_THRESHOLD = 10;
 
+// Mark the query terms inside a content-match snippet so the eye lands on WHY
+// the line matched instead of re-scanning it. Terms mirror the server's
+// AND-term split.
+const highlightSnippet = (snippet: string, query: string): ReactNode => {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (!terms.length) return snippet;
+  const pattern = terms.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const parts = snippet.split(new RegExp(`(${pattern})`, "ig"));
+  return parts.map((part, i) => (i % 2 === 1 ? <mark key={i}>{part}</mark> : part));
+};
+
 // Zoom ladder: one +/− press per step. Each level sets the grid's minimum
 // tile width, the preview window height, and the preview font size (the
 // focused terminal inherits the same metrics so preview → terminal stays a
@@ -343,6 +355,11 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   // Wired by the live effect; watch mode leaves them null so keys go nowhere.
   const sendInputRef = useRef<((data: string) => void) | null>(null);
   const kbdEnhancedRef = useRef(false);
+  // Throttle gate for typing-driven size ownership (below) — same 500ms
+  // budget as the full-screen terminal's fit-on-type, and for the same
+  // reason: proposeDimensions() forces a layout read, and doing that on
+  // every keystroke is what stalled touch input on phones there.
+  const lastTypeFitAtRef = useRef(0);
   // null = watching; "live"/"down" = connected state for the chrome.
   const [conn, setConn] = useState<"live" | "down" | null>(null);
   // Last bytes from the session — paces the app-scroll coast (flywheel).
@@ -724,7 +741,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     const sock = new WebSocket(
       wsBase + sep + "room=" + encodeURIComponent(room)
       + "&name=" + encodeURIComponent((userName || "user") + " (wall)")
-      + "&replay=0&cols=" + dims.cols + "&rows=" + dims.rows
+      + "&source=monitor&replay=0&cols=" + dims.cols + "&rows=" + dims.rows
     );
     sock.onopen = () => {
       try {
@@ -927,6 +944,30 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     };
     connect();
     sendInputRef.current = (data: string) => {
+      // A keystroke INTO this tile is a genuine user action on it — per the
+      // size-ownership model, it should take the size and fit the tile it
+      // was typed into. Until now the tile only ever declared the SESSION's
+      // mirrored size (from wsUrl's cols/rows, unchanged since connect), so
+      // the server's keystroke ownership-transfer had nothing to apply: the
+      // tile "won" but never actually resized to itself. Declare the tile's
+      // own box fit as an ordinary resize (no claim, no monitor tag) before
+      // the input — same pattern as SecondaryPane's fitFocused(), applied on
+      // typing here since a wall tile has no separate focus/blur moment.
+      const nowFit = performance.now();
+      if (ws && ws.readyState === WebSocket.OPEN && nowFit - lastTypeFitAtRef.current > 500) {
+        lastTypeFitAtRef.current = nowFit;
+        const fitAddon = fitRef.current;
+        const boxEl = boxRef.current;
+        const t = termRef.current;
+        if (fitAddon && boxEl && t && boxEl.clientWidth >= 60 && boxEl.clientHeight >= 40) {
+          const dims = fitAddon.proposeDimensions();
+          if (dims?.cols && dims?.rows && dims.cols >= 20 && dims.rows >= 5
+            && (t.cols !== dims.cols || t.rows !== dims.rows)) {
+            t.resize(dims.cols, dims.rows);
+            ws.send(JSON.stringify({ type: "resize", cols: dims.cols, rows: dims.rows }));
+          }
+        }
+      }
       if (!ws || ws.readyState !== WebSocket.OPEN) {
         pendingInput.push({ data, at: Date.now() });
         if (pendingInput.length > 200) pendingInput.shift();
@@ -1513,10 +1554,14 @@ export const SessionSwitcher = ({
   // Content-aware matches: debounced grep over each session's recent screen
   // text (daemon-side, over already-retained output — no index, no polling).
   const [contentMatches, setContentMatches] = useState<Array<{ session: SwitcherSession; snippet: string }>>([]);
+  // The server caps how many sessions it greps per keystroke; when the fleet
+  // exceeds the cap, say so — silence would read as "searched everything".
+  const [contentTruncated, setContentTruncated] = useState(false);
   useEffect(() => {
     const q = filter.trim();
     if (!open || q.length < 3) {
       setContentMatches([]);
+      setContentTruncated(false);
       return;
     }
     let cancelled = false;
@@ -1534,8 +1579,12 @@ export const SessionSwitcher = ({
             })
             .filter(Boolean) as Array<{ session: SwitcherSession; snippet: string }>
         );
+        setContentTruncated(data?.truncated === true);
       } catch {
-        if (!cancelled) setContentMatches([]);
+        if (!cancelled) {
+          setContentMatches([]);
+          setContentTruncated(false);
+        }
       }
     }, 250);
     return () => {
@@ -1544,6 +1593,37 @@ export const SessionSwitcher = ({
     };
   }, [open, filter, visibleSessions]);
 
+  // Full-history search: greps ENTIRE transcripts server-side (ripgrep), so
+  // it runs only when the user explicitly asks — never per keystroke. Results
+  // are pinned to the query they answered; editing the filter discards them.
+  const [deepSearch, setDeepSearch] = useState<{
+    q: string;
+    status: "loading" | "done" | "unavailable";
+    rows: Array<{ session: SwitcherSession; snippet: string }>;
+  } | null>(null);
+  useEffect(() => {
+    if (deepSearch && deepSearch.q !== filter.trim()) setDeepSearch(null);
+  }, [filter, deepSearch]);
+  const runDeepSearch = async () => {
+    const q = filter.trim();
+    if (q.length < 3) return;
+    setDeepSearch({ q, status: "loading", rows: [] });
+    try {
+      const res = await fetch(`/api/sessions/search?q=${encodeURIComponent(q)}&deep=1`);
+      const data = await res.json();
+      const byKey = new Map(visibleSessions.map((s) => [s.internalName || s.name, s]));
+      const rows = (Array.isArray(data?.matches) ? data.matches : [])
+        .map((m: { internalName?: string; name?: string; snippet?: string }) => {
+          const session = byKey.get(m.internalName || "") || byKey.get(m.name || "");
+          return session ? { session, snippet: m.snippet || "" } : null;
+        })
+        .filter(Boolean) as Array<{ session: SwitcherSession; snippet: string }>;
+      setDeepSearch({ q, status: data?.deepUnavailable ? "unavailable" : "done", rows });
+    } catch {
+      setDeepSearch({ q, status: "unavailable", rows: [] });
+    }
+  };
+
   // Content matches the name filter didn't already surface.
   const extraContentMatches = useMemo(() => {
     // Content hits surface in EVERY mode under a query. They were rendered
@@ -1565,18 +1645,39 @@ export const SessionSwitcher = ({
     return contentMatches.filter((m) => !seen.has(sessionKey(m.session)));
   }, [model, contentMatches, filter]);
 
+  // History hits the shallower tiers already showed are noise here — only
+  // sessions the user hasn't been offered yet earn a history card.
+  const extraDeepMatches = useMemo(() => {
+    if (!deepSearch || deepSearch.status !== "done" || deepSearch.q !== filter.trim()) return [];
+    const seen = new Set<string>();
+    if (model.mode === "filter") model.rows.forEach((r) => seen.add(sessionKey(r)));
+    else if (model.mode === "manual") {
+      model.rows.forEach((r) => seen.add(sessionKey(r)));
+      model.folders.forEach((f) => f.rows.forEach((r) => seen.add(sessionKey(r))));
+    }
+    extraContentMatches.forEach((m) => seen.add(sessionKey(m.session)));
+    const out: Array<{ session: SwitcherSession; snippet: string }> = [];
+    for (const m of deepSearch.rows) {
+      const key = sessionKey(m.session);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(m);
+    }
+    return out;
+  }, [deepSearch, model, extraContentMatches, filter]);
+
   // Flat navigation order = exactly the visual order: heroes, then group rows
   // (and under a filter: name matches, then on-screen content matches).
   const flatNav = useMemo<SwitcherSession[]>(
     () => {
-      if (model.mode === "filter") return [...model.rows, ...extraContentMatches.map((m) => m.session)];
+      if (model.mode === "filter") return [...model.rows, ...extraContentMatches.map((m) => m.session), ...extraDeepMatches.map((m) => m.session)];
       // Folder rows come first because that is their visual order; keyboard
       // ↑/↓ and Enter must traverse what the eye sees, foldered included.
-      if (model.mode === "manual") return [...model.folders.flatMap((f) => f.rows), ...model.rows, ...extraContentMatches.map((m) => m.session)];
+      if (model.mode === "manual") return [...model.folders.flatMap((f) => f.rows), ...model.rows, ...extraContentMatches.map((m) => m.session), ...extraDeepMatches.map((m) => m.session)];
       if (model.mode === "project") return model.groups.flatMap((g) => g.rows);
       return [...model.hero, ...model.groups.flatMap((g) => g.rows)];
     },
-    [model, extraContentMatches]
+    [model, extraContentMatches, extraDeepMatches]
   );
   const navIndexByKey = useMemo(() => {
     const m = new Map<string, number>();
@@ -2434,7 +2535,7 @@ export const SessionSwitcher = ({
                 : (preview?.text || " ")}
           </pre>
         )}
-        {snippet && <div className="switcher-card-snippet" title={snippet}>{snippet}</div>}
+        {snippet && <div className="switcher-card-snippet" title={snippet}>{highlightSnippet(snippet, filter.trim())}</div>}
         <div className="switcher-card-meta">
           <span className="switcher-card-dir" title={s.cwd || undefined}>{dirPath(s) ? `\u200E${dirPath(s)}\u200E` : "\u00a0"}</span>
           <span className="switcher-card-when">{meta(s)}</span>
@@ -2482,6 +2583,50 @@ export const SessionSwitcher = ({
   const sheetSession = sheet?.session;
   const sheetAgentPermitted = sheetSession?.agentPermitted === true;
 
+  // Content/history hits plus the full-history row, rendered below whatever
+  // the mode showed. Manual mode keeps its own branch under a query (filtering
+  // narrows the user's order in place), so this tail must ride along there
+  // too — search reaches past the name tier in every mode, not just Recent.
+  const searchTail = filter.trim() ? (
+    <>
+      {extraContentMatches.length > 0 && (
+        <section className="switcher-group">
+          <h3 className="switcher-group-label">found in terminal output{contentTruncated ? " · most recent sessions only" : ""}</h3>
+          <div className="switcher-grid">
+            {extraContentMatches.map(({ session: s, snippet }) => renderCard(s, snippet))}
+          </div>
+        </section>
+      )}
+      {extraDeepMatches.length > 0 && (
+        <section className="switcher-group">
+          <h3 className="switcher-group-label">found in full history</h3>
+          <div className="switcher-grid">
+            {extraDeepMatches.map(({ session: s, snippet }) => renderCard(s, snippet))}
+          </div>
+        </section>
+      )}
+      {filter.trim().length >= 3 && (
+        <div className="switcher-deep-row">
+          {!deepSearch ? (
+            <button type="button" className="switcher-deep-btn" onClick={runDeepSearch}>
+              Search full history for “{filter.trim()}”
+            </button>
+          ) : deepSearch.status === "loading" ? (
+            <span className="switcher-deep-note">searching full history…</span>
+          ) : deepSearch.status === "unavailable" ? (
+            <span className="switcher-deep-note">full-history search unavailable on this host</span>
+          ) : (
+            <span className="switcher-deep-note">
+              {extraDeepMatches.length > 0
+                ? `${extraDeepMatches.length} more in full history`
+                : "nothing further back matches"}
+            </span>
+          )}
+        </div>
+      )}
+    </>
+  ) : null;
+
   return (
     <div
       // tile-dense: too narrow for inline actions. tile-micro: too short for
@@ -2669,19 +2814,12 @@ export const SessionSwitcher = ({
           // cards at the current zoom, same as the wall — the screen content
           // is usually WHY you're looking for the session.
           <>
-            {model.rows.length === 0 && extraContentMatches.length === 0 ? (
+            {model.rows.length === 0 && extraContentMatches.length === 0 && extraDeepMatches.length === 0 ? (
               <div className="switcher-empty">No sessions match “{filter.trim()}”</div>
             ) : (
               <div className="switcher-grid">{model.rows.map((s) => renderCard(s))}</div>
             )}
-            {extraContentMatches.length > 0 && (
-              <section className="switcher-group">
-                <h3 className="switcher-group-label">found in terminal output</h3>
-                <div className="switcher-grid">
-                  {extraContentMatches.map(({ session: s, snippet }) => renderCard(s, snippet))}
-                </div>
-              </section>
-            )}
+            {searchTail}
           </>
         ) : model.mode === "project" ? (
           <>
@@ -2707,7 +2845,9 @@ export const SessionSwitcher = ({
         ) : model.mode === "manual" ? (
           <>
             {model.rows.length === 0 && model.folders.every((f) => f.rows.length === 0) ? (
-              <div className="switcher-empty">{filter.trim() ? "No matches" : "No sessions"}</div>
+              extraContentMatches.length === 0 && extraDeepMatches.length === 0 && (
+                <div className="switcher-empty">{filter.trim() ? "No matches" : "No sessions"}</div>
+              )
             ) : (
               <>
                 <p className="switcher-hint">
@@ -2784,6 +2924,7 @@ export const SessionSwitcher = ({
                 <div className="switcher-grid">{model.rows.map((s) => renderCard(s))}</div>
               </>
             )}
+            {searchTail}
           </>
         ) : (
           <>

package/hay/apps/web/src/styles.css

@@ -2893,6 +2893,38 @@ button.primary {
   text-overflow: ellipsis;
   white-space: nowrap;
 }
+.switcher-card-snippet mark {
+  background: none;
+  color: var(--accent);
+  font-weight: 600;
+}
+
+/* Full-history search: an explicit act, so it's a button under the results,
+   never something a keystroke triggers. */
+.switcher-deep-row {
+  display: flex;
+  justify-content: center;
+  padding: 10px 0 14px;
+}
+.switcher-deep-btn {
+  font-family: var(--font-mono);
+  font-size: 11.5px;
+  color: var(--ink-muted);
+  background: var(--bg-alt);
+  border: 1px solid var(--line);
+  border-radius: 7px;
+  padding: 6px 12px;
+  cursor: pointer;
+}
+.switcher-deep-btn:hover {
+  color: var(--ink);
+  border-color: var(--ink-muted);
+}
+.switcher-deep-note {
+  font-family: var(--font-mono);
+  font-size: 11.5px;
+  color: var(--ink-muted);
+}
 
 /* Tap-a-URL prompt (mobile: remote apps can't open the phone's browser) */
 /* Link menu: the terminal's tap-a-URL menu, on the shared context-menu look.

package/hay/apps/web/src/utils/switcherModel.ts

@@ -107,28 +107,63 @@ export const projectKey = (cwd?: string) => {
   return (lead ? lead + "/" : "/") + kept.join("/");
 };
 
+/** Characters of `needle` appear in `hay` in order (VS Code-style fuzzy). */
+const isSubsequence = (needle: string, hay: string): boolean => {
+  let i = 0;
+  for (let j = 0; j < hay.length && i < needle.length; j++) {
+    if (hay[j] === needle[i]) i++;
+  }
+  return i === needle.length;
+};
+
 /**
- * Ranked filter matching: exact beats prefix beats substring, and the
+ * Ranked matching for ONE term: exact beats prefix beats substring, and the
  * home-shortened cwd the UI displays is first-class ("~" must rank sessions
- * whose workdir IS ~ above everything that merely lives under it).
+ * whose workdir IS ~ above everything that merely lives under it). Below the
+ * name/cwd tiers come the user's own descriptions — the tagline (`hop ai
+ * tagline`) and the folder the session is filed in — then the foreground
+ * process, then a typo-tolerant subsequence tier ("hubl" still finds Hubble;
+ * 3+ chars so one letter can't fuzzy-match half the wall).
  */
-export const filterScore = (s: SwitcherSession, q: string): number => {
+const termScore = (s: SwitcherSession, t: string, folderName: string): number => {
   const name = (s.displayName || s.name).toLowerCase();
   const cwdRaw = (s.cwd || "").toLowerCase();
   const cwdShort = s.cwd ? shortenForGroup(s.cwd).toLowerCase() : "";
   const proc = (s.foregroundProcess || "").toLowerCase();
-  if (name === q) return 100;
-  if (cwdShort === q) return 90; // exact workdir ("~", "~/code/hop2")
-  if (name.startsWith(q)) return 80;
+  const tagline = (s.tagline || "").toLowerCase();
+  if (name === t) return 100;
+  if (cwdShort === t) return 90; // exact workdir ("~", "~/code/hop2")
+  if (name.startsWith(t)) return 80;
   const cwdBase = cwdShort.split("/").filter(Boolean).pop() || "";
-  if (cwdBase === q) return 70; // project dir name typed exactly
-  if (name.includes(q)) return 60;
-  if (cwdShort.startsWith(q)) return 55; // workdir prefix ("~/code")
-  if (cwdShort.includes(q) || cwdRaw.includes(q)) return 40;
-  if (proc.includes(q)) return 30;
+  if (cwdBase === t) return 70; // project dir name typed exactly
+  if (name.includes(t)) return 60;
+  if (cwdShort.startsWith(t)) return 55; // workdir prefix ("~/code")
+  if (tagline.includes(t)) return 50; // the user's own words for the session
+  if (folderName.includes(t)) return 45; // the folder they filed it in
+  if (cwdShort.includes(t) || cwdRaw.includes(t)) return 40;
+  if (proc.includes(t)) return 30;
+  if (t.length >= 3 && isSubsequence(t, name)) return 20;
   return 0;
 };
 
+/**
+ * Multi-word queries are AND-terms, each free to hit a different field —
+ * "hop web" matches a session named "web" in ~/Code/hop2. The score is the
+ * weakest term's (every word must genuinely match), so single-term queries
+ * rank exactly as before.
+ */
+export const filterScore = (s: SwitcherSession, q: string, folderName = ""): number => {
+  const terms = q.split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return 0;
+  let weakest = Infinity;
+  for (const t of terms) {
+    const score = termScore(s, t, folderName);
+    if (score === 0) return 0;
+    if (score < weakest) weakest = score;
+  }
+  return weakest;
+};
+
 export const filterSessionsByOrigin = (
   sessions: SwitcherSession[],
   scope: SessionOriginScope
@@ -231,7 +266,11 @@ export const buildSwitcherModel = (
   const query = filter.trim();
   if (query) {
     const q = query.toLowerCase();
-    const matches = sessions.filter((s) => filterScore(s, q) > 0);
+    // Typing a folder's name surfaces the sessions filed in it.
+    const folderNameById = new Map(folders.map((f) => [f.id, f.name.toLowerCase()]));
+    const scoreOf = (s: SwitcherSession) =>
+      filterScore(s, q, (s.folderId && folderNameById.get(s.folderId)) || "");
+    const matches = sessions.filter((s) => scoreOf(s) > 0);
     // Manual mode: filtering NARROWS the wall, it never re-ranks it. Keeping
     // the user's own order in the filtered view is what makes "find it, then
     // drag it" work — you can see where a card sits relative to the other
@@ -246,7 +285,7 @@ export const buildSwitcherModel = (
       return { mode: "manual", rows: split.loose, folders: split.folders };
     }
     const rows = matches
-      .map((s) => ({ s, score: filterScore(s, q) }))
+      .map((s) => ({ s, score: scoreOf(s) }))
       .sort((a, b) => b.score - a.score || byAttentionThenRecency(a.s, b.s))
       .map((x) => x.s);
     return { mode: "filter", rows };

package/hay/apps/web/test/SessionSwitcher.test.tsx

@@ -325,4 +325,16 @@ describe("manual folders in the wall", () => {
     expect(screen.getByText("inside")).toBeTruthy();
     expect(screen.getByText("Filed")).toBeTruthy();
   });
+
+  it("a query in manual mode still offers the full-history search", () => {
+    // Manual keeps its own render branch under a query (narrow-in-place), so
+    // the search tail — content hits + the deep button — must ride along or
+    // manual-mode users never see anything past the name tier.
+    render(<SessionSwitcher {...props} sessions={withFolder} folders={folders} open />);
+    fireEvent.click(screen.getByRole("button", { name: "Manual" }));
+    const input = document.querySelector(".switcher-top input") as HTMLInputElement
+      || document.querySelector("input") as HTMLInputElement;
+    fireEvent.change(input, { target: { value: "outsid" } });
+    expect(screen.getByRole("button", { name: /Search full history for/ })).toBeTruthy();
+  });
 });

package/hay/apps/web/test/switcherModel.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   buildSwitcherModel,
+  filterScore,
   filterSessionsByOrigin,
   projectKey,
   relativeTime,
@@ -375,3 +376,63 @@ describe("manual mode folders under filter", () => {
     expect(model.rows).toEqual([]); // loose list empty ≠ no results
   });
 });
+
+describe("filterScore tiers", () => {
+  it("searches taglines — the user's own words for a session", () => {
+    const s = mk({ name: "exp42", tagline: "protein folding sweep" });
+    expect(filterScore(s, "folding")).toBe(50);
+    expect(filterScore(mk({ name: "exp43" }), "folding")).toBe(0);
+  });
+
+  it("ranks a name substring above a tagline hit", () => {
+    const byName = mk({ name: "folding-ui" });
+    const byTagline = mk({ name: "exp42", tagline: "protein folding sweep" });
+    expect(filterScore(byName, "folding")).toBeGreaterThan(filterScore(byTagline, "folding"));
+  });
+
+  it("multi-word terms AND across different fields", () => {
+    const s = mk({ name: "web", cwd: "/Users/x/Code/hop2" });
+    expect(filterScore(s, "hop2 web")).toBeGreaterThan(0);
+    expect(filterScore(s, "hop2 nothere")).toBe(0);
+  });
+
+  it("multi-word score is the weakest term's — every word must earn the rank", () => {
+    const s = mk({ name: "web", cwd: "/Users/x/Code/hop2" });
+    // "web" hits the name exactly (100); "hop2" only the cwd (≤70).
+    expect(filterScore(s, "web hop2")).toBeLessThan(filterScore(s, "web"));
+  });
+
+  it("single-term ranking is unchanged: exact > prefix > substring", () => {
+    expect(filterScore(mk({ name: "hub" }), "hub")).toBe(100);
+    expect(filterScore(mk({ name: "hubble" }), "hub")).toBe(80);
+    expect(filterScore(mk({ name: "the-hub-x" }), "hub")).toBe(60);
+  });
+
+  it("tolerates typos via subsequence, ranked below everything else", () => {
+    const s = mk({ name: "hubble" });
+    expect(filterScore(s, "hbl")).toBe(20);
+    expect(filterScore(s, "hlb")).toBe(0); // order matters
+    expect(filterScore(mk({ name: "ab" }), "ab")).toBe(100);
+  });
+
+  it("subsequence needs 3+ chars so short queries stay literal", () => {
+    expect(filterScore(mk({ name: "hubble" }), "he")).toBe(0);
+  });
+
+  it("matches the folder a session is filed in, passed by the model", () => {
+    const folders = [{ id: "f1", name: "Experiments" }];
+    const sessions = [mk({ name: "alpha", folderId: "f1" }), mk({ name: "beta" })];
+    const model = buildSwitcherModel(sessions, null, "experi", "recent", [], folders);
+    if (model.mode !== "filter") throw new Error("expected filter");
+    expect(model.rows.map((r) => r.name)).toEqual(["alpha"]);
+  });
+
+  it("folder-name queries narrow manual mode to that folder's sessions", () => {
+    const folders = [{ id: "f1", name: "Experiments" }];
+    const sessions = [mk({ name: "alpha", folderId: "f1" }), mk({ name: "beta" })];
+    const model = buildSwitcherModel(sessions, null, "experiments", "manual", [], folders);
+    if (model.mode !== "manual") throw new Error("expected manual");
+    expect(model.folders[0].rows.map((r) => r.name)).toEqual(["alpha"]);
+    expect(model.rows).toEqual([]);
+  });
+});