symbiot 0.50.2 → 0.51.0

package/server.mjs

@@ -11,7 +11,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
 import { EMBEDDED_UI } from "./ui.mjs";
-import { VERSION, LATEST_VERSION, REGISTRY, semverGt, checkLatest, loadConfig, saveConfig, loadTasks, hasCmd, chromeBinary } from "./core.mjs";
+import { VERSION, LATEST_VERSION, REGISTRY, semverGt, checkLatest, CONFIG_PATH, loadConfig, saveConfig, loadTasks, hasCmd, chromeBinary } from "./core.mjs";
 import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, answerQuestions, skipIdea, agentsList, startWaiting } 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";
@@ -23,11 +23,15 @@ import { mapPage, wholePage, pressRegion, typeRegion, scrollPage, signIn, keepBr
 import { weeklyState, setWeekly, runWeekly, startWeekly, autostartState, setAutostart } from "./desktop.mjs";
 import { watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, checkWatch, startWatches, setBrief, draftReply, openChat, watchBoard, boardChat, clearBoardChat } from "./watch.mjs";
 import { linksState, linkSite, checkLink, unlinkSite } from "./links.mjs";
+import { postsState, draftPosts, approvePost, editPost, skipPost, voiceFromLinkedIn } from "./post.mjs";
 import { mindState, forget } from "./mind.mjs";
 import { lanesTick, lanesState } from "./lanes.mjs";
+import { keepFacts, skipFacts, awaitTick, awaitingState, stopWaiting } from "./handback.mjs";
 import { adaptState, noteUse } from "./adapt.mjs";
 import { homeState, homeAsk, workScene, workGo } from "./home.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";
 
 // The in-app update installs the EXACT newest version (not the `latest` tag, which
 // npm's cache/propagation can resolve stale — that caused an update loop where the
@@ -103,6 +107,8 @@ function readBody(req) {
 function appLink(url) { return url.replace(/^http:\/\//, "symbiot://"); }
 // Symbiot running in Termux (not the Android app's own)
 const IN_TERMUX = process.platform === "android" && process.env.SYMBIOT_ANDROID_APP !== "1";
+const SANDBOX = !!process.env.SYMBIOT_SANDBOX; // symbiot app --fresh (sandbox.mjs)
+const FIRST_RUN = !existsSync(CONFIG_PATH); // no config yet when Symbiot started: a brand-new install
 function openApp(url) {
   try {
     // Android (Termux): Symbiot's Android app shows this Symbiot full screen (it
@@ -225,6 +231,12 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/scanroots") return json(res, { roots: loadConfig().scanRoots || [], effective: scanRoots(), home: scanHome() });
       if (u.pathname === "/api/scanroots/add" && req.method === "POST") { const b = await readBody(req); return json(res, addScanRoot(String(b.path || ""))); }
       if (u.pathname === "/api/scanroots/remove" && req.method === "POST") { const b = await readBody(req); return json(res, removeScanRoot(String(b.path || ""))); }
+      // knowledge folders (knowledge.mjs): added or removed, the index catches up at once
+      if (u.pathname === "/api/knowledge") return json(res, knowledgeState());
+      if (u.pathname === "/api/knowledge/add" && req.method === "POST") { const b = await readBody(req), r = addKnowledgeFolder(String(b.path || ""), b.examples); if (r.error) return json(res, r); indexKnowledge(); return json(res, { ok: true, ...knowledgeState() }); }
+      if (u.pathname === "/api/knowledge/remove" && req.method === "POST") { const b = await readBody(req), r = removeKnowledgeFolder(String(b.path || "")); if (r.error) return json(res, r); indexKnowledge(); return json(res, { ok: true, ...knowledgeState() }); }
+      if (u.pathname === "/api/knowledge/index" && req.method === "POST") { const r = indexKnowledge(); return json(res, { ...r, ...knowledgeState() }); }
+      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/grant" && req.method === "POST") { const b = await readBody(req); return json(res, grantAgent({ tool: b.tool, dir: b.dir })); }
@@ -240,6 +252,10 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/agents") return json(res, await withReleases(agentsList()));
       if (u.pathname === "/api/agents/answer" && req.method === "POST") { const b = await readBody(req); return json(res, answerQuestions(String(b.path || ""), b.answers, { rerun: !!b.rerun })); }
       if (u.pathname === "/api/agents/skip" && req.method === "POST") { const b = await readBody(req); return json(res, skipIdea(String(b.path || ""), b.text)); }
+      // What a run handed back (handback.mjs): facts for memory, kept only on Remember; replies it waits on.
+      if (u.pathname === "/api/agents/remember" && req.method === "POST") { const b = await readBody(req); return json(res, b.skip === true ? skipFacts(String(b.path || "")) : keepFacts(String(b.path || ""), { only: Array.isArray(b.only) ? b.only.map(Number) : undefined })); }
+      if (u.pathname === "/api/awaiting") return json(res, awaitingState());
+      if (u.pathname === "/api/awaiting/stop" && req.method === "POST") { const b = await readBody(req); return json(res, stopWaiting(String(b.id || ""))); }
       if (u.pathname === "/api/mail") return json(res, mailState());
       if (u.pathname === "/api/mail/set" && req.method === "POST") { const b = await readBody(req); return json(res, setMail(b)); }
       if (u.pathname === "/api/mail/preview") { const items = sentMail(Number(u.searchParams.get("days")) || since, true); return json(res, { count: items.length, items: items.slice(0, 20) }); }
@@ -283,6 +299,19 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/links/link" && req.method === "POST") { const b = await readBody(req); return json(res, await linkSite(String(b.id || ""))); }
       if (u.pathname === "/api/links/check" && req.method === "POST") { const b = await readBody(req); return json(res, await checkLink(String(b.id || ""))); }
       if (u.pathname === "/api/links/unlink" && req.method === "POST") { const b = await readBody(req); return json(res, unlinkSite(String(b.id || ""))); }
+      // Posts (post.mjs): the week's drafts, waiting on you. Approve only records your yes:
+      // the page copies the post itself and opens LinkedIn's share box; nothing is posted.
+      if (u.pathname === "/api/posts") return json(res, postsState());
+      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)); }
+      if (u.pathname === "/api/posts/skip" && req.method === "POST") { const b = await readBody(req); return json(res, skipPost(String(b.id || ""))); }
+      // reads your LinkedIn only on your click (confirmed), never by itself
+      if (u.pathname === "/api/posts/voice" && req.method === "POST") { const b = await readBody(req); if (b.confirmed !== true) return json(res, { error: "Reading your LinkedIn posts needs your click." }); return json(res, await voiceFromLinkedIn()); }
+      // Reports (reports.mjs): what runs wrote up in their .symbiot/; read by id, never by path.
+      if (u.pathname === "/api/reports") return json(res, { reports: listReports() });
+      if (u.pathname === "/api/reports/read") return json(res, readReport(u.searchParams.get("id") || ""));
+      if (u.pathname === "/api/reports/seen" && req.method === "POST") return json(res, markAllRead());
       // Home (home.mjs): the liquid's live data, and its talk; Adapt (adapt.mjs): its
       // shape from how you use it (commit=1 when it wakes from rest, never mid-gesture).
       if (u.pathname === "/api/home") return json(res, homeState({ fresh: u.searchParams.get("fresh") === "1" }));
@@ -329,10 +358,13 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       // the Week tab's week is saved to weeks/ too, as Write it now saves it (no notification: you're looking at it)
       if (u.pathname === "/api/run" && req.method === "POST") { const b = await readBody(req); const cmd = ["week", "standup", "todo"].includes(b.cmd) ? b.cmd : "week"; return json(res, cmd === "week" ? await runWeekly(writeup, { notify: false }) : await writeup(cmd)); }
       if (u.pathname === "/api/connect" && req.method === "POST") { return json(res, await connectProvider(await readBody(req))); }
-      if (u.pathname === "/api/ping") { if (u.searchParams.get("fresh") === "1") await checkLatest(); return json(res, { version: VERSION, started: SERVER_STARTED, latest: LATEST_VERSION, newer: semverGt(LATEST_VERSION, VERSION), ...(IN_TERMUX ? { termux: true } : {}) }); }
+      // a sandbox (symbiot app --fresh) never offers an update: it would replace your real install
+      if (u.pathname === "/api/ping") { if (u.searchParams.get("fresh") === "1" && !SANDBOX) await checkLatest(); return json(res, { version: VERSION, started: SERVER_STARTED, latest: LATEST_VERSION, newer: !SANDBOX && semverGt(LATEST_VERSION, VERSION), ...(IN_TERMUX ? { termux: true } : {}), ...(SANDBOX ? { sandbox: true } : {}) }); }
       // What's new: after an update, since the version you last saw (until you click Got it);
       // ?latest=1, what the update on offer brings, from its package on npm
       if (u.pathname === "/api/whatsnew") {
+        // a brand-new install has nothing to catch up on: this version counts as seen
+        if (u.searchParams.get("latest") !== "1" && FIRST_RUN && !loadConfig().seenVersion) { const cfg = loadConfig(); cfg.seenVersion = VERSION; saveConfig(cfg); return json(res, { version: VERSION, changes: [] }); }
         if (u.searchParams.get("latest") !== "1") return json(res, whatsNew());
         const to = LATEST_VERSION; if (!semverGt(to, VERSION)) return json(res, { version: to, changes: [] });
         const md = await registryChangelog(to);
@@ -345,6 +377,7 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
         // reconnects and reloads. Free the port first and mark the new copy as a
         // relaunch, so it takes over instead of finding us and bowing out.
         // SYMBIOT_UPDATE_CMD replaces the install (the tests use a no-op).
+        if (SANDBOX) return json(res, { error: "This is a sandbox (symbiot app --fresh): update your real Symbiot instead." });
         const { target, cmd } = updateCmd(LATEST_VERSION, VERSION);
         const inst = process.env.SYMBIOT_UPDATE_CMD || cmd;
         const e = track("symbiot update", inst, homedir(), (code) => {
@@ -381,6 +414,8 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
   startPhone(); // Watch on your phone: the computer listens if it's switched on, the phone asks if it's paired
   setInterval(() => { try { startWaiting(); } catch {} }, 20000).unref(); // a run that waits for your step starts once the file it names changes
   setInterval(() => { try { lanesTick(); } catch {} }, 20000).unref(); // agents hand work to other lanes, and hear back when it's done
+  setTimeout(() => { try { knowledgeTick(); } catch {} }, 5000).unref(); setInterval(() => { try { knowledgeTick(); } catch {} }, 3 * 60 * 1000).unref(); // knowledge folders: changed files re-read (a stat per file when nothing changed)
+  setInterval(() => { try { awaitTick(); } catch {} }, 60000).unref(); // a reply an agent's email waits on: found, and handed on
 }
 
 export { updateCmd, changesSince, whatsNew, tarFile, registryChangelog, BROWSER_KEEP, startApp, askRunningApp, isAppRunningWeekly };

package/tasks.mjs

@@ -4,35 +4,52 @@
 // it shows.
 import { spawnSync } from "node:child_process";
 import { join } from "node:path";
-import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { VERSION, LATEST_VERSION, REGISTRY, semverGt, loadConfig, saveConfig, loadTasks, saveTasks, taskWords, sameTask, uniqueTasks, sh, hasCmd, repoState } from "./core.mjs";
-import { handoverRules, ONLY_YOU } from "./handover.mjs";
+import { VERSION, LATEST_VERSION, REGISTRY, semverGt, loadConfig, saveConfig, loadTasks, saveTasks, TASK_MAX, clipWords, taskWords, sameTask, uniqueTasks, sh, hasCmd, repoState } from "./core.mjs";
+import { handoverRules, ONLY_YOU, HANDBACK } from "./handover.mjs";
 import { userStyleLine } from "./adapt.mjs";
-import { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, startHeldTasks, connectorsLine } from "./agents.mjs";
+import { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, droppedTasks, startHeldTasks, connectorsLine } from "./agents.mjs";
 import { gitDefaultBranch } from "./drift.mjs";
 import { repoPathMap, openWork, detectRepo } from "./scan.mjs";
 
 // ---- tasks: a persistent checklist (stored by core.mjs) -------------------
 // One line (TASKS.md has a task per line, and a tick only matches a whole one),
-// long enough for a pasted list of next steps: 300 cut one off mid-list.
-function addTask(text, repo) {
-  text = String(text || "").replace(/\s+/g, " ").trim().slice(0, 1000);
+// long enough for a pasted list of next steps: 300 cut one off mid-list. Longer
+// than a task holds (TASK_MAX), nothing is cut: the task keeps its whole text as
+// written (full), and its line is how it starts plus a link to the rest, which
+// goes out with its brief as .symbiot/full/<id>.md (pushTasks). after: what ends
+// its line either way, "(handed over by coral)".
+const LEAD_MAX = 600, FULL_DIR = "full";
+const fullLink = (id) => ` Full text: \`.symbiot/${FULL_DIR}/${id}.md\``;
+// A long task's start: its whole sentences up to LEAD_MAX, or its words.
+function leadOf(text) {
+  const m = text.slice(0, LEAD_MAX + 1).match(/^.*[.!?](?=\s)/s);
+  return m && m[0].length >= LEAD_MAX / 3 ? m[0] + " …" : clipWords(text, LEAD_MAX);
+}
+function addTask(text, repo, { after = "" } = {}) {
+  const raw = String(text || "").trim(), tail = String(after || "").trim();
+  text = raw.replace(/\s+/g, " ");
   if (!text) return { error: "empty" };
-  const t = loadTasks();
+  const long = text.length + tail.length + 1 > TASK_MAX, full = long ? raw + (tail ? "\n\n" + tail : "") : "";
+  const lineFor = (id) => (long ? leadOf(text) + fullLink(id) : text) + (tail ? " " + tail : "");
+  const t = loadTasks(), id = randomBytes(6).toString("hex"), line = lineFor(id);
   // The same task already open in the same repo (in review counts), even in
   // other words (sameTask): that task, not a duplicate. When the new wording has
   // a clause more, the task takes it, unless it's in review (its tick is on the
   // old words). Handed out already, a tick on either wording counts (syncTasks).
-  const dup = t.find((x) => !x.done && !x.archived && (x.repo || "") === (repo || "") && sameTask(x.text, text));
-  if (dup && !dup.review && taskWords(text).length > taskWords(dup.text).length) { dup.text = text; saveTasks(t); return { ...dup, duplicate: true, reworded: true }; }
+  const dup = t.find((x) => !x.done && !x.archived && (x.repo || "") === (repo || "") && sameTask(x.text, line));
+  if (dup && !dup.review && taskWords(full || line).length > taskWords(dup.full || dup.text).length) {
+    dup.text = lineFor(dup.id); if (long) dup.full = full; else delete dup.full;
+    saveTasks(t); return { ...dup, duplicate: true, reworded: true };
+  }
   if (dup) return { ...dup, duplicate: true };
-  const item = { id: randomBytes(6).toString("hex"), text, repo: repo || "", done: false, ts: Date.now() };
+  const item = { id, text: line, ...(long ? { full } : {}), repo: repo || "", done: false, ts: Date.now() };
   t.unshift(item); saveTasks(t); return item;
 }
 function toggleTask(id) { const t = loadTasks(); const it = t.find((x) => x.id === id); if (it) { it.done = !it.done; saveTasks(t); } return it || { error: "not found" }; }
 function removeTask(id) { saveTasks(loadTasks().filter((x) => x.id !== id)); return { ok: true }; }
-function restoreTask(id) { const t = loadTasks(); const it = t.find((x) => x.id === id); if (it) { it.archived = false; it.done = false; delete it.archivedAt; if (it.removedBy) { it.kept = true; delete it.removedBy; delete it.merged; } saveTasks(t); } return it || { error: "not found" }; }
+function restoreTask(id) { const t = loadTasks(); const it = t.find((x) => x.id === id); if (it) { it.archived = false; it.done = false; delete it.archivedAt; if (it.removedBy || it.dropped) { it.kept = true; delete it.removedBy; delete it.merged; delete it.dropped; } saveTasks(t); } return it || { error: "not found" }; }
 // Which task texts the agent checked off in a repo's .symbiot/TASKS.md
 function completedInRepo(repoPath) {
   try { return readFileSync(join(repoPath, ".symbiot", "TASKS.md"), "utf8").split("\n").filter((l) => /^\s*-\s*\[x\]/i.test(l)).map((l) => l.replace(/^\s*-\s*\[x\]\s*/i, "").trim().toLowerCase()); }
@@ -68,6 +85,19 @@ function applyRemovals(t) {
   }
   return n;
 }
+// A task the agent deleted from its TASKS.md (droppedTasks: the brief tells it
+// to, only when the user says to drop one) is closed: archived as dropped, so
+// the next brief doesn't bring it back. Only open tasks from before that brief,
+// and never one you restored (kept). map: repo name → path.
+function applyDrops(t, map) {
+  let n = 0; const now = Date.now(), seen = {};
+  for (const x of t) {
+    if (x.done || x.archived || x.review || x.kept || !x.repo || !map[x.repo]) continue;
+    const gone = seen[x.repo] || (seen[x.repo] = droppedTasks(map[x.repo]));
+    if (gone.some((d) => (x.ts || 0) <= d.at && sameTask(d.text, x.text))) { Object.assign(x, { done: true, archived: true, archivedAt: now, dropped: true }); n++; }
+  }
+  return n;
+}
 // "Check what was handed out, see what's completed, then archive it" — with an
 // approval step in between. An agent ticking an item in TASKS.md means "done,
 // please review", NOT archived: it waits in review until the user approves it
@@ -77,6 +107,7 @@ function applyRemovals(t) {
 // starts on what's still open in them (one `push --open` started can't do that).
 function syncTasks() {
   const t = loadTasks(); const map = repoPathMap(); let review = 0, archived = 0, started = 0; const checkedByRepo = {};
+  const dropped = applyDrops(t, map);
   for (const x of t) {
     if (x.archived || x.done || x.review || !x.repo) continue;
     if (!(x.repo in checkedByRepo)) { const p = map[x.repo]; if (p && startHeldTasks(p)) started++; checkedByRepo[x.repo] = p ? completedInRepo(p) : []; }
@@ -85,7 +116,7 @@ function syncTasks() {
   for (const x of t) { if (x.done && !x.archived) { x.archived = true; x.archivedAt = Date.now(); archived++; } }
   const removed = applyRemovals(t);
   saveTasks(t);
-  return { review, archived, started, removed };
+  return { review, archived, started, removed, dropped };
 }
 // git with an argv (task text goes into commit messages — never through a shell)
 function git(repo, args, timeout = 30000) {
@@ -264,7 +295,7 @@ const NOT_OWN = /(^|\/)(package(-lock)?\.json|npm-shrinkwrap\.json|CHANGELOG\.md
 function changelogEntry(text) {
   let s = String(text || "").replace(/\s+/g, " ").trim();
   const m = s.match(/^(.{40,}?(?<!\be\.g|\bi\.e|\betc|\bvs)[.!?])\s+(?=[^a-z])/); if (m && m[1].length <= ENTRY_MAX) s = m[1]; // not at "e.g. `x`" or "e.g. when"
-  return s.length > ENTRY_MAX ? s.slice(0, ENTRY_MAX - 1).replace(/\s+\S*$/, "") + "…" : s;
+  return clipWords(s, ENTRY_MAX);
 }
 function changelogSection(version, texts, files = [], day = new Date().toISOString().slice(0, 10), notes = null) {
   const own = files.filter((f) => !NOT_OWN.test(f));
@@ -386,7 +417,7 @@ function commitSubject(texts) {
   const more = texts.length > 1 ? ` (+${texts.length - 1} more)` : "", max = 72 - more.length;
   const t = String(texts[0]).split("\n").find((l) => l.trim()) || "";
   const s = t.replace(/^\s*(#+|[-*+]|\d+[.)])\s+/, "").replace(/\*\*|__/g, "").replace(/\s+/g, " ").trim() || `${texts.length} approved tasks`;
-  return (s.length > max ? s.slice(0, max - 1).replace(/\s+\S*$/, "") + "…" : s) + more;
+  return clipWords(s, max) + more;
 }
 // Sync approved work: off the default branch onto symbiot/<task>, commit the
 // working tree (minus .symbiot/), push, and open a PR with gh. On a branch whose
@@ -525,8 +556,8 @@ function buildTasksMd(name, ctx, list) {
   const byType = {}; for (const t of list) { const ty = taskType(t.text); (byType[ty] = byType[ty] || []).push(t); }
   const keys = Object.keys(byType).sort((a, b) => TASK_ORDER.indexOf(a) - TASK_ORDER.indexOf(b));
   for (const ty of keys) { L.push(`### ${ty}`); for (const t of byType[ty]) L.push(`- [ ] ${t.text}`); L.push(""); }
-  L.push("## When you finish an item", "- Tick it here (`- [x]`) as soon as it's done — that's how it reaches review. Ticking doesn't archive it: the user approves it in Symbiot, which commits it on a branch and opens a PR.", "- Leave your changes **uncommitted**, and don't tick anything you didn't finish or couldn't verify.", "");
-  L.push(...handoverRules(ctx.lanes || [], name));
+  L.push("## When you finish an item", "- Tick it here (`- [x]`) as soon as it's done — that's how it reaches review. Ticking doesn't archive it: the user approves it in Symbiot, which commits it on a branch and opens a PR.", "- Leave your changes **uncommitted**, and don't tick anything you didn't finish or couldn't verify.", "- If the user says to drop an item (in ANSWERS.md, say), delete its line here: Symbiot closes it, so it isn't sent again. Don't delete one for any other reason.", "");
+  L.push(...handoverRules(ctx.lanes || [], name), ...HANDBACK);
   L.push("## If you need a decision, or have ideas", "You may be running unattended, so you can't ask in chat. Write `.symbiot/QUESTIONS.md` instead: Symbiot shows it to the user on your block in its Agents tab, and their answers come back in `.symbiot/ANSWERS.md` (read that first if it exists).",
     `- At most ${QUESTIONS_MAX} questions, under a \`## Questions\` heading. Each is a \`### \` heading, then a line of context, then exactly ${OPTIONS_SHOWN} options as \`- \` bullets, the one you recommend first, marked \`(recommended)\`. Symbiot shows only the first ${OPTIONS_SHOWN}; the user can always answer in their own words.`,
     "- Judge the options before you ask. Most people pick the recommended option without weighing the other, and Symbiot works for a whole company (developers, sales, everyone), not one person, so the choice is really yours. Both options must be good routes to the best solution, never filler or one you wouldn't take. Each says in plain words, with no jargon, what it does and what it changes from then on for the project, the people working on it and the company. Recommend the one that's best for, in this order, the company, the people doing the work, then the task's goal. Base that on evidence you can check here (git history, tests, logs, how it's used, the answers so far), not on what's quickest, and give that evidence in the context line in a sentence.",
@@ -541,12 +572,13 @@ function buildTasksMd(name, ctx, list) {
   return L.join("\n") + "\n";
 }
 function pushTasks(filter) {
-  const all = loadTasks(); if (applyRemovals(all)) saveTasks(all); // what an approved Drop/Merge named never goes out again
+  const byName = repoPathMap(); // from the already-scanned map when there is one
+  // what an approved Drop/Merge named, or an agent deleted from its brief, never goes out again
+  const all = loadTasks(); if (applyRemovals(all) + applyDrops(all, byName)) saveTasks(all);
   let tasks = all.filter((t) => !t.done && !t.archived && !t.review);
   if (filter && filter.type) tasks = tasks.filter((t) => taskType(t.text) === filter.type);
   if (filter && filter.repo) tasks = tasks.filter((t) => t.repo === filter.repo);
   if (!tasks.length) return { empty: true, written: [], unresolved: [] };
-  const byName = repoPathMap(); // from the already-scanned map when there is one
   const groups = {}; for (const t of tasks) { const k = t.repo || ""; (groups[k] = groups[k] || []).push(t); }
   const written = [], unresolved = [], connectors = connectorsLine(); // the same for every repo's run
   for (const name of Object.keys(groups)) {
@@ -560,6 +592,8 @@ function pushTasks(filter) {
       const open = openWork([{ path, name }]).slice(0, 12);
       const det = detectRepo({ path, name, recency: 0 });
       const stack = [...det.langs.slice(0, 4), ...det.tools].join(", ");
+      // a long task's whole text, where its line links to (addTask)
+      for (const t of groups[name].filter((x) => x.full)) { mkdirSync(join(path, ".symbiot", FULL_DIR), { recursive: true }); writeFileSync(join(path, ".symbiot", FULL_DIR, t.id + ".md"), t.full.replace(/\s*$/, "\n")); }
       const risk = [];
       if (st.stale) risk.push("stale checkout — working tree is an old snapshot, not new work");
       if (st.behind) risk.push(`${st.behind} behind upstream on ${st.branch}`);
@@ -572,4 +606,4 @@ function pushTasks(filter) {
   return { empty: false, written, unresolved, handoff: handoffCmd() };
 }
 
-export { addTask, toggleTask, removeTask, restoreTask, completedInRepo, removalOf, applyRemovals, syncTasks, workingChanges, workingDiff, publishesOnMerge, unreleased, bumpOffer, learnNpm, releaseNeeded, withReleases, setVersion, changelogEntry, changelogSection, noteChangelog, releaseInput, shipWithBump, runSummary, saidFinished, pendingReview, commitSubject, shipChanges, autoMergeRepos, setAutoMerge, approveRepo, approveChanges, sendBack, TASK_ORDER, taskType, buildTasksMd, pushTasks };
+export { addTask, toggleTask, removeTask, restoreTask, completedInRepo, removalOf, applyRemovals, applyDrops, syncTasks, workingChanges, workingDiff, publishesOnMerge, unreleased, bumpOffer, learnNpm, releaseNeeded, withReleases, setVersion, changelogEntry, changelogSection, noteChangelog, releaseInput, shipWithBump, runSummary, saidFinished, pendingReview, commitSubject, shipChanges, autoMergeRepos, setAutoMerge, approveRepo, approveChanges, sendBack, TASK_ORDER, taskType, buildTasksMd, pushTasks };