symbiot 0.51.0 → 0.51.2

package/home.mjs

@@ -8,21 +8,48 @@
 // The app's sections (Map, Tasks, Agents, Week…) are shaped by adapt.mjs from
 // how you use them; this is the live data around them. Home's talk goes to the
 // same Symbiot as every chat (mind.mjs converse), told what home shows.
-import { watchBoard } from "./watch.mjs";
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { watchBoard, watchState, isMail } from "./watch.mjs";
 import { pendingReview, pushTasks } from "./tasks.mjs";
-import { agentsList, runHandoff } from "./agents.mjs";
-import { loadTasks } from "./core.mjs";
+import { agentsList, runHandoff, handoffCmd, connectorsInfo, parkedPaths, agentMissing } from "./agents.mjs";
+import { linksState } from "./links.mjs";
+import { knowledgeState } from "./knowledge.mjs";
+import { CONFIG_DIR, loadConfig, loadTasks } from "./core.mjs";
 import { lanesState } from "./lanes.mjs";
 import { converse, actIn, actNow, taskIn } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
 import { resolveProvider } from "./ai.mjs";
 import { reportsNews } from "./reports.mjs";
+import { awaitingState } from "./handback.mjs";
 
 const KEEP = 15000; // the slower reads (git per repo awaiting review) are cached this long
 let cached = null;
+const RUNS = join(CONFIG_DIR, "drafts"); // an ops run's folder (mind.mjs actNow): its own lane, not a repo
+const RUNS_LANE = "ops"; // what the work scene calls them all, together
 
-// { you: [{ kind, id, title, sub, shape }], feeds: [{ id, title, sub, count, shape }],
-//   lanes: [{ from, to, text, status }], working: n, at }
+// A project's name as people say it: the folder can lag behind (CallForge AI is
+// Dailify). The README's title when it's a short name, else package.json's name
+// when it's a word, else the folder's. Read once per folder.
+const NAMES = new Map();
+function displayName(path, folder) {
+  folder = String(folder || ""); if (!path) return folder;
+  if (NAMES.has(path)) return NAMES.get(path);
+  const read = (f) => { try { return readFileSync(join(path, f), "utf8"); } catch { return ""; } };
+  const plainName = (s) => { s = String(s || "").replace(/[*`[\]]|^_+|_+$/g, "").trim(); return s && s.length <= 32 && s.split(/\s+/).length <= 4 && !/[:—–|]|\s-\s/.test(s) ? s : ""; };
+  const h1 = plainName((read("README.md").match(/^#\s+(.+?)\s*#*\s*$/m) || [])[1]);
+  let pkg = ""; try { pkg = String(JSON.parse(read("package.json")).name || "").replace(/^@[^/]+\//, ""); } catch {}
+  const name = h1 || (/^[a-z][a-z0-9-]{1,30}$/i.test(pkg) && pkg.toLowerCase() !== folder.toLowerCase().replace(/\s+/g, "-") ? pkg.charAt(0).toUpperCase() + pkg.slice(1) : "") || folder;
+  NAMES.set(path, name);
+  return name;
+}
+// The lane a folder is: the repo it is (by the scan's map), or an ops run.
+const laneOfPath = (path, map) => Object.keys(map || {}).find((n) => map[n] === path) || (String(path || "").startsWith(RUNS) ? "" : null);
+
+// { you: [{ kind, id, title, sub, shape, … }], feeds: [{ id, title, sub, count, shape }],
+//   lanes: [{ from, to, text, status, times }], working: n, at }
+// An ask carries what its blob on home needs: the lane (repo, or "" for an ops
+// run), its name as people say it, the question and its first two options.
 function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   if (!fresh && !deps.board && cached && now - cached.at < KEEP) return cached;
   const board = deps.board || (() => { try { return watchBoard(24, now); } catch { return { cards: [] }; } });
@@ -32,38 +59,86 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   const reports = deps.reports || (() => { try { return reportsNews(); } catch { return { count: 0 }; } });
   const connected = deps.connected || (() => !!resolveProvider());
   const repos = deps.repos || (() => { try { return repoPathMap(); } catch { return {}; } });
-  const you = [];
+  const waits = deps.waits || (() => { try { return awaitingState().waits; } catch { return []; } });
+  // can a reply be noticed? Email on (mail on this computer), or an inbox watched
+  const seesInbox = deps.seesInbox || (() => { try { return !!(loadConfig().mail || {}).enabled || watchState().watches.some((w) => isMail(w.url)); } catch { return true; } });
+  // the agent the handoff command runs, gone from this computer; Claude connectors linked here but signed out
+  const agentGone = deps.agentGone || (() => { try { return handoffCmd() ? agentMissing() : ""; } catch { return ""; } });
+  const signedOut = deps.signedOut || (() => { try { const c = connectorsInfo(); return c.claude ? (c.links || []).filter((x) => x.connector && !x.ready) : []; } catch { return []; } });
+  const named = deps.name || displayName;
+  const you = [], map = repos() || {};
+  // What Symbiot works through (an AI, your agent, the connectors runs use) shows
+  // only when it's missing, and then first (urgent): nothing works without it.
   // First run: what only a new user can do before the rest means anything.
-  if (!connected()) you.push({ kind: "setup", id: "setup:ai", title: "Connect an AI", sub: "a key, or a free local model", shape: "settings" });
-  if (!Object.keys(repos() || {}).length) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings" });
+  if (!connected()) you.push({ kind: "setup", id: "setup:ai", urgent: true, title: "Connect an AI", sub: "Symbiot can't work without one: a key, or a free local model", shape: "settings", focus: "ai" });
+  const gone = agentGone(); if (gone) you.push({ kind: "setup", id: "setup:agent", urgent: true, title: "Your agent is unavailable", sub: `${gone} isn't on this computer any more, so no task can start`, shape: "settings", focus: "agent" });
+  for (const c of signedOut()) you.push({ kind: "setup", id: "setup:conn:" + c.id, urgent: true, title: `Reconnect ${c.name}`, sub: `its Claude connector is signed out, so agent runs can't use ${c.name}`, shape: "settings", focus: "agent" });
+  if (!Object.keys(map).length) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings", focus: "work" });
   for (const r of pending()) {
     if (!r.path || r.running) continue;
     const n = (r.tasks || []).length, files = (r.files || []).length;
     if (!n && !files) continue;
-    you.push({ kind: "approve", id: "approve:" + r.repo, title: `Approve ${r.repo}`, sub: `${n ? `${n} task${n > 1 ? "s" : ""} done` : "changes without a task"}${files ? ` · ${files} file${files > 1 ? "s" : ""}` : ""} · only you decide`, shape: "tasks" });
+    you.push({ kind: "approve", id: "approve:" + r.repo, repo: r.repo, name: named(r.path, r.repo), title: `Approve ${r.repo}`, sub: `${n ? `${n} task${n > 1 ? "s" : ""} done` : "changes without a task"}${files ? ` · ${files} file${files > 1 ? "s" : ""}` : ""} · only you decide`, shape: "tasks" });
   }
   const list = agents(), seen = new Set();
   for (const a of list) {
     if (seen.has(a.path)) continue; seen.add(a.path);
-    const q = a.ask && a.ask.questions && a.ask.questions[0];
-    if (q) you.push({ kind: "ask", id: "ask:" + a.path, title: `${a.name} asks`, sub: String(q.q || "").slice(0, 90), shape: "agents" });
+    const qs = (a.ask && a.ask.questions) || [], q = qs[0];
+    if (!q) continue;
+    const lane = laneOfPath(a.path, map), repo = lane || (lane === "" ? "" : a.name);
+    you.push({ kind: "ask", id: "ask:" + a.path, path: a.path, repo, name: repo ? named(lane ? map[lane] : a.path, repo) : plain(String(a.name || "an agent").replace(/^Agent:\s*/, ""), 60),
+      title: `${a.name} asks`, sub: String(q.q || "").slice(0, 90), q: String(q.q || ""), options: (q.options || []).slice(0, 2), ...(qs.length > 1 ? { more: qs.length - 1 } : {}), shape: "agents" });
   }
+  // A run is waiting on an emailed reply that nothing will see: say so, once,
+  // until an inbox is watched or Email is on (handback.mjs looks in either).
+  if (waits().some((w) => w.status === "waiting") && !seesInbox()) you.push({ kind: "setup", id: "setup:inbox", title: "Let me see your inbox", sub: "so I notice their reply", shape: "settings", focus: "links" });
   const feeds = ((board() || {}).cards || []).filter((c) => c.count > 0).map((c) => ({ id: "feed:" + c.id, title: c.name, sub: c.label, count: c.count, shape: "board" }));
   const rep = reports();
   if (rep.count) feeds.push({ id: "feed:reports", title: "Reports", sub: `${rep.count} unread`, latest: rep.latest, count: rep.count, shape: "reports" });
-  const hs = ((lanes() || {}).handoffs || []).slice(0, 5).map((h) => ({ from: h.from, to: h.to, text: h.text, status: h.status }));
+  const hs = ((lanes() || {}).handoffs || []).slice(0, 5).map((h) => ({ from: h.from, to: h.to, text: h.text, status: h.status, ...(h.times > 1 ? { times: h.times } : {}) }));
   const working = list.filter((a) => a.status === "running").length;
-  const out = { you: you.slice(0, 6), feeds: feeds.slice(0, 6), lanes: hs, working, at: now };
+  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, at: now };
   if (!deps.board) cached = out;
   return out;
 }
 
+// Settings' first steps, in the order they matter (FIRST-RUN-AUDIT.md: a new user
+// found Settings one long page with nothing saying what comes first). Each is
+// done or not from what's set up, so it ticks itself; the company folder is
+// optional. The linked site says whether agent runs can use it too: only through
+// Claude's own connector for it (a link signs in Symbiot's browser, not the run).
+function firstSteps({ deps = {} } = {}) {
+  const tryOr = (f, d) => { try { return f(); } catch { return d; } };
+  const ai = tryOr(deps.connected || (() => !!resolveProvider()), false);
+  const repos = Object.keys(tryOr(deps.repos || repoPathMap, {}) || {}).length;
+  const cmd = String(tryOr(deps.cmd || handoffCmd, "") || "");
+  const site = ((tryOr(deps.links || linksState, {}) || {}).items || []).find((x) => x.state && x.state !== "off");
+  const conns = tryOr(deps.connectors || connectorsInfo, {}) || {};
+  const folders = ((tryOr(deps.knowledge || knowledgeState, {}) || {}).folders || []).length;
+  let runs = "";
+  if (site) {
+    const c = (conns.links || []).find((x) => x.id === site.id);
+    runs = !conns.claude ? "Agent runs can't use it: they get connectors only with Claude Code as your agent."
+      : c && c.ready ? `Agent runs can use it too, through Claude's ${c.connector || c.name} connector.`
+      : c ? `Agent runs can't use it yet: connect ${c.name} in claude.ai → Settings → Connectors (only you can sign in there).`
+      : "Agent runs can't use it: it signs in Symbiot's browser only, and Claude has no connector for it.";
+  }
+  const steps = [
+    { id: "ai", title: "Connect an AI", done: ai, sub: ai ? "connected" : "a key, or a free local model" },
+    { id: "work", title: "Where your work is", done: repos > 0, sub: repos ? `${repos} repo${repos > 1 ? "s" : ""} found` : "the folders your repos are in" },
+    { id: "agent", title: "Your agent", done: !!cmd, sub: cmd ? "Send to repos hands tasks to it" : "the coding agent that takes your tasks" },
+    { id: "site", title: "Link one site", done: !!site, sub: site ? `${site.name} linked. ${runs}` : "your mail, chat or code, so Symbiot sees what arrives" },
+    { id: "company", title: "A company folder", optional: true, done: folders > 0, sub: folders ? "your chats can quote it, and Symbiot checks where its files disagree" : "documents your chats can quote, and Symbiot checks" },
+  ];
+  return { steps, done: steps.every((s) => s.done) };
+}
+
 // One line per thing home shows, for the talk's context.
 function homeContext(h) {
   return [
     `Only the user can do (${h.you.length}):`, ...h.you.map((y) => `- ${y.title}: ${y.sub}`),
     `New on what they watch:`, ...(h.feeds.length ? h.feeds.map((f) => `- ${f.title}: ${f.sub}${f.latest ? ` (latest: ${f.latest})` : ""}`) : ["- nothing new"]),
-    `Agents working: ${h.working}. Recent handovers:`, ...(h.lanes.length ? h.lanes.map((l) => `- ${l.from} → ${l.to}: ${l.text} (${l.status})`) : ["- none"]),
+    `Agents working: ${h.working}. Recent handovers:`, ...(h.lanes.length ? h.lanes.map((l) => `- ${l.from} → ${l.to}: ${l.text} (${l.status}${l.times ? `, handed over ${l.times} times` : ""})`) : ["- none"]),
   ].join("\n");
 }
 
@@ -89,36 +164,51 @@ async function homeAsk(question, { ask, now = Date.now(), state } = {}) {
 // there's anything a Go would start. The details (steps, files, cost) stay one
 // tap away, in the Agents panel.
 const plain = (s, n = 64) => { s = String(s || "").replace(/[\`*_#>]/g, "").replace(/\s+/g, " ").trim(); return s.length > n ? s.slice(0, n - 1).replace(/\s+\S*$/, "") + "…" : s; };
+// Projects (the lanes) are sorted the way you'd look for them: what needs you
+// first (a question, an Approve), then what's at work, ready, waiting, and the
+// most recent. Ops runs (act-…: no repo of their own) are one "Agent runs" lane,
+// not a sphere each with an id for a name.
 function workScene({ deps = {} } = {}) {
   const agents = deps.agents || (() => { try { return agentsList(); } catch { return []; } });
   const pending = deps.pending || (() => { try { return pendingReview(); } catch { return []; } });
   const tasks = deps.tasks || (() => { try { return loadTasks(); } catch { return []; } });
-  const seen = new Set(), running = [];
+  const map = (deps.repos || (() => { try { return repoPathMap(); } catch { return {}; } }))() || {};
+  const named = deps.name || displayName;
+  const parked = new Set((deps.parked || (() => { try { return parkedPaths(); } catch { return []; } }))());
+  const isParked = (repo) => !!map[repo] && parked.has(map[repo]);
+  const laneOf = (a) => { const l = laneOfPath(a.path, map); return l === "" ? RUNS_LANE : l || a.name; };
+  const seen = new Set(), running = [], asks = {};
   for (const a of agents()) {
-    if (a.status !== "running" || seen.has(a.path)) continue; seen.add(a.path);
+    if (seen.has(a.path)) continue; seen.add(a.path);
+    const nq = (a.ask && a.ask.questions && a.ask.questions.length) || 0;
+    if (nq) asks[laneOf(a)] = (asks[laneOf(a)] || 0) + nq;
+    if (a.status !== "running") continue;
     const w = a.work || {}, todo = (w.todos || []).find((t) => t.status === "in_progress"), pg = a.progress;
-    running.push({ id: "run:" + a.path, path: a.path, name: a.name, doing: plain(todo ? todo.active : w.doing || "Working on it", 120), progress: pg || null, waiting: !!(a.ask && a.ask.questions && a.ask.questions.length) });
+    running.push({ id: "run:" + a.path, path: a.path, name: a.name, lane: laneOf(a), doing: plain(todo ? todo.active : w.doing || "Working on it", 120), progress: pg || null, waiting: !!nq, started: a.startedAt || (a.elapsed ? Date.now() - a.elapsed : 0) });
   }
   const ready = pending().filter((r) => r.path && !r.running && ((r.tasks || []).length || (r.files || []).length)).map((r) => ({ id: "ready:" + r.repo, repo: r.repo, count: (r.tasks || []).length }));
-  const busy = new Set(running.map((r) => r.name)), open = tasks().filter((t) => !t.done && !t.archived && !t.review && t.repo);
-  const waiting = open.map((t) => ({ id: "task:" + t.id, text: plain(t.text, 160), repo: t.repo, busy: busy.has(t.repo) })); // the app shortens it for a tag
-  // Projects: each repo with work on it, what's going on there in one line's worth
-  const by = {}, at = (name) => (by[name] = by[name] || { repo: name, waiting: 0, ready: 0, running: null });
-  running.forEach((r) => { at(r.name).running = { doing: r.doing, progress: r.progress, ask: r.waiting }; });
+  const busy = new Set(running.map((r) => r.lane)), open = tasks().filter((t) => !t.done && !t.archived && !t.review && t.repo);
+  const waiting = open.map((t) => ({ id: "task:" + t.id, text: plain(t.text, 160), repo: t.repo, busy: busy.has(t.repo), ...(isParked(t.repo) ? { parked: true } : {}) })); // the app shortens it for a tag
+  // Projects: each lane with work on it, what's going on there in one line's worth
+  const by = {}, at = (name) => (by[name] = by[name] || { repo: name, name: name === RUNS_LANE ? "Agent runs" : named(map[name], name), waiting: 0, ready: 0, asks: 0, running: null, last: 0, ...(name === RUNS_LANE ? { runs: 0 } : {}) });
+  running.forEach((r) => { const p = at(r.lane); if (r.lane === RUNS_LANE) p.runs++; if (!p.running) p.running = { doing: r.doing, progress: r.progress, ask: r.waiting }; p.last = Math.max(p.last, r.started || 0); });
   ready.forEach((r) => { at(r.repo).ready = r.count || 1; });
-  open.forEach((t) => { at(t.repo).waiting++; });
-  const projects = Object.values(by).sort((a, b) => (b.running ? 1 : 0) - (a.running ? 1 : 0) || b.ready - a.ready || b.waiting - a.waiting || (a.repo < b.repo ? -1 : 1));
-  return { running, ready, waiting: waiting.slice(0, 12), waitingCount: waiting.length, canGo: waiting.filter((w) => !w.busy).length, projects: projects.slice(0, 10), projectCount: projects.length };
+  open.forEach((t) => { const p = at(t.repo); p.waiting++; p.last = Math.max(p.last, Number(t.ts) || 0); });
+  Object.keys(asks).forEach((l) => { at(l).asks = asks[l]; });
+  for (const p of Object.values(by)) { p.lit = !!(p.asks || p.ready); if (isParked(p.repo)) p.parked = true; }
+  const projects = Object.values(by).sort((a, b) => (b.lit ? 1 : 0) - (a.lit ? 1 : 0) || (a.parked ? 1 : 0) - (b.parked ? 1 : 0) || (b.running ? 1 : 0) - (a.running ? 1 : 0) || b.ready - a.ready || b.waiting - a.waiting || b.last - a.last || (a.repo < b.repo ? -1 : 1));
+  return { running, ready, waiting: waiting.slice(0, 12), waitingCount: waiting.length, canGo: waiting.filter((w) => !w.busy && !w.parked).length, projects: projects.slice(0, 24), projectCount: projects.length };
 }
 // Go: everything waiting goes to its repo's agent, the way Send to repos and an
 // agent per repo would: briefs written, an agent started in each (or queued
-// behind one already there). { started, queued, repos } or { error }.
+// behind one already there); a parked project's wait for it to be unparked.
+// { started, queued, repos, parked? } or { error }.
 function workGo({ push = pushTasks, run = runHandoff } = {}) {
   const r = push({});
   if (r.empty) return { started: 0, queued: 0, repos: [], note: "Nothing waiting to start." };
-  let started = 0, queued = 0; const repos = [];
-  for (const w of r.written || []) { const e = run(w.path); if (e && e.id && !e.busy && !e.blocked) started++; else queued++; repos.push(w.name); }
-  return { started, queued, repos, ...(r.unresolved && r.unresolved.length ? { unresolved: r.unresolved.map((u) => u.name) } : {}) };
+  let started = 0, queued = 0; const repos = [], parked = [];
+  for (const w of r.written || []) { const e = run(w.path); if (e && e.parked) { parked.push(w.name); continue; } if (e && e.id && !e.busy && !e.blocked) started++; else queued++; repos.push(w.name); }
+  return { started, queued, repos, ...(parked.length ? { parked } : {}), ...(r.unresolved && r.unresolved.length ? { unresolved: r.unresolved.map((u) => u.name) } : {}) };
 }
 
-export { homeState, homeContext, homeAsk, workScene, workGo };
+export { homeState, homeContext, homeAsk, workScene, workGo, displayName, firstSteps };

package/knowledge.mjs

@@ -358,4 +358,4 @@ function knowledgeState({ file = KNOW_FILE, cfg = loadConfig() } = {}) {
   };
 }
 
-export { KNOW_FILE, DEFAULT_EXAMPLES, knowledgeFolders, addKnowledgeFolder, removeKnowledgeFolder, isExample, frontMatter, csvRows, indexKnowledge, knowledgeTick, searchKnowledge, myName, setMyName, namesYou, waitingOn, ownerOf, knowledgeFor, knowledgeState, itemLine, caseLine };
+export { KNOW_FILE, DEFAULT_EXAMPLES, READ, MAX_BYTES, walk, cite, knowledgeFolders, addKnowledgeFolder, removeKnowledgeFolder, isExample, frontMatter, csvRows, indexKnowledge, knowledgeTick, searchKnowledge, myName, setMyName, namesYou, waitingOn, ownerOf, knowledgeFor, knowledgeState, itemLine, caseLine };

package/lanes.mjs

@@ -19,7 +19,7 @@ import { join, basename } from "node:path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, chmodSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { CONFIG_DIR, loadTasks, clipWords } from "./core.mjs";
-import { runHandoff, runningHandoff, waitingFor } from "./agents.mjs";
+import { runHandoff, runningHandoff, waitingFor, agentQuestions } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
 import { actNow } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
@@ -91,6 +91,17 @@ function lastWords(path) {
 // When the newest run in a folder started (its log header), or 0.
 function lastRunStart(path) { const log = readSym(path, "agent.log"), m = [...log.matchAll(/^=== .* (\d{4}-\d\d-\d\dT[\d:.]+Z) ===$/gm)].pop(); return m ? Date.parse(m[1]) || 0 : 0; }
 const openQuestions = (path) => /^###\s+/m.test(readSym(path, "QUESTIONS.md").split(/^##\s+Suggestions/m)[0]);
+// A repo lane's run does a whole brief, so its last words cover every task in it,
+// not just the one handed over (ops heard about a first-run audit and a posting
+// test, three times, in reply to its four gaps). Only the lines about this one
+// go back: those sharing most of its words. "" when it said nothing about it.
+const COMMON = new Set(["with", "that", "this", "from", "have", "will", "your", "them", "then", "what", "when", "into", "about", "there", "their", "which", "would", "could", "should", "while", "please"]);
+const keyWords = (s) => new Set(String(s || "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3 && !COMMON.has(w)).map((w) => w.replace(/s$/, "")));
+function aboutIt(words, text) {
+  const want = keyWords(firstLine(text)); if (want.size < 2) return words;
+  const hits = String(words || "").split(/\n+/).filter((l) => { const has = keyWords(l); let n = 0; for (const w of want) if (has.has(w)) n++; return n >= 2 && n / want.size >= 0.25; });
+  return hits.join("\n").trim();
+}
 
 // Is it done? Ops: its run ended (ticked or not). A repo: the task it was given
 // is ticked or its run ended, and no agent is working there. Waiting on the
@@ -106,8 +117,20 @@ function outcome(e, { tasks = loadTasks(), running = runningHandoff } = {}) {
     return { text: `${ticked ? "Done" : "It stopped without finishing"} (the ops agent).${words ? `\n\nWhat it said:\n${words}` : ""}` };
   }
   const t = tasks.find((x) => x.id === e.task);
-  const done = t && (t.review || t.done || t.archived);
-  return { text: `${done ? `Done in ${e.to.lane}: the task is ticked, and its changes wait for the user's review in Symbiot` : `${e.to.lane}'s agent stopped without ticking it`}.${words ? `\n\nWhat it said:\n${words}` : ""}` };
+  const done = t && (t.review || t.done || t.archived), about = aboutIt(words, e.text);
+  return { text: `${done ? `Done in ${e.to.lane}: the task is ticked, and its changes wait for the user's review in Symbiot` : `${e.to.lane}'s agent stopped without ticking it`}.${about ? `\n\nWhat it said about this:\n${about}` : words ? `\n\nIts last message was about other work in ${e.to.lane}, not this.` : ""}` };
+}
+// A run that stopped partway: questions to the user still open, or work it
+// handed to another lane that hasn't come back (the ledger, or HANDOFF.md not
+// picked up yet). The review card says what it waits on, rather than calling its
+// changes "uncommitted, with no ticked task". null when it waits on nothing.
+function partlyDone(path, { ledger = loadLedger() } = {}) {
+  if (!path) return null;
+  let questions = 0; try { questions = agentQuestions(path, "").questions.length; } catch {}
+  const mine = ledger.handoffs.filter((h) => h.from.path === path);
+  const handed = mine.filter((h) => !h.reportedAt && h.status !== "error").map((h) => ({ lane: h.to.lane, text: clipWords(firstLine(h.text), 90) }));
+  for (const h of parseHandoffs(readSym(path, "HANDOFF.md"))) if (!mine.some((x) => x.to.lane.toLowerCase() === h.lane.toLowerCase() && x.text === h.text)) handed.push({ lane: h.lane, text: clipWords(firstLine(h.text), 90) });
+  return questions || handed.length ? { questions, handed: handed.slice(0, 3) } : null;
 }
 // Tell the agent that asked: the result as an answer in its ANSWERS.md, then
 // start it again to carry on (unless it's still running: it reads it next time).
@@ -141,7 +164,18 @@ function lanesTick({ map = repoPathMap(), act = actNow, run = runHandoff, runnin
   return { started, reported };
 }
 // The Agents tab's list: newest first. Each shows its first line; full, all of a
-// longer one, and result, all of what came back, open under it.
-function lanesState() { return { handoffs: loadLedger().handoffs.slice(-30).reverse().map((e) => ({ id: e.id, from: e.from.lane, to: e.to.lane, text: clipWords(firstLine(e.text), 160), ...(e.text.trim() !== firstLine(e.text).trim() || e.text.length > 160 ? { full: e.text } : {}), at: e.at, status: e.status, ...(e.error ? { error: e.error } : {}), ...(e.result ? { result: e.result } : {}) })) }; }
+// longer one, and result, all of what came back, open under it. What reads the
+// same (one lane to the same lane, the same first line: a run that handed it
+// over twice) is one row, the newest, with how many times (times).
+function lanesState() {
+  const out = [], byKey = new Map();
+  for (const e of loadLedger().handoffs.slice().reverse()) {
+    const k = [e.from.lane, e.to.lane, firstLine(e.text).replace(/\s+/g, " ").trim()].join("\n").toLowerCase();
+    if (byKey.has(k)) { byKey.get(k).times++; continue; }
+    const row = { id: e.id, from: e.from.lane, to: e.to.lane, text: clipWords(firstLine(e.text), 160), ...(e.text.trim() !== firstLine(e.text).trim() || e.text.length > 160 ? { full: e.text } : {}), at: e.at, status: e.status, ...(e.error ? { error: e.error } : {}), ...(e.result ? { result: e.result } : {}), times: 1 };
+    byKey.set(k, row); out.push(row);
+  }
+  return { handoffs: out.slice(0, 30) };
+}
 
-export { LEDGER, MAX_CHAIN, loadLedger, laneOf, lastRunStart, dispatch, outcome, report, lanesTick, lanesState };
+export { LEDGER, MAX_CHAIN, loadLedger, laneOf, lastRunStart, dispatch, outcome, report, lanesTick, lanesState, aboutIt, partlyDone };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "symbiot",
-  "version": "0.51.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.",
+  "version": "0.51.2",
+  "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice \u2014 Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
     "symbiot": "index.mjs"
@@ -33,6 +33,7 @@
     "desktop.mjs",
     "handback.mjs",
     "knowledge.mjs",
+    "checks.mjs",
     "post.mjs",
     "reports.mjs",
     "sandbox.mjs",
@@ -73,7 +74,7 @@
     "@anthropic-ai/sdk": "^0.128.0"
   },
   "scripts": {
-    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/lanes.mjs && node test/handback.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
+    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/checks.mjs &&node test/lanes.mjs && node test/handback.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
     "lint": "eslint ."
   },
   "devDependencies": {

package/post.mjs

@@ -22,7 +22,7 @@ import { join, dirname } from "node:path";
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, chmodSync, existsSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { CONFIG_DIR, sh, hasCmd } from "./core.mjs";
+import { CONFIG_DIR, sh, hasCmd, loadConfig } from "./core.mjs";
 import { resolveProvider, write } from "./ai.mjs";
 import { commits, discoveredRepos } from "./scan.mjs";
 import { readTexts } from "./headless.mjs";
@@ -41,7 +41,10 @@ const noVoice = (file) => `Symbiot drafts posts in your voice, from examples of
 
 // ---- your voice ------------------------------------------------------------------
 // voice.md's examples: what's between lines of ---, each long enough to be a post.
-function voiceOf(text) { return String(text || "").split(/^\s*-{3,}\s*$/m).map((s) => s.trim()).filter((s) => s.length >= 20); }
+// LinkedIn's page text puts a "hashtag" line (a label for screen readers) over each
+// #tag; read into voice.md, the drafts copied it under every tag. Dropped wherever seen.
+const noTagLabels = (t) => String(t || "").replace(/^[ \t]*hashtag[ \t]*\r?\n(?=[ \t]*#)/gim, "");
+function voiceOf(text) { return noTagLabels(text).split(/^\s*-{3,}\s*$/m).map((s) => s.trim()).filter((s) => s.length >= 20); }
 function loadVoice(file = PATHS.voice) { try { return voiceOf(readFileSync(file, "utf8")); } catch { return []; } }
 function saveText(file, text) { mkdirSync(dirname(file), { recursive: true }); writeFileSync(file, text, { mode: 0o600 }); try { chmodSync(file, 0o600); } catch {} }
 
@@ -50,7 +53,7 @@ function saveText(file, text) { mkdirSync(dirname(file), { recursive: true }); w
 // runs by itself. `read` is headless.mjs readTexts (the tests pass their own).
 const LINKEDIN_ACTIVITY = "https://www.linkedin.com/in/me/recent-activity/shares/";
 const LINKEDIN_POST_TEXT = ".update-components-text, .feed-shared-update-v2__description, .feed-shared-text";
-const tidyPost = (t) => String(t || "").replace(/\s*…\s*(see )?more\s*$/i, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+const tidyPost = (t) => noTagLabels(t).replace(/\s*…\s*(see )?more\s*$/i, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
 async function voiceFromLinkedIn({ read = readTexts, paths = PATHS, max = 10 } = {}) {
   const r = (await read(LINKEDIN_ACTIVITY, LINKEDIN_POST_TEXT)) || { error: "Nothing came back from LinkedIn." };
   if (r.busy) return { error: "Symbiot's browser is busy (a sign-in window, or a map). Close it, then try again." };
@@ -173,7 +176,7 @@ function extractJson(s) {
 // The AI's answer as drafts, by kind: [{ kind, text, facts: [n] }].
 function parseDrafts(raw) {
   const j = extractJson(raw), list = j && Array.isArray(j.posts) ? j.posts : [];
-  return list.map((p, i) => ({ kind: KINDS.includes(p && p.kind) ? p.kind : KINDS[i] || "", text: String((p && p.text) || "").trim().slice(0, MAX_TEXT), facts: (Array.isArray(p && p.facts) ? p.facts : []).map(Number).filter(Number.isInteger) }))
+  return list.map((p, i) => ({ kind: KINDS.includes(p && p.kind) ? p.kind : KINDS[i] || "", text: noTagLabels((p && p.text) || "").trim().slice(0, MAX_TEXT), facts: (Array.isArray(p && p.facts) ? p.facts : []).map(Number).filter(Number.isInteger) }))
     .filter((p) => p.kind && p.text);
 }
 // A draft checked against the facts: the facts it cites that exist, and what it
@@ -244,11 +247,13 @@ function logAction(action, p, now = Date.now(), paths = PATHS, extra = {}) {
 }
 function postLog(paths = PATHS) { try { return readFileSync(paths.log, "utf8").split("\n").filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return []; } }
 // What the Dashboard shows: the drafts waiting on you, the last few you dealt with,
-// and whether it can draft (an AI connected, voice examples).
-function postsState(paths = PATHS) {
-  const d = loadPosts(paths);
+// and whether it can draft: an AI connected, and your voice (examples in voice.md,
+// or LinkedIn linked to fill it from). Until then the Dashboard says so in a line.
+function postsState(paths = PATHS, { linked = () => (loadConfig().linked || {}) } = {}) {
+  const d = loadPosts(paths), voice = loadVoice(paths.voice).length, connected = !!resolveProvider();
+  let linkedin = false; try { linkedin = !!linked().linkedin; } catch {}
   return { posts: d.posts.filter((p) => p.status === "waiting"), done: d.posts.filter((p) => p.status === "approved" || p.status === "skipped").slice(0, 5),
-    voice: { count: loadVoice(paths.voice).length, file: paths.voice }, connected: !!resolveProvider(), share: SHARE_URL, labels: KIND_LABEL };
+    voice: { count: voice, file: paths.voice }, connected, linkedin, canDraft: connected && (linkedin || voice > 0), share: SHARE_URL, labels: KIND_LABEL };
 }
 // One waiting draft, by id (or the start of one), and the store it's in.
 function waiting(id, paths) {

package/server.mjs

@@ -12,7 +12,7 @@ import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
 import { EMBEDDED_UI } from "./ui.mjs";
 import { VERSION, LATEST_VERSION, REGISTRY, semverGt, checkLatest, CONFIG_PATH, loadConfig, saveConfig, loadTasks, hasCmd, chromeBinary } from "./core.mjs";
-import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, answerQuestions, skipIdea, agentsList, startWaiting } from "./agents.mjs";
+import { shSingle, handoffCmd, setHandoffCmd, grantAgent, runHandoff, track, detectHandoffs, connectorsInfo, answerQuestions, skipIdea, agentsList, startWaiting, parkLane, parkedPaths } 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";
@@ -25,13 +25,14 @@ import { watchState, addWatch, setEvery, removeWatch, clearNews, seenWatch, chec
 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 { lanesTick, lanesState, partlyDone } 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 { homeState, homeAsk, workScene, workGo, firstSteps } 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";
+import { runChecks, checksState } from "./checks.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
@@ -218,9 +219,11 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       if (u.pathname === "/api/pending") { // ticked by the agent, awaiting approval
         // what npm has decides the bump offer, and for a repo that publishes on
         // merge, what's unreleased: ask, then recount (answers are cached)
+        // partly: what a run that stopped partway still waits on (its questions, a handover)
+        const partly = (l) => l.map((r) => { const p = r.path ? partlyDone(r.path) : null; return p ? { ...r, partly: p } : r; });
         const list = pendingReview(), ask = list.filter((r) => r.path && (!r.bumpOffer || r.publishesOnMerge)).map((r) => r.path);
-        if (!ask.length) return json(res, list);
-        await learnNpm(ask); return json(res, pendingReview());
+        if (!ask.length) return json(res, partly(list));
+        await learnNpm(ask); return json(res, partly(pendingReview()));
       }
       if (u.pathname === "/api/pending/diff") { const p = repoPathMap()[u.searchParams.get("repo") || ""]; return json(res, { diff: p ? workingDiff(p) : "" }); }
       if (u.pathname === "/api/pending/approve" && req.method === "POST") { const b = await readBody(req), repo = String(b.repo || ""); if (b.bump) await learnNpm([repoPathMap()[repo]]); const notes = await releaseNotes(releaseInput(repo, { bump: b.bump })); return json(res, approveRepo(repo, { bump: b.bump, notes })); }
@@ -234,8 +237,11 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       // 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/remove" && req.method === "POST") { const b = await readBody(req), r = removeKnowledgeFolder(String(b.path || "")); if (r.error) return json(res, r); indexKnowledge(); try { runChecks(); } catch {} return json(res, { ok: true, ...knowledgeState() }); }
       if (u.pathname === "/api/knowledge/index" && req.method === "POST") { const r = indexKnowledge(); return json(res, { ...r, ...knowledgeState() }); }
+      // where two of the folders' files disagree (checks.mjs): the last result, or checked again now
+      if (u.pathname === "/api/knowledge/checks") return json(res, checksState());
+      if (u.pathname === "/api/knowledge/checks/run" && req.method === "POST") return json(res, runChecks());
       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)); }
@@ -318,11 +324,15 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
       // the work scene: what agents are doing, what's waiting, what's ready; Go starts what's waiting
       if (u.pathname === "/api/work") return json(res, workScene());
       if (u.pathname === "/api/work/go" && req.method === "POST") return json(res, workGo());
+      if (u.pathname === "/api/firststeps") return json(res, firstSteps()); // Settings' first steps: what's set up, in order
       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());
+      // a parked project (lane) starts no agent runs until it's unparked (agents.mjs parkLane)
+      if (u.pathname === "/api/lanes/parked") { const map = repoPathMap(), ps = parkedPaths(); return json(res, { repos: Object.keys(map).filter((n) => ps.includes(map[n])), paths: ps }); }
+      if (u.pathname === "/api/lanes/park" && req.method === "POST") { const b = await readBody(req), map = repoPathMap(), p = Object.values(map).includes(String(b.path || "")) ? String(b.path) : map[String(b.repo || "")]; if (!p) return json(res, { error: "That project isn't on this computer." }); return json(res, parkLane(p, b.on !== false)); }
       // Watch (watch.mjs): a mapped page read again every few minutes, and what's new on it.
       if (u.pathname === "/api/watch") return json(res, watchState());
       if (u.pathname === "/api/watch/board") return json(res, watchBoard(Math.min(168, Math.max(1, Number(u.searchParams.get("hours")) || 24))));
@@ -414,7 +424,9 @@ 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)
+  // knowledge folders: changed files re-read (a stat per file when nothing changed), then checked again for where two files disagree (checks.mjs)
+  const knowTick = () => { try { const r = knowledgeTick(); if (r && (r.read || r.removed || !checksState().at)) runChecks(); } catch {} };
+  setTimeout(knowTick, 5000).unref(); setInterval(knowTick, 3 * 60 * 1000).unref();
   setInterval(() => { try { awaitTick(); } catch {} }, 60000).unref(); // a reply an agent's email waits on: found, and handed on
 }
 

package/tasks.mjs

@@ -574,7 +574,17 @@ function buildTasksMd(name, ctx, list) {
 function pushTasks(filter) {
   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);
+  const all = loadTasks(); let changed = applyRemovals(all) + applyDrops(all, byName);
+  // what an agent ticked since the Tasks tab last looked goes to review first, as
+  // syncTasks would: a new brief over TASKS.md would wipe its ticks, and finished
+  // work went out again as new tasks (7 of symbiot's, 2026-10-07)
+  const ticked = {};
+  for (const t of all) {
+    if (t.done || t.archived || t.review || !t.repo || !byName[t.repo]) continue;
+    if (!(t.repo in ticked)) ticked[t.repo] = completedInRepo(byName[t.repo]);
+    if (ticked[t.repo].some((c) => sameTask(c, t.text))) { t.review = true; t.reviewAt = Date.now(); changed++; }
+  }
+  if (changed) 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);