hop2 0.11.65 → 0.11.67

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,8 @@ 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 { CheckbacksPanel } from "./components/CheckbacksPanel";
 import { MobileKeyboard } from "./components/MobileKeyboard";
 import { SessionSwitcher } from "./components/SessionSwitcher";
 import { SecondaryPane } from "./components/SecondaryPane";
@@ -266,6 +268,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 +481,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 +710,9 @@ 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);
+  // The ⏰ chip's window: what is waiting on a session.
+  const [checkbacksOpen, setCheckbacksOpen] = useState<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 +1517,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 +1536,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 +1547,7 @@ const App = () => {
     })) return;
     attachClaimPendingRef.current = true;
     deliberateAttachRef.current = true;
+    if (force) takeSizeRef.current = true;
     fitToViewport();
     handleResize();
   };
@@ -2110,6 +2130,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 +2170,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 +3078,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 +3265,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
@@ -3469,9 +3500,18 @@ const App = () => {
   // lands full-screen in the terminal you were just typing in. State-only:
   // while the wall is open the full-screen socket stays down (one client per
   // tab); the wall-close deliberate attach performs the actual connect.
+  // Opening a session IS reading it. The daemon's seen witness says so on
+  // the next poll (≤5s); the card should not wait for it — mark the turn
+  // read locally now, and poll soon so the daemon's own verdict replaces
+  // the local one.
+  const markTurnSeenLocally = (key: string) => {
+    setSessions((prev) => prev.map((s) => ((s.internalName || s.name) === key && s.turnSeen === false ? { ...s, turnSeen: true } : s)));
+    window.setTimeout(() => { void fetchSessions({ showLoading: false }); }, 900);
+  };
   const focusSessionInPlace = (nextSession: SessionInfo) => {
     const targetRoom = nextSession.internalName || nextSession.name;
     if ((session?.room ?? null) === targetRoom) return;
+    markTurnSeenLocally(targetRoom);
     const markers = loadSeenMarkers();
     markers[targetRoom] = { out: nextSession.lastActivityAt || 0, bell: nextSession.bellSeq || 0 };
     saveSeenMarkers(markers);
@@ -3491,6 +3531,7 @@ const App = () => {
   };
 
   const switchSession = (nextSession: SessionInfo) => {
+    markTurnSeenLocally(nextSession.internalName || nextSession.name);
     const targetRoom = nextSession.internalName || nextSession.name;
     const nextPath = buildSessionPath(targetRoom);
     const currentRoom = session?.room ?? sessionLabel;
@@ -3909,10 +3950,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 +3961,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 +4014,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 +4111,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 +4122,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 +4180,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 +4192,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 +4202,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 +4312,8 @@ const App = () => {
             onRefresh={() => fetchSessions({ showLoading: false })}
             onNotice={showToast}
             tileWsBase={resolveWsUrl()}
-            onOpenViews={(scope) => setViewsOpen({ session: scope })}
+            onOpenViews={(scope, item) => setViewsOpen({ session: scope, item })}
+            onOpenCheckbacks={(scope) => setCheckbacksOpen(scope)}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
           />
@@ -4908,7 +4977,8 @@ const App = () => {
             tileWsBase={resolveWsUrl()}
             onFocusSession={focusSessionInPlace}
             folders={folders}
-            onOpenViews={(scope) => setViewsOpen({ session: scope })}
+            onOpenViews={(scope, item) => setViewsOpen({ session: scope, item })}
+            onOpenCheckbacks={(scope) => setCheckbacksOpen(scope)}
             userName={name}
             terminalTheme={resolveTerminalTheme(themeMode)}
             onOpenSettings={() => {
@@ -5051,8 +5121,16 @@ 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. */}
+      {checkbacksOpen && (
+        <CheckbacksPanel
+          session={checkbacksOpen}
+          sessionName={sessions.find((s) => (s.internalName || s.name) === checkbacksOpen)?.displayName || checkbacksOpen}
+          onClose={() => setCheckbacksOpen(null)}
+          onChanged={() => { void fetchSessions({ showLoading: false }); }}
+        />
+      )}
       {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/CheckbacksPanel.tsx

@@ -0,0 +1,96 @@
+import { useEffect, useState } from "react";
+import { describeState, describeTrigger, orderForSession, type Checkback } from "../utils/checkbackText";
+
+// What is waiting on a session: the check-backs hop will type into it, when,
+// and the recent ones it already typed. Opened from the ⏰ chip on a card.
+// Pending ones can be cancelled here; scheduling stays with `hop checkback`
+// and the agent's own MCP tool.
+
+type Props = {
+  session: string;
+  sessionName: string;
+  onClose: () => void;
+  // The wall's chip count comes from the session list; a cancel here should
+  // show there without waiting for the next poll.
+  onChanged?: () => void;
+};
+
+export const CheckbacksPanel = ({ session, sessionName, onClose, onChanged }: Props) => {
+  const [items, setItems] = useState<Checkback[] | null>(null);
+  const [failed, setFailed] = useState(false);
+  const [busy, setBusy] = useState<string | null>(null);
+  const now = Date.now();
+
+  const load = () => {
+    fetch("/api/checkbacks", { cache: "no-store" })
+      .then((r) => (r.ok ? r.json() : Promise.reject(new Error(String(r.status)))))
+      .then((d) => { setItems(Array.isArray(d?.items) ? d.items : []); setFailed(false); })
+      .catch(() => { setFailed(true); setItems([]); });
+  };
+  useEffect(() => { load(); }, [session]);
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); onClose(); } };
+    window.addEventListener("keydown", onKey, true);
+    return () => window.removeEventListener("keydown", onKey, true);
+  }, [onClose]);
+
+  const cancel = async (id: string) => {
+    setBusy(id);
+    try {
+      await fetch("/api/checkbacks/cancel", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id }) });
+    } finally {
+      setBusy(null);
+      load();
+      onChanged?.();
+    }
+  };
+
+  const rows = items ? orderForSession(items, session) : [];
+  const pending = rows.filter((c) => c.status === "pending");
+  const past = rows.filter((c) => c.status !== "pending").slice(0, 8);
+
+  return (
+    <>
+      <div className="views-backdrop" onClick={onClose} />
+      <div className="views-panel checkbacks-panel" role="dialog" aria-label={`Check-backs for ${sessionName}`}>
+        <div className="views-head">
+          <span className="views-badge">⏰ Check-backs</span>
+          <span className="checkbacks-session">{sessionName}</span>
+          <span className="views-head-spacer" />
+          <button type="button" className="views-close" aria-label="Close" onClick={onClose}>×</button>
+        </div>
+        {items === null ? (
+          <p className="checkbacks-empty">Loading…</p>
+        ) : failed ? (
+          <p className="checkbacks-empty">Could not load check-backs.</p>
+        ) : (
+          <div className="checkbacks-list">
+            {pending.length === 0 && <p className="checkbacks-empty">Nothing waiting on this session.</p>}
+            {pending.map((c) => (
+              <div key={c.id} className={"checkback-row pending" + (c.firedAt ? " fired" : "")}>
+                <div className="checkback-when">{describeTrigger(c.trigger, now)}{c.force ? " · typed even mid-turn" : ""}</div>
+                <div className="checkback-message">{c.message}</div>
+                <div className="checkback-foot">
+                  <span className="checkback-state">{describeState(c, now)} · by {c.createdBy === "agent" ? "the agent" : "you"}</span>
+                  <button type="button" className="checkback-cancel" disabled={busy === c.id} onClick={() => cancel(c.id)}>Cancel</button>
+                </div>
+              </div>
+            ))}
+            {past.length > 0 && (
+              <>
+                <div className="checkbacks-past-head">Recent</div>
+                {past.map((c) => (
+                  <div key={c.id} className={"checkback-row " + c.status}>
+                    <div className="checkback-when">{describeState(c, now)} · {describeTrigger(c.trigger, now)}</div>
+                    <div className="checkback-message">{c.message}</div>
+                  </div>
+                ))}
+              </>
+            )}
+            <p className="checkbacks-hint">Schedule one with <code>hop checkback</code> inside the session, or the agent does it itself over MCP.</p>
+          </div>
+        )}
+      </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,