symbiot 0.61.1 → 0.62.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 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.62.1
+
+- **A phone that had Symbiot before goes to "Your computer" first.** Installing the new app over an older one kept the old app's setup, already started at "Meet Symbiot", so the phone went on to "Your AI" and asked to install Claude Code, and never offered to pair with your computer. An unfinished setup on a phone that isn't paired now opens on **Your computer** (scan the QR your computer shows, or type its address and code), once; "No computer" carries on as before. Checked on the Android emulator: 0.59.0, then 0.62.0 over it (the problem), then this over that (fixed).
+
+## 0.62.0 — 2026-10-09
+
+- **Your phone shows your computer's work, and you can act on it there.** Pair Symbiot's Android app (or Symbiot in Termux) with your computer and the phone gets a droplet on Home, **On <your computer>**: your tasks, what needs you, your agents' questions, the work waiting for your Approve, and what Watch found (as notifications too). Tick and add tasks, answer an agent and approve from it. "Watch on your phone" is now **Your phone**, in Settings and in Setup.
+- **Sealed between the two.** At pairing the phone and the computer agree a key, and everything after is encrypted with it and stamped so a copy can't be sent again. Your mail's subjects no longer cross your Wi-Fi in the clear. Phones paired before this are asked to pair again.
+- **Pair by scanning.** Switch it on and the computer shows a QR: point your phone's camera at it and the app pairs. The QR carries your computer's key, so a scan can't pair with a stand-in. Typing the address and code still works, with the computers found on your network listed, and `symbiot phone code` prints the QR in the terminal.
+- **In Setup.** A new install's Setup has an optional **Your phone** step, and the Android app's Setup starts with **Your computer** (or "No computer: use Symbiot on this phone"). Settings' first steps list it too.
+- **Found again by itself.** While the link is on, your computer says it's there on your network (mDNS, under a neutral name), so your phone finds it after the router hands it a new address, without pairing again.
+- **Back without a wait.** After a failed try the phone asks again in 15 seconds, 30, then a minute, and at once when its network changes or you open the app. A network error never unpairs it.
+- **Your work, with the computer off.** The phone keeps the last copy and shows it, with one calm line saying the computer is out of reach and when it last heard from it. What you change meanwhile shows at once, marked "waiting to send", and goes in order once the computer is back, each change once. If your computer changed the same thing later, the computer's stays and the phone says so.
+- **Approve from your phone, safely.** An approve goes through only if the work is still exactly what the phone showed; it runs the same Approve as the button, and Home and the Workdesk say which phone approved. Unpairing a phone stops it at once, including what it had queued. A phone can do these few things only; nothing else on your computer is reachable from it.
+- **Away from home, through symbiot.co.za.** With a phone paired, your computer keeps a line open to a relay at relay.symbiot.co.za, which passes the sealed messages on and can't read them or keep them. At home nothing goes through it, and **Away from home too** in Settings switches it off. The relay is in the repo (`relay/`); it goes live once it's deployed.
+- **Keys kept safer.** Your computer keeps only a hash of each phone's token (a copied config can't pose as your phone) and its own key in `secrets.json`, out of agents' reach. The Android app keeps its key sealed by Android's Keystore.
+- **A sign-in stays signed in.** Sites that keep your login only until the browser closes (domains.co.za's, with its SMS PIN) lost it the moment you were done signing in. Symbiot now keeps those sign-ins for 12 hours, and lets Chrome finish saving them before it closes.
+- **A sign-in kept in a tab comes along too.** Some sites keep you signed in in the tab's own storage (sessionStorage) rather than a cookie. Symbiot now carries that over from the Symbiot Browser, site by site, for 12 hours, and no other site's page can see it.
+- **Setup on the phone starts at "Your computer".** A new install of the Android app opened on "Meet Symbiot", so a phone paired by scanning the QR showed nothing, not even an error. It now starts at "Your computer", and a pairing link that arrives during setup shows there, paired or why not.
+- **Sign in to any site, from where you are.** Settings → Connections has **Add a site**: type the page you see once signed in (www.domains.co.za/client/dashboard), and the Symbiot Browser opens on it straight away. The site appears under **Your sites** (here and in the Symbiot Browser, whose address bar adds a site the same way), turns green once you've signed in and clicked Done, and agents can use it. Each trusted site has a **Sign in** button too.
+- **A card or a reply that asks you to sign in has the button for it.** "Sign in to domains.co.za" opens the Symbiot Browser on it, instead of a pointer to "Symbiot's browser" with no way to find it. Agents and Talk to Symbiot now name the site and where to sign in.
+- Agents can run `symbiot screens` from where Symbiot is installed again: the guard stopped any command that only mentioned its folder. Changing Symbiot's own files is still stopped.
+- symbiot.co.za's footer says © 2026 Symbiot.
+- The 4-week posting test counts posts that went out through Marketing too (marked posted, or their scheduled time on LinkedIn passed), and its replies are comments, replies, mentions and messages, not reactions or a bare badge count.
+
 ## 0.61.1
 
 - **The Symbiot Browser opens on its page, not blank.** 0.61.0 only knew the page's address in the copy of Symbiot that hands over to one already running, so in the running app "Open the Symbiot Browser" opened an empty window. It's set where the app starts serving now, and a test checks it.

package/README.md

@@ -297,6 +297,72 @@ to a GitHub release tagged `apk-<version>`, signed with that same key once it's
 in the repo's `SYMBIOT_KEYSTORE_B64` and `SYMBIOT_KEYSTORE_PASS` secrets (see
 `.github/workflows/publish.yml`).
 
+### Your phone
+
+Your computer's work, on your phone: your tasks, what needs you, your agents'
+questions, the work waiting for your Approve, and what Watch found (as a
+notification too). Experimental.
+
+- **Pair it.** On the computer, Setup's **Your phone** step (or Settings → **Your
+  phone**) switches the link on and shows a QR. Point your phone's camera at it and
+  tap its link: it opens symbiot.co.za/pair, which hands it to Symbiot's app (the
+  part of the link with the code never leaves your phone), and the app pairs. The
+  Android app's own Setup starts with **Your computer** for this, or **No computer:
+  use Symbiot on this phone**. No camera, or Termux? Type the computer's address and
+  the 6-digit code it shows (**Look for it on this network** lists the computers it
+  finds), or `symbiot phone pair <address> <code>` (or the QR's link) in Termux;
+  `symbiot phone code` on the computer prints the QR in the terminal. A code lasts
+  10 minutes and 5 tries.
+- **Sealed.** At pairing the phone and the computer agree a key (X25519, then HKDF),
+  and every request and answer after that is sealed with it (AES-256-GCM) and stamped,
+  so a copy sent again is refused. The QR carries the computer key's fingerprint, so a
+  scan can't pair with a stand-in. The computer keeps only a hash of each phone's
+  token, and its own private key in `secrets.json`, which agent runs can't read. The
+  Android app keeps its token and key sealed by a key in Android's Keystore; in Termux
+  they're in `secrets.json` (readable only by you, 0600).
+- **What a phone can do.** Only this: what's new, a copy of your work, and four
+  changes (add a task, mark one done or not, answer an agent, approve). The computer
+  listens on port 7392 of your network for that alone; the rest of Symbiot stays on
+  `127.0.0.1`, and nothing else is reachable from the phone. An approve goes through
+  only if the work is still exactly what the phone showed, runs the same Approve as
+  the button, and Home and the Workdesk say which phone approved. Unpairing a phone
+  stops it at once, including what it had queued. A firewall on the computer may need
+  to allow the port.
+- **With the computer off.** The phone keeps the last copy (`computer.json`) and shows
+  it, with one line saying the computer is out of reach and when it last heard from
+  it. What you change meanwhile shows at once, marked "waiting to send", and goes in
+  order once the computer is back, each change once. When the computer changed the
+  same thing later, the computer's stays, and the phone says so.
+- **Finding it again.** While the link is on, the computer says it's here on your
+  network (mDNS, as a printer does, under a neutral name, not your computer's), so
+  the phone finds it after a new address; it never unpairs because of a network
+  error. It asks every 2 minutes, sooner after a failed try (15 s, 30 s, a minute),
+  and at once when the phone's network changes or you open the app.
+- **Away from home.** With a phone paired, the computer keeps a line open to a relay
+  at `relay.symbiot.co.za` (it connects out: no port opened on your router). The phone
+  uses it only when it can't reach the computer on your network, so at home nothing
+  goes through it. The relay passes the sealed messages on and can't read them; it
+  stores nothing; it knows a pair only by a hash. It does see when a pair talks, and
+  how much. Untick **Away from home too** in Settings → Your phone to keep it to your
+  Wi-Fi. The relay is in `relay/` (a Cloudflare Worker, or `node relay/server.mjs` on
+  a server of your own, with `SYMBIOT_RELAY=<its address>` on the computer).
+
+In Termux:
+
+```bash
+symbiot phone pair 192.168.1.21:7392 123456   # the computer's address and the code it shows
+symbiot phone pair 'https://symbiot.co.za/pair#a=…'   # or the link its QR holds
+symbiot phone                                 # the computer it's paired with
+symbiot phone check                           # ask it now
+symbiot phone forget                          # stop asking it
+```
+
+On the computer, `symbiot phone` lists where it listens, the phones paired and the
+relay, and `symbiot phone code` opens a new code and prints its QR (while `symbiot
+app` runs there). The phone asks the computer while `symbiot app` runs in Termux, so
+start it after pairing. In Termux, notifications need the Termux:API app and
+`pkg install termux-api`.
+
 ## Hand tasks to your coding agent: `symbiot push`
 
 ```bash
@@ -1098,8 +1164,9 @@ price told two ways) also shows on Home, under Watching, until you open it.
   [experimental](#screens-blueprints-for-screen-automation) Screens takes a
   screenshot only when you click Capture, and opens only the web pages you map
   or Watch (in a browser profile of its own). What it maps and what Watch finds
-  stay on your computer, unless you pair your phone (Watch on your phone) or
-  switch on the brief, which sends what's new to your AI.
+  stay on your computer, unless you pair your phone (Your phone: sealed between
+  the two, and away from home through a relay that can't read it) or switch on
+  the brief, which sends what's new to your AI.
 - **Runs only what you set:** the agent command is yours, and deploy commands are
   read only from your own `~/.config/symbiot/`, never from a repo.
 
@@ -1125,9 +1192,11 @@ can't fully check, so they may change. Everything above works without them.
   Type and Trusted sites work on web pages only.
 - **Watch**: reads your Gmail inbox, but hasn't yet been seen to notify a new
   email on a real one. GitHub through `gh` has been read from a real account,
-  but not yet left running. The brief, Standup's "Waiting on you" line and
-  **Watch on your phone** are new; the phone side hasn't been tried on a real
-  phone yet.
+  but not yet left running. The brief and Standup's "Waiting on you" line are new.
+- **Your phone**: the sealed link, the copy, the queue and the relay are tested
+  between two Symbiots on one computer (`test/phone.mjs`; the relay's Worker was
+  also run through it in Miniflare, Cloudflare's local runtime), but not yet on a
+  real phone, and the relay at relay.symbiot.co.za isn't up yet.
 
 ### Your sent email, without an API: `symbiot mail`
 
@@ -1357,35 +1426,12 @@ from what Watch found: `Waiting on you: 3 emails, 2 GitHub notifications`. Symbi
 counts them itself, so the numbers are right; the AI only sees them to know
 what's next.
 
-**On your phone.** What Watch finds on your computer can show up as a
-notification on your phone, through Symbiot there (the [Android app](#the-android-app-apk),
-or Symbiot in [Termux](#on-your-phone-android-in-termux)). On the computer, tick
-**Watch on your phone** in Settings: it shows the computer's address and a 6-digit
-code, good for 10 minutes. On the phone, in Settings → **Watch on your phone**,
-type both and click **Pair**. From then on, while Symbiot runs on both, the phone
-asks the computer every 2 minutes and notifies what's new there, with its brief.
-They have to be on the same network (or both on a VPN such as Tailscale, whose
-address is listed too). For this, the computer listens on port 7392 of your
-network, and serves only two things there: pairing with that code (5 wrong tries
-and the code is gone), and what's new for a phone that paired (with a token of its
-own; unpair it in Settings). Nothing can be changed from there, and the rest of
-Symbiot stays on `127.0.0.1`. What's new crosses your network unencrypted, so
-switch it on at home, not on a café's Wi-Fi. A firewall on the computer may need
-to allow the port. In Termux, notifications need the Termux:API app and
-`pkg install termux-api`.
-
-In Termux you can pair from the command line too, without the app window:
-
-```bash
-symbiot phone pair 192.168.1.21:7392 123456   # the computer's address and the code it shows
-symbiot phone                                 # the computer it's paired with
-symbiot phone check                           # ask it what's new now
-symbiot phone forget                          # stop asking it
-```
-
-On the computer, `symbiot phone` lists where it listens and the phones paired, and
-`symbiot phone code` opens a new code (while `symbiot app` runs there). The phone
-asks the computer while `symbiot app` runs in Termux, so start it after pairing.
+**On your phone.** Your phone can show your computer's work, through Symbiot
+there (the [Android app](#the-android-app-apk), or Symbiot in
+[Termux](#on-your-phone-android-in-termux)): your tasks, what needs you, your
+agents' questions, the work waiting for your Approve, and what Watch found, which
+also comes as a notification. From the phone you can add and tick tasks, answer
+your agents and approve. See [Your phone](#your-phone) for how it works.
 
 **More than one display?** Symbiot reads how your displays are laid out
 (`cosmic-randr`, `wlr-randr`, `kscreen-doctor` or `xrandr` on Linux, PowerShell on

package/browser.html

@@ -86,7 +86,8 @@ document.getElementById("list").addEventListener("click", function (e) {
   }).catch(function () {});
   else say("Sign in to it in the window that opened, then come back here.");
 });
-document.getElementById("go").addEventListener("submit", function (e) { e.preventDefault(); var u = fromInput(document.getElementById("addr").value); if (u) openSite(u); });
+// any site: opened, and kept under Your sites with whether you're signed in (links.mjs addSite)
+document.getElementById("go").addEventListener("submit", function (e) { e.preventDefault(); var u = fromInput(document.getElementById("addr").value); if (!u) return; openSite(u); api("/api/links/site", { site: u, here: true }).then(function (r) { if (r && !r.error) { say("Sign in to it in the window that opened, then come back here. It's under " + ((r.item && r.item.group) || "Your sites") + " now."); load(); } }).catch(function () {}); });
 document.getElementById("done").addEventListener("click", function () { say("Closing, and checking your sites…"); api("/api/browser/done", {}).catch(function () {}); });
 load(); setInterval(load, 5000);
 </script>

package/core.mjs

@@ -28,7 +28,9 @@ const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 // 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"];
+// The phone link's keys too (phone.mjs): this computer's private key, and on a phone
+// its token and the key it shares with the computer.
+const SECRETS_PATH = join(CONFIG_DIR, "secrets.json"), SECRET_KEYS = ["apiKey", "appToken", "phoneSecret", "computerSecret"];
 const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 function splitSecrets(cfg) {
   const pub = { ...cfg }, sec = {};

package/guard.mjs

@@ -31,6 +31,35 @@ function symbiotConfig(p, home) { const d = join(home, ".config", "symbiot"); re
 // runs through (SYMBIOT_OWNER, set by Symbiot, not by the agent).
 const SELF = resolve(fileURLToPath(new URL(".", import.meta.url)));
 const selfFile = (p) => !process.env.SYMBIOT_OWNER && under(p, SELF);
+// A shell command that names Symbiot's files changes them unless it only reads them, runs
+// Symbiot's own CLI (`node <its index.mjs> screens map …`, as TASKS.md tells agents to),
+// sets a variable to the path or prints it, and writes (>, >>, tee) nowhere inside them.
+// Anything else naming them (sed -i, cp, mv, rm, git, npm, cd into them…) is stopped. A
+// command that only named the path was stopped too, and ops couldn't use Screens (2026-10-09).
+const SELF_READ = /^(cat|less|more|head|tail|grep|egrep|fgrep|rg|ls|wc|file|stat|diff|cmp|sha\d*sum|md5sum|readlink|realpath|du|tree|jq|echo|printf|test|\[)$/;
+const SELF_WRAP = /^(timeout|nice|nohup|env|time|command|exec|xargs)$/;
+const unquote = (x) => String(x).replace(/^['"]|['"]$/g, "");
+function changesSelf(part, { home, cwd }) {
+  const mentions = (x) => { const v = unquote(x); return v.includes(SELF) && (v === SELF || v.includes(SELF + "/") || under(expand(v.replace(/^[A-Za-z_][A-Za-z0-9_]*=/, ""), home, cwd), SELF)); };
+  for (const seg of part.split(/\|(?!\|)/)) {
+    const t = seg.trim(); if (!t || !t.includes(SELF)) continue;
+    // where it writes: a redirect's file, or tee's
+    for (const m of t.matchAll(/\d*>>?\s*(?!&)(\S+)/g)) if (mentions(m[1])) return true;
+    let w = t.split(/\s+/), i = 0;
+    while (i < w.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(w[i])) i++; // VAR=… on its own sets a variable, nothing more
+    if (i < w.length && w[i] === "export") { i++; while (i < w.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(w[i])) i++; }
+    while (i < w.length && SELF_WRAP.test(w[i])) { i++; while (i < w.length && (w[i].startsWith("-") || /^\d+[smhd]?$/.test(w[i]))) i++; }
+    if (i >= w.length) continue;
+    const cmd = w[i].split("/").pop(), args = w.slice(i + 1);
+    if (cmd === "tee" && args.some((x) => !x.startsWith("-") && mentions(x))) return true;
+    if (SELF_READ.test(cmd)) continue;
+    if (cmd === "find" && !args.some((x) => /^-(delete|exec|execdir|ok|okdir|fprint\w*|fls)$/.test(x))) continue;
+    // node running a script of Symbiot's (not code given inline, which could write anything)
+    if (/^(node|nodejs)$/.test(cmd) && !args.some((x) => /^(-e|--eval|-p|--print)$/.test(x) || /^--(eval|print)=/.test(x))) { const script = args.find((x) => !x.startsWith("-")); if (script && mentions(script) && /\.(m?js|cjs)['"]?$/.test(script)) continue; }
+    return true;
+  }
+  return false;
+}
 
 // the branch a bare `git push` pushes: the one checked out in cwd
 function currentBranch(cwd) { try { return execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim(); } catch { return ""; } }
@@ -42,7 +71,7 @@ function judgeBash(cmd, { cwd, home, branch }) {
     const s = part.trim(); if (!s) continue;
     const w = s.split(/\s+/);
     if (/^(sudo|su|doas)$/.test(w[0])) return { why: "sudo: only you run things as root" };
-    if (!process.env.SYMBIOT_OWNER && (s.includes(SELF + "/") || s.includes(SELF + " ") || s.endsWith(SELF))) return { why: "Symbiot doesn't edit its own code" };
+    if (!process.env.SYMBIOT_OWNER && s.includes(SELF) && changesSelf(s, { home, cwd })) return { why: "Symbiot doesn't edit its own code" };
     if (/^(shutdown|reboot|poweroff|halt)$/.test(w[0])) return { why: "shutting the computer down is yours to do" };
     if (/^(mkfs(\.\w+)?|fdisk|parted|wipefs)$/.test(w[0]) || (/^dd$/.test(w[0]) && /\bof=\/dev\//.test(s))) return { why: "that writes a disk directly" };
     if (/^git$/.test(w[0]) || /^git\s/.test(s)) {

package/handover.mjs

@@ -27,7 +27,7 @@ function handoverRules(lanes = [], here = "") {
 }
 // The rule for options in QUESTIONS.md: the user gets only what no agent can do,
 // and the option says which kind it is.
-const ONLY_YOU = "- Only what no agent can do is the user's: their body (a phone in their hand, a cable, which network they're on), their identity or secrets (signing in, a 2FA code, a token from a provider's console) or a decision that's theirs (closing an account, spending money, sending something in their name). Start such an option with `👤 You (only you: <which>):`, e.g. `👤 You (only you: your Meta token): paste it into .env`. Anything an agent could do, yours or another lane's, is never a 👤 step: do it, or hand it over. Local git work (staging, committing, pulling, pushing, in this repo or another lane's) is never a 👤 step either: do it, or hand it to that repo's lane, and ask only for an OK in QUESTIONS.md before a push, with the files it pushes. Prefer what's already linked: Symbiot's own browser (`~/.config/symbiot/browser`) is signed in to the sites the user linked under Connections, so use that session over any route that needs a new sign-in, an app, a key or their consent (a platform's API, a developer app, OAuth). Check what's linked before you write a 👤 sign-in or link step, ask them to sign in only when a real attempt found the session expired (and say so), and never offer doing an agent's job by hand. An option where picking it is enough starts with `🤖 Agent:`. Tag actions only: an option that just reports what the user saw or decides (`it notified me`, `not tried yet`) gets no tag. A permission your run doesn't have (a command, a folder) is never a chore for the user. Write the rules, as narrow as the task needs, to `.symbiot/allowlist.proposed.json` (`{\"permissions\": {\"allow\": [...], \"deny\": [...], \"additionalDirectories\": [...]}}`), ask for it in QUESTIONS.md with the option `👤 You (only you: a permission): allow the list in .symbiot/allowlist.proposed.json`, and stop. If it stays inside the user's work (the folders they gave Symbiot, not ~/.ssh or ~/.config), asks for nothing wide, and doesn't publish or reach another machine, Symbiot turns it on by itself and runs you again: no question reaches the user. Their knowledge folders are already yours to read. Never ask them to copy files or run claude in a terminal for it. Decide what can be undone yourself, as a trusted colleague would: the approach, names, which of two fixes, how to lay files out; pick, do it, and say what you chose and why in your last message. Ask only about what can't be undone, costs money, goes out in the user's name, or needs who they are, and then give 2–3 options with your pick first, marked (recommended). Their answer comes back into this same conversation, so you'll remember everything when it does. Symbiot's membrane (its guard) stops the few things only the user does (pushing to main, publishing, deleting outside your folder, sudo, their keys); if it stops you, ask, don't work around it. Whatever waits on the user's OK (sending, posting, deleting, paying, closing) or on a step only they can take goes in QUESTIONS.md as a question, with what they should check first in its context line, never only in your last message: they aren't asked about what your last message says.";
+const ONLY_YOU = "- Only what no agent can do is the user's: their body (a phone in their hand, a cable, which network they're on), their identity or secrets (signing in, a 2FA code, a token from a provider's console) or a decision that's theirs (closing an account, spending money, sending something in their name). Start such an option with `👤 You (only you: <which>):`, e.g. `👤 You (only you: your Meta token): paste it into .env`. Anything an agent could do, yours or another lane's, is never a 👤 step: do it, or hand it over. Local git work (staging, committing, pulling, pushing, in this repo or another lane's) is never a 👤 step either: do it, or hand it to that repo's lane, and ask only for an OK in QUESTIONS.md before a push, with the files it pushes. Prefer what's already linked: Symbiot's own browser (`~/.config/symbiot/browser`) is signed in to the sites the user linked under Connections, so use that session over any route that needs a new sign-in, an app, a key or their consent (a platform's API, a developer app, OAuth). Check what's linked before you write a 👤 sign-in or link step, ask them to sign in only when a real attempt found the session expired (and say so), and never offer doing an agent's job by hand. When they do have to sign in to a site, name the site's address and the place in the app: `👤 You (only you: your sign-in): sign in to <site, e.g. www.domains.co.za/client/dashboard> in the Symbiot Browser (Settings → Connections → Add a site)`, never just \"in Symbiot's browser\": Symbiot puts a Sign in button on that card, which opens the window there. An option where picking it is enough starts with `🤖 Agent:`. Tag actions only: an option that just reports what the user saw or decides (`it notified me`, `not tried yet`) gets no tag. A permission your run doesn't have (a command, a folder) is never a chore for the user. Write the rules, as narrow as the task needs, to `.symbiot/allowlist.proposed.json` (`{\"permissions\": {\"allow\": [...], \"deny\": [...], \"additionalDirectories\": [...]}}`), ask for it in QUESTIONS.md with the option `👤 You (only you: a permission): allow the list in .symbiot/allowlist.proposed.json`, and stop. If it stays inside the user's work (the folders they gave Symbiot, not ~/.ssh or ~/.config), asks for nothing wide, and doesn't publish or reach another machine, Symbiot turns it on by itself and runs you again: no question reaches the user. Their knowledge folders are already yours to read. Never ask them to copy files or run claude in a terminal for it. Decide what can be undone yourself, as a trusted colleague would: the approach, names, which of two fixes, how to lay files out; pick, do it, and say what you chose and why in your last message. Ask only about what can't be undone, costs money, goes out in the user's name, or needs who they are, and then give 2–3 options with your pick first, marked (recommended). Their answer comes back into this same conversation, so you'll remember everything when it does. Symbiot's membrane (its guard) stops the few things only the user does (pushing to main, publishing, deleting outside your folder, sudo, their keys); if it stops you, ask, don't work around it. Whatever waits on the user's OK (sending, posting, deleting, paying, closing) or on a step only they can take goes in QUESTIONS.md as a question, with what they should check first in its context line, never only in your last message: they aren't asked about what your last message says.";
 
 // What a run hands back to Symbiot itself (handback.mjs reads it): facts for
 // memory, and emails that wait on a reply, which Symbiot then watches for; and

package/headless.mjs

@@ -21,7 +21,7 @@
 // signed in. It's separate from your everyday browser profile.
 import { spawn, spawnSync } from "node:child_process";
 import { join, resolve as resolvePath } from "node:path";
-import { mkdirSync, existsSync, statSync, readlinkSync } from "node:fs";
+import { mkdirSync, existsSync, statSync, readlinkSync, readFileSync, writeFileSync } from "node:fs";
 import { CONFIG_DIR, chromeBinary, loadConfig, saveConfig } from "./core.mjs";
 import { loadScreens, addPageScreen, center, stitchPng, stitchListPng } from "./screens.mjs";
 
@@ -45,10 +45,11 @@ function siteUrl(input) {
 }
 
 // The browser's flags. The same profile and password store headless and not, so
-// a sign-in made in the window is readable by the hidden browser.
+// a sign-in made in the window is readable by the hidden browser. The hidden one
+// restores the last session: that's what keeps a site's session-only sign-in (keepSessions).
 function browserArgs(headless, url = "about:blank") {
   return [
-    ...(headless ? ["--headless=new", "--hide-scrollbars", "--mute-audio", "--remote-debugging-pipe", `--window-size=${VIEW.w},${VIEW.h}`] : ["--new-window"]),
+    ...(headless ? ["--headless=new", "--hide-scrollbars", "--mute-audio", "--remote-debugging-pipe", `--window-size=${VIEW.w},${VIEW.h}`, "--restore-last-session"] : ["--new-window"]),
     "--user-data-dir=" + PROFILE, "--no-first-run", "--no-default-browser-check",
     ...(process.platform === "linux" ? ["--password-store=basic"] : process.platform === "darwin" ? ["--use-mock-keychain"] : []),
     url,
@@ -84,6 +85,67 @@ function connect(proc) {
   return { send, until, on: (f) => { listeners.add(f); return () => listeners.delete(f); }, closed: () => closed };
 }
 
+// A sign-in that lives in a session-only cookie (domains.co.za's PHPSESSID: no "remember
+// me") is still on disk when the Sign in window closes, but Chrome drops session cookies
+// when it next starts, unless it restores the last session. So the hidden browser starts
+// that way (browserArgs), and at once makes each session cookie a cookie that lasts
+// SESSION_KEEP; and again before it closes, for one a site set meanwhile. Twice the user
+// signed in to domains.co.za, SMS PIN and all, and lost it as the window closed (2026-10-09).
+const SESSION_KEEP = 12 * 3600; // seconds
+async function keepSessions(c, now = Date.now()) {
+  let cookies = []; try { ({ cookies = [] } = await c.send("Storage.getCookies")); } catch { return 0; }
+  let n = 0;
+  for (const k of cookies.filter((x) => x.session)) {
+    const host = String(k.domain || "").replace(/^\./, ""); if (!host) continue;
+    const port = k.sourcePort > 0 && k.sourcePort !== 80 && k.sourcePort !== 443 ? ":" + k.sourcePort : "";
+    const at = k.domain.startsWith(".") ? { domain: k.domain } : { url: `${k.secure ? "https" : "http"}://${host}${port}${k.path || "/"}` }; // host-only stays host-only
+    const p = { name: k.name, value: k.value, path: k.path || "/", secure: !!k.secure, httpOnly: !!k.httpOnly, expires: Math.floor(now / 1000) + SESSION_KEEP, ...at,
+      ...(k.sameSite ? { sameSite: k.sameSite } : {}), ...(k.priority ? { priority: k.priority } : {}), ...(k.partitionKey ? { partitionKey: k.partitionKey } : {}) };
+    try { await c.send("Storage.setCookies", { cookies: [p] }); n++; } catch {}
+  }
+  return n;
+}
+// A sign-in some sites keep in sessionStorage (a tab's own, not a cookie) comes back with
+// the tab it was in when the last session is restored, and the hidden browser works in a
+// tab of its own. So each restored tab's sessionStorage is kept, by site, for SESSION_KEEP,
+// in the profile (SESSIONS), and filled into the hidden browser's tab when it opens a page
+// of that site with none of its own (sessionFill: in a world of its own, so no page sees
+// another site's). Its own tab's is kept again before it closes.
+const SESSIONS = join(PROFILE, "symbiot-sessions.json"), SS_MAX = 200000; // bytes, all of it
+const SS_READ = `location.origin.startsWith("http") ? JSON.stringify({ origin: location.origin, items: Object.fromEntries(Object.entries(sessionStorage)) }) : ""`;
+function loadSessions(now = Date.now(), file = SESSIONS) {
+  let d = {}; try { d = JSON.parse(readFileSync(file, "utf8")) || {}; } catch {}
+  return Object.fromEntries(Object.entries(d).filter(([o, v]) => /^https?:\/\//.test(o) && v && v.items && typeof v.items === "object" && now - Number(v.at) < SESSION_KEEP * 1000));
+}
+function saveSessions(add, now = Date.now(), file = SESSIONS) {
+  const d = { ...loadSessions(now, file) };
+  for (const x of add) if (x && x.origin && x.items) { if (Object.keys(x.items).length) d[x.origin] = { at: now, items: x.items }; else delete d[x.origin]; }
+  let out = JSON.stringify(d); if (out.length > SS_MAX) out = "{}"; // too big to be a sign-in: keep nothing rather than half
+  try { writeFileSync(file, out, { mode: 0o600 }); } catch {}
+}
+const sessionFill = (d) => `(() => { try { const o = ${JSON.stringify(Object.fromEntries(Object.entries(d).map(([k, v]) => [k, v.items])))}[location.origin]; if (!o || sessionStorage.length) return; for (const k of Object.keys(o)) sessionStorage.setItem(k, String(o[k])); } catch {} })()`;
+// wait: a restored tab may not have its page yet (about:blank a moment longer); our own tab has it
+async function readSession(send, wait = false) {
+  for (let i = 0; i < (wait ? 10 : 1); i++) {
+    try { const r = await send("Runtime.evaluate", { expression: SS_READ, returnByValue: true }); const v = r && r.result && r.result.value; if (v) return JSON.parse(v); } catch {}
+    if (wait) await sleep(200);
+  }
+  return null;
+}
+// The tabs the last session left (restored with it): their sessionStorage kept, then
+// closed, so nothing loads unseen.
+async function closeOthers(c, keep) {
+  try {
+    const { targetInfos = [] } = await c.send("Target.getTargets"), got = [];
+    for (const t of targetInfos) {
+      if (t.type !== "page" || t.targetId === keep) continue;
+      if (/^https?:/.test(t.url || "")) try { const { sessionId } = await c.send("Target.attachToTarget", { targetId: t.targetId, flatten: true }); got.push(await readSession((m, p) => c.send(m, p, sessionId), true)); } catch {}
+      try { await c.send("Target.closeTarget", { targetId: t.targetId }); } catch {}
+    }
+    if (got.some(Boolean)) saveSessions(got.filter(Boolean));
+  } catch {}
+}
+
 // One browser at a time: they share a profile, and Chrome locks it.
 let queue = Promise.resolve();
 const oneAtATime = (fn) => { const run = queue.then(fn, fn); queue = run.catch(() => {}); return run; };
@@ -135,6 +197,7 @@ async function launch() {
         if (existsSync(join(PROFILE, "SingletonLock")) || /existing browser session|ProcessSingleton/i.test(err)) throw new Error("Symbiot's browser is already open, in a window (Sign in) or in another Symbiot: close that, then try again.");
         throw new Error("The browser didn't start: " + ((err.trim().split("\n").pop()) || e.message));
       }
+      await closeOthers(c, targetId); await keepSessions(c);
       const { sessionId } = await c.send("Target.attachToTarget", { targetId, flatten: true });
       const send = (method, params) => c.send(method, params, sessionId);
       const until = (method, ms) => c.until((m) => m.sessionId === sessionId && m.method === method, ms);
@@ -152,6 +215,7 @@ async function launch() {
         while (Date.now() < end && calm < 600) { await sleep(100); calm = inflight.size <= 1 ? calm + 100 : 0; }
       };
       await send("Page.enable"); await send("Network.enable");
+      const ss = loadSessions(); if (Object.keys(ss).length) try { await send("Page.addScriptToEvaluateOnNewDocument", { source: sessionFill(ss), worldName: "symbiot-sessions" }); } catch {}
       await send("Emulation.setDeviceMetricsOverride", { width: VIEW.w, height: VIEW.h, deviceScaleFactor: 1, mobile: false });
       // Sites serve "HeadlessChrome" something else (or a block page): look like the browser it is.
       const { userAgent } = await c.send("Browser.getVersion");
@@ -168,7 +232,10 @@ async function launch() {
 async function shut(b) {
   if (!b) return;
   clearTimeout(b.timer); if (live === b) live = null;
-  if (!b.c.closed()) { try { await Promise.race([b.c.send("Browser.close"), sleep(3000)]); } catch {} }
+  if (!b.c.closed()) { try { if (b.page) { const own = await Promise.race([readSession(b.page.send), sleep(2500)]); if (own) saveSessions([own]); } await Promise.race([keepSessions(b.c), sleep(3000)]); await Promise.race([b.c.send("Browser.close"), sleep(3000)]); } catch {} }
+  // Chrome writes its cookies to disk as it shuts down: killed before that, a sign-in made
+  // or kept since it started is lost. Give it a few seconds to finish.
+  if (b.proc.exitCode === null) await Promise.race([new Promise((r) => b.proc.once("exit", r)), sleep(5000)]);
   if (b.proc.exitCode === null) try { b.proc.kill("SIGKILL"); } catch {}
 }
 // Close the hidden browser now (the Sign in window needs its profile).
@@ -487,13 +554,17 @@ function wholePage(id) {
 // browser is open for you or an agent (type, then press), it leaves it alone
 // ({ busy }) rather than take its page somewhere else; and it doesn't keep the
 // browser open after.
-function readPage(input) {
+// password: a page asking for a password counts as a sign-in page too (a site's own login
+// form at an address that doesn't say so), for a check of whether you're signed in.
+const ASKS_PASSWORD = `!![...document.querySelectorAll('input[type=password]')].find((e) => { const b = e.getBoundingClientRect(); return b.width > 0 && b.height > 0; })`;
+function readPage(input, { password = false } = {}) {
   const url = siteUrl(input);
   if (!url) return Promise.resolve({ error: "Give a site to read: a name (gmail), a host or a web address." });
   return oneAtATime(() => browserOpen() ? { busy: true } : withPage(async (page) => {
     await open(page, url);
     const info = await collect(page);
-    return { ...info, login: signInPage(info.url) };
+    let pw = false; if (password) try { pw = !!((await page.send("Runtime.evaluate", { expression: ASKS_PASSWORD, returnByValue: true })).result || {}).value; } catch {}
+    return { ...info, login: signInPage(info.url) || pw };
   }, false)).catch((e) => ({ error: String((e && e.message) || e) }));
 }
 // The words on a page, not its buttons: the text of each element `selector`
@@ -846,7 +917,10 @@ const kill = (pids) => { for (const p of pids) try { process.kill(p, "SIGTERM");
 async function openSymbiotBrowser(url = "") {
   const chrome = chromeBinary();
   if (!chrome) return { error: "The Symbiot Browser needs Chrome, Chromium, Edge or Brave on this computer, and none was found." };
-  await oneAtATime(closeBrowser);
+  // the hidden browser starts and closes once first (not when a window's open already: it'd
+  // hand over to it): a session sign-in from the last window is kept (keepSessions) before
+  // this one, which doesn't restore the last session, drops it
+  await oneAtATime(async () => { await closeBrowser(); if (process.platform !== "win32" && existsSync(PROFILE) && !profilePids({ headless: false }).length) try { await shut(await launch()); } catch {} });
   const hidden = profilePids({ headless: true }); if (hidden.length) { kill(hidden); await sleep(800); }
   try {
     mkdirSync(PROFILE, { recursive: true, mode: 0o700 });
@@ -867,4 +941,4 @@ async function closeSymbiotBrowser() {
   return { closed: open.length };
 }
 
-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 , openSymbiotBrowser, closeSymbiotBrowser, setBrowserHub , browserHub };
+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, keepSessions, SESSION_KEEP, SESSIONS, loadSessions, trustedSites, isTrusted, trustSite, untrustSite, PROFILE , openSymbiotBrowser, closeSymbiotBrowser, setBrowserHub , browserHub };

package/home.mjs

@@ -17,7 +17,7 @@ import { watchBoard, draftReply, draftCards, draftAnswer } from "./watch.mjs";
 import { pendingReview, pushTasks, addTask, taskType } from "./tasks.mjs";
 import { estimate, estimateWords } from "./estimate.mjs";
 import { setHandoffCmd, agentsList, runHandoff, runningHandoff, handoffCmd, loadRuns, connectorsInfo, parkedPaths, agentMissing, settleNeeds, pickAgent, detectHandoffs, linkReach } from "./agents.mjs";
-import { linksState } from "./links.mjs";
+import { linksState, signInAsked } from "./links.mjs";
 import { knowledgeState } from "./knowledge.mjs";
 import { CONFIG_DIR, loadTasks, saveTasks, loadConfig, saveConfig, sameTask } from "./core.mjs";
 import { lanesState, stuckHandovers, allowHandover, skipHandover } from "./lanes.mjs";
@@ -28,6 +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 { PHONE, ANDROID_APP, computerView, phoneApprovals, linkState } from "./phone.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
@@ -71,7 +72,7 @@ function troubles({ stuck = [], list = [], map = {}, named = displayName, now =
     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" });
+        q: n.what + (n.check ? ` Check first: ${n.check}` : ""), options: ok ? ["Go ahead (recommended)", "Skip"] : ["Done it (recommended)", "Skip"], ...signInCard([n.label, n.what, n.check]), shape: "agents" });
       continue;
     }
     if (a.status !== "failed" || dropped.has(a.id) || (a.endedAt && now - a.endedAt > FAILED_FOR)) continue;
@@ -354,7 +355,7 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
     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" });
+      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 } : {}), ...signInCard([q.q, ...(q.options || []).slice(0, 2)]), 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?"),
@@ -386,7 +387,7 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   }
   // nothing waits on you: a few things that can be done next (none while anything does)
   const next = you.length ? [] : nextUp({ now, map, list, named, deps: { board: () => bd, reports: () => rep, ...(deps.next || {}) } });
-  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, runs: runs.slice(0, 4), next, marketing: marketing({ list, map, named, pend }), at: now };
+  const out = { you: you.slice(0, 6), youCount: you.length, feeds: feeds.slice(0, 6), lanes: hs, working, runs: runs.slice(0, 4), next, marketing: marketing({ list, map, named, pend }), ...(deps.phone || phoneBits)(now), at: now };
   if (!deps.board) cached = out;
   return out;
 }
@@ -466,9 +467,29 @@ function firstSteps({ deps = {} } = {}) {
     { 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" },
   ];
+  // your phone: on a computer, pairing the Symbiot app on it (Setup offers it too)
+  if (!PHONE) { const ph = tryOr(deps.phone || linkState, { phones: [] }), n = (ph.phones || []).length;
+    steps.push({ id: "phone", title: "Your phone", optional: true, done: n > 0, sub: n ? `${ph.phones.map((p) => p.name).join(", ")} paired: your tasks and what needs you, there too` : "your tasks, what needs you and agents' questions on your phone, and Approve from there" }); }
   return { steps, done: steps.every((s) => s.done) };
 }
 
+// Your phone (phone.mjs) on Home. On a phone paired with a computer: that computer's
+// droplet, from the copy it keeps (what needs you there, its open tasks, whether it's
+// out of reach and since when, what's waiting to send). On the computer: what was
+// approved from a phone today, so you know it wasn't you at this desk.
+function phoneBits(now = Date.now()) {
+  try {
+    if (!PHONE) {
+      const a = phoneApprovals(now), l = linkState(), phones = l.on ? (l.phones || []).map((p) => ({ name: p.name, ...(p.seen ? { seen: p.seen } : {}), ...(p.via ? { via: p.via } : {}), ...(p.old ? { old: true } : {}) })) : [];
+      return { ...(phones.length ? { phones } : {}), ...(a.length ? { phoneApproved: a.map((x) => ({ repo: x.repo, phone: x.phone, at: x.at, status: x.status, ...(x.pr ? { pr: x.pr } : {}), ...(x.error ? { error: x.error } : {}) })) } : {}) };
+    }
+    const v = computerView(); if (!v.paired) return {};
+    const c = v.copy || {}, asks = (c.asks || []).filter((x) => !x.waiting).length, approves = (c.approves || []).filter((x) => !x.waiting).length;
+    return { computer: { name: v.name, ...(v.old ? { old: true } : {}), ...(v.away ? { away: true } : {}), heard: v.heard || 0, queued: v.queued || 0, asks, approves, needs: (c.needs || []).length,
+      tasks: (c.tasks || []).filter((t) => !t.done).length, notes: (c.notes || []).length, copy: !!v.copy } };
+  } catch { return {}; }
+}
+
 // One line per thing home shows, for the talk's context.
 function homeContext(h) {
   return [
@@ -478,6 +499,8 @@ function homeContext(h) {
     "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"]),
     ...(h.marketing ? [`Marketing (a lane of its own, for marketing across all their products; "repo": "${MARKETING}"): ${h.marketing.needs ? `${h.marketing.needs} thing${h.marketing.needs > 1 ? "s" : ""} there need${h.marketing.needs > 1 ? "" : "s"} them` : "nothing needs them"}${h.marketing.working ? ", its agent is at work" : ""}.`] : []),
     ...((h.next || []).length ? ["Could be done next (Home suggests these, one tap each):", ...h.next.map((s) => `- ${s.title}: ${s.gain} (${s.time})`)] : []),
+    ...(h.computer ? [`On their computer (${h.computer.name}, this phone keeps a copy${h.computer.away ? `; out of reach, last heard ${new Date(h.computer.heard).toLocaleString()}` : ""}): ${h.computer.asks} agent question${h.computer.asks === 1 ? "" : "s"}, ${h.computer.approves} waiting for Approve, ${h.computer.tasks} open task${h.computer.tasks === 1 ? "" : "s"}${h.computer.queued ? `, ${h.computer.queued} change${h.computer.queued > 1 ? "s" : ""} waiting to send` : ""}. They act on it in its droplet ("On ${h.computer.name}").`] : []),
+    ...((h.phoneApproved || []).length ? ["Approved from their phone today:", ...h.phoneApproved.map((a) => `- ${a.repo} from ${a.phone}: ${a.status}${a.pr ? ` (${a.pr})` : ""}`)] : []),
   ].join("\n");
 }
 
@@ -611,14 +634,14 @@ function workScene({ deps = {}, full = false } = {}) {
       const line = plain(String(t).split(/\n\s*\n/)[0], 220);
       if (line) { p.summary = line; p.state = a.status === "running" ? "at work" : qs.length ? "asks you" : "done"; p.path = a.path; }
     }
-    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 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, ...signInCard([q.q, ...(q.options || []).slice(0, 3)]) }); }
     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 []; } });
   const drafts = deps.drafts || (() => { try { return draftCards(); } catch { return []; } });
   for (const t of troubles({ stuck: stuck(), list: AG, map, named, drafts: drafts() })) {
     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, ...(t.draft ? { draft: t.draft } : {}) });
+    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, ...(t.draft ? { draft: t.draft } : {}), ...(t.signInTo ? { signInTo: t.signInTo } : {}) });
   }
   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));
@@ -636,6 +659,9 @@ function workScene({ deps = {}, full = false } = {}) {
 // ended without ticking it, is flagged (`stuck`) rather than started again and again.
 const AUTO_GRACE = 30000, STUCK_AFTER = 5 * 60000, RETRY_AFTER = 5 * 60000, AUTO_FAIL = {}; // lane → { at, note }: a start that didn't take
 const yours = (text) => /^\s*👤/.test(String(text || "")); // "👤 You (only you: …)": the user's step, never an agent's
+// A card that asks you to sign in to a site ("sign in to domains.co.za in Symbiot's browser")
+// carries the site, and shows a button that opens Symbiot's browser window on it (links.mjs).
+function signInCard(texts) { let s = null; try { s = signInAsked(texts.filter(Boolean).join("\n")); } catch {} return s ? { signInTo: s } : {}; }
 const asAgent = (text) => String(text || "").replace(/^\s*🤖\s*/u, "").replace(/^Agent:\s*/i, "").trim();
 const minutes = (ms) => { const m = Math.round(ms / 60000); return m >= 120 ? `${Math.round(m / 60)} hours` : `${m} min`; };
 // What a folder's agent was last handed (agents.mjs handed.json) and when its last run started.
@@ -724,9 +750,29 @@ const goOps = () => startOps(loadTasks().filter((t) => t.repo === RUNS_LANE && !
 // where your work is, your agent, every app you use (connected, or "I don't use it"),
 // your documents, then Home. It's in config.onboarding: { pending, step, skipped: [link
 // ids you don't use] }; a Symbiot that ran before this existed isn't sent through it.
-const ONB_STEPS = ["welcome", "ai", "work", "agent", "apps", "docs", "done"];
+// Your phone has a step of its own (optional): on a computer, pair the app on your phone
+// (after your documents); in the Android app, "Your computer" comes first, and "no
+// computer" carries on with the rest, as Symbiot on the phone alone.
+const ONB_STEPS = ["welcome", "ai", "work", "agent", "apps", "docs", "phone", "done"];
+const ONB_STEPS_PHONE = ["computer", "welcome", "ai", "work", "agent", "apps", "docs", "done"];
+const onbSteps = (app = ANDROID_APP, phone = PHONE) => (app ? ONB_STEPS_PHONE : phone ? ONB_STEPS.filter((s) => s !== "phone") : ONB_STEPS); // (Symbiot in Termux is on the phone already)
+// A new install (`symbiot app` the first time): setup, from its first step, "Your computer"
+// in the Android app (it started at "welcome" there, so a phone paired by its QR showed nothing).
+function startOnboarding() { const cf = loadConfig(); if (!cf.onboarding) { cf.onboarding = { pending: true, step: onbSteps()[0], skipped: [], ...(onbSteps()[0] === "computer" ? { computer: true } : {}) }; saveConfig(cf); } return cf.onboarding; }
+// The phone app over an older one (a phone that had Symbiot before "Your computer"
+// existed): its unfinished setup carried on at "Meet Symbiot", then "Your AI" asked to
+// install Claude Code on the phone. An unfinished setup on a phone that isn't paired
+// goes to "Your computer" first, once (computer: true): "No computer" carries on as before.
+function phoneSetupFirst({ app = ANDROID_APP, paired = () => !!computerView().paired } = {}) {
+  if (!app) return null;
+  const cf = loadConfig(), o = cf.onboarding;
+  if (!o || !o.pending || o.computer) return o || null;
+  let isPaired = false; try { isPaired = paired(); } catch {}
+  if (!isPaired) o.step = "computer";
+  o.computer = true; saveConfig(cf); return o;
+}
 function onboarding({ fresh = false } = {}) {
-  const cfg = loadConfig(), o = cfg.onboarding || {};
+  const cfg = loadConfig(), o = cfg.onboarding || {}, steps = onbSteps();
   const tryOr = (f, d) => { try { return f(); } catch { return d; } };
   let st = null; try { st = claudeState(fresh); } catch {}
   const r = tryOr(() => resolveProvider(), null);
@@ -736,7 +782,9 @@ function onboarding({ fresh = false } = {}) {
     ...(reach && reach.sites && reach.sites[x.id] ? { agents: !!reach.sites[x.id].ready, connector: reach.sites[x.id].name } : {}) }));
   const det = tryOr(() => detectHandoffs(), { agents: [] }), cmd = tryOr(() => handoffCmd(), "");
   return {
-    pending: !!o.pending, step: ONB_STEPS.includes(o.step) ? o.step : "welcome", steps: ONB_STEPS,
+    pending: !!o.pending, step: steps.includes(o.step) ? o.step : steps[0], steps,
+    phone: tryOr(() => { const p = PHONE ? computerView() : linkState(); return PHONE ? { role: "phone", paired: !!p.paired, name: p.name || "", ...(p.error ? { error: p.error } : {}) }
+      : { role: "computer", on: p.on, listening: p.listening, ...(p.error ? { error: p.error } : {}), code: p.code || "", until: p.until || 0, link: p.link || "", qr: p.qr || "", addresses: p.addresses || [], port: p.port, phones: (p.phones || []).map((x) => x.name) }; }, null),
     ai: { connected: !!r, provider: r ? r.provider : "", line: r ? `${PROVIDERS[r.provider].label}${r.model ? " · " + r.model : ""}` : "", claude: tryOr(() => claudeSetup(), st ? { installed: st.installed, signedIn: st.signedIn } : null) },
     work: { searching: reps.searching, at: reps.at || 0, done: reps.done || 0, total: reps.total || 0, count: reps.list.length, repos: reps.list.slice(0, 60).map((x) => ({ name: x.name, path: x.path })), roots: tryOr(() => scanRoots(), []).map((r) => (r === homedir() ? "~" : r.startsWith(homedir() + "/") ? "~" + r.slice(homedir().length) : r)) },
     agent: { cmd, pick: tryOr(() => pickAgent(), null), agents: (det.agents || []).map((a) => ({ label: a.label, tmpl: a.tmpl })) },
@@ -747,8 +795,8 @@ function onboarding({ fresh = false } = {}) {
 // step: where you are; skip / unskip: an app you do or don't use; skipRest: every app not connected.
 function setOnboarding({ step, skip, unskip, skipRest, done, restart } = {}) {
   const cfg = loadConfig(), o = { ...(cfg.onboarding || {}) }, sk = new Set(o.skipped || []);
-  if (restart) { o.pending = true; o.step = "welcome"; }
-  if (step && ONB_STEPS.includes(step)) o.step = step;
+  if (restart) { o.pending = true; o.step = onbSteps()[0]; }
+  if (step && onbSteps().includes(step)) o.step = step;
   if (skip) sk.add(String(skip)); if (unskip) sk.delete(String(unskip));
   if (skipRest) { try { for (const x of linksState().items) if (x.state === "off") sk.add(x.id); } catch {} }
   o.skipped = [...sk];
@@ -757,4 +805,4 @@ function setOnboarding({ step, skip, unskip, skipRest, done, restart } = {}) {
   return onboarding();
 }
 
-export { reportIdeasAdd, reportAsk, reportDraftAnswer, workTick, waitWhy, AUTO_GRACE, STUCK_AFTER, marketingState, marketingGo, marketingDraftAnswer, marketingTask, moveToMarketing, goLane, homeState, homeContext, homeAsk, homeAnswer, homeNext, nextUp, laneNamed, NEXT_FILE, workScene, workGo, displayName, firstSteps, onboarding, setOnboarding, ONB_STEPS };
+export { reportIdeasAdd, reportAsk, reportDraftAnswer, workTick, waitWhy, AUTO_GRACE, STUCK_AFTER, marketingState, marketingGo, marketingDraftAnswer, marketingTask, moveToMarketing, goLane, homeState, homeContext, homeAsk, homeAnswer, homeNext, nextUp, laneNamed, NEXT_FILE, workScene, workGo, displayName, firstSteps, onboarding, setOnboarding, startOnboarding, ONB_STEPS, ONB_STEPS_PHONE, onbSteps, phoneBits , phoneSetupFirst };