samagotchi 0.135.0 → 0.136.1

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

@@ -1,28 +1,18 @@
-// The session bar's LLM context chip: the strategy the next turn runs under
-// ("llm ctx stale,forget"; "· session" when the session set its own), and a
-// popover that sets the session's own strategy, apply rule and budget by
-// running /llm-context in its worker (the command's reply shows in the
-// conversation, like a typed one). The values and where each came from are
-// the session's llm_context (LLMContextStrategy::Explained#summary: the
+// The session's LLM context (LLMContextStrategy::Explained#summary: the
 // worker's snapshot, a command_ran, or the server's own reading of the
-// session file).
+// session file) as the settings panels read and change it: the session's own
+// values (ownValues), the /llm-context line a session bar's pick runs in its
+// worker (commandLine; settings_chip.js), a typed budget (parseBudget).
 //
-// The start page's new session sets its strategy in the ⚙ panel instead
+// The start page's new session sets its strategy in the ⚙ panel
 // (start_settings.js): mergeChoice and choiceWords are its, a choice in the
 // session file's shape sent as POST /api/sessions' llm_context words.
 
-import { createChipPopover } from "./chip_popover.js";
-import { html, nothing, render } from "./vendor/lit-html.js";
-
-const STRATEGIES = [
-  { value: "none", label: "none" },
-  { value: "stale", label: "stale" },
-  { value: "stale,forget", label: "stale + forget (experimental)" },
-];
 export const APPLIES = ["payoff", "next_request", "turn_end"];
-export const SESSION = "session";
 
 const DEFAULT = "default";
+// What a budget parseBudget refuses gets, under the fields.
+export const BUDGET_ERROR = "A budget is a number of tokens from 4000 (4k) to 10000000, or off.";
 const LAYER_ORDER = ["stale", "forget"];
 
 // Layers as one value, in chi's order (stale before forget); unknown ones after.
@@ -41,31 +31,12 @@ export function ownValues(summary) {
   return { strategy, apply: own.apply || DEFAULT, budget };
 }
 
-// The chip: its text, tooltip and whether the session set its own; null
-// without a summary (an older worker).
-export function chipModel(summary) {
-  if (!summary || !summary.strategy) return null;
-  const own = summary.strategy_source === "session" || !!summary.own;
-  const budget = summary.budget_tokens ? `${summary.budget_tokens} tokens` : "off";
-  const title = `LLM context strategy: ${summary.strategy} (${summary.strategy_where}); apply ${summary.apply} ` +
-    `(${summary.apply_where}); budget ${budget} (${summary.budget_where}). Click to change it for this session.`;
-  return { text: `llm ctx ${summary.strategy}${own ? ` · ${SESSION}` : ""}`, title, own };
-}
-
-// 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 llmctx-chip${chip.own ? " own" : ""}`} title=${chip.title} aria-haspopup="dialog">${chip.text}</button>`;
-}
-
-// The /llm-context line for the form's values. With +initial+ (the values
-// the form opened with) only the fields the user changed go, so a value the
-// form can't show is never unset by a Set; null when nothing changed.
+// The /llm-context line for the panel's values. With +initial+ (the
+// session's own values, ownValues) only the fields that differ go, so a
+// value the tap didn't touch is never unset; null when nothing changed.
 // Without it every field goes, "default" for one left to the model, and all
-// of them default is a reset. With --yes: the form states what a change
-// costs, so a Set is the choice (no confirm step), as level_chip.js's.
+// of them default is a reset. With --yes: the panel states what a change
+// costs, so a pick is the choice (no confirm step), as level_chip.js's.
 export function commandLine({ strategy = DEFAULT, apply = DEFAULT, budget = "" } = {}, initial = null) {
   const words = { strategy, apply, budget: String(budget).trim() || DEFAULT };
   const was = initial && { strategy: initial.strategy, apply: initial.apply, budget: String(initial.budget).trim() || DEFAULT };
@@ -104,7 +75,7 @@ export function mergeChoice(choice, { strategy = DEFAULT, apply = DEFAULT, budge
     else if (field === "apply") next.apply = word;
     else {
       const tokens = parseBudget(word);
-      if (tokens === null) throw new Error("A budget is a number of tokens from 4000 (4k) to 10000000, or off.");
+      if (tokens === null) throw new Error(BUDGET_ERROR);
       next.budget_tokens = tokens;
     }
   }
@@ -122,105 +93,3 @@ export function choiceWords(choice) {
   if (typeof choice.budget_tokens === "number") words.budget = choice.budget_tokens > 0 ? String(choice.budget_tokens) : "off";
   return Object.keys(words).length ? words : undefined;
 }
-
-// The strategy list, with the session's own value when it isn't one of them
-// (forget alone, a newer chi's layer).
-function strategyOptions(chosen) {
-  if (chosen === DEFAULT || STRATEGIES.some((s) => s.value === chosen)) return STRATEGIES;
-  return [...STRATEGIES, { value: chosen, label: chosen }];
-}
-
-const option = (value, label) => html`<option value=${value}>${label}</option>`;
-
-// The popover's form: the values now (each with its source), and the
-// session's own to change.
-export function nowText(summary) {
-  const budget = summary.budget_tokens ? `${summary.budget_tokens} tokens` : "off";
-  return `Now: ${summary.strategy} (${summary.strategy_where}) · apply ${summary.apply} (${summary.apply_where}) · ` +
-    `budget ${budget} (${summary.budget_where})`;
-}
-
-// The popover's form (a lit-html template). +now+ is the summary its "Now:"
-// line reads (refresh passes a newer one, the rest stays as the form opened,
-// so lit leaves what the user typed alone). The selects take their value as a property (.value), set after their
-// options: +unset+ draws the options alone, the first pass renderForm makes.
-export function formTemplate(summary, { running = false, now = summary, unset = false } = {}) {
-  const own = ownValues(summary);
-  const follow = (field) => (summary[`${field}_source`] === "session" ? "follow the model" : `follow the model (${summary[field]})`);
-  const when = "From the next turn's start. Turning forget on or off re-reads the whole prompt once.";
-  const chosen = (value) => (unset ? nothing : value);
-  return html`<form class="llmctx-form"><div class="ctx-pop-head"><strong>LLM context</strong
-    ><span class="ctx-pop-kind">this session</span
-    ><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div
-    ><div class="ctx-pop-meta llmctx-now">${nowText(now)}</div
-    ><label class="llmctx-field"><span>Strategy</span><span class="select-wrap"><select name="strategy" .value=${chosen(own.strategy)}>${
-      option(DEFAULT, follow("strategy"))}${strategyOptions(own.strategy).map((s) => option(s.value, s.label))}</select></span></label
-    ><label class="llmctx-field"><span>Apply</span><span class="select-wrap"><select name="apply" .value=${chosen(own.apply)}>${
-      option(DEFAULT, follow("apply"))}${APPLIES.map((a) => option(a, a))}</select></span></label
-    ><label class="llmctx-field"><span>Budget</span><input name="budget" type="text" inputmode="numeric" autocomplete="off"
-      placeholder="follow the model (64000, 64k or off)" .value=${own.budget}></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="button" class="ctx-pop-detach" data-act="reset">follow the model</button
-    ><button type="submit" class="llmctx-set">Set</button></div></form>`;
-}
-
-// Draws the form into +target+ (formTemplate's options). A first draw (no
-// form there yet) makes two passes, the options and then the selects'
-// values: lit sets an element's own bindings before its children, so a
-// select's .value would land before its options exist. A later draw is
-// one pass, and lit writes only what changed since the last (the "Now:"
-// line), never a value the user changed.
-export function renderForm(target, summary, opts = {}) {
-  if (!target.firstElementChild) render(formTemplate(summary, { ...opts, unset: true }), target);
-  render(formTemplate(summary, opts), target);
-}
-
-// The chip's popover (chip_popover.js' shell). el: where the chip is drawn
-// (#infoText, info_bar.js: clicks are delegated); summary(): the open
-// session's llm_context; session(): the open session's id; running(): a
-// turn runs; run(line): sends the command. id and anchor: the popover's id
-// and the chip's selector.
-export function createLlmContextControl({ el, summary, session = () => null, running = () => false, run,
-                                          id = "llmContextPopover", anchor = ".llmctx-chip",
-                                          doc = document, win = window }) {
-  // The values the form opened with.
-  let initial = null;
-  // What the open form was drawn from: the summary, the form's options and
-  // the summary its "Now:" line reads.
-  let shown = null;
-  const draw = (changes = {}) => {
-    shown = { ...shown, ...changes };
-    renderForm(shell.pop, shown.data, { ...shown.opts, now: shown.now });
-  };
-
-  // A refresh (a newer summary): an open form keeps what the user typed;
-  // only its "Now:" line follows (the same template again: lit writes that
-  // line alone).
-  function show(data, opening) {
-    if (!opening) return draw({ now: data });
-    initial = ownValues(data);
-    shown = { data, opts: { running: running() } };
-    draw({ now: data });
-  }
-
-  function submit(form) {
-    const values = { strategy: form.elements.strategy.value, apply: form.elements.apply.value,
-                     budget: form.elements.budget.value };
-    const line = commandLine(values, initial);
-    shell.close();
-    if (line) run(line);
-  }
-
-  function act(name) {
-    if (name !== "reset") return;
-    shell.close();
-    run(commandLine());
-  }
-
-  const shell = createChipPopover({
-    id, className: "ctx-popover llmctx-popover", width: 360, el, anchor, summary, session, show,
-    onClose: () => { initial = null; shown = null; }, onSubmit: submit, onAct: act, doc, win,
-  });
-
-  return { close: shell.close, refresh: shell.refresh, get open() { return shell.isOpen(); } };
-}

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

@@ -1,13 +1,10 @@
-// The session bar's reasoning history chip: which of its own reasoning the
-// session's model gets back from the next turn on ("reasoning all";
-// "· session" when the session set its own), and a popover with a level
-// select that runs /reasoning-history in the session's worker. The summary
-// is the session's reasoning_history (SettingExplained#summary; null on a
-// native host, which ignores it, or from an older worker: no chip then).
-// A config on level_chip.js.
+// Reasoning history as a level setting (level_chip.js): which of its own
+// reasoning the session's model gets back from the next turn on. The session
+// bar's ⚙ panel draws its row on a chat host (settings_chip.js; the summary
+// is null on a native host, which ignores it, or from an older worker: no
+// row then) and runs /reasoning-history in the session's worker.
 
 import * as level from "./level_chip.js";
-import { html, nothing } from "./vendor/lit-html.js";
 
 export const LEVELS = ["drop", "turn", "all"];
 
@@ -16,34 +13,11 @@ export const CONFIG = Object.freeze({
   prefix: "reasoning",
   command: "/reasoning-history",
   levels: LEVELS,
-  anchor: "[data-rh-chip]",
-  formClass: "rh-form",
-  popoverClass: "rh-popover",
-  nowClass: "rh-now",
-  when: () => "From the next turn's start. A change to or from all makes the server read the conversation again.",
+  cost: "A reasoning history change to or from all makes the server read the conversation again.",
 });
 
-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 rh-chip${chip.own ? " own" : ""}`} title=${chip.title} data-rh-chip aria-haspopup="dialog">${chip.text}</button>`;
-}
-
+// The /reasoning-history line for a level, with --yes; null when it is the
+// session's (+initial+).
 export function commandLine(choice, initial = null) {
   return level.commandLine(CONFIG, choice, initial);
 }
-
-export function formTemplate(summary, opts) {
-  return level.formTemplate(CONFIG, summary, opts);
-}
-
-// The chip's popover in the session bar (level_chip.js createLevelControl).
-export function createReasoningHistoryControl({ id = "reasoningHistoryPopover", ...opts }) {
-  return level.createLevelControl({ cfg: CONFIG, id, ...opts });
-}

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

@@ -41,6 +41,10 @@ export const KEPT = ".plugin-card.warn, .verify-verdict, .bubble.recap";
 const ANSWERS = ".bubble.output:not(.report-reply)";
 const UNFINISHED = ".streaming";
 const OPENING = "[data-turn-id]";
+// A fold row (answer_fold.js) just before an opening: a delegate report's
+// that opens its turn, the opening's header (in its range, the stub above it).
+const FOLD_ROW = "answer-fold";
+const headOf = (opening) => (opening.previousElementSibling?.classList.contains(FOLD_ROW) ? opening.previousElementSibling : null);
 const STOPPED = ".bubble.cancel";
 const LABEL_CHARS = 120;
 // The stored key of a stub unfolded by hand (answer_fold.js's list).
@@ -143,10 +147,11 @@ export function historyTurns(historyEl) {
   };
   for (const el of historyEl.children) {
     if (el.classList.contains(STUB_CLASS) || el.classList.contains(ROW_CLASS)) continue;
+    if (el.classList.contains(FOLD_ROW) && el.nextElementSibling?.matches(OPENING)) continue;
     const opening = el.matches(OPENING) ? el : el.querySelector(OPENING);
     if (opening || el.matches(NOTE_BOUNDARY)) {
       close();
-      turn = { id: opening?.dataset.turnId || null, opening: el, prompt: opening || null, els: [], answer: null, wake: !opening };
+      turn = { id: opening?.dataset.turnId || null, opening: el, head: headOf(el), prompt: opening || null, els: [], answer: null, wake: !opening };
       turns.push(turn);
       continue;
     }
@@ -196,7 +201,8 @@ export function installReviseStacks({
       if (stored().includes(stubKey(id))) stub.classList.add("open");
       stubs.set(id, stub);
     }
-    if (stub.parentElement !== historyEl || stub.nextElementSibling !== opening) historyEl.insertBefore(stub, opening);
+    const top = headOf(opening) || opening;
+    if (stub.parentElement !== historyEl || stub.nextElementSibling !== top) historyEl.insertBefore(stub, top);
     return stub;
   }
 
@@ -252,7 +258,7 @@ export function installReviseStacks({
     const keepStubs = new Set();
     const keepRows = new Set();
     for (const turn of turns) {
-      const range = [turn.opening, ...turn.els];
+      const range = [turn.head, turn.opening, ...turn.els].filter(Boolean);
       const place = turn.id && superseded.get(turn.id);
       if (place) {
         const stub = stubFor(turn.id, turn.opening, stored);

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

@@ -64,7 +64,7 @@ export const FIELDS = {
     redraws: ["infoBar"],
     writers: "store.setStatus only (statusWrite below): the hub, the stream, a turn end's re-read, Stop, the payload",
   },
-  thinking: { redraws: ["thinkingChip", "infoBar"], writers: "stream_handlers.js command_ran" },
+  thinking: { redraws: ["settingsPanel", "infoBar"], writers: "stream_handlers.js command_ran" },
   model: {
     source: (d) => d.session?.model_name,
     redraws: ["infoBar"],
@@ -94,11 +94,12 @@ export const FIELDS = {
     writers: "followSelectedSession, workerGone",
   },
   llmContext: {
-    redraws: ["llmContextChip", "workingSetStrategy", "infoBar"],
+    redraws: ["settingsPanel", "workingSetStrategy", "infoBar"],
     writers: "stream_handlers.js command_ran",
   },
-  reasoningHistory: { redraws: ["reasoningChip", "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"],
@@ -108,7 +109,6 @@ export const FIELDS = {
   turnStarted: { redraws: ["composer", "infoBar"], writers: "setTurnRunning" },
   streamSeq: { redraws: [], writers: "resync" },
   streamFromGuess: { redraws: [], writers: "followWokenWorker, startStream, the stream's takeGuess" },
-  attachCopiedAt: { redraws: ["infoBar"], writers: "the info bar's copy button" },
 };
 
 // The fields a hub card brings for the open session (followSelectedSession):

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

@@ -57,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
@@ -76,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,
   };
 }
 
@@ -118,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

@@ -17,7 +17,7 @@ import { FIELDS, statusWrite } from "./session_fields.js";
 export const ORDER = [
   "lists",
   "paintActive",
-  "llmContextChip", "thinkingChip", "reasoningChip", "workingSetStrategy",
+  "settingsPanel", "workingSetStrategy",
   "featureGates",
   "composer",
   "infoBar",

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

@@ -0,0 +1,212 @@
+// The session bar's ⚙ chip and its panel: the open session's thinking,
+// reasoning history and LLM context in one place, as the start page's ⚙
+// panel has them for a new session (settings_panel.js draws both). The chip
+// reads "⚙" alone while the session follows the model for all three, else
+// "⚙" and the session's own in the start page's words ("⚙ think low · ctx
+// stale"; class own, the accent). A pick in the panel runs that row's
+// command with --yes in the session's worker at once (one reply line in the
+// conversation, like a typed /thinking low) and the panel stays open; the
+// pressed segment follows the session's summary when the reply's command_ran
+// lands, never the tap. The summaries are the session's thinking,
+// reasoning_history and llm_context (SettingExplained#summary,
+// LLMContextStrategy::Explained#summary: the worker's snapshot, a
+// command_ran, or the server's own reading of the session file).
+//
+// 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 { createChipPopover, SHEET_TALL } from "./chip_popover.js";
+import { DEFAULT, commandLine as levelLine, segments } from "./level_chip.js";
+import { BUDGET_ERROR, commandLine as contextLine, ownValues, parseBudget } from "./llm_context_chip.js";
+import { CONFIG as REASONING } from "./reasoning_history_chip.js";
+import { contextSegments, contextWords, settingsPanelTemplate } from "./settings_panel.js";
+import { CONFIG as THINKING } from "./thinking_chip.js";
+import { html, nothing, render } from "./vendor/lit-html.js";
+
+export const PANEL_LABEL = "Session settings";
+export const NOTE = "From the next turn's start.";
+export const RUNNING_NOTE = "A turn is running: it applies after this turn.";
+const CONTEXT_COST = "Turning forget on or off re-reads the whole prompt once.";
+
+// A level's own value ("low"), null when it follows the model.
+const levelOwn = (summary) => summary?.own || null;
+
+// The context's own values in a few words ("stale · budget 64000"), null
+// when the session has none.
+const contextOwn = (summary) => (summary?.own ? contextWords(summary.own) : null);
+
+function levelTitle(cfg, summary) {
+  return `${cfg.name}: ${summary.level} (${summary.own ? "this session" : summary.source || "the model's own"})`;
+}
+
+function contextTitle(summary) {
+  const budget = summary.budget_tokens ? `${summary.budget_tokens} tokens` : "off";
+  return `LLM context: ${summary.strategy} (${summary.strategy_where}); apply ${summary.apply} (${summary.apply_where}); ` +
+    `budget ${budget} (${summary.budget_where})`;
+}
+
+// The chip for +summaries+ ({thinking, reasoningHistory, llmContext}, each
+// a summary or null): {text (the own values past ⚙, "" for none), own,
+// title (each value and where it comes from), label (the accessible name:
+// the panel and what is set, settingsLabel's shape)}; null without any
+// summary (an older worker: no chip).
+export function chipModel({ thinking = null, reasoningHistory = null, llmContext = null } = {}) {
+  const think = thinking?.level ? thinking : null;
+  const rh = reasoningHistory?.level ? reasoningHistory : null;
+  const ctx = llmContext?.strategy ? llmContext : null;
+  if (!think && !rh && !ctx) return null;
+  const set = [
+    levelOwn(think) && `${THINKING.prefix} ${levelOwn(think)}`,
+    levelOwn(rh) && `${REASONING.prefix} ${levelOwn(rh)}`,
+    contextOwn(ctx) && `ctx ${contextOwn(ctx)}`,
+  ].filter(Boolean);
+  const lines = [think && levelTitle(THINKING, think), rh && levelTitle(REASONING, rh), ctx && contextTitle(ctx)].filter(Boolean);
+  return {
+    text: set.join(" · "),
+    own: set.length > 0,
+    title: `${lines.join(". ")}. Click to change them for this session.`,
+    label: set.length ? `${PANEL_LABEL}: ${set.join(", ")}` : PANEL_LABEL,
+  };
+}
+
+// The session bar's chip (a lit-html template; info_bar.js), nothing
+// without a summary. ⚙ is drawn as the start page's settings icon (the
+// glyph stays the text); the own values are a span of their own: a phone
+// shows ⚙ with a dot instead (index.html's CSS).
+export function chipTemplate(summaries) {
+  const chip = summaries && chipModel(summaries);
+  if (!chip) return nothing;
+  return html`<button type="button" class=${`model settings-chip${chip.own ? " own" : ""}`} title=${chip.title}
+    aria-label=${chip.label} aria-haspopup="dialog" data-settings-chip><span class="chip-icon sc-gear" aria-hidden="true">⚙</span>${
+    chip.text ? html`<span class="sc-own"> ${chip.text}</span>` : nothing}</button>`;
+}
+
+// The panel's note: when a change applies (after the running turn, while
+// one runs) and what each drawn row's change costs.
+export function noteText({ thinking, reasoningHistory, llmContext, running = false }) {
+  return [NOTE, running ? RUNNING_NOTE : null, thinking ? THINKING.cost : null, reasoningHistory ? REASONING.cost : null,
+          llmContext ? CONTEXT_COST : null].filter(Boolean).join(" ");
+}
+
+// The panel (settings_panel.js settingsPanelTemplate) over the session's
+// summaries: the Thinking row, the Reasoning history row (a chat host's
+// only), the Context row with its Apply and budget disclosure; each row's
+// pressed segment the session's own. +more+: the disclosure open; +error+:
+// its Set's.
+export function panelTemplate({ thinking = null, reasoningHistory = null, llmContext = null, running = false,
+                                more = false, error = null }) {
+  const think = segments(THINKING, thinking, levelOwn(thinking));
+  const rh = segments(REASONING, reasoningHistory, levelOwn(reasoningHistory));
+  const ctx = contextSegments(llmContext, llmContext?.own || null);
+  return settingsPanelTemplate({
+    heading: PANEL_LABEL,
+    kind: "this session",
+    rows: [
+      think ? { name: "think", label: THINKING.name, segments: think, act: "think" } : null,
+      // "Reasoning", the chip's word: "Reasoning history" wraps in the label's column.
+      rh ? { name: "rh", label: "Reasoning", segments: rh, act: "reasoning" } : null,
+      ctx ? { name: "ctx", label: "Context", segments: ctx, act: "ctx",
+              more: { open: more, summary: llmContext, choice: llmContext.own || null, error } } : null,
+    ],
+    note: noteText({ thinking: think, reasoningHistory: rh, llmContext: ctx, running }),
+  });
+}
+
+// What a pick (+act+, a segment's data-act: "think:low", "reasoning:all",
+// "ctx:stale", "ctx:default") runs for +summaries+: the line, or null (the
+// segment pressed already). One field alone (D2): a strategy tap sends the
+// strategy only, the session's own apply and budget stay; the Context
+// row's default is the reset (strategy, apply and budget follow the model
+// again), only when the session has any of its own.
+export function actLine(act, { thinking = null, reasoningHistory = null, llmContext = null } = {}) {
+  const [what, value] = act.split(/:(.*)/s);
+  if (what === "think") return levelLine(THINKING, value, levelOwn(thinking) || DEFAULT);
+  if (what === "reasoning") return levelLine(REASONING, value, levelOwn(reasoningHistory) || DEFAULT);
+  if (what !== "ctx") return null;
+  if (value === DEFAULT) return llmContext?.own ? contextLine() : null;
+  const initial = ownValues(llmContext);
+  return contextLine({ ...initial, strategy: value }, initial);
+}
+
+// The disclosure's Set: the apply rule and the budget as typed, against the
+// session's own; only the field that changed goes. {line} (null: nothing
+// changed) or {error} (a budget chi wouldn't take).
+export function moreLine({ apply, budget }, llmContext) {
+  const typed = String(budget ?? "").trim();
+  if (typed && parseBudget(typed) === null) return { error: BUDGET_ERROR };
+  const initial = ownValues(llmContext);
+  return { line: contextLine({ ...initial, apply, budget: typed }, initial) };
+}
+
+// The chip's panel on chip_popover.js' shell (a bottom sheet on a phone).
+// el: where the chip is drawn (#infoText, info_bar.js: clicks are
+// delegated); summaries(): the open session's {thinking, reasoningHistory,
+// llmContext} (null: no session); session(): its id; running(): a turn
+// runs; run(line): sends the command.
+// @return {close, refresh, open}
+export function createSettingsControl({ el, summaries, session = () => null, running = () => false, run,
+                                        id = "settingsPopover", anchor = "[data-settings-chip]",
+                                        doc = document, win = window }) {
+  // The summaries the open panel is drawn from (each refresh's newer ones),
+  // the disclosure and its Set's error.
+  let shown = null;
+  let more = false;
+  let error = null;
+
+  function draw() {
+    render(panelTemplate({ ...shown, running: running(), more, error }), shell.pop);
+    shell.replace();
+  }
+
+  function show(data, opening) {
+    shown = data;
+    if (opening) {
+      const own = data.llmContext?.own;
+      more = !!(own?.apply || typeof own?.budget_tokens === "number");
+      error = null;
+    }
+    draw();
+  }
+
+  function act(name) {
+    if (name === "ctx-more") {
+      more = !more;
+      return draw();
+    }
+    const line = actLine(name, shown);
+    if (line) run(line);
+  }
+
+  function submit(form) {
+    if (!form.classList.contains("sset-ctx-form")) return;
+    const result = moreLine({ apply: form.elements.apply.value, budget: form.elements.budget.value }, shown.llmContext);
+    error = result.error || null;
+    draw();
+    if (result.line) run(result.line);
+  }
+
+  // Focus inside on open (the popover sits at the end of <body>): the
+  // pressed segment of the first row.
+  function focusInside() {
+    shell.pop.querySelector(".sset-seg [aria-pressed=true]")?.focus();
+  }
+
+  const present = () => {
+    const data = summaries();
+    return data && chipModel(data) ? data : null;
+  };
+  const shell = createChipPopover({
+    id, className: "ctx-popover start-settings session-settings", width: 440, el, anchor, summary: present, session,
+    show, sheet: true, sheetShare: SHEET_TALL, modal: true, label: PANEL_LABEL, onOpen: focusInside,
+    onClose: () => { shown = null; error = null; }, onSubmit: submit, onAct: act, doc, win,
+  });
+  // An edit makes the disclosure Set's error stale.
+  shell.pop.addEventListener("input", (e) => {
+    if (error && e.target.closest(".sset-ctx-form")) {
+      error = null;
+      draw();
+    }
+  });
+
+  return { close: shell.close, refresh: shell.refresh, get open() { return shell.isOpen(); } };
+}