samagotchi 0.154.1 → 0.156.0

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

@@ -0,0 +1,130 @@
+// A chi-ui picks (docs/internals/inline-widgets.md): rows of things to decide,
+// each with its options as chips, the recommended one marked and picked to
+// start with, a "+ note" per row, and one "Fill reply" that puts the picks in
+// the composer as plain text ("1: fix now (today) · D4: B"). It never sends:
+// the composer text is the widget's only way out, and the owner reads it
+// before sending. Ported from eval 0013's viewer.
+//
+// The data is P1a's normalised JSON (InlineWidgets). Its strings are the
+// model's: they go in as textContent or attributes only, never markup. The
+// picks live here, in the widget: a rewrite of the bubble starts over.
+//
+// A module of its own: static JS is cached at unversioned URLs.
+
+// What a row starts with: its recommended option picked, no note.
+export function initialPicks(rows) {
+  return (rows || []).map((r) => ({ pick: r.recommended != null ? String(r.recommended) : null, note: "" }));
+}
+
+// The reply the picks make: "id: option (note)" per picked row, " · " between
+// them; a row with no pick is left out.
+export function replyText(rows, picks) {
+  return (rows || [])
+    .map((r, k) => {
+      const { pick, note } = picks[k] || {};
+      if (!pick) return null;
+      const said = String(note ?? "").replace(/\s+/g, " ").trim();
+      return `${r.id ?? k + 1}: ${pick}${said ? ` (${said})` : ""}`;
+    })
+    .filter(Boolean)
+    .join(" · ");
+}
+
+// The composer's text with +reply+: after a draft on a line of its own, the
+// draft kept as typed.
+export function withDraft(draft, reply) {
+  const typed = String(draft ?? "").trimEnd();
+  return typed ? `${typed}\n${reply}` : reply;
+}
+
+function el(doc, tag, className, text) {
+  const node = doc.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = String(text);
+  return node;
+}
+
+function button(doc, className, text) {
+  const node = el(doc, "button", className, text);
+  node.type = "button";
+  return node;
+}
+
+// The picks as an element, for a widget host's shadow root.
+// @param fill (reply) => puts +reply+ in the composer (never sends)
+export function drawPicks(picks, { fill, doc = document }) {
+  const rows = picks.rows || [];
+  const state = initialPicks(rows);
+
+  const box = el(doc, "div", "w picks");
+  box.setAttribute("role", "group");
+  box.setAttribute("aria-label", `Picks: ${picks.title || "choices"}`);
+  const head = el(doc, "div", "w-head");
+  const count = el(doc, "span", "w-count");
+  head.append(el(doc, "span", "w-kind", "Picks"), el(doc, "span", "w-title", picks.title || ""), count);
+  const body = el(doc, "div", "w-body");
+  box.append(head, body);
+
+  const list = el(doc, "div", "wp-list");
+  const chips = rows.map((r, k) => {
+    const id = String(r.id ?? k + 1);
+    const row = el(doc, "div", "wp-row");
+    const text = el(doc, "div", "wp-text");
+    text.append(el(doc, "div", null, r.text || ""));
+    if (r.why) text.append(el(doc, "div", "wp-why", r.why));
+    const add = button(doc, "wp-addnote", "+ note");
+    add.addEventListener("click", () => {
+      const input = el(doc, "input", "wp-note");
+      input.type = "text";
+      input.placeholder = "a word for this row";
+      input.setAttribute("aria-label", `Note for ${id}`);
+      input.addEventListener("input", () => { state[k].note = input.value; });
+      add.replaceWith(input);
+      input.focus();
+    });
+    text.append(add);
+    const opts = el(doc, "div", "wp-opts");
+    opts.setAttribute("role", "group");
+    opts.setAttribute("aria-label", `Options for ${id}`);
+    const own = (r.options || []).map((option) => {
+      const o = String(option);
+      const b = button(doc, "wp-opt", o);
+      if (r.recommended != null && String(r.recommended) === o) {
+        b.append(el(doc, "span", "rec", "rec"));
+        b.title = "recommended";
+      }
+      b.addEventListener("click", () => {
+        state[k].pick = state[k].pick === o ? null : o;
+        paint();
+      });
+      opts.append(b);
+      return [o, b];
+    });
+    row.append(el(doc, "span", "wp-id", id), text, opts);
+    list.append(row);
+    return own;
+  });
+
+  const foot = el(doc, "div", "wp-foot");
+  const fillBtn = button(doc, "wp-fill", "Fill reply");
+  fillBtn.title = "Put the picks in the composer; you send it";
+  foot.append(fillBtn, el(doc, "span", "hint", "fills the composer, never sends"));
+  body.append(list, foot);
+
+  fillBtn.addEventListener("click", () => {
+    const reply = replyText(rows, state);
+    if (reply) fill(reply);
+  });
+
+  function paint() {
+    chips.forEach((own, k) => {
+      for (const [o, b] of own) b.setAttribute("aria-pressed", String(state[k].pick === o));
+    });
+    const picked = state.filter((s) => s.pick).length;
+    count.textContent = `${picked} of ${rows.length} picked`;
+    fillBtn.disabled = picked === 0;
+  }
+
+  paint();
+  return box;
+}

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

@@ -0,0 +1,230 @@
+// A chi-ui walk (docs/internals/inline-widgets.md): a scenario stepped through
+// one step at a time. On top a swimlane, one column per actor and one row per
+// step (the current, the seen and a case's target marked; a click jumps); under
+// it the step's card (the actor, what it does, "You see", the dashed "Behind
+// it"); a fork asks "Which case?" instead of Next; Back, Next and the path
+// taken, and the arrow keys while the widget has the focus. Ported from eval
+// 0013's viewer.
+//
+// The data is P1a's normalised JSON (InlineWidgets): ids are strings, every
+// next and goto names a step, round 1's branches are cases. Its strings are
+// the model's: they go in as textContent or attributes only, never markup.
+// The position lives here, in the widget: a rewrite of the bubble starts over.
+//
+// A module of its own: static JS is cached at unversioned URLs.
+
+// A case that is no condition: round 1 wrote the usual path as "always".
+export const ALWAYS = /^(always|otherwise|then|next)$/i;
+export const USUAL = "otherwise (the usual path)";
+// A step's `next: end` (InlineWidgets::END_NEXT): the walk ends there, a
+// branch that ends early.
+export const END = "end";
+
+const isAlways = (when) => ALWAYS.test(String(when ?? "").trim());
+
+// Where each step of +walk+ goes, by index.
+// - nextOf(k): the step after k when it isn't a fork: its next, else a case
+//   that is no condition, else the step below; null at the end, and at a
+//   step whose next is `end`.
+// - casesOf(k): a fork's cases, [{when, to}] (to null when the goto names no
+//   step), or null when k is no fork. A case that is no condition reads as
+//   the usual path, and a step that names a next as well offers it first when
+//   no case goes there (round 1's next + branches).
+export function walkRoutes(walk) {
+  const steps = walk?.steps || [];
+  const byId = new Map(steps.map((s, k) => [String(s.id), k]));
+  const idx = (id) => (id == null ? null : byId.get(String(id)) ?? null);
+  const casesIn = (k) => (Array.isArray(steps[k]?.cases) ? steps[k].cases : []);
+  const isFork = (k) => casesIn(k).some((c) => !isAlways(c.when));
+
+  function nextOf(k) {
+    const step = steps[k];
+    if (!step || step.next === END) return null;
+    const named = idx(step.next);
+    if (named != null) return named;
+    const always = casesIn(k).find((c) => isAlways(c.when) && idx(c.goto) != null);
+    if (always && !isFork(k)) return idx(always.goto);
+    return k + 1 < steps.length ? k + 1 : null;
+  }
+
+  function casesOf(k) {
+    if (!isFork(k)) return null;
+    const cases = casesIn(k).map((c) => ({ when: isAlways(c.when) ? USUAL : String(c.when ?? ""), to: idx(c.goto) }));
+    const named = idx(steps[k].next);
+    if (named != null && !cases.some((c) => c.to === named)) cases.unshift({ when: USUAL, to: named });
+    return cases;
+  }
+
+  return { steps, nextOf, casesOf };
+}
+
+// The swimlane's cells: one per step, in its actor's column (1-based, after
+// the number column) and its own row (after the actors' row), with a tag that
+// says where it leads when that isn't the step below: "N cases", "→ n", "end".
+export function swimlaneCells(walk, routes = walkRoutes(walk)) {
+  const actors = (walk?.actors || []).map(String);
+  const { steps, nextOf, casesOf } = routes;
+  return steps.map((s, k) => {
+    const cases = casesOf(k);
+    const next = nextOf(k);
+    let tag = null;
+    if (cases) tag = { text: `${cases.length} cases`, fork: true };
+    else if (next != null && next !== k + 1) tag = { text: `→ ${next + 1}`, fork: false };
+    else if (next == null && k < steps.length - 1) tag = { text: "end", fork: false };
+    return { k, column: Math.max(0, actors.indexOf(String(s.actor))) + 2, row: k + 2, text: String(s.does || s.sees || ""), tag };
+  });
+}
+
+// Where the walker is: the path taken (step indexes) and the steps seen.
+// next() at the end starts over.
+export function createWalker(routes) {
+  let path = [0];
+  const seen = new Set([0]);
+  return {
+    get at() { return path[path.length - 1]; },
+    get path() { return [...path]; },
+    seen: (k) => seen.has(k),
+    go(k) {
+      if (k == null || !routes.steps[k] || k === this.at) return;
+      path.push(k);
+      seen.add(k);
+    },
+    back() { if (path.length > 1) path.pop(); },
+    next() {
+      const n = routes.nextOf(this.at);
+      if (n != null) { this.go(n); return; }
+      path = [0];
+      seen.clear();
+      seen.add(0);
+    },
+  };
+}
+
+// The path's words under the card, empty before the first move.
+export function trailText(path) {
+  return path.length > 1 ? `path ${path.map((k) => k + 1).join(" → ")}` : "";
+}
+
+function el(doc, tag, className, text) {
+  const node = doc.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = String(text);
+  return node;
+}
+
+function button(doc, className, text) {
+  const node = el(doc, "button", className, text);
+  node.type = "button";
+  return node;
+}
+
+// The walk as an element, for a widget host's shadow root.
+export function drawWalk(walk, doc = document) {
+  const routes = walkRoutes(walk);
+  const { steps, nextOf, casesOf } = routes;
+  const actors = (walk.actors || []).map(String);
+  const walker = createWalker(routes);
+
+  const box = el(doc, "div", "w walk");
+  box.tabIndex = 0;
+  box.setAttribute("role", "group");
+  box.setAttribute("aria-label", `Walk: ${walk.title || "a scenario"}`);
+  const head = el(doc, "div", "w-head");
+  const count = el(doc, "span", "w-count");
+  head.append(el(doc, "span", "w-kind", "Walk"), el(doc, "span", "w-title", walk.title || ""), count);
+  const body = el(doc, "div", "w-body");
+  box.append(head, body);
+
+  const lane = el(doc, "div", "ww-swim");
+  lane.style.setProperty("--actors", String(actors.length));
+  lane.append(el(doc, "span"));
+  for (const actor of actors) lane.append(el(doc, "span", "ww-swim-actor", actor));
+  const cells = swimlaneCells(walk, routes).map((cell) => {
+    const num = el(doc, "span", "ww-swim-num", cell.k + 1);
+    num.style.gridRow = String(cell.row);
+    const node = button(doc, "ww-cell");
+    node.style.gridColumn = String(cell.column);
+    node.style.gridRow = String(cell.row);
+    node.append(el(doc, "span", "ww-cell-t", cell.text));
+    if (cell.tag) node.append(el(doc, "span", cell.tag.fork ? "ww-tag fork" : "ww-tag", cell.tag.text));
+    const s = steps[cell.k];
+    node.title = `${s.does || ""}${s.does && s.sees ? "\n" : ""}${s.sees ? `sees: ${s.sees}` : ""}`;
+    node.setAttribute("aria-label", `Step ${cell.k + 1}, ${s.actor}: ${cell.text}`);
+    node.addEventListener("click", () => { walker.go(cell.k); render(); });
+    lane.append(num, node);
+    return node;
+  });
+
+  const card = el(doc, "div", "ww-step");
+  card.setAttribute("aria-live", "polite");
+  const nav = el(doc, "div", "ww-nav");
+  const prev = button(doc, "btn", "← Back");
+  const next = button(doc, "btn primary", "Next →");
+  const trail = el(doc, "span", "ww-trail");
+  nav.append(prev, trail, next);
+  body.append(lane, card, nav);
+
+  prev.addEventListener("click", () => { walker.back(); render(); });
+  next.addEventListener("click", () => { walker.next(); render(); });
+  box.addEventListener("keydown", (e) => {
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+    if (e.key === "ArrowRight" && !next.hidden) { e.preventDefault(); next.click(); }
+    if (e.key === "ArrowLeft" && !prev.disabled) { e.preventDefault(); prev.click(); }
+  });
+
+  const peek = (k, on) => cells[k]?.classList.toggle("peek", on);
+
+  function pane(className, label, text) {
+    const node = el(doc, "div", `ww-pane ${className}`);
+    node.append(el(doc, "span", "eyebrow", label), el(doc, "span", null, text));
+    return node;
+  }
+
+  // A keyboard move can remove, hide or disable the focused button (a case,
+  // Next at a fork, Back at the start): the focus stays in the widget.
+  function render() {
+    const focused = box.getRootNode()?.activeElement;
+    const hadFocus = !!focused && box.contains(focused);
+    const k = walker.at;
+    const s = steps[k] || {};
+    card.replaceChildren();
+    const top = el(doc, "div", "ww-step-top");
+    top.append(el(doc, "span", "ww-actor", s.actor || ""), el(doc, "span", "ww-stepno", `${k + 1} / ${steps.length}`));
+    card.append(top);
+    if (s.does) card.append(el(doc, "div", "ww-does", s.does));
+    if (s.sees) card.append(pane("ww-sees", "You see", s.sees));
+    if (s.behind) card.append(pane("ww-behind", "Behind it", s.behind));
+    const cases = casesOf(k);
+    if (cases) {
+      const fork = el(doc, "div", "ww-fork");
+      fork.append(el(doc, "span", "eyebrow", "Which case?"));
+      for (const c of cases) {
+        const b = button(doc, "ww-case");
+        b.append(el(doc, "span", null, c.when), el(doc, "span", "ww-case-to", c.to != null ? `step ${c.to + 1} →` : "?"));
+        b.disabled = c.to == null;
+        b.addEventListener("click", () => { walker.go(c.to); render(); });
+        for (const [type, on] of [["mouseenter", true], ["mouseleave", false], ["focus", true], ["blur", false]]) {
+          b.addEventListener(type, () => peek(c.to, on));
+        }
+        fork.append(b);
+      }
+      card.append(fork);
+    }
+    cells.forEach((cell, j) => {
+      cell.classList.toggle("cur", j === k);
+      cell.classList.toggle("seen", walker.seen(j) && j !== k);
+      cell.classList.remove("peek");
+      if (j === k) cell.setAttribute("aria-current", "step");
+      else cell.removeAttribute("aria-current");
+    });
+    count.textContent = `step ${k + 1} of ${steps.length}`;
+    prev.disabled = walker.path.length < 2;
+    next.hidden = !!cases;
+    next.textContent = nextOf(k) == null ? "Start over" : "Next →";
+    trail.textContent = trailText(walker.path);
+    if (hadFocus && (!focused.isConnected || focused.hidden || focused.disabled)) box.focus({ preventScroll: true });
+  }
+
+  render();
+  return box;
+}

data/lib/samagotchi/web/public/widgets.css

@@ -0,0 +1,70 @@
+/* A chi-ui widget (inline_widgets.js), inside its host's shadow root: chi's :root tokens (tokens.css) reach it as inherited custom properties, so light and dark follow the page. Ported from eval 0013's viewer. At a phone's width the swimlane scrolls sideways inside the widget; the page never does. */
+:host{display:block;min-width:0}
+*{box-sizing:border-box}
+[hidden]{display:none!important}
+button{font:inherit;color:inherit;cursor:pointer;margin:0}
+button:disabled{cursor:default}
+button:focus-visible,input:focus-visible,.w:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.eyebrow{font-size:10px;letter-spacing:.06em;text-transform:uppercase;color:var(--text-muted)}
+
+/* The frame both share. The head leaves room on the right for the figure's source toggle and a code block's copy button (block_renderers.css). */
+.w{border:1px solid var(--accent-border);border-radius:10px;background:var(--bg-inset);overflow:hidden;font-size:14px;line-height:1.5;color:var(--text-2)}
+.w-head{display:flex;gap:8px;align-items:baseline;padding:8px 68px 8px 12px;border-bottom:1px solid var(--border);flex-wrap:wrap}
+.w-kind{font-size:11px;letter-spacing:.06em;text-transform:uppercase;color:var(--accent);font-weight:600}
+.w-title{font-weight:600;color:var(--text-bright);min-width:0;overflow-wrap:anywhere}
+.w-count{margin-left:auto;color:var(--text-muted);font-size:12px;font-variant-numeric:tabular-nums}
+.w-body{padding:12px;display:grid;gap:12px;min-width:0}
+
+/* walk */
+.ww-swim{display:grid;grid-template-columns:22px repeat(var(--actors,2),minmax(84px,1fr));gap:3px 6px;align-items:stretch;font-size:12px;overflow-x:auto;padding-bottom:2px}
+.ww-swim-actor{font-size:11px;letter-spacing:.06em;text-transform:uppercase;color:var(--text-muted);text-align:center;padding-bottom:2px;border-bottom:1px solid var(--border-strong);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.ww-swim-num{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-faint);font-size:11px;align-self:center;text-align:right}
+.ww-cell{display:flex;gap:6px;align-items:center;justify-content:space-between;text-align:left;min-width:0;border:1px solid var(--border);background:var(--bg-panel);border-radius:6px;padding:3px 8px;color:var(--text-3);transition:background .15s,border-color .15s}
+.ww-cell:hover{border-color:var(--border-strong)}
+.ww-cell-t{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.ww-cell.seen{border-color:var(--accent-border);color:var(--text-2)}
+.ww-cell.cur{background:var(--accent);border-color:var(--accent);color:var(--on-solid)}
+.ww-cell.peek{border-color:var(--warn);box-shadow:0 0 0 2px var(--warn-bg)}
+.ww-tag{flex:none;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:10px;color:var(--text-faint)}
+.ww-tag.fork{color:var(--warn)}
+.ww-cell.cur .ww-tag{color:var(--on-solid);opacity:.85}
+.ww-step{display:grid;gap:8px;min-height:120px;border-top:1px solid var(--border);padding-top:12px;align-content:start}
+.ww-step-top{display:flex;justify-content:space-between;align-items:baseline;gap:8px}
+.ww-actor{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--accent);font-size:12px}
+.ww-stepno{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-faint);font-size:11px}
+.ww-does{font-size:16px;color:var(--text-bright);font-weight:500;text-wrap:pretty;overflow-wrap:anywhere}
+.ww-pane{border-radius:8px;padding:8px 10px;display:grid;gap:2px;overflow-wrap:anywhere}
+.ww-sees{background:var(--bg-panel);border:1px solid var(--border);color:var(--text)}
+.ww-behind{background:transparent;border:1px dashed var(--border-strong);color:var(--text-3);font-size:13px}
+.ww-fork{display:grid;gap:6px}
+.ww-case{display:flex;gap:10px;justify-content:space-between;align-items:center;text-align:left;border:1px solid var(--border-strong);background:var(--bg-panel);border-radius:8px;padding:7px 10px;overflow-wrap:anywhere}
+.ww-case:hover:not(:disabled),.ww-case:focus-visible{border-color:var(--warn)}
+.ww-case:disabled{opacity:.5}
+.ww-case-to{flex:none;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;color:var(--warn)}
+.ww-nav{display:flex;gap:10px;align-items:center;justify-content:space-between}
+.ww-nav .btn{flex:none;border:1px solid var(--border-strong);background:var(--bg-panel);border-radius:8px;padding:4px 12px}
+.ww-nav .btn.primary{background:var(--accent);border-color:var(--accent);color:var(--on-solid)}
+.ww-nav .btn:disabled{opacity:.4}
+.ww-trail{font-size:12px;color:var(--text-faint);font-family:ui-monospace,SFMono-Regular,Menlo,monospace;overflow-wrap:anywhere;text-align:center;flex:1;min-width:0}
+@media (prefers-reduced-motion:reduce){.ww-cell{transition:none}}
+
+/* picks */
+.wp-row{display:grid;grid-template-columns:auto minmax(0,1fr) auto;gap:10px;align-items:start;padding:8px 0;border-bottom:1px solid var(--border)}
+.wp-row:first-child{padding-top:0}
+.wp-row:last-child{border-bottom:0}
+.wp-id{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;color:var(--text-muted);padding-top:2px;min-width:24px}
+.wp-text{color:var(--text);min-width:0;overflow-wrap:anywhere}
+.wp-why{color:var(--text-muted);font-size:12px}
+.wp-note{display:block;margin-top:4px;width:100%;background:var(--bg-panel);border:1px solid var(--border-strong);border-radius:6px;color:var(--text);padding:3px 6px;font:inherit;font-size:12px}
+.wp-opts{display:flex;flex-wrap:wrap;gap:4px;justify-content:flex-end;max-width:320px}
+.wp-opt{border:1px solid var(--border-strong);background:var(--bg-panel);border-radius:6px;padding:2px 10px;font-size:12px;overflow-wrap:anywhere;text-align:left}
+.wp-opt:hover{border-color:var(--accent-border)}
+.wp-opt[aria-pressed="true"]{background:var(--accent);border-color:var(--accent);color:var(--on-solid)}
+.wp-opt .rec{font-size:9px;letter-spacing:.06em;text-transform:uppercase;margin-left:5px;opacity:.75}
+.wp-addnote{background:none;border:0;color:var(--text-faint);font-size:12px;padding:2px 0}
+.wp-addnote:hover{color:var(--text-2)}
+.wp-foot{display:flex;gap:10px;align-items:center;flex-wrap:wrap}
+.wp-fill{background:var(--accent);border:1px solid var(--accent);color:var(--on-solid);border-radius:8px;padding:4px 14px}
+.wp-fill:disabled{opacity:.4}
+.hint{color:var(--text-faint);font-size:12px}
+@media (max-width:560px){.wp-row{grid-template-columns:auto minmax(0,1fr)}.wp-opts{grid-column:2;justify-content:flex-start;max-width:none}}

data/lib/samagotchi/web/session_access_routes.rb

@@ -78,14 +78,14 @@ module Samagotchi
       # 404 not_found; 400 ambiguous_id with ids (the sessions it names).
       def handle_resolve(req)
         given = req.params["id"].to_s
-        return error_response(404, "not_found", "no session #{given[0, 80]}") unless Session.valid_id?(given)
+        return session_not_found(given) unless Session.valid_id?(given)
         return participant_resolve(principal(req).grant, given) unless principal(req).owner?
 
         json_response(200, { id: session_access.resolve(given) })
       rescue Session::AmbiguousId => e
         refusal_response(400, "ambiguous_id", e, ids: e.ids)
-      rescue ArgumentError
-        error_response(404, "not_found", "no session #{given[0, 80]}")
+      rescue ArgumentError # NotFound, a file that won't load
+        session_not_found(given)
       end
 
       # GET /api/sessions/:id?brief=1: the session as a session command

data/lib/samagotchi/web/session_control.rb

@@ -47,7 +47,7 @@ module Samagotchi
 
       def handle_question_answer(req, id)
         session = @session_class.load(id, state_dir: default_state_dir) rescue nil
-        return error_response(404, "not_found", "Session not found: #{id}") unless session
+        return session_not_found(id) unless session
 
         body = parse_json(request_body(req))
         return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
@@ -239,7 +239,7 @@ module Samagotchi
         return [] if raw.nil?
 
         session_dir = image_session_dir(id)
-        return "unknown session" unless session_dir
+        return Session::NotFound.new(id).message unless session_dir
 
         ImageStore.check_refs(session_dir, raw)
       end
@@ -259,7 +259,7 @@ module Samagotchi
       # (converted, downscaled); answers the ref the turn then names.
       def handle_image_upload(req, id)
         session_dir = image_session_dir(id)
-        return error_response(404, "not_found", "unknown session") unless session_dir
+        return session_not_found(id) unless session_dir
 
         length = req.content_length.to_i
         if length > MAX_IMAGE_UPLOAD_BYTES

data/lib/samagotchi/web/session_create.rb

@@ -140,7 +140,7 @@ module Samagotchi
       end
 
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
-      # link of that session's chain (SessionManager.continue_session), in its
+      # link of that session's chain (SessionContinue.run), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
       # 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
@@ -328,11 +328,11 @@ module Samagotchi
         [level, nil]
       end
 
-      # SessionManager.continue_session, its refusals as responses: [session,
+      # SessionContinue.run, its refusals as responses: [session,
       # nil] or [nil, the response]. Only its own errors: what fails after
       # the new link started is not a refusal of it.
       def continue_from(given, prompt:, preview:, model:)
-        [@manager.continue_session(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
+        [SessionContinue.run(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
       rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : {}
         [nil, refusal_response(409, e.reason.to_s, e, session_id: e.session_id, reason: e.reason.to_s, ids: e.ids, **extra)]

data/lib/samagotchi/web/session_hub.rb

@@ -412,7 +412,7 @@ module Samagotchi
       # read is mtime-cached), so a host added or a window changed while
       # chi web runs is picked up on the next refresh of a card.
       def hub_registry
-        hosts = ConfigFile.hosts_config
+        hosts = HostConfig.all
         if @hub_registry.nil? || hosts != @hub_registry_hosts
           @hub_registry = HostRegistry.new(hosts_config: hosts)
           @hub_registry_hosts = hosts

data/lib/samagotchi/web/session_show.rb

@@ -184,7 +184,7 @@ module Samagotchi
       # cards from its light GET tail, else the saved ones; the session file
       # is only stat'ed (the 404), never parsed.
       def handle_cards_read(id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         tail = live_tail(id)
         json_response(200, { cards: cards_for_display(live_or_saved(tail, "cards") { saved_cards(id) }) })
@@ -201,7 +201,7 @@ module Samagotchi
       # are the newest turn's (#recent_timing), which the page merges by id
       # (the page still sends ?recent=1, which is accepted and not needed).
       def handle_tail_read(req, id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         turn_id = req.params["turn_id"].to_s.strip
         turn_id = nil if turn_id.empty?
@@ -259,7 +259,7 @@ module Samagotchi
       # the live ones) and turn_count, when the page's merge comes up short.
       # The worker's GET state, never its messages.
       def handle_timing_read(id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         state = bridge_get_json(id, "state")
         json_response(200, { timing: timing_payload(id, live_metrics: state && state["session_state_snapshot"]&.fetch("metrics", nil)) })

data/lib/samagotchi/web/session_summary.rb

@@ -146,13 +146,12 @@ module Samagotchi
       private_class_method :budget_resolver
 
       # status is turn state (idle/running). The live worker's snapshot is the
-      # truth; on disk, a "running" with no live owner was left by a worker
-      # that died mid-turn.
+      # truth; on disk, Session#displayed_status (a "running" with no live
+      # owner was left by a worker that died mid-turn).
       def displayed_status(session, snapshot = nil, owner:)
         return snapshot["status"] if snapshot.is_a?(Hash) && snapshot["status"]
-        return session.status unless session.status == Session::STATUS_RUNNING
 
-        owner ? session.status : Session::STATUS_IDLE
+        session.displayed_status(owner: owner)
       end
 
       def first_preview_for(session)