hop2 0.11.39 → 0.11.40

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

@@ -2612,6 +2612,26 @@ button.primary {
   background: color-mix(in srgb, var(--err) 12%, transparent);
 }
 
+/* A file held over a card: this session is where it will land. */
+.switcher-card.file-drop {
+  outline: 2px dashed var(--accent);
+  outline-offset: -2px;
+}
+
+/* Folder picker: the session's current folder is marked, not highlighted —
+   a filled row in a list of plain rows reads as hover state. */
+.switcher-sheet > button.on {
+  font-weight: 600;
+}
+.switcher-sheet > button.on::before {
+  content: "✓";
+  margin-right: 6px;
+  color: var(--accent);
+}
+.switcher-sheet > button.back {
+  color: var(--ink-muted);
+}
+
 /* Touch: same menu, roomier targets. */
 @media (pointer: coarse) {
   .switcher-sheet {
@@ -3521,9 +3541,60 @@ button.primary {
 
 .switcher-create-row {
   display: flex;
+  flex-wrap: wrap;
   gap: 6px;
   padding: 0 16px 10px;
 }
+/* Working directory: its own full-width line under name + type, with the
+   completion list floating below it. */
+.switcher-create-cwd {
+  position: relative;
+  flex-basis: 100%;
+  min-width: 0;
+}
+.switcher-create-cwd input {
+  width: 100%;
+  box-sizing: border-box;
+}
+.cwd-suggest {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: calc(100% + 4px);
+  z-index: 30;
+  max-height: 240px;
+  overflow-y: auto;
+  padding: 4px;
+  border-radius: 8px;
+  background: var(--panel);
+  border: 1px solid var(--line);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12), 0 12px 32px rgba(0, 0, 0, 0.22);
+}
+.cwd-suggest-label {
+  padding: 4px 8px 2px;
+  font-size: 10.5px;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--ink-muted);
+}
+.switcher-create-row .cwd-suggest button {
+  display: block;
+  width: 100%;
+  padding: 6px 8px;
+  border: none;
+  border-radius: 6px;
+  background: none;
+  color: var(--ink);
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  cursor: pointer;
+}
+.switcher-create-row .cwd-suggest button.on,
+.switcher-create-row .cwd-suggest button:hover {
+  background: var(--bg-alt);
+}
 /* New-session launch-type picker: Terminal / Claude / Codex, a small
    segmented control in the create row. Maps to the create API's startup. */
 .switcher-create-type {
@@ -3731,13 +3802,19 @@ button.primary {
   0%, 100% { opacity: 1; transform: scale(1); }
   50% { opacity: 0.45; transform: scale(0.75); }
 }
+/* A live caption: what matters is the words arriving NOW. nowrap + ellipsis
+   pinned the START of the transcript and hid everything after the first
+   line, so a long dictation looked frozen. Right-aligned in a clipping flex
+   box, the text overflows off the LEFT edge and the tail stays in view. */
 .voice-text {
   font-family: var(--font-mono);
   font-size: 12.5px;
   color: var(--ink, #ddd);
   white-space: nowrap;
   overflow: hidden;
-  text-overflow: ellipsis;
+  display: flex;
+  justify-content: flex-end;
+  min-width: 0;
 }
 .voice-text.muted { color: var(--ink-muted, #888); }
 

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

@@ -0,0 +1,15 @@
+// The browser tab's title.
+//
+// A session tab reads by session: its name first, the app second, so a row
+// of hop tabs is scannable and still says what it is. The hub — no session
+// open — is just the app. Before this, the hub showed the placeholder room id
+// minted for a would-be new session ("room-k3x9q"), and the pre-hydration
+// title was the web package's internal name ("Hay"): neither named anything
+// the user had.
+export const APP_TITLE = "hop";
+
+export const tabTitle = (sessionLabel: string | null | undefined, alert: boolean): string => {
+  const label = (sessionLabel || "").trim();
+  const base = label ? `${label} · ${APP_TITLE}` : APP_TITLE;
+  return `${alert ? "● " : ""}${base}`;
+};

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

@@ -61,16 +61,25 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
   let finalText = "";
   let interimText = "";
   let rec: RecognitionLike | null = null;
+  /** stop() was called: the next onend is ours, not the recogniser giving up. */
+  let stopping = false;
+  /** Consecutive recogniser restarts that produced nothing — a loop guard. */
+  let emptyRestarts = 0;
 
   const finish = (sendText: boolean) => {
     if (!active) return;
     active = false;
     pending = false;
+    stopping = false;
+    emptyRestarts = 0;
     rec = null;
     window.clearTimeout(watchdog);
     window.removeEventListener("blur", onWindowBlur);
     opts.setOverlay(null);
-    const text = (finalText || interimText).trim();
+    // Final AND interim: a recogniser stopped by us often ends before it
+    // finalises the last phrase, and `final || interim` dropped that phrase
+    // whenever anything earlier had already been finalised.
+    const text = (finalText + interimText).trim();
     finalText = "";
     interimText = "";
     if (sendText && text) opts.send(text);
@@ -83,18 +92,37 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     // Silence here read as "voice randomly does nothing": the space vanished
     // (or didn't) and no overlay ever appeared, with no reason given.
     if (!Ctor) { opts.notify("Voice input is not supported in this browser"); return; }
-    let r: RecognitionLike;
-    try { r = new Ctor(); } catch { opts.notify("Voice input could not start"); return; }
     active = true;
+    stopping = false;
+    emptyRestarts = 0;
     finalText = "";
     interimText = "";
     // Erase every space that reached the app during this hold.
     for (let i = 0; i < Math.max(1, spacesTyped); i++) opts.send("\x7f");
     spacesTyped = 0;
+    armWatchdog();
+    window.addEventListener("blur", onWindowBlur);
+    opts.setOverlay("");
+    if (!listen(Ctor)) { opts.notify("Voice input could not start"); finish(false); }
+  };
+
+  // One recogniser session. The hold outlives it: browser recognisers end
+  // on their own schedule — Safari after a pause in speech, Chrome after a
+  // few seconds of silence ("no-speech") — and `continuous` does not change
+  // that in practice. Ending the hold with them meant dictation cut out
+  // while Space was still down and whatever came next was lost. So a
+  // recogniser that ends while the key is held is simply replaced; the words
+  // already final are kept, and only OUR stop() finishes the hold.
+  const listen = (Ctor: new () => RecognitionLike): boolean => {
+    let r: RecognitionLike;
+    try { r = new Ctor(); } catch { return false; }
+    let heard = false;
     r.lang = navigator.language || "en-US";
     r.continuous = true;
     r.interimResults = true;
     r.onresult = (ev) => {
+      heard = true;
+      emptyRestarts = 0;
       let interim = "";
       for (let i = ev.resultIndex; i < ev.results.length; i++) {
         const res = ev.results[i];
@@ -104,11 +132,25 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
       interimText = interim;
       opts.setOverlay((finalText + interim).trim());
     };
+    const ended = () => {
+      if (!active || rec !== r) return;      // an old recogniser, or already finished
+      if (stopping) { finish(true); return; } // released: type what we have
+      // A finished phrase is folded in; the interim is gone with the session.
+      interimText = "";
+      // Three recognisers in a row that heard nothing is the service refusing
+      // us, not silence — give the space bar back rather than spin forever.
+      if (!heard && ++emptyRestarts >= 3) { finish(true); return; }
+      opts.setOverlay(finalText.trim());
+      if (!listen(Ctor)) finish(true);
+    };
     r.onerror = (ev) => {
-      // EVERY failure explains itself. Only mic-denial was surfaced before;
-      // Chrome's cloud recognizer routinely fails with "network", and that
-      // silent death read as "voice randomly doesn't work".
       const code = ev?.error || "unknown";
+      // Quiet or interrupted while still held: not a failure, just this
+      // recogniser's session ending — the onend that follows restarts it.
+      if (active && !stopping && (code === "no-speech" || code === "aborted")) return;
+      // EVERY real failure explains itself. Only mic-denial was surfaced
+      // before; Chrome's cloud recogniser routinely fails with "network",
+      // and that silent death read as "voice randomly doesn't work".
       if (code === "not-allowed" || code === "service-not-allowed") {
         opts.notify("Microphone permission needed for voice input");
       } else if (code === "network") {
@@ -120,18 +162,17 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
       }
       finish(false);
     };
-    r.onend = () => finish(true);
+    r.onend = ended;
     rec = r;
-    armWatchdog();
-    window.addEventListener("blur", onWindowBlur);
-    opts.setOverlay("");
-    try { r.start(); } catch { opts.notify("Voice input could not start"); finish(false); }
+    try { r.start(); } catch { rec = null; return false; }
+    return true;
   };
 
   const stop = () => {
     const r = rec;
-    rec = null;
+    stopping = true;
     try { r?.stop(); } catch { /* already gone */ }
+    rec = null;
     // Finish on OUR schedule rather than waiting for the recogniser's onend.
     // A recogniser that never fires one (it happens: the service drops, the
     // tab backgrounds, permission is revoked mid-hold) left `active` stuck

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

@@ -371,6 +371,47 @@ describe("manual folders in the wall", () => {
     }
   });
 
+  it("files a session into a folder from its menu, no drag needed", async () => {
+    const calls: Array<{ url: string; body: Record<string, unknown> | null }> = [];
+    vi.stubGlobal("fetch", vi.fn(async (url: string, init?: RequestInit) => {
+      const u = String(url);
+      calls.push({ url: u, body: init?.body ? JSON.parse(String(init.body)) : null });
+      if (u.includes("digest")) return { ok: false, json: async () => null };
+      if (u === "/api/folders") return { ok: true, json: async () => ({ ok: true, folder: { id: "f2", name: "Fresh" } }) };
+      return { ok: true, json: async () => ({ ok: true }) };
+    }));
+    try {
+      render(<SessionSwitcher {...props} sessions={withFolder} folders={folders} open />);
+      // Into an existing folder.
+      fireEvent.click(screen.getByRole("button", { name: "More actions for outside" }));
+      fireEvent.click(screen.getByRole("button", { name: "Move to folder…" }));
+      fireEvent.click(screen.getByRole("button", { name: "Filed" }));
+      await vi.waitFor(() => expect(calls.some((c) => c.url === "/api/sessions/move")).toBe(true));
+      expect(calls.find((c) => c.url === "/api/sessions/move")!.body).toEqual({ internalName: "outside", folderId: "f1" });
+
+      // Out of its folder: the current one is marked, "No folder" clears it.
+      calls.length = 0;
+      fireEvent.click(screen.getByRole("button", { name: "More actions for inside" }));
+      fireEvent.click(screen.getByRole("button", { name: "Move to folder…" }));
+      expect(screen.getByRole("button", { name: "Filed" }).className).toContain("on");
+      fireEvent.click(screen.getByRole("button", { name: "No folder" }));
+      await vi.waitFor(() => expect(calls.some((c) => c.url === "/api/sessions/move")).toBe(true));
+      expect(calls.find((c) => c.url === "/api/sessions/move")!.body).toEqual({ internalName: "inside", folderId: null });
+
+      // A brand-new folder, created and filed into in one gesture.
+      calls.length = 0;
+      vi.stubGlobal("prompt", vi.fn(() => "Fresh"));
+      fireEvent.click(screen.getByRole("button", { name: "More actions for outside" }));
+      fireEvent.click(screen.getByRole("button", { name: "Move to folder…" }));
+      fireEvent.click(screen.getByRole("button", { name: "New folder…" }));
+      await vi.waitFor(() => expect(calls.some((c) => c.url === "/api/sessions/move")).toBe(true));
+      expect(calls.find((c) => c.url === "/api/folders")!.body).toEqual({ name: "Fresh" });
+      expect(calls.find((c) => c.url === "/api/sessions/move")!.body).toEqual({ internalName: "outside", folderId: "f2" });
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
   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
@@ -384,6 +425,103 @@ describe("manual folders in the wall", () => {
   });
 });
 
+describe("handoff to the other tool", () => {
+  afterEach(() => { vi.unstubAllGlobals(); document.body.innerHTML = ""; });
+
+  it("asks the daemon for a codex target and reports the extract", async () => {
+    const bodies: Array<Record<string, unknown>> = [];
+    vi.stubGlobal("fetch", vi.fn(async (url: string, init?: RequestInit) => {
+      const u = String(url);
+      if (u.includes("digest")) return { ok: false, json: async () => null };
+      if (u === "/api/sessions/fork") {
+        bodies.push(JSON.parse(String(init?.body)));
+        return { ok: true, json: async () => ({ ok: true, name: "alpha-codex", kind: "handoff", target: "codex", extract: { turns: 12, bytes: 40960 } }) };
+      }
+      return { ok: true, json: async () => ({ ok: true }) };
+    }));
+    render(<SessionSwitcher {...props} open />);
+    fireEvent.click(screen.getAllByRole("button", { name: /More actions for/ })[0]);
+    fireEvent.click(screen.getByRole("button", { name: "Continue in Codex…" }));
+    await vi.waitFor(() => expect(bodies.length).toBe(1));
+    expect(bodies[0]).toMatchObject({ target: "codex" });
+    expect(typeof bodies[0].internalName).toBe("string");
+    await vi.waitFor(() => expect(props.onNotice).toHaveBeenCalledWith("alpha-codex — 12 turns handed off (40 KB); it reads them first"));
+  });
+});
+
+describe("file drop on a wall card", () => {
+  afterEach(() => { vi.unstubAllGlobals(); document.body.innerHTML = ""; });
+
+  it("uploads to that session instead of being swallowed by the reorder handlers", async () => {
+    const calls: string[] = [];
+    vi.stubGlobal("fetch", vi.fn(async (url: string) => {
+      const u = String(url);
+      calls.push(u);
+      if (u.includes("digest")) return { ok: false, json: async () => null };
+      return { ok: true, json: async () => ({ path: "/Users/me/.hop2/uploads/x/notes.txt" }) };
+    }));
+    render(<SessionSwitcher {...props} open />);
+    const card = document.querySelector(".switcher-card[data-session-key]") as HTMLElement;
+    const key = card.getAttribute("data-session-key")!;
+    const file = new File(["hi"], "notes.txt", { type: "text/plain" });
+    const dataTransfer = { types: ["Files"], files: [file], items: [], dropEffect: "none" };
+    fireEvent.dragOver(card, { dataTransfer });
+    expect(card.className).toContain("file-drop");
+    fireEvent.drop(card, { dataTransfer });
+    await vi.waitFor(() => expect(calls.some((u) => u.startsWith(`/api/sessions/upload?name=${encodeURIComponent(key)}&filename=notes.txt`))).toBe(true));
+    await vi.waitFor(() => expect(props.onNotice).toHaveBeenCalledWith(expect.stringContaining("/Users/me/.hop2/uploads/x/notes.txt")));
+  });
+});
+
+describe("create form working directory", () => {
+  afterEach(() => { vi.unstubAllGlobals(); document.body.innerHTML = ""; try { localStorage.setItem("hay_create_cwd", ""); } catch { /* stubbed storage */ } });
+
+  it("completes directories from the daemon and sends the chosen one with the create", async () => {
+    const calls: Array<{ url: string; body: string | null }> = [];
+    vi.stubGlobal("fetch", vi.fn(async (url: string, init?: RequestInit) => {
+      const u = String(url);
+      calls.push({ url: u, body: init?.body ? String(init.body) : null });
+      if (u.startsWith("/api/fs/complete")) {
+        return { ok: true, json: async () => ({ home: "/Users/me", dir: "/Users/me/Code", entries: [{ name: "hop2", path: "/Users/me/Code/hop2" }] }) };
+      }
+      if (u.includes("digest")) return { ok: false, json: async () => null };
+      return { ok: true, json: async () => ({ ok: true, name: "fresh", internalName: "s_fresh" }) };
+    }));
+    render(<SessionSwitcher {...props} open />);
+    fireEvent.click(screen.getAllByRole("button", { name: "New session" })[0]);
+    fireEvent.change(screen.getByLabelText("New session name"), { target: { value: "fresh" } });
+    const cwd = screen.getByLabelText("Working directory") as HTMLInputElement;
+    fireEvent.change(cwd, { target: { value: "~/Code/ho" } });
+    // Suggestions are shortened to ~ and completing a directory descends into it.
+    const option = await screen.findByRole("option", { name: "~/Code/hop2" });
+    expect(calls.some((c) => c.url === "/api/fs/complete?q=" + encodeURIComponent("~/Code/ho"))).toBe(true);
+    fireEvent.mouseDown(option);
+    expect(cwd.value).toBe("~/Code/hop2/");
+    fireEvent.submit(cwd.closest("form")!);
+    await vi.waitFor(() => expect(calls.some((c) => c.url === "/api/sessions" && c.body)).toBe(true));
+    const create = JSON.parse(calls.find((c) => c.url === "/api/sessions" && c.body)!.body!);
+    expect(create).toMatchObject({ name: "fresh", cwd: "~/Code/hop2/" });
+    // Remembered for the next create — written once the create succeeds.
+    await vi.waitFor(() => expect(localStorage.getItem("hay_create_cwd")).toBe("~/Code/hop2/"));
+  });
+
+  it("offers the directories of recent sessions before anything is typed", () => {
+    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: false, json: async () => null })));
+    const withCwd: SwitcherSession[] = [
+      { name: "a", displayName: "a", internalName: "a", active: true, starting: false, createdBy: "user", cwd: "/Users/me/Code/one", lastActivityAt: 2 },
+      { name: "b", displayName: "b", internalName: "b", active: true, starting: false, createdBy: "user", cwd: "/Users/me/Code/two", lastActivityAt: 1 }
+    ];
+    render(<SessionSwitcher {...props} sessions={withCwd} open />);
+    fireEvent.click(screen.getAllByRole("button", { name: "New session" })[0]);
+    const cwd = screen.getByLabelText("Working directory") as HTMLInputElement;
+    fireEvent.focus(cwd);
+    const options = screen.getAllByRole("option").map((o) => o.textContent);
+    expect(options).toEqual(["~/Code/one", "~/Code/two"]);
+    fireEvent.mouseDown(screen.getByRole("option", { name: "~/Code/one" }));
+    expect(cwd.value).toBe("~/Code/one");
+  });
+});
+
 describe("create colliding with a hidden session", () => {
   afterEach(() => { vi.unstubAllGlobals(); });
 

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { tabTitle } from "../src/utils/tabTitle";
+
+describe("tab title", () => {
+  it("names the session first and the app second", () => {
+    expect(tabTitle("angler", false)).toBe("angler · hop");
+  });
+  it("is just the app on the hub, never a placeholder room id", () => {
+    expect(tabTitle(null, false)).toBe("hop");
+    expect(tabTitle("", false)).toBe("hop");
+  });
+  it("marks attention with a leading dot", () => {
+    expect(tabTitle("angler", true)).toBe("● angler · hop");
+    expect(tabTitle(null, true)).toBe("● hop");
+  });
+});

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

@@ -227,6 +227,52 @@ describe("hold-space dictation", () => {
     expect(overlays[overlays.length - 1]).toBe(null);
   });
 
+  it("a recogniser that ends on its own mid-hold is replaced, and the words survive", () => {
+    // Safari ends a session at the first pause in speech; Chrome after a few
+    // silent seconds. Neither is the user letting go of Space.
+    const hold = makeHold();
+    hold.handleKey(keydown());
+    vi.advanceTimersByTime(500);
+    const first = FakeRecognition.last!;
+    first.onresult?.({ resultIndex: 0, results: [{ isFinal: true, 0: { transcript: "hello " } }] });
+    first.onend?.();
+
+    expect(hold.isActive()).toBe(true);
+    const second = FakeRecognition.last!;
+    expect(second).not.toBe(first);
+    expect(second.started).toBe(true);
+    second.onresult?.({ resultIndex: 0, results: [{ isFinal: false, 0: { transcript: "world" } }] });
+    expect(overlays[overlays.length - 1]).toBe("hello world");
+
+    hold.handleKey(keyup());
+    expect(hold.isActive()).toBe(false);
+    expect(sent[sent.length - 1]).toBe("hello world");
+  });
+
+  it("Chrome's no-speech mid-hold is a pause, not a failure", () => {
+    const hold = makeHold();
+    hold.handleKey(keydown());
+    vi.advanceTimersByTime(500);
+    const first = FakeRecognition.last!;
+    first.onerror?.({ error: "no-speech" });
+    first.onend?.();
+    expect(hold.isActive()).toBe(true);
+    expect(notices).toEqual([]);
+    expect(FakeRecognition.last).not.toBe(first);
+  });
+
+  it("gives the space bar back when recognisers keep ending without hearing anything", () => {
+    const hold = makeHold();
+    hold.handleKey(keydown());
+    vi.advanceTimersByTime(500);
+    FakeRecognition.last!.onend?.();
+    FakeRecognition.last!.onend?.();
+    expect(hold.isActive()).toBe(true);
+    FakeRecognition.last!.onend?.();
+    expect(hold.isActive()).toBe(false);
+    expect(overlays[overlays.length - 1]).toBe(null);
+  });
+
   it("a recogniser that never ends cannot kill the space bar", () => {
     // The regression that bit Jian: dictation started, the recogniser never
     // fired onend, `active` stuck true — and because every space is eaten