samagotchi 0.116.0 → 0.117.0

data/lib/samagotchi/task_watch.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 require_relative "config"
 require_relative "log"
 require_relative "tools/task_runtime"
@@ -182,19 +184,35 @@ module Samagotchi
     # @return [Array<Entry>]
     def holding = entries.reject { |entry| entry.note_only || entry.failures >= MAX_FAILURES }
 
-    # The #holding tasks still running ({id:, command:}), for /exit
-    # (WorkerIdleExit's watched_running): one finished meanwhile is noted
-    # as the worker leaves. One `ps` per task.
-    # @return [Array<Hash>]
+    # A watched task still running, as /exit and the exit ask see it:
+    # +age_seconds+, the seconds since it started (nil when its record has
+    # no start time).
+    Running = Data.define(:id, :command, :age_seconds)
+
+    # The #holding tasks still running, for /exit (WorkerIdleExit's
+    # watched_running): one finished meanwhile is noted as the worker leaves.
+    # One `ps` per task.
+    # @return [Array<Running>]
     def running
       holding.filter_map do |entry|
         record, = Tools::TaskRuntime.get_record(entry.id)
-        { id: entry.id, command: record.command.to_s } if record&.running?
+        next unless record&.running?
+
+        Running.new(id: entry.id, command: record.command.to_s, age_seconds: age_seconds(record))
       end
     end
 
     private
 
+    # Seconds since the task started, from its record's iso8601 +started_at+;
+    # nil when that can't be read.
+    def age_seconds(record)
+      started = Time.parse(record.started_at.to_s)
+      [(Time.now - started).round, 0].max
+    rescue ArgumentError, TypeError
+      nil
+    end
+
     # Removes +entry+; nil (a filter_map's skip), or with +kept+ whether it
     # was there. +log+: why a task leaves without a note, at +level+ (debug
     # by default), with +error+ when there is one.

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -57,17 +57,35 @@ module Samagotchi
       # An exit the worker agreed to in an empty session. Said before it has
       # left: it checks again once it lets go, and a note or prompt arriving
       # first keeps the session (SessionManager.discard_left_session).
-      EMPTY_EXIT = "Detached; the session is empty: it will be discarded if nothing arrives before its worker stops."
+      EMPTY_WORDS = "the session is empty: it will be discarded if nothing arrives before its worker stops."
+      EMPTY_EXIT = "Detached; #{EMPTY_WORDS}"
       # Why the worker stayed up after /exit, by the reason it gave.
       HELD_REASONS = {
         "turn_running" => "a turn is running", "input_queued" => "prompts are queued",
         "continue_offered" => "a continue offer is pending", "client_connected" => "another UI is attached",
         "reminders" => "reminders are set", "starting" => "the worker is still starting",
-        "background_tasks" => "background tasks it started are still running"
+        "background_tasks" => "background tasks it started are still running",
+        "delegates" => "delegates of this session are still running"
       }.freeze
       # How to end a background task that holds the worker up (an older
       # worker's 409 has no hint of its own).
       TASK_STOP_HINT = "stop one with the web's stop-task button or by asking for task_stop"
+      # The /exit ask, when every hold is one the user can stop: what still
+      # runs, then the three answers. Each kind, singular and plural.
+      EXIT_HOLD_WORDS = {
+        "reminders" => %w[reminder reminders],
+        "background_tasks" => ["background task", "background tasks"],
+        "delegates" => %w[delegate delegates]
+      }.freeze
+      # The 200's +stopped+ keys, by the kind the ask lists them under.
+      STOPPED_KEYS = { "reminders" => "reminders", "tasks" => "background_tasks", "delegates" => "delegates" }.freeze
+      EXIT_ASK_OPTIONS = ["Keep running in the background (detach)", "Stop them and exit", "Back to the session"].freeze
+      # How the ask reads an answer.
+      EXIT_ANSWERS = {
+        "1" => :keep, "keep" => :keep, "detach" => :keep, "background" => :keep,
+        "2" => :stop, "stop" => :stop, "exit" => :stop,
+        "3" => :back, "back" => :back, "stay" => :back
+      }.freeze
       # How much of the last answer a join shows.
       JOIN_ANSWER_LINES = 12
       JOIN_ANSWER_CHARS = 1200
@@ -175,6 +193,8 @@ module Samagotchi
         @own_failed = false
         # A continue offer is pending: the prompt asks for the answer.
         @continue_offer = nil
+        # The /exit ask is open: the next line is its answer (#answer_exit_ask).
+        @exit_ask = nil
         # The status row: the worker's model, ctx, the session's memories.
         @status = StatusRow.new(screen)
         # Participants' names by author ("p:<id>"), from the join's state
@@ -470,6 +490,14 @@ module Samagotchi
 
       # @return [Symbol, nil] :detach to end the loop
       def submit(line)
+        if @exit_ask
+          # The exit ask is open: this line answers it. Ctrl-D and /detach
+          # detach without stopping anything, the way its 1 does.
+          return detach(kept_line(@exit_ask)) if line.nil? || command_registry.lookup_local(line.strip)&.id == :detach
+
+          return answer_exit_ask(line)
+        end
+
         return detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if line.nil?
 
         text = line.strip
@@ -599,14 +627,104 @@ module Samagotchi
 
       # Detach, and ask the worker to exit now. The worker decides: it stays
       # up while anything still needs it (a turn, queued input, a continue
-      # offer, another UI, reminders), and the line says which.
-      # @return [Symbol] :detach
+      # offer, another UI, reminders), and the line says which. When the only
+      # holds are ones the user can stop, it asks what to do with them instead
+      # of detaching (#answer_exit_ask).
+      # @return [Symbol, nil] :detach, or nil to stay at the prompt
       def exit_worker
-        detach(exit_line(@client.request_exit(client_id: @client_id)))
+        reply = @client.request_exit(client_id: @client_id)
+        holds = reply.status == 409 ? reply.json&.fetch("holds", nil) : nil
+        return detach(exit_line(reply)) unless holds.is_a?(Array) && !holds.empty?
+
+        @exit_ask = holds
+        @screen.commit(ask_lines(holds))
+        nil
+      rescue SystemCallError, IOError => e
+        detach(exit_failed_line(e.message))
+      end
+
+      # The ask: what still runs, then the three answers.
+      def ask_lines(holds)
+        lines = holds.map do |hold|
+          items = Array(hold["items"])
+          singular, plural = hold_words(hold["kind"])
+          "  • #{items.size} #{items.size == 1 ? singular : plural}: #{items.map { |item| item_word(item, hold["kind"]) }.join(", ")}"
+        end
+        lines += EXIT_ASK_OPTIONS.each_with_index.map { |option, index| "  #{index + 1}. #{option}" }
+        (["This session still has:"] + lines).join("\n")
+      end
+
+      # One entry of a hold: the command or name, with its detail in
+      # brackets; a delegate leads with its short id and its title in quotes.
+      def item_word(item, kind)
+        label = item["label"].to_s
+        label = "#{item["id"].to_s[0, 8]} \"#{label}\"" if kind == "delegates"
+        detail = item["detail"].to_s
+        detail.empty? ? label : "#{label} (#{detail})"
+      end
+
+      # The answer to the exit ask.
+      # @return [Symbol, nil] :detach for 1 and 2, nil for 3 or a line the
+      #   ask doesn't understand
+      def answer_exit_ask(line)
+        choice = EXIT_ANSWERS[line.to_s.strip.downcase]
+        unless choice
+          @screen.commit("Say 1 (keep running), 2 (stop them and exit) or 3 (back to the session).")
+          return nil
+        end
+
+        holds = @exit_ask
+        @exit_ask = nil
+        case choice
+        when :keep then detach(kept_line(holds))
+        when :stop then stop_and_exit
+        else
+          @screen.commit("(nothing stopped; the worker keeps running)")
+          nil
+        end
+      end
+
+      # 1: detach, everything left running.
+      def kept_line(holds)
+        "Detached; the session keeps running (#{hold_words_list(holds)}). " \
+          "Re-attach with: #{via.attach(@client.session_id)}"
+      end
+
+      # 2: ask the worker to stop them all and exit.
+      # @return [Symbol] :detach
+      def stop_and_exit
+        reply = @client.request_exit(client_id: @client_id, stop: true)
+        detach(exit_line(reply))
       rescue SystemCallError, IOError => e
         detach(exit_failed_line(e.message))
       end
 
+      # "2 reminders, 1 background task, 1 delegate" from the ask's holds.
+      def hold_words_list(holds)
+        holds.map do |hold|
+          items = Array(hold["items"])
+          singular, plural = hold_words(hold["kind"])
+          "#{items.size} #{items.size == 1 ? singular : plural}"
+        end.join(", ")
+      end
+
+      def hold_words(kind) = EXIT_HOLD_WORDS.fetch(kind.to_s, [kind.to_s, kind.to_s])
+
+      # What a stop-all exit stopped: "stopped 2 reminders (api_health, git
+      # push), 1 background task (rails s)"; nil when it stopped nothing.
+      def stopped_words(stopped)
+        return nil unless stopped.is_a?(Hash)
+
+        parts = STOPPED_KEYS.filter_map do |key, kind|
+          names = Array(stopped[key])
+          next if names.empty?
+
+          singular, plural = hold_words(kind)
+          "#{names.size} #{names.size == 1 ? singular : plural} (#{names.join(", ")})"
+        end
+        parts.empty? ? nil : "stopped #{parts.join(", ")}"
+      end
+
       # /exit --delete: the worker exits as for /exit, then the session is
       # deleted. When the worker stays up (another UI, queued input, ...),
       # nothing is deleted.
@@ -656,7 +774,9 @@ module Samagotchi
       # (SessionManager.archive_session). An empty session: the worker
       # deletes it as it leaves.
       def exit_and_archive
-        reply = @client.request_exit(client_id: @client_id)
+        # /archive can't ask about what still runs: a child the archive will
+        # stop is not worth a question here.
+        reply = @client.request_exit(client_id: @client_id, ask: false)
         id = @client.session_id
         return detach(EMPTY_EXIT) if reply.status == 200 && discards?(reply)
         return detach("#{exit_line(reply)} Not archived.") unless [200, 409].include?(reply.status)
@@ -676,9 +796,11 @@ module Samagotchi
         error = reply.json&.fetch("error", nil)
         case reply.status
         when 200
-          return EMPTY_EXIT if discards?(reply)
+          stopped = stopped_words(reply.json&.fetch("stopped", nil))
+          return EMPTY_EXIT if discards?(reply) && stopped.nil?
+          return "Detached; #{stopped}. #{EMPTY_WORDS.capitalize}" if discards?(reply)
 
-          "Detached; the session's worker is stopping. Resume with: #{via.resume(id)}"
+          "Detached; #{stopped || "the session's worker is stopping"}. Resume with: #{via.resume(id)}"
         when 409
           reason = reply.json&.fetch("reason", nil).to_s
           "Detached; the session keeps running (#{held_words(reason, reply.json&.fetch("tasks", nil))}). " \

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.116.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],

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

@@ -4,6 +4,8 @@ import {
   sendTurn,
   cancelTurn,
   stopSession,
+  sessionHolds,
+  stopSessionHolds,
   restartSession,
   deleteSession,
   archiveSession,
@@ -98,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";
@@ -565,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,
@@ -584,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
@@ -1659,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_size.js

@@ -1,9 +1,10 @@
 // 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). 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).
+// 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
@@ -15,15 +16,21 @@ export const GRIP_CLICK_FOLD_MS = 250; // how long a click on the expanded grip
 // 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

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

@@ -194,6 +194,20 @@ 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/index.html

@@ -1226,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 };
+}

data/lib/samagotchi/web/session_access_routes.rb

@@ -304,22 +304,25 @@ module Samagotchi
         { epoch: sidecar.epoch, started_at: sidecar.started_at, version: sidecar.version, features: sidecar.features }
       end
 
-      # POST /api/sessions/:id/exit {client_id, delete}: a remote attached
+      # POST /api/sessions/:id/exit {client_id, delete, stop}: a remote attached
       # TUI's /exit (and the worker's half of /exit --delete and /archive),
       # relayed to the live worker's exit (BridgeClient#request_exit; never
       # wakes one). client_id is passed on only when it is an attached TUI's
       # (tui:…): any other is dropped, and then every stream counts as a UI,
-      # which only keeps the worker up. 200 the Bridge's {status: exiting,
-      # session_id, discard}; 409 held with its {status, reason, tasks,
-      # hint}; 503 not_live, 501 not_supported (an older worker), 504
-      # worker_timeout.
+      # which only keeps the worker up. stop: true means the ask's "stop them
+      # and exit". 200 the Bridge's {status: exiting, session_id, discard,
+      # stopped}; 409 held with its {status, reason, tasks, hint, holds};
+      # 503 not_live, 501 not_supported (an older worker), 504 worker_timeout.
       def handle_exit(req, id)
         body = body_hash(req) or return refusal(400, "invalid_json", "invalid JSON body")
         @session_class.load(id, state_dir: default_state_dir)
         client_id = body["client_id"] if body["client_id"].is_a?(String) && body["client_id"].start_with?(ClientId::TUI_PREFIX)
         delete = body["delete"] == true
+        options = { delete: delete }
+        options[:stop] = true if body["stop"] == "all"
+        options[:ask] = false if body["ask"] == false
 
-        request = ->(client) { client.request_exit(client_id: client_id, delete: delete) }
+        request = ->(client) { client.request_exit(client_id: client_id, **options) }
         with_message(relay(id, bridge_client(id), request, what: "the worker was not asked to exit", cant: "exit from here") do |reply|
           case reply.status
           when 200 then json_response(200, reply.json || { status: "exiting", session_id: id })