samagotchi 0.96.0 → 0.98.0

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

@@ -40,6 +40,10 @@ const PENDING = ".bubble.question:not(.answered):not(.cancelled), .bubble.contin
 // asks the user too, but the turn goes on: it waits only while the turn runs
 // and never holds the hand-off (a turn cut short can leave it open).
 const ASKS = ".plugin-card[data-in-turn] .card-action";
+// The model's own question (question_cards.js data-kind; not an approval,
+// the step limit, a hook's question or a delegate's relayed one): the one
+// card whose long asking text gets the question room.
+const ASK_CARD = '.bubble.question[data-kind="question"]:not([data-relay])';
 
 function readCollapsed() {
   return readStored(COLLAPSE_KEY) === "1";
@@ -113,6 +117,14 @@ export function createStageView({
   chip.type = "button";
   const chipLabel = node("span", "ts-chip-label", chip);
   const ticks = node("span", "ts-ticks", chip);
+  // The question room's jump pill, at the scroller's bottom edge (absolute,
+  // above the chip): while the room's card is out of the stage's view it
+  // eases the stage to it (drawPill).
+  const pill = node("button", "ts-room-pill", cloud);
+  pill.type = "button";
+  pill.setAttribute("aria-label", "Go to the question");
+  pill.hidden = true;
+  pill.textContent = "❓ Answer ↓";
   // Below the turn's card: the lines queued for after it (placeKind
   // "queued"), each to run as a turn of its own; they hand off last.
   const queuedSlot = node("div", "ts-queued", stage);
@@ -140,6 +152,21 @@ export function createStageView({
   let revealed = false;
   let rafPending = false;
   let foldTimer = null;
+  // The question room (drawRoom): the pending ask card whose asking text
+  // overflowed its cap, and the turn's raised cap (stage_frame.js; kept
+  // until the next turn: the frame is grow-only).
+  let roomCard = null;
+  let roomCap = false;
+  // What the overflow was measured for ({ card, text }): measured once the
+  // asking text shows in its final form (its markdown, or the raw text when
+  // there is none: the raw text is taller, and a short question's could
+  // overflow where its markdown fits), again only for a new card or text,
+  // never at a cap's change (a phone's keyboard).
+  let measured = null;
+  // The ask card whose arrival reveal has run (no pill while the stage
+  // grows to it), and whether the room's card is in the stage's view.
+  let arrived = null;
+  let cardInSight = true;
 
   const view = createTurnView({
     historyEl,
@@ -181,6 +208,69 @@ export function createStageView({
     return !!(extras.querySelector(PENDING) || tail.querySelector(PENDING));
   }
 
+  // The pending card in the extras when it is the model's own question
+  // (never the tail's: a post-end card, the step limit; asking is empty then).
+  function askCard() {
+    const card = extras.querySelector(PENDING);
+    return card?.matches(ASK_CARD) ? card : null;
+  }
+
+  // The asking text overflows its cap (+1 px of rounding), measured with
+  // the room's class off.
+  function askingOverflows() {
+    return !asking.hidden && asking.scrollHeight > asking.clientHeight + 1;
+  }
+
+  // The question room: while a model's own question waits and its asking
+  // text didn't fit its cap, the slot loses its cap and the stage's one
+  // scroll reads the whole reply (index.html .question-room); the cap rises
+  // for the rest of the turn. The card keeps the room until it stops
+  // pending (+text+: the asking text drawn).
+  function drawRoom(blocked, text) {
+    const ask = blocked ? askCard() : null;
+    if (roomCard && ask === roomCard) return;
+    if (roomCard) {
+      cardSight.unobserve(roomCard);
+      stage.classList.remove("question-room");
+      roomCard = null;
+    }
+    if (!ask || !slotsView.askingSettled() || (measured && measured.card === ask && measured.text === text)) return;
+    measured = { card: ask, text };
+    if (!askingOverflows()) return;
+    roomCard = ask;
+    stage.classList.add("question-room");
+    cardInSight = true;
+    cardSight.observe(roomCard);
+    if (!roomCap) {
+      roomCap = true;
+      frame.fitCap();
+    }
+    // Decided after the card's arrival reveal (a slow markdown read): the
+    // reply reads from its start now, the pill only after that.
+    if (arrived === ask) {
+      arrived = null;
+      frame.afterGrowth(() => {
+        if (roomCard !== ask) return;
+        frame.reveal(extras, { fromStart: true });
+        arrived = ask;
+        drawPill();
+      });
+    }
+  }
+
+  // The pill: the room's card out of the stage's view, once its arrival
+  // reveal has run, the stage open.
+  function drawPill() {
+    pill.hidden = !(roomCard && !collapsed && arrived === roomCard && !cardInSight);
+  }
+
+  // The room's card in the stage's view: ~40 px of it shows above the
+  // scroller's bottom edge (where the pill sits).
+  const cardSight = new IntersectionObserver((entries) => {
+    for (const entry of entries) if (entry.target === roomCard) cardInSight = entry.isIntersecting;
+    drawPill();
+  }, { root: scroller, rootMargin: "0px 0px -40px 0px", threshold: 0 });
+
   function asksCard() {
     return !endKind && !!extras.querySelector(ASKS);
   }
@@ -214,7 +304,10 @@ export function createStageView({
     // next step (held-wait, set with waiting): the card under them never
     // moves at the answer. The waiting height is measured before the swap.
     const wasWaiting = stage.classList.contains("waiting");
-    if (blocked && !wasWaiting) stage.classList.add("held-wait");
+    if (blocked && !wasWaiting) {
+      stage.classList.add("held-wait");
+      live.style.minHeight = "";
+    }
     if (!blocked && wasWaiting) stage.style.setProperty("--live-held", `${live.offsetHeight}px`);
     stage.classList.toggle("plain", plain);
     stage.classList.toggle("ended", !!endKind);
@@ -225,7 +318,9 @@ export function createStageView({
     phaseEl.textContent = slots.phase;
 
     slotsView.drawHeadline(slots.headline);
-    slotsView.drawAsking(slots.asking);
+    slotsView.drawAsking(slots.asking, slots.askingRefs);
+    drawRoom(blocked, slots.asking);
+    drawPill();
     slotsView.drawNow(slots.tool, slots.quiet);
     slotsView.drawTrail(slots.trail, flash);
     slotsView.drawTicks(slots.ticks);
@@ -253,6 +348,25 @@ export function createStageView({
     tail.hidden = !tail.firstChild;
   }
 
+  // The next step: the live slots' waiting height is let go. In a turn
+  // with the question room that height was the whole reply's: it goes as
+  // far as the stage's scroll absorbs it (the scroll moves up by as much,
+  // in the same task: the card in view stays put), the rest kept as the
+  // live slots' least height until the next wait or turn.
+  function releaseHeldWait() {
+    const held = roomCap && stage.classList.contains("held-wait") && !stage.classList.contains("waiting");
+    const before = held ? live.offsetHeight : 0;
+    const top = scroller.scrollTop;
+    stage.classList.remove("held-wait");
+    stage.style.removeProperty("--live-held");
+    live.style.minHeight = "";
+    if (!held) return;
+    const after = live.offsetHeight;
+    const absorbed = Math.min(Math.max(0, before - after), top);
+    if (before - absorbed > after) live.style.minHeight = `${before - absorbed}px`;
+    if (absorbed) scroller.scrollTop = top - absorbed;
+  }
+
   // One line in the trail for FLASH_MS, ahead of the calls (a newer flash
   // takes its place).
   function flashTrail(what) {
@@ -339,6 +453,13 @@ export function createStageView({
     else setCloud(!cloudOpen);
   });
   headline.addEventListener("click", peek);
+  // To the card: its end in sight (the arrival's rule), or back up to it
+  // for a reader below it (the cloud open under the card).
+  pill.addEventListener("click", () => {
+    if (!roomCard) return;
+    if (roomCard.offsetTop < scroller.scrollTop) frame.easeStage(Math.max(0, roomCard.offsetTop - 8));
+    else frame.reveal(extras);
+  });
   // A ref's "show in turn" (refs.js) names a row in the cloud: open the
   // stage and the cloud to it, as a hand toggle would.
   // A collapsed stage opens for this turn only: the kept choice
@@ -378,6 +499,7 @@ export function createStageView({
     isHolding: () => holding,
     isCollapsed: () => collapsed,
     isCloudOpen: () => cloudOpen,
+    isRoomCap: () => roomCap,
   });
 
   // The in-use watch (stage_watch.js): an ended turn hands off once the
@@ -421,9 +543,16 @@ export function createStageView({
     thinkingLine = null;
     flash = null;
     clearTimeout(flashTimer);
+    if (roomCard) cardSight.unobserve(roomCard);
+    roomCard = null;
+    roomCap = false;
+    measured = null;
+    arrived = null;
+    pill.hidden = true;
     setCloud(false);
-    stage.classList.remove("plain", "ended", "waiting", "held-wait", "asking", "in-use");
+    stage.classList.remove("plain", "ended", "waiting", "held-wait", "asking", "in-use", "question-room");
     stage.style.removeProperty("--live-held");
+    live.style.minHeight = "";
   }
 
   // The turn leaves the stage's care (the hand-off's start, a reset, a new
@@ -546,9 +675,7 @@ export function createStageView({
       refresh();
     },
     generationStarted(data, now = null) {
-      // The next step: the live slots' waiting height is let go.
-      stage.classList.remove("held-wait");
-      stage.style.removeProperty("--live-held");
+      releaseHeldWait();
       view.generationStarted(data, now);
     },
     chunk: (data) => view.chunk(data),
@@ -600,6 +727,11 @@ export function createStageView({
     },
     containsLive: (el) => view.containsLive(el),
     askingText: () => view.askingText(),
+    // The asking slot pairs them on its next draw.
+    questionRefs(refs) {
+      view.questionRefs(refs);
+      scheduleRefresh();
+    },
     // The turn model and its live phase as the status row reads it (the
     // composer's delivery line).
     current: () => view.current(),
@@ -637,8 +769,17 @@ export function createStageView({
       else scheduleRefresh();
       // A card that waits for the user is brought into the stage's view: in
       // a short window the prompt and headline fill it and the card sat
-      // below, out of sight (once the stage has grown for it).
-      if (waits) frame.afterGrowth(() => frame.reveal(slot));
+      // below, out of sight (once the stage has grown for it). A question
+      // with the room reads from the reply's start instead (its pill leads
+      // to the card); its pill shows from here on.
+      if (waits) {
+        frame.afterGrowth(() => {
+          const ask = askCard();
+          frame.reveal(slot, { fromStart: !!ask && ask === roomCard });
+          arrived = ask;
+          drawPill();
+        });
+      }
       return true;
     },
     // Where the live timing line goes (the status row), null: the history.

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

@@ -332,7 +332,11 @@ export function createStreamHandlers(deps) {
     },
     question_requested: (data) => {
       const pq = data.pending_question;
-      if (pq && pq.id) questionCards.renderQuestion(pq);
+      if (!pq || !pq.id) return;
+      // A plugin's refs on the reply that asks: on its step before the card
+      // draws the asking slot.
+      if (pq.refs) turnDom.questionRefs?.(pq.refs);
+      questionCards.renderQuestion(pq);
     },
     question_answered: (data) => {
       questionCards.resolveQuestion(data.id, { answer: data.answer });

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

@@ -174,6 +174,26 @@ export function askingText(turn) {
   return gen.text.trim();
 }
 
+// A plugin's refs on the reply that asks (a question's refs, from its
+// pending question): kept on the asking step's gen, the last one, while
+// the turn goes on, for the stage's asking slot (askingRefs) and the
+// step's closed text (turn_view.js). A non-array or an empty list keeps
+// what the gen has. The gen, or null.
+export function questionRefs(turn, refs) {
+  if (!turn || turn.ended || !Array.isArray(refs) || !refs.length) return null;
+  const gen = turn.gens[turn.gens.length - 1];
+  if (!gen) return null;
+  gen.refs = refs;
+  return gen;
+}
+
+// The refs on the asking text (questionRefs), while it shows
+// (askingText's rule); else null.
+export function askingRefs(turn) {
+  if (!askingText(turn)) return null;
+  return turn.gens[turn.gens.length - 1].refs || null;
+}
+
 // The turn is over (completed, canceled, failed, the worker gone).
 export function turnEnded(turn) {
   const closed = closeCurrent(turn);

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

@@ -21,7 +21,7 @@
 // chrome (CSS :has), so a plain answer streams like today's bubble, and is
 // removed at the end: the answer bubble takes its place.
 import { html, nothing, render } from "./vendor/lit-html.js";
-import { setAnswerRefs } from "./answer_refs.js";
+import { answerRefsOf, setAnswerRefs } from "./answer_refs.js";
 import { bindRowRefs } from "./refs.js";
 import { leavesBlock } from "./card.js";
 import { failedTurnText, normalize, sourceLabel } from "./format.js";
@@ -70,13 +70,14 @@ function thinkingTemplate({ body, wrapped = true, line = null, cls = "thinking",
 // the newest last), the live "…" until the first one, or a closed step's
 // full text. None when there is nothing to say. A closed step's text is
 // set whole (.textContent): its refs (ref_scan.js) split it into spans
-// that a text part's update would leave behind.
-function textTemplate(text, { live, sentences, placeholder }) {
+// that a text part's update would leave behind. +at+: a reloaded step's
+// message index, for its refs (data-answer-at, as an answer's).
+function textTemplate(text, { live, sentences, placeholder, at = null }) {
   if (live && sentences?.length) {
     return html`<div class="gen-text streaming"><div class="narration">${sentences.map((s) => html`<div class="sentence">${s}</div>`)}</div></div>`;
   }
   if (live) return placeholder ? html`<div class="gen-text streaming">…</div>` : nothing;
-  return text ? html`<div class="gen-text" .textContent=${text}></div>` : nothing;
+  return text ? html`<div class="gen-text" data-answer-at=${at ?? nothing} .textContent=${text}></div>` : nothing;
 }
 
 // One step, live or reloaded. +gen+: { text, thinking, tools, answer } (a
@@ -86,16 +87,17 @@ function textTemplate(text, { live, sentences, placeholder }) {
 // answers, its +items+ (tool rows, notices, cards: nodes or templates; a
 // reload's are its rows' nodes), the thinking +body+ node, the ticker's
 // +line+, the narration's +sentences+ and "…" +placeholder+, +on+ (the
-// click and toggle handlers).
+// click and toggle handlers). A reload's +at+: the step's message index
+// (textTemplate).
 export function stepTemplate(gen, st = {}) {
   const { live = false, index = 0, open = live, steers = [], items = [], body = gen.thinking, line = null,
-    sentences = null, placeholder = false, on = {} } = st;
+    sentences = null, placeholder = false, on = {}, at = null } = st;
   const text = gen.answer ? "" : gen.text || "";
   const label = live ? { repeats: false, content: `step ${index + 1}` } : closedLabel({ ...gen, text });
   const failed = !live && model.failedCount(gen.tools) > 0;
   // A step left with its thinking only reads "thinking" once.
   const wrapped = live || !!text || gen.tools.length > 0;
-  return html`<details class=${`gen${live ? " live" : ""}${failed ? " has-failed" : ""}`} .open=${open}><summary class=${label.repeats ? "repeats" : nothing} @click=${on.stepClick ?? nothing}>${label.content}</summary>${steers}${gen.thinking ? thinkingTemplate({ body, wrapped, line, on }) : nothing}${textTemplate(text, { live, sentences, placeholder })}${items.length ? html`<div class="activity-body">${items}</div>` : nothing}</details>`;
+  return html`<details class=${`gen${live ? " live" : ""}${failed ? " has-failed" : ""}`} .open=${open}><summary class=${label.repeats ? "repeats" : nothing} @click=${on.stepClick ?? nothing}>${label.content}</summary>${steers}${gen.thinking ? thinkingTemplate({ body, wrapped, line, on }) : nothing}${textTemplate(text, { live, sentences, placeholder, at })}${items.length ? html`<div class="activity-body">${items}</div>` : nothing}</details>`;
 }
 
 // A hook's line (hook_notice) as a step's row. data.line is a whole row of
@@ -254,6 +256,10 @@ export function createTurnView({
       live: !entry.closed, index: entry.index, open: entry.open, steers: entry.steers, items: entry.items,
       body: entry.thinkingText, line: entry.line, sentences: entry.sentences, placeholder: entry.placeholder, on: entry.on,
     }), entry.frag, { renderBefore: entry.end });
+    // A closed step that asked a question knows its refs (model.questionRefs):
+    // the page pairs them with its text at the turn's end (linkTextRefs).
+    const text = entry.closed && entry.gen.refs ? entry.el?.querySelector(":scope > .gen-text") : null;
+    if (text && !answerRefsOf(text)) setAnswerRefs(text, entry.gen.refs);
   }
 
   // A step's nodes (lit's start marker, the <details>, the end marker), to
@@ -776,6 +782,10 @@ export function createTurnView({
     // The running turn's asking reply (turn_model.js askingText): what a
     // question or approval card keeps once answered.
     askingText: () => model.askingText(turn),
+    // A question's refs (its pending question's) on the step that asks it.
+    questionRefs(refs) {
+      if (turn) model.questionRefs(turn, refs);
+    },
     step(i) {
       const entry = turn && genEls.get(turn.gens[i]);
       return entry ? { el: entry.el, summary: entry.el.querySelector(":scope > summary"), thinkingWrap: thinkingWrap(entry) } : null;
@@ -880,6 +890,8 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
         // The steers the step answered first, where the live rows went.
         steers: (group.steps[k].steers || []).map((i) => steerTemplate(i, false)),
         items: gen.tools.length ? [rowNodes(gen.tools, thumbs)] : [],
+        // Its text knows its message's refs (a question's), as an answer does.
+        at: group.steps[k].i,
       }));
       parts.push(html`<details class="turn-work done"><summary>${model.blockSummary({ gens, ended: true })}</summary>${steps}</details>`);
       outlines.push(gens);
@@ -910,8 +922,9 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
   const out = nodesOf(parts);
   // A finished turn's block as the live end leaves it: its outline, open.
   [...out.children].filter((el) => el.matches(".turn-work")).forEach((block, i) => outlineBlock(block, outlines[i] || []));
-  // Each answer bubble knows its message's refs (answer_refs.js; the
-  // page pairs them after the render), the index stays out of the DOM.
+  // Each answer bubble and step text knows its message's refs
+  // (answer_refs.js; the page pairs them after the render), the index
+  // stays out of the DOM.
   for (const bubble of out.querySelectorAll("[data-answer-at]")) {
     setAnswerRefs(bubble, items[Number(bubble.dataset.answerAt)]?.display_refs);
     bubble.removeAttribute("data-answer-at");

data/lib/samagotchi/worker.rb

@@ -237,6 +237,7 @@ module Samagotchi
       @config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :worker) do |message|
         @engine.announce(type: :hook_notice, hook: "config", text: message, level: :warn, between_turns: true)
       end
+      prune_tombstones
       settle_interrupted_turn
       # Before the Bridge serves anything: a UI joining a resumed worker's
       # stream gets the session's history and status in its snapshot, not
@@ -491,6 +492,15 @@ module Samagotchi
       save_or_log(:interrupted_turn) { save_session }
     end
 
+    # The per-input tombstones (removed, settled) older than
+    # SessionInbox::TOMBSTONE_MAX_AGE, once per worker start: they only go
+    # with the session dir otherwise.
+    def prune_tombstones
+      removed = SessionInbox.prune_removed(@session_dir)
+      settled = TurnCheckpoint.prune_settled(@session_dir)
+      Log.info(:worker, "tombstones_pruned", removed: removed, settled: settled) if (removed + settled).positive?
+    end
+
     # A saved parent_answers that isn't a level reads as hard on every
     # answer without a word; said once here, as the session loads.
     def announce_session_warnings
@@ -958,6 +968,8 @@ module Samagotchi
       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 }
       event[:anytime] = true if anytime
+      # The session's title after /title (nil: cleared), for the TUIs' row.
+      event[:title] = @engine.session&.title if changed.include?(:title)
       # Its line was shown at its command_queued (waits: turn_end).
       event[:queued] = true if command.waits_for_turn_end?
       # The chips the command moved (SessionSetting#changed_by): what the next
@@ -1259,12 +1271,14 @@ module Samagotchi
       # The Bridge serves before the idle-exit policy exists.
       return WorkerIdleExit::Hold.new(reason: :starting) unless @idle_exit
 
-      hold = restart ? @idle_exit.hold_for_restart : @idle_exit.hold_for_request(requester: client_id)
-      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)
+      if restart
+        hold = @idle_exit.hold_for_restart
+        return WorkerIdleExit::Hold.new(reason: hold) if hold
+      else
+        # /exit names the tasks it waits for (D3), from the one look that found them.
+        hold = @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT)
+        return hold if hold
       end
-      return WorkerIdleExit::Hold.new(reason: hold) if hold
 
       @exit_requested = true
       @exit_requested_by = client_id

data/lib/samagotchi/worker_idle_exit.rb

@@ -94,15 +94,23 @@ module Samagotchi
     #   still be open, untagged)
     # @return [Symbol, nil] :turn_running, :input_queued, :continue_offered,
     #   :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?
+    def hold_for_request(requester:, streams: true) = request_hold(requester: requester, streams: streams)&.reason
 
-      nil
+    # #hold_for_request as a Hold: for :background_tasks, the watched tasks
+    # still running, read once (TaskWatch#running looks at each task's
+    # process), with +hint+.
+    # @return [Hold, nil]
+    def request_hold(requester:, streams: true, hint: nil)
+      reason = if @engine.turn_running? then :turn_running
+               elsif @input_pending.call then :input_queued
+               elsif @awaiting_continue.call then :continue_offered
+               elsif streams && @bridge && @bridge.open_streams_except(requester).positive? then :client_connected
+               elsif @engine.reminder_store&.any? then :reminders
+               end
+      return Hold.new(reason: reason) if reason
+
+      running = @watched_running.call
+      running.any? ? Hold.new(reason: :background_tasks, tasks: running, hint: hint) : nil
     end
 
     # What keeps the worker from restarting now (a client asked: POST /exit

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.96.0
+  version: 0.98.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -437,6 +437,7 @@ files:
 - lib/samagotchi/memory_bundle/system_bundle.rb
 - lib/samagotchi/memory_bundle/trash.rb
 - lib/samagotchi/memory_bundle/uninstaller.rb
+- lib/samagotchi/memory_command.rb
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/message_parts.rb
 - lib/samagotchi/model_catalog.rb
@@ -484,6 +485,7 @@ files:
 - lib/samagotchi/prompt_note.rb
 - lib/samagotchi/prompt_warmup.rb
 - lib/samagotchi/question_answer.rb
+- lib/samagotchi/question_asked.rb
 - lib/samagotchi/question_desk.rb
 - lib/samagotchi/queued_command.rb
 - lib/samagotchi/reasoning_history.rb