hop2 0.11.65 → 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

@@ -23,6 +23,7 @@ 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";
@@ -266,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;
@@ -477,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.
@@ -700,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
@@ -1505,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 } : {})
     });
   };
 
@@ -1519,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,
@@ -1528,6 +1544,7 @@ const App = () => {
     })) return;
     attachClaimPendingRef.current = true;
     deliberateAttachRef.current = true;
+    if (force) takeSizeRef.current = true;
     fitToViewport();
     handleResize();
   };
@@ -2110,6 +2127,9 @@ const App = () => {
       // ⌥-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,
@@ -2147,6 +2167,9 @@ 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.
@@ -3052,6 +3075,10 @@ 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;
@@ -3235,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
@@ -3909,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();
@@ -3920,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;
@@ -3973,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();
@@ -4061,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);
@@ -4071,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 () => {
@@ -4115,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)` }}>
@@ -4127,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>
@@ -4136,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>
         );
@@ -4244,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)}
           />
@@ -4908,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={() => {
@@ -5052,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

@@ -82,6 +82,9 @@ export const SecondaryPane = ({
       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,

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

@@ -18,6 +18,7 @@ import { getMathTip } from "../utils/mathTooltip";
 import { claimOnTileFocus, sizeIsForeign } from "../utils/sizeClaim";
 import { cardPhase, phaseLabel, phaseTitle } from "../utils/agentPhase";
 import { installDragSelect } from "../utils/dragSelect";
+import { enableViewBlocks } from "../utils/viewBlocks";
 import { urlAtCell, cellAtPoint } from "../utils/urlAtCell";
 import { attachScrollFlywheel } from "../utils/scrollFlywheel";
 import { ContextMenu, type MenuRequest } from "./ContextMenu";
@@ -116,7 +117,7 @@ type Props = {
   onFind?: () => void;
   // Open the Views panel. No argument = the whole fleet (header button); an
   // internalName = just that session (a card's chip).
-  onOpenViews?: (session?: string) => void;
+  onOpenViews?: (session?: string, item?: string) => void;
 };
 
 type Sheet = {
@@ -357,9 +358,11 @@ 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, codexApp = false, 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, onOpenView }: {
   /** The wall keeps a registry of live tiles' input senders (file drops). */
   onSender?: (send: ((data: string) => void) | null) => void;
+  /** An inline hop view card's Open: the reader for that session, on that item. */
+  onOpenView?: (session: string, item: string) => void;
   wsBase: string; room: string; userName: string; theme: object | undefined;
   /**
    * `live` says the tile is the focused one; `deliberate` says the human
@@ -430,6 +433,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
   const looksLikeClaude = () => isClaudeSurface(claudeAppRef.current, termRef.current as never);
   const codexAppRef = useRef(codexApp);
   codexAppRef.current = codexApp;
+  const onOpenViewRef = useRef(onOpenView);
+  onOpenViewRef.current = onOpenView;
   if (!voiceHoldRef.current) {
     voiceHoldRef.current = createVoiceHold({
       send: (data) => sendInputRef.current?.(data),
@@ -505,6 +510,9 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       rows: activeRows && activeRows > 1 ? activeRows : 24,
       scrollback: 2000,
       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,
       // 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.
@@ -535,6 +543,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       window.open(target, "_blank", "noopener");
     }));
     enableMathHover(term, getMathTip()); // rendered math on hover, here too
+    const uninstallViewBlocks = enableViewBlocks(term as never, (b) => onOpenViewRef.current?.(b.session, b.name));
     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.
@@ -758,6 +767,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
       detachFlywheel();
       ro?.disconnect();
       sub.dispose();
+      uninstallViewBlocks();
       uninstallDragSelect();
       term.dispose();
       termRef.current = null;
@@ -2996,6 +3006,11 @@ export const SessionSwitcher = ({
             </span>
           )}
           {!current && s.starting && !s.active && <span className="switcher-chip starting">STARTING</span>}
+          {!!s.checkbacks && (
+            <span className="switcher-chip checkback" title={`${s.checkbacks} scheduled check-back${s.checkbacks === 1 ? "" : "s"} will be typed into this session (hop checkback --list)`}>
+              ⏰ {s.checkbacks}
+            </span>
+          )}
           {phase && (
             <span className={`switcher-chip phase ${phase}`} title={phaseTitle(phase)}>
               <span className="phase-dot" aria-hidden="true" />{phaseLabel(phase)}
@@ -3046,6 +3061,7 @@ export const SessionSwitcher = ({
               onUnfocus={() => setFocusedKey(null)}
               onNotice={onNotice}
               onSender={(fn) => { if (fn) tileSendersRef.current.set(key, fn); else tileSendersRef.current.delete(key); }}
+              onOpenView={(scope, item) => onOpenViews?.(scope, item)}
             />
           </div>
         ) : (

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

@@ -65,6 +65,9 @@ type Props = {
   // the screen's edge was farther from where the eye already is. The dock
   // stays available for a caller that wants it.
   dock?: boolean;
+  // Open straight on this item (its file name within `session`), e.g. from
+  // an inline hop view card in the terminal.
+  item?: string;
   onClose: () => void;
 };
 
@@ -176,7 +179,7 @@ const DEFAULT_DOCK_W = 760;
 const clampDockW = (w: number) =>
   Math.max(560, Math.min(Math.round(window.innerWidth * 0.75), w));
 
-export const ViewsPanel = ({ session, sessions = [], dock = false, onClose }: Props) => {
+export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose }: Props) => {
   const [items, setItems] = useState<ViewItem[] | null>(null);
   const [failed, setFailed] = useState(false);
   const [preview, setPreview] = useState<ViewItem | null>(null);
@@ -276,7 +279,8 @@ export const ViewsPanel = ({ session, sessions = [], dock = false, onClose }: Pr
   useEffect(() => {
     if (!items || !canPreview()) return;
     if (preview && flatRows.some((r) => r.path === preview.path)) return;
-    setPreview(flatRows[0] ?? null);
+    const asked = item ? flatRows.find((r) => r.name === item) : null;
+    setPreview(asked ?? flatRows[0] ?? null);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [items, flatRows]);