hop2 0.11.2 → 0.11.4

package/hay/apps/web/src/App.tsx

@@ -13,6 +13,7 @@ import { activityLabel, sortPresence } from "./utils/presence";
 import { createOptimisticEcho } from "./utils/optimisticEcho";
 import { attachScrollFlywheel } from "./utils/scrollFlywheel";
 import { collectTerminalMatches, selectTerminalMatch } from "./utils/terminalSearch";
+import { createVoiceHold, speechRecognitionCtor } from "./utils/voiceHold";
 import { scanKeyboardProtocol } from "./utils/keyboardProtocol";
 import { originalPathHint } from "./utils/fileDrop";
 import { MobileKeyboard } from "./components/MobileKeyboard";
@@ -518,6 +519,10 @@ const App = () => {
   const shouldReconnectRef = useRef(true);
   const connectNonceRef = useRef(0);
   const userScrolledUpRef = useRef(false);
+  // Late-bound hooks for the voice controller (created before these exist).
+  const handleUserInputRef = useRef<((data: string) => void) | null>(null);
+  const pushNoticeRef = useRef<((m: string) => void) | null>(null);
+  const foregroundIsClaudeRef = useRef<(() => boolean) | null>(null);
   // Custom overlay scrollbar (native overlay bars can't be styled, and styled
   // webkit bars reserve layout width): a floating semi-transparent thumb.
   const termScrollbarRef = useRef<HTMLDivElement | null>(null);
@@ -562,13 +567,44 @@ const App = () => {
   // Claude Code titles its process with a bare version number; hop's session
   // poll surfaces it as foregroundProcess. Used to unlock claude-specific key
   // encodings (Shift+Enter) without protocol negotiation.
+  // Is Claude Code the thing on screen? The foreground PROCESS cannot answer
+  // alone: a session relaunched by `hop restore` runs
+  // `shell -lc "claude ...; exec shell -l"`, so the room reports the WRAPPER
+  // SHELL for claude's whole life. Everything gated on this — Shift+Enter as
+  // a newline, hold-space voice — silently stopped working in exactly the
+  // sessions a restore brought back, which is why voice "does not always
+  // work". The screen is the honest witness, so fall back to claude's own
+  // chrome in the buffer (cached ~1s, since key handlers ask per keystroke).
+  const claudeScreenRef = useRef<{ at: number; value: boolean }>({ at: 0, value: false });
+  const screenLooksLikeClaude = () => {
+    const now = performance.now();
+    if (now - claudeScreenRef.current.at < 1000) return claudeScreenRef.current.value;
+    let value = false;
+    const t = termRef.current;
+    if (t) {
+      try {
+        const buf = t.buffer.active;
+        const end = buf.baseY + t.rows;
+        let text = "";
+        for (let i = Math.max(0, end - 30); i < end; i++) {
+          text += (buf.getLine(i)?.translateToString(true) ?? "") + "\n";
+        }
+        value = /bypass permissions on|shift\+tab to cycle|esc to interrupt|\? for shortcuts/i.test(text);
+      } catch { /* disposed mid-read */ }
+    }
+    claudeScreenRef.current = { at: now, value };
+    return value;
+  };
   const foregroundIsClaude = () => {
     const room = activeSessionRoomRef.current;
-    if (!room) return false;
-    const s = sessionsRef.current.find((x) => (x.internalName || x.name) === room);
-    const proc = (s?.foregroundProcess || "").trim();
-    return proc === "claude" || /^\d+\.\d+\.\d+$/.test(proc);
+    if (room) {
+      const s = sessionsRef.current.find((x) => (x.internalName || x.name) === room);
+      const proc = (s?.foregroundProcess || "").trim();
+      if (proc === "claude" || /^\d+\.\d+\.\d+$/.test(proc)) return true;
+    }
+    return screenLooksLikeClaude();
   };
+  foregroundIsClaudeRef.current = foregroundIsClaude;
   const drawerOpenRef = useRef(drawerOpen);
   drawerOpenRef.current = drawerOpen;
   const shortcutHelpRef = useRef(shortcutHelpOpen);
@@ -723,6 +759,7 @@ const App = () => {
     }, 3000);
   };
 
+  pushNoticeRef.current = pushNotice;
   const showToast = (message: string, durationMs = 2000) => {
     setToast(message);
     if (toastTimeout.current) {
@@ -953,78 +990,18 @@ const App = () => {
   };
 
   // ── Voice input: hold SPACE in a Claude session to dictate. ──
-  // Browser SpeechRecognition (Chrome + Safari; where absent, space behaves
-  // normally). The first press types its space instantly — no latency on the
-  // most common key; crossing the hold threshold erases that space and
-  // listens until release. The transcript is TYPED, not submitted: you can
-  // edit before Enter. Auto-repeat spaces are swallowed while held, which in
-  // a Claude composer is noise nobody wants anyway.
-  const voiceTimerRef = useRef(0);
-  const voiceActiveRef = useRef(false);
-  const voiceRecRef = useRef<{ stop: () => void } | null>(null);
-  const voiceFinalRef = useRef("");
-  const voiceInterimRef = useRef("");
+  // Shared controller (utils/voiceHold) — the live wall tiles run the same
+  // machine, so dictation exists on every surface a Claude composer does.
   const [voiceOverlay, setVoiceOverlay] = useState<{ interim: string } | null>(null);
-  const speechRecognitionCtor = () =>
-    (window as unknown as { SpeechRecognition?: unknown; webkitSpeechRecognition?: unknown }).SpeechRecognition
-    || (window as unknown as { webkitSpeechRecognition?: unknown }).webkitSpeechRecognition;
-  const finishVoiceInput = (send: boolean) => {
-    if (!voiceActiveRef.current) return;
-    voiceActiveRef.current = false;
-    voiceRecRef.current = null;
-    setVoiceOverlay(null);
-    // Engines usually finalize pending speech on stop(); if only an interim
-    // result ever arrived, it is still what the user said — use it.
-    const text = (voiceFinalRef.current || voiceInterimRef.current).trim();
-    voiceFinalRef.current = "";
-    voiceInterimRef.current = "";
-    if (send && text) handleUserInput(text);
-  };
-  const startVoiceInput = () => {
-    if (voiceActiveRef.current) return;
-    const Ctor = speechRecognitionCtor() as (new () => never) | undefined;
-    if (!Ctor) return;
-    let rec: never;
-    try { rec = new Ctor(); } catch { return; }
-    const r = rec as {
-      lang: string; continuous: boolean; interimResults: boolean;
-      onresult: (ev: { resultIndex: number; results: ArrayLike<{ isFinal: boolean; 0: { transcript: string } }> }) => void;
-      onerror: (ev: { error?: string }) => void; onend: () => void;
-      start: () => void; stop: () => void;
-    };
-    voiceActiveRef.current = true;
-    voiceFinalRef.current = "";
-    voiceInterimRef.current = "";
-    handleUserInput(""); // erase the space the initial press typed
-    r.lang = navigator.language || "en-US";
-    r.continuous = true;
-    r.interimResults = true;
-    r.onresult = (ev) => {
-      let interim = "";
-      for (let i = ev.resultIndex; i < ev.results.length; i++) {
-        const res = ev.results[i];
-        if (res.isFinal) voiceFinalRef.current += res[0].transcript;
-        else interim += res[0].transcript;
-      }
-      voiceInterimRef.current = interim;
-      setVoiceOverlay({ interim: (voiceFinalRef.current + interim).trim() });
-    };
-    r.onerror = (ev) => {
-      if (ev?.error === "not-allowed" || ev?.error === "service-not-allowed") {
-        pushNotice("Microphone permission needed for voice input");
-      }
-      finishVoiceInput(false);
-    };
-    r.onend = () => finishVoiceInput(true);
-    voiceRecRef.current = r;
-    setVoiceOverlay({ interim: "" });
-    try { r.start(); } catch { finishVoiceInput(false); }
-  };
-  const stopVoiceInput = () => {
-    const rec = voiceRecRef.current;
-    if (rec) { try { rec.stop(); } catch { finishVoiceInput(true); } }
-    else finishVoiceInput(true);
-  };
+  const voiceHoldRef = useRef<ReturnType<typeof createVoiceHold> | null>(null);
+  if (!voiceHoldRef.current) {
+    voiceHoldRef.current = createVoiceHold({
+      send: (data) => handleUserInputRef.current?.(data),
+      notify: (m) => pushNoticeRef.current?.(m),
+      setOverlay: (interim) => setVoiceOverlay(interim === null ? null : { interim }),
+      eligible: () => foregroundIsClaudeRef.current?.() ?? false
+    });
+  }
 
   const handleUserInput = (data: string) => {
     // Typing is "I am at the prompt": any earlier scroll-up turned
@@ -1105,6 +1082,7 @@ const App = () => {
 
   // One-shot: armed when a snapshot loads (fresh session open/switch), consumed
   // by the next resize so it goes out as an attach claim.
+  handleUserInputRef.current = handleUserInput;
   const attachClaimPendingRef = useRef(false);
   // Throttle gate for fit-on-type (one fit per typing burst, not per key).
   const lastTypeFitAtRef = useRef(0);
@@ -1452,9 +1430,12 @@ const App = () => {
           remoteMouseSgrRef.current = message.mouseSgr === true;
           optimisticEchoRef.current.reset();
           userScrolledUpRef.current = false;
-          // A snapshot near the requested bound was almost certainly cut —
-          // that's when the "load full history" pill is worth offering.
-          snapshotWasCappedRef.current = typeof message.data === "string" && message.data.length >= 350000
+          // Deeper history exists than this snapshot carries: the server says
+          // so outright for serialized snapshots (which are a few KB no
+          // matter how deep the session is), and for raw tails a payload near
+          // the requested bound was almost certainly cut.
+          snapshotWasCappedRef.current = (message.capped === true
+            || (typeof message.data === "string" && message.data.length >= 350000))
             && !deepReplayRoomsRef.current.has(activeSessionRoomRef.current || "");
           // Reset IN the stream (RIS) rather than as a separate call. A bare
           // reset() paints an empty terminal immediately, while the snapshot
@@ -1470,7 +1451,13 @@ const App = () => {
           deepRestoreRef.current = null;
           if (termRef.current) {
             const t = termRef.current;
-            t.write(`\x1bc${message.data}`, () => {
+            // Re-assert remote modes in-band after the snapshot: serialized
+            // snapshots carry the screen but not private modes, and xterm's
+            // own mode state gates scroll ownership and selection behavior
+            // (the refs above cover synthesized reports, not xterm itself).
+            const modeSeq = (message.mouseReporting ? "\x1b[?1002h" + (message.mouseSgr ? "\x1b[?1006h" : "") : "")
+              + (message.cursorHidden ? "\x1b[?25l" : "");
+            t.write(`\x1bc${message.data}${modeSeq}`, () => {
               if (pendingRestore) {
                 // The user was reading at the top of the OLD buffer; that
                 // content now sits newLen - oldLen lines down. Land there,
@@ -1772,32 +1759,10 @@ const App = () => {
         }
         return false;
       }
-      // Long-press SPACE = voice input (Claude sessions, when the browser has
-      // SpeechRecognition). First press types its space with zero latency;
-      // holding past the threshold erases it and dictates until release.
-      if (event.code === 'Space' && !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey
-          && foregroundIsClaude() && !!speechRecognitionCtor()) {
-        if (event.type === 'keydown') {
-          if (!event.repeat) {
-            window.clearTimeout(voiceTimerRef.current);
-            voiceTimerRef.current = window.setTimeout(startVoiceInput, 550);
-            return true;
-          }
-          return false; // swallow auto-repeat while held
-        }
-        if (event.type === 'keyup') {
-          window.clearTimeout(voiceTimerRef.current);
-          if (voiceActiveRef.current) {
-            stopVoiceInput();
-            return false;
-          }
-          return true;
-        }
-      }
-      // Any other keydown cancels a pending (not yet active) voice hold —
-      // normal typing must never trip the mic.
-      if (event.type === 'keydown' && event.code !== 'Space') {
-        window.clearTimeout(voiceTimerRef.current);
+      // Long-press SPACE = voice input — shared controller; see voiceHold.ts.
+      {
+        const verdict = voiceHoldRef.current?.handleKey(event);
+        if (verdict !== undefined) return verdict;
       }
       // Shift+Enter: xterm.js would emit a plain \r (indistinguishable from
       // Enter), which apps like Claude Code treat as "submit". Synthesize the

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

@@ -15,6 +15,7 @@ import { WebglAddon } from "@xterm/addon-webgl";
 import { attachScrollFlywheel } from "../utils/scrollFlywheel";
 import { ContextMenu, type MenuRequest } from "./ContextMenu";
 import { collectTerminalMatches, selectTerminalMatch } from "../utils/terminalSearch";
+import { bufferLooksLikeClaude, createVoiceHold } from "../utils/voiceHold";
 import {
   buildSwitcherModel,
   filterSessionsByOrigin,
@@ -159,20 +160,41 @@ const PREVIEW_BASE_LH = PREVIEW_BASE_FS * 1.3;
 // Measured advance width of one monospace cell at the base font — resolved
 // lazily because the terminal font stack loads with the page.
 let previewCharW = 0;
+const advanceCache = new Map<number, number>();
 if (typeof document !== "undefined") {
-  document.fonts?.ready?.then(() => { previewCharW = 0; }).catch(() => { /* no Font API */ });
+  document.fonts?.ready?.then(() => { previewCharW = 0; advanceCache.clear(); }).catch(() => { /* no Font API */ });
 }
-const measurePreviewCharW = () => {
-  if (previewCharW) return previewCharW;
+const measureAdvanceAt = (fs: number) => {
+  const hit = advanceCache.get(fs);
+  if (hit) return hit;
   const el = document.createElement("span");
-  el.style.cssText = `position:absolute;visibility:hidden;white-space:pre;font-size:${PREVIEW_BASE_FS}px;line-height:1`;
+  el.style.cssText = `position:absolute;visibility:hidden;white-space:pre;font-size:${fs}px;line-height:1`;
   el.style.fontFamily = "var(--font-terminal)";
   el.textContent = "0".repeat(100);
   document.body.appendChild(el);
-  previewCharW = el.getBoundingClientRect().width / 100 || PREVIEW_BASE_FS * 0.6;
+  const adv = el.getBoundingClientRect().width / 100 || fs * 0.6;
   el.remove();
+  advanceCache.set(fs, adv);
+  return adv;
+};
+const measurePreviewCharW = () => {
+  if (previewCharW) return previewCharW;
+  previewCharW = measureAdvanceAt(PREVIEW_BASE_FS);
   return previewCharW;
 };
+// The WebGL renderer — what live tiles actually use — FLOORS the cell width
+// to whole device pixels: cell = floor(advance × dpr) / dpr (measured
+// empirically at four font sizes across dpr 1 and 2; the DOM renderer
+// instead rounds to hundredths, which is why matching THAT rule still left
+// a shift). The preview's DOM text flows at the font's true fractional
+// advance, so 76+ columns accumulate a visible right-edge disagreement in
+// the preview → terminal swap. Fractional letter-spacing puts preview
+// glyphs on exactly the grid the WebGL terminal will draw.
+const tileLetterSpacing = (fs: number) => {
+  const adv = measureAdvanceAt(fs);
+  const dpr = (typeof window !== "undefined" && window.devicePixelRatio) || 1;
+  return Math.floor(adv * dpr) / dpr - adv;
+};
 
 // ONE font for the whole wall at a given zoom, derived from the box width —
 // never from any session's geometry. Both live tiles and static previews use
@@ -192,6 +214,7 @@ const previewScaleObserver = typeof ResizeObserver !== "undefined"
         const fs2 = tileFontFor(box.clientWidth);
         inner.style.fontSize = fs2 + "px";
         inner.style.lineHeight = Math.round(fs2 * 1.3) + "px";
+        inner.style.letterSpacing = tileLetterSpacing(fs2) + "px";
       }
     })
   : null;
@@ -216,7 +239,7 @@ const ScaledScreen = ({ frame }: { frame: PreviewFrame }) => {
     <div className="switcher-preview-scalebox" ref={boxRef}>
       <div
         className="switcher-preview-screen"
-        style={{ fontSize: PREVIEW_BASE_FS, lineHeight: `${PREVIEW_BASE_LH}px` }}
+        style={{ fontSize: PREVIEW_BASE_FS, lineHeight: `${PREVIEW_BASE_LH}px`, letterSpacing: `${tileLetterSpacing(PREVIEW_BASE_FS)}px` }}
       >
         {renderPreviewRuns(padded)}
       </div>
@@ -270,10 +293,10 @@ const runningApp = (s: SwitcherSession) => {
 // responsiveness and whether keystrokes are accepted. The old design — an
 // HTML preview swapped for a fresh xterm + socket behind a veil — is gone.
 const LIVETILE_POLL_MS = 5000;
-const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, activeCols, activeRows, onFullscreen, onUnfocus }: {
+const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, activeCols, activeRows, onFullscreen, onUnfocus, onNotice }: {
   wsBase: string; room: string; userName: string; theme: object | undefined;
   live: boolean; claudeApp: boolean; claimSize: boolean; activeCols?: number; activeRows?: number;
-  onFullscreen: () => void; onUnfocus: () => void;
+  onFullscreen: () => void; onUnfocus: () => void; onNotice: (m: string) => void;
 }) => {
   const boxRef = useRef<HTMLDivElement | null>(null);
   const termRef = useRef<Terminal | null>(null);
@@ -284,6 +307,24 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   const kbdEnhancedRef = useRef(false);
   // null = watching; "live"/"down" = connected state for the chrome.
   const [conn, setConn] = useState<"live" | "down" | null>(null);
+  // Hold-space voice, same controller as the full screen — the tile is where
+  // typing mostly happens now, and dictation not existing here was most of
+  // "voice doesn't always work".
+  const [voiceInterim, setVoiceInterim] = useState<string | null>(null);
+  const voiceHoldRef = useRef<ReturnType<typeof createVoiceHold> | null>(null);
+  if (!voiceHoldRef.current) {
+    voiceHoldRef.current = createVoiceHold({
+      send: (data) => sendInputRef.current?.(data),
+      notify: (m) => onNoticeRef.current?.(m),
+      setOverlay: setVoiceInterim,
+      eligible: () => {
+        if (claudeAppRef.current) return true;
+        const t = termRef.current;
+        return !!t && bufferLooksLikeClaude(t as never);
+      }
+    });
+  }
+
   // In-tile find (⌘F while the tile is live): same engine as the full-screen
   // find bar. Scope follows focus — ⌘F in a live tile searches THIS session;
   // ⌘F anywhere else is the wall filter, which finds sessions.
@@ -319,6 +360,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   const myIdRef = useRef<string | null>(null);
   const [viewers, setViewers] = useState<Array<{ name: string }>>([]);
   const [driver, setDriver] = useState<{ name: string; color: string } | null>(null);
+  const onNoticeRef = useRef(onNotice);
+  onNoticeRef.current = onNotice;
   const claudeAppRef = useRef(claudeApp);
   claudeAppRef.current = claudeApp;
   const liveRef = useRef(live);
@@ -407,6 +450,10 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     // Keys route through refs so the handler survives mode flips untouched.
     term.attachCustomKeyEventHandler((ev) => {
       if (!liveRef.current) return false; // watching: the terminal takes no keys
+      {
+        const verdict = voiceHoldRef.current?.handleKey(ev);
+        if (verdict !== undefined) return verdict;
+      }
       if ((ev.metaKey || ev.ctrlKey) && !ev.altKey && !ev.shiftKey && ev.key.toLowerCase() === "f") {
         // Scope follows focus: find in THIS terminal. (The wall filter stays
         // one ⌘K away; ⌘. still unfocuses the tile.)
@@ -661,7 +708,17 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
             // In-band RIS: clear and repaint in one parse pass. A separate
             // reset() painted an empty frame before the snapshot landed —
             // the blink that made preview → terminal feel like a switch.
-            term.write("\x1bc" + m.data, () => {
+            //
+            // Then re-assert the remote app's modes from the flags: a
+            // serialized snapshot carries the SCREEN but not private modes
+            // (the raw tail incidentally did), and this terminal's own state
+            // is what gates wheel forwarding vs local scrollback and
+            // plain-drag vs shift-drag selection — without it every tile
+            // guessed "no tracking" and scrolling/selection went wrong
+            // per-session.
+            const modes = (m.mouseReporting ? "\x1b[?1002h" + (m.mouseSgr ? "\x1b[?1006h" : "") : "")
+              + (m.cursorHidden ? "\x1b[?25l" : "");
+            term.write("\x1bc" + m.data + modes, () => {
               term.scrollToBottom();
               term.refresh(0, term.rows - 1);
               rescaleRef.current();
@@ -752,6 +809,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
       setConn(null);
       setViewers([]);
       setDriver(null);
+      voiceHoldRef.current?.dispose();
       setFind(null);
       findIndexRef.current = -1;
       term.blur();
@@ -770,6 +828,14 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
       onPointerDown={live ? (e) => e.stopPropagation() : undefined}
     >
       <div className="switcher-focus-term" ref={boxRef} />
+      {voiceInterim !== null && (
+        <div className="voice-overlay" aria-hidden="true">
+          <span className="voice-dot" />
+          <span className={voiceInterim ? "voice-text" : "voice-text muted"}>
+            {voiceInterim || "Listening… release Space to insert"}
+          </span>
+        </div>
+      )}
       {live && (
         <div className="switcher-live-chrome" onClick={(e) => e.stopPropagation()}>
           <span className={"switcher-focus-label" + (conn === "down" ? " down" : "")}>
@@ -1495,6 +1561,30 @@ export const SessionSwitcher = ({
         body: JSON.stringify({ internalName: sessionKey(session), parked: false })
       }).catch(() => { /* daemon will still show it parked; harmless */ });
     }
+    // A DEAD terminal session starts IN PLACE instead of falling through to
+    // full screen — the last accidental door into the mode. Attaching is what
+    // starts a known session, so a claim-free throwaway socket kicks it
+    // alive; the tile is pre-focused and goes live the moment the session
+    // reports active. Ports still open full screen (they are web pages), and
+    // without live tiles (no wsBase / small zoom) the old switch stands.
+    if (session.type !== "port" && !session.active && interactiveTiles && tileWsBase) {
+      const key = sessionKey(session);
+      try {
+        const sep = tileWsBase.includes("?") ? "&" : "?";
+        const kick = new WebSocket(
+          tileWsBase + sep + "room=" + encodeURIComponent(key)
+          + "&name=" + encodeURIComponent((userName || "user") + " (start)")
+          + "&replay=0&nudge=0&cols=80&rows=24"
+        );
+        kick.onopen = () => { window.setTimeout(() => { try { kick.close(); } catch { /* done */ } }, 400); };
+        kick.onerror = () => { try { kick.close(); } catch { /* refused */ } };
+      } catch { /* daemon will surface it as starting on the next poll */ }
+      onNotice("Starting " + (session.displayName || session.name) + "…");
+      setFocusedKey(key);
+      onFocusSession?.(session);
+      onRefresh();
+      return;
+    }
     onSwitch(session);
   };
 
@@ -1840,8 +1930,8 @@ export const SessionSwitcher = ({
       setCreating(false);
       setCreateDraft("");
       if (createInFolder) {
-        // File it before switching: reuses the move endpoint, which is the
-        // one place membership is persisted durably.
+        // File it first: the move endpoint is the one place membership is
+        // persisted durably.
         await fetch("/api/sessions/move", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -1849,7 +1939,13 @@ export const SessionSwitcher = ({
         }).catch(() => { /* filing is best-effort; the session exists */ });
         setCreateInFolder(null);
       }
-      onSwitch({ name: data.name, displayName: data.name, active: false, starting: true, internalName: data.name });
+      // Stay on the wall. Creating used to jump straight to full screen —
+      // the exact accidental mode-entry the hotkey inversion removed from
+      // clicks. The new tile becomes current and goes live in place as soon
+      // as the session reports active.
+      onFocusSession?.({ name: data.name, displayName: data.name, active: false, starting: true, internalName: data.name });
+      setFocusedKey(data.name);
+      onRefresh();
     } catch {
       onNotice("Failed to create session");
     }
@@ -2016,6 +2112,7 @@ export const SessionSwitcher = ({
               activeRows={preview?.rows}
               onFullscreen={() => onSwitch(s)}
               onUnfocus={() => setFocusedKey(null)}
+              onNotice={onNotice}
             />
           </div>
         ) : (
@@ -2235,10 +2332,10 @@ export const SessionSwitcher = ({
         </div>
         {/* Create form lives in the top bar so the header ＋ works from EVERY
             mode — the dashed grid card only exists in recent mode. */}
-        {creating && (
+        {creating && !createInFolder && (
           <form className="switcher-create-row inline-edit" onSubmit={submitCreate}>
             <input
-              placeholder={createInFolder ? "new session in " + createInFolder.name : "session-name"}
+              placeholder="session-name"
               value={createDraft}
               onChange={(e) => setCreateDraft(e.target.value)}
               maxLength={64}
@@ -2331,8 +2428,22 @@ export const SessionSwitcher = ({
                       <button type="button" onClick={() => renameFolder(folder)} title="Rename folder">✎</button>
                       <button type="button" onClick={() => deleteFolder(folder)} title="Delete folder">🗑</button>
                     </h3>
+                    {creating && createInFolder?.id === folder.id && (
+                      <form className="switcher-create-row inline-edit switcher-create-infolder" onSubmit={submitCreate}>
+                        <input
+                          placeholder={"new session in " + folder.name}
+                          value={createDraft}
+                          onChange={(e) => setCreateDraft(e.target.value)}
+                          maxLength={64}
+                          autoFocus
+                          aria-label={"New session name in " + folder.name}
+                        />
+                        <button type="submit">Create</button>
+                        <button type="button" onClick={() => { setCreating(false); setCreateDraft(""); setCreateInFolder(null); }}>✕</button>
+                      </form>
+                    )}
                     {rows.length === 0 ? (
-                      <p className="switcher-folder-empty">Drag a session here</p>
+                      creating && createInFolder?.id === folder.id ? null : <p className="switcher-folder-empty">Drag a session here, or ＋ to create one</p>
                     ) : (
                       <div className="switcher-grid">{rows.map((s) => renderCard(s))}</div>
                     )}

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

@@ -3892,3 +3892,16 @@ button.primary {
     opacity: 1;
   }
 }
+
+/* Create-in-folder: the input appears INSIDE the folder, where the session
+   will land — not up in the header bar two scrolls away from the + that
+   asked for it. */
+.switcher-folder .switcher-create-infolder {
+  margin: 4px 0 8px;
+}
+
+/* Voice overlay inside a live tile: same pill, tile-scaled. */
+.switcher-live-tile .voice-overlay {
+  bottom: 30px;
+  max-width: 86%;
+}