symbiot 0.43.0 → 0.44.0

package/README.md

@@ -67,6 +67,8 @@ Tabs:
   any tab, and once you watch something the app opens on the Dashboard instead of
   the Map. `symbiot watch board` prints the same cards as JSON, and
   `symbiot watch board --line` as one line for a status bar (`2 emails · 1 WhatsApp message`).
+  `symbiot watch chat <id> "question"` is the card's 💬 chat from a terminal, so an
+  agent can go over what's new with you too.
 - **Drift** — the [`symbiot drift`](#whats-out-of-sync-symbiot-drift) report, with
   a "fetch latest" toggle (and an [experimental](#experimental) "check CI").
 - **Week / Standup / Todo** — the write-ups (these use your chosen AI).
@@ -381,7 +383,15 @@ Reading both costs about 40 lines.
 ```
 
 Up to five questions show on that agent's block in the **Agents** tab, each with
-its options and room for your own answer, alongside its ideas. Each option says
+two options and room for your own answer, alongside its ideas, two at a time.
+Two, because most people pick the recommended option or add every idea without
+weighing them, so the agent is told to be the judge. Both options have to be good
+routes, each saying in plain words what it changes for the project, the people on
+it and the company. The recommended one has to be the best for, in that order,
+the company, the people doing the work and the goal, based on evidence the agent
+checked (git history, tests, logs). An idea that's in your Tasks leaves the list,
+and the next one moves up. **Suggest next steps** on the Map follows the same rule
+and suggests two. Each option says
 who acts: **You** (a setting, a click, a command) or **Agent** (picking it is
 enough). A question that needs a release ("Once 0.41.0 is installed: …") shows
 the version installed here and the one on npm, and holds back a "Done" answer
@@ -401,8 +411,10 @@ committed. The questions stay on the Agents tab after Symbiot restarts (or when
 the answer and reminds you the step is still yours to do. Your agent waits for it
 instead of starting straight away and asking the same thing again. If the step
 names a file in backticks (`` `.env` ``), the agent starts by itself once that
-file changes, while the app runs. Otherwise **Start it now** on that folder's
-block starts it once you've done the step.
+file changes, while the app runs. A step in Settings (**Allow command**, a
+connector) changes the agent command rather than a file, so a changed agent
+command counts as the step being done too. Otherwise **Start it now** on that
+folder's block starts it once you've done the step.
 
 **A run that stopped on questions isn't repeated for nothing.** When a run ends
 having asked questions you haven't answered, with tasks still unticked, Symbiot
@@ -496,6 +508,29 @@ can't do.
   app, so context carries from page to page without re-sending everything.
   Settings → **What Symbiot remembers** lists it, and forgets any of it.
 
+### Lanes: agents hand work to each other
+
+Each agent has its own lane: a repo, or **ops** for everything outside one (this
+computer, accounts, services, your connectors). When an agent needs something
+that's another lane's job, it doesn't stop and it doesn't ask you to do it. It
+writes it to its `.symbiot/HANDOFF.md`, under the lane's name, and Symbiot:
+
+1. starts that lane's agent on it: a repo gets it as a task, the way **Send to
+   repos** does, and ops gets a run of its own;
+2. when that agent is done, puts what it did into the asking agent's
+   `.symbiot/ANSWERS.md` and starts that agent again, so it carries on.
+
+The Agents tab lists the **Handovers**: who handed what to whom, and where it
+stands. A handover to a lane that doesn't exist, or back to the agent's own lane,
+goes back to the agent, not to you. After 4 handovers in a row, the next one isn't
+started, so two lanes can't pass the same job back and forth.
+
+What still reaches you is only what no agent can do: your body (a phone in your
+hand, a cable, which network you're on), your identity or secrets (signing in, a
+2FA code, a token from a provider's console) or a decision that's yours (closing an
+account, spending money, sending something in your name). Every brief tells the
+agent so, and such a question says which: `👤 You (only you: your Meta token): …`.
+
 ## Connect it (once)
 
 Pick the AI you want it to write with:
@@ -770,6 +805,7 @@ symbiot watch new --hours 24               # what's new, newest first (JSON)
 symbiot watch board                        # the Dashboard's cards (JSON; .total is the count, for a status bar)
 symbiot watch board --line                 # the same as one line: "2 emails · 1 WhatsApp message" (empty when nothing's new)
 symbiot watch seen <watch id>              # set a card back to 0, like its Seen button
+symbiot watch chat <watch id> "what needs me?"  # talk a card over with your AI, like its 💬 (--clear starts over)
 symbiot watch check                        # read them all now (JSON)
 symbiot watch draft <id>                   # Draft a reply to a new email or chat message (see below)
 symbiot watch brief on                     # your AI says what needs you (off to stop)

package/agents.mjs

@@ -112,9 +112,9 @@ function runHandoff(repoPath, { force = false } = {}) {
   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) { try { unlinkSync(join(repoPath, ".symbiot", WAITING)); } catch {} }
-  else { const w = waitingFor(repoPath); if (w) return { blocked: true, waiting: true, questions: 0, note: waitNote(w) }; }
+  if (!force) { const w = waitingFor(repoPath); if (w) 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);
   const env = opts.env && typeof opts.env === "object" ? Object.fromEntries(Object.entries(opts.env).map(([k, v]) => [k, String(v)])) : null;
   const e = track(typeof opts.name === "string" && opts.name ? opts.name.slice(0, 80) : repoPath.split("/").pop(), fillHandoff(tmpl, repoPath), repoPath, (code) => {
@@ -165,11 +165,17 @@ function earlierRuns() {
 // only gets the same questions back. So answerQuestions reminds them the step is
 // theirs, and Send answers & continue waits instead of starting: .symbiot/
 // waiting.json keeps the step and how each file it names (in backticks, like
-// `.env`) was then. Once one of them changes, the next run goes ahead
-// (startWaiting starts the one that was asked for); with no file to watch, it
+// `.env`) was then, and the agent command: a step done in Settings (Allow
+// command, a connector) changes that, not a file, so it counts as done too, as
+// it does for blocked.json. Once one of them changes, the next run goes ahead
+// (startWaiting starts the one that was asked for); with neither changed, it
 // waits for Start it now. Start it anyway (force) always goes ahead.
 const WAITING = "waiting.json";
 const yourStep = (a) => /👤/.test(String(a || ""));
+// 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).
+const runCmd = (path) => digest(withConnectors(handoffCmd(), path));
 // The files a step names, in backticks: `.env`, `~/.termux/termux.properties`,
 // `.claude/settings.json`. Not a command (`npm test`), a site (`web.whatsapp.com`,
 // unless there's a file by that name) or a path that can't be one here.
@@ -186,27 +192,36 @@ function namedFiles(text, dir) {
   return out.filter((f, i) => out.findIndex((g) => g.path === f.path) === i).slice(0, 5);
 }
 const fileSig = (p) => { try { const s = statSync(p); return s.mtimeMs + ":" + s.size; } catch { return "none"; } };
-// What a folder is waiting on: { step, files: [names], at, rerun }, or null (and
-// waiting.json goes) once a file it names has changed.
+// What a folder is waiting on: { step, files: [names], cmd, at, rerun }, or null
+// once a file it names, or the agent command, has changed. Then waiting.json
+// goes, unless a run was asked for: startWaiting needs it to start that one (the
+// Agents tab asks this every few seconds, and used to lose it first), and the
+// run deletes it as it starts. cmd: the step is one in Settings, so the note says
+// the command counts.
 function waitingFor(path) {
   let w = null; try { w = JSON.parse(readSymbiot(path, WAITING)); } catch {}
   if (!w || typeof w.step !== "string") return null;
   const files = Array.isArray(w.files) ? w.files : [];
-  if (files.some((f) => f && fileSig(f.path) !== f.sig)) { try { unlinkSync(join(path, ".symbiot", WAITING)); } catch {} return null; }
-  return { step: w.step, files: files.map((f) => f.name), at: w.at || 0, rerun: !!w.rerun };
+  if (files.some((f) => f && fileSig(f.path) !== f.sig) || (w.cmd && runCmd(path) !== w.cmd)) { if (!w.rerun) try { unlinkSync(join(path, ".symbiot", WAITING)); } catch {} return null; }
+  return { step: w.step, files: files.map((f) => f.name), cmd: !!w.cmd && settingsStep(w.step), at: w.at || 0, rerun: !!w.rerun };
+}
+// "`.env` or the agent command in Settings → Handoff", what a wait ends on ("" if neither).
+function waitOn(files, cmd) {
+  const names = files.map((f) => "`" + f + "`").join(" or ");
+  return cmd ? (names ? names + " or " : "") + "the agent command (Settings → Handoff)" : names;
 }
 function waitNote(w) {
-  const names = w.files.map((f) => "`" + f + "`").join(" or ");
-  return `Not started: your step comes first: ${w.step.replace(/^\s*👤\s*(You:)?\s*/, "")} ${names ? `Your agent starts once ${names} changes.` : "Once it's done, click Start it now (or Start it anyway)."}`;
+  const on = waitOn(w.files, w.cmd);
+  return `Not started: your step comes first: ${w.step.replace(/^\s*👤\s*(You:)?\s*/, "")} ${on ? `Your agent starts once ${on} changes. Done it some other way? Click Start it now.` : "Once it's done, click Start it now (or Start it anyway)."}`;
 }
-// Runs that waited for a file of yours, and were asked for, start once it changes.
-// The app calls this every so often. Returns the jobs started.
+// Runs that waited for a file of yours (or the agent command), and were asked
+// for, start once it changes. The app calls this every so often. Returns the jobs started.
 function startWaiting() {
   const started = [];
   for (const r of loadRuns()) {
     let w = null; try { w = JSON.parse(readSymbiot(r.path, WAITING)); } catch {}
-    if (!w || !w.rerun || !Array.isArray(w.files) || !w.files.length || runningHandoff(r.path)) continue;
-    if (waitingFor(r.path)) continue; // nothing it names has changed yet
+    if (!w || !w.rerun || !Array.isArray(w.files) || !(w.files.length || w.cmd) || runningHandoff(r.path)) continue;
+    if (waitingFor(r.path)) continue; // nothing it names, nor the command, has changed yet
     const e = runHandoff(r.path); if (e && !e.busy && !e.blocked) started.push(e);
   }
   return started;
@@ -438,6 +453,12 @@ function agentChanges(path, startedAt) {
 // .symbiot/ANSWERS.md for the next run to read. Plain files, so it works the
 // same whichever model or tool the agent is.
 const QUESTIONS_MAX = 5;
+// Two at a time: most people pick the recommended option, or + task an idea,
+// without weighing the rest, and the choices are the agent's to judge (the
+// brief says how). So a question shows its first two options, and the Agents
+// tab the ideas two at a time (`ideasShown`): one in Tasks leaves the list, and
+// the next moves up. The rest are a click away.
+const OPTIONS_SHOWN = 2, IDEAS_SHOWN = 2;
 const qKey = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ");
 const readSymbiot = (path, f) => { try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
 // "## Questions" → "### question", context lines, "- option" bullets;
@@ -479,9 +500,10 @@ function agentQuestions(path, repo) {
   const done = new Set([...readSymbiot(path, "ANSWERS.md").matchAll(/^###\s+(.+)$/gm)].map((m) => qKey(m[1])));
   const open = p.questions.filter((x) => !done.has(qKey(x.q)));
   const tasks = p.suggestions.length ? loadTasks() : [];
+  const ideas = p.suggestions.map(suggestionTarget).map(({ repo: to, text }) => ({ text, repo: to || repo, other: !!to && to !== repo, added: tasks.some((t) => t.repo === (to || repo) && sameTask(t.text, text)) })).filter((s) => !s.added);
   return {
-    questions: open.slice(0, QUESTIONS_MAX), answered: p.questions.length - open.length,
-    suggestions: p.suggestions.map(suggestionTarget).map(({ repo: to, text }) => ({ text, repo: to || repo, other: !!to && to !== repo, added: tasks.some((t) => t.repo === (to || repo) && sameTask(t.text, text)) })),
+    questions: open.slice(0, QUESTIONS_MAX).map((x) => ({ ...x, options: x.options.slice(0, OPTIONS_SHOWN) })), answered: p.questions.length - open.length,
+    suggestions: ideas, ideasShown: IDEAS_SHOWN,
   };
 }
 // Save answers to .symbiot/ANSWERS.md; opts.rerun hands the repo back to the
@@ -508,10 +530,10 @@ function answerQuestions(path, answers, opts = {}) {
   const yours = rows.filter((x) => yourStep(x.a)).map((x) => stepText(x.a)).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);
-    try { writeFileSync(join(path, ".symbiot", WAITING), JSON.stringify({ step, files: files.map((f) => ({ ...f, sig: fileSig(f.path) })), at: Date.now(), rerun: !!opts.rerun })); } catch {}
-    const names = files.map((f) => "`" + f.name + "`").join(" or ");
+    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);
-    out.note = "Answers saved. That step is still yours to do. " + (files.length ? `Your agent ${opts.rerun ? "starts by itself" : "can start"} once ${names} changes${opts.rerun ? " (while Symbiot runs)" : ""}.` : "Once it's done, click Start it now on this folder.");
+    out.note = "Answers saved. That step is still yours to do. " + (on ? `Your agent ${opts.rerun ? "starts by itself" : "can start"} once ${on} changes${opts.rerun ? " (while Symbiot runs)" : ""}.` : "Once it's done, click Start it now on this folder.");
     return out;
   }
   if (opts.rerun) { const e = runHandoff(path); if (e && e.busy) out.note = "Answers saved. An agent is still running in that folder, so another wasn't started. Send them again once it finishes."; else if (e && e.blocked) out.note = "Answers saved. " + e.note; else if (e) out.rerun = e.id; else out.note = "Answers saved. Set an agent command in Settings to have the agent pick them up automatically."; }
@@ -535,4 +557,4 @@ function agentsList() {
   }).concat(earlierRuns());
 }
 
-export { HANDOFFS, HANDOFF_PROMPT, QUESTIONS_MAX, 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, agentQuestions, answerQuestions, agentsList };
+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, agentQuestions, answerQuestions, agentsList };

package/handover.mjs

@@ -0,0 +1,38 @@
+// symbiot — Handover: what every brief says about lanes, and about the steps
+// only the user can do. Each agent works in its own lane (a repo, or ops for
+// everything outside one), and hands what's another lane's job to that lane
+// instead of stopping or asking the user (lanes.mjs runs it). What reaches the
+// user is only what no agent can do, and the brief makes the agent say which.
+// Text and parsing only, no imports: shared by every brief (tasks.mjs
+// buildTasksMd, mind.mjs actBrief) and by lanes.mjs.
+
+const OPS = "ops";
+const MAX_LANES_LISTED = 40;
+
+// The lines a brief gets about lanes. here: this agent's lane; lanes: the others
+// it can hand to (repo folder names).
+function handoverRules(lanes = [], here = "") {
+  const others = [...new Set(lanes.filter((l) => l && l !== here))].slice(0, MAX_LANES_LISTED);
+  return ["## Hand over what's another lane's job",
+    `Each agent has its own lane${here ? `: this one is \`${here}\`` : ""}. When something you need is another lane's job, don't stop, and don't ask the user to do it: hand it over. Write \`.symbiot/HANDOFF.md\` with a \`### \` heading naming the lane, then what's needed, self-contained (names, paths, links, ids) and why. Symbiot starts that lane's agent on it, and its result comes back to you in \`.symbiot/ANSWERS.md\`. Carry on with what doesn't depend on it, and don't tick what does.`,
+    `- \`${OPS}\`: anything outside a repo: this computer (find or install a tool, a JDK, an SDK), accounts and services (cloud, GitHub, DNS, email), the user's connectors.`,
+    `- A repo, by its folder name, for work that belongs in that project${others.length ? `: ${others.map((l) => `\`${l}\``).join(", ")}` : ""}.`,
+    ""];
+}
+// The rule for options in QUESTIONS.md: the user gets only what no agent can do,
+// and the option says which kind it is.
+const ONLY_YOU = "- Only what no agent can do is the user's: their body (a phone in their hand, a cable, which network they're on), their identity or secrets (signing in, a 2FA code, a token from a provider's console) or a decision that's theirs (closing an account, spending money, sending something in their name). Start such an option with `👤 You (only you: <which>):`, e.g. `👤 You (only you: your Meta token): paste it into .env`. Anything an agent could do, yours or another lane's, is never a 👤 step: do it, or hand it over. An option where picking it is enough starts with `🤖 Agent:`. Tag actions only: an option that just reports what the user saw or decides (`it notified me`, `not tried yet`) gets no tag.";
+
+// What an agent handed over: [{ lane, text }] from its .symbiot/HANDOFF.md.
+function parseHandoffs(md) {
+  const out = []; let cur = null;
+  for (const raw of String(md || "").split(/\r?\n/)) {
+    const m = raw.match(/^###\s+`?([^`\s]+)`?\s*$/);
+    if (m) { cur = { lane: m[1].trim(), text: "" }; out.push(cur); continue; }
+    if (/^#{1,2}\s/.test(raw)) { cur = null; continue; }
+    if (cur) cur.text += raw + "\n";
+  }
+  return out.map((h) => ({ lane: h.lane, text: h.text.trim().slice(0, 4000) })).filter((h) => h.lane && h.text);
+}
+
+export { OPS, handoverRules, ONLY_YOU, parseHandoffs };

package/index.mjs

@@ -39,7 +39,7 @@ import { buildTasksMd, taskType, shipChanges, shipWithBump, bumpOffer, learnNpm,
 import { produce, mailState, setMail, sentMail } from "./writeups.mjs";
 import { loadScreens, screenImage, blueprint } from "./screens.mjs";
 import { mapPage, wholePage, pressRegion, typeRegion, scrollPage, signIn, isTrusted } from "./headless.mjs";
-import { watchState, addWatch, removeWatch, seenWatch, newsSince, markNews, checkWatch, setBrief, draftReply, watchBoard, boardLine } from "./watch.mjs";
+import { watchState, addWatch, removeWatch, seenWatch, newsSince, markNews, checkWatch, setBrief, draftReply, watchBoard, boardLine, boardChat, boardTalk, clearBoardChat } from "./watch.mjs";
 import { PORT as PHONE_PORT, phoneState, pairComputer, pollComputer, forgetComputer } from "./phone.mjs";
 import { startApp, updateCmd, isAppRunningWeekly } from "./server.mjs";
 
@@ -380,7 +380,7 @@ async function cmdScreens() {
 // ---- `symbiot watch`: pages Symbiot keeps track of, and what's new on them ----
 // new, board, seen, add, remove and check print JSON, for you or an agent.
 async function cmdWatch() {
-  const [sub = "list", a1] = argv.slice(1).filter((x, i, all) => !x.startsWith("--") && !["--every", "--hours"].includes(all[i - 1]));
+  const [sub = "list", a1, a2] = argv.slice(1).filter((x, i, all) => !x.startsWith("--") && !["--every", "--hours"].includes(all[i - 1]));
   const out = (x) => { console.log(JSON.stringify(x, null, 2)); if (x && x.error) process.exitCode = 1; };
   const hours = Number(flag("hours", 24)) || 24;
   if (sub === "list") {
@@ -404,6 +404,17 @@ async function cmdWatch() {
     const where = r.chat ? "types it into the chat's message box in Symbiot's browser, never sent" : "leaves it in Drafts, never sent";
     return out(r.ok ? { ...r, next: `Your agent is writing the reply and ${where}. Its log is in ` + join(r.dir, ".symbiot", "agent.log") + " (and the app's Agents tab)." } : r);
   }
+  // a card's chat, the same talk as 💬 on the Dashboard (through the app when it
+  // runs, so an agent it starts shows in its Agents tab): a reply drafted from that
+  // card brings it along. No question: the talk so far; --clear starts it over.
+  if (sub === "chat") {
+    if (!a1) return out({ error: "Give the watch's id: symbiot watch board lists them. Then  symbiot watch chat <id> \"what needs me?\"" });
+    if (has("clear")) return out((await viaApp("/api/watch/chat/clear", { id: a1 })) || clearBoardChat(a1));
+    if (!a2) return out(boardTalk(a1));
+    const r = (await viaApp("/api/watch/chat", { id: a1, question: a2 })) || await boardChat(a1, a2);
+    if (r.error === "not-connected") return out({ error: "Connect a model first: symbiot login (or Settings in the app)." });
+    const { chat, ...rest } = r; return out(chat ? { ...rest, messages: chat.length } : rest);
+  }
   if (sub === "add") { const screen = loadScreens().some((s) => s.id === a1) ? a1 : ""; return out(addWatch({ screen, site: screen ? "" : a1, every: flag("every", 15) })); }
   if (sub === "remove") return out(removeWatch(String(a1 || "")));
   if (sub === "brief") { if (a1 === "on" || a1 === "off") return out(setBrief(a1 === "on")); return out({ brief: watchState().brief, briefs: watchState().briefs }); }
@@ -428,6 +439,10 @@ async function cmdWatch() {
                                                empty line when nothing's new)
   symbiot watch seen <id>                      set a card's count back to 0, like its Seen
                                                button (what it found stays in watch new)
+  symbiot watch chat <id> "question"           talk over what's new on a card with your AI,
+                                               like 💬 on the Dashboard: a reply drafted from
+                                               that card follows what you agreed (JSON)
+  symbiot watch chat <id> [--clear]            the talk so far, or start it over
   symbiot watch check [id]                     read them now (JSON)
   symbiot watch draft <id>                     your agent drafts a reply to that new email
                                                ("mail": true in watch new) and leaves it in

package/lanes.mjs

@@ -0,0 +1,142 @@
+// symbiot — Lanes: agents hand work to each other, so it keeps moving without
+// you. Each agent has its own lane: a repo, or ops (everything outside one: this
+// computer, accounts, services, connectors; a run of its own, mind.mjs actNow).
+// When one needs another lane's job done, it writes it to its .symbiot/HANDOFF.md
+// (handover.mjs: a "### <lane>" heading, then what's needed). Every 20 seconds
+// the app (lanesTick) starts that lane's agent on it: a repo lane gets it as a
+// task and a run there, the way Send to repos does; ops gets a run of its own.
+// When the agent that took it over is done, what it did goes back to the agent
+// that asked, in its .symbiot/ANSWERS.md, and that agent is started again to
+// carry on. You only see what no agent can do, as a question in the Agents tab.
+//
+// The ledger, ~/.config/symbiot/lanes.json: { handoffs: [{ id, key, from: { lane,
+// path }, to: { lane, path }, text, at, chain, status, job?, task?, error?,
+// result?, reportedAt? }] }. status: started, held (that lane's agent was busy:
+// it starts when it's free), done (reported back) or error (reported back too).
+// chain: how many handovers in a row led here; past MAX_CHAIN it stops, so two
+// lanes can't hand the same thing back and forth forever.
+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 { addTask, pushTasks } from "./tasks.mjs";
+import { actNow } from "./mind.mjs";
+import { repoPathMap } from "./scan.mjs";
+import { OPS, parseHandoffs } from "./handover.mjs";
+
+const LEDGER = join(CONFIG_DIR, "lanes.json");
+const ACT_DIR = join(CONFIG_DIR, "drafts");
+const MAX_KEEP = 200, MAX_CHAIN = 4, TAIL = 1500;
+
+function loadLedger() { try { const d = JSON.parse(readFileSync(LEDGER, "utf8")); return { handoffs: Array.isArray(d.handoffs) ? d.handoffs : [] }; } catch { return { handoffs: [] }; } }
+// It can name accounts and what's in them: yours only (0600).
+function saveLedger(d) { try { mkdirSync(CONFIG_DIR, { recursive: true }); writeFileSync(LEDGER, JSON.stringify({ handoffs: d.handoffs.slice(-MAX_KEEP) }, null, 1), { mode: 0o600 }); try { chmodSync(LEDGER, 0o600); } catch {} return true; } catch { return false; } }
+const readSym = (path, f) => { try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
+const firstLine = (t) => String(t || "").split("\n").find((l) => l.trim()) || "";
+
+// A folder's lane: the repo it is, or ops for a run of its own.
+function laneOf(path, map) {
+  if (path.startsWith(ACT_DIR)) return OPS;
+  const hit = Object.entries(map).find(([, p]) => p === path);
+  return hit ? hit[0] : basename(path);
+}
+// The lane a handover names, as a folder: a repo (any case), or ops. null if none.
+function laneTarget(lane, map) {
+  if (lane.toLowerCase() === OPS) return { lane: OPS, path: "" };
+  const name = Object.keys(map).find((n) => n.toLowerCase() === lane.toLowerCase());
+  return name ? { lane: name, path: map[name] } : null;
+}
+
+// Pick up what a folder's agent handed over and start the lanes it named.
+// Each handover is started once (its key: where from, which lane, what).
+function dispatch(path, { map = repoPathMap(), act = actNow, run = runHandoff, add = addTask, push = pushTasks, now = Date.now(), ledger = loadLedger() } = {}) {
+  const asked = parseHandoffs(readSym(path, "HANDOFF.md")); if (!asked.length) return [];
+  const from = { lane: laneOf(path, map), path }, parent = ledger.handoffs.filter((h) => h.to.path === path).pop(), chain = (parent ? parent.chain : 0) + 1;
+  const started = [];
+  for (const h of asked) {
+    const key = createHash("sha1").update(path + "\n" + h.lane.toLowerCase() + "\n" + h.text).digest("hex").slice(0, 16);
+    if (ledger.handoffs.some((x) => x.key === key)) continue;
+    const e = { id: randomBytes(4).toString("hex"), key, from, to: { lane: h.lane, path: "" }, text: h.text, at: now, chain, status: "started" };
+    const to = laneTarget(h.lane, map);
+    if (chain > MAX_CHAIN) Object.assign(e, { status: "error", error: `${MAX_CHAIN} handovers in a row led here, so this one wasn't started. Do it yourself, or ask the user.` });
+    else if (!to) Object.assign(e, { status: "error", error: `There's no lane called ${h.lane}. Lanes: ops, or a repo: ${Object.keys(map).slice(0, 30).join(", ")}.` });
+    else if (to.lane.toLowerCase() === from.lane.toLowerCase()) Object.assign(e, { status: "error", error: `${to.lane} is your own lane: do it yourself.` });
+    else if (to.lane === OPS) {
+      const r = act(h.text, { title: `handed over by ${from.lane}`, context: `${from.lane}'s agent (in ${path}) handed this over, and carries on once it's done.`, now });
+      if (r.error) Object.assign(e, { status: "error", error: r.error });
+      else Object.assign(e, { to: { lane: OPS, path: r.dir }, job: r.job });
+    } else {
+      const t = add(`${h.text.replace(/\s+/g, " ").slice(0, 900)} (handed over by ${from.lane})`, to.lane);
+      if (t.error) Object.assign(e, { status: "error", error: t.error });
+      else {
+        push({ repo: to.lane });
+        const r = run(to.path) || {};
+        Object.assign(e, { to, task: t.id, status: r.id && !r.busy && !r.blocked ? "started" : "held", ...(r.id ? { job: r.id } : {}) });
+      }
+    }
+    ledger.handoffs.push(e); started.push(e);
+  }
+  return started;
+}
+
+// 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
+  return run.length > TAIL ? "…" + run.slice(-TAIL) : run;
+}
+// When the newest run in a folder started (its log header), or 0.
+function lastRunStart(path) { const log = readSym(path, "agent.log"), m = [...log.matchAll(/^=== .* (\d{4}-\d\d-\d\dT[\d:.]+Z) ===$/gm)].pop(); return m ? Date.parse(m[1]) || 0 : 0; }
+const openQuestions = (path) => /^###\s+/m.test(readSym(path, "QUESTIONS.md").split(/^##\s+Suggestions/m)[0]);
+
+// Is it done? Ops: its run ended (ticked or not). A repo: the task it was given
+// is ticked or its run ended, and no agent is working there. Waiting on the
+// user's answer to a question there isn't done: that's in the Agents tab.
+function outcome(e, { tasks = loadTasks(), running = runningHandoff } = {}) {
+  if (e.status === "error") return { text: `Couldn't hand it over: ${e.error}` };
+  const p = e.to.path; if (!p || running(p)) return null;
+  if (lastRunStart(p) < e.at) return null; // its run hasn't started yet (held while that lane was busy)
+  if (openQuestions(p) && !/^- \[x\]/im.test(readSym(p, "TASKS.md"))) return null; // waiting on the user, in that lane
+  const words = lastWords(p);
+  if (e.to.lane === OPS) {
+    const ticked = /^- \[x\]/im.test(readSym(p, "TASKS.md"));
+    return { text: `${ticked ? "Done" : "It stopped without finishing"} (the ops agent).${words ? `\n\nWhat it said:\n${words}` : ""}` };
+  }
+  const t = tasks.find((x) => x.id === e.task);
+  const done = t && (t.review || t.done || t.archived);
+  return { text: `${done ? `Done in ${e.to.lane}: the task is ticked, and its changes wait for the user's review in Symbiot` : `${e.to.lane}'s agent stopped without ticking it`}.${words ? `\n\nWhat it said:\n${words}` : ""}` };
+}
+// 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() } = {}) {
+  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 });
+  return true;
+}
+
+// One pass: start what's been handed over, from every lane, then report back
+// what's done. The app runs it every 20 seconds.
+function lanesTick({ map = repoPathMap(), act = actNow, run = runHandoff, running = runningHandoff, add = addTask, push = pushTasks, tasks, now = Date.now() } = {}) {
+  const ledger = loadLedger();
+  let acts = []; try { acts = readdirSync(ACT_DIR).filter((d) => d.startsWith("act-")).map((d) => join(ACT_DIR, d)); } catch {}
+  const started = [];
+  for (const path of [...Object.values(map), ...acts]) if (existsSync(join(path, ".symbiot", "HANDOFF.md"))) started.push(...dispatch(path, { map, act, run, add, push, now, ledger }));
+  const t = tasks || loadTasks(), reported = [];
+  for (const e of ledger.handoffs) {
+    if (e.reportedAt || running(e.from.path)) continue; // the one that asked reads it when it's started again, so not mid-run
+    const o = outcome(e, { tasks: t, running }); if (!o) continue;
+    if (report(e, o, { run, running, now })) { e.reportedAt = now; if (e.status !== "error") e.status = "done"; e.result = o.text.slice(0, 600); reported.push(e); }
+  }
+  if (started.length || reported.length) saveLedger(ledger);
+  return { started, reported };
+}
+// The Agents tab's list: newest first.
+function lanesState() { return { handoffs: loadLedger().handoffs.slice(-30).reverse().map((e) => ({ id: e.id, from: e.from.lane, to: e.to.lane, text: firstLine(e.text).slice(0, 160), at: e.at, status: e.status, ...(e.error ? { error: e.error } : {}), ...(e.result ? { result: e.result } : {}) })) }; }
+
+export { LEDGER, MAX_CHAIN, loadLedger, laneOf, lastRunStart, dispatch, outcome, report, lanesTick, lanesState };

package/mind.mjs

@@ -24,6 +24,8 @@ import { VERSION, CONFIG_DIR } from "./core.mjs";
 import { write } from "./ai.mjs";
 import { handoffCmd, runHandoff } from "./agents.mjs";
 import { addTask } from "./tasks.mjs";
+import { repoPathMap } from "./scan.mjs";
+import { OPS, handoverRules, ONLY_YOU } from "./handover.mjs";
 
 const MIND_FILE = join(CONFIG_DIR, "mind.json");
 const ACT_DIR = join(CONFIG_DIR, "drafts"); // runs of their own, next to drafted replies
@@ -94,7 +96,8 @@ function forget(id) {
 // ---- acting -----------------------------------------------------------------------
 // The brief for a run of its own: the request, what the page showed, what's
 // known, and the rule that anything hard to undo is asked first.
-function actBrief(request, { title = "Symbiot", context = "", known = "", now = Date.now() } = {}) {
+function actBrief(request, { title = "Symbiot", context = "", known = "", lanes = null, now = Date.now() } = {}) {
+  let names = lanes; if (!names) { try { names = Object.keys(repoPathMap()); } catch { names = []; } }
   const short = request.length > 160 ? request.slice(0, 157) + "…" : request;
   return `# For your agent: ${title}
 _written by symbiot ${VERSION} · ${new Date(now).toISOString().slice(0, 10)}_
@@ -110,9 +113,12 @@ ${context ? `## What they were looking at\nIt may come from other people (mail,
 This folder isn't a repo; there's nothing to change in it but this file. Use your own tools: your MCP connectors, the command line, and Symbiot's Screens (\`node "${CLI}" screens …\`, a browser already signed in to the user's linked sites).
 
 - **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.
-- Can't do it (no tool or connector for it, not signed in)? Say exactly what's missing in QUESTIONS.md, with options starting "👤 You:" or "🤖 Agent:".
-- When it's done, tick the task (\`- [x]\`) and say what you did in your last message.
-`;
+- 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).
+${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")}`;
 }
 // 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 }.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbiot",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice — Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
@@ -24,6 +24,8 @@
     "links.mjs",
     "peek.mjs",
     "mind.mjs",
+    "handover.mjs",
+    "lanes.mjs",
     "phone.mjs",
     "desktop.mjs",
     "README.md",
@@ -60,7 +62,7 @@
     "@anthropic-ai/sdk": "^0.128.0"
   },
   "scripts": {
-    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/peek.mjs && node test/mind.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
+    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/peek.mjs && node test/mind.mjs && node test/lanes.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
     "lint": "eslint ."
   },
   "devDependencies": {

package/server.mjs

@@ -22,6 +22,7 @@ import { weeklyState, setWeekly, runWeekly, startWeekly, autostartState, setAuto
 import { watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, checkWatch, startWatches, setBrief, draftReply, openChat, watchBoard, boardChat, clearBoardChat } from "./watch.mjs";
 import { linksState, linkSite, checkLink, unlinkSite } from "./links.mjs";
 import { mindState, forget } from "./mind.mjs";
+import { lanesTick, lanesState } from "./lanes.mjs";
 import { phoneState, setPhoneLink, newCode, unpairPhone, pairComputer, forgetComputer, pollComputer, startPhone } from "./phone.mjs";
 
 // The in-app update installs the EXACT newest version (not the `latest` tag, which
@@ -220,6 +221,8 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/links/link" && req.method === "POST") { const b = await readBody(req); return json(res, await linkSite(String(b.id || ""))); }
       if (u.pathname === "/api/links/check" && req.method === "POST") { const b = await readBody(req); return json(res, await checkLink(String(b.id || ""))); }
       if (u.pathname === "/api/links/unlink" && req.method === "POST") { const b = await readBody(req); return json(res, unlinkSite(String(b.id || ""))); }
+      // Lanes (lanes.mjs): work agents handed to each other, and where it stands.
+      if (u.pathname === "/api/lanes") return json(res, lanesState());
       // Watch (watch.mjs): a mapped page read again every few minutes, and what's new on it.
       if (u.pathname === "/api/watch") return json(res, watchState());
       if (u.pathname === "/api/watch/board") return json(res, watchBoard(Math.min(168, Math.max(1, Number(u.searchParams.get("hours")) || 24))));
@@ -297,6 +300,7 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
   startWatches(); // pages you watch (Screens → Watch), read every few minutes
   startPhone(); // Watch on your phone: the computer listens if it's switched on, the phone asks if it's paired
   setInterval(() => { try { startWaiting(); } catch {} }, 20000).unref(); // a run that waits for your step starts once the file it names changes
+  setInterval(() => { try { lanesTick(); } catch {} }, 20000).unref(); // agents hand work to other lanes, and hear back when it's done
 }
 
 export { updateCmd, BROWSER_KEEP, startApp, askRunningApp, isAppRunningWeekly };

package/tasks.mjs

@@ -7,7 +7,8 @@ import { join } from "node:path";
 import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { VERSION, LATEST_VERSION, REGISTRY, semverGt, loadConfig, saveConfig, loadTasks, saveTasks, taskWords, sameTask, uniqueTasks, sh, hasCmd, repoState } from "./core.mjs";
-import { QUESTIONS_MAX, handoffCmd, runningHandoff, writeTasks, startHeldTasks } from "./agents.mjs";
+import { handoverRules, ONLY_YOU } from "./handover.mjs";
+import { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, startHeldTasks } from "./agents.mjs";
 import { gitDefaultBranch } from "./drift.mjs";
 import { repoPathMap, openWork, detectRepo } from "./scan.mjs";
 
@@ -435,12 +436,14 @@ function buildTasksMd(name, ctx, list) {
   const keys = Object.keys(byType).sort((a, b) => TASK_ORDER.indexOf(a) - TASK_ORDER.indexOf(b));
   for (const ty of keys) { L.push(`### ${ty}`); for (const t of byType[ty]) L.push(`- [ ] ${t.text}`); L.push(""); }
   L.push("## When you finish an item", "- Tick it here (`- [x]`) as soon as it's done — that's how it reaches review. Ticking doesn't archive it: the user approves it in Symbiot, which commits it on a branch and opens a PR.", "- Leave your changes **uncommitted**, and don't tick anything you didn't finish or couldn't verify.", "");
+  L.push(...handoverRules(ctx.lanes || [], name));
   L.push("## If you need a decision, or have ideas", "You may be running unattended, so you can't ask in chat. Write `.symbiot/QUESTIONS.md` instead: Symbiot shows it to the user on your block in its Agents tab, and their answers come back in `.symbiot/ANSWERS.md` (read that first if it exists).",
-    `- At most ${QUESTIONS_MAX} questions, under a \`## Questions\` heading. Each is a \`### \` heading, then an optional line of context, then 2–4 options as \`- \` bullets (put the one you recommend first).`,
-    "- Start every option with who acts, because the user reads it as something they'd be agreeing to do: `👤 You:` when they have to do something (a setting, a click, a command), `🤖 Agent:` when picking it is enough and the next run does the work. If it takes both, put their step first: `👤 You: allow npm install in Settings. 🤖 Agent: the next run adds ESLint`. Tag actions only: an option that just reports what the user saw or decides (`it notified me`, `not tried yet`, `keep it as it is`) gets no tag.",
+    `- At most ${QUESTIONS_MAX} questions, under a \`## Questions\` heading. Each is a \`### \` heading, then a line of context, then exactly ${OPTIONS_SHOWN} options as \`- \` bullets, the one you recommend first, marked \`(recommended)\`. Symbiot shows only the first ${OPTIONS_SHOWN}; the user can always answer in their own words.`,
+    "- Judge the options before you ask. Most people pick the recommended option without weighing the other, and Symbiot works for a whole company (developers, sales, everyone), not one person, so the choice is really yours. Both options must be good routes to the best solution, never filler or one you wouldn't take. Each says in plain words, with no jargon, what it does and what it changes from then on for the project, the people working on it and the company. Recommend the one that's best for, in this order, the company, the people doing the work, then the task's goal. Base that on evidence you can check here (git history, tests, logs, how it's used, the answers so far), not on what's quickest, and give that evidence in the context line in a sentence.",
+    ONLY_YOU,
     "- A `👤 You:` answer holds the next run back until the user's step is done. If their step changes a file, name the file in backticks (`.env`, `~/.termux/termux.properties`): the next run starts once it changes.",
     "- If a step needs a release that isn't out yet, name its version in the question (\"Once 0.41.0 is installed: …\"). Symbiot shows it next to the installed and npm versions, and holds back an answer that starts \"Done\" until that release is out and installed.",
-    "- Ideas, options or follow-ups outside these tasks go under `## Suggestions` as `- ` bullets — the user can add them to their tasks in one click.",
+    `- Ideas, options or follow-ups outside these tasks go under \`## Suggestions\` as \`- \` bullets. The user can add them to their tasks in one click, and often adds every one, so judge them the same way: only ideas you'd recommend, best first, each saying what it changes and why it's worth doing. Symbiot shows them ${IDEAS_SHOWN} at a time.`,
     "- An idea for a different project than this one (Symbiot itself, say, the app that sent you this brief) starts with that project's folder name, `- [repo: symbiot] …`, so it goes to that project's tasks instead of this one's.",
     "- Carry on with everything that doesn't depend on an answer, and don't tick an item that does. Ask there rather than doing anything destructive.", "");
   L.push("---", 'To action these, tell your coding agent: "Read `.symbiot/TASKS.md` and implement the unchecked items in this repo, using the context above. Tick each item as you finish it and leave changes uncommitted for review. Confirm with me before anything destructive."');
@@ -471,7 +474,7 @@ function pushTasks(filter) {
       if (st.behind) risk.push(`${st.behind} behind upstream on ${st.branch}`);
       if (st.dirty && !st.stale) risk.push(`${st.dirty} uncommitted (${st.mod} mod / ${st.del} del / ${st.add} new)`);
       // held: an agent is still running there, so it lands when that one exits
-      const held = writeTasks(path, buildTasksMd(name, { branch: st.branch, commits, open, drift: risk, stack }, list));
+      const held = writeTasks(path, buildTasksMd(name, { branch: st.branch, commits, open, drift: risk, stack, lanes: Object.keys(byName) }, list));
       written.push({ name, file: join(path, ".symbiot", "TASKS.md"), path, count: list.length, held });
     } catch (e) { unresolved.push({ name, count: list.length, error: String((e && e.message) || e) }); }
   }

package/ui.mjs

@@ -220,6 +220,7 @@ label.check input{width:auto}
 <section id="panel-agents" class="hidden">
 <div class="row"><span class="muted">Agents Symbiot has handed work to — live status and output. Questions, options and ideas an agent leaves for you show up on its block, whichever model it runs.</span><button class="ghost" id="agentsrefresh" style="margin-left:auto">Refresh</button></div>
 <div id="agentsmsg"></div>
+<div id="laneslist"></div>
 <div id="agentslist"></div>
 </section>
 <section id="panel-drift" class="hidden">
@@ -537,8 +538,10 @@ qs.forEach(function(q,i){var rl=q.release;h+="<div class='q' data-i='"+i+"'><div
 (q.options||[]).forEach(function(o,j){var off=rl&&rl.waiting&&DONEOPT.test(o);h+="<label class='opt"+(off?" off":"")+"'><input type='radio' name='q_"+esc(a.id)+"_"+i+"' value='"+j+"'"+(off?" disabled":"")+"><span>"+whoHtml(o)+(off?" <i>(once "+esc(rl.name+" "+rl.needs)+" is installed)</i>":"")+"</span></label>";});
 h+="<input class='qother' placeholder='"+((q.options&&q.options.length)?"or answer in your own words":"your answer")+"'></div>";});
 h+="<div class='row'><button class='act qsend' title='save the answers and hand the repo back to your agent'>Send answers &amp; continue</button><button class='ghost qsave' title='save the answers for the next run'>Save only</button></div>";}
-if(ss.length){h+="<h4>&#128161; Ideas from the agent</h4>";ss.forEach(function(s,i){h+="<div class='idea'><span style='flex:1'>"+esc(s.text)+(s.other?" <span class='tag' title='this idea is for another project, so + task adds it to that one'>for "+esc(s.repo)+"</span>":"")+"</span>"+(s.added?"<span class='tag'>in Tasks</span>":"<button class='ghost qidea' data-i='"+i+"' style='padding:3px 9px;font-size:12px'>+ task</button>")+"</div>";});}
+if(ss.length){var shown=IDEASOPEN[a.path]?ss.length:(k.ideasShown||ss.length);h+="<h4>&#128161; Ideas from the agent</h4>";ss.forEach(function(s,i){if(i>=shown)return;h+="<div class='idea'><span style='flex:1'>"+esc(s.text)+(s.other?" <span class='tag' title='this idea is for another project, so + task adds it to that one'>for "+esc(s.repo)+"</span>":"")+"</span>"+(s.added?"<span class='tag'>in Tasks</span>":"<button class='ghost qidea' data-i='"+i+"' style='padding:3px 9px;font-size:12px'>+ task</button>")+"</div>";});
+if(ss.length>shown)h+="<div class='row'><button class='ghost qmore' title='the agent ranks its ideas best first: weigh these two before adding more'>"+(ss.length-shown)+" more idea"+(ss.length-shown>1?"s":"")+", ranked lower</button></div>";}
 return h+"</div>";}
+var IDEASOPEN={};
 function qKeyOf(qe){var box=qe.closest('.aq');var a=box&&agentById(box.getAttribute('data-id'));var q=a&&a.ask.questions[+qe.getAttribute('data-i')];return q?a.path+'|'+q.q:'';}
 function saveDrafts(el){el.querySelectorAll('.aq .q').forEach(function(qe){var k=qKeyOf(qe);if(!k)return;var pick=qe.querySelector('input[type=radio]:checked');QDRAFT[k]={o:pick?pick.value:'',t:qe.querySelector('.qother').value};});}
 function restoreDrafts(el){el.querySelectorAll('.aq .q').forEach(function(qe){var d=QDRAFT[qKeyOf(qe)];if(!d)return;qe.querySelectorAll('input[type=radio]').forEach(function(r){r.checked=!r.disabled&&r.value===d.o;});qe.querySelector('.qother').value=d.t||'';});}
@@ -553,15 +556,21 @@ if(!r||r.error){box.querySelectorAll('button').forEach(function(b){b.disabled=fa
 msg.innerHTML="<div class='note ok'>&#10003; Saved "+r.saved+" answer"+(r.saved>1?"s":"")+" for <b>"+esc(a.name)+"</b> in .symbiot/ANSWERS.md"+(r.rerun?" &middot; your agent is picking them up now.":".")+(r.yours&&r.yours.length?"<div class='err'>&#128100; Still yours to do: "+esc(r.yours.join(' '))+"</div>":"")+(r.note?"<div class='muted'>"+esc(r.note)+"</div>":"")+"</div>";loadAgents();});}
 var s1=box.querySelector('.qsend'),s2=box.querySelector('.qsave');
 if(s1)s1.addEventListener('click',function(){send(true);});if(s2)s2.addEventListener('click',function(){send(false);});
+var more=box.querySelector('.qmore');if(more)more.addEventListener('click',function(){IDEASOPEN[a.path]=true;loadAgents();});
 box.querySelectorAll('.qidea').forEach(function(btn){btn.addEventListener('click',function(){var s=a.ask.suggestions[+btn.getAttribute('data-i')];if(!s)return;btn.disabled=true;
 api('/api/tasks/add',{text:s.text,repo:s.repo||a.name}).then(function(){s.added=true;btn.outerHTML="<span class='tag'>in Tasks</span>";});});});});}
 // A step of yours an answer picked (👤 You): the next run waits for it (agents.mjs waitingFor)
-function waitHtml(a){var w=a.waiting;if(!w)return '';var fs=(w.files||[]).map(function(f){return "<code>"+esc(f)+"</code>";}).join(" or ");
+function waitHtml(a){var w=a.waiting;if(!w)return '';var fs=(w.files||[]).map(function(f){return "<code>"+esc(f)+"</code>";}).join(" or ");if(w.cmd)fs=(fs?fs+" or ":"")+"the agent command in Settings &rarr; Handoff";
 return "<div class='aq'><h4>&#9208; Waiting on your step</h4><div class='qt'>&#128100; "+esc(w.step)+"</div><div class='qc'>"+(fs?"Your agent "+(w.rerun?"starts by itself":"can start")+" once "+fs+" changes"+(w.rerun?", while Symbiot runs":"")+". Done it some other way?":"Your agent waits for it, so it doesn't stop on the same questions again.")+" Start it now once it's done.</div><div class='row'><button class='act wstart' data-id='"+esc(a.id)+"'>Start it now</button></div></div>";}
 function wireWaits(el){el.querySelectorAll('.wstart').forEach(function(btn){btn.addEventListener('click',function(){var a=agentById(btn.getAttribute('data-id'));if(!a)return;btn.disabled=true;
 api('/api/open',{path:a.path,force:true}).then(function(x){var msg=document.getElementById('agentsmsg');msg.innerHTML=x&&x.opened?"<div class='note ok'>&#10003; Started your agent in <b>"+esc(a.name)+"</b>.</div>":"<div class='note err'>"+esc(a.name)+": "+(x&&x.busy?"an agent is already running there.":"it didn&#39;t start. Check the command in Settings.")+"</div>";loadAgents();}).catch(function(e){btn.disabled=false;document.getElementById('agentsmsg').innerHTML="<div class='note err'>"+esc(String((e&&e.message)||e))+"</div>";});});});}
 function answering(){var f=document.activeElement;return !!(f&&f.closest&&f.closest('.aq'));}
-function loadAgents(){api('/api/agents').then(function(list){var el=document.getElementById('agentslist');
+// Handovers (lanes.mjs): what one lane's agent handed to another, and where it stands.
+var LANEWORD={started:'working on it',held:'queued: that lane is busy',done:'done, reported back',error:"couldn't hand over"};
+function loadLanes(){api('/api/lanes').then(function(d){var el=document.getElementById('laneslist');if(!el||!d)return;var hs=d.handoffs||[];
+el.innerHTML=hs.length?"<div class='tgroup'>Handovers <span class='tcount'>"+hs.length+"</span></div>"+hs.slice(0,12).map(function(h){
+return "<div class='task' title='"+escQ(h.result||h.error||h.text)+"'><span class='t'><b>"+esc(h.from)+"</b> &rarr; <b>"+esc(h.to)+"</b>: "+esc(h.text)+"</span><span class='rp'"+(h.status==='error'?" style='color:var(--amber)'":"")+">"+esc(LANEWORD[h.status]||h.status)+"</span></div>";}).join(''):'';});}
+function loadAgents(){loadLanes();api('/api/agents').then(function(list){var el=document.getElementById('agentslist');
 if(!list||!list.length){AGENTLIST=[];el.innerHTML="<div class='muted' style='margin-top:12px'>No agents yet. In <b>Tasks</b>, tick ideas and hit <b>Send to repos</b> (with an agent command set in Settings) &mdash; you'll watch it work here.</div>";stopAgentsPoll();return;}
 var anyRunning=list.some(function(a){return a.status==='running';});
 if(answering()){stopAgentsPoll();if(anyRunning&&current==='agents')agentsTimer=setTimeout(loadAgents,2000);return;} // don't re-render under someone typing an answer

package/watch.mjs

@@ -280,6 +280,8 @@ async function boardChat(id, question, { hours = 72, now = Date.now(), ask = wri
   saveWatch(d2);
   return { answer, chat: w2.chat, ...(peeks.length ? { links: peeks } : {}), ...(r.did ? { did: r.did } : {}) };
 }
+// The card's talk so far (symbiot watch chat <id>), [{ role, text, ts }].
+function boardTalk(id) { const w = loadWatch().watches.find((x) => x.id === id); return w ? { chat: w.chat || [] } : { error: `No watch ${id}.` }; }
 function clearBoardChat(id) { const d = loadWatch(), w = d.watches.find((x) => x.id === id); if (!w) return { error: `No watch ${id}.` }; delete w.chat; saveWatch(d); return { ok: true }; }
 // The card's talk, for a draft's brief: "" when there's been none.
 function talkOf(w) {
@@ -493,4 +495,4 @@ function startWatches(opts = {}) {
   return () => { clearTimeout(first); clearInterval(every); };
 }
 
-export { LINK_ASK, WATCH_FILE, EVERY, GITHUB_INBOX, DRAFTS_DIR, itemsOf, itemKey, newItems, remember, isGitHubInbox, githubItems, readGitHub, setBrief, briefOf, newsNotice, markNews, watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, newsSince, newsAfter, waitingOn, watchBoard, boardLine, boardChat, clearBoardChat, talkOf, isMail, isChat, draftsUrl, draftBrief, chatBrief, draftReply, openChat, checkWatch, dueWatches, startWatches };
+export { LINK_ASK, WATCH_FILE, EVERY, GITHUB_INBOX, DRAFTS_DIR, itemsOf, itemKey, newItems, remember, isGitHubInbox, githubItems, readGitHub, setBrief, briefOf, newsNotice, markNews, watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, newsSince, newsAfter, waitingOn, watchBoard, boardLine, boardChat, boardTalk, clearBoardChat, talkOf, isMail, isChat, draftsUrl, draftBrief, chatBrief, draftReply, openChat, checkWatch, dueWatches, startWatches };

package/writeups.mjs

@@ -69,6 +69,12 @@ function extractJson(s) {
   if (a >= 0 && b > a) { try { return JSON.parse(t.slice(a, b + 1)); } catch {} }
   return null;
 }
+// Two at a time, judged (as agents' questions are, agents.mjs OPTIONS_SHOWN):
+// most people act on whatever's suggested without weighing it, so the model
+// picks, and says why in a line.
+const JUDGE = `Judge them before you write them: people tend to do whatever is listed without weighing it, and this is for a whole company, not one person. ` +
+  `List only what you'd recommend, best first, and choose by what's best for, in this order, the company, the people doing the work, then the project's goal. ` +
+  `For each, say in plain words (no jargon) what it changes from then on and the evidence for it. `;
 // AI "value" suggestions for one repo, from its recent commits + open work.
 async function repoSuggest(path) {
   if (!resolveProvider()) return { error: "not-connected" };
@@ -81,8 +87,8 @@ async function repoSuggest(path) {
   const footer = reportFooter(path, auth, state, rd);
   const system =
     `You are a pragmatic senior engineer advising on one project. Write exactly three short sections with headings: ` +
-    `"In flight" (what's clearly underway), "Next steps" (3-5 concrete actions), "Ideas" (2-3 that fit where this is heading). ` +
-    `Ground each point in the evidence; recent commits beat the README. Do not advise against the stated conventions. ` +
+    `"In flight" (what's clearly underway), "Next steps" (the 2 best concrete actions), "Ideas" (the 2 best that fit where this is heading). ` +
+    JUDGE + `Recent commits beat the README. Do not advise against the stated conventions. ` +
     (state.stale ? `CRITICAL: the working tree is a STALE checkout — never suggest committing it (would revert history). ` : ``) +
     `No filler, no preamble.`;
   const prompt =
@@ -107,8 +113,8 @@ async function folderSuggest(path) {
   const system =
     `You are a pragmatic senior engineer looking at a project FOLDER that is NOT under version control. ` +
     `From its files, write exactly three short sections with headings: "Overview" (what this project is, 1-2 sentences), ` +
-    `"Next steps" (3-5 concrete actions — a strong first one is often "git init" if this looks like real work), ` +
-    `"Ideas" (2-3 that fit where it's heading). Ground every point in the actual files/manifest/README shown. No preamble.`;
+    `"Next steps" (the 2 best concrete actions — a strong first one is often "git init" if this looks like real work), ` +
+    `"Ideas" (the 2 best that fit where it's heading). ` + JUDGE + `The evidence here is the files, manifest and README shown. No preamble.`;
   const prompt =
     `Folder: ${det.name}\nStack: ${stack}\nFiles (${det.files}):\n${rels.slice(0, 120).join("\n")}\n\n` +
     (manifest ? `Manifest:\n${manifest}\n\n` : "") + (readme ? `README excerpt:\n${readme}\n\n` : "") + `Write the overview and suggestions.`;