hop2 0.11.63 → 0.11.64

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

@@ -261,6 +261,10 @@ type SessionInfo = {
   createdBy?: "user" | "agent";
   createdVia?: string | null;
   agent?: "claude" | "codex" | null;
+  // Server-decided: a turn in flight, or the last one finished — and whether
+  // a human has opened the session since it finished (see lib/agent-phase.js).
+  agentPhase?: "working" | "done" | null;
+  turnSeen?: boolean;
   attentionReason?: string;
   attentionNote?: string;
   cols?: number;
@@ -3205,6 +3209,8 @@ const App = () => {
           createdBy: s.createdBy === "agent" ? "agent" : "user",
           createdVia: typeof s.createdVia === "string" ? s.createdVia : null,
           agent: s.agent === "claude" || s.agent === "codex" ? s.agent : null,
+          agentPhase: s.agentPhase === "working" || s.agentPhase === "done" ? s.agentPhase : null,
+          turnSeen: s.turnSeen !== false,
           cols: Number.isInteger(s.cols) ? s.cols : undefined,
           rows: Number.isInteger(s.rows) ? s.rows : undefined,
           // These three were silently dropped here, so the switcher never saw
@@ -3966,7 +3972,7 @@ const App = () => {
         grab();
         setViewsOpen((v) => v ? null
           : (activeSessionRoomRef.current
-              ? { session: activeSessionRoomRef.current, dock: true }
+              ? { session: activeSessionRoomRef.current }
               : {}));
         return;
       }
@@ -4160,7 +4166,7 @@ const App = () => {
               // DOCKED and scoped: in full-screen mode you almost always want
               // THIS session's results, read beside the live terminal rather
               // than over it. The panel's own toggle widens to the fleet.
-              onClick={() => setViewsOpen({ session: session.room, dock: true })}
+              onClick={() => setViewsOpen({ session: session.room })}
             >
               Views
               {(() => {
@@ -4214,7 +4220,7 @@ const App = () => {
             onRefresh={() => fetchSessions({ showLoading: false })}
             onNotice={showToast}
             tileWsBase={resolveWsUrl()}
-            onOpenViews={(scope) => setViewsOpen({ session: scope, dock: true })}
+            onOpenViews={(scope) => setViewsOpen({ session: scope })}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
           />
@@ -4878,7 +4884,7 @@ const App = () => {
             tileWsBase={resolveWsUrl()}
             onFocusSession={focusSessionInPlace}
             folders={folders}
-            onOpenViews={(scope) => setViewsOpen({ session: scope, dock: true })}
+            onOpenViews={(scope) => setViewsOpen({ session: scope })}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
             onOpenSettings={() => {

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

@@ -15,6 +15,8 @@ import { FitAddon } from "@xterm/addon-fit";
 import { WebLinksAddon } from "@xterm/addon-web-links";
 import { enableMathHover } from "../utils/mathLinkProvider";
 import { getMathTip } from "../utils/mathTooltip";
+import { claimOnTileFocus, sizeIsForeign } from "../utils/sizeClaim";
+import { cardPhase, phaseLabel, phaseTitle } from "../utils/agentPhase";
 import { urlAtCell, cellAtPoint } from "../utils/urlAtCell";
 import { attachScrollFlywheel } from "../utils/scrollFlywheel";
 import { ContextMenu, type MenuRequest } from "./ContextMenu";
@@ -354,11 +356,17 @@ 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, onNotice, onSender }: {
+const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp, claimSize, activeCols, activeRows, onFullscreen, onUnfocus, onNotice, onSender }: {
   /** The wall keeps a registry of live tiles' input senders (file drops). */
   onSender?: (send: ((data: string) => void) | null) => void;
   wsBase: string; room: string; userName: string; theme: object | undefined;
-  live: boolean; claudeApp: boolean; claimSize: boolean; activeCols?: number; activeRows?: number;
+  /**
+   * `live` says the tile is the focused one; `deliberate` says the human
+   * put it there (click, Enter, start, create) rather than the wall
+   * pre-focusing the current session as it opened. Only a deliberate focus
+   * takes the session's size — see claimOnTileFocus.
+   */
+  live: boolean; deliberate: boolean; claudeApp: boolean; claimSize: boolean; activeCols?: number; activeRows?: number;
   onFullscreen: () => void; onUnfocus: () => void; onNotice: (m: string) => void;
 }) => {
   const boxRef = useRef<HTMLDivElement | null>(null);
@@ -367,6 +375,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   const rescaleRef = useRef<() => void>(() => {});
   // Wired by the live effect; watch mode leaves them null so keys go nowhere.
   const sendInputRef = useRef<((data: string) => void) | null>(null);
+  const deliberateRef = useRef(deliberate);
+  deliberateRef.current = deliberate;
   // When the link addon last opened something from this tile — so the click
   // that follows its mouseup does not open the same URL a second time.
   const lastLinkOpenAtRef = useRef(0);
@@ -782,13 +792,9 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     // for sizes that are genuinely foreign (full-screen leftovers), not for
     // disagreements about rounding.
     const cur = termRef.current;
-    if (cur) {
-      const closeCols = Math.abs(cur.cols - dims.cols) <= Math.max(3, Math.round(dims.cols * 0.15));
-      const closeRows = Math.abs(cur.rows - dims.rows) <= Math.max(2, Math.round(dims.rows * 0.15));
-      if (closeCols && closeRows) {
-        lastClaimRef.current = { cols: dims.cols, rows: dims.rows, at: performance.now() };
-        return;
-      }
+    if (cur && !sizeIsForeign({ cols: cur.cols, rows: cur.rows }, { cols: dims.cols, rows: dims.rows })) {
+      lastClaimRef.current = { cols: dims.cols, rows: dims.rows, at: performance.now() };
+      return;
     }
     lastClaimRef.current = { cols: dims.cols, rows: dims.rows, at: performance.now() };
     const sep = wsBase.includes("?") ? "&" : "?";
@@ -931,6 +937,31 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     let reconnectTimer = 0;
     let reconnectAttempt = 0;
     const pendingInput: Array<{ data: string; at: number }> = [];
+    // Engaging a tile is an act on it, the same as opening the session full
+    // screen, and takes the size the same way — through THIS socket, as an
+    // attach claim, so ownership moves here and the election's active_size
+    // confirms the fit (the handler below resizes the tile to it). Until
+    // now a clicked tile only ever attached at the session's current size
+    // and fitted itself on the first keystroke; a session wearing a
+    // full-screen size stayed a wall of tiny text when clicked ("clicking
+    // the tile does not enter the terminal, but full screen does"). Once
+    // per focus: a reconnect is the same socket healing, not a new act.
+    let focusClaimDone = false;
+    const claimFitOnFocus = (sock: WebSocket) => {
+      if (focusClaimDone) return;
+      focusClaimDone = true;
+      const fitAddon = fitRef.current;
+      const boxEl = boxRef.current;
+      const t = termRef.current;
+      if (!fitAddon || !boxEl || !t || boxEl.clientWidth < 60 || boxEl.clientHeight < 40) return;
+      const dims = fitAddon.proposeDimensions();
+      const natural = dims?.cols && dims?.rows ? { cols: dims.cols, rows: dims.rows } : null;
+      if (!natural || !claimOnTileFocus({ deliberate: deliberateRef.current, natural, current: { cols: t.cols, rows: t.rows } })) return;
+      lastClaimRef.current = { cols: natural.cols, rows: natural.rows, at: performance.now() };
+      try {
+        sock.send(JSON.stringify({ type: "resize", cols: natural.cols, rows: natural.rows, claim: "attach", user: true }));
+      } catch { /* closing; the next act re-claims */ }
+    };
     // Sub-second drops stay invisible: the "reconnecting…" chrome waits out
     // a grace window, and the first retry goes immediately — a tunnel
     // restart or a waking laptop usually reconnects before either fires.
@@ -963,6 +994,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
         if (disposed || ws !== sock) return;
         reconnectAttempt = 0;
         markLive();
+        claimFitOnFocus(sock);
         window.setTimeout(() => rescaleRef.current(), 30);
         const cutoff = Date.now() - 15000;
         for (const pend of pendingInput) {
@@ -1614,7 +1646,11 @@ export const SessionSwitcher = ({
       else sessionStorage.removeItem("hay_switcher_focus");
     } catch { /* private mode */ }
   }, [focusedKey]);
-  useEffect(() => { if (!open) setFocusedKey(null); }, [open]);
+  // The key the HUMAN focused (click, Enter, start, create), as opposed to
+  // the wall pre-focusing the current session as it opens. The live tile
+  // takes the session's size only for the former.
+  const deliberateFocusRef = useRef<string | null>(null);
+  useEffect(() => { if (!open) { setFocusedKey(null); deliberateFocusRef.current = null; } }, [open]);
   useEffect(() => { if (!interactiveTiles) setFocusedKey(null); }, [interactiveTiles]);
   const [renameDraft, setRenameDraft] = useState("");
   const [creating, setCreating] = useState(false);
@@ -2002,6 +2038,7 @@ export const SessionSwitcher = ({
     if (!current) return;
     initialFocusDoneRef.current = true;
     const key = sessionKey(current);
+    deliberateFocusRef.current = null; // the wall's own pre-focus, not an act
     setFocusedKey(key);
     const idx = navIndexByKey.get(key);
     if (typeof idx === "number") {
@@ -2242,6 +2279,7 @@ export const SessionSwitcher = ({
   const focusInPlace = (session: SwitcherSession) => {
     const key = sessionKey(session);
     filterInputRef.current?.blur();
+    deliberateFocusRef.current = key;
     setFocusedKey(key);
     onFocusSession?.(session);
     const idx = flatNav.findIndex((x) => sessionKey(x) === key);
@@ -2291,6 +2329,7 @@ export const SessionSwitcher = ({
         kick.onerror = () => { try { kick.close(); } catch { /* refused */ } };
       } catch { /* daemon will surface it as starting on the next poll */ }
       onNotice("Starting " + (session.displayName || session.name) + "…");
+      deliberateFocusRef.current = key;
       setFocusedKey(key);
       onFocusSession?.(session);
       onRefresh();
@@ -2703,6 +2742,7 @@ export const SessionSwitcher = ({
           if (hiddenByOrigin) setOriginScope("all");
           if (taken.parked) setParkedOpen(true);
           const key = sessionKey(taken);
+          deliberateFocusRef.current = key;
           setFocusedKey(key);
           if (visible) {
             const idx = navIndexByKey.get(key);
@@ -2746,6 +2786,7 @@ export const SessionSwitcher = ({
       // The id is minted server-side now; the display name is what the user
       // typed. Keys ride on the id, labels on the name.
       onFocusSession?.({ name: data.displayName || data.name, displayName: data.displayName || data.name, active: false, starting: true, internalName: data.internalName || data.name });
+      deliberateFocusRef.current = data.internalName || data.name;
       setFocusedKey(data.internalName || data.name);
       onRefresh();
     } catch {
@@ -2831,7 +2872,11 @@ export const SessionSwitcher = ({
     // producing output RIGHT NOW glows instead of jumping to the top.
     // Window comfortably exceeds the 10s relative-time tick so a busy
     // session's glow holds steady rather than flickering between polls.
-    const activeNow = !current && now - (s.lastActivityAt || 0) < 12000;
+    // Agent sessions wear their PHASE (working / done / read) instead of the
+    // generic "output right now" ring: the daemon's verdict is the sharper
+    // signal, and two rings on one card were unreadable.
+    const phase = cardPhase(s);
+    const activeNow = !current && !phase && now - (s.lastActivityAt || 0) < 12000;
     // Freshness: recency the eye can read WITHOUT the row moving. A left-edge
     // bar whose intensity decays from full (just active) to nothing over
     // ~10 minutes — bright means "just now", faint means "a while ago",
@@ -2852,7 +2897,7 @@ export const SessionSwitcher = ({
         tabIndex={0}
         data-nav-index={navIndexByKey.get(key)}
         data-session-key={key}
-        className={`switcher-card${current ? " current" : ""}${activeNow ? " active-now" : ""}${kbdSelected ? " kbd-selected" : ""}${focusedKey === key ? " focused" : ""}${dragKey === key ? " dragging" : ""}${draggable ? " draggable" : ""}${fileDropKey === key ? " file-drop" : ""}`}
+        className={`switcher-card${current ? " current" : ""}${activeNow ? " active-now" : ""}${phase ? ` phase-${phase}` : ""}${kbdSelected ? " kbd-selected" : ""}${focusedKey === key ? " focused" : ""}${dragKey === key ? " dragging" : ""}${draggable ? " draggable" : ""}${fileDropKey === key ? " file-drop" : ""}`}
         draggable={draggable}
         onDragStart={draggable ? (e) => { setDragKey(key); e.dataTransfer.effectAllowed = "move"; } : undefined}
         onDragEnter={draggable ? () => { if (dragKey && dragKey !== key) moveManual(dragKey, key); } : undefined}
@@ -2941,6 +2986,11 @@ export const SessionSwitcher = ({
             </span>
           )}
           {!current && s.starting && !s.active && <span className="switcher-chip starting">STARTING</span>}
+          {phase && (
+            <span className={`switcher-chip phase ${phase}`} title={phaseTitle(phase)}>
+              <span className="phase-dot" aria-hidden="true" />{phaseLabel(phase)}
+            </span>
+          )}
           {/* A result waiting on this session is worth as much as its status:
               a published PDF or write-up was otherwise invisible from the wall.
               stopPropagation on pointerdown keeps the long-press sheet out of
@@ -2976,6 +3026,7 @@ export const SessionSwitcher = ({
               userName={userName || "user"}
               theme={terminalTheme}
               live={focusedKey === key}
+              deliberate={deliberateFocusRef.current === key}
               claudeApp={appLabel(s) === "claude"}
               claimSize={s.hasLocalCli !== true}
               activeCols={preview?.cols}

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

@@ -60,8 +60,10 @@ type Props = {
   // Only used to translate internalName into the name the user renamed it to;
   // the manifest has no idea a session was ever renamed.
   sessions?: { name: string; displayName?: string; internalName?: string }[];
-  // Right-side dock beside a live terminal (full-screen mode). Falls back to
-  // the modal below ~1100px, where a dock would leave no terminal to see.
+  // Right-side dock beside a live terminal. Off by default everywhere now:
+  // the reader opens as the CENTERED window, index beside page — a dock at
+  // the screen's edge was farther from where the eye already is. The dock
+  // stays available for a caller that wants it.
   dock?: boolean;
   onClose: () => void;
 };

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

@@ -3795,6 +3795,59 @@ body.pane-dragging { user-select: none; }
   color: #1a1200;
 }
 
+/* The agent's phase, the wall's three colours (utils/agentPhase.ts):
+   WORKING blue, DONE (unread) green, READ quiet. Purple stays "current /
+   focused", amber stays "asking you", so no two signals share a hue. */
+.switcher-chip.phase {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+.switcher-chip.phase .phase-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+}
+.switcher-chip.phase.working {
+  background: color-mix(in srgb, #3b82f6 22%, var(--bg-alt));
+  color: #3b82f6;
+}
+.switcher-chip.phase.working .phase-dot {
+  animation: phase-working-pulse 1.2s ease-in-out infinite;
+}
+@keyframes phase-working-pulse {
+  0%, 100% { opacity: 1; transform: scale(1); }
+  50% { opacity: 0.35; transform: scale(0.7); }
+}
+.switcher-chip.phase.done-unread {
+  background: #22a06b;
+  color: #04170d;
+}
+.switcher-chip.phase.done-read {
+  background: var(--bg-alt);
+  color: var(--ink-muted);
+}
+@media (prefers-reduced-motion: reduce) {
+  .switcher-chip.phase.working .phase-dot { animation: none; }
+}
+.switcher-card.phase-working {
+  border-color: color-mix(in srgb, #3b82f6 65%, var(--line));
+  box-shadow: 0 0 0 1px color-mix(in srgb, #3b82f6 30%, transparent);
+}
+.switcher-card.phase-done-unread {
+  border-color: color-mix(in srgb, #22a06b 75%, var(--line));
+  box-shadow: 0 0 0 1px color-mix(in srgb, #22a06b 40%, transparent), 0 0 12px -2px color-mix(in srgb, #22a06b 45%, transparent);
+}
+.switcher-card.phase-done-read {
+  opacity: 0.88;
+}
+.switcher-card.phase-done-read.current,
+.switcher-card.phase-done-read.focused,
+.switcher-card.phase-done-read:hover {
+  opacity: 1;
+}
+
 /* Colour-preview rows. Inline spans paint their background only over the
    glyph box, and at line-height 1.3 the half-leading above and below stayed
    the tile's background — code blocks rendered as horizontal stripes with a

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

@@ -0,0 +1,26 @@
+// The wall's three agent colours, from the daemon's verdict. The daemon
+// decides working / done and whether a human has opened the session since
+// the turn ended (its seen witness counts every device), so the web wall and
+// the phone paint the same session the same colour.
+//
+//   working      blue   a turn is in flight
+//   done-unread  green  finished; nobody has opened it since
+//   done-read    quiet  finished, and looked at
+//
+// A question the agent is asking (attentionReason "ask") keeps its own amber
+// signal on top; it is not folded in here.
+export type CardPhase = "working" | "done-unread" | "done-read" | null;
+
+export const cardPhase = (s: { agentPhase?: "working" | "done" | null; turnSeen?: boolean }): CardPhase => {
+  if (s.agentPhase === "working") return "working";
+  if (s.agentPhase === "done") return s.turnSeen === false ? "done-unread" : "done-read";
+  return null;
+};
+
+export const phaseLabel = (p: CardPhase): string =>
+  p === "working" ? "WORKING" : p === "done-unread" ? "DONE" : p === "done-read" ? "READ" : "";
+
+export const phaseTitle = (p: CardPhase): string =>
+  p === "working" ? "The agent is working on a turn"
+    : p === "done-unread" ? "The agent finished — you have not opened this session since"
+    : p === "done-read" ? "The agent finished, and you have looked" : "";

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

@@ -56,3 +56,36 @@ export const isPlainClick = (
   if (!down) return true;
   return Math.hypot(up.x - down.x, up.y - down.y) <= slopPx;
 };
+
+/**
+ * CLOSE ENOUGH is the right size. A tile that renders the session scaled
+ * by ~0.9 is visually free; a claim is for sizes that are genuinely
+ * foreign (a full-screen leftover on a wall tile), not for two walls
+ * disagreeing about rounding — that disagreement, claimed, was two
+ * browsers re-sizing every session back and forth on every open.
+ */
+export const sizeIsForeign = (current: Size, natural: Size): boolean => {
+  const closeCols = Math.abs(current.cols - natural.cols) <= Math.max(3, Math.round(natural.cols * 0.15));
+  const closeRows = Math.abs(current.rows - natural.rows) <= Math.max(2, Math.round(natural.rows * 0.15));
+  return !(closeCols && closeRows);
+};
+
+/**
+ * A wall tile going live because the human ENGAGED it — a click, Enter,
+ * starting or creating a session there — is the same act as opening a
+ * session full screen, and takes the size the same way: only when what the
+ * session is wearing is foreign to the tile. The wall pre-focusing the
+ * current session as it opens is not an act (nobody clicked), and a tile
+ * that already fits has nothing to claim — a claim there would be a resize
+ * on every wall open, the fight the size-ownership rules exist to end.
+ */
+export const claimOnTileFocus = (o: {
+  deliberate: boolean;
+  natural: Size | null;
+  current: Size | null;
+}): boolean => {
+  if (!o.deliberate || !o.natural) return false;
+  if (o.natural.cols < 20 || o.natural.rows < 5) return false;
+  if (!o.current) return true;
+  return sizeIsForeign(o.current, o.natural);
+};

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

@@ -35,6 +35,9 @@ export type SwitcherSession = {
   foregroundProcess?: string;
   /** What the session runs, by its hooks' records: claude, codex, or nothing known. */
   agent?: "claude" | "codex" | null;
+  /** Server-decided: a turn in flight / the last turn finished; turnSeen = a human opened it since. */
+  agentPhase?: "working" | "done" | null;
+  turnSeen?: boolean;
   agentPermitted?: boolean;
   cols?: number;
   rows?: number;

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

@@ -49,9 +49,26 @@ export type VoiceHoldOptions = {
   thresholdMs?: number;
 };
 
+// A ring of what the controller saw and did — key events with their
+// verdicts, recogniser lifecycle, why a hold ended. Read from the console
+// (window.__hopVoiceTrace) or shipped with the client diagnostics, so a
+// "dictation stopped and spaces started typing" report can be replayed
+// instead of guessed at.
+const TRACE_MAX = 240;
+export const voiceTrace: string[] = [];
+const trace = (line: string) => {
+  voiceTrace.push(`${new Date().toISOString().slice(11, 23)} ${line}`);
+  if (voiceTrace.length > TRACE_MAX) voiceTrace.splice(0, voiceTrace.length - TRACE_MAX);
+};
+if (typeof window !== "undefined") (window as unknown as { __hopVoiceTrace?: string[] }).__hopVoiceTrace = voiceTrace;
+
 export const createVoiceHold = (opts: VoiceHoldOptions) => {
   const threshold = opts.thresholdMs ?? 550;
   const MAX_HOLD_MS = 60000;
+  // A recogniser that ends this soon after starting, having heard nothing,
+  // was refused (no mic, no service), not silent: Chrome's own silence
+  // timeout is several seconds. Only refusals count toward giving up.
+  const REFUSED_MS = 1500;
   let timer = 0;
   let watchdog = 0;
   let active = false;
@@ -66,8 +83,9 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
   /** Consecutive recogniser restarts that produced nothing — a loop guard. */
   let emptyRestarts = 0;
 
-  const finish = (sendText: boolean) => {
+  const finish = (sendText: boolean, why = "") => {
     if (!active) return;
+    trace(`finish send=${sendText} why=${why} final=${JSON.stringify(finalText.slice(-40))} interim=${JSON.stringify(interimText.slice(-40))}`);
     active = false;
     pending = false;
     stopping = false;
@@ -91,7 +109,8 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     const Ctor = speechRecognitionCtor();
     // 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; }
+    if (!Ctor) { trace("start: no recogniser"); opts.notify("Voice input is not supported in this browser"); return; }
+    trace(`start spacesTyped=${spacesTyped}`);
     active = true;
     stopping = false;
     emptyRestarts = 0;
@@ -103,7 +122,7 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     armWatchdog();
     window.addEventListener("blur", onWindowBlur);
     opts.setOverlay("");
-    if (!listen(Ctor)) { opts.notify("Voice input could not start"); finish(false); }
+    if (!listen(Ctor)) { opts.notify("Voice input could not start"); finish(false, "listen-failed"); }
   };
 
   // One recogniser session. The hold outlives it: browser recognisers end
@@ -117,6 +136,7 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     let r: RecognitionLike;
     try { r = new Ctor(); } catch { return false; }
     let heard = false;
+    const startedAt = Date.now();
     r.lang = navigator.language || "en-US";
     r.continuous = true;
     r.interimResults = true;
@@ -133,21 +153,35 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
       opts.setOverlay((finalText + interim).trim());
     };
     const ended = () => {
+      const age = Date.now() - startedAt;
+      trace(`rec end heard=${heard} age=${age}ms stopping=${stopping} current=${rec === r}`);
       if (!active || rec !== r) return;      // an old recogniser, or already finished
-      if (stopping) { finish(true); return; } // released: type what we have
+      if (stopping) { finish(true, "released"); 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; }
+      // Silence is not a reason to stop: Space is still down, and the hold
+      // ending on its own is exactly what "dictation just cut out and then
+      // spaces typed" looks like from the chair. Only a recogniser that is
+      // REFUSING us — ending at once, three times, having heard nothing —
+      // gives the space bar back rather than spin forever.
+      if (!heard && age < REFUSED_MS) {
+        if (++emptyRestarts >= 3) { finish(true, "refused"); return; }
+      } else {
+        emptyRestarts = 0;
+      }
       opts.setOverlay(finalText.trim());
-      if (!listen(Ctor)) finish(true);
+      if (!listen(Ctor)) finish(true, "restart-failed");
     };
     r.onerror = (ev) => {
       const code = ev?.error || "unknown";
+      trace(`rec error ${code} stopping=${stopping} current=${rec === r}`);
+      // Our own stop() is finishing this hold with the words it has; an
+      // error the recogniser raises on the way out ("aborted") must not
+      // finish it again WITHOUT them.
+      if (stopping || rec !== r) return;
       // 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;
+      if (active && (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".
@@ -160,7 +194,7 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
       } else if (code !== "aborted") {
         opts.notify(`Voice input failed: ${code}`);
       }
-      finish(false);
+      finish(false, `error:${code}`);
     };
     r.onend = ended;
     rec = r;
@@ -170,6 +204,7 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
 
   const stop = () => {
     const r = rec;
+    trace("stop");
     stopping = true;
     try { r?.stop(); } catch { /* already gone */ }
     rec = null;
@@ -179,7 +214,7 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     // true — and since every space is deliberately eaten while active, that
     // is a terminal that cannot type a space AT ALL. onend arriving later is
     // harmless; finish() is a no-op once inactive.
-    finish(true);
+    finish(true, "stop");
   };
 
   // Last line of defence. Nothing should hold the microphone for a minute,
@@ -223,8 +258,10 @@ export const createVoiceHold = (opts: VoiceHoldOptions) => {
     }
     // A keypress carries no `code` in some engines; fall back to the key.
     const isSpace = ev.code === "Space" || (ev.type === "keypress" && ev.key === " ");
-    if (isSpace && !ev.metaKey && !ev.ctrlKey && !ev.altKey && !ev.shiftKey
-        && !!speechRecognitionCtor() && (active || pending || opts.eligible())) {
+    if (isSpace && !ev.metaKey && !ev.ctrlKey && !ev.altKey && !ev.shiftKey) {
+      const eligible = active || pending || opts.eligible();
+      trace(`space ${ev.type}${ev.repeat ? " repeat" : ""} active=${active} pending=${pending} eligible=${eligible}`);
+      if (!speechRecognitionCtor() || !eligible) return undefined;
       if (ev.type === "keydown") {
         if (active) {
           // A genuine auto-repeat is the only thing that may be eaten while

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

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { cardPhase, phaseLabel } from "../src/utils/agentPhase";
+
+describe("cardPhase — the wall's three agent colours come from the daemon's verdict", () => {
+  it("working while a turn is in flight", () => {
+    expect(cardPhase({ agentPhase: "working", turnSeen: true })).toBe("working");
+  });
+  it("done and unread until a human has opened it since the turn ended", () => {
+    expect(cardPhase({ agentPhase: "done", turnSeen: false })).toBe("done-unread");
+    expect(cardPhase({ agentPhase: "done", turnSeen: true })).toBe("done-read");
+  });
+  it("nothing for a plain shell or an agent that has not finished a turn", () => {
+    expect(cardPhase({ agentPhase: null })).toBe(null);
+    expect(cardPhase({})).toBe(null);
+  });
+  it("labels", () => {
+    expect(phaseLabel("working")).toBe("WORKING");
+    expect(phaseLabel("done-unread")).toBe("DONE");
+    expect(phaseLabel("done-read")).toBe("READ");
+    expect(phaseLabel(null)).toBe("");
+  });
+});

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { claimOnAttach, claimOnClick, isPlainClick } from "../src/utils/sizeClaim";
+import { claimOnAttach, claimOnClick, claimOnTileFocus, isPlainClick, sizeIsForeign } from "../src/utils/sizeClaim";
 
 describe("claimOnAttach — only a deliberate open takes the size", () => {
   const base = { viewMode: "fit" as const, visible: true, deliberate: true };
@@ -40,3 +40,26 @@ describe("isPlainClick — the release of a drag is not a click", () => {
     expect(isPlainClick({ x: 100, y: 100 }, { x: 100, y: 100 }, true)).toBe(false);
   });
 });
+
+describe("claimOnTileFocus — a tile you engaged fits itself, a tile the wall pre-focused does not", () => {
+  const natural = { cols: 90, rows: 28 };
+  it("claims when a click lands on a tile wearing a full-screen size", () => {
+    expect(claimOnTileFocus({ deliberate: true, natural, current: { cols: 180, rows: 48 } })).toBe(true);
+  });
+  it("stays quiet when the session already fits, within rounding", () => {
+    expect(claimOnTileFocus({ deliberate: true, natural, current: { cols: 88, rows: 30 } })).toBe(false);
+    expect(claimOnTileFocus({ deliberate: true, natural, current: natural })).toBe(false);
+  });
+  it("never claims for the wall's own pre-focus of the current session", () => {
+    expect(claimOnTileFocus({ deliberate: false, natural, current: { cols: 180, rows: 48 } })).toBe(false);
+  });
+  it("needs a measurable tile and refuses a degenerate fit", () => {
+    expect(claimOnTileFocus({ deliberate: true, natural: null, current: { cols: 180, rows: 48 } })).toBe(false);
+    expect(claimOnTileFocus({ deliberate: true, natural: { cols: 12, rows: 3 }, current: { cols: 180, rows: 48 } })).toBe(false);
+  });
+  it("sizeIsForeign is the same tolerance the ⤢ badge uses", () => {
+    expect(sizeIsForeign({ cols: 93, rows: 30 }, natural)).toBe(false);
+    expect(sizeIsForeign({ cols: 120, rows: 28 }, natural)).toBe(true);
+    expect(sizeIsForeign({ cols: 90, rows: 40 }, natural)).toBe(true);
+  });
+});

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

@@ -261,7 +261,7 @@ describe("hold-space dictation", () => {
     expect(FakeRecognition.last).not.toBe(first);
   });
 
-  it("gives the space bar back when recognisers keep ending without hearing anything", () => {
+  it("gives the space bar back when recognisers REFUSE — ending at once, three times, hearing nothing", () => {
     const hold = makeHold();
     hold.handleKey(keydown());
     vi.advanceTimersByTime(500);
@@ -273,6 +273,36 @@ describe("hold-space dictation", () => {
     expect(overlays[overlays.length - 1]).toBe(null);
   });
 
+  it("silence never ends a hold that is still held — sessions timing out are replaced for as long as Space is down", () => {
+    const hold = makeHold();
+    hold.handleKey(keydown());
+    vi.advanceTimersByTime(500);
+    // Chrome's no-speech comes after seconds of silence, session after session.
+    for (let i = 0; i < 6; i++) {
+      vi.advanceTimersByTime(8000);
+      FakeRecognition.last!.onerror?.({ error: "no-speech" });
+      FakeRecognition.last!.onend?.();
+      expect(hold.isActive()).toBe(true);
+      expect(overlays[overlays.length - 1]).not.toBe(null);
+    }
+    // Still held, still listening: an auto-repeat is eaten, not typed.
+    expect(pressSpace(hold, { repeat: true }).typed).toBe(false);
+    hold.handleKey(keyup());
+    expect(hold.isActive()).toBe(false);
+  });
+
+  it("an 'aborted' error raised while we are stopping does not throw the words away", () => {
+    const hold = makeHold();
+    hold.handleKey(keydown());
+    vi.advanceTimersByTime(500);
+    FakeRecognition.last!.onresult?.({ resultIndex: 0, results: [Object.assign([{ transcript: "keep this" }], { isFinal: true })] } as never);
+    const r = FakeRecognition.last!;
+    hold.handleKey(keyup());          // stop(): finishes with the words
+    r.onerror?.({ error: "aborted" }); // the recogniser objecting on its way out
+    r.onend?.();
+    expect(sent.filter((d) => d !== "\x7f")).toEqual(["keep this"]);
+  });
+
   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

package/hop

@@ -18,6 +18,8 @@ const WebSocket = require('ws');
 const { resolveActorFromHeaders, canActorAccessSession } = require('./lib/terminal-access');
 const { generateSessionName, getThemeChoices, isValidTheme, DEFAULT_THEME } = require('./lib/naming-themes');
 const { AuthSessionStore, isSessionToken: isAuthSessionToken } = require('./lib/auth-sessions');
+const { agentPhase } = require('./lib/agent-phase');
+const { snapshotFromMetas, planRefiles, pruneList, snapshotFileName } = require('./lib/identity-snapshot');
 const { rotateAuditFile, sweepStaleAuditDirs } = require('./lib/audit-rotation');
 const {
     createFailureTracker,
@@ -5357,6 +5359,30 @@ function readTurnAt(internalName) {
         return Number.isFinite(at) ? at : 0;
     } catch (e) { return 0; }
 }
+// When the agent's current turn BEGAN (Claude's UserPromptSubmit hook; Codex
+// has no equivalent, so 0 there). Paired with readTurnAt by agentPhase().
+function readPromptAt(internalName) {
+    try {
+        const at = Date.parse(JSON.parse(fs.readFileSync(
+            path.join(CLAUDE_SESSIONS_DIR, `${internalName}.prompt`), 'utf8')).at);
+        return Number.isFinite(at) ? at : 0;
+    } catch (e) { return 0; }
+}
+// The wall's three agent colours, decided here so the web and the phone
+// agree: working / done-unread / done-read. Plain shells get null.
+function agentPhaseFields(s) {
+    if (!s.agent) return { agentPhase: null, turnSeen: true, turnAt: null };
+    const turnAt = readTurnAt(s.internalName);
+    const r = agentPhase({
+        agent: s.agent,
+        turnAt,
+        promptAt: readPromptAt(s.internalName),
+        lastActivityAt: Number(s.lastActivityAt) || 0,
+        lastUserSeenAt: Number(s.lastUserSeenAt) || 0,
+        userAttached: s.userAttached === true
+    });
+    return { agentPhase: r.phase, turnSeen: r.turnSeen, turnAt: turnAt || null };
+}
 // The newest published view's time (ms) for a session, from the manifest
 // the views summary already reads. `hop view` rings one bell per publish.
 function latestViewAtMs(internalName) {
@@ -5708,6 +5734,55 @@ function listClaudeSessionMetas() {
     return out;
 }
 
+// ---- Identity snapshots (lib/identity-snapshot.js) -------------------------
+// A second copy of the durable metas' user-authored fields — above all which
+// FOLDER each session is filed in — written at start, at stop and hourly.
+// The 2026-09-26 `stop --all` deleted every live session's records and the
+// rebuilt metas had no folder to go back to; the snapshot is what makes that
+// recoverable next time. restore re-files from the newest one.
+const IDENTITY_SNAPSHOT_DIR = path.join(HOME_DIR, 'restore-snapshots');
+function writeIdentitySnapshot(reason) {
+    try {
+        const snap = snapshotFromMetas(listClaudeSessionMetas(), sessionStore.folders, { reason });
+        fs.mkdirSync(IDENTITY_SNAPSHOT_DIR, { recursive: true, mode: 0o700 });
+        const file = path.join(IDENTITY_SNAPSHOT_DIR, snapshotFileName(snap.at));
+        writePrivateFile(file, JSON.stringify(snap, null, 1), 0o600);
+        for (const old of pruneList(fs.readdirSync(IDENTITY_SNAPSHOT_DIR))) {
+            try { fs.unlinkSync(path.join(IDENTITY_SNAPSHOT_DIR, old)); } catch (e) { /* best effort */ }
+        }
+        return file;
+    } catch (e) {
+        log(`[snapshot] could not write identity snapshot: ${e?.message || e}`, DIM);
+        return null;
+    }
+}
+function latestIdentitySnapshot() {
+    try {
+        const names = fs.readdirSync(IDENTITY_SNAPSHOT_DIR).filter((n) => /^identity-.*\.json$/.test(n)).sort();
+        if (!names.length) return null;
+        const file = path.join(IDENTITY_SNAPSHOT_DIR, names[names.length - 1]);
+        return { file, snapshot: JSON.parse(fs.readFileSync(file, 'utf8')) };
+    } catch (e) { return null; }
+}
+// Sessions whose meta has no folder at all but which the newest snapshot
+// remembers in a folder that still exists get their folder back. An
+// explicit `folderId: null` (unfiled on purpose) is respected.
+function refileFromIdentitySnapshot({ dryRun = false } = {}) {
+    const latest = latestIdentitySnapshot();
+    if (!latest) return [];
+    const plan = planRefiles(listClaudeSessionMetas(), latest.snapshot, sessionStore.folders);
+    for (const item of plan) {
+        const folderName = sessionStore.folders[item.folderId]?.name || item.folderId;
+        if (dryRun) { log(`  would re-file ${item.displayName} → ${folderName} (from ${path.basename(latest.file)})`, DIM); continue; }
+        const durable = readClaudeSessionMeta(item.internalName) || {};
+        writeClaudeSessionMeta(item.internalName, { ...durable, internalName: item.internalName, folderId: item.folderId });
+        rememberRuntimeSessionMetadata(item.internalName, { ...(getRuntimeSessionMetadata(item.internalName) || {}), folderId: item.folderId });
+        if (sessionStore.sessions[item.internalName]) moveSessionToFolder(item.internalName, item.folderId);
+        log(`  re-filed ${item.displayName} → ${folderName} (from ${path.basename(latest.file)})`, DIM);
+    }
+    return plan;
+}
+
 // Claude Code slugifies a project cwd for <config-root>/projects/<slug>/.
 // The rule has changed across versions (older: every non-alphanumeric -> '-';
 // newer builds preserve spaces: "nebula-notebook 2" keeps its space), so
@@ -6448,6 +6523,11 @@ function resolveRestoreTargets(names, snapshot) {
     return { resolved, unknown };
 }
 async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = false, only = null } = {}) {
+    // Folders first: a session whose meta lost its folder (records deleted,
+    // meta rebuilt) is put back where the newest identity snapshot says it
+    // was, so the restored wall is filed the way the user left it.
+    const refiled = refileFromIdentitySnapshot({ dryRun });
+    if (refiled.length) log(`${dryRun ? 'Would re-file' : 'Re-filed'} ${refiled.length} session(s) into their folders from the identity snapshot.`, DIM);
     const snapshot = await listAllSessionEntriesRuntimeFirst();
     const live = new Set(snapshot.entries.filter((e) => e.live).map((e) => e.internalName));
     // Targeted redo (`hop restore <name>...`): the named sessions are planned
@@ -6822,7 +6902,9 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
 // The same script is registered for two events: SessionStart (records the
 // conversation id for `hop restore`) and Stop (bumps a per-turn counter a driver
 // can wait on). See scripts/claude-session-hook.js.
-const CLAUDE_HOOK_EVENTS = ['SessionStart', 'Stop', 'Notification', 'PreToolUse'];
+// UserPromptSubmit marks the START of a turn (with Stop's end, the wall
+// colours the session "working" / "done" — see lib/agent-phase.js).
+const CLAUDE_HOOK_EVENTS = ['SessionStart', 'Stop', 'Notification', 'PreToolUse', 'UserPromptSubmit'];
 // Notification (permission prompts, elicitation) and PreToolUse (the two tools
 // that open a dialog and wait) bump the per-session ASK record — "whenever an
 // agent asks me a question, notify me" (Jian). PreToolUse gets a matcher, or
@@ -11644,6 +11726,9 @@ happens until someone clicks it.
                 cwd: s.cwd,
                 foregroundProcess: s.foregroundProcess,
                 agent: s.agent || null,
+                // working / done + whether the human has opened it since the
+                // turn ended (server-side seen witness, so every device agrees).
+                ...agentPhaseFields(s),
                 lastActivityAt: s.lastActivityAt,
                 // For sessions armed with notify-on-finish, each completed turn
                 // adds to bellSeq so the phone treats a finished response like a
@@ -12570,13 +12655,16 @@ happens until someone clicks it.
             req.on('end', () => {
                 try {
                     const { name, internalName, folderId, index } = JSON.parse(body);
+                    // Unfiling is recorded as an explicit null: a meta with
+                    // NO folderId key is one that may have LOST it, and the
+                    // identity snapshot re-files those on restore.
                     const persistMembership = (target) => {
                         if (!target) return;
                         const durable = readClaudeSessionMeta(target) || {};
                         writeClaudeSessionMeta(target, {
                             ...durable,
                             internalName: target,
-                            folderId: folderId || undefined
+                            folderId: folderId || null
                         });
                     };
                     // Resolve like every other session endpoint: a live
@@ -19317,6 +19405,12 @@ async function main() {
         // per file, and a no-op when the folder doesn't exist yet.
         setTimeout(enforceUploadBudget, 20000).unref?.();
         setInterval(enforceUploadBudget, 3600000).unref?.();
+
+        // Identity snapshot (folders, names, origins): once the boot settles,
+        // then hourly. Cheap — one small file — and the reason restore can
+        // put sessions back in their folders after their records are lost.
+        setTimeout(() => writeIdentitySnapshot('start'), 30000).unref?.();
+        setInterval(() => writeIdentitySnapshot('hourly'), 3600000).unref?.();
     }
 
     if (DAEMON_FLAG) {
@@ -19324,6 +19418,7 @@ async function main() {
             if (shuttingDown) return;
             shuttingDown = true;
             log(`Cleaning up...`, YELLOW);
+            writeIdentitySnapshot('stop');
 
             stopTunnelHealthMonitor();
 

package/lib/agent-phase.js

@@ -0,0 +1,57 @@
+'use strict';
+// What an agent session is doing right now, for the wall's colours — the web
+// wall and the phone both read it from the session list, so they agree:
+//
+//   working      a turn is in flight
+//   done         the last turn finished, and the human has not opened the
+//                session since  (turnSeen: false)
+//   done, read   the last turn finished and the human has looked  (turnSeen: true)
+//
+// Decided from records hop already keeps. The turn record (`.turn`, written by
+// Claude's Stop hook and Codex's notify chain) says when the last turn ENDED.
+// Claude's UserPromptSubmit hook (`.prompt`) says when the current one began;
+// Codex has no such hook, so for it — and for Claude sessions that predate
+// the hook — output flowing after the last turn ended stands in for it.
+// "Read" is the daemon's seen witness: a user client (not a wall preview, not
+// an agent's terminal) attached to the session since the turn ended.
+
+/** Output this recent means a turn is in flight (Codex spins while it works). */
+const WORKING_RECENT_MS = 15000;
+/** A submitted prompt with no output for this long was interrupted (Esc), not working. */
+const PROMPT_STALE_MS = 45000;
+/** The final render lands just after the Stop hook fires; output inside this tail is the turn's own. */
+const TURN_TAIL_MS = 1500;
+
+/**
+ * @param {object} o
+ * @param {string|null} o.agent            'claude' | 'codex' | null
+ * @param {number} [o.turnAt]              ms, when the last turn ended (0 = never)
+ * @param {number} [o.promptAt]            ms, when the last prompt was submitted (0 = unknown)
+ * @param {number} [o.lastActivityAt]      ms, last PTY output
+ * @param {number} [o.lastUserSeenAt]      ms, when a user client last left (or attached)
+ * @param {boolean} [o.userAttached]       a user client is on it right now
+ * @param {number} [o.now]
+ * @returns {{ phase: 'working'|'done'|null, turnSeen: boolean }}
+ */
+function agentPhase(o) {
+    const now = Number.isFinite(o.now) ? o.now : Date.now();
+    if (!o.agent) return { phase: null, turnSeen: true };
+    const turnAt = Number(o.turnAt) || 0;
+    const promptAt = Number(o.promptAt) || 0;
+    const active = Number(o.lastActivityAt) || 0;
+    let working;
+    if (promptAt > turnAt) {
+        // Claude, with the prompt hook: a prompt newer than the last turn end
+        // is a turn in flight — unless the screen has been dead quiet for so
+        // long that it was interrupted and never finished.
+        working = active > 0 && now - active < PROMPT_STALE_MS;
+    } else {
+        working = active > 0 && now - active < WORKING_RECENT_MS && active > turnAt + TURN_TAIL_MS;
+    }
+    if (working) return { phase: 'working', turnSeen: true };
+    if (!turnAt) return { phase: null, turnSeen: true };
+    const seenAt = o.userAttached ? now : (Number(o.lastUserSeenAt) || 0);
+    return { phase: 'done', turnSeen: seenAt >= turnAt };
+}
+
+module.exports = { agentPhase, WORKING_RECENT_MS, PROMPT_STALE_MS, TURN_TAIL_MS };

package/lib/identity-snapshot.js

@@ -0,0 +1,74 @@
+'use strict';
+// A second copy of what only the durable session metas know — the user's
+// own filing (folder), name and origin per session — written on every
+// daemon start and stop and hourly in between, so losing the metas (the
+// 2026-09-26 `stop --all` deleted all 34 live sessions' records; a
+// thermal-sleep crash before that lost three days of them) no longer means
+// losing the folders too. `hop restore` re-files a session from the newest
+// snapshot when its meta has forgotten which folder it was in.
+//
+// Pure: the daemon supplies the metas, folders and clock, and applies the
+// plan. The one subtlety is the difference between "unfiled on purpose"
+// and "forgot": the move endpoint now records an unfiling as an explicit
+// `folderId: null`, so a meta with NO folderId key is the one that may have
+// lost it. Metas older than that change have no key either way, which is
+// why a session is only re-filed when a snapshot actually remembers a
+// folder for it.
+
+const KEEP = 24;
+
+/** The identity worth a second copy, per session. */
+function snapshotFromMetas(metas, folders, { at, reason } = {}) {
+    const sessions = {};
+    for (const m of metas || []) {
+        if (!m || !m.internalName) continue;
+        sessions[m.internalName] = {
+            displayName: m.displayName || undefined,
+            folderId: m.folderId || null,
+            createdBy: m.createdBy || undefined,
+            cwd: m.cwd || undefined,
+            parked: m.parked === true || undefined,
+            archived: m.archived === true || undefined
+        };
+    }
+    return {
+        at: at || new Date().toISOString(),
+        reason: reason || '',
+        folders: folders || {},
+        sessions
+    };
+}
+
+/**
+ * Which sessions to re-file, given the current metas and the newest
+ * snapshot: those whose meta has no folderId key at all (never filed, or
+ * lost) but which the snapshot remembers in a folder that still exists.
+ * A meta that says `folderId: null` was unfiled on purpose and is left
+ * alone; one that already names a folder is not second-guessed.
+ */
+function planRefiles(metas, snapshot, folders) {
+    if (!snapshot || !snapshot.sessions) return [];
+    const out = [];
+    for (const m of metas || []) {
+        if (!m || !m.internalName) continue;
+        if (Object.prototype.hasOwnProperty.call(m, 'folderId')) continue;
+        const remembered = snapshot.sessions[m.internalName];
+        const folderId = remembered && remembered.folderId;
+        if (!folderId) continue;
+        if (!folders || !folders[folderId]) continue;
+        out.push({ internalName: m.internalName, folderId, displayName: m.displayName || remembered.displayName || m.internalName });
+    }
+    return out;
+}
+
+/** Snapshot file names sort by time; keep the newest KEEP. */
+function pruneList(names, keep = KEEP) {
+    const mine = (names || []).filter((n) => /^identity-.*\.json$/.test(n)).sort();
+    return mine.slice(0, Math.max(0, mine.length - keep));
+}
+
+function snapshotFileName(at) {
+    return `identity-${String(at || new Date().toISOString()).replace(/[:.]/g, '-')}.json`;
+}
+
+module.exports = { snapshotFromMetas, planRefiles, pruneList, snapshotFileName, KEEP };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.63",
+  "version": "0.11.64",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {

package/scripts/claude-session-hook.js

@@ -8,6 +8,9 @@
 //
 //   Stop -> bump a per-turn completion counter at
 //       <HOP_HOME>/claude-sessions/<HOP_SESSION>.turn
+//   UserPromptSubmit -> note that a turn just BEGAN, at
+//       <HOP_HOME>/claude-sessions/<HOP_SESSION>.prompt
+//       (with .turn this is how the wall colours a session "working")
 //       ({ sessionId, count, at }). `count` increments once each time Claude
 //       finishes a turn, giving a deterministic "agent is done with this turn"
 //       signal a driver (the hop MCP) can wait on instead of scraping the screen.
@@ -190,6 +193,74 @@ function bumpTurn(dir, hopSession, payload) {
   } catch { /* ignore */ }
 }
 
+// A turn just began: the human (or a driver) submitted a prompt. With the
+// Stop record this brackets the turn, so the wall can colour a session
+// "working" from the first second instead of guessing from output — and
+// keeps colouring it through a long silent think. Overwritten each prompt.
+function notePrompt(dir, hopSession, payload) {
+  const file = path.join(dir, `${hopSession}.prompt`);
+  const record = JSON.stringify({
+    sessionId: typeof payload.session_id === "string" ? payload.session_id : null,
+    at: new Date().toISOString()
+  });
+  try { writeDurable(file, record); } catch { /* ignore */ }
+}
+
+// The agent is ASKING the human something — a permission prompt, an
+// AskUserQuestion dialog, a plan awaiting approval — and will sit there until
+// answered. Recorded per hop session as `<session>.ask` {count, at, type,
+// message}: the daemon folds the count into bellSeq (always on — a question
+// is worth a buzz by definition) and passes the message through, so the
+// phone can say WHAT is being asked. Claude reports these two ways:
+// the Notification event (permission_prompt / elicitation_dialog — the
+// idle_prompt and auth_success types are not questions) and PreToolUse for
+// the two tools that open a dialog (AskUserQuestion carries the question
+// text itself; ExitPlanMode is a plan waiting for approval).
+function bumpAsk(dir, hopSession, payload, event) {
+  let type = "", message = "";
+  if (event === "Notification") {
+    type = typeof payload.notification_type === "string" ? payload.notification_type : "notification";
+    if (type === "idle_prompt" || type === "auth_success") return;
+    message = typeof payload.message === "string" && payload.message
+      ? payload.message
+      : (typeof payload.title === "string" && payload.title ? payload.title : "needs your attention");
+  } else if (event === "PermissionRequest") {
+    // Codex (hooks.json): fires before Codex asks to approve a command or
+    // network access. tool_input.description is Codex's own one-line reason.
+    type = "permission";
+    const ti = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {};
+    const tool = typeof payload.tool_name === "string" ? payload.tool_name : "";
+    message = typeof ti.description === "string" && ti.description ? ti.description
+      : (typeof ti.command === "string" && ti.command ? `wants to run: ${ti.command}`
+      : (tool ? `needs your approval for ${tool}` : "needs your approval"));
+  } else if (event === "PreToolUse") {
+    const tool = typeof payload.tool_name === "string" ? payload.tool_name : "";
+    if (tool === "AskUserQuestion") {
+      type = "question";
+      const qs = Array.isArray(payload.tool_input?.questions) ? payload.tool_input.questions : [];
+      message = qs.map((q) => (q && typeof q.question === "string" ? q.question : ""))
+        .filter(Boolean).join(" · ") || "has a question for you";
+    } else if (tool === "ExitPlanMode") {
+      type = "plan";
+      message = "has a plan ready for your approval";
+    } else return;
+  } else return;
+  const file = path.join(dir, `${hopSession}.ask`);
+  let count = 0;
+  try {
+    const prev = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (prev && Number.isInteger(prev.count) && prev.count >= 0) count = prev.count;
+  } catch { /* first ask */ }
+  try {
+    writeDurable(file, JSON.stringify({
+      sessionId: typeof payload.session_id === "string" ? payload.session_id : null,
+      count: count + 1,
+      at: new Date().toISOString(),
+      type,
+      message: String(message).replace(/\s+/g, " ").trim().slice(0, 300)
+    }));
+  } catch { /* ignore */ }
+}
 function main() {
   const hopSession = process.env.HOP_SESSION;
   if (!hopSession || !/^[A-Za-z0-9_-]+$/.test(hopSession)) return; // not a hop session
@@ -226,6 +297,10 @@ function main() {
   // signals a premature "turn done".
   if (event === "Stop") {
     bumpTurn(dir, hopSession, payload);
+  } else if (event === "UserPromptSubmit") {
+    notePrompt(dir, hopSession, payload);
+  } else if (event === "Notification" || event === "PreToolUse" || event === "PermissionRequest") {
+    bumpAsk(dir, hopSession, payload, event);
   } else {
     recordSession(dir, hopSession, payload, launchCmd); // SessionStart (default)
   }

package/tests/agent-phase.unit.test.cjs

@@ -0,0 +1,47 @@
+// The wall's three agent colours — working / done / done-and-read — decided
+// from the records hop keeps, the same way for the web and the phone.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { agentPhase } = require('../lib/agent-phase');
+
+const NOW = 1_800_000_000_000;
+const s = (o) => agentPhase({ agent: 'claude', now: NOW, ...o });
+
+test('a plain shell has no phase', () => {
+  assert.deepEqual(agentPhase({ agent: null, turnAt: NOW - 1000, lastActivityAt: NOW, now: NOW }), { phase: null, turnSeen: true });
+});
+
+test('claude with the prompt hook: a prompt newer than the last turn end is WORKING while the screen moves', () => {
+  assert.equal(s({ turnAt: NOW - 60_000, promptAt: NOW - 5_000, lastActivityAt: NOW - 2_000 }).phase, 'working');
+  // Thinking for a while with a slow spinner still counts.
+  assert.equal(s({ turnAt: NOW - 60_000, promptAt: NOW - 30_000, lastActivityAt: NOW - 20_000 }).phase, 'working');
+});
+
+test('an interrupted prompt (dead quiet for long) is not working forever', () => {
+  const r = s({ turnAt: NOW - 600_000, promptAt: NOW - 300_000, lastActivityAt: NOW - 120_000, lastUserSeenAt: NOW - 100_000 });
+  assert.equal(r.phase, 'done');
+  assert.equal(r.turnSeen, true);
+});
+
+test('codex (no prompt hook): output flowing after the last turn ended is WORKING', () => {
+  assert.equal(agentPhase({ agent: 'codex', turnAt: NOW - 60_000, lastActivityAt: NOW - 3_000, now: NOW }).phase, 'working');
+});
+
+test('the final render right after the Stop hook is the turn\'s own output, not a new turn', () => {
+  assert.equal(s({ turnAt: NOW - 3_000, lastActivityAt: NOW - 2_200 }).phase, 'done');
+});
+
+test('quiet after a turn is DONE; unread until a user client has been on it since', () => {
+  assert.deepEqual(s({ turnAt: NOW - 60_000, lastActivityAt: NOW - 61_000, lastUserSeenAt: NOW - 120_000 }), { phase: 'done', turnSeen: false });
+  assert.deepEqual(s({ turnAt: NOW - 60_000, lastActivityAt: NOW - 61_000, lastUserSeenAt: NOW - 30_000 }), { phase: 'done', turnSeen: true });
+  assert.deepEqual(s({ turnAt: NOW - 60_000, lastActivityAt: NOW - 61_000, lastUserSeenAt: 0 }), { phase: 'done', turnSeen: false });
+});
+
+test('a user attached right now has read whatever just finished', () => {
+  assert.deepEqual(s({ turnAt: NOW - 1_000, lastActivityAt: NOW - 2_000, lastUserSeenAt: 0, userAttached: true }), { phase: 'done', turnSeen: true });
+});
+
+test('an agent session that has never completed a turn and is quiet has no phase', () => {
+  assert.equal(s({ turnAt: 0, lastActivityAt: NOW - 60_000 }).phase, null);
+  assert.equal(s({ turnAt: 0, lastActivityAt: NOW - 1_000 }).phase, 'working');
+});

package/tests/claude-session-hook.unit.test.cjs

@@ -192,3 +192,14 @@ test('outside hop the hook is a no-op', () => {
   });
   assert.equal(fs.readdirSync(path.join(home, 'claude-sessions')).length, 0);
 });
+
+test('a submitted prompt is noted as the start of a turn, and a headless helper\'s is not', () => {
+  const home = freshHome();
+  runHook(home, 'alpha', { hook_event_name: 'UserPromptSubmit', session_id: 'sess-1', prompt: 'do the thing' });
+  const rec = JSON.parse(fs.readFileSync(path.join(home, 'claude-sessions', 'alpha.prompt'), 'utf8'));
+  assert.equal(rec.sessionId, 'sess-1');
+  assert.ok(Number.isFinite(Date.parse(rec.at)));
+  // A nested claude (its env carries the parent's id) never marks the terminal's turn.
+  runHook(home, 'beta', { hook_event_name: 'UserPromptSubmit', session_id: 'child-1' }, { CLAUDE_CODE_SESSION_ID: 'parent-1' });
+  assert.equal(fs.existsSync(path.join(home, 'claude-sessions', 'beta.prompt')), false);
+});

package/tests/identity-snapshot.unit.test.cjs

@@ -0,0 +1,52 @@
+// The second copy of the user's filing, and how restore uses it.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { snapshotFromMetas, planRefiles, pruneList, snapshotFileName } = require('../lib/identity-snapshot');
+
+const folders = { f_a: { id: 'f_a', name: 'Research' }, f_b: { id: 'f_b', name: 'Softwares' } };
+
+test('a snapshot keeps name, folder and origin per session, and the folders themselves', () => {
+  const snap = snapshotFromMetas([
+    { internalName: 's_1', displayName: 'Aurora', folderId: 'f_a', createdBy: 'user', cwd: '/w' },
+    { internalName: 's_2', displayName: 'Lyra' },
+    { internalName: '' }
+  ], folders, { at: '2026-09-29T00:00:00.000Z', reason: 'start' });
+  assert.equal(snap.reason, 'start');
+  assert.deepEqual(Object.keys(snap.sessions), ['s_1', 's_2']);
+  assert.equal(snap.sessions.s_1.folderId, 'f_a');
+  assert.equal(snap.sessions.s_2.folderId, null);
+  assert.equal(snap.folders.f_b.name, 'Softwares');
+});
+
+test('a session whose meta forgot its folder is re-filed from the snapshot', () => {
+  const snap = snapshotFromMetas([{ internalName: 's_1', displayName: 'Aurora', folderId: 'f_a' }], folders);
+  const plan = planRefiles([{ internalName: 's_1', displayName: 'Aurora', cwd: '/w' }], snap, folders);
+  assert.deepEqual(plan, [{ internalName: 's_1', folderId: 'f_a', displayName: 'Aurora' }]);
+});
+
+test('unfiled on purpose (explicit null) and already-filed metas are left alone', () => {
+  const snap = snapshotFromMetas([
+    { internalName: 's_1', folderId: 'f_a' },
+    { internalName: 's_2', folderId: 'f_a' }
+  ], folders);
+  const plan = planRefiles([
+    { internalName: 's_1', folderId: null },
+    { internalName: 's_2', folderId: 'f_b' }
+  ], snap, folders);
+  assert.deepEqual(plan, []);
+});
+
+test('a folder that no longer exists, or a session the snapshot never filed, is not re-filed', () => {
+  const snap = snapshotFromMetas([
+    { internalName: 's_1', folderId: 'f_gone' },
+    { internalName: 's_2' }
+  ], folders);
+  assert.deepEqual(planRefiles([{ internalName: 's_1' }, { internalName: 's_2' }, { internalName: 's_3' }], snap, folders), []);
+  assert.deepEqual(planRefiles([{ internalName: 's_1' }], null, folders), []);
+});
+
+test('snapshot files sort by time and the oldest are pruned', () => {
+  const names = ['identity-2026-09-01T00-00-00-000Z.json', 'identity-2026-09-03T00-00-00-000Z.json', 'other.json', 'identity-2026-09-02T00-00-00-000Z.json'];
+  assert.deepEqual(pruneList(names, 2), ['identity-2026-09-01T00-00-00-000Z.json']);
+  assert.equal(snapshotFileName('2026-09-29T01:02:03.004Z'), 'identity-2026-09-29T01-02-03-004Z.json');
+});