hop2 0.11.64 → 0.11.65

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

@@ -22,6 +22,7 @@ import { getMathTip } from "./utils/mathTooltip";
 import { scanKeyboardProtocol } from "./utils/keyboardProtocol";
 import { originalPathHint, pasteableUploadPaths } from "./utils/fileDrop";
 import { claimOnAttach, claimOnClick, isPlainClick } from "./utils/sizeClaim";
+import { installDragSelect } from "./utils/dragSelect";
 import { MobileKeyboard } from "./components/MobileKeyboard";
 import { SessionSwitcher } from "./components/SessionSwitcher";
 import { SecondaryPane } from "./components/SecondaryPane";
@@ -743,6 +744,14 @@ const App = () => {
     return screenLooksLikeClaude();
   };
   foregroundIsClaudeRef.current = foregroundIsClaude;
+  // Which agent the current session runs, by the daemon's hook records.
+  const currentSessionAgentRef = useRef<(() => "claude" | "codex" | null) | null>(null);
+  currentSessionAgentRef.current = () => {
+    const room = activeSessionRoomRef.current;
+    if (!room) return null;
+    const s = sessionsRef.current.find((x) => (x.internalName || x.name) === room);
+    return s?.agent || null;
+  };
   const drawerOpenRef = useRef(drawerOpen);
   drawerOpenRef.current = drawerOpen;
   const shortcutHelpRef = useRef(shortcutHelpOpen);
@@ -2098,6 +2107,9 @@ const App = () => {
       fontFamily: getComputedStyle(document.documentElement).getPropertyValue("--font-terminal").trim()
         || "Menlo, Monaco, 'Courier New', monospace",
       fontSize,
+      // ⌥-drag always selects, iTerm's escape hatch for apps that track the
+      // mouse. (Plain drag selects too in agent sessions — utils/dragSelect.)
+      macOptionClickForcesSelection: true,
       lineHeight: 1.3,
       cursorBlink: true,
       scrollback: 50000,
@@ -2136,6 +2148,14 @@ const App = () => {
     // Unicode, the browser around the terminal draws properly.
     enableMathHover(terminal, getMathTip());
     terminal.open(containerRef.current);
+    // Plain drag selects in Claude/Codex sessions even though they track the
+    // mouse; the wheel still reaches them. See utils/dragSelect.ts.
+    // Hooked on the SCROLL wrapper, not xterm's host: a press in the gutter
+    // lands on the wrapper (which still starts a selection when tracking is
+    // off), and a capture listener only sees presses on its own subtree.
+    (terminal as any).__dragSelectCleanup = installDragSelect(terminal as never,
+      (containerRef.current.closest(".terminal-scroll") as HTMLElement | null) || containerRef.current, () =>
+      foregroundIsClaudeRef.current?.() === true || currentSessionAgentRef.current?.() === "codex");
 
     // GPU-accelerated rendering (same renderer VS Code uses). Must load after
     // open(). If WebGL isn't available (old GPU, blocklisted driver) the
@@ -3032,6 +3052,10 @@ const App = () => {
           (terminal as any).__overlayScrollbarCleanup();
           (terminal as any).__overlayScrollbarCleanup = null;
         }
+        if ((terminal as any).__dragSelectCleanup) {
+          (terminal as any).__dragSelectCleanup();
+          (terminal as any).__dragSelectCleanup = null;
+        }
         terminal.dispose();
         termRef.current = null;
         fitRef.current = null;

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

@@ -1,4 +1,6 @@
 import { useEffect, useRef, useState, type PointerEvent as ReactPointerEvent } from "react";
+import { installDragSelect } from "../utils/dragSelect";
+import { bufferLooksLikeClaude } from "../utils/voiceHold";
 import { Terminal } from "@xterm/xterm";
 import { FitAddon } from "@xterm/addon-fit";
 import { safeParseServerMessage } from "hay-shared";
@@ -58,6 +60,8 @@ export const SecondaryPane = ({
   onSplit,
   onZoom
 }: Props) => {
+  const procLabelRef = useRef(procLabel);
+  procLabelRef.current = procLabel;
   const hostRef = useRef<HTMLDivElement>(null);
   const boxRef = useRef<HTMLDivElement>(null);
   const termRef = useRef<Terminal | null>(null);
@@ -77,6 +81,7 @@ export const SecondaryPane = ({
       cols: sizeRef.current.cols,
       rows: sizeRef.current.rows,
       fontSize,
+      macOptionClickForcesSelection: true,
       fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
       theme: theme as never,
       scrollback: 2000,
@@ -86,6 +91,10 @@ export const SecondaryPane = ({
     term.loadAddon(fitAddon);
     enableMathHover(term, getMathTip());
     term.open(hostRef.current);
+    // Plain drag selects in Claude/Codex panes even though they track the
+    // mouse; the wheel still reaches them. See utils/dragSelect.ts.
+    const uninstallDragSelect = installDragSelect(term as never, hostRef.current, () =>
+      /^(claude|codex)$/i.test(procLabelRef.current || "") || bufferLooksLikeClaude(term as never));
     termRef.current = term;
 
     let shouldReconnect = true;
@@ -222,6 +231,7 @@ export const SecondaryPane = ({
       ro.disconnect();
       dataSub.dispose();
       try { wsRef.current?.close(); } catch { /* ignore */ }
+      uninstallDragSelect();
       term.dispose();
       termRef.current = null;
     };

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

@@ -17,6 +17,7 @@ import { enableMathHover } from "../utils/mathLinkProvider";
 import { getMathTip } from "../utils/mathTooltip";
 import { claimOnTileFocus, sizeIsForeign } from "../utils/sizeClaim";
 import { cardPhase, phaseLabel, phaseTitle } from "../utils/agentPhase";
+import { installDragSelect } from "../utils/dragSelect";
 import { urlAtCell, cellAtPoint } from "../utils/urlAtCell";
 import { attachScrollFlywheel } from "../utils/scrollFlywheel";
 import { ContextMenu, type MenuRequest } from "./ContextMenu";
@@ -356,7 +357,7 @@ 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, deliberate, claudeApp, claimSize, activeCols, activeRows, onFullscreen, onUnfocus, onNotice, onSender }: {
+const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp, codexApp = false, 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;
@@ -366,7 +367,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
    * 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;
+  live: boolean; deliberate: boolean; claudeApp: boolean; codexApp?: boolean; claimSize: boolean; activeCols?: number; activeRows?: number;
   onFullscreen: () => void; onUnfocus: () => void; onNotice: (m: string) => void;
 }) => {
   const boxRef = useRef<HTMLDivElement | null>(null);
@@ -427,6 +428,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
   // every session that came back through `hop restore`. The buffer's own
   // chrome is the honest witness; both callers share it.
   const looksLikeClaude = () => isClaudeSurface(claudeAppRef.current, termRef.current as never);
+  const codexAppRef = useRef(codexApp);
+  codexAppRef.current = codexApp;
   if (!voiceHoldRef.current) {
     voiceHoldRef.current = createVoiceHold({
       send: (data) => sendInputRef.current?.(data),
@@ -501,6 +504,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       cols: activeCols && activeCols > 1 ? activeCols : 80,
       rows: activeRows && activeRows > 1 ? activeRows : 24,
       scrollback: 2000,
+      macOptionClickForcesSelection: true,
       // Same scroll feel as the full-screen terminal: one wheel notch moves
       // 4 lines (xterm's default of 1 is the "tiles feel sluggish" report),
       // Shift+wheel blasts. Momentum is attached below.
@@ -532,6 +536,9 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
     }));
     enableMathHover(term, getMathTip()); // rendered math on hover, here too
     term.open(box);
+    // Plain drag selects in Claude/Codex tiles even though they track the
+    // mouse; the wheel still reaches them. See utils/dragSelect.ts.
+    const uninstallDragSelect = installDragSelect(term as never, box, () => looksLikeClaude() || codexAppRef.current);
     termRef.current = term;
     fitRef.current = fit;
     const inner = box.querySelector(".xterm") as HTMLElement | null;
@@ -751,6 +758,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       detachFlywheel();
       ro?.disconnect();
       sub.dispose();
+      uninstallDragSelect();
       term.dispose();
       termRef.current = null;
       fitRef.current = null;
@@ -2877,6 +2885,8 @@ export const SessionSwitcher = ({
     // signal, and two rings on one card were unreadable.
     const phase = cardPhase(s);
     const activeNow = !current && !phase && now - (s.lastActivityAt || 0) < 12000;
+    // A question waiting on you is the card's colour too (amber), over the phase.
+    const needsYou = s.attentionReason === "ask" || waitingOnUser(preview);
     // 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",
@@ -2897,7 +2907,7 @@ export const SessionSwitcher = ({
         tabIndex={0}
         data-nav-index={navIndexByKey.get(key)}
         data-session-key={key}
-        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" : ""}`}
+        className={`switcher-card${current ? " current" : ""}${activeNow ? " active-now" : ""}${phase ? ` phase-${phase}` : ""}${needsYou ? " needs-you" : ""}${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}
@@ -3028,6 +3038,7 @@ export const SessionSwitcher = ({
               live={focusedKey === key}
               deliberate={deliberateFocusRef.current === key}
               claudeApp={appLabel(s) === "claude"}
+              codexApp={appLabel(s) === "codex"}
               claimSize={s.hasLocalCli !== true}
               activeCols={preview?.cols}
               activeRows={preview?.rows}

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

@@ -2249,8 +2249,18 @@ button.primary {
   .switcher-card.active-now .switcher-card-fresh { animation: none; }
 }
 
-.switcher-card.current {
-  border-color: var(--accent);
+/* CURRENT and FOCUSED used to paint the whole frame purple, which made
+   purple the loudest colour on the wall — and purple says nothing about
+   the session. The frame and the wash now belong to STATUS (see the
+   phase/needs-you rules below); current is a purple bar along the top
+   edge plus its chip, focused a thin purple outline. */
+.switcher-card.current::before {
+  content: "";
+  position: absolute;
+  top: 0; left: 0; right: 0;
+  height: 3px;
+  background: var(--accent);
+  pointer-events: none;
 }
 
 /* The wall's order freezes while open — a session producing output RIGHT NOW
@@ -2971,7 +2981,6 @@ button.primary {
 .switcher-row.kbd-selected {
   outline: 2px solid var(--accent);
   outline-offset: -2px;
-  background: color-mix(in srgb, var(--accent) 7%, var(--panel));
 }
 
 /* AI tagline (hop ai tagline): what this session is working on, in words the
@@ -3185,7 +3194,8 @@ button.primary {
 }
 
 .switcher-card.focused {
-  border-color: var(--accent);
+  outline: 1px solid var(--accent);
+  outline-offset: -1px;
 }
 
 @media (min-width: 769px) {
@@ -3831,13 +3841,19 @@ body.pane-dragging { user-select: none; }
 @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);
+/* STATUS owns the card's colour: the frame, a wash over the whole card and
+   a soft ring, all in one hue — blue working, green finished-and-unread,
+   amber asking you (wins over the phase: a question is the more urgent
+   fact). A read session goes quiet. Purple is reserved for "you are here". */
+.switcher-card.phase-working { --status: #3b82f6; }
+.switcher-card.phase-done-unread { --status: #22a06b; }
+.switcher-card.needs-you { --status: var(--warn); }
+.switcher-card.phase-working,
+.switcher-card.phase-done-unread,
+.switcher-card.needs-you {
+  border-color: var(--status);
+  background: color-mix(in srgb, var(--status) 9%, var(--panel));
+  box-shadow: 0 0 0 1px color-mix(in srgb, var(--status) 35%, transparent), 0 0 14px -3px color-mix(in srgb, var(--status) 45%, transparent);
 }
 .switcher-card.phase-done-read {
   opacity: 0.88;

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

@@ -0,0 +1,100 @@
+// Drag to select in an AGENT session, even while the app has mouse tracking on.
+//
+// Claude Code and Codex both enable mouse tracking (for the wheel), and
+// xterm then hands every drag to the app instead of selecting. On a Mac
+// xterm offers no rescue gesture by default: Shift is ignored there, and
+// ⌥-drag needs an option nobody sets. So "I selected text and ⌘C copied
+// nothing" was really "nothing was ever selected" — the drag went to Claude,
+// which does nothing with it.
+//
+// Neither agent uses clicks or drags, only the wheel. So while the pointer
+// is down for a plain left drag on an agent surface, tracking is switched
+// off LOCALLY (xterm's protocol state is local anyway — the app is never
+// told), the drag selects, and the protocol is put back on release. The
+// wheel still reaches the app between drags. Other TUIs (vim, htop, tmux
+// with the mouse on) keep their drags: the gate is the agent surface, not
+// the tracking mode.
+
+export type TrackingTerminal = {
+  modes: { mouseTrackingMode: string };
+  hasSelection: () => boolean;
+  onSelectionChange: (cb: () => void) => { dispose: () => void };
+  _core?: { coreMouseService?: { activeProtocol: string } };
+};
+
+/** A plain left press on an agent surface while the app tracks the mouse. */
+export const shouldSelectLocally = (o: {
+  button: number;
+  metaKey: boolean;
+  ctrlKey: boolean;
+  trackingMode: string;
+  agentSurface: boolean;
+}): boolean =>
+  o.button === 0 && !o.metaKey && !o.ctrlKey && o.trackingMode !== "none" && o.agentSurface;
+
+/**
+ * Installs the capture-phase mousedown that pauses tracking for the drag.
+ * Tracking stays paused for as long as the selection it produced exists:
+ * xterm DISABLES its selection service when a protocol comes back on, and
+ * disabling clears the selection — restoring on release wiped the very
+ * text the drag had just selected (so ⌘C copied nothing). The selection
+ * clears on the next keypress or a click elsewhere, and tracking returns
+ * then. Returns the uninstaller. `agentSurface` is consulted at press time,
+ * so a session that stops being an agent session (shell after `exit`) gets
+ * its drags forwarded again.
+ */
+export const installDragSelect = (
+  terminal: TrackingTerminal,
+  element: HTMLElement,
+  agentSurface: () => boolean
+): (() => void) => {
+  let paused: { prev: string; sub: { dispose: () => void } | null } | null = null;
+  const mouse = () => terminal._core?.coreMouseService;
+  const resume = () => {
+    if (!paused) return;
+    const { prev, sub } = paused;
+    paused = null;
+    sub?.dispose();
+    const m = mouse();
+    // Put it back only if nothing else changed it meanwhile (the app
+    // switching tracking off during the pause is its own decision).
+    try { if (m && m.activeProtocol === "NONE") m.activeProtocol = prev; } catch { /* gone */ }
+  };
+  const onUp = () => {
+    if (!paused) return;
+    let has = false;
+    try { has = terminal.hasSelection(); } catch { has = false; }
+    if (!has) { resume(); return; }
+    if (!paused.sub) {
+      paused.sub = terminal.onSelectionChange(() => {
+        let still = false;
+        try { still = terminal.hasSelection(); } catch { still = false; }
+        if (!still) resume();
+      });
+    }
+  };
+  const onDown = (ev: MouseEvent) => {
+    const m = mouse();
+    if (!m) return;
+    let trackingMode = "none";
+    try { trackingMode = terminal.modes.mouseTrackingMode; } catch { return; }
+    const local = shouldSelectLocally({ button: ev.button, metaKey: ev.metaKey, ctrlKey: ev.ctrlKey, trackingMode, agentSurface: agentSurface() });
+    if (paused) {
+      // Already paused for a standing selection: another selecting press
+      // just replaces it; any other press hands the mouse back first.
+      if (!local) resume();
+      return;
+    }
+    if (!local) return;
+    const prev = m.activeProtocol;
+    try { m.activeProtocol = "NONE"; } catch { return; }
+    paused = { prev, sub: null };
+  };
+  element.addEventListener("mousedown", onDown, true);
+  window.addEventListener("mouseup", onUp, true);
+  return () => {
+    element.removeEventListener("mousedown", onDown, true);
+    window.removeEventListener("mouseup", onUp, true);
+    resume();
+  };
+};

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

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { installDragSelect, shouldSelectLocally, type TrackingTerminal } from "../src/utils/dragSelect";
+
+const fakeTerminal = (mode: string, protocol: string) => {
+  const mouse = { activeProtocol: protocol };
+  const subs = new Set<() => void>();
+  const t = {
+    modes: { mouseTrackingMode: mode },
+    _core: { coreMouseService: mouse },
+    mouse,
+    selected: false,
+    hasSelection: () => t.selected,
+    onSelectionChange: (cb: () => void) => { subs.add(cb); return { dispose: () => subs.delete(cb) }; },
+    setSelected: (v: boolean) => { t.selected = v; for (const cb of subs) cb(); }
+  };
+  return t as TrackingTerminal & typeof t;
+};
+
+describe("shouldSelectLocally — a plain drag on an agent surface selects, tracking or not", () => {
+  const base = { button: 0, metaKey: false, ctrlKey: false, trackingMode: "drag", agentSurface: true };
+  it("yes for a plain left press while Claude/Codex track the mouse", () => {
+    expect(shouldSelectLocally(base)).toBe(true);
+  });
+  it("no when the app is not an agent (vim, htop, tmux keep their drags)", () => {
+    expect(shouldSelectLocally({ ...base, agentSurface: false })).toBe(false);
+  });
+  it("no when tracking is already off (xterm selects by itself), or for right/ctrl/cmd presses", () => {
+    expect(shouldSelectLocally({ ...base, trackingMode: "none" })).toBe(false);
+    expect(shouldSelectLocally({ ...base, button: 2 })).toBe(false);
+    expect(shouldSelectLocally({ ...base, ctrlKey: true })).toBe(false);
+    expect(shouldSelectLocally({ ...base, metaKey: true })).toBe(false);
+  });
+});
+
+describe("installDragSelect — tracking pauses for the drag and stays paused while the selection stands", () => {
+  const press = (el: HTMLElement) => el.dispatchEvent(new MouseEvent("mousedown", { button: 0, bubbles: true }));
+  const release = () => window.dispatchEvent(new MouseEvent("mouseup", { button: 0, bubbles: true }));
+  it("a drag that selected nothing hands the mouse back on release", () => {
+    const t = fakeTerminal("drag", "DRAG");
+    const el = document.createElement("div"); document.body.appendChild(el);
+    const off = installDragSelect(t, el, () => true);
+    press(el);
+    expect(t.mouse.activeProtocol).toBe("NONE");
+    release();
+    expect(t.mouse.activeProtocol).toBe("DRAG");
+    off();
+  });
+  it("a drag that selected text keeps tracking off until the selection clears — so ⌘C still has it", () => {
+    const t = fakeTerminal("drag", "DRAG");
+    const el = document.createElement("div"); document.body.appendChild(el);
+    const off = installDragSelect(t, el, () => true);
+    press(el); t.setSelected(true); release();
+    expect(t.mouse.activeProtocol).toBe("NONE");
+    // A second selecting press replaces the selection, still paused.
+    press(el); t.setSelected(true); release();
+    expect(t.mouse.activeProtocol).toBe("NONE");
+    // A keypress clears the selection (xterm does this): tracking returns.
+    t.setSelected(false);
+    expect(t.mouse.activeProtocol).toBe("DRAG");
+    off();
+  });
+  it("leaves a non-agent surface alone, and respects the app turning tracking off mid-drag", () => {
+    const t = fakeTerminal("drag", "DRAG");
+    const el = document.createElement("div"); document.body.appendChild(el);
+    let agent = false;
+    const off = installDragSelect(t, el, () => agent);
+    press(el);
+    expect(t.mouse.activeProtocol).toBe("DRAG");
+    release();
+    agent = true;
+    press(el);
+    expect(t.mouse.activeProtocol).toBe("NONE");
+    t.mouse.activeProtocol = "ANY"; // the app changed its mind during the drag
+    release();
+    expect(t.mouse.activeProtocol).toBe("ANY");
+    off();
+  });
+  it("a right or ctrl press while paused hands the mouse back first", () => {
+    const t = fakeTerminal("drag", "DRAG");
+    const el = document.createElement("div"); document.body.appendChild(el);
+    const off = installDragSelect(t, el, () => true);
+    press(el); t.setSelected(true); release();
+    el.dispatchEvent(new MouseEvent("mousedown", { button: 2, bubbles: true }));
+    expect(t.mouse.activeProtocol).toBe("DRAG");
+    off();
+  });
+});

package/hop

@@ -18,8 +18,9 @@ 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 { agentPhase, screenSaysWorking } = require('./lib/agent-phase');
 const { snapshotFromMetas, planRefiles, pruneList, snapshotFileName } = require('./lib/identity-snapshot');
+const { withCodexIdentity } = require('./lib/codex-identity');
 const { rotateAuditFile, sweepStaleAuditDirs } = require('./lib/audit-rotation');
 const {
     createFailureTracker,
@@ -5370,7 +5371,7 @@ function readPromptAt(internalName) {
 }
 // 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) {
+function agentPhaseFields(s, screenWorking = null) {
     if (!s.agent) return { agentPhase: null, turnSeen: true, turnAt: null };
     const turnAt = readTurnAt(s.internalName);
     const r = agentPhase({
@@ -5379,10 +5380,45 @@ function agentPhaseFields(s) {
         promptAt: readPromptAt(s.internalName),
         lastActivityAt: Number(s.lastActivityAt) || 0,
         lastUserSeenAt: Number(s.lastUserSeenAt) || 0,
-        userAttached: s.userAttached === true
+        userAttached: s.userAttached === true,
+        screenWorking
     });
     return { agentPhase: r.phase, turnSeen: r.turnSeen, turnAt: turnAt || null };
 }
+// The screen's own word on whether a turn is running ("esc to interrupt" in
+// both TUIs), read from the host's live grid. Asked only for the sessions
+// the timing rules call working — the small set that can be wrong that way
+// (Codex repaints while idle: rotating tips, the user typing) — and memoised
+// for a few seconds so every client's poll shares one read per session.
+const screenWorkingMemo = new Map(); // internalName -> { t, p: Promise<boolean|null> }
+function screenWorkingOf(internalName) {
+    const now = Date.now();
+    const hit = screenWorkingMemo.get(internalName);
+    if (hit && now - hit.t < 4000) return hit.p;
+    const p = (async () => {
+        try {
+            const hostRes = await callExternalHayHostApi(`/rooms/${encodeURIComponent(internalName)}/serialized`);
+            const raw = hostRes?.data?.data;
+            if (typeof raw !== 'string' || !raw) return null;
+            return screenSaysWorking(stripAnsiForSearch(raw));
+        } catch (e) { return null; }
+    })();
+    screenWorkingMemo.set(internalName, { t: now, p });
+    if (screenWorkingMemo.size > 500) screenWorkingMemo.clear();
+    return p;
+}
+// Phase for every entry of a list, the screen consulted where it matters.
+async function agentPhaseFieldsForAll(entries) {
+    const verdicts = new Map();
+    await Promise.all(entries.map(async (s) => {
+        if (!s.agent) return;
+        if (agentPhaseFields(s).agentPhase !== 'working') return;
+        verdicts.set(s.internalName, await screenWorkingOf(s.internalName));
+    }));
+    const out = new Map();
+    for (const s of entries) out.set(s.internalName, agentPhaseFields(s, verdicts.has(s.internalName) ? verdicts.get(s.internalName) : null));
+    return out;
+}
 // 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) {
@@ -6424,7 +6460,8 @@ async function sweepRestoreReconcile() {
             if (!/[%$#\u276f>]\s*$/.test(last)) continue; // not an idle prompt yet
             try {
                 const e2 = await attachTerminalApiClient(name, exp.displayName, { actor: 'system', label: 'reconcile' });
-                const cmd = exp.command.endsWith('\n') ? exp.command : `${exp.command}\n`;
+                const pinned = withCodexIdentity(exp.command, name);
+                const cmd = pinned.endsWith('\n') ? pinned : `${pinned}\n`;
                 try { sendTerminalInput(e2, cmd); } finally { try { closeTerminalApiEntry(e2.id); } catch (e) {} }
                 exp.redrives += 1;
                 exp.lastDriveAt = now;
@@ -6782,7 +6819,11 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
                 // A fresh shell reports its own name once it has execed; that
                 // is our prompt-ready signal, and it beats guessing with a timer.
                 if (Date.now() - job.since < 400) continue;
-                const cmd = job.plan.command.endsWith('\n') ? job.plan.command : `${job.plan.command}\n`;
+                // A codex launch carries its hop session id in the thread's own
+                // config (lib/codex-identity.js): Codex's shared daemon would
+                // otherwise hand every session the FIRST session's identity.
+                const pinned = withCodexIdentity(job.plan.command, job.internalName);
+                const cmd = pinned.endsWith('\n') ? pinned : `${pinned}\n`;
                 try { sendTerminalInput(job.entry, cmd); } catch (e) { finish('write-failed'); continue; }
                 job.attempts += 1;
                 job.state = 'verify';
@@ -9574,7 +9615,7 @@ async function ensureExternalRuntimeSession(sessionName, cwd, displayName, opts
     // Launch the room ON the relaunch command instead of typing it after the
     // shell is up: no prompt to race, nothing half-typed, no command echo.
     if (typeof opts.command === 'string' && opts.command) {
-        roomBody.command = opts.command;
+        roomBody.command = withCodexIdentity(opts.command, sessionName);
     }
     const response = await callExternalHayHostApi('/rooms', 'POST', roomBody, 2500);
     if (!response || response.status < 200 || response.status >= 300 || !response.data?.ok) {
@@ -11711,6 +11752,7 @@ happens until someone clicks it.
             // compares latestAt against its own last-seen mark. No new state,
             // no new poll, and the badge works the same everywhere.
             const viewsBySession = viewSummaryBySession();
+            const phaseBySession = await agentPhaseFieldsForAll(visibleEntries);
             const sessions = visibleEntries.map(s => ({
                 views: viewsBySession[s.internalName] || undefined,
                 name: s.displayName,
@@ -11728,7 +11770,7 @@ happens until someone clicks it.
                 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),
+                ...(phaseBySession.get(s.internalName) || { agentPhase: null, turnSeen: true, turnAt: null }),
                 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
@@ -13108,7 +13150,8 @@ happens until someone clicks it.
                     });
 
                     if (startup && autoStart !== false) {
-                        sendTerminalInput(entry, startup.endsWith('\n') ? startup : `${startup}\n`);
+                        const pinnedStartup = withCodexIdentity(startup, internalName);
+                        sendTerminalInput(entry, pinnedStartup.endsWith('\n') ? pinnedStartup : `${pinnedStartup}\n`);
                     }
 
                     res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -13306,7 +13349,7 @@ happens until someone clicks it.
                         res.end(JSON.stringify({ error: 'Missing command' }));
                         return;
                     }
-                    const line = String(command);
+                    const line = withCodexIdentity(String(command), entry.sessionName);
                     sendTerminalInput(entry, line.endsWith('\n') ? line : `${line}\n`);
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: true }));
@@ -16651,7 +16694,7 @@ async function main() {
         log(`${dryRun ? 'Would recover' : 'Recovering'} ${BOLD}${display}${RESET} (${kind}) in this terminal:`, RESET);
         log(`  ${DIM}${command}${RESET}`, RESET);
         if (dryRun) process.exit(0);
-        const child = spawn('/bin/zsh', ['-lc', command], { stdio: 'inherit', cwd: plan?.cwd || cwd, env: process.env });
+        const child = spawn('/bin/zsh', ['-lc', withCodexIdentity(command, target)], { stdio: 'inherit', cwd: plan?.cwd || cwd, env: process.env });
         child.on('exit', (code, signal) => process.exit(signal ? 1 : (code ?? 0)));
         return;
     }
@@ -17480,6 +17523,9 @@ async function main() {
         } else {
             console.log(`View: ${proxyUrl}`);
         }
+        // Name the session it was filed under, so a wrong one is visible at
+        // once (an inherited HOP_SESSION can belong to another session).
+        console.log(`Filed under ${getSessionDisplayName(session) || session}${wantSession ? '' : ' (from HOP_SESSION; pass --session <name> to file elsewhere)'}.`);
         // Same one-bell convention as `hop view` — the human is usually
         // waiting on this, and the link scrolls away unannounced otherwise.
         process.stdout.write('\x07');

package/lib/agent-phase.js

@@ -30,6 +30,10 @@ const TURN_TAIL_MS = 1500;
  * @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 {boolean|null} [o.screenWorking]  what the LIVE screen says, when it was read:
+ *        both TUIs print "esc to interrupt" only while a turn runs. Wins over
+ *        the timing heuristics — Codex repaints while idle (rotating tips, the
+ *        user typing), which looked like work from the timestamps alone.
  * @param {number} [o.now]
  * @returns {{ phase: 'working'|'done'|null, turnSeen: boolean }}
  */
@@ -40,7 +44,9 @@ function agentPhase(o) {
     const promptAt = Number(o.promptAt) || 0;
     const active = Number(o.lastActivityAt) || 0;
     let working;
-    if (promptAt > turnAt) {
+    if (o.screenWorking === true || o.screenWorking === false) {
+        working = o.screenWorking;
+    } else 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.
@@ -54,4 +60,8 @@ function agentPhase(o) {
     return { phase: 'done', turnSeen: seenAt >= turnAt };
 }
 
-module.exports = { agentPhase, WORKING_RECENT_MS, PROMPT_STALE_MS, TURN_TAIL_MS };
+/** The screen's own word: a turn in flight prints this in both TUIs. */
+const WORKING_SCREEN_RE = /esc to interrupt/i;
+const screenSaysWorking = (text) => WORKING_SCREEN_RE.test(String(text || ''));
+
+module.exports = { agentPhase, screenSaysWorking, WORKING_SCREEN_RE, WORKING_RECENT_MS, PROMPT_STALE_MS, TURN_TAIL_MS };

package/lib/codex-identity.js

@@ -0,0 +1,48 @@
+'use strict';
+// Codex 0.159 runs EVERY session's shell commands and MCP servers through one
+// shared app-server daemon, spawned by whichever codex started first. The
+// daemon inherits that first session's environment, so HOP_SESSION — hop's
+// "which session am I in" — named the first session for all of them: the
+// surf session's `hop view` filed its result under Accessibility-fork-codex,
+// and the hop MCP server every codex talks to answered with the wrong name.
+//
+// Identity must travel with the THREAD, not the process tree. Codex applies
+// its shell_environment_policy per thread when it spawns a command, and the
+// per-thread MCP server config likewise, and both accept per-launch `-c`
+// overrides. So every codex hop launches carries its own session id in
+// both — verified: with HOP_SESSION=wrong in the environment, a command run
+// by codex saw the override.
+//
+// And it runs WITHOUT the shared daemon (`--no-daemon`): hop is already the
+// multiplexer, and a second one inside Codex is what mixed the sessions up —
+// its notify program (the turn-complete hook behind "finished" and restore)
+// also ran with the daemon's environment, so every session's turns were
+// counted against the first one. Verified: without the daemon the MCP
+// servers are children of the session's own codex, carrying its id.
+
+const FLAG_MARK = 'shell_environment_policy.set.HOP_SESSION';
+
+/** The per-launch overrides that pin a codex thread to a hop session. */
+function codexIdentityFlags(internalName) {
+    const id = String(internalName || '').replace(/[^A-Za-z0-9_-]/g, '');
+    if (!id) return '';
+    return `--no-daemon -c '${FLAG_MARK}="${id}"' -c 'mcp_servers.hop.env.HOP_SESSION="${id}"'`;
+}
+
+/**
+ * `codex …` (optionally behind `command ` / `exec `) becomes
+ * `codex <identity flags> …`. Anything else — a shell, claude, an already
+ * pinned codex line — is returned unchanged.
+ */
+function withCodexIdentity(command, internalName) {
+    const raw = typeof command === 'string' ? command : '';
+    const flags = codexIdentityFlags(internalName);
+    if (!flags) return raw;
+    if (raw.includes(FLAG_MARK)) return raw;
+    const m = /^(\s*(?:(?:command|exec)\s+)?)codex(?=\s|$)/.exec(raw);
+    if (!m) return raw;
+    const rest = raw.slice(m[0].length);
+    return `${m[1]}codex ${flags}${rest}`;
+}
+
+module.exports = { withCodexIdentity, codexIdentityFlags, FLAG_MARK };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.64",
+  "version": "0.11.65",
   "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/codex-notify-hook.js

@@ -24,11 +24,33 @@ const os = require("node:os");
 const path = require("node:path");
 const { spawn } = require("node:child_process");
 
-function turnFilePath() {
+function turnsDir() {
   const home = process.env.HOP_HOME || path.join(os.homedir(), ".hop2");
   const dir = path.join(home, "claude-sessions"); // shared with the claude hook; hop reads <internal>.turn here
   try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
-  return path.join(dir, `${process.env.HOP_SESSION}.turn`);
+  return dir;
+}
+
+// WHICH hop session finished a turn. The environment says HOP_SESSION, but
+// under Codex's shared app-server daemon every session's notify ran with
+// the FIRST session's environment, so surf's turns were counted against
+// Accessibility-fork-codex (233 of them) and its own record sat at 1. The
+// thread is the truth: if another session's turn record already names this
+// root thread, the turn is that session's. (hop launches codex without the
+// daemon now; this keeps the sessions that predate the change honest.)
+function resolveHopSession(dir, rootId, envSession) {
+  if (!rootId) return envSession;
+  let names = [];
+  try { names = fs.readdirSync(dir).filter((f) => f.endsWith(".turn")); } catch { return envSession; }
+  const owners = [];
+  for (const f of names) {
+    try {
+      const rec = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
+      if (rec && rec.agent === "codex" && rec.sessionId === rootId) owners.push(f.slice(0, -".turn".length));
+    } catch { /* unreadable record */ }
+  }
+  if (owners.includes(envSession)) return envSession;
+  return owners.length === 1 ? owners[0] : envSession;
 }
 
 // A sub-agent's rollout names its parent in its first line (session_meta →
@@ -73,23 +95,26 @@ function rootThreadId(id) {
 // Same crash-safe write + same {sessionId, count, at} shape the Claude hook
 // uses, so hop's finishBump() reads one number regardless of which agent wrote.
 function bumpTurn(payload) {
-  const hopSession = process.env.HOP_SESSION;
-  if (!hopSession || !/^[A-Za-z0-9_-]+$/.test(hopSession)) return; // not a hop session
-  const file = turnFilePath();
+  const envSession = process.env.HOP_SESSION;
+  if (!envSession || !/^[A-Za-z0-9_-]+$/.test(envSession)) return; // not a hop session
+  const dir = turnsDir();
+  const rawThread = (payload && typeof payload["thread-id"] === "string") ? payload["thread-id"]
+             : (payload && typeof payload.thread_id === "string") ? payload.thread_id
+             : (payload && typeof payload.session_id === "string") ? payload.session_id : null;
+  const rootId = rootThreadId(rawThread);
+  const hopSession = resolveHopSession(dir, rootId, envSession);
+  const file = path.join(dir, `${hopSession}.turn`);
   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 { /* missing/corrupt -> start at 0 */ }
-  const threadId = (payload && typeof payload["thread-id"] === "string") ? payload["thread-id"]
-             : (payload && typeof payload.thread_id === "string") ? payload.thread_id
-             : (payload && typeof payload.session_id === "string") ? payload.session_id : null;
   const rec = JSON.stringify({
     // The thread id is the conversation (and the rollout file's name); the
     // turn id names one turn and matches nothing on disk. With multi-agent
     // codex the thread that finished may be a SUB-agent, which cannot be
     // resumed on its own — record the root, which can.
-    sessionId: rootThreadId(threadId),
+    sessionId: rootId,
     count: count + 1,
     at: new Date().toISOString(),
     agent: "codex"

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

@@ -2,7 +2,7 @@
 // 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 { agentPhase, screenSaysWorking } = require('../lib/agent-phase');
 
 const NOW = 1_800_000_000_000;
 const s = (o) => agentPhase({ agent: 'claude', now: NOW, ...o });
@@ -45,3 +45,20 @@ 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');
 });
+
+test('the live screen decides when it was read: an idle composer is DONE however recent the repaint', () => {
+  // Codex idle at "› Ask Codex to do anything", tips rotating, user typing: fresh output, no turn.
+  const r = agentPhase({ agent: 'codex', turnAt: NOW - 60_000, lastActivityAt: NOW - 1_000, lastUserSeenAt: NOW, screenWorking: false, now: NOW });
+  assert.equal(r.phase, 'done');
+  // A silent long think still shows "esc to interrupt": working, whatever the timestamps say.
+  assert.equal(s({ turnAt: NOW - 60_000, lastActivityAt: NOW - 120_000, screenWorking: true }).phase, 'working');
+  // No screen read (null): the timing rules apply as before.
+  assert.equal(agentPhase({ agent: 'codex', turnAt: NOW - 60_000, lastActivityAt: NOW - 1_000, screenWorking: null, now: NOW }).phase, 'working');
+});
+
+test('screenSaysWorking reads both TUIs\' in-flight line', () => {
+  assert.equal(screenSaysWorking('⏵⏵ bypass permissions on (shift+tab to cycle) · esc to interrupt · ← 1 agent'), true);
+  assert.equal(screenSaysWorking('• Working (12s • esc to interrupt)'), true);
+  assert.equal(screenSaysWorking('› Ask Codex to do anything\n  ? for shortcuts'), false);
+  assert.equal(screenSaysWorking(''), false);
+});

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

@@ -0,0 +1,32 @@
+// Every codex hop launches carries its hop session id in the thread's own
+// config, so commands run through Codex's shared daemon still know which
+// session they belong to.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { withCodexIdentity, codexIdentityFlags } = require('../lib/codex-identity');
+
+test('a bare codex launch gets both overrides', () => {
+  const out = withCodexIdentity('codex', 's_82da12887f');
+  assert.equal(out, `codex --no-daemon -c 'shell_environment_policy.set.HOP_SESSION="s_82da12887f"' -c 'mcp_servers.hop.env.HOP_SESSION="s_82da12887f"'`);
+});
+
+test('a resume keeps its arguments after the flags; command/exec prefixes survive', () => {
+  assert.equal(withCodexIdentity("codex resume '01a0e0dc-314d'", 'surf'),
+    `codex ${codexIdentityFlags('surf')} resume '01a0e0dc-314d'`);
+  assert.equal(withCodexIdentity('command codex --full-auto -c check_for_update_on_startup=false', 's_1'),
+    `command codex ${codexIdentityFlags('s_1')} --full-auto -c check_for_update_on_startup=false`);
+});
+
+test('anything else is untouched: shells, claude, a codex somewhere later in the line, an already pinned launch', () => {
+  assert.equal(withCodexIdentity('claude --resume abc', 's_1'), 'claude --resume abc');
+  assert.equal(withCodexIdentity('cd x && codex', 's_1'), 'cd x && codex');
+  assert.equal(withCodexIdentity('codexify --help', 's_1'), 'codexify --help');
+  const pinned = withCodexIdentity('codex', 's_1');
+  assert.equal(withCodexIdentity(pinned, 's_2'), pinned);
+  assert.equal(withCodexIdentity('', 's_1'), '');
+  assert.equal(withCodexIdentity('codex', ''), 'codex');
+});
+
+test('the id is sanitised — it lands inside a quoted config value', () => {
+  assert.equal(codexIdentityFlags('bad"id;rm -rf'), `--no-daemon -c 'shell_environment_policy.set.HOP_SESSION="badidrm-rf"' -c 'mcp_servers.hop.env.HOP_SESSION="badidrm-rf"'`);
+});

package/tests/codex-notify-hook.unit.test.cjs

@@ -0,0 +1,47 @@
+// The Codex notify wrapper: which session a finished turn is counted against.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const HOOK = path.join(__dirname, '..', 'scripts', 'codex-notify-hook.js');
+const freshHome = () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'hop-codex-hook-'));
+  fs.mkdirSync(path.join(home, 'claude-sessions'), { recursive: true });
+  return home;
+};
+const run = (home, session, payload) => execFileSync(process.execPath, [HOOK, JSON.stringify(payload)], {
+  env: { ...process.env, HOP_HOME: home, HOP_SESSION: session }
+});
+const turn = (home, name) => { try { return JSON.parse(fs.readFileSync(path.join(home, 'claude-sessions', `${name}.turn`), 'utf8')); } catch { return null; } };
+
+test('a turn is counted against HOP_SESSION when no other session claims the thread', () => {
+  const home = freshHome();
+  run(home, 'alpha', { type: 'agent-turn-complete', 'thread-id': 'thread-A', 'turn-id': 't1' });
+  assert.equal(turn(home, 'alpha').count, 1);
+  assert.equal(turn(home, 'alpha').sessionId, 'thread-A');
+  assert.equal(turn(home, 'alpha').agent, 'codex');
+});
+
+test("under a shared daemon the environment lies: the session whose record already names the thread gets the turn", () => {
+  const home = freshHome();
+  fs.writeFileSync(path.join(home, 'claude-sessions', 'surf.turn'), JSON.stringify({ sessionId: 'thread-S', count: 4, at: '2026-09-28T22:46:53.450Z', agent: 'codex' }));
+  fs.writeFileSync(path.join(home, 'claude-sessions', 'owner.turn'), JSON.stringify({ sessionId: 'thread-O', count: 9, at: '2026-09-29T20:00:00.000Z', agent: 'codex' }));
+  // The daemon runs notify with HOP_SESSION=owner, for surf's thread.
+  run(home, 'owner', { type: 'agent-turn-complete', 'thread-id': 'thread-S', 'turn-id': 't2' });
+  assert.equal(turn(home, 'surf').count, 5, 'surf got its turn');
+  assert.equal(turn(home, 'surf').sessionId, 'thread-S');
+  assert.equal(turn(home, 'owner').count, 9, 'the owner was not credited with it');
+  assert.equal(turn(home, 'owner').sessionId, 'thread-O', "and the owner's own thread id was not overwritten");
+  // The owner's own turn still lands on the owner.
+  run(home, 'owner', { type: 'agent-turn-complete', 'thread-id': 'thread-O', 'turn-id': 't3' });
+  assert.equal(turn(home, 'owner').count, 10);
+});
+
+test('other event types count nothing', () => {
+  const home = freshHome();
+  run(home, 'alpha', { type: 'something-else', 'thread-id': 'thread-A' });
+  assert.equal(turn(home, 'alpha'), null);
+});