samagotchi 0.55.0 → 0.57.0

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

@@ -0,0 +1,206 @@
+// `path:line` refs in an answer's or a step's text (traceable refs P3).
+// A name becomes a file ref (refs.js: span.ref with data-ref-kind="file")
+// only when it names a file the session's rows touched (their refs): the
+// answer's text is unchanged, it resolves on the page, and nothing the
+// session didn't touch gets linked. The scan is github-pr's LineLinker
+// (bundles/github-pr/plugin.rb) on the DOM: pre, links and fenced blocks
+// are left alone, inline code only when it is the ref alone, a bare URL's
+// text too.
+
+import { refAttrs } from "./refs.js";
+
+// A path (no spaces), a line, an optional end line and an optional column
+// (kept in the text, not used). LineLinker::REF.
+export const REF = /(?<![\w./@+~-])(?<path>[\w./@+~-]*[\w@+~-]):(?<from>\d+)(?:-(?<to>\d+))?(?::\d+)?(?![\w/])/;
+export const REF_ALONE = new RegExp(`^${REF.source}$`);
+// A ref, or a bare path (no `:line`): a bare one counts only when it is a
+// touched file exactly (resolveRef's +bare+). Not after a `\` or a `:`
+// either: the tail of `C:\x\foo.rb:3` or `host:lib/foo.rb:3` is another
+// machine's file.
+const REF_OR_PATH = /(?<![\w./@+~\\:-])(?<path>[\w./@+~-]*[\w@+~-])(?::(?<from>\d+)(?:-(?<to>\d+))?(?::\d+)?(?![\w/])|(?![\w/]|:\d))/g;
+const PATH_ALONE = /^(?<path>[\w./@+~-]*[\w@+~-])$/;
+const URL_SPAN = /[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+const MARKDOWN_LINK = /\[[^\]]*\]\([^)]*\)/g;
+// A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+// Elements whose text is never scanned: code blocks, links (a github-pr
+// PR link stays the PR's), a ref already made.
+const SKIP = "pre, a, [data-ref-kind]";
+
+// The ref a match names: { path, line, endLine } or null. A path has a `/`
+// or an extension (`10:30` is a time, `host:8080` a port); line 0 is never
+// a ref; an end line not after the line is dropped.
+export function refOf(groups) {
+  const path = groups?.path || "";
+  if (!path.includes("/") && !/\.[A-Za-z0-9]+$/.test(path)) return null;
+  if (groups.from === undefined) return { path, line: null, endLine: null };
+  const line = Number(groups.from);
+  if (!line) return null;
+  const to = groups.to === undefined ? null : Number(groups.to);
+  return { path, line, endLine: to && to > line ? to : null };
+}
+
+// The absolute touched file +path+ names, or null: the path itself when
+// absolute, else the path under +cwd+ (`.` and `..` folded either way); else (not for a +bare+ path: no
+// `:line`) the ONE touched file ending in `/<path>`. Ambiguous: none.
+export function resolveRef(path, touched, cwd, { bare = false } = {}) {
+  const rel = String(path).replace(/^(?:\.\/)+/, "");
+  const exact = rel.startsWith("/") ? joinPath("", rel) : cwd ? joinPath(cwd, rel) : null;
+  if (exact && touched.has(exact)) return exact;
+  if (bare || rel.startsWith("/")) return null;
+  const tail = `/${rel.replace(/^(?:\.\.\/)+/, "")}`;
+  const found = [...touched].filter((file) => file.endsWith(tail));
+  return found.length === 1 ? found[0] : null;
+}
+
+// +rel+ under +dir+, `.` and `..` segments folded.
+function joinPath(dir, rel) {
+  const out = [];
+  for (const part of `${dir}/${rel}`.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return `/${out.join("/")}`;
+}
+
+// [start, end, ref] for each ref in a plain +text+ that names a touched
+// file: fenced blocks, markdown links and URLs skipped, inline code only
+// as the ref alone (the span with its backticks). +touched+: a Set of
+// absolute paths; +cwd+: the session's working directory.
+export function textRefs(text, touched, cwd) {
+  if (!touched?.size || !text) return [];
+  const fences = fencedBlocks(text);
+  const skipped = [...fences, ...spans(text, URL_SPAN), ...spans(text, MARKDOWN_LINK)];
+  const code = inlineCode(text, fences);
+  const found = [];
+  for (const [start, end, inner] of code) {
+    if (insideAny(skipped, start, end)) continue;
+    const ref = aloneRef(inner, touched, cwd);
+    if (ref) found.push([start, end, ref]);
+  }
+  for (const match of text.matchAll(REF_OR_PATH)) {
+    const start = match.index;
+    const end = start + match[0].length;
+    if (insideAny(skipped, start, end) || insideAny(code, start, end)) continue;
+    const ref = resolved(refOf(match.groups), touched, cwd);
+    if (ref) found.push([start, end, ref]);
+  }
+  return found.sort((a, b) => a[0] - b[0]);
+}
+
+// The ref an inline code's text is when it is a ref (or a touched path)
+// alone, else null.
+function aloneRef(text, touched, cwd) {
+  const inner = String(text).trim();
+  const match = inner.match(REF_ALONE) || inner.match(PATH_ALONE);
+  return match ? resolved(refOf(match.groups), touched, cwd) : null;
+}
+
+function resolved(ref, touched, cwd) {
+  if (!ref) return null;
+  const path = resolveRef(ref.path, touched, cwd, { bare: ref.line === null });
+  return path ? { kind: "file", path, line: ref.line, end_line: ref.endLine } : null;
+}
+
+// The absolute paths of the file refs under +roots+ (the session's rows,
+// approval cards): what a text ref may name.
+export function touchedFiles(roots) {
+  const touched = new Set();
+  for (const root of roots) {
+    for (const el of root.querySelectorAll('[data-ref-kind="file"][data-ref-path]')) {
+      touched.add(el.dataset.refPath);
+    }
+  }
+  return touched;
+}
+
+// Wraps the refs in +el+'s text in span.ref (refs.js clicks and
+// hover them as it does a row title). Text inside pre, a link or a ref is
+// left alone; an inline code element is wrapped whole when it is a ref
+// alone. Runs again over the same element without wrapping twice.
+export function linkRefs(el, touched, cwd) {
+  if (!el || !touched?.size) return;
+  const doc = el.ownerDocument;
+  for (const code of [...el.querySelectorAll("code")]) {
+    if (code.closest(SKIP)) continue;
+    const ref = aloneRef(code.textContent, touched, cwd);
+    if (!ref) continue;
+    const span = refSpan(doc, ref);
+    code.replaceWith(span);
+    span.append(code);
+  }
+  const walker = doc.createTreeWalker(el, 4 /* NodeFilter.SHOW_TEXT */);
+  const nodes = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const skip = node.parentElement?.closest(`${SKIP}, code`);
+    if (!skip || !el.contains(skip)) nodes.push(node);
+  }
+  for (const node of nodes) wrapRefs(node, textRefs(node.data, touched, cwd));
+}
+
+function wrapRefs(node, hits) {
+  if (!hits.length) return;
+  const doc = node.ownerDocument;
+  const frag = doc.createDocumentFragment();
+  let pos = 0;
+  for (const [start, end, ref] of hits) {
+    if (start < pos) continue;
+    if (start > pos) frag.append(node.data.slice(pos, start));
+    const span = refSpan(doc, ref);
+    span.textContent = node.data.slice(start, end);
+    frag.append(span);
+    pos = end;
+  }
+  if (pos < node.data.length) frag.append(node.data.slice(pos));
+  node.replaceWith(frag);
+}
+
+function refSpan(doc, ref) {
+  const holder = doc.createElement("div");
+  holder.innerHTML = `<span class="ref"${refAttrs(ref)}></span>`;
+  return holder.firstChild;
+}
+
+// [start, end] of each fenced block (an unclosed one runs to the end).
+function fencedBlocks(text) {
+  const blocks = [];
+  let open = null;
+  let offset = 0;
+  for (const line of text.split(/(?<=\n)/)) {
+    const marker = line.match(FENCE_OPEN)?.[1];
+    if (!open && marker) {
+      open = [offset, marker];
+    } else if (open && marker && marker[0] === open[1][0] && marker.length >= open[1].length && line.trim() === marker) {
+      blocks.push([open[0], offset + line.length]);
+      open = null;
+    }
+    offset += line.length;
+  }
+  if (open) blocks.push([open[0], text.length]);
+  return blocks;
+}
+
+// [start, end, inner] of each inline code span outside +fences+: a run of
+// backticks to the next run of the same length.
+function inlineCode(text, fences) {
+  const runs = spans(text, /`+/g).filter(([start, end]) => !insideAny(fences, start, end));
+  const found = [];
+  let index = 0;
+  while (index < runs.length) {
+    const [start, end] = runs[index];
+    const closing = runs.findIndex(([s, e], k) => k > index && e - s === end - start);
+    if (closing < 0) { index += 1; continue; }
+    found.push([start, runs[closing][1], text.slice(end, runs[closing][0])]);
+    index = closing + 1;
+  }
+  return found;
+}
+
+function spans(text, regex) {
+  return [...text.matchAll(regex)].map((m) => [m.index, m.index + m[0].length]);
+}
+
+function insideAny(list, start, end) {
+  return list.some(([s, e]) => start >= s && end <= e);
+}

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

@@ -1,7 +1,8 @@
 // Refs: quiet links from what a turn touched to the thing itself. A ref is
 // a kind and a target: today a file tool's row title (the server's FileRef,
-// {kind: "file", path, line?, end_line?}) and that row's diff lines (the
-// same file at a line). The DOM carries data-ref-kind and the target's
+// {kind: "file", path, line?, end_line?}), that row's diff lines and a
+// read row's numbered lines (the same file at a line), and an edit/write
+// approval card's paths and its dry run's diff lines. The DOM carries data-ref-kind and the target's
 // attributes, never what a click does: that is an action, kept per kind in
 // REF_ACTIONS, and a click runs the first one available to this viewer. A
 // ref with none (a phone: no editor) stays plain text; the page marks the
@@ -51,19 +52,27 @@ export function availableKinds(viewer, actions = REF_ACTIONS) {
   return Object.keys(actions).filter((kind) => refAction(kind, viewer, actions));
 }
 
+// What owns a ref and its diff lines: a tool row, or an edit's approval
+// card (its paths and its dry run).
+const OWNERS = ".activity-row, .bubble.approval";
+
+// A line of the owner's file: a diff line, or a read row's numbered line.
+const LINES = ".diff-line[data-line], .read-line[data-line]";
+
 // What a click on +el+ points at: {kind, path, line, owner} or null. A row
-// title opens its file at the lines the call named (an edit without any at
-// its first changed line); a diff line (or a hunk header) in a row with a
-// ref opens the row's file at that line. A diff line outside a row (an
-// approval card's dry run) is none.
+// title (or an approval card's path) opens its file at the lines the call
+// named (an edit without any at its first changed line); a diff line (or a
+// hunk header) or a read row's numbered line, in a row or a card with a
+// ref, opens that file at that line.
+// A diff line elsewhere is none.
 export function refTarget(el) {
   const title = el?.closest?.("[data-ref-kind]");
   if (title) {
-    const owner = title.closest(".activity-row");
+    const owner = title.closest(OWNERS);
     return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title };
   }
-  const diffLine = el?.closest?.(".diff-line[data-line]");
-  const owner = diffLine?.closest(".activity-row");
+  const diffLine = el?.closest?.(LINES);
+  const owner = diffLine?.closest(OWNERS);
   const ref = owner?.querySelector("[data-ref-kind]");
   if (!ref) return null;
   return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner };
@@ -116,7 +125,7 @@ export function installRefClicks(root, viewer, { open = defaultOpen, selection =
   root.addEventListener("mouseover", (e) => {
     const target = refTarget(e.target);
     if (!target) return;
-    const el = e.target.closest("[data-ref-kind]") || e.target.closest(".diff-line[data-line]");
+    const el = e.target.closest("[data-ref-kind]") || e.target.closest(LINES);
     if (!el) return;
     if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
     const own = el.dataset.refTitle;

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

@@ -45,6 +45,9 @@ export function emptySessionState() {
     // 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.
     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).
+    reasoningHistory: null,
     timing: normalizeTiming(),
   };
 }
@@ -78,6 +81,8 @@ export function sessionStateFrom(data) {
   state.promptNotes = Array.isArray(s.prompt_notes) ? s.prompt_notes : [];
   state.llmContext = s.llm_context || null;
   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;
   state.parentId = s.parent_id || null;
   state.continues = s.continues || null;
   state.commands = Array.isArray(data.commands) ? data.commands : [];

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

@@ -15,7 +15,8 @@
 //   capabilities()        the page's capabilities (card.js shownElsewhere)
 //   historyEl             the history element (keepFollowing, the failed-turn redraw)
 //   liveTurn, turnDom, shownTexts, questionCards, contextChips,
-//   llmContextControl, thinkingControl      the page's views
+//   llmContextControl, thinkingControl,
+//   reasoningHistoryControl                 the page's views
 //   sentIds, earlyRestores                  restore.js's bookkeeping
 //   stream: {takeGuess(), restart()}        the stream was opened from a
 //                         guess (takeGuess: whether, and forget it); restart:
@@ -49,7 +50,7 @@ import { keepEarlyRestore, restoreAction } from "./restore.js";
 export function createStreamHandlers(deps) {
   const {
     selected, state, clientId, capabilities, historyEl,
-    liveTurn, turnDom, shownTexts, questionCards, contextChips, llmContextControl, thinkingControl,
+    liveTurn, turnDom, shownTexts, questionCards, contextChips, llmContextControl, thinkingControl, reasoningHistoryControl,
     sentIds, earlyRestores, stream, composer, getSession,
     resync, updateInfoBar, applyPromptOps, showSteers, markRecapStale, setTurnRunning, setLiveStatus, endTurnView,
     appendChunk, readTurnEnd, applyFinalMarkdown, refreshTimingFromSession, makeUserBubble, addEndBubble,
@@ -213,6 +214,13 @@ export function createStreamHandlers(deps) {
         updateInfoBar();
         thinkingControl.refresh();
       }
+      // /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 (view.resync) await resync();
       // A card's action that isn't anytime (the step-limit question's
       // /continue) has no bubble: nothing to remove. An anytime or queued

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

@@ -2,20 +2,35 @@
 // 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 (Thinking::Explained#summary:
+// 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).
+// server's own reading of the session file). A config on level_chip.js.
 //
 // The start page has one too (kind "new chat"): it shows the picked
 // model's level (GET /api/models' thinking) and keeps a choice for the
 // next create only (POST /api/sessions' thinking), never remembered:
 // nothing is sent unless the user sets one.
 
-import { NEW_CHAT, SESSION, popoverPlace } from "./llm_context_chip.js";
-import { html, nothing, render } from "./vendor/lit-html.js";
+import { SESSION } from "./llm_context_chip.js";
+import * as level from "./level_chip.js";
+import { html, nothing } from "./vendor/lit-html.js";
 
 export const LEVELS = ["off", "low", "medium", "high"];
-const DEFAULT = "default";
+
+export const CONFIG = Object.freeze({
+  name: "Thinking",
+  prefix: "think",
+  command: "/thinking",
+  levels: LEVELS,
+  anchor: "[data-think-chip]",
+  formClass: "think-form",
+  popoverClass: "think-popover",
+  nowClass: "think-now",
+  when: (fresh) => (fresh ? "For the new chat's first turn on; not remembered for the next one."
+    : "From the next turn's start. On Gemma the whole prompt is read again; a hosted API reads the whole conversation again."),
+});
+
+export const { nowText } = level;
 
 // The new chat's choice (a level, or null) laid over the model's summary:
 // what the chip shows. The model's own summary without a choice.
@@ -28,13 +43,8 @@ export function withChoice(summary, choice) {
 // 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, { kind = SESSION } = {}) {
-  if (!summary || !summary.level) return null;
-  const own = !!summary.own;
-  const what = kind === NEW_CHAT ? "the new chat" : "this session";
-  const from = own ? what : summary.source || "the model's own";
-  const title = `Thinking: ${summary.level} (${from}). Click to change it for ${what}.`;
-  return { text: `think ${summary.level}${own ? ` · ${kind}` : ""}`, title, own };
+export function chipModel(summary, opts) {
+  return level.chipModel(CONFIG, summary, opts);
 }
 
 // The session bar's chip (a lit-html template; info_bar.js), nothing
@@ -45,134 +55,19 @@ export function chipTemplate(summary) {
   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 ("default" unsets the session's
-// own); null when it is what the form opened with.
-export function commandLine(level, initial = null) {
-  if (initial !== null && level === initial) return null;
-  return `/thinking ${level}`;
-}
-
-// "Now: low (session)", "Now: default (the model's own)".
-export function nowText(summary) {
-  return `Now: ${summary.level} (${summary.source || "the model's own"})`;
+// The /thinking line for a select value, with --yes (level_chip.js
+// commandLine); null when it is what the form opened with.
+export function commandLine(choice, initial = null) {
+  return level.commandLine(CONFIG, choice, initial);
 }
 
-const option = (value, label, chosen) => html`<option value=${value} ?selected=${value === chosen}>${label}</option>`;
-
-// The popover's form (a lit-html template). For the new chat (kind
-// NEW_CHAT), +summary+ is the model's and +choice+ the level the form
-// shows; +now+ is the summary its "Now:" line reads (refresh passes a
-// newer one, the rest stays as the form opened).
-export function formTemplate(summary, { running = false, kind = SESSION, choice = null, now = summary } = {}) {
-  const fresh = kind === NEW_CHAT;
-  const chosen = (fresh ? choice : summary.own) || DEFAULT;
-  const follow = summary.own && !fresh ? "follow the model" : `follow the model (${summary.level})`;
-  const when = fresh ? "For the new chat's first turn on; not remembered for the next one."
-    : "From the next turn's start. On Gemma the whole prompt is read again; a hosted API may restart its cache.";
-  return html`<form class="think-form llmctx-form"><div class="ctx-pop-head"><strong>Thinking</strong
-    ><span class="ctx-pop-kind">${fresh ? NEW_CHAT : "this session"}</span
-    ><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div
-    ><div class="ctx-pop-meta think-now">${nowText(now)}</div
-    ><label class="llmctx-field"><span>Level</span><select name="level">${option(DEFAULT, follow, chosen)}${
-      LEVELS.map((level) => option(level, level, chosen))}</select></label
-    ><div class="ctx-pop-meta">${when}${running ? " A turn is running: it applies after this turn." : ""}</div
-    ><div class="ctx-pop-actions"><button type="submit" class="llmctx-set">Set</button></div></form>`;
+// The popover's form (level_chip.js formTemplate).
+export function formTemplate(summary, opts) {
+  return level.formTemplate(CONFIG, summary, opts);
 }
 
-// The chip's popover, as createLlmContextControl's: el is where the chip
-// is drawn (clicks are delegated: #infoText, info_bar.js);
-// summary(): the open session's thinking; session(): its id; running():
-// a turn runs; run(line): sends the command. The start page's (kind
-// NEW_CHAT): summary() is the picked model's, choice() the pending level
-// and choose(next) takes a Set's (null for "follow the model"). id and
-// anchor (the chip's selector) keep it apart from the llm ctx control on
-// the same element.
-export function createThinkingControl({ el, summary, session = () => null, running = () => false, run,
-                                        kind = SESSION, choice = () => null, choose = null,
-                                        id = "thinkingPopover", anchor: anchorSel = "[data-think-chip]",
-                                        doc = document, win = window }) {
-  const fresh = kind === NEW_CHAT;
-  const pop = doc.createElement("div");
-  pop.id = id;
-  pop.className = "ctx-popover think-popover";
-  pop.setAttribute("role", "dialog");
-  pop.hidden = true;
-  doc.body.appendChild(pop);
-  let initial = null;
-  let openFor = null;
-  // What the open form was drawn from: the model's or session's summary
-  // and the form's options. A closed popover is empty, so each open draws
-  // a fresh form (an unsent pick is gone).
-  let shown = null;
-  const draw = (now) => render(formTemplate(shown.data, { ...shown.opts, now }), pop);
-
-  function place(anchor) {
-    const width = Math.min(320, win.innerWidth - 32);
-    pop.style.width = `${width}px`;
-    pop.style.maxHeight = "";
-    const at = popoverPlace(anchor.getBoundingClientRect(), { width, height: pop.offsetHeight,
-                                                              innerWidth: win.innerWidth, innerHeight: win.innerHeight });
-    pop.style.left = `${at.left}px`;
-    pop.style.top = at.top === undefined ? "" : `${at.top}px`;
-    pop.style.bottom = at.bottom === undefined ? "" : `${at.bottom}px`;
-    if (at.maxHeight !== undefined) pop.style.maxHeight = `${at.maxHeight}px`;
-  }
-
-  function open(anchor) {
-    const data = summary();
-    if (!data) return;
-    initial = (fresh ? choice() : data.own) || DEFAULT;
-    openFor = session();
-    shown = { data, opts: { running: running(), kind, choice: choice() } };
-    draw(data);
-    pop.hidden = false;
-    place(anchor);
-  }
-
-  function close() {
-    pop.hidden = true;
-    initial = null;
-    openFor = null;
-    shown = null;
-    render(nothing, pop);
-  }
-
-  function isOpen() { return !pop.hidden; }
-
-  // A new summary: an open form keeps the user's pick; only "Now:" follows
-  // (the same template again: lit writes that line alone).
-  function refresh() {
-    if (!isOpen()) return;
-    const data = summary();
-    if (!data || session() !== openFor) return close();
-    draw(data);
-  }
-
-  el.addEventListener("click", (e) => {
-    const anchor = e.target.closest(anchorSel);
-    if (!anchor) return;
-    e.stopPropagation();
-    if (isOpen()) close();
-    else open(anchor);
-  });
-  pop.addEventListener("submit", (e) => {
-    e.preventDefault();
-    const level = e.target.elements.level.value;
-    const was = initial;
-    close();
-    if (fresh) return choose(level === DEFAULT ? null : level);
-    const line = commandLine(level, was);
-    if (line) run(line);
-  });
-  pop.addEventListener("click", (e) => {
-    if (e.target.closest("[data-act]")?.dataset.act === "close") close();
-  });
-  doc.addEventListener("click", (e) => {
-    if (isOpen() && !pop.contains(e.target) && !e.target.closest?.(anchorSel)) close();
-  });
-  doc.addEventListener("keydown", (e) => {
-    if (e.key === "Escape" && isOpen()) close();
-  });
-
-  return { close, refresh, get open() { return isOpen(); } };
+// The chip's popover (level_chip.js createLevelControl); the start page's
+// passes kind NEW_CHAT, choice and choose.
+export function createThinkingControl({ id = "thinkingPopover", ...opts }) {
+  return level.createLevelControl({ cfg: CONFIG, id, ...opts });
 }

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

@@ -8,6 +8,7 @@ import { copySourceAttr } from "./copy.js";
 import { activityDiffHtml } from "./diff_view.js";
 import { escapeHtml, userBodyHtml } from "./format.js";
 import { refAttrs } from "./refs.js";
+import { readLinesHtml } from "./read_view.js";
 import { formatDuration } from "./timing.js";
 import { emptyAnswerLine } from "./turn_events.js";
 
@@ -72,7 +73,8 @@ function llmEditHtml(row) {
 // else the full params line, on hover), the word an exception shows, the
 // call's duration, the full command (an execute/task_create's view, also
 // while it runs), the output once done (its "[tool]" tag dropped, 300 chars,
-// the rest on hover), its images (+thumbs+(images) draws them) and an
+// the rest on hover; a read of the file as-is also its numbered lines,
+// closed: read_view.js), its images (+thumbs+(images) draws them) and an
 // edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
 // part with nothing to say is left out.
 export function toolRowHtml(row, { thumbs = () => "" } = {}) {
@@ -96,7 +98,7 @@ export function toolRowInnerHtml(row, { thumbs = () => "" } = {}) {
   const status = statusParts(row.status, { noMatch: !!row.no_match });
   return `${statusMarkHtml(status)}<span class="activity-tool">${escapeHtml(toolName(row))}</span>${params}${alias}${statusWordHtml(status)}` +
     `${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
-    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}` +
+    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}${output ? readLinesHtml(row) : ""}` +
     `${row.images?.length ? thumbs(row.images) : ""}${row.diff ? activityDiffHtml(row.diff) : ""}`;
 }
 

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

@@ -63,13 +63,15 @@ export function thinkingTemplate({ body, wrapped = true, line = null, cls = "thi
 
 // A step's narration: the live box of complete sentences (one per line,
 // the newest last), the live "…" until the first one, or a closed step's
-// full text. None when there is nothing to say.
+// full text. None when there is nothing to say. A closed step's text is
+// set whole (.textContent): its refs (ref_scan.js) split it into spans
+// that a text part's update would leave behind.
 function textTemplate(text, { live, sentences, placeholder }) {
   if (live && sentences?.length) {
     return html`<div class="gen-text streaming"><div class="narration">${sentences.map((s) => html`<div class="sentence">${s}</div>`)}</div></div>`;
   }
   if (live) return placeholder ? html`<div class="gen-text streaming">…</div>` : nothing;
-  return text ? html`<div class="gen-text">${text}</div>` : nothing;
+  return text ? html`<div class="gen-text" .textContent=${text}></div>` : nothing;
 }
 
 // One step, live or reloaded. +gen+: { text, thinking, tools, answer } (a
@@ -118,7 +120,7 @@ function rawNodes(markup) {
 // The parts of a drawn tool row a user may have changed (the command's
 // raw toggle, an opened diff) or that never change once there (the
 // thumbs): a redraw keeps them as they are.
-const KEPT_PARTS = ["activity-command", "activity-diff", "thumbs"];
+const KEPT_PARTS = ["activity-command", "activity-diff", "activity-read", "thumbs"];
 
 const childWith = (el, cls) => [...el.children].find((c) => c.classList.contains(cls));
 

data/lib/samagotchi/web/token.rb

@@ -5,6 +5,7 @@ require "securerandom"
 require_relative "../atomic_file"
 
 require_relative "../session"
+require_relative "../redacted_inspect"
 
 module Samagotchi
   module Web
@@ -62,6 +63,8 @@ module Samagotchi
       # its mtime changes (one stat per check), so `chi web --new-token`
       # takes effect at once, without a restart.
       class Source
+        include RedactedInspect
+
         attr_reader :path
 
         def initialize(path = Token.path)

data/lib/samagotchi/worker.rb

@@ -693,7 +693,8 @@ module Samagotchi
       resolved = @continue_offer.resolved?(awaiting, result)
       @engine.synchronize_events do
         @continue_offer.announce_resolved(result, command) if resolved
-        announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed))
+        announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed),
+                                  confirm: result.confirm)
         shown.each { |event| @engine.announce(event) }
       end
       save_or_log(:command) { save_session } unless Array(result.changed).empty?
@@ -706,9 +707,14 @@ module Samagotchi
     #   the cards and notices it showed, held: they follow its command_ran,
     #   as its output
     def run_command_line(command)
-      @engine.holding_announcements { command_result(command) { @commands.run(command.line) } }
+      @engine.holding_announcements { command_result(command) { @commands.run(command.line, confirm: confirm?(command)) } }
     end
 
+    # Whether +command+ asks before a costly /thinking or /reasoning-history
+    # change (CacheConfirm): only a person at a web tab or a TUI sees the
+    # question; chi send, a delegate, a plugin and a card's action apply it.
+    def confirm?(command) = ClientId.interactive?(command.client_id) && !command.card
+
     # The block's Result for +command+; one that raised, or found no
     # command for the line, is an error Result saying so.
     # @return [SessionCommands::Result]
@@ -767,9 +773,9 @@ module Samagotchi
     # saved.
     def start_anytime_command(command)
       @engine.spawn_anytime do
-        result = command_result(command) { @engine.running_anytime { @commands.run(command.line) } }
+        result = command_result(command) { @engine.running_anytime { @commands.run(command.line, confirm: confirm?(command)) } }
         announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed),
-                                  anytime: true)
+                                  anytime: true, confirm: result.confirm)
       rescue StandardError => e
         Log.warn(:worker, "anytime_command_failed", line: command.line, error: e.class.name, msg: e.message)
       end
@@ -777,7 +783,9 @@ module Samagotchi
 
     # @param anytime [Boolean] an anytime command's: its line was shown at
     #   its command_queued already
-    def announce_command(command, status:, output:, changed:, anytime: false)
+    # @param confirm [CacheConfirm::Confirm, nil] the change asks first: the
+    #   line that applies it (the TUI's prefill, the web's Apply button)
+    def announce_command(command, status:, output:, changed:, anytime: false, confirm: nil)
       text = output.to_s
       event = { type: :command_ran, **command.event_fields, status: status, output: text[0, COMMAND_OUTPUT_LIMIT],
                 changed: changed.map(&:to_s), model_name: @engine.effective_model_name }
@@ -788,6 +796,10 @@ module Samagotchi
       event[:llm_context] = @engine.llm_context_summary if changed.intersect?(%i[llm_context model])
       # /thinking or /model: the level the next turn runs at (the web's chip).
       event[:thinking] = @engine.thinking_explained&.summary if changed.intersect?(%i[thinking model])
+      # /reasoning-history or /model: the level the next turn runs under
+      # (the web's chip); nil on a native host, which ignores it.
+      event[:reasoning_history] = @engine.reasoning_history_explained&.summary if changed.intersect?(%i[reasoning_history model])
+      event[:confirm] = confirm.to_h if confirm
       event[:output_truncated] = true if text.length > COMMAND_OUTPUT_LIMIT
       @engine.announce(event)
     end