samagotchi 0.43.0 → 0.45.0

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

@@ -30,10 +30,12 @@ export function moveSelection(index, count, delta) {
 }
 
 // One row's parts: the name, its description, and a note (the bundle it
-// comes from; "mid-turn too" for an anytime one), "" when there is none.
+// comes from; "mid-turn too" for an anytime one, "show: mid-turn too" for
+// one whose show form is), "" when there is none.
 export function commandRow(command) {
   const notes = [];
   if (command.source && command.source !== "core") notes.push(command.source);
   if (command.anytime) notes.push("mid-turn too");
+  else if (command.mid_turn === "depends") notes.push("show: mid-turn too");
   return { name: command.name, description: command.description || "", note: notes.join(" · ") };
 }

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

@@ -2,11 +2,24 @@
 // the kernel resolved for this generation (:generation_started carries it as
 // context_window_tokens); llama.cpp's stream payloads report token counts
 // but no n_ctx, so without it only a precomputed pct or an n_ctx works.
+// `budgetTokens` is the session's LLM context budget (llm_context's
+// budget_tokens): a percentage this file computes counts against it when it
+// is smaller than the window, as the kernel's :context_status does
+// (ContextStatus#counted_against), so the meter reads the same from either.
 
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
 
+// What a fill counts against: the window, or the budget when one is set
+// and smaller; null without a window.
+export function countedTokens(windowTokens, budgetTokens = null) {
+  const window = num(windowTokens);
+  if (!window || window <= 0) return null;
+  const budget = num(budgetTokens);
+  return budget && budget > 0 ? Math.min(budget, window) : window;
+}
+
 // Tokens in context after this chunk: prompt + generated so far.
 function usedTokens(p) {
   if (!p || typeof p !== "object") return null;
@@ -18,30 +31,35 @@ function usedTokens(p) {
   return (prompt ?? 0) + (completion ?? 0);
 }
 
-export function extractCtxPct(data, windowTokens = null) {
+export function extractCtxPct(data, windowTokens = null, budgetTokens = null) {
   if (!data || typeof data !== "object") return null;
   if (num(data.ctx_pct) !== null) return data.ctx_pct;
   if (num(data.est_pct) !== null) return data.est_pct;
   if (num(data.ctxPct) !== null) return data.ctxPct;
   // The kernel's :context_status event: { usage: { estimated_pct, ... }, bucket }.
   if (num(data.usage?.estimated_pct) !== null) return data.usage.estimated_pct;
-  if (data.context_window_tokens && data.total_tokens) return (data.total_tokens / data.context_window_tokens) * 100;
+  if (data.context_window_tokens && data.total_tokens) {
+    const against = countedTokens(data.context_window_tokens, budgetTokens);
+    if (against) return (data.total_tokens / against) * 100;
+  }
   const p = data.payload || data;
   if (num(p.ctx_pct) !== null) return p.ctx_pct;
-  const window = num(p.n_ctx) || num(windowTokens);
+  const against = countedTokens(num(p.n_ctx) || num(windowTokens), budgetTokens);
   const used = usedTokens(p);
-  if (!window || window <= 0 || used === null) return null;
-  return (used / window) * 100;
+  if (!against || used === null) return null;
+  return (used / against) * 100;
 }
 
 // The saved context (the session's timing.context: used_tokens after the
 // last counted turn, the window now): the meter's value on load, before a
-// turn streams. null when either count is missing.
-export function savedCtxPct(context) {
+// turn streams, counted against +budgetTokens+ (the session's llm_context
+// budget_tokens) when it is smaller, as live. null when either count is
+// missing.
+export function savedCtxPct(context, budgetTokens = null) {
   const used = num(context?.used_tokens);
-  const window = num(context?.window_tokens);
-  if (used === null || !window || window <= 0) return null;
-  return (used / window) * 100;
+  const against = countedTokens(context?.window_tokens, budgetTokens);
+  if (used === null || !against) return null;
+  return (used / against) * 100;
 }
 
 // A session card's quiet ctx: "12%", or "" when the list row has none.
@@ -99,18 +117,27 @@ export function ctxBarText(pct, windowSource = null) {
   return `ctx ${windowSource === "default" ? "~" : ""}${Math.round(pct)}%`;
 }
 
-// The ctx tooltip's window line ({tokens:, source:, pct:} the session's
-// window, where it came from and the meter's value): "context: ~41.0k of
-// 128.0k tokens (server)", as /stats names the source; "" without a window.
+// The ctx tooltip's window line ({tokens:, source:, pct:, budget:} the
+// session's window, where it came from, the meter's value and the LLM
+// context budget): "context: ~41.0k of 128.0k tokens (server)", as /stats
+// names the source; under a budget smaller than the window the meter's
+// percentage is of the budget: "context: ~41.0k of the 64.0k budget,
+// 128.0k window (server)"; "" without a window.
 export function ctxWindowText(window) {
   const tokens = num(window?.tokens);
   if (!tokens || tokens <= 0) return "";
+  const against = countedTokens(tokens, window.budget);
   const pct = num(window.pct);
-  const used = pct === null ? "" : `~${countK((pct / 100) * tokens)} of `;
   const source = window.source === "default"
     ? "chi's default, a guess: set window_tokens for this model"
     : window.source;
-  return `context: ${used}${countK(tokens)} tokens${source ? ` (${source})` : ""}`;
+  const sourceText = source ? ` (${source})` : "";
+  if (against < tokens) {
+    const used = pct === null ? "" : `~${countK((pct / 100) * against)} of `;
+    return `context: ${used}the ${countK(against)} budget, ${countK(tokens)} window${sourceText}`;
+  }
+  const used = pct === null ? "" : `~${countK((pct / 100) * tokens)} of `;
+  return `context: ${used}${countK(tokens)} tokens${sourceText}`;
 }
 
 // The ctx tooltip (info bar and card): +title+, then the session's tokens

data/lib/samagotchi/web/public/index.html

@@ -172,6 +172,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .activity-output{flex:1 1 100%;min-width:0}
 /* An edit/write's change: a closed "diff +3 −1" under the output, lined up with it. */
 .activity-diff{flex:1 1 100%;min-width:0;margin:2px 0 2px var(--row-gutter)}
+/* A reloaded row's ✂ mark (an LLM context edit on its output), one line above the output. */
+.activity-edit{flex:1 1 100%;min-width:0;margin:2px 0 0 var(--row-gutter);font-size:12px;color:var(--text-3);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;cursor:help}
 .activity-diff>summary{cursor:pointer;font-size:12px;color:var(--text-muted);width:max-content;font-variant-numeric:tabular-nums}
 .activity-diff>summary:hover{color:var(--text-2)}
 .activity-diff[open]>summary{margin-bottom:4px}
@@ -212,6 +214,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
   .activity-params{flex:1 1 0}
   .activity-output{margin-left:0}
   .activity-diff{margin-left:0}
+  .activity-edit{margin-left:0}
   .activity-row>.activity-command{margin-left:0}
 }
 .bubble.thinking{border-left:3px solid var(--think);background:color-mix(in srgb,var(--think) 6%,var(--bg-panel));padding:8px 12px}
@@ -299,6 +302,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .note-text{white-space:pre-wrap;max-height:8em;overflow:auto}
 .bubble.command.busy{border-left-color:var(--warn)}
 .bubble.command.failed{border-left-color:var(--danger)}
+.bubble.command.queued{border-left-style:dashed}
+.bubble.command.queued .command-output{color:var(--text-faint)}
 .command-line{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-3)}
 .command-output{margin:6px 0 0;white-space:pre-wrap;font-size:12px;color:var(--text-2)}
 .bubble.continue{border-left:3px solid var(--accent);background:var(--bg-panel);padding:10px 12px}
@@ -374,6 +379,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .gen .hook-notice{font-size:13px;color:var(--text-3);padding:5px 2px 5px 8px;border-top:1px solid var(--border);border-left:2px solid var(--text-faint);white-space:pre-wrap;word-break:break-word}
 .gen .activity-body>.hook-notice:first-child{border-top:none}
 .gen .hook-notice.warn{border-left-color:var(--warn);color:var(--warn-text)}
+.hook-notice.llm-context{border-left-style:dashed;cursor:help}
 /* A plugin's steer (a nudge into the running turn): a row of its step, or a bubble; its text collapsed. */
 .steer-row{font-size:13px;color:var(--text-3);border-left:2px solid var(--accent-border)}
 .steer-row>summary{cursor:pointer;list-style:none;font-style:italic}
@@ -608,7 +614,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .ts-trail-item:is(.error,.blocked){color:var(--danger-text)}
 .ts-trail-item.warn{color:var(--warn-text)}
 .ts-trail-item.stopped{color:var(--warn-text);opacity:.8}
-.ts-trail-item.info,.ts-trail-item.steer{color:var(--accent)}
+.ts-trail-item.info,.ts-trail-item.steer,.ts-trail-item.edit{color:var(--accent)}
 .ts-trail-item.none{font-style:italic}
 /* A card waits: the tool row and trail give it their room. */
 .turn-stage.waiting .ts-now,.turn-stage.waiting .ts-trail{display:none}

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

@@ -179,9 +179,9 @@ export function formHtml(summary, escapeHtml, { running = false, kind = SESSION,
     `<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="${escapeHtml(own.budget)}"></label>` +
     `<div class="ctx-pop-error llmctx-error" hidden></div>` +
-    `<div class="ctx-pop-meta">${when}${running ? " A turn is running: set it when it ends." : ""}</div>` +
+    `<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"${running ? " disabled" : ""}>Set</button></div></form>`;
+    `<button type="submit" class="llmctx-set">Set</button></div></form>`;
 }
 
 const EDGE = 16;
@@ -263,8 +263,6 @@ export function createLlmContextControl({ el, escapeHtml, summary, session = ()
     if (!data || session() !== openFor) return close();
     const now = pop.querySelector(".llmctx-now");
     if (now) now.textContent = nowText(data);
-    const set = pop.querySelector(".llmctx-set");
-    if (set) set.disabled = running();
   }
 
   el.addEventListener("click", (e) => {

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

@@ -198,15 +198,29 @@ export function handOffOrder({ prompt = null, block = null, extras = [], answer
 // history (it is idle-only).
 // What flashes in the trail for a few seconds while the turn runs (the
 // rows themselves go into their step inside the closed cloud): a hook's
-// notice, warn or info, as its row reads, and a plugin's nudge (steer).
-// chi's own asking-again row (a notice with a line and no hook) does not:
-// the status line tells that already. null: nothing flashes.
+// notice, warn or info, as its row reads, the ✂ row of an applied LLM
+// context edit (kind "edit"), a steer-cut row (a message cut in on a
+// thinking-only generation; kind "steer"), and a plugin's nudge (steer).
+// The row's leading mark ("✂ ", "↪ ") goes: FLASH_MARKS's stands in.
+// chi's own asking-again row (a notice with a line and no hook or cls)
+// does not: the status line tells that already. null: nothing flashes.
+// A hookless notice's cls names its flash: [cls, trail kind, the leading
+// mark the line loses].
+const HOOKLESS_FLASH = [
+  ["llm-context", "edit", /^✂ /],
+  ["steer-cut", "steer", /^↪ /],
+];
 export function flashOf(what, data = {}) {
   if (what === "steer") {
     const sender = steerSender(data.source);
     return { kind: "steer", text: sender ? `${sender} nudged the model` : "nudged the model" };
   }
-  if (what !== "notice" || !data.hook) return null;
+  if (what !== "notice") return null;
+  if (!data.hook) {
+    const flash = HOOKLESS_FLASH.find(([cls]) => cls === data.cls);
+    if (!flash || !data.line) return null;
+    return { kind: flash[1], text: data.line.replace(flash[2], "") };
+  }
   return { kind: data.level === "warn" ? "warn" : "info", text: data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}` };
 }
 

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

@@ -28,9 +28,9 @@ const PENDING = ".bubble.question:not(.answered):not(.cancelled), .bubble.contin
 // and never holds the hand-off (a turn cut short can leave it open).
 const ASKS = ".plugin-card[data-in-turn] .card-action";
 const MARKS = { answered: "✓", "no answer": "∅", canceled: "■", failed: "✕" };
-// The mark of a flash in the trail: a warn notice, a hook's info notice, a
-// plugin's nudge (steer).
-const FLASH_MARKS = { warn: "⚠", info: "ℹ", steer: "↪" };
+// The mark of a flash in the trail: a warn notice, a hook's info notice,
+// an applied LLM context edit (✂), a steer-cut row and a plugin's nudge (↪).
+const FLASH_MARKS = { warn: "⚠", info: "ℹ", edit: "✂", steer: "↪" };
 
 function node(tag, cls, parent = null) {
   const el = document.createElement(tag);

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

@@ -156,6 +156,39 @@ export function steerCutLine({ source } = {}) {
   return `↪ cut in for ${STEER_CUT_FOR[source] || "your message"}`;
 }
 
+// The ✂ row of a batch of LLM context edits the server applied
+// (llm_context_edited, LLMContextNotice): its line as the server built
+// it ("✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens"),
+// so the web and the TUI say the same.
+export function llmContextLine({ text } = {}) {
+  return text || "✂ LLM context edited";
+}
+
+// The ✂ row's hover: what each group did, one line per output (its id,
+// tool and title), and what the batch costs ("~": chars/4).
+export function llmContextHover({ groups = [], freed_tokens: freed, tail_tokens: tail, staged, moment } = {}) {
+  const lines = [];
+  const output = (item) => [item.id, item.tool, item.title].filter(Boolean).join(" ");
+  for (const group of Array.isArray(groups) ? groups : []) {
+    const items = Array.isArray(group.items) ? group.items : [];
+    if (group.kind === "stale") {
+      lines.push("Stubbed as stale:");
+      for (const item of items) lines.push(`  ${output(item)}${item.note ? ` — ${item.note}` : ""}`);
+    } else if (group.kind === "forget") {
+      lines.push(`Forgotten by the ${group.by || "model"}: ${group.note || ""}`);
+      for (const item of items) lines.push(`  ${output(item)}${item.kept ? ` · lines ${item.kept} kept` : ""}`);
+    }
+  }
+  const cost = [];
+  if (Number(freed) > 0) cost.push(`frees ~${freed} tokens`);
+  if (Number(tail) > 0) cost.push(`the server reads ~${tail} tokens again`);
+  if (cost.length) lines.push(cost.join("; "));
+  if (Number(staged) > 0) lines.push(`${staged} more staged until the turn ends`);
+  lines.push(moment === "turn_end" ? "Sent from the next turn on." : "Sent from the next request on.");
+  lines.push("The session keeps the originals.");
+  return lines.join("\n");
+}
+
 // The one muted line for a turn that ended with no answer (turn_completed's
 // turn_summary.empty_answer, or a reloaded turn's marker): the TUI words
 // it the same (TurnNote.empty_answer_line; spec/shared/labels_matrix.json).
@@ -170,6 +203,7 @@ export function emptyAnswerLine({ retries = 0 } = {}) {
 export function noticeLine(entry = {}) {
   if (entry.type === "empty_answer_retry") return emptyRetryLine(entry);
   if (entry.type === "steer_cut") return steerCutLine(entry);
+  if (entry.type === "llm_context_edited") return llmContextLine(entry);
   return `${hookNoticeLabel(entry.hook)}: ${entry.text || ""}`;
 }
 
@@ -305,18 +339,26 @@ export function continueLine(choice, reason = "") {
 // tab's own), `resync` says the conversation changed (!rollback, !cmd, a
 // continue answered no) and must be read again. An anytime command's
 // (`anytime`, D8) bubble is drawn at its command_queued, before the cards
-// it shows; its command_ran fills that bubble in (`commandId`).
+// it shows; its command_ran fills that bubble in (`commandId`). So is a
+// command queued for after the running turn (`queued`): its command_queued
+// (waits: "turn_end") draws it `waiting`, saying so, until it ran or was
+// dropped (styled as failed).
+export const QUEUED_TEXT = "queued: runs after this turn";
+
 export function commandView(event, myId) {
   const own = isOwn(event.client_id, myId);
+  const waiting = event.waits === "turn_end";
   return {
     label: own ? null : clientLabel(event.client_id),
     line: event.line || "",
-    text: event.output || "",
+    text: event.output || (waiting ? QUEUED_TEXT : ""),
     busy: event.status === "busy",
-    failed: event.status === "error",
+    failed: event.status === "error" || event.status === "dropped",
     resync: (event.changed || []).includes("messages"),
     modelName: event.model_name || null,
     anytime: event.anytime === true,
+    queued: waiting || event.queued === true,
+    waiting,
     commandId: event.command_id || null,
     // A card's action (Nudge…): no bubble unless it says something back.
     hidden: event.card === true && !event.output && event.status !== "error",
@@ -464,7 +506,7 @@ export function replaysDrawnTurn(event, turnRecords = []) {
 // A `notice` part carries its event as it came (TurnNotice). The TUI replays
 // a turn the same way (TurnAccumulator.replay_events); spec/shared/
 // turn_snapshot.json pins both.
-export function snapshotEvents({ current_turn: turn = null, queued = [], started_at = undefined } = {}) {
+export function snapshotEvents({ current_turn: turn = null, queued = [], queued_commands: commands = [], started_at = undefined } = {}) {
   const events = [];
   if (turn) {
     events.push(withImages({ type: "turn_started", prompt: turn.prompt, origin: turn.origin, continue: !!turn.continue, started_at }, turn.images));
@@ -542,6 +584,10 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
   for (const entry of queued || []) {
     events.push(withImages({ type: "turn_enqueued", enqueued_id: entry.enqueued_id, client_id: entry.client_id, prompt: entry.prompt }, entry.images));
   }
+  // Commands waiting for the turn's end: their bubbles, as live.
+  for (const entry of commands || []) {
+    events.push({ type: "command_queued", command_id: entry.command_id, client_id: entry.client_id, line: entry.line, waits: "turn_end" });
+  }
   return events;
 }
 

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

@@ -33,12 +33,43 @@ function statusWordHtml({ cls, word }) {
   return word ? `<span class="activity-state ${cls}">${word}</span>` : "";
 }
 
+// A reloaded row's ✂ mark: what an LLM context edit saved on its output
+// sends the model instead (MessageParts.edit_marks): a stale stub and
+// what it frees, a forget's note (or the output whose row carries it) and
+// its kept lines, a forget still staged. The live rows get none (a reload
+// shows them).
+export function llmEditLine(edit) {
+  if (!edit || typeof edit !== "object") return "";
+  const kept = edit.kept ? ` · lines ${edit.kept} kept` : "";
+  if (edit.kind === "forget") {
+    if (edit.staged) return `✂ forget staged${kept}`;
+    return `${edit.with ? `✂ forgotten with ${edit.with}` : `✂ forgotten: ${edit.note || ""}`}${kept}`;
+  }
+  if (edit.kind === "stale") {
+    const tokens = Number(edit.tokens) > 0 ? ` · ~${compactTokens(Number(edit.tokens))}` : "";
+    return `✂ stubbed: ${edit.note || "stale"}${tokens}`;
+  }
+  return "";
+}
+
+function compactTokens(n) {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k tokens` : `${n} tokens`;
+}
+
+function llmEditHtml(row) {
+  const line = llmEditLine(row.edit);
+  if (!line) return "";
+  const hover = `${row.tool_id ? `${row.tool_id}: ` : ""}${line}\nThe model is sent this instead of the output; the session keeps it.`;
+  return `<div class="activity-edit" title="${escapeHtml(hover)}">${escapeHtml(line)}</div>`;
+}
+
 // A tool row: its status mark, tool, title (else params; the full command,
 // 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
-// edit's collapsed diff. A part with nothing to say is left out.
+// 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 = () => "" } = {}) {
   return `<div class="activity-row" data-key="${escapeHtml(row.key)}">${toolRowInnerHtml(row, { thumbs })}</div>`;
 }
@@ -55,7 +86,7 @@ export function toolRowInnerHtml(row, { thumbs = () => "" } = {}) {
   const status = statusParts(row.status);
   return `${statusMarkHtml(status)}<span class="activity-tool">${escapeHtml(toolName(row))}</span>${params}${statusWordHtml(status)}` +
     `${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
-    `${commandBlockHtml(row.view, row.title)}${output}` +
+    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}` +
     `${row.images?.length ? thumbs(row.images) : ""}${row.diff ? activityDiffHtml(row.diff) : ""}`;
 }
 

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

@@ -422,15 +422,17 @@ export function createTurnView({
   // A hook's line (hook_notice) as a row of the current step, above the row
   // of the call it judged; false with no running turn (app.js shows the
   // bubble then). data.line is a whole row of chi's own (an empty-answer
-  // retry), shown as is.
+  // retry), shown as is; data.cls a class of its own and data.title its
+  // hover (a ✂ row's).
   function notice(data) {
     const r = turn && model.notice(turn, data);
     if (!r) return false;
     const entry = genEls.get(r.gen);
     if (!r.gen.text) entry.text.textContent = "";
     const el = document.createElement("div");
-    el.className = "hook-notice" + (data.level === "warn" ? " warn" : "");
+    el.className = "hook-notice" + (data.level === "warn" ? " warn" : "") + (data.cls ? ` ${data.cls}` : "");
     el.textContent = data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
+    if (data.title) el.title = data.title;
     const stick = isNearBottom();
     activityEl(r.gen).appendChild(el);
     if (stick) follow();

data/lib/samagotchi/web/session_hub.rb

@@ -297,7 +297,7 @@ module Samagotchi
 
         entry.owner = owner
         entry.live = live
-        summary = SessionSummary.build(entry.session, owner: owner, session_dir: dir)
+        summary = SessionSummary.build(entry.session, owner: owner, session_dir: dir, registry: hub_registry)
         # A new worker (pid) or a new Bridge for the same session is an
         # event for the page even when the summary reads the same: it
         # reconnects its stream on it.
@@ -307,6 +307,14 @@ module Samagotchi
         emit("session", session: summary)
       end
 
+      # One HostRegistry for the hub's lifetime: every session's ctx_pct may
+      # need its llm_context budget resolved, and the registry's config read
+      # is what would otherwise repeat per scan and per session. Built on
+      # the first summary that needs it.
+      def hub_registry
+        @hub_registry ||= HostRegistry.new
+      end
+
       def drop(id)
         entry = @sessions.delete(id)
         emit("session_gone", id: id) if entry&.summary

data/lib/samagotchi/web/session_summary.rb

@@ -4,6 +4,8 @@ require_relative "../session"
 require_relative "../recap_store"
 require_relative "../archive_store"
 require_relative "../session_metrics"
+require_relative "../llm_context_strategy"
+require_relative "../host_registry"
 require_relative "../bridge_client"
 require_relative "../worker_sidecar"
 require_relative "../bridge/pending_card"
@@ -26,12 +28,18 @@ module Samagotchi
       # @param root_cache [Hash, nil] ProjectScope.root_for's cache, shared
       #   across one listing (a session saved before project_root existed
       #   looks its project up)
+      # @param registry [HostRegistry, nil] the hosts to resolve the
+      #   session's llm_context budget against (its ctx_pct counts against
+      #   the smaller of that budget and the window, as the live meter
+      #   does). nil: one is built here; a caller that builds many summaries
+      #   (the session hub) keeps one and passes it.
       # @return [Hash] symbol keys
-      def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil)
+      def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil,
+                registry: nil)
         used = Array(session.used_memory_names)
         up = bridge_up?(session_dir, owner)
         sidecar = up ? WorkerSidecar.read(session_dir) : nil
-        saved = SessionMetrics.saved_summary(session_dir)
+        saved = SessionMetrics.saved_summary(session_dir, budget_tokens: budget_resolver(session, registry))
         {
           id: session.id,
           status: status,
@@ -86,6 +94,15 @@ module Samagotchi
         }
       end
 
+      # The budget resolver SessionMetrics.saved_summary takes: a callable,
+      # so the session's llm_context budget (config + the registry's index,
+      # no network) is resolved only for a session that has a saved context
+      # to count. One registry per caller (the hub) or one built here.
+      def budget_resolver(session, registry)
+        -> { LLMContextStrategy.session_budget(session, registry: registry ||= HostRegistry.new) }
+      end
+      private_class_method :budget_resolver
+
       # status is turn state (idle/running). The live worker's snapshot is the
       # truth; on disk, a "running" with no live owner was left by a worker
       # that died mid-turn.