samagotchi 0.134.0 → 0.136.0

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

@@ -4,19 +4,21 @@
 //
 // Everything that changes while the page runs is read through deps at the
 // event, never captured at creation: the open session (selected()), its
-// fields (state(): resetSessionState replaces the object), the page's
+// fields (store.current: app.js forgetSession replaces the object), the page's
 // capabilities, the composer's text. A session switch mid-stream is handled
 // as before: the handlers act on whatever is open when the event comes.
 //
 // deps:
 //   selected()            the open session's id, or null
-//   state()               the open session's fields (session_state.js)
+//   store                 the page's session store (session_store.js): the
+//                         open session's fields are read as store.current
+//                         and written with store.update, one patch per handler
+//                         (or one batch); a write redraws what reads it (the
+//                         bar, a chip's popover), so no handler calls a redraw
 //   clientId              this tab's id (own prompts and commands)
 //   capabilities()        the page's capabilities (card.js shownElsewhere)
 //   historyEl             the history element (keepFollowing, the failed-turn redraw)
-//   liveTurn, turnDom, shownTexts, questionCards, contextChips,
-//   llmContextControl, thinkingControl,
-//   reasoningHistoryControl                 the page's views
+//   liveTurn, turnDom, shownTexts, questionCards, contextChips  the page's views
 //   workingSet            the stage view's working set (web.working_set),
 //                         null when off
 //   participantsControl   the owner's participants panel (participants_panel.js),
@@ -27,8 +29,9 @@
 //                         close the stream and resync
 //   composer: {empty(), refill(text), setChips(chips)}
 //   restoreVerify(anchor) a restored Verify turn's claim, armed again for its resend
+//   restoreRevise(anchor) a restored Revise turn's draft ({turn_id}), its chip back
 //   getSession(id, opts)  data.js
-//   resync(), updateInfoBar(), applyPromptOps(data), showSteers(steers),
+//   resync(), applyPromptOps(data), showSteers(steers),
 //   markRecapStale(), setTurnRunning(running), setLiveStatus(status),
 //   endTurnView(kind, endText, opts), appendChunk(text), readTurnEnd(),
 //   applyFinalMarkdown(messages), refreshTimingFromSession(),
@@ -56,13 +59,14 @@ import { commandView, drawCommandBubble, historyHasCommandBubble } from "./comma
 import { keepEarlyRestore, restoreAction } from "./restore.js";
 import { PAIR, setBadgeMode } from "./participant_names.js";
 import { isParticipantAuthor } from "./participant_model.js";
+import { stillOn } from "./latest.js";
 
 export function createStreamHandlers(deps) {
   const {
-    selected, state, clientId, capabilities, historyEl,
-    liveTurn, turnDom, shownTexts, questionCards, contextChips, llmContextControl, thinkingControl, reasoningHistoryControl,
+    selected, store, clientId, capabilities, historyEl,
+    liveTurn, turnDom, shownTexts, questionCards, contextChips,
     workingSet = null, participantsControl = null, sentIds, earlyRestores, stream, composer, getSession,
-    resync, updateInfoBar, applyPromptOps, showSteers, markRecapStale, setTurnRunning, setLiveStatus, endTurnView,
+    resync, applyPromptOps, showSteers, markRecapStale, setTurnRunning, setLiveStatus, endTurnView,
     appendChunk, readTurnEnd, applyFinalMarkdown, refreshTimingFromSession, makeUserBubble, addEndBubble,
     commandBubble, addCommandBubble, addNoteBubble, findInTurnRoots, setUsedMemories, showRecap,
     showGuardrailWarning, showHookNotice, onInitEvent, upsertCard, refreshCardBodies, syncModelPick,
@@ -85,26 +89,21 @@ export function createStreamHandlers(deps) {
       const { text, thinking } = routeChunk(data);
       liveTurn.timing.setNote("");
       turnDom.chunk({ text, thinking, iteration: data.iteration ?? null, now: data.replayed ? null : Date.now() });
-      const current = state();
+      const current = store.current;
       const pct = extractCtxPct(data, current.ctxWindow, current.llmContext?.budget_tokens);
-      if (pct !== null && !Number.isNaN(pct)) {
-        current.ctxPct = pct;
-        updateInfoBar();
-      }
+      // A chunk with the same % redraws nothing (the store compares).
+      if (pct !== null && !Number.isNaN(pct)) store.update({ current: { ctxPct: pct } });
     },
     generation_started: (data) => {
       // The request after a /model's unresolved window started: whatever it
       // brings, the ctx tooltip no longer waits for it (ctxBarTip).
-      const current = state();
-      let contextChanged = current.ctxUnknownAfterSwitch !== false;
-      current.ctxUnknownAfterSwitch = false;
+      // A changed value redraws the bar (the store), an unchanged one not.
+      const patch = { ctxUnknownAfterSwitch: false };
       if (data?.context_window_tokens) {
-        const source = data.context_window_source || null;
-        contextChanged ||= current.ctxWindow !== data.context_window_tokens || current.ctxWindowSource !== source;
-        current.ctxWindow = data.context_window_tokens;
-        current.ctxWindowSource = source;
+        patch.ctxWindow = data.context_window_tokens;
+        patch.ctxWindowSource = data.context_window_source || null;
       }
-      if (contextChanged) updateInfoBar();
+      store.update({ current: patch });
       liveTurn.timing.setNote("");
       // The step's clock (the composer's delivery line): the page's own at a
       // live start; a replay's comes from the snapshot's generation age,
@@ -114,15 +113,19 @@ export function createStreamHandlers(deps) {
     },
     generation_completed: (data) => {
       liveTurn.timing.setNote("");
-      const current = state();
-      if (data?.served_model) current.served = [data.served_model, data.requested_model, data.served_expected_by || null];
-      // The generation's speed and the session's token totals, from the server.
-      current.timing.tokens = generationTokens(current.timing.tokens, data);
-      // The rows per model, the server's whole list (the open one with this
-      // generation in); an event without them (a replay, an older worker)
-      // keeps the page's.
-      if (Array.isArray(data?.model_segments)) current.timing.modelSegments = data.model_segments;
-      if (data?.served_model || data?.tokens) updateInfoBar();
+      const current = store.current;
+      // The generation's speed and the session's token totals, from the
+      // server; the rows per model, the server's whole list (the open one
+      // with this generation in). An event without them (a replay, an older
+      // worker) keeps the page's: the timing object stays, no redraw.
+      const patch = {};
+      const tokens = generationTokens(current.timing.tokens, data);
+      const segments = Array.isArray(data?.model_segments) ? data.model_segments : null;
+      if (tokens !== current.timing.tokens || segments) {
+        patch.timing = { ...current.timing, tokens, ...(segments ? { modelSegments: segments } : {}) };
+      }
+      if (data?.served_model) patch.served = [data.served_model, data.requested_model, data.served_expected_by || null];
+      store.update({ current: patch });
       turnDom.generationCompleted();
     },
     // Prompts sent while a turn ran merge into it at an iteration boundary:
@@ -142,14 +145,14 @@ export function createStreamHandlers(deps) {
     turn_started: (data) => keepFollowing(historyEl, () => {
       if (stream.takeGuess()) {
         // A replay of a turn the render drew: re-read and stream from there.
-        if (replaysDrawnTurn(data, state().timing.turnRecords)) {
+        if (replaysDrawnTurn(data, store.current.timing.turnRecords)) {
           stream.restart();
           return;
         }
       }
       // A finished turn still in the stage goes first: the start op looks
       // for a queued prompt among its rows.
-      turnDom.handOff?.({ immediate: true });
+      turnDom.handOff({ immediate: true });
       markRecapStale();
       shownTexts.turnStarted();
       const promptBubble = applyPromptOps(data);
@@ -171,13 +174,19 @@ export function createStreamHandlers(deps) {
       if (data.participant_mode) setBadgeMode(promptBubble, data.participant_mode);
       // The owner's input queues behind it (the composer's delivery line).
       liveTurn.participantTurn = participant;
-      setTurnRunning(true);
-      setLiveStatus("running");
+      // One redraw of the composer, the bar and the lists, before
+      // keepFollowing's scroll.
+      store.batch(() => {
+        setTurnRunning(true);
+        setLiveStatus("running");
+      });
       liveTurn.timing.detach();
       turnDom.turnStarted({ ...data, promptBubble });
       liveTurn.timing.start(data.started_at, data.turn_id || null);
     }),
     turn_completed: async (data) => {
+      // The turn's id: the event names none, its turn_started did.
+      const turnId = data.turn_id || liveTurn.timing.turnId || null;
       activityEnded();
       // A participant's turn: their spend and turns in the panel moved.
       if (data.origin?.author) participantsControl?.reload();
@@ -185,6 +194,13 @@ export function createStreamHandlers(deps) {
       const out = turnOutput(data);
       if (out) appendChunk(out);
       if (data.verdict) deps.placeVerdict?.(data.verdict);
+      // A Revise turn that revised: its prompt takes the stamp, as a reload
+      // draws it, and the stack folds (revise_stack.js follows the DOM).
+      if (data.revises?.turn_id && turnId) {
+        for (const prompt of findInTurnRoots(".bubble.user[data-turn-id]")) {
+          if (prompt.dataset.turnId === turnId) prompt.dataset.revises = data.revises.turn_id;
+        }
+      }
       // after_turn hooks are running and may present the answer: its
       // answer_display (display: null when they didn't) comes next. A worker
       // that dies before it never sends one: workerGone releases the wait, and
@@ -193,13 +209,11 @@ export function createStreamHandlers(deps) {
       if (display) liveTurn.displayPending = display;
       liveTurn.endRead = readTurnEnd();
       await liveTurn.endRead;
-      // The answer bubble the turn view held at its box's height pops now
-      // 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 stage has no hold.
+      // The stage's answer is settled now that the rendered markdown is in
+      // it (or the re-read failed), and the display if one was coming, so
+      // the hand-off never moves it before its links swap in.
       if (display) await display.promise;
-      turnDom.answerReady?.();
+      turnDom.answerReady();
       // A participant's review turn: Apply under its reply, as a reload shows it.
       const review = liveTurn.review;
       liveTurn.review = null;
@@ -212,11 +226,12 @@ export function createStreamHandlers(deps) {
     // other session's answers alone.
     answer_display: async (data) => {
       const id = selected();
+      const still = stillOn(selected, id);
       try {
         await liveTurn.endRead;
-        if (!id || id !== selected() || (!data.display && !data.refs)) return;
+        if (!id || !still() || (!data.display && !data.refs)) return;
         const d = await getSession(id, { tail: true, recent: true });
-        if (id !== selected()) return;
+        if (!still()) return;
         if (Array.isArray(d.messages)) applyFinalMarkdown(d.messages);
       } catch (_) {
       } finally {
@@ -247,9 +262,11 @@ export function createStreamHandlers(deps) {
     prompt_restored: async (data) => {
       const id = selected();
       keepEarlyRestore(data, earlyRestores, { myId: clientId, sentIds });
-      const { refill, label, images: restoredImages, verify } = restoreAction(data, { myId: clientId, sentIds, composerEmpty: composer.empty() });
+      const { refill, label, images: restoredImages, verify, revises } = restoreAction(data, { myId: clientId, sentIds, composerEmpty: composer.empty() });
       if (refill) composer.refill(refill);
       if (refill && verify) deps.restoreVerify?.(verify);
+      // A Revise turn's draft too: its chip comes back with the text.
+      if (refill && revises) deps.restoreRevise?.(revises);
       if (restoredImages?.length) composer.setChips(restoredChips(selected(), restoredImages));
       const failedText = liveTurn.failedText;
       liveTurn.failedText = null;
@@ -276,40 +293,24 @@ export function createStreamHandlers(deps) {
       // A queued /working-set line is no longer pending (the list's pill).
       workingSet?.commandRan(data);
       const view = commandView(data, clientId);
-      if (view.modelName && view.modelName !== state().model) {
-        state().model = view.modelName;
-        state().served = null;
-        updateInfoBar();
-      }
-      // A fresh link's picker shows the model the worker kept, a refused
-      // /model too (its pick set the button before the answer).
-      if (view.modelName) syncModelPick?.();
+      // What the command changed, in one patch: the bar and the chips'
+      // popovers redraw once (the store; the working set's list follows
+      // /llm-context: workingSetStrategy).
+      const patch = {};
+      if (view.modelName && view.modelName !== store.current.model) Object.assign(patch, { model: view.modelName, served: null });
       // /llm-context changed what the next turn runs under.
-      if (data.llm_context) {
-        state().llmContext = data.llm_context;
-        updateInfoBar();
-        llmContextControl.refresh();
-        // The working set's list offers pin only under forget.
-        workingSet?.strategyChanged();
-      }
+      if (data.llm_context) patch.llmContext = data.llm_context;
       // /thinking (or /model) changed the level the next turn runs at.
-      if (data.thinking) {
-        state().thinking = data.thinking;
-        updateInfoBar();
-        thinkingControl.refresh();
-      }
+      if (data.thinking) patch.thinking = data.thinking;
       // /reasoning-history (or /model) changed it; null: the model now runs
       // on a native host, which ignores it (the chip goes).
-      if ("reasoning_history" in data) {
-        state().reasoningHistory = data.reasoning_history || null;
-        updateInfoBar();
-        reasoningHistoryControl.refresh();
-      }
+      if ("reasoning_history" in data) patch.reasoningHistory = data.reasoning_history || null;
       // /toolkit changed what the next turn declares; null: full (no chip).
-      if ("toolkit" in data) {
-        state().toolkit = data.toolkit || null;
-        updateInfoBar();
-      }
+      if ("toolkit" in data) patch.toolkit = data.toolkit || null;
+      store.update({ current: patch });
+      // A fresh link's picker shows the model the worker kept, a refused
+      // /model too (its pick set the button before the answer): an event (D9).
+      if (view.modelName) syncModelPick?.();
       if (view.resync) {
         await resync();
         // Another session was opened during the re-read: the bubble isn't its.
@@ -375,34 +376,33 @@ export function createStreamHandlers(deps) {
     // ignored with web.working_set off.
     working_set_updated: (data) => { workingSet?.update({ items: data.items, at: data.at, ...(data.adds ? { adds: data.adds } : {}) }); },
     context_status: (data) => {
-      const current = state();
+      const current = store.current;
+      const patch = {};
       // After /model (Engine#announce_switched_context!): the new model's
       // window, and usage null when it didn't resolve (the % clears, "ctx ?").
       // Only that event carries the key: a null drops the old model's window,
       // so the chunks before the next window count no % against it.
       if (data && "context_window_tokens" in data) {
-        current.ctxWindow = data.context_window_tokens || null;
-        current.ctxWindowSource = data.context_window_tokens ? data.context_window_source || null : null;
+        patch.ctxWindow = data.context_window_tokens || null;
+        patch.ctxWindowSource = data.context_window_tokens ? data.context_window_source || null : null;
         // The ctx tooltip's "until the next request" (ctxBarTip).
-        current.ctxUnknownAfterSwitch = !data.context_window_tokens;
+        patch.ctxUnknownAfterSwitch = !data.context_window_tokens;
       }
       if (data && "usage" in data && data.usage === null) {
-        current.ctxPct = null;
-        updateInfoBar();
+        store.update({ current: { ...patch, ctxPct: null } });
         return;
       }
-      const pct = extractCtxPct(data, current.ctxWindow, current.llmContext?.budget_tokens);
-      if (pct !== null) {
-        current.ctxPct = pct;
-        updateInfoBar();
-      }
+      const ctxWindow = "ctxWindow" in patch ? patch.ctxWindow : current.ctxWindow;
+      const pct = extractCtxPct(data, ctxWindow, current.llmContext?.budget_tokens);
+      if (pct !== null) patch.ctxPct = pct;
+      store.update({ current: patch });
     },
     question_requested: (data) => {
       const pq = data.pending_question;
       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);
+      if (pq.refs) turnDom.questionRefs(pq.refs);
       questionCards.renderQuestion(pq);
     },
     question_answered: (data) => {
@@ -417,13 +417,12 @@ export function createStreamHandlers(deps) {
     // the server's whole side block, for the ctx tooltip's line at once.
     side_usage: (data) => {
       if (!data?.side || typeof data.side !== "object") return;
-      state().timing.side = data.side;
-      updateInfoBar();
+      store.update({ current: { timing: { ...store.current.timing, side: data.side } } });
     },
     // One collected just as a turn started describes the chat before it.
     recap_ready: (data) => {
       // After the turn it covers, never above it.
-      turnDom.handOff?.({ immediate: true });
+      turnDom.handOff({ immediate: true });
       if (!liveTurn.running) showRecap(data.recap, 0, data.created_at || null);
     },
     guardrail_warning: (data) => showGuardrailWarning(data.message, data.label || "guardrails"),
@@ -433,8 +432,7 @@ export function createStreamHandlers(deps) {
     hook_notice: (data) => {
       // A plugin put the session on another toolkit (ctx.use_toolkit).
       if ("toolkit" in data) {
-        state().toolkit = data.toolkit || null;
-        updateInfoBar();
+        store.update({ current: { toolkit: data.toolkit || null } });
       }
       if (shownElsewhere(data, capabilities())) return;
       if (!turnDom.notice(data)) showHookNotice(data);

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

@@ -4,7 +4,7 @@
 // and the stops in flight. The in-flight set lives here, not in the DOM:
 // the stage rebuilds its "now" slot, and a redraw must keep a clicked
 // button disabled. Pure but for the injected calls, so `node --test`
-// covers it; turn_view.js and stage_view.js draw the button.
+// covers it; turn_block.js and stage_view.js draw the button.
 import { stopTask as postStopTask } from "./data.js";
 import { clip } from "./format.js";
 

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

@@ -1,16 +1,9 @@
-// The session bar's thinking chip: the level the next turn runs at ("think
-// low"; "· session" when the session set its own), and a popover with a
-// level select that runs /thinking in the session's worker (the command's
-// reply shows in the conversation, like a typed one). The level and where
-// it came from are the session's thinking (SettingExplained#summary:
-// {level, source, own}; the worker's snapshot, a command_ran, or the
-// server's own reading of the session file). A config on level_chip.js.
-//
-// The start page's new session sets its level in the ⚙ panel instead
-// (start_settings.js, over LEVELS).
+// Thinking as a level setting (level_chip.js): the levels the settings
+// panels' Thinking row offers (settings_panel.js; the start page's ⚙ panel,
+// the session bar's, settings_chip.js) and the /thinking line a session's
+// pick runs in its worker.
 
 import * as level from "./level_chip.js";
-import { html, nothing } from "./vendor/lit-html.js";
 
 export const LEVELS = ["off", "low", "medium", "high"];
 
@@ -19,42 +12,11 @@ export const CONFIG = Object.freeze({
   prefix: "think",
   command: "/thinking",
   levels: LEVELS,
-  anchor: "[data-think-chip]",
-  formClass: "think-form",
-  popoverClass: "think-popover",
-  nowClass: "think-now",
-  when: () => "From the next turn's start. On Gemma the whole prompt is read again; a hosted API reads the whole conversation again.",
+  cost: "A thinking change: on Gemma the whole prompt is read again; a hosted API reads the whole conversation again.",
 });
 
-export const { nowText } = level;
-
-// The chip: its text, tooltip and whether the session set its own; null
-// without a summary (an older worker). The default with nothing set
-// anywhere shows too ("think default"): the chip is where the level is set.
-export function chipModel(summary) {
-  return level.chipModel(CONFIG, summary);
-}
-
-// The session bar's chip (a lit-html template; info_bar.js), nothing
-// without a summary.
-export function chipTemplate(summary) {
-  const chip = chipModel(summary);
-  if (!chip) return nothing;
-  return html`<button type="button" class=${`model think-chip${chip.own ? " own" : ""}`} title=${chip.title} data-think-chip aria-haspopup="dialog">${chip.text}</button>`;
-}
-
-// The /thinking line for a select value, with --yes (level_chip.js
-// commandLine); null when it is what the form opened with.
+// The /thinking line for a level, with --yes (level_chip.js commandLine);
+// null when it is the session's (+initial+).
 export function commandLine(choice, initial = null) {
   return level.commandLine(CONFIG, choice, initial);
 }
-
-// The popover's form (level_chip.js formTemplate).
-export function formTemplate(summary, opts) {
-  return level.formTemplate(CONFIG, summary, opts);
-}
-
-// The chip's popover (level_chip.js createLevelControl).
-export function createThinkingControl({ id = "thinkingPopover", ...opts }) {
-  return level.createLevelControl({ cfg: CONFIG, id, ...opts });
-}

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

@@ -28,7 +28,7 @@ export function timeGapEl(text) {
 
 // The history items a group (timing.js turnGroups) holds, by index.
 function groupIndexes(group) {
-  if (group.kind === "note" || group.kind === "steer") return [group.i];
+  if (group.kind === "note" || group.kind === "steer" || group.kind === "command") return [group.i];
   if (group.kind === "answer") return [group.answer];
   const steps = group.steps || [];
   return [
@@ -54,11 +54,14 @@ export function groupTimes(group, items) {
 
 // For each group, the divider text before it, or null. A group with no
 // known time draws none and hides the gap across it (no divider measured
-// over a stretch whose times are unknown).
+// over a stretch whose times are unknown). A `!cmd`'s record is saved with
+// no time: it draws none and the gap is measured across it (it ran in that
+// stretch).
 export function groupGaps(groups, items, now = Date.now()) {
   let prevEnd = null;
   return groups.map((group) => {
     const { start, end } = groupTimes(group, items);
+    if (group.kind === "command" && start === null) return null;
     const text = prevEnd !== null && start !== null ? gapText(prevEnd, start, now) : null;
     prevEnd = end;
     return text;

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

@@ -1,3 +1,5 @@
+import { isShellCommandItem } from "./shell_command.js";
+
 export function formatDuration(milliseconds) {
   const ms = Number(milliseconds);
   if (!Number.isFinite(ms) || ms < 0) return "";
@@ -148,8 +150,10 @@ export function turnRecordAt(timing, index) {
 }
 
 // A history item that starts a turn: a prompt, or the note a context wake
-// turn starts with (turn_start).
-const startsTurn = (item) => item?.role === "user" || (item?.role === "note" && item.turn_start === true);
+// turn starts with (turn_start). A `!cmd`'s record (shell_command.js) is a
+// user message but no prompt: no turn, no record, no timing.
+const startsTurn = (item) =>
+  (item?.role === "user" && !isShellCommandItem(item)) || (item?.role === "note" && item.turn_start === true);
 
 // For each history item, the turn index its timing shows under, or null. A
 // turn with tool calls holds several assistant messages; only the last one
@@ -173,7 +177,7 @@ export function timedTurnIndexes(items) {
   return result;
 }
 
-// The history as turns, for the turn view's reload: notes on their own, and
+// The history as turns, for the turn block's reload: notes on their own, and
 // per prompt a turn with its record, its steps (one per iteration: the
 // turn's tool records grouped by iteration, and the assistant messages but
 // the last, in order; a text-less iteration leaves no message, so a text
@@ -181,7 +185,9 @@ export function timedTurnIndexes(items) {
 // assistant message). Assistant messages before any prompt are answers on
 // their own. A turn that ended with no answer (the server's empty_answer
 // item) has no answer: its texts are steps, and `emptyAnswer` is that
-// item's index. The turn index counts prompts, as timedTurnIndexes does. The
+// item's index. A `!cmd`'s record is a group of its own (`command`, its
+// index): no steps, no record, no turn index. 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) {
@@ -191,6 +197,10 @@ export function turnGroups(items, timing) {
   items.forEach((item, i) => {
     if (item?.role === "note" && !startsTurn(item)) {
       groups.push({ kind: "note", i });
+    } else if (isShellCommandItem(item)) {
+      // A `!cmd`'s record: its bubble alone, between the turns.
+      groups.push({ kind: "command", i });
+      turn = null;
     } else if (item?.role === "steer") {
       if (turn) turn.steers.push(i);
       else groups.push({ kind: "steer", i });
@@ -267,7 +277,7 @@ function turnGroup(g, items, timing) {
 }
 
 // A canceled turn that ran more than one step or any call has no answer:
-// its partial text stays in the block, as it does live (turn_view.js
+// its partial text stays in the block, as it does live (turn_block.js
 // turnEnded promotes only a completed turn or a lone step with no tools). A
 // failed turn never answered: its texts are steps.
 function canceledSteps(g, record, tools) {

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

@@ -1,20 +1,34 @@
-// The session bar's tools chip: the session's toolkit when it isn't full
-// ("tools lean"), with the tools it leaves out and how to change them in
-// its tooltip. The summary is the session's toolkit ({name, label,
-// left_out, reachable, removed, fallback}: Toolkit::Explained#summary; the
-// worker's snapshot or a command_ran; the server's own reading of the
-// session file has no lists). Left out is reachable (find_tools and
-// call_tool reach them) and removed (only /toolkit add brings one back).
-// Changing it is /toolkit (no popover yet). A kit with a prompt text has
-// it on the summary too (prompt), and the tooltip ends with it.
+// The session bar's 🧰 chip, after ⚙: the session's toolkit. "🧰" alone
+// while the session is on config's default kit (toolkit.default, full
+// unless set; GET /api/sessions/:id's session.toolkit_default), "🧰 lean"
+// on another; the tooltip names the kit, the tools it leaves out and how to
+// change them. No popover: /toolkit changes it. The summary is the
+// session's toolkit ({name, label, left_out, reachable, removed, fallback}:
+// Toolkit::Explained#summary, null on full; the worker's snapshot or a
+// command_ran; the server's own reading of the session file has no lists).
+// Left out is reachable (find_tools and call_tool reach them) and removed
+// (only /toolkit add brings one back). A kit with a prompt text has it on
+// the summary too (prompt), and the tooltip ends with it.
 
 import { html, nothing } from "./vendor/lit-html.js";
 
-// The chip's text and tooltip; null without a summary (full).
-export function chipModel(summary) {
-  if (!summary) return null;
+const FULL = "full";
+const CHANGE = "/toolkit lists them; /toolkit NAME, add TOOL or remove TOOL changes them from the next turn.";
+
+// The chip's text ("" while on the default kit: 🧰 alone), tooltip and
+// whether it is the default. +summary+: the session's (null: full);
+// +defaultKit+: config's toolkit.default (null: not known, full).
+export function chipModel(summary, defaultKit = null) {
+  const fallbackKit = defaultKit || FULL;
+  if (!summary) {
+    const isDefault = fallbackKit === FULL;
+    const title = isDefault ? `Toolkit: ${FULL} (the default), every tool is declared. ${CHANGE}`
+      : `Toolkit: ${FULL}, every tool is declared (the default is ${fallbackKit}). ${CHANGE}`;
+    return { text: isDefault ? "" : FULL, title, isDefault };
+  }
   const label = summary.label || summary.name;
-  const parts = [`Toolkit: ${label}, the tools this session declares.`];
+  const isDefault = !summary.fallback && label === fallbackKit;
+  const parts = [`Toolkit: ${label}${isDefault ? " (the default)" : ""}, the tools this session declares.`];
   if (summary.fallback) parts.push(`${summary.fallback}: every tool is declared (full) until it resolves.`);
   if (Array.isArray(summary.groups)) {
     parts.push(`Source groups: ${summary.groups.length ? summary.groups.join(", ") : "none"}.`);
@@ -27,15 +41,17 @@ export function chipModel(summary) {
   } else if (Array.isArray(summary.left_out)) {
     parts.push(summary.left_out.length ? `Not loaded: ${summary.left_out.join(", ")}.` : "Nothing left out.");
   }
-  parts.push("/toolkit lists them; /toolkit NAME, add TOOL or remove TOOL changes them from the next turn.");
+  parts.push(CHANGE);
   if (summary.prompt) parts.push(`Prompt: ${summary.prompt}`);
-  return { text: `tools ${label}${summary.fallback ? " ?" : ""}`, title: parts.join(" ") };
+  return { text: isDefault ? "" : `${label}${summary.fallback ? " ?" : ""}`, title: parts.join(" "), isDefault };
 }
 
-// The session bar's chip (a lit-html template; info_bar.js), nothing on
-// full.
-export function chipTemplate(summary) {
-  const chip = chipModel(summary);
-  if (!chip) return nothing;
-  return html`<span class="model tools-chip" title=${chip.title}>${chip.text}</span>`;
+// The session bar's chip (a lit-html template; info_bar.js): +toolkit+ is
+// {summary, defaultKit}; nothing without it. 🧰 is drawn as the start
+// page's toolkit icon (the glyph stays the text; index.html's CSS).
+export function chipTemplate(toolkit) {
+  if (!toolkit) return nothing;
+  const chip = chipModel(toolkit.summary, toolkit.defaultKit);
+  return html`<span class=${`model tools-chip${chip.isDefault ? " default" : ""}`} title=${chip.title}><span
+    class="chip-icon tc-kit" aria-hidden="true">🧰</span>${chip.text ? ` ${chip.text}` : ""}</span>`;
 }