samagotchi 0.101.0 → 0.102.0

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

@@ -5,9 +5,20 @@
 // 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
+// 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
+// it), until its command_ran. On a phone's sheet a tap on a row opens its
+// action strip under it, one at a time.
+//
 // The server's projection (WorkingSet: a :working_set_updated event, a GET
 // working_set when a session's set is seeded and when the expanded view
-// opens) is one session-wide snapshot, the newer by its at kept; every form
+// opens) is one session-wide snapshot: an event always taken, a GET's
+// answer unless an event overtook it (working_set.js newerSnapshot); every form
 // overlays its state and tokens on the rows' items by key (working_set.js
 // overlay), so a state is the item's now, not then. A new snapshot redraws
 // them all: the chip, the open popover, the footprints in place and the rail
@@ -21,8 +32,8 @@ import { html, nothing, render, svg } from "./vendor/lit-html.js";
 import { createChipPopover } from "./chip_popover.js";
 import { showRow } from "./refs.js";
 import {
-  BUDGETS, fold, footprint, footprintText, GLYPHS, isFresh, itemsOfTurn, labelText, labelTitle, newerSnapshot, opsText, overlay,
-  sessionItems, stepRange, stepTag, tokensText,
+  BUDGETS, dropRefusal, fold, footprint, footprintText, GLYPHS, INVERSE, isFresh, itemsOfTurn, labelText, labelTitle, newerSnapshot,
+  opsText, overlay, parseSteerLine, pendingSteers, sessionItems, steerId, steerLine, stepRange, stepTag, tokensText,
 } from "./working_set.js";
 
 // The popover's files fold to this many lines (groups open in place, one at
@@ -83,7 +94,7 @@ export function footprintTemplate(items, ordinal) {
   const sep = html` <span class="sep">·</span> `;
   const parts = fp.labels.map((l, i) => html`${i ? sep : nothing}<span class=${`l ${l.kind}${l.state && l.state !== "live" ? ` ${l.state}` : ""}`} title=${labelTitle(l)}>${l.glyph ? html`<span class="k">${l.glyph}</span> ` : nothing}${labelText({ ...l, glyph: "" })}</span>${footTag(l)}`);
   const text = footprintText(items, BUDGETS.footprint);
-  return html`<div class="ws-foot" role="button" tabindex="0" data-ws-turn=${ordinal} data-ws-sig=${footSig(items)} aria-label=${`Working set of this turn: ${text.replace(/^touched /, "")}. Open the list.`}><span class="w">touched</span> ${parts}${fp.tail ? html`${sep}<span class="w">${fp.tail}</span>` : nothing}${fp.edited ? html`${sep}<span class="e">edited ${fp.edited}</span>` : nothing}${fp.forgotten ? html`${sep}<span class="f">${fp.forgotten} forgotten</span>` : nothing}</div>`;
+  return html`<div class="ws-foot" role="button" tabindex="0" data-ws-turn=${ordinal} data-ws-sig=${footSig(items)} aria-label=${`Working set of this turn: ${text.replace(/^touched /, "")}. Open the list.`}><span class="w">touched</span> ${parts}${fp.tail ? html`${sep}<span class="w">${fp.tail}</span>` : nothing}${fp.edited ? html`${sep}<span class="e">edited ${fp.edited}</span>` : nothing}${fp.forgotten ? html`${sep}<span class="f">${fp.forgotten} forgotten</span>` : nothing}${fp.dropped ? html`${sep}<span class="f">${fp.dropped} dropped</span>` : nothing}</div>`;
 }
 
 // What a footprint shows that can change after it is drawn: its items'
@@ -122,7 +133,10 @@ function memberName(item, group) {
 // +infoEl+: the session bar's line (the chip's popover is delegated there);
 // +onChange()+: the chip's count or dot changed (app.js updateInfoBar).
 // +getWorkingSet(id)+: the server's projection (data.js; null: none asked).
-export function createWorkingSet({ historyEl, stageRoot = () => null, state, session = () => null, infoEl, onChange = () => {}, getWorkingSet = null, doc = document }) {
+// +sendLine(line)+: posts a steer line as the session's command (null: no
+// steering, the list reads only).
+export function createWorkingSet({ historyEl, stageRoot = () => null, state, session = () => null, infoEl, onChange = () => {}, getWorkingSet = null,
+  sendLine = null, doc = document }) {
   // The finished turns' sets ({items, prompt}), the running turn's (null:
   // none), the rail's first-sight times (its fresh cue), the session count
   // at the last open (the chip's dot).
@@ -135,9 +149,16 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
   let view = { scope: "session", turn: null };
   let openGroup = null;
   // The server's snapshot ({items, at}) and the session it is of; what
-  // redraws the rail when it changes.
+  // redraws the rail when it changes. +events+ counts the events taken, so
+  // a GET knows whether one came while it was on its way.
   let server = null;
   let serverOf = null;
+  let events = 0;
+  // The steer lines queued for after the running turn, by command id, and
+  // the session they are of; the row whose action strip is open (a sheet).
+  const queued = new Map();
+  let queuedOf = null;
+  let stripOpen = null;
   const listeners = new Set();
   const lit = (items) => overlay(items, server);
 
@@ -175,7 +196,32 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     onClose: () => { openGroup = null; onChange(); },
   });
 
-  function rowTemplate(item, { session: inSession, group = null, now }) {
+  const pending = () => pendingSteers([...queued.values()]);
+
+  // 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(" ");
+    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>`;
+  }
+
+  // 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) {
+    if (!sendLine) return { pill: nothing, buttons: nothing };
+    const op = pend.get(steerId(item));
+    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>`;
+      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 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 }) };
+  }
+
+  function rowTemplate(item, { session: inSession, group = null, now, pend = new Map() }) {
     const fresh = isFresh(seenAt(item), now);
     const tag = stepTag(item, { session: inSession });
     const words = `${opsText(item)}${fresh ? " · just now" : ""}`;
@@ -201,7 +247,15 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const edited = item.kind === "file" && item.ops.includes("edit");
     const state = item.state && item.state !== "live" ? ` ${item.state}` : "";
     const tokens = tokensText(item.tokens);
-    return html`<div class=${`ws-row ${item.kind}${fresh ? " fresh" : ""}${item.muted ? " muted" : ""}${group ? " member" : ""}${state}`}><span class="k">${glyph}</span>${nameEl}${edited ? html`<span class="e">✎</span>` : nothing}<span class="st">${words}</span>${tokens ? html`<span class="tk" title=${`about ${item.tokens} tokens of it are sent`}>${tokens}</span>` : nothing}${tagEl}</div>`;
+    const id = steerId(item);
+    const { pill, buttons } = rowActions(item, pend);
+    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>`;
+    // 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}`;
   }
 
   // A section's labels: leaves as rows, groups as an opener row and, open,
@@ -211,8 +265,11 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
       if (label.type === "leaf") return rowTemplate(label.members[0], opts);
       const open = openGroup === label.id;
       const state = label.state && label.state !== "live" ? ` ${label.state}` : "";
-      const head = html`<button type="button" class=${`ws-row ws-group-head ${label.kind}${state}`} data-ws="group" data-id=${label.id} aria-expanded=${String(open)} title=${labelTitle(label)}><span class="k">${open ? "▾" : "▸"}</span><span class="t">${label.glyph ? `${label.glyph} ` : ""}${label.text}</span>${label.count ? html`<span class="n">· ${label.count}</span>` : nothing}${label.edited ? html`<span class="e">✎${label.edited}</span>` : nothing}${label.cut ? html`<span class="c" title=${`${label.cut} forgotten`}>✂${label.cut}</span>` : nothing}<span class="chev">${open ? "close" : "open"}</span></button>`;
-      return html`${head}${open ? label.members.map((m) => rowTemplate(m, { ...opts, group: label })) : nothing}`;
+      const head = html`<button type="button" class=${`ws-row ws-group-head ${label.kind}${state}`} data-ws="group" data-id=${label.id} aria-expanded=${String(open)} title=${labelTitle(label)}><span class="k">${open ? "▾" : "▸"}</span><span class="t">${label.glyph ? `${label.glyph} ` : ""}${label.text}</span>${label.count ? html`<span class="n">· ${label.count}</span>` : nothing}${label.edited ? html`<span class="e">✎${label.edited}</span>` : nothing}${label.cut ? html`<span class="c" title=${`${label.cut} cut (forgotten or dropped)`}>✂${label.cut}</span>` : nothing}<span class="chev">${open ? "close" : "open"}</span></button>`;
+      // A group drops its members that can be, not pending already.
+      const droppable = sendLine ? label.members.filter((m) => dropRefusal(m) === "" && !opts.pend.has(steerId(m))) : [];
+      const act = droppable.length ? html`<span class="ws-act">${actButton("drop", droppable, { label: `drop ${droppable.length}`, title: "send stubs instead of their reads from the next turn's start" })}</span>` : nothing;
+      return html`<div class="ws-ghead">${head}${act}</div>${open ? label.members.map((m) => rowTemplate(m, { ...opts, group: label })) : nothing}`;
     });
   }
 
@@ -224,7 +281,8 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const files = set.items.filter((i) => i.kind === "file");
     const memories = set.items.filter((i) => i.kind === "memory");
     const urls = set.items.filter((i) => i.kind === "url");
-    const opts = { session: inSession, now };
+    const pend = pending();
+    const opts = { session: inSession, now, pend };
     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;
@@ -238,7 +296,8 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
       ${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}
-      <div class="ctx-pop-meta ws-hint">A file opens its ref; a step tag goes to the call. Esc closes.</div>`;
+      ${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>`;
     render(tpl, popover.pop);
   }
 
@@ -267,10 +326,37 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     return [turn, step, row].every(Number.isInteger) ? { turn, step, row } : null;
   };
 
+  // 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 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(() => {});
+  }
+
   popover.pop.addEventListener("click", (e) => {
     const act = e.target.closest("[data-ws]");
+    // A sheet's row: a tap outside its links and buttons opens its strip.
+    if (!act && popover.pop.classList.contains("sheet")) {
+      const row = e.target.closest(".ws-row[data-ws-id]");
+      if (row && !e.target.closest("a, button, .ref")) {
+        stripOpen = stripOpen === row.dataset.wsId ? null : row.dataset.wsId;
+        draw();
+        popover.replace();
+      }
+      return;
+    }
     if (!act) return;
-    if (act.dataset.ws === "jump") {
+    if (act.dataset.ws === "steer") {
+      steer(act.dataset.op, act.dataset.ids.split(" ").filter(Boolean));
+    } else if (act.dataset.ws === "undo-all") {
+      const pend = pending();
+      for (const op of ["drop", "undrop"]) {
+        const ids = [...pend].filter(([, o]) => o === op).map(([id]) => id);
+        steer(INVERSE[op], ids);
+      }
+    } else if (act.dataset.ws === "jump") {
       const at = parseAt(act.dataset.at);
       if (at) jump(at);
     } else if (act.dataset.ws === "scope") {
@@ -332,9 +418,9 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
   }
 
   // A newer server snapshot redraws every form; an older one (a GET that
-  // answered after a newer event) is dropped.
-  function takeServer(snapshot) {
-    const next = newerSnapshot(server, snapshot);
+  // answered after a newer event) is dropped. +how+: newerSnapshot's.
+  function takeServer(snapshot, how) {
+    const next = newerSnapshot(server, snapshot, how);
     if (next === server) return;
     server = next;
     serverOf = session();
@@ -348,9 +434,10 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
   function fetchServer() {
     const id = session();
     if (!getWorkingSet || !id) return;
+    const asked = events;
     Promise.resolve()
       .then(() => getWorkingSet(id))
-      .then((snapshot) => { if (session() === id) takeServer(snapshot); })
+      .then((snapshot) => { if (session() === id) takeServer(snapshot, { overtaken: events !== asked }); })
       .catch(() => {});
   }
 
@@ -360,21 +447,49 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     seed(list) {
       turns = list.slice();
       live = null;
-      if (popover.isOpen()) popover.close();
-      // Another session's snapshot goes; the same session's (a resync)
-      // stays until the newer one comes.
+      // The snapshot's replay (after this) brings the queued lines again.
+      queued.clear();
+      queuedOf = session();
+      stripOpen = null;
+      // Another session's snapshot goes; the same session's (a resync, after
+      // a steer from the list) stays until the newer one comes, and so does
+      // the open list.
       if (serverOf !== session()) {
+        if (popover.isOpen()) popover.close();
         server = null;
         serverOf = session();
+      } else if (popover.isOpen()) {
+        if (view.turn !== null && view.turn >= turns.length) view = { scope: "session", turn: turns.length - 1 };
+        popover.refresh();
       }
       openedCount = sessionSet().items.length;
       refreshFootprints();
       fetchServer();
     },
     // A :working_set_updated event's set ({items, at}).
-    update(snapshot) { takeServer(snapshot); },
+    update(snapshot) {
+      events += 1;
+      takeServer(snapshot, { event: true });
+    },
     // +fn()+ runs after each new server snapshot (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.
+    commandQueued(event) {
+      if (queuedOf !== session()) {
+        queued.clear();
+        queuedOf = session();
+      }
+      if (event?.waits !== "turn_end" || !event.command_id || !parseSteerLine(event.line)) return;
+      queued.set(event.command_id, event.line);
+      changed();
+    },
+    // A command ran (or was dropped): its line is no longer pending.
+    commandRan(event) {
+      if (event?.command_id && queued.delete(event.command_id)) changed();
+    },
+    // The steer lines pending (for the specs and the rail).
+    pending: () => pending(),
     // The running turn's items (its model +turn+), its ordinal the next
     // turn's; the chip follows.
     liveItems(turn, prompt = "") {

data/lib/samagotchi/worker.rb

@@ -259,7 +259,7 @@ module Samagotchi
                                           })
       # A recap written while a continue offer waits says the turn stopped
       # unfinished (before the idle jobs start).
-      @engine.recap&.awaiting_continue = -> { @turn_flow.awaiting_continue? }
+      @engine.recap_awaiting_continue = -> { @turn_flow.awaiting_continue? }
       # The seq of the last turn's end event: a command queued before it was
       # queued while that turn ran.
       @turn_end_seq = 0
@@ -943,14 +943,17 @@ module Samagotchi
     # finishes) comes after its command_queued. The cards it shows go out at
     # once (btw's "thinking…" card), after its command_queued, which the
     # UIs draw its line at (Engine#running_anytime). Its handler reads
-    # copies (ctx.messages) and shows things through ctx only. One saves:
-    # /title, a field no turn writes, through Session#save, which takes the
-    # session's lock and writes a running turn's checkpoint (as
-    # WorkerSignals' save off the turn thread does), so the turn's own saves
-    # keep it.
+    # copies (ctx.messages) and shows things through ctx only. One that
+    # changed the session (/title, /recap off: fields no turn writes) is
+    # saved here, as a queued one is (#run_command), through Session#save,
+    # which takes the session's lock and writes a running turn's checkpoint
+    # (as WorkerSignals' save off the turn thread does), so the turn's own
+    # saves keep it.
     def start_anytime_command(command)
       @engine.spawn_anytime do
         result = command_result(command) { @engine.running_anytime { @commands.run(command.line, confirm: confirm?(command)) } }
+        # Saved before its command_ran: a client that reads the file on the reply finds it.
+        save_or_log(:command) { save_session } unless Array(result.changed).empty?
         announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed),
                                   anytime: true, confirm: result.confirm)
       rescue StandardError => e

data/lib/samagotchi/working_set.rb

@@ -39,10 +39,12 @@ module Samagotchi
     LIVE = "live"
     STALE = "stale"
     FORGOTTEN = "forgotten"
+    # Forgotten, every output of it by the user's drop (WorkingSetSteer).
+    DROPPED = "dropped"
 
     # One thing the model touched: +kind+ file|memory|url; +key+ a file's
     # absolute path (FileRef), a memory's name, a URL (whitespace
-    # collapsed); +state+ live|stale|forgotten; +tokens+ its content
+    # collapsed); +state+ live|stale|forgotten|dropped; +tokens+ its content
     # outputs as sent; +ops+ read|edit for a file, read|write for a memory,
     # read for a URL, in first-seen order; +count+ the runs that touched
     # it; +first_id+ the first one's chi id (ToolIds).
@@ -85,17 +87,47 @@ module Samagotchi
     def build(conversation, cwd:, strategy:, stat: File.method(:stat))
       conversation = Array(conversation)
       view = LLMContextView.new(strategy: strategy)
+      items = all_touches(conversation, cwd, view).group_by { |touch| [touch.kind, touch.key] }.map do |(kind, key), group|
+        item(kind, key, group, conversation, view, stat)
+      end
+      Snapshot.new(items: items, at: conversation.size)
+    end
+
+    # One content output (read, memory_read, web_fetch) of an item: its
+    # chi +id+ (ToolIds), the +index+ of the tool_response entry holding
+    # it, whether the id is +derived+ (a legacy entry's: nothing can name
+    # it) and whether the model is still +sent+ it under the strategy.
+    Output = Data.define(:id, :index, :derived, :sent)
+
+    # The content outputs of the item +kind+/+key+ (#build's identity: a
+    # file's absolute path, a memory's name, a URL), in conversation
+    # order, by the same pairing #build uses, so what acts on an item's
+    # outputs and the projection never disagree. Edit-only items have
+    # none. A memory_read of several names is one output of each.
+    # @return [Array<Output>]
+    def outputs_of(conversation, kind:, key:, strategy:, cwd:)
+      conversation = Array(conversation)
+      view = LLMContextView.new(strategy: strategy)
+      all_touches(conversation, cwd, view).filter_map do |touch|
+        next unless touch.content && touch.kind == kind && touch.key == key
+
+        ref = touch.run.ref
+        Output.new(id: ref.id, index: touch.run.index, derived: ref.derived?,
+                   sent: still_sent?(touch, conversation, view))
+      end
+    end
+
+    # Every paired run's touches, with what +view+ sends of its output.
+    def all_touches(conversation, cwd, view)
       stored = LLMContextStale.paired_runs(conversation)
-      sent = if view.none?
+      # Under none with no drop the view sends the conversation as it is.
+      messages = view.messages(conversation)
+      sent = if messages.equal?(conversation)
                {}
              else
-               LLMContextStale.paired_runs(view.messages(conversation)).to_h { |run| [run.ref.id, run.text] }
+               LLMContextStale.paired_runs(messages).to_h { |run| [run.ref.id, run.text] }
              end
-      touches = stored.flat_map { |run| touches(run, sent.fetch(run.ref.id, run.text), cwd) }
-      items = touches.group_by { |touch| [touch.kind, touch.key] }.map do |(kind, key), group|
-        item(kind, key, group, conversation, view, stat)
-      end
-      Snapshot.new(items: items, at: conversation.size)
+      stored.flat_map { |run| touches(run, sent.fetch(run.ref.id, run.text), cwd) }
     end
 
     # The items +run+ touched (none when it failed or was interrupted).
@@ -141,7 +173,7 @@ module Samagotchi
       contents = group.select(&:content)
       tokens = contents.sum { |touch| touch.sent.length / TokenUsage::CHARS_PER_TOKEN / touch.share }.ceil
       state = if contents.any? && contents.none? { |touch| still_sent?(touch, conversation, view) }
-                FORGOTTEN
+                contents.all? { |touch| dropped?(touch, conversation) } ? DROPPED : FORGOTTEN
               elsif kind == FILE && changed?(key, group.last.run, conversation, stat)
                 STALE
               else
@@ -161,11 +193,17 @@ module Samagotchi
       return true if sent == stored || sent == with_id(stored, touch.run.ref.id)
 
       edit = LLMContextEdit.on(conversation[touch.run.index])[touch.run.ref.id]
-      return true unless edit&.applied? && view.layers.include?(edit.kind)
+      return true unless edit && view.sends?(edit)
 
       edit.kind == :forget ? edit.keep? : edit.note.match?(BY_EDIT)
     end
 
+    # Whether +touch+'s output holds the user's applied drop.
+    def dropped?(touch, conversation)
+      edit = LLMContextEdit.on(conversation[touch.run.index])[touch.run.ref.id]
+      !edit.nil? && edit.kind == LLMContextEdit::DROP && edit.applied?
+    end
+
     def with_id(text, id)
       match = text.match(ToolResponse::LEAD)
       match ? "#{match[0]}[##{id}] #{match.post_match}" : nil
@@ -195,6 +233,6 @@ module Samagotchi
 
     def field(hash, key) = hash.key?(key) ? hash[key] : hash[key.to_s]
 
-    private_class_method :touches, :failed?, :found_names, :item, :still_sent?, :with_id, :changed?, :stamp_of, :field
+    private_class_method :all_touches, :touches, :failed?, :found_names, :item, :still_sent?, :dropped?, :with_id, :changed?, :stamp_of, :field
   end
 end

data/lib/samagotchi/working_set_command.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "working_set"
+require_relative "working_set_steer"
+
+module Samagotchi
+  # /working-set: with no arguments the session's working set (WorkingSet,
+  # as the web's list shows it: each item, what was done to it, its state
+  # and tokens, then the changes the next turn starts with); `drop KEY…`
+  # and `undrop KEY…` steer it (WorkingSetSteer). KEY: a path (absolute or
+  # the session's folder's), memory:NAME, a URL.
+  #
+  # An op runs between turns (mid_turn :queue: a line sent while a turn
+  # runs waits for its end), on a copy of the session's messages that
+  # replaces them, so the next turn's first request is the first with it.
+  class WorkingSetCommand
+    NAME = "/working-set"
+    USAGE = "usage: #{NAME} [drop KEY… | undrop KEY…] (KEY: a path, memory:NAME or a URL)".freeze
+    VERBS = [WorkingSetSteer::DROP, WorkingSetSteer::UNDROP].freeze
+    OP_WORDS = { WorkingSetSteer::DROP => "dropped", WorkingSetSteer::UNDROP => "undropped" }.freeze
+
+    # @param engine [Engine] #session, #working_set_strategy,
+    #   #clone_messages, #replace_messages
+    # @param save [#call] saves the session after a change
+    def initialize(engine:, save:)
+      @engine = engine
+      @save = save
+    end
+
+    # @param args [String] what follows /working-set
+    # @return [Array(String, Boolean, Symbol)] the reply, whether the
+    #   conversation changed, and :ok or :error (every key refused)
+    # @raise [ArgumentError] a line that isn't one (its message and USAGE)
+    def run(args)
+      verb, *words = args.to_s.split
+      return [listing, false, :ok] if verb.nil?
+      raise ArgumentError, USAGE unless VERBS.include?(verb) && !words.empty?
+
+      session = @engine.session or raise ArgumentError, "no session yet"
+      cwd = session.working_directory
+      strategy = @engine.working_set_strategy
+      messages = @engine.clone_messages(session.messages)
+      lines = []
+      done = 0
+      words.each do |word|
+        target = WorkingSetSteer.target(word, cwd: cwd)
+        result = if verb == WorkingSetSteer::DROP
+                   WorkingSetSteer.drop(messages, target, strategy: strategy, cwd: cwd)
+                 else
+                   sent = !WorkingSetSteer.pending?(messages, WorkingSetSteer::DROP, target)
+                   WorkingSetSteer.undrop(messages, target, strategy: strategy, cwd: cwd, sent: sent)
+                 end
+        messages = WorkingSetSteer.record!(messages, result)
+        lines << done_line(result)
+        done += 1
+      rescue WorkingSetSteer::Refused => e
+        lines << "#{verb} #{word}: #{e.message}"
+      end
+      if done.positive?
+        @engine.replace_messages(messages)
+        @save.call(session)
+      end
+      [lines.join("\n"), done.positive?, done.positive? ? :ok : :error]
+    end
+
+    # The set under the strategy the next turn runs, and the pending ops.
+    def listing
+      session = @engine.session
+      return "no session yet" unless session
+
+      messages = Array(session.messages)
+      items = WorkingSet.build(messages, cwd: session.working_directory, strategy: @engine.working_set_strategy).items
+      return "working set: empty (the files, memories and URLs the turns read show here)\n#{USAGE}" if items.empty?
+
+      rows = items.map { |item| [name(item, session.working_directory), words(item)] }
+      width = rows.map { |row, _| row.length }.max
+      lines = ["working set (#{items.size} item#{"s" unless items.size == 1}):"]
+      lines.concat(rows.map { |row, text| "  #{row.ljust(width)}  #{text}" })
+      pending = WorkingSetSteer.pending_ops(messages)
+      unless pending.empty?
+        lines << "at the next turn's start: #{pending.map { |op| "#{OP_WORDS[op["op"]]} #{op["label"]}" }.join(", ")}"
+      end
+      lines << USAGE
+      lines.join("\n")
+    end
+
+    private
+
+    def name(item, cwd)
+      case item.kind
+      when WorkingSet::FILE then WorkingSetSteer.target(item.key, cwd: cwd).label
+      when WorkingSet::MEMORY then "#{WorkingSetSteer::MEMORY_PREFIX}#{item.key}"
+      else item.key
+      end
+    end
+
+    def words(item)
+      parts = [item.ops.join(", ")]
+      parts << "×#{item.count}" if item.count > 1
+      parts << item.state unless item.state == WorkingSet::LIVE
+      parts << "~#{item.tokens} tokens" if item.tokens.positive?
+      parts.join(" · ")
+    end
+
+    def done_line(done)
+      what = "#{OP_WORDS[done.op]} #{done.target.label} (#{done.ids.join(", ")})"
+      if done.op == WorkingSetSteer::DROP
+        frees = done.freed_chars.positive? ? "frees #{WorkingSetSteer.k(done.freed_chars)}" : "frees nothing, the stubs are as long"
+        "#{what}: the next turn's first request sends the stubs (#{frees}; the server reads the " \
+          "#{WorkingSetSteer.k(done.tail_chars)} after them again)"
+      elsif done.free
+        "#{what}: its drop was never sent; nothing changes"
+      else
+        "#{what}: the next request sends it whole again (the server reads the #{WorkingSetSteer.k(done.tail_chars)} " \
+          "from it on again)"
+      end
+    end
+  end
+end