symbiot 0.40.4 → 0.41.0

package/watch.mjs

@@ -7,26 +7,34 @@
 // An agent reads what's new with `symbiot watch new`, and can act on it with
 // `symbiot screens press` / `type`.
 //
+// GitHub's notifications (github.com/notifications) are read through `gh`
+// when it's signed in, not the page: see readGitHub.
+//
 // Stored in ~/.config/symbiot/watch.json, readable by you only:
-// { watches: [{ id, name, url, every (minutes), added, last, checked?, error?, seen: [key…] }],
-//   news: [{ id, watch, name, ts, text, href? }] }
+// { watches: [{ id, name, url, every (minutes), added, last, checked?, error?, via?, seen: [key…] }],
+//   news: [{ id, watch, name, ts, text, href? }],
+//   briefs: [{ id, watch, name, ts, count, text }] }
 // `last` is when it was last read, `checked` when a read last worked; `seen`
-// holds what's been listed, as itemKey()s.
+// holds what's been listed, as itemKey()s. A brief is your AI's read of one
+// batch of news (config.watchBrief switches it on), with the same `ts`.
 import { join } from "node:path";
 import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { CONFIG_DIR } from "./core.mjs";
+import { CONFIG_DIR, loadConfig, saveConfig } from "./core.mjs";
 import { readPage, siteUrl } from "./headless.mjs";
 import { loadScreens } from "./screens.mjs";
 import { desktopNotify } from "./desktop.mjs";
+import { resolveProvider, write } from "./ai.mjs";
 
 const WATCH_FILE = join(CONFIG_DIR, "watch.json");
 const EVERY = [5, 15, 30, 60]; // minutes between reads
-const MAX_WATCHES = 12, MAX_SEEN = 1000, MAX_NEWS = 200, MAX_PER_READ = 25;
+const MAX_WATCHES = 12, MAX_SEEN = 1000, MAX_NEWS = 200, MAX_PER_READ = 25, MAX_BRIEFS = 50;
 
 function loadWatch() {
-  try { const d = JSON.parse(readFileSync(WATCH_FILE, "utf8")); return { watches: Array.isArray(d.watches) ? d.watches : [], news: Array.isArray(d.news) ? d.news : [] }; }
-  catch { return { watches: [], news: [] }; }
+  const list = (d, k) => (Array.isArray(d[k]) ? d[k] : []);
+  try { const d = JSON.parse(readFileSync(WATCH_FILE, "utf8")); return { watches: list(d, "watches"), news: list(d, "news"), briefs: list(d, "briefs") }; }
+  catch { return { watches: [], news: [], briefs: [] }; }
 }
 // What's new can be your mail's senders and subjects, so it's yours only (0600).
 function saveWatch(d) {
@@ -65,10 +73,11 @@ function itemKey(text) {
   return s.replace(/[\s,;·•|]+/g, " ").trim().slice(0, 240);
 }
 // The items not seen before, top first, and the keys of everything listed now.
+// An item can bring its own key (GitHub's: its thread and when it changed).
 function newItems(seen, items) {
   const known = new Set(seen), keys = new Set(), fresh = [];
   for (const it of items) {
-    const k = itemKey(it.text); if (!k || keys.has(k)) continue;
+    const k = it.key || itemKey(it.text); if (!k || keys.has(k)) continue;
     keys.add(k); if (!known.has(k)) fresh.push(it);
   }
   return { fresh, keys: [...keys] };
@@ -76,22 +85,76 @@ function newItems(seen, items) {
 // Remember what's listed now as the most recent, and forget the oldest.
 function remember(seen, keys) { const now = new Set(keys); return [...(seen || []).filter((k) => !now.has(k)), ...keys].slice(-MAX_SEEN); }
 
+// ---- GitHub, through gh --------------------------------------------------------
+// Review requests, failed CI runs and mentions read better from GitHub's API than
+// from its page: with the GitHub CLI signed in (gh auth login), Symbiot asks it
+// for your unread notifications. No browser, no Sign in. Without gh, the page is
+// read like any other.
+const GITHUB_INBOX = "https://github.com/notifications";
+const isGitHubInbox = (url) => /^https:\/\/(www\.)?github\.com\/notifications(?:[/?#]|$)/i.test(String(url || ""));
+const REASON = { review_requested: "Review requested", approval_requested: "Approval requested", mention: "Mentioned", team_mention: "Team mentioned", assign: "Assigned", security_alert: "Security alert", invitation: "Invitation", comment: "New comment", state_change: "Changed" };
+// The page on github.com for a notification (its subject's url is the API's).
+function githubHref(n) {
+  const repo = (n.repository && n.repository.html_url) || "", api = String((n.subject && n.subject.url) || "");
+  const m = api.match(/^https:\/\/api\.github\.com\/repos\/([^/]+\/[^/]+)\/(pulls|issues|commits|releases)\/([^/]+)$/);
+  if (m) return m[2] === "releases" ? `https://github.com/${m[1]}/releases` : `https://github.com/${m[1]}/${{ pulls: "pull", issues: "issues", commits: "commit" }[m[2]]}/${m[3]}`;
+  if (n.subject && /^(CheckSuite|WorkflowRun)$/.test(n.subject.type) && repo) return repo + "/actions";
+  return repo || GITHUB_INBOX;
+}
+// GET /notifications's answer as items. Each is keyed by its thread and when it
+// last changed: a CI run failing again on the same branch, or a new comment on a
+// pull request, is new again.
+function githubItems(list) {
+  return (Array.isArray(list) ? list : []).filter((n) => n && n.id && n.subject && n.subject.title).map((n) => {
+    const why = n.reason === "ci_activity" ? "" : REASON[n.reason] || "";
+    const repo = (n.repository && n.repository.full_name) || "";
+    return { text: [why, repo, n.subject.title].filter(Boolean).join(" · ").slice(0, 300), href: githubHref(n), key: `github ${n.id} ${n.updated_at || ""}` };
+  });
+}
+// Your unread notifications through gh, as a page Watch reads ({ url, list,
+// via }), or null when gh isn't there or isn't signed in (then the page is read).
+function readGitHub() {
+  return new Promise((resolve) => {
+    execFile("gh", ["api", "notifications?per_page=50"], { timeout: 30000, maxBuffer: 8 << 20, windowsHide: true }, (err, out) => {
+      if (err) return resolve(null);
+      try { resolve({ url: GITHUB_INBOX, list: githubItems(JSON.parse(out)), via: "gh" }); } catch { resolve(null); }
+    });
+  });
+}
+
+// ---- the brief -------------------------------------------------------------------
+// Switched on, your AI reads each batch of news (what the page lists: for mail,
+// the sender, subject and Gmail's one-line preview) and says what needs you and
+// what can wait. That's in the app and in the notification. A local Ollama model
+// keeps it all on this computer.
+const briefOn = () => !!loadConfig().watchBrief;
+function setBrief(on) { const cfg = loadConfig(); if (on) cfg.watchBrief = true; else delete cfg.watchBrief; return saveConfig(cfg) ? { brief: !!on } : { error: "Couldn't write the config file." }; }
+async function briefOf(news, name) {
+  if (!resolveProvider()) return "";
+  const system = `You triage what just arrived on a page someone watches: their email inbox, or their GitHub notifications. ` +
+    `In at most 3 short lines of plain text, first what needs them (and why, in a few words), then what can wait. ` +
+    `Name things by sender and subject so they can find them. Use only what's shown; never guess at what a message says beyond it. No preamble, no markdown.`;
+  const text = await write(system, `New on ${name}:\n${news.map((n) => "- " + n.text).join("\n")}\n\nWhat needs me, and what can wait?`);
+  return text && !/^\(?couldn't reach the model/i.test(text) ? text.trim().slice(0, 600) : "";
+}
+
 // ---- watches -------------------------------------------------------------------
-const view = (w) => ({ id: w.id, name: w.name, url: w.url, every: w.every, added: w.added, last: w.last || 0, ...(w.checked ? { checked: w.checked } : {}), ...(w.error ? { error: w.error } : {}), known: (w.seen || []).length });
-function watchState() { const d = loadWatch(); return { watches: d.watches.map(view), news: d.news.slice(0, 50), every: EVERY }; }
+const view = (w) => ({ id: w.id, name: w.name, url: w.url, every: w.every, added: w.added, last: w.last || 0, ...(w.checked ? { checked: w.checked } : {}), ...(w.error ? { error: w.error } : {}), ...(w.via ? { via: w.via } : {}), known: (w.seen || []).length });
+function watchState() { const d = loadWatch(); return { watches: d.watches.map(view), news: d.news.slice(0, 50), briefs: d.briefs.slice(0, 10), brief: briefOn(), every: EVERY }; }
 
-// Watch a mapped page (`screen`: its id) or a site (`site`). Watching the same
-// address again just changes how often.
+// Watch a mapped page (`screen`: its id) or a site (`site`; "github" is GitHub's
+// notifications). Watching the same address again just changes how often.
 function addWatch({ screen, site, every, name } = {}) {
   const s = screen ? loadScreens().find((x) => x.id === screen) : null;
   if (screen && !s) return { error: `No screen ${screen}.` };
   if (s && !s.page) return { error: "Watch reads a web page you mapped (Map page). A screenshot of your screen can't be read again by itself." };
-  const url = s ? s.page.url : siteUrl(site);
-  if (!url) return { error: "Give a mapped page or a site to watch: gmail, github.com/notifications or a web address." };
+  const url = s ? s.page.url : /^\s*(https?:\/\/)?(www\.)?github(\.com)?\/?\s*$/i.test(String(site || "")) ? GITHUB_INBOX : siteUrl(site);
+  if (!url) return { error: "Give a mapped page or a site to watch: gmail, github or a web address." };
   const d = loadWatch(), had = d.watches.find((w) => w.url === url);
   if (had) { had.every = everyOf(every, had.every); return saveWatch(d) ? view(had) : { error: "Couldn't write " + WATCH_FILE + "." }; }
   if (d.watches.length >= MAX_WATCHES) return { error: `You're watching ${MAX_WATCHES} pages already. Stop watching one first.` };
-  const w = { id: randomBytes(4).toString("hex"), name: String(name || (s && s.name) || hostOf(url)).trim().slice(0, 80) || hostOf(url), url, every: everyOf(every, 15), added: Date.now(), last: 0, seen: [] };
+  const fallback = isGitHubInbox(url) ? "GitHub notifications" : hostOf(url);
+  const w = { id: randomBytes(4).toString("hex"), name: String(name || (s && s.name) || fallback).trim().slice(0, 80) || fallback, url, every: everyOf(every, 15), added: Date.now(), last: 0, seen: [] };
   d.watches.push(w);
   return saveWatch(d) ? view(w) : { error: "Couldn't write " + WATCH_FILE + "." };
 }
@@ -103,42 +166,84 @@ function setEvery(id, every) {
 // Stop watching, and forget what it found.
 function removeWatch(id) {
   const d = loadWatch(); if (!d.watches.some((x) => x.id === id)) return { error: `No watch ${id}.` };
-  d.watches = d.watches.filter((x) => x.id !== id); d.news = d.news.filter((n) => n.watch !== id);
+  d.watches = d.watches.filter((x) => x.id !== id); d.news = d.news.filter((n) => n.watch !== id); d.briefs = d.briefs.filter((n) => n.watch !== id);
   saveWatch(d); return { ok: true };
 }
-function clearNews() { const d = loadWatch(); d.news = []; saveWatch(d); return { ok: true }; }
+function clearNews() { const d = loadWatch(); d.news = []; d.briefs = []; saveWatch(d); return { ok: true }; }
 // What's new in the last `hours`, newest first (what an agent reads).
 function newsSince(hours = 24, now = Date.now()) { return loadWatch().news.filter((n) => n.ts >= now - hours * 3600000); }
+// What's new after `ts` (exclusive), and its briefs: what the phone asks for.
+function newsAfter(ts) { const d = loadWatch(), t = Number(ts) || 0; return { news: d.news.filter((n) => n.ts > t), briefs: d.briefs.filter((b) => b.ts > t) }; }
 
-// Read a watched page now and note what's new. `read` and `notify` are
-// headless.mjs's readPage and a desktop notification (the tests pass their own).
-// Gives the watch, plus `new` (what was new) or `learned` (the first read), or
-// `busy` when the hidden browser is in use (nothing changes: it's read later).
-async function checkWatch(id, { read = readPage, notify = desktopNotify } = {}) {
+// ---- for Standup: "3 emails waiting on you" ------------------------------------
+// What a watch lists, as a noun: mail, GitHub notifications, else new things on it.
+function kindOf(url) {
+  const h = hostOf(url);
+  if (isGitHubInbox(url)) return ["GitHub notification", "GitHub notifications"];
+  if (/^(mail|webmail)\.|^outlook\.(live|office|office365)\.com$/.test(h)) return ["email", "emails"];
+  return null;
+}
+// What's new on each page you watch in the last `hours`: [{ name, count, label,
+// items }], label like "3 emails" or "2 new on Jira".
+function waitingOn(hours = 24, now = Date.now()) {
+  const d = loadWatch(), out = new Map();
+  for (const n of d.news.filter((x) => x.ts >= now - hours * 3600000)) {
+    const w = d.watches.find((x) => x.id === n.watch); if (!w) continue;
+    const g = out.get(w.id) || { name: w.name, url: w.url, items: [] }; g.items.push(n.text); out.set(w.id, g);
+  }
+  return [...out.values()].map((g) => {
+    const k = kindOf(g.url), count = g.items.length;
+    return { name: g.name, count, label: k ? `${count} ${k[count === 1 ? 0 : 1]}` : `${count} new on ${g.name}`, items: g.items };
+  });
+}
+
+// A batch of news as one notification: how many and where, then the brief if
+// there is one, else the first few. The phone (phone.mjs) shows the same.
+function newsNotice(news, name, brief = "") {
+  return [`${news.length} new · ${String(name).slice(0, 50)}`,
+    brief || news.slice(0, 3).map((n) => n.text.slice(0, 90)).join("\n") + (news.length > 3 ? `\n…and ${news.length - 3} more in Symbiot` : "")];
+}
+
+// Read a watched page now and note what's new. `read`, `github`, `notify` and
+// `brief` are headless.mjs's readPage, readGitHub, a desktop notification and
+// briefOf (the tests pass their own). Gives the watch, plus `new` (what was new)
+// and `brief`, or `learned` (the first read), or `busy` when the hidden browser
+// is in use (nothing changes: it's read later).
+async function checkWatch(id, { read = readPage, github = readGitHub, notify = desktopNotify, brief = briefOf } = {}) {
   const w0 = loadWatch().watches.find((x) => x.id === id); if (!w0) return { error: `No watch ${id}.` };
-  const page = (await read(w0.url)) || { error: "Nothing came back from the page." };
+  const page = (isGitHubInbox(w0.url) && await github()) || (await read(w0.url)) || { error: "Nothing came back from the page." };
   if (page.busy) return { ...view(w0), busy: true };
   // read again: the file may have changed while the page loaded
   const d = loadWatch(), w = d.watches.find((x) => x.id === id); if (!w) return { error: "That watch was removed." };
   w.last = Date.now();
-  const items = page.error || page.login ? [] : itemsOf(page), before = w.error || "";
-  if (page.login) w.error = `Signed out of ${hostOf(page.url) || hostOf(w.url)}. Under Screens, type ${hostOf(w.url)} and click Sign in, sign in once and close the window.`;
+  // through gh, a list with nothing unread is a good read; a page always lists something
+  const items = page.error || page.login ? [] : page.list || itemsOf(page), before = w.error || "";
+  if (page.login) w.error = `Signed out of ${hostOf(page.url) || hostOf(w.url)}. Under Screens, type ${hostOf(w.url)} and click Sign in, sign in once and close the window.` + (isGitHubInbox(w.url) ? " Or sign in the GitHub CLI (gh auth login): Symbiot then reads your notifications through it." : "");
   else if (page.error) w.error = page.error;
-  else if (!items.length) w.error = "Found nothing listed on the page this time.";
-  if (page.error || page.login || !items.length) {
+  else if (!items.length && !page.list) w.error = "Found nothing listed on the page this time.";
+  if (page.error || page.login || (!items.length && !page.list)) {
     saveWatch(d);
     // signed out needs you; the rest (the browser busy with Sign in, a slow page) usually passes by itself
     if (page.login && w.error !== before) notify("Symbiot", `${w.name}: ${w.error}`);
     return view(w);
   }
   delete w.error;
-  const first = !w.checked, { fresh, keys } = newItems(w.seen, items);
+  // read another way than last time (gh, or the page while gh is out): the same
+  // things look different, so learn them again rather than announce them all
+  const first = !w.checked || (w.via || "") !== (page.via || ""), { fresh, keys } = newItems(w.seen, items);
+  if (page.via) w.via = page.via; else delete w.via;
   w.seen = remember(w.seen, keys); w.checked = w.last;
   const news = first ? [] : fresh.slice(0, MAX_PER_READ).map((it) => ({ id: randomBytes(4).toString("hex"), watch: w.id, name: w.name, ts: w.last, text: it.text.slice(0, 300), ...(it.href ? { href: it.href } : {}) }));
   d.news = [...news, ...d.news].slice(0, MAX_NEWS);
   saveWatch(d);
-  if (news.length) notify(`${news.length} new · ${w.name.slice(0, 50)}`, news.slice(0, 3).map((n) => n.text.slice(0, 90)).join("\n") + (news.length > 3 ? `\n…and ${news.length - 3} more in Symbiot` : ""));
-  return { ...view(w), ...(first ? { learned: keys.length } : { new: news }) };
+  if (first) return { ...view(w), learned: keys.length };
+  let said = "";
+  if (news.length && briefOn()) {
+    said = await brief(news, w.name).catch(() => "");
+    if (said) { const d2 = loadWatch(); d2.briefs = [{ id: randomBytes(4).toString("hex"), watch: w.id, name: w.name, ts: w.last, count: news.length, text: said }, ...d2.briefs].slice(0, MAX_BRIEFS); saveWatch(d2); }
+  }
+  if (news.length) notify(...newsNotice(news, w.name, said));
+  return { ...view(w), new: news, ...(said ? { brief: said } : {}) };
 }
 // The watches that are due, longest-waiting first.
 function dueWatches(now = Date.now()) { return loadWatch().watches.filter((w) => now - (w.last || 0) >= w.every * 60000).sort((a, b) => (a.last || 0) - (b.last || 0)); }
@@ -157,4 +262,4 @@ function startWatches(opts = {}) {
   return () => { clearTimeout(first); clearInterval(every); };
 }
 
-export { WATCH_FILE, EVERY, itemsOf, itemKey, newItems, remember, watchState, addWatch, setEvery, removeWatch, clearNews, newsSince, checkWatch, dueWatches, startWatches };
+export { WATCH_FILE, EVERY, GITHUB_INBOX, itemsOf, itemKey, newItems, remember, isGitHubInbox, githubItems, readGitHub, setBrief, briefOf, newsNotice, watchState, addWatch, setEvery, removeWatch, clearNews, newsSince, newsAfter, waitingOn, checkWatch, dueWatches, startWatches };

package/writeups.mjs

@@ -0,0 +1,251 @@
+// What Symbiot writes with your AI: your week, standup and to-dos, a repo's
+// review and next steps, a folder's overview, and the Q&A on a task. Plus the
+// opt-in sent mail that week and standup fold in (read by mail.mjs).
+import { join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { VERSION, loadConfig, saveConfig, loadTasks, saveTasks, sh, repoState } from "./core.mjs";
+import { resolveProvider, write } from "./ai.mjs";
+import { detectMailSources, mailActivity } from "./mail.mjs";
+import { waitingOn } from "./watch.mjs";
+import { me, authorship, authorArgs, readmeInfo, repoShape, houseRules, reportFooter, expandRoot, commits, openWork, detectFolder, repoPathMap, discoveredRepos } from "./scan.mjs";
+import { taskType, workingChanges, workingDiff } from "./tasks.mjs";
+
+// ---- render ---------------------------------------------------------------
+function renderCommits(list) {
+  return list.map((x) => `- [${x.repo}] ${x.subject}${x.files.length ? ` (${x.files.length} files)` : ""}`).join("\n");
+}
+
+// AI review of one repo: what it does, what it's for, possible upgrades.
+async function repoReview(path) {
+  if (!resolveProvider()) return { error: "not-connected" };
+  if (!path) return { error: "no repo" };
+  const name = path.split("/").pop();
+  const auth = authorship(path), state = repoState(path), rd = readmeInfo(path), shape = repoShape(path), rules = houseRules(path);
+  const commits = sh(`git -C ${JSON.stringify(path)} log ${authorArgs(auth.emails)} --format='%ad %s' --date=short -50 2>/dev/null`).trim()
+    || sh(`git -C ${JSON.stringify(path)} log --format='%ad %s' --date=short -50 2>/dev/null`).trim();
+  const footer = reportFooter(path, auth, state, rd);
+  // Cheap maturity gauge, so the model can be told to show restraint instead of
+  // always inventing new features (over-engineering is a failure, not a win).
+  const testFiles = Number(sh(`git -C ${JSON.stringify(path)} ls-files 2>/dev/null | grep -icE '(^|/)(tests?|spec|__tests__)/|\\.(test|spec)\\.'`).trim()) || 0;
+  const churn = Number(sh(`git -C ${JSON.stringify(path)} log --since='14 days ago' --oneline 2>/dev/null | wc -l`).trim()) || 0;
+  const posture = state.stale ? "the checkout is a stale snapshot — the priority is getting current, not new work"
+    : (testFiles === 0 && shape.total > 40) ? "a real codebase with NO test files — favour tests/stabilising over new features"
+    : (churn >= 25) ? "very rapid churn lately — likely over-iterating; be conservative, prefer consolidation/finishing over new features"
+    : (state.dirty > 20) ? "a lot of unfinished/uncommitted work — finish what's open before starting new things"
+    : "no red flags — but still only propose what clearly pays off";
+  const system =
+    `You are a pragmatic, restraint-minded reviewer of ONE software project. Respond with ONLY a JSON object (no fences): {"review": string, "verdict": string, "ideas": string[]}. ` +
+    `"review": 3-6 sentences on what it does and who it's for. ` +
+    `"verdict": ONE honest sentence on whether this project needs new work now, and of what KIND. Over-engineering is a failure: if it's already capable, or shows churn / missing tests / unfinished work, say so and steer toward STABILISING (tests, docs, finishing, removing) or simply SHIPPING — not more features. ` +
+    `"ideas": AT MOST 5, ranked by value, ONLY items that clearly pay off. Do NOT pad the list — returning 0–2 ideas with a "stabilise, don't add" verdict is a good, correct answer. Prefer fixes / tests / simplification / finishing over new features unless a feature is clearly warranted by the evidence. ` +
+    `Ground every claim in the evidence; recent commits beat the README; never propose building something already in the structure; never advise against the stated conventions. ` +
+    (state.stale ? `CRITICAL: the working tree is a STALE checkout — never suggest committing it. ` : ``);
+  const prompt =
+    `Project: ${name}\nBranch ${state.branch} · ${auth.total} commits total (${auth.mineCount} yours${auth.filterDropped ? ", filter dropped so counting everyone" : ""})\n` +
+    `Maturity signal: ${posture}. (${testFiles} test files, ${churn} commits in the last 14 days.)\n\n` +
+    (rd.file ? `README (last changed ${rd.lastDate || "?"}, ${rd.commitsAgo} commits ago — may be out of date):\n${rd.excerpt}\n\n` : "(no README)\n\n") +
+    `Structure (top folders · file counts): ${shape.dirs.join(", ")}\nManifests: ${shape.manifests.join(", ") || "none"}\nDocs present: ${shape.docs.join(", ") || "none"}\n\n` +
+    `Recent commits (newest first):\n${commits || "(none)"}\n\n` +
+    (rules ? `Conventions this team has chosen — do NOT advise against these:\n${rules}\n\n` : "") +
+    (state.stale ? `Working tree: STALE (≈ ${state.staleBy ? "HEAD~" + state.staleBy : "older"}); its "changes" are the gap to an old snapshot, not new work.\n\n` : "") +
+    `Return the JSON. Remember: fewer, higher-value ideas beat a long list; a "don't add — stabilise" verdict with 0–2 ideas is a valid answer.`;
+  const raw = await write(system, prompt);
+  if (!raw) return { text: "(couldn't reach the model)", ideas: [], verdict: "", footer };
+  const j = extractJson(raw);
+  if (j && (j.review || j.ideas || j.verdict)) return {
+    text: String(j.review || "").trim() || raw,
+    verdict: String(j.verdict || "").trim(),
+    ideas: Array.isArray(j.ideas) ? j.ideas.map((x) => String(x).trim()).filter(Boolean).slice(0, 5) : [],
+    footer,
+  };
+  return { text: raw, ideas: [], verdict: "", footer };
+}
+function extractJson(s) {
+  if (!s) return null;
+  let t = String(s).trim().replace(/^```(?:json)?/i, "").replace(/```$/,"").trim();
+  const a = t.indexOf("{"), b = t.lastIndexOf("}");
+  if (a >= 0 && b > a) { try { return JSON.parse(t.slice(a, b + 1)); } catch {} }
+  return null;
+}
+// AI "value" suggestions for one repo, from its recent commits + open work.
+async function repoSuggest(path) {
+  if (!resolveProvider()) return { error: "not-connected" };
+  if (!path) return { error: "no repo" };
+  const name = path.split("/").pop();
+  const auth = authorship(path), state = repoState(path), rd = readmeInfo(path), rules = houseRules(path);
+  const recent = sh(`git -C ${JSON.stringify(path)} log ${authorArgs(auth.emails)} --format='%ad %s' --date=short -50 2>/dev/null`).trim()
+    || sh(`git -C ${JSON.stringify(path)} log --format='%ad %s' --date=short -50 2>/dev/null`).trim();
+  const open = openWork([{ path, name }]);
+  const footer = reportFooter(path, auth, state, rd);
+  const system =
+    `You are a pragmatic senior engineer advising on one project. Write exactly three short sections with headings: ` +
+    `"In flight" (what's clearly underway), "Next steps" (3-5 concrete actions), "Ideas" (2-3 that fit where this is heading). ` +
+    `Ground each point in the evidence; recent commits beat the README. Do not advise against the stated conventions. ` +
+    (state.stale ? `CRITICAL: the working tree is a STALE checkout — never suggest committing it (would revert history). ` : ``) +
+    `No filler, no preamble.`;
+  const prompt =
+    `Project: ${name} (branch ${state.branch}, ${auth.total} commits, ${auth.mineCount} yours${auth.filterDropped ? " — filter dropped" : ""}).\n\n` +
+    `Recent commits:\n${recent || "(none)"}\n\nOpen / unfinished:\n${open.length ? open.map((o) => "- " + o).join("\n") : "(none found)"}\n\n` +
+    (rules ? `Conventions — do NOT advise against these:\n${rules}\n\n` : "") + `Give the advice.`;
+  const text = await write(system, prompt);
+  return { text: text || "(couldn't reach the model)", footer };
+}
+// Overview + suggestions for a NON-git project folder (no commits to read), from
+// its file tree, manifest and README. The folder-node equivalent of repoSuggest.
+async function folderSuggest(path) {
+  if (!resolveProvider()) return { error: "not-connected" };
+  if (!path) return { error: "no path" };
+  const det = detectFolder(path);
+  const files = sh(`find ${JSON.stringify(path)} -maxdepth 2 \\( -name node_modules -o -name .git \\) -prune -o -type f -print 2>/dev/null | head -200`).split("\n").filter(Boolean);
+  const rels = files.map((f) => f.slice(path.length + 1));
+  const pick = (names) => { for (const n of names) { const hit = files.find((f) => f.split("/").pop().toLowerCase() === n); if (hit) { try { return readFileSync(hit, "utf8").slice(0, 2000); } catch {} } } return ""; };
+  const manifest = pick(["package.json", "requirements.txt", "pyproject.toml", "go.mod", "cargo.toml", "pom.xml", "composer.json", "gemfile", "pubspec.yaml"]);
+  const readme = pick(["readme.md", "readme.txt", "readme"]);
+  const stack = [...det.langs, ...det.tools].join(", ") || "unknown";
+  const system =
+    `You are a pragmatic senior engineer looking at a project FOLDER that is NOT under version control. ` +
+    `From its files, write exactly three short sections with headings: "Overview" (what this project is, 1-2 sentences), ` +
+    `"Next steps" (3-5 concrete actions — a strong first one is often "git init" if this looks like real work), ` +
+    `"Ideas" (2-3 that fit where it's heading). Ground every point in the actual files/manifest/README shown. No preamble.`;
+  const prompt =
+    `Folder: ${det.name}\nStack: ${stack}\nFiles (${det.files}):\n${rels.slice(0, 120).join("\n")}\n\n` +
+    (manifest ? `Manifest:\n${manifest}\n\n` : "") + (readme ? `README excerpt:\n${readme}\n\n` : "") + `Write the overview and suggestions.`;
+  const text = await write(system, prompt);
+  const footer = `symbiot ${VERSION} · folder · ${det.files} files · ${stack} · not a git repo`;
+  return { text: text || "(couldn't reach the model)", footer };
+}
+// Ask questions about a task: a short Q&A thread kept on the task itself
+// (task.chat), grounded in the repo/folder it belongs to — and, once an agent
+// has ticked it, in the changes waiting for review.
+const CHAT_KEEP = 40; // messages stored per task
+async function taskChat(id, question) {
+  question = String(question || "").trim().slice(0, 2000);
+  const it = loadTasks().find((x) => x.id === id);
+  if (!it) return { error: "not found" };
+  if (!question) return { error: "empty" };
+  if (!resolveProvider()) return { error: "not-connected" };
+  const path = it.repo ? repoPathMap()[it.repo] : "";
+  const ctx = [];
+  if (path) {
+    const isGit = existsSync(join(path, ".git"));
+    if (isGit) ctx.push(`Recent commits:\n${sh(`git -C ${JSON.stringify(path)} log --format='%ad %s' --date=short -15 2>/dev/null`).trim() || "(none)"}`);
+    else { const det = detectFolder(path); ctx.push(`Project folder (not a git repo) · ${det.files} files · ${[...det.langs, ...det.tools].join(", ") || "unknown stack"}`); }
+    const rd = readmeInfo(path); if (rd.excerpt) ctx.push(`README excerpt:\n${rd.excerpt.slice(0, 1500)}`);
+    const rules = houseRules(path); if (rules) ctx.push(`Conventions — do NOT advise against these:\n${rules}`);
+    if (it.review && isGit) {
+      const ch = workingChanges(path);
+      ctx.push(`The agent has ticked this task; its uncommitted changes await review (${ch.stat || "no changes"}):\n${ch.files.map((f) => `${f.st} ${f.file}`).slice(0, 40).join("\n") || "(none)"}\n\nDiff (truncated):\n${workingDiff(path, 6000)}`);
+    }
+  }
+  const history = (it.chat || []).slice(-12).map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text}`).join("\n\n");
+  const system =
+    `You are a pragmatic senior engineer helping someone with ONE task on their list — before or after they hand it to a coding agent. ` +
+    `Answer their question about the task directly and concisely, in plain text, no preamble. Ground what you say in the project evidence shown; ` +
+    `if the evidence doesn't settle it, say so and what you'd check. If the task is ambiguous, say how you'd read it and what to clarify. ` +
+    `Never invent files, features or history.`;
+  const prompt =
+    `Task: ${it.text}\nKind: ${taskType(it.text)} · repo: ${it.repo || "(none)"} · status: ${it.archived ? "archived" : it.review ? "done by the agent, awaiting review" : it.done ? "done" : "open"}\n\n` +
+    (ctx.length ? ctx.join("\n\n") + "\n\n" : path ? "" : "(no repo attached — answer from the task text alone)\n\n") +
+    (history ? `Conversation so far:\n${history}\n\n` : "") + `Question: ${question}`;
+  const answer = (await write(system, prompt)) || "(couldn't reach the model)";
+  // Re-read: other requests may have changed tasks.json while the model ran.
+  const t = loadTasks(); const cur = t.find((x) => x.id === id); const now = Date.now();
+  if (!cur) return { answer, chat: [] };
+  cur.chat = [...(cur.chat || []), { role: "user", text: question, ts: now }, { role: "ai", text: answer, ts: now }].slice(-CHAT_KEEP);
+  saveTasks(t);
+  return { answer, chat: cur.chat };
+}
+function clearTaskChat(id) { const t = loadTasks(); const it = t.find((x) => x.id === id); if (!it) return { error: "not found" }; delete it.chat; saveTasks(t); return { ok: true }; }
+
+// ---- email: opt-in, local, no API (see mail.mjs) ---------------------------
+// config.mail = { enabled, sources: [extra folders/.mbox files], addresses: [your
+// mail addresses, to pick your mail out of a whole-mailbox export] }.
+function mailCfg() {
+  const m = loadConfig().mail || {};
+  return { enabled: !!m.enabled, sources: Array.isArray(m.sources) ? m.sources : [], addresses: Array.isArray(m.addresses) ? m.addresses : [] };
+}
+function mailState() { return { ...mailCfg(), detected: detectMailSources() }; }
+function setMail(b = {}) {
+  const m = mailCfg();
+  if (typeof b.enabled === "boolean") m.enabled = b.enabled;
+  if (b.add) {
+    const p = expandRoot(b.add);
+    // A website typed here (it sits under Trusted sites, easily mixed up): say where it goes.
+    const site = p && !existsSync(p) && !/\.(mbox|mbx|eml|msf|sbd)$/i.test(p) && /^(https?:\/\/)?[a-z0-9-]+(\.[a-z0-9-]+)+(:\d+)?([/?#].*)?$/i.test(p) ? new URL(/^https?:/i.test(p) ? p : "https://" + p).hostname : "";
+    if (site) return { ...mailState(), site, error: `${site} is a website, not mail on this computer. To let Screens press and type there without asking, add it under Trusted sites, just above.` };
+    if (!p || !existsSync(p)) return { ...mailState(), error: "not found: " + (p || "(empty)") };
+    if (!m.sources.includes(p)) m.sources.push(p);
+  }
+  if (b.remove) m.sources = m.sources.filter((x) => x !== b.remove);
+  if (typeof b.addresses === "string") m.addresses = b.addresses.split(/[\s,;]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.includes("@"));
+  const cfg = loadConfig(); cfg.mail = m; saveConfig(cfg);
+  return mailState();
+}
+// Mail you sent in the window — [] unless it's switched on (preview ignores that).
+function sentMail(days, preview = false) {
+  const m = mailCfg(); if (!m.enabled && !preview) return [];
+  return mailActivity({ days, sources: m.sources, addresses: [...m.addresses, me().email].filter(Boolean) });
+}
+const renderMail = (list) => list.slice(0, 60).map((x) => `- ${x.date} · to ${x.to.join(", ") || "?"} · ${x.subject}`).join("\n");
+
+// What's new on the pages you watch since yesterday (watch.mjs), for Standup:
+// one line, "Waiting on you: 3 emails, 2 GitHub notifications", under the
+// write-up. Counted here, not by the AI, so the numbers are right; the AI sees
+// them only to know what's next.
+const WAITING_HOURS = 24;
+function waitingLine(groups) { return groups.length ? "Waiting on you: " + groups.map((g) => g.label).join(", ") : ""; }
+const withWaiting = (text, line) => (line ? `${text}\n\n${line}` : text);
+
+// Build a write-up for a command; returns { text, sub, error? } without printing.
+// Shared by the CLI (cmdRun) and the web UI (symbiot app). since: the days
+// `week` covers (--since); all: everyone's commits, not just yours (--all).
+async function produce(cmd, { since = 7, all: everyone = false } = {}) {
+  if (!resolveProvider()) return { error: "not-connected" };
+  if (cmd === "todo") {
+    const repos = discoveredRepos();
+    const open = openWork(repos);
+    if (!open.length) return { text: "Nothing outstanding found (no TODOs or uncommitted work).", sub: "0 open items · todo" };
+    const system =
+      `You summarise what's still on a developer's plate from their TODO markers and uncommitted work. ` +
+      `Group by project, lead with what looks most in-flight (uncommitted work) then the to-dos. ` +
+      `Be concise and concrete. No preamble.`;
+    const text = await write(system, `Open work:\n${open.map((o) => `- ${o}`).join("\n")}\n\nWhat's still on my plate?`);
+    return { text: text || "(couldn't reach the model)", sub: `${open.length} open items · todo`, footer: `symbiot ${VERSION} · ${repos.length} repos scanned · ${open.length} open items` };
+  }
+  const label = cmd === "standup" ? "standup" : "week";
+  const days = cmd === "standup" ? 2 : since;
+  const who = me();
+  // Discover the Map's repo set, then keep only those with commits in the window.
+  const all = discoveredRepos();
+  const repos = all.filter((r) => sh(`git -C ${JSON.stringify(r.path)} log --since="${days} days ago" --oneline -1 2>/dev/null`).trim());
+  const mail = sentMail(days); // [] unless email is switched on
+  const waiting = label === "standup" ? waitingOn(WAITING_HOURS) : [], line = waitingLine(waiting);
+  const waitNote = waiting.length ? " · " + waiting.map((g) => g.label).join(", ") + " waiting" : "";
+  if (!repos.length && !mail.length) return { text: withWaiting(`No commits in the last ${days} days across your ${all.length} repos.\nAdd folders to scan in Settings, or check your git identity.`, line), sub: "no activity" + waitNote };
+  let cs = commits(repos, `${days} days ago`, !everyone);
+  if (!cs.length) cs = commits(repos, `${days} days ago`, false); // fall back to all if none matched you
+  const open = label === "week" ? openWork(repos) : [];
+  if (!cs.length && !mail.length) return { text: withWaiting("Found repos, but no commits in the window.", line), sub: "no commits" + waitNote };
+
+  const system =
+    `You write a short, first-person work update from a person's git commits${mail.length ? " and the emails they sent" : ""}. ` +
+    `Write as them ("I"), plainly and specifically, grouped by theme or project, most important first. ` +
+    `Turn commit messages into outcomes a manager or teammate would understand — not a raw commit list. ` +
+    (mail.length ? `Fold the emails into those themes (a decision, a hand-off, who they worked with); skip routine ones (receipts, scheduling, one-line replies). You only have their subjects and recipients — don't guess at what they said. ` : "") +
+    `${label === "standup" ? "Keep it to 3-5 bullets: done, and what's next." : "A short paragraph or a few grouped bullets; end with a one-line 'In progress / next' if there are open items."} ` +
+    `No preamble, no sign-off, no invented work — only what the commits${mail.length ? ", emails" : ""} and open items show.` +
+    (waiting.length ? ` What's waiting on them (new on pages they watch) is counted in a line added under what you write: don't list or count it, but you may name one as next if it's clearly work (a review request, a failed CI run).` : "");
+  const prompt =
+    `Person: ${who.name || "me"}. Window: ${label === "standup" ? "since yesterday" : `last ${days} days`}.\n\n` +
+    `Commits:\n${cs.length ? renderCommits(cs) : "(none)"}\n\n` +
+    (mail.length ? `Emails I sent (date · to · subject):\n${renderMail(mail)}\n\n` : "") +
+    (open.length ? `Open / in progress:\n${open.map((o) => `- ${o}`).join("\n")}\n\n` : "") +
+    (waiting.length ? `Waiting on me (new since yesterday):\n${waiting.map((g) => `- ${g.label}:\n${g.items.slice(0, 10).map((t) => `  - ${t.slice(0, 160)}`).join("\n")}`).join("\n")}\n\n` : "") +
+    `Write the ${label === "standup" ? "standup" : "update"}.`;
+
+  const text = await write(system, prompt);
+  const mailNote = mail.length ? ` · ${mail.length} sent email${mail.length === 1 ? "" : "s"}` : "";
+  return { text: text ? withWaiting(text, line) : "(couldn't reach the model)", sub: `${cs.length} commits across ${new Set(cs.map((x) => x.repo)).size} repos${mailNote}${waitNote} · ${label}`, footer: `symbiot ${VERSION} · ${all.length} repos (same as the Map) · ${repos.length} active · ${cs.length} commits in last ${days}d${mailNote}` };
+}
+
+export { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, produce };