samagotchi 0.134.0 → 0.136.0

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

@@ -7,13 +7,16 @@ import { inTree } from "./sessions_list.js";
 // and Unarchive, Delete and Stop, from the info bar's buttons, a card's or a
 // batch; and the start page when the open session is gone.
 //
-// Hooks: +selected()+ the open session's id or null; +state()+ its fields
-// (session_state.js); +sessions()+ / +setSessions(list)+ the page's list;
+// Hooks: +selected()+ the open session's id or null; +store+ the page's
+// session store (session_store.js: Stop's status; touch("infoBar") for the
+// continue and review in-flight sets, which it doesn't hold); +sessions()+ /
+// +setSessions(list)+ the page's list (the store's: a new list redraws the
+// lists and the bar);
 // +api+: {continueSession, startReview, archiveSession, unarchiveSession,
 // deleteSession, stopSession, sessionHolds, stopSessionHolds} (data.js);
 // +eventsLive()+ the hub's stream is open (else
-// +refresh()+ fetches the list); +lists+ (lists_view.js: render);
-// +select(id)+, +clearSelection()+, +showNotice(text)+, +updateInfoBar()+,
+// +refresh()+ fetches the list);
+// +select(id)+, +clearSelection()+, +showNotice(text)+,
 // +toast(text, action, options)+, +addCreatedSession(created)+,
 // +fillOpener(created, continuedId)+ (the new link's composer; returns a draft
 // from another session it displaced, or null), +restoreDraft(draft, opener)+
@@ -28,8 +31,8 @@ export function reviewStartedText(id, created) {
 }
 
 export function createSessionActions({
-  selected, state, sessions, setSessions, api, eventsLive, refresh, lists,
-  select, clearSelection, showNotice, updateInfoBar, toast, addCreatedSession, fillOpener, restoreDraft, closeLiveStream, workerGone,
+  selected, store, sessions, setSessions, api, eventsLive, refresh,
+  select, clearSelection, showNotice, toast, addCreatedSession, fillOpener, restoreDraft, closeLiveStream, workerGone,
   alert = (text) => globalThis.alert(text), confirm = (text) => globalThis.confirm(text),
   // The Stop sheet (stop_sheet.js): +open(id, holds)+ shows it and answers
   // true; nothing to stop (or no sheet wired) is false, and Stop is the
@@ -59,7 +62,6 @@ export function createSessionActions({
     }
     setSessions(sessions().filter((s) => s.id !== id));
     if (selected() === id) clearSelection();
-    lists.render();
   }
 
   // The open session no longer exists: back to the start page, saying why.
@@ -146,7 +148,7 @@ export function createSessionActions({
     const id = selected();
     const short = id.slice(0, 8);
     continuingIds.add(id);
-    updateInfoBar();
+    store.touch("infoBar");
     try {
       const created = await api.continueSession(id);
       markArchived([id], true);
@@ -176,7 +178,7 @@ export function createSessionActions({
       }
     } finally {
       continuingIds.delete(id);
-      updateInfoBar();
+      store.touch("infoBar");
     }
   }
 
@@ -192,7 +194,7 @@ export function createSessionActions({
     if (!selected() || reviewingIds.has(selected())) return null;
     const id = selected();
     reviewingIds.add(id);
-    updateInfoBar();
+    store.touch("infoBar");
     try {
       const created = await api.startReview(id);
       addCreatedSession(created);
@@ -210,7 +212,7 @@ export function createSessionActions({
       return null;
     } finally {
       reviewingIds.delete(id);
-      updateInfoBar();
+      store.touch("infoBar");
     }
   }
 
@@ -235,7 +237,7 @@ export function createSessionActions({
   // archive): don't wait for its stream to notice.
   function stoppedWorker(id) {
     closeLiveStream();
-    state().status = "stopped";
+    store.setStatus("stopped", "stop");
     workerGone(id);
   }
 
@@ -270,8 +272,7 @@ export function createSessionActions({
       alert(`Could not ${archive ? "archive" : "unarchive"} session ${short}: ${answer.error.message}`);
       return;
     }
-    lists.render();
-    updateInfoBar();
+    // markArchived's list redrew the lists and the bar already.
     if (!eventsLive()) refresh();
     const what = archive ? "Archived" : "Unarchived";
     toast(`${what} ${short}`, undo ? { label: "Undo", run: () => setArchived(id, !archive, { undo: false }) } : null);

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

@@ -0,0 +1,152 @@
+// The open session's fields (session_state.js emptySessionState), one entry
+// each: where a payload (GET /sessions/:id) and a hub card carry it, what
+// redraws it (session_store.js ORDER names) and who writes it. The table a
+// new field or a new writer starts from (docs/internals/web-frontend.md,
+// "The session store").
+//
+// Every write goes through the store (app.js `store`: update, setStatus,
+// replaceCurrent), never `current.X = …` (the lint rule in
+// eslint.config.js). Two writers stay outside, on purpose (D8):
+// - live_timing.js sets `timing().activeTurn` in place (start, finish,
+//   finishLine): the running turn's own clock, which mergeTurnTiming keeps.
+// - verdict_fresh.js `startFresh` pushes onto `fresh.running`, which is
+//   `verifyFresh` (verifyFreshState hands the array out): returning the
+//   entry for an update would leave the card holding the old array.
+//
+// A new module: the page's modules are cached at unversioned URLs, and a
+// new export of an old module would leave a cached copy without it.
+
+import { withLiveStatus } from "./format.js";
+
+const isList = (v) => Array.isArray(v);
+const list = (v) => (isList(v) ? v : undefined);
+
+// Per field:
+//   source(payload)  the payload carries it (not undefined): a partial
+//                    re-read takes it (session_payload.js sessionFieldsFrom).
+//                    No source: a payload always sets it (sessionStateFrom),
+//                    or never does (the page's own fields).
+//   card(sess)       its value on a hub card (followSelectedSession)
+//   redraws          what reads it (session_store.js ORDER)
+//   writers          who writes it (besides renderSessionView's payload and
+//                    forgetSession's reset, which write every field)
+export const FIELDS = {
+  firstPreview: { redraws: ["infoBar"], writers: "send_turn.js (the first prompt)" },
+  usedMemories: {
+    source: (d) => list(d.session?.used_memory_names),
+    redraws: ["infoBar"],
+    writers: "setUsedMemories (stream), readTurnEnd; both replace the card too",
+  },
+  preloadedMemories: { source: (d) => list(d.session?.preloaded_memory_names), redraws: ["infoBar"], writers: "the payload" },
+  mutedMemories: { source: (d) => list(d.session?.muted_memory_names), redraws: ["infoBar"], writers: "the payload" },
+  promptNotes: { source: (d) => list(d.session?.prompt_notes), redraws: ["infoBar"], writers: "readTurnEnd" },
+  parentId: { redraws: ["infoBar"], writers: "the payload" },
+  continues: { redraws: ["infoBar"], writers: "the payload" },
+  review: { redraws: ["infoBar"], writers: "the payload" },
+  verdicts: {
+    source: (d) => list(d.session?.verdicts),
+    redraws: [],
+    writers: "placeVerdict (its card draws itself: placeVerdictWithFresh)",
+  },
+  verifyFresh: {
+    source: (d) => list(d.session?.verify_fresh),
+    redraws: [],
+    writers: "placeVerdict (settleRunning); verdict_fresh.js startFresh pushes in place (D8)",
+  },
+  createdAt: { redraws: ["infoBar"], writers: "the payload" },
+  ctxPct: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_chunk, context_status)" },
+  ctxWindow: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },
+  ctxWindowSource: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },
+  ctxUnknownAfterSwitch: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },
+  status: {
+    source: (d) => d.session?.status || undefined,
+    card: (sess) => sess.status,
+    redraws: ["infoBar"],
+    writers: "store.setStatus only (statusWrite below): the hub, the stream, a turn end's re-read, Stop, the payload",
+  },
+  thinking: { redraws: ["settingsPanel", "infoBar"], writers: "stream_handlers.js command_ran" },
+  model: {
+    source: (d) => d.session?.model_name,
+    redraws: ["infoBar"],
+    writers: "stream_handlers.js command_ran (a new model also syncModelPick: an event, D9)",
+  },
+  served: { redraws: ["infoBar"], writers: "stream_handlers.js (command_ran, generation_completed)" },
+  dir: { source: (d) => d.session?.working_directory, redraws: ["infoBar"], writers: "the payload" },
+  owner: {
+    card: (sess) => sess.owner || null,
+    redraws: ["composer", "infoBar"],
+    writers: "followSelectedSession, workerGone (worker → null), send_turn.js and composerCommands.ownedByTui (\"tui\")",
+  },
+  commands: {
+    source: (d) => list(d.commands),
+    redraws: ["infoBar"],
+    writers: "the payload (the / list and the annotate bar read it at use; the bar refreshes the annotate bar)",
+  },
+  workerVersion: { card: (sess) => sess.worker_version || null, redraws: ["infoBar"], writers: "followSelectedSession" },
+  workerFeatures: {
+    card: (sess) => (isList(sess.worker_features) ? sess.worker_features : []),
+    redraws: ["featureGates", "infoBar"],
+    writers: "followSelectedSession",
+  },
+  bridgeUp: {
+    card: (sess) => sess.bridge_up === true,
+    redraws: ["featureGates", "infoBar"],
+    writers: "followSelectedSession, workerGone",
+  },
+  llmContext: {
+    redraws: ["settingsPanel", "workingSetStrategy", "infoBar"],
+    writers: "stream_handlers.js command_ran",
+  },
+  reasoningHistory: { redraws: ["settingsPanel", "infoBar"], writers: "stream_handlers.js command_ran" },
+  toolkit: { redraws: ["infoBar"], writers: "stream_handlers.js (command_ran, hook_notice)" },
+  toolkitDefault: { redraws: ["infoBar"], writers: "the payload" },
+  timing: {
+    source: (d) => d.timing,
+    redraws: ["infoBar"],
+    writers: "mergeTurnTiming; stream_handlers.js (generation_completed: tokens, modelSegments; side_usage: side), " +
+      "always a new object; live_timing.js sets activeTurn in place (D8)",
+  },
+  turnStarted: { redraws: ["composer", "infoBar"], writers: "setTurnRunning" },
+  streamSeq: { redraws: [], writers: "resync" },
+  streamFromGuess: { redraws: [], writers: "followWokenWorker, startStream, the stream's takeGuess" },
+};
+
+// The fields a hub card brings for the open session (followSelectedSession):
+// its owner and worker. Never its status: that goes through setStatus, so
+// "the hub's status only while not streaming" can't be bypassed.
+const CARD_FIELDS = ["owner", "workerVersion", "workerFeatures", "bridgeUp"];
+
+// @param sess a hub card (the open session's)
+// @return {owner, workerVersion, workerFeatures, bridgeUp}
+export function fieldsFromCard(sess) {
+  return Object.fromEntries(CARD_FIELDS.map((key) => [key, FIELDS[key].card(sess)]));
+}
+
+// Whether a status write from +source+ applies, and what it does to the
+// open session's card (null: the card is left alone).
+//   payload  renderSessionView: always
+//   hub      followSelectedSession: only while the stream isn't live
+//   stream   setLiveStatus (turn_*, workerGone's idle): always; the card
+//            takes it too (withLiveStatus: status, owner, updated_at)
+//   turnEnd  readTurnEnd, the turn_canceled re-read: only while no turn
+//            runs (a re-read landing after the next queued turn's
+//            turn_started doesn't write its stored "idle" over "running";
+//            mergeTurnTiming keeps activeTurn by the same test); the caller
+//            skips a payload without one; readTurnEnd writes its card
+//            itself, after its timing merge
+//   stop     session_actions.js stoppedWorker: always; workerGone's
+//            withoutWorker takes care of the card
+// @param source one of the above
+// @param streaming whether the open session's stream is live
+// @param running whether a turn runs on the page (liveTurn.running)
+// @return {apply, card: (sess, status) => sess | null}
+export function statusWrite(source, { streaming = false, running = false } = {}) {
+  switch (source) {
+    case "payload": return { apply: true, card: null };
+    case "hub": return { apply: !streaming, card: null };
+    case "stream": return { apply: true, card: withLiveStatus };
+    case "turnEnd": return { apply: !running, card: null };
+    case "stop": return { apply: true, card: null };
+    default: throw new Error(`statusWrite: no source ${source}`);
+  }
+}

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

@@ -0,0 +1,35 @@
+// A partial re-read of the open session (GET /sessions/:id with ?tail,
+// ?recent…): the fields of the page's session state it brings, read as a
+// full load reads them (session_state.js sessionStateFrom), so a field's
+// rule lives in one place. app.js applySessionPayload writes them through
+// the store; the caller then calls the field's redraw
+// (docs/internals/web-frontend.md, "The session store").
+//
+// A new module, not an export of session_state.js: the page's modules are
+// cached at unversioned URLs, and a new export of an old module would
+// leave a cached copy without it.
+
+import { sessionStateFrom } from "./session_state.js";
+import { FIELDS } from "./session_fields.js";
+
+// Where each field comes from in the payload (session_fields.js FIELDS
+// sources): a field whose source the payload doesn't carry (a partial read
+// leaves it out, or an older chi web never sent it) is not touched. Fields
+// without one are always taken.
+//
+// The named +fields+ of the session state +data+ sets (sessionStateFrom's
+// values), those whose source it carries.
+// @param data a GET /sessions/:id answer (it has a session)
+// @param fields the state's keys (emptySessionState's), e.g. ["status"]
+// @return {field: value} for the fields it brings
+export function sessionFieldsFrom(data, fields) {
+  if (!data?.session) return {};
+  const all = sessionStateFrom(data);
+  const out = {};
+  for (const field of fields) {
+    const source = FIELDS[field]?.source;
+    if (source && source(data) === undefined) continue;
+    if (field in all) out[field] = all[field];
+  }
+  return out;
+}

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

@@ -40,6 +40,8 @@ export function emptySessionState() {
     // (stream_handlers.js context_status): the ctx tooltip says it waits.
     ctxUnknownAfterSwitch: false,
     status: "",
+    // The level the next turn thinks at ({level, source, own}: the thinking chip), or null.
+    thinking: null,
     model: "",
     // What the worker's server said it served for a model name: [served, asked].
     served: null,
@@ -55,12 +57,15 @@ export function emptySessionState() {
     workerFeatures: [],
     bridgeUp: false,
     // The LLM context strategy, apply rule and budget the next turn runs
-    // under, each with its source (the info bar's llm ctx chip), or null.
+    // under, each with its source (the info bar's ⚙ chip), or null.
     llmContext: null,
     // Which of its reasoning the model gets back from the next turn on, with
-    // its source (the reasoning history chip), or null (a native host).
+    // its source (the ⚙ chip's), or null (a native host).
     reasoningHistory: null,
     toolkit: null,
+    // config's toolkit.default as chi web reads it (the 🧰 chip: a session on
+    // it shows 🧰 alone), or null (an older chi web: no 🧰 for full).
+    toolkitDefault: null,
     timing: normalizeTiming(),
     // A turn started on it while the page had it open (setTurnRunning): a
     // fresh link's picker goes at once, before the timing re-read brings the
@@ -74,8 +79,6 @@ export function emptySessionState() {
     // The stream was opened from 0 (a wake with no cursor to go on) and no
     // new turn has started on it yet (app.js followWokenWorker).
     streamFromGuess: false,
-    // When the info bar's "copy chi --attach" copied (its "copied ✓").
-    attachCopiedAt: 0,
   };
 }
 
@@ -116,8 +119,9 @@ export function sessionStateFrom(data) {
   state.thinking = s.thinking || null;
   // null on a native host (it ignores the level) and from an older worker.
   state.reasoningHistory = s.reasoning_history || null;
-  // The tools chip's (null on full).
+  // The 🧰 chip's (null on full) and the default kit it is read against.
   state.toolkit = s.toolkit || null;
+  state.toolkitDefault = s.toolkit_default || null;
   state.parentId = s.parent_id || null;
   state.continues = s.continues || null;
   state.review = s.review || null;

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

@@ -0,0 +1,191 @@
+// The owner page's session state in one place: the open session's id
+// (selected), its fields (current, session_state.js) and every card
+// (sessions, the hub's projection). Writes go through update() (and
+// replaceCurrent() for forgetSession's reset); a write marks the redraws
+// that read what changed, and they run synchronously at the end of the
+// outermost batch(), or at once for a bare write.
+// See docs/internals/web-frontend.md ("The session store").
+//
+// A new module: the page's modules are cached at unversioned URLs, and a
+// new export of an old module would leave a cached copy without it.
+
+import { FIELDS, statusWrite } from "./session_fields.js";
+
+// The redraws, by name, in the one order a flush runs them: the lists
+// before the bar (updateSessionTitle reads the strip's active card), the
+// composer before the bar (as setTurnRunning runs them).
+export const ORDER = [
+  "lists",
+  "paintActive",
+  "settingsPanel", "workingSetStrategy",
+  "featureGates",
+  "composer",
+  "infoBar",
+];
+
+// What a change of the list or of the open session's id redraws: the bar
+// reads the list too (the chain's ← → links, the children chip, the
+// archived button, the card's title, the fresh link's picker).
+const SESSIONS_REDRAWS = ["lists", "infoBar"];
+const SELECTED_REDRAWS = ["paintActive", "composer", "infoBar"];
+
+// A flush whose redraws keep writing stops after this many passes.
+export const MAX_PASSES = 3;
+
+// @param initial the open session's fields to start from (emptySessionState())
+// @param fields {key: {redraws: [name]}} what each field of `current` redraws
+//   (session_fields.js FIELDS by default); a field it doesn't list redraws nothing
+// @param log where a refused batch, a capped flush and a redraw error that
+//   can't be thrown go (console by default)
+export function createSessionStore({ initial = {}, fields = FIELDS, log = console } = {}) {
+  let selected = null;
+  let current = initial;
+  let sessions = [];
+  const redraws = new Map(ORDER.map((name) => [name, []]));
+  const pending = new Set();
+  let depth = 0;
+  let flushing = false;
+
+  const enqueue = (names) => names.forEach((name) => pending.add(name));
+  const fieldRedraws = (key) => fields[key]?.redraws || [];
+
+  // Run the pending redraws in ORDER, a pass at a time: a write made during
+  // a redraw only enqueues (the flushing flag), and the next pass takes it.
+  // A redraw that throws doesn't stop the others; the first error is thrown
+  // once the flush is over.
+  function flush() {
+    if (flushing || depth > 0) return;
+    flushing = true;
+    let error = null;
+    try {
+      for (let pass = 0; pending.size > 0; pass += 1) {
+        if (pass === MAX_PASSES) {
+          log.error(`session store: still redrawing after ${MAX_PASSES} passes: ${[...pending].join(", ")}`);
+          pending.clear();
+          break;
+        }
+        const names = ORDER.filter((name) => pending.has(name));
+        pending.clear();
+        for (const name of names) {
+          for (const fn of redraws.get(name)) {
+            try {
+              fn();
+            } catch (e) {
+              error ??= e;
+            }
+          }
+        }
+      }
+    } finally {
+      flushing = false;
+    }
+    if (error) throw error;
+  }
+
+  const store = {
+    get selected() { return selected; },
+    get current() { return current; },
+    get sessions() { return sessions; },
+
+    // Write the given parts: +selected+ (an id or null), +current+ (fields
+    // written into the open session's object, which stays the same object),
+    // +sessions+ (a new list: one changed in place isn't seen). A changed
+    // value (!==) marks its redraws.
+    update(patch = {}) {
+      if ("selected" in patch && patch.selected !== selected) {
+        selected = patch.selected;
+        enqueue(SELECTED_REDRAWS);
+      }
+      if (patch.current) {
+        for (const [key, value] of Object.entries(patch.current)) {
+          if (current[key] === value) continue;
+          current[key] = value;
+          enqueue(fieldRedraws(key));
+        }
+      }
+      if ("sessions" in patch && patch.sessions !== sessions) {
+        sessions = patch.sessions;
+        enqueue(SESSIONS_REDRAWS);
+      }
+      flush();
+    },
+
+    // The open session's status from +source+ (session_fields.js statusWrite:
+    // payload, hub, stream, turnEnd, stop), under that source's rule; a
+    // source with a card rule replaces the open session's card too.
+    // @param streaming whether the open session's stream is live (the hub's rule)
+    // @param running whether a turn runs on the page
+    // @return whether the open session's card was replaced (the caller redraws the lists)
+    setStatus(value, source, { streaming = false, running = false } = {}) {
+      const { apply, card } = statusWrite(source, { streaming, running });
+      if (!apply) return false;
+      let carded = false;
+      store.batch(() => {
+        store.update({ current: { status: value } });
+        if (!card) return;
+        const i = sessions.findIndex((s) => s.id === selected);
+        if (i < 0) return;
+        const next = sessions.slice();
+        next[i] = card(sessions[i], value);
+        store.update({ sessions: next });
+        carded = true;
+      });
+      return carded;
+    },
+
+    // A new open session's fields (forgetSession only): always a new object,
+    // so a stale async writer still holding the old one writes into it alone.
+    replaceCurrent(state) {
+      current = { ...state };
+      enqueue(Object.keys(current).flatMap(fieldRedraws));
+      flush();
+    },
+
+    // Run +fn+ (synchronous) with its writes' redraws held to its end; nested
+    // batches join the outermost. The redraws run even when +fn+ throws (the
+    // page shows what was written), then its error is rethrown. An +fn+ that
+    // returns a promise is refused: its writes after an await would land
+    // outside the batch, so batch only an async function's synchronous parts.
+    batch(fn) {
+      depth += 1;
+      let result;
+      let failed = false;
+      let error;
+      try {
+        result = fn();
+      } catch (e) {
+        failed = true;
+        error = e;
+      } finally {
+        depth -= 1;
+      }
+      if (result && typeof result.then === "function") {
+        log.error("session store: batch() takes a synchronous function; batch an async one's synchronous parts");
+      }
+      if (failed) {
+        try {
+          flush();
+        } catch (e) {
+          log.error(e);
+        }
+        throw error;
+      }
+      flush();
+      return result;
+    },
+
+    // Something the store doesn't hold changed (the clock, versions, the
+    // stream): +name+'s redraw runs.
+    touch(name) {
+      enqueue([name]);
+      flush();
+    },
+
+    // Register +fn+ as (one of) the redraw(s) called +name+ (one of ORDER).
+    on(name, fn) {
+      if (!redraws.has(name)) throw new Error(`session store: no redraw called ${name}`);
+      redraws.get(name).push(fn);
+    },
+  };
+  return store;
+}