symbiot 0.55.1 → 0.55.2

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