samagotchi 0.40.0 → 0.42.0

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

@@ -0,0 +1,194 @@
+// 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
+// worker's snapshot, a command_ran, or the server's own reading of the
+// session file).
+
+export 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"];
+
+const DEFAULT = "default";
+const LAYER_ORDER = ["stale", "forget"];
+
+// Layers as one value, in chi's order (stale before forget); unknown ones after.
+export function strategyValue(layers) {
+  if (!layers.length) return "none";
+  const rank = (name) => { const at = LAYER_ORDER.indexOf(name); return at < 0 ? LAYER_ORDER.length : at; };
+  return [...layers].sort((a, b) => rank(a) - rank(b)).join(",");
+}
+
+// The session's own values as the form shows them: a strategy value, an
+// apply rule and a budget word ("64000", "off"); "default" / "" for unset.
+export function ownValues(summary) {
+  const own = summary?.own || {};
+  const strategy = Array.isArray(own.strategy) ? strategyValue(own.strategy) : DEFAULT;
+  const budget = typeof own.budget_tokens === "number" ? (own.budget_tokens > 0 ? String(own.budget_tokens) : "off") : "";
+  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 };
+}
+
+export function chipHtml(summary, escapeHtml) {
+  const chip = chipModel(summary);
+  if (!chip) return "";
+  return `<button type="button" class="model llmctx-chip${chip.own ? " own" : ""}" title="${escapeHtml(chip.title)}" ` +
+    `aria-haspopup="dialog">${escapeHtml(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.
+// Without it every field goes, "default" for one left to the model, and all
+// of them default is a reset.
+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 };
+  const fields = Object.keys(words).filter((field) => !was || words[field] !== was[field]);
+  if (!fields.length) return null;
+  if (!was && fields.every((field) => words[field] === DEFAULT)) return "/llm-context reset";
+  return `/llm-context ${fields.map((field) => `${field} ${words[field]}`).join(" ")}`;
+}
+
+// The strategy list, with the session's own value when it isn't one of them
+// (forget alone, a newer chi's layer).
+export function strategyOptions(chosen) {
+  if (chosen === DEFAULT || STRATEGIES.some((s) => s.value === chosen)) return STRATEGIES;
+  return [...STRATEGIES, { value: chosen, label: chosen }];
+}
+
+function option(value, label, chosen, escapeHtml) {
+  return `<option value="${escapeHtml(value)}"${value === chosen ? " selected" : ""}>${escapeHtml(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})`;
+}
+
+export function formHtml(summary, escapeHtml, { running = false } = {}) {
+  const own = ownValues(summary);
+  const follow = (field) => (summary[`${field}_source`] === "session" ? "follow the model" : `follow the model (${summary[field]})`);
+  return `<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">${escapeHtml(nowText(summary))}</div>` +
+    `<label class="llmctx-field"><span>Strategy</span><select name="strategy">` +
+    option(DEFAULT, follow("strategy"), own.strategy, escapeHtml) +
+    strategyOptions(own.strategy).map((s) => option(s.value, s.label, own.strategy, escapeHtml)).join("") + `</select></label>` +
+    `<label class="llmctx-field"><span>Apply</span><select name="apply">` +
+    option(DEFAULT, follow("apply"), own.apply, escapeHtml) +
+    APPLIES.map((a) => option(a, a, own.apply, escapeHtml)).join("") + `</select></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="${escapeHtml(own.budget)}"></label>` +
+    `<div class="ctx-pop-meta">From the next turn's start. Turning forget on or off re-reads the whole prompt once.` +
+    `${running ? " A turn is running: set it when it ends." : ""}</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>`;
+}
+
+// The chip's popover. el: where the chip is drawn (#infoText, redrawn every
+// tick: 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.
+export function createLlmContextControl({ el, escapeHtml, summary, session = () => null, running = () => false, run,
+                                          doc = document, win = window }) {
+  const pop = doc.createElement("div");
+  pop.id = "llmContextPopover";
+  pop.className = "ctx-popover llmctx-popover";
+  pop.setAttribute("role", "dialog");
+  pop.hidden = true;
+  doc.body.appendChild(pop);
+  // The values the form opened with, and the session it is for.
+  let initial = null;
+  let openFor = null;
+
+  function place(anchor) {
+    const rect = anchor.getBoundingClientRect();
+    const width = Math.min(360, win.innerWidth - 32);
+    pop.style.width = `${width}px`;
+    pop.style.left = `${Math.max(16, Math.min(rect.left, win.innerWidth - width - 16))}px`;
+    pop.style.bottom = `${Math.max(16, win.innerHeight - rect.top + 8)}px`;
+  }
+
+  function open(anchor) {
+    const data = summary();
+    if (!data) return;
+    initial = ownValues(data);
+    openFor = session();
+    pop.innerHTML = formHtml(data, escapeHtml, { running: running() });
+    pop.hidden = false;
+    place(anchor);
+  }
+
+  function close() {
+    pop.hidden = true;
+    initial = null;
+    openFor = null;
+  }
+
+  function isOpen() { return !pop.hidden; }
+
+  // A new summary (a command_ran, a re-read): an open form keeps what the
+  // user typed; only its "Now:" line and Set's state follow. Another
+  // session closes it.
+  function refresh() {
+    if (!isOpen()) return;
+    const data = summary();
+    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) => {
+    const anchor = e.target.closest(".llmctx-chip");
+    if (!anchor) return;
+    e.stopPropagation();
+    if (isOpen()) close();
+    else open(anchor);
+  });
+  pop.addEventListener("submit", (e) => {
+    e.preventDefault();
+    const form = e.target;
+    const line = commandLine({ strategy: form.elements.strategy.value, apply: form.elements.apply.value,
+                               budget: form.elements.budget.value }, initial);
+    close();
+    if (line) run(line);
+  });
+  pop.addEventListener("click", (e) => {
+    const act = e.target.closest("[data-act]")?.dataset.act;
+    if (act === "close") close();
+    else if (act === "reset") {
+      close();
+      run(commandLine());
+    }
+  });
+  doc.addEventListener("click", (e) => {
+    if (isOpen() && !pop.contains(e.target) && !e.target.closest?.(".llmctx-chip")) close();
+  });
+  doc.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && isOpen()) close();
+  });
+
+  return { close, refresh, get open() { return isOpen(); } };
+}

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

@@ -14,6 +14,9 @@ export function emptySessionState() {
     // in the info bar's tooltip).
     preloadedMemories: [],
     mutedMemories: [],
+    // The model notes the session's prompt carried (its prompt_notes: name,
+    // scope, chars, digest; the info bar's notes chip).
+    promptNotes: [],
     // A delegated session's parent (the info bar's "delegated by" chip).
     parentId: null,
     ctxPct: null,
@@ -33,6 +36,9 @@ export function emptySessionState() {
     // worker_version / worker_features): the info bar's stale-worker badge.
     workerVersion: null,
     workerFeatures: [],
+    // 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,
     timing: normalizeTiming(),
   };
 }

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

@@ -61,6 +61,9 @@ export function normalizeTiming(data = {}) {
     activeTurn: validRecord(data.active_turn) ? data.active_turn : null,
     // The session's token sums and speeds (SessionMetrics' tokens block).
     tokens: validRecord(data.tokens) ? data.tokens : null,
+    // The memory indexes the session's prompt holds (SessionMetrics'
+    // memory_index), for the ctx tooltip.
+    memoryIndex: validRecord(data.memory_index) ? data.memory_index : null,
   };
 }
 
@@ -96,7 +99,8 @@ export function mergeTiming(timing, data = {}) {
     if (!replaceById(toolRecords, record)) toolRecords.push(record);
   });
   const tokens = fresh.tokens || timing?.tokens || null;
-  return { timing: { ...fresh, turnRecords, toolRecords, tokens }, short: turnRecords.length < count };
+  const memoryIndex = fresh.memoryIndex || timing?.memoryIndex || null;
+  return { timing: { ...fresh, turnRecords, toolRecords, tokens, memoryIndex }, short: turnRecords.length < count };
 }
 
 function replaceById(records, record) {
@@ -229,8 +233,10 @@ function turnGroup(g, items, timing) {
 
 // A canceled turn that ran more than one step or any call has no answer:
 // its partial text stays in the block, as it does live (turn_view.js
-// turnEnded promotes only a completed turn or a lone step with no tools).
+// turnEnded promotes only a completed turn or a lone step with no tools). A
+// failed turn never answered: its texts are steps.
 function canceledSteps(g, record, tools) {
+  if (record?.status === "failed") return true;
   return record?.status === "canceled" && (g.texts.length > 1 || tools.length > 0);
 }
 

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

@@ -11,7 +11,7 @@
 // removed at the end: the answer bubble takes its place.
 import { leavesBlock } from "./card.js";
 import { copySourceAttr } from "./copy.js";
-import { escapeHtml, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
+import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
@@ -701,6 +701,17 @@ function setLabel(summary, gen) {
   summary.innerHTML = html;
 }
 
+// A re-rendered failed turn's line (a .bubble.cancel, as live's
+// addEndBubble), in turn_failed's words (failedTurnText) from what the turn
+// record kept of it (SessionMetrics' failure: summary, message,
+// error_class, kept_steps); "" for any other record, or a failed one saved
+// before records kept that.
+function failedLineHtml(record) {
+  const failure = record?.status === "failed" ? record.failure : null;
+  if (!failure || typeof failure !== "object") return "";
+  return `<div class="bubble cancel">${escapeHtml(failedTurnText(failure))}</div>`;
+}
+
 // A reloaded history in the turn view (renderHistory's object path): per
 // turn the prompt, a collapsed block of its steps when it had any (texts,
 // and with the server's parts the thinking, params and output, from the
@@ -789,8 +800,10 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     // timing after its prompt and steps, where the live view leaves it.
     else if (group.answer === null) parts.push(timingHtml(group));
     else parts.push(answerHtml(items[group.answer], timingHtml(group)));
-    // A canceled turn ends with its cancel line, as the live view left it.
+    // A canceled turn ends with its cancel line, a failed one whose steps
+    // stayed with its failure line, as the live view left them.
     parts.push(cancelLineHtml(group.record, escapeHtml));
+    parts.push(failedLineHtml(group.record));
     return parts.join("");
   }).join("");
 }

data/lib/samagotchi/web/session_summary.rb

@@ -47,6 +47,8 @@ module Samagotchi
           # The session's --memory and --mute lists (info-bar tooltip).
           preloaded_memory_names: Array(session.preloaded_memory_names),
           muted_memory_names: Array(session.muted_memory_names),
+          # The model notes its prompt carried (the info bar's notes chip).
+          prompt_notes: Array(session.prompt_notes).map(&:to_h),
           # The session that delegated this one (the `delegate` tool), else nil.
           parent_id: session.parent_id,
           # Started by the delegate tool (Session#delegate?); a fork has a
@@ -62,6 +64,8 @@ module Samagotchi
           # one read of analytics.json.
           ctx_pct: saved&.ctx_pct&.round(1),
           tokens: saved&.tokens,
+          # The memory indexes its prompt held (the card's ctx tooltip).
+          memory_index: saved&.memory_index,
           # Hidden from the strip and the list unless "include archived".
           archived: ArchiveStore.archived?(session_dir),
           project_root: session.project_root(cache: root_cache),

data/lib/samagotchi/worker.rb

@@ -413,10 +413,9 @@ module Samagotchi
       run_engine_turn(nil, continue: true, origin: context_wake.origin,
                            id: context_wake.turn_id, max_iterations: IterationLimit.for) do |result, error|
         if error
-          note = TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message,
-                                 wake: "the change in attached context #{name}")
-          @turn_flow.prompt_turn_failed(note: note)
-          @inbound.unmark_wake(context_wake)
+          kept = @turn_flow.prompt_turn_failed(error: error, wake: "the change in attached context #{name}") == :kept
+          # A turn that got somewhere stays, its wake mark with it.
+          @inbound.unmark_wake(context_wake) unless kept
           @wakes.pause!
         else
           @continue_offer.after_turn(result)
@@ -508,17 +507,24 @@ module Samagotchi
       @wakes.hand_over(reports)
       Log.info(:worker, "delegate_wake_turn", reports: reports.size, in_a_row: @wakes.count!)
       @turn_flow.before_prompt_turn
+      restores = @turn_flow.restores
       run_engine_turn(nil, continue: true, origin: reports.first.origin, max_iterations: IterationLimit.for) do |result, error|
         if error
-          # The rings stay (settle_child_reports): the user's next turn takes them.
-          note = TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message,
-                                 wake: reports.size == 1 ? "a delegate's report" : "#{reports.size} delegate reports",
-                                 kept: "chi keeps #{reports.size == 1 ? "the report and brings it" : "the reports and brings them"} " \
-                                       "again with the user's next message.")
-          @turn_flow.prompt_turn_failed(note: note)
+          # Rolled back, the rings stay (settle_child_reports): the user's
+          # next turn takes them. A turn that got somewhere stays, and read them.
+          @turn_flow.prompt_turn_failed(
+            error: error, wake: reports.size == 1 ? "a delegate's report" : "#{reports.size} delegate reports",
+            wake_kept: "chi keeps #{reports.size == 1 ? "the report and brings it" : "the reports and brings them"} " \
+                       "again with the user's next message."
+          )
           @wakes.pause!
         else
           @continue_offer.after_turn(result)
+          # Stopped before it got anywhere (a Stop or a before_turn hook's
+          # cancel before the model call) and restored: its rings stay, and
+          # wait for the user's next message as after a failure, rather
+          # than waking again at once.
+          @wakes.pause! if result.canceled? && @turn_flow.restores != restores
         end
       end
       true
@@ -635,6 +641,8 @@ module Samagotchi
                 model_name: @engine.effective_model_name }
       event[:anytime] = true if anytime
       event[:card] = true if command[:card]
+      # /llm-context or /model: what the next turn runs under now (the web's chip).
+      event[:llm_context] = @engine.llm_context_summary if changed.intersect?(%i[llm_context model])
       event[:output_truncated] = true if text.length > COMMAND_OUTPUT_LIMIT
       @engine.announce(event)
     end
@@ -654,6 +662,7 @@ module Samagotchi
       # a fresh worker's first), so the list is this turn's from the start.
       @merged_this_turn = []
       @reporting_turn = reports_to_parent?(turn_args[:origin])
+      restores = @turn_flow.restores
       begin
         @session.status = Session::STATUS_RUNNING
         @session.save(state_dir: @state_dir)
@@ -680,15 +689,22 @@ module Samagotchi
         SessionInbox.write_output(@session_dir, response)
       end
       save_or_log(:turn) { save_session }
-      settle_child_reports(error)
+      # The reports the turn merged were read unless its end took the turn
+      # back out of the conversation (TurnFlow restored a checkpoint: a
+      # failed prompt or wake turn that got nowhere, a canceled continue
+      # turn). A failed turn whose work stayed, and a reminder or continue
+      # turn that failed (kept with its failed note), read them.
+      settle_child_reports(rolled_back: @turn_flow.restores != restores)
       ring_parent_after_turn
     end
 
     # The delegate reports this turn took: a kept turn moves the cursors on
-    # and deletes their rings; a failed one (rolled back) leaves the rings
-    # for the next turn.
-    def settle_child_reports(error)
-      error ? @child_reports.release : @child_reports.commit
+    # and deletes their rings; a rolled-back one leaves the rings for the
+    # next turn. Once either way: the model reads a report in the
+    # conversation, or the next turn brings it (unless a later !rollback
+    # erases a kept turn, which drops what it read).
+    def settle_child_reports(rolled_back:)
+      rolled_back ? @child_reports.release : @child_reports.commit
     end
 
     # A delegate child's turn that was its parent's (#reports_to_parent?)
@@ -735,16 +751,18 @@ module Samagotchi
     # prompt it took (its own and any merged into it) goes back to its
     # sender, who can send it again. The rollback and the announcements are
     # one step of the event log: a snapshot shows the failed turn's messages
-    # or the restored ones, never the one without the other.
+    # or the restored ones, never the one without the other. A turn that
+    # got somewhere stays instead (TurnFlow#prompt_turn_failed), with the
+    # prompts it took: nothing goes back.
     # @param prompts [Array<Array(String, Hash|nil, Array|nil)>] [prompt,
     #   origin, images] (a web client gets its image chips back)
     # @param error [Exception, nil] what failed: its one line stays in the
     #   conversation as a turn note
     # Not saved here: run_engine_turn saves after its block.
     def restore_failed_turn(prompts, error: nil)
-      note = error && TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message, restored: true)
       @engine.synchronize_events do
-        @turn_flow.prompt_turn_failed(note: note)
+        next if @turn_flow.prompt_turn_failed(error: error) == :kept
+
         prompts.each do |prompt, origin, images|
           restored = { type: :prompt_restored, prompt: prompt, origin: origin }
           restored[:images] = images unless Array(images).empty?

data/lib/samagotchi/worker_wakes.rb

@@ -73,7 +73,8 @@ module Samagotchi
     # A wake turn starts. @return [Integer] the wake turns in a row now
     def count! = @in_a_row += 1
 
-    # A wake turn failed: none starts again until a human's input.
+    # A wake turn failed (or was stopped before it got anywhere): none
+    # starts again until a human's input.
     def pause!
       @paused = true
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.40.0
+  version: 0.42.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -312,8 +312,10 @@ files:
 - lib/samagotchi/llm/usage.rb
 - lib/samagotchi/llm/utf8_scrub.rb
 - lib/samagotchi/llm_context_apply.rb
+- lib/samagotchi/llm_context_command.rb
 - lib/samagotchi/llm_context_edit.rb
 - lib/samagotchi/llm_context_forget.rb
+- lib/samagotchi/llm_context_override.rb
 - lib/samagotchi/llm_context_stale.rb
 - lib/samagotchi/llm_context_strategy.rb
 - lib/samagotchi/llm_context_view.rb
@@ -323,6 +325,7 @@ files:
 - lib/samagotchi/log_subscriber.rb
 - lib/samagotchi/memory_bundle.rb
 - lib/samagotchi/memory_bundle/builder.rb
+- lib/samagotchi/memory_bundle/index_size.rb
 - lib/samagotchi/memory_bundle/index_sync.rb
 - lib/samagotchi/memory_bundle/index_updater.rb
 - lib/samagotchi/memory_bundle/installer.rb
@@ -341,6 +344,8 @@ files:
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/model_catalog.rb
 - lib/samagotchi/model_list_store.rb
+- lib/samagotchi/model_match.rb
+- lib/samagotchi/model_notes.rb
 - lib/samagotchi/model_overlay.rb
 - lib/samagotchi/model_profile.rb
 - lib/samagotchi/model_ref.rb
@@ -368,6 +373,7 @@ files:
 - lib/samagotchi/prompt.rb
 - lib/samagotchi/prompt_history.rb
 - lib/samagotchi/prompt_literal_guard.rb
+- lib/samagotchi/prompt_note.rb
 - lib/samagotchi/prompt_warmup.rb
 - lib/samagotchi/question_desk.rb
 - lib/samagotchi/recap_setup.rb
@@ -507,6 +513,7 @@ files:
 - lib/samagotchi/web/public/init_row.js
 - lib/samagotchi/web/public/live_timing.js
 - lib/samagotchi/web/public/live_turn.js
+- lib/samagotchi/web/public/llm_context_chip.js
 - lib/samagotchi/web/public/model_pick.js
 - lib/samagotchi/web/public/model_picker.js
 - lib/samagotchi/web/public/notifications.js