symbiot 0.54.2 → 0.54.4

package/home.mjs

@@ -4,24 +4,28 @@
 //   folders), always out front;
 // - feeds: what's new on the sites you watch (watch.mjs), sized by how much;
 // - lanes: work handed between agents (lanes.mjs), the latest few.
-// Reports agents wrote up that you haven't read (reports.mjs) are a feed too.
+// Reports agents wrote up that you haven't read (reports.mjs) are a feed too, and
+// so is a clash in your company folder that matters (checks.mjs newClashes).
 // 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 { join } from "node:path";
-import { readFileSync } from "node:fs";
-import { watchBoard, watchState, isMail } from "./watch.mjs";
+import { homedir } from "node:os";
+import { readFileSync, writeFileSync } from "node:fs";
+import { watchBoard } from "./watch.mjs";
 import { pendingReview, pushTasks } from "./tasks.mjs";
-import { agentsList, runHandoff, handoffCmd, connectorsInfo, parkedPaths, agentMissing } from "./agents.mjs";
+import { agentsList, runHandoff, runningHandoff, handoffCmd, connectorsInfo, parkedPaths, agentMissing, settleNeeds, pickAgent } from "./agents.mjs";
 import { linksState } from "./links.mjs";
 import { knowledgeState } from "./knowledge.mjs";
-import { CONFIG_DIR, loadConfig, loadTasks } from "./core.mjs";
-import { lanesState } from "./lanes.mjs";
+import { CONFIG_DIR, loadTasks } from "./core.mjs";
+import { lanesState, stuckHandovers, allowHandover, skipHandover } from "./lanes.mjs";
 import { converse, actIn, actNow, taskIn } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
 import { resolveProvider } from "./ai.mjs";
 import { reportsNews } from "./reports.mjs";
-import { awaitingState } from "./handback.mjs";
+import { awaitingState, inboxSight } from "./handback.mjs";
+import { newClashes } from "./checks.mjs";
+import { postsState } from "./post.mjs";
 
 const KEEP = 15000; // the slower reads (git per repo awaiting review) are cached this long
 let cached = null;
@@ -46,6 +50,41 @@ function displayName(path, folder) {
 // 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);
 
+// A run that failed shows for a day, until you run it again or skip it; one
+// that's been followed by another run in its folder is past.
+const FAILED_FOR = 86400000, dropped = new Set();
+const firstLine = (t) => String(t || "").split("\n").find((l) => l.trim()) || "";
+// What stopped and can't go on without you, as questions: a handover that couldn't
+// start (lanes.mjs stuckHandovers: "Allow this run access to ~/Company?"), a run
+// that ended waiting on you (agents.mjs needsOf: a draft for your OK, a sudo step,
+// a step your answer left you) with what to check first, and a run that ended in an
+// error. Each is answered on its blob (homeAnswer), on Home and on its lane in
+// Tasks. repo: its lane ("" for an ops run).
+function troubles({ stuck = [], list = [], map = {}, named = displayName, now = Date.now() } = {}) {
+  const out = [], seen = new Set();
+  for (const t of stuck) {
+    const lane = t.from.lane === RUNS_LANE ? "" : t.from.lane;
+    out.push({ kind: "ask", fix: "handover", id: "stuck:" + t.id, path: lane ? map[lane] || t.from.path : t.from.path, repo: lane, name: lane ? named(map[lane], lane) : "Agent runs",
+      title: `${lane || "An agent run"} is stuck`, sub: plain(firstLine(t.text), 90), q: t.q, options: t.options, why: plain(t.error, 160), shape: "agents" });
+  }
+  for (const a of list) {
+    if (seen.has(a.path)) continue; seen.add(a.path); // the newest run in each folder (agentsList: newest first)
+    if (a.status === "running" || (a.ask && a.ask.questions && a.ask.questions.length)) continue; // at work, or it asked: that's its question
+    const lane = laneOfPath(a.path, map), repo = lane || "", nm = repo ? named(map[lane], repo) : plain(String(a.name || "an agent").replace(/^Agent:\s*/, "").replace(/^\W*What['’]s needed:\W*/i, "").replace(/^./, (c) => c.toUpperCase()), 60);
+    const n = a.needs;
+    if (n && !dropped.has("needs:" + a.id)) {
+      const ok = n.kind === "approve";
+      out.push({ kind: "ask", fix: "needs", id: "needs:" + a.id, path: a.path, repo, name: nm, title: ok ? `${nm} waits for your OK` : `${nm} needs you`, sub: plain(n.label || n.what, 90),
+        q: n.what + (n.check ? ` Check first: ${n.check}` : ""), options: ok ? ["Go ahead (recommended)", "Skip"] : ["Done it (recommended)", "Skip"], shape: "agents" });
+      continue;
+    }
+    if (a.status !== "failed" || dropped.has(a.id) || (a.endedAt && now - a.endedAt > FAILED_FOR)) continue;
+    const said = plain(String(a.tail || "").split(/\n+/).filter((l) => l.trim()).pop() || "", 140);
+    out.push({ kind: "ask", fix: "failed", id: "failed:" + a.id, path: a.path, repo, name: nm, title: `${nm}'s run stopped`, sub: said || `it exited with code ${a.exitCode}`,
+      q: `Its run stopped with an error${said ? `: ${said}` : ` (exit code ${a.exitCode})`}. Run it again?`, options: ["Run it again (recommended)", "Skip"], shape: "agents" });
+  }
+  return out;
+}
 // { 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
@@ -60,11 +99,17 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   const connected = deps.connected || (() => !!resolveProvider());
   const repos = deps.repos || (() => { try { return repoPathMap(); } catch { return {}; } });
   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; } });
+  const clashes = deps.clashes || (() => { try { return newClashes(); } catch { return []; } });
+  // can a reply be noticed? Email on (mail on this computer), or an inbox watched and signed in
+  const seesInbox = deps.seesInbox || (() => { try { return inboxSight(); } 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 stuck = deps.stuck || (() => { try { return stuckHandovers({ now }); } catch { return []; } });
+  const agentCmd = deps.agentCmd || (() => { try { return handoffCmd(); } catch { return "x"; } });
+  const offer = deps.pickAgent || (() => { try { return pickAgent(); } catch { return null; } });
+  // Marketing (its own section, off the Dashboard) once posts can be drafted, or there are some
+  const marketing = deps.marketing || (() => { try { const p = postsState(); return !!(p.canDraft || p.posts.length || p.done.length); } catch { return false; } });
   const named = deps.name || displayName;
   const you = [], map = repos() || {};
   // What Symbiot works through (an AI, your agent, the connectors runs use) shows
@@ -74,6 +119,9 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   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" });
+  // no agent yet: Send to repos and Go would only write TASKS.md files nothing runs, so
+  // Home didn't say "All handled" truthfully. One click for the one on this computer.
+  if (!agentCmd()) { const p = offer(); you.push({ kind: "setup", id: "setup:pick", title: "Pick your agent", sub: p ? `${p.name} is on this computer: one click and it takes your tasks` : "the coding agent that takes your tasks", shape: "settings", focus: "agent", ...(p ? { pick: { name: p.name, tmpl: p.tmpl } } : {}) }); }
   for (const r of pending()) {
     if (!r.path || r.running) continue;
     const n = (r.tasks || []).length, files = (r.files || []).length;
@@ -89,19 +137,75 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
     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" });
   }
+  // What stopped and can't go on without you, as a question too: a handover that
+  // couldn't start (lanes.mjs stuckHandovers: "Allow this run access to ~/Company?"),
+  // and a run that ended in an error. Answered on its blob (homeAnswer).
+  you.push(...troubles({ stuck: stuck(), list, map, named, now }));
   // 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" });
+  // until an inbox is watched (and signed in) or Email is on (handback.mjs looks in either).
+  if (waits().some((w) => w.status === "waiting")) {
+    const s = seesInbox(), sight = s && typeof s === "object" ? s : { sees: !!s, signedOut: [] };
+    if (!sight.sees) you.push(sight.signedOut.length
+      ? { kind: "setup", id: "setup:inbox", signin: true, title: `Sign in to ${sight.signedOut[0]} again`, sub: "it's signed out, so I won't notice their reply", shape: "settings", focus: "links" }
+      : { kind: "setup", id: "setup:inbox", title: "Let me see your inbox", sub: "so I notice their reply", shape: "settings", focus: "links" });
+  }
   const feeds = ((board() || {}).cards || []).filter((c) => c.count > 0).map((c) => ({ id: "feed:" + c.id, title: c.name, sub: c.label, count: c.count, shape: "board" }));
+  // a clash in your files that matters (checks.mjs: high), first under Watching, until you've opened it
+  const clash = clashes();
+  if (clash.length) feeds.unshift({ id: "feed:clash", title: "Where your files disagree", sub: `${clash.length} clash${clash.length > 1 ? "es" : ""} to look at`, latest: plain(clash[0].text, 140), count: clash.length, shape: "settings" });
   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, ...(h.times > 1 ? { times: h.times } : {}) }));
   const working = list.filter((a) => a.status === "running").length;
-  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, at: now };
+  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, marketing: marketing(), at: now };
   if (!deps.board) cached = out;
   return out;
 }
 
+// An answer on a stuck handover's, a waiting run's or a failed run's blob. pick: the
+// option's place (0 goes ahead, 1 skips); text: your own words, which go ahead with
+// them unless they say no. The handover's run (lanes.mjs allowHandover) reports back
+// to the agent that asked; a run waiting on your OK or your step starts again with
+// "go ahead" or "done" in its ANSWERS.md (skipped, it doesn't ask again); a failed
+// run starts again in its folder, with your words in its ANSWERS.md. { ok, said } or { error }.
+const SAYS_NO = /^\s*(skip|no|nope|don'?t|do not|cancel|leave it|never ?mind|stop)\b/i;
+// An answer, in the folder's ANSWERS.md, for the run that picks it up.
+function noteAnswer(path, heading, text) {
+  const f = join(path, ".symbiot", "ANSWERS.md"); let had = ""; try { had = readFileSync(f, "utf8"); } catch {}
+  try { writeFileSync(f, `${(had || "# Answers\n").replace(/\s*$/, "")}\n\n### ${String(heading).replace(/\s+/g, " ").trim()}\n${text}\n_answered ${new Date().toISOString().slice(0, 10)}_\n`); } catch {}
+}
+function homeAnswer(id, { pick, text = "" } = {}, deps = {}) {
+  id = String(id || ""); text = String(text || "").trim().slice(0, 2000);
+  const go = text ? !SAYS_NO.test(text) : Number(pick) === 0, ref = id.replace(/^\w+:/, "");
+  cached = null;
+  if (id.startsWith("stuck:")) {
+    if (!go) { const r = (deps.skip || skipHandover)(ref); return r.error ? r : { ok: true, said: "Skipped. Its agent knows." }; }
+    const r = (deps.allow || allowHandover)(ref, { note: text }); if (r.error) return r;
+    return { ok: true, said: `Started a run on it${r.dirs && r.dirs.length ? `, allowed into ${r.dirs.map((d) => (d.startsWith(homedir() + "/") ? "~" + d.slice(homedir().length) : d)).join(" and ")}` : ""}. What it does goes back to the agent that asked.` };
+  }
+  if (id.startsWith("failed:")) {
+    const a = (deps.agents || agentsList)().find((x) => x.id === ref); if (!a) return { error: "That run isn't here any more." };
+    if (!go) { dropped.add(ref); return { ok: true, said: "Skipped." }; }
+    if ((deps.running || runningHandoff)(a.path)) return { ok: true, said: "An agent is already at work there." };
+    if (text) noteAnswer(a.path, "Your last run stopped with an error", text);
+    const e = (deps.run || runHandoff)(a.path, { force: true }); dropped.add(ref);
+    return e && e.id && !e.blocked ? { ok: true, said: "Running it again.", rerun: e.id } : { error: (e && e.note) || "It didn't start. Check your agent in Settings." };
+  }
+  if (id.startsWith("needs:")) {
+    const a = (deps.agents || agentsList)().find((x) => x.id === ref), n = a && a.needs;
+    if (!n) return { error: "That isn't waiting on you any more." };
+    const settle = deps.settle || settleNeeds;
+    if (!go) { settle(a.path, n.key); dropped.add(id); return { ok: true, said: "Skipped. It won't ask again." }; }
+    if ((deps.running || runningHandoff)(a.path)) return { ok: true, said: "An agent is already at work there." };
+    const said = n.kind === "approve" ? `Go ahead: ${text || "do it as you had it, once you've checked what you flagged"}.` : `Done: the user did it${text ? ` (${text})` : ""}. Check it worked, then carry on.`;
+    noteAnswer(a.path, n.what, said);
+    const e = (deps.run || runHandoff)(a.path, { force: true });
+    if (e && e.id && !e.blocked) { settle(a.path, n.key); dropped.add(id); }
+    return e && e.id && !e.blocked ? { ok: true, said: n.kind === "approve" ? "Its agent is going ahead." : "Its agent is checking and carrying on.", rerun: e.id } : { error: (e && e.note) || "It didn't start. Check your agent in Settings." };
+  }
+  return { error: "Answer that one on its block in Agents." };
+}
+
 // 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
@@ -136,7 +240,7 @@ function firstSteps({ deps = {} } = {}) {
 // 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}`),
+    `Only the user can do (${h.you.length}):`, ...h.you.map((y) => `- ${y.title}: ${y.sub}${y.q && y.q !== y.sub ? ` (asks: ${y.q}${(y.options || []).length ? ` ${y.options.join(" / ")}` : ""})` : ""}`),
     `New on what they watch:`, ...(h.feeds.length ? h.feeds.map((f) => `- ${f.title}: ${f.sub}${f.latest ? ` (latest: ${f.latest})` : ""}`) : ["- nothing new"]),
     `Agents working: ${h.working}. Recent handovers:`, ...(h.lanes.length ? h.lanes.map((l) => `- ${l.from} → ${l.to}: ${l.text} (${l.status}${l.times ? `, handed over ${l.times} times` : ""})`) : ["- none"]),
   ].join("\n");
@@ -218,6 +322,11 @@ function workScene({ deps = {} } = {}) {
     for (const q of qs) { p.qs = p.qs || []; if (p.qs.length < 3) p.qs.push({ q: q.q, options: (q.options || []).slice(0, 3), path: a.path }); }
     for (const s of ideas) { p.ideas = p.ideas || []; if (p.ideas.length < 4) p.ideas.push({ text: plain(s.text, 200), full: String(s.text), repo: s.repo || l, path: a.path }); }
   }
+  const stuck = deps.stuck || (() => { try { return stuckHandovers(); } catch { return []; } });
+  for (const t of troubles({ stuck: stuck(), list: AG, map, named })) {
+    const p = at(t.repo || RUNS_LANE); p.asks++; p.qs = p.qs || [];
+    if (p.qs.length < 3) p.qs.unshift({ q: t.q, options: t.options, path: t.path, fix: t.fix, id: t.id, sub: t.sub });
+  }
   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 };
@@ -234,4 +343,4 @@ function workGo({ push = pushTasks, run = runHandoff } = {}) {
   return { started, queued, repos, ...(parked.length ? { parked } : {}), ...(r.unresolved && r.unresolved.length ? { unresolved: r.unresolved.map((u) => u.name) } : {}) };
 }
 
-export { homeState, homeContext, homeAsk, workScene, workGo, displayName, firstSteps };
+export { homeState, homeContext, homeAsk, homeAnswer, workScene, workGo, displayName, firstSteps };

package/index.mjs

@@ -25,8 +25,8 @@
 
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { realpathSync } from "node:fs";
+import { join, basename } from "node:path";
+import { realpathSync, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { EMBEDDED_UI } from "./ui.mjs";
@@ -41,7 +41,7 @@ import { loadScreens, screenImage, blueprint } from "./screens.mjs";
 import { mapPage, wholePage, pressRegion, typeRegion, scrollPage, signIn, isTrusted } from "./headless.mjs";
 import { watchState, addWatch, removeWatch, seenWatch, newsSince, markNews, checkWatch, setBrief, draftReply, watchBoard, boardLine, boardChat, boardTalk, clearBoardChat } from "./watch.mjs";
 import { PORT as PHONE_PORT, phoneState, pairComputer, pollComputer, forgetComputer } from "./phone.mjs";
-import { KIND_LABEL as POST_KIND, PATHS as POST_PATHS, draftPosts, postsState, postLog, approvePost, editPost, skipPost, voiceFromLinkedIn, openUrl } from "./post.mjs";
+import { KIND_LABEL as POST_KIND, PATHS as POST_PATHS, draftPosts, postsState, postLog, approvePost, editPost, skipPost, voiceFromLinkedIn, openUrl, addMedia as addPostMedia, removeMedia as removePostMedia, mediaDir as postMediaDir, pictureOfPage, clipOfPage } from "./post.mjs";
 import { startApp, updateCmd, isAppRunningWeekly } from "./server.mjs";
 import { listReports, readReport } from "./reports.mjs";
 import { runSandbox } from "./sandbox.mjs";
@@ -621,18 +621,22 @@ async function cmdPhone() {
 // Nothing is ever posted by Symbiot: approve copies one post to your clipboard and
 // gives LinkedIn's share box, where you paste it and post it yourself.
 async function cmdPost() {
-  const [sub = "draft", a1, a2] = argv.slice(1).filter((x, i, all) => !x.startsWith("--") && all[i - 1] !== "--since");
+  const [sub = "draft", a1, a2] = argv.slice(1).filter((x, i, all) => !x.startsWith("--") && all[i - 1] !== "--since" && all[i - 1] !== "--seconds");
   const fail = (msg) => { console.log(c.y(msg)); process.exitCode = 1; };
   const show = (p) => {
     console.log(`\n${c.b(POST_KIND[p.kind] || p.kind)}  ${c.d(`${p.id} · ${p.status}${p.edited ? " · edited" : ""}`)}\n${p.text}`);
     if (p.sources && p.sources.length) console.log(c.d("  from git: " + p.sources.slice(0, 4).map((s) => s.replace(/^\[\d+\]\s*/, "")).join("\n            ") + (p.sources.length > 4 ? `\n            …and ${p.sources.length - 4} more` : "")));
+    for (const m of p.media || []) console.log(c.d(`  ${m.kind} ${m.id}: `) + join(postMediaDir(p.id), m.file) + c.d(m.url ? `  (${m.from === "clip" ? "clip" : "picture"} of ${m.url})` : ""));
+    if (p.show && !(p.media || []).length) console.log(c.d("  picture idea: " + p.show));
   };
   if (sub === "draft" || sub === "new") {
     const r = await draftPosts({ days: SINCE_WEEK || 7 });
     if (r.error) return fail(r.error);
     for (const p of r.posts) show(p);
+    if (r.retried) console.log("\n" + c.d("The first try kept none (each claimed what git doesn't show), so Symbiot tried again by itself."));
+    if (r.pictures) console.log(c.d(`${r.pictures === 1 ? "One draft names" : `${r.pictures} drafts name`} a screen of an app you run here, so ${r.pictures === 1 ? "it has its picture" : "they have their pictures"} already: keep or remove (symbiot post remove <id> <media id>).`));
     if (r.dropped.length) console.log("\n" + c.y(`Dropped ${r.dropped.length}: `) + r.dropped.map((x) => `${POST_KIND[x.kind] || x.kind} (${x.cited ? "claimed " + x.unsupported.join(", ") + ", which git doesn't show" : "cited nothing from git"})`).join("; "));
-    console.log("\n" + c.d(`${r.posts.length} draft${r.posts.length === 1 ? "" : "s"} from ${r.facts} things git shows this week, in the voice of your ${r.voice} example${r.voice === 1 ? "" : "s"}. They wait on the app's Dashboard too.`));
+    console.log("\n" + c.d(`${r.posts.length} draft${r.posts.length === 1 ? "" : "s"} from ${r.facts} things git shows this week, in the voice of your ${r.voice} example${r.voice === 1 ? "" : "s"}. They wait under Marketing in the app too.`));
     console.log(c.d("Nothing is posted until you approve one:  symbiot post approve <id>  (or edit / skip)."));
     return;
   }
@@ -648,10 +652,33 @@ async function cmdPost() {
     console.log(`${c.g("✓")} Approved.\n\n${r.post.text}\n`);
     console.log(r.copied ? `${c.g("✓")} Copied to your clipboard (${r.copied}).` : c.y("No clipboard tool found (wl-copy, xclip, xsel, pbcopy or clip): copy it from above."));
     console.log(`Paste it into LinkedIn's share box: ${c.b(r.share)}` + (has("open") ? "" : c.d("  (--open opens it)")));
-    if (has("open")) openUrl(r.share);
+    if (r.files.length) console.log(`Then add ${r.files.length === 1 ? "this" : "these"} with its photo or video button:\n${r.files.map((f) => "  " + f).join("\n")}` + (has("open") ? "" : c.d("  (--open opens their folder)")));
+    if (has("open")) { openUrl(r.share); if (r.folder) openUrl(r.folder); }
     console.log(c.d(r.note));
     return;
   }
+  // pictures and video on a draft: a file of yours, or a picture or clip of a page
+  if (sub === "add") {
+    if (!a2) return fail("Give the draft and the file:  symbiot post add <id> <picture or video>");
+    let data; try { data = readFileSync(a2); } catch (e) { return fail(`Can't read ${a2}: ${e.message}`); }
+    const r = addPostMedia(a1, data, { name: basename(a2) });
+    if (r.error) return fail(r.error);
+    show(r.post); return;
+  }
+  if (sub === "page") {
+    if (!a2) return fail("Give the draft and the page:  symbiot post page <id> <web address> [--clip] [--seconds 8]");
+    const clip = has("clip"), i = argv.indexOf("--seconds"), seconds = i >= 0 ? Number(argv[i + 1]) || 8 : 8;
+    console.log(c.d(clip ? `Recording ${seconds} s of ${a2}…` : `Taking a picture of ${a2}…`));
+    // through the app when it runs: its hidden browser and this one share a profile
+    const r = (await viaApp("/api/posts/media/page", { id: a1, url: a2, clip, seconds })) || await (clip ? clipOfPage(a1, a2, { seconds }) : pictureOfPage(a1, a2));
+    if (r.error) return fail(r.error);
+    show(r.post); return;
+  }
+  if (sub === "unadd" || sub === "remove") {
+    const r = removePostMedia(a1, a2);
+    if (r.error) return fail(r.error);
+    console.log(`${c.g("✓")} Taken off ${r.post.id}.`); return;
+  }
   if (sub === "edit") {
     if (!a2) return fail('Give the new text:  symbiot post edit <id> "the post"');
     const r = editPost(a1, a2);
@@ -685,6 +712,14 @@ async function cmdPost() {
                                    copy it to your clipboard, and give (--open:
                                    open) LinkedIn's share box to paste it into
   symbiot post edit <id> "text"    change a draft's words
+  symbiot post add <id> <file>     put a picture or video of yours on a draft
+                                   (PNG, JPG, GIF, MP4, MOV, WebM)
+  symbiot post page <id> <page> [--clip] [--seconds 8]
+                                   a picture of a web page (localhost too) on a
+                                   draft; --clip records a short video of it,
+                                   scrolling down (needs ffmpeg)
+  symbiot post remove <id> <media id>
+                                   take a picture or video off a draft
   symbiot post skip <id>           drop a draft
   symbiot post log                 everything drafted, edited, approved, skipped
   symbiot post voice [--linkedin]  your example posts (voice.md), or read your

package/lanes.mjs

@@ -15,11 +15,13 @@
 // it starts when it's free), done (reported back) or error (reported back too).
 // chain: how many handovers in a row led here; past MAX_CHAIN it stops, so two
 // lanes can't hand the same thing back and forth forever.
-import { join, basename } from "node:path";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, chmodSync } from "node:fs";
+import { join, basename, dirname, resolve, relative } from "node:path";
+import { homedir } from "node:os";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, chmodSync, statSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
 import { CONFIG_DIR, loadTasks, clipWords } from "./core.mjs";
-import { runHandoff, runningHandoff, waitingFor, agentQuestions } from "./agents.mjs";
+import { runHandoff, runningHandoff, waitingFor, agentQuestions, findOrcaCli, installAllowlist } from "./agents.mjs";
 import { addTask, pushTasks } from "./tasks.mjs";
 import { actNow } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
@@ -149,7 +151,7 @@ function report(e, o, { run = runHandoff, running = runningHandoff, waiting = wa
 
 // One pass: start what's been handed over, from every lane, then report back
 // what's done. The app runs it every 20 seconds.
-function lanesTick({ map = repoPathMap(), act = actNow, run = runHandoff, running = runningHandoff, add = addTask, push = pushTasks, tasks, now = Date.now() } = {}) {
+function lanesTick({ map = repoPathMap(), act = actNow, run = runHandoff, running = runningHandoff, add = addTask, push = pushTasks, tasks, now = Date.now(), relink = orcaRelink } = {}) {
   const ledger = loadLedger();
   let acts = []; try { acts = readdirSync(ACT_DIR).filter((d) => d.startsWith("act-")).map((d) => join(ACT_DIR, d)); } catch {}
   const started = [];
@@ -161,8 +163,133 @@ function lanesTick({ map = repoPathMap(), act = actNow, run = runHandoff, runnin
     if (report(e, o, { run, running, now })) { e.reportedAt = now; if (e.status !== "error") e.status = "done"; e.result = o.text; reported.push(e); }
   }
   if (started.length || reported.length) saveLedger(ledger);
+  if (reported.length) relink({ map }).catch(() => {}); // a handover may have renamed a lane's folder
   return { started, reported };
 }
+
+// ---- a handover that couldn't start: yours to unblock, on Home ---------------------
+// A handover that errored (an ops run limited to its folder handed "needs a run that
+// can edit ~/Company" to ops, its own lane; a lane that doesn't exist; too long a
+// chain) went back to the agent that asked, and stopped there: Home said nothing
+// needed you. Now it's a question on Home (homeState) for STUCK_FOR, until you
+// answer it or something like it goes through another way. Allow starts it as a
+// run of its own, allowed to read, edit and move files in the folders it names
+// (that run only: its .claude/settings.local.json), and its result goes back to the
+// agent that asked, as any handover's does; Skip lets it go.
+const STUCK_FOR = 3 * 86400000;
+const tilde = (p) => { const h = homedir(); return p === h ? "~" : p.startsWith(h + "/") ? "~" + p.slice(h.length) : p; };
+// Two handovers about the same thing: most of the shorter one's words in the other.
+function alike(a, b) {
+  const x = keyWords(a), y = keyWords(b), [s, l] = x.size <= y.size ? [x, y] : [y, x]; if (s.size < 3) return false;
+  let n = 0; for (const w of s) if (l.has(w)) n++;
+  return n / s.size >= 0.5;
+}
+// The folders a handover names that a run would need: ones on this computer, not
+// the asking run's own, not Symbiot's, not your home itself or a hidden one in it
+// (~/.ssh). A file named in one counts as the folder it's in. Outermost only, 3 at most.
+function namedDirs(text, own = "", { exists = (p) => { try { return statSync(p); } catch { return null; } } } = {}) {
+  const home = homedir(), out = [];
+  const roots = ["~", "/home", "/Users", "/srv", "/opt", "/mnt", "/media", home].map((r) => r.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")).join("|");
+  for (const m of String(text || "").matchAll(new RegExp(`(?:^|[\\s\`'"(])((?:${roots})\\/[^\\s\`'",;)]+)`, "g"))) {
+    let p = resolve(m[1].replace(/^~(?=\/)/, home).replace(/[.:]+$/, "")); const st = exists(p); if (!st) continue;
+    if (!st.isDirectory()) p = dirname(p);
+    const rel = relative(home, p);
+    if (p === home || p === "/" || (!rel.startsWith("..") && rel.split("/")[0].startsWith(".")) || p.startsWith(CONFIG_DIR) || (own && (p === own || p.startsWith(own + "/")))) continue;
+    out.push(p);
+  }
+  return [...new Set(out)].filter((p, i, all) => !all.some((q) => q !== p && p.startsWith(q + "/"))).slice(0, 3);
+}
+// It went through since another way: the same thing handed over again (or done,
+// after it), or the run that asked has run again and ticked all it had.
+function pastIt(e, hs) {
+  if (hs.some((x) => x !== e && x.status !== "error" && Math.max(x.at || 0, x.reportedAt || 0) > e.at && alike(x.text, e.text))) return true;
+  const md = readSym(e.from.path, "TASKS.md");
+  return lastRunStart(e.from.path) > e.at && /^- \[x\]/im.test(md) && !/^\s*- \[ \]/m.test(md);
+}
+// The errored handovers that still wait on you, newest first:
+// [{ id, from, text, error, at, dirs, q, options }].
+function stuckHandovers({ ledger = loadLedger(), now = Date.now(), dirsOf = namedDirs } = {}) {
+  const hs = ledger.handoffs, out = [];
+  hs.forEach((e) => {
+    if (e.status !== "error" || e.skipped || now - (e.at || 0) > STUCK_FOR) return;
+    if (pastIt(e, hs)) return;
+    const dirs = dirsOf(e.text, e.from.path);
+    out.unshift({ id: e.id, from: e.from, text: e.text, error: e.error || "", at: e.at, dirs,
+      q: dirs.length ? `Allow this run access to ${dirs.map(tilde).join(" and ")}?` : `${e.from.lane}'s handover didn't start (${String(e.error || "").replace(/[.:]\s.*$|\.$/, "")}). Start it as a run of its own?`,
+      options: [dirs.length ? "Allow (recommended)" : "Start it (recommended)", "Skip"] });
+  });
+  return out;
+}
+// The rules a run gets for the folders you allowed it: read, edit and move files
+// there (git mv too), nothing wide.
+const dirRules = (dirs) => dirs.flatMap((d) => [`Read(/${d}/**)`, `Edit(/${d}/**)`, `Write(/${d}/**)`]).concat(dirs.length ? ["Bash(mv:*)", "Bash(git mv:*)", "Bash(mkdir:*)", "Bash(ls:*)", "Bash(find:*)"] : []);
+function grantDirs(dir, dirs) {
+  if (!dirs.length) return null;
+  try { writeFileSync(join(dir, ".symbiot", "allowlist.proposed.json"), JSON.stringify({ permissions: { allow: dirRules(dirs), additionalDirectories: dirs } }, null, 2) + "\n"); } catch { return null; }
+  return installAllowlist(dir);
+}
+// Allow (or Start it): a run of its own on what was handed over, with what you
+// said added, allowed into the folders it names. The ledger's entry becomes that
+// handover, started, so its result goes back to the agent that asked. { ok, job, dirs } or { error }.
+function allowHandover(id, { note = "", act = actNow, run = runHandoff, now = Date.now(), dirsOf = namedDirs } = {}) {
+  const ledger = loadLedger(), e = ledger.handoffs.find((x) => x.id === id);
+  if (!e || e.status !== "error" || e.skipped) return { error: "That handover isn't waiting on you any more." };
+  const dirs = dirsOf(e.text, e.from.path), said = String(note || "").trim().slice(0, 2000);
+  const r = act(e.text + (said ? `\n\nThe user said: ${said}` : ""), { now, title: `handed over by ${e.from.lane}`,
+    context: `${e.from.lane}'s agent (in ${e.from.path}) handed this over, and carries on once it's done.${dirs.length ? ` The user allowed this run to read, edit and move files in ${dirs.join(", ")}.` : ""}`,
+    run: (dir, o) => { grantDirs(dir, dirs); return run(dir, o); } });
+  if (!r || r.error) return { error: (r && r.error) || "The run didn't start." };
+  Object.assign(e, { status: "started", to: { lane: OPS, path: r.dir }, job: r.job, at: now, allowedAt: now });
+  delete e.error; delete e.reportedAt; delete e.result;
+  saveLedger(ledger);
+  return { ok: true, job: r.job, dirs };
+}
+// Skip: it stops asking, and the agent that handed it over reads that you skipped it.
+function skipHandover(id, { now = Date.now() } = {}) {
+  const ledger = loadLedger(), e = ledger.handoffs.find((x) => x.id === id);
+  if (!e || e.status !== "error") return { error: "That handover isn't waiting on you any more." };
+  e.skipped = now; saveLedger(ledger);
+  const file = join(e.from.path, ".symbiot", "ANSWERS.md");
+  try { if (existsSync(join(e.from.path, ".symbiot"))) writeFileSync(file, `${(existsSync(file) ? readFileSync(file, "utf8") : "# Answers\n").replace(/\s*$/, "")}\n\n### Handed over to ${e.to.lane}: ${clipWords(firstLine(e.text), 120)}\nThe user skipped it: don't hand it over again.\n_answered ${new Date(now).toISOString().slice(0, 10)}_\n`); } catch {}
+  return { ok: true };
+}
+
+// ---- Orca, kept pointing at the lanes ---------------------------------------------
+// A handover can rename a lane's folder (CallForge AI → dailify), and the run that
+// did it can't tell Orca (its CLI is outside what a run may do), so Orca keeps a
+// path that's gone. After a handover comes back, and when the app starts, each repo
+// Orca has at a path that's gone is added again where it is now: the scanned repo
+// with the GitHub remote Orca kept for it, else the one with its name. Orca's CLI
+// can't drop the old entry: it shows as missing there until you remove it.
+const remoteKey = (url) => String(url || "").trim().replace(/^[a-z+]+:\/\//i, "").replace(/^[^@/]+@/, "").replace(/:(?!\d)/, "/").replace(/\/+$/, "").replace(/\.git$/i, "").toLowerCase();
+const gitRemote = (path) => new Promise((res) => execFile("git", ["-C", path, "remote", "get-url", "origin"], { timeout: 5000, encoding: "utf8" }, (e, out) => res(e ? "" : out)));
+const runOrca = (cli, args) => new Promise((res) => execFile(cli, args, { timeout: 20000, encoding: "utf8" }, (e, out) => res(e ? "" : out)));
+// Orca's repos ({ path, displayName, gitRemoteIdentity }) whose folder is gone, each
+// with where it is now: [{ from, to, name }]. Only a single match moves it.
+async function orcaMoves(repos, map, { remoteOf = gitRemote, exists = existsSync } = {}) {
+  const known = new Set(repos.map((r) => r.path)), free = Object.values(map).filter((p) => !known.has(p) && exists(p)), remotes = new Map();
+  const remote = async (p) => { if (!remotes.has(p)) remotes.set(p, remoteKey(await remoteOf(p))); return remotes.get(p); };
+  const moves = [];
+  for (const r of repos) {
+    if (!r.path || exists(r.path)) continue;
+    const key = remoteKey((r.gitRemoteIdentity || {}).canonicalKey), hit = [];
+    if (key) for (const p of free) if ((await remote(p)) === key) hit.push(p);
+    if (!hit.length) { const names = [r.displayName, basename(r.path)].filter(Boolean).map((s) => s.toLowerCase()); hit.push(...free.filter((p) => names.includes(basename(p).toLowerCase()))); }
+    if (hit.length === 1 && !moves.some((m) => m.to === hit[0])) moves.push({ from: r.path, to: hit[0], name: r.displayName || basename(hit[0]) });
+  }
+  return moves;
+}
+// Add each moved repo again in Orca, where it is now. Nothing when Orca isn't
+// installed or isn't running (its CLI can't reach it), and never from a sandbox
+// (symbiot app --fresh): that Orca is your real one. { moves: [{ from, to, name, ok }] }
+async function orcaRelink({ map, cli, orca = runOrca, remoteOf } = {}) {
+  if (process.env.SYMBIOT_SANDBOX) return { moves: [] };
+  cli = cli ?? findOrcaCli(); if (!cli) return { moves: [] };
+  let repos = []; try { repos = JSON.parse(await orca(cli, ["repo", "list", "--json"])).result.repos || []; } catch { return { moves: [] }; }
+  const moves = await orcaMoves(repos, map || repoPathMap(), { remoteOf });
+  for (const m of moves) m.ok = /"ok":\s*true/.test(await orca(cli, ["repo", "add", "--path", m.to, "--json"]));
+  return { moves };
+}
 // 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. What reads the
 // same (one lane to the same lane, the same first line: a run that handed it
@@ -178,4 +305,4 @@ function lanesState() {
   return { handoffs: out.slice(0, 30) };
 }
 
-export { LEDGER, MAX_CHAIN, loadLedger, laneOf, lastRunStart, dispatch, outcome, report, lanesTick, lanesState, aboutIt, partlyDone };
+export { LEDGER, MAX_CHAIN, loadLedger, laneOf, lastRunStart, dispatch, outcome, report, lanesTick, lanesState, aboutIt, partlyDone, remoteKey, orcaMoves, orcaRelink, stuckHandovers, allowHandover, skipHandover, namedDirs, alike };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "symbiot",
-  "version": "0.54.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.",
+  "version": "0.54.4",
+  "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": {
     "symbiot": "index.mjs"