samagotchi 0.102.0 → 0.103.0

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

@@ -197,9 +197,10 @@ export function unarchiveSession(id, opts = {}) {
   return api(`/api/sessions/${encodeURIComponent(id)}/unarchive`, { method: "POST", body: JSON.stringify({}), ...opts });
 }
 
-// Deletes the session for good; the server stops a live worker first.
+// Deletes the session for good; force=true has the server stop a live
+// worker first (the page's confirm says so; without it, 409 worker_running).
 export function deleteSession(id, opts = {}) {
-  return api(`/api/sessions/${encodeURIComponent(id)}`, { method: "DELETE", ...opts });
+  return api(`/api/sessions/${encodeURIComponent(id)}?force=true`, { method: "DELETE", ...opts });
 }
 
 // One EventSource listener per handler, named by the handler's key (the

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

@@ -914,6 +914,7 @@ body.working-set .ts-live{position:relative;padding-right:264px}
 .ws-item.leave,.ws-more.leave{opacity:0;pointer-events:none}
 /* Just entered (FLASH_MS): an accent dot for the glyph and a tint; it settles (the tint fades 800 ms). */
 .ws-item.fresh{background:var(--accent-tint)}
+.ws-item.pending{outline:1px dashed var(--warn-border);outline-offset:-1px;background:var(--warn-bg)}
 .ws-item.fresh .k{font-size:0;display:flex;align-items:center;justify-content:center;height:var(--ws-line)}
 .ws-item.fresh .k::before{content:"";display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--accent);box-shadow:0 0 0 2px var(--accent-ring)}
 .ws-more{padding-left:17px;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;color:var(--text-faint);font-variant-numeric:tabular-nums}
@@ -973,7 +974,7 @@ button.ws-row:hover:not(:disabled){filter:none;background:var(--bg-hover)}
 .ws-row a.t:hover{text-decoration:underline}
 .ws-row .e{flex:none;color:var(--accent);font-weight:600}
 .ws-row .n{flex:none;color:var(--text-faint)}
-.ws-row .st{flex:none;margin-left:auto;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;color:var(--text-faint)}
+.ws-row .st{flex:0 4 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;margin-left:auto;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;color:var(--text-faint)}
 .ws-row .chev{flex:none;margin-left:auto;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;color:var(--text-faint)}
 .ws-row .ws-step{flex:none}
 .ws-row .tk,.ws-row .c{flex:none;font-family:ui-sans-serif,system-ui,sans-serif;font-size:11px;color:var(--text-faint);font-variant-numeric:tabular-nums}
@@ -981,7 +982,8 @@ 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. */
+/* Steering (drop / undrop, pin / unpin): 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; a pinned row's 📌. */
+.ws-pin{flex:none;font-size:10px;line-height:1}
 .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}}
@@ -992,9 +994,14 @@ button.ws-row:hover:not(:disabled){filter:none;background:var(--bg-hover)}
 .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)}
+/* A pending row: its pill and undo take the tokens' and the step tag's room, so the name stays readable. */
+.ws-row.pending .tk,.ws-row.pending .ws-step{display:none}
 .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-pending{display:flex;align-items:center;gap:6px;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{flex:none;margin-left:auto;white-space:nowrap;color:var(--warn-text);border-color:var(--warn-border)}
+.ws-pending-t{min-width:0}
+/* A phone's sheet: one line, the rows' pills say when. */
+.ws-popover.sheet .ws-pending-when{display:none}
 .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}
@@ -1004,6 +1011,15 @@ button.ws-row:hover:not(:disabled){filter:none;background:var(--bg-hover)}
 .ws-popover.sheet .ctx-pop-head>.ctx-pop-kind{order:3;flex:1 0 calc(100% - 30px)}
 .ws-popover.sheet .ctx-pop-head>.ws-ring{order:4}
 .ws-popover.sheet .ws-row{height:30px;line-height:30px}
+/* + add: the list's foot (a sheet's last row), one KEY typed; an added item the set doesn't hold yet is a pending row of its own. */
+.ws-add{display:flex;align-items:center;gap:6px;margin-top:8px}
+.ws-add-in{flex:1;min-width:0;height:26px;box-sizing:border-box;padding:0 8px;border:1px dashed var(--border-strong);border-radius:6px;background:transparent;color:var(--text);font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px}
+.ws-add-in::placeholder{color:var(--text-faint)}
+.ws-add-in:focus{outline:none;border-style:solid;border-color:var(--accent)}
+.ws-add .ws-act-b{line-height:22px;padding:0 10px}
+.ws-row.added .k{color:var(--warn-text);font-weight:600}
+.ws-popover.sheet .ws-add-in{height:34px;font-size:16px}
+.ws-popover.sheet .ws-add .ws-act-b{line-height:32px;padding:0 14px;font-size:12.5px;border-radius:6px}
 /* The session bar's chip, in the mem chip's place: a dot (the accent: changed since its list was last opened) and the count. */
 #infoBar .meta .ws-chip{display:inline-flex;align-items:center;gap:5px;padding:2px 7px;border:1px solid transparent;cursor:pointer;font-family:inherit;font-weight:400;white-space:nowrap;font-variant-numeric:tabular-nums}
 #infoBar .meta .ws-chip:hover:not(:disabled){filter:none;color:var(--text);border-color:var(--accent-border);background:var(--accent-bg)}

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

@@ -183,7 +183,12 @@ export function createStageFrame({ stage, scroller, status, cloud, queuedSlot, h
     reveal,
     // A new turn, or none: no height held yet.
     resetHeld: () => { held = null; },
-    // The tallest content seen is forgotten (a new turn, the cloud closed by hand).
-    forgetContent: () => { maxContent = 0; },
+    // The tallest content seen and the height held for it are forgotten (a
+    // new turn, the cloud closed by hand): the frame refits to what shows now.
+    forgetContent: () => {
+      maxContent = 0;
+      held = null;
+      fitFrame();
+    },
   };
 }

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

@@ -341,7 +341,7 @@ export function createStageView({
     if (rail) {
       const { items, ordinal } = workingSet.liveItems(turn, promptWords());
       stampRows(blockEl, turn, ordinal);
-      rail.draw(items, { ctxPct: workingSet.ctxPct() });
+      rail.draw(items, { ctxPct: workingSet.ctxPct(), pending: workingSet.pending() });
     }
     const calls = slots.ticks.length;
     // An ended turn says each thing once: its steps in the chip (the label
@@ -437,7 +437,8 @@ export function createStageView({
   function setCloud(open) {
     cloudOpen = open;
     cloudBody.hidden = !open || cloud.hidden;
-    // Closed by hand: its room isn't held at the scroller's end.
+    // Closed by hand: its room isn't held (the stage shrinks back to what
+    // shows).
     if (!open) frame.forgetContent();
     cloud.classList.toggle("open", open);
     stage.classList.toggle("cloud-open", open);

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

@@ -244,6 +244,8 @@ export function createStreamHandlers(deps) {
         state().llmContext = data.llm_context;
         updateInfoBar();
         llmContextControl.refresh();
+        // The working set's list offers pin only under forget.
+        workingSet?.strategyChanged();
       }
       // /thinking (or /model) changed the level the next turn runs at.
       if (data.thinking) {
@@ -315,7 +317,7 @@ export function createStreamHandlers(deps) {
     },
     // The server's working set (WorkingSet), at a request and at turn end;
     // ignored with web.working_set off.
-    working_set_updated: (data) => { workingSet?.update({ items: data.items, at: data.at }); },
+    working_set_updated: (data) => { workingSet?.update({ items: data.items, at: data.at, ...(data.adds ? { adds: data.adds } : {}) }); },
     context_status: (data) => {
       const current = state();
       // After /model (Engine#announce_switched_context!): the new model's

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

@@ -15,9 +15,12 @@
 // 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, 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.
+// tokens (and whether the user pinned it) by key (overlay), never its at.
+// The user steers it with `/working-set drop|undrop|pin|unpin|add|unadd KEY…`
+// lines (steerLine, addLine); one queued for after the running turn is
+// pending (pendingSteers) until its command_ran, and an add stays pending
+// until the next turn sends its note (the server's adds). Pins show only
+// under a strategy with the forget layer (forgetOn).
 
 export const FLASH_MS = 4000;
 // Labels per form: the rail's four lines, the row's and the footprint's
@@ -217,9 +220,11 @@ function serverItem(index, item) {
   return index.urls.find((it) => String(it.key).startsWith(head)) || null;
 }
 
-// +items+ with the server's state and tokens (+server+: a snapshot {items,
-// at}, or null); an item it doesn't know stays live, without tokens. New
-// objects only where something changed; never touches at, ops or count.
+// +items+ with the server's state, tokens, pinned and hasDrop (its
+// has_drop: some output holds the user's drop) (+server+: a snapshot
+// {items, at}, or null); an item it doesn't know stays live, without
+// tokens, unpinned. New objects only where something changed; never
+// touches at, ops or count.
 export function overlay(items, server) {
   if (!server) return items;
   const index = serverIndex(server);
@@ -229,8 +234,14 @@ export function overlay(items, server) {
     const tokens = found && Number.isFinite(found.tokens) ? found.tokens : undefined;
     // 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 pinned = found?.pinned === true ? true : undefined;
+    const hasDrop = found?.has_drop === true ? true : undefined;
+    if (item.state === state && item.tokens === tokens && item.serverKey === serverKey && item.pinned === pinned && item.hasDrop === hasDrop) return item;
     const next = { ...item, state };
+    if (pinned) next.pinned = true;
+    else delete next.pinned;
+    if (hasDrop) next.hasDrop = true;
+    else delete next.hasDrop;
     if (tokens === undefined) delete next.tokens;
     else next.tokens = tokens;
     if (serverKey === undefined) delete next.serverKey;
@@ -544,26 +555,33 @@ export function nextSettle(seenTimes, now, ms = FLASH_MS) {
   return next;
 }
 
-// ── steering (drop / undrop) ──────────────────────────────────────────────
+// ── steering (drop / undrop, pin / unpin) ─────────────────────────────────
 
 export const STEER_COMMAND = "/working-set";
-const STEER_LINE = /^\/working-set\s+(drop|undrop)\s+(\S.*)$/;
+const STEER_LINE = /^\/working-set\s+(drop|undrop|pin|unpin|add|unadd)\s+(\S.*)$/;
 const URL_WORD = /^[a-z][a-z0-9+.-]*:\/\//i;
-export const INVERSE = Object.freeze({ drop: "undrop", undrop: "drop" });
+export const INVERSE = Object.freeze({ drop: "undrop", undrop: "drop", pin: "unpin", unpin: "pin", add: "unadd", unadd: "add" });
+export const STEER_OPS = Object.freeze(Object.keys(INVERSE));
 
 // 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) {
+// path, relative to +dir+ (the session's folder, which the worker resolves
+// it against) when inside it, else absolute; memory:NAME; a URL (the
+// server's full one for a cut row).
+export function steerWord(item, dir = "") {
   if (item.kind === "memory") return `memory:${item.key}`;
   if (item.kind === "url") return item.serverKey || item.key;
-  return item.key;
+  const base = String(dir || "").replace(/\/+$/, "");
+  return base && item.key.startsWith(`${base}/`) ? item.key.slice(base.length + 1) : item.key;
 }
 
-// The id the page keys an item by ("file:/abs/a.rb"), from a steer word.
-function wordId(word) {
+// The id the page keys an item by ("file:/abs/a.rb"), from a steer word; a
+// relative path is +dir+'s.
+function wordId(word, dir = "") {
   if (word.startsWith("memory:")) return `memory:${word.slice("memory:".length)}`;
   if (URL_WORD.test(word)) return `url:${word}`;
-  return `file:${word}`;
+  const base = String(dir || "").replace(/\/+$/, "");
+  if (!base || word.startsWith("/")) return `file:${word}`;
+  return `file:${base}/${word.replace(/^(\.\/)+/, "")}`;
 }
 
 // An item's id as steer lines name it.
@@ -571,27 +589,62 @@ 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 line's words as the worker reads them (WorkingSetSteer.words):
+// whitespace-separated, a quoted one ("…" or '…') keeps its spaces, a
+// backslash escapes its quote or itself; an unclosed quote runs to the end.
+const WORD = /\s*(?:"((?:[^"\\]|\\.)*)"?|'((?:[^'\\]|\\.)*)'?|(\S+))/ys;
+export function steerWords(text) {
+  const words = [];
+  const source = String(text || "");
+  WORD.lastIndex = 0;
+  let m;
+  while (WORD.lastIndex < source.length && (m = WORD.exec(source))) {
+    const quoted = m[1] ?? m[2];
+    const word = quoted === undefined ? m[3] : quoted.replace(/\\(["'\\])/g, "$1");
+    if (word) words.push(word);
+  }
+  return words;
+}
+
+// +word+ as a line names it (WorkingSetSteer.quote): quoted when it has
+// whitespace or starts with a quote, else as it is.
+export function quoteWord(word) {
+  return /\s|^["']/.test(word) ? `"${word.replace(/["\\]/g, "\\$&")}"` : word;
 }
 
-// A steer line's op and ids ({op, ids}), or null for any other line.
-export function parseSteerLine(line) {
+// The line that does +op+ to +items+ ("/working-set drop lib/a.rb memory:x"),
+// a file inside +dir+ (the session's folder) by its relative path, a key
+// with spaces quoted.
+export function steerLine(op, items, dir = "") {
+  return `${STEER_COMMAND} ${op} ${items.map((item) => quoteWord(steerWord(item, dir))).join(" ")}`;
+}
+
+// A steer line's op and ids ({op, ids}), or null for any other line; a
+// relative path is +dir+'s.
+export function parseSteerLine(line, dir = "") {
   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) };
+  return { op: m[1], ids: steerWords(m[2]).map((word) => wordId(word, dir)) };
 }
 
 // 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();
+// item id: its last op ("drop", "undrop", "pin", "unpin", "add"). An op
+// followed by its inverse nets to nothing (the worker runs both, the second
+// undoing the first); a pin after a drop is the pin (it takes the pending
+// drop off), a drop after a pin is refused (the pin stays). +adds+: the ids
+// the server's snapshot says are added already (made between turns, its
+// adds), pending before any line; an unadd with no add pending is refused.
+// A relative path is +dir+'s (the session's folder).
+export function pendingSteers(lines, dir = "", adds = []) {
+  const pending = new Map(adds.map((id) => [id, "add"]));
   for (const line of lines) {
-    const parsed = parseSteerLine(line);
+    const parsed = parseSteerLine(line, dir);
     if (!parsed) continue;
     for (const id of parsed.ids) {
+      // A drop after a pending pin: the worker refuses it (unpin it first).
+      if (parsed.op === "drop" && pending.get(id) === "pin") continue;
+      // An unadd of nothing added: the worker refuses it.
+      if (parsed.op === "unadd" && pending.get(id) !== "add") continue;
       if (pending.get(id) === INVERSE[parsed.op]) pending.delete(id);
       else pending.set(id, parsed.op);
     }
@@ -601,12 +654,90 @@ export function pendingSteers(lines) {
 
 // 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).
+// server doesn't know it yet: a running call). A pinned one asks for an
+// unpin first (WorkingSetSteer::Refused's words).
 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.pinned) return "pinned by the user: unpin it first";
   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 "";
 }
+
+// Whether +item+ offers pin or unpin: one the server knows (its tokens), an
+// edit-only one too (its later reads are covered), not a muted or dropped
+// one, nor one holding a drop (undrop it first), nor a memory only preloaded.
+export function pinnable(item) {
+  if (item.muted || item.state === "dropped" || item.hasDrop) return false;
+  if (item.preloaded && !item.ops.includes("read")) return false;
+  return Number.isFinite(item.tokens);
+}
+
+// Whether the strategy an llm ctx summary names ({strategy: "stale,forget"},
+// session_state's llmContext) has the forget layer: pins mean something
+// only there.
+export function forgetOn(llmContext) {
+  return String(llmContext?.strategy || "").split(/[\s,|]+/).includes("forget");
+}
+
+// Whether +item+ offers undrop: dropped, or holding the user's drop on some
+// of its outputs (hasDrop: the rest forgotten by the model's layers, or
+// still sent).
+export function undroppable(item) {
+  return item.state === "dropped" || item.hasDrop === true;
+}
+
+// ── + add ─────────────────────────────────────────────────────────────────
+
+// The line that adds what the user typed (one KEY: a path, memory:NAME or a
+// URL; quoted when it has spaces), or null for nothing typed.
+export function addLine(text) {
+  const word = String(text || "").trim();
+  return word ? `${STEER_COMMAND} add ${quoteWord(word)}` : null;
+}
+
+// The ids (kind:key) of a server snapshot's adds (WorkingSet::Add: the
+// adds the next turn's note asks the model to read).
+export function serverAddIds(server) {
+  return (server?.adds || []).filter((a) => a && a.kind && a.key).map((a) => `${a.kind}:${a.key}`);
+}
+
+// An item for an id ("file:/abs/a.rb", "memory:x", "url:https://…") that
+// the set doesn't hold yet: a pending add's row (added), a file by its path
+// relative to +dir+ when inside it; +label+ the server's name when it has one.
+export function addedItem(id, dir = "", label = "") {
+  const at = id.indexOf(":");
+  const kind = id.slice(0, at);
+  const key = id.slice(at + 1);
+  const item = { kind, key, ops: [], at: null, count: 0, state: "live", added: true };
+  if (kind === "file") {
+    const base = String(dir || "").replace(/\/+$/, "");
+    item.path = label || (base && key.startsWith(`${base}/`) ? key.slice(base.length + 1) : key);
+    item.label = item.path;
+  } else if (kind === "url") {
+    item.url = key;
+    item.label = urlLabel(key);
+  } else {
+    item.label = key;
+  }
+  return item;
+}
+
+// The pending adds of items +items+ doesn't hold, as rows (addedItem), in
+// the order they were added; the server's labels where it has them.
+export function addedItems(pending, items, server = null, dir = "") {
+  const held = new Set(items.map(steerId));
+  const labels = new Map((server?.adds || []).map((a) => [`${a.kind}:${a.key}`, a.label]));
+  return [...pending].filter(([id, op]) => op === "add" && !held.has(id)).map(([id]) => addedItem(id, dir, labels.get(id) || ""));
+}
+
+// Whether +item+ offers refresh (an add of an item the set holds: the model
+// reads it again): stale, or forgotten without a drop of the user's (undrop
+// brings that back); one the server knows, not muted nor only preloaded.
+export function refreshable(item) {
+  if (item.muted || item.added || (item.preloaded && !item.ops.includes("read"))) return false;
+  if (!Number.isFinite(item.tokens)) return false;
+  return item.state === "stale" || (item.state === "forgotten" && item.hasDrop !== true);
+}

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

@@ -7,8 +7,31 @@
 // so nothing restarts; a fold fades the absorbed lines out in place and the
 // lines below slide up once (each line sits at its slot by a transform).
 // Collapsed (kept per browser), it is its head line only, with the newest
-// entry ticking through it.
-import { BUDGETS, ariaLabel, fold, isFresh, labelTitle, nextSettle, shown } from "./working_set.js";
+// entry ticking through it. Read-only: steering is the expanded view's; a
+// line with a pending op (a /working-set line queued for the turn's end) is
+// dashed, its title saying what applies next turn; an item added that the
+// turn's set doesn't hold is a dashed `+ name · next turn` line of its own.
+
+// A pending op's words on a line's title.
+const PENDING_WORDS = { drop: "drops", undrop: "comes back", pin: "pinned", unpin: "unpinned", add: "read again" };
+
+// The pending ops of +label+'s members (+pending+: working_set.js
+// pendingSteers' Map), as "drops next turn" words; "" when none.
+export function pendingText(label, pending) {
+  if (!pending?.size) return "";
+  const ops = [...new Set(label.members.map((m) => pending.get(steerId(m))).filter(Boolean))];
+  return ops.length ? `${ops.map((op) => PENDING_WORDS[op]).join(", ")} next turn` : "";
+}
+import { addedItems, BUDGETS, ariaLabel, fold, GLYPHS, isFresh, labelTitle, nextSettle, shown, steerId } from "./working_set.js";
+
+// The pending adds +items+ doesn't hold as lines: `+ name · next turn`.
+export function addLabels(items, pending) {
+  if (!pending?.size) return [];
+  return addedItems(pending, items).map((item) => ({
+    id: `add:${steerId(item)}`, type: "leaf", kind: item.kind, glyph: "+", text: `${GLYPHS[item.kind] ? `${GLYPHS[item.kind]} ` : ""}${item.kind === "file" ? item.path.split("/").pop() : item.label} · next turn`,
+    n: 1, edited: 0, cut: 0, state: "live", members: [], added: true,
+  }));
+}
 import { readStored, writeStored } from "./storage.js";
 import { reducedMotion } from "./stage_frame.js";
 
@@ -157,16 +180,17 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
 
   // A state (the server's: stale faded, forgotten struck) is a class and a
   // mark on the same line: it never refolds and never moves a line.
-  function fillLine(node, label, fresh) {
+  function fillLine(node, label, fresh, pend) {
     const state = label.state && label.state !== "live" ? ` ${label.state}` : "";
-    node.className = `ws-item ${label.kind}${label.type !== "leaf" ? " group" : ""}${fresh ? " fresh" : ""}${state}`;
+    node.className = `ws-item ${label.kind}${label.type !== "leaf" ? " group" : ""}${fresh ? " fresh" : ""}${state}${pend ? " pending" : ""}`;
     const [k, t, n, e, c] = node.children;
     k.textContent = label.glyph || "";
     t.textContent = label.text;
     n.textContent = label.count ? `· ${label.count}` : "";
     e.textContent = label.edited ? (label.type === "leaf" ? "✎" : `✎${label.edited}`) : "";
     c.textContent = label.type !== "leaf" && label.cut ? `✂${label.cut}` : "";
-    node.title = labelTitle(label);
+    if (label.added) node.title = "added: the model reads it at the next turn's start";
+    else node.title = pend ? `${labelTitle(label)}\n${pend}` : labelTitle(label);
   }
 
   // A line at its slot. A new line is placed before it is in the page (no
@@ -185,8 +209,9 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
   }
 
   // Draws +items+ (the running turn's, working_set.js itemsOfTurn); +ctxPct+
-  // the ring's value (null: no ring yet).
-  function draw(items, { ctxPct = null, now = Date.now() } = {}) {
+  // the ring's value (null: no ring yet); +pending+ the queued steer ops
+  // (working_set.js pendingSteers).
+  function draw(items, { ctxPct = null, now = Date.now(), pending = null } = {}) {
     // A turn joined mid-way (a reload, another tab): what is there already
     // is not new.
     for (const item of items) {
@@ -194,7 +219,8 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
       if (!seen.has(id)) seen.set(id, first ? -Infinity : now);
     }
     first = false;
-    const budget = form() === "rail" ? BUDGETS.rail : BUDGETS.row;
+    const adds = addLabels(items, pending);
+    const budget = Math.max(1, (form() === "rail" ? BUDGETS.rail : BUDGETS.row) - adds.length);
     const folded = fold(items, budget, { kept });
     kept = folded.groups;
     const view = shown(folded.labels, budget);
@@ -222,8 +248,9 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
 
     // The lines, by key: an unchanged one is left alone.
     const animate = !reducedMotion();
-    const lines = view.labels.map((label) => ({ id: label.id, label, fresh: freshOf(label) }));
+    const lines = view.labels.map((label) => ({ id: label.id, label, fresh: freshOf(label), pend: pendingText(label, pending) }));
     if (view.more) lines.push({ id: "more", more: view.more });
+    for (const label of adds) lines.push({ id: label.id, label, fresh: false, pend: "added next turn" });
     const ids = new Set(lines.map((l) => l.id));
     for (const [id, entry] of nodes) {
       if (ids.has(id)) continue;
@@ -235,7 +262,7 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
     }
     lines.forEach((line, i) => {
       let entry = nodes.get(line.id);
-      const key = JSON.stringify(line.more ? ["more", line.more] : [line.id, line.label.text, line.label.count || "", line.label.n, line.label.edited, line.label.cut || 0, line.label.state || "live", line.fresh]);
+      const key = JSON.stringify(line.more ? ["more", line.more] : [line.id, line.label.text, line.label.count || "", line.label.n, line.label.edited, line.label.cut || 0, line.label.state || "live", line.fresh, line.pend]);
       if (!entry) {
         const node = line.more ? el("div", "ws-more") : lineNode(line.label);
         entry = { node, key: null, slot: -1 };
@@ -247,14 +274,14 @@ export function createWorkingSetRail({ live, stage, onOpen, onChange }) {
       if (entry.key !== key) {
         entry.key = key;
         if (line.more) entry.node.textContent = `+ ${line.more} more`;
-        else fillLine(entry.node, line.label, line.fresh);
+        else fillLine(entry.node, line.label, line.fresh, line.pend);
       }
       if (entry.slot !== i) {
         place(entry.node, i);
         entry.slot = i;
       }
     });
-    rail.classList.toggle("empty", !items.length);
+    rail.classList.toggle("empty", !items.length && !adds.length);
     scheduleSettle(now);
   }