symbiot 0.57.0 → 0.57.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.57.2
+
+- **No more "Show me your work" when you've already said.** On a big home folder the search for your projects could run out of time and come back empty, so Home asked where your repos were. Repos found before the cut-off are now kept, a short search keeps the repos the last one found, the folders you set in Settings count as your answer, and your main checkout stays a lane even when a worktree is fresher. Tool installs like `~/.nvm` and `~/.rustup` are no longer taken for projects.
+
+## 0.57.1
+
+- **Windows is tested on every change.** A Windows job runs on GitHub with each pull request: Symbiot has to install, start, open into setup, find your Claude subscription and uninstall cleanly there, or the change doesn't go in. The whole suite runs there too and reports what isn't Windows-ready yet.
+- **Your Claude subscription on Windows.** Claude Code installs as `claude.cmd` on Windows, which Symbiot didn't find, so it fell back to asking for a key. And Symbiot's instructions now reach Claude Code in a file instead of on the command line, which Windows caps at about 8,000 characters.
+- **`symbiot --version` and `symbiot --help` work.** Both ran the weekly write-up instead.
+
 ## 0.57.0
 
 - **Setup, before anything else.** A new Symbiot opens straight into setup: what it is (it watches, it works, it asks), your AI (your Claude subscription, found by itself), your work (your projects, found while you read), your coding agent (one click), every app you use (each connected, or marked "I don't use it"; you can't go on until they're all decided), and an optional folder of your documents. Then a short "finding your way" and Home. Where you are is kept, so closing it resumes there; Settings → Setup → Run setup again walks it again.

package/ai.mjs

@@ -4,7 +4,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { spawn, spawnSync } from "node:child_process";
 import { homedir, totalmem, cpus as oscpus } from "node:os";
 import { join } from "node:path";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { loadConfig, saveConfig, sh, hasCmd, CONFIG_DIR } from "./core.mjs";
 
 const MAX_TOKENS = 1600;
@@ -26,13 +26,33 @@ const PROVIDERS = {
 // agents. Whether it's there and signed in: `claude auth status` (a quarter of a
 // second), kept 5 minutes. SYMBIOT_CLAUDE_CMD replaces the command (the tests' stand-in).
 const CLAUDE_BIN = () => process.env.SYMBIOT_CLAUDE_CMD || "claude";
+// How to run it. Windows: npm installs `claude` as claude.cmd, which Node can only
+// start through cmd.exe (a .exe, from Claude's own installer, it starts directly), so
+// it's found with `where` and its arguments are quoted for cmd.exe.
+const winQuote = (a) => '"' + String(a).replace(/"/g, '""') + '"';
+function claudeCommand(platform = process.platform) {
+  const bin = CLAUDE_BIN();
+  if (platform !== "win32") return { file: bin, shell: false };
+  if (/\.exe$/i.test(bin)) return { file: bin, shell: false };
+  if (/\.(cmd|bat)$/i.test(bin)) return { file: bin, shell: true };
+  try {
+    const hits = String(spawnSync("where", [bin], { encoding: "utf8", timeout: 5000 }).stdout || "").split(/\r?\n/).map((x) => x.trim()).filter(Boolean);
+    const exe = hits.find((h) => /\.exe$/i.test(h)); if (exe) return { file: exe, shell: false };
+    const cmd = hits.find((h) => /\.(cmd|bat)$/i.test(h)); if (cmd) return { file: cmd, shell: true };
+  } catch {}
+  return { file: bin, shell: true };
+}
+function claudeSpawn(args, opts = {}, sync = false) {
+  const c = claudeCommand(), run = sync ? spawnSync : spawn;
+  return c.shell ? run([c.file, ...args].map(winQuote).join(" "), [], { ...opts, shell: true, windowsHide: true }) : run(c.file, args, { ...opts, windowsHide: true });
+}
 let CLAUDE_SEEN = null;
 function claudeState(fresh = false) {
   if (!fresh && CLAUDE_SEEN && Date.now() - CLAUDE_SEEN.at < 300000) return CLAUDE_SEEN;
   let installed = !!process.env.SYMBIOT_CLAUDE_CMD || hasCmd("claude"), signedIn = false;
   if (installed) {
     try {
-      const r = spawnSync(CLAUDE_BIN(), ["auth", "status"], { encoding: "utf8", timeout: 8000, env: process.env });
+      const r = claudeSpawn(["auth", "status"], { encoding: "utf8", timeout: 8000, env: process.env }, true);
       if (r.error && r.error.code === "ENOENT") installed = false;
       else { const j = JSON.parse(String(r.stdout || "").trim() || "{}"); signedIn = !!j.loggedIn && j.authMethod !== "apiKey"; }
     } catch {}
@@ -83,7 +103,8 @@ function resolveProvider() {
 
 // ---- model calls (one per provider, same in/out) --------------------------
 // Claude Code, headless, on your subscription: Symbiot's own instructions as the
-// system prompt, the prompt on stdin, no tools (Read only, for screenshots you
+// system prompt (from a file: Windows' command line holds only ~8,000 characters,
+// and they run longer), the prompt on stdin, no tools (Read only, for screenshots you
 // attached), none of your settings, plugins or servers, no session kept. Not --bare:
 // that ignores the subscription sign-in.
 function callClaude(r, system, prompt, images = []) {
@@ -93,15 +114,18 @@ function callClaude(r, system, prompt, images = []) {
     try { const dir = join(CONFIG_DIR, "uploads"); mkdirSync(dir, { recursive: true, mode: 0o700 }); const f = join(dir, `${Date.now()}-${shots.length}.${/png/.test(i.mime) ? "png" : /webp/.test(i.mime) ? "webp" : /gif/.test(i.mime) ? "gif" : "jpg"}`); writeFileSync(f, Buffer.from(i.data, "base64"), { mode: 0o600 }); shots.push(f); } catch {}
   }
   const input = shots.length ? `${prompt}\n\nScreenshots they attached (look at them with your Read tool): ${shots.join(", ")}` : prompt;
-  const args = ["-p", "--output-format", "json", "--system-prompt", system, "--tools", shots.length ? "Read" : "", "--setting-sources", "",
+  let sysFile = ""; try { mkdirSync(CONFIG_DIR, { recursive: true }); sysFile = join(CONFIG_DIR, `.system-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`); writeFileSync(sysFile, system, { mode: 0o600 }); } catch { sysFile = ""; }
+  const drop = () => { if (sysFile) { try { unlinkSync(sysFile); } catch {} } };
+  const args = ["-p", "--output-format", "json", ...(sysFile ? ["--system-prompt-file", sysFile] : ["--system-prompt", system]), "--tools", shots.length ? "Read" : "", "--setting-sources", "",
     "--strict-mcp-config", "--no-session-persistence", "--disable-slash-commands", ...(r.model ? ["--model", r.model] : [])];
   return new Promise((resolve, reject) => {
     let out = "", err = "", done = false;
-    let ch; try { ch = spawn(CLAUDE_BIN(), args, { cwd: CONFIG_DIR, stdio: ["pipe", "pipe", "pipe"], env: process.env }); } catch (e) { reject(e); return; }
+    let ch; try { ch = claudeSpawn(args, { cwd: CONFIG_DIR, stdio: ["pipe", "pipe", "pipe"], env: process.env }); } catch (e) { drop(); reject(e); return; }
     const t = setTimeout(() => { if (!done) { done = true; try { ch.kill("SIGTERM"); } catch {} reject(new Error("Claude Code didn't answer within 3 minutes")); } }, 180000);
     ch.stdout.on("data", (d) => { out += d; }); ch.stderr.on("data", (d) => { err += d; });
-    ch.on("error", (e) => { if (!done) { done = true; clearTimeout(t); reject(e); } });
+    ch.on("error", (e) => { drop(); if (!done) { done = true; clearTimeout(t); reject(e); } });
     ch.on("close", () => {
+      drop();
       if (done) return; done = true; clearTimeout(t);
       let j = null; try { j = JSON.parse(out.trim().split("\n").filter(Boolean).pop() || "{}"); } catch {}
       if (j && j.is_error === false && typeof j.result === "string") { resolve(j.result.trim()); return; }
@@ -284,4 +308,4 @@ async function connectProvider(b) {
   return saveConfig(cfg) ? { ok: true, message: `Connected: ${PROVIDERS[provider].label} · ${model}` } : { ok: false, message: "Couldn't write the config file." };
 }
 
-export { PROVIDERS, AI_UI, resolveProvider, write, validate, connectProvider, detectHardware, recommendModels, hasOllama, ollamaInstall, ensureOllama, useOllamaModel , claudeState, claudeReady, claudeHelp };
+export { PROVIDERS, AI_UI, resolveProvider, write, validate, connectProvider, detectHardware, recommendModels, hasOllama, ollamaInstall, ensureOllama, useOllamaModel , claudeState, claudeReady, claudeHelp , claudeCommand };

package/home.mjs

@@ -256,6 +256,7 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   // Marketing, a lane of its own across products: its orb, lit when something there needs you
   const marketing = deps.marketing || ((o) => { try { const m = marketingState(o); return m.on ? { needs: m.needCount, working: m.working, waiting: m.waiting } : false; } catch { return false; } });
   const named = deps.name || displayName;
+  const rootsSet = deps.rootsSet || (() => { try { const r = loadConfig().scanRoots; return Array.isArray(r) && r.length > 0; } catch { return false; } });
   const you = [], map = repos() || {};
   // What Symbiot works through (an AI, your agent, the connectors runs use) shows
   // only when it's missing, and then first (urgent): nothing works without it.
@@ -263,7 +264,9 @@ function homeState({ now = Date.now(), fresh = false, deps = {} } = {}) {
   if (!connected()) you.push({ kind: "setup", id: "setup:ai", urgent: true, title: "Connect an AI", sub: "Symbiot can't work without one: your Claude subscription (sign in to Claude Code), a key, or a free local model", shape: "settings", focus: "ai" });
   const gone = agentGone(); if (gone) you.push({ kind: "setup", id: "setup:agent", urgent: true, title: "Your agent is unavailable", sub: `${gone} isn't on this computer any more, so no task can start`, shape: "settings", focus: "agent" });
   for (const c of signedOut()) you.push({ kind: "setup", id: "setup:conn:" + c.id, urgent: true, title: `Reconnect ${c.name}`, sub: `its Claude connector is signed out, so agent runs can't use ${c.name}`, shape: "settings", focus: "agent" });
-  if (!Object.keys(map).some((n) => map[n] !== MARKETING_DIR)) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings", focus: "work" });
+  // Folders you set in Settings (scanRoots) are your answer already: a search that finds
+  // nothing in them (or is cut short) is Symbiot's to retry, never a card asking again.
+  if (!rootsSet() && !Object.keys(map).some((n) => map[n] !== MARKETING_DIR)) you.push({ kind: "setup", id: "setup:folders", title: "Show me your work", sub: "where your repos are", shape: "settings", focus: "work" });
   // no agent yet: Send to repos and Go would only write TASKS.md files nothing runs, so
   // Home didn't say "All handled" truthfully. One click for the one on this computer.
   if (!agentCmd()) { const p = offer(); you.push({ kind: "setup", id: "setup:pick", title: "Pick your agent", sub: p ? `${p.name} is on this computer: one click and it takes your tasks` : "the coding agent that takes your tasks", shape: "settings", focus: "agent", ...(p ? { pick: { name: p.name, tmpl: p.tmpl } } : {}) }); }

package/index.mjs

@@ -49,7 +49,8 @@ import { knowledgeState, addKnowledgeFolder, removeKnowledgeFolder, indexKnowled
 
 // ---- tiny arg parse --------------------------------------------------------
 const argv = process.argv.slice(2);
-const cmd = (argv[0] && !argv[0].startsWith("-") ? argv[0] : "week").toLowerCase();
+// a first word that's a flag means the default (week), except asking for help or the version
+const cmd = (argv[0] && (!argv[0].startsWith("-") || ["--help", "-h", "--version", "-v"].includes(argv[0])) ? argv[0] : "week").toLowerCase();
 const flag = (name, def) => {
   const i = argv.indexOf(`--${name}`);
   return i >= 0 && argv[i + 1] ? argv[i + 1] : def;
@@ -812,6 +813,7 @@ ${c.b("Usage")}
   symbiot standup                   yesterday + today, for standup
   symbiot todo                      what's still on your plate
   symbiot app                       open the visual app in your browser
+  symbiot --version                 which Symbiot this is
   symbiot open                      start Symbiot in the background and open its window
                                     (what its app-menu icon does)
   symbiot uninstall [--keep-data]   remove Symbiot and everything it added
@@ -868,6 +870,7 @@ ${c.d("local Ollama model).")}`;
 // ---- main -----------------------------------------------------------------
 async function main() {
   if (cmd === "help" || cmd === "--help" || cmd === "-h") { console.log(HELP); return; }
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") { console.log(VERSION); return; }
   if (cmd === "login" || cmd === "auth") return cmdLogin();
   if (cmd === "logout") return cmdLogout();
   if (cmd === "whoami" || cmd === "status") return cmdWhoami();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbiot",
-  "version": "0.57.0",
+  "version": "0.57.2",
   "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice \u2014 Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {
@@ -80,7 +80,7 @@
     "@anthropic-ai/sdk": "^0.128.0"
   },
   "scripts": {
-    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/checks.mjs &&node test/lanes.mjs && node test/handback.mjs && node test/autoallow.mjs && node test/guard.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/away.mjs && node test/subscription.mjs && node test/launcher.mjs && node test/onboarding.mjs && node test/marketing.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
+    "test": "node test/load.mjs && node test/fixtures.mjs && node test/links.mjs && node test/post.mjs && node test/peek.mjs && node test/mind.mjs && node test/knowledge.mjs && node test/checks.mjs &&node test/lanes.mjs && node test/handback.mjs && node test/autoallow.mjs && node test/guard.mjs && node test/reports.mjs && node test/sandbox.mjs && node test/adapt.mjs && node test/work.mjs && node test/mapknn.mjs && node test/away.mjs && node test/subscription.mjs && node test/launcher.mjs && node test/onboarding.mjs && node test/windows.mjs && node test/marketing.mjs && node test/paths.mjs && node test/smoke.mjs && node test/app.mjs && node test/install.mjs",
     "lint": "eslint .",
     "postinstall": "node postinstall.mjs"
   },

package/scan.mjs

@@ -57,20 +57,29 @@ function scanDraw() {
 }
 // Run `find` directly (no shell, no pipe): a timeout then kills find itself
 // rather than a shell whose piped children keep running, and whatever it found
-// before the timeout is kept instead of discarded.
-function findPaths(args, limit) {
-  const timeout = SCAN.active ? Math.max(1000, Math.min(FIND_TIMEOUT_MS, SCAN.deadline - Date.now())) : FIND_TIMEOUT_MS;
-  const r = spawnSync("find", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024, timeout, killSignal: "SIGKILL" });
+// before the timeout is kept instead of discarded. Kept only if find wrote it out:
+// writing to a pipe, GNU find holds its output in a 4 KB buffer, so a kill threw
+// every repo away (a home folder that took 21s gave 0 repos, and Home then asked
+// the user where their repos were). stdbuf -oL makes it write each line as found.
+let STDBUF = null;
+const hasStdbuf = () => (STDBUF === null ? (STDBUF = spawnSync("stdbuf", ["--version"], { stdio: "ignore" }).status === 0) : STDBUF);
+function findPaths(args, limit, cap = FIND_TIMEOUT_MS) {
+  const timeout = SCAN.active ? Math.max(1000, Math.min(cap, SCAN.deadline - Date.now())) : cap;
+  const [cmd, argv] = hasStdbuf() ? ["stdbuf", ["-oL", "find", ...args]] : ["find", args];
+  const r = spawnSync(cmd, argv, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024, timeout, killSignal: "SIGKILL" });
   if (r.error && r.error.code !== "ETIMEDOUT") return [];
   if (r.error && SCAN.active) SCAN.partial = true;
   return String(r.stdout || "").split("\n").filter(Boolean).slice(0, limit);
 }
-const PRUNE = ["node_modules", ".cache", ".local", ".npm", "venv", ".venv", ".gradle", "Pods"];
+// Tool installs that are git checkouts (~/.nvm, ~/.rustup…) aren't your projects: a lane for
+// them is a lane nobody works in.
+const PRUNE = ["node_modules", ".cache", ".local", ".npm", "venv", ".venv", ".gradle", "Pods", ".nvm", ".rustup", ".cargo", ".pyenv", ".oh-my-zsh"];
 const anyName = (names) => ["(", ...names.flatMap((n, i) => (i ? ["-o", "-name", n] : ["-name", n])), ")"];
 // find .git dirs quickly by PRUNING heavy trees (node_modules etc.) instead of
-// crawling into them — this is the big speedup for the map scan.
+// crawling into them — this is the big speedup for the map scan. Finding the repos
+// is what the scan is for, so this walk gets the scan's whole budget, not one walk's.
 function findGitDirs(base, limit) {
-  return findPaths([base, "-maxdepth", "7", ...anyName([...PRUNE, ".git-crypt"]), "-prune", "-o", "-name", ".git", "-print"], limit);
+  return findPaths([base, "-maxdepth", "7", ...anyName([...PRUNE, ".git-crypt"]), "-prune", "-o", "-name", ".git", "-print"], limit, SCAN_TIMEOUT_MS);
 }
 function me() {
   return { email: sh("git config --global user.email").trim(), name: sh("git config --global user.name").trim() };
@@ -299,18 +308,24 @@ function loadRepoCache() {
 function refreshRepos({ worker = true } = {}) {
   if (REPO_JOB) return REPO_JOB;
   REPO_STATE.searching = true; Object.assign(REPO_STATE, { done: 0, total: 0, phase: "" });
-  const finish = (list) => {
-    REPO_CACHE = { at: Date.now(), list: Array.isArray(list) ? list : [] }; REPO_STATE.at = REPO_CACHE.at; REPO_STATE.searching = false; REPO_JOB = null; LAST_MAP = null;
+  const finish = (list, partial = false) => {
+    list = Array.isArray(list) ? list : [];
+    // A search cut short by its deadline found less than is there: keep the repos the
+    // last one found that still exist, rather than lose lanes (and ask the user where
+    // their repos are) because a disk was slow this time.
+    if (partial && REPO_CACHE) { const have = new Set(list.map((r) => r.path)); list = [...list, ...REPO_CACHE.list.filter((r) => r && !have.has(r.path) && existsSync(join(r.path, ".git")))]; }
+    REPO_CACHE = { at: Date.now(), list }; REPO_STATE.at = REPO_CACHE.at; REPO_STATE.searching = false; REPO_JOB = null; LAST_MAP = null;
     try { mkdirSync(join(repoFile(), ".."), { recursive: true }); writeFileSync(repoFile(), JSON.stringify(REPO_CACHE), { mode: 0o600 }); } catch {}
     try { if (REPO_STATE.onChange) REPO_STATE.onChange(REPO_CACHE.list); } catch {}
     return REPO_CACHE.list;
   };
-  if (!worker) { const was = OPTS.cache; OPTS.cache = false; let l = []; try { l = findAllRepos(); } finally { OPTS.cache = was; } return Promise.resolve(finish(l)); }
+  loadRepoCache();
+  if (!worker) { const was = OPTS.cache; OPTS.cache = false; let l = []; try { l = findAllRepos(); } finally { OPTS.cache = was; } return Promise.resolve(finish(l, SCAN.partial)); }
   REPO_JOB = new Promise((resolve) => {
     let w; try { w = new Worker(new URL("./scanworker.mjs", import.meta.url)); } catch { const was = OPTS.cache; OPTS.cache = false; let l = []; try { l = findAllRepos(); } finally { OPTS.cache = was; } resolve(finish(l)); return; }
-    let got = null;
-    w.on("message", (m) => { if (m && m.progress) Object.assign(REPO_STATE, m.progress); if (m && m.list) got = m.list; });
-    w.on("error", () => {}); w.on("exit", () => resolve(finish(got || (REPO_CACHE && REPO_CACHE.list) || [])));
+    let got = null, partial = false;
+    w.on("message", (m) => { if (m && m.progress) Object.assign(REPO_STATE, m.progress); if (m && m.list) { got = m.list; partial = !!m.partial; } });
+    w.on("error", () => {}); w.on("exit", () => resolve(finish(got || (REPO_CACHE && REPO_CACHE.list) || [], partial || !got)));
   });
   return REPO_JOB;
 }
@@ -339,15 +354,25 @@ function findAllRepos(base) {
         if (last) repos.push({ path: repo, name: repo.split("/").pop(), recency: last });
       }
     }
-    // Group worktrees by shared git dir; keep only the freshest checkout of each.
+    // Group worktrees by shared git dir: the main checkout is always a lane (it's
+    // where the project lives: dropping it for a fresher worktree lost the lane), plus
+    // the freshest worktree kept outside it (one inside it, like .claude/worktrees,
+    // is an agent's scratch copy, not a place of its own).
     // (Not deadline-bound: it's what makes the result correct, and it's cheap.)
     const byCommon = {};
     for (const r of repos) {
-      const cd = sh(`git -C ${JSON.stringify(r.path)} rev-parse --git-common-dir 2>/dev/null`).trim() || r.path;
+      const cd = sh(`git -C ${JSON.stringify(r.path)} rev-parse --git-common-dir 2>/dev/null`).trim() || join(r.path, ".git");
       const key = cd.startsWith("/") ? cd : join(r.path, cd);
-      if (!byCommon[key] || byCommon[key].recency < r.recency) byCommon[key] = r;
+      const g = byCommon[key] || (byCommon[key] = { main: null, trees: [] });
+      if (key === join(r.path, ".git")) g.main = r; else g.trees.push(r);
     }
-    return Object.values(byCommon).sort((a, b) => b.recency - a.recency).slice(0, 60);
+    const kept = [];
+    for (const { main, trees } of Object.values(byCommon)) {
+      if (main) kept.push(main);
+      const tree = trees.filter((t) => !(main && t.path.startsWith(main.path + "/"))).sort((a, b) => b.recency - a.recency)[0];
+      if (tree) kept.push(tree);
+    }
+    return kept.sort((a, b) => b.recency - a.recency).slice(0, 60);
   } finally { scanEnd(own); }
 }
 // What a project is about, in its own words: its package description and keywords

package/scanworker.mjs

@@ -9,4 +9,4 @@ const tick = setInterval(() => { const s = scan.SCAN; parentPort.postMessage({ p
 let list = [];
 try { list = scan.findAllRepos(); } catch {}
 clearInterval(tick);
-parentPort.postMessage({ list });
+parentPort.postMessage({ list, partial: scan.SCAN.partial });