samagotchi 0.90.0 → 0.92.0

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

@@ -35,10 +35,10 @@ import { createReasoningHistoryControl } from "./reasoning_history_chip.js";
 import { renderInfoBar } from "./info_bar.js";
 import { sessionBar, workerBadgeFor } from "./info_bar_model.js";
 import { createShownTexts } from "./shown_texts.js";
-import { MODEL_KEY } from "./model_pick.js";
+import { MODEL_KEY, modelsFailedText } from "./model_pick.js";
 import { emptySessionState, sessionStateFrom } from "./session_state.js";
 import { createModelPicker } from "./model_picker.js";
-import { admitImages, chipName, chipsTemplate, imageFiles, restoredChips, thumbsTemplate, turnRefs, turnText, uploadChips } from "./images.js";
+import { admitImages, chipName, chipsAfterSend, chipsTemplate, imageFiles, restoredChips, thumbsTemplate, turnRefs, turnText, uploadChips } from "./images.js";
 import { normalize, firstPreview, failedTurnText, deleteConfirmText, goneSessionNotice, cantText, withLiveStatus, withoutWorker } from "./format.js";
 import { createTurnView, turnHistoryNodes } from "./turn_view.js";
 import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
@@ -992,7 +992,10 @@ async function readTurnEnd() {
       lists.render();
       lists.paintActive();
     }
-  } catch(_){}
+  } catch (_) {
+    // A failed read (the server or worker gone a moment) leaves the answer
+    // as the stream drew it, plain text: the session's next load renders it.
+  }
 }
 
 function seedSeenFromDom() {
@@ -1452,8 +1455,9 @@ async function handleSendTurn({ delivery: chosen = null } = {}) {
     if (restored?.refill && sentTo === selected) openForVisit();
     promptEl.value = composerAfterAck({ sent: line, current: promptEl.value, refill: restored?.refill || "" });
     fitPrompt();
-    clearChips();
-    if (restored?.images?.length) setChips(restoredChips(sentTo, restored.images));
+    // Only the sent chips go: images added since stay (they go up at their own send).
+    const kept = chipsAfterSend(chips, sending);
+    setChips(restored?.images?.length ? kept.concat(restoredChips(sentTo, restored.images)) : kept);
     // Its turn_enqueued usually tagged the echo already; the ack covers a
     // worker that wasn't live (no turn_enqueued then).
     if (ack?.enqueued_id && !echo.dataset.enqueuedId && !bubbleById(ack.enqueued_id)) {
@@ -1548,7 +1552,7 @@ async function handleCancel() {
 $("#newBtn").addEventListener("click", () => {
   if (allViewOpen()) leaveAllView("");
   clearSelection();
-  loadModels();
+  loadModels({ asked: true });
 });
 
 // ── The start page's model picker ──────────────────────────────────────────
@@ -1641,11 +1645,19 @@ function restoreStartPick() {
   renderNewChatLlmContext();
   renderNewChatThinking();
 }
-async function loadModels() {
+// A reload cuts the fetch: its error is no news (modelsFailedText).
+let pageLeaving = false;
+addEventListener("beforeunload", () => { pageLeaving = true; });
+addEventListener("pagehide", () => { pageLeaving = true; });
+addEventListener("pageshow", () => { pageLeaving = false; }); // back from the bfcache
+// +asked+: + new session's load, for the start page it opens.
+async function loadModels({ asked = false } = {}) {
   let payload;
   try {
     payload = await listModels();
-  } catch (_) {
+  } catch (e) {
+    const text = modelsFailedText(e, { startPage: !selected, asked, leaving: pageLeaving });
+    if (text) showToast(text);
     return;
   }
   const stored = readStored(MODEL_KEY);
@@ -1678,16 +1690,13 @@ function renderChips() {
   drawFoldControls();
 }
 
+// A chip that goes frees its preview; one kept in +list+ keeps it.
 function setChips(list) {
-  for (const c of chips) if (c.file && c.src) URL.revokeObjectURL(c.src);
+  for (const c of chips) if (c.file && c.src && !list.includes(c)) URL.revokeObjectURL(c.src);
   chips = list;
   renderChips();
 }
 
-function clearChips() {
-  setChips([]);
-}
-
 // A paste's, a drop's or the image button's files: the images the message
 // may still take become chips (images.js admitImages); a toast says why the
 // rest stayed out. Whether any went in.
@@ -1806,7 +1815,8 @@ composerEl.addEventListener("drop", (e) => {
 const unqueue = createUnqueue({
   sessionId: () => selected,
   clientId,
-  toast: (text) => showToast(text),
+  toast: (text, action, options) => showToast(text, action, options),
+  copy: (text) => copyText(text),
   // Edit: the removed text back into an empty composer (never over a draft).
   putBack: (text) => {
     if (promptEl.value.trim() || chips.length) return false;

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

@@ -150,7 +150,10 @@ export function createCardsPlace({
           const el = card.type === "card" && cardElement(card.id);
           if (el) refreshCardBody(el, card);
         }
-      } catch (_) {}
+      } catch (_) {
+        // The live text stays (a failed re-read is only a lost render);
+        // the next card or load renders it.
+      }
     }, 150);
   }
 

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

@@ -94,6 +94,12 @@ export function chipsTemplate(chips) {
     html`<span class="chip" data-index=${i}><img src=${c.src} alt=""><span class="chip-name">${c.name}</span><button type="button" class="chip-remove" data-index=${i} aria-label=${`remove ${c.name}`}>×</button></span>`);
 }
 
+// The chips left once a send is acked: those added while it was in flight
+// (an upload can take seconds) stay for the next message.
+export function chipsAfterSend(chips, sent) {
+  return (chips || []).filter((c) => !sent.includes(c));
+}
+
 // The {file, name} refs a turn names.
 export function turnRefs(chips) {
   return (chips || []).filter((c) => c.ref).map((c) => ({ file: c.ref.file, name: c.name }));

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

@@ -1,7 +1,17 @@
 // The start page's model picker: pure helpers over GET /api/models' payload.
+import { cantText } from "./format.js";
 
 export const MODEL_KEY = "chi_model";
 
+// A failed GET /api/models' toast: the picker stays hidden, so it says why
+// and what a new session gets (+ new session asks again). "" (no toast) in
+// a session, where no picker shows (+asked+: + new session's own load),
+// and for a fetch aborted or cut by the page unloading.
+export function modelsFailedText(error, { startPage = true, asked = false, leaving = false } = {}) {
+  if (leaving || error?.name === "AbortError" || !(startPage || asked)) return "";
+  return `${cantText("list the models", error)}. A new session starts on the default model.`;
+}
+
 // The name to preselect from the rows (modelRows): the remembered one when
 // it is still offered (any case), else the server's default, both even
 // when their host is down; else the first row whose host answered, else

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

@@ -15,11 +15,11 @@ export function notifyState({ hasNotification, secureContext, permission, wanted
 }
 
 // A finished turn shorter than this was watched: no "done". Not a turn
-// chi ran for a delegate child's report (last_turn origin delegate_report)
-// or an attached context change (context): nobody started it, so nobody
-// watched it.
+// chi ran for a delegate child's report (last_turn origin delegate_report),
+// an attached context change (context) or a finished background task
+// (task): nobody started it, so nobody watched it.
 const DONE_MIN_SECONDS = 10;
-const UNWATCHED_ORIGINS = ["delegate_report", "context"];
+const UNWATCHED_ORIGINS = ["delegate_report", "context", "task"];
 
 // The step-limit question (kind "continue": a turn ran out of iterations
 // and asks whether to go on) has its own reason: "out of steps".

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

@@ -36,19 +36,26 @@ export function createToasts({ el, onChange = () => {}, doc = globalThis.documen
     entry.el);
   }
 
+  function item(text, action, sticky) {
+    const entry = { el: doc.createElement("div"), timer: null, sticky, action, key: null };
+    entry.el.className = "toast-item";
+    draw(entry, text, action, sticky);
+    entry.key = entry.el.querySelector(".toast-message").textContent;
+    return entry;
+  }
+
   function show(text, action = null, { sticky = false } = {}) {
-    const candidate = { el: doc.createElement("div"), timer: null, sticky, action, key: null };
-    candidate.el.className = "toast-item";
-    draw(candidate, text, action, sticky);
-    candidate.key = candidate.el.querySelector(".toast-message").textContent;
+    // Words are their own key; a template's key is its drawn text, so only
+    // a template is drawn before the look-up.
+    const candidate = typeof text === "string" ? null : item(text, action, sticky);
+    const key = candidate ? candidate.key : text;
 
-    const duplicate = entries.find((entry) => entry.key === candidate.key);
+    const duplicate = entries.find((entry) => entry.key === key);
     if (duplicate) {
       if (duplicate.timer !== null) clearTimeout(duplicate.timer);
       duplicate.timer = null;
       duplicate.sticky = sticky || duplicate.sticky;
       duplicate.action = action || duplicate.action;
-      duplicate.key = candidate.key;
       draw(duplicate, text, duplicate.action, duplicate.sticky);
       entries.push(...entries.splice(entries.indexOf(duplicate), 1));
       el.appendChild(duplicate.el);
@@ -60,9 +67,10 @@ export function createToasts({ el, onChange = () => {}, doc = globalThis.documen
     if (entries.length === MAX_TOASTS) {
       remove(entries.find((entry) => !entry.sticky) || entries[0], false);
     }
-    entries.push(candidate);
-    el.appendChild(candidate.el);
-    if (!sticky) candidate.timer = setTimeout(() => remove(candidate), TOAST_MS);
+    const entry = candidate || item(text, action, sticky);
+    entries.push(entry);
+    el.appendChild(entry.el);
+    if (!sticky) entry.timer = setTimeout(() => remove(entry), TOAST_MS);
     sync();
   }
 

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

@@ -107,13 +107,25 @@ export function isReportClient(clientId) {
 
 // A turn chi ran because an attached context source changed: context:<name>.
 const CONTEXT_CLIENT = "context:";
+// A turn chi ran because a background task the session started finished
+// unseen: task:<task id> (the Worker's finish wake).
+const TASK_CLIENT = "task:";
+
+// A task id as people read it: the random part a task_create id ends with
+// (it starts with the time), else its first 8 chars (TaskRecord.short_id).
+function shortTaskId(id) {
+  const m = /-([0-9a-f]{8})$/i.exec(id);
+  return m ? m[1] : id.slice(0, 8);
+}
 
 // The label on another client's prompt, by its client_id prefix; a context
-// change's turn as "context <name> changed".
+// change's turn as "context <name> changed", a finished task's as
+// "task <id8> finished".
 export function clientLabel(clientId) {
   if (!clientId) return null;
   const id = String(clientId);
   if (id.startsWith(CONTEXT_CLIENT) && id.length > CONTEXT_CLIENT.length) return `context ${id.slice(CONTEXT_CLIENT.length)} changed`;
+  if (id.startsWith(TASK_CLIENT) && id.length > TASK_CLIENT.length) return `task ${shortTaskId(id.slice(TASK_CLIENT.length))} finished`;
   const colon = id.indexOf(":");
   return CLIENT_LABELS[id] || (colon >= 0 && CLIENT_LABELS[id.slice(0, colon + 1)]) || AUTOMATIC_LABEL;
 }

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

@@ -4,8 +4,9 @@
 // goes with the turn_dequeued every tab gets (bubbles.js op "remove"), and
 // here at the 200 already. Its text comes back (edit): into an empty
 // composer, to change and send again; over a draft only in a toast (the
-// draft stays). Its images don't come back. A refusal keeps it and says why
-// in a toast. No confirm: nothing is lost. Pure but for the
+// draft stays), and after a switch to another session meanwhile only in a
+// sticky toast naming its session, with Copy. Its images don't come back. A refusal keeps it
+// and says why in a toast. No confirm: nothing is lost. Pure but for the
 // injected calls, so `node --test` covers it; app.js binds onClick to the
 // turn roots.
 import { dequeueTurn as postDequeue } from "./data.js";
@@ -28,8 +29,9 @@ function clipped(text) {
 
 // +sessionId+ is read at each click (the open session); +clientId+ is this
 // tab's (the turn_dequeued names who removed it); +putBack(text)+ fills the
-// composer when it is empty and says whether it did.
-export function createUnqueue({ sessionId, clientId = null, dequeue = postDequeue, toast = () => {}, putBack = () => false }) {
+// composer when it is empty and says whether it did; +copy(text)+ says
+// whether the clipboard took it; +toast(text, action, options)+ as showToast.
+export function createUnqueue({ sessionId, clientId = null, dequeue = postDequeue, toast = () => {}, putBack = () => false, copy = null }) {
   // A click on a queued bubble's ×; any other click is left alone.
   async function onClick(e) {
     const button = e.target?.closest?.("button.unqueue");
@@ -44,6 +46,12 @@ export function createUnqueue({ sessionId, clientId = null, dequeue = postDequeu
       const result = await dequeue(id, enqueuedId, { clientId });
       removeQueuedBubble(bubble);
       const text = String(result?.prompt || "");
+      // Another session opened meanwhile: its composer isn't where this
+      // text goes, so only the toast has it.
+      if (text.trim() && sessionId() !== id) {
+        movedOn(id, text);
+        return result;
+      }
       if (text.trim() && !putBack(text)) toast(`Removed (your draft stays): ${clipped(text)}`);
       return result;
     } catch (error) {
@@ -52,5 +60,13 @@ export function createUnqueue({ sessionId, clientId = null, dequeue = postDequeu
       return null;
     }
   }
+  // The removed text after a switch: in a sticky toast, its Copy takes the
+  // whole text (the toast clips it); a failed copy shows the toast again.
+  function movedOn(id, text) {
+    const line = `Removed from ${id.slice(0, 8)}: ${clipped(text)}`;
+    const show = () => toast(line, copy ? action : null, { sticky: true });
+    const action = { label: "Copy", run: async () => { if (await copy(text)) toast("Copied"); else show(); } };
+    show();
+  }
   return { onClick };
 }

data/lib/samagotchi/worker.rb

@@ -15,6 +15,7 @@ require_relative "worker_idle_exit"
 require_relative "worker_wakes"
 require_relative "worker_inbound"
 require_relative "worker_signals"
+require_relative "worker_task_wakes"
 require_relative "session_manager"
 require_relative "archive_store"
 require_relative "log"
@@ -31,6 +32,7 @@ require_relative "child_reports"
 require_relative "child_move"
 require_relative "context_absorber"
 require_relative "context_poller"
+require_relative "task_watch"
 require_relative "tools/task_runtime"
 
 module Samagotchi
@@ -74,6 +76,8 @@ module Samagotchi
     # How much of a command's output goes into its :command_ran.
     COMMAND_OUTPUT_LIMIT = 4096
     BUSY_OUTPUT = "busy: wait for the turn to end"
+    # /exit held by background tasks a finish wake waits for: how to end them.
+    TASK_STOP_HINT = "stop one with the web's stop-task button or by asking for task_stop"
     # !rollback mid-turn would mean "the turn I'm in".
     ROLLBACK_BUSY_OUTPUT = "busy: Ctrl-C the turn first, then !rollback"
     # How long a signalled worker's turn has to end (it is canceled at once,
@@ -242,7 +246,7 @@ module Samagotchi
       # a command queued mid-turn (/thinking, /model, /llm-context) changes
       # what it starts with: no turn-end warm-up then.
       @engine.next_turn_waiting = lambda {
-        !@command_queue.empty? || SessionInbox.find_new_input_files(@session_dir).any? || wake_due?
+        !@command_queue.empty? || SessionInbox.find_new_input_files(@session_dir).any? || wake_due? || @task_wakes.due?
       }
       @turn_flow = TurnFlow.new(engine: @engine)
       # Its question's answer is queued as the matching /continue (the
@@ -258,6 +262,12 @@ module Samagotchi
       # The seq of the last turn's end event: a command queued before it was
       # queued while that turn ran.
       @turn_end_seq = 0
+      # The background tasks this session started and hasn't seen finish:
+      # one that finishes unseen wakes the idle session (#run_task_wake).
+      @task_wakes = WorkerTaskWakes.new(engine: @engine, session: @session, wakes: @wakes,
+                                        awaiting_continue: -> { @turn_flow.awaiting_continue? },
+                                        idle: -> { nothing_queued? && !@exit_requested },
+                                        save: -> { save_or_log(:task_notes) { save_session } })
       @engine.subscribe(observer: lambda { |event|
         if Events::TURN_END.include?(event[:type])
           @turn_end_seq = event[:event_seq]
@@ -269,6 +279,7 @@ module Samagotchi
           @turn_ending = false
         end
         ring_question(event) if event[:type] == :question_requested
+        @task_wakes.observe(event)
       })
       # This session's own delegate children's news (rings in children/).
       @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir,
@@ -315,7 +326,13 @@ module Samagotchi
         timeout_minutes: @idle_exit_minutes || SessionManager.config_idle_exit_minutes,
         input_pending: -> { !@command_queue.empty? || !SessionInbox.find_new_input_files(@session_dir).empty? },
         awaiting_continue: -> { @turn_flow.awaiting_continue? },
-        running_tasks: -> { Tools::TaskRuntime.running_created_in(@engine.messages_checkpoint) }
+        running_tasks: -> { Tools::TaskRuntime.running_created_in(@engine.messages_checkpoint) },
+        # Only when a finish would wake the session (D3): with queue its end
+        # is just a note, not worth keeping the worker up for. One that
+        # finished since the pass looked holds too, until the next pass
+        # wakes for it (#run_task_wake).
+        watched_tasks: -> { TaskWatch.mode == "wake" ? @task_wakes.watch.holding : [] },
+        watched_running: -> { TaskWatch.mode == "wake" ? @task_wakes.watch.running : [] }
       )
     end
 
@@ -371,12 +388,13 @@ module Samagotchi
       run_input_files(input_files)
     end
 
-    # Nothing queued: a delegate wake turn or a due reminder runs, else
-    # the worker leaves when the idle exit or a client's exit is due, else
-    # it sleeps until woken or the fallback tick.
+    # Nothing queued: a delegate wake turn, a task finish wake turn or a due
+    # reminder runs, else the worker leaves when the idle exit or a client's
+    # exit is due, else it sleeps until woken or the fallback tick.
     # @return [Symbol, nil] as #pass
     def idle_pass
       return if run_wake_turn
+      return if run_task_wake
       return if run_due_reminders
       return left(:idle_exit) if @idle_exit.due? && leave_idle
       return left(@exit_restart ? :restart : :exit_requested) if @exit_requested && leave_on_request
@@ -441,6 +459,9 @@ module Samagotchi
         memories: @session.preloaded_memory_names,
         muted_memories: @session.muted_memory_names,
         appended_prompt_files: @session.appended_prompt_files,
+        # The finish wake reports a task the model leaves running: the tool
+        # descriptions say so, fixed for this worker (a stable prompt prefix).
+        task_finish_notes: TaskWatch.mode != "off",
         reminders: {
           callback: lambda { |due_names|
             # A reminder is due: the loop runs a reminder turn for it once
@@ -514,26 +535,14 @@ module Samagotchi
     # A turn nobody typed for a changed source (a context wake): a continue
     # turn from context:<name> whose first message is the wake note already
     # in the conversation (named by +turn_id+), on the same rules as a
-    # delegate report's wake turn: it counts toward session.max_wakes (a
-    # peer's answer toward context.peer_turns too, unless it agrees), and a failure goes back
-    # to before the turn (the note stays, as a plain one:
-    # WorkerInbound#unmark_wake) and pauses wakes until a human's input.
+    # delegate report's wake turn (#run_wake): it counts toward
+    # session.max_wakes (a peer's answer toward context.peer_turns too,
+    # unless it agrees).
     # +context_wake+: a WorkerInbound::ContextWake.
     def run_context_wake_turn(context_wake)
       name = context_wake.name
       Log.info(:worker, "context_wake_turn", name: name, in_a_row: @wakes.count!(peer: context_wake.peer_turn?))
-      @turn_flow.before_prompt_turn
-      run_engine_turn(nil, continue: true, origin: context_wake.origin,
-                           id: context_wake.turn_id, max_iterations: IterationLimit.for) do |result, error|
-        if error
-          kept = @turn_flow.prompt_turn_failed(error: error, wake: "the change in attached context #{name}") == :kept
-          # A turn that got somewhere stays, its wake mark with it.
-          @inbound.unmark_wake(context_wake) unless kept
-          @wakes.pause!
-        else
-          @continue_offer.after_turn(result)
-        end
-      end
+      run_wake(origin: context_wake.origin, failed: "the change in attached context #{name}", mark: context_wake)
     end
 
     # The first prompt (spawn_session's): a delegate child's task, which is
@@ -552,8 +561,10 @@ module Samagotchi
     # @param prompt [WorkerInbound::Prompt]
     def run_prompt(prompt)
       origin = prompt.origin
-      # A first turn sees the context attached before it.
+      # A first turn sees the context attached before it, and any turn the
+      # background tasks that finished since the last look.
       absorb_context(before_turn: true)
+      @task_wakes.absorb
       user_input(origin&.dig(:client_id))
       @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
@@ -621,30 +632,68 @@ module Samagotchi
 
       @wakes.hand_over(reports)
       Log.info(:worker, "delegate_wake_turn", reports: reports.size, in_a_row: @wakes.count!)
+      # Rolled back, the rings stay (settle_child_reports): the user's next
+      # turn takes them. A turn that got somewhere stays, and read them.
+      run_wake(origin: reports.first.origin,
+               failed: reports.size == 1 ? "a delegate's report" : "#{reports.size} delegate reports",
+               kept: "chi keeps #{reports.size == 1 ? "the report and brings it" : "the reports and brings them"} " \
+                     "again with the user's next message.")
+      true
+    ensure
+      @wakes.drop_handed
+    end
+
+    # A wake turn (a delegate report's, an attached context change's, a
+    # finished task's): a continue turn nobody typed, from +origin+. A
+    # failure goes back to before the turn and pauses wakes until a human's
+    # input (a provider outage doesn't loop); so does a Stop before it got
+    # anywhere (a Stop or a before_turn hook's cancel before the model
+    # call, restored by TurnFlow), rather than waking again at once. Either
+    # way +mark+ (a WorkerInbound::ContextWake or TaskWake: its wake note,
+    # the turn's first message) goes back to a plain note
+    # (WorkerInbound#unmark_wake), unless the failed turn kept its steps.
+    # +failed+ names the wake in the failed turn's note, +kept+ says what
+    # happens to it (TurnFlow#prompt_turn_failed).
+    def run_wake(origin:, failed:, kept: nil, mark: nil)
       @turn_flow.before_prompt_turn
       restores = @turn_flow.restores
-      run_engine_turn(nil, continue: true, origin: reports.first.origin, max_iterations: IterationLimit.for) do |result, error|
+      run_engine_turn(nil, continue: true, origin: origin, id: mark&.turn_id,
+                           max_iterations: IterationLimit.for) do |result, error|
         if error
-          # Rolled back, the rings stay (settle_child_reports): the user's
-          # next turn takes them. A turn that got somewhere stays, and read them.
-          @turn_flow.prompt_turn_failed(
-            error: error, wake: reports.size == 1 ? "a delegate's report" : "#{reports.size} delegate reports",
-            wake_kept: "chi keeps #{reports.size == 1 ? "the report and brings it" : "the reports and brings them"} " \
-                       "again with the user's next message."
-          )
+          steps_kept = @turn_flow.prompt_turn_failed(error: error, wake: failed, wake_kept: kept) == :kept
+          @inbound.unmark_wake(mark) if mark && !steps_kept
           @wakes.pause!
         else
           @continue_offer.after_turn(result)
-          # Stopped before it got anywhere (a Stop or a before_turn hook's
-          # cancel before the model call) and restored: its rings stay, and
-          # wait for the user's next message as after a failure, rather
-          # than waking again at once.
-          @wakes.pause! if result.canceled? && @turn_flow.restores != restores
+          if result.canceled? && @turn_flow.restores != restores
+            @inbound.unmark_wake(mark) if mark
+            @wakes.pause!
+          end
         end
       end
+    end
+
+    # The background tasks this session started that finished unseen, as
+    # notes (WorkerTaskWakes#take), and the wake turn the first one may
+    # start.
+    # @return [Boolean] whether a wake turn ran
+    def run_task_wake
+      task_wake = @task_wakes.take
+      return false unless task_wake
+
+      run_task_wake_turn(task_wake)
       true
-    ensure
-      @wakes.drop_handed
+    end
+
+    # A turn nobody typed for a finished task: a continue turn from
+    # task:<id> whose first message is the wake note, on the delegate wake's
+    # rules (#run_wake; counted toward session.max_wakes): a failure that
+    # kept nothing, or a Stop that restored the conversation, leaves the
+    # note as a plain one (M4).
+    def run_task_wake_turn(task_wake)
+      Log.info(:worker, "task_wake_turn", task_id: task_wake.id, in_a_row: @wakes.count!)
+      run_wake(origin: task_wake.origin, failed: "a finished background task (#{task_wake.name.delete_prefix("task ")})",
+               kept: "Its note stays for the user's next message.", mark: task_wake)
     end
 
     # The idle loop's sleep: the fallback tick, or less while reports wait
@@ -901,7 +950,7 @@ module Samagotchi
     # @param confirm [CacheConfirm::Confirm, nil] the change asks first: the
     #   line that applies it (the TUI's prefill, the web's Apply button)
     def announce_command(command, status:, output:, changed:, anytime: false, confirm: nil)
-      TurnCheckpoint.record_command_outcome(@session_dir, command.enqueued_id)
+      TurnCheckpoint.record_command_outcome(@session_dir, command.enqueued_id, status: status)
       text = output.to_s
       event = { type: :command_ran, **command.event_fields, status: status, output: text[0, COMMAND_OUTPUT_LIMIT],
                 changed: changed.map(&:to_s), model_name: @engine.effective_model_name }
@@ -1200,13 +1249,19 @@ module Samagotchi
     # +delete+: the session is deleted after (/exit --delete), so no recap.
     # +restart+: a new worker takes over (on the newest chi installed), so
     # WorkerIdleExit#hold_for_restart's rules, and no recap or discard.
-    # @return [Symbol, nil] what keeps the worker up, nil when it will leave
+    # @return [WorkerIdleExit::Hold, nil] what keeps the worker up (for
+    #   :background_tasks, the watched tasks still running), nil when it
+    #   will leave
     def exit_request(client_id, delete: false, restart: false)
       # The Bridge serves before the idle-exit policy exists.
-      return :starting unless @idle_exit
+      return WorkerIdleExit::Hold.new(reason: :starting) unless @idle_exit
 
       hold = restart ? @idle_exit.hold_for_restart : @idle_exit.hold_for_request(requester: client_id)
-      return hold if hold
+      if hold == :background_tasks && !restart
+        # /exit names the tasks it waits for (D3).
+        return WorkerIdleExit::Hold.new(reason: hold, tasks: @task_wakes.watch.running, hint: TASK_STOP_HINT)
+      end
+      return WorkerIdleExit::Hold.new(reason: hold) if hold
 
       @exit_requested = true
       @exit_requested_by = client_id
@@ -1253,10 +1308,17 @@ module Samagotchi
     # A restart keeps even an empty session (a new worker takes it over at
     # once) and leaves the recap to the conversation's next real pause.
     def left(result)
+      deleting = result == :exit_requested && @exit_deletes
+      # The watch goes with this process: a task that finished since the
+      # last look (nothing held the exit for it: queue, a note-only task,
+      # /exit) is a plain note for the next turn, not lost. Not into a
+      # session /exit --delete deletes next: its save could land after the
+      # delete and write the session back.
+      @task_wakes.absorb unless deleting
       return result if result == :restart
 
       @discard = empty_session?
-      write_recap_on_leave unless @discard || (result == :exit_requested && @exit_deletes)
+      write_recap_on_leave unless @discard || deleting
       result
     end
 

data/lib/samagotchi/worker_idle_exit.rb

@@ -13,6 +13,9 @@ module Samagotchi
   # * a reminder is registered. Reminders live only in the Engine and repeat
   #   until the agent cancels them, so an exit would drop them for good;
   # * a continue offer waits for an answer; it too lives only in memory;
+  # * a background task the worker watches for a finish wake (TaskWatch)
+  #   still runs, or finished and waits for the next pass's wake: its end
+  #   would go unnoticed after an exit (D3);
   # * less than the timeout has passed since the worker started, the Engine's
   #   last activity, or the last client request or disconnect.
   #
@@ -21,6 +24,15 @@ module Samagotchi
   # the timeout and leaves out the asking client's own stream. A restart
   # (POST /exit restart: true) has its own rules, #hold_for_restart.
   class WorkerIdleExit
+    # What keeps the worker up when a client asks it to exit (Worker#exit_request,
+    # the Bridge's 409): +reason+, a #hold_for_request (or #hold_for_restart)
+    # Symbol, or :starting before this policy exists; for :background_tasks
+    # the watched tasks still running ({id:, command:}) and a +hint+ on
+    # stopping them.
+    Hold = Data.define(:reason, :tasks, :hint) do
+      def initialize(reason:, tasks: nil, hint: nil) = super
+    end
+
     # @param engine [Engine] #turn_running?, #last_activity_at, #reminder_store
     # @param bridge [Bridge, nil] #open_streams, #last_client_activity_at; nil
     #   when the worker's Bridge failed to start
@@ -29,15 +41,23 @@ module Samagotchi
     # @param awaiting_continue [#call] true while a continue offer waits
     # @param running_tasks [#call] the background tasks this conversation
     #   started that still run (Tools::TaskRuntime.running_created_in)
+    # @param watched_tasks [#call] the ones a finish wake would wake for,
+    #   running or not yet taken (TaskWatch#holding): they hold the idle exit
+    # @param watched_running [#call] those of them still running
+    #   (TaskWatch#running): they hold /exit (one that finished is a note
+    #   as the worker leaves)
     # @param clock [#call] monotonic seconds, the Engine's and Bridge's clock
     def initialize(engine:, bridge:, timeout_minutes:, input_pending:, awaiting_continue: -> { false },
-                   running_tasks: -> { [] }, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+                   running_tasks: -> { [] }, watched_tasks: -> { [] }, watched_running: -> { [] },
+                   clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @engine = engine
       @bridge = bridge
       @timeout = timeout_minutes.to_f * 60
       @input_pending = input_pending
       @awaiting_continue = awaiting_continue
       @running_tasks = running_tasks
+      @watched_tasks = watched_tasks
+      @watched_running = watched_running
       @clock = clock
       @started_at = clock.call
     end
@@ -49,7 +69,8 @@ module Samagotchi
 
     # What keeps the worker up, or nil when nothing does.
     # @return [Symbol, nil] :disabled, :turn_running, :input_queued,
-    #   :continue_offered, :client_connected, :reminders or :recent_activity
+    #   :continue_offered, :client_connected, :reminders, :background_tasks
+    #   or :recent_activity
     def hold
       return :disabled unless @timeout.positive?
       return :turn_running if @engine.turn_running?
@@ -57,6 +78,7 @@ module Samagotchi
       return :continue_offered if @awaiting_continue.call
       return :client_connected if @bridge && @bridge.open_streams.positive?
       return :reminders if @engine.reminder_store&.any?
+      return :background_tasks if @watched_tasks.call.any?
       return :recent_activity if idle_seconds < @timeout
 
       nil
@@ -71,13 +93,14 @@ module Samagotchi
     #   either (the last check before leaving, when the asker's stream may
     #   still be open, untagged)
     # @return [Symbol, nil] :turn_running, :input_queued, :continue_offered,
-    #   :client_connected or :reminders
+    #   :client_connected, :reminders or :background_tasks
     def hold_for_request(requester:, streams: true)
       return :turn_running if @engine.turn_running?
       return :input_queued if @input_pending.call
       return :continue_offered if @awaiting_continue.call
       return :client_connected if streams && @bridge && @bridge.open_streams_except(requester).positive?
       return :reminders if @engine.reminder_store&.any?
+      return :background_tasks if @watched_running.call.any?
 
       nil
     end