symbiot 0.55.0 → 0.55.2

package/away.mjs

@@ -1,5 +1,5 @@
 // symbiot — Away: Symbiot full screen on every screen while you're away from the
-// desk (Super+S, or `symbiot away`): the orb at rest, the time, and what's going on
+// desk (Super+`, or `symbiot away`): the orb at rest, the time, and what's going on
 // (agents at work and what they're doing, how much waits on you), counts only, no
 // one's words. One screen: the orb in the middle. More: it bounces across all of
 // them, one kiosk window per screen, each working out where the orb is from the
@@ -11,7 +11,7 @@
 // own move-to-screen shortcut). So under Wayland it's one window, full screen where
 // you are, the orb in the middle. Each window's profile lets Symbiot's address see the
 // screens and go full screen without a click, so nothing asks.
-// Any key or click, or Super+S again, closes every window. Not a lock: Super+Esc
+// Any key or click, or Super+` again, closes every window. Not a lock: Super+Esc
 // locks the computer.
 import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
@@ -65,6 +65,7 @@ function grantProfile(dir, origin) {
 const placeable = (env = process.env) => (env.XDG_SESSION_TYPE || "").toLowerCase() === "x11" || (!env.WAYLAND_DISPLAY && !!env.DISPLAY);
 function openAway(url, { chrome = chromeBinary(), scr = placeable() ? screens() : { list: [], display: "" }, now = Date.now() } = {}) {
   if (!chrome) return { error: "Away needs Chrome or Chromium on this computer." };
+  if (process.env.SYMBIOT_NO_OPEN === "1") return { open: false, note: "Windows are off here (SYMBIOT_NO_OPEN): tests, and runs that mustn't open any." };
   closeAway();
   const qs = awayQueries(scr.list, now);
   const origin = (String(url).match(/^https?:\/\/[^/?#]+/) || [""])[0];
@@ -77,31 +78,36 @@ function openAway(url, { chrome = chromeBinary(), scr = placeable() ? screens()
   });
   return { open: KIDS.length > 0, screens: Math.max(1, scr.list.length) };
 }
-// Open, close (open: false) or, with neither said, the other way round.
+// open: true opens, false closes, "toggle" goes the other way; anything else only
+// says whether it's open (a call that names nothing never opens windows: the smoke
+// test calls every endpoint, and it opened Away on the owner's screen every run).
 function toggleAway(url, open, deps) {
-  const want = open === undefined || open === null ? !awayOpen() : !!open;
+  if (open !== true && open !== false && open !== "toggle") return { open: awayOpen() };
+  const want = open === "toggle" ? !awayOpen() : open;
   if (!want) { closeAway(); return { open: false }; }
   return openAway(url, deps);
 }
 
 // ---- the shortcut -------------------------------------------------------------
-// Super+S runs `symbiot away`. COSMIC: a custom shortcut in its config (it reloads
-// it as it changes; one for Super+S takes over the default there, which stacks
-// windows). Elsewhere it says how to add one.
+// Super+` (the key above Tab) runs `symbiot away`: free on COSMIC, where Super+S
+// stacks windows. COSMIC: a custom shortcut in its config (it reloads it as it
+// changes). Elsewhere it says how to add one.
 const COSMIC_CUSTOM = (home = homedir()) => join(home, ".config", "cosmic", "com.system76.CosmicSettings.Shortcuts", "v1", "custom");
-function shortcutLine(cmd) { return `    (modifiers: [Super], key: "s"): Spawn(${JSON.stringify(cmd)}),`; }
-// The new custom file: whatever was there, minus any Super+S, plus ours.
+const KEY = "grave";
+function shortcutLine(cmd) { return `    (modifiers: [Super], key: "${KEY}"): Spawn(${JSON.stringify(cmd)}),`; }
+// The new custom file: whatever was there, minus any Super+` and any earlier one of
+// ours (on another key), plus ours.
 function withShortcut(text, cmd) {
   const body = String(text || "").trim().replace(/^\{/, "").replace(/\}\s*$/, "");
-  const kept = body.split("\n").filter((l) => l.trim() && !/\(modifiers:\s*\[\s*Super\s*,?\s*\],\s*key:\s*"s"\s*\)/.test(l));
+  const kept = body.split("\n").filter((l) => l.trim() && !/\(modifiers:\s*\[\s*Super\s*,?\s*\],\s*key:\s*"grave"\s*\)/.test(l) && !/Spawn\("[^"]*symbiot[^"]* away"\)/.test(l));
   return "{\n" + [...kept.map((l) => l.replace(/\s*$/, "")), shortcutLine(cmd)].join("\n") + "\n}\n";
 }
 function installShortcut({ cmd, home = homedir(), desktop = process.env.XDG_CURRENT_DESKTOP || "" } = {}) {
-  if (!/cosmic/i.test(desktop)) return { manual: true, note: `Add a keyboard shortcut in your desktop's settings: Super+S runs  ${cmd}` };
+  if (!/cosmic/i.test(desktop)) return { manual: true, note: `Add a keyboard shortcut in your desktop's settings: Super+\` runs  ${cmd}` };
   const f = COSMIC_CUSTOM(home);
   let had = ""; try { had = existsSync(f) ? readFileSync(f, "utf8") : ""; } catch {}
   try { mkdirSync(join(f, ".."), { recursive: true }); writeFileSync(f, withShortcut(had, cmd)); } catch (e) { return { error: "Couldn't write " + f + ": " + ((e && e.message) || e) }; }
-  return { ok: true, file: f, replaced: /key:\s*"s"/.test(had) };
+  return { ok: true, file: f, replaced: /key:\s*"grave"/.test(had) };
 }
 
 export { placeable, grantProfile, parseMonitors, screens, awayQueries, openAway, closeAway, awayOpen, toggleAway, withShortcut, installShortcut, COSMIC_CUSTOM };

package/guard.mjs

@@ -8,6 +8,8 @@
 //   - delete outside the agent's own folder, or wipe a disk
 //   - sudo, or pipe something from the internet into a shell
 //   - read SSH keys or cloud credentials; change Symbiot's own settings
+//   - in a sandboxed repo run (agents.mjs sandboxFor), edit or write a file outside its
+//     repo and your folders (SYMBIOT_WRITES): its commands are held there by the sandbox
 // judge(tool, input, { cwd, home }) → null (go ahead) or { why }.
 import { resolve, join, relative } from "node:path";
 import { homedir } from "node:os";
@@ -61,7 +63,7 @@ function judgeBash(cmd, { cwd, home, branch }) {
   return null;
 }
 
-function judge(tool, input = {}, { cwd = process.cwd(), home = homedir(), branch } = {}) {
+function judge(tool, input = {}, { cwd = process.cwd(), home = homedir(), branch, writes = null } = {}) {
   const t = String(tool || "");
   if (t === "Bash") return judgeBash(input.command, { cwd, home, branch: branch != null ? branch : currentBranch(cwd) });
   const p = input.file_path || input.path || input.notebook_path;
@@ -69,6 +71,7 @@ function judge(tool, input = {}, { cwd = process.cwd(), home = homedir(), branch
   const abs = expand(p, home, cwd);
   if (secretPath(abs, home)) return { why: "your keys and cloud credentials stay yours" };
   if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(t) && symbiotConfig(abs, home)) return { why: "Symbiot's own settings are yours to change" };
+  if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(t) && Array.isArray(writes) && writes.length && !writes.some((d) => under(abs, d))) return { why: "this run writes only in its repo and your folders (its sandbox), not " + p };
   return null;
 }
 
@@ -78,7 +81,8 @@ const main = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(impor
 if (main) {
   let raw = ""; try { raw = readFileSync(0, "utf8"); } catch {}
   let ev = {}; try { ev = JSON.parse(raw); } catch {}
-  const r = judge(ev.tool_name, ev.tool_input || {}, { cwd: ev.cwd || process.cwd() });
+  let writes = null; try { writes = JSON.parse(process.env.SYMBIOT_WRITES || "null"); } catch {} // a sandboxed repo run's folders
+  const r = judge(ev.tool_name, ev.tool_input || {}, { cwd: ev.cwd || process.cwd(), writes });
   if (r) { process.stderr.write("Blocked by Symbiot's membrane: " + r.why + ". If it's needed, ask the user in .symbiot/QUESTIONS.md with options.\n"); process.exit(2); }
   process.exit(0);
 }

package/handback.mjs

@@ -33,7 +33,7 @@ import { remember, actIn } from "./mind.mjs";
 import { newsSince, watchState, isMail, isSignedOut } from "./watch.mjs";
 import { inboxMail } from "./mail.mjs";
 import { desktopNotify } from "./desktop.mjs";
-import { repoPathMap } from "./scan.mjs";
+import { laneMap } from "./scan.mjs";
 
 const AWAIT_FILE = join(CONFIG_DIR, "awaiting.json");
 const RUNS_DIR = join(CONFIG_DIR, "drafts"); // runs of their own (act-…) and drafted replies
@@ -151,7 +151,7 @@ function handOn(w, r, { map, act = actIn, notify = desktopNotify, now = Date.now
 // One pass, from the app every minute: take in new waits, look for their
 // replies, and hand on the ones that came in. `news`, `inbox`, `act`, `notify`
 // and `running` can be given (the tests do).
-function awaitTick({ map = repoPathMap(), now = Date.now(), news, inbox, act, notify, running } = {}) {
+function awaitTick({ map = laneMap(), now = Date.now(), news, inbox, act, notify, running } = {}) {
   const d = loadWaits(), added = collectWaits(d, { map, running, now }), open = d.waits.filter((w) => w.status === "waiting");
   const replied = [];
   if (open.length) {

package/handover.mjs

@@ -7,6 +7,8 @@
 // buildTasksMd, mind.mjs actBrief), by lanes.mjs and by handback.mjs.
 
 const OPS = "ops";
+// Marketing across every product, a lane of its own too (marketing.mjs)
+const MARKETING = "marketing";
 const MAX_LANES_LISTED = 40;
 // How long a handover can be: an email to draft, quoted whole, fits. 4000 cut
 // the one to ops mid-email (a repo lane's task links to the rest: addTask).
@@ -15,10 +17,11 @@ const HANDOVER_MAX = 20000;
 // 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);
+  const mk = lanes.includes(MARKETING) && here !== MARKETING, others = [...new Set(lanes.filter((l) => l && l !== here && l !== MARKETING))].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.`,
+    ...(mk ? [`- \`${MARKETING}\`: marketing for any product: posts, demo videos and screenshots, launches, landing-page copy, campaigns. It drafts them for the user to approve, and never posts.`] : []),
     `- A repo, by its folder name, for work that belongs in that project${others.length ? `: ${others.map((l) => `\`${l}\``).join(", ")}` : ""}.`,
     ""];
 }
@@ -69,6 +72,14 @@ const ACTS = /\b(?:send|sent|sending|post|posted|publish|delete|remove|pay|close
 const CATCH = /\b(?:catch|before you|check|make sure|careful|fix (?:that|it)|first)\b/i;
 const NOT_THEIRS = /\bconnectors?\b|\bclaude\.ai\b/i; // a connector to sign in again shows on Home already
 const SENDS = /draft|reply|email|mail|message|post/i;
+// "when / if / once / until …" before it: it says how something behaves, not that
+// something waits on the user now ("It's lit amber when something needs you: … work
+// waiting for your OK" described a feature, and showed as a step only you could do).
+const COND = /\b(?:when|whenever|if|once|until|unless)\b/i;
+function asksNow(s) {
+  for (const re of [HELD, YOURS]) { const m = re.exec(s); if (m) { const c = COND.exec(s); if (!c || c.index > m.index) return true; } }
+  return false;
+}
 function leftToYou(text) {
   const points = String(text || "").replace(/```[\s\S]*?```/g, (m) => m.replace(/\s+/g, " ")).split(/\n+|\s+-\s+(?=\*\*)/).map((p) => p.replace(/^\s*[-*•]\s+/, "").trim()).filter(Boolean)
     .map((p) => { const lm = p.match(/^\*\*([^*]{2,60}?):?\*\*:?\s*/), body = lm ? p.slice(lm[0].length) : p;
@@ -76,7 +87,7 @@ function leftToYou(text) {
   const clean = (x, n) => { x = String(x || "").replace(/\*\*/g, "").replace(/\s+/g, " ").trim(); return x.length > n ? x.slice(0, n - 1).replace(/\s+\S*$/, "") + "…" : x; };
   for (let k = 0; k < points.length; k++) {
     const { label, ss, off } = points[k]; if (off) continue;
-    const i = ss.findIndex((s) => !DID.test(s) && (HELD.test(s) || YOURS.test(s)));
+    const i = ss.findIndex((s) => !DID.test(s) && asksNow(s));
     if (i < 0) continue;
     const s = ss[i], next = points[k + 1] && !points[k + 1].off ? points[k + 1].ss : [];
     // what to check first: the catch it named (in this point, then the next), else what it says next
@@ -104,4 +115,4 @@ function parseHandoffs(md) {
   return out.map((h) => ({ lane: h.lane, text: h.text.trim().slice(0, HANDOVER_MAX) })).filter((h) => h.lane && h.text);
 }
 
-export { OPS, HANDOVER_MAX, handoverRules, ONLY_YOU, HANDBACK, parseFacts, parseAwaiting, parseHandoffs, leftToYou };
+export { OPS, MARKETING, HANDOVER_MAX, handoverRules, ONLY_YOU, HANDBACK, parseFacts, parseAwaiting, parseHandoffs, leftToYou };

package/home.mjs

@@ -11,42 +11,28 @@
 // same Symbiot as every chat (mind.mjs converse), told what home shows.
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { readFileSync, writeFileSync } from "node:fs";
-import { watchBoard } from "./watch.mjs";
-import { pendingReview, pushTasks } from "./tasks.mjs";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { watchBoard, draftReply } from "./watch.mjs";
+import { pendingReview, pushTasks, addTask } from "./tasks.mjs";
 import { agentsList, runHandoff, runningHandoff, handoffCmd, connectorsInfo, parkedPaths, agentMissing, settleNeeds, pickAgent } from "./agents.mjs";
 import { linksState } from "./links.mjs";
 import { knowledgeState } from "./knowledge.mjs";
-import { CONFIG_DIR, loadTasks } from "./core.mjs";
+import { CONFIG_DIR, loadTasks, saveTasks } from "./core.mjs";
 import { lanesState, stuckHandovers, allowHandover, skipHandover } from "./lanes.mjs";
-import { converse, actIn, actNow, taskIn } from "./mind.mjs";
-import { repoPathMap } from "./scan.mjs";
+import { converse, actIn, actNow, taskIn, loadMind } from "./mind.mjs";
+import { repoPathMap, laneMap } from "./scan.mjs";
 import { resolveProvider } from "./ai.mjs";
-import { reportsNews } from "./reports.mjs";
+import { reportsNews, listReports } from "./reports.mjs";
 import { awaitingState, inboxSight } from "./handback.mjs";
 import { newClashes } from "./checks.mjs";
 import { postsState } from "./post.mjs";
+import { MARKETING, MARKETING_DIR, MARKETING_WORDS, displayName, productNames, productOf, untagged, tagged, draftFiles } from "./marketing.mjs";
 
 const KEEP = 15000; // the slower reads (git per repo awaiting review) are cached this long
 let cached = null;
 const RUNS = join(CONFIG_DIR, "drafts"); // an ops run's folder (mind.mjs actNow): its own lane, not a repo
 const RUNS_LANE = "ops"; // what the work scene calls them all, together
 
-// A project's name as people say it: the folder can lag behind (CallForge AI is
-// Dailify). The README's title when it's a short name, else package.json's name
-// when it's a word, else the folder's. Read once per folder.
-const NAMES = new Map();
-function displayName(path, folder) {
-  folder = String(folder || ""); if (!path) return folder;
-  if (NAMES.has(path)) return NAMES.get(path);
-  const read = (f) => { try { return readFileSync(join(path, f), "utf8"); } catch { return ""; } };
-  const plainName = (s) => { s = String(s || "").replace(/[*`[\]]|^_+|_+$/g, "").trim(); return s && s.length <= 32 && s.split(/\s+/).length <= 4 && !/[:—–|]|\s-\s/.test(s) ? s : ""; };
-  const h1 = plainName((read("README.md").match(/^#\s+(.+?)\s*#*\s*$/m) || [])[1]);
-  let pkg = ""; try { pkg = String(JSON.parse(read("package.json")).name || "").replace(/^@[^/]+\//, ""); } catch {}
-  const name = h1 || (/^[a-z][a-z0-9-]{1,30}$/i.test(pkg) && pkg.toLowerCase() !== folder.toLowerCase().replace(/\s+/g, "-") ? pkg.charAt(0).toUpperCase() + pkg.slice(1) : "") || folder;
-  NAMES.set(path, name);
-  return name;
-}
 // The lane a folder is: the repo it is (by the scan's map), or an ops run.
 const laneOfPath = (path, map) => Object.keys(map || {}).find((n) => map[n] === path) || (String(path || "").startsWith(RUNS) ? "" : null);
 
@@ -85,6 +71,165 @@ function troubles({ stuck = [], list = [], map = {}, named = displayName, now =
   }
   return out;
 }
+
+// ---- next up: what can be done when nothing waits on you ----------------------------
+// With "Only the user can do" empty, Home suggests a few things that CAN be done next,
+// each with its gain spelled out and one tap that starts an agent or makes a task
+// (homeNext), from what Symbiot already knows: unread reports, a task with no project,
+// a handover that errored and was left, a project's tasks waiting days for its agent,
+// new mail or chats with no reply, and a decision you made that no task carries yet.
+// One you took stays away a week (NEXT_FILE); the app lets you dismiss the box.
+const NEXT_FILE = join(CONFIG_DIR, "home-next.json"), NEXT_MAX = 5, NEXT_KEEP = 7 * 86400000, DAY = 86400000;
+const STALE_AFTER = 3 * DAY, RETRY_WITHIN = 14 * DAY, DECIDED_WITHIN = 14 * DAY;
+function loadNext(file = NEXT_FILE) { try { const d = JSON.parse(readFileSync(file, "utf8")); return d && typeof d.taken === "object" && d.taken ? d : { taken: {} }; } catch { return { taken: {} }; } }
+function saveNext(d, file = NEXT_FILE) { try { mkdirSync(CONFIG_DIR, { recursive: true }); writeFileSync(file, JSON.stringify(d), { mode: 0o600 }); } catch {} }
+// a remembered decision that asks for something to be done ("the user wants…", "decided to…"), not a fact about how things are
+const WANTS = /\b(?:wants?|decided|asked for|plans? to|going to|agreed to)\b/i;
+const words4 = (s) => new Set(String(s || "").toLowerCase().match(/[a-z0-9]{4,}/g) || []);
+// The lane a task's words name (whatsapp_module for "…the WhatsApp module…"), or "".
+function laneNamed(text, lanes) {
+  const t = " " + String(text || "").toLowerCase().replace(/[^a-z0-9]+/g, " ") + " ";
+  let best = "", len = 0;
+  for (const l of lanes) { const k = l.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim(); if (k.length >= 4 && k.length > len && t.includes(" " + k + " ")) { best = l; len = k.length; } }
+  return best;
+}
+const ago = (ms) => { const d = Math.floor(ms / DAY); return d >= 2 ? `${d} days` : d === 1 ? "a day" : "today"; };
+// [{ id, title, gain, time, act: "agent"|"task"|"drafts"|"retry"|"go"|"assign", label }], best first.
+function nextUp({ now = Date.now(), map = {}, list = [], named = displayName, deps = {} } = {}) {
+  const tryOr = (f, d) => { try { return f(); } catch { return d; } };
+  const taken = (deps.taken || (() => loadNext().taken))() || {};
+  const fresh = (id) => !(taken[id] && now - taken[id] < NEXT_KEEP);
+  const lanes = Object.keys(map), out = [];
+  const busy = new Set(list.filter((a) => a.status === "running").map((a) => laneOfPath(a.path, map)).filter(Boolean));
+  const parked = new Set(tryOr(deps.parked || parkedPaths, []) || []);
+  const allTasks = (tryOr(deps.tasks || loadTasks, []) || []).filter(Boolean), tasks = allTasks.filter((t) => !t.done && !t.archived && !t.review);
+  // unread reports: an agent reads them all and leaves one page, their next steps as ideas you add in a click
+  const rep = tryOr(deps.reports || reportsNews, { count: 0 }) || { count: 0 };
+  if (rep.count && fresh("next:reports")) out.push({ id: "next:reports", title: `Triage the ${rep.count} unread report${rep.count > 1 ? "s" : ""}`, gain: `clears the backlog: one page to read, and their next steps as tasks you add in a click`, time: `~${Math.max(5, Math.min(30, Math.ceil(rep.count * 1.25 / 5) * 5))} min, by an agent`, act: "agent", label: "Start an agent" });
+  // a handover that errored and was left (older than Home's asks): run it on its own
+  const retry = (tryOr(() => (deps.stuck || stuckHandovers)({ now, within: RETRY_WITHIN }), []) || []).filter((h) => fresh("next:retry:" + h.id));
+  for (const h of retry.slice(0, 1)) out.push({ id: "next:retry:" + h.id, title: `Retry ${h.from.lane}'s handover: ${plain(firstLine(h.text), 70)}`, gain: `it errored ${ago(now - (h.at || now))} ago (${plain(String(h.error || "").replace(/[.\s]+$/, ""), 60) || "it didn't start"}), and ${h.from.lane}'s agent carries on once it's done`, time: "runs by itself", act: "retry", label: "Retry it" });
+  // a project's tasks waiting days for its agent, nothing at work there
+  const byRepo = {};
+  for (const t of tasks) if (t.repo && map[t.repo] && !busy.has(t.repo) && !parked.has(map[t.repo])) (byRepo[t.repo] = byRepo[t.repo] || []).push(t);
+  const stale = Object.keys(byRepo).map((r) => ({ repo: r, n: byRepo[r].length, oldest: Math.min(...byRepo[r].map((t) => Number(t.ts) || now)) }))
+    .filter((g) => now - g.oldest > STALE_AFTER && fresh("next:go:" + g.repo)).sort((a, b) => a.oldest - b.oldest);
+  for (const g of stale.slice(0, 2)) out.push({ id: "next:go:" + g.repo, title: `Send ${named(map[g.repo], g.repo)}'s ${g.n} waiting task${g.n > 1 ? "s" : ""} to its agent`, gain: `the oldest has waited ${ago(now - g.oldest)}, and nothing is at work there`, time: "runs by itself", act: "go", label: "Start its agent" });
+  // a task with no project: the project its words name gets it, else an agent of its own
+  for (const t of tasks.filter((x) => !x.repo && fresh("next:float:" + x.id)).slice(0, 1)) {
+    const lane = laneNamed(t.text, lanes);
+    out.push({ id: "next:float:" + t.id, title: `${lane ? `Give ${named(map[lane], lane)}` : "Start"} "${plain(t.text, 60)}"`, gain: lane ? `it has no project, so no agent picks it up: ${lane}'s agent takes it now` : "it has no project, so no agent picks it up: one of its own starts on it", time: "runs by itself", act: lane ? "assign" : "agent", label: "Start an agent", ...(lane ? { repo: lane } : {}) });
+  }
+  // new mail or chats with no reply: your agent drafts them, unsent, for you to check
+  const cards = ((tryOr(deps.board || (() => watchBoard(24, now)), { cards: [] }) || {}).cards || []).filter((c) => c.count > 0 && /^(mail|chat|social)$/.test(c.source || "") && fresh("next:drafts:" + c.id));
+  for (const c of cards.slice(0, 1)) { const k = Math.min(3, c.count), where = plain(String(c.name || "").split(" - ")[0], 30);
+    out.push({ id: "next:drafts:" + c.id, title: c.count > k ? `Draft replies to the newest ${k} of the ${c.label} on ${where}` : `Draft replies to the ${c.label} on ${where}`, gain: "each waits as a draft, unsent, for you to check and send", time: `~${k * 3} min, by an agent`, act: "drafts", label: "Draft replies" }); }
+  // a decision you made lately (Symbiot's memory) that no open task carries yet
+  if (out.length < 3) {
+    const nodes = (tryOr(deps.mind || (() => loadMind().nodes), []) || []).filter((n) => n.kind === "decision");
+    const carried = allTasks.map((t) => words4(t.text)); // done or not: what a task already took on
+    const facts = nodes.flatMap((n) => (n.facts || []).map((f) => ({ n, f }))).filter(({ f }) => now - (f.ts || 0) < DECIDED_WITHIN).sort((a, b) => b.f.ts - a.f.ts);
+    for (const { n, f } of facts) {
+      const id = "next:decision:" + n.id + ":" + (f.ts || 0), w = words4(f.text);
+      if (!fresh(id) || !WANTS.test(f.text) || carried.some((c) => [...w].filter((x) => c.has(x)).length >= Math.max(3, w.size * 0.5))) continue;
+      const lane = laneNamed(n.name + " " + f.text, lanes);
+      out.push({ id, title: `Make a task of what you decided: ${plain(f.text, 70)}`, gain: `so it's done${lane ? ` in ${named(map[lane], lane)}` : ""}, not only remembered`, time: "a tap", act: "task", label: "Make a task", ...(lane ? { repo: lane } : {}), text: f.text });
+      break;
+    }
+  }
+  return out.slice(0, NEXT_MAX);
+}
+// Take a suggestion (its id, from homeState's next): it starts its agent or makes
+// its task, and stays away a week. { ok, said } or { error }.
+function homeNext(id, deps = {}) {
+  id = String(id || ""); cached = null;
+  const h = deps.state || homeState({ fresh: true }), s = (h.next || []).find((x) => x.id === id);
+  if (!s) return { error: (h.you || []).length ? "Something needs you first: it's at the top of Home." : "That suggestion isn't here any more." };
+  const map = (deps.repos || (() => { try { return laneMap(); } catch { return {}; } }))() || {};
+  const run = deps.run || runHandoff, ref = id.split(":").slice(2).join(":");
+  let r;
+  if (s.act === "agent" && id === "next:reports") {
+    const reps = (deps.reportsList || listReports)({ map }).filter((x) => x.new).slice(0, 20);
+    if (!reps.length) return { error: "No unread reports left." };
+    r = (deps.act || actNow)(`Triage the user's ${reps.length} unread Symbiot reports, so they read one page instead of ${reps.length}. Read each:\n${reps.map((x) => `- ${x.title} (${x.lane || "ops"}): ${x.file}`).join("\n")}\n\nWrite \`.symbiot/REPORTS-TRIAGE.md\` (a "# " title first): per report, two lines at most on what it found and what's still open, the ones that need a decision first. Put each open next step under \`## Suggestions\` in \`.symbiot/QUESTIONS.md\`, starting with its project's folder name (\`- [repo: <lane>] …\`), so the user adds it as a task in a click. Change nothing else.`, { title: "Home: what's next" });
+  } else if (s.act === "agent") {
+    const t = (deps.tasks || loadTasks)().find((x) => x.id === ref); if (!t) return { error: "That task isn't on the list any more." };
+    r = (deps.act || actNow)(`${t.text}\n\n(This was on the user's task list with no project. If it belongs in one of their repos, hand it over to that lane.)`, { title: "Home: what's next" });
+  } else if (s.act === "assign") {
+    const all = (deps.tasks || loadTasks)(), t = all.find((x) => x.id === ref); if (!t) return { error: "That task isn't on the list any more." };
+    t.repo = s.repo; (deps.save || saveTasks)(all);
+    r = goLane(s.repo, map, { push: deps.push, run });
+  } else if (s.act === "go") r = goLane(ref, map, { push: deps.push, run });
+  else if (s.act === "retry") r = (deps.allow || allowHandover)(ref, {});
+  else if (s.act === "task") r = (deps.task || taskIn)(s.text, s.repo || "", { map });
+  else if (s.act === "drafts") {
+    const card = ((deps.board || (() => watchBoard(24)))().cards || []).find((c) => c.id === ref), items = ((card && card.items) || []).filter((n) => n.need).slice(0, 3);
+    if (!items.length) return { error: "Nothing there waits for a reply any more." };
+    const done = items.map((n) => (deps.draft || draftReply)(n.id, { run })), okN = done.filter((x) => x && x.ok).length;
+    r = okN ? { ok: true, n: okN } : done[0];
+  }
+  if (!r || r.error) return { error: (r && r.error) || "It didn't start. Check your agent in Settings." };
+  const d = loadNext(deps.file); d.taken[id] = Date.now(); for (const k of Object.keys(d.taken)) if (Date.now() - d.taken[k] > NEXT_KEEP) delete d.taken[k]; saveNext(d, deps.file);
+  const said = s.act === "task" ? `It's a task now${s.repo ? ` in ${s.repo}` : ""}.` : s.act === "drafts" ? `Your agent is drafting ${r.n} repl${r.n > 1 ? "ies" : "y"}. They wait, unsent, for you to check.` : s.act === "retry" ? "Started it as a run of its own. What it does goes back to the agent that asked." : r.queued ? "Its agent takes it once the run there now finishes." : "An agent started on it. It's on the Workdesk.";
+  return { ok: true, said };
+}
+// A lane's waiting tasks to its agent, the way Go does for one project.
+function goLane(repo, map, { push = pushTasks, run = runHandoff } = {}) {
+  if (!map[repo]) return { error: `${repo} isn't one of your projects any more.` };
+  const p = (push || pushTasks)({ repo }); if (!p || !p.written || !p.written.length) return { error: `Nothing of ${repo}'s is waiting to start.` };
+  const e = (run || runHandoff)(map[repo]); if (!e) return { error: "The agent didn't start. Check its command in Settings → Handoff." };
+  return e.parked ? { error: `${repo} is parked: unpark it to start its agent.` } : { ok: true, ...(e.busy || e.blocked ? { queued: true } : { job: e.id }) };
+}
+
+// ---- Marketing: a lane of its own, across products (marketing.mjs) ----------------------
+// What its page shows, and its orb on Home: what needs you there (its agent's questions,
+// its work waiting for your OK, the week's post drafts waiting on you), its tasks with the
+// product each markets, other lanes' tasks about marketing, and what its agent drafted.
+// on: whether Home shows its orb (once posts can be drafted, or it has anything at all).
+function marketingState({ deps = {}, list, pend, map, named = displayName } = {}) {
+  const tryOr = (f, d) => { try { return f(); } catch { return d; } };
+  map = map || tryOr(deps.repos || laneMap, {}) || {};
+  const dir = map[MARKETING] || MARKETING_DIR;
+  const posts = tryOr(deps.posts || postsState, null) || { posts: [], done: [] };
+  const tasks = (tryOr(deps.tasks || loadTasks, []) || []).filter((t) => t && !t.done && !t.archived);
+  // the products to tag by: your repos', the ones tasks were tagged with, and those its agent drafted for
+  const known = [...new Set([...productNames(map), ...tasks.map((t) => productOf(t.text)).filter(Boolean)])];
+  const files = tryOr(() => (deps.files || draftFiles)(dir, known), []) || [];
+  const names = [...new Set([...known, ...files.map((f) => f.product).filter(Boolean)])];
+  list = list || tryOr(deps.agents || agentsList, []) || [];
+  const run = list.find((a) => a.path === dir), qs = (run && run.ask && run.ask.questions) || [], working = !!(run && run.status === "running");
+  const needs = qs.map((q, i) => ({ kind: "ask", id: "ask:" + i, text: plain(q.q, 160), options: (q.options || []).slice(0, 2), product: productOf(q.q, names) }));
+  const ready = (pend || tryOr(deps.pending || pendingReview, []) || []).find((r) => r.repo === MARKETING && r.path && !r.running && ((r.tasks || []).length || (r.files || []).length));
+  if (ready) { const n = (ready.tasks || []).length, f = (ready.files || []).length; needs.push({ kind: "approve", id: "approve", text: `${n ? `${n} piece${n > 1 ? "s" : ""} of marketing done` : "Marketing's agent changed things without a task"}${f ? ` · ${f} file${f > 1 ? "s" : ""}` : ""}: only you decide`, count: n || f }); }
+  for (const p of (posts.posts || []).filter((x) => x.status === "waiting")) needs.push({ kind: "draft", id: "draft:" + p.id, text: plain(firstLine(p.text), 120), product: productOf(p.text, names) });
+  const lane = tasks.filter((t) => t.repo === MARKETING).map((t) => ({ id: t.id, text: plain(untagged(t.text), 220), product: productOf(t.text, names), status: t.review ? "review" : working ? "working" : "waiting", ts: t.ts || 0 }));
+  const elsewhere = tasks.filter((t) => t.repo !== MARKETING && MARKETING_WORDS.test(t.text)).slice(0, 12).map((t) => ({ id: t.id, text: plain(untagged(t.text), 220), product: productOf(t.text, names), repo: t.repo || "", name: t.repo ? named(map[t.repo], t.repo) : "" }));
+  const seen = [...new Set([...lane, ...elsewhere, ...needs, ...files].map((x) => x.product).filter(Boolean))];
+  const on = !!(posts.canDraft || (posts.posts || []).length || (posts.done || []).length || lane.length || elsewhere.length || files.length || needs.length || run);
+  return { on, needs, needCount: needs.length, lane, elsewhere, files: files.map(({ rel, name, product, at }) => ({ rel, name, product, at })), products: [...new Set([...seen, ...names])], working, waiting: lane.filter((t) => t.status === "waiting").length };
+}
+// A task for Marketing, tagged with the product it markets (the page's Add). The task or { error }.
+function marketingTask(text, product = "", { add = addTask } = {}) {
+  text = String(text || "").trim(); if (!text) return { error: "Say what the marketing task is." };
+  cached = null; return add(tagged(text, product), MARKETING);
+}
+// Another lane's task about marketing, moved to Marketing (and tagged): its agent takes it
+// from then on. Not one waiting for your OK: approve or send it back where it is first.
+function moveToMarketing(id, product = "", { load = loadTasks, save = saveTasks, map } = {}) {
+  const all = load(), t = all.find((x) => x.id === String(id || ""));
+  if (!t || t.done || t.archived) return { error: "That task isn't open any more." };
+  if (t.review) return { error: "It waits for your OK where it is: approve it or send it back first." };
+  if (product || !/^\s*\[/.test(t.text)) t.text = tagged(t.text, product || productOf(t.text, productNames(map || (() => { try { return laneMap(); } catch { return {}; } })())));
+  t.repo = MARKETING; save(all); cached = null;
+  return { ok: true, id: t.id };
+}
+// Start Marketing's agent on its waiting tasks (the page's Start its agent). { ok } or { error }.
+function marketingGo(deps = {}) {
+  cached = null;
+  const map = (deps.repos || (() => { try { return laneMap(); } catch { return {}; } }))() || {};
+  return goLane(MARKETING, map, { push: deps.push, run: deps.run });
+}
+
 // { you: [{ kind, id, title, sub, shape, … }], feeds: [{ id, title, sub, count, shape }],
 //   lanes: [{ from, to, text, status, times }], working: n, at }
 // An ask carries what its blob on home needs: the lane (repo, or "" for an ops
@@ -97,7 +242,7 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   const lanes = deps.lanes || (() => { try { return lanesState(); } catch { return { handoffs: [] }; } });
   const reports = deps.reports || (() => { try { return reportsNews(); } catch { return { count: 0 }; } });
   const connected = deps.connected || (() => !!resolveProvider());
-  const repos = deps.repos || (() => { try { return repoPathMap(); } catch { return {}; } });
+  const repos = deps.repos || (() => { try { return laneMap(); } catch { return {}; } });
   const waits = deps.waits || (() => { try { return awaitingState().waits; } catch { return []; } });
   const clashes = deps.clashes || (() => { try { return newClashes(); } catch { return []; } });
   // can a reply be noticed? Email on (mail on this computer), or an inbox watched and signed in
@@ -108,8 +253,8 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   const stuck = deps.stuck || (() => { try { return stuckHandovers({ now }); } catch { return []; } });
   const agentCmd = deps.agentCmd || (() => { try { return handoffCmd(); } catch { return "x"; } });
   const offer = deps.pickAgent || (() => { try { return pickAgent(); } catch { return null; } });
-  // Marketing (its own section, off the Dashboard) once posts can be drafted, or there are some
-  const marketing = deps.marketing || (() => { try { const p = postsState(); return !!(p.canDraft || p.posts.length || p.done.length); } catch { return false; } });
+  // Marketing, a lane of its own across products: its orb, lit when something there needs you
+  const marketing = deps.marketing || ((o) => { try { const m = marketingState(o); return m.on ? { needs: m.needCount, working: m.working, waiting: m.waiting } : false; } catch { return false; } });
   const named = deps.name || displayName;
   const you = [], map = repos() || {};
   // What Symbiot works through (an AI, your agent, the connectors runs use) shows
@@ -118,11 +263,12 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   if (!connected()) you.push({ kind: "setup", id: "setup:ai", urgent: true, title: "Connect an AI", sub: "Symbiot can't work without one: a key, or a free local model", shape: "settings", focus: "ai" });
   const gone = agentGone(); if (gone) you.push({ kind: "setup", id: "setup:agent", urgent: true, title: "Your agent is unavailable", sub: `${gone} isn't on this computer any more, so no task can start`, shape: "settings", focus: "agent" });
   for (const c of signedOut()) you.push({ kind: "setup", id: "setup:conn:" + c.id, urgent: true, title: `Reconnect ${c.name}`, sub: `its Claude connector is signed out, so agent runs can't use ${c.name}`, shape: "settings", focus: "agent" });
-  if (!Object.keys(map).length) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings", focus: "work" });
+  if (!Object.keys(map).some((n) => map[n] !== MARKETING_DIR)) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings", focus: "work" });
   // no agent yet: Send to repos and Go would only write TASKS.md files nothing runs, so
   // Home didn't say "All handled" truthfully. One click for the one on this computer.
   if (!agentCmd()) { const p = offer(); you.push({ kind: "setup", id: "setup:pick", title: "Pick your agent", sub: p ? `${p.name} is on this computer: one click and it takes your tasks` : "the coding agent that takes your tasks", shape: "settings", focus: "agent", ...(p ? { pick: { name: p.name, tmpl: p.tmpl } } : {}) }); }
-  for (const r of pending()) {
+  const pend = pending();
+  for (const r of pend) {
     if (!r.path || r.running) continue;
     const n = (r.tasks || []).length, files = (r.files || []).length;
     if (!n && !files) continue;
@@ -149,7 +295,7 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
       ? { kind: "setup", id: "setup:inbox", signin: true, title: `Sign in to ${sight.signedOut[0]} again`, sub: "it's signed out, so I won't notice their reply", shape: "settings", focus: "links" }
       : { kind: "setup", id: "setup:inbox", title: "Let me see your inbox", sub: "so I notice their reply", shape: "settings", focus: "links" });
   }
-  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 bd = board() || {}, feeds = (bd.cards || []).filter((c) => c.count > 0).map((c) => ({ id: "feed:" + c.id, title: c.name, sub: c.label, count: c.count, shape: "board" }));
   // a clash in your files that matters (checks.mjs: high), first under Watching, until you've opened it
   const clash = clashes();
   if (clash.length) feeds.unshift({ id: "feed:clash", title: "Where your files disagree", sub: `${clash.length} clash${clash.length > 1 ? "es" : ""} to look at`, latest: plain(clash[0].text, 140), count: clash.length, shape: "settings" });
@@ -157,7 +303,9 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   if (rep.count) feeds.push({ id: "feed:reports", title: "Reports", sub: `${rep.count} unread`, latest: rep.latest, count: rep.count, shape: "reports" });
   const hs = ((lanes() || {}).handoffs || []).slice(0, 5).map((h) => ({ from: h.from, to: h.to, text: h.text, status: h.status, ...(h.times > 1 ? { times: h.times } : {}) }));
   const working = list.filter((a) => a.status === "running").length;
-  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, marketing: marketing(), at: now };
+  // nothing waits on you: a few things that can be done next (none while anything does)
+  const next = you.length ? [] : nextUp({ now, map, list, named, deps: { board: () => bd, reports: () => rep, ...(deps.next || {}) } });
+  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, next, marketing: marketing({ list, map, named, pend }), at: now };
   if (!deps.board) cached = out;
   return out;
 }
@@ -203,7 +351,7 @@ function homeAnswer(id, { pick, text = "" } = {}, deps = {}) {
     if (e && e.id && !e.blocked) { settle(a.path, n.key); dropped.add(id); }
     return e && e.id && !e.blocked ? { ok: true, said: n.kind === "approve" ? "Its agent is going ahead." : "Its agent is checking and carrying on.", rerun: e.id } : { error: (e && e.note) || "It didn't start. Check your agent in Settings." };
   }
-  return { error: "Answer that one on its block in Agents." };
+  return { error: "Answer that one on its block on the Workdesk." };
 }
 
 // Settings' first steps, in the order they matter (FIRST-RUN-AUDIT.md: a new user
@@ -243,6 +391,8 @@ function homeContext(h) {
     `Only the user can do (${h.you.length}):`, ...h.you.map((y) => `- ${y.title}: ${y.sub}${y.q && y.q !== y.sub ? ` (asks: ${y.q}${(y.options || []).length ? ` ${y.options.join(" / ")}` : ""})` : ""}`),
     `New on what they watch:`, ...(h.feeds.length ? h.feeds.map((f) => `- ${f.title}: ${f.sub}${f.latest ? ` (latest: ${f.latest})` : ""}`) : ["- nothing new"]),
     `Agents working: ${h.working}. Recent handovers:`, ...(h.lanes.length ? h.lanes.map((l) => `- ${l.from} → ${l.to}: ${l.text} (${l.status}${l.times ? `, handed over ${l.times} times` : ""})`) : ["- none"]),
+    ...(h.marketing ? [`Marketing (a lane of its own, for marketing across all their products; "repo": "${MARKETING}"): ${h.marketing.needs ? `${h.marketing.needs} thing${h.marketing.needs > 1 ? "s" : ""} there need${h.marketing.needs > 1 ? "" : "s"} them` : "nothing needs them"}${h.marketing.working ? ", its agent is at work" : ""}.`] : []),
+    ...((h.next || []).length ? ["Could be done next (Home suggests these, one tap each):", ...h.next.map((s) => `- ${s.title}: ${s.gain} (${s.time})`)] : []),
   ].join("\n");
 }
 
@@ -256,7 +406,7 @@ async function homeAsk(question, { ask, now = Date.now(), state, images = [] } =
   const shotNote = pics.length ? `\n\nScreenshots the user attached (open them with your Read tool): ${pics.map((i) => i.path).join(", ")}` : "";
   if (!ask && !resolveProvider()) return { error: "not-connected" };
   const h = state || homeState({ now });
-  let map = {}; try { map = repoPathMap(); } catch {}
+  let map = {}; try { map = laneMap(); } 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: question + (pics.length ? `\n(The user attached ${pics.length} screenshot${pics.length > 1 ? "s" : ""}: you can see ${pics.length > 1 ? "them" : "it"}.)` : ""), map, now, images: pics.map(({ mime, data }) => ({ mime, data })), ...(ask ? { ask } : {}),
     act: {
@@ -280,7 +430,7 @@ function workScene({ deps = {} } = {}) {
   const agents = deps.agents || (() => { try { return agentsList(); } catch { return []; } });
   const pending = deps.pending || (() => { try { return pendingReview(); } catch { return []; } });
   const tasks = deps.tasks || (() => { try { return loadTasks(); } catch { return []; } });
-  const map = (deps.repos || (() => { try { return repoPathMap(); } catch { return {}; } }))() || {};
+  const map = (deps.repos || (() => { try { return laneMap(); } catch { return {}; } }))() || {};
   const named = deps.name || displayName;
   const parked = new Set((deps.parked || (() => { try { return parkedPaths(); } catch { return []; } }))());
   const isParked = (repo) => !!map[repo] && parked.has(map[repo]);
@@ -343,4 +493,4 @@ function workGo({ push = pushTasks, run = runHandoff } = {}) {
   return { started, queued, repos, ...(parked.length ? { parked } : {}), ...(r.unresolved && r.unresolved.length ? { unresolved: r.unresolved.map((u) => u.name) } : {}) };
 }
 
-export { homeState, homeContext, homeAsk, homeAnswer, workScene, workGo, displayName, firstSteps };
+export { marketingState, marketingGo, marketingTask, moveToMarketing, goLane, homeState, homeContext, homeAsk, homeAnswer, homeNext, nextUp, laneNamed, NEXT_FILE, workScene, workGo, displayName, firstSteps };

package/index.mjs

@@ -329,16 +329,16 @@ async function viaApp(path, body) {
   } catch (e) { return { error: "Lost Symbiot's app mid-way: " + ((e && e.message) || e) }; }
 }
 // symbiot away: Symbiot full screen on every screen (again: closes it). --shortcut:
-// Super+S runs it (on COSMIC it's set up; elsewhere it says how).
+// Super+` runs it (on COSMIC it's set up; elsewhere it says how).
 async function cmdAway() {
   if (has("shortcut")) {
     const { installShortcut } = await import("./away.mjs");
     const r = installShortcut({ cmd: `${process.execPath} ${process.argv[1]} away` });
     if (r.error) { console.log(c.y(r.error)); process.exitCode = 1; return; }
-    console.log(r.manual ? r.note : `${c.g("✓")} Super+S now opens Away${r.replaced ? " (it replaces what Super+S did before)" : ""}. ${c.d(r.file)}`);
+    console.log(r.manual ? r.note : `${c.g("✓")} Super+\` (the key above Tab) now opens Away. ${c.d(r.file)}`);
     return;
   }
-  const r = await viaApp("/api/away", {});
+  const r = await viaApp("/api/away", { open: "toggle" });
   if (!r) { console.log(c.y("Symbiot's app isn't running.") + c.d("  Start it with  symbiot app,  then Away works.")); process.exitCode = 1; return; }
   if (r.error) { console.log(c.y(r.error)); process.exitCode = 1; }
 }
@@ -768,7 +768,7 @@ ${c.b("Usage")}
   symbiot todo                      what's still on your plate
   symbiot app                       open the visual app in your browser
   symbiot away [--shortcut]         Symbiot full screen on every screen while you're away;
-                                    again closes it. --shortcut: Super+S does it
+                                    again closes it. --shortcut: Super+\` does it
   symbiot app --fresh [--keep]      try it as someone new: a brand-new Symbiot in
                                     a throwaway home, none of your data or accounts
   symbiot drift [--fetch]           what's out of sync / at risk across repos

package/lanes.mjs

@@ -24,7 +24,7 @@ import { CONFIG_DIR, loadTasks, clipWords } from "./core.mjs";
 import { runHandoff, runningHandoff, waitingFor, agentQuestions, findOrcaCli, installAllowlist } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
 import { actNow } from "./mind.mjs";
-import { repoPathMap } from "./scan.mjs";
+import { laneMap } from "./scan.mjs";
 import { parseRun, lastRunText, readRunLog } from "./work.mjs";
 import { OPS, parseHandoffs } from "./handover.mjs";
 
@@ -53,7 +53,7 @@ function laneTarget(lane, map) {
 
 // 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() } = {}) {
+function dispatch(path, { map = laneMap(), 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 = [];
@@ -151,7 +151,7 @@ function report(e, o, { run = runHandoff, running = runningHandoff, waiting = wa
 
 // 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(), relink = orcaRelink } = {}) {
+function lanesTick({ map = laneMap(), act = actNow, run = runHandoff, running = runningHandoff, add = addTask, push = pushTasks, tasks, now = Date.now(), relink = orcaRelink } = {}) {
   const ledger = loadLedger();
   let acts = []; try { acts = readdirSync(ACT_DIR).filter((d) => d.startsWith("act-")).map((d) => join(ACT_DIR, d)); } catch {}
   const started = [];
@@ -208,10 +208,10 @@ function pastIt(e, hs) {
 }
 // The errored handovers that still wait on you, newest first:
 // [{ id, from, text, error, at, dirs, q, options }].
-function stuckHandovers({ ledger = loadLedger(), now = Date.now(), dirsOf = namedDirs } = {}) {
+function stuckHandovers({ ledger = loadLedger(), now = Date.now(), dirsOf = namedDirs, within = STUCK_FOR } = {}) {
   const hs = ledger.handoffs, out = [];
   hs.forEach((e) => {
-    if (e.status !== "error" || e.skipped || now - (e.at || 0) > STUCK_FOR) return;
+    if (e.status !== "error" || e.skipped || now - (e.at || 0) > within) return;
     if (pastIt(e, hs)) return;
     const dirs = dirsOf(e.text, e.from.path);
     out.unshift({ id: e.id, from: e.from, text: e.text, error: e.error || "", at: e.at, dirs,
@@ -286,7 +286,7 @@ async function orcaRelink({ map, cli, orca = runOrca, remoteOf } = {}) {
   if (process.env.SYMBIOT_SANDBOX) return { moves: [] };
   cli = cli ?? findOrcaCli(); if (!cli) return { moves: [] };
   let repos = []; try { repos = JSON.parse(await orca(cli, ["repo", "list", "--json"])).result.repos || []; } catch { return { moves: [] }; }
-  const moves = await orcaMoves(repos, map || repoPathMap(), { remoteOf });
+  const moves = await orcaMoves(repos, map || laneMap(), { remoteOf });
   for (const m of moves) m.ok = /"ok":\s*true/.test(await orca(cli, ["repo", "add", "--path", m.to, "--json"]));
   return { moves };
 }