samagotchi 0.115.0 → 0.117.0

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.115.0"
+  VERSION = "0.117.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -236,6 +236,8 @@ module Samagotchi
         ["POST", %r{\A/api/sessions/([^/]+)/tasks/([^/]+)/stop\z}, :handle_task_stop, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/turn/([^/]+)/dequeue\z}, :handle_dequeue_turn, :participant, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/stop\z}, :handle_stop, :owner, :session],
+        ["GET", %r{\A/api/sessions/([^/]+)/holds\z}, :handle_session_holds, :owner, :session],
+        ["POST", %r{\A/api/sessions/([^/]+)/holds/stop\z}, :handle_stop_holds, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/restart\z}, :handle_restart, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/archive\z}, :handle_archive, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/unarchive\z}, :handle_unarchive, :owner, :session],
@@ -247,6 +249,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/worker\z}, :handle_worker, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/exit\z}, :handle_exit, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/recap\z}, :handle_recap, :owner, :session],
+        ["POST", %r{\A/api/sessions/([^/]+)/guardrails/wrong\z}, :handle_system_one_wrong, :owner, :session],
         ["GET", %r{\A/api/sessions/([^/]+)/stats\z}, :handle_stats, :owner, :session],
         ["GET", %r{\A/api/sessions/([^/]+)/children/counts\z}, :handle_children_counts, :owner, :session],
         ["GET", %r{\A/api/sessions/([^/]+)/turns/([^/]+)/records\z}, :handle_turn_records, :owner, :session],

data/lib/samagotchi/web/public/activity.js

@@ -144,6 +144,16 @@ export function addCompleted(model, event = {}, now = null) {
   Object.assign(row, pickFields(event.activity, ACTIVITY_FIELDS));
   // A grep that found nothing (status ok): the row says "no match".
   if (event.activity?.no_match) row.no_match = true;
+  // System 1 allowed the call once instead of asking (the row's label); any
+  // other guardrail verdict draws nothing.
+  const guardrail = event.activity?.guardrail;
+  if (guardrail?.decided_by === "system one") {
+    row.guardrail = {
+      rule: guardrail.rule,
+      p: guardrail.p,
+      ...(guardrail.judgment_id ? { judgment_id: guardrail.judgment_id } : {}),
+    };
+  }
   // The images the tool returned (a reload in the turn view draws them from
   // the saved parts, turn_html.js toolRowTemplate).
   if (event.images?.length) row.images = event.images;

data/lib/samagotchi/web/public/app.js

@@ -4,6 +4,8 @@ import {
   sendTurn,
   cancelTurn,
   stopSession,
+  sessionHolds,
+  stopSessionHolds,
   restartSession,
   deleteSession,
   archiveSession,
@@ -50,6 +52,7 @@ import { createGapClock, lastActivity } from "./time_gaps.js";
 import { createMarkdownPlace } from "./markdown_place.js";
 import { openerFill, openTitle, restoredComposer } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
+import { createSystemOneWrongAction } from "./system_one_wrong.js";
 import { appendQuote } from "./annotations.js";
 import { applyComposerText, applyRowTemplate, fetchApply } from "./review_apply.js";
 import { authorBadge, nameUnnamedBadges } from "./participant_names.js";
@@ -97,6 +100,7 @@ import { createToasts } from "./toasts.js";
 import { createUnqueue } from "./unqueue.js";
 import { createStartPage } from "./start_page.js";
 import { createSessionActions } from "./session_actions.js";
+import { createStopSheet } from "./stop_sheet.js";
 import { createRename } from "./session_rename.js";
 import { createSendTurn } from "./send_turn.js";
 import { createMarkdownTip } from "./markdown_tip.js";
@@ -299,6 +303,8 @@ const { placeToast } = createDockReserve({
 function turnRoots() {
   return turnDom.root ? [historyEl, turnDom.root] : [historyEl];
 }
+const systemOneWrongAction = createSystemOneWrongAction({ sessionId: () => selected });
+turnRoots().forEach((root) => root.addEventListener("click", systemOneWrongAction));
 function findInTurnRoots(selector) {
   return turnRoots().flatMap((root) => [...root.querySelectorAll(selector)]);
 }
@@ -562,12 +568,21 @@ const lists = createListsView({
 
 // Continue, Archive, Delete and Stop, and the start page when the open
 // session is gone (session_actions.js).
+// The Stop sheet first (stop_sheet.js): its buttons are the two ways to stop,
+// and the sheet is only shown when the worker has something the user can stop.
+const stopSheet = createStopSheet({
+  doc: document, win: window,
+  stopAll: (id) => sessionActions.stopSelected(id, { stopHolds: true }),
+  stopSession: (id) => sessionActions.stopSelected(id),
+});
+
 const sessionActions = createSessionActions({
   selected: () => selected,
   state: () => current,
   sessions: () => allSessions,
   setSessions: (list) => { allSessions = list; },
-  api: { continueSession, startReview, archiveSession, unarchiveSession, deleteSession, stopSession },
+  api: { continueSession, startReview, archiveSession, unarchiveSession, deleteSession, stopSession,
+         sessionHolds, stopSessionHolds },
   eventsLive: () => !!eventsControl,
   refresh,
   lists,
@@ -581,6 +596,7 @@ const sessionActions = createSessionActions({
   restoreDraft,
   closeLiveStream: () => streamControl?.close(),
   workerGone,
+  stopSheet,
 });
 // The title's ✎: /title through the chips' path (session_rename.js), the
 // input over the title row on screen: the top bar's when it shows the
@@ -1656,6 +1672,9 @@ attachInput.addEventListener("change", () => {
   attachInput.value = "";
 });
 // ── Composer height: grows with the text; the top-edge grip sets a floor ───
+// The floor is saved as it was set; fitPrompt holds it to half the window it is
+// drawn in (composer_size.js), so a floor saved in a bigger window fits this one
+// and comes back when the window is big again.
 let promptFloor = Number(readStored(GRIP_KEY)) || null;
 
 // The empty box: one line in a session, three on the start page.

data/lib/samagotchi/web/public/composer_fold.js

@@ -14,17 +14,17 @@ export function composerFolded({ saved, archivedVisit, visitOpen }) {
   return !!saved || !!archivedVisit;
 }
 
-// The composer's grip while it is the fold's handle. Expanded it only says
-// how to resize and hide; folded it is drawn as the handle on the info
-// bar's top edge, pulled up or clicked to open, and marked: `draft` (the
-// box holds text or images: folding never clears them: the accent),
-// `waiting` (the attention colour: the session waits on the user, and its
-// card may not take the focus while a draft is there). The title carries
-// the words.
+// The composer's grip while it is the fold's handle. Expanded it says how to
+// resize it and that a click hides it (a double-click resets the height);
+// folded it is drawn as the handle on the info bar's top edge, pulled up or
+// clicked to open, and marked: `draft` (the box holds text or images: folding
+// never clears them: the accent), `waiting` (the attention colour: the session
+// waits on the user, and its card may not take the focus while a draft is
+// there). The title carries the words.
 // @return {title, folded, draft, waiting}
 export function foldHandle({ folded, draft, waiting }) {
   if (!folded) {
-    return { title: "Drag to make the message box taller, down to hide it (double-click resets)", folded: false, draft: false, waiting: false };
+    return { title: "Drag to resize, click to hide (double-click resets)", folded: false, draft: false, waiting: false };
   }
   const marked = !!draft;
   let title = "Pull up or click to write";

data/lib/samagotchi/web/public/composer_grip.js

@@ -1,9 +1,9 @@
-import { GRIP_OPEN_PX, gripFloor, gripFolds } from "./composer_size.js";
+import { GRIP_CLICK_FOLD_MS, GRIP_OPEN_PX, gripFloor, gripFolds, gripGesture } from "./composer_size.js";
 import { COMPOSER_FOLD_KEY, composerFolded, foldHandle, opensOnKey } from "./composer_fold.js";
 import { readStored, removeStored, writeStored } from "./storage.js";
 
-// The composer's grip and fold (used by app.js): the grip's drag, tap and keys, the
-// fold's state per visit and its page-wide listeners. app.js keeps the box's
+// The composer's grip and fold (used by app.js): the grip's drag, click and keys,
+// the fold's state per visit and its page-wide listeners. app.js keeps the box's
 // height (fitPrompt) and the grip's floor (+floor+ / +setFloor+), which
 // fitPrompt reads; the floor is saved under GRIP_KEY.
 export const GRIP_KEY = "chi_composer_floor";
@@ -24,22 +24,44 @@ export function createComposerGrip({
   // past the fold threshold.
   const gripStartTitle = composeGrip.title;
   let gripWillFold = false;
+  // A click on the expanded grip folds GRIP_CLICK_FOLD_MS after it, so a
+  // second click in that window can still mean "reset the height" (a
+  // double-click). A drag or a key acts at once and takes the wait back.
+  let pendingFold = null;
   // This visit's state (a visit is one select() call): opened by the page
   // (a focus, a restored line), archived (decided once, from the visit's
   // first getSession answer).
   const newFoldVisit = () => ({ open: false, archived: false, decided: false });
   let foldVisit = newFoldVisit();
 
-  // A drag down past the box folds the composer on release (a session only: the
-  // start page's grip only resizes); from folded, a pull up opens it and the box
-  // follows the pointer in the same gesture, a tap opens it and focuses the box.
-  // No click listener: a click still fires after pointerdown's preventDefault
-  // and would toggle twice.
+  function cancelPendingFold() {
+    if (!pendingFold) return;
+    clearTimeout(pendingFold);
+    pendingFold = null;
+  }
+
+  // The grip's custom height, forgotten only by a double-click.
+  function resetFloor() {
+    setFloor(null);
+    removeStored(GRIP_KEY);
+    fitPrompt();
+  }
+
+  // One release of the grip is one gesture, decided by composer_size.js's
+  // gripGesture: a drag down past the box folds the composer on release (a
+  // session only: the start page's grip only resizes); from folded, a pull up
+  // opens it and the box follows the pointer in the same gesture, a tap opens it
+  // and focuses the box; a click on the expanded grip folds it too, GRIP_CLICK_FOLD_MS
+  // after the release so a second click in that window can still reset the height.
+  // No click listener: a click still fires after pointerdown's preventDefault,
+  // so the release is the one that acts.
   composeGrip.addEventListener("pointerdown", (e) => {
     e.preventDefault();
     composeGrip.setPointerCapture(e.pointerId);
     composeGrip.classList.add("dragging");
     const tapY = e.clientY;
+    // The height the box had before this press: a drag that folds brings it back.
+    const floorBefore = floor();
     let startY = tapY;
     let startH = promptEl.offsetHeight;
     let opened = false;
@@ -76,17 +98,35 @@ export function createComposerGrip({
     };
     const up = (ev) => {
       const folds = end();
-      if (folds) {
-        // The next opening starts at the minimum (or the text's height).
-        setFloor(null);
-        removeStored(GRIP_KEY);
+      const gesture = gripGesture({
+        session: !!session(),
+        folded: isComposerFolded(),
+        dy: ev.clientY - tapY,
+        willFold: folds,
+        pending: !!pendingFold,
+      });
+      if (gesture === "fold") {
+        cancelPendingFold();
+        // The drag asked for a smaller box, but opening it brings back the
+        // height it had before the press: only a double-click forgets it.
+        setFloor(floorBefore);
+        writeStored(GRIP_KEY, String(floorBefore || ""));
         setComposerFolded(true);
-      } else if (session() && isComposerFolded()) {
-        if (Math.abs(ev.clientY - tapY) < GRIP_OPEN_PX) {
-          setComposerFolded(false);
-          promptEl.focus();
-        }
-      } else {
+      } else if (gesture === "open") {
+        cancelPendingFold();
+        setComposerFolded(false);
+        promptEl.focus();
+      } else if (gesture === "reset") {
+        resetFloor();
+      } else if (gesture === "hide") {
+        writeStored(GRIP_KEY, String(floor() || ""));
+        pendingFold = setTimeout(() => {
+          pendingFold = null;
+          setComposerFolded(true);
+        }, GRIP_CLICK_FOLD_MS);
+      } else if (gesture === "resize") {
+        // A drag that stops short of folding: keep the box at the height it asks for.
+        cancelPendingFold();
         writeStored(GRIP_KEY, String(floor() || ""));
         // A pull that opened the box leaves the focus in it, as a tap does.
         if (opened) promptEl.focus();
@@ -103,15 +143,16 @@ export function createComposerGrip({
   });
   composeGrip.addEventListener("dblclick", () => {
     if (session() && isComposerFolded()) return;
-    setFloor(null);
-    removeStored(GRIP_KEY);
-    fitPrompt();
+    cancelPendingFold();
+    resetFloor();
   });
   // Enter or Space on the focused handle folds, or opens and focuses the box
-  // (a session only; preventDefault: Space would scroll the page).
+  // (a session only; preventDefault: Space would scroll the page). At once:
+  // the keyboard has no double-click to wait for.
   composeGrip.addEventListener("keydown", (e) => {
     if (!session() || (e.key !== "Enter" && e.key !== " ")) return;
     e.preventDefault();
+    cancelPendingFold();
     if (isComposerFolded()) {
       setComposerFolded(false);
       promptEl.focus();
@@ -135,6 +176,8 @@ export function createComposerGrip({
   }
   function applyComposerFolded() {
     const folded = isComposerFolded();
+    // Anything else opened the composer: the click's wait for its fold is over.
+    if (!folded) cancelPendingFold();
     const was = doc.body.classList.contains("composer-folded");
     doc.body.classList.toggle("composer-folded", folded);
     // Its height was measured while hidden.

data/lib/samagotchi/web/public/composer_size.js

@@ -1,24 +1,36 @@
-// The composer's height. It grows with its text up to a cap; the grip on
-// its top edge sets a taller floor (the cap then is at least that floor).
+// The composer's height and the gestures of the grip on its top edge. The
+// height grows with the text up to a cap; the grip sets a taller floor (the
+// cap then is at least that floor), and no floor — saved in another window or
+// dragged here — takes more than half of the window the box is shown in. A
+// release of the grip is one gesture: a drag that resizes, a drag far enough
+// down that folds the box away, or a click (which, expanded, folds too — after
+// a delay, so a double-click can still reset the height).
 export const PROMPT_MIN_PX = 72; // about three lines of the 15 px field: the start page
 export const PROMPT_LINE_PX = 26; // one line (15 px × 1.45 + 4 padding): in a session
 const PROMPT_CAP_SHARE = 0.35; // of the window's height, for growing with text
 const PROMPT_GRIP_SHARE = 0.5; // of the window's height, for the grip
 export const GRIP_FOLD_PX = 32; // a drag down this far past what the box shows folds the composer (on release)
 export const GRIP_OPEN_PX = 8; // a drag up this far from the folded handle opens it; less is a tap
+export const GRIP_CLICK_FOLD_MS = 250; // how long a click on the expanded grip waits before folding, so a second click in that window can still mean a reset
 
 // contentPx: the text's height (scrollHeight plus borders); floorPx: the
 // grip's height, or null; minPx: the empty box's height.
 export function promptHeight({ contentPx, floorPx = null, viewportPx, minPx = PROMPT_MIN_PX }) {
-  const floor = Math.max(minPx, floorPx || 0);
+  // The floor, as THIS window can hold it: a floor saved in a bigger window
+  // (a rotated phone, a resized window, another device on the same origin) is
+  // held down to the share a drag may set here, and comes back whole when the
+  // window is big again — only the height shown shrinks, never the saved floor.
+  const floor = gripFloor(floorPx, viewportPx, minPx);
   const cap = Math.max(floor, Math.round(viewportPx * PROMPT_CAP_SHARE));
   return { height: Math.min(Math.max(contentPx, floor), cap), scrolls: contentPx > cap };
 }
 
 // A grip drag: the floor it asks for, kept between the minimum and the
-// grip's share of the window.
+// grip's share of the window. The same rule fits a floor saved earlier (see
+// promptHeight), so the box never takes more of a window than a drag in it
+// could have given it.
 export function gripFloor(px, viewportPx, minPx = PROMPT_MIN_PX) {
-  return Math.round(Math.min(Math.max(px, minPx), viewportPx * PROMPT_GRIP_SHARE));
+  return Math.max(minPx, Math.min(px || 0, Math.round(viewportPx * PROMPT_GRIP_SHARE)));
 }
 
 // Whether a grip drag asks to fold the composer: it wants the box at least
@@ -28,3 +40,26 @@ export function gripFloor(px, viewportPx, minPx = PROMPT_MIN_PX) {
 export function gripFolds({ requestedPx, shownPx }) {
   return shownPx - requestedPx >= GRIP_FOLD_PX;
 }
+
+// What a grip release asks for, decided from the press alone (the strip's
+// grip's twin, strip.js's stripGripAction). +session+: is there a session (the
+// start page's grip only resizes). +folded+: the composer is folded now.
+// +dy+: the release y minus the press y, down positive. +willFold+: the drag is
+// past GRIP_FOLD_PX below what the box shows. +pending+: an earlier click's fold
+// is still waiting its GRIP_CLICK_FOLD_MS, so this release is the second click.
+//   fold   – hide the box now
+//   open   – a tap on the folded handle
+//   hide   – the first click on the expanded grip: fold it after the delay
+//   reset  – the second click in that delay: a double-click, so the height is reset
+//   resize – a drag that stops short: keep the box and save the floor it asks for
+//   none   – a drag down on the folded handle (pulling up opens it while dragging)
+export function gripGesture({ session, folded, dy, willFold, pending }) {
+  if (willFold) return "fold";
+  const tap = Math.abs(dy) < GRIP_OPEN_PX;
+  if (tap) {
+    if (folded) return "open";
+    if (!session) return "resize";
+    return pending ? "reset" : "hide";
+  }
+  return folded ? "none" : "resize";
+}

data/lib/samagotchi/web/public/data.js

@@ -180,10 +180,34 @@ export function dismissQuestion(id, questionId, opts = {}) {
   });
 }
 
+// Flags a System 1 auto-allow in this session as one it should have asked
+// about; the owner-only route returns 404 for an unknown judgment.
+export function markSystemOneWrong(id, judgmentId, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/guardrails/wrong`, {
+    method: "POST",
+    body: JSON.stringify({ id: judgmentId }),
+    ...opts,
+  });
+}
+
 export function stopSession(id, opts = {}) {
   return api(`/api/sessions/${id}/stop`, { method: "POST", body: JSON.stringify({}), ...opts });
 }
 
+// What this session's worker still has that the user can stop (reminders, a
+// background task running, a delegate with a live worker), for the Stop
+// button's sheet: 200 {holds: []} always — no worker, or one that can't say,
+// is an empty list, so Stop stays one tap.
+export function sessionHolds(id, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/holds`, { ...opts });
+}
+
+// The sheet's "Stop all": the worker stops everything the user can before the
+// Stop TERMs it. 200 {status: "stopped", stopped: {reminders, tasks, delegates}}.
+export function stopSessionHolds(id, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/holds/stop`, { method: "POST", body: JSON.stringify({}), ...opts });
+}
+
 // Kills a background task the session's conversation started (the
 // stop-task button): 200 {status, stop_reason}; 409 it already ended, 503
 // no live worker.

data/lib/samagotchi/web/public/favicon.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#7aa5ff"/><stop offset="1" stop-color="#8957e5"/></linearGradient></defs><rect x="1" y="1" width="30" height="30" rx="7.5" fill="url(#g)"/><g fill="none" stroke="#fff" stroke-width="3.2" stroke-linecap="round" stroke-linejoin="round"><path d="M7.8 9.6c2.3-1.3 4-.7 5.2 1.4l6 10.1c1.2 2.1 2.9 2.7 5.2 1.4"/><path d="M22.6 9.2 9.4 22.8"/></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#1f6feb"/><stop offset="1" stop-color="#6e40c9"/></linearGradient></defs><rect x="1" y="1" width="30" height="30" rx="7.5" fill="url(#g)"/><g fill="none" stroke="#fff" stroke-width="3.2" stroke-linecap="round" stroke-linejoin="round"><path d="M7.8 9.6c2.3-1.3 4-.7 5.2 1.4l6 10.1c1.2 2.1 2.9 2.7 5.2 1.4"/><path d="M22.6 9.2 9.4 22.8"/></g></svg>

data/lib/samagotchi/web/public/index.html

@@ -184,6 +184,11 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .ts-now button.task-stop{align-self:center}
 .activity-params{color:var(--text-muted);overflow-wrap:anywhere}
 .activity-alias{color:var(--text-faint);white-space:nowrap}
+.activity-auto{color:var(--accent);font-size:11px;white-space:nowrap;cursor:help}
+button.system-one-wrong,.system-one-wrong.marked{flex:none;padding:1px 6px;border:1px solid var(--border-strong);border-radius:6px;background:transparent;color:var(--text-muted);font-size:10px;line-height:16px;white-space:nowrap}
+button.system-one-wrong:hover:not(:disabled){background:var(--bg-hover);color:var(--text)}
+.system-one-wrong.marked{border-color:var(--accent-border);color:var(--text-3)}
+.activity-row.guardrail-wrong .activity-auto{color:var(--text-muted)}
 .activity-duration{color:var(--text-faint);font-size:11px;font-variant-numeric:tabular-nums;white-space:nowrap}
 .activity-output{margin:4px 0 2px var(--row-gutter);font-size:12px;color:var(--text-muted);white-space:pre-wrap;word-break:break-word;background:var(--bg);border-radius:6px;padding:6px 8px;max-height:160px;overflow:auto}
 .activity-output.tail{display:flex;flex-direction:column-reverse}
@@ -1221,6 +1226,22 @@ body.has-session.composer-folded #infoBar{border-top-color:transparent}
 .push-devices.sheet .pd-done{font-size:13px}
 .push-devices.sheet .pd-meta,.push-devices.sheet .pd-note{font-size:12.5px}
 .push-devices.sheet .pd-remove{padding:6px 12px;font-size:13px}
+/* The Stop button's sheet (stop_sheet.js): what still runs, and the three answers; a bottom sheet on a phone. */
+.stop-sheet .ctx-pop-head strong{font-family:inherit}
+.stop-sheet.sheet{border-radius:14px;padding:14px 16px;font-size:14px}
+.ss-lines{list-style:none;display:flex;flex-direction:column;gap:6px;margin:4px 0 10px;padding:0}
+.ss-line{display:flex;flex-wrap:wrap;align-items:baseline;gap:3px 8px;padding:8px 10px;border-radius:10px;background:var(--bg-inset)}
+.ss-line b{color:var(--text-bright)}
+.ss-items{flex-basis:100%;color:var(--text-2)}
+.ss-note,.ss-more{font-size:11.5px;color:var(--text-muted)}
+.ss-acts{display:flex;gap:8px;flex-wrap:wrap}
+.ss-acts button{padding:8px 12px;border-radius:8px;font-size:13px;cursor:pointer;border:1px solid var(--border-strong);background:var(--bg-raised);color:var(--text-2)}
+.ss-acts button:hover{background:var(--bg-hover);color:var(--text-hover)}
+.ss-stop-all{background:var(--warn-bg);border-color:var(--warn-border);color:var(--warn-text)}
+.ss-stop-all:hover{background:var(--warn-border);color:var(--text-hover)}
+.ss-cancel{background:transparent}
+.stop-sheet.sheet .ss-acts button{flex:1 1 auto;font-size:14px;padding:10px 12px}
+.ss-foot{font-size:11.5px;color:var(--text-muted);margin-top:6px}
 .ctx-pop-head{display:flex;align-items:baseline;gap:8px}
 .ctx-pop-head strong{font-family:ui-monospace,monospace;color:var(--text-bright)}
 .ctx-pop-kind{font-size:11px;color:var(--text-muted)}

data/lib/samagotchi/web/public/session_actions.js

@@ -10,7 +10,8 @@ import { inTree } from "./sessions_list.js";
 // Hooks: +selected()+ the open session's id or null; +state()+ its fields
 // (session_state.js); +sessions()+ / +setSessions(list)+ the page's list;
 // +api+: {continueSession, startReview, archiveSession, unarchiveSession,
-// deleteSession, stopSession} (data.js); +eventsLive()+ the hub's stream is open (else
+// deleteSession, stopSession, sessionHolds, stopSessionHolds} (data.js);
+// +eventsLive()+ the hub's stream is open (else
 // +refresh()+ fetches the list); +lists+ (lists_view.js: render);
 // +select(id)+, +clearSelection()+, +showNotice(text)+, +updateInfoBar()+,
 // +toast(text, action, options)+, +addCreatedSession(created)+,
@@ -30,6 +31,10 @@ export function createSessionActions({
   selected, state, sessions, setSessions, api, eventsLive, refresh, lists,
   select, clearSelection, showNotice, updateInfoBar, toast, addCreatedSession, fillOpener, restoreDraft, closeLiveStream, workerGone,
   alert = (text) => globalThis.alert(text), confirm = (text) => globalThis.confirm(text),
+  // The Stop sheet (stop_sheet.js): +open(id, holds)+ shows it and answers
+  // true; nothing to stop (or no sheet wired) is false, and Stop is the
+  // confirm.
+  stopSheet = { open: () => false },
 }) {
   // The session this tab is stopping: its stream may close before the stop
   // request returns (workerGone reads it).
@@ -64,11 +69,39 @@ export function createSessionActions({
     showNotice(goneSessionNotice(id, why));
   }
 
-  // The info bar's Stop: the open session's worker, after a confirm.
-  async function stopSelected() {
-    if (!selected()) return;
-    if (!confirm(`Stop session ${selected()}?`)) return;
-    const id = selected();
+  // The info bar's Stop: the open session's worker. It first asks the worker
+  // what still runs that the user can stop (GET …/holds); when there is
+  // something, the sheet (stop_sheet.js) asks what to do with it; when there
+  // is nothing, or no worker to ask, it is today's confirm and one tap.
+  // +stopHolds+ is the sheet's "Stop all": the worker's stop-all step, then
+  // the stop. A delegate or a background task outlives the worker either way
+  // (docs/sessions.md, "Stopping a worker"), which is why the sheet says so.
+  async function stopSelected(id = selected(), { stopHolds = false } = {}) {
+    if (!id) return;
+
+    if (!stopHolds) {
+      let holds = [];
+      try {
+        const answer = await api.sessionHolds(id);
+        holds = answer?.holds || [];
+      } catch {
+        holds = []; // a worker that can't say, or none: stop as before
+      }
+      if (stopSheet.open(id, holds)) return;
+      if (!confirm(`Stop session ${id}?`)) return;
+    }
+
+    // Stop all: the worker stops what it can first. A failure is said and
+    // doesn't hold the stop: the session goes either way, and the sheet's
+    // other button is exactly that.
+    if (stopHolds) {
+      try {
+        await api.stopSessionHolds(id);
+      } catch (e) {
+        toast(`${cantText("stop what the session runs", e)} — stopping the session anyway`, null, { sticky: true });
+      }
+    }
+
     stoppingId = id;
     try {
       await api.stopSession(id);

data/lib/samagotchi/web/public/stop_sheet.js

@@ -0,0 +1,126 @@
+// The Stop button's sheet (session_actions.js asks the worker first): when
+// the session's worker still has things the user can stop — reminders, a
+// background task that runs, a delegate with a live worker — Stop asks what
+// to do with them before TERMed-ing the worker. Nothing to stop, or no worker
+// to ask, is today's one tap.
+//
+// "Stop all" runs the worker's stop-all step (POST …/holds/stop, the same
+// HoldStop#stop_all the terminal's /exit ask uses) and then today's Stop;
+// "Stop session only" is today's Stop exactly, so what survives keeps running
+// (docs/sessions.md, "Stopping a worker"). Reminders are listed with a note:
+// they live only in the worker, so they end with the session either way.
+//
+// A phone gets it as a bottom sheet, a wider window as a popover at the Stop
+// button (chip_popover.js). Pure model and template plus createStopSheet, so
+// the specs run them under node --test.
+
+import { html, nothing, render } from "./vendor/lit-html.js";
+import { createChipPopover } from "./chip_popover.js";
+
+// At most this many of a kind named in the sheet; the rest are one "+N more".
+export const MAX_NAMED = 3;
+
+// The Stop button the sheet opens at.
+export const STOP_ANCHOR = "#infoStopBtn";
+
+const KIND_WORDS = {
+  reminders: ["reminder", "reminders"],
+  background_tasks: ["background task", "background tasks"],
+  delegates: ["delegate", "delegates"],
+};
+
+// One entry of a hold as the sheet writes it: the command, the reminder's
+// name with its schedule, a delegate's short id and its title. A long command
+// is cut short: the sheet must fit a phone without scrolling.
+function itemWords(item, kind) {
+  const label = String(item?.label ?? item?.id ?? "").trim();
+  const detail = String(item?.detail ?? "").trim();
+  const cut = label.length > 42 ? `${label.slice(0, 42)}…` : label;
+  if (kind === "delegates") {
+    const id = String(item?.id ?? "").slice(0, 8);
+    return `${id} "${cut || "untitled"}"${detail ? ` ${detail}` : ""}`;
+  }
+  const name = cut || String(item?.id ?? "").slice(0, 8);
+  return detail ? `${name} (${detail})` : name;
+}
+
+// What the sheet says from the worker's holds (GET …/holds): null when there
+// is nothing to ask about (no sheet: Stop stays one tap), else its lines, one
+// per kind, and the total.
+// @return {lines: [{kind, count, word, items, more, note}], total} | null
+export function stopSheetModel(holds) {
+  const lines = [];
+  for (const hold of Array.isArray(holds) ? holds : []) {
+    const kind = String(hold?.kind ?? "");
+    const items = Array.isArray(hold?.items) ? hold.items : [];
+    if (!items.length) continue;
+
+    const [singular, plural] = KIND_WORDS[kind] ?? [kind || "hold", `${kind || "holds"}s`];
+    lines.push({
+      kind,
+      count: items.length,
+      word: items.length === 1 ? singular : plural,
+      items: items.slice(0, MAX_NAMED).map((item) => itemWords(item, kind)),
+      more: Math.max(0, items.length - MAX_NAMED),
+      note: kind === "reminders" ? "they end with the session" : "",
+    });
+  }
+  if (!lines.length) return null;
+
+  return { lines, total: lines.reduce((sum, line) => sum + line.count, 0) };
+}
+
+function lineTemplate(line) {
+  return html`<li class="ss-line" data-kind=${line.kind}>
+    <b>${line.count} ${line.word}</b>
+    ${line.note ? html` <span class="ss-note">(${line.note})</span>` : nothing}
+    ${line.items.length ? html` <span class="ss-items">${line.items.join(" · ")}${line.more ? html` <span class="ss-more">+${line.more} more</span>` : nothing}</span>` : nothing}
+  </li>`;
+}
+
+// The sheet's content (a lit-html template).
+export function stopSheetTemplate(model) {
+  const things = model.total === 1 ? "1 thing" : `${model.total} things`;
+  return html`<div class="ctx-pop-head"><strong>This session still has</strong
+    ><span class="ctx-pop-kind">${things}</span
+    ><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div
+    ><ul class="ss-lines">${model.lines.map(lineTemplate)}</ul
+    ><div class="ss-acts"><button type="button" class="ss-stop-all" data-act="all">Stop all</button
+      ><button type="button" class="ss-stop-only" data-act="session">Stop session only</button
+      ><button type="button" class="ss-cancel" data-act="cancel">Cancel</button></div
+    ><div class="ss-foot">Stopping the session ends its worker; a background task or a delegate runs on its own, so it stays.</div>`;
+}
+
+// The sheet at the Stop button. +stopAll(id)+ stops what the worker can and
+// then the session; +stopSession(id)+ is today's Stop; +open(id, holds)+ shows
+// it only when there is something (false otherwise, so the caller can fall
+// back to the plain confirm). @return {open, close, isOpen, pop}
+export function createStopSheet({ doc = globalThis.document, win = globalThis.window,
+                                  anchor = STOP_ANCHOR, el = doc.createElement("span"),
+                                  stopAll = () => {}, stopSession = () => {} }) {
+  let model = null;
+  let forId = null;
+
+  const shell = createChipPopover({
+    id: "stopSheet", className: "ctx-popover stop-sheet", width: 400, el, anchor, openers: anchor,
+    summary: () => model, sheet: true, label: "Stop the session?", doc, win,
+    show: (data) => render(stopSheetTemplate(data), shell.pop),
+    onClose: () => { model = null; forId = null; },
+    onAct: (act) => {
+      const id = forId;
+      if (act === "all") { shell.close(); stopAll(id); }
+      else if (act === "session") { shell.close(); stopSession(id); }
+      else if (act === "cancel") shell.close();
+    },
+  });
+
+  function open(id, holds) {
+    model = stopSheetModel(holds);
+    if (!model) return false;
+    forId = id;
+    shell.open(doc.querySelector(anchor) ?? el);
+    return true;
+  }
+
+  return { open, close: () => shell.close(), isOpen: shell.isOpen, pop: shell.pop };
+}