symbiot 0.55.1 → 0.55.3

package/index.mjs

@@ -32,7 +32,7 @@ import { fileURLToPath } from "node:url";
 import { EMBEDDED_UI } from "./ui.mjs";
 import { VERSION, CONFIG_PATH, loadConfig, saveConfig, repoState, semverGt } from "./core.mjs";
 import { HANDOFF_PROMPT, CLAUDE_CMD, ORCA_CLAUDE_CMD, handoffCmd, setHandoffCmd, fillHandoff, runHandoff, orcaHandoffCmd, migrateOrcaCmd, migrateClaudeCmd, parseQuestions, agentQuestions } from "./agents.mjs";
-import { AI_UI, PROVIDERS, resolveProvider, validate, detectHardware, recommendModels, hasOllama, ollamaInstall, ensureOllama, useOllamaModel } from "./ai.mjs";
+import { AI_UI, PROVIDERS, resolveProvider, validate, detectHardware, recommendModels, hasOllama, ollamaInstall, ensureOllama, useOllamaModel, claudeState, connectProvider } from "./ai.mjs";
 import { setScanOptions, scanBase, authorship, readmeInfo, repoShape, houseRules, reportFooter, findAllRepos, buildMap } from "./scan.mjs";
 import { gitDefaultBranch, loadDeploys, driftRepo, computeDrift } from "./drift.mjs";
 import { buildTasksMd, taskType, shipChanges, shipWithBump, bumpOffer, learnNpm, releaseNeeded, withReleases, setVersion, syncTasks, pendingReview, unreleased, publishesOnMerge, addTask, approveRepo, approveChanges, sendBack, pushTasks } from "./tasks.mjs";
@@ -118,7 +118,7 @@ function ask(question, { secret = false } = {}) {
 
 const AUTH_HELP =
   c.y("Symbiot needs an AI to write your updates. Connect one:\n") +
-  "  " + c.b("symbiot login") + c.d("   pick Claude, OpenAI, Gemini, or a local model (Ollama)") + "\n" +
+  "  " + c.b("symbiot login") + c.d("   your Claude subscription (Claude Code, no key), Claude, OpenAI, Gemini or a local model") + "\n" +
   c.d("  Or set a key in your environment: ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY.");
 // What writing with the AI (ai.mjs) shows in the terminal.
 Object.assign(AI_UI, {
@@ -215,26 +215,34 @@ async function cmdLogin() {
   const flagProvider = flag("provider", null);
   const existing = resolveProvider();
   if (existing && !flagProvider && !flag("key", null) && !has("force")) {
-    console.log(c.g("✓ ") + `Already connected — ${PROVIDERS[existing.provider].label} via ${existing.source}.`);
+    console.log(c.g("✓ ") + (existing.provider === "claude" ? "Already connected: your Claude subscription, through Claude Code signed in here. No key needed." : `Already connected — ${PROVIDERS[existing.provider].label} via ${existing.source}.`));
     console.log(c.d("  Switch or replace it with `symbiot login --force`."));
     return;
   }
 
   let provider = flagProvider;
   if (!provider) {
+    const cs = claudeState(true);
     console.log("\n" + c.b("Connect Symbiot") + "\n");
     console.log("Which AI should Symbiot write your updates with?\n");
-    console.log("  1) " + PROVIDERS.anthropic.label + c.d("    — needs an Anthropic API key"));
-    console.log("  2) " + PROVIDERS.openai.label + c.d("          — needs an OpenAI API key"));
-    console.log("  3) " + PROVIDERS.gemini.label + c.d("       — needs a Google AI API key"));
-    console.log("  4) " + PROVIDERS.ollama.label + c.d("  — runs on your machine, no key"));
-    const pick = (await ask("\nChoose 1-4 [1]: ")) || "1";
-    provider = { 1: "anthropic", 2: "openai", 3: "gemini", 4: "ollama" }[pick] || (PROVIDERS[pick] ? pick : "anthropic");
+    console.log("  1) " + PROVIDERS.claude.label + c.d(cs.signedIn ? "  — signed in here, no key" : cs.installed ? "  — Claude Code is here; sign in first (run  claude )" : "  — needs Claude Code, signed in (no key)"));
+    console.log("  2) " + PROVIDERS.anthropic.label + c.d("    — needs an Anthropic API key"));
+    console.log("  3) " + PROVIDERS.openai.label + c.d("          — needs an OpenAI API key"));
+    console.log("  4) " + PROVIDERS.gemini.label + c.d("       — needs a Google AI API key"));
+    console.log("  5) " + PROVIDERS.ollama.label + c.d("  — runs on your machine, no key"));
+    const pick = (await ask("\nChoose 1-5 [1]: ")) || "1";
+    provider = { 1: "claude", 2: "anthropic", 3: "openai", 4: "gemini", 5: "ollama" }[pick] || (PROVIDERS[pick] ? pick : "claude");
   }
   if (!PROVIDERS[provider]) { console.log(c.y("Unknown provider: " + provider)); return; }
   const meta = PROVIDERS[provider];
   const cfg = loadConfig();
 
+  if (provider === "claude") {
+    const r = await connectProvider({ provider: "claude", model: flag("model", null) || "" });
+    if (!r.ok) { console.log(c.y(r.message)); process.exitCode = 1; return; }
+    console.log(c.g("✓ ") + r.message + "  Try:  " + c.b("symbiot week"));
+    return;
+  }
   if (provider === "ollama") {
     const baseUrl = (flag("base-url", null) || (await ask("Ollama URL [http://localhost:11434]: ")) || "").trim() || "http://localhost:11434";
     const model = (flag("model", null) || (await ask(`Model name [${meta.model}]: `)) || "").trim() || meta.model;

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 };
 }

package/marketing.mjs

@@ -0,0 +1,130 @@
+// symbiot — Marketing: a lane of its own, for marketing work across every product the
+// user makes (Symbiot, Dailify, the agent products…), not one repo's. Tasks go to it as
+// "marketing" (a lane, the way ops is one), from the Marketing page, any chat, or
+// another lane's handover; its agent works in ~/.config/symbiot/marketing, a git repo
+// of its own (local only, no remote), so what it drafts is reviewed and approved like
+// any repo's work (Approve commits it there). Each item is tagged with the product it
+// markets: "[Dailify] …" as written, else the product its words name. Home shows the
+// lane as an orb among the projects, lit when something there needs you (home.mjs
+// marketingState). Low level on purpose: scan.mjs (laneMap) imports it.
+import { join, relative, basename } from "node:path";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { CONFIG_DIR } from "./core.mjs";
+import { MARKETING } from "./handover.mjs";
+
+const MARKETING_DIR = join(CONFIG_DIR, "marketing");
+const DRAFTS = "drafts";
+const README = `# Marketing
+
+Symbiot's marketing lane: posts, demo videos and screenshots, launches and campaigns for
+every product, not one repo's. Its agent drafts here, one folder per product under
+\`${DRAFTS}/\`; you review and approve each piece under Marketing in Symbiot, and post it
+yourself. Nothing here is ever posted, published or sent by an agent.
+`;
+
+// The lane's folder, made the first time a task goes to it: a README (its name on the
+// Workdesk), .symbiot kept out of git, and a first commit, so Approve has a branch to
+// commit on. Your git name and email when you have them, else Symbiot's.
+function ensureMarketing(dir = MARKETING_DIR) {
+  if (existsSync(join(dir, ".git"))) return dir;
+  try {
+    mkdirSync(join(dir, DRAFTS), { recursive: true });
+    if (!existsSync(join(dir, "README.md"))) writeFileSync(join(dir, "README.md"), README);
+    if (!existsSync(join(dir, ".gitignore"))) writeFileSync(join(dir, ".gitignore"), ".symbiot/\n");
+  } catch { return ""; }
+  const git = (args, env = {}) => spawnSync("git", ["-C", dir, ...args], { encoding: "utf8", timeout: 20000, env: { ...process.env, GIT_TERMINAL_PROMPT: "0", ...env } });
+  if (git(["init", "-q", "-b", "main"]).status !== 0 && git(["init", "-q"]).status !== 0) return "";
+  const me = String(git(["config", "user.email"]).stdout || "").trim();
+  const who = me ? {} : { GIT_AUTHOR_NAME: "Symbiot", GIT_AUTHOR_EMAIL: "symbiot@localhost", GIT_COMMITTER_NAME: "Symbiot", GIT_COMMITTER_EMAIL: "symbiot@localhost" };
+  git(["add", "-A"]);
+  git(["commit", "-q", "-m", "Marketing: a lane of its own"], who);
+  return dir;
+}
+
+// A project's name as people say it (Home's droplets, and the products to tag by): 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 products to tag by: each repo's name as people say it, capitalised.
+function productNames(map = {}) {
+  const out = new Set();
+  for (const [n, p] of Object.entries(map)) { if (n === MARKETING) continue; const d = displayName(p, n); if (d) out.add(d.charAt(0).toUpperCase() + d.slice(1)); }
+  return [...out];
+}
+
+// ---- product tags -------------------------------------------------------------------
+// "[Dailify] Write the launch post": the tag as written. Without one, the first product
+// its words name as it's written (capitalised: "Dailify" in a sentence, not "server").
+const TAG = /^\s*\[([^\]\n]{2,40})\]\s*/;
+const reEsc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function productOf(text, names = []) {
+  const t = String(text || ""), m = t.match(TAG); if (m) return m[1].trim();
+  let best = "", at = Infinity;
+  for (const n of names) {
+    const s = String(n || "").trim(); if (s.length < 3 || !/^[A-Z0-9]/.test(s)) continue;
+    const r = new RegExp(`(^|[^A-Za-z0-9])${reEsc(s)}(?![A-Za-z0-9])`).exec(t);
+    if (r && r.index < at) { at = r.index; best = s; }
+  }
+  return best;
+}
+const untagged = (text) => String(text || "").replace(TAG, "");
+// A task's text with its product's tag first (one tag: a new one replaces the old).
+function tagged(text, product) {
+  const p = String(product || "").replace(/[[\]\n]/g, "").trim().slice(0, 40), t = untagged(text).trim();
+  return p ? `[${p}] ${t}` : t;
+}
+// What counts as marketing in another lane's tasks: posting, launches, campaigns, pricing.
+const MARKETING_WORDS = /\b(marketing|symbiot post|posting|posts? (?:to|on) linkedin|linkedin posts?|social (?:media )?posts?|launch|campaign|audience|newsletter|brand|pricing|4-week test|landing page|drafts to post|demo video)\b/i;
+
+// ---- what its agent has drafted -------------------------------------------------------
+// drafts/<product>/<name>.md (two levels down at most), newest first: [{ file, name,
+// product, at }]. Its product: the "product:" line at its top, else its folder's name.
+function draftFiles(dir = MARKETING_DIR, names = [], { max = 30 } = {}) {
+  const root = join(dir, DRAFTS), out = [];
+  const walk = (d, depth) => {
+    let ents = []; try { ents = readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      if (e.name.startsWith(".")) continue;
+      const p = join(d, e.name);
+      if (e.isDirectory()) { if (depth < 2) walk(p, depth + 1); continue; }
+      if (!/\.md$/i.test(e.name)) continue;
+      let head = "", at = 0; try { head = readFileSync(p, "utf8").slice(0, 600); at = statSync(p).mtimeMs; } catch {}
+      const tagLine = (head.match(/^\s*product:\s*(.+)$/im) || [])[1], folder = relative(root, d).split("/")[0] || "";
+      const product = (tagLine || "").trim() || names.find((n) => n.toLowerCase() === folder.toLowerCase()) || (folder ? folder.charAt(0).toUpperCase() + folder.slice(1) : "");
+      const title = (head.match(/^#\s+(.+)$/m) || [])[1];
+      out.push({ file: p, rel: relative(dir, p), name: (title || basename(e.name, ".md").replace(/[-_]+/g, " ")).trim().slice(0, 120), product, at });
+    }
+  };
+  walk(root, 0);
+  return out.sort((a, b) => b.at - a.at).slice(0, max);
+}
+
+// ---- its brief ----------------------------------------------------------------------------
+// The lines TASKS.md gets for this lane (tasks.mjs buildTasksMd): what it is, the products
+// its tasks name and where each one's code and docs are, and its rules.
+function marketingBrief(list = [], { map = {}, names = productNames(map) } = {}) {
+  const named = [...new Set(list.map((t) => productOf(t.text, names)).filter(Boolean))];
+  // its repo: by folder, or by its name as people say it (Dailify is in CallForge AI)
+  const pathOf = (p) => { const k = Object.keys(map).find((n) => n !== MARKETING && map[n] && [n, basename(map[n]), displayName(map[n], n)].some((x) => x.toLowerCase() === p.toLowerCase())); return k ? map[k] : ""; };
+  const where = named.map((p) => ({ p, path: pathOf(p) }));
+  return ["## This lane: marketing",
+    "This lane markets every product the user makes, not one repo's: posts, demo videos and screenshots, launches, landing-page copy, campaigns. This folder is the lane's own (a local git repo, no remote): what you write here is reviewed and approved under Marketing in Symbiot.",
+    ...(where.length ? ["- **Products in these tasks** (read each one's README and docs for what it is and its end goal):", ...where.map((w) => `  - ${w.p}${w.path ? `: \`${w.path}\`` : " (not one of the user's repos here: ask in QUESTIONS.md where it lives, or hand it over)"}`)] : []),
+    `- Write each piece as a \`.md\` under \`${DRAFTS}/<product>/\` (\`${DRAFTS}/dailify/launch-post.md\`), a \`# \` title first, then \`product: <Product>\`, so the Marketing page tags it. Its screenshots and clips go next to it.`,
+    "- Every post opens with a strong hook (its first line written for reach), says plainly what the product is, and states its end goal. Where the end goal isn't written down, draft one and flag it in QUESTIONS.md for the user to confirm.",
+    "- Never post, publish, schedule or send anything, and never sign in anywhere as the user: they approve each draft under Marketing and post it themselves. A post that waits on their OK is a question in QUESTIONS.md, with what to check first."];
+}
+
+export { MARKETING, MARKETING_DIR, displayName, productNames, ensureMarketing, productOf, untagged, tagged, MARKETING_WORDS, draftFiles, marketingBrief };

package/mind.mjs

@@ -24,15 +24,15 @@ import { VERSION, CONFIG_DIR, clipWords } from "./core.mjs";
 import { write } from "./ai.mjs";
 import { handoffCmd, runHandoff } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
-import { repoPathMap } from "./scan.mjs";
-import { OPS, HANDOVER_MAX, handoverRules, ONLY_YOU, HANDBACK } from "./handover.mjs";
+import { laneMap } from "./scan.mjs";
+import { OPS, MARKETING, HANDOVER_MAX, handoverRules, ONLY_YOU, HANDBACK } from "./handover.mjs";
 import { styleOf, styleLine, userStyleLine } from "./adapt.mjs";
 import { knowledgeFor } from "./knowledge.mjs";
 
 const MIND_FILE = join(CONFIG_DIR, "mind.json");
 const ACT_DIR = join(CONFIG_DIR, "drafts"); // runs of their own, next to drafted replies
 const CLI = fileURLToPath(new URL("./index.mjs", import.meta.url));
-const MAX_NODES = 400, MAX_FACTS = 12, MAX_LOG = 120, RECALL = 8, LOG_LINES = 6;
+const MAX_NODES = 400, MAX_FACTS = 12, MAX_LOG = 240, RECALL = 8, LOG_LINES = 6, TURN_CHARS = 1500;
 
 // ---- memory ---------------------------------------------------------------------
 function loadMind() {
@@ -80,10 +80,19 @@ function recall(query, now = Date.now(), d = loadMind(), limit = RECALL) {
 }
 const recallText = (nodes) => nodes.map((n) => `- ${n.name} (${n.kind}): ${n.facts.slice(-4).map((f) => f.text).join("; ")}`).join("\n");
 function logTurn(where, role, text, now = Date.now(), d = loadMind()) {
-  d.log = [...d.log, { ts: now, where, role, text: String(text || "").replace(/\s+/g, " ").trim().slice(0, 400) }].slice(-MAX_LOG);
+  d.log = [...d.log, { ts: now, where, role, text: String(text || "").replace(/\s+/g, " ").trim().slice(0, TURN_CHARS) }].slice(-MAX_LOG);
 }
 // The last few lines said anywhere else in the app: how the next page knows
 // what you were just talking about.
+// This chat's own last turns, for a chat that doesn't keep its thread itself (Home):
+// without them a "yeah" to "want that?" went to whatever was said elsewhere (a
+// kernel reboot card) and the task they'd agreed to was never made. Home is where
+// people think things through, so it keeps a real conversation: 16 turns, each whole
+// (up to TURN_CHARS), from the last 12 hours.
+const THREAD_TURNS = 16, THREAD_AGE = 12 * 3600000;
+function ownThread(where, d = loadMind(), now = Date.now()) {
+  return d.log.filter((l) => l.where === where && now - (l.ts || 0) < THREAD_AGE).slice(-THREAD_TURNS).map((l) => `${l.role === "user" ? "User" : "You"}: ${l.text}`).join("\n");
+}
 function lately(where, d = loadMind(), n = LOG_LINES) {
   return d.log.filter((l) => l.where !== where).slice(-n).map((l) => `- [${l.where}] ${l.role === "user" ? "User" : "You"}: ${l.text.slice(0, 200)}`).join("\n");
 }
@@ -99,7 +108,7 @@ function forget(id) {
 // 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 = "", lanes = null, now = Date.now() } = {}) {
-  let names = lanes; if (!names) { try { names = Object.keys(repoPathMap()); } catch { names = []; } }
+  let names = lanes; if (!names) { try { names = Object.keys(laneMap()); } catch { names = []; } }
   const short = clipWords(request.replace(/\s+/g, " "), 160); // its task line; the whole request is quoted above it
   return `# For your agent: ${title}
 _written by symbiot ${VERSION} · ${new Date(now).toISOString().slice(0, 10)}_
@@ -153,9 +162,12 @@ function rulesFor(lanes = [], self = "") {
 {"reply": "what you say, plain text, brief, no preamble",
  "do": null or {"agent": "what a coding agent should do now: self-contained, with names, links and ids", "repo": "the lane it's for, or empty"} or {"task": "a task for later", "repo": "the lane it's for, or empty"},
  "remember": [{"name": "…", "kind": "person|account|site|repo|project|decision|preference", "fact": "…"}]}
-When they ask you to do something (look into it, find out, fix, set up, sign in, close, send, chase), do it, don't explain what you can't do: "agent" starts a coding agent now, with their tools and connectors (MCP, the command line, a browser signed in to their linked sites). With a "repo", it's that project's agent, working in it; empty, an agent for everything outside a repo (this computer, accounts, services). Use "task" for what's for later. Don't ask their permission to hand it over: the agent asks them first, in the Agents tab, before anything hard to undo (closing an account, deleting, paying, sending); say so in your reply when it applies, with what to check first. A question you can answer from what's here: answer it, "do": null.
-Lanes ("repo" is one of these, exactly): ${lanes.length ? lanes.slice(0, 60).join(", ") : "(none found)"}.${self ? ` Symbiot itself is "${self}": a flaw in how Symbiot works (how it read a page, what a brief or a card said, anything in the app) goes there.` : ""}
+When they ask you to do something (look into it, find out, fix, set up, sign in, close, send, chase), do it, don't explain what you can't do: "agent" starts a coding agent now, with their tools and connectors (MCP, the command line, a browser signed in to their linked sites). With a "repo", it's that project's agent, working in it; empty, an agent for everything outside a repo (this computer, accounts, services). Use "task" for what's for later. Don't ask their permission to hand it over: the agent asks them first, on the Workdesk, before anything hard to undo (closing an account, deleting, paying, sending); say so in your reply when it applies, with what to check first. A question you can answer from what's here: answer it, "do": null.
+Lanes ("repo" is one of these, exactly): ${lanes.length ? lanes.slice(0, 60).join(", ") : "(none found)"}.${lanes.includes(MARKETING) ? ` "${MARKETING}" is a lane of its own for marketing any of their products (posts, demo videos, launches, campaigns, pricing pages' copy): marketing work goes there, starting with the product it's for in brackets, "[Dailify] a launch post".` : ""}${self ? ` Symbiot itself is "${self}": a flaw in how Symbiot works (how it read a page, what a brief or a card said, anything in the app) goes there.` : ""}
 Don't wait to be asked to fix Symbiot. When you notice it got something wrong (you misread a page, a brief or a card misled them, a step made them do an agent's job), say so plainly and, in the same reply, start the fix: "agent"${self ? ` with "repo": "${self}"` : ""}, saying what went wrong, an example, and what it should do instead.
+A short answer (yes, yeah, ok, sure, go, do it, that one, 2) answers what you last said in "This chat so far", never something from elsewhere in the app. If you'd proposed a task or an agent and they agree, do it now in "do", in the lane you named.
+Hash it out first: when they bring an idea rather than a clear ask, sharpen it with them: say what's strong, push back where it's weak, add what's missing, and propose it as a task (naming the lane) once it holds up. "do" stays null until they agree.
+When an ask could mean two or more things (which lane, how much, what done looks like), don't guess: "do" stays null, and the reply gives 2-3 short numbered readings, your pick first, and asks which. A clear ask goes straight through.
 "remember": only lasting facts worth knowing on another page (who someone is, which account is what, a decision, how they like things); [] for anything else.`;
 }
 // Symbiot's own repo among your lanes (its package.json is symbiot's), or "".
@@ -193,6 +205,7 @@ function parseReply(raw) {
 // what "do" runs here. Gives { reply, did?, remembered }.
 async function converse({ where, role = "", context = "", history = "", question, act = {}, ask = write, map = null, now = Date.now(), images = [] }) {
   const d = loadMind(), hits = recall(question, now, d), known = recallText(hits), elsewhere = lately(where, d);
+  if (!history) history = ownThread(where, d, now);
   // what it did to answer, to show under the reply (as the app shows an agent's work)
   const steps = [];
   if (hits.length) steps.push(`recalled ${hits.length === 1 ? hits[0].name : hits.length + " things: " + hits.slice(0, 3).map((h) => h.name).join(", ")}`);
@@ -201,11 +214,11 @@ async function converse({ where, role = "", context = "", history = "", question
   // your knowledge folders (knowledge.mjs): a few short excerpts, each with its file to cite; never examples
   let kn = { text: "", steps: [] }; try { kn = knowledgeFor(question); } catch {}
   steps.push(...kn.steps);
-  let lanes = map; if (!lanes) { try { lanes = repoPathMap(); } catch { lanes = {}; } }
+  let lanes = map; if (!lanes) { try { lanes = laneMap(); } catch { lanes = {}; } }
   // how they talk, from what they've typed into any chat (adapt.mjs: accommodation)
   const voice = styleLine(styleOf(d.log.filter((l) => l.role === "user").map((l) => l.text).concat(question)));
   const system = `${IDENTITY} ${role}\n\n${rulesFor(Object.keys(lanes), selfLane(lanes))}${voice ? "\n" + voice : ""}`;
-  const prompt = (known ? `What you know (from across the app):\n${known}\n\n` : "") + (kn.text ? kn.text + "\n\n" : "") + (elsewhere ? `Lately, elsewhere in the app:\n${elsewhere}\n\n` : "") +
+  const prompt = (known ? `What you know (from across the app):\n${known}\n\n` : "") + (kn.text ? kn.text + "\n\n" : "") + (elsewhere ? `Lately, elsewhere in the app (other chats: a short answer here doesn't reply to these):\n${elsewhere}\n\n` : "") +
     (context ? context + "\n\n" : "") + (history ? `This chat so far:\n${history}\n\n` : "") + `They say (on ${where}): ${question}`;
   const raw = await ask(system, prompt, images.length ? { images } : undefined);
   if (!raw || /^\(?couldn't reach the model/i.test(String(raw))) return { reply: "(couldn't reach the model)", remembered: 0 };
@@ -217,8 +230,8 @@ async function converse({ where, role = "", context = "", history = "", question
   if (want && want.agent && act.agent) {
     did = { kind: "agent", request: String(want.agent).slice(0, HANDOVER_MAX), ...(await act.agent(String(want.agent), known, repo)) };
     reply += did.error ? `\n\n(I couldn't hand it to an agent: ${did.error})`
-      : did.lane ? `\n\n→ Handed to ${did.lane}'s agent, as a task there${did.queued ? " (it starts once the run there now finishes)" : ""}. It's in the Agents tab.`
-      : "\n\n→ Handed to your agent. It's in the Agents tab, and it asks you there before anything hard to undo.";
+      : did.lane ? `\n\n→ Handed to ${did.lane}'s agent, as a task there${did.queued ? " (it starts once the run there now finishes)" : ""}. It's on the Workdesk.`
+      : "\n\n→ Handed to your agent. It's on the Workdesk, and it asks you there before anything hard to undo.";
   } else if (want && want.task && act.task) {
     did = { kind: "task", text: String(want.task).slice(0, 300), ...(await act.task(String(want.task), repo)) };
     reply += did.error ? `\n\n(I couldn't add the task: ${did.error})`
@@ -235,6 +248,6 @@ async function converse({ where, role = "", context = "", history = "", question
   return { reply, ...(did ? { did } : {}), remembered, steps };
 }
 // The usual "task" act, for a caller with no lanes of its own to pass.
-const addToTasks = (text, repo) => { let map = {}; try { map = repoPathMap(); } catch {} return taskIn(text, repo, { map }); };
+const addToTasks = (text, repo) => { let map = {}; try { map = laneMap(); } catch {} return taskIn(text, repo, { map }); };
 
-export { MIND_FILE, loadMind, remember, recall, recallText, lately, mindState, forget, actBrief, actNow, actIn, taskIn, selfLane, rulesFor, parseReply, converse, addToTasks };
+export { MIND_FILE, loadMind, remember, recall, recallText, lately, mindState, forget, actBrief, actNow, actIn, taskIn, selfLane, rulesFor, parseReply, converse, addToTasks , ownThread };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbiot",
-  "version": "0.55.1",
+  "version": "0.55.3",
   "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice \u2014 Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
@@ -43,7 +43,8 @@
     "fonts",
     "mapknn.mjs",
     "guard.mjs",
-    "away.mjs"
+    "away.mjs",
+    "marketing.mjs"
   ],
   "engines": {
     "node": ">=18"
@@ -76,7 +77,7 @@
     "@anthropic-ai/sdk": "^0.128.0"
   },
   "scripts": {
-    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/checks.mjs &&node test/lanes.mjs && node test/handback.mjs && node test/autoallow.mjs && node test/guard.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/away.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/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/checks.mjs &&node test/lanes.mjs && node test/handback.mjs && node test/autoallow.mjs && node test/guard.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/away.mjs && node test/subscription.mjs && node test/marketing.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
     "lint": "eslint ."
   },
   "devDependencies": {

package/reports.mjs

@@ -20,10 +20,10 @@ import { createHash } from "node:crypto";
 import { CONFIG_DIR } from "./core.mjs";
 import { runFolders, laneOf, runTitle } from "./handback.mjs";
 import { runningHandoff } from "./agents.mjs";
-import { repoPathMap } from "./scan.mjs";
+import { laneMap } from "./scan.mjs";
 
 const SEEN_FILE = join(CONFIG_DIR, "reports.json");
-const NOT_REPORTS = /^(?:TASKS|QUESTIONS|ANSWERS|HANDOFF|SKIPPED|CLAUDE|AGENTS)\.md$|^BRIEF/i;
+const NOT_REPORTS = /^(?:TASKS(?:\.[\w-]+)?|QUESTIONS|ANSWERS|HANDOFF|SKIPPED|CLAUDE|AGENTS)\.md$|^BRIEF/i; // TASKS.next.md too: the tasks held for after a run
 const MAX_READ = 512 * 1024, MAX_LIST = 200;
 const idOf = (file) => createHash("sha1").update(file).digest("hex").slice(0, 12);
 
@@ -40,7 +40,7 @@ function titleOf(text, name) {
 // run, size, mtime, new, running }]. `folders`, `running` and `seen` can be given
 // (the tests do).
 function listReports({ map, folders, running = runningHandoff, seen } = {}) {
-  if (!folders) { map = map || repoPathMap(); folders = runFolders(map); }
+  if (!folders) { map = map || laneMap(); folders = runFolders(map); }
   const s = (seen || loadSeen()).seen, out = [];
   for (const folder of folders) {
     const dir = join(folder, ".symbiot");

package/scan.mjs

@@ -10,6 +10,7 @@ import { VERSION, loadConfig, saveConfig, sh, repoState } from "./core.mjs";
 import { detectHandoffs } from "./agents.mjs";
 import { PROVIDERS, resolveProvider } from "./ai.mjs";
 import { mapKnn } from "./mapknn.mjs";
+import { MARKETING, MARKETING_DIR } from "./marketing.mjs";
 
 const MAX_COMMITS = 140;
 
@@ -444,7 +445,8 @@ async function buildMapScan() {
       if (scanExpired()) break;
       await yieldTick();
       const det = detectFolder(d); folders++; scanTick(det.name);
-      add({ id: "folder:" + d, type: "folder", label: det.name, weight: 10, meta: { path: d, langs: det.langs.slice(0, 3), tools: det.tools, files: det.files } });
+      let last = ""; try { last = new Date(statSync(d).mtimeMs).toISOString().slice(0, 10); } catch {} // the Map sorts folders by it, as repos by their last commit
+      add({ id: "folder:" + d, type: "folder", label: det.name, weight: 10, meta: { path: d, langs: det.langs.slice(0, 3), tools: det.tools, files: det.files, last } });
       edges.push({ source: "me", target: "folder:" + d });
       for (const L of det.langs.slice(0, 3)) { const id = "lang:" + L; add({ id, type: "lang", label: L, weight: 15 }); edges.push({ source: "folder:" + d, target: id }); }
     } }
@@ -547,6 +549,11 @@ function repoPathMap() {
   return byName;
 }
 
+// The lanes a task can go to: every repo and project folder, and Marketing, a lane of
+// its own for marketing across products (marketing.mjs). A repo of yours called
+// marketing keeps the name. Counting your repos is repoPathMap's job, not this.
+function laneMap() { const m = repoPathMap(); if (!Object.keys(m).some((n) => n.toLowerCase() === MARKETING)) m[MARKETING] = MARKETING_DIR; return m; }
+
 // The SAME repo set the Map uses — reuse its cached scan when present, else do
 // the identical discovery. So week/standup/todo/drift all agree with the Map.
 function discoveredRepos() {
@@ -554,4 +561,4 @@ function discoveredRepos() {
   return findAllRepos();
 }
 
-export { SCAN, SCAN_TIMEOUT_MS, setScanOptions, scanBegin, scanPhase, scanTick, scanExpired, scanEnd, me, authorship, authorArgs, readmeInfo, repoShape, houseRules, reportFooter, expandRoot, scanHome, scanBase, storageBlocked, prootDistros, prootHomes, scanRoots, addScanRoot, removeScanRoot, commits, openWork, findAllRepos, detectRepo, findProjectFolders, detectFolder, claudeProjects, buildMap, nodeDetail, repoPathMap, discoveredRepos };
+export { laneMap, SCAN, SCAN_TIMEOUT_MS, setScanOptions, scanBegin, scanPhase, scanTick, scanExpired, scanEnd, me, authorship, authorArgs, readmeInfo, repoShape, houseRules, reportFooter, expandRoot, scanHome, scanBase, storageBlocked, prootDistros, prootHomes, scanRoots, addScanRoot, removeScanRoot, commits, openWork, findAllRepos, detectRepo, findProjectFolders, detectFolder, claudeProjects, buildMap, nodeDetail, repoPathMap, discoveredRepos };

package/server.mjs

@@ -14,9 +14,9 @@ import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
 import { EMBEDDED_UI } from "./ui.mjs";
 import { VERSION, LATEST_VERSION, REGISTRY, semverGt, checkLatest, CONFIG_PATH, loadConfig, saveConfig, loadTasks, hasCmd, chromeBinary, CONFIG_DIR } from "./core.mjs";
-import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, linkReach, answerQuestions, skipIdea, agentsList, startWaiting, parkLane, parkedPaths, autoAllowSweep, trustFull } from "./agents.mjs";
+import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, linkReach, answerQuestions, skipIdea, agentsList, startWaiting, parkLane, parkedPaths, autoAllowSweep, trustFull, readLastWords, sandboxState } from "./agents.mjs";
 import { PROVIDERS, resolveProvider, connectProvider, detectHardware, recommendModels, hasOllama, ollamaInstall, ensureOllama, useOllamaModel } from "./ai.mjs";
-import { SCAN, SCAN_TIMEOUT_MS, scanRoots, scanHome, addScanRoot, removeScanRoot, buildMap, nodeDetail, repoPathMap } from "./scan.mjs";
+import { SCAN, SCAN_TIMEOUT_MS, scanRoots, scanHome, addScanRoot, removeScanRoot, buildMap, nodeDetail, repoPathMap, laneMap } from "./scan.mjs";
 import { computeDrift } from "./drift.mjs";
 import { addTask, toggleTask, removeTask, restoreTask, syncTasks, taskType, pushTasks, pendingReview, workingDiff, learnNpm, withReleases, releaseInput, approveRepo, approveChanges, sendBack, setAutoMerge } from "./tasks.mjs";
 import { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, produce, releaseNotes } from "./writeups.mjs";
@@ -30,7 +30,8 @@ import { mindState, forget } from "./mind.mjs";
 import { lanesTick, lanesState, partlyDone, orcaRelink } from "./lanes.mjs";
 import { keepFacts, skipFacts, awaitTick, awaitingState, stopWaiting } from "./handback.mjs";
 import { adaptState, noteUse } from "./adapt.mjs";
-import { homeState, homeAsk, homeAnswer, workScene, workGo, firstSteps } from "./home.mjs";
+import { homeState, homeAsk, homeAnswer, homeNext, workScene, workGo, firstSteps, marketingState, marketingGo, marketingTask, moveToMarketing } from "./home.mjs";
+import { MARKETING_DIR } from "./marketing.mjs";
 import { listReports, readReport, markAllRead } from "./reports.mjs";
 import { phoneState, setPhoneLink, newCode, unpairPhone, pairComputer, forgetComputer, pollComputer, startPhone } from "./phone.mjs";
 import { knowledgeState, addKnowledgeFolder, removeKnowledgeFolder, indexKnowledge, knowledgeTick, searchKnowledge } from "./knowledge.mjs";
@@ -230,7 +231,7 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (tok !== TOKEN) { res.writeHead(403); res.end("forbidden"); return; }
     }
     try {
-      if (u.pathname === "/api/status") { const r = resolveProvider(); return json(res, r ? { connected: true, line: `${PROVIDERS[r.provider].label} · ${r.model}` } : { connected: false }); }
+      if (u.pathname === "/api/status") { const r = resolveProvider(); return json(res, r ? { connected: true, provider: r.provider, line: `${PROVIDERS[r.provider].label}${r.model ? " · " + r.model : ""}` } : { connected: false }); }
       if (u.pathname === "/api/map") return json(res, await buildMap()); // local git only — no AI key needed
       if (u.pathname === "/api/scan") return json(res, { active: SCAN.active, phase: SCAN.phase, done: SCAN.done, total: SCAN.total, item: SCAN.item, elapsed: SCAN.startedAt ? Date.now() - SCAN.startedAt : 0, timeout: SCAN_TIMEOUT_MS, partial: SCAN.partial });
       if (u.pathname === "/api/models") { const hw = detectHardware(); return json(res, { hardware: hw, rec: recommendModels(hw) }); }
@@ -255,9 +256,9 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
         if (!ask.length) return json(res, partly(list));
         await learnNpm(ask); return json(res, partly(pendingReview()));
       }
-      if (u.pathname === "/api/pending/diff") { const p = repoPathMap()[u.searchParams.get("repo") || ""]; return json(res, { diff: p ? workingDiff(p) : "" }); }
-      if (u.pathname === "/api/pending/approve" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([repoPathMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump })); return json(res, approveRepo(repo, { bump: b.bump, notes })); }
-      if (u.pathname === "/api/pending/approve-changes" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([repoPathMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump, tick: b.tick })); return json(res, approveChanges(repo, { bump: b.bump, tick: b.tick, notes })); }
+      if (u.pathname === "/api/pending/diff") { const p = laneMap()[u.searchParams.get("repo") || ""]; return json(res, { diff: p ? workingDiff(p) : "" }); }
+      if (u.pathname === "/api/pending/approve" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([laneMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump })); return json(res, approveRepo(repo, { bump: b.bump, notes })); }
+      if (u.pathname === "/api/pending/approve-changes" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([laneMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump, tick: b.tick })); return json(res, approveChanges(repo, { bump: b.bump, tick: b.tick, notes })); }
       if (u.pathname === "/api/pending/sendback" && req.method === "POST") { const b = await readBody(req); return json(res, sendBack(String(b.id || ""))); }
       if (u.pathname === "/api/automerge" && req.method === "POST") { const b = await readBody(req); return json(res, setAutoMerge(String(b.repo || ""), !!b.on)); }
       if (u.pathname === "/api/tasks/push" && req.method === "POST") { const b = await readBody(req); return json(res, pushTasks(b)); }
@@ -277,8 +278,8 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/knowledge/search") return json(res, { hits: searchKnowledge(u.searchParams.get("q") || "", { examples: u.searchParams.get("examples") === "1" }) });
       if (u.pathname === "/api/agentcfg") { const d = detectHandoffs(); return json(res, { cmd: handoffCmd(), agents: d.agents, editors: d.editors, connectors: connectorsInfo() }); }
       if (u.pathname === "/api/agentcmd" && req.method === "POST") { const b = await readBody(req); return json(res, setHandoffCmd(b.cmd)); }
-      if (u.pathname === "/api/agent/trust") return json(res, { full: trustFull() });
-      if (u.pathname === "/api/agent/trust/set" && req.method === "POST") { const b = await readBody(req); const cfg = loadConfig(); if (b.full) delete cfg.agentTrust; else cfg.agentTrust = "ask"; saveConfig(cfg); return json(res, { full: trustFull() }); }
+      if (u.pathname === "/api/agent/trust") return json(res, { full: trustFull(), sandbox: sandboxState() });
+      if (u.pathname === "/api/agent/trust/set" && req.method === "POST") { const b = await readBody(req); const cfg = loadConfig(); if (b.full) delete cfg.agentTrust; else cfg.agentTrust = "ask"; saveConfig(cfg); return json(res, { full: trustFull(), sandbox: sandboxState() }); }
       if (u.pathname === "/api/agent/grant" && req.method === "POST") { const b = await readBody(req); return json(res, grantAgent({ tool: b.tool, dir: b.dir })); }
       if (u.pathname === "/api/open" && req.method === "POST") { const b = await readBody(req); const e = runHandoff(String(b.path || ""), { force: !!b.force }); return json(res, { opened: !!e && !e.busy && !e.blocked, busy: !!(e && e.busy), auto: !!(e && e.auto), blocked: !!(e && e.blocked), note: (e && e.note) || "", id: (e && e.id) || "" }); }
       if (u.pathname === "/api/setup-local" && req.method === "POST") {
@@ -348,8 +349,15 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
         const ws = watchState(), news = markNews(newsSince(24 * 60), ws.watches), p = postsState(), t = testWeeks({ news, map: repoPathMap() });
         let n = null; try { n = await testInstalls(t, { get: (url) => fetch(url, { signal: AbortSignal.timeout(8000) }).then((r) => (r.ok ? r.json() : null)) }); } catch {}
         if (t && n) t.rows.forEach((r, i) => { r.installs = n[i]; });
-        return json(res, { linkedin: p.linkedin, replies: news.filter((x) => x.social && x.ts >= Date.now() - 30 * 86400000).slice(0, 30), test: t });
+        let lane = null; try { lane = marketingState(); } catch {}
+        return json(res, { linkedin: p.linkedin, replies: news.filter((x) => x.social && x.ts >= Date.now() - 30 * 86400000).slice(0, 30), test: t, lane });
       }
+      // Marketing's own lane (marketing.mjs): a task for it, tagged with its product; another
+      // lane's marketing task moved to it; its agent started; a draft its agent wrote, opened
+      if (u.pathname === "/api/marketing/task" && req.method === "POST") { const b = await readBody(req); return json(res, marketingTask(b.text, b.product)); }
+      if (u.pathname === "/api/marketing/move" && req.method === "POST") { const b = await readBody(req); return json(res, moveToMarketing(b.id, b.product)); }
+      if (u.pathname === "/api/marketing/go" && req.method === "POST") return json(res, marketingGo());
+      if (u.pathname === "/api/marketing/open" && req.method === "POST") { const b = await readBody(req), f = join(MARKETING_DIR, String(b.rel || "")); return json(res, f.startsWith(MARKETING_DIR + "/") && existsSync(f) ? { ok: openUrl(f) } : { error: "That draft isn't there any more." }); }
       if (u.pathname === "/api/posts/draft" && req.method === "POST") return json(res, await draftPosts());
       if (u.pathname === "/api/posts/approve" && req.method === "POST") { const b = await readBody(req); return json(res, approvePost(String(b.id || ""), { copy: null })); }
       if (u.pathname === "/api/posts/edit" && req.method === "POST") { const b = await readBody(req); return json(res, editPost(String(b.id || ""), b.text)); }
@@ -375,14 +383,15 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/firststeps") return json(res, firstSteps()); // Settings' first steps: what's set up, in order
       if (u.pathname === "/api/home/answer" && req.method === "POST") { const b = await readBody(req); return json(res, homeAnswer(b.id, { pick: b.pick, text: b.text })); }
       if (u.pathname === "/api/away" && req.method === "POST") { const b = await readBody(req); return json(res, toggleAway(`http://127.0.0.1:${server.address().port}/?t=${TOKEN}`, b.open)); }
+      if (u.pathname === "/api/home/next" && req.method === "POST") { const b = await readBody(req); return json(res, homeNext(b.id)); }
       if (u.pathname === "/api/home/ask" && req.method === "POST") { const b = await readBody(req); return json(res, await homeAsk(b.question, { images: saveShots(b.images) })); }
       if (u.pathname === "/api/adapt") return json(res, adaptState({ from: String(u.searchParams.get("from") || ""), commit: u.searchParams.get("commit") === "1", ...(u.searchParams.has("touch") ? { touch: u.searchParams.get("touch") === "1" } : {}) }));
       if (u.pathname === "/api/adapt/use" && req.method === "POST") { const b = await readBody(req); return json(res, noteUse(b)); }
       // Lanes (lanes.mjs): work agents handed to each other, and where it stands.
       if (u.pathname === "/api/lanes") return json(res, lanesState());
       // a parked project (lane) starts no agent runs until it's unparked (agents.mjs parkLane)
-      if (u.pathname === "/api/lanes/parked") { const map = repoPathMap(), ps = parkedPaths(); return json(res, { repos: Object.keys(map).filter((n) => ps.includes(map[n])), paths: ps }); }
-      if (u.pathname === "/api/lanes/park" && req.method === "POST") { const b = await readBody(req), map = repoPathMap(), p = Object.values(map).includes(String(b.path || "")) ? String(b.path) : map[String(b.repo || "")]; if (!p) return json(res, { error: "That project isn't on this computer." }); return json(res, parkLane(p, b.on !== false)); }
+      if (u.pathname === "/api/lanes/parked") { const map = laneMap(), ps = parkedPaths(); return json(res, { repos: Object.keys(map).filter((n) => ps.includes(map[n])), paths: ps }); }
+      if (u.pathname === "/api/lanes/park" && req.method === "POST") { const b = await readBody(req), map = laneMap(), p = Object.values(map).includes(String(b.path || "")) ? String(b.path) : map[String(b.repo || "")]; if (!p) return json(res, { error: "That project isn't on this computer." }); return json(res, parkLane(p, b.on !== false)); }
       // 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))));
@@ -491,6 +500,8 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
   // an agent's allow list that stays inside your work is turned on by itself, and the agent carries on
   setTimeout(() => { try { autoAllowSweep(); } catch {} }, 4000).unref();
   setInterval(() => { try { autoAllowSweep(); } catch {} }, 20000).unref();
+  // a finished run's last words, read by your AI for anything left to you that the patterns missed (agents.mjs readLastWords)
+  setInterval(() => { readLastWords().catch(() => {}); }, 60000).unref();
   // knowledge folders: changed files re-read (a stat per file when nothing changed), then checked again for where two files disagree (checks.mjs)
   const knowTick = () => { try { const r = knowledgeTick(); if (r && (r.read || r.removed || !checksState().at)) runChecks(); } catch {} };
   setTimeout(knowTick, 5000).unref(); setInterval(knowTick, 3 * 60 * 1000).unref();