samagotchi 0.29.0 → 0.31.0

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

@@ -19,17 +19,26 @@ export function stopTarget(row, features) {
   return row.view?.task_id || null;
 }
 
+// A task_wait row's title without its wait ("npm test · up to 600s").
+const WAIT_SUFFIX = / · up to \d+s$/;
+
 // The command a task_create of this turn started +taskId+ with (its row's
-// view), or null: a task from an earlier turn has no row here.
+// view), else a task_wait row's title for it (the server titles one by its
+// task's command, also for a task from an earlier turn: ToolActivity.
+// task_title), or null.
 export function taskCommand(gens, taskId) {
+  let titled = null;
   for (const gen of gens || []) {
     for (const row of gen.tools || []) {
+      if (row.tool === "task_wait" && row.view?.task_id === taskId && row.title) {
+        titled ||= row.title.replace(WAIT_SUFFIX, "");
+      }
       if (row.tool !== "task_create") continue;
       const id = /(?:^|\n)task_id: (\S+)/.exec(row.output || "")?.[1];
       if (id === taskId) return row.view?.command || null;
     }
   }
-  return null;
+  return titled;
 }
 
 export function confirmText(taskId, command) {

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

@@ -24,20 +24,25 @@ export function turnTimingText(number, durationMs, { running = false, canceled =
 // CANCEL_REASONS); anything else as it is. Both sides: spec/shared/labels_matrix.json.
 const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook" };
 
-// The line a canceled turn ends with: "✕ canceled (stopped)", live from
+// The line a canceled turn ends with: "■ canceled (stopped)", live from
 // turn_canceled's reason and after a re-render from the turn record's
 // cancellation_reason (records saved before it existed: no reason). A
-// hook's stop that names who (+by+, cancelled_by): "✕ stopped by loop-guard".
+// hook's stop that names who (+by+, cancelled_by): "■ stopped by loop-guard".
+// Every cancel is a stop someone chose (the user, Ctrl-C, a hook), not a
+// failure: the ■ mark and the stopped colours of a call the Stop cut
+// (STOPPED_LINE_CLASS), not the ✕ of an error.
+export const STOP_MARK = "\u25A0";
+export const STOPPED_LINE_CLASS = "bubble cancel stopped";
 export function cancelLineText(reason, by) {
-  if (reason === "hook" && by) return `\u2715 stopped by ${by}`;
-  return "\u2715 canceled" + (reason ? ` (${CANCEL_REASONS[reason] || reason})` : "");
+  if (reason === "hook" && by) return `${STOP_MARK} stopped by ${by}`;
+  return `${STOP_MARK} canceled` + (reason ? ` (${CANCEL_REASONS[reason] || reason})` : "");
 }
 
-// A re-rendered turn's cancel line (a .bubble.cancel), or "" when the turn
-// record is not a canceled one.
+// A re-rendered turn's cancel line (a .bubble.cancel.stopped), or "" when
+// the turn record is not a canceled one.
 export function cancelLineHtml(record, escape) {
   if (record?.status !== "canceled") return "";
-  return `<div class="bubble cancel">${escape(cancelLineText(record.cancellation_reason, record.cancelled_by))}</div>`;
+  return `<div class="${STOPPED_LINE_CLASS}">${escape(cancelLineText(record.cancellation_reason, record.cancelled_by))}</div>`;
 }
 
 export function elapsedSince(startedAt, now = Date.now()) {

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

@@ -14,10 +14,12 @@ export function turnOutput(data) {
 
 // The end line for a turn whose worker went away mid-turn (the footer's
 // stop, a crash): no turn_canceled comes, so the page ends the turn itself.
+// The footer's stop is the user's, drawn as a cancel is (\u25A0, timing.js
+// cancelLineText); a worker that exited on its own is a failure (\u2715).
 // null when no turn was running.
 export function workerGoneText({ turnRunning, stopped = false }) {
   if (!turnRunning) return null;
-  return `\u2715 canceled (${stopped ? "session stopped" : "worker exited"})`;
+  return stopped ? "\u25A0 canceled (session stopped)" : "\u2715 canceled (worker exited)";
 }
 
 // How long a turn's answer waits for the after_turn hooks' answer_display
@@ -91,7 +93,13 @@ export function isOwn(clientId, myId) {
 
 // As the TUI labels them (Formatting::CLIENT_LABELS); this file's label
 // helpers and the TUI's agree per spec/shared/labels_matrix.json.
-const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate" });
+const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate", child: "delegate report" });
+
+// A delegate child's report comes in as client child:<id8> (ChildReports).
+const REPORT_CLIENT = "child:";
+export function isReportClient(clientId) {
+  return String(clientId || "").startsWith(REPORT_CLIENT);
+}
 
 // The label on another client's prompt, by its client_id prefix.
 export function clientLabel(clientId) {
@@ -117,9 +125,10 @@ export function hookNoticeLabel(hook) {
 }
 
 // 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";
+// after a plugin cut the generation (stopped_by: the bundle), or after a
+// corrupt native generation (malformed).
+export function emptyRetryLine({ attempt, of, stopped_by: stoppedBy, malformed } = {}) {
+  const what = stoppedBy ? `cut by ${stoppedBy}` : malformed ? "malformed answer" : "empty answer";
   return `↻ ${what}, asking again (${attempt}/${of})`;
 }
 
@@ -379,9 +388,14 @@ export function composerAfterAck({ sent = "", current = "", refill = "" } = {})
 //   tag   — this tab's own local echo gets its enqueued_id
 //   start — the bubble's turn started (drops the "queued" badge)
 //   steer — the bubble was merged into the running turn
+//   report — the merge brought a delegate child's report (origin
+//           child:<id8>, no bubble anywhere): its text gets a labelled one
 // `known(enqueuedId)` says whether a bubble carries that id already;
-// `unmatchedMerge` whether the last input_merged had an origin with no bubble.
-export function promptOps(event, { myId, known, unmatchedMerge = false }) {
+// `unmatchedMerge` whether the last input_merged had an origin with no
+// bubble ("report": a delegate report's); `wakeStart` whether this is the
+// first merge of a turn chi ran for reports (its bubble starts the turn,
+// no "steered" badge, as a reload shows it).
+export function promptOps(event, { myId, known, unmatchedMerge = false, wakeStart = false }) {
   if (!event) return [];
   switch (event.type) {
     case "turn_enqueued": {
@@ -401,12 +415,18 @@ export function promptOps(event, { myId, known, unmatchedMerge = false }) {
       }
       return [withImages({ op: "add", enqueuedId: id, prompt: event.prompt, state: "started", label: clientLabel(origin.client_id) }, event.images)];
     }
-    case "input_merged":
-      return (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
+    case "input_merged": {
+      const ops = (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
         known(o.enqueued_id) ? { op: "steer", enqueuedId: o.enqueued_id } : { op: "steer", enqueuedId: o.enqueued_id, unmatched: true },
       );
+      if ((event.origins || []).some((o) => o && !o.enqueued_id && isReportClient(o.client_id))) ops.push({ op: "report" });
+      return ops;
+    }
     case "pending_input_merged":
       if (!unmatchedMerge || !event.content) return [];
+      if (unmatchedMerge === "report") {
+        return [{ op: "add", enqueuedId: null, prompt: event.content, state: wakeStart ? null : "steered", label: clientLabel(REPORT_CLIENT) }];
+      }
       return [{ op: "add", enqueuedId: null, prompt: event.content, state: "steered", label: null }];
     default:
       return [];

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

@@ -176,21 +176,26 @@ export function failedCount(rows) {
 // call's title ("edit lib/a.rb"), else the tools it worked with, else
 // "thinking"; then its call count and how many failed.
 export function genLabel(gen) {
+  const { head, calls } = genLabelParts(gen);
+  return calls ? `${head} · ${calls}` : head;
+}
+
+// genLabel in its parts: +head+, +calls+ ("3 tool calls (1 failed)", or ""
+// without calls) and +repeats+: the head is words the open step's body
+// starts with (its narration, its first call's title), so an open step's
+// summary can say only its calls (turn_view.js labelHtml).
+export function genLabelParts(gen) {
   const line = String(gen.text || "").trim().split("\n")[0].trim();
-  const calls = gen.tools.length;
+  const calls = gen.tools.length ? toolCallsText(gen.tools) : "";
   const first = gen.tools[0];
-  let head;
-  if (line) {
-    head = cut(line);
-  } else if (first?.title) {
-    head = cut(`${toolName(first)} ${first.title}`);
-  } else if (calls) {
+  if (line) return { head: cut(line), calls, repeats: true };
+  if (first?.title) return { head: cut(`${toolName(first)} ${first.title}`), calls, repeats: true };
+  if (gen.tools.length) {
     const names = [...new Set(gen.tools.map(toolName))];
-    head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
-  } else {
-    return "thinking";
+    const head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
+    return { head, calls, repeats: false };
   }
-  return calls ? `${head} · ${toolCallsText(gen.tools)}` : head;
+  return { head: "thinking", calls: "", repeats: false };
 }
 
 // The block's summary line: "working · 3 steps · 8 tool calls · execute ×7 · …"

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

@@ -14,7 +14,7 @@ import { leavesBlock } from "./card.js";
 import { copySourceAttr } from "./copy.js";
 import { commandBlockHtml, rowHover } from "./command_view.js";
 import { activityDiffHtml } from "./diff_view.js";
-import { escapeHtml, messageBodyHtml, noteHtml, normalize, steerRowHtml } from "./format.js";
+import { escapeHtml, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { emptyAnswerLine, hookNoticeLabel } from "./turn_events.js";
@@ -399,7 +399,7 @@ export function createTurnView({
   // an ellipsed label): at close, and again when a late tool result lands
   // in a step that already closed.
   function writeClosedLabel(entry, gen) {
-    entry.summary.textContent = model.genLabel(gen);
+    setLabel(entry.summary, gen);
     entry.el.classList.toggle("has-failed", model.failedCount(gen.tools) > 0);
   }
 
@@ -551,7 +551,7 @@ export function createTurnView({
     }
     entry.text = document.createElement("div");
     entry.text.className = "gen-text";
-    entry.summary.textContent = model.genLabel({ ...gen, text: "" });
+    setLabel(entry.summary, { ...gen, text: "" });
     model.takeAnswer(turn, gen);
     // Cards and hook notices in a step that goes (below, or with the whole
     // block for a plain answer) stay: before the answer, out of the block,
@@ -731,6 +731,29 @@ function defaultPlaceAnswer(appendToHistory) {
   };
 }
 
+// A closed step's summary (model.genLabel). When its head is the words the
+// body starts with (the narration's first line, the first call's title)
+// and it has calls, the summary is marked .repeats and its parts are
+// spans: an open step shows only its calls (index.html), so it doesn't say
+// the same words twice. Its text stays genLabel's either way.
+// { repeats, html } (the summary's inside).
+function labelParts(gen) {
+  const { head, calls, repeats } = model.genLabelParts(gen);
+  if (!repeats || !calls) return { repeats: false, html: escapeHtml(model.genLabel(gen)) };
+  return { repeats: true, html: `<span class="gen-head">${escapeHtml(head)}</span><span class="gen-sep"> · </span><span class="gen-calls">${escapeHtml(calls)}</span>` };
+}
+
+function labelHtml(gen) {
+  const { repeats, html } = labelParts(gen);
+  return `<summary${repeats ? ' class="repeats"' : ""}>${html}</summary>`;
+}
+
+function setLabel(summary, gen) {
+  const { repeats, html } = labelParts(gen);
+  summary.classList.toggle("repeats", repeats);
+  summary.innerHTML = html;
+}
+
 // A reloaded tool row, the live row's markup (fillActivityRow): status, tool, params, the full command (an
 // execute/task_create's view), output (its "[tool]" tag dropped, 300 chars, the rest on hover), plus the call's
 // duration from its record.
@@ -782,13 +805,28 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const { body, renderedMarkdown } = messageBodyHtml(m);
     return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
+  // The live bubble's origin label (app.js makeUserBubble), for a line
+  // chi brought in: a delegate report.
+  const originLabelHtml = (m) => {
+    const label = sourceLabel(m?.source);
+    return label ? `<span class="origin-label">${escapeHtml(label)}</span>` : "";
+  };
+  // The first text after a delegate report merged mid-turn, unless it is
+  // the turn's answer (shown anyway).
+  const reportReplyHtml = (i, group) => {
+    if (items[i]?.source !== "delegate_report") return "";
+    const j = items.findIndex((m, k) => k > i && m?.role === "assistant" && String(m.content ?? "").trim());
+    if (j < 0 || j === group.answer || items.slice(i + 1, j).some((m) => m?.role === "user" && !m.merged)) return "";
+    const { body, renderedMarkdown } = messageBodyHtml(items[j]);
+    return `<div class="bubble output report-reply${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(items[j], renderedMarkdown)}>${body}</div>`;
+  };
   const steerHtml = (i, bubble) => steerRowHtml({ source: items[i].source, text: items[i].content }, { bubble });
   return turnGroups(items, timing).map((group) => {
     if (group.kind === "note") return `<div class="bubble note">${noteHtml(items[group.i])}</div>`;
     if (group.kind === "steer") return steerHtml(group.i, true);
     if (group.kind === "answer") return answerHtml(items[group.answer], "");
     const prompt = items[group.user];
-    const parts = [`<div class="bubble user"${copySourceAttr(prompt, false)}><div class="user-message">${messageBodyHtml(prompt).body}${thumbs(prompt.images)}</div></div>`];
+    const parts = [`<div class="bubble user"${copySourceAttr(prompt, false)}>${originLabelHtml(prompt)}<div class="user-message">${messageBodyHtml(prompt).body}${thumbs(prompt.images)}</div></div>`];
     const [only] = group.steps;
     const ended = group.answer !== null || group.emptyAnswer != null;
     const textless = only && (only.i === null || !String(items[only.i].content ?? ""));
@@ -811,7 +849,7 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
         const steers = (group.steps[k].steers || []).map((i) => steerHtml(i, false)).join("");
         const tools = gen.tools.length ? `<div class="activity-body">${gen.tools.map((r) => reloadRowHtml(r, thumbs)).join("")}</div>` : "";
         const failed = model.failedCount(gen.tools) ? " has-failed" : "";
-        return `<details class="gen${failed}"><summary>${escapeHtml(model.genLabel(gen))}</summary>${steers}${thinking}${text}${tools}</details>`;
+        return `<details class="gen${failed}">${labelHtml(gen)}${steers}${thinking}${text}${tools}</details>`;
       });
       parts.push(`<details class="turn-work done"><summary>${escapeHtml(model.blockSummary({ gens, ended: true }))}</summary>${rows.join("")}</details>`);
     }
@@ -820,9 +858,13 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const loose = noBlock ? [...group.steps.flatMap((step) => step.steers || []), ...(group.steers || [])] : group.steers || [];
     parts.push(loose.map((i) => steerHtml(i, true)).join(""));
     // The user's lines merged into the turn: the live "steered" bubbles,
-    // after its steps and before its answer.
+    // after its steps and before its answer. A delegate report's is
+    // followed by the text that answered it when that isn't the answer: a
+    // small model tells its user about a report before its next tool call,
+    // and that step's text would stay folded in the block.
     parts.push((group.merged || []).map((i) =>
-      `<div class="bubble user steered" data-user-state="steered"${items[i].step ? ` data-step="${Number(items[i].step)}"` : ""}${copySourceAttr(items[i], false)}><div class="user-message">${messageBodyHtml(items[i]).body}${thumbs(items[i].images)}</div><span class="state-badge">steered</span></div>`).join(""));
+      `<div class="bubble user steered" data-user-state="steered"${items[i].step ? ` data-step="${Number(items[i].step)}"` : ""}${copySourceAttr(items[i], false)}>${originLabelHtml(items[i])}<div class="user-message">${messageBodyHtml(items[i]).body}${thumbs(items[i].images)}</div><span class="state-badge">steered</span></div>` +
+      reportReplyHtml(i, group)).join(""));
     // A turn that ended with no answer: chi's muted notice where the answer
     // would be, before the timing, as live.
     if (group.emptyAnswer != null) parts.push(`${emptyAnswerHtml(items[group.emptyAnswer])}${timingHtml(group)}`);