hop2 0.11.80 → 0.11.82

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

@@ -276,6 +276,8 @@ type SessionInfo = {
   turnSeen?: boolean;
   // Scheduled check-backs waiting on this session (hop checkback).
   checkbacks?: number;
+  checkbackNext?: number;
+  codexAutomations?: number;
   attentionReason?: string;
   attentionNote?: string;
   cols?: number;
@@ -3301,6 +3303,8 @@ const App = () => {
           agentPhase: s.agentPhase === "working" || s.agentPhase === "done" ? s.agentPhase : null,
           turnSeen: s.turnSeen !== false,
           checkbacks: Number(s.checkbacks) > 0 ? Number(s.checkbacks) : undefined,
+          checkbackNext: Number(s.checkbackNext) > 0 ? Number(s.checkbackNext) : undefined,
+          codexAutomations: Number(s.codexAutomations) > 0 ? Number(s.codexAutomations) : 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

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

@@ -1,10 +1,15 @@
 import { useEffect, useState } from "react";
-import { describeState, describeTrigger, orderForSession, type Checkback } from "../utils/checkbackText";
+import {
+  chipWhen, conditionLabel, dayHeading, describeRrule, describeState, describeTrigger, isTimed,
+  nextOfTrigger, orderForSession, relative, timeOfDay, type Checkback, type CodexAutomation
+} 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.
+// What is scheduled on a session, read like a reminders list: the timed ones
+// under their day, the ones waiting on something (a job, a file, idle) in a
+// list of their own, the Codex automations aimed at the same conversation
+// beside hop's, and the recent past folded away. Opened from a card's chip.
+// hop's own can be cancelled here; scheduling stays with `hop checkback` and
+// the agent's MCP tool, and Codex's automations with Codex.
 
 type Props = {
   session: string;
@@ -15,16 +20,26 @@ type Props = {
   onChanged?: () => void;
 };
 
+type Timed =
+  | { source: "hop"; at: number; cb: Checkback }
+  | { source: "codex"; at: number; auto: CodexAutomation; rule: string };
+
 export const CheckbacksPanel = ({ session, sessionName, onClose, onChanged }: Props) => {
   const [items, setItems] = useState<Checkback[] | null>(null);
+  const [automations, setAutomations] = useState<CodexAutomation[]>([]);
   const [failed, setFailed] = useState(false);
   const [busy, setBusy] = useState<string | null>(null);
+  const [open, setOpen] = useState<string | null>(null);
   const now = Date.now();
 
   const load = () => {
-    fetch("/api/checkbacks", { cache: "no-store" })
+    fetch(`/api/checkbacks?session=${encodeURIComponent(session)}`, { 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); })
+      .then((d) => {
+        setItems(Array.isArray(d?.items) ? d.items : []);
+        setAutomations(Array.isArray(d?.automations) ? d.automations : []);
+        setFailed(false);
+      })
       .catch(() => { setFailed(true); setItems([]); });
   };
   useEffect(() => { load(); }, [session]);
@@ -47,14 +62,43 @@ export const CheckbacksPanel = ({ session, sessionName, onClose, onChanged }: Pr
 
   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);
+  const past = rows.filter((c) => c.status !== "pending").slice(0, 12);
+  // A one-shot Codex automation whose time has passed is not upcoming:
+  // Codex keeps it ACTIVE whether or not it ran (some never arrive), so it
+  // folds away under "Past due" instead of heading the list as "Overdue".
+  const autoTimes = automations.map((auto) => ({ auto, r: describeRrule(auto.rrule, now) }));
+  const isPastDue = (r: { next: number | null }, rule: string) => /COUNT=1/.test(rule) && r.next !== null && r.next < now;
+  const activeAutos = autoTimes.filter(({ auto, r }) => auto.status === "ACTIVE" && !isPastDue(r, auto.rrule)).map(({ auto }) => auto);
+  const pastDueAutos = autoTimes.filter(({ auto, r }) => auto.status === "ACTIVE" && isPastDue(r, auto.rrule));
+  const pausedAutos = automations.filter((a) => a.status !== "ACTIVE");
+
+  // Everything with a clock time, hop's and Codex's together, soonest first.
+  const timed: Timed[] = [
+    ...pending.filter((c) => isTimed(c.trigger)).map((cb) => ({ source: "hop" as const, at: nextOfTrigger(cb.trigger) ?? now, cb })),
+    ...activeAutos.map((auto) => { const r = describeRrule(auto.rrule, now); return { source: "codex" as const, at: r.next ?? Number.MAX_SAFE_INTEGER, auto, rule: r.label }; })
+  ].sort((a, b) => a.at - b.at);
+  const days: Array<[string, Timed[]]> = [];
+  for (const t of timed) {
+    const head = t.at === Number.MAX_SAFE_INTEGER ? "Repeating" : dayHeading(t.at, now);
+    const last = days[days.length - 1];
+    if (last && last[0] === head) last[1].push(t); else days.push([head, [t]]);
+  }
+  const waiting = pending.filter((c) => !isTimed(c.trigger));
+  const nothing = timed.length === 0 && waiting.length === 0;
+
+  const message = (key: string, text: string) => (
+    <div className={"sched-message" + (open === key ? " open" : "")}
+         onClick={() => setOpen((o) => (o === key ? null : key))}
+         title={open === key ? "" : "Click to read it all"}>{text}</div>
+  );
+  const who = (c: Checkback) => (c.createdBy === "agent" ? "the agent" : "you");
 
   return (
     <>
       <div className="views-backdrop" onClick={onClose} />
-      <div className="views-panel checkbacks-panel" role="dialog" aria-label={`Check-backs for ${sessionName}`}>
+      <div className="views-panel checkbacks-panel" role="dialog" aria-label={`Scheduled for ${sessionName}`}>
         <div className="views-head">
-          <span className="views-badge">⏰ Check-backs</span>
+          <span className="views-badge">Scheduled</span>
           <span className="checkbacks-session">{sessionName}</span>
           <span className="views-head-spacer" />
           <button type="button" className="views-close" aria-label="Close" onClick={onClose}>×</button>
@@ -62,32 +106,116 @@ export const CheckbacksPanel = ({ session, sessionName, onClose, onChanged }: Pr
         {items === null ? (
           <p className="checkbacks-empty">Loading…</p>
         ) : failed ? (
-          <p className="checkbacks-empty">Could not load check-backs.</p>
+          <p className="checkbacks-empty">Could not load what is scheduled.</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>
+            {nothing && <p className="checkbacks-empty">Nothing scheduled on this session.</p>}
+
+            {days.map(([head, list]) => (
+              <section key={head} className="sched-day">
+                <div className="sched-day-head">{head}</div>
+                {list.map((t) => t.source === "hop" ? (
+                  <div key={t.cb.id} className={"sched-row" + (t.cb.firedAt ? " fired" : "")}>
+                    <div className="sched-time">{t.at === Number.MAX_SAFE_INTEGER ? "—" : timeOfDay(t.at)}</div>
+                    <div className="sched-body">
+                      {message(t.cb.id, t.cb.message)}
+                      <div className="sched-meta">
+                        {t.cb.trigger.kind === "every" ? describeTrigger(t.cb.trigger, now) : chipWhen(t.at, now)}
+                        {t.cb.firedAt ? " · due, waiting for the agent to be idle" : ""}
+                        {t.cb.force ? " · typed even mid-turn" : ""} · by {who(t.cb)}
+                      </div>
+                    </div>
+                    <button type="button" className="checkback-cancel" disabled={busy === t.cb.id} onClick={() => cancel(t.cb.id)}>Cancel</button>
+                  </div>
+                ) : (
+                  <div key={"codex-" + t.auto.id} className="sched-row codex">
+                    <div className="sched-time">{t.at === Number.MAX_SAFE_INTEGER ? "—" : timeOfDay(t.at)}</div>
+                    <div className="sched-body">
+                      <div className="sched-title">{t.auto.name}</div>
+                      {message("codex-" + t.auto.id, t.auto.prompt)}
+                      <div className="sched-meta">Codex automation · {t.rule}{t.at !== Number.MAX_SAFE_INTEGER && t.at < now ? " · past due" : ""}</div>
+                    </div>
+                    <span className="sched-owner" title="Codex runs this one; manage it in Codex">Codex</span>
+                  </div>
+                ))}
+              </section>
             ))}
+
+            {waiting.length > 0 && (
+              <section className="sched-day">
+                <div className="sched-day-head">When something happens</div>
+                {waiting.map((c) => {
+                  const cond = conditionLabel(c.trigger);
+                  return (
+                    <div key={c.id} className={"sched-row" + (c.firedAt ? " fired" : "")}>
+                      <div className="sched-time tag">{cond.tag}</div>
+                      <div className="sched-body">
+                        {message(c.id, c.message)}
+                        <div className="sched-meta">
+                          <code className="sched-cond" title={cond.detail}>{cond.detail}</code>
+                        </div>
+                        <div className="sched-meta">
+                          {c.firedAt ? "happened · waiting for the agent to be idle" : c.trigger.kind === "cmd" ? describeTrigger(c.trigger, now).replace(/^when `.*` succeeds · /, "") : "watching"}
+                          {c.lastError && !c.firedAt ? ` · ${c.lastError}` : ""} · by {who(c)}
+                        </div>
+                      </div>
+                      <button type="button" className="checkback-cancel" disabled={busy === c.id} onClick={() => cancel(c.id)}>Cancel</button>
+                    </div>
+                  );
+                })}
+              </section>
+            )}
+
+            {pastDueAutos.length > 0 && (
+              <details className="sched-fold">
+                <summary>Past due Codex automations ({pastDueAutos.length})</summary>
+                <p className="checkbacks-hint">Codex still lists these as active, but a one-shot follow-up is not always delivered — check the session before counting on it.</p>
+                {pastDueAutos.map(({ auto, r }) => (
+                  <div key={auto.id} className="sched-row codex past">
+                    <div className="sched-time tag">was due</div>
+                    <div className="sched-body">
+                      <div className="sched-title">{auto.name}</div>
+                      <div className="sched-meta">{r.next ? `${dayHeading(r.next, now) === "Due now" ? new Date(r.next).toLocaleString([], { weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }) : timeOfDay(r.next)} · ${relative(r.next, now)}` : r.label}</div>
+                    </div>
+                  </div>
+                ))}
+              </details>
+            )}
+
+            {pausedAutos.length > 0 && (
+              <details className="sched-fold">
+                <summary>Paused Codex automations ({pausedAutos.length})</summary>
+                {pausedAutos.map((a) => (
+                  <div key={a.id} className="sched-row codex past">
+                    <div className="sched-time tag">paused</div>
+                    <div className="sched-body">
+                      <div className="sched-title">{a.name}</div>
+                      <div className="sched-meta">{describeRrule(a.rrule, now).label}</div>
+                    </div>
+                  </div>
+                ))}
+              </details>
+            )}
+
             {past.length > 0 && (
-              <>
-                <div className="checkbacks-past-head">Recent</div>
+              <details className="sched-fold">
+                <summary>Recent ({past.length})</summary>
                 {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 key={c.id} className={"sched-row past " + c.status}>
+                    <div className="sched-time tag">{c.status === "delivered" ? "sent" : "cancelled"}</div>
+                    <div className="sched-body">
+                      {message(c.id, c.message)}
+                      <div className="sched-meta">{describeState(c, now)}</div>
+                    </div>
                   </div>
                 ))}
-              </>
+              </details>
             )}
-            <p className="checkbacks-hint">Schedule one with <code>hop checkback</code> inside the session, or the agent does it itself over MCP.</p>
+
+            <p className="checkbacks-hint">
+              hop types these into the session when they come due and the agent is idle. Schedule with <code>hop checkback</code> or
+              the agent's <code>hop_checkback</code> tool; Codex automations are run by Codex.
+            </p>
           </div>
         )}
       </div>

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

@@ -220,9 +220,16 @@ export const DigestCard = ({ sessions, onOpen }: {
       <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.recommendation ? (
+        <span className="digest-reco"><span className="digest-reco-label">Suggested</span>{item.recommendation}</span>
+      ) : null}
       {item.replies?.length ? (
-        <span className="digest-replies">{item.replies.map((r) => <span key={r} className="digest-reply">{r}</span>)}</span>
+        // The ways the agent offered to go — words, not buttons: the card
+        // opens the session, where the answer is given.
+        <span className="digest-replies">
+          <span className="digest-replies-label">Options</span>
+          {item.replies.map((r, i) => <span key={r} className="digest-reply">{i > 0 ? " · " : ""}{r}</span>)}
+        </span>
       ) : null}
     </button>
   );
@@ -237,7 +244,7 @@ export const DigestCard = ({ sessions, onOpen }: {
           if (!rows.length) return null;
           return (
             <div key={slot} className={"digest-slot slot-" + slot}>
-              <div className="digest-slot-head">{SLOT_LABEL[slot]}</div>
+              <div className="digest-slot-head">{SLOT_LABEL[slot]}<span className="digest-slot-count">{rows.length}</span></div>
               {rows.map((it) => renderItem(it, s))}
             </div>
           );
@@ -351,7 +358,9 @@ export const DigestCard = ({ sessions, onOpen }: {
                         <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}
+                        {item.recommendation ? (
+                          <span className="digest-reco"><span className="digest-reco-label">Suggested</span>{item.recommendation}</span>
+                        ) : null}
                       </div>
                     ))}
                   </div>

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

@@ -38,6 +38,7 @@ import {
   insertAfter, describeAccount, type AgentHome, type AgentHomes } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
 import { isAppCtrlEnter, isFullscreenChord } from "../utils/fullscreenChord";
+import { chipWhen } from "../utils/checkbackText";
 import { DigestCard } from "./DigestCard";
 import { hasUnseenViews, loadViewsSeen } from "./ViewsPanel";
 
@@ -3087,18 +3088,29 @@ export const SessionSwitcher = ({
             </span>
           )}
           {!current && s.starting && !s.active && <span className="switcher-chip starting">STARTING</span>}
-          {!!s.checkbacks && (
-            <button
-              type="button"
-              className="switcher-chip checkback"
-              title={`${s.checkbacks} scheduled check-back${s.checkbacks === 1 ? "" : "s"} will be typed into this session — click to see what is waiting`}
-              aria-label={`${s.checkbacks} check-back${s.checkbacks === 1 ? "" : "s"} waiting on ${s.displayName}`}
-              onClick={(e) => { e.stopPropagation(); onOpenCheckbacks?.(key); }}
-              onPointerDown={(e) => e.stopPropagation()}
-            >
-              ⏰ {s.checkbacks}
-            </button>
-          )}
+          {(!!s.checkbacks || !!s.codexAutomations) && (() => {
+            // What is scheduled here, hop's and Codex's own: the chip says WHEN
+            // the next timed one is due ("in 12m", "4:30 PM"), or that it is
+            // waiting on something (a job, a file) when nothing has a time.
+            const total = (s.checkbacks || 0) + (s.codexAutomations || 0);
+            const when = s.checkbackNext ? chipWhen(s.checkbackNext, Date.now()) : "waiting";
+            return (
+              <button
+                type="button"
+                className="switcher-chip checkback"
+                title={`${total} scheduled${s.codexAutomations ? ` (${s.codexAutomations} Codex automation${s.codexAutomations === 1 ? "" : "s"})` : ""}${s.checkbackNext ? ` — next ${when}` : " — waiting on a condition"}. Click to see the list.`}
+                aria-label={`${total} scheduled on ${s.displayName}`}
+                onClick={(e) => { e.stopPropagation(); onOpenCheckbacks?.(key); }}
+                onPointerDown={(e) => e.stopPropagation()}
+              >
+                <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+                  <rect x="3" y="5" width="18" height="16" rx="3" /><path d="M3 10h18M8 3v4M16 3v4" />
+                </svg>
+                <span>{when}</span>
+                {total > 1 && <span className="checkback-count">{total}</span>}
+              </button>
+            );
+          })()}
           {s.agentHome && homesFor(s.agent).length > 1 && (() => {
             const known = homesFor(s.agent).find((h) => h.dir === s.agentHome?.dir);
             const out = known?.login && !known.login.loggedIn;

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

@@ -46,7 +46,10 @@ type ViewItem = {
   mtime?: number;
   // "server" is a LIVE proxied localhost server (`hop port`), not a stored
   // file: it stops working when the server does, which a file never does.
-  kind?: "file" | "server";
+  // "link" points at another app entirely — a Nebula notebook on its own
+  // server — opened at `target`; `app` names what opens it.
+  kind?: "file" | "server" | "link";
+  app?: string;
   // For a server, the proxy itself. The manifest scan can only see the
   // redirect page `hop port` leaves behind; going straight to the proxy skips
   // a visible flash and a round trip.
@@ -104,6 +107,7 @@ export const hasUnseenViews = (
 // that the column stops lining up. The tag also survives a monospace column.
 const kindOf = (name: string, kind?: string) => {
   if (kind === "server") return "LIVE";
+  if (kind === "link") return "NB";
   const ext = (name.split(".").pop() || "").toLowerCase();
   if (["csv", "tsv"].includes(ext)) return "TBL";
   if (["mp3", "m4a", "wav", "flac", "aac", "ogg", "opus"].includes(ext)) return "AUD";
@@ -128,13 +132,13 @@ const formatBytes = (n?: number) => {
 };
 
 const hrefFor = (item: ViewItem) =>
-  item.kind === "server" && item.target ? item.target : item.path;
+  (item.kind === "server" || item.kind === "link") && item.target ? item.target : item.path;
 
 // The stored file itself, as an attachment: the daemon's /download mode
 // serves the markdown an agent wrote rather than the page it renders into.
 // Only files — a server is live, there is nothing to save.
 const downloadHrefFor = (item: ViewItem) =>
-  item.kind === "server" ? null : item.path.replace(/\/inline$/, "") + "/download";
+  item.kind === "server" || item.kind === "link" ? null : item.path.replace(/\/inline$/, "") + "/download";
 
 // A hidden same-origin anchor with `download`: the row is already an <a>
 // (anchors cannot nest), and window.open would show the file, not save it.
@@ -371,7 +375,8 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
   };
 
   const copyLink = (item: ViewItem) => {
-    const url = location.origin + hrefFor(item);
+    const href = hrefFor(item);
+    const url = /^https?:\/\//.test(href) ? href : location.origin + href;
     navigator.clipboard?.writeText(url).then(() => {
       setCopied(item.path);
       window.setTimeout(() => setCopied((c) => (c === item.path ? null : c)), 1400);
@@ -447,12 +452,16 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
   const rowsFor = (key: string, rows: ViewItem[]) => rows.map((item) => {
     const fresh = (item.mtime || 0) > (seenAtOpen[key] || 0);
     const isServer = item.kind === "server";
+    const isLink = item.kind === "link";
     const selected = preview?.path === item.path;
     // A server has no meaningful size and its filename is an implementation
     // detail (the redirect page) — it is a door, not a document, so say what
     // it is instead.
+    const linkHost = isLink ? (() => { try { return new URL(item.target || "").host; } catch { return ""; } })() : "";
     const meta = isServer
       ? "live server"
+      : isLink
+      ? [item.app === "nebula" ? "Nebula notebook" : "link", linkHost, relativeTime((item.mtime || 0) * 1000, now)].filter(Boolean).join(" · ")
       : [
           // The filename is only worth a line of its own when the title isn't
           // already showing it.
@@ -464,7 +473,7 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
       <a
         key={item.path}
         className={"views-row" + (fresh ? " fresh" : "")
-          + (isServer ? " server" : "") + (selected ? " selected" : "")}
+          + (isServer || isLink ? " server" : "") + (selected ? " selected" : "")}
         href={hrefFor(item)}
         target="_blank"
         rel="noopener"
@@ -487,7 +496,7 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
           <button type="button" className="views-act"
                   title="Open in a new tab" aria-label="Open in a new tab"
                   onClick={() => window.open(hrefFor(item), "_blank", "noopener")}>↗</button>
-          {!isServer && (
+          {!isServer && !isLink && (
             <button type="button" className="views-act"
                     title="Download" aria-label={`Download ${item.name}`}
                     onClick={() => triggerDownload(item)}>⤓</button>
@@ -496,7 +505,7 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
                   title={copied === item.path ? "Copied" : "Copy link"}
                   aria-label="Copy link"
                   onClick={() => copyLink(item)}>{copied === item.path ? "✓" : "⧉"}</button>
-          {!isServer && (
+          {!isServer && !isLink && (
             /* The FILE, not the page: ?download=1 serves the published bytes as
                an attachment under their real name (md/csv/json raw, not the
                rendered view). A window.open, not an anchor: anchors can't nest
@@ -556,8 +565,24 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
   // stay iframes — sandboxed only for LIVE servers (an arbitrary dev app
   // must not frame-bust the wall); our own files skip the sandbox, because a
   // sandboxed iframe disables the browser's PDF viewer.
+  // A notebook lives in its own app: the pane says where it opens rather
+  // than framing Nebula (another origin, often reached over a forwarded port).
+  const linkFile = (() => {
+    if (!preview || preview.kind !== "link") return "";
+    try { return new URL(preview.target || "").searchParams.get("file") || ""; } catch { return ""; }
+  })();
   const page = showPreview && (
-    preview.kind !== "server" && isImage(preview.name) ? (
+    preview.kind === "link" ? (
+      <div className="views-link-card">
+        <div className="views-link-app">{preview.app === "nebula" ? "Nebula notebook" : "Link"}</div>
+        <div className="views-link-title">{preview.title || preview.name}</div>
+        {linkFile && <code className="views-link-path">{linkFile}</code>}
+        <a className="views-link-open" href={preview.target} target="_blank" rel="noopener">
+          Open in {preview.app === "nebula" ? "Nebula" : "a new tab"} ↗
+        </a>
+        <div className="views-link-host">{(() => { try { return new URL(preview.target || "").host; } catch { return ""; } })()}</div>
+      </div>
+    ) : preview.kind !== "server" && isImage(preview.name) ? (
       <div className="views-media"><img src={preview.path} alt={preview.title || preview.name} /></div>
     ) : preview.kind !== "server" && isVideo(preview.name) ? (
       <div className="views-media"><video src={preview.path} controls autoPlay={false} /></div>
@@ -600,7 +625,7 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
       <span className="views-head-spacer" />
       {preview && (
         <span className="views-nav-acts">
-          {preview.kind !== "server" && (
+          {preview.kind !== "server" && preview.kind !== "link" && (
             <button type="button" className="views-act"
                     title="Download" aria-label={`Download ${preview.name}`}
                     onClick={() => triggerDownload(preview)}>⤓</button>

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

@@ -5035,3 +5035,106 @@ body.pane-dragging { user-select: none; }
 }
 .math-tip-hint { margin-top: 4px; font-size: 10px; color: var(--ink-muted); }
 .math-tip-error { font-family: var(--font-mono); color: var(--err); }
+
+/* A Views row that opens in another app (a Nebula notebook): the pane is a
+   door, not a frame. */
+.views-link-card {
+  margin: auto; max-width: 460px; padding: 28px 24px; display: flex; flex-direction: column;
+  align-items: center; gap: 10px; text-align: center;
+}
+.views-link-app { font-size: 12px; font-weight: 600; letter-spacing: 0.04em; text-transform: uppercase; color: var(--ink-muted); }
+.views-link-title { font-size: 17px; font-weight: 600; color: var(--ink); overflow-wrap: anywhere; }
+.views-link-path { font-size: 12px; color: var(--ink-muted); overflow-wrap: anywhere; }
+.views-link-open {
+  margin-top: 6px; padding: 8px 16px; border-radius: 8px; background: var(--accent, #7c5cff);
+  color: #fff; font-weight: 600; text-decoration: none;
+}
+.views-link-host { font-size: 12px; color: var(--ink-muted); }
+
+/* Scheduled: the card chip names WHEN, with a small calendar glyph; the list
+   reads like reminders — a time column, the message, its provenance. */
+.switcher-chip.checkback { display: inline-flex; align-items: center; gap: 4px; }
+.switcher-chip.checkback svg { flex-shrink: 0; opacity: 0.8; }
+.checkback-count {
+  min-width: 15px; padding: 0 4px; border-radius: 999px; font-size: 10px; line-height: 15px; text-align: center;
+  background: color-mix(in srgb, var(--accent) 18%, transparent); color: var(--ink);
+}
+.sched-day { display: flex; flex-direction: column; }
+.sched-day-head {
+  font-size: 11px; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; color: var(--ink-muted);
+  padding: 8px 2px 4px; border-bottom: 1px solid var(--line);
+}
+.sched-row {
+  display: grid; grid-template-columns: 72px 1fr auto; gap: 10px; align-items: start;
+  padding: 9px 2px; border-bottom: 1px solid color-mix(in srgb, var(--line) 60%, transparent);
+}
+.sched-row.fired .sched-time { color: var(--warn); }
+.sched-row.past { opacity: 0.7; }
+.sched-time { font-size: 13px; font-weight: 600; color: var(--ink); font-variant-numeric: tabular-nums; padding-top: 1px; }
+.sched-time.tag { font-size: 10.5px; font-weight: 700; letter-spacing: 0.03em; text-transform: uppercase; color: var(--ink-muted); padding-top: 3px; }
+.sched-body { min-width: 0; }
+.sched-title { font-size: 13px; font-weight: 600; color: var(--ink); }
+.sched-message {
+  font-size: 13px; color: var(--ink); white-space: pre-wrap; word-break: break-word; cursor: pointer;
+  display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden;
+}
+.sched-message.open { display: block; cursor: default; }
+.sched-meta { margin-top: 3px; font-size: 11.5px; color: var(--ink-muted); }
+.sched-cond {
+  display: block; font-family: var(--font-mono); font-size: 11px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}
+.sched-owner {
+  font-size: 10.5px; font-weight: 600; padding: 2px 7px; border-radius: 6px; border: 1px solid var(--line); color: var(--ink-muted);
+}
+.sched-fold { margin-top: 6px; }
+.sched-fold > summary { cursor: pointer; font-size: 12px; font-weight: 600; color: var(--ink-muted); padding: 6px 2px; }
+
+/* Briefing, read as a page: the SECTION carries the urgency colour (a dot in
+   its heading, a rule beside each item); session names are quiet labels, not
+   a second set of red capitals; lines stop at a readable measure; the
+   agent's recommendation is a tinted "Suggested" note; the reply options are
+   words, since the card itself is what opens the session. */
+.digest-slot { margin-top: 12px; display: flex; flex-direction: column; }
+.digest-slot-head {
+  font-family: inherit; font-size: 11px; font-weight: 700; letter-spacing: 0.06em;
+  display: flex; align-items: center; gap: 7px;
+  padding: 0 0 6px; border-bottom: 1px solid var(--line);
+}
+.digest-slot-head::before { content: ""; width: 7px; height: 7px; border-radius: 50%; background: currentColor; }
+.digest-slot-count { font-weight: 600; color: var(--ink-muted); letter-spacing: 0; }
+.digest-slot .digest-item {
+  position: relative; margin: 0; border-radius: 0; gap: 3px;
+  padding: 10px 10px 11px 16px;
+  border-bottom: 1px solid color-mix(in srgb, var(--line) 60%, transparent);
+}
+.digest-slot .digest-item::before {
+  content: ""; position: absolute; left: 4px; top: 12px; bottom: 12px; width: 3px; border-radius: 2px;
+  background: var(--ink-muted); opacity: 0.35;
+}
+.digest-slot.slot-decide .digest-item::before { background: #e5484d; opacity: 0.85; }
+.digest-slot.slot-watch .digest-item::before { background: #e79d13; opacity: 0.85; }
+.digest-slot.slot-done .digest-item::before { background: #30a46c; opacity: 0.85; }
+.digest-slot .digest-item .digest-dateline,
+.digest-slot .digest-item.needs .digest-dateline,
+.digest-slot .digest-item.blocked .digest-dateline,
+.digest-slot .digest-item.done .digest-dateline {
+  color: var(--ink-muted); text-transform: none; letter-spacing: 0; font-size: 11px; font-weight: 600;
+}
+.digest-headline { font-size: 13.5px; line-height: 1.35; }
+.digest-headline, .digest-why, .digest-reco, .digest-replies { max-width: 76ch; }
+.digest-why { font-size: 12.5px; line-height: 1.45; }
+.digest-reco {
+  font-style: normal; font-size: 12.5px; line-height: 1.4; margin-top: 4px;
+  padding: 5px 9px; border-radius: 7px; width: fit-content;
+  background: color-mix(in srgb, var(--accent, #7c5cff) 9%, transparent);
+}
+.digest-reco-label {
+  font-size: 10px; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase;
+  color: var(--accent, #7c5cff); margin-right: 7px;
+}
+.digest-replies { display: block; margin-top: 3px; font-size: 12px; color: var(--ink-muted); }
+.digest-replies-label { font-size: 10px; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase; margin-right: 7px; }
+.digest-reply { font-family: inherit; font-size: inherit; padding: 0; border: none; border-radius: 0; background: none; color: var(--ink-muted); }
+/* The item is a <button>, whose global weight made every line bold. */
+.digest-item .digest-why, .digest-item .digest-replies, .digest-item .digest-reply { font-weight: 400; }
+.digest-item .digest-reco { font-weight: 500; }

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

@@ -71,3 +71,104 @@ export const orderForSession = (items: Checkback[], session: string): Checkback[
   const done = mine.filter((c) => c.status !== "pending").sort((a, b) => ((b.deliveredAt || b.cancelledAt || b.createdAt || 0) - (a.deliveredAt || a.cancelledAt || a.createdAt || 0)));
   return [...pending, ...done];
 };
+
+// Codex's own scheduled jobs ("automations"), as the daemon reads them from
+// ~/.codex/automations for the thread a session runs. Codex runs them; hop
+// only shows them beside its own.
+export type CodexAutomation = {
+  id: string;
+  name: string;
+  kind: string;
+  status: string;
+  prompt: string;
+  rrule: string;
+  thread: string;
+  updatedAt?: number | null;
+};
+
+const PERIOD_MS: Record<string, number> = { MINUTELY: MIN, HOURLY: HOUR, DAILY: DAY, WEEKLY: 7 * DAY };
+
+const parseDtstart = (v: string): number | null => {
+  const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z?)$/.exec(v.trim());
+  if (!m) return null;
+  const [, y, mo, d, h, mi, s, z] = m;
+  return z
+    ? Date.UTC(+y, +mo - 1, +d, +h, +mi, +s)
+    : new Date(+y, +mo - 1, +d, +h, +mi, +s).getTime();
+};
+
+/** An RRULE (with optional DTSTART) as words, and its next run when that can be known. */
+export const describeRrule = (rrule: string, now: number): { label: string; next: number | null } => {
+  let start: number | null = null;
+  const parts: Record<string, string> = {};
+  for (const line of rrule.split(/\r?\n/)) {
+    const [key, ...rest] = line.split(":");
+    const value = rest.join(":");
+    if (key === "DTSTART") start = parseDtstart(value);
+    else for (const kv of (key === "RRULE" ? value : line).split(";")) {
+      const [k, v] = kv.split("=");
+      if (k && v !== undefined) parts[k.trim()] = v.trim();
+    }
+  }
+  const freq = parts.FREQ || "";
+  const interval = Math.max(1, Number(parts.INTERVAL) || 1);
+  const count = Number(parts.COUNT) || 0;
+  if (count === 1 && start !== null) return { label: `at ${clock(start)}`, next: start };
+  const step = PERIOD_MS[freq] ? PERIOD_MS[freq] * interval : 0;
+  if (parts.BYHOUR !== undefined && (freq === "DAILY" || freq === "WEEKLY")) {
+    // Floating local times, one or more hours a day.
+    const hours = parts.BYHOUR.split(",").map(Number).filter(Number.isFinite).sort((a, b) => a - b);
+    const minute = Number(parts.BYMINUTE) || 0;
+    let next: number | null = null;
+    for (let dayOffset = 0; dayOffset < 2 && next === null; dayOffset++) {
+      for (const h of hours) {
+        const d = new Date(now);
+        d.setDate(d.getDate() + dayOffset);
+        d.setHours(h, minute, 0, 0);
+        if (d.getTime() > now) { next = d.getTime(); break; }
+      }
+    }
+    const mm = String(minute).padStart(2, "0");
+    const label = hours.length > 3 ? `${hours.length}× a day` : `daily at ${hours.map((h) => `${h}:${mm}`).join(", ")}`;
+    return { label, next };
+  }
+  if (step) {
+    const label = `every ${period(step)}`;
+    if (start === null) return { label, next: null };
+    const k = now <= start ? 0 : Math.ceil((now - start) / step);
+    return { label, next: start + k * step };
+  }
+  return { label: freq ? freq.toLowerCase() : "scheduled", next: start };
+};
+
+/** "Today" / "Tomorrow" / "Mon, Oct 19" — the day heading a time sits under. */
+export const dayHeading = (ms: number, now: number): string => {
+  const startOf = (t: number) => { const d = new Date(t); d.setHours(0, 0, 0, 0); return d.getTime(); };
+  const days = Math.round((startOf(ms) - startOf(now)) / DAY);
+  if (days < 0) return "Due now";   // fired; hop types it once the agent is idle
+  if (days === 0) return "Today";
+  if (days === 1) return "Tomorrow";
+  return new Date(ms).toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" });
+};
+
+/** The clock time alone ("4:30 PM"), for the left column of a day's list. */
+export const timeOfDay = (ms: number): string =>
+  new Date(ms).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+
+/** Short words for the chip: "in 12m" under an hour, else the clock time (with the day when not today). */
+export const chipWhen = (ms: number, now: number): string =>
+  ms - now < HOUR && ms > now ? relative(ms, now) : clock(ms);
+
+/** A condition trigger in a few words, for the "when something happens" list. */
+export const conditionLabel = (t: CheckbackTrigger): { tag: string; detail: string } => {
+  switch (t.kind) {
+    case "cmd": return { tag: "on check", detail: t.command };
+    case "file": return { tag: t.baselineMtime ? "on change" : "on file", detail: t.path };
+    case "idle": return { tag: "on idle", detail: t.afterMs ? `after ${period(t.afterMs)} idle` : "the next time the agent is idle" };
+    default: return { tag: "", detail: "" };
+  }
+};
+
+export const isTimed = (t: CheckbackTrigger) => t.kind === "at" || t.kind === "every";
+export const nextOfTrigger = (t: CheckbackTrigger): number | null =>
+  t.kind === "at" ? t.at : t.kind === "every" ? t.next : null;

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

@@ -59,6 +59,10 @@ export type SwitcherSession = {
   turnSeen?: boolean;
   /** Scheduled check-backs waiting on this session (hop checkback). */
   checkbacks?: number;
+  /** When the soonest TIMED one is due (ms); absent when all wait on a condition. */
+  checkbackNext?: number;
+  /** Active Codex automations aimed at this session's conversation. */
+  codexAutomations?: number;
   agentPermitted?: boolean;
   cols?: number;
   rows?: number;

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { conditionLabel, dayHeading, describeRrule } from "../src/utils/checkbackText";
+
+const at = (y: number, mo: number, d: number, h = 0, mi = 0) => new Date(y, mo - 1, d, h, mi).getTime();
+
+describe("Codex automation schedules", () => {
+  const now = at(2026, 10, 16, 12, 0);
+  it("a one-shot (DTSTART + COUNT=1) runs at its start", () => {
+    const r = describeRrule("DTSTART:20261017T040000Z\nRRULE:FREQ=DAILY;COUNT=1", now);
+    expect(r.next).toBe(Date.UTC(2026, 9, 17, 4, 0, 0));
+    expect(r.label).toMatch(/^at /);
+  });
+  it("an interval without a start says how often, with no next time", () => {
+    expect(describeRrule("FREQ=HOURLY;INTERVAL=4", now)).toEqual({ label: "every 4h", next: null });
+    expect(describeRrule("FREQ=MINUTELY;INTERVAL=15", now).label).toBe("every 15m");
+  });
+  it("a daily clock time finds today's or tomorrow's slot", () => {
+    const r = describeRrule("FREQ=DAILY;BYHOUR=9;BYMINUTE=0;BYSECOND=0", now);
+    expect(r.label).toBe("daily at 9:00");
+    expect(r.next).toBe(at(2026, 10, 17, 9, 0));
+    expect(describeRrule("FREQ=DAILY;BYHOUR=8,18;BYMINUTE=30", now).next).toBe(at(2026, 10, 16, 18, 30));
+  });
+});
+
+describe("reminder-list headings", () => {
+  const now = at(2026, 10, 16, 12, 0);
+  it("names today, tomorrow, and later days", () => {
+    expect(dayHeading(at(2026, 10, 16, 18), now)).toBe("Today");
+    expect(dayHeading(at(2026, 10, 17, 1), now)).toBe("Tomorrow");
+    expect(dayHeading(at(2026, 10, 15, 9), now)).toBe("Due now");
+    expect(dayHeading(at(2026, 10, 20, 9), now)).not.toMatch(/Today|Tomorrow/);
+  });
+  it("labels a condition by what it waits on", () => {
+    expect(conditionLabel({ kind: "cmd", command: "squeue -j 1 | grep -q DONE" })).toEqual({ tag: "on check", detail: "squeue -j 1 | grep -q DONE" });
+    expect(conditionLabel({ kind: "file", path: "out.csv" }).tag).toBe("on file");
+  });
+});

package/hop

@@ -644,8 +644,11 @@ function rebuildViewManifest() {
                     // than a stored file: it can stop working when the server
                     // does, and `target` is the proxy itself, so a client can
                     // skip the redirect page the scan actually found.
-                    kind: m.kind === 'server' ? 'server' : 'file',
-                    target: m.kind === 'server' ? (m.target || '') : undefined,
+                    // 'link' points somewhere else entirely — a Nebula
+                    // notebook on its own server — and `app` says what opens it.
+                    kind: m.kind === 'server' ? 'server' : m.kind === 'link' ? 'link' : 'file',
+                    target: m.kind === 'server' || m.kind === 'link' ? (m.target || '') : undefined,
+                    app: m.kind === 'link' && m.app ? String(m.app) : undefined,
                     port: m.kind === 'server' ? m.port : undefined,
                     // Whether the proxied session behind a server row still
                     // EXISTS. A row whose session evaporated used to open the
@@ -1303,7 +1306,11 @@ function getEffectiveSessionConfig(name) {
             displayName: resolveDisplayNameClaim(name, durable.displayName),
             folderId: durable.folderId,
             createdBy: durable.createdBy,
-            cwd: durable.cwd
+            cwd: durable.cwd,
+            // A stopped session has nothing but this record; dropping its
+            // flags listed it as a live, unparked card that would not open.
+            ...(durable.parked !== undefined ? { parked: durable.parked } : {}),
+            ...(durable.archived !== undefined ? { archived: durable.archived } : {})
         };
     }
     const merged = { ...base };
@@ -4668,6 +4675,26 @@ function hopSessionExists(name) {
     return hayRooms.hasRoom(name) || activeSessions[name];
 }
 
+// Internal names whose durable record says Stop & park (archived). Re-read
+// only when the records directory changes — the list is polled every few
+// seconds and a directory listing plus ~100 small reads each time is waste.
+let stoppedDurableCache = { mtimeMs: -1, names: [] };
+function listStoppedDurableSessions() {
+    let st;
+    try { st = fs.statSync(CLAUDE_SESSIONS_DIR); } catch (e) { return []; }
+    if (st.mtimeMs === stoppedDurableCache.mtimeMs) return stoppedDurableCache.names;
+    const names = [];
+    let files = [];
+    try { files = fs.readdirSync(CLAUDE_SESSIONS_DIR).filter((f) => f.endsWith('.meta')); } catch (e) { /* none */ }
+    for (const f of files) {
+        const name = f.slice(0, -'.meta'.length);
+        if (!SESSION_NAME_RE.test(name)) continue;
+        if (readClaudeSessionMeta(name)?.archived === true) names.push(name);
+    }
+    stoppedDurableCache = { mtimeMs: st.mtimeMs, names };
+    return names;
+}
+
 function buildSessionEntries(haySessions, opts = {}) {
     const includeStoredTerminalSessions = opts.includeStoredTerminalSessions !== false;
     const sessionMap = new Map();
@@ -4821,6 +4848,37 @@ function buildSessionEntries(haySessions, opts = {}) {
         });
     }
 
+    // Stopped & parked sessions have no room, and their saved definition is
+    // in-memory only (no workspace file), so a daemon restart dropped them
+    // from every list — the wall's parked section, search, `hop ls` — while
+    // their durable record still says parked + archived and opening one
+    // still resumes the conversation. List them from that record.
+    if (includeStoredTerminalSessions) {
+        for (const name of listStoppedDurableSessions()) {
+            if (sessionMap.has(name)) continue;
+            const effective = getEffectiveSessionConfig(name) || {};
+            const clientSummary = getSessionClientSummary(name);
+            sessionMap.set(name, {
+                name,
+                windows: null,
+                attached: false,
+                type: 'terminal',
+                live: false,
+                displayName: effective.displayName || toDisplaySessionName(name),
+                folderId: effective.folderId || null,
+                internalName: name,
+                cwd: effective.cwd,
+                workspaceName: resolveSessionWorkspaceName(effective),
+                createdBy: effective.createdBy || 'user',
+                agentPermitted: effective.agentPermitted === true,
+                ...sessionAgentFields(name, effective),
+                localCliCount: clientSummary.localCliCount,
+                hasLocalCli: clientSummary.hasLocalCli,
+                ...getSessionSeenInfo(name)
+            });
+        }
+    }
+
     const folderIndex = new Map();
     folderIndex.set('root', -1);
     sessionStore.order.folders.forEach((id, index) => {
@@ -6022,6 +6080,73 @@ function saveCheckbacks() {
 function pendingCheckbacksFor(internalName) {
     return loadCheckbacks().items.filter((c) => c.status === 'pending' && c.session === internalName).length;
 }
+// When the soonest TIMED check-back on a session is due (ms), or null when
+// everything waiting is a condition (a job, a file, idle) with no clock time.
+function nextCheckbackAt(internalName) {
+    let next = null;
+    for (const c of loadCheckbacks().items) {
+        if (c.status !== 'pending' || c.session !== internalName) continue;
+        const t = c.trigger || {};
+        const at = t.kind === 'at' ? t.at : t.kind === 'every' ? t.next : null;
+        if (Number.isFinite(at) && (next === null || at < next)) next = at;
+    }
+    return next;
+}
+
+// Codex keeps its own scheduled jobs ("automations", ~/.codex/automations/
+// <id>/automation.toml) aimed at a THREAD. Agents in hop's Codex sessions
+// create them, so a session's schedule is incomplete without them. Read-only
+// here: Codex owns and runs them. Cached briefly; the files change rarely.
+let codexAutomationCache = { at: 0, items: [] };
+function readCodexAutomations() {
+    if (Date.now() - codexAutomationCache.at < 30_000) return codexAutomationCache.items;
+    const root = path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'automations');
+    const items = [];
+    let names = [];
+    try { names = fs.readdirSync(root); } catch (e) { /* none */ }
+    for (const name of names) {
+        let text = '';
+        try { text = fs.readFileSync(path.join(root, name, 'automation.toml'), 'utf8'); } catch (e) { continue; }
+        const field = (k) => {
+            const m = text.match(new RegExp(`^${k}\\s*=\\s*(?:"((?:[^"\\\\]|\\\\.)*)"|(\\S+))`, 'm'));
+            if (!m) return null;
+            return m[1] !== undefined ? m[1].replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\') : m[2];
+        };
+        const thread = field('target_thread_id');
+        if (!thread) continue;
+        items.push({
+            id: field('id') || name,
+            name: field('name') || name,
+            kind: field('kind') || 'automation',
+            status: field('status') || 'ACTIVE',
+            prompt: field('prompt') || '',
+            rrule: field('rrule') || '',
+            thread,
+            updatedAt: Number(field('updated_at')) || null
+        });
+    }
+    codexAutomationCache = { at: Date.now(), items };
+    return items;
+}
+// A one-shot (COUNT=1) whose start has passed. Codex leaves these ACTIVE
+// whether or not they ran — Accessibility's 10-15 follow-up never arrived in
+// its thread — so they are not "upcoming", and the card's count skips them.
+function codexAutomationPastDue(a, now = Date.now()) {
+    const rule = String(a?.rrule || '');
+    if (!/(^|[;:\n])COUNT=1(;|$|\n)/.test(rule)) return false;
+    const m = rule.match(/DTSTART:(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z?)/);
+    if (!m) return false;
+    const [, y, mo, d, h, mi, sec, z] = m;
+    const at = z ? Date.UTC(+y, +mo - 1, +d, +h, +mi, +sec) : new Date(+y, +mo - 1, +d, +h, +mi, +sec).getTime();
+    return at < now;
+}
+function codexAutomationsForSession(internalName) {
+    const turn = readTurnInfo(internalName);
+    if (!turn || turn.agent !== 'codex' || !turn.sessionId) return [];
+    // The notify hook already records the ROOT thread — the one automations
+    // target — so no rollout walk here (the wall polls this list).
+    return readCodexAutomations().filter((a) => a.thread === turn.sessionId);
+}
 // Prune delivered/cancelled records older than a day so the file stays small.
 function pruneCheckbacks(now = Date.now()) {
     const store = loadCheckbacks();
@@ -6078,7 +6203,10 @@ async function composerStillHolds(internalName, message) {
         return holds;
     } catch (e) { if (process.env.HOP_CHECKBACK_DEBUG) log(`[checkback] composer check failed: ${e?.message || e}`, DIM); return false; }
 }
-async function typeAndSubmit(entry, internalName, message) {
+// `submitKey`: Enter by default. Codex treats Enter DURING a turn as a steer —
+// it interrupts the model to inject the message — and Tab as "queue it for
+// when this turn ends"; a forced check-back typed into a busy Codex queues.
+async function typeAndSubmit(entry, internalName, message, submitKey = '\r') {
     // The attach returns before its socket is open; type only once it is,
     // or the text and the Enter leave in one burst (see adapterBundle.ready).
     const t0 = Date.now();
@@ -6091,13 +6219,13 @@ async function typeAndSubmit(entry, internalName, message) {
     // Codex folds keys that arrive within ~half a second of the text into a
     // paste, Enter included (measured: 400ms failed, 1s submitted).
     await sleepMs(1000);
-    dbg('sending Enter');
-    sendTerminalInput(entry, '\r');
+    dbg(submitKey === '\t' ? 'sending Tab (queue)' : 'sending Enter');
+    sendTerminalInput(entry, submitKey);
     for (let attempt = 0; attempt < 2; attempt++) {
         await sleepMs(1500);
         if (!(await composerStillHolds(internalName, message))) return;
-        if (process.env.HOP_CHECKBACK_DEBUG) log(`[checkback] Enter did not take (attempt ${attempt + 1}); sending it again`, DIM);
-        sendTerminalInput(entry, '\r');
+        if (process.env.HOP_CHECKBACK_DEBUG) log(`[checkback] submit did not take (attempt ${attempt + 1}); sending it again`, DIM);
+        sendTerminalInput(entry, submitKey);
     }
 }
 
@@ -6151,7 +6279,9 @@ async function runCheckbackSweep() {
                     continue;
                 }
                 const e2 = await attachTerminalApiClient(cb.session, entry.displayName || cb.session, { actor: 'system', label: 'checkback', typeOnly: true });
-                try { await typeAndSubmit(e2, cb.session, cb.message); }
+                // Forced into a Codex mid-turn: queue (Tab), never steer (Enter).
+                const queueIntoCodex = phase === 'working' && readTurnInfo(cb.session)?.agent === 'codex';
+                try { await typeAndSubmit(e2, cb.session, cb.message, queueIntoCodex ? '\t' : '\r'); }
                 finally { try { closeTerminalApiEntry(e2.id); } catch (e) { /* closed */ } }
                 Object.assign(cb, checkbacks.afterDelivery(cb, now));
                 dirty = true;
@@ -12355,6 +12485,8 @@ happens until someone clicks it.
                 ...(phaseBySession.get(s.internalName) || { agentPhase: null, turnSeen: true, turnAt: null }),
                 // Scheduled check-backs waiting on this session (hop checkback).
                 checkbacks: pendingCheckbacksFor(s.internalName) || undefined,
+                checkbackNext: nextCheckbackAt(s.internalName) || undefined,
+                codexAutomations: codexAutomationsForSession(s.internalName).filter((a) => a.status === 'ACTIVE' && !codexAutomationPastDue(a)).length || undefined,
                 lastActivityAt: s.lastActivityAt,
                 // For sessions armed with notify-on-finish, each completed turn
                 // adds to bellSeq so the phone treats a finished response like a
@@ -13616,8 +13748,12 @@ happens until someone clicks it.
         if (parsedUrl.pathname === '/api/checkbacks' && req.method === 'GET') {
             const now = Date.now();
             const items = loadCheckbacks().items.map((c) => ({ ...c, sessionName: getSessionDisplayName(c.session) || c.session, line: checkbacks.describe(c, now) }));
+            // ?session=: also the Codex automations aimed at that session's thread.
+            const forSession = typeof parsedUrl.query.session === 'string' && parsedUrl.query.session
+                ? resolveSessionInternalName(parsedUrl.query.session, parsedUrl.query.session) : null;
+            const automations = forSession ? codexAutomationsForSession(forSession) : undefined;
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ items, now }));
+            res.end(JSON.stringify({ items, now, ...(automations ? { automations } : {}) }));
             return;
         }
         if (parsedUrl.pathname === '/api/checkbacks' && req.method === 'POST') {
@@ -16836,6 +16972,7 @@ const HELP_SECTIONS = [
         `hop view <file...>        Publish HTML/PDF/image/video/markdown behind hop's auth and print the link`,
         `hop view --title "..."    Say what the result IS — clients lead with this, not the filename`,
         `hop view --name x.md -    Publish what's on stdin (no temp file needed)`,
+        `hop view --nebula <nb>    Link a notebook on a Nebula server; opens in your Nebula UI (hop config nebula <url>)`,
         `hop view --list [--all]   What this session has published (--all: the whole fleet)`,
         `hop view --rm <name>      Unpublish one`,
         `hop view --clear [--all]  Clear published copies — frees hop's space, never touches source files`,
@@ -18158,8 +18295,9 @@ async function main() {
                 } catch (e) { /* publish under the name given */ }
             }
         }
+        const nebulaUrlArg = flagValue('--nebula-url');
         const consumed = new Set(['--title', title, '--name', stdinName, '--session', wantSessionArg,
-                                  '--list', '--rm', ...removals]);
+                                  '--nebula-url', nebulaUrlArg, '--list', '--rm', ...removals]);
         const files = argv.filter((a) => !consumed.has(a) && (a === '-' || !a.startsWith('-')));
         // WHICH session a result belongs to is the whole filing system: the
         // chip that lights, the panel it appears in, the conversation it
@@ -18219,6 +18357,80 @@ async function main() {
             log(`Removed ${gone} view${gone === 1 ? '' : 's'}.`, gone ? GREEN : RESET);
             process.exit(gone ? 0 : 1);
         }
+        // A Nebula notebook is not a file to copy: it lives — and runs — on
+        // its Nebula server, often a cluster this machine reaches through a
+        // forwarded port (ssh -L 3000:…). The view is a LINK that opens the
+        // notebook in that Nebula UI, live kernel and all; the path is the
+        // one the Nebula server sees.
+        if (argv.includes('--nebula')) {
+            const base = String(nebulaUrlArg || process.env.HOP_NEBULA_URL || getHopConfig().nebula_url
+                || 'http://localhost:3000').replace(/\/+$/, '');
+            if (!/^https?:\/\/[^/\s]+$/.test(base)) {
+                log(`hop view --nebula: not a Nebula address: ${base}`, RED);
+                process.exit(2);
+            }
+            if (!files.length) {
+                log('Usage: hop view --nebula [--title "..."] [--nebula-url http://localhost:3000] <notebook path on the Nebula server>...', YELLOW);
+                log(`  Default Nebula: ${base}  (hop config nebula <url> to change it)`, DIM);
+                process.exit(1);
+            }
+            if (!session) { callerSessionOrExplain('hop view'); process.exit(2); }
+            const getJson = async (u) => {
+                try {
+                    const r = await fetch(u, { signal: AbortSignal.timeout(5000) });
+                    return { status: r.status, body: await r.json().catch(() => null) };
+                } catch (e) { return null; }
+            };
+            const health = await getJson(`${base}/api/health`);
+            const reachable = !!(health && health.status === 200 && health.body);
+            if (!reachable) {
+                log(`hop view: Nebula at ${base} is not answering — filing the link anyway; it opens once the server (or its port forward) is up.`, YELLOW);
+            }
+            const serverCwd = reachable && typeof health.body.cwd === 'string' ? health.body.cwd : null;
+            fs.mkdirSync(destDir, { recursive: true });
+            const meta = readViewMeta(session);
+            let failed = 0;
+            for (const raw of files) {
+                // Relative paths are the SERVER's relative paths: pin them to
+                // its working directory so the link means one notebook.
+                const nb = raw.startsWith('/') || !serverCwd ? raw : path.posix.join(serverCwd, raw);
+                if (reachable) {
+                    const st = await getJson(`${base}/api/fs/file-mtime?path=${encodeURIComponent(nb)}`);
+                    if (st && st.status === 404) {
+                        log(`hop view: Nebula has no notebook at ${nb}`, RED);
+                        failed += 1;
+                        continue;
+                    }
+                }
+                const target = `${base}/?file=${encodeURIComponent(nb)}`;
+                const label = path.posix.basename(nb);
+                const artifactName = `${label.replace(/[^\w.-]/g, '_')}.nebula.html`;
+                const attr = (v) => String(v).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+                // The redirect page is what older clients open; current ones
+                // read `target` from the metadata and go straight there.
+                fs.writeFileSync(path.join(destDir, artifactName), [
+                    '<!DOCTYPE html><html><head><meta charset="utf-8">',
+                    `<title>${attr(label)}</title>`,
+                    `<meta http-equiv="refresh" content="0;url=${attr(target)}">`,
+                    `</head><body>Opening <a href="${attr(target)}">${attr(label)}</a> in Nebula…</body></html>`
+                ].join(''));
+                meta[artifactName] = {
+                    ...(meta[artifactName] || {}),
+                    title: title || `${label} — Nebula notebook`,
+                    kind: 'link',
+                    app: 'nebula',
+                    target
+                };
+                console.log(`View: ${target}`);
+            }
+            writeViewMeta(session, meta);
+            rebuildViewManifest();
+            if (files.length > failed) {
+                console.log(`Filed under ${getSessionDisplayName(session) || session}.`);
+                process.stdout.write('\x07');
+            }
+            process.exit(failed ? 1 : 0);
+        }
         if (files.length === 0) {
             log('Usage: hop view [--title "what this is"] <file...>', YELLOW);
             log('       hop view --name report.md --title "..." -     (read the file from stdin)', DIM);
@@ -18416,6 +18628,29 @@ async function main() {
     // Handle `hop config` command
     if (process.argv[2] === 'config') {
         const subCmd = process.argv[3];
+        // Where `hop view --nebula` links open: the Nebula UI as THIS
+        // machine reaches it (often a port forward to a cluster server).
+        if (subCmd === 'nebula') {
+            const value = String(process.argv[4] || '').trim().replace(/\/+$/, '');
+            const cfg = getHopConfig();
+            if (value === 'reset') {
+                delete cfg.nebula_url;
+                saveHopConfig(cfg);
+                log('Nebula links open at http://localhost:3000 (the default).', GREEN);
+            } else if (value) {
+                if (!/^https?:\/\/[^/\s]+$/.test(value)) {
+                    log(`Not a Nebula address: ${value} — e.g. http://localhost:3000`, RED);
+                    process.exit(1);
+                }
+                cfg.nebula_url = value;
+                saveHopConfig(cfg);
+                log(`Nebula links open at ${value}.`, GREEN);
+            } else {
+                log(`Nebula: ${BOLD}${cfg.nebula_url || 'http://localhost:3000'}${RESET}${cfg.nebula_url ? '' : ' (default)'}`, RESET);
+                log(`Change with: ${CYAN}hop config nebula <url>${RESET}   (reset: hop config nebula reset)`, DIM);
+            }
+            process.exit(0);
+        }
         // How restored sessions answer claude's resume question.
         if (subCmd === 'resume' || subCmd === 'resume-mode') {
             const modeArg = String(process.argv[4] || '').toLowerCase();

package/package.json

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

package/skills/hop-session/SKILL.md

@@ -73,6 +73,18 @@ quotes), not dumped as raw text:
 generate_summary | hop view --name findings.md --title "What the profiler found" -
 ```
 
+A **Nebula notebook** is handed over as a link, not a copy — it lives (and
+runs) on its Nebula server, and the human opens it in their own Nebula UI
+with the kernel live. Give the path **as the Nebula server sees it** (a
+relative path is resolved against the server's working directory):
+
+```bash
+hop view --nebula --title "Fit diagnostics, run 12" /gpfs/data/lab/runs/fit.ipynb
+```
+
+The link opens at the human's Nebula address (`hop config nebula`, default
+`http://localhost:3000`); a notebook the server doesn't have is refused.
+
 Reach for this whenever the answer is long enough that reading it in a
 terminal is worse than reading it as a page: comparisons, tables of numbers,
 anything with structure. A table in the scrollback of a phone terminal is
@@ -133,6 +145,32 @@ Write the message as the prompt your future self needs — it arrives with
 no other context. Never poll in a loop or sleep to wait for a job; schedule
 a check-back and finish.
 
+**How it arrives.** hop types the message only when you are idle (between
+turns), so it lands as a normal new prompt for both Claude and Codex — you
+need not think about Enter vs Tab. A forced one (`--force`, typed even
+mid-turn) is queued into a busy Codex with Tab, never sent with Enter, which
+in Codex would interrupt the running turn to steer it; Claude queues a
+mid-turn message on its own.
+
+**Your own scheduler, or hop's?** If your agent has a built-in scheduler
+(Claude Code's `/loop` and wakeups, Codex automations), it is fine for a
+plain "remind me in 30 minutes" inside a session that will stay up. Use
+hop's when any of these matter — they are what only hop does here:
+
+- **Wait on a condition, not a clock:** a job finishing (`--when-cmd`), a
+  file appearing or changing (`--when-file`), the agent going idle.
+- **Survive restarts:** hop's schedule lives in the daemon, so it still
+  fires after the agent, the terminal or the Mac restarts — it waits until
+  the agent is back on screen, and never types into a bare shell.
+- **Reach another terminal:** schedule into a different session
+  (`--session <name>`) — hand work to another agent, Claude or Codex alike.
+- **Be visible:** the human sees every pending one on the session card and
+  can cancel it there.
+
+When one wait has several exits (done / failed / deadline), cancel the
+others once one fires (`hop checkback --cancel <id>`) — they don't cancel
+each other.
+
 ## Asking for attention — two tiers
 
 **Finished something, or pausing normally?** Ring the bell:

package/tests/terminal-api.integration.test.cjs

@@ -870,6 +870,75 @@ test('fork falls past a poisoned record cwd to the durable one', async () => {
 });
 
 
+// A Stop & parked session has no room and its saved definition lives only in
+// memory, so after a daemon restart only its durable record remains. It must
+// still be LISTED — parked and stopped — or the wall's parked section and
+// search lose it while opening it would still resume the conversation.
+test('a stopped & parked session known only from its record is listed, parked', async () => {
+  const name = 'parkedonlyrecord';
+  await fs.mkdir(path.join(hopHome, 'claude-sessions'), { recursive: true });
+  await fs.writeFile(path.join(hopHome, 'claude-sessions', `${name}.meta`), JSON.stringify({
+    internalName: name, displayName: 'lightscope-probe', cwd: tempDir, createdBy: 'user', parked: true, archived: true
+  }), { mode: 0o600 });
+  try {
+    const list = await requestJson(state.port, state.sessionSecret, 'GET', '/api/sessions');
+    const hit = list.data.sessions.find((s) => s.internalName === name);
+    assert.ok(hit, 'the stopped session is in the list');
+    assert.equal(hit.displayName, 'lightscope-probe');
+    assert.equal(hit.parked, true);
+    assert.equal(hit.archived, true);
+    assert.equal(hit.live, false);
+  } finally {
+    await fs.rm(path.join(hopHome, 'claude-sessions', `${name}.meta`), { force: true });
+  }
+});
+
+
+// `hop view --nebula`: a notebook on a Nebula server becomes a LINK that
+// opens in the Nebula UI this machine reaches. A relative path is pinned to
+// the server's working directory, and a notebook the server doesn't have is
+// refused rather than filed as a dead link.
+test('hop view --nebula files a link to the notebook on its Nebula server', async () => {
+  const { execFile } = require('node:child_process');
+  const nebula = http.createServer((req, res) => {
+    const u = new URL(req.url, 'http://x');
+    res.setHeader('Content-Type', 'application/json');
+    if (u.pathname === '/api/health') return res.end(JSON.stringify({ status: 'ok', cwd: '/srv/lab' }));
+    if (u.pathname === '/api/fs/file-mtime') {
+      if (u.searchParams.get('path') === '/srv/lab/runs/fit.ipynb') return res.end(JSON.stringify({ mtime: 1 }));
+      res.statusCode = 404; return res.end(JSON.stringify({ detail: 'File not found' }));
+    }
+    res.statusCode = 404; res.end('{}');
+  });
+  await new Promise((r) => nebula.listen(0, '127.0.0.1', r));
+  const base = `http://127.0.0.1:${nebula.address().port}`;
+  const run = (args) => new Promise((resolve) => execFile(process.execPath,
+    [path.join(__dirname, '..', 'hop'), 'view', '--session', 'nebulaprobe', ...args],
+    { env: daemonEnv, timeout: 30000 }, (err, stdout, stderr) => resolve({ code: err ? err.code : 0, out: stdout + stderr })));
+  try {
+    const ok = await run(['--nebula', '--nebula-url', base, '--title', 'Fit results', 'runs/fit.ipynb']);
+    assert.equal(ok.code, 0, ok.out);
+    const want = `${base}/?file=${encodeURIComponent('/srv/lab/runs/fit.ipynb')}`;
+    assert.ok(ok.out.includes(`View: ${want}`), ok.out);
+
+    const missing = await run(['--nebula', '--nebula-url', base, 'runs/gone.ipynb']);
+    assert.notEqual(missing.code, 0);
+    assert.match(missing.out, /no notebook at \/srv\/lab\/runs\/gone\.ipynb/);
+
+    const views = await requestJson(state.port, state.sessionSecret, 'GET', '/api/views');
+    const mine = views.data.items.filter((i) => i.session === 'nebulaprobe');
+    assert.equal(mine.length, 1, JSON.stringify(mine));
+    assert.equal(mine[0].kind, 'link');
+    assert.equal(mine[0].app, 'nebula');
+    assert.equal(mine[0].title, 'Fit results');
+    assert.equal(mine[0].target, want);
+  } finally {
+    nebula.close();
+    await fs.rm(path.join(hopHome, 'views', 'nebulaprobe'), { recursive: true, force: true });
+  }
+});
+
+
 // A view the browser cannot display (pptx, zip) is saved instead of shown.
 // Opening it must still name the file — without a Content-Disposition name
 // the browser took the URL's last segment and every download read "inline".