samagotchi 0.148.0 → 0.149.0

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

@@ -0,0 +1,22 @@
+// An objectives note in the conversation, in place of the plain note bubble
+// (turn_html.js noteBubbleTemplate): the list as pills, or, for a later edit, one
+// line saying what the user changed. Read-only: the strip above the history is
+// where the list is edited (objectives_strip.js). The raw note text stays the
+// tooltip. A module of its own: static JS is cached at unversioned URLs.
+import { html, nothing } from "./vendor/lit-html.js";
+import { DROPPED, entryLine } from "./objectives_model.js";
+
+function pill(item) {
+  const klass = `obj-pill ${item.status}`;
+  return html`<span class=${klass} title=${item.done_when ? `done when: ${item.done_when}` : nothing}><span class="obj-id">${item.id}</span> ${item.status === "done" ? "✓ " : ""}${item.text}</span>`;
+}
+
+export function objectivesEntryTemplate(note, timeTitle = "") {
+  const line = entryLine(note.objectives);
+  const tip = [timeTitle, note.content].filter(Boolean).join("\n");
+  if (line) {
+    return html`<div class="bubble note objectives-entry change" title=${tip}><span class="obj-rule" aria-hidden="true"></span><span class="obj-change">${line}</span><span class="obj-rule" aria-hidden="true"></span></div>`;
+  }
+  const items = (note.objectives?.items || []).filter((i) => i.status !== DROPPED);
+  return html`<div class="bubble note objectives-entry" title=${tip}><span class="obj-entry-label">Objectives</span>${items.map(pill)}</div>`;
+}

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

@@ -0,0 +1,100 @@
+// The session's objectives as the page reads them (pure, no DOM): the fold the
+// server sends (Objectives.view: {items: [{id, text, status, done_when?,
+// move?, check?}], pending}) and what a list note's entry says (Objectives.entry:
+// {items, changes?}). See docs/internals/objectives.md.
+
+export const ACTIVE = "active";
+export const DONE = "done";
+export const DROPPED = "dropped";
+
+const itemsOf = (list) => (Array.isArray(list?.items) ? list.items : []);
+
+// The objectives the strip shows: active first, then done; a dropped one only
+// in the edit list.
+export function stripItems(list) {
+  const items = itemsOf(list);
+  return [...items.filter((i) => i.status === ACTIVE), ...items.filter((i) => i.status === DONE)];
+}
+
+// Done of the ones still meant (a dropped one doesn't count).
+export function progress(list) {
+  const kept = itemsOf(list).filter((i) => i.status !== DROPPED);
+  return { done: kept.filter((i) => i.status === DONE).length, total: kept.length };
+}
+
+// The one objective a one-line strip names: the first still active, else the
+// last one done.
+export function headline(list) {
+  const items = stripItems(list);
+  return items.find((i) => i.status === ACTIVE) || items[items.length - 1] || null;
+}
+
+// One change as words after "You": "marked O2 done", "reworded O3: old → new".
+export function changeText(change) {
+  const { id, kind, text, was } = change || {};
+  switch (kind) {
+    case "added": return `added ${id} ${text}`;
+    case "reworded": return `reworded ${id}: ${was} → ${text}`;
+    case DONE: return `marked ${id} done`;
+    case DROPPED: return `dropped ${id} ${text}`;
+    case "reopened": return `reopened ${id}`;
+    default: return String(id ?? "");
+  }
+}
+
+// An entry's line: what the user did, or null when it has nothing to say (a
+// first list, a list sent again), which then shows the list itself.
+export function entryLine(entry) {
+  const changes = Array.isArray(entry?.changes) ? entry.changes : [];
+  return changes.length ? `You ${changes.map(changeText).join(" · ")}` : null;
+}
+
+// The one route to an edit: the lines /objectives takes (ObjectivesCommand).
+const oneLine = (text) => String(text ?? "").replace(/\s+/g, " ").trim();
+export const markLine = (verb, id) => `/objectives ${verb} ${id}`;
+export const addLine = (text) => (oneLine(text) ? `/objectives add ${oneLine(text)}` : null);
+export const rewordLine = (id, text) => (oneLine(text) ? `/objectives edit ${id} ${oneLine(text)}` : null);
+
+// An item's text as the edit box shows it: the form /objectives reads back.
+export function editableText(item) {
+  return item?.done_when ? `${item.text} (done when: ${item.done_when})` : String(item?.text ?? "");
+}
+
+// What the strip says about an edit waiting for the running turn's end. Idle,
+// it lands in a moment and says nothing.
+export function pendingText(list, running) {
+  return list?.pending && running ? "Applies after this turn" : null;
+}
+
+// A check's line in the list: its verdict and reason, or that it runs. Information
+// only (ObjectivesCheck). null: no check of the latest move.
+export function checkText(check) {
+  if (!check) return null;
+  if (check.running) return "Checking…";
+  const word = check.verdict === "no_answer" ? "no answer" : check.verdict;
+  return `Check: ${word}${check.reason ? ` — ${check.reason}` : ""}`;
+}
+
+// When the soonest running check runs out, in ms; null with none. No event says so
+// when its worker dies.
+export function nextExpiry(list) {
+  const times = itemsOf(list).filter((i) => i.check?.running && i.check.until).map((i) => Date.parse(i.check.until)).filter(Number.isFinite);
+  return times.length ? Math.min(...times) : null;
+}
+
+// +list+ without the running checks past their time.
+export function expireChecks(list, now) {
+  if (!list) return list;
+  const gone = (i) => i.check?.running && Date.parse(i.check.until) <= now;
+  if (!itemsOf(list).some(gone)) return list;
+  return { ...list, items: list.items.map((i) => {
+    if (!gone(i)) return i;
+    const { check: _gone, ...rest } = i;
+    return rest;
+  }) };
+}
+
+// What a tap on Not yet tells the agent: a normal message, as if typed.
+export function notYetText(item) {
+  return `Not yet on ${item.id} (${item.text}).`;
+}

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

@@ -0,0 +1,145 @@
+// The model's moves on the objectives, as chips in the conversation. A tool row
+// of the objectives tool shows its id as a chip (moveRowText, turn_html.js, live
+// and reloaded alike), but a finished turn's steps collapse, so a finished turn
+// also gets a line of its moves between its block and its answer (mockup G). The
+// rows are the record: one observer on the history reads them back, as
+// answer_fold.js decorates its answers, so every path that fills it is covered.
+// Nothing is drawn for a turn with no move. A decision-card's "Concerns O2" gets
+// the same chip. The newest long answer of a session with a list offers its
+// short version where the bundle's /short is there (decision-card): the card
+// lands under it, so the button sits there too. A module of its own: static JS is cached at unversioned URLs.
+import { foldable } from "./answer_fold.js";
+import { keepFollowing } from "./scroll.js";
+import { html, nothing, render } from "./vendor/lit-html.js";
+
+const ROW_TITLE = /^(O\d+)\s+([^]*)$/;
+const RECORDED = /Recorded a move on /;
+const CONCERNS = /^Concerns (O\d+)\b/;
+
+// A row's move: {id, note}, null for any other row, and for a call that recorded
+// nothing (no list, a refusal: Tools::ObjectivesTool).
+export function moveOfRow(row) {
+  if (row?.tool !== "objectives" || !RECORDED.test(String(row.output || ""))) return null;
+  const found = ROW_TITLE.exec(String(row.title || row.params || ""));
+  return found ? { id: found[1], note: found[2] } : null;
+}
+
+// The row's title, its objective a chip, marked for the line above an answer
+// when the call recorded a move.
+export function moveRowText(row, shown) {
+  if (row?.tool !== "objectives") return shown;
+  const found = ROW_TITLE.exec(String(shown ?? ""));
+  if (!found) return shown;
+  const move = moveOfRow(row);
+  return html`<span class="obj-pill obj-mark" data-move-id=${move ? move.id : nothing} data-move-note=${move ? move.note : nothing}>${found[1]}</span> ${found[2]}`;
+}
+
+// A finished turn block's moves, in order.
+export function movesInBlock(block) {
+  return [...block.querySelectorAll("[data-move-id]")].map((el) => ({ id: el.dataset.moveId, note: el.dataset.moveNote || "" }));
+}
+
+// A card body's "Concerns O2 …" paragraph: the id a chip. Idempotent.
+export function chipConcerns(body) {
+  for (const p of body.querySelectorAll("p")) {
+    const first = p.firstChild;
+    if (first?.nodeType !== 3) continue;
+    const found = CONCERNS.exec(first.textContent);
+    if (!found) continue;
+    const chip = body.ownerDocument.createElement("span");
+    chip.className = "obj-pill obj-mark";
+    chip.textContent = found[1];
+    first.textContent = first.textContent.slice(found[0].length);
+    p.insertBefore(chip, first);
+    p.classList.add("obj-concerns");
+  }
+}
+
+function lineFor(block) {
+  const next = block.nextElementSibling;
+  return next?.classList.contains("obj-moves") ? next : null;
+}
+
+// @param historyEl the history
+// @param notYet (id) the tap on a move's Not yet (the newest turn's only: CSS)
+// @param canShorten () whether the newest long answer offers its short version
+// @param shorten () the tap on it
+export function createObjectivesMoves({ historyEl, notYet = () => {}, canShorten = () => false, shorten = () => {} }) {
+  // Off once tapped; back when +ask+ answers false (a failure, already told).
+  const once = (e, ask) => {
+    const button = e.currentTarget;
+    button.disabled = true;
+    Promise.resolve(ask()).then((sent) => {
+      if (sent === false) button.disabled = false;
+    });
+  };
+  const drawLine = (line, moves) => render(html`${moves.map((m) => html`<div class="obj-move-line">
+    <span class="obj-pill obj-mark">${m.id}</span><span class="obj-move-note">${m.note}</span>
+    <button type="button" class="obj-act ghost obj-notyet" title=${`Tell the agent: not yet on ${m.id}`} @click=${(e) => once(e, () => notYet(m.id))}>Not yet</button>
+  </div>`)}`, line);
+
+  const markNewest = () => {
+    const lines = [...historyEl.querySelectorAll(":scope > .obj-moves")];
+    lines.forEach((line, i) => line.classList.toggle("newest", i === lines.length - 1));
+  };
+
+  // After an answer's own rows (its Revise row, its timing line: the bubble's
+  // next siblings, one of which CSS reads by adjacency).
+  function shortRowPlace(answer) {
+    let place = answer;
+    while (place.nextElementSibling?.matches(".revise-row, .turn-timing")) place = place.nextElementSibling;
+    return place;
+  }
+
+  function placeShort() {
+    const answers = canShorten() ? historyEl.querySelectorAll(":scope > .bubble.output:not(.streaming)") : [];
+    const answer = answers[answers.length - 1];
+    const long = answer && foldable(answer.dataset.copySource || answer.textContent);
+    let row = historyEl.querySelector(":scope > .obj-short");
+    if (!long) {
+      row?.remove();
+      return;
+    }
+    if (!row) {
+      row = historyEl.ownerDocument.createElement("div");
+      row.className = "obj-short";
+      render(html`<button type="button" class="obj-act ghost" title="Ask for the short version; nothing enters the conversation"
+        @click=${(e) => once(e, shorten)}>Short version</button>`, row);
+    }
+    const place = shortRowPlace(answer);
+    if (place.nextElementSibling !== row) {
+      row.querySelector("button").disabled = false;
+      keepFollowing(historyEl, () => place.after(row));
+    }
+  }
+
+  function decorate() {
+    for (const block of historyEl.querySelectorAll(":scope > .turn-work")) {
+      const moves = movesInBlock(block);
+      const line = lineFor(block);
+      if (!moves.length) {
+        line?.remove();
+        continue;
+      }
+      const sig = JSON.stringify(moves);
+      if (line?.dataset.sig === sig) continue;
+      keepFollowing(historyEl, () => {
+        const el = line || historyEl.ownerDocument.createElement("div");
+        el.className = "obj-moves";
+        el.dataset.sig = sig;
+        drawLine(el, moves);
+        if (!line) block.after(el);
+      });
+    }
+    markNewest();
+    placeShort();
+    for (const card of historyEl.querySelectorAll(".plugin-card .card-body")) {
+      if (card.closest(".plugin-card").querySelector(".card-source")?.textContent === "decision-card") chipConcerns(card);
+    }
+  }
+
+  // The class toggle isn't a childList change, so this doesn't feed itself.
+  new MutationObserver(decorate).observe(historyEl, { childList: true, subtree: true });
+  decorate();
+  return { decorate };
+}

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

@@ -0,0 +1,242 @@
+// The session's objectives above the conversation: the fold's current state
+// (Objectives.view), from the session read (seed) and live from the stream's
+// objectives_updated (update). No list: the element stays hidden, nothing on
+// the page. A tap opens the edit list (chip_popover.js: a bottom sheet on a
+// phone): add, done, drop, undo and a new text, each a /objectives line on the
+// command route, the one way to an edit, so its refusals are the command's. No
+// message and no turn; the worker's next event redraws (every tab's), and a
+// mid-turn edit shows as waiting until the turn's end. A module of its own:
+// static JS is cached at unversioned URLs.
+import { createChipPopover, SHEET_TALL } from "./chip_popover.js";
+import { addLine, checkText, DONE, DROPPED, editableText, expireChecks, headline, markLine, nextExpiry, notYetText, pendingText, progress, rewordLine, stripItems } from "./objectives_model.js";
+import { html, nothing, render } from "./vendor/lit-html.js";
+
+const EXPIRY_SLACK_MS = 50;
+const EXPIRY_MAX_MS = 140_000;
+
+// @param el the strip's element (index.html #objectivesStrip)
+// @param session () the open session's id
+// @param running () a turn runs
+// @param sendLine (line) posts it as the session's command: a promise
+// @param sendMessage (text) sends it as the user's message: a promise (Not yet)
+// @param failed (error) a refused post, to tell the user
+// @param onChange () the list came or went
+export function createObjectivesStrip({ el, session = () => null, running = () => false, sendLine = async () => {},
+                                        sendMessage = async () => {}, failed = () => {}, onChange = () => {}, doc = document, win = window }) {
+  let list = null;
+  // The item whose text is being edited; while a post is out.
+  let editing = null;
+  let busy = false;
+  // The ids Not yet was sent for, since the list last changed or the panel closed.
+  const told = new Set();
+  let expiry = null;
+
+  // +first+: the one chip a phone's one-line strip keeps (objectives.css).
+  function chip(item, first) {
+    return html`<button type="button" class=${`obj-chip obj-open ${item.status}${first ? " first" : ""}`} data-id=${item.id} title=${item.text} aria-expanded="false"><span class="obj-id">${item.id}</span><span class="obj-text">${item.status === DONE ? "✓ " : ""}${item.text}</span></button>`;
+  }
+
+  function draw() {
+    el.hidden = !list;
+    if (!list) {
+      render(nothing, el);
+      return;
+    }
+    const { done, total } = progress(list);
+    const waiting = pendingText(list, running());
+    render(html`<div class="obj-strip" role="group" aria-label="Objectives">
+      <div class="obj-chips">${stripItems(list).map((item) => chip(item, item === headline(list)))}</div>
+      ${waiting ? html`<span class="obj-waiting" role="status">${waiting}</span>` : nothing}
+      <span class="obj-count">${done}/${total}</span>
+      <button type="button" class="obj-edit obj-open" aria-expanded="false">Edit</button>
+    </div>`, el);
+  }
+
+  function post(line) {
+    if (!line || busy) return;
+    busy = true;
+    drawPanel();
+    Promise.resolve(sendLine(line)).catch(failed).finally(() => {
+      busy = false;
+      drawPanel();
+    });
+  }
+
+  function subline(item) {
+    const parts = [];
+    if (item.done_when) parts.push(html`<span>done when: ${item.done_when}</span>`);
+    if (item.move) parts.push(html`<span>last move: ${item.move.note}${item.move.evidence ? ` (${item.move.evidence})` : ""}</span>`);
+    const check = checkText(item.check);
+    if (check) parts.push(html`<span class=${`obj-check ${item.check.verdict || "running"}`} title=${item.check.model ? `Read by ${item.check.model}. Information only.` : "Information only."}>${check}</span>`);
+    return parts.length ? html`<div class="obj-row-sub">${parts}</div>` : nothing;
+  }
+
+  function actions(item) {
+    const act = (name, label, title, off = false) => html`<button type="button" class="obj-act ghost" data-obj-act=${name} data-id=${item.id} title=${title} ?disabled=${busy || off}>${label}</button>`;
+    // A status button stays apart from it: a check never changes one.
+    const check = item.move && item.status !== DROPPED
+      ? [act("check", "Check this", `One side request reads this move against the session's record. Information only, nothing enters the conversation`, !!item.check?.running)]
+      : [];
+    if (item.status === "active") {
+      const notYet = item.move ? [act("notyet", "Not yet", `Tell the agent: not yet on ${item.id}`, told.has(item.id))] : [];
+      return [...check, ...notYet, act("done", "Done", `Mark ${item.id} done`), act("drop", "Drop", `Drop ${item.id}`)];
+    }
+    return [...check, act("undo", "Undo", `Back to active: ${item.id}`)];
+  }
+
+  function row(item) {
+    const klass = `obj-row ${item.status}`;
+    if (editing === item.id) {
+      return html`<form class=${klass} data-id=${item.id}>
+        <span class="obj-id">${item.id}</span>
+        <input class="obj-input" name="text" .value=${editableText(item)} aria-label=${`New text of ${item.id}`} autocomplete="off">
+        <button type="submit" class="obj-act" ?disabled=${busy}>Save</button>
+        <button type="button" class="obj-act ghost" data-obj-act="cancel">Cancel</button>
+      </form>`;
+    }
+    return html`<div class=${klass} data-row=${item.id}>
+      <span class="obj-id">${item.id}</span>
+      <div class="obj-row-main">
+        <button type="button" class="obj-row-text" data-obj-act="reword" data-id=${item.id} title=${`Edit the text of ${item.id}`}>${item.status === DONE ? "✓ " : ""}${item.text}</button>
+        ${subline(item)}
+      </div>
+      <div class="obj-row-acts">${actions(item)}</div>
+    </div>`;
+  }
+
+  const panelTemplate = () => {
+    const waiting = pendingText(list, running());
+    return html`<div class="ctx-pop-head"><span class="ctx-pop-kind">Objectives</span><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div>
+      <div class="obj-rows">${list.items.map(row)}</div>
+      <form class="obj-add" data-add="1">
+        <input class="obj-input" name="text" placeholder="Add an objective" aria-label="Add an objective" autocomplete="off">
+        <button type="submit" class="obj-act" ?disabled=${busy}>Add</button>
+      </form>
+      <div class="obj-note" role="status">${waiting || "No message, no turn: the agent reads the change before its next turn."}</div>`;
+  };
+
+  const shell = createChipPopover({
+    id: "objectivesPanel", className: "ctx-popover obj-panel", width: 560, el, anchor: ".obj-open", summary: () => list,
+    session, label: "Objectives", sheet: true, sheetShare: SHEET_TALL, doc, win,
+    show: () => render(panelTemplate(), shell.pop),
+    onOpen: () => {
+      const id = shell.opener?.()?.dataset?.id;
+      const target = id && shell.pop.querySelector(`[data-row="${id}"] .obj-row-text`);
+      (target || shell.pop.querySelector(".obj-add .obj-input"))?.focus();
+    },
+    onClose: () => {
+      editing = null;
+      told.clear();
+    },
+    onSubmit: (form) => {
+      const text = form.elements.text.value;
+      if (form.dataset.add) {
+        post(addLine(text));
+        form.reset();
+        return;
+      }
+      const line = rewordLine(form.dataset.id, text);
+      editing = null;
+      // A blank text takes the edit back.
+      if (line) post(line);
+      else drawPanel();
+    },
+  });
+
+  function drawPanel() {
+    if (shell.isOpen() && list) render(panelTemplate(), shell.pop);
+  }
+
+  shell.pop.addEventListener("click", (e) => {
+    const button = e.target.closest("[data-obj-act]");
+    if (!button) return;
+    const { objAct: act, id } = button.dataset;
+    if (act === "reword") {
+      editing = id;
+      drawPanel();
+      const input = shell.pop.querySelector(`form[data-id="${id}"] .obj-input`);
+      input?.focus();
+      input?.select();
+    } else if (act === "cancel") {
+      editing = null;
+      drawPanel();
+    } else if (act === "notyet") {
+      notYet(id);
+    } else {
+      post(markLine(act, id));
+    }
+  });
+  // Esc in the text being edited takes that edit back, not the panel.
+  shell.pop.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && editing && e.target.closest("form[data-id]")) {
+      e.stopPropagation();
+      editing = null;
+      drawPanel();
+    }
+  });
+
+  // One tap: a normal message the agent reads at its next step, or as the next
+  // turn. Any tab's echo is the stream's.
+  // @return {Promise<boolean>} false: it didn't go (a failure, already told)
+  async function notYet(id) {
+    const item = list?.items.find((i) => i.id === id);
+    if (!item || told.has(id)) return false;
+    told.add(id);
+    drawPanel();
+    try {
+      await sendMessage(notYetText(item));
+      return true;
+    } catch (e) {
+      told.delete(id);
+      failed(e);
+      drawPanel();
+      return false;
+    }
+  }
+
+  // A running check whose worker died gets no event: let it go at its time. The
+  // cap keeps a page whose clock is off from holding it for long.
+  function armExpiry() {
+    win.clearTimeout(expiry);
+    const at = nextExpiry(list);
+    if (at === null) return;
+    expiry = win.setTimeout(() => {
+      list = expireChecks(list, Math.max(Date.now(), at));
+      draw();
+      drawPanel();
+      armExpiry();
+    }, Math.min(Math.max(at - Date.now(), 0) + EXPIRY_SLACK_MS, EXPIRY_MAX_MS));
+  }
+
+  // The list without what a check adds: its start and end aren't a change to it.
+  const listSig = (view) => JSON.stringify(view?.items?.map(({ check: _check, ...item }) => item) ?? null);
+
+  const take = (view) => {
+    const next = view && Array.isArray(view.items) ? expireChecks(view, Date.now()) : null;
+    if (listSig(next) !== listSig(list)) told.clear();
+    list = next;
+    armExpiry();
+    draw();
+    shell.refresh();
+    onChange();
+  };
+
+  return {
+    // A session read's list; none clears it.
+    seed: take,
+    // The stream's objectives_updated.
+    update: take,
+    // No session open.
+    reset: () => {
+      if (shell.isOpen()) shell.close();
+      take(null);
+    },
+    notYet,
+    hasList: () => !!list,
+    // A turn started or ended: the waiting line's words.
+    redraw: () => {
+      draw();
+      drawPanel();
+    },
+  };
+}

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

@@ -0,0 +1,62 @@
+// The objectives' strip and moves, wired to the page's routes, so that app.js
+// holds a few lines of them (its size cap). Every post follows the worker it woke
+// only while the page still shows that session (latest.js), as cards_place.js does.
+// A module of its own: static JS is cached at unversioned URLs.
+import { stillOn } from "./latest.js";
+import { cantText } from "./format.js";
+import { createObjectivesMoves } from "./objectives_moves.js";
+import { createObjectivesStrip } from "./objectives_strip.js";
+
+// @param el the strip's element
+// @param historyEl the history
+// @param session () the open session's id
+// @param running () a turn runs
+// @param holding () the stage holds a finished turn (its answer, the newest, isn't in the history yet)
+// @param commands () the session's command listing
+// @param clientId this tab's
+// @param sendCommand, sendTurn data.js's
+// @param follow () follows a worker a post woke
+// @param toast (text, action, options)
+// @return {seed, update, reset, redraw, notYet}
+export function createObjectives({ el, historyEl, session, running, holding = () => false, commands, clientId, sendCommand, sendTurn, follow, toast }) {
+  const posted = async (request) => {
+    const still = stillOn(session);
+    await request(session());
+    if (still()) follow();
+  };
+  const told = (what) => (e) => toast(cantText(what, e), null, { sticky: true });
+
+  const strip = createObjectivesStrip({
+    el, session, running,
+    // A tap's edit goes as a card's action does: no echo, the worker woken.
+    sendLine: (line) => posted((id) => sendCommand(id, line, { clientId, card: true })),
+    // Not yet: a tab of its own as far as the echo goes, so the stream draws it here too.
+    sendMessage: (text) => posted((id) => sendTurn(id, text, { clientId: `${clientId}:objectives`, history: false })),
+    failed: told("edit the objectives"),
+    onChange: () => moves.decorate(),
+  });
+  const moves = createObjectivesMoves({
+    historyEl, notYet: (id) => strip.notYet(id),
+    // Not during a turn: its answer isn't there yet, and /short refuses it. Nor
+    // with a turn still in the stage: the history's last answer isn't the newest,
+    // which is what /short reads. The hand-off fills the history, which redraws this.
+    canShorten: () => strip.hasList() && !running() && !holding() && (commands() || []).some((c) => c?.name === "/short"),
+    // false: a failure, already told: the button comes back.
+    shorten: () => posted((id) => sendCommand(id, "/short", { clientId, card: true })).then(() => true, (e) => {
+      told("ask for it")(e);
+      return false;
+    }),
+  });
+
+  return {
+    seed: strip.seed,
+    update: strip.update,
+    reset: strip.reset,
+    notYet: strip.notYet,
+    // A turn started or ended.
+    redraw: () => {
+      strip.redraw();
+      moves.decorate();
+    },
+  };
+}

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

@@ -326,6 +326,8 @@ export function createStreamHandlers(deps) {
       // one's bubble was drawn at its command_queued: filled in here. One
       // queued for after the turn ran after it: its bubble moves from among
       // the turn's rows to after its answer and timing line.
+      // A card's action the worker refused: its buttons come back.
+      if (data.card && data.status === "error") deps.cardActionFailed?.(data.line);
       const queued = view.anytime || view.queued ? commandBubble(view.commandId) : null;
       if (view.hidden) queued?.remove();
       else if (queued && view.queued && !view.anytime) {
@@ -360,10 +362,13 @@ export function createStreamHandlers(deps) {
     context_added: (data) => {
       const at = data.at || data.created_at || null;
       gapBefore(at);
-      addNoteBubble({ label: data.label, content: data.text || "", at });
+      addNoteBubble({ label: data.label, content: data.text || "", at, objectives: data.objectives });
       // An attached context source's note: its chip changed.
       if (data.context_source) contextChips.refresh();
     },
+    // The session's list changed (objectives_strip.js): an edit waiting, a
+    // list note in, a turn's moves.
+    objectives_updated: (data) => deps.objectivesUpdated?.(data),
     // Someone joined, left or was revoked (the worker's ParticipantsWatch):
     // the owner's chip and panel read the list again.
     participants_changed: () => participantsControl?.reload(),

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

@@ -6,6 +6,8 @@
 import { toolName } from "./activity.js";
 import { html, nothing, render } from "./vendor/lit-html.js";
 import { commandBlockTemplate, rowHover } from "./command_view.js";
+import { objectivesEntryTemplate } from "./objectives_entry.js";
+import { moveRowText } from "./objectives_moves.js";
 import { copySource } from "./copy.js";
 import { activityDiffTemplate } from "./diff_view.js";
 import { clip, fullTime, steerSender } from "./format.js";
@@ -158,7 +160,7 @@ export function toolRowInnerTemplate(row, { thumbs = () => nothing, stop = nothi
   const ref = shown ? rowTitleRef(row) : null;
   const attr = (value) => (value ? String(value) : nothing);
   const params = shown
-    ? html`<span class=${`activity-params${ref?.kind ? " ref" : ""}`} title=${hover || nothing} data-ref-kind=${attr(ref?.kind)} data-ref-path=${attr(ref?.kind && ref.path)} data-ref-line=${attr(ref?.kind && ref.line)} data-ref-end-line=${attr(ref?.kind && ref.end_line)}>${shown}</span>`
+    ? html`<span class=${`activity-params${ref?.kind ? " ref" : ""}`} title=${hover || nothing} data-ref-kind=${attr(ref?.kind)} data-ref-path=${attr(ref?.kind && ref.path)} data-ref-line=${attr(ref?.kind && ref.line)} data-ref-end-line=${attr(ref?.kind && ref.end_line)}>${moveRowText(row, shown)}</span>`
     : nothing;
   // The name the model called the tool by when it was an alias's, or the
   // tool it was reached through (call_tool), dim.
@@ -280,6 +282,7 @@ export function answerBubbleTemplate(message, { cls = "", at = null, turnId = nu
 // in; the model reads it, nobody asked it anything): who sent it, then its
 // text.
 export function noteBubbleTemplate(note) {
+  if (note?.objectives) return objectivesEntryTemplate(note, timeTitle(note.at));
   const from = note?.label ? `note from ${note.label}` : "note";
   return html`<div class="bubble note" title=${timeTitle(note?.at)}><div class="note-line">${from}</div><div class="note-text">${note?.content ?? ""}</div></div>`;
 }

data/lib/samagotchi/web/session_show.rb

@@ -6,6 +6,7 @@ require "uri"
 require_relative "../analytics_file"
 require_relative "../answer_refs"
 require_relative "../answer_tail"
+require_relative "../objectives"
 require_relative "../output_formatter"
 require_relative "../question_asked"
 require_relative "../guardrails/approvals"
@@ -91,10 +92,20 @@ module Samagotchi
           # The stream cursor `<seq>-<epoch>`: a later worker resets it
           # instead of taking the seq as its own. Only the snapshot has it.
           last_event_id: turn_snapshot && turn_snapshot["event_id"],
-          timing: timing
+          timing: timing,
+          **objectives_field(id, raw_messages)
         })
       end
 
+      # The session's list (the page's strip), and no key with no list: a
+      # session without one reads as it always did. A snapshot's entries have
+      # string keys (paired_runs reads symbols).
+      def objectives_field(id, messages)
+        symbols = Array(messages).map { |message| message.is_a?(Hash) ? message.transform_keys(&:to_sym) : message }
+        view = Samagotchi::Objectives.view(id, symbols, state_dir: default_state_dir)
+        view ? { objectives: view } : {}
+      end
+
       # A list in the worker's turn +snapshot+ (queued prompts, commands,
       # init tasks); [] without a worker.
       def snapshot_list(snapshot, key) = Array(snapshot&.[](key))

data/lib/samagotchi/worker.rb

@@ -1203,6 +1203,9 @@ module Samagotchi
         save_or_log(:command) { save_session } unless Array(result.changed).empty?
         announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed),
                                   anytime: true, confirm: result.confirm)
+        # It may have left a note (/objectives): an idle loop takes it now, not
+        # at the fallback tick. Harmless otherwise: one more pass.
+        @waker.wake
       rescue StandardError => e
         Log.warn(:worker, "anytime_command_failed", line: command.line, error: e.class.name, msg: e.message)
       end