samagotchi 0.5.1 → 0.6.0

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

@@ -21,7 +21,6 @@ import { MODEL_KEY } from "./model_pick.js";
 import { createModelPicker } from "./model_picker.js";
 import { chipName, chipsHtml, imageFiles, restoredChips, thumbsHtml, turnRefs, turnText } from "./images.js";
 import { escapeHtml, messageBodyHtml, noteHtml, normalize, steerRowHtml, userBodyHtml, ownerBadge, previewForCard, relativeTime, firstMessageOf, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy } from "./format.js";
-import { chatHistoryHtml, createChatView } from "./chat_view.js";
 import { createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { createStageView } from "./stage_view.js";
 import { annotateBarLeft, annotationSource, appendQuote, quoteBlock } from "./annotations.js";
@@ -31,7 +30,7 @@ import { routeChunk } from "./chunk_router.js";
 import { extractCtxPct, savedCtxPct, cardCtxText } from "./ctx.js";
 import { diffHtml } from "./diff_view.js";
 import { approvalAllowed, approvalView, isApproval, nextCardAction, resultText, summaryText } from "./question_card.js";
-import { cardClass, cardInnerHtml, cardPlace, splitSnapshotCards, turnNoticePlace } from "./card.js";
+import { cardClass, cardInnerHtml, cardPlace, isCard, splitSnapshotCards, turnNoticePlace } from "./card.js";
 import { gripFloor, promptHeight } from "./composer_size.js";
 import { commandMatches, commandRow, moveSelection, pickCommand } from "./command_complete.js";
 import { ALL_SESSIONS_HASH, sessionHash, sessionIdFromHash } from "./route.js";
@@ -44,7 +43,7 @@ import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, normalizeTiming, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, continueLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, continueLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -73,14 +72,12 @@ let resyncsInFlight = 0;
 let resyncAgain = false;
 let allSessions = [];
 let seenContent = new Set();
-// The page's view of a turn (web.view, or ?view=turn|stage|chat): one block
-// per turn with its steps (turn_view.js), the running turn pinned above the
-// composer (the stage), or a row of bubbles (chat_view.js).
-const view = ["turn", "stage", "chat"].includes(document.body.dataset.view) ? document.body.dataset.view : "turn";
-// The turn and stage views draw a turn as steps (a reload asks for parts).
-const turnView = view !== "chat";
-// The running turn's DOM: the streaming bubbles, the thinking block and the
-// activity panel, the turn block, or the stage (the turn block in its cloud).
+// The page's view of a turn (web.view, or ?view=stage|turn): the running
+// turn pinned above the composer (the stage, stage_view.js), or one block
+// per turn with its steps in the history (turn_view.js).
+const view = ["stage", "turn"].includes(document.body.dataset.view) ? document.body.dataset.view : "stage";
+// The running turn's DOM: the turn block, or the stage (the turn block in
+// its cloud).
 const viewArgs = {
   historyEl,
   appendToHistory: (el) => appendToHistory(el),
@@ -90,7 +87,7 @@ const viewArgs = {
 };
 const turnDom = view === "stage"
   ? createStageView({ ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl })
-  : (turnView ? createTurnView : createChatView)(viewArgs);
+  : createTurnView(viewArgs);
 // Where a running turn's rows can be: the history, and the stage while it
 // holds a turn (lookups by id, copy, annotate, card actions).
 function turnRoots() {
@@ -683,7 +680,7 @@ async function resync({ endText = null } = {}) {
   let data;
   try {
     try {
-      data = await getSession(id, { parts: turnView });
+      data = await getSession(id, { parts: true });
     } catch (e) {
       if (e.status === 404) return leaveGoneSession(id, "not_found");
       if (id === selected) historyEl.innerHTML = `<div class="hint">Error: ${escapeHtml(e.message)}</div>`;
@@ -749,9 +746,11 @@ function renderSessionView(data) {
   seedSeenFromDom();
   seedInitTasks(initTasks, data.init_tasks);
   renderInitRow();
-  // A guardrail file that failed to load, announced before this page joined.
-  showGuardrailWarning(data.guardrail_warning);
-  showGuardrailWarning(data.plugin_warning, "plugins");
+  // A guardrail file that failed to load, announced before this page
+  // joined: where it came (the snapshot's cards), else at the end.
+  const loadWarned = (label) => (data.cards || []).some((c) => c?.type === "guardrail_warning" && (c.label || "guardrails") === label);
+  if (!loadWarned("guardrails")) showGuardrailWarning(data.guardrail_warning);
+  if (!loadWarned("plugins")) showGuardrailWarning(data.plugin_warning, "plugins");
   // The recap saved with the session (also a stopped one's), else a live
   // worker's from before saved_recap existed.
   if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since);
@@ -789,10 +788,8 @@ function renderHistory(items) {
     historyEl.innerHTML = `<div class="hint">No output yet. Send a message.</div>`;
     return;
   }
-  if (typeof items[0] === "object" && items[0].role && turnView) {
+  if (typeof items[0] === "object" && items[0].role) {
     historyEl.innerHTML = turnHistoryHtml(items, currentTiming, { thumbs: (images) => thumbsHtml(selected, images) });
-  } else if (typeof items[0] === "object" && items[0].role) {
-    historyEl.innerHTML = chatHistoryHtml(items, currentTiming, { thumbs: (images) => thumbsHtml(selected, images) });
   } else {
     historyEl.innerHTML = items.map((c) => `<div class="bubble output">${escapeHtml(c)}</div>`).join("");
   }
@@ -905,7 +902,7 @@ function addEndBubble(text) {
 function endTurnView(kind, endText = null) {
   setTurnRunning(false);
   const kept = turnDom.turnEnded({ kind }) || [];
-  finishLiveTurnTiming();
+  finishLiveTurnTiming(null, { canceled: kind === "canceled" });
   if (endText) addEndBubble(endText);
   if (kept.length) {
     kept.forEach((el) => appendToHistory(el));
@@ -1034,7 +1031,7 @@ function showRecap(text, turnsSince = 0) {
   details.appendChild(body);
   // A stale one sits where it was written, above the turns it doesn't cover.
   // Never in the stage: a recap is between turns.
-  const before = recapPlace([...historyEl.querySelectorAll(":scope > .bubble.user")], turnsSince);
+  const before = recapPlace(turnPromptBubbles(), turnsSince);
   keepFollowing(historyEl, () => (before ? historyEl.insertBefore(details, before) : appendAboveLiveTiming(historyEl, details, liveTurnTimingEl)));
 }
 
@@ -1049,21 +1046,23 @@ function markRecapStale() {
 
 // A guardrail hook or rule file that failed to load (once per worker), or
 // a bundle's plugin (+label+ "plugins").
-function showGuardrailWarning(text, label = "guardrails") {
+// +before+: the element it goes above (a snapshot's), else the end.
+function showGuardrailWarning(text, label = "guardrails", { before = null } = {}) {
   if (!text) return;
   const el = document.createElement("div");
   el.className = "bubble guardrail-warning";
   el.textContent = `${label}: ${text}`;
   const follow = isNearBottom();
-  appendToHistory(el);
+  if (before) historyEl.insertBefore(el, before);
+  else appendToHistory(el);
   if (follow) historyEl.scrollTop = historyEl.scrollHeight;
 }
 
 // A hook's line to the user (event[:notify]): "<bundle>: text", in the
 // warning colour for level warn.
 // +before+: the element it goes above (a snapshot's notice), else the end.
-// A plugin's steers (pending_input_merged's steers): in the turn view a row
-// of the running turn's step, else a bubble.
+// A plugin's steers (pending_input_merged's steers): a row of the running
+// turn's step, else (no turn runs) a bubble.
 function showSteers(steers) {
   for (const steer of steers || []) {
     if (turnDom.steer(steer)) continue;
@@ -1080,7 +1079,7 @@ function showHookNotice(data, { before = null } = {}) {
   removeHintIfEmpty();
   const el = document.createElement("div");
   el.className = "bubble hook-notice" + (data.level === "warn" ? " warn" : "");
-  el.textContent = `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
+  el.textContent = data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
   const follow = isNearBottom();
   if (before) historyEl.insertBefore(el, before);
   else appendToHistory(el);
@@ -1101,6 +1100,9 @@ function cardElement(id) {
 function drawCard(el, card) {
   el.className = cardClass(card);
   el.dataset.cardId = card.id;
+  // A running turn's own card (the stage's status waits on one that asks).
+  if (card.in_turn) el.dataset.inTurn = "1";
+  else delete el.dataset.inTurn;
   if (card.body_html === undefined && el.dataset.body === String(card.body ?? "") && el.querySelector(".card-body")) {
     // The same body again from the stream: keep the rendered one.
     const body = el.querySelector(".card-body").innerHTML;
@@ -1139,41 +1141,35 @@ function upsertCard(card, { before = null } = {}) {
 // A snapshot's cards and notices, each above the first turn after it; a
 // turn's own notice where it showed live (placeTurnNotice).
 function placeSnapshotCards(entries) {
-  const users = [...historyEl.querySelectorAll(":scope > .bubble.user")];
+  const users = turnPromptBubbles();
   for (const entry of entries) {
     const before = cardPlace(users, entry);
-    if (entry.type === "hook_notice" && entry.in_turn) placeTurnNotice(entry, before);
+    if (isCard(entry)) upsertCard(entry, { before });
+    else if (entry.type === "question") placeResolvedQuestion(entry, before);
+    else if (entry.type === "guardrail_warning") showGuardrailWarning(entry.message, entry.label || "guardrails", { before });
+    else if (entry.in_turn) placeTurnNotice(entry, before);
     else if (entry.type === "hook_notice") showHookNotice(entry, { before });
-    else upsertCard(entry, { before });
   }
 }
 
-// A finished turn's hook notice (+before+: the next turn's prompt, or null
-// for the last turn): in the turn view a row of its step, above the row of
-// the call it came before, as live; else (the chat view, a plain answer, a
-// step the history doesn't have) a bubble before the turn's answer, or
-// before its timing line when it has none.
+// A finished turn's row, a hook's notice or the loop's asking again
+// (+before+: the next turn's prompt, or null for the last turn): a row of
+// its step, above the row of the call it came before, as live; else (a
+// plain answer, a step the history doesn't have) a bubble before the
+// turn's answer, or before its timing line when it has none.
 function placeTurnNotice(entry, before) {
-  const turnEls = [];
-  for (let el = before ? before.previousElementSibling : historyEl.lastElementChild; el; el = el.previousElementSibling) {
-    turnEls.unshift(el);
-    if (el.matches(".bubble.user")) break;
-  }
+  const line = noticeLine(entry);
+  const turnEls = reloadedTurnEls(before);
   const place = turnNoticePlace(entry);
   const block = turnEls.find((el) => el.matches(".turn-work"));
   const step = place && block ? block.querySelectorAll(":scope > .gen")[place.step] : null;
   if (!step) {
-    // The chat view's canceled turn has no answer: its text bubbles are
-    // partial narration the notice came after.
-    const canceled = !turnView && turnEls.some((el) => el.matches(".bubble.cancel"));
-    const answer = canceled ? null : turnEls.filter((el) => el.matches(".bubble.output")).pop();
-    const timing = turnEls.find((el) => el.matches(".turn-timing"));
-    showHookNotice(entry, { before: answer || timing || before });
+    showHookNotice({ ...entry, line }, { before: turnAnswerEl(turnEls) || before });
     return;
   }
   const el = document.createElement("div");
   el.className = "hook-notice" + (entry.level === "warn" ? " warn" : "");
-  el.textContent = `${hookNoticeLabel(entry.hook)}: ${entry.text || ""}`;
+  el.textContent = line;
   let body = step.querySelector(":scope > .activity-body");
   if (!body) {
     body = document.createElement("div");
@@ -1184,6 +1180,49 @@ function placeTurnNotice(entry, before) {
   body.insertBefore(el, row || null);
 }
 
+// A prompt that started a turn: not a line steered into a running one.
+const TURN_PROMPT = ".bubble.user:not(.steered)";
+
+// The history's turn prompts, oldest first (what turns_since counts).
+function turnPromptBubbles() {
+  return [...historyEl.querySelectorAll(`:scope > ${TURN_PROMPT}`)];
+}
+
+// The elements of the reloaded turn that ends before +before+ (the next
+// turn's prompt, or null for the last turn), its prompt first.
+function reloadedTurnEls(before) {
+  const turnEls = [];
+  for (let el = before ? before.previousElementSibling : historyEl.lastElementChild; el; el = el.previousElementSibling) {
+    turnEls.unshift(el);
+    if (el.matches(TURN_PROMPT)) break;
+  }
+  return turnEls;
+}
+
+// What goes after a reloaded turn's own rows and cards: its answer, else
+// its timing line; null when it has neither.
+function turnAnswerEl(turnEls) {
+  return turnEls.filter((el) => el.matches(".bubble.output")).pop() || turnEls.find((el) => el.matches(".turn-timing")) || null;
+}
+
+// A finished turn's question (the snapshot's cards keep it with its
+// answer): the card as it was left live, resolved, before the lines the
+// user sent into the turn after it (a steered bubble's data-step: the step
+// that read it) and the turn's answer. A pending one is the running turn's
+// (pending_question draws it).
+function placeResolvedQuestion(entry, before) {
+  const pq = entry.pending_question;
+  if (!pq?.id || !(entry.answer || entry.cancelled)) return;
+  renderQuestionCard(pq);
+  const card = questionCardEl;
+  if (!card || card.dataset.qid !== String(pq.id)) return;
+  resolveQuestionCard(pq.id, { answer: entry.answer || null, cancelled: !!entry.cancelled, reason: entry.reason || "" });
+  const turnEls = reloadedTurnEls(before);
+  const asked = Number(entry.iteration) || 1;
+  const later = turnEls.find((el) => el.matches(".bubble.user.steered") && Number(el.dataset.step) > asked);
+  historyEl.insertBefore(card, later || turnAnswerEl(turnEls) || before);
+}
+
 // A live card's body comes as text; the worker's snapshot (through the
 // server) has it rendered. One re-read for a burst of cards.
 let cardBodiesTimer = null;
@@ -1337,7 +1376,9 @@ function setLiveTurnNote(text) {
   if (currentTiming.activeTurn) updateLiveTiming();
 }
 
-function finishLiveTurnTiming(record = null) {
+// A canceled turn's line says so (+canceled+, or its record's status), as
+// a reload's does.
+function finishLiveTurnTiming(record = null, { canceled = false } = {}) {
   const duration = Number.isFinite(Number(record?.duration_ms))
     ? Number(record.duration_ms)
     : elapsedSince(currentTiming.activeTurn?.started_at);
@@ -1345,7 +1386,8 @@ function finishLiveTurnTiming(record = null) {
     liveTurnNote = "";
     liveTurnTimingEl.classList.remove("live");
     const at = record ? currentTiming.turnRecords.indexOf(record) : -1;
-    liveTurnTimingEl.textContent = turnTimingText(at >= 0 ? at + 1 : liveTurnNumber, duration);
+    liveTurnTimingEl.textContent = turnTimingText(at >= 0 ? at + 1 : liveTurnNumber, duration,
+      { canceled: canceled || record?.status === "canceled" });
   }
   currentTiming.activeTurn = null;
   clearTimingInterval();
@@ -1496,7 +1538,7 @@ const streamHandlers = {
     // that the rendered markdown is in it (or the re-read failed: then the
     // plain text pops), and the display if one was coming, so the links
     // never swap in after the pop. The hold reveals by itself after
-    // HOLD_MS whatever comes. The chat view has no hold.
+    // HOLD_MS whatever comes. The stage has no hold.
     if (display) await display;
     turnDom.answerReady?.();
   },
@@ -1611,10 +1653,10 @@ const streamHandlers = {
     if (!turnRunning) showRecap(data.recap);
   },
   guardrail_warning: (data) => showGuardrailWarning(data.message, data.label || "guardrails"),
-  // In the turn view, a notice during a turn is a row of its current step.
+  // A notice during a turn is a row of its current step.
   hook_notice: (data) => { if (!turnDom.notice(data)) showHookNotice(data); },
-  // The loop asks again after an empty answer: a row of the empty step (the
-  // chat view shows nothing; after a reload neither does the turn view).
+  // The loop asks again after an empty answer: a row of the empty step
+  // (a reload puts it back from the snapshot's cards).
   empty_answer_retry: (data) => { turnDom.notice({ line: emptyRetryLine(data) }); },
   // The provider is asked again after an error, or the turn waits for
   // plugins' setup: a note on the live timing line until it streams.

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

@@ -53,15 +53,22 @@ export function cardPlace(userBubbles, card) {
 // (a row of its current step once the turn is drawn), and the ones that
 // came during the running turn but aren't its own (an anytime command's,
 // such as /btw: after the running turn once it is drawn, as they came).
+// The running turn's own rows (a hook's notice, a retry) are left out:
+// they come with the turn's parts (snapshotEvents).
 export function splitSnapshotCards(cards) {
   const list = Array.isArray(cards) ? cards : [];
   return {
     placed: list.filter((c) => !c.current && !c.during),
-    current: list.filter((c) => c.current),
+    current: list.filter((c) => c.current && isCard(c)),
     during: list.filter((c) => !c.current && c.during),
   };
 }
 
+// An entry of the snapshot's cards that is a card (not a notice or a row).
+export function isCard(entry) {
+  return (entry?.type ?? "card") === "card";
+}
+
 // Where a snapshot's turn notice (a hook's notice during a turn, in_turn)
 // goes in its reloaded turn's block: the step of its iteration (the
 // iteration-th .gen, 0-based index here) and the key of the tool row it

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

@@ -25,7 +25,7 @@ export function noteHtml(note) {
 
 // A plugin's steer (a nudge put into the running turn): one line that
 // names who nudged the model, its text collapsed under it. +bubble+: on its
-// own between bubbles (the chat view), not a row of a step.
+// own between bubbles (no step holds it), not a row of a step.
 export function steerRowHtml({ source, text } = {}, { bubble = false } = {}) {
   const who = source ? `${source} nudged the model` : "nudged the model";
   return `<details class="${bubble ? "bubble " : ""}steer-row"><summary>${escapeHtml(who)}</summary>` +

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

@@ -104,11 +104,6 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .bubble.recap summary{cursor:pointer;color:var(--think-text);font-size:12px}
 .bubble.recap .recap-body{white-space:pre-wrap;margin-top:6px}
 .bubble.recap.stale{opacity:.7;border-left-style:dashed}
-.bubble.activity{border-left:3px solid var(--accent);background:var(--bg-panel);padding:8px 12px}
-.bubble.activity>summary{cursor:pointer;color:var(--text-muted);font-size:13px;font-weight:600;user-select:none;list-style:none}
-.bubble.activity>summary::-webkit-details-marker{display:none}
-.bubble.activity>summary::before{content:"▸ ";color:var(--accent)}
-.bubble.activity[open]>summary::before{content:"▾ "}
 .activity-body{margin-top:6px}
 .activity-row{display:flex;gap:8px;align-items:baseline;font-size:13px;color:var(--text-2);padding:5px 2px;border-top:1px solid var(--border)}
 .activity-row:first-child{border-top:none}
@@ -561,6 +556,8 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
   #composeHint{display:none}
   #infoBar{flex-wrap:nowrap;align-items:center;gap:6px;padding:6px 10px 8px}
   #infoBar .preview-line{display:none}
+  /* No terminal on a phone to attach from. */
+  #infoBar .meta .copy-attach{display:none}
   #infoBar .meta{flex-wrap:nowrap;overflow-x:auto;scrollbar-width:none;white-space:nowrap}
   #infoBar .meta::-webkit-scrollbar{display:none}
   #infoBar .meta>*{flex-shrink:0}

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

@@ -3,6 +3,7 @@
 // history, and in what order its pieces go there. No DOM, so `node --test`
 // covers the rules; stage_view.js draws them.
 import { toolName } from "./activity.js";
+import { splitSentences } from "./sentences.js";
 
 const READ_LIKE = new Set(["read", "memory_read", "web_fetch", "task_get", "task_list", "list_sessions"]);
 const EDITS = new Set(["edit", "write", "memory_write"]);
@@ -14,6 +15,49 @@ export const QUIET_MS = 1500;
 // A touch, wheel or scroll counts as use this long (phones have no hover).
 export const TOUCH_MS = 4000;
 
+// One headline sentence as plain text: the markdown a streaming answer
+// carries (headings, quotes, bullets, table pipes, emphasis, code ticks,
+// links) goes, and a line that is only syntax (a code fence, a table's
+// separator row, a rule) is empty. A small pass, no renderer: a live line
+// only needs to read well, and an unclosed "**" mid-stream goes too.
+export function plainHeadline(line) {
+  let s = String(line ?? "").trim();
+  if (/^(```|~~~)/.test(s)) return "";
+  if (/^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?$/.test(s)) return "";
+  if (/^([-*_])(\s*\1){2,}$/.test(s)) return "";
+  s = s.replace(/^(>\s*)+/, "").replace(/^#{1,6}\s+/, "").replace(/^[-*+]\s+(\[[ xX]\]\s+)?/, "");
+  // A table row: a pipe at either end (a pipe mid-prose, "a || b", stays).
+  if (/^\||\|$/.test(s)) {
+    s = s.replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim()).filter(Boolean).join(" · ");
+  }
+  // Code spans keep their text as is; an unclosed tick just goes.
+  const code = [];
+  s = s.replace(/`+([^`]+)`+/g, (_, c) => `\u0000${code.push(c) - 1}\u0000`);
+  s = s
+    .replace(/!\[([^\]]*)\]\([^)]*\)?/g, "$1")
+    .replace(/\[([^\]]*)\]\([^)]*\)?/g, "$1")
+    .replace(/<(https?:\/\/[^>\s]+)>/g, "$1")
+    .replace(/`+/g, "")
+    .replace(/(^|[^\w])__(?=\S)(.*?\S)__(?=$|[^\w])/g, "$1$2")
+    .replace(/(\*\*|~~)/g, "")
+    .replace(/(^|[^\w*])\*(?=\S)([^*]*?\S)\*(?=$|[^\w*])/g, "$1$2")
+    .replace(/(^|[^\w])_(?=\S)([^_]*?\S)_(?=$|[^\w])/g, "$1$2")
+    .replace(/\u0000(\d+)\u0000/g, (_, i) => code[Number(i)]);
+  return s.replace(/\s+/g, " ").trim();
+}
+
+// The step's newest narration sentence, as plain text: the end of a
+// finished text is a boundary (its last line may have no period), a live
+// one's not yet. A sentence that is only markdown syntax is skipped.
+export function headlineOf(text, done) {
+  const { sentences, rest } = splitSentences(text, { atEnd: true });
+  const fragment = plainHeadline(rest);
+  if (done && fragment) return fragment;
+  const plain = sentences.map(plainHeadline).filter(Boolean);
+  if (plain.length) return plain[plain.length - 1];
+  return fragment.length > 160 ? fragment : "";
+}
+
 // A tool's tick colour: read-like, edit, exec or other.
 export function toolKind(name) {
   if (READ_LIKE.has(name)) return "read";

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

@@ -11,8 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { handOffDue, handOffOrder, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
-import { splitSentences } from "./sentences.js";
+import { handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 
 const COLLAPSE_KEY = "chi_stage_collapsed";
@@ -23,6 +22,10 @@ const SETTLE_CAP_MS = 8000;
 const FOLD_MS = 420;
 const FLASH_MS = 4000;
 const PENDING = ".bubble.question:not(.answered):not(.cancelled), .bubble.continue:not(.resolved)";
+// A running turn's card with actions (check-in's Nudge / Keep going / Stop)
+// 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";
 const MARKS = { answered: "✓", canceled: "■", failed: "✕" };
 
 function node(tag, cls, parent = null) {
@@ -32,16 +35,6 @@ function node(tag, cls, parent = null) {
   return el;
 }
 
-// The step's newest narration sentence: the end of a finished text is a
-// boundary (its last line may have no period), a live one's not yet.
-function headlineOf(text, done) {
-  const { sentences, rest } = splitSentences(text, { atEnd: true });
-  const fragment = rest.replace(/\s+/g, " ").trim();
-  if (done && fragment) return fragment;
-  if (sentences.length) return sentences[sentences.length - 1];
-  return fragment.length > 160 ? fragment : "";
-}
-
 function readCollapsed() {
   try { return localStorage.getItem(COLLAPSE_KEY) === "1"; } catch (_) { return false; }
 }
@@ -153,6 +146,13 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     return !!(extras.querySelector(PENDING) || tail.querySelector(PENDING));
   }
 
+  function asksCard() {
+    return !endKind && !!extras.querySelector(ASKS);
+  }
+  // A card answered or redrawn in place (its buttons gone) changes the
+  // status without a turn event.
+  new MutationObserver(() => scheduleRefresh()).observe(extras, { childList: true, subtree: true });
+
   function refresh() {
     rafPending = false;
     const { turn, blockEl } = view.current();
@@ -169,12 +169,14 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     if (blockEl && blockEl.parentNode === cloudBody) blockEl.open = true;
     const narration = gen?.text ? headlineOf(gen.text, gen.textDone || gen.closed) : "";
     const thinking = thinkingLine && thinkingLine.step === turn.gens.length ? thinkingLine.text : "";
-    const pending = pendingCard();
-    const slots = liveSlots(turn, { narration, thinking, pending, ended: endKind });
+    // A question blocks the turn: its card takes the live slots' room. An
+    // asking card's turn goes on: the status waits, the slots stay.
+    const blocked = pendingCard();
+    const slots = liveSlots(turn, { narration, thinking, pending: blocked || asksCard(), ended: endKind });
 
     stage.classList.toggle("plain", plain);
     stage.classList.toggle("ended", !!endKind);
-    stage.classList.toggle("waiting", pending);
+    stage.classList.toggle("waiting", blocked);
     stage.dataset.phase = slots.phase;
     mark.textContent = MARKS[slots.phase] || "";
     phaseEl.textContent = slots.phase;
@@ -521,6 +523,11 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     turnEnded(args) {
       const kept = view.turnEnded(args) || [];
       if (!holding) return kept;
+      // The warn cards the extras kept in sight leave the turn with the
+      // block's (card.js leavesBlock): after the end line, as a reload has them.
+      const warn = [...extras.querySelectorAll(":scope > .plugin-card.warn")];
+      warn.forEach((el) => el.remove());
+      kept.push(...warn);
       view.chronological();
       endKind = args.kind;
       endedAt = Date.now();
@@ -542,7 +549,9 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
       return placed;
     },
     steer: (data) => view.steer(data),
-    card: (el) => view.card(el),
+    // A warn card (a plugin's warning) stays in sight: false puts it in the
+    // extras (place), not in its step inside the closed cloud.
+    card: (el) => !el.classList.contains("warn") && view.card(el),
     flush: () => view.flush(),
     answerReady() {
       settled = true;
@@ -564,7 +573,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
       const stick = slot.scrollHeight - slot.scrollTop - slot.clientHeight < 24;
       slot.appendChild(el);
       slot.hidden = false;
-      if (stick || el.matches?.(PENDING)) slot.scrollTop = slot.scrollHeight;
+      if (stick || el.matches?.(PENDING) || el.querySelector?.(ASKS)) slot.scrollTop = slot.scrollHeight;
       scheduleRefresh();
       return true;
     },

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

@@ -88,7 +88,9 @@ export function timedTurnIndexes(items) {
 // the last, in order; a text-less iteration leaves no message, so a text
 // can sit one step early: inspection, not truth) and its answer (the last
 // assistant message). Assistant messages before any prompt are answers on
-// their own. The turn index counts prompts, as timedTurnIndexes does.
+// their own. The turn index counts prompts, as timedTurnIndexes does. The
+// user's lines merged into the running turn (`merged`, the server's
+// Steer::INPUT_KIND) stay in it: the turn's `merged` list.
 export function turnGroups(items, timing) {
   const groups = [];
   let turnIndex = -1;
@@ -99,9 +101,11 @@ export function turnGroups(items, timing) {
     } else if (item?.role === "steer") {
       if (turn) turn.steers.push(i);
       else groups.push({ kind: "steer", i });
+    } else if (item?.role === "user" && item.merged && turn) {
+      turn.merged.push(i);
     } else if (item?.role === "user") {
       turnIndex += 1;
-      turn = { kind: "turn", turnIndex, user: i, texts: [], steers: [] };
+      turn = { kind: "turn", turnIndex, user: i, texts: [], steers: [], merged: [] };
       groups.push(turn);
     } else if (item?.role === "assistant") {
       if (turn) turn.texts.push(i);
@@ -110,7 +114,9 @@ export function turnGroups(items, timing) {
   });
   return groups.map((g) => {
     if (g.kind !== "turn") return g;
-    return withSteers(turnGroup(g, items, timing), g.steers, items);
+    const group = withSteers(turnGroup(g, items, timing), g.steers, items);
+    // A turn with no merged lines keeps its shape.
+    return g.merged.length ? { ...group, merged: g.merged } : group;
   });
 }
 

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

@@ -55,9 +55,18 @@ export function hookNoticeLabel(hook) {
   return /^[a-z][a-z0-9-]*$/.test(name) ? name : "hook";
 }
 
-// The row a step gets when the loop asks again after an empty answer.
-export function emptyRetryLine({ attempt, of } = {}) {
-  return `↻ empty answer, asking again (${attempt}/${of})`;
+// The row a step gets when the loop asks again after an empty answer, or
+// after a plugin cut the generation (stopped_by: the bundle).
+export function emptyRetryLine({ attempt, of, stopped_by: stoppedBy } = {}) {
+  const what = stoppedBy ? `cut by ${stoppedBy}` : "empty answer";
+  return `↻ ${what}, asking again (${attempt}/${of})`;
+}
+
+// The text of a turn's row from a snapshot entry (CardStore): a hook's
+// notice as "<label>: text", the loop's asking-again row as its line.
+export function noticeLine(entry = {}) {
+  if (entry.type === "empty_answer_retry") return emptyRetryLine(entry);
+  return `${hookNoticeLabel(entry.hook)}: ${entry.text || ""}`;
 }
 
 // The live turn's status while the provider is asked again after an error
@@ -211,6 +220,7 @@ export function promptOps(event, { myId, known, unmatchedMerge = false }) {
 // parts in order), then the prompts queued behind it. app.js feeds these to
 // its stream handlers, so a join renders exactly like watching live.
 // `merged_input` is the one synthetic type: a prompt merged into the turn.
+// A `notice` part carries its event as it came (TurnNotice).
 export function snapshotEvents({ current_turn: turn = null, queued = [], started_at = undefined } = {}) {
   const events = [];
   if (turn) {
@@ -256,9 +266,12 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
           closeText();
           events.push({ type: "reminder_injected", reminders: part.reminders || [] });
           break;
-        case "hook_notice":
+        // One of the turn's rows (a hook's notice, an empty-answer retry, a
+        // question and its answer): the event itself, which the live
+        // handler draws where it drew it live.
+        case "notice":
           closeText();
-          events.push({ type: "hook_notice", hook: part.hook, text: part.text, level: part.level });
+          if (part.event?.type) events.push({ ...part.event });
           break;
         // A plugin's steer: a steer-only merge, as live.
         case "steer":