samagotchi 0.101.0 → 0.102.0

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.101.0"
+  VERSION = "0.102.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -670,13 +670,13 @@ module Samagotchi
         thinking, error = request_thinking(body["thinking"])
         return error if error
 
-        # bundle_settings: the session's own bundle settings (chi --set:
-        # {bundle => {key => scalar}}), checked against the installed
-        # bundles the same way.
+        # settings: the session's own settings, flat as chi --set names
+        # them ({"recap.enabled" => false, "cost-cap.cap" => 3}), checked
+        # the same way (SessionConfig.from_request).
         begin
-          bundle_settings = BundleSessionSettings.from_request(body["bundle_settings"])
-        rescue BundleSessionSettings::Error => e
-          return error_response(400, "invalid_bundle_settings", e.message)
+          settings = SessionConfig.from_request(body["settings"])
+        rescue SessionConfig::Error => e
+          return error_response(400, "invalid_settings", e.message)
         end
 
         folder = dir ? { working_directory: dir } : {}
@@ -689,7 +689,7 @@ module Samagotchi
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
         folder[:preview] = preview unless preview.empty?
-        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, bundle_settings: bundle_settings)
+        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, settings: settings)
         folder[:setup] = setup unless setup.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
@@ -709,7 +709,7 @@ module Samagotchi
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
-      # and reasoning_history levels, bundle settings), so dir, llm_context, thinking and bundle_settings are
+      # and reasoning_history levels, settings), so dir, llm_context, thinking and settings are
       # refused beside it (a create takes no reasoning_history). It runs on
       # model (or model_name) when given, else on the previous link's: one
       # whose host is gone falls back to the default, and the 201's
@@ -724,9 +724,9 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir llm_context thinking bundle_settings].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir llm_context thinking settings].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, llm_context, thinking and bundle_settings; " \
+                                "continues takes the previous session's folder, llm_context, thinking and settings; " \
                                 "leave out #{fields.join(", ")}")
         end
 
@@ -1486,15 +1486,24 @@ module Samagotchi
       # ── The working set (web.working_set) ───────────────────────────────
 
       # GET /api/sessions/:id/working_set: the working set as the model has
-      # it ({items:, at:}, WorkingSet), what the page overlays on its rows'
+      # it ({items:, at:, running:}, WorkingSet), what the page overlays on its rows'
       # set when it seeds a session's and when the expanded view opens (a
       # file changed while the session sat idle). A live worker's snapshot
       # messages are the truth, as #handle_show's, else the file's; the
       # strategy is the session's llm ctx chip's, the folder its working
-      # directory.
+      # directory. running: a turn runs. The snapshot's messages lag it, so
+      # the answer is then the turn's last :working_set_updated (the
+      # snapshot's working_set, TurnAccumulator#working_set); before the
+      # turn emitted one, or from an older worker without the field, it is
+      # the session's messages, behind that turn's events, and the page
+      # keeps theirs (working_set.js newerSnapshot).
       def handle_working_set(_req, id)
         session = @session_class.load(id, state_dir: default_state_dir)
         live = bridge_get_json(id, "snapshot")
+        running = !live&.dig("snapshot", "current_turn").nil?
+        turn_set = running && running_working_set(live["snapshot"]["working_set"])
+        return json_response(200, turn_set.merge(running: true)) if turn_set
+
         messages = live_or_saved(live && live["snapshot"], "messages") { session.messages }
         # A snapshot's entries have string keys (paired_runs reads symbols).
         messages = Array(messages).map { |message| message.is_a?(Hash) ? message.transform_keys(&:to_sym) : message }
@@ -1502,7 +1511,15 @@ module Samagotchi
           SessionSetting::LLM_CONTEXT.saved_summary(session, registry: host_registry)
         end
         snapshot = WorkingSet.build(messages, cwd: session.working_directory, strategy: working_set_strategy(llm_context))
-        json_response(200, snapshot.to_h)
+        json_response(200, snapshot.to_h.merge(running: running))
+      end
+
+      # The running turn's set from a worker's snapshot ({"items", "at"}), as
+      # {items:, at:}; nil when it has none (none emitted yet, an older worker).
+      def running_working_set(set)
+        return nil unless set.is_a?(Hash) && set["items"].is_a?(Array) && set["at"].is_a?(Integer)
+
+        { items: set["items"], at: set["at"] }
       end
 
       # The strategy an llm ctx chip names ("none", "stale,forget"), as

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

@@ -236,6 +236,8 @@ const workingSet = view === "stage" && document.body.dataset.workingSet === "1"
   ? createWorkingSet({
     historyEl, stageRoot: () => turnDom.root, state: () => current, session: () => selected, infoEl: infoTextEl,
     onChange: () => updateInfoBar(), getWorkingSet,
+    // A drop or undrop from the list: the session's command, as typed.
+    sendLine: (line) => (selected ? sendCommand(selected, line, { clientId }) : null),
   })
   : null;
 document.body.classList.toggle("working-set", !!workingSet);

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

@@ -109,13 +109,19 @@ const WEB_LOCAL_REPLIES = {
   "/detach": "/detach: a terminal's command; close the tab to leave, the worker keeps running",
   "/exit": "/exit: close the tab to leave; stop in the session bar stops the worker",
   "/quit": "/quit: close the tab to leave; stop in the session bar stops the worker",
-  "/recap": "/recap: not in the web yet; a recap shows here by itself when you come back to an idle session, and /recap in a terminal (chi --attach) makes one now",
+  "/recap": "/recap: not in the web yet; a recap shows here by itself when you come back to an idle session, and /recap in a terminal (chi --attach) makes one now. /recap on|off|default sets this session's recap here too",
   "/unqueue": "/unqueue: a terminal's command; here the × on a message queued for after the turn removes it",
   "/stats": "/stats: not in the web yet; each turn shows its time, the session bar the context use and speed (hover ctx for tokens and cost), and /stats in a terminal (chi --attach) has the rest",
 };
 
+// The ones whose words after the name are the worker's (/recap off): the
+// page answers only the bare name.
+const WORKER_WITH_WORDS = new Set(["/recap"]);
+
 export function webLocalReply(text) {
-  const name = String(text || "").trim().split(/\s+/)[0].toLowerCase();
+  const words = String(text || "").trim().split(/\s+/);
+  const name = words[0].toLowerCase();
+  if (WORKER_WITH_WORDS.has(name) && words.length > 1) return null;
   return WEB_LOCAL_REPLIES[name] || null;
 }
 

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

@@ -298,8 +298,9 @@ export function openEvents(handlers = {}, opts = {}) {
   };
 }
 
-// A session's working set as the model has it (WorkingSet: {items, at}),
-// what the stage view's working set overlays on its rows (web.working_set).
+// A session's working set as the model has it (WorkingSet: {items, at,
+// running}), what the stage view's working set overlays on its rows
+// (web.working_set).
 export function getWorkingSet(id, opts = {}) {
   return api(`/api/sessions/${encodeURIComponent(id)}/working_set`, opts);
 }

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

@@ -905,9 +905,10 @@ body.working-set .ts-live{position:relative;padding-right:264px}
 /* The server's states (WorkingSet): stale faded; forgotten struck, faint and faded (a group only when all its members are). The words are the popover's and the titles' (colour is never alone). */
 .ws-item.stale{opacity:.55}
 .ws-item.forgotten{opacity:.5}
-.ws-item.forgotten .t,.ws-row.forgotten .t,.ws-foot .l.forgotten{text-decoration:line-through;color:var(--text-faint)}
+.ws-item.forgotten,.ws-item.dropped{opacity:.5}
+.ws-item.forgotten .t,.ws-row.forgotten .t,.ws-foot .l.forgotten,.ws-item.dropped .t,.ws-row.dropped .t,.ws-foot .l.dropped{text-decoration:line-through;color:var(--text-faint)}
 .ws-row.stale .k,.ws-row.stale .t,.ws-foot .l.stale{opacity:.55}
-.ws-row.forgotten .k,.ws-row.forgotten .t,.ws-foot .l.forgotten{opacity:.5}
+.ws-row.forgotten .k,.ws-row.forgotten .t,.ws-foot .l.forgotten,.ws-row.dropped .k,.ws-row.dropped .t,.ws-foot .l.dropped{opacity:.5}
 .ws-item.enter{animation:ws-in .2s ease}
 @keyframes ws-in{from{opacity:0}}
 .ws-item.leave,.ws-more.leave{opacity:0;pointer-events:none}
@@ -980,6 +981,23 @@ button.ws-row:hover:not(:disabled){filter:none;background:var(--bg-hover)}
 .ws-row.fresh{background:var(--accent-tint)}
 .ws-row.fresh .k{color:var(--accent)}
 .ws-row.muted{opacity:.6}
+/* Steering (drop / undrop): a row's actions on hover and keyboard focus (always where there is no hover); a pending op's row dashed warn with its pill, the footer counting them. */
+.ws-act{flex:none;display:inline-flex;gap:4px;opacity:0}
+.ws-row:hover .ws-act,.ws-row:focus-within .ws-act,.ws-ghead:hover .ws-act,.ws-ghead:focus-within .ws-act,.ws-row.pending .ws-act{opacity:1}
+@media (hover:none){.ws-act{opacity:1}}
+.ws-act-b{flex:none;padding:0 6px;border:1px solid var(--border-strong);border-radius:4px;background:transparent;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;font-weight:400;line-height:16px;color:var(--text-muted);cursor:pointer}
+.ws-act-b:hover:not(:disabled){filter:none;color:var(--accent);border-color:var(--accent);background:var(--accent-bg)}
+.ws-act-b:disabled{opacity:.5;cursor:default}
+.ws-ghead{display:flex;align-items:center;gap:4px}
+.ws-ghead>.ws-group-head{flex:1;min-width:0}
+.ws-row.pending{border:1px dashed var(--warn-border);background:var(--warn-bg)}
+.ws-row.pending:hover{background:var(--warn-bg)}
+.ws-pend{flex:none;padding:0 6px;border:1px solid var(--warn-border);border-radius:999px;background:var(--warn-bg);color:var(--warn-text);font-family:ui-sans-serif,system-ui,sans-serif;font-size:10.5px;line-height:15px;white-space:nowrap}
+.ws-pending{margin-top:8px;padding:4px 8px;border:1px dashed var(--warn-border);border-radius:6px;background:var(--warn-bg);color:var(--warn-text);font-size:11.5px;line-height:20px}
+.ws-pending .ws-act-b{color:var(--warn-text);border-color:var(--warn-border)}
+.ws-popover.sheet .ws-row .ws-act{display:none}
+.ws-strip{display:flex;gap:8px;padding:2px 6px 6px 26px}
+.ws-strip .ws-act-b{padding:0 14px;font-size:12.5px;line-height:28px;border-radius:6px}
 .ws-popover.sheet{border-radius:14px}
 /* A phone's sheet: the name, the scope and × on the first line, the count and the ring under them. */
 .ws-popover.sheet .ctx-pop-close{order:2}

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

@@ -228,6 +228,8 @@ export function createStreamHandlers(deps) {
     // the conversation (!rollback, !cmd, a continue answered no) re-reads it.
     command_ran: async (data) => {
       const id = selected();
+      // A queued /working-set line is no longer pending (the list's pill).
+      workingSet?.commandRan(data);
       const view = commandView(data, clientId);
       if (view.modelName && view.modelName !== state().model) {
         state().model = view.modelName;
@@ -290,6 +292,8 @@ export function createStreamHandlers(deps) {
     // turn: its bubble goes here, so the cards it shows come after it. One
     // queued for after the turn (/model X mid-turn) shows waiting here.
     command_queued: (data) => {
+      // A /working-set line queued for after the turn: pending in the list.
+      workingSet?.commandQueued(data);
       // A card's action waits for its command_ran: shown only if it answers.
       if ((data.anytime || data.waits) && !data.card && !commandBubble(data.command_id)) addCommandBubble(commandView(data, clientId));
     },

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

@@ -60,6 +60,11 @@ export function llmEditLine(edit) {
     const tokens = Number(edit.tokens) > 0 ? ` · ~${compactTokens(Number(edit.tokens))}` : "";
     return `✂ stubbed: ${edit.note || "stale"}${tokens}`;
   }
+  // The user's drop (/working-set drop, the working set's list).
+  if (edit.kind === "drop") {
+    const tokens = Number(edit.tokens) > 0 ? ` · ~${compactTokens(Number(edit.tokens))}` : "";
+    return `✂ dropped by the user${tokens}`;
+  }
   return "";
 }
 

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

@@ -14,8 +14,10 @@
 // touch unions its ops and bumps its count, never its at: within a turn
 // the set is append-only, which keeps the fold stable. state is "live" from
 // the rows; the server's projection (GET working_set, :working_set_updated:
-// WorkingSet) overlays its state (live, stale, forgotten) and tokens by key
-// (overlay), never its at.
+// WorkingSet) overlays its state (live, stale, forgotten, dropped) and
+// tokens by key (overlay), never its at. The user steers it with
+// `/working-set drop|undrop KEY…` lines (steerLine); one queued for after the
+// running turn is pending (pendingSteers) until its command_ran.
 
 export const FLASH_MS = 4000;
 // Labels per form: the rail's four lines, the row's and the footprint's
@@ -186,7 +188,7 @@ export function sessionItems({ turns = [], live = [], preloaded = [], muted = []
 
 // ── the server's truth ────────────────────────────────────────────────────
 
-export const STATES = Object.freeze(["live", "stale", "forgotten"]);
+export const STATES = Object.freeze(["live", "stale", "forgotten", "dropped"]);
 const ELLIPSIS = "\u2026";
 
 // The server's items by "kind:key", and its URLs (a cut row key matches one
@@ -225,21 +227,31 @@ export function overlay(items, server) {
     const found = serverItem(index, item);
     const state = found ? found.state : "live";
     const tokens = found && Number.isFinite(found.tokens) ? found.tokens : undefined;
-    if (item.state === state && item.tokens === tokens) return item;
+    // A cut URL row's full key, the one a steer line names.
+    const serverKey = found && found.key !== item.key ? found.key : undefined;
+    if (item.state === state && item.tokens === tokens && item.serverKey === serverKey) return item;
     const next = { ...item, state };
     if (tokens === undefined) delete next.tokens;
     else next.tokens = tokens;
+    if (serverKey === undefined) delete next.serverKey;
+    else next.serverKey = serverKey;
     return next;
   });
 }
 
-// Which snapshot to keep: +next+ when there is none yet or it is built from
-// as much of the conversation as the kept one (its at), else +kept+. A GET
-// that answered after a newer event never wins over it.
-export function newerSnapshot(kept, next) {
+// Which snapshot to keep, +next+ or +kept+. Events come in the order the
+// server built them, so an event (+event+) always wins: a smaller at is a
+// rollback that shortened the conversation, not an older set. A GET's
+// answer loses to an event that came while it was on its way (+overtaken+),
+// and, asked while a turn runs (its running: it is built from the session's
+// messages, behind that turn's events), to a kept one from more of the
+// conversation (its at).
+export function newerSnapshot(kept, next, { event = false, overtaken = false } = {}) {
   if (!next || !Array.isArray(next.items) || !Number.isFinite(next.at)) return kept;
-  if (!kept || next.at >= kept.at) return next;
-  return kept;
+  if (!kept || event) return next;
+  if (overtaken) return kept;
+  if (next.running && next.at < kept.at) return kept;
+  return next;
 }
 
 // Tokens as the popover shows them: "~840", "~1.2k", "~12k".
@@ -251,13 +263,17 @@ export function tokensText(tokens) {
 }
 
 const isForgotten = (item) => item.state === "forgotten";
-const isFaded = (item) => item.state === "stale" || item.state === "forgotten";
-
-// A group's state: forgotten when all its members are, stale when all are
-// stale or forgotten, else live (spec §3: struck only when all forgotten,
-// faded when all stale or forgotten).
+// Nothing of it is sent: the model forgot it, or the user dropped it.
+const isStruck = (item) => item.state === "forgotten" || item.state === "dropped";
+const isFaded = (item) => item.state === "stale" || isStruck(item);
+
+// A group's state: dropped when all its members are, forgotten when all are
+// struck (forgotten or dropped), stale when all are stale or struck, else
+// live (spec §3: struck only when all forgotten, faded when all stale or
+// forgotten).
 export function groupState(members) {
-  if (members.length && members.every(isForgotten)) return "forgotten";
+  if (members.length && members.every((m) => m.state === "dropped")) return "dropped";
+  if (members.length && members.every(isStruck)) return "forgotten";
   if (members.length && members.every(isFaded)) return "stale";
   return "live";
 }
@@ -278,7 +294,7 @@ export function leafText(item) {
 function leafLabel(item) {
   return {
     id: `${item.kind}:${item.key}`, type: "leaf", kind: item.kind, glyph: GLYPHS[item.kind] || "", text: leafText(item),
-    n: 1, edited: edited(item) ? 1 : 0, cut: isForgotten(item) ? 1 : 0, state: item.state || "live", members: [item],
+    n: 1, edited: edited(item) ? 1 : 0, cut: isStruck(item) ? 1 : 0, state: item.state || "live", members: [item],
   };
 }
 
@@ -295,7 +311,7 @@ function groupLabel(spec, members) {
   const edits = members.filter(edited).length;
   // The state marks (spec §3): ✂n the forgotten members, the group's own
   // state from all of them.
-  const marks = { cut: members.filter(isForgotten).length, state: groupState(members) };
+  const marks = { cut: members.filter(isStruck).length, state: groupState(members) };
   if (spec.type === "dir") {
     return { id: `dir:${spec.dir}`, type: "dir", kind: "file", glyph: "", text: dirLabel(spec.dir), count: plural(n, "file"), n, edited: edits, ...marks, members, dir: spec.dir };
   }
@@ -451,9 +467,16 @@ export function opsText(item) {
 
 // A label as the screen reader says it ("web/public 9 files 2 edited").
 function spoken(label) {
-  if (label.type === "dir") return `${label.text.replace(/^…\//, "").replace(/\/$/, "")} ${label.count}${label.edited ? ` ${label.edited} edited` : ""}${label.cut ? ` ${label.cut} forgotten` : ""}`;
+  if (label.type === "dir") return `${label.text.replace(/^…\//, "").replace(/\/$/, "")} ${label.count}${label.edited ? ` ${label.edited} edited` : ""}${cutWords(label)}`;
   if (label.type === "leaf") return `${label.kind === "memory" ? "memory " : label.kind === "url" ? "url " : ""}${label.text}${label.edited ? " edited" : ""}${label.state && label.state !== "live" ? ` ${label.state}` : ""}`;
-  return `${label.text}${label.cut ? ` ${label.cut} forgotten` : ""}`;
+  return `${label.text}${cutWords(label)}`;
+}
+
+// A group's struck members in words: " 2 forgotten, 1 dropped".
+function cutWords(label) {
+  const dropped = label.members.filter((m) => m.state === "dropped").length;
+  const forgotten = label.cut - dropped;
+  return [forgotten ? ` ${forgotten} forgotten` : "", dropped ? ` ${dropped} dropped` : ""].filter(Boolean).join(",");
 }
 
 // The rail's (or row's, footprint's) aria-label: the folded text spoken.
@@ -476,7 +499,8 @@ export function footprint(items, budget = BUDGETS.footprint) {
     const kinds = new Set(rest.map((m) => m.kind));
     tail = kinds.size === 1 ? `+${plural(rest.length, KIND_WORDS[[...kinds][0]])}` : `+${rest.length} more`;
   }
-  return { labels: head, tail, edited: items.filter(edited).length, forgotten: items.filter(isForgotten).length };
+  return { labels: head, tail, edited: items.filter(edited).length, forgotten: items.filter(isForgotten).length,
+    dropped: items.filter((i) => i.state === "dropped").length };
 }
 
 // A label's text as the footprint and the row draw it: its glyph, text,
@@ -498,6 +522,7 @@ export function footprintText(items, budget = BUDGETS.footprint) {
   if (fp.tail) parts.push(fp.tail);
   if (fp.edited) parts.push(`edited ${fp.edited}`);
   if (fp.forgotten) parts.push(`${fp.forgotten} forgotten`);
+  if (fp.dropped) parts.push(`${fp.dropped} dropped`);
   return `touched ${parts.join(" · ")}`;
 }
 
@@ -518,3 +543,70 @@ export function nextSettle(seenTimes, now, ms = FLASH_MS) {
   }
   return next;
 }
+
+// ── steering (drop / undrop) ──────────────────────────────────────────────
+
+export const STEER_COMMAND = "/working-set";
+const STEER_LINE = /^\/working-set\s+(drop|undrop)\s+(\S.*)$/;
+const URL_WORD = /^[a-z][a-z0-9+.-]*:\/\//i;
+export const INVERSE = Object.freeze({ drop: "undrop", undrop: "drop" });
+
+// The word a steer line names +item+ by (WorkingSetSteer.target): a file's
+// absolute path, memory:NAME, a URL (the server's full one for a cut row).
+export function steerWord(item) {
+  if (item.kind === "memory") return `memory:${item.key}`;
+  if (item.kind === "url") return item.serverKey || item.key;
+  return item.key;
+}
+
+// The id the page keys an item by ("file:/abs/a.rb"), from a steer word.
+function wordId(word) {
+  if (word.startsWith("memory:")) return `memory:${word.slice("memory:".length)}`;
+  if (URL_WORD.test(word)) return `url:${word}`;
+  return `file:${word}`;
+}
+
+// An item's id as steer lines name it.
+export function steerId(item) {
+  return wordId(steerWord(item));
+}
+
+// The line that does +op+ to +items+ ("/working-set drop /abs/a.rb memory:x").
+export function steerLine(op, items) {
+  return `${STEER_COMMAND} ${op} ${items.map(steerWord).join(" ")}`;
+}
+
+// A steer line's op and ids ({op, ids}), or null for any other line.
+export function parseSteerLine(line) {
+  const m = STEER_LINE.exec(String(line || "").trim());
+  if (!m) return null;
+  return { op: m[1], ids: m[2].split(/\s+/).filter(Boolean).map(wordId) };
+}
+
+// The ops queued for after the running turn (+lines+, in queue order), per
+// item id: "drop" or "undrop". An op followed by its inverse nets to
+// nothing (the worker runs both, the second undoing the first).
+export function pendingSteers(lines) {
+  const pending = new Map();
+  for (const line of lines) {
+    const parsed = parseSteerLine(line);
+    if (!parsed) continue;
+    for (const id of parsed.ids) {
+      if (pending.get(id) === INVERSE[parsed.op]) pending.delete(id);
+      else pending.set(id, parsed.op);
+    }
+  }
+  return pending;
+}
+
+// Why +item+ can't be dropped (a title for its disabled button), "" when
+// it can, null when it has no drop at all (muted, dropped already, or the
+// server doesn't know it yet: a running call).
+export function dropRefusal(item) {
+  if (item.muted || item.state === "dropped") return null;
+  if (item.preloaded && !item.ops.includes("read")) return "preloaded into the system prompt: not dropped from here";
+  if (!Number.isFinite(item.tokens)) return null;
+  if (!item.ops.includes("read")) return "only edited or written: nothing of it to drop";
+  if (item.state === "forgotten") return "forgotten: nothing of it is sent";
+  return "";
+}