symbiot 0.44.0 → 0.45.0

package/mind.mjs

@@ -23,9 +23,10 @@ import { randomBytes } from "node:crypto";
 import { VERSION, CONFIG_DIR } from "./core.mjs";
 import { write } from "./ai.mjs";
 import { handoffCmd, runHandoff } from "./agents.mjs";
-import { addTask } from "./tasks.mjs";
+import { addTask, pushTasks } from "./tasks.mjs";
 import { repoPathMap } from "./scan.mjs";
 import { OPS, handoverRules, ONLY_YOU } from "./handover.mjs";
+import { styleOf, styleLine, userStyleLine } from "./adapt.mjs";
 
 const MIND_FILE = join(CONFIG_DIR, "mind.json");
 const ACT_DIR = join(CONFIG_DIR, "drafts"); // runs of their own, next to drafted replies
@@ -114,12 +115,14 @@ This folder isn't a repo; there's nothing to change in it but this file. Use you
 
 - **Anything hard to undo you only ask about:** closing or deleting an account, deleting data, paying or buying, sending something to someone. Find out what it would affect first (what's running, what it costs, what's in it), then stop and ask in \`.symbiot/QUESTIONS.md\` with what you found, and don't go ahead until ANSWERS.md says to.
 - Is part of it a repo's work? Hand it over (below) rather than doing it from here.
-- Need the user? Only for what no agent can do: ask in \`.symbiot/QUESTIONS.md\` (a \`## Questions\` heading, a \`### \` heading per question, then 2–4 options as \`- \` bullets).
+- Need the user? Only for what no agent can do: ask in \`.symbiot/QUESTIONS.md\` (a \`## Questions\` heading, a \`### \` heading per question, then 2–4 options as \`- \` bullets).${voiceLine()}
 ${ONLY_YOU}
 - When it's done, tick the task (\`- [x]\`) and say what you did in your last message: it's what goes back to whoever asked.
 
 ${handoverRules(names, OPS).join("\n")}`;
 }
+// How to write to the user, for a brief: their talking style, if it's known.
+const voiceLine = () => { const v = userStyleLine(); return v ? "\n- Writing to the user (questions, your last message): " + v : ""; };
 // Run the coding agent on a request, in a folder of its own (it shows in the
 // Agents tab, with its questions). { ok, job, dir } or { error }.
 function actNow(request, { title, context, known, run = runHandoff, now = Date.now() } = {}) {
@@ -141,11 +144,39 @@ function actNow(request, { title, context, known, run = runHandoff, now = Date.n
 
 // ---- one voice --------------------------------------------------------------------
 const IDENTITY = `You are Symbiot, the one assistant in the user's Symbiot app. The Dashboard's cards, the Tasks list and the rest are only places they talk to you: it's all you, and you remember across them (see "What you know" and "Lately, elsewhere in the app").`;
-const RULES = `Reply with JSON only, no markdown fence:
+// lanes: the repos "do" can point at; self: Symbiot's own repo among them, where
+// a flaw in Symbiot itself is fixed.
+function rulesFor(lanes = [], self = "") {
+  return `Reply with JSON only, no markdown fence:
 {"reply": "what you say, plain text, brief, no preamble",
- "do": null or {"agent": "what their coding agent should do now: self-contained, with names, links and ids"} or {"task": "a task for their list", "repo": "a repo name, or empty"},
+ "do": null or {"agent": "what a coding agent should do now: self-contained, with names, links and ids", "repo": "the lane it's for, or empty"} or {"task": "a task for later", "repo": "the lane it's for, or empty"},
  "remember": [{"name": "…", "kind": "person|account|site|repo|project|decision|preference", "fact": "…"}]}
-When they ask you to do something (look into it, find out, fix, set up, sign in, close, send, chase), do it, don't explain what you can't do: "agent" runs their coding agent now, with their tools and connectors (MCP, the command line, a browser signed in to their linked sites). Use "task" for what's for later, or belongs in a repo's work. Don't ask their permission to hand it over: the agent asks them first, in the Agents tab, before anything hard to undo (closing an account, deleting, paying, sending); say so in your reply when it applies, with what to check first. A question you can answer from what's here: answer it, "do": null. "remember": only lasting facts worth knowing on another page (who someone is, which account is what, a decision, how they like things); [] for anything else.`;
+When they ask you to do something (look into it, find out, fix, set up, sign in, close, send, chase), do it, don't explain what you can't do: "agent" starts a coding agent now, with their tools and connectors (MCP, the command line, a browser signed in to their linked sites). With a "repo", it's that project's agent, working in it; empty, an agent for everything outside a repo (this computer, accounts, services). Use "task" for what's for later. Don't ask their permission to hand it over: the agent asks them first, in the Agents tab, before anything hard to undo (closing an account, deleting, paying, sending); say so in your reply when it applies, with what to check first. A question you can answer from what's here: answer it, "do": null.
+Lanes ("repo" is one of these, exactly): ${lanes.length ? lanes.slice(0, 60).join(", ") : "(none found)"}.${self ? ` Symbiot itself is "${self}": a flaw in how Symbiot works (how it read a page, what a brief or a card said, anything in the app) goes there.` : ""}
+Don't wait to be asked to fix Symbiot. When you notice it got something wrong (you misread a page, a brief or a card misled them, a step made them do an agent's job), say so plainly and, in the same reply, start the fix: "agent"${self ? ` with "repo": "${self}"` : ""}, saying what went wrong, an example, and what it should do instead.
+"remember": only lasting facts worth knowing on another page (who someone is, which account is what, a decision, how they like things); [] for anything else.`;
+}
+// Symbiot's own repo among your lanes (its package.json is symbiot's), or "".
+function selfLane(map) {
+  for (const [n, p] of Object.entries(map)) { try { if (JSON.parse(readFileSync(join(p, "package.json"), "utf8")).name === "symbiot") return n; } catch {} }
+  return "";
+}
+const laneName = (repo, map) => Object.keys(map).find((n) => n.toLowerCase() === String(repo || "").trim().toLowerCase()) || "";
+// Do it, in the right lane: a repo's work joins its tasks and its agent starts
+// there, the way Send to repos does; anything else, an agent of its own (actNow).
+function actIn(request, repo, { map = {}, known = "", title, context, run = runHandoff, add = addTask, push = pushTasks, ops = actNow, now = Date.now() } = {}) {
+  const lane = laneName(repo, map);
+  if (!lane) return { ...ops(request, { title, context, known, now }), lane: "" };
+  const t = add(request, lane); if (t && t.error) return { error: t.error };
+  const p = push({ repo: lane }); if (!p || !p.written || !p.written.length) return { error: `Couldn't write ${lane}'s tasks for its agent.` };
+  const e = run(map[lane]); if (!e) return { error: "The agent didn't start. Check its command in Settings → Handoff." };
+  return { ok: true, lane, task: t.id, ...(e.busy || e.blocked ? { queued: true } : { job: e.id }) };
+}
+// For later: on the list, in a repo's lane if it names one Symbiot knows.
+function taskIn(text, repo, { map = {}, add = addTask } = {}) {
+  const lane = laneName(repo, map), r = add(text, lane);
+  return r && r.error ? { error: r.error } : { ok: true, id: r.id, lane };
+}
 
 function parseReply(raw) {
   const t = String(raw || "").trim().replace(/^```(?:json)?/i, "").replace(/```$/, "").trim();
@@ -158,9 +189,12 @@ function parseReply(raw) {
 // what this page is for; context: what the page shows; history: this chat's
 // own last turns. act: { agent(request) -> result, task(text, repo) -> result },
 // what "do" runs here. Gives { reply, did?, remembered }.
-async function converse({ where, role = "", context = "", history = "", question, act = {}, ask = write, now = Date.now() }) {
+async function converse({ where, role = "", context = "", history = "", question, act = {}, ask = write, map = null, now = Date.now() }) {
   const d = loadMind(), known = recallText(recall(question, now, d)), elsewhere = lately(where, d);
-  const system = `${IDENTITY} ${role}\n\n${RULES}`;
+  let lanes = map; if (!lanes) { try { lanes = repoPathMap(); } catch { lanes = {}; } }
+  // how they talk, from what they've typed into any chat (adapt.mjs: accommodation)
+  const voice = styleLine(styleOf(d.log.filter((l) => l.role === "user").map((l) => l.text).concat(question)));
+  const system = `${IDENTITY} ${role}\n\n${rulesFor(Object.keys(lanes), selfLane(lanes))}${voice ? "\n" + voice : ""}`;
   const prompt = (known ? `What you know (from across the app):\n${known}\n\n` : "") + (elsewhere ? `Lately, elsewhere in the app:\n${elsewhere}\n\n` : "") +
     (context ? context + "\n\n" : "") + (history ? `This chat so far:\n${history}\n\n` : "") + `They say (on ${where}): ${question}`;
   const raw = await ask(system, prompt);
@@ -168,12 +202,18 @@ async function converse({ where, role = "", context = "", history = "", question
   const j = parseReply(raw);
   let reply = String(j.reply || "").trim().slice(0, 4000) || "(no answer)", did = null;
   const want = j.do && typeof j.do === "object" ? j.do : null;
+  // say where it actually went, from what happened, not from what the model meant
+  const repo = want ? String(want.repo || "") : "";
   if (want && want.agent && act.agent) {
-    did = { kind: "agent", request: String(want.agent).slice(0, 2000), ...(await act.agent(String(want.agent), known)) };
-    reply += did.error ? `\n\n(I couldn't hand it to your agent: ${did.error})` : "\n\n→ Handed to your agent. It's in the Agents tab, and it asks you there before anything hard to undo.";
+    did = { kind: "agent", request: String(want.agent).slice(0, 2000), ...(await act.agent(String(want.agent), known, repo)) };
+    reply += did.error ? `\n\n(I couldn't hand it to an agent: ${did.error})`
+      : did.lane ? `\n\n→ Handed to ${did.lane}'s agent, as a task there${did.queued ? " (it starts once the run there now finishes)" : ""}. It's in the Agents tab.`
+      : "\n\n→ Handed to your agent. It's in the Agents tab, and it asks you there before anything hard to undo.";
   } else if (want && want.task && act.task) {
-    did = { kind: "task", text: String(want.task).slice(0, 300), repo: String(want.repo || ""), ...(await act.task(String(want.task), String(want.repo || ""))) };
-    reply += did.error ? `\n\n(I couldn't add the task: ${did.error})` : `\n\n→ Added to your tasks${did.repo ? ` for ${did.repo}` : ""}: ${did.text}`;
+    did = { kind: "task", text: String(want.task).slice(0, 300), ...(await act.task(String(want.task), repo)) };
+    reply += did.error ? `\n\n(I couldn't add the task: ${did.error})`
+      : did.lane ? `\n\n→ Added to ${did.lane}'s tasks: ${did.text}`
+      : `\n\n→ Added to your tasks, but not to a repo${repo ? ` (there's no lane called ${repo})` : ""}, so no agent will pick it up until it has one: ${did.text}`;
   }
   // read again: another chat may have written while the model answered
   const d2 = loadMind(), remembered = rememberIn(d2, j.remember, where, now);
@@ -181,7 +221,7 @@ async function converse({ where, role = "", context = "", history = "", question
   saveMind(d2);
   return { reply, ...(did ? { did } : {}), remembered };
 }
-// The usual "task" act: added to your list (a repo's, if named).
-const addToTasks = (text, repo) => { const r = addTask(text, repo); return r && r.error ? { error: r.error } : { ok: true, id: r.id }; };
+// The usual "task" act, for a caller with no lanes of its own to pass.
+const addToTasks = (text, repo) => { let map = {}; try { map = repoPathMap(); } catch {} return taskIn(text, repo, { map }); };
 
-export { MIND_FILE, loadMind, remember, recall, recallText, lately, mindState, forget, actBrief, actNow, parseReply, converse, addToTasks };
+export { MIND_FILE, loadMind, remember, recall, recallText, lately, mindState, forget, actBrief, actNow, actIn, taskIn, selfLane, rulesFor, parseReply, converse, addToTasks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbiot",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice — Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
@@ -26,9 +26,12 @@
     "mind.mjs",
     "handover.mjs",
     "lanes.mjs",
+    "adapt.mjs",
+    "home.mjs",
     "phone.mjs",
     "desktop.mjs",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "engines": {
@@ -62,7 +65,7 @@
     "@anthropic-ai/sdk": "^0.128.0"
   },
   "scripts": {
-    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/peek.mjs && node test/mind.mjs && node test/lanes.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
+    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/peek.mjs && node test/mind.mjs && node test/lanes.mjs && node test/adapt.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
     "lint": "eslint ."
   },
   "devDependencies": {

package/server.mjs

@@ -5,17 +5,19 @@
 import { spawn, spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
 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, semverGt, checkLatest, loadConfig, saveConfig, loadTasks, hasCmd, chromeBinary } from "./core.mjs";
-import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, answerQuestions, agentsList, startWaiting } from "./agents.mjs";
+import { VERSION, LATEST_VERSION, REGISTRY, semverGt, checkLatest, 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";
 import { computeDrift } from "./drift.mjs";
-import { addTask, toggleTask, removeTask, restoreTask, syncTasks, taskType, pushTasks, pendingReview, workingDiff, learnNpm, withReleases, approveRepo, approveChanges, sendBack, setAutoMerge } from "./tasks.mjs";
-import { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, produce } from "./writeups.mjs";
+import { addTask, toggleTask, removeTask, restoreTask, syncTasks, taskType, pushTasks, pendingReview, workingDiff, learnNpm, withReleases, releaseInput, approveRepo, approveChanges, sendBack, setAutoMerge } from "./tasks.mjs";
+import { repoReview, repoSuggest, folderSuggest, taskChat, clearTaskChat, mailState, setMail, sentMail, produce, releaseNotes } from "./writeups.mjs";
 import { loadScreens, screenImage, captureScreen, splitScreen, listMonitors, allowScreenshots, importScreen, setRegions, renameScreen, removeScreen, blueprint, clickRegion } from "./screens.mjs";
 import { mapPage, wholePage, pressRegion, typeRegion, scrollPage, signIn, keepBrowserOpen, isTrusted, trustedSites, trustSite, untrustSite } from "./headless.mjs";
 import { weeklyState, setWeekly, runWeekly, startWeekly, autostartState, setAutostart } from "./desktop.mjs";
@@ -23,6 +25,8 @@ import { watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, chec
 import { linksState, linkSite, checkLink, unlinkSite } from "./links.mjs";
 import { mindState, forget } from "./mind.mjs";
 import { lanesTick, lanesState } from "./lanes.mjs";
+import { adaptState, noteUse } from "./adapt.mjs";
+import { homeState, homeAsk } from "./home.mjs";
 import { phoneState, setPhoneLink, newCode, unpairPhone, pairComputer, forgetComputer, pollComputer, startPhone } from "./phone.mjs";
 
 // The in-app update installs the EXACT newest version (not the `latest` tag, which
@@ -34,6 +38,57 @@ function updateCmd(latest, current, platform = process.platform) {
   return { target, cmd: (platform === "win32" ? "npm i -g " : "npm install -g ") + "symbiot@" + target + " --prefer-online" };
 }
 
+// ---- what's new: the changelog's releases between two versions -------------------
+// CHANGELOG.md's "## 0.45.0 — 2026-10-06" sections newer than `from` and up to
+// `to`, newest first: [{ version, date, items }]. It ships with Symbiot, so after an
+// update the app shows once what came with it (config.seenVersion is the version
+// you last saw it for). Before an update, the new version's own CHANGELOG.md is
+// read from its package on npm (registryChangelog).
+const CHANGELOG = fileURLToPath(new URL("./CHANGELOG.md", import.meta.url));
+function changesSince(md, from, to) {
+  const out = [];
+  for (const part of String(md || "").split(/^## /m).slice(1)) {
+    const m = part.match(/^\[?v?(\d+\.\d+\.\d+)\]?(?:\s*[—–-]\s*(\d{4}-\d{2}-\d{2}))?/); if (!m) continue;
+    if ((from && !semverGt(m[1], from)) || (to && semverGt(m[1], to))) continue;
+    out.push({ version: m[1], date: m[2] || "", items: part.split("\n").filter((l) => /^[-*]\s+/.test(l)).map((l) => l.replace(/^[-*]\s+/, "").trim()).slice(0, 30) });
+  }
+  return out.slice(0, 15);
+}
+const localChangelog = () => { try { return readFileSync(CHANGELOG, "utf8"); } catch { return ""; } };
+// After an update: what's new since the version you last saw it for. The first
+// time (no seenVersion yet) that's just this version's own release.
+function whatsNew(cfg = loadConfig(), md = localChangelog()) {
+  const seen = typeof cfg.seenVersion === "string" ? cfg.seenVersion : "";
+  if (seen && !semverGt(VERSION, seen)) return { version: VERSION, changes: [] };
+  const all = changesSince(md, "", VERSION);
+  return { version: VERSION, changes: seen ? changesSince(md, seen, VERSION) : all.slice(0, 1) };
+}
+// A file in a package tarball (.tgz: gzip, then tar's 512-byte headers, each
+// followed by its file's bytes), "" if it isn't there.
+function tarFile(tgz, name) {
+  let buf; try { buf = gunzipSync(tgz); } catch { return ""; }
+  const str = (a, b, at) => buf.subarray(at + a, at + b).toString("utf8").replace(/\0[\s\S]*$/, "");
+  for (let at = 0; at + 512 <= buf.length;) {
+    if (!buf[at]) break;
+    const size = parseInt(str(124, 136, at).trim() || "0", 8) || 0, pre = str(345, 500, at), path = (pre ? pre + "/" : "") + str(0, 100, at);
+    if (path === name) return buf.subarray(at + 512, at + 512 + size).toString("utf8");
+    at += 512 + Math.ceil(size / 512) * 512;
+  }
+  return "";
+}
+// The new version's CHANGELOG.md, from its package on npm (kept once found).
+const REGISTRY_LOGS = new Map();
+async function registryChangelog(version, registry = REGISTRY) {
+  if (REGISTRY_LOGS.has(version)) return REGISTRY_LOGS.get(version);
+  let md = "";
+  try {
+    const r = await fetch(`${registry}/symbiot/-/symbiot-${encodeURIComponent(version)}.tgz`, { signal: AbortSignal.timeout(15000) });
+    if (r.ok) md = tarFile(Buffer.from(await r.arrayBuffer()), "package/CHANGELOG.md");
+  } catch {}
+  if (md) REGISTRY_LOGS.set(version, md);
+  return md;
+}
+
 // ---- `symbiot app` : the same UI in a chrome-less browser window ----------
 // Self-contained HTML served at / — no backticks or ${} inside (it lives in a
 // template literal). Talks to the local API with the per-launch token.
@@ -156,8 +211,8 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
         await learnNpm(ask); return json(res, pendingReview());
       }
       if (u.pathname === "/api/pending/diff") { const p = repoPathMap()[u.searchParams.get("repo") || ""]; return json(res, { diff: p ? workingDiff(p) : "" }); }
-      if (u.pathname === "/api/pending/approve" && req.method === "POST") { const b = await readBody(req); if (b.bump) await learnNpm([repoPathMap()[String(b.repo || "")]]); return json(res, approveRepo(String(b.repo || ""), { bump: b.bump })); }
-      if (u.pathname === "/api/pending/approve-changes" && req.method === "POST") { const b = await readBody(req); if (b.bump) await learnNpm([repoPathMap()[String(b.repo || "")]]); return json(res, approveChanges(String(b.repo || ""), { bump: b.bump })); }
+      if (u.pathname === "/api/pending/approve" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([repoPathMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump })); return json(res, approveRepo(repo, { bump: b.bump, notes })); }
+      if (u.pathname === "/api/pending/approve-changes" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([repoPathMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump, tick: b.tick })); return json(res, approveChanges(repo, { bump: b.bump, tick: b.tick, notes })); }
       if (u.pathname === "/api/pending/sendback" && req.method === "POST") { const b = await readBody(req); return json(res, sendBack(String(b.id || ""))); }
       if (u.pathname === "/api/automerge" && req.method === "POST") { const b = await readBody(req); return json(res, setAutoMerge(String(b.repo || ""), !!b.on)); }
       if (u.pathname === "/api/tasks/push" && req.method === "POST") { const b = await readBody(req); return json(res, pushTasks(b)); }
@@ -178,6 +233,7 @@ 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)); }
       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) }); }
@@ -221,6 +277,12 @@ 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 || ""))); }
+      // 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" }));
+      if (u.pathname === "/api/home/ask" && req.method === "POST") { const b = await readBody(req); return json(res, await homeAsk(b.question)); }
+      if (u.pathname === "/api/adapt") return json(res, adaptState({ from: String(u.searchParams.get("from") || ""), commit: u.searchParams.get("commit") === "1", ...(u.searchParams.has("touch") ? { touch: u.searchParams.get("touch") === "1" } : {}) }));
+      if (u.pathname === "/api/adapt/use" && req.method === "POST") { const b = await readBody(req); return json(res, noteUse(b)); }
       // Lanes (lanes.mjs): work agents handed to each other, and where it stands.
       if (u.pathname === "/api/lanes") return json(res, lanesState());
       // Watch (watch.mjs): a mapped page read again every few minutes, and what's new on it.
@@ -259,6 +321,15 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       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 } : {}) }); }
+      // 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") {
+        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);
+        return json(res, { version: to, changes: changesSince(md, VERSION, to), ...(md ? {} : { error: `Couldn't read ${to}'s changelog from npm.` }) });
+      }
+      if (u.pathname === "/api/whatsnew/seen" && req.method === "POST") { const cfg = loadConfig(); cfg.seenVersion = VERSION; return json(res, saveConfig(cfg) ? { ok: true } : { error: "Couldn't write the config file." }); }
       if (u.pathname === "/api/update" && req.method === "POST") {
         // Install the exact newest version (see updateCmd), then relaunch this
         // same app (same port+token => same URL) and exit. The page's heartbeat
@@ -303,4 +374,4 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
   setInterval(() => { try { lanesTick(); } catch {} }, 20000).unref(); // agents hand work to other lanes, and hear back when it's done
 }
 
-export { updateCmd, BROWSER_KEEP, startApp, askRunningApp, isAppRunningWeekly };
+export { updateCmd, changesSince, whatsNew, tarFile, registryChangelog, BROWSER_KEEP, startApp, askRunningApp, isAppRunningWeekly };

package/tasks.mjs

@@ -8,7 +8,8 @@ import { readFileSync, writeFileSync, existsSync, readdirSync } 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 { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, startHeldTasks } from "./agents.mjs";
+import { userStyleLine } from "./adapt.mjs";
+import { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, startHeldTasks, connectorsLine } from "./agents.mjs";
 import { gitDefaultBranch } from "./drift.mjs";
 import { repoPathMap, openWork, detectRepo } from "./scan.mjs";
 
@@ -250,18 +251,94 @@ function setVersion(path, to) {
   }
   return () => { for (const [file, text] of saved) try { writeFileSync(file, text); } catch {} };
 }
+// ---- the changelog: what each release brought ---------------------------------
+// A repo that keeps a CHANGELOG.md gets a section for each version Approve bumps
+// to, "## 0.45.0 — 2026-10-06", newest first, with what was approved: each task
+// (near-duplicates once), up to its first sentence. Changes approved without a
+// task are named by the files they touch. With an AI connected, Approve has it
+// word them as release notes first (writeups.mjs releaseNotes): opts.notes, one
+// per task. Symbiot ships its own, and the app shows it as what's new in an
+// update (server.mjs changesSince).
+const ENTRY_MAX = 220;
+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;
+}
+function changelogSection(version, texts, files = [], day = new Date().toISOString().slice(0, 10), notes = null) {
+  const own = files.filter((f) => !NOT_OWN.test(f));
+  const items = notes && notes.length ? [...new Set(notes)] : texts.length ? uniqueTasks(texts.map(changelogEntry))
+    : [own.length ? `Changes approved without a task, in ${own.slice(0, 6).join(", ")}${own.length > 6 ? ` and ${own.length - 6} more` : ""}.` : "Version bump only."];
+  return `## ${version} — ${day}\n\n${items.map((x) => "- " + x).join("\n")}\n`;
+}
+// Put the section in above the newest one (after the file's own heading and
+// intro), once per version. Gives back a function that restores the file.
+function noteChangelog(path, version, texts, files, notes) {
+  const file = join(path, "CHANGELOG.md"); let text = "";
+  try { text = readFileSync(file, "utf8"); } catch { return () => {}; }
+  if (new RegExp(`^##\\s+\\[?v?${version.replace(/\./g, "\\.")}\\b`, "m").test(text)) return () => {};
+  const at = text.search(/^## /m), sec = changelogSection(version, texts, files, undefined, notes) + "\n";
+  try { writeFileSync(file, at < 0 ? text.replace(/\s*$/, "\n\n") + sec : text.slice(0, at) + sec + text.slice(at)); } catch { return () => {}; }
+  return () => { try { writeFileSync(file, text); } catch {} };
+}
+// What Approve will put in the changelog, for your AI to word (writeups.mjs
+// releaseNotes): the tasks it ships, in the order it ships them, and the files
+// and diff behind them. null when it won't write one: no bump, no CHANGELOG.md,
+// or the agent is still working there. opts as approveRepo / approveChanges take them.
+function releaseInput(repo, opts = {}) {
+  const path = repoPathMap()[repo];
+  if (!path || !(opts.bump === "patch" || opts.bump === "minor") || !bumpOffer(path) || !existsSync(join(path, "CHANGELOG.md")) || runningHandoff(path)) return null;
+  const t = loadTasks(), ids = new Set(Array.isArray(opts.tick) ? opts.tick.map(String) : []);
+  const review = t.filter((x) => x.repo === repo && x.review && !x.done && !x.archived);
+  const items = review.length ? review : t.filter((x) => ids.has(x.id) && x.repo === repo && !x.done && !x.archived && !x.review);
+  const files = workingChanges(path).files.map((f) => f.file).filter((f) => !NOT_OWN.test(f));
+  const texts = uniqueTasks(items.map((x) => x.text));
+  return texts.length || files.length ? { path, texts, files, diff: workingDiff(path, 30000) } : null;
+}
 // Ship with the version bumped when opts.bump is "patch" or "minor" and the repo
-// is offered one (bumpOffer). The bump is put back if the ship fails.
+// is offered one (bumpOffer), noted in its CHANGELOG.md if it keeps one (in
+// opts.notes' words, when given). Both are put back if the ship fails.
 function shipWithBump(path, texts, opts) {
   const offer = (opts.bump === "patch" || opts.bump === "minor") && bumpOffer(path);
   if (!offer) return shipChanges(path, texts, opts);
-  const to = offer[opts.bump], undo = setVersion(path, to);
+  const to = offer[opts.bump], files = workingChanges(path).files.map((f) => f.file);
+  const undo = setVersion(path, to), undoLog = noteChangelog(path, to, texts, files, opts.notes);
   const r = shipChanges(path, texts, { ...opts, bumped: to });
-  if (r.error) { undo(); return r; }
+  if (r.error) { undo(); undoLog(); return r; }
   return { ...r, bumped: to };
 }
+// What the last run in a folder said when it finished: agent.log after the last
+// run's "=== name time ===" and "$ command" lines.
+function runSummary(path) {
+  let log = ""; try { log = readFileSync(join(path, ".symbiot", "agent.log"), "utf8"); } catch { return ""; }
+  const at = log.lastIndexOf("\n=== "), rest = at < 0 ? log : log.slice(log.indexOf("\n", at + 1) + 1);
+  return rest.replace(/^\$ .*\n?/, "").trim().slice(-8000);
+}
+// Whether a run's summary says it finished a task: one of its lines (a bullet,
+// a paragraph) has most of the task's words, and doesn't say it wasn't done. A
+// guess the user confirms, so it leans to ticking: an unticked task only comes
+// back as a task.
+const NOT_DONE = /\b(didn['’]?t|did not|couldn['’]?t|could not|can['’]?t|cannot|wasn['’]?t|isn['’]?t|haven['’]?t|not (yet|done|finished|ticked|started)|still (open|to do|needs?)|left (it|them|alone)|blocked)\b/i;
+const keyWords = (s) => new Set(taskWords(s).split(" ").filter((w) => w.length > 3).map((w) => w.replace(/s$/, "")));
+function saidFinished(summary, text) {
+  const want = keyWords(text); if (want.size < 2) return false;
+  return String(summary || "").split(/\n/).some((l) => {
+    if (NOT_DONE.test(l)) return false;
+    const has = keyWords(l); let n = 0; for (const w of want) if (has.has(w)) n++;
+    return n >= Math.min(3, want.size) && n / want.size >= 0.4;
+  });
+}
+// The open tasks of a repo whose changes are approved without one: Approve
+// offers to tick them, checked when the last run's summary says it finished them,
+// so finished work doesn't go out again as new tasks on the next send.
+function finishedOffer(path, open) {
+  const summary = runSummary(path);
+  return uniqueTasks(open.map((x) => x.text)).slice(0, 12).map((text) => { const x = open.find((y) => y.text === text); return { id: x.id, text, finished: saidFinished(summary, text) }; });
+}
 // Repos with tasks awaiting review, plus repos Symbiot sent tasks to that have
-// uncommitted changes no ticked task covers (untasked: approve them as-is).
+// uncommitted changes no ticked task covers (untasked: approve them as-is, with
+// `open`, the repo's open tasks, to tick the ones the run finished).
 // running: an agent is still editing there, so its changes may be half done.
 function pendingReview() {
   const t = loadTasks(), by = {}; for (const x of t) if (x.review && !x.done && !x.archived) (by[x.repo] = by[x.repo] || []).push(x);
@@ -271,7 +348,9 @@ function pendingReview() {
   const out = Object.keys(by).sort().map((repo) => { const path = map[repo] || ""; return { repo, path, tasks: by[repo], autoMerge: am.includes(repo), running: !!(path && runningHandoff(path)), ...(path ? { ...workingChanges(path), unreleased: unreleased(path), bumpOffer: bumpOffer(path), publishesOnMerge: publishesOnMerge(path) } : { branch: "", files: [], stat: "" }) }; });
   for (const repo of sent.sort()) {
     const path = map[repo]; if (!path || !existsSync(join(path, ".symbiot", "TASKS.md"))) continue;
-    const wc = workingChanges(path); if (wc.files.length) out.push({ repo, path, tasks: [], untasked: true, autoMerge: am.includes(repo), running: !!runningHandoff(path), ...wc, unreleased: unreleased(path), bumpOffer: bumpOffer(path), publishesOnMerge: publishesOnMerge(path) });
+    const wc = workingChanges(path); if (!wc.files.length) continue;
+    const open = finishedOffer(path, t.filter((x) => x.repo === repo && !x.done && !x.archived && !x.review));
+    out.push({ repo, path, tasks: [], untasked: true, open, autoMerge: am.includes(repo), running: !!runningHandoff(path), ...wc, unreleased: unreleased(path), bumpOffer: bumpOffer(path), publishesOnMerge: publishesOnMerge(path) });
   }
   return out;
 }
@@ -389,14 +468,24 @@ function approveRepo(repo, opts = {}) {
 }
 // "Approve changes without a task": ship the uncommitted changes even though no
 // ticked task is behind them (a fix the agent made but didn't tick). If tasks are
-// awaiting review in the repo, this is just Approve.
+// awaiting review in the repo, this is just Approve. opts.tick: ids of the
+// repo's open tasks the changes finished (the run didn't tick them): they're
+// approved with the changes, as Approve does, so they don't go out again.
 function approveChanges(repo, opts = {}) {
   if (loadTasks().some((x) => x.repo === repo && x.review && !x.done && !x.archived)) return approveRepo(repo, opts);
   const path = repoPathMap()[repo]; if (!path) return { error: "Repo not found: " + (repo || "(no repo)") };
   const busy = stillWorking(repo, path); if (busy) return busy;
   if (!workingChanges(path).files.length) return { error: "No uncommitted changes in " + repo + "." };
-  const r = shipWithBump(path, [], { ...opts, autoMerge: opts.autoMerge !== undefined ? opts.autoMerge : autoMergeRepos().includes(repo) });
-  return r.error ? r : { ...r, approved: 0 };
+  const ids = new Set(Array.isArray(opts.tick) ? opts.tick.map(String) : []);
+  const ticked = (t) => t.filter((x) => ids.has(x.id) && x.repo === repo && !x.done && !x.archived && !x.review);
+  const r = shipWithBump(path, uniqueTasks(ticked(loadTasks()).map((x) => x.text)), { ...opts, autoMerge: opts.autoMerge !== undefined ? opts.autoMerge : autoMergeRepos().includes(repo) });
+  if (r.error) return r;
+  // read again: the ship took a while, and the list may have changed meanwhile
+  const t = loadTasks(), items = ticked(t), now = Date.now();
+  for (const x of items) { x.done = true; x.archived = true; x.archivedAt = now; x.approvedAt = now; for (const k of ["branch", "commit", "pr"]) if (r[k]) x[k] = r[k]; }
+  const removed = items.length ? applyRemovals(t) : 0;
+  if (items.length) saveTasks(t);
+  return { ...r, approved: items.length, ...(removed ? { removed } : {}) };
 }
 // Not right: reopen it and untick it in TASKS.md so the agent picks it up again.
 function sendBack(id) {
@@ -431,6 +520,7 @@ function buildTasksMd(name, ctx, list) {
   if (ctx.commits && ctx.commits.length) { L.push("- **Recent commits:**"); for (const c of ctx.commits) L.push(`  - ${c}`); }
   if (ctx.open && ctx.open.length) { L.push("- **Open markers (TODO/FIXME + uncommitted):**"); for (const o of ctx.open) L.push(`  - ${o}`); }
   if (ctx.drift && ctx.drift.length) { L.push("- **Current drift / risk:**"); for (const d of ctx.drift) L.push(`  - ${d}`); }
+  if (ctx.connectors) L.push(`- **Connectors:** ${ctx.connectors}`);
   L.push("", "## Tasks");
   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));
@@ -441,9 +531,10 @@ function buildTasksMd(name, ctx, list) {
     `- 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.",
     ONLY_YOU,
+    ...(userStyleLine() ? ["- Writing to the user (questions, options, your last message): " + userStyleLine()] : []),
     "- A `👤 You:` answer holds the next run back until the user's step is done. If their step changes a file, name the file in backticks (`.env`, `~/.termux/termux.properties`): the next run starts once it changes.",
     "- If a step needs a release that isn't out yet, name its version in the question (\"Once 0.41.0 is installed: …\"). Symbiot shows it next to the installed and npm versions, and holds back an answer that starts \"Done\" until that release is out and installed.",
-    `- Ideas, options or follow-ups outside these tasks go under \`## Suggestions\` as \`- \` bullets. The user can add them to their tasks in one click, and often adds every one, so judge them the same way: only ideas you'd recommend, best first, each saying what it changes and why it's worth doing. Symbiot shows them ${IDEAS_SHOWN} at a time.`,
+    `- Ideas, options or follow-ups outside these tasks go under \`## Suggestions\` as \`- \` bullets. The user can add them to their tasks in one click, and often adds every one, so judge them the same way: only ideas you'd recommend, best first, each saying what it changes and why it's worth doing. Symbiot shows them ${IDEAS_SHOWN} at a time. Ideas the user turned down are in \`.symbiot/SKIPPED.md\`: don't suggest them again.`,
     "- An idea for a different project than this one (Symbiot itself, say, the app that sent you this brief) starts with that project's folder name, `- [repo: symbiot] …`, so it goes to that project's tasks instead of this one's.",
     "- Carry on with everything that doesn't depend on an answer, and don't tick an item that does. Ask there rather than doing anything destructive.", "");
   L.push("---", 'To action these, tell your coding agent: "Read `.symbiot/TASKS.md` and implement the unchecked items in this repo, using the context above. Tick each item as you finish it and leave changes uncommitted for review. Confirm with me before anything destructive."');
@@ -457,7 +548,7 @@ function pushTasks(filter) {
   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 = [];
+  const written = [], unresolved = [], connectors = connectorsLine(); // the same for every repo's run
   for (const name of Object.keys(groups)) {
     const list = uniqueTasks(groups[name].map((t) => t.text)).map((text) => ({ text })), path = name && byName[name]; // near-duplicates once
     if (!path) { unresolved.push({ name: name || "(no repo)", count: list.length }); continue; }
@@ -474,11 +565,11 @@ function pushTasks(filter) {
       if (st.behind) risk.push(`${st.behind} behind upstream on ${st.branch}`);
       if (st.dirty && !st.stale) risk.push(`${st.dirty} uncommitted (${st.mod} mod / ${st.del} del / ${st.add} new)`);
       // held: an agent is still running there, so it lands when that one exits
-      const held = writeTasks(path, buildTasksMd(name, { branch: st.branch, commits, open, drift: risk, stack, lanes: Object.keys(byName) }, list));
+      const held = writeTasks(path, buildTasksMd(name, { branch: st.branch, commits, open, drift: risk, stack, lanes: Object.keys(byName), connectors }, list));
       written.push({ name, file: join(path, ".symbiot", "TASKS.md"), path, count: list.length, held });
     } catch (e) { unresolved.push({ name, count: list.length, error: String((e && e.message) || e) }); }
   }
   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, shipWithBump, pendingReview, commitSubject, shipChanges, autoMergeRepos, setAutoMerge, approveRepo, approveChanges, sendBack, TASK_ORDER, taskType, buildTasksMd, pushTasks };
+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 };