samagotchi 0.102.0 → 0.104.0

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

@@ -5,10 +5,19 @@
 // and the step tags' jump to a call. The rail is working_set_rail.js's; the
 // rules are working_set.js's.
 //
-// Steering (P3a: drop / undrop): the list's rows and groups post
-// `/working-set drop|undrop KEY…` lines (+sendLine+, the session command
-// route). Between turns one runs at once: its command_ran re-reads the
-// conversation and the re-emitted set strikes the item `dropped`. While a
+// Steering (drop / undrop, pin / unpin, + add): the list's rows and groups post
+// `/working-set drop|undrop|pin|unpin|add KEY…` lines (+sendLine+, the session
+// command route). The list's foot (the sheet's last row) adds what the user
+// types (a path, memory:NAME or a URL); a stale or forgotten row offers
+// refresh (an add of it). An add is pending until the next turn sends its
+// note: the server's snapshot lists it (adds) between turns, a queued line
+// mid-turn; an added item the set doesn't hold yet is a `+ name` row with
+// `reads next turn` and an undo (unadd). Between turns one runs at once: its command_ran re-reads the
+// conversation and the re-emitted set strikes the item `dropped` (or marks
+// it pinned). A row offers pin only when the session's strategy has the
+// forget layer (forgetOn: pins guard against the model's forget); a pinned
+// row shows its 📌 and unpin under any strategy, since its drop waits for
+// the unpin. While a
 // turn runs it is queued: its command_queued (waits: "turn_end"; any
 // client's, and the snapshot's replay after a reload) makes it pending, a
 // dashed-warn row with a pill and an undo (the inverse line, queued after
@@ -32,8 +41,9 @@ import { html, nothing, render, svg } from "./vendor/lit-html.js";
 import { createChipPopover } from "./chip_popover.js";
 import { showRow } from "./refs.js";
 import {
-  BUDGETS, dropRefusal, fold, footprint, footprintText, GLYPHS, INVERSE, isFresh, itemsOfTurn, labelText, labelTitle, newerSnapshot,
-  opsText, overlay, parseSteerLine, pendingSteers, sessionItems, steerId, steerLine, stepRange, stepTag, tokensText,
+  addedItems, addLine, BUDGETS, dropRefusal, fold, footprint, footprintText, forgetOn, GLYPHS, INVERSE, isFresh, itemsOfTurn, labelText,
+  labelTitle, newerSnapshot, opsText, overlay, parseSteerLine, pendingSteers, pinnable, refreshable, serverAddIds, sessionItems, STEER_OPS,
+  steerId, steerLine, stepRange, stepTag, tokensText, undroppable,
 } from "./working_set.js";
 
 // The popover's files fold to this many lines (groups open in place, one at
@@ -194,38 +204,69 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
       if (opening) fetchServer();
     },
     onClose: () => { openGroup = null; onChange(); },
+    // The foot's + add (the popover's submit): one KEY as typed (quoted
+    // when it has spaces).
+    onSubmit: (form) => {
+      if (!form?.matches?.(".ws-add")) return;
+      const input = form.querySelector(".ws-add-in");
+      const line = sendLine && addLine(input?.value);
+      if (!line) return;
+      input.value = "";
+      Promise.resolve(sendLine(line)).catch(() => {});
+    },
   });
 
-  const pending = () => pendingSteers([...queued.values()]);
+  // The pending ops: the server's adds (made between turns), then the
+  // queued lines.
+  const pending = () => pendingSteers([...queued.values()], state().dir, serverAddIds(server));
+  // The pending adds the set doesn't hold yet, as rows.
+  const adding = (pend = pending()) => addedItems(pend, sessionSet().items, server, state().dir);
 
   // A steer button: +op+ on +items+ ("undo" sends the inverse of a pending op).
   function actButton(op, items, { label = op, title = "", disabled = false } = {}) {
-    const ids = items.map(steerId).join(" ");
+    // JSON: an id may hold spaces (a file under "my notes/").
+    const ids = JSON.stringify(items.map(steerId));
     return html`<button type="button" class=${`ws-act-b ${op}`} data-ws="steer" data-op=${op} data-ids=${ids} title=${title} ?disabled=${disabled}>${label}</button>`;
   }
 
+  // A pending op's pill.
+  const PILLS = { drop: "drops next turn", undrop: "back next turn", pin: "applies next turn", unpin: "applies next turn",
+    add: "reads next turn" };
+
   // What a row offers: a pending op's pill and undo, an undrop, a drop (or
-  // why not); nothing for an item no op applies to.
-  function rowActions(item, pend) {
+  // why not), a pin or an unpin; nothing for an item no op applies to.
+  function rowActions(item, pend, forget) {
     if (!sendLine) return { pill: nothing, buttons: nothing };
-    const op = pend.get(steerId(item));
+    let op = pend.get(steerId(item));
+    // A drop queued for a pinned item: the worker refuses it (unpin it
+    // first), so it isn't pending; the row offers its greyed drop.
+    if (op === "drop" && item.pinned) op = undefined;
     if (op) {
-      const pill = html`<span class="ws-pend" title="applies at the next turn's start">${op === "drop" ? "drops next turn" : "back next turn"}</span>`;
+      const when = op === "add" ? "the next turn's note asks the model to read it first" : "applies at the next turn's start";
+      const pill = html`<span class="ws-pend" title=${when}>${PILLS[op]}</span>`;
       return { pill, buttons: actButton(INVERSE[op], [item], { label: "undo", title: `take back the queued ${op}` }) };
     }
-    if (item.state === "dropped") {
-      return { pill: nothing, buttons: actButton("undrop", [item], { title: "send it whole again from the next request (a cache break)" }) };
-    }
+    const undrop = actButton("undrop", [item], { title: "send it whole again from the next request (a cache break)" });
+    // Dropped, or a drop on some reads with nothing else of it sent (the
+    // model's layers stubbed the rest): undrop is all it offers.
+    if (item.state === "dropped" || (undroppable(item) && item.state === "forgotten")) return { pill: nothing, buttons: undrop };
+    const buttons = [];
     const why = dropRefusal(item);
-    if (why === null) return { pill: nothing, buttons: nothing };
-    return { pill: nothing, buttons: actButton("drop", [item], { title: why || "send a stub instead of its reads from the next turn's start", disabled: !!why }) };
+    if (why !== null) buttons.push(actButton("drop", [item], { title: why || "send a stub instead of its reads from the next turn's start", disabled: !!why }));
+    if (item.pinned) buttons.push(actButton("unpin", [item], { title: "the model's forget_outputs may forget it again" }));
+    else if (forget && pinnable(item)) buttons.push(actButton("pin", [item], { title: "keep it from the model's forget_outputs (its later reads too)" }));
+    // A drop on some of its reads, others still sent: undrop takes it back.
+    if (undroppable(item)) buttons.push(undrop);
+    if (refreshable(item)) buttons.push(actButton("add", [item], { label: "refresh", title: "the next turn's note asks the model to read it again" }));
+    return { pill: nothing, buttons: buttons.length ? buttons : nothing };
   }
 
-  function rowTemplate(item, { session: inSession, group = null, now, pend = new Map() }) {
+  function rowTemplate(item, { session: inSession, group = null, now, pend = new Map(), forget = false }) {
     const fresh = isFresh(seenAt(item), now);
     const tag = stepTag(item, { session: inSession });
-    const words = `${opsText(item)}${fresh ? " · just now" : ""}`;
-    const glyph = item.muted ? GLYPHS.muted : fresh ? "●" : GLYPHS[item.kind] || "";
+    // An added row's words: what it is (a phone's tap on them opens its strip).
+    const words = item.added ? "added" : `${opsText(item)}${fresh ? " · just now" : ""}`;
+    const glyph = item.added ? "+" : item.muted ? GLYPHS.muted : fresh ? "●" : GLYPHS[item.kind] || "";
     const name = memberName(item, group);
     const full = item.kind === "file" ? item.path || item.key : item.kind === "url" ? item.url || item.key : item.key;
     let nameEl;
@@ -248,11 +289,12 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const state = item.state && item.state !== "live" ? ` ${item.state}` : "";
     const tokens = tokensText(item.tokens);
     const id = steerId(item);
-    const { pill, buttons } = rowActions(item, pend);
+    const { pill, buttons } = rowActions(item, pend, forget);
+    const pin = item.pinned ? html`<span class="ws-pin" title="pinned: the model's forget_outputs refuses it">📌</span>` : nothing;
     const isPending = pill !== nothing;
     const strip = stripOpen === id && buttons !== nothing;
     const open = item.kind === "file" ? html`<button type="button" class="ws-act-b open ref" data-ref-kind="file" data-ref-path=${item.ref?.path || full}>open</button>` : nothing;
-    const row = html`<div class=${`ws-row ${item.kind}${fresh ? " fresh" : ""}${item.muted ? " muted" : ""}${group ? " member" : ""}${state}${isPending ? " pending" : ""}${strip ? " strip-open" : ""}`} data-ws-id=${id}><span class="k">${glyph}</span>${nameEl}${edited ? html`<span class="e">✎</span>` : nothing}<span class="st">${words}</span>${pill}${tokens ? html`<span class="tk" title=${`about ${item.tokens} tokens of it are sent`}>${tokens}</span>` : nothing}${tagEl}${buttons !== nothing ? html`<span class="ws-act">${buttons}</span>` : nothing}</div>`;
+    const row = html`<div class=${`ws-row ${item.kind}${item.added ? " added" : ""}${fresh ? " fresh" : ""}${item.muted ? " muted" : ""}${group ? " member" : ""}${state}${isPending ? " pending" : ""}${strip ? " strip-open" : ""}`} data-ws-id=${id}><span class="k">${glyph}</span>${nameEl}${pin}${edited ? html`<span class="e">✎</span>` : nothing}<span class="st">${words}</span>${pill}${tokens ? html`<span class="tk" title=${`about ${item.tokens} tokens of it are sent`}>${tokens}</span>` : nothing}${tagEl}${buttons !== nothing ? html`<span class="ws-act">${buttons}</span>` : nothing}</div>`;
     // One template either way, so the tapped row stays the same node (a
     // click outside the popover closes it).
     return html`${row}${strip ? html`<div class="ws-strip">${buttons}${open}</div>` : nothing}`;
@@ -282,7 +324,8 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const memories = set.items.filter((i) => i.kind === "memory");
     const urls = set.items.filter((i) => i.kind === "url");
     const pend = pending();
-    const opts = { session: inSession, now, pend };
+    const forget = forgetOn(st.llmContext);
+    const opts = { session: inSession, now, pend, forget };
     const fileLabels = fold(files, POP_BUDGET).labels;
     // Memories are rows of their own; past the budget one group that opens.
     const memoryLabels = fold(memories, memories.length > POP_BUDGET ? 1 : Infinity).labels;
@@ -290,14 +333,17 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const memMeta = [`${memories.length - preloaded} used`, preloaded ? `${preloaded} preloaded` : "", set.muted.length ? `${set.muted.length} muted` : ""].filter(Boolean).join(" · ");
     const turnLabel = view.turn !== null && view.turn >= 0 ? `turn ${view.turn + 1}` : "this turn";
     const pct = Number.isFinite(st.ctxPct) ? ` · ctx ${Math.round(st.ctxPct)} %` : "";
-    const empty = !set.items.length && !set.muted.length;
+    const added = sendLine ? adding(pend) : [];
+    const empty = !set.items.length && !set.muted.length && !added.length;
     const tpl = html`<div class="ctx-pop-head"><strong>working set</strong><span class="ws-scope" role="group" aria-label="Scope"><button type="button" class=${!inSession ? "on" : ""} aria-pressed=${String(!inSession)} data-ws="scope" data-scope="turn" ?disabled=${view.turn === null || view.turn < 0}>${turnLabel}</button><button type="button" class=${inSession ? "on" : ""} aria-pressed=${String(inSession)} data-ws="scope" data-scope="session">session</button></span><span class="ctx-pop-kind">${set.items.length} item${set.items.length === 1 ? "" : "s"}${pct}</span>${ringTemplate(st.ctxPct)}<button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div>
       ${empty ? html`<div class="ctx-pop-meta">Nothing yet: the files, memories and URLs ${inSession ? "this session's turns read" : "this turn reads"} show here.</div>` : nothing}
       ${files.length ? html`<div class="ctx-pop-meta">files · ${files.length}</div>${labelsTemplate(fileLabels, opts)}` : nothing}
       ${memories.length || set.muted.length ? html`<div class="ctx-pop-meta">memories${memMeta ? ` · ${memMeta}` : ""}</div>${labelsTemplate(memoryLabels, opts)}${set.muted.map((m) => rowTemplate(m, opts))}` : nothing}
       ${urls.length ? html`<div class="ctx-pop-meta">urls · ${urls.length}</div>${labelsTemplate(fold(urls, POP_BUDGET).labels, opts)}` : nothing}
-      ${pend.size ? html`<div class="ws-pending" role="status">${pend.size} change${pend.size === 1 ? "" : "s"} pending · apply at the next turn's start · <button type="button" class="ws-act-b" data-ws="undo-all">undo all</button></div>` : nothing}
-      <div class="ctx-pop-meta ws-hint">A file opens its ref; a step tag goes to the call.${sendLine ? " Drop sends stubs instead of an item's reads from the next turn." : ""} Esc closes.</div>`;
+      ${added.length ? html`<div class="ctx-pop-meta">adding · ${added.length}</div>${added.map((it) => rowTemplate(it, opts))}` : nothing}
+      ${pend.size ? html`<div class="ws-pending" role="status"><span class="ws-pending-t">${pend.size} change${pend.size === 1 ? "" : "s"} pending<span class="ws-pending-when"> · apply at the next turn's start</span></span><button type="button" class="ws-act-b" data-ws="undo-all">undo all</button></div>` : nothing}
+      ${sendLine ? html`<form class="ws-add" data-ws="add-form"><input class="ws-add-in" type="text" name="key" placeholder="+ path, memory:NAME or URL" aria-label="Add to the working set: a path, memory:NAME or a URL" autocomplete="off" autocapitalize="off" spellcheck="false" enterkeyhint="go"><button type="submit" class="ws-act-b">add</button></form>` : nothing}
+      <div class="ctx-pop-meta ws-hint">A file opens its ref; a step tag goes to the call.${sendLine ? " Drop sends stubs instead of an item's reads from the next turn; add asks the model to read one first." : ""}${sendLine && forget ? " Pin keeps an item from the model's forget." : ""} Esc closes.</div>`;
     render(tpl, popover.pop);
   }
 
@@ -329,10 +375,10 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
   // Posts +op+ for the ids (the items' steer words, from the set).
   function steer(op, ids) {
     if (!sendLine || !ids.length) return;
-    const all = [...sessionSet().items, ...turnItems(view.turn)];
+    const all = [...sessionSet().items, ...turnItems(view.turn), ...adding()];
     const byId = new Map(all.map((it) => [steerId(it), it]));
     const items = ids.map((id) => byId.get(id)).filter(Boolean);
-    if (items.length) Promise.resolve(sendLine(steerLine(op, items))).catch(() => {});
+    if (items.length) Promise.resolve(sendLine(steerLine(op, items, state().dir))).catch(() => {});
   }
 
   popover.pop.addEventListener("click", (e) => {
@@ -349,10 +395,10 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     }
     if (!act) return;
     if (act.dataset.ws === "steer") {
-      steer(act.dataset.op, act.dataset.ids.split(" ").filter(Boolean));
+      steer(act.dataset.op, JSON.parse(act.dataset.ids || "[]"));
     } else if (act.dataset.ws === "undo-all") {
       const pend = pending();
-      for (const op of ["drop", "undrop"]) {
+      for (const op of STEER_OPS) {
         const ids = [...pend].filter(([, o]) => o === op).map(([id]) => id);
         steer(INVERSE[op], ids);
       }
@@ -398,6 +444,12 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     if (popover.isOpen()) popover.refresh();
   }
 
+  // The pending ops changed: the list and the rail's marks.
+  function pendingChanged() {
+    changed();
+    for (const fn of listeners) fn();
+  }
+
   // The footprints on the page (the history's, the hand-off's) drawn again
   // in place when their items' states changed: the same node (its focus,
   // the popover's opener), its children and label replaced.
@@ -466,12 +518,18 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
       refreshFootprints();
       fetchServer();
     },
+    // The session's strategy changed (/llm-context's command_ran): the open
+    // list redraws, its pin buttons shown only under forget (forgetOn).
+    strategyChanged() {
+      if (popover.isOpen()) popover.refresh();
+    },
     // A :working_set_updated event's set ({items, at}).
     update(snapshot) {
       events += 1;
       takeServer(snapshot, { event: true });
     },
-    // +fn()+ runs after each new server snapshot (the rail's redraw).
+    // +fn()+ runs after each new server snapshot and each change of the
+    // pending ops (the rail's redraw).
     onServer(fn) { listeners.add(fn); },
     // A command queued for after the running turn (its command_queued,
     // waits "turn_end"): a steer line is pending until its command_ran.
@@ -482,11 +540,11 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
       }
       if (event?.waits !== "turn_end" || !event.command_id || !parseSteerLine(event.line)) return;
       queued.set(event.command_id, event.line);
-      changed();
+      pendingChanged();
     },
     // A command ran (or was dropped): its line is no longer pending.
     commandRan(event) {
-      if (event?.command_id && queued.delete(event.command_id)) changed();
+      if (event?.command_id && queued.delete(event.command_id)) pendingChanged();
     },
     // The steer lines pending (for the specs and the rail).
     pending: () => pending(),

data/lib/samagotchi/web/server.rb

@@ -95,6 +95,8 @@ module Samagotchi
             puts lan_off_line(setting)
             return 0
           end
+          # The participants' grants: never served from a store others can read.
+          Grants.check_permissions!(Grants.path)
           if start(port: port, host: host, url: url, open_browser: open_browser, markdown: markdown, view: view,
                    annotate_presets: annotate_presets, editor: editor, lan: lan, working_set: working_set)
             0
@@ -102,7 +104,7 @@ module Samagotchi
             1
           end
         end
-      rescue Lan::Error => e
+      rescue Lan::Error, Grants::Insecure => e
         warn "Error: #{e.message}"
         1
       rescue Interrupt