hop2 0.11.64 → 0.11.66

package/README.md

@@ -245,6 +245,32 @@ curl -X POST http://127.0.0.1:$PORT/api/sessions/fork \
   -d '{"name":"angler","target":"codex"}'     # omit target to fork with the same tool
 ```
 
+### Check back later (`hop checkback`)
+
+Agents promise to "check back in 30 minutes" and then don't — Codex
+especially. A check-back makes hop do the remembering: a message that hop
+types into a session (and submits) when a trigger fires, once the session
+is idle, so it lands at the prompt like something you typed.
+
+```bash
+hop checkback --in 30m "Check the training job and report the loss curve"      # inside a session: this one
+hop checkback --session surf --at 15:00 "Summarise today's AF results for me"
+hop checkback --session surf --every 2h --until 18:00 "Status?"
+hop checkback --when-idle --idle-for 15m "Idle 15 minutes: write the status note and stop"
+hop checkback --when-file results/af.csv "The AF results are in: summarise them"   # --changed: on change, not existence
+hop checkback --when-cmd "squeue -j 123 | grep -q COMPLETED" --every 5m "Job 123 finished — collect its outputs"
+hop checkback --list            hop checkback --cancel <id>            hop checkback --cancel-all --session surf
+```
+
+Triggers: a moment (`--in 45m`, `--at 15:00` / `3pm` / ISO), a period
+(`--every`, with `--until`), the session going idle (`--when-idle`, optionally
+after a quiet spell), a file appearing or changing (`--when-file`), a shell
+command succeeding (`--when-cmd`, polled). Delivery waits for the agent to
+finish its turn unless `--force`. Check-backs are durable (`~/.hop2/checkbacks.json`)
+and survive daemon restarts; the wall shows ⏰ on a session that has one
+waiting. Agents get the same over MCP (`hop_checkback`, `hop_list_checkbacks`,
+`hop_cancel_checkback`) and are told to use it on themselves.
+
 ### Render LaTeX math (`hop math`)
 
 Glance at a formula without leaving the terminal:
@@ -277,6 +303,11 @@ hop view --list          # what this session published
 hop view --rm x.png      # unpublish
 ```
 
+On the web, every delivery also shows as a small inline card right where
+`hop view` printed it — title, file, size, a thumbnail for an image, and
+an Open button that lands the Views reader on that item. Plain terminals
+and the phone see the same delivery as a text box.
+
 HTML, PDF, images, video and markdown all render (markdown is converted at
 serve time — headings, tables, fenced code). `--title` is what a human sees
 in the session's Views list, so it is worth writing properly. Published files
@@ -424,6 +455,7 @@ Hop uses the external Hay host runtime for PTY hosting and session recovery.
 | `hop` | Start hop daemon/tunnel if needed, then launch a local terminal. Unnamed launches do not reuse a session that already has a local CLI attached. |
 | `hop start` | Start the hop daemon and print QR codes |
 | `hop attach [session]` | Attach to an existing terminal session |
+| `hop checkback …` | Type a message into a session later: `--in`, `--at`, `--every`, `--when-idle`, `--when-file`, `--when-cmd`; `--list`, `--cancel` |
 | `hop attach all` | Attach sequentially to all terminal sessions |
 | `hop local [session]` | Start a daemonless local terminal (`[session]` attaches if it exists) |
 | `hop stop` | Stop the hop daemon (terminal sessions keep running) |

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

@@ -22,6 +22,8 @@ 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 { enableViewBlocks } from "./utils/viewBlocks";
 import { MobileKeyboard } from "./components/MobileKeyboard";
 import { SessionSwitcher } from "./components/SessionSwitcher";
 import { SecondaryPane } from "./components/SecondaryPane";
@@ -265,6 +267,8 @@ type SessionInfo = {
   // a human has opened the session since it finished (see lib/agent-phase.js).
   agentPhase?: "working" | "done" | null;
   turnSeen?: boolean;
+  // Scheduled check-backs waiting on this session (hop checkback).
+  checkbacks?: number;
   attentionReason?: string;
   attentionNote?: string;
   cols?: number;
@@ -476,8 +480,14 @@ const App = () => {
   // while you cycle (⌘J/⌘L held / two-finger swipe) and commits on release — like
   // ⌘Tab. Frozen ring so neighbours don't reshuffle mid-cycle (same rule as
   // the iOS swipe order). Ref mirror for the keyup/wheel listeners.
-  const [switchHud, setSwitchHud] = useState<{ ring: SessionInfo[]; index: number } | null>(null);
-  const switchHudRef = useRef<{ ring: SessionInfo[]; index: number } | null>(null);
+  // via: how the HUD was opened. "keys" (⌘J/⌘L) lands on the modifier's
+  // release — the hold IS the deciding time. "wheel" (a two-finger swipe)
+  // has no release, so it waits: ⏎ or a click on a card switches, esc
+  // cancels, and a quiet spell closes it without switching. It used to
+  // commit 320ms after the swipe settled, i.e. while you were still looking.
+  const [switchHud, setSwitchHud] = useState<{ ring: SessionInfo[]; index: number; via: "keys" | "wheel" } | null>(null);
+  const switchHudRef = useRef<{ ring: SessionInfo[]; index: number; via: "keys" | "wheel" } | null>(null);
+  const hudPickRef = useRef<((index: number) => void) | null>(null);
   switchHudRef.current = switchHud;
   // Server-owned folders (Manual mode). Kept in App because the sessions
   // fetch already carries them.
@@ -699,7 +709,7 @@ const App = () => {
   const [shortcutHelpOpen, setShortcutHelpOpen] = useState(false);
   // Published views (`hop view`). `session` scopes the panel to one session;
   // an object with none open it fleet-wide. Null = closed.
-  const [viewsOpen, setViewsOpen] = useState<{ session?: string; dock?: boolean } | null>(null);
+  const [viewsOpen, setViewsOpen] = useState<{ session?: string; dock?: boolean; item?: string } | null>(null);
   const sessionsRef = useRef(sessions);
   sessionsRef.current = sessions;
   // Claude Code titles its process with a bare version number; hop's session
@@ -743,6 +753,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);
@@ -1496,12 +1514,17 @@ const App = () => {
     lastSentSizeRef.current = { cols, rows };
     const deliberate = claim === "attach" && deliberateAttachRef.current;
     if (deliberate) deliberateAttachRef.current = false;
+    // An explicit Fit says "use MY size" even over someone typing now;
+    // opening/clicking only takes the size from an idle or absent owner.
+    const take = takeSizeRef.current;
+    takeSizeRef.current = false;
     sendMessage({
       type: "resize",
       cols,
       rows,
       ...(claim ? { claim } : {}),
-      ...(deliberate ? { user: true } : {})
+      ...(deliberate ? { user: true } : {}),
+      ...(take ? { take: true } : {})
     });
   };
 
@@ -1510,6 +1533,8 @@ const App = () => {
    * here. Quiet when the session is already at our fit, so an ordinary click
    * (or a selection drag) never pushes a resize.
    */
+  // Set by an explicit Fit: the next resize carries take:true.
+  const takeSizeRef = useRef(false);
   const claimSizeHere = (force = false) => {
     if (!force && !claimOnClick({
       viewMode: viewModeRef.current,
@@ -1519,6 +1544,7 @@ const App = () => {
     })) return;
     attachClaimPendingRef.current = true;
     deliberateAttachRef.current = true;
+    if (force) takeSizeRef.current = true;
     fitToViewport();
     handleResize();
   };
@@ -2098,6 +2124,12 @@ 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,
+      // Decorations (inline hop view cards, utils/viewBlocks.ts) are a
+      // proposed xterm API; this is the switch that lets them register.
+      allowProposedApi: true,
       lineHeight: 1.3,
       cursorBlink: true,
       scrollback: 50000,
@@ -2135,7 +2167,18 @@ const App = () => {
     // KaTeX, a click pins it. What `hop math` could only approximate in
     // Unicode, the browser around the terminal draws properly.
     enableMathHover(terminal, getMathTip());
+    // `hop view` deliveries become small inline cards where they printed;
+    // Open lands in the Views reader on that item.
+    (terminal as any).__viewBlocksCleanup = enableViewBlocks(terminal as never, (b) => setViewsOpen({ session: b.session, item: b.name }));
     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 +3075,14 @@ const App = () => {
           (terminal as any).__overlayScrollbarCleanup();
           (terminal as any).__overlayScrollbarCleanup = null;
         }
+        if ((terminal as any).__viewBlocksCleanup) {
+          (terminal as any).__viewBlocksCleanup();
+          (terminal as any).__viewBlocksCleanup = null;
+        }
+        if ((terminal as any).__dragSelectCleanup) {
+          (terminal as any).__dragSelectCleanup();
+          (terminal as any).__dragSelectCleanup = null;
+        }
         terminal.dispose();
         termRef.current = null;
         fitRef.current = null;
@@ -3211,6 +3262,7 @@ const App = () => {
           agent: s.agent === "claude" || s.agent === "codex" ? s.agent : null,
           agentPhase: s.agentPhase === "working" || s.agentPhase === "done" ? s.agentPhase : null,
           turnSeen: s.turnSeen !== false,
+          checkbacks: Number(s.checkbacks) > 0 ? Number(s.checkbacks) : undefined,
           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
@@ -3885,10 +3937,10 @@ const App = () => {
       [...sessionsRef.current]
         .filter((s) => s.type !== "port")
         .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
-    const hudStep = (dir: 1 | -1) => {
+    const hudStep = (dir: 1 | -1, via: "keys" | "wheel" = "keys") => {
       const open = switchHudRef.current;
       if (open) {
-        setSwitchHud({ ring: open.ring, index: Math.min(open.ring.length - 1, Math.max(0, open.index + dir)) });
+        setSwitchHud({ ...open, index: Math.min(open.ring.length - 1, Math.max(0, open.index + dir)) });
         return;
       }
       const ring = hudRing();
@@ -3896,7 +3948,7 @@ const App = () => {
       const curKey = activeSessionRoomRef.current;
       const cur = ring.findIndex((s) => s.name === curKey || s.internalName === curKey);
       const start = cur < 0 ? 0 : cur;
-      setSwitchHud({ ring, index: Math.min(ring.length - 1, Math.max(0, start + dir)) });
+      setSwitchHud({ ring, index: Math.min(ring.length - 1, Math.max(0, start + dir)), via });
     };
     const hudCommit = () => {
       const open = switchHudRef.current;
@@ -3949,12 +4001,21 @@ const App = () => {
       const mod = isMacPlatform
         ? event.metaKey && !event.ctrlKey && !event.altKey
         : event.ctrlKey && event.shiftKey && !event.metaKey && !event.altKey;
+      // esc cancels the HUD whether or not the modifier is still held — the
+      // hint promises it, and with ⌘ down it used to fall through.
+      if (event.key === "Escape" && switchHudRef.current) {
+        event.preventDefault();
+        event.stopPropagation();
+        hudCancel();
+        return;
+      }
       if (!mod) {
-        if (event.key === "Escape" && switchHudRef.current) {
-          event.preventDefault();
-          event.stopPropagation();
-          hudCancel();
-          return;
+        // A swipe-opened HUD waits for a decision: ⏎ switches, ← → step.
+        if (switchHudRef.current?.via === "wheel") {
+          if (event.key === "Enter") { event.preventDefault(); event.stopPropagation(); hudCommit(); return; }
+          if (event.key === "ArrowLeft" || event.key === "ArrowRight") {
+            event.preventDefault(); event.stopPropagation(); hudStep(event.key === "ArrowRight" ? 1 : -1, "wheel"); return;
+          }
         }
         if (event.key === "Escape" && (drawerOpenRef.current || shortcutHelpRef.current)) {
           event.preventDefault();
@@ -4037,7 +4098,8 @@ const App = () => {
     // target, ⌘Tab-style. Any keyup counts: the modifier's own release AND
     // releasing it while another key is up both leave the flag false.
     const onKeyUp = (event: KeyboardEvent) => {
-      if (!switchHudRef.current) return;
+      const open = switchHudRef.current;
+      if (!open || open.via !== "keys") return; // a swipe-opened HUD lands on ⏎ or a click, not on a key release
       if (!(isMacPlatform ? event.metaKey : event.ctrlKey)) hudCommit();
     };
     window.addEventListener("keyup", onKeyUp, true);
@@ -4047,20 +4109,34 @@ const App = () => {
     // swipe never fires. Steps per 60pt of travel, settles into a commit.
     let wheelAccum = 0;
     let wheelTimer: number | null = null;
+    const HUD_IDLE_CLOSE_MS = 8000;
     const onWheel = (event: WheelEvent) => {
       if (!session) return;
       const el = event.target as Element | null;
       if (el?.closest(".switcher-scroll, .views-panel, .drawer, input, textarea, [contenteditable]")) return;
       if (Math.abs(event.deltaX) <= Math.abs(event.deltaY) * 1.3) return;
+      // A swipe never opens the HUD over a keyboard-held one.
+      if (switchHudRef.current && switchHudRef.current.via !== "wheel") return;
       event.preventDefault();
       wheelAccum += event.deltaX;
       while (Math.abs(wheelAccum) >= 60) {
         const dir: 1 | -1 = wheelAccum > 0 ? 1 : -1;
         wheelAccum -= dir * 60;
-        hudStep(dir);
+        hudStep(dir, "wheel");
       }
+      // The gesture settling is NOT a decision. The HUD stays until ⏎ or a
+      // click (switch) or esc; left alone, it closes without switching.
       if (wheelTimer) window.clearTimeout(wheelTimer);
-      wheelTimer = window.setTimeout(() => { wheelAccum = 0; hudCommit(); }, 320);
+      wheelTimer = window.setTimeout(() => {
+        wheelAccum = 0;
+        if (switchHudRef.current?.via === "wheel") hudCancel();
+      }, HUD_IDLE_CLOSE_MS);
+    };
+    hudPickRef.current = (index: number) => {
+      const open = switchHudRef.current;
+      if (!open) return;
+      switchHudRef.current = { ...open, index };
+      hudCommit();
     };
     window.addEventListener("wheel", onWheel, { passive: false, capture: true });
     return () => {
@@ -4091,7 +4167,7 @@ const App = () => {
         const curKey = session?.room ?? sessionLabel;
         const SLOT = 152; // card 140 + gap 12; must match .switch-hud CSS
         return (
-          <div className="switch-hud" aria-hidden="true">
+          <div className={"switch-hud" + (switchHud.via === "wheel" ? " waits" : "")} aria-hidden="true">
             <div className="switch-hud-window">
               <div className="switch-hud-strip"
                    style={{ transform: `translateX(-${switchHud.index * SLOT + 70}px)` }}>
@@ -4103,7 +4179,8 @@ const App = () => {
                     <div key={key}
                          className={"switch-hud-card"
                                     + (isTarget ? " is-target" : "")
-                                    + (isCurrent ? " is-current" : "")}>
+                                    + (isCurrent ? " is-current" : "")}
+                         onClick={() => hudPickRef.current?.(i)}>
                       <span className="switch-hud-name">{s.displayName || s.name}</span>
                       {isCurrent && <span className="switch-hud-now">now</span>}
                     </div>
@@ -4112,7 +4189,9 @@ const App = () => {
               </div>
             </div>
             <div className="switch-hud-hint">
-              {isMacPlatform ? "⌘J / ⌘L step · release ⌘ to switch" : "Ctrl+Shift+J / +L step · release to switch"} · esc cancels
+              {switchHud.via === "wheel"
+                ? "swipe or ← → to step · ⏎ or click to switch · esc cancels"
+                : `${isMacPlatform ? "⌘J / ⌘L step · release ⌘ to switch" : "Ctrl+Shift+J / +L step · release to switch"} · esc cancels`}
             </div>
           </div>
         );
@@ -4220,7 +4299,7 @@ const App = () => {
             onRefresh={() => fetchSessions({ showLoading: false })}
             onNotice={showToast}
             tileWsBase={resolveWsUrl()}
-            onOpenViews={(scope) => setViewsOpen({ session: scope })}
+            onOpenViews={(scope, item) => setViewsOpen({ session: scope, item })}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
           />
@@ -4884,7 +4963,7 @@ const App = () => {
             tileWsBase={resolveWsUrl()}
             onFocusSession={focusSessionInPlace}
             folders={folders}
-            onOpenViews={(scope) => setViewsOpen({ session: scope })}
+            onOpenViews={(scope, item) => setViewsOpen({ session: scope, item })}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
             onOpenSettings={() => {
@@ -5028,7 +5107,7 @@ const App = () => {
       {/* Outside the mode ternary on purpose: Views opens from the hub, from a
           session, and from over the switcher, and it must outlive a switch. */}
       {viewsOpen && (
-        <ViewsPanel session={viewsOpen.session} sessions={sessions} dock={viewsOpen.dock}
+        <ViewsPanel session={viewsOpen.session} item={viewsOpen.item} sessions={sessions} dock={viewsOpen.dock}
                     onClose={() => setViewsOpen(null)} />
       )}
     </div>

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

@@ -1,4 +1,5 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { createReadWitness, wordCount } from "../utils/readWitness";
 import type { SwitcherSession } from "../utils/switcherModel";
 
 // The briefing, on the desktop wall — the same editions the iOS app renders,
@@ -16,7 +17,14 @@ type DigestItem = {
   headline: string;
   why?: string;
   urgency?: string;
+  // The chief-of-staff page: decide / watch / done, and an "also" roll-up
+  // of headline-only items. Older editions have no slot and render flat.
+  slot?: "decide" | "watch" | "done" | "also";
+  recommendation?: string;
+  replies?: string[];
 };
+const SLOT_LABEL: Record<string, string> = { decide: "Decide", watch: "Watch", done: "Done" };
+const SLOT_ORDER = ["decide", "watch", "done"];
 
 type Edition = {
   generated_at?: string;
@@ -63,6 +71,18 @@ export const DigestCard = ({ sessions, onOpen }: {
   onOpen: (session: SwitcherSession) => void;
 }) => {
   const [editions, setEditions] = useState<Edition[]>([]);
+  // The read witness: dwell on a visible story, with the human present,
+  // reports glimpsed/read to the daemon; opening a session from a story
+  // reports acted. The daemon's union across devices feeds the "new"
+  // badge below and tells the generator what may be told as a delta.
+  const witnessRef = useRef<ReturnType<typeof createReadWitness> | null>(null);
+  if (!witnessRef.current) {
+    witnessRef.current = createReadWitness((reads) => {
+      fetch("/api/digest/reads", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ reads }), keepalive: true })
+        .catch(() => { /* offline: the next batch carries it */ });
+    });
+  }
+  useEffect(() => () => { witnessRef.current?.dispose(); witnessRef.current = null; }, []);
   const [dismissed, setDismissed] = useState(() => {
     try { return localStorage.getItem(DISMISS_KEY) || ""; } catch { return ""; }
   });
@@ -83,9 +103,13 @@ export const DigestCard = ({ sessions, onOpen }: {
       // the very first briefing, before an archive exists.
       Promise.all([
         fetch("/assets/digest-archive.json", { cache: "no-store" }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
-        fetch("/assets/digest.json", { cache: "no-store" }).then((r) => (r.ok ? r.json() : null)).catch(() => null)
-      ]).then(([archive, latest]: [{ editions?: Edition[] } | null, Edition | null]) => {
+        fetch("/assets/digest.json", { cache: "no-store" }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
+        fetch("/api/digest/reads", { cache: "no-store" }).then((r) => (r.ok ? r.json() : null)).catch(() => null)
+      ]).then(([archive, latest, serverReads]: [{ editions?: Edition[] } | null, Edition | null, { editionsSeen?: string[] } | null]) => {
         if (cancelled) return;
+        // Editions any device has witnessed are not "new" here either.
+        const seenElsewhere = Array.isArray(serverReads?.editionsSeen) ? serverReads!.editionsSeen! : [];
+        if (seenElsewhere.length) setSeen((prev) => { const next = new Set(prev); for (const x of seenElsewhere) next.add(x); saveSeen(next); return next; });
         let list: Edition[] = Array.isArray(archive?.editions) ? archive!.editions! : [];
         if (latest?.summary && (!list.length || list[0]?.generated_at !== latest.generated_at)) {
           list = [latest, ...list];
@@ -171,7 +195,8 @@ export const DigestCard = ({ sessions, onOpen }: {
     );
   }
 
-  const openItem = (session: string) => {
+  const openItem = (session: string, edition?: string) => {
+    if (edition) witnessRef.current?.acted(edition, session);
     const t = find(session);
     if (t) onOpen(t);
   };
@@ -181,6 +206,63 @@ export const DigestCard = ({ sessions, onOpen }: {
     try { localStorage.setItem(MODE_KEY, m); } catch { /* ok */ }
   };
 
+  // One edition's page. New editions carry slots: Decide, Watch, Done as
+  // sections, then "Also" as a row of session chips — the roll-up that keeps
+  // a tap into each session without a paragraph each. Older editions (no
+  // slot) render as the flat list they were written as.
+  const renderItem = (item: DigestItem, s?: string) => (
+    <button
+      key={item.session + item.headline}
+      ref={witnessRef.current!.ref({ edition: s || "", item: item.session, words: wordCount(item.headline + " " + (item.why || "") + " " + (item.recommendation || "")) })}
+      className={"digest-item " + urgencyClass(item.urgency)}
+      onClick={() => openItem(item.session, s)}
+    >
+      <span className="digest-dateline">{sessionLabel(item.session)}</span>
+      <span className="digest-headline">{item.headline}</span>
+      {item.why ? <span className="digest-why">{item.why}</span> : null}
+      {item.recommendation ? <span className="digest-reco">→ {item.recommendation}</span> : null}
+      {item.replies?.length ? (
+        <span className="digest-replies">{item.replies.map((r) => <span key={r} className="digest-reply">{r}</span>)}</span>
+      ) : null}
+    </button>
+  );
+  const renderEdition = (ed: Edition, s?: string) => {
+    const items = ed.items || [];
+    if (!items.some((it) => it.slot)) return items.map((it) => renderItem(it, s));
+    const also = items.filter((it) => it.slot === "also");
+    return (
+      <>
+        {SLOT_ORDER.map((slot) => {
+          const rows = items.filter((it) => it.slot === slot);
+          if (!rows.length) return null;
+          return (
+            <div key={slot} className={"digest-slot slot-" + slot}>
+              <div className="digest-slot-head">{SLOT_LABEL[slot]}</div>
+              {rows.map((it) => renderItem(it, s))}
+            </div>
+          );
+        })}
+        {also.length ? (
+          <div className="digest-also">
+            <span className="digest-slot-head">Also</span>
+            {also.map((it) => (
+              <button
+                key={it.session}
+                ref={witnessRef.current!.ref({ edition: s || "", item: it.session, words: wordCount(it.headline) })}
+                className="digest-also-chip"
+                title={it.headline}
+                onClick={() => openItem(it.session, s)}
+              >
+                <span className="digest-also-name">{sessionLabel(it.session)}</span>
+                <span className="digest-also-head">{it.headline}</span>
+              </button>
+            ))}
+          </div>
+        ) : null}
+      </>
+    );
+  };
+
   const toggleEdition = (s?: string) => {
     if (!s) return;
     setOpenEditions((prev) => {
@@ -234,17 +316,7 @@ export const DigestCard = ({ sessions, onOpen }: {
                   <span className="digest-edition-summary">{ed.summary}</span>
                   <span className="digest-caret">{open ? "▾" : "▸"}</span>
                 </button>
-                {open && (ed.items || []).map((item) => (
-                  <button
-                    key={item.session + item.headline}
-                    className={"digest-item " + urgencyClass(item.urgency)}
-                    onClick={() => openItem(item.session)}
-                  >
-                    <span className="digest-dateline">{sessionLabel(item.session)}</span>
-                    <span className="digest-headline">{item.headline}</span>
-                    {item.why ? <span className="digest-why">{item.why}</span> : null}
-                  </button>
-                ))}
+                {open && renderEdition(ed, s)}
               </section>
             );
           })}
@@ -271,14 +343,15 @@ export const DigestCard = ({ sessions, onOpen }: {
                     into the live session. */}
                 {open && (
                   <div className="digest-thread">
-                    <button className="digest-open-session" onClick={() => openItem(g.session)}>
+                    <button className="digest-open-session" onClick={() => openItem(g.session, newest?.at)}>
                       open {sessionLabel(g.session)} →
                     </button>
                     {g.items.map((item, i) => (
-                      <div key={i} className={"digest-thread-item " + urgencyClass(item.urgency)}>
+                      <div key={i} ref={witnessRef.current!.ref({ edition: item.at || "", item: g.session, words: wordCount(item.headline + " " + (item.why || "")) })} className={"digest-thread-item " + urgencyClass(item.urgency)}>
                         <span className="digest-when">{ago(item.at)}</span>
                         <span className="digest-headline">{item.headline}</span>
                         {item.why ? <span className="digest-why">{item.why}</span> : null}
+                        {item.recommendation ? <span className="digest-reco">→ {item.recommendation}</span> : null}
                       </div>
                     ))}
                   </div>

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,10 @@ export const SecondaryPane = ({
       cols: sizeRef.current.cols,
       rows: sizeRef.current.rows,
       fontSize,
+      macOptionClickForcesSelection: true,
+      // Decorations (inline hop view cards, utils/viewBlocks.ts) are a
+      // proposed xterm API; this is the switch that lets them register.
+      allowProposedApi: true,
       fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
       theme: theme as never,
       scrollback: 2000,
@@ -86,6 +94,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 +234,7 @@ export const SecondaryPane = ({
       ro.disconnect();
       dataSub.dispose();
       try { wsRef.current?.close(); } catch { /* ignore */ }
+      uninstallDragSelect();
       term.dispose();
       termRef.current = null;
     };