symbiot 0.58.2 → 0.58.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 What each Symbiot release brought, newest first. When Approve bumps the version, it writes that release here from the tasks it approved, worded as release notes by your connected AI (or in the tasks' own words without one). The app shows the releases newer than yours under "What's new" when it offers an update, and once more after you update.
 
+## 0.58.3 — 2026-10-09
+
+- Fixed urgent requests to a parked project: it is now unparked for the work, and other projects are released if nothing starts.
+- Fixed a stuck urgent hold that kept projects paused for hours; it now clears about two minutes after nothing starts running.
+- Changed agents so they no longer start in a folder with no open tasks or new answers, which avoids wasted sessions.
+- Fixed Symbiot saying an agent was "already on urgent work" when nothing was running.
+- Added a "posted" status for marketing drafts so a posted draft leaves the Marketing orb and can't be posted twice.
+- Added `symbiot screens upload` to attach a picture or video to a page's file field, such as a LinkedIn post.
+- Added a fact-only brand brief for the designer making the Symbiot icon and logo.
+- Changed the LinkedIn reader to capture who sent each message and what each notification is about, not just badge counts.
+- Added a review of the mobile companion spec, with follow-up tasks and open decisions.
+- Added a "superseded" status so a redone marketing post replaces the old one on the Marketing orb.
+- Added the pick tray to the Marketing page, showing captures with switchable blur boxes and one-click media selection.
+- Fixed Home cards erasing what you were typing in "answer in your own words" whenever the page updated.
+- Fixed tall question cards on Home overlapping the working-agents row below them.
+- Changed where Symbiot keeps your AI key and app token so agent runs can no longer read them.
+
 ## 0.58.2
 
 - **A voice that doesn't sound robotic, picked for you.** When Symbiot reads a reply out, it uses your computer's own voice only when that's a modern, natural one (Edge's Natural voices on Windows, Apple's Premium and Enhanced voices, a phone's own). Otherwise, as on Linux, where Chrome only has its older Google voices and espeak, Symbiot speaks with its own voice: Piper, a small open-source speech engine that runs on your computer. The accent follows where you are (British English for South Africa, the UK, Australia and the rest; American for the US and Canada), and both voices are public domain. Nothing to choose, no account, nothing leaves your computer. It downloads once (about 85 MB) the first time it's needed, while the system voice covers that first reply, and then answers sentence by sentence, the first in under a second.

package/README.md

@@ -1250,6 +1250,8 @@ symbiot screens type <id> "Search mail" "invoice" --enter --yes   # type into a
                                        # (--yes isn't needed on a site under Trusted sites in Settings)
 symbiot screens type <id> To "sam@example.com" --yes   # without --enter: the text stays in the field...
 symbiot screens press <new id> Send --yes  # ...for a press on the screen that just printed
+symbiot screens upload <id> "Add media" ~/clip.mp4 --yes   # put a file in the page's file box: the field,
+                                       # or the button a site hides it behind ("used" says which box)
 symbiot screens scroll <id>            # "more": "below"? scroll down and map the next part (or up, top, bottom)
 symbiot screens whole <id>             # all of that page in one tall screen (or: symbiot screens map <site> --whole)
 symbiot screens show <id>              # a saved screen's blueprint

package/agents.mjs

@@ -190,7 +190,7 @@ function withTrust(tmpl, box = null) {
 // config.agentSandbox: false turns it off.
 const SANDBOX_DIR = join(CONFIG_DIR, "sandbox");
 const SANDBOX_CACHES = [".npm", ".cache"]; // npm's cache and logs; pip, uv, node-gyp, Chrome for Testing
-const SANDBOX_SECRETS = [".ssh", ".gnupg", ".aws", ".azure", ".kube", ".docker", ".config/gcloud", ".config/gh", ".netrc", ".npmrc", ".pypirc", ".git-credentials", ".config/symbiot/config.json"]; // your AI's key and the app's token too
+const SANDBOX_SECRETS = [".ssh", ".gnupg", ".aws", ".azure", ".kube", ".docker", ".config/gcloud", ".config/gh", ".netrc", ".npmrc", ".pypirc", ".git-credentials", ".config/symbiot/config.json", ".config/symbiot/secrets.json"]; // your AI's key and the app's token too
 // Local sockets are allowed (headless Chrome needs one to start, so the browser tests
 // ran in no sandboxed run), but the ones that would be a way out are hidden: Docker's,
 // and your session's (its bus starts commands outside, through systemd-run; X11 and
@@ -264,12 +264,14 @@ function noteSession(path, code, resumed) {
 // A folder whose last run stopped on questions, with nothing changed since
 // that could answer them, gets no run: { blocked, questions, note }
 // (blockedAgain). force starts one anyway (something changed elsewhere).
-function runHandoff(repoPath, { force = false } = {}) {
+// A folder with nothing to work from gets none either, forced or not (nothingToDo).
+function runHandoff(repoPath, { force = false, lost = false } = {}) {
   let tmpl = handoffCmd(); if (!tmpl || !repoPath) return null;
   if (isParked(repoPath)) return { blocked: true, parked: true, questions: 0, note: PARKED_NOTE }; // even forced: that's what parking is for
   let opts = {}; try { opts = JSON.parse(readSymbiot(repoPath, "handoff.json")) || {}; } catch {}
   const busy = runningHandoff(repoPath); if (busy) return { busy: true, id: busy.id || "", pid: busy.pid, auto: !!busy.auto };
   releaseHeldTasks(repoPath); // held for an agent another process started, which has since exited
+  const idle = !lost && nothingToDo(repoPath); if (idle) return { blocked: true, idle: true, questions: 0, note: idle };
   const scoped = withScope(withConnectors(tmpl, repoPath), repoPath), box = isClaudeCmd(scoped) && trustFull() ? sandboxFor(repoPath, scoped) : null; // a repo run's sandbox, on top of the membrane
   tmpl = withStream(withTrust(scoped, box));
   const resume = isClaudeCmd(tmpl) ? resumeFor(repoPath) : null;
@@ -282,7 +284,7 @@ function runHandoff(repoPath, { force = false } = {}) {
   const own = opts.env && typeof opts.env === "object" ? Object.fromEntries(Object.entries(opts.env).map(([k, v]) => [k, String(v)])) : null, boxEnv = sandboxEnv(box);
   const env = own || boxEnv ? { ...(own || {}), ...(boxEnv || {}) } : null;
   const e = track(typeof opts.name === "string" && opts.name ? opts.name.slice(0, 80) : repoPath.split("/").pop(), fillHandoff(runCmd, repoPath, resume ? RESUME_PROMPT : HANDOFF_PROMPT), repoPath, (code) => {
-    if (noteSession(repoPath, code, !!resume) === "lost") { setTimeout(() => { try { runHandoff(repoPath, { force: true }); } catch {} }, 300); return; } // its conversation is gone: start afresh
+    if (noteSession(repoPath, code, !!resume) === "lost") { setTimeout(() => { try { runHandoff(repoPath, { force: true, lost: true }); } catch {} }, 300); return; } // its conversation is gone: start afresh
     try { if (JSON.parse(readFileSync(lock, "utf8")).pid === e.pid) unlinkSync(lock); } catch {}
     noteBlocked(repoPath, tmpl, e.startedAt, code);
     setTimeout(() => { try { autoAllow(repoPath); } catch {} }, 300); // a list it proposed inside your work: turned on, and on it goes
@@ -296,6 +298,27 @@ function runHandoff(repoPath, { force = false } = {}) {
   noteRun(e);
   return e;
 }
+// ---- nothing to do: no run ----------------------------------------------------
+// A run in ~ started with no .symbiot/TASKS.md there, found nothing to action and
+// only cost a session (2026-10-07). A run needs something to work from: an
+// unticked task, or an answer that came in since the folder's last run started
+// (an approved post or draft, a reply to its question: those carry on with every
+// task ticked, and Marketing's folder may have no TASKS.md at all). Else the note
+// for { blocked, idle }, even forced: Start it anyway would start the same
+// nothing. Briefs are written before their run starts (actNow, draftReply,
+// pushTasks), and a held one lands first (runHandoff), so they count. Only the
+// run that restarts a lost conversation skips this: its answer is older than the
+// failed resume's start.
+const OPEN_TASK = /^\s*(?:[-*+]|\d+[.)])\s*\[ \]/m;
+function nothingToDo(path) {
+  const md = readSymbiot(path, "TASKS.md"); if (OPEN_TASK.test(md)) return "";
+  let answered = 0; try { answered = statSync(join(path, ".symbiot", "ANSWERS.md")).mtimeMs; } catch {}
+  const last = [...readSymbiot(path, "agent.log").matchAll(/^=== .* (\d{4}-\d\d-\d\dT[\d:.]+Z) ===$/gm)].pop();
+  if (answered && answered > (last ? Date.parse(last[1]) || 0 : 0)) return "";
+  const name = path === homedir() ? "~" : path.split(/[\\/]/).filter(Boolean).pop() || path;
+  return md.trim() ? `Not started: every task in ${name}'s .symbiot/TASKS.md is ticked and no answer has come in since its last run, so an agent there would have nothing to do. Send it a task first.`
+    : `Not started: ${name} has no .symbiot/TASKS.md, so an agent there would have nothing to do. Send it a task first.`;
+}
 // ---- a parked lane: its tasks start no runs ----------------------------------
 // A lane blocked on something only the user can give (a token from Meta) ran 27
 // times: every answer, handover, Go and Start it anyway started it again, to say
@@ -321,7 +344,12 @@ function parkLane(path, on) {
 // test stopped halfway would be void), stops the urgent lane's own routine run (its
 // changes stay in the folder, and the next run carries on from them) so the urgent
 // one starts now, and when that run ends, urgentDone unparks those lanes in their
-// old order and starts the ones with work waiting. Lanes you parked stay parked.
+// old order and starts the ones with work waiting. Lanes you parked stay parked,
+// except the urgent lane itself: on 2026-10-09 symbiot was parked, so every urgent
+// handover there parked marketing, started nothing, and still said "it's already on
+// urgent work, and takes this next" while 0 agents worked. Asking for urgent work in
+// a lane is the newest thing you've said about it, so it's unparked for it; and if
+// its run still doesn't start, urgentUndo takes back what urgentFirst did.
 const CAPS_OK = /^(README|TODO|FIXME|HTML|JSON|YAML|HTTP|HTTPS|OAUTH|CHANGELOG|TASKS|ANSWERS|QUESTIONS|HANDOFF|REMEMBER|AWAITING|SKIPPED|LICENSE|CLAUDE|AGENTS|NOTE|ASAP|SAST|UTC|GPU|CPU|RAM|USB|SDK|JDK|API|URL|CSS|DNS|SSH|SMS|PDF|PNG|SVG|MCP|LLM|CLI|ENV|PATH|HOME|WIP|ETA)$/;
 function isUrgent(text) {
   const t = String(text || "");
@@ -338,24 +366,43 @@ function stopRun(path) {
   try { process.kill(-r.pid, "SIGTERM"); } catch { try { process.kill(r.pid, "SIGTERM"); } catch { return false; } } // its own process group (track: detached)
   return true;
 }
-// lanes: the paths to consider ({ name: path }); returns { parked: [names], stopped }
+// lanes: the paths to consider ({ name: path }); returns { parked: [names], parkedPaths,
+// stopped, unparked (it was parked: now it isn't), busy: "urgent" | "routine" | "" (a run
+// there now: one already on urgent work, which this waits for, or one it couldn't stop) }
 function urgentFirst(path, { lanes = null, stop = stopRun, running = runningHandoff } = {}) {
-  if (!path) return { parked: [], stopped: false };
+  if (!path) return { parked: [], parkedPaths: [], stopped: false, unparked: false, busy: "" };
   const u = urgentState() || { at: Date.now(), paths: [], parked: [], runs: [] };
-  if (!u.paths.includes(path)) u.paths.push(path);
-  if (u.parked.includes(path)) { u.parked = u.parked.filter((p) => p !== path); parkLane(path, false); } // urgent itself now
+  if (!u.paths.includes(path)) { u.paths.push(path); u.at = Date.now(); }
+  if (u.parked.includes(path)) u.parked = u.parked.filter((p) => p !== path); // urgent itself now
+  const unparked = isParked(path); if (unparked) parkLane(path, false);
   const all = lanes || Object.fromEntries(loadRuns().map((r) => [String(r.name || r.path.split("/").pop()), r.path]));
-  const parked = [], already = parkedPaths();
+  const parked = [], mine = [], already = parkedPaths();
   for (const [name, p] of Object.entries(all)) {
     if (!p || u.paths.includes(p) || already.includes(p)) continue; // yours stay yours
     if (!running(p) && !readSymbiot(p, HELD)) continue; // nothing going or waiting there
-    parkLane(p, true); u.parked.push(p); parked.push(name);
+    parkLane(p, true); u.parked.push(p); parked.push(name); mine.push(p);
   }
-  // its own lane: a routine run stops so this one starts now; one that's already on urgent work keeps going
-  const busy = running(path), onIt = busy && (u.runs.includes(busy.id) || hasOpenUrgent(readSymbiot(path, "TASKS.md")));
+  // its own lane: a routine run stops so this one starts now; one that's already on urgent
+  // work keeps going, and counts as the urgent run, so its end resumes what was parked
+  const busy = running(path), onIt = !!busy && (u.runs.includes(busy.id) || hasOpenUrgent(readSymbiot(path, "TASKS.md")));
+  if (onIt && busy.id && !u.runs.includes(busy.id)) u.runs.push(busy.id);
   const stopped = !!busy && !onIt && stop(path);
   saveUrgent(u);
-  return { parked, stopped };
+  return { parked, parkedPaths: mine, stopped, unparked, busy: !busy ? "" : onIt ? "urgent" : stopped ? "" : "routine" };
+}
+// The urgent lane's run didn't start (no agent command, a step of yours first, its
+// questions unanswered) and nothing runs there: nothing will end to resume the lanes
+// urgentFirst parked, so they're unparked now, and the lane leaves the urgent record.
+function urgentUndo(path, did, { running = runningHandoff } = {}) {
+  if (!path || !did || running(path)) return false;
+  const u = urgentState(); if (!u) return false;
+  const back = (did.parkedPaths || []).filter((p) => u.parked.includes(p));
+  for (const p of back) if (parkedPaths().includes(p)) parkLane(p, false);
+  u.parked = u.parked.filter((p) => !back.includes(p));
+  u.paths = u.paths.filter((p) => p !== path);
+  saveUrgent(u.paths.length ? u : null);
+  if (!u.paths.length && u.parked.length) resumeParked(u.parked); // parked by an earlier urgent ask that never ran either
+  return true;
 }
 // the urgent lane's run started: when it ends, the parked work resumes (runHandoff's exit)
 function noteUrgentRun(path, id) { const u = urgentState(); if (u && u.paths.includes(path) && id && !u.runs.includes(id)) { u.runs.push(id); saveUrgent(u); } }
@@ -376,11 +423,13 @@ function resumeParked(paths, start = runHandoff) {
   return { unparked: paths, resumed };
 }
 // The app restarted under an urgent run (its exit never came), or it never started:
-// the parked lanes don't wait forever.
-const URGENT_MAX = 6 * 3600 * 1000;
+// the parked lanes don't wait forever. A record with no run going in any urgent lane is
+// over once URGENT_GRACE has passed (a stopped routine run takes a moment to exit, and
+// the urgent one starts then): before, one whose run never started held marketing for 6h.
+const URGENT_MAX = 6 * 3600 * 1000, URGENT_GRACE = 2 * 60 * 1000;
 function urgentSweep({ running = runningHandoff, now = Date.now(), start = runHandoff } = {}) {
   const u = urgentState(); if (!u) return null;
-  const ended = u.runs.length > 0 && !u.paths.some((p) => running(p));
+  const ended = !u.paths.some((p) => running(p)) && (u.runs.length > 0 || now - (u.at || 0) >= URGENT_GRACE);
   if (!ended && now - (u.at || 0) < URGENT_MAX) return null;
   saveUrgent(null);
   return resumeParked(u.parked, start);
@@ -999,7 +1048,7 @@ const HARM_RULE = /^Bash\(\s*(rm|dd|mkfs|chmod|chown|shred|truncate)\b/i;
 const wideRule = (r) => ANY_RULE.test(r) || (HARM_RULE.test(r) && /\*/.test(r));
 // Whatever an agent is allowed, it never edits Symbiot's own settings: that's where
 // what agents may do is kept, so an agent could widen its own permissions there.
-const GUARD = () => { const c = join(homedir(), ".config", "symbiot", "config.json"); return [`Edit(${c})`, `Write(${c})`]; };
+const GUARD = () => { const c = join(homedir(), ".config", "symbiot", "config.json"), s = join(homedir(), ".config", "symbiot", "secrets.json"); return [`Edit(${c})`, `Write(${c})`, `Read(${s})`, `Edit(${s})`, `Write(${s})`]; };
 function installAllowlist(path) {
   let p; try { p = JSON.parse(readFileSync(join(path, ".symbiot", "allowlist.proposed.json"), "utf8")).permissions || {}; } catch { return null; }
   const list = (x) => (Array.isArray(x) ? x.filter((r) => typeof r === "string" && r.trim()).map((r) => r.trim()) : []);
@@ -1190,4 +1239,4 @@ function agentsList() {
   }).concat(earlierRuns());
 }
 
-export { FACTS, factsOf, knownRun, withStream, workOf, HANDOFFS, HANDOFF_PROMPT, QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, shSingle, CLAUDE_CMD, ORCA_CLAUDE_CMD, handoffCmd, setHandoffCmd, grantAgent, grantRule, allowTool, claudeConnectors, withConnectors, linkedConnectors, connectorsLine, connectorsInfo, linkReach, fillHandoff, runHandoff, PARKED_NOTE, parkedPaths, isParked, parkLane, agentMissing, blockedAgain, runningHandoff, loadRuns, earlierRuns, namedFiles, waitingFor, startWaiting, noteUntracked, untrackedBefore, forgetUntracked, writeTasks, droppedTasks, releaseHeldTasks, startHeldTasks, detectHandoffs, pickAgent, findOrcaCli, orcaHandoffCmd, migrateOrcaCmd, migrateClaudeCmd, track, agentChanges, parseQuestions, suggestionTarget, skipIdea, agentQuestions, answerQuestions, agentsList, needsOf, settleNeeds, NEEDS_FOR, readLastWords, readNeeds, parseRead, READ_FILE, autoAllow, autoAllowSweep, allowlistInWork, installAllowlist, inWork, withScope, withTrust, sandboxFor, sandboxEnv, sandboxNeeds, sandboxState, sandboxWrites, SANDBOX_DIR, resumeFor, noteSession, trustFull, GUARD_SETTINGS, isUrgent, urgentFirst, urgentDone, urgentSweep, urgentState };
+export { FACTS, factsOf, knownRun, withStream, workOf, HANDOFFS, HANDOFF_PROMPT, QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, shSingle, CLAUDE_CMD, ORCA_CLAUDE_CMD, handoffCmd, setHandoffCmd, grantAgent, grantRule, allowTool, claudeConnectors, withConnectors, linkedConnectors, connectorsLine, connectorsInfo, linkReach, fillHandoff, runHandoff, nothingToDo, PARKED_NOTE, parkedPaths, isParked, parkLane, agentMissing, blockedAgain, runningHandoff, loadRuns, earlierRuns, namedFiles, waitingFor, startWaiting, noteUntracked, untrackedBefore, forgetUntracked, writeTasks, droppedTasks, releaseHeldTasks, startHeldTasks, detectHandoffs, pickAgent, findOrcaCli, orcaHandoffCmd, migrateOrcaCmd, migrateClaudeCmd, track, agentChanges, parseQuestions, suggestionTarget, skipIdea, agentQuestions, answerQuestions, agentsList, needsOf, settleNeeds, NEEDS_FOR, readLastWords, readNeeds, parseRead, READ_FILE, autoAllow, autoAllowSweep, allowlistInWork, installAllowlist, inWork, withScope, withTrust, sandboxFor, sandboxEnv, sandboxNeeds, sandboxState, sandboxWrites, SANDBOX_DIR, resumeFor, noteSession, trustFull, GUARD_SETTINGS, isUrgent, urgentFirst, urgentUndo, urgentDone, urgentSweep, urgentState };

package/core.mjs

@@ -21,17 +21,43 @@ async function checkLatest() { try { const r = await fetch(REGISTRY + "/symbiot"
 // ---- config ---------------------------------------------------------------
 const CONFIG_DIR = join(homedir(), ".config", "symbiot");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+// Symbiot's own keys (your AI's API key, the app's token) live apart from its
+// settings, in secrets.json: a run outside the sandbox could `cat` config.json, and
+// with the token call Symbiot's own API and change the agent command, which the
+// membrane never sees. The membrane (guard.mjs) and a run's sandbox (agents.mjs
+// SANDBOX_SECRETS) refuse secrets.json. loadConfig joins the two and saveConfig
+// splits them, so nothing else changes; a config.json from before still reads, and
+// its keys move out on the next save (the app saves once as it starts: moveSecrets).
+const SECRETS_PATH = join(CONFIG_DIR, "secrets.json"), SECRET_KEYS = ["apiKey", "appToken"];
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function splitSecrets(cfg) {
+  const pub = { ...cfg }, sec = {};
+  for (const k of SECRET_KEYS) if (k in pub) { sec[k] = pub[k]; delete pub[k]; }
+  for (const [k, v] of Object.entries(pub)) if (isObj(v) && "apiKey" in v) { sec[k] = { apiKey: v.apiKey }; pub[k] = { ...v }; delete pub[k].apiKey; } // a provider's: { anthropic: { apiKey, model } }
+  return { pub, sec };
+}
+const readJson = (f) => { try { const o = JSON.parse(readFileSync(f, "utf8")); return isObj(o) ? o : {}; } catch { return {}; } };
 function loadConfig() {
-  try { return JSON.parse(readFileSync(CONFIG_PATH, "utf8")); } catch { return {}; }
+  const cfg = readJson(CONFIG_PATH), sec = readJson(SECRETS_PATH);
+  for (const [k, v] of Object.entries(sec)) {
+    if (SECRET_KEYS.includes(k)) { if (!(k in cfg)) cfg[k] = v; } // one still in config.json is newer (an older Symbiot wrote it)
+    else if (isObj(v) && "apiKey" in v && !(isObj(cfg[k]) && "apiKey" in cfg[k])) cfg[k] = { ...(isObj(cfg[k]) ? cfg[k] : {}), apiKey: v.apiKey };
+  }
+  return cfg;
 }
 function saveConfig(cfg) {
   try {
     mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+    const { pub, sec } = splitSecrets(cfg || {});
+    writeFileSync(SECRETS_PATH, JSON.stringify(sec, null, 2) + "\n", { mode: 0o600 }); // first: a key is never only in neither
+    try { chmodSync(SECRETS_PATH, 0o600); } catch {}
+    writeFileSync(CONFIG_PATH, JSON.stringify(pub, null, 2) + "\n");
     try { chmodSync(CONFIG_PATH, 0o600); } catch {}
     return true;
   } catch { return false; }
 }
+// Keys still in config.json (from before secrets.json): moved out. True if any were.
+function moveSecrets() { const raw = readJson(CONFIG_PATH); return Object.keys(splitSecrets(raw).sec).length ? saveConfig(loadConfig()) : false; }
 // ---- tasks: a persistent checklist (~/.config/symbiot/tasks.json) ---------
 const TASKS_PATH = join(CONFIG_DIR, "tasks.json");
 function loadTasks() { try { return JSON.parse(readFileSync(TASKS_PATH, "utf8")); } catch { return []; } }
@@ -180,4 +206,4 @@ function repoState(repoPath) {
   return { branch, dirty, del, mod, add, stale, staleBy, behind };
 }
 
-export { VERSION, LATEST_VERSION, semverGt, REGISTRY, checkLatest, CONFIG_DIR, CONFIG_PATH, loadConfig, saveConfig, loadTasks, saveTasks, TASK_MAX, clipWords, taskWords, sameTask, uniqueTasks, sh, hasCmd, chromeBinary, repoState };
+export { VERSION, LATEST_VERSION, semverGt, REGISTRY, checkLatest, CONFIG_DIR, CONFIG_PATH, SECRETS_PATH, loadConfig, saveConfig, moveSecrets, splitSecrets, loadTasks, saveTasks, TASK_MAX, clipWords, taskWords, sameTask, uniqueTasks, sh, hasCmd, chromeBinary, repoState };

package/guard.mjs

@@ -7,7 +7,8 @@
 //   - push to main/master, or force-push; publish a package
 //   - delete outside the agent's own folder, or wipe a disk
 //   - sudo, or pipe something from the internet into a shell
-//   - read SSH keys or cloud credentials; change Symbiot's own settings
+//   - read SSH keys or cloud credentials, or Symbiot's own keys (secrets.json: your AI's
+//     key and the app's token); change Symbiot's own settings
 //   - open the user's running Symbiot in a browser (a check uses a sandbox copy)
 //   - in a sandboxed repo run (agents.mjs sandboxFor), edit or write a file outside its
 //     repo and your folders (SYMBIOT_WRITES): its commands are held there by the sandbox
@@ -18,7 +19,7 @@ import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-const SECRET = [".ssh", ".gnupg", ".aws", ".azure", ".kube", ".docker/config.json", ".config/gcloud", ".config/gh/hosts.yml", ".netrc", ".npmrc", ".pypirc", ".git-credentials"];
+const SECRET = [".ssh", ".gnupg", ".aws", ".azure", ".kube", ".docker/config.json", ".config/gcloud", ".config/gh/hosts.yml", ".netrc", ".npmrc", ".pypirc", ".git-credentials", ".config/symbiot/secrets.json"];
 const under = (p, d) => p === d || p.startsWith(d.endsWith("/") ? d : d + "/");
 const expand = (p, home, cwd) => resolve(cwd, String(p).replace(/^~(?=\/|$)/, home).replace(/^\$HOME(?=\/|$)/, home).replace(/^\$\{HOME\}(?=\/|$)/, home));
 const BROWSER = /\b(google-chrome(-stable)?|chromium(-browser)?|chrome|firefox|msedge|playwright|puppeteer|wkhtmltoimage|cutycapt)\b/i;
@@ -65,7 +66,7 @@ function judgeBash(cmd, { cwd, home, branch }) {
       const own = w[0] === "scp" ? SCP_VALUE : null;
       for (const p of w.slice(1).filter((a, i, all) => !a.startsWith("-") && !(own && own.test(all[i - 1] || "")))) { if (secretPath(expand(p, home, cwd), home)) return { why: "your keys and cloud credentials stay yours" }; }
     }
-    if (/(^|\s)(>|>>|tee|sed\s+-i)\s*\S*\.config\/symbiot\/config\.json/.test(s)) return { why: "Symbiot's own settings are yours to change" };
+    if (/(^|\s)(>|>>|tee|sed\s+-i)\s*\S*\.config\/symbiot\/(config|secrets)\.json/.test(s)) return { why: "Symbiot's own settings are yours to change" };
   }
   if (/\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(ba|z|da)?sh\b/.test(c)) return { why: "running a script straight from the internet" };
   // a browser on the user's running Symbiot: each page it opened counted as a new window and

package/headless.mjs

@@ -2,11 +2,12 @@
 // screenshot and map every button, link and field on it by itself, as a screen
 // whose regions are already named (screens.mjs). Nothing to bring to the front,
 // nothing to drag. Each region keeps how to find it again (a CSS selector), so it
-// can be pressed (or a field typed into) in that same hidden browser, which maps
-// the page it lands on: map → press → map is how an agent finds its way around a
-// site. On a site you trust (Settings), that goes ahead without asking. In the
-// app the browser stays open for a few minutes after each action, so the next
-// one carries on from the page as it is (type into a field, then press Send).
+// can be pressed (a field typed into, a file put in a file box) in that same
+// hidden browser, which maps the page it lands on: map → press → map is how an
+// agent finds its way around a site. On a site you trust (Settings), that goes
+// ahead without asking. In the app the browser stays open for a few minutes
+// after each action, so the next one carries on from the page as it is (type
+// into a field, then press Send).
 // A map has what fits in the window: Scroll down maps the next part, and Whole
 // page maps all of it in one tall screenshot: the page, or, where a list scrolls
 // inside it (Gmail's mail), that list opened out to its full length.
@@ -19,8 +20,8 @@
 // site once there (signIn opens it as a normal window) and later maps see it
 // signed in. It's separate from your everyday browser profile.
 import { spawn } from "node:child_process";
-import { join } from "node:path";
-import { mkdirSync, existsSync } from "node:fs";
+import { join, resolve as resolvePath } from "node:path";
+import { mkdirSync, existsSync, statSync } from "node:fs";
 import { CONFIG_DIR, chromeBinary, loadConfig, saveConfig } from "./core.mjs";
 import { loadScreens, addPageScreen, center, stitchPng, stitchListPng } from "./screens.mjs";
 
@@ -499,6 +500,39 @@ function readTexts(input, selector, { scrolls = 3 } = {}) {
   }, false)).catch((e) => ({ error: String((e && e.message) || e) }));
 }
 
+// LinkedIn's own lists, for Watch (watch.mjs linkedinDetail): its top bar's badges
+// say "Messaging, 1 new notification", never who, and the brief could only say
+// "2 new notifications" (2026-10-09). This reads who and what, in the signed-in
+// hidden browser, only looking, like readPage: "messages" (each conversation: who,
+// its last line, when, unread) or "notifications" (each card: its words, who, its
+// link, unread). LinkedIn's class names drift, so each has a fallback: its heading,
+// its first paragraph. { items } or { busy } / { error }.
+const LI_TEXT = "const tx = (r, s) => { const e = r.querySelector(s); return e ? String(e.innerText || e.textContent || '').replace(/\\s+/g, ' ').trim() : ''; };";
+const LI_UNREAD = "const un = (r) => /unread/i.test(String(r.className || '')) || !!r.querySelector('[class*=unread],.notification-badge--show') || /\\bunread\\b/i.test(r.getAttribute('aria-label') || '');";
+const LI_READ = {
+  messages: ["https://www.linkedin.com/messaging/", `(() => { ${LI_TEXT} ${LI_UNREAD}
+    return [...document.querySelectorAll('li.msg-conversation-listitem, li.msg-conversations-container__convo-item')].slice(0, 20).map((r) => ({
+      name: tx(r, '.msg-conversation-listitem__participant-names, .msg-conversation-card__participant-names, h3'),
+      preview: tx(r, '.msg-conversation-card__message-snippet, .msg-conversation-card__message-snippet-body, p').slice(0, 200),
+      time: tx(r, 'time, .msg-conversation-listitem__time-stamp, .msg-conversation-card__time-stamp'), unread: un(r) })).filter((x) => x.name);
+  })()`],
+  notifications: ["https://www.linkedin.com/notifications/", `(() => { ${LI_TEXT} ${LI_UNREAD}
+    return [...document.querySelectorAll('article.nt-card, .nt-card-list article, main article')].slice(0, 20).map((r) => ({
+      text: (tx(r, '.nt-card__text--3-line, .nt-card__headline, .nt-card__text') || String(r.innerText || '').replace(/\\s+/g, ' ').trim()).slice(0, 300),
+      actor: tx(r, '.nt-card__text--3-line strong, .nt-card__headline strong, strong').slice(0, 80),
+      href: String((r.querySelector('a[href*="linkedin.com/"], a[href^="/"]') || {}).href || '').slice(0, 500), unread: un(r) })).filter((x) => x.text);
+  })()`],
+};
+function readLinkedIn(kind) {
+  const it = LI_READ[kind]; if (!it) return Promise.resolve({ error: "messages or notifications" });
+  return oneAtATime(() => browserOpen() ? { busy: true } : withPage(async (page) => {
+    await open(page, it[0]);
+    const at = String((await evaluate(page, "location.href")) || it[0]);
+    if (signInPage(at)) return { login: true, url: at };
+    return { url: at, items: (await evaluate(page, it[1])) || [] };
+  }, false)).catch((e) => ({ error: String((e && e.message) || e) }));
+}
+
 // A picture, or a short clip, of a page, for a post (post.mjs): only on your
 // click, and it only looks, like readPage. The picture is the window at twice its
 // pixels, so it stays sharp in a feed: { png, url, title }. The clip records the
@@ -630,7 +664,7 @@ function actOnRegion(id, regionId, verb, confirmed, check, act) {
   const r = (s.regions || []).find((x) => x.id === regionId); if (!r) return Promise.resolve({ error: "That region is gone. Reload the screen." });
   const bad = check(r); if (bad) return Promise.resolve({ error: bad });
   const host = hostOf(s.page.url);
-  if (!confirmed && !isTrusted(s.page.url)) return Promise.resolve({ error: `${verb === "Type" ? "Typing into" : "Pressing"} "${r.label}" acts on the real site, signed in as you, and ${host} isn't one of your trusted sites.`, confirm: true, host });
+  if (!confirmed && !isTrusted(s.page.url)) return Promise.resolve({ error: `${verb === "Type" ? "Typing into" : verb === "Upload" ? "Attaching a file with" : "Pressing"} "${r.label}" acts on the real site, signed in as you, and ${host} isn't one of your trusted sites.`, confirm: true, host });
   return oneAtATime(() => withPage(async (page, b) => {
     const here = await showScreen(page, b, s);
     // A new tab would leave this one where it was, so a link opens here instead.
@@ -701,6 +735,68 @@ function typeRegion(id, regionId, text, { enter = false, confirmed = false, noSe
   });
 }
 
+// Upload: put a file (or a few) in a page's file box, as picking it in the file
+// dialog would (DevTools' DOM.setFileInputFiles): a picture or video for a LinkedIn
+// post. Sites hide the real <input type=file> behind a button ("Add media"), and a
+// map only has what shows, so the field is usually that button: the box is then
+// the one inside it, its label's, else the nearest one going up from it, and
+// `used` says which. A page that makes its box only once the button is pressed:
+// pressed, with the file dialog caught instead of shown, and the file put in the
+// box that dialog was for. The files are checked (absolute, there) before a
+// browser starts, and off your trusted sites it asks first, like press and type.
+const FILE_BOX = (sel, at) => `(() => {
+  const isBox = (x) => !!x && x.tagName === 'INPUT' && String(x.type).toLowerCase() === 'file', all = [...document.querySelectorAll('input[type=file]')];
+  let e = null; try { e = ${JSON.stringify(sel || "")} && document.querySelector(${JSON.stringify(sel || "")}); } catch (x) {}
+  e = e || document.elementFromPoint(${Number(at.x) || 0}, ${Number(at.y) || 0});
+  let box = null, how = '';
+  if (isBox(e)) { box = e; how = 'the field itself'; }
+  else if (e) {
+    const lab = e.closest('label'), inside = e.querySelector('input[type=file]');
+    if (inside) { box = inside; how = 'the file box inside it'; }
+    else if (lab && isBox(lab.control)) { box = lab.control; how = "its label's file box"; }
+    else for (let n = e.parentElement; n && !box; n = n.parentElement) { const f = n.querySelector('input[type=file]'); if (f) { box = f; how = all.length === 1 ? 'the only file box on the page' : "the nearest of the page's " + all.length + ' file boxes'; } }
+  }
+  if (!box && all.length === 1) { box = all[0]; how = 'the only file box on the page'; }
+  if (!box) return null;
+  window.__symbiotFileBox = box;
+  const name = box.getAttribute('aria-label') || box.name || box.id || '';
+  return { how, box: 'input[type=file]' + (name ? ' "' + name + '"' : '') + (box.accept ? ' (takes ' + box.accept + ')' : ''), multiple: !!box.multiple };
+})()`;
+async function attachFiles(page, at, r, files) {
+  const box = await evaluate(page, FILE_BOX(r.selector, at));
+  if (box) {
+    if (files.length > 1 && !box.multiple) throw new Error(`${box.box} takes one file at a time.`);
+    const { result } = await page.send("Runtime.evaluate", { expression: "window.__symbiotFileBox" });
+    if (!result || !result.objectId) throw new Error("Lost the page's file box. Map the page again.");
+    await page.send("DOM.setFileInputFiles", { files, objectId: result.objectId });
+    await page.send("Runtime.evaluate", { expression: "delete window.__symbiotFileBox" }).catch(() => {});
+    return { used: `${box.box}, ${box.how}` };
+  }
+  // no box on the page yet: press it, and catch the file dialog that opens
+  await page.send("Page.setInterceptFileChooserDialog", { enabled: true });
+  try {
+    const opened = page.until("Page.fileChooserOpened", 5000);
+    await clickAt(page, at);
+    const m = await opened, p = (m && m.params) || {};
+    if (!p.backendNodeId) throw new Error(`No file box on the page, and pressing "${r.label}" didn't open a file dialog. Press it, then upload with what the new map shows.`);
+    if (files.length > 1 && p.mode !== "selectMultiple") throw new Error("That file box takes one file at a time.");
+    await page.send("DOM.setFileInputFiles", { files, backendNodeId: p.backendNodeId });
+    return { used: "the file box the file dialog it opened was for" };
+  } finally { await page.send("Page.setInterceptFileChooserDialog", { enabled: false }).catch(() => {}); }
+}
+// files: a path or a list of them, relative to where you are
+function uploadFiles(files) {
+  const list = (Array.isArray(files) ? files : [files]).filter((f) => f != null && String(f).trim()).map((f) => resolvePath(String(f)));
+  if (!list.length) return { error: "Give the file to upload." };
+  const bad = list.find((f) => { try { return !statSync(f).isFile(); } catch { return true; } });
+  return bad ? { error: `No file at ${bad}.` } : { files: list };
+}
+function uploadRegion(id, regionId, files, { confirmed = false } = {}) {
+  const f = uploadFiles(files);
+  return actOnRegion(id, regionId, "Upload", confirmed, () => f.error || "",
+    async (page, at, r) => ({ uploaded: r.label, files: f.files, ...(await attachFiles(page, at, r, f.files)) }));
+}
+
 // Open the site in Symbiot's browser profile as a normal window, to sign in (or
 // accept cookies) once. Close it before mapping: the profile is shared. The hidden
 // browser is closed first, or the window would open in it, out of sight.
@@ -714,4 +810,4 @@ async function signIn(input) {
   return { ok: true, url };
 }
 
-export { siteUrl, browserArgs, mapPage, wholePage, readPage, readTexts, pagePicture, pageClip, CLIP, isSend, pressRegion, typeRegion, scrollPage, SCROLLS, signIn, keepBrowserOpen, closeBrowser, browserOpen, trustedSites, isTrusted, trustSite, untrustSite, PROFILE };
+export { siteUrl, browserArgs, mapPage, wholePage, readPage, readTexts, readLinkedIn, LI_READ, pagePicture, pageClip, CLIP, isSend, pressRegion, typeRegion, uploadRegion, uploadFiles, attachFiles, FILE_BOX, scrollPage, SCROLLS, signIn, keepBrowserOpen, closeBrowser, browserOpen, trustedSites, isTrusted, trustSite, untrustSite, PROFILE };

package/home.mjs

@@ -28,7 +28,7 @@ import { reportsNews, listReports, readReport, decide } from "./reports.mjs";
 import { awaitingState, inboxSight } from "./handback.mjs";
 import { newClashes } from "./checks.mjs";
 import { postsState } from "./post.mjs";
-import { MARKETING, MARKETING_DIR, MARKETING_WORDS, displayName, productNames, productOf, untagged, tagged, draftFiles, setDraftStatus } from "./marketing.mjs";
+import { MARKETING, MARKETING_DIR, MARKETING_WORDS, displayName, productNames, productOf, untagged, tagged, draftFiles, setDraftStatus, postedCmd } from "./marketing.mjs";
 
 const KEEP = 15000; // the slower reads (git per repo awaiting review) are cached this long
 let cached = null;
@@ -223,7 +223,9 @@ function goLane(repo, map, { push = pushTasks, run = runHandoff } = {}) {
   if (!map[repo]) return { error: `${repo} isn't one of your projects any more.` };
   const p = (push || pushTasks)({ repo }); if (!p || !p.written || !p.written.length) return { error: `Nothing of ${repo}'s is waiting to start.` };
   const e = (run || runHandoff)(map[repo]); if (!e) return { error: "The agent didn't start. Check its command in Settings → Handoff." };
-  return e.parked ? { error: `${repo} is parked: unpark it to start its agent.` } : { ok: true, ...(e.busy || e.blocked ? { queued: true } : { job: e.id }) };
+  if (e.parked) return { error: `${repo} is parked: unpark it to start its agent.` };
+  if (e.blocked && !e.busy) return { error: `${repo}'s agent didn't start: ${e.note || "it's waiting on something"}` }; // queued only behind a run that's really going
+  return { ok: true, ...(e.busy ? { queued: true } : { job: e.id }) };
 }
 
 // ---- Marketing: a lane of its own, across products (marketing.mjs) ----------------------
@@ -280,7 +282,7 @@ function marketingDraftAnswer(rel, status, deps = {}) {
   cached = null;
   const d = r.draft, when = d.when ? `, scheduled in ${d.platform}'s own scheduler for ${d.when}` : "";
   if (status === "skipped") { noteAnswer(dir, `Skipped: ${rel}`, "Don't post it. Leave the draft where it is."); return { ok: true, said: "Skipped. Its agent won't post it." }; }
-  noteAnswer(dir, `Approved: ${rel}`, `The user approved its preview. Post it on ${d.platform}${when}, through Symbiot's signed-in browser, with exactly the text under its post (${d.body.length} characters, unchanged)${d.media.length ? ` and ${d.media.join(", ")} attached` : ""}. Then check it's there, and say so in your last message.`);
+  noteAnswer(dir, `Approved: ${rel}`, `The user approved its preview. Post it on ${d.platform}${when}, through Symbiot's signed-in browser, with exactly the text under its post (${d.body.length} characters, unchanged)${d.media.length ? ` and ${d.media.join(", ")} attached` : ""}. Then check it's there, mark it posted (\`${postedCmd(rel)}\`), and say so in your last message.`);
   if ((deps.running || runningHandoff)(dir)) return { ok: true, said: "Approved. Its agent posts it once the run there now finishes." };
   const e = (deps.run || runHandoff)(dir, { force: true });
   return e && e.id && !e.blocked ? { ok: true, said: `Approved. Its agent is ${d.when ? "scheduling" : "posting"} it now.`, rerun: e.id } : { ok: true, said: `Approved. ${(e && e.note) || "Start its agent to post it."}` };
@@ -491,12 +493,12 @@ async function homeAsk(question, { ask, now = Date.now(), state, images = [] } =
   const h = state || homeState({ now });
   let map = {}; try { map = laneMap(); } catch {}
   const role = "Here they're on Symbiot's home: one liquid surface that shows what only they can do, what's new on what they watch, and the lanes. Answer from what it shows, and act on what they ask.";
-  const r = await converse({ where: "Home", role, context: homeContext(h), question: question + (pics.length ? `\n(The user attached ${pics.length} screenshot${pics.length > 1 ? "s" : ""}: you can see ${pics.length > 1 ? "them" : "it"}.)` : ""), map, now, images: pics.map(({ mime, data, path }) => ({ mime, data, path })), ...(ask ? { ask } : {}),
+  const r = await converse({ where: "Home", role, nav: true, context: homeContext(h), question: question + (pics.length ? `\n(The user attached ${pics.length} screenshot${pics.length > 1 ? "s" : ""}: you can see ${pics.length > 1 ? "them" : "it"}.)` : ""), map, now, images: pics.map(({ mime, data, path }) => ({ mime, data, path })), ...(ask ? { ask } : {}),
     act: {
       agent: (req, known, repo) => (repo ? actIn(req + shotNote, repo, { map, known, title: "Home" }) : actNow(req + shotNote, { title: "Home", known })),
       task: (text, repo) => taskIn(text + shotNote, repo, { map }),
     } });
-  return { answer: r.reply, ...(r.did ? { did: r.did } : {}), steps: r.steps || [] };
+  return { answer: r.reply, spoken: r.spoken, ...(r.did ? { did: r.did } : {}), ...(r.go ? { go: r.go } : {}), steps: r.steps || [] };
 }
 
 // ---- acting on a report, where you read it (reports.mjs reportIdeas) -------------------
@@ -527,7 +529,7 @@ async function reportAsk(id, question, { ask, deps = {} } = {}) {
       agent: (req, known, repo) => ((repo || lane) ? actIn(req, repo || lane, { map, known, title: "Reports" }) : actNow(req, { title: "Reports", known })),
       task: (text, repo) => taskIn(text, repo || lane, { map }),
     } });
-  return { answer: res.reply, ...(res.did ? { did: res.did } : {}), steps: res.steps || [] };
+  return { answer: res.reply, spoken: res.spoken, ...(res.did ? { did: res.did } : {}), steps: res.steps || [] };
 }
 // Approve or Reject on a draft report: its agent is told in ANSWERS.md, and an approved
 // one goes ahead (its agent starts, or takes it once the run there finishes).