symbiot 0.44.1 → 0.46.0

package/adapt.mjs

@@ -0,0 +1,222 @@
+// symbiot — Adapt: Symbiot shapes itself to the person using it, with no
+// settings. It measures how they work and how they talk; the browser side reads
+// their colours from the system (ui.mjs). Every rule here is a known model, so
+// what it does can be checked rather than taken on trust:
+//
+// - Frecency: each shape's use decays with a half-life (HALF_LIFE): score =
+//   score·2^(−Δt/h) + 1 per use. Recent counts most; nothing needs a history.
+// - What comes next: a Markov chain over shape-to-shape moves, with a Dirichlet
+//   prior (Laplace smoothing, ALPHA) so a handful of moves can't swing it, and an
+//   hour-of-day profile smoothed over neighbouring hours (circular kernel).
+//   Combined as a product of experts into p, a probability per shape.
+// - How predictable they are: Shannon entropy of p, normalised to 0..1. Low
+//   entropy (habits) lets the layout adapt strongly; high entropy (scattered
+//   use) keeps it uniform and stable. Few events in all: it barely adapts yet.
+// - Size, Fitts's law: time to hit a target is a + b·log2(D/W + 1). Minimising
+//   the expected time Σ p·T over all shapes with the total area fixed gives
+//   area ∝ p (radius ∝ √p). The fixed total is conservation of mass: one
+//   droplet growing takes liquid from the others.
+// - How many to show, Hick–Hyman: choice time grows with log2(n + 1), so the
+//   shapes that cover HICK_COVER of the probability show, the rest go under
+//   "more" (always reachable, and by talking).
+// - Stability, hysteresis: a new layout replaces the shown one only when it
+//   saves at least HYSTERESIS of the expected Fitts time, and only when asked to
+//   commit (the app does that when it wakes from rest, never mid-gesture). A
+//   shape's angle is fixed once given, so spatial memory holds: adapting moves
+//   size and distance, not where things are.
+// - How they work it: talk vs click vs keyboard vs touch, each a frecency score,
+//   decides the talk band's weight, the target size floor (a finger needs more
+//   than a pointer: 48 vs 44 px) and whether focus rings stay on.
+// - How they talk, Communication Accommodation: a style profile from what they
+//   type (length, capitals, punctuation, emoji, questions vs instructions, the
+//   languages they mix in) becomes one instruction for every reply and brief:
+//   converge on their style, without copying their typos.
+//
+// Stored in ~/.config/symbiot/adapt.json, yours only.
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { CONFIG_DIR } from "./core.mjs";
+
+const ADAPT_FILE = join(CONFIG_DIR, "adapt.json");
+const MIND_FILE = join(CONFIG_DIR, "mind.json");
+const DAY = 86400000;
+const HALF_LIFE = 3 * DAY;
+const ALPHA = 1;                         // Dirichlet prior per outcome
+const EXPERT_W = { use: 1, next: 0.7, hour: 0.5 }; // product-of-experts exponents
+const HOUR_KERNEL = [0.25, 0.5, 0.25];   // weights for the hour before, the hour, the hour after
+const MIN_EVENTS = 12;                   // under this many uses, adaptation fades in
+const HICK_COVER = 0.9, HICK_MIN = 3, HICK_MAX = 7;
+const HYSTERESIS = 0.15;
+const FITTS = { a: 0.1, b: 0.15 };       // seconds; only ratios matter here
+const SHAPES = ["board", "map", "tasks", "agents", "week", "standup", "todo", "drift", "settings"];
+
+function loadAdapt(file = ADAPT_FILE) {
+  try { const d = JSON.parse(readFileSync(file, "utf8")); return { shapes: d.shapes || {}, trans: d.trans || {}, hours: d.hours || {}, modes: d.modes || {}, slots: d.slots || {}, shown: d.shown || null, events: d.events || 0 }; }
+  catch { return { shapes: {}, trans: {}, hours: {}, modes: {}, slots: {}, shown: null, events: 0 }; }
+}
+function saveAdapt(d, file = ADAPT_FILE) {
+  try { mkdirSync(CONFIG_DIR, { recursive: true }); writeFileSync(file, JSON.stringify(d), { mode: 0o600 }); try { chmodSync(file, 0o600); } catch {} return true; } catch { return false; }
+}
+
+// ---- frecency ---------------------------------------------------------------------
+const decayed = (rec, now) => (rec ? rec.s * Math.pow(2, -(now - rec.t) / HALF_LIFE) : 0);
+const bump = (rec, now) => ({ s: decayed(rec, now) + 1, t: now, n: ((rec && rec.n) || 0) + 1 });
+
+// One use of a shape: from where, how (click, talk, key or touch), when.
+function recordUse(d, shape, { from = "", via = "click", now = Date.now() } = {}) {
+  if (!shape) return d;
+  d.shapes[shape] = bump(d.shapes[shape], now);
+  if (from && from !== shape) { const row = d.trans[from] || (d.trans[from] = {}); row[shape] = (row[shape] || 0) + 1; }
+  const h = new Date(now).getHours(), hs = d.hours[shape] || (d.hours[shape] = new Array(24).fill(0)); hs[h]++;
+  if (["click", "talk", "key", "touch"].includes(via)) d.modes[via] = bump(d.modes[via], now);
+  if (!(shape in d.slots)) d.slots[shape] = Object.keys(d.slots).length;
+  d.events = (d.events || 0) + 1;
+  return d;
+}
+
+// ---- prediction -------------------------------------------------------------------
+const normalise = (xs) => { const s = xs.reduce((a, b) => a + b, 0); return s > 0 ? xs.map((x) => x / s) : xs.map(() => 1 / xs.length); };
+function predict(d, ids = SHAPES, { from = "", hour = new Date().getHours(), now = Date.now() } = {}) {
+  const K = ids.length;
+  const pUse = normalise(ids.map((id) => decayed(d.shapes[id], now) + ALPHA));
+  const row = (from && d.trans[from]) || {}, N = ids.reduce((s, id) => s + (row[id] || 0), 0);
+  const pNext = ids.map((id) => ((row[id] || 0) + ALPHA) / (N + ALPHA * K));
+  const pHour = normalise(ids.map((id) => { const hs = d.hours[id] || []; return HOUR_KERNEL.reduce((s, w, k) => s + w * (hs[(hour + k - 1 + 24) % 24] || 0), 0) + ALPHA; }));
+  const log = ids.map((_, i) => EXPERT_W.use * Math.log(pUse[i]) + EXPERT_W.next * Math.log(pNext[i]) + EXPERT_W.hour * Math.log(pHour[i]));
+  const m = Math.max(...log);
+  return normalise(log.map((x) => Math.exp(x - m)));
+}
+// Shannon entropy of p over its K outcomes, normalised to 0 (certain) .. 1 (uniform).
+function entropy(p) { const K = p.length; if (K < 2) return 0; return -p.reduce((s, x) => s + (x > 0 ? x * Math.log(x) : 0), 0) / Math.log(K); }
+// How strongly to adapt, 0..1: predictable use and enough of it.
+function adaptivity(d, p) { return (1 - entropy(p)) * Math.min(1, (d.events || 0) / MIN_EVENTS); }
+
+// ---- layout: Fitts, Hick, mass conservation ---------------------------------------
+const fittsTime = (D, W) => FITTS.a + FITTS.b * Math.log2(D / Math.max(W, 1) + 1);
+// Radii from probability under a fixed total area (area ∝ p minimises Σ p·log(D/W)),
+// clamped to [minR, maxR] with the leftover area shared again among the rest
+// (water-filling), so the total stays the budget.
+function allocate(p, { budget, minR, maxR }) {
+  let r = p.map(() => 0), free = p.map((_, i) => i), area = budget;
+  for (let pass = 0; pass < p.length && free.length; pass++) {
+    const ps = free.reduce((s, i) => s + p[i], 0) || 1, next = [];
+    for (const i of free) {
+      const ri = Math.sqrt((area * p[i] / ps) / Math.PI);
+      if (ri < minR) r[i] = minR;
+      else if (ri > maxR) r[i] = maxR;
+      else { r[i] = ri; next.push(i); }
+    }
+    if (next.length === free.length) break; // nothing clamped: done
+    area = Math.max(0, budget - p.reduce((s, _, i) => s + (next.includes(i) ? 0 : Math.PI * r[i] * r[i]), 0));
+    free = next;
+  }
+  return r;
+}
+// The shapes to show (Hick): fewest that cover HICK_COVER, within [HICK_MIN, HICK_MAX].
+function hick(ids, p) {
+  const order = ids.map((id, i) => ({ id, p: p[i] })).sort((a, b) => b.p - a.p);
+  let cum = 0; const shown = [];
+  for (const o of order) { if (shown.length >= HICK_MAX) break; if (shown.length >= HICK_MIN && cum >= HICK_COVER) break; shown.push(o.id); cum += o.p; }
+  return { shown, more: order.filter((o) => !shown.includes(o.id)).map((o) => o.id) };
+}
+// Expected Fitts time of a layout under p: [{ id, d, r }] (d, r in px).
+function expectedTime(items, pOf) { return items.reduce((s, it) => s + (pOf[it.id] || 0) * fittsTime(it.d, 2 * it.r), 0); }
+
+// The layout for these shapes: who shows, how big (radius, px) and how far from
+// the core (px), and its fixed angle. Mixed toward uniform by (1 − adaptivity),
+// then held by hysteresis unless the saving is worth it and commit is set.
+function layoutFor(d, ids = SHAPES, { from = "", now = Date.now(), hour, budget = 7 * Math.PI * 42 * 42, minR = 26, maxR = 64, near = 250, far = 400, commit = false, touch = false } = {}) {
+  const pRaw = predict(d, ids, { from, now, hour: hour ?? new Date(now).getHours() });
+  const a = adaptivity(d, pRaw), p = pRaw.map((x) => a * x + (1 - a) / ids.length);
+  const pOf = Object.fromEntries(ids.map((id, i) => [id, p[i]]));
+  const { shown, more } = hick(ids, p);
+  const floor = touch ? Math.max(minR, 34) : minR;
+  const radii = allocate(shown.map((id) => pOf[id]), { budget, minR: floor, maxR });
+  const pmax = Math.max(...shown.map((id) => pOf[id])), pmin = Math.min(...shown.map((id) => pOf[id]));
+  for (const id of ids) if (!(id in d.slots)) d.slots[id] = Object.keys(d.slots).length;
+  const items = shown.map((id, i) => ({ id, p: pOf[id], r: radii[i], d: pmax > pmin ? far - (far - near) * (pOf[id] - pmin) / (pmax - pmin) : (near + far) / 2, angle: (d.slots[id] * 2.399963) % (2 * Math.PI) })); // golden angle: slots never collide
+  let use = { items, more, at: now, touch: !!touch };
+  const prev = d.shown && d.shown.items && d.shown.items.length ? d.shown : null;
+  if (prev) {
+    const sameSet = prev.items.map((x) => x.id).sort().join() === items.map((x) => x.id).sort().join();
+    const gain = (expectedTime(prev.items, pOf) - expectedTime(items, pOf)) / Math.max(expectedTime(prev.items, pOf), 1e-9);
+    // a new input method (a finger now, not a pointer) always re-lays out: its targets must fit it
+    if (!!prev.touch === !!touch && (!commit || (sameSet && gain < HYSTERESIS))) use = prev; // not worth moving things under your hand
+  }
+  if (commit || !prev) d.shown = use;
+  return { ...use, p: pOf, adaptivity: a, entropy: entropy(pRaw), changed: use !== prev };
+}
+
+// How they work it: shares of talk / click / key / touch, from frecency.
+function modes(d, now = Date.now()) {
+  const ks = ["talk", "click", "key", "touch"], v = ks.map((k) => decayed(d.modes[k], now)), s = v.reduce((a, b) => a + b, 0);
+  const share = Object.fromEntries(ks.map((k, i) => [k, s ? v[i] / s : 0]));
+  return { ...share, talkWeight: Math.min(1, 0.35 + share.talk), touch: share.touch > 0.3, keyboard: share.key > 0.25 };
+}
+
+// ---- how they talk -----------------------------------------------------------------
+// Words that are distinctly Afrikaans (none that are also everyday English:
+// not "is", "met", "van", "op", "more"). A message counts as Afrikaans with two.
+const AFRIKAANS = new Set("die en ek jy julle ons nie baie dankie lekker uit asseblief wat hoe nou ja nee maar ook vir sal kan moet hier daar goed mooi totsiens aand dit hulle weet gaan kom".split(" "));
+// A request, however it's put: a bare verb, "i want / i need / can you / it
+// should / make sure …", with a greeting or "now / ok / so" in front.
+const IMPERATIVE = /^(?:(?:hey|hi|ok|okay|so|and|now|then|right|please)[,!.]?\s+)*(?:(?:i|we)\s+(?:want|need|would like|'d like)|can you|could you|would you|it should|make sure|let's|lets)?\s*(?:please\s+)?(add|make|fix|build|do|go|check|look|show|tell|send|close|open|set|put|take|stop|start|run|push|get|give|find|write|change|update|remove|delete|merge|bump|move|use|try|create|let|keep|raise|lower|link|ship|publish|approve|test|clean|rename|drop|turn|switch|copy|paste|install|connect|sign|watch|read|reply|draft|answer|have|be|see|know)?\b/i;
+const isRequest = (t) => { const m = t.match(IMPERATIVE); return !!(m && (m[1] || /^(?:(?:hey|hi|ok|okay|so|and|now|then|right|please)[,!.]?\s+)*(?:(?:i|we)\s+(?:want|need|would like|'d like)|can you|could you|would you|it should|make sure)/i.test(t))); };
+const EMOJI = /\p{Extended_Pictographic}/u;
+const median = (xs) => { if (!xs.length) return 0; const s = [...xs].sort((a, b) => a - b), m = s.length >> 1; return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };
+// A style profile from what they've typed; null with too little to go on.
+function styleOf(texts) {
+  const ms = (texts || []).map((t) => String(t || "").trim()).filter((t) => t.length > 1).slice(-120);
+  if (ms.length < 3) return null;
+  const share = (f) => ms.filter(f).length / ms.length;
+  const words = ms.map((t) => t.split(/\s+/).length);
+  const afrikaans = (t) => (t.toLowerCase().match(/[a-z']+/g) || []).filter((w) => AFRIKAANS.has(w)).length >= 2;
+  return {
+    samples: ms.length,
+    words: median(words),
+    lowercase: share((t) => /^[a-z]/.test(t)),
+    endsPunct: share((t) => /[.!?]$/.test(t)),
+    emoji: share((t) => EMOJI.test(t)),
+    questions: share((t) => /\?\s*$/.test(t)),
+    instructions: share(isRequest),
+    emphasis: share((t) => /[A-Z]{3,}/.test(t) || /!{2,}/.test(t)),
+    afrikaans: share(afrikaans),
+  };
+}
+// One instruction from the profile: converge on their style (accommodation),
+// never copy their typos. "" when there isn't enough to go on.
+function styleLine(st) {
+  if (!st) return "";
+  const parts = [];
+  const target = Math.round(Math.min(120, Math.max(20, st.words * 2.5)));
+  parts.push(st.words <= 12 ? `They write short (about ${Math.round(st.words)} words a message): keep replies brief, about ${target} words, the point first, no pleasantries` : `They write at length (about ${Math.round(st.words)} words): you can explain, up to about ${target} words`);
+  if (st.lowercase > 0.6 && st.endsPunct < 0.5) parts.push("their tone is casual (lowercase, little punctuation): plain and relaxed, not formal");
+  if (st.instructions > 0.4) parts.push("they mostly give instructions: act and say what you did, rather than discuss");
+  else if (st.questions > 0.4) parts.push("they mostly ask: answer directly");
+  if (st.emoji < 0.05) parts.push("no emoji"); else if (st.emoji > 0.2) parts.push("an emoji is fine where it fits");
+  if (st.emphasis > 0.08) parts.push("when they write in capitals they mean it: take it as the priority");
+  if (st.afrikaans > 0.08) parts.push("they mix in Afrikaans: understand it, keep their Afrikaans words as they are, and reply in Afrikaans only when they write a whole message in it");
+  return "Match how they talk: " + parts.join("; ") + ". Don't copy their typos.";
+}
+// The style line from everything typed to Symbiot's chats (mind.json's log).
+function userStyleLine(file = MIND_FILE) {
+  try { const d = JSON.parse(readFileSync(file, "utf8")); return styleLine(styleOf((d.log || []).filter((l) => l.role === "user").map((l) => l.text))); } catch { return ""; }
+}
+
+// ---- the app's view ------------------------------------------------------------------
+function adaptState({ from = "", commit = false, touch, now = Date.now() } = {}) {
+  const d = loadAdapt(), m = modes(d, now);
+  const layout = layoutFor(d, SHAPES, { from, now, commit, touch: touch ?? m.touch });
+  if (commit || layout.changed) saveAdapt(d);
+  let style = null; try { const md = JSON.parse(readFileSync(MIND_FILE, "utf8")); style = styleOf((md.log || []).filter((l) => l.role === "user").map((l) => l.text)); } catch {}
+  return { layout, modes: m, style, styleLine: styleLine(style), events: d.events || 0 };
+}
+function noteUse(body = {}) {
+  const shape = String(body.shape || ""), via = String(body.via || "click"), from = String(body.from || "");
+  if (!SHAPES.includes(shape)) return { error: "unknown shape" };
+  const d = recordUse(loadAdapt(), shape, { from: SHAPES.includes(from) ? from : "", via });
+  saveAdapt(d);
+  return { ok: true, events: d.events };
+}
+
+export { ADAPT_FILE, SHAPES, HALF_LIFE, HYSTERESIS, decayed, bump, recordUse, predict, entropy, adaptivity, fittsTime, allocate, hick, expectedTime, layoutFor, modes, styleOf, styleLine, userStyleLine, adaptState, noteUse, loadAdapt, saveAdapt };

package/agents.mjs

@@ -4,9 +4,11 @@
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { readFileSync, writeFileSync, mkdirSync, existsSync, openSync, writeSync, unlinkSync, readdirSync, statSync } from "node:fs";
 import { randomBytes, createHash } from "node:crypto";
 import { CONFIG_DIR, loadConfig, saveConfig, loadTasks, sameTask, taskWords, sh, hasCmd } from "./core.mjs";
+import { parseRun, lastRunText } from "./work.mjs";
 
 const HANDOFFS = []; // live registry of agents Symbiot has handed work to
 // ---- hand a repo (+ its tasks) to the user's agent — generic, settings-based
@@ -90,8 +92,34 @@ function withConnectors(tmpl, dir, file) {
   if (!isClaudeCmd(tmpl)) return tmpl;
   return claudeConnectors(dir, file).filter((c) => c.ready).reduce((cmd, c) => allowTool(cmd, c.rule), tmpl).replace(/\s+$/, "");
 }
-// For Settings → Handoff: the connectors, and whether this command's runs get them.
-function connectorsInfo(file) { return { claude: isClaudeCmd(handoffCmd()), list: claudeConnectors("", file).map(({ name, ready }) => ({ name, ready })) }; }
+// Linking a site in Symbiot (Links: Gmail, Drive…) signs Symbiot's own browser in;
+// it doesn't give Claude's runs that site's tools. Those come from Claude's own
+// connector for it (claude.ai → Settings → Connectors), passed through above. So
+// Drive, linked in both, reached runs, and Gmail, linked only in Symbiot, didn't.
+// The sites linked in Symbiot (config.linked) that Claude has connectors for, each
+// with the one it has (connector: its name, or "") and whether it's ready.
+const CLI = fileURLToPath(new URL("./index.mjs", import.meta.url));
+const LINK_CONNECTOR = { gmail: ["Gmail", /gmail/i], outlook: ["Outlook", /outlook|microsoft 365/i], gcal: ["Google Calendar", /google calendar/i], gdrive: ["Google Drive", /google drive/i], notion: ["Notion", /notion/i], slack: ["Slack", /slack/i], jira: ["Jira & Confluence", /atlassian|jira|confluence/i], linear: ["Linear", /linear/i], asana: ["Asana", /asana/i], hubspot: ["HubSpot", /hubspot/i] };
+function linkedConnectors(conns = claudeConnectors(), l = loadConfig().linked) {
+  if (!l || typeof l !== "object" || Array.isArray(l)) return [];
+  return Object.keys(l).filter((id) => LINK_CONNECTOR[id]).map((id) => {
+    const [name, re] = LINK_CONNECTOR[id], c = conns.find((x) => re.test(x.name));
+    return { id, name, connector: c ? c.name : "", ready: !!c && c.ready };
+  });
+}
+// For a run's brief: what its connectors are, and what's linked in Symbiot that
+// isn't one (no tools for it in this run). "" when nothing's linked to either.
+function connectorsLine(tmpl = handoffCmd(), file, linked) {
+  if (!isClaudeCmd(tmpl)) return "";
+  const conns = claudeConnectors("", file), ready = conns.filter((c) => c.ready), off = linkedConnectors(conns, linked).filter((x) => !x.ready);
+  const nm = (s) => s.replace(/^claude\.ai\s+/i, ""), names = off.map((x) => x.name), them = names.length > 1 ? names.slice(0, -1).join(", ") + " and " + names.at(-1) : names[0];
+  const has = ready.length ? `this run can use ${ready.map((c) => `${nm(c.name)} (\`${c.rule}__…\` tools)`).join(", ")}.` : "";
+  const not = off.length ? ` ${them} ${off.length === 1 ? "is" : "are"} linked in Symbiot but not ${off.some((x) => x.connector) ? "ready " : ""}as a Claude connector, so this run has no tools for ${off.length === 1 ? "it" : "them"}: don't say you checked ${off.length === 1 ? "it" : "them"}. What's new there is in \`node "${CLI}" watch new\`; to read more, ask the user (👤) to connect ${them} in claude.ai → Settings → Connectors.` : "";
+  return (has + not).trim();
+}
+// For Settings → Handoff: the connectors, whether this command's runs get them, and
+// the sites linked in Symbiot that aren't Claude connectors (so runs can't use them).
+function connectorsInfo(file) { const conns = claudeConnectors("", file); return { claude: isClaudeCmd(handoffCmd()), list: conns.map(({ name, ready }) => ({ name, ready })), links: linkedConnectors(conns) }; }
 const fillHandoff = (tmpl, repoPath) => tmpl.replace(/\{dir\}/g, shSingle(repoPath)).replace(/\{prompt\}/g, escDq(HANDOFF_PROMPT));
 // One agent per folder: two identical runs once started on the same repo 6s
 // apart and raced each other. The registry catches a second click in this
@@ -111,8 +139,8 @@ function runHandoff(repoPath, { force = false } = {}) {
   let opts = {}; try { opts = JSON.parse(readSymbiot(repoPath, "handoff.json")) || {}; } catch {}
   const busy = runningHandoff(repoPath); if (busy) return { busy: true, id: busy.id || "", pid: busy.pid, auto: !!busy.auto };
   releaseHeldTasks(repoPath); // held for an agent another process started, which has since exited
-  tmpl = withConnectors(tmpl, repoPath);
-  if (!force) { const w = waitingFor(repoPath); if (w) return { blocked: true, waiting: true, questions: 0, note: waitNote(w) }; }
+  tmpl = withStream(withConnectors(tmpl, repoPath));
+  if (!force) { const w = waitingFor(repoPath); if (w) { askedFor(repoPath); return { blocked: true, waiting: true, questions: 0, note: waitNote(w) }; } }
   const blocked = !force && blockedAgain(repoPath, tmpl); if (blocked) return blocked;
   try { unlinkSync(join(repoPath, ".symbiot", WAITING)); } catch {} // the step's done (or this is Start it anyway): this is the run it waited for
   const lock = join(repoPath, ".symbiot", LOCK);
@@ -153,8 +181,8 @@ function earlierRuns() {
     const busy = runningHandoff(r.path), ask = agentQuestions(r.path, r.name), wait = waitingFor(r.path);
     if (!busy && !ask.questions.length && !wait) continue;
     const log = join(r.path, ".symbiot", "agent.log"), startedAt = (busy && busy.startedAt) || Number(r.startedAt) || Date.now();
-    let tail = "", end = Date.now(); try { tail = readFileSync(log, "utf8").slice(-1200); if (!busy) end = statSync(log).mtimeMs; } catch {}
-    out.push({ id: "earlier-" + digest(r.path).slice(0, 8), name: String(r.name || r.path.split("/").pop()), path: r.path, status: busy ? "running" : "done", earlier: true, elapsed: Math.max(0, end - startedAt), exitCode: null, tail, changed: agentChanges(r.path, startedAt), ask, held: heldTasks(r.path), waiting: wait, fromHeld: false });
+    let tail = "", work = null, progress = null, end = Date.now(); try { ({ tail, work, progress } = workOf(r.path, readFileSync(log, "utf8"))); if (!busy) end = statSync(log).mtimeMs; } catch {}
+    out.push({ id: "earlier-" + digest(r.path).slice(0, 8), name: String(r.name || r.path.split("/").pop()), path: r.path, status: busy ? "running" : "done", earlier: true, elapsed: Math.max(0, end - startedAt), exitCode: null, tail, work, progress, changed: agentChanges(r.path, startedAt), ask, held: heldTasks(r.path), waiting: wait, fromHeld: false });
   }
   return out;
 }
@@ -172,6 +200,23 @@ function earlierRuns() {
 // waits for Start it now. Start it anyway (force) always goes ahead.
 const WAITING = "waiting.json";
 const yourStep = (a) => /👤/.test(String(a || ""));
+// An answer in the user's own words that says to wait is their step too: "don't
+// start another run until it's in", "hold off until I've added it", "not yet".
+// It waits on the files the question's 👤 options named (the `.env` that "it"
+// goes in), since the answer itself rarely names one. "That can wait" isn't one.
+const HOLD = [
+  /\b(?:don'?t|do not|never)\s+(?:start|run|send|launch|kick off|begin)\b/i,
+  /\b(?:another|next|new|a) (?:run|agent)\b[^.]{0,60}\b(?:until|till|unless|before)\b/i,
+  /\b(?:wait|hold(?: off| on| back)?|stop)\b[^.]{0,40}\b(?:until|till|for me to|before)\b/i,
+  /^\s*not yet\b/i,
+];
+const holdAnswer = (a) => !yourStep(a) && HOLD.some((re) => re.test(String(a || "")));
+// Asked for a run while one waits on a step of yours (a Send, a handover's
+// result): it starts by itself once the step's done, as the note says.
+function askedFor(path) {
+  const f = join(path, ".symbiot", WAITING);
+  try { const w = JSON.parse(readFileSync(f, "utf8")); if (w && !w.rerun) writeFileSync(f, JSON.stringify({ ...w, rerun: true })); } catch {}
+}
 // A step in Settings → Handoff: the note names the command as what it waits on.
 const settingsStep = (s) => /\bsettings\b|\ballow\b|\bgrant|connector/i.test(String(s || ""));
 // The command the folder's next run would get, connectors and all (runHandoff).
@@ -544,9 +589,14 @@ function answerQuestions(path, answers, opts = {}) {
     writeFileSync(join(path, ".symbiot", "ANSWERS.md"), prev.replace(/\s*$/, "\n") + rows.map((x) => `\n### ${x.q}\n${x.a}\n_answered ${day}_\n`).join(""));
   } catch (e) { return { error: "Couldn't write ANSWERS.md: " + ((e && e.message) || e) }; }
   const out = { ok: true, saved: rows.length };
-  const yours = rows.filter((x) => yourStep(x.a)).map((x) => stepText(x.a)).filter(Boolean);
+  // a "wait until…" answer: the step is the question's 👤 option (what "it" is), and its files are waited on
+  const asked = new Map(parseQuestions(readSymbiot(path, "QUESTIONS.md")).questions.map((x) => [qKey(x.q), x]));
+  const youOpts = (q) => ((asked.get(qKey(q)) || {}).options || []).filter(yourStep).map((o) => o.split("🤖")[0]);
+  const steps = rows.filter((x) => yourStep(x.a) || holdAnswer(x.a)).map((x) => yourStep(x.a) ? { step: stepText(x.a), named: x.a.split("🤖")[0] }
+    : { step: (youOpts(x.q).map(stepText)[0] || x.a).trim(), named: [x.a, ...youOpts(x.q)].join(" ") });
+  const yours = steps.map((s) => s.step).filter(Boolean);
   if (yours.length) {
-    const step = yours.join(" "), files = namedFiles(rows.filter((x) => yourStep(x.a)).map((x) => x.a.split("🤖")[0]).join(" "), path);
+    const step = yours.join(" "), files = namedFiles(steps.map((s) => s.named).join(" "), path);
     try { writeFileSync(join(path, ".symbiot", WAITING), JSON.stringify({ step, files: files.map((f) => ({ ...f, sig: fileSig(f.path) })), cmd: runCmd(path), at: Date.now(), rerun: !!opts.rerun })); } catch {}
     const on = waitOn(files.map((f) => f.name), settingsStep(step));
     out.yours = yours; if (files.length) out.waitFiles = files.map((f) => f.name);
@@ -565,13 +615,32 @@ function heldTasks(path) {
 // newest job per folder — the questions/ideas it left, any tasks held for it and
 // a step of yours it waits on. Then runs from before the app started that still
 // need you (earlierRuns).
+// A run's work, to draw: parsed from its log (work.mjs), with how far through its
+// TASKS.md it is. tail is what to show as text: what it said, for a streaming
+// run; the log's end, for another agent.
+// Claude Code in print mode (claude -p) streams each step as JSON, so the work
+// can be drawn as it happens (work.mjs). Added to a claude -p command that has no
+// output format of its own; anything else (an Orca tab, another agent) as it is.
+function withStream(cmd) {
+  const c = String(cmd || "");
+  if (!/^\s*claude\b/.test(c) || !/\s-p\b|\s--print\b/.test(c) || /--output-format\b/.test(c)) return c;
+  return c + " --output-format stream-json --verbose";
+}
+function workOf(path, log) {
+  const w = parseRun(lastRunText(log)), md = readSymbiot(path, "TASKS.md");
+  const done = (md.match(/^\s*-\s*\[x\]/gim) || []).length, total = done + (md.match(/^\s*-\s*\[ \]/gm) || []).length;
+  const tail = w.stream ? (w.final || w.said.join("\n\n") || (w.doing ? w.doing + "…" : "")) : String(log).slice(-1200);
+  const work = w.stream ? { model: w.model, doing: w.doing, steps: w.steps.slice(-16), todos: w.todos, cost: w.cost, turns: w.turns, tokens: w.tokens, tests: w.tests, files: w.files, pace: w.pace, errors: w.errors, final: w.final.slice(0, 1200), count: w.steps.length } : null;
+  return { tail, work, progress: total ? { done, total } : null };
+}
 function agentsList() {
   const seen = new Set();
   return HANDOFFS.map((e) => {
-    let tail = ""; try { tail = readFileSync(e.log, "utf8").slice(-1200); } catch {}
+    let log = ""; try { log = readFileSync(e.log, "utf8"); } catch {}
+    const { tail, work, progress } = workOf(e.path, log);
     const first = !seen.has(e.path); seen.add(e.path);
-    return { id: e.id, name: e.name, path: e.path, status: e.status, elapsed: (e.endedAt || Date.now()) - e.startedAt, exitCode: e.exitCode, tail, changed: agentChanges(e.path, e.startedAt), ask: first ? agentQuestions(e.path, e.name) : null, held: first ? heldTasks(e.path) : null, waiting: first && e.status !== "running" ? waitingFor(e.path) : null, fromHeld: !!e.fromHeld };
+    return { id: e.id, name: e.name, path: e.path, status: e.status, elapsed: (e.endedAt || Date.now()) - e.startedAt, exitCode: e.exitCode, tail, work, progress, changed: agentChanges(e.path, e.startedAt), ask: first ? agentQuestions(e.path, e.name) : null, held: first ? heldTasks(e.path) : null, waiting: first && e.status !== "running" ? waitingFor(e.path) : null, fromHeld: !!e.fromHeld };
   }).concat(earlierRuns());
 }
 
-export { HANDOFFS, HANDOFF_PROMPT, QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, shSingle, CLAUDE_CMD, ORCA_CLAUDE_CMD, handoffCmd, setHandoffCmd, grantAgent, grantRule, allowTool, claudeConnectors, withConnectors, connectorsInfo, fillHandoff, runHandoff, blockedAgain, runningHandoff, loadRuns, earlierRuns, namedFiles, waitingFor, startWaiting, writeTasks, releaseHeldTasks, startHeldTasks, detectHandoffs, orcaHandoffCmd, migrateOrcaCmd, migrateClaudeCmd, track, agentChanges, parseQuestions, suggestionTarget, skipIdea, agentQuestions, answerQuestions, agentsList };
+export { withStream, workOf, HANDOFFS, HANDOFF_PROMPT, QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, shSingle, CLAUDE_CMD, ORCA_CLAUDE_CMD, handoffCmd, setHandoffCmd, grantAgent, grantRule, allowTool, claudeConnectors, withConnectors, linkedConnectors, connectorsLine, connectorsInfo, fillHandoff, runHandoff, blockedAgain, runningHandoff, loadRuns, earlierRuns, namedFiles, waitingFor, startWaiting, writeTasks, releaseHeldTasks, startHeldTasks, detectHandoffs, orcaHandoffCmd, migrateOrcaCmd, migrateClaudeCmd, track, agentChanges, parseQuestions, suggestionTarget, skipIdea, agentQuestions, answerQuestions, agentsList };

package/core.mjs

@@ -48,7 +48,7 @@ function sameTask(a, b) {
   const x = taskWords(a), y = taskWords(b); if (!x || !y) return false;
   if (x === y) return true;
   const [s, l] = x.length < y.length ? [x, y] : [y, x];
-  return (s.split(" ").length >= 8 && l.startsWith(s + " ")) || nearTask(a, b);
+  return (s.split(" ").length >= 8 && l.startsWith(s + " ")) || nearTask(a, b) || sameAsk(a, b);
 }
 // Nearly the same task, two ways:
 // - nearly all the same words in the same order, 12+ words each ("…nothing
@@ -85,6 +85,23 @@ function nearTask(a, b) {
   for (; j < n; j++) if (y[j].name) ny = true;
   return !(nx && ny);
 }
+// The same ask in other words: "Send Jono the two asks yourself: verify
+// `X-Wa-Signature-256`…" and "Ask Jono to verify `X-Wa-Signature-256`… Also ask
+// him…". Both name exactly the same things (Jono, X-Wa-Signature-256), and most
+// of the shorter one's own words (not "the", "his", "once"; "asks" is "ask") are
+// in the other. Checked against 263 real tasks (11,770 pairs): at 0.6 it found 7
+// rewordings and nothing else; at 0.45 it took "Whole page for Gmail too" for
+// "Map the whole page … (not for Gmail)".
+const ASK = 0.6, ASK_WORDS = 8;
+const STOP = new Set(("the and but for from with are was were been its this that these those then than once each his her him she they them their you your yourself can cant not does did have has had will would should could just also there here into onto out about before after when what which who whom how why all any some more most other only own same too very again").split(" "));
+function askWords(s) { return new Set(wordsOf(s).map((x) => x.w).filter((w) => w.length > 2 && !STOP.has(w)).map((w) => w.replace(/(ing|ed|es|s)$/, ""))); }
+function sameAsk(a, b) {
+  const x = askWords(a), y = askWords(b); if (Math.min(x.size, y.size) < ASK_WORDS) return false;
+  const nx = new Set(wordsOf(a).filter((w) => w.name).map((w) => w.w)), ny = new Set(wordsOf(b).filter((w) => w.name).map((w) => w.w));
+  if (!nx.size || nx.size !== ny.size || [...nx].some((w) => !ny.has(w))) return false;
+  let both = 0; for (const w of x) if (y.has(w)) both++;
+  return both / Math.min(x.size, y.size) >= ASK;
+}
 // One of each: near-duplicates collapse into the wording that says the most.
 function uniqueTasks(texts) {
   const out = [];

package/headless.mjs

@@ -294,6 +294,14 @@ const collectJs = (whole, list = null) => `(() => { ${SCROLLER}
     const box = ${whole ? "{ x: Math.max(0, b.left + X), y: Math.max(0, b.top + Y), w: b.width, h: b.height }" : "{ x, y: y + down, w: x2 - x, h: y2 - y }"};
     const r = { label: full.slice(0, 80) || kind, kind, x: Math.round(box.x), y: Math.round(box.y), w: Math.round(box.w), h: Math.round(box.h), selector: reused ? '' : cssPath(e) };
     if (full.length > 80) r.text = full.slice(0, 400); // all of a long one (an inbox row), for Watch
+    // a chat list's row (WhatsApp's), for Watch: what only its icons say, not its text. Its
+    // unread badge ("2 unread messages"), and the ticks on a last message you sent
+    if (kind === 'row' || kind === 'menu item') {
+      const un = [...e.querySelectorAll('[aria-label]')].map((x) => clean(x.getAttribute('aria-label'))).find((s) => /\\bunread\\b/i.test(s));
+      if (un) r.unread = +(un.match(/(\\d+)\\s+unread/i) || [0, 1])[1] || 1;
+      if (e.querySelector('[data-icon^="msg-check"],[data-icon^="msg-dblcheck"],[data-icon^="msg-time"],[data-icon^="status-check"],[data-icon^="status-dblcheck"]') ||
+        [...e.querySelectorAll('[aria-label]')].some((x) => /^(read|delivered|sent|pending)$/i.test(clean(x.getAttribute('aria-label'))))) r.mine = true;
+    }
     if (e.href && /^https?:/.test(e.href)) r.href = String(e.href).slice(0, 500);
     out.push(r);
   }

package/home.mjs

@@ -0,0 +1,74 @@
+// symbiot — Home: what the liquid shows, from real data. Three kinds of droplet:
+// - only you: what no agent can do (an Approve waiting for you; an agent's open
+//   question to you), always out front;
+// - feeds: what's new on the sites you watch (watch.mjs), sized by how much;
+// - lanes: work handed between agents (lanes.mjs), the latest few.
+// The app's sections (Map, Tasks, Agents, Week…) are shaped by adapt.mjs from
+// how you use them; this is the live data around them. Home's talk goes to the
+// same Symbiot as every chat (mind.mjs converse), told what home shows.
+import { watchBoard } from "./watch.mjs";
+import { pendingReview } from "./tasks.mjs";
+import { agentsList } from "./agents.mjs";
+import { lanesState } from "./lanes.mjs";
+import { converse, actIn, actNow, taskIn } from "./mind.mjs";
+import { repoPathMap } from "./scan.mjs";
+import { resolveProvider } from "./ai.mjs";
+
+const KEEP = 15000; // the slower reads (git per repo awaiting review) are cached this long
+let cached = null;
+
+// { you: [{ kind, id, title, sub, shape }], feeds: [{ id, title, sub, count, shape }],
+//   lanes: [{ from, to, text, status }], working: n, at }
+function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
+  if (!fresh && !deps.board && cached && now - cached.at < KEEP) return cached;
+  const board = deps.board || (() => { try { return watchBoard(24, now); } catch { return { cards: [] }; } });
+  const pending = deps.pending || (() => { try { return pendingReview(); } catch { return []; } });
+  const agents = deps.agents || (() => { try { return agentsList(); } catch { return []; } });
+  const lanes = deps.lanes || (() => { try { return lanesState(); } catch { return { handoffs: [] }; } });
+  const you = [];
+  for (const r of pending()) {
+    if (!r.path || r.running) continue;
+    const n = (r.tasks || []).length, files = (r.files || []).length;
+    if (!n && !files) continue;
+    you.push({ kind: "approve", id: "approve:" + r.repo, title: `Approve ${r.repo}`, sub: `${n ? `${n} task${n > 1 ? "s" : ""} done` : "changes without a task"}${files ? ` · ${files} file${files > 1 ? "s" : ""}` : ""} · only you decide`, shape: "tasks" });
+  }
+  const list = agents(), seen = new Set();
+  for (const a of list) {
+    if (seen.has(a.path)) continue; seen.add(a.path);
+    const q = a.ask && a.ask.questions && a.ask.questions[0];
+    if (q) you.push({ kind: "ask", id: "ask:" + a.path, title: `${a.name} asks`, sub: String(q.q || "").slice(0, 90), shape: "agents" });
+  }
+  const feeds = ((board() || {}).cards || []).filter((c) => c.count > 0).map((c) => ({ id: "feed:" + c.id, title: c.name, sub: c.label, count: c.count, shape: "board" }));
+  const hs = ((lanes() || {}).handoffs || []).slice(0, 5).map((h) => ({ from: h.from, to: h.to, text: h.text, status: h.status }));
+  const working = list.filter((a) => a.status === "running").length;
+  const out = { you: you.slice(0, 6), feeds: feeds.slice(0, 6), lanes: hs, working, at: now };
+  if (!deps.board) cached = out;
+  return out;
+}
+
+// One line per thing home shows, for the talk's context.
+function homeContext(h) {
+  return [
+    `Only the user can do (${h.you.length}):`, ...h.you.map((y) => `- ${y.title}: ${y.sub}`),
+    `New on what they watch:`, ...(h.feeds.length ? h.feeds.map((f) => `- ${f.title}: ${f.sub}`) : ["- nothing new"]),
+    `Agents working: ${h.working}. Recent handovers:`, ...(h.lanes.length ? h.lanes.map((l) => `- ${l.from} → ${l.to}: ${l.text} (${l.status})`) : ["- none"]),
+  ].join("\n");
+}
+
+// Home's talk: the same Symbiot, acting in the right lane (mind.mjs actIn/actNow).
+async function homeAsk(question, { ask, now = Date.now(), state } = {}) {
+  question = String(question || "").trim().slice(0, 2000);
+  if (!question) return { error: "empty" };
+  if (!ask && !resolveProvider()) return { error: "not-connected" };
+  const h = state || homeState({ now });
+  let map = {}; try { map = repoPathMap(); } catch {}
+  const role = "Here they're on Symbiot's home: one liquid surface that shows what only they can do, what's new on what they watch, and the lanes. Answer from what it shows, and act on what they ask.";
+  const r = await converse({ where: "Home", role, context: homeContext(h), question, map, now, ...(ask ? { ask } : {}),
+    act: {
+      agent: (req, known, repo) => (repo ? actIn(req, repo, { map, known, title: "Home" }) : actNow(req, { title: "Home", known })),
+      task: (text, repo) => taskIn(text, repo, { map }),
+    } });
+  return { answer: r.reply, ...(r.did ? { did: r.did } : {}), steps: r.steps || [] };
+}
+
+export { homeState, homeContext, homeAsk };

package/lanes.mjs

@@ -19,10 +19,11 @@ import { join, basename } from "node:path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, chmodSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { CONFIG_DIR, loadTasks } from "./core.mjs";
-import { runHandoff, runningHandoff } from "./agents.mjs";
+import { runHandoff, runningHandoff, waitingFor } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
 import { actNow } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
+import { parseRun, lastRunText } from "./work.mjs";
 import { OPS, parseHandoffs } from "./handover.mjs";
 
 const LEDGER = join(CONFIG_DIR, "lanes.json");
@@ -83,7 +84,8 @@ function dispatch(path, { map = repoPathMap(), act = actNow, run = runHandoff, a
 // What an agent said last: its log after the newest run's header.
 function lastWords(path) {
   const log = readSym(path, "agent.log"), at = log.lastIndexOf("\n=== "); if (at < 0) return "";
-  const run = log.slice(at).split("\n").slice(3).join("\n").trim(); // past the header and the command
+  const w = parseRun(lastRunText(log)); // a streaming run: its final answer, not its JSON
+  const run = w.stream ? (w.final || w.said.join("\n")) : log.slice(at).split("\n").slice(3).join("\n").trim(); // past the header and the command
   return run.length > TAIL ? "…" + run.slice(-TAIL) : run;
 }
 // When the newest run in a folder started (its log header), or 0.
@@ -109,14 +111,16 @@ function outcome(e, { tasks = loadTasks(), running = runningHandoff } = {}) {
 }
 // Tell the agent that asked: the result as an answer in its ANSWERS.md, then
 // start it again to carry on (unless it's still running: it reads it next time).
-function report(e, o, { run = runHandoff, running = runningHandoff, now = Date.now() } = {}) {
+// Not past a step of the user's it waits on (a key for .env, "don't start another
+// run until it's in"): that run starts by itself once the step's done.
+function report(e, o, { run = runHandoff, running = runningHandoff, waiting = waitingFor, now = Date.now() } = {}) {
   const p = e.from.path, file = join(p, ".symbiot", "ANSWERS.md");
   try {
     mkdirSync(join(p, ".symbiot"), { recursive: true });
     const had = existsSync(file) ? readFileSync(file, "utf8") : "# Answers\nAnswers to your questions, and what other lanes did with what you handed over, newest last.\n";
     writeFileSync(file, `${had.replace(/\s*$/, "")}\n\n### Handed over to ${e.to.lane}: ${firstLine(e.text).slice(0, 120)}\n${o.text}\n_answered by symbiot (handover) ${new Date(now).toISOString().slice(0, 10)}_\n`);
   } catch { return false; }
-  if (!running(p)) run(p, { force: true });
+  if (!running(p)) run(p, { force: !waiting(p) });
   return true;
 }
 

package/mind.mjs

@@ -26,6 +26,7 @@ import { handoffCmd, runHandoff } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
 import { repoPathMap } from "./scan.mjs";
 import { OPS, handoverRules, ONLY_YOU } from "./handover.mjs";
+import { styleOf, styleLine, userStyleLine } from "./adapt.mjs";
 
 const MIND_FILE = join(CONFIG_DIR, "mind.json");
 const ACT_DIR = join(CONFIG_DIR, "drafts"); // runs of their own, next to drafted replies
@@ -114,12 +115,14 @@ This folder isn't a repo; there's nothing to change in it but this file. Use you
 
 - **Anything hard to undo you only ask about:** closing or deleting an account, deleting data, paying or buying, sending something to someone. Find out what it would affect first (what's running, what it costs, what's in it), then stop and ask in \`.symbiot/QUESTIONS.md\` with what you found, and don't go ahead until ANSWERS.md says to.
 - Is part of it a repo's work? Hand it over (below) rather than doing it from here.
-- Need the user? Only for what no agent can do: ask in \`.symbiot/QUESTIONS.md\` (a \`## Questions\` heading, a \`### \` heading per question, then 2–4 options as \`- \` bullets).
+- Need the user? Only for what no agent can do: ask in \`.symbiot/QUESTIONS.md\` (a \`## Questions\` heading, a \`### \` heading per question, then 2–4 options as \`- \` bullets).${voiceLine()}
 ${ONLY_YOU}
 - When it's done, tick the task (\`- [x]\`) and say what you did in your last message: it's what goes back to whoever asked.
 
 ${handoverRules(names, OPS).join("\n")}`;
 }
+// How to write to the user, for a brief: their talking style, if it's known.
+const voiceLine = () => { const v = userStyleLine(); return v ? "\n- Writing to the user (questions, your last message): " + v : ""; };
 // Run the coding agent on a request, in a folder of its own (it shows in the
 // Agents tab, with its questions). { ok, job, dir } or { error }.
 function actNow(request, { title, context, known, run = runHandoff, now = Date.now() } = {}) {
@@ -187,9 +190,16 @@ function parseReply(raw) {
 // own last turns. act: { agent(request) -> result, task(text, repo) -> result },
 // what "do" runs here. Gives { reply, did?, remembered }.
 async function converse({ where, role = "", context = "", history = "", question, act = {}, ask = write, map = null, now = Date.now() }) {
-  const d = loadMind(), known = recallText(recall(question, now, d)), elsewhere = lately(where, d);
+  const d = loadMind(), hits = recall(question, now, d), known = recallText(hits), elsewhere = lately(where, d);
+  // what it did to answer, to show under the reply (as the app shows an agent's work)
+  const steps = [];
+  if (hits.length) steps.push(`recalled ${hits.length === 1 ? hits[0].name : hits.length + " things: " + hits.slice(0, 3).map((h) => h.name).join(", ")}`);
+  const places = [...new Set(d.log.filter((l) => l.where !== where).slice(-6).map((l) => l.where))];
+  if (places.length) steps.push(`picked up what you said on ${places.slice(0, 2).join(" and ")}`);
   let lanes = map; if (!lanes) { try { lanes = repoPathMap(); } catch { lanes = {}; } }
-  const system = `${IDENTITY} ${role}\n\n${rulesFor(Object.keys(lanes), selfLane(lanes))}`;
+  // how they talk, from what they've typed into any chat (adapt.mjs: accommodation)
+  const voice = styleLine(styleOf(d.log.filter((l) => l.role === "user").map((l) => l.text).concat(question)));
+  const system = `${IDENTITY} ${role}\n\n${rulesFor(Object.keys(lanes), selfLane(lanes))}${voice ? "\n" + voice : ""}`;
   const prompt = (known ? `What you know (from across the app):\n${known}\n\n` : "") + (elsewhere ? `Lately, elsewhere in the app:\n${elsewhere}\n\n` : "") +
     (context ? context + "\n\n" : "") + (history ? `This chat so far:\n${history}\n\n` : "") + `They say (on ${where}): ${question}`;
   const raw = await ask(system, prompt);
@@ -214,7 +224,10 @@ async function converse({ where, role = "", context = "", history = "", question
   const d2 = loadMind(), remembered = rememberIn(d2, j.remember, where, now);
   logTurn(where, "user", question, now, d2); logTurn(where, "ai", reply, now, d2);
   saveMind(d2);
-  return { reply, ...(did ? { did } : {}), remembered };
+  if (voice) steps.push("matched how you talk");
+  if (did && !did.error) steps.push(did.kind === "agent" ? (did.lane ? `handed it to ${did.lane}'s agent` : "handed it to an agent") : did.lane ? `added a task to ${did.lane}` : "added a task");
+  if (remembered) steps.push(`remembered ${remembered} new thing${remembered > 1 ? "s" : ""}`);
+  return { reply, ...(did ? { did } : {}), remembered, steps };
 }
 // The usual "task" act, for a caller with no lanes of its own to pass.
 const addToTasks = (text, repo) => { let map = {}; try { map = repoPathMap(); } catch {} return taskIn(text, repo, { map }); };