@frod.io/bridge 0.7.5 → 0.7.6

package/README.md

@@ -145,9 +145,10 @@ says the same). When the desk is clear, it swaps `current` atomically, logs
 `bridge.updated {from, to}`, and restarts through the supervisor: it exits
 with code 75, a non-zero exit that launchd's `KeepAlive SuccessfulExit=false`
 and systemd's `Restart=on-failure` both bring straight back up — a clean exit
-(code 0) is deliberately a final goodbye, not a restart signal. Windows'
-scheduled task has no restart-on-failure, so there the bridge relaunches the
-new version itself, detached; if that fails, the next logon starts it.
+(code 0) is deliberately a final goodbye, not a restart signal. On Windows the
+logon task carries the same rule (`RestartOnFailure`, three tries a minute
+apart), and the bridge also relaunches the new version itself, detached and
+with no console window; if that fails, the next logon starts it.
 
 The keychain item is never touched by an update. You'll see `Updated to <v>`
 in `~/.frod/bridge.log` and the new version on the computer card. Two
@@ -258,12 +259,57 @@ Never-ask policy as the others. Each adapter is one file.
   unit is written correctly, but `systemctl --user` doesn't exist in a
   container, so the manual command is printed instead. Not yet proven on a
   real Linux machine.
-- **Windows** — a scheduled task *Frod.io bridge* at logon
-  (`schtasks /Create`), also pointing at `current`. If it refuses, the exact
-  command is printed. Not yet proven on a real Windows machine.
+- **Windows** — a logon task *Frod.io bridge*, registered from a task
+  definition (`schtasks /Create /XML`, written to `~/.frod/bridge-task.xml`)
+  and pointing at `current` through `~/.frod/bridge-hidden.vbs`, a launcher
+  that starts the bridge with **no window** and appends its output to
+  `~/.frod/bridge.log`. The definition also says what the command line cannot:
+  hidden, no 72-hour execution limit, indifferent to battery, restart after a
+  crash. A real Windows *service* would run as SYSTEM while the runtime CLIs
+  are signed in as the person, so a logon task — the equivalent of the macOS
+  user agent — is deliberate. If the definition is refused, the plain
+  `schtasks /Create /TR` form is still tried (it works, and it shows a console
+  window), and the exact commands are printed. Not yet proven on a real
+  Windows machine.
+
+Finding the runtimes on Windows needs no hand configuration either: `claude`,
+`codex` and `grok` are looked for in npm's global folder (`%APPDATA%\npm`),
+`~/.local/bin`, the per-tool folders and `%LOCALAPPDATA%\Programs`, with
+`.exe`, `.cmd` and `.bat` tried in that order, then `where.exe`. An npm
+`.cmd` shim cannot be spawned without a shell (CVE-2024-27980), so the shim is
+read and the JavaScript entry it names is started with the bridge's own node —
+which also keeps Claude Code's system prompt out of a cmd.exe command line and
+its ~8 KB limit. `FROD_CLAUDE_PATH` / `FROD_CODEX_PATH` / `FROD_GROK_PATH`
+still override everything, on every OS.
 
 ## Changelog
 
+### 0.7.6
+
+- **Windows, without hand configuration.** The runtimes are found where Windows
+  actually puts them (npm's global folder, `~/.local/bin`, the per-tool folders,
+  then `where.exe`) instead of only Unix paths and a `/usr/bin/which` that does
+  not exist there — no `FROD_*_PATH` to set by hand. An npm `.cmd` shim is read
+  and its JavaScript entry started with our own node, because Node refuses to
+  spawn a `.cmd` without a shell and a cmd.exe command line cannot carry an
+  agent's system prompt.
+- **Windows, without a window.** The logon task is registered from a task
+  definition and runs a launcher that starts the bridge hidden and logs to
+  `~/.frod/bridge.log` — so there is no console window a person can close and
+  kill the bridge with. The definition also turns off the 72-hour execution
+  limit and the stop-on-battery default, and turns on restart-after-crash. The
+  old command-line form remains the fallback. Not yet proven on real Windows
+  hardware.
+- **A computer's desk is sized by its memory**, not fixed at two sessions: the
+  ceiling is what memory allows after a 4 GB reserve at 200 MB a session, and
+  the default is 30 or that ceiling, whichever is smaller. A computer joined
+  before this is raised once, and a number a person chose is never overruled.
+- **Capacity reads Claude Code's Keychain item by account**, as Claude Code
+  writes it, so a Mac that is signed in is no longer reported signed out
+  because of a stray item; a failed read now says why.
+- Per-turn usage on Codex and Grok Build is billed as the increment, not the
+  running session total.
+
 ### 0.7.4 — unreleased
 
 - `join` is runtime-neutral: it admits a computer when at least one of Claude

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// @frod.io/bridge 0.7.5. One file; do not edit: the source is apps/bridge/src in the platform repository.
+// @frod.io/bridge 0.7.6. One file; do not edit: the source is apps/bridge/src in the platform repository.
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 var __create = Object.create;
@@ -3705,10 +3705,10 @@ var require_websocket_server = __commonJS({
 });
 
 // src/cli.ts
-import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, realpathSync as realpathSync4 } from "node:fs";
-import { homedir as homedir7, hostname as hostname2, platform as platform6 } from "node:os";
-import { dirname as dirname5, join as join11, resolve as resolve6 } from "node:path";
+import { execFileSync as execFileSync8 } from "node:child_process";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, realpathSync as realpathSync4 } from "node:fs";
+import { homedir as homedir8, hostname as hostname2, platform as platform6 } from "node:os";
+import { dirname as dirname5, join as join12, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawn as spawn6 } from "node:child_process";
 
@@ -3904,7 +3904,7 @@ function leave(apiUrl, token) {
 
 // src/adapters/claude.ts
 import { spawn, execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync2, existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync2, existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join5 } from "node:path";
 
 // src/adapters/claude-stream.ts
@@ -4184,6 +4184,44 @@ var log = {
   }
 };
 
+// src/win-launch.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { win32 as winPath } from "node:path";
+function defaultLaunchIo() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    node: process.execPath,
+    exists: existsSync4,
+    readFile: (path) => readFileSync4(path, "utf8")
+  };
+}
+var BATCH = /\.(cmd|bat)$/i;
+var SHIM_ENTRY = /%~?dp0%?[\\/]+([^"\s]+\.(?:c|m)?js)/i;
+function shimEntry(shimPath, io = defaultLaunchIo()) {
+  let text;
+  try {
+    text = io.readFile(shimPath);
+  } catch {
+    return null;
+  }
+  const found = SHIM_ENTRY.exec(text)?.[1];
+  if (!found) return null;
+  const entry = winPath.isAbsolute(found) ? found : winPath.resolve(winPath.dirname(shimPath), found);
+  return io.exists(entry) ? entry : null;
+}
+function launchOf(exe, args = [], io = defaultLaunchIo()) {
+  if (io.platform !== "win32" || !BATCH.test(exe)) return { command: exe, args, via: "direct" };
+  const entry = shimEntry(exe, io);
+  if (entry) return { command: io.node, args: [entry, ...args], via: "node-shim" };
+  return {
+    command: io.env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", exe, ...args],
+    via: "cmd",
+    note: `${exe} is a batch shim whose entry could not be read, so it starts through cmd.exe \u2014 where a long system prompt (more than about 8 KB of arguments) fails. Point the FROD_CLAUDE_PATH / FROD_CODEX_PATH / FROD_GROK_PATH override at a .exe if there is one.`
+  };
+}
+
 // src/permission-policy.ts
 import { resolve, isAbsolute, sep, dirname } from "node:path";
 import { realpathSync } from "node:fs";
@@ -4462,7 +4500,7 @@ function cleanEnv(base, extra = {}) {
 var CHILDREN_PATH = join5(FROD_DIR, "children.json");
 function readChildren() {
   try {
-    return existsSync4(CHILDREN_PATH) ? JSON.parse(readFileSync4(CHILDREN_PATH, "utf8")) : [];
+    return existsSync5(CHILDREN_PATH) ? JSON.parse(readFileSync5(CHILDREN_PATH, "utf8")) : [];
   } catch {
     return [];
   }
@@ -4514,8 +4552,12 @@ var ClaudeAdapter = class {
   }
   /** `claude --version`, and whether the CLI says it is signed in. Never throws. */
   static check(claudePath, commands = {}) {
-    const versionCommand = commands.version ?? ((path) => execFileSync2(path, ["--version"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString());
-    const authStatusCommand = commands.authStatus ?? ((path) => execFileSync2(path, ["auth", "status"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString());
+    const run = (path, args) => {
+      const l = launchOf(path, args);
+      return execFileSync2(l.command, l.args, { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString();
+    };
+    const versionCommand = commands.version ?? ((path) => run(path, ["--version"]));
+    const authStatusCommand = commands.authStatus ?? ((path) => run(path, ["auth", "status"]));
     let version;
     try {
       version = versionCommand(claudePath).trim();
@@ -4532,7 +4574,7 @@ var ClaudeAdapter = class {
     }
   }
   async start(spec, o) {
-    if (!existsSync4(o.sessionDir)) mkdirSync2(o.sessionDir, { recursive: true, mode: 448 });
+    if (!existsSync5(o.sessionDir)) mkdirSync2(o.sessionDir, { recursive: true, mode: 448 });
     const stored = spec.resume_session_id ? getStored(spec.session_id) : null;
     const resumeId = spec.resume_session_id && stored?.hostSessionId === spec.resume_session_id ? spec.resume_session_id : null;
     const live = {
@@ -4629,7 +4671,9 @@ var ClaudeAdapter = class {
     if (bytes > ARGV_LIMIT_BYTES) {
       throw new Error(`The agent's instructions are too long to start Claude Code on this computer (${Math.round(bytes / 1024)} KB of arguments; the limit here is about ${Math.round(ARGV_LIMIT_BYTES / 1024)} KB). Shorten its skills or system instructions.`);
     }
-    const child = spawn(this.opts.claudePath, args, {
+    const launch = launchOf(this.opts.claudePath, args);
+    if (launch.note) log.warn(launch.note);
+    const child = spawn(launch.command, launch.args, {
       cwd: live.sessionDir,
       env: cleanEnv(process.env, { ...this.opts.env, ...live.secretEnv }),
       stdio: ["pipe", "pipe", "pipe"]
@@ -5101,9 +5145,13 @@ var CodexAdapter = class _CodexAdapter {
   }
   /** The version and whether somebody is signed in — the same shape ClaudeAdapter.check returns. */
   static check(codexPath, commands = {}) {
-    const versionCommand = commands.version ?? ((path) => execFileSync3(path, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString());
+    const versionCommand = commands.version ?? ((path) => {
+      const l = launchOf(path, ["--version"]);
+      return execFileSync3(l.command, l.args, { stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString();
+    });
     const loginStatusCommand = commands.loginStatus ?? ((path) => {
-      const res = spawnSync(path, ["login", "status"], { encoding: "utf8", timeout: 3e4 });
+      const l = launchOf(path, ["login", "status"]);
+      const res = spawnSync(l.command, l.args, { encoding: "utf8", timeout: 3e4 });
       if (res.error) throw res.error;
       return `${res.stdout ?? ""}${res.stderr ?? ""}`;
     });
@@ -5232,7 +5280,9 @@ var CodexAdapter = class _CodexAdapter {
   // The process and the wire
   // -------------------------------------------------------------------------
   spawnChild(live) {
-    const child = spawn2(this.opts.codexPath, ["app-server"], {
+    const launch = launchOf(this.opts.codexPath, ["app-server"]);
+    if (launch.note) log.warn(launch.note);
+    const child = spawn2(launch.command, launch.args, {
       cwd: live.sessionDir,
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env }
@@ -5506,7 +5556,7 @@ function describeError(err) {
 
 // src/adapters/grok.ts
 import { spawn as spawn3, spawnSync as spawnSync2, execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "node:fs";
 
 // src/adapters/grok-spec.ts
 import { isAbsolute as isAbsolute2, resolve as resolve2, sep as sep2, join as join6 } from "node:path";
@@ -5833,9 +5883,13 @@ var GrokAdapter = class _GrokAdapter {
    */
   static check(grokPath, commands = {}) {
     const env = { ...process.env, GROK_DISABLE_AUTOUPDATER: "1" };
-    const versionCommand = commands.version ?? ((path) => execFileSync4(path, ["--version"], { env, stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString());
+    const versionCommand = commands.version ?? ((path) => {
+      const l = launchOf(path, ["--version"]);
+      return execFileSync4(l.command, l.args, { env, stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString();
+    });
     const modelsCommand = commands.models ?? ((path) => {
-      const res = spawnSync2(path, ["models"], { env, encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
+      const l = launchOf(path, ["models"]);
+      const res = spawnSync2(l.command, l.args, { env, encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
       if (res.error) throw res.error;
       return `${res.stdout ?? ""}
 ${res.stderr ?? ""}`;
@@ -5886,7 +5940,7 @@ ${res.stderr ?? ""}`;
       stderrTail: []
     };
     this.live.set(spec.session_id, live);
-    if (!existsSync5(o.sessionDir)) mkdirSync4(o.sessionDir, { recursive: true, mode: 448 });
+    if (!existsSync6(o.sessionDir)) mkdirSync4(o.sessionDir, { recursive: true, mode: 448 });
     this.spawnChild(live);
     let init;
     try {
@@ -6019,7 +6073,9 @@ ${res.stderr ?? ""}`;
   // The process and the wire
   // -------------------------------------------------------------------------
   spawnChild(live) {
-    const child = spawn3(this.opts.grokPath, grokArgs(live.spec), {
+    const launch = launchOf(this.opts.grokPath, grokArgs(live.spec));
+    if (launch.note) log.warn(launch.note);
+    const child = spawn3(launch.command, launch.args, {
       cwd: live.sessionDir,
       stdio: ["pipe", "pipe", "pipe"],
       env: grokEnv(process.env)
@@ -6228,7 +6284,7 @@ import { hostname, platform as platform2 } from "node:os";
 
 // src/repo.ts
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readdirSync, rmSync, statSync } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync, rmSync, statSync } from "node:fs";
 import { join as join7, resolve as resolve3 } from "node:path";
 var PLATFORM_COMMIT_ENV = {
   GIT_AUTHOR_NAME: "AgentOrchestrator",
@@ -6329,7 +6385,7 @@ async function canReach(gitUrl, timeoutMs = 3e4) {
   return { ok: false, detail: firstLine(r.stderr) || `git exited ${r.code}`, ms: r.ms };
 }
 async function originOf(dir) {
-  if (!existsSync6(join7(dir, ".git"))) return null;
+  if (!existsSync7(join7(dir, ".git"))) return null;
   const r = await git(["-C", dir, "remote", "get-url", "origin"], void 0, { timeoutMs: 1e4 });
   return r.code === 0 ? r.stdout.trim() : null;
 }
@@ -6354,7 +6410,7 @@ async function prepareCheckout(repo, workdir, computerName, log2, opts = {}) {
     throw new Error(`${dir} already holds a different repository (${existing}); not touching it`);
   }
   if (!existing) {
-    if (existsSync6(dir)) rmSync(dir, { recursive: true, force: true });
+    if (existsSync7(dir)) rmSync(dir, { recursive: true, force: true });
     mkdirSync5(resolve3(dir, ".."), { recursive: true, mode: 448 });
     const branchToClone = onOrigin ? repo.branch : repo.default_branch;
     const clone = await git(["clone", "--quiet", "--branch", branchToClone, "--single-branch", "--", repo.git_url, dir], void 0, { timeoutMs: 10 * 6e4 });
@@ -6430,7 +6486,7 @@ function pruneRunDirs(workdir, maxAgeMs = 7 * 24 * 60 * 6e4) {
   let removed = 0;
   for (const sub of ["runs"]) {
     const root = join7(workdir, sub);
-    if (!existsSync6(root)) continue;
+    if (!existsSync7(root)) continue;
     for (const name of readdirSync(root)) {
       const p = resolve3(root, name);
       try {
@@ -6446,7 +6502,7 @@ function pruneRunDirs(workdir, maxAgeMs = 7 * 24 * 60 * 6e4) {
 }
 
 // src/repo-door.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 var DoorCheckouts = class {
   bySession = /* @__PURE__ */ new Map();
   get(sessionId, repositoryId) {
@@ -6525,7 +6581,7 @@ async function handleRepoRequest(req, sessionId, ctx, checkouts) {
   }
   const known = checkouts.get(sessionId, req.repository.id);
   const at = known?.dir ?? dir;
-  if (!existsSync7(at)) throw new Error(`${req.repository.name} is not checked out on ${ctx.computerName} for this session \u2014 call checkout_repository first`);
+  if (!existsSync8(at)) throw new Error(`${req.repository.name} is not checked out on ${ctx.computerName} for this session \u2014 call checkout_repository first`);
   if (req.action === "status") {
     const [branch, head, changed] = await Promise.all([
       git(["-C", at, "symbolic-ref", "--short", "-q", "HEAD"], void 0, { timeoutMs: 1e4 }),
@@ -6543,7 +6599,7 @@ async function handleRepoRequest(req, sessionId, ctx, checkouts) {
 }
 
 // src/workdir.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname2, isAbsolute as isAbsolute3, relative, resolve as resolve4, sep as sep3 } from "node:path";
 function expandHome(p, home = homedir4()) {
@@ -6581,12 +6637,12 @@ function resolveWorkdir(requested, rule, opts = {}) {
   const realAnchor = realpathSync2(anchor);
   const realTarget = resolve4(realAnchor, relative(anchor, abs));
   if (!realRoots.some((root) => under(realTarget, root))) throw new Error(`${refusalWords(rule, home)} (the folder links to a place outside them)`);
-  if (opts.create !== false && !existsSync8(abs)) mkdirSync6(abs, { recursive: true, mode: 448 });
-  return existsSync8(abs) ? realpathSync2(abs) : realTarget;
+  if (opts.create !== false && !existsSync9(abs)) mkdirSync6(abs, { recursive: true, mode: 448 });
+  return existsSync9(abs) ? realpathSync2(abs) : realTarget;
 }
 function deepestExisting(abs) {
   let cur = abs;
-  while (!existsSync8(cur)) {
+  while (!existsSync9(cur)) {
     const parent = dirname2(cur);
     if (parent === cur) return cur;
     cur = parent;
@@ -7076,12 +7132,12 @@ function plainWords(message) {
 
 // src/install.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2 } from "node:fs";
 import { homedir as homedir5, platform as platform4, userInfo } from "node:os";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname4, join as join9, win32 as winPath2 } from "node:path";
 
 // src/updater.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, rmSync as rmSync2, readdirSync as readdirSync2, renameSync, symlinkSync, readFileSync as readFileSync5, lstatSync, realpathSync as realpathSync3, readlinkSync, cpSync, writeFileSync as writeFileSync5, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, rmSync as rmSync2, readdirSync as readdirSync2, renameSync, symlinkSync, readFileSync as readFileSync6, lstatSync, realpathSync as realpathSync3, readlinkSync, cpSync, writeFileSync as writeFileSync5, statSync as statSync2 } from "node:fs";
 import { join as join8, dirname as dirname3, basename, resolve as resolve5, sep as sep4 } from "node:path";
 import { platform as platform3 } from "node:os";
 import { execFileSync as execFileSync5 } from "node:child_process";
@@ -7192,7 +7248,7 @@ function currentVersion(currentLink = CURRENT_LINK) {
 }
 function packageVersionAt(root) {
   try {
-    const pkg = JSON.parse(readFileSync5(join8(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync6(join8(root, "package.json"), "utf8"));
     return pkg.name && pkg.version ? { name: pkg.name, version: pkg.version } : null;
   } catch {
     return null;
@@ -7204,14 +7260,14 @@ function stagePackage(loc, expectedVersion, versionsDir = VERSIONS_DIR) {
   if (pkg.version !== expectedVersion) return { ok: false, reason: `the package at ${loc.packageRoot} is ${pkg.version}, this bridge is ${expectedVersion}` };
   const dest = join8(versionsDir, pkg.version);
   if (loc.installedVersion === pkg.version && safeReal(loc.packageRoot) === safeReal(dest)) return { ok: true, dir: dest, copied: false };
-  if (!existsSync9(join8(loc.packageRoot, "dist", "cli.js"))) {
+  if (!existsSync10(join8(loc.packageRoot, "dist", "cli.js"))) {
     return { ok: false, reason: `${loc.packageRoot} has no dist/cli.js \u2014 run \`npm run build -w @frod.io/bridge\` in the checkout, or run the published package: npx @frod.io/bridge@latest install` };
   }
-  if (existsSync9(join8(dest, "dist", "cli.js"))) return { ok: true, dir: dest, copied: false };
+  if (existsSync10(join8(dest, "dist", "cli.js"))) return { ok: true, dir: dest, copied: false };
   const partial = `${dest}.partial`;
   rmSync2(partial, { recursive: true, force: true });
   mkdirSync7(partial, { recursive: true, mode: 493 });
-  for (const f of ["package.json", "README.md"]) if (existsSync9(join8(loc.packageRoot, f))) cpSync(join8(loc.packageRoot, f), join8(partial, f));
+  for (const f of ["package.json", "README.md"]) if (existsSync10(join8(loc.packageRoot, f))) cpSync(join8(loc.packageRoot, f), join8(partial, f));
   cpSync(join8(loc.packageRoot, "dist"), join8(partial, "dist"), { recursive: true });
   rmSync2(dest, { recursive: true, force: true });
   renameSync(partial, dest);
@@ -7271,7 +7327,7 @@ async function stageRelease(release, opts = {}) {
   const pkg = packageVersionAt(root);
   if (!pkg || pkg.name !== "@frod.io/bridge") return refuse("the tarball is not the @frod.io/bridge package");
   if (pkg.version !== v) return refuse(`the tarball says it is ${pkg.version}, not ${v}`);
-  if (!existsSync9(join8(root, "dist", "cli.js"))) return refuse("the tarball has no dist/cli.js");
+  if (!existsSync10(join8(root, "dist", "cli.js"))) return refuse("the tarball has no dist/cli.js");
   try {
     rmSync2(dest, { recursive: true, force: true });
     renameSync(root, dest);
@@ -7283,7 +7339,7 @@ async function stageRelease(release, opts = {}) {
 }
 function swapCurrent(version, versionsDir = VERSIONS_DIR, currentLink = CURRENT_LINK) {
   const target = join8(versionsDir, version);
-  if (!existsSync9(join8(target, "dist", "cli.js"))) throw new Error(`${target} has no dist/cli.js \u2014 not swapping`);
+  if (!existsSync10(join8(target, "dist", "cli.js"))) throw new Error(`${target} has no dist/cli.js \u2014 not swapping`);
   mkdirSync7(dirname3(currentLink), { recursive: true });
   const tmp = `${currentLink}.tmp-${process.pid}`;
   rmSync2(tmp, { recursive: true, force: true });
@@ -7298,7 +7354,7 @@ function swapCurrent(version, versionsDir = VERSIONS_DIR, currentLink = CURRENT_
 }
 function pruneVersions(opts = {}) {
   const versionsDir = opts.versionsDir ?? VERSIONS_DIR;
-  if (!existsSync9(versionsDir)) return [];
+  if (!existsSync10(versionsDir)) return [];
   const keepSet = new Set([opts.running ?? "", currentVersion(opts.currentLink ?? CURRENT_LINK) ?? ""].filter(Boolean));
   const entries = readdirSync2(versionsDir);
   const versions = entries.filter((e) => SEMVER.test(e)).sort((a, b) => -(compareSemver(a, b) ?? 0));
@@ -7460,17 +7516,22 @@ function xml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function defaultTarget() {
-  return { node: process.execPath, cli: join9(CURRENT_LINK, "dist", "cli.js"), workdir: BRIDGE_DIR, home: homedir5(), frodDir: FROD_DIR, logPath: LOG_PATH };
+  return { node: process.execPath, cli: join9(CURRENT_LINK, "dist", "cli.js"), workdir: BRIDGE_DIR, home: homedir5(), frodDir: FROD_DIR, logPath: LOG_PATH, user: windowsUser() };
+}
+function windowsUser(env = process.env) {
+  const name = env.USERNAME ?? userInfo().username;
+  const domain = env.USERDOMAIN;
+  return domain ? `${domain}\\${name}` : name;
 }
 var realIo = {
   exec: (cmd, args) => {
     execFileSync6(cmd, args, { stdio: "pipe" });
   },
-  writeFile: (path, content, mode) => {
-    writeFileSync6(path, content, { encoding: "utf8", mode });
+  writeFile: (path, content, mode, encoding = "utf8") => {
+    writeFileSync6(path, content, { encoding, mode });
   },
   mkdir: (dir) => {
-    if (!existsSync10(dir)) mkdirSync8(dir, { recursive: true });
+    if (!existsSync11(dir)) mkdirSync8(dir, { recursive: true });
   }
 };
 function renderLaunchdPlist(t) {
@@ -7544,7 +7605,7 @@ function uninstallMacOS() {
     execFileSync6("launchctl", ["bootout", `gui/${uid}/${LAUNCHD_LABEL}`], { stdio: "ignore" });
   } catch {
   }
-  if (existsSync10(plistPath())) {
+  if (existsSync11(plistPath())) {
     unlinkSync2(plistPath());
     return { removed: true };
   }
@@ -7621,12 +7682,96 @@ function uninstallLinux(t = defaultTarget(), io = realIo) {
   } catch (err) {
     detail = `systemctl: ${err instanceof Error ? err.message : String(err)}`;
   }
-  if (existsSync10(path)) {
+  if (existsSync11(path)) {
     unlinkSync2(path);
     return { removed: true, detail };
   }
   return { removed: false, detail };
 }
+function hiddenLauncherPath(t) {
+  return winPath2.join(t.frodDir, "bridge-hidden.vbs");
+}
+function windowsTaskXmlPath(t) {
+  return winPath2.join(t.frodDir, "bridge-task.xml");
+}
+function vbString(s) {
+  return `"${s.replace(/"/g, '""')}"`;
+}
+function renderHiddenLauncher(t) {
+  const command = `cmd /c "${'"'}${t.node}${'"'} ${'"'}${t.cli}${'"'} run >> ${'"'}${t.logPath}${'"'} 2>&1"`;
+  return [
+    `' Frod.io bridge \u2014 started at logon by the scheduled task "` + WINDOWS_TASK + '".',
+    "' No window: the bridge is not something a person can close by accident.",
+    "Dim command",
+    `command = ${vbString(command)}`,
+    'CreateObject("WScript.Shell").Run command, 0, False',
+    ""
+  ].join("\r\n");
+}
+function system32(name, env) {
+  return winPath2.join(env.SystemRoot ?? "C:\\Windows", "System32", name);
+}
+function windowsAction(t, env = process.env) {
+  return { command: system32("wscript.exe", env), args: `//B //NoLogo "${hiddenLauncherPath(t)}"` };
+}
+function renderWindowsTaskXml(t, env = process.env) {
+  const action = windowsAction(t, env);
+  const user = t.user ?? "BUILTIN\\Users";
+  return `\uFEFF<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>${xml("Frod.io bridge \u2014 hosts your agents' sessions on this computer. Starts at logon, runs with no window.")}</Description>
+    <URI>\\${xml(WINDOWS_TASK)}</URI>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xml(user)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xml(user)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>3</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xml(action.command)}</Command>
+      <Arguments>${xml(action.args)}</Arguments>
+      <WorkingDirectory>${xml(t.workdir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+function renderSchtasksXmlArgs(t) {
+  return ["/Create", "/F", "/TN", WINDOWS_TASK, "/XML", windowsTaskXmlPath(t)];
+}
 function renderSchtasksArgs(t) {
   const tr = `"${t.node}" "${t.cli}" run`;
   return ["/Create", "/F", "/TN", WINDOWS_TASK, "/SC", "ONLOGON", "/RL", "LIMITED", "/TR", tr];
@@ -7634,26 +7779,60 @@ function renderSchtasksArgs(t) {
 function windowsManualPath(t) {
   return [
     "To run it at logon, in a command prompt:",
-    `  schtasks ${renderSchtasksArgs(t).map((a) => /\s/.test(a) && !a.startsWith('"') ? `"${a}"` : a).join(" ")}`,
+    `  schtasks /Create /F /TN "${WINDOWS_TASK}" /XML "${windowsTaskXmlPath(t)}"`,
     `  schtasks /Run /TN "${WINDOWS_TASK}"`,
-    `Restart on failure: schtasks cannot set it from the command line \u2014 open Task Scheduler \u2192 "${WINDOWS_TASK}" \u2192 Settings \u2192 "If the task fails, restart every 1 minute" if you want it. A self-update relaunches the bridge itself; if that fails, the next logon starts it.`,
-    `Logs: ${t.logPath} is not written by the Task Scheduler; run \`node "${t.cli}" run\` in a terminal to watch it.`
+    `The task definition and the launcher it runs are written to ${windowsTaskXmlPath(t)} and ${hiddenLauncherPath(t)} whatever happens, so you can register them by hand or open Task Scheduler and import the XML.`,
+    `Without that definition the plain form still works \u2014 schtasks ${renderSchtasksArgs(t).map((a) => /\s/.test(a) && !a.startsWith('"') ? `"${a}"` : a).join(" ")} \u2014 but it shows a console window that ends the bridge when closed, it has no restart on failure, and Windows stops it after 72 hours or when the machine goes on battery.`,
+    `Logs: ${t.logPath}, written by the launcher. A self-update relaunches the bridge itself; if that fails, the next logon starts it.`
   ].join("\n");
 }
-function installWindows(t = defaultTarget(), io = realIo) {
+function installWindows(t = defaultTarget(), io = realIo, env = process.env) {
   const manual = windowsManualPath(t);
+  io.mkdir(t.frodDir);
+  let wrote = true;
+  try {
+    io.writeFile(hiddenLauncherPath(t), renderHiddenLauncher(t), 420);
+    io.writeFile(windowsTaskXmlPath(t), renderWindowsTaskXml(t, env), 420, "utf16le");
+  } catch {
+    wrote = false;
+  }
+  if (wrote) {
+    try {
+      io.exec("schtasks", renderSchtasksXmlArgs(t));
+      try {
+        io.exec("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+      } catch {
+      }
+      return { loaded: true, hidden: true, detail: `scheduled task "${WINDOWS_TASK}" created (at logon, no window, restarts after a crash)`, manual };
+    } catch {
+    }
+  }
   try {
     io.exec("schtasks", renderSchtasksArgs(t));
     try {
       io.exec("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
     } catch {
     }
-    return { loaded: true, detail: `scheduled task "${WINDOWS_TASK}" created (at logon)`, manual };
+    return { loaded: true, hidden: false, detail: `scheduled task "${WINDOWS_TASK}" created (at logon) \u2014 the task definition was refused, so it runs in a console window`, manual };
   } catch (err) {
-    return { loaded: false, detail: `schtasks refused: ${err instanceof Error ? err.message : String(err)}`, manual };
+    return { loaded: false, hidden: false, detail: `schtasks refused: ${err instanceof Error ? err.message : String(err)}`, manual };
+  }
+}
+function windowsTaskLoaded(io = realIo) {
+  try {
+    io.exec("schtasks", ["/Query", "/TN", WINDOWS_TASK]);
+    return true;
+  } catch {
+    return false;
   }
 }
-function uninstallWindows(io = realIo) {
+function uninstallWindows(io = realIo, t = defaultTarget()) {
+  for (const path of [hiddenLauncherPath(t), windowsTaskXmlPath(t)]) {
+    try {
+      if (existsSync11(path)) unlinkSync2(path);
+    } catch {
+    }
+  }
   try {
     io.exec("schtasks", ["/Delete", "/F", "/TN", WINDOWS_TASK]);
     return { removed: true, detail: "task deleted" };
@@ -7665,11 +7844,84 @@ function installStub(t = defaultTarget()) {
   return `Automatic install is not available on ${platform4()}. Run: node "${t.cli}" run`;
 }
 
+// src/runtime-paths.ts
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
+import { homedir as homedir6, platform as osPlatform } from "node:os";
+import { join as join10, win32 as winPath3 } from "node:path";
+var ENV_OVERRIDE = {
+  claude: "FROD_CLAUDE_PATH",
+  codex: "FROD_CODEX_PATH",
+  grok: "FROD_GROK_PATH"
+};
+var WINDOWS_EXTENSIONS = [".exe", ".cmd", ".bat"];
+function posixCandidates(name, home) {
+  const dirs = [join10(home, ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"];
+  if (name === "grok") dirs.splice(1, 0, join10(home, ".grok", "bin"));
+  return dirs.map((d) => join10(d, name));
+}
+function windowsCandidates(name, home, env) {
+  const appData = env.APPDATA ?? winPath3.join(home, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA ?? winPath3.join(home, "AppData", "Local");
+  const dirs = [
+    winPath3.join(appData, "npm"),
+    winPath3.join(localAppData, "npm"),
+    winPath3.join(home, ".local", "bin"),
+    winPath3.join(home, `.${name}`, "bin"),
+    winPath3.join(localAppData, "Programs", name),
+    winPath3.join(localAppData, name, "bin")
+  ];
+  const out = [];
+  for (const dir of dirs) for (const ext of WINDOWS_EXTENSIONS) out.push(winPath3.join(dir, `${name}${ext}`));
+  return out;
+}
+function findOnWindowsPath(command, env = process.env) {
+  const whereExe = winPath3.join(env.SystemRoot ?? "C:\\Windows", "System32", "where.exe");
+  for (const tool of [whereExe, "where.exe"]) {
+    try {
+      const lines = execFileSync7(tool, [command], { stdio: ["ignore", "pipe", "ignore"], timeout: 1e4 }).toString().split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      if (lines.length === 0) return null;
+      for (const ext of WINDOWS_EXTENSIONS) {
+        const hit = lines.find((l) => l.toLowerCase().endsWith(ext));
+        if (hit) return hit;
+      }
+      return lines[0];
+    } catch {
+    }
+  }
+  return null;
+}
+function findOnPosixPath(command) {
+  try {
+    const found = execFileSync7("/usr/bin/which", [command], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    return found || null;
+  } catch {
+    return null;
+  }
+}
+function defaultLookup() {
+  const platform7 = osPlatform();
+  return {
+    platform: platform7,
+    env: process.env,
+    home: homedir6(),
+    exists: existsSync12,
+    onPath: (command) => platform7 === "win32" ? findOnWindowsPath(command, process.env) : findOnPosixPath(command)
+  };
+}
+function findRuntime(name, lookup = defaultLookup()) {
+  const override = lookup.env[ENV_OVERRIDE[name]];
+  if (override && lookup.exists(override)) return override;
+  const candidates = lookup.platform === "win32" ? windowsCandidates(name, lookup.home, lookup.env) : posixCandidates(name, lookup.home);
+  for (const c of candidates) if (lookup.exists(c)) return c;
+  return lookup.onPath(name);
+}
+
 // src/capacity.ts
 import { execFile, spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync11, mkdtempSync, readFileSync as readFileSync6 } from "node:fs";
-import { homedir as homedir6, platform as platform5, tmpdir as tmpdir2 } from "node:os";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync13, mkdtempSync, readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir7, platform as platform5, tmpdir as tmpdir2, userInfo as userInfo2 } from "node:os";
+import { join as join11 } from "node:path";
 import { createInterface } from "node:readline";
 var SAMPLE_INTERVAL_MS = 30 * 6e4;
 var READER_TIMEOUT_MS = 25e3;
@@ -7679,9 +7931,27 @@ var CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var CLAUDE_PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
 var CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
 var APPROVAL_WORDS = "Needs a one-time approval on this computer: allow the bridge to read Claude Code's sign-in in the Keychain";
+var SECURITY_ITEM_NOT_FOUND = 44;
+function securityRunner(timeoutMs) {
+  return (args) => new Promise((resolve7) => {
+    execFile("security", args, { timeout: timeoutMs, maxBuffer: 1 << 20 }, (err, stdout) => {
+      if (err) {
+        const e = err;
+        resolve7({ ok: false, code: typeof e.code === "number" ? e.code : null, killed: e.killed === true || e.signal === "SIGTERM" });
+        return;
+      }
+      resolve7({ ok: true, stdout: String(stdout) });
+    });
+  });
+}
+async function keychainAccountOf(run) {
+  const meta = await run(["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE]);
+  if (!meta.ok) return null;
+  return /"acct"<blob>="([^"]*)"/.exec(meta.stdout)?.[1] ?? null;
+}
 function readClaudeCredential(deps = {}) {
   const os = deps.platform ?? platform5();
-  const home = deps.home ?? homedir6();
+  const home = deps.home ?? homedir7();
   const parse = (raw) => {
     try {
       const j = JSON.parse(raw);
@@ -7693,25 +7963,34 @@ function readClaudeCredential(deps = {}) {
     }
   };
   if (os === "darwin") {
-    return new Promise((resolve7) => {
-      execFile("security", ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w"], { timeout: deps.timeoutMs ?? KEYCHAIN_TIMEOUT_MS, maxBuffer: 1 << 20 }, (err, stdout) => {
-        if (err) {
-          const killed = err.killed || err.signal === "SIGTERM";
-          resolve7({ problem: killed ? APPROVAL_WORDS : "Claude Code is not signed in on this computer" });
-          return;
-        }
-        resolve7(parse(String(stdout).trim()));
-      });
-    });
+    return readClaudeKeychain(deps.security ?? securityRunner(deps.timeoutMs ?? KEYCHAIN_TIMEOUT_MS), deps.account ?? userInfo2().username, parse);
   }
-  const file = join10(home, ".claude", ".credentials.json");
-  if (!existsSync11(file)) return Promise.resolve({ problem: "Claude Code is not signed in on this computer" });
+  const file = join11(home, ".claude", ".credentials.json");
+  if (!existsSync13(file)) return Promise.resolve({ problem: "Claude Code is not signed in on this computer" });
   try {
-    return Promise.resolve(parse(readFileSync6(file, "utf8")));
+    return Promise.resolve(parse(readFileSync7(file, "utf8")));
   } catch {
     return Promise.resolve({ problem: "Claude Code's sign-in could not be read on this computer" });
   }
 }
+async function readClaudeKeychain(run, account, parse) {
+  let answer = await run(["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-a", account, "-w"]);
+  let scoped = true;
+  if (!answer.ok && !answer.killed && answer.code === SECURITY_ITEM_NOT_FOUND) {
+    answer = await run(["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w"]);
+    scoped = false;
+  }
+  if (!answer.ok) {
+    if (answer.killed) return { problem: APPROVAL_WORDS };
+    if (answer.code === SECURITY_ITEM_NOT_FOUND) return { problem: "Claude Code is not signed in on this computer" };
+    return { problem: `Claude Code's sign-in could not be read from the Keychain (security exit ${answer.code ?? "unknown"}) \u2014 it may need a one-time approval on this computer` };
+  }
+  const cred = parse(answer.stdout.trim());
+  if (!("problem" in cred) || scoped) return cred;
+  const other = await keychainAccountOf(run);
+  if (!other || other === account) return cred;
+  return { problem: `The Keychain's Claude Code entry on this computer belongs to "${other}", not to ${account}, and carries no sign-in \u2014 remove that entry if it is not yours` };
+}
 function claudeTierWords(profile) {
   const org = profile?.organization;
   const tier = org?.rate_limit_tier ?? "";
@@ -7846,7 +8125,7 @@ function parseGrokBilling(result) {
 }
 async function readGrokCapacity(grokPath, deps = {}) {
   const ask = deps.ask ?? askChild;
-  const cwd = deps.cwd ?? mkdtempSync(join10(tmpdir2(), "frod-capacity-"));
+  const cwd = deps.cwd ?? mkdtempSync(join11(tmpdir2(), "frod-capacity-"));
   const r = await ask({
     command: grokPath,
     args: ["agent", "--no-leader", "stdio"],
@@ -7950,10 +8229,56 @@ function samplesInWords(samples) {
   return samples.map((s) => `${label[s.provider]} ${s.usedPct === null ? `(${s.words ?? "no number"})` : `${Math.round(s.usedPct)}% of ${win[s.window]}`}`).join(" \xB7 ") || "nothing to report";
 }
 
+// src/session-cap.ts
+import { totalmem } from "node:os";
+var SESSION_RAM_MB = 200;
+var RESERVED_RAM_MB = 4 * 1024;
+var HARD_MAX_SESSIONS = 100;
+var DEFAULT_MAX_SESSIONS = 30;
+var LEGACY_DEFAULT_MAX_SESSIONS = 2;
+function sessionCeiling(totalMemBytes = totalmem()) {
+  const usableMb = Math.floor(totalMemBytes / (1024 * 1024)) - RESERVED_RAM_MB;
+  return Math.max(1, Math.min(HARD_MAX_SESSIONS, Math.floor(usableMb / SESSION_RAM_MB)));
+}
+function defaultMaxSessions(totalMemBytes) {
+  return Math.min(DEFAULT_MAX_SESSIONS, sessionCeiling(totalMemBytes));
+}
+function resolveMaxSessions(requested, totalMemBytes) {
+  const ceiling = sessionCeiling(totalMemBytes);
+  if (requested === null || requested === void 0 || !Number.isFinite(requested)) {
+    return { value: defaultMaxSessions(totalMemBytes), ceiling, clamped: false };
+  }
+  const asked = Math.max(1, Math.floor(requested));
+  return { value: Math.min(asked, ceiling), ceiling, clamped: asked > ceiling };
+}
+function clampWords(asked, cap) {
+  if (!cap.clamped) return null;
+  return `${asked} sessions were asked for; this computer's memory carries ${cap.ceiling} at ${SESSION_RAM_MB} MB a session. Using ${cap.value}.`;
+}
+function applySessionCap(cfg, totalMemBytes) {
+  const words = [];
+  let write2 = false;
+  if (cfg.maxSessionsChosen === void 0 && cfg.maxSessions <= LEGACY_DEFAULT_MAX_SESSIONS) {
+    const raised = defaultMaxSessions(totalMemBytes);
+    if (raised > cfg.maxSessions) {
+      words.push(`This computer offered ${cfg.maxSessions} sessions at a time \u2014 the old default. Raising it to ${raised}, which its memory carries at ${SESSION_RAM_MB} MB a session. Set "maxSessions" in the settings file to choose your own; this happens once.`);
+      cfg.maxSessions = raised;
+    }
+    cfg.maxSessionsChosen = false;
+    write2 = true;
+  }
+  const cap = resolveMaxSessions(cfg.maxSessions, totalMemBytes);
+  if (cap.clamped) {
+    words.push(`The settings file asks for ${cfg.maxSessions} sessions; this computer's memory carries ${cap.ceiling} at ${SESSION_RAM_MB} MB a session. Using ${cap.value} \u2014 the file is left as it is.`);
+    cfg.maxSessions = cap.value;
+  }
+  return { write: write2, words };
+}
+
 // package.json
 var package_default = {
   name: "@frod.io/bridge",
-  version: "0.7.5",
+  version: "0.7.6",
   type: "module",
   description: "Your computer is a desk: hosts a Frod.io agent's sessions with your own Claude Code, Codex or Grok Build. Installs and updates itself.",
   license: "UNLICENSED",
@@ -8005,33 +8330,13 @@ function arg(flag, argv) {
   return i >= 0 ? argv[i + 1] : void 0;
 }
 function findClaude() {
-  const candidates = [process.env.FROD_CLAUDE_PATH, join11(homedir7(), ".local", "bin", "claude"), "/opt/homebrew/bin/claude", "/usr/local/bin/claude"].filter((c) => !!c);
-  for (const c of candidates) if (existsSync12(c)) return c;
-  try {
-    return execFileSync7("/usr/bin/which", ["claude"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-  } catch {
-  }
-  return null;
+  return findRuntime("claude");
 }
 function findCodex() {
-  const candidates = [process.env.FROD_CODEX_PATH, join11(homedir7(), ".local", "bin", "codex"), "/opt/homebrew/bin/codex", "/usr/local/bin/codex"].filter((c) => !!c);
-  for (const c of candidates) if (existsSync12(c)) return c;
-  try {
-    const found = execFileSync7("/usr/bin/which", ["codex"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-    return found || null;
-  } catch {
-    return null;
-  }
+  return findRuntime("codex");
 }
 function findGrok() {
-  const candidates = [process.env.FROD_GROK_PATH, join11(homedir7(), ".local", "bin", "grok"), join11(homedir7(), ".grok", "bin", "grok"), "/opt/homebrew/bin/grok", "/usr/local/bin/grok"].filter((c) => !!c);
-  for (const c of candidates) if (existsSync12(c)) return c;
-  try {
-    const found = execFileSync7("/usr/bin/which", ["grok"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-    return found || null;
-  } catch {
-    return null;
-  }
+  return findRuntime("grok");
 }
 var RUNTIME_ORDER = ["claude", "codex", "grok"];
 var RUNTIME_LABELS = { claude: "Claude Code", codex: "Codex", grok: "Grok Build" };
@@ -8101,7 +8406,7 @@ async function cmdJoin(argv, overrides = {}) {
     join: join3,
     storeToken,
     ensureWorkdir: (path) => {
-      if (!existsSync12(path)) mkdirSync9(path, { recursive: true, mode: 448 });
+      if (!existsSync14(path)) mkdirSync9(path, { recursive: true, mode: 448 });
     },
     writeConfig,
     reportGitAccess,
@@ -8117,8 +8422,10 @@ async function cmdJoin(argv, overrides = {}) {
   if (refusal) throw new Error(refusal);
   const safeApi = assertSafeEndpoint(apiUrl);
   const name = arg("--name", argv) ?? defaultName();
-  const workdir = resolve6(arg("--workdir", argv) ?? join11(homedir7(), "frod-work"));
-  const maxSessions = Math.max(1, Math.min(20, Number(arg("--max-sessions", argv) ?? 2)));
+  const workdir = resolve6(arg("--workdir", argv) ?? join12(homedir8(), "frod-work"));
+  const askedSessions = arg("--max-sessions", argv);
+  const cap = resolveMaxSessions(askedSessions === void 0 ? null : Number(askedSessions));
+  const maxSessions = cap.value;
   const probes = probeAllRuntimes(deps.probes);
   for (const runtime of RUNTIME_ORDER) {
     const probe = probes[runtime];
@@ -8139,6 +8446,7 @@ async function cmdJoin(argv, overrides = {}) {
     name,
     workdir,
     maxSessions,
+    maxSessionsChosen: askedSessions !== void 0,
     adapters,
     claudePath: isReady(probes.claude) ? probes.claude.path : null,
     codexPath: isReady(probes.codex) ? probes.codex.path : void 0,
@@ -8153,7 +8461,9 @@ async function cmdJoin(argv, overrides = {}) {
   log.info(`Joined. This computer is now "${name}" \u2014 ${joined.person?.name ?? "your"} computer in ${joined.workspaceName ?? joined.workspaceId} \u2014 hosting ${hostedAgentsWords(cfg)}.`);
   for (const b of cfg.bindings ?? []) log.info(`  ${b.agentName}: ${bindingWords(b)}`);
   log.info(`Token kept in ${store === "keychain" ? "the OS keychain" : `a 0600 file under ${dirname5(CONFIG_PATH)} (no keychain available on this computer \u2014 stated, not hidden)`}; it expires ${joined.expiresAt.slice(0, 10)}.`);
-  log.info(`Settings: ${CONFIG_PATH}. Sessions work under ${workdir}/sessions. Up to ${maxSessions} at a time, across every agent this computer hosts.`);
+  const clamped = askedSessions === void 0 ? null : clampWords(Math.max(1, Math.floor(Number(askedSessions))), cap);
+  if (clamped) log.info(clamped);
+  log.info(`Settings: ${CONFIG_PATH}. Sessions work under ${workdir}/sessions. Up to ${maxSessions} at a time, across every agent this computer hosts \u2014 this computer's memory carries ${cap.ceiling} at ${SESSION_RAM_MB} MB a session; change "maxSessions" in the settings file.`);
   log.info(`To host more agents from here: open the agent's page in Mission Control \u2192 "Join from your computer" \u2192 "Attach an existing computer". No second join.`);
   await deps.reportGitAccess(arg("--repo", argv));
   if (argv.includes("--no-install")) {
@@ -8165,12 +8475,12 @@ async function cmdJoin(argv, overrides = {}) {
 async function reportGitAccess(repoUrl) {
   let version = "not found";
   try {
-    version = execFileSync7("git", ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString().trim();
+    version = execFileSync8("git", ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString().trim();
   } catch {
   }
   let helper = "none configured";
   try {
-    helper = execFileSync7("git", ["config", "--global", "--get-all", "credential.helper"], { stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString().trim().split("\n").filter(Boolean).join(", ") || helper;
+    helper = execFileSync8("git", ["config", "--global", "--get-all", "credential.helper"], { stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString().trim().split("\n").filter(Boolean).join(", ") || helper;
   } catch {
   }
   const url = repoUrl ?? "";
@@ -8193,6 +8503,9 @@ async function cmdRun() {
   }
   const token = tokenFor(cfg);
   ensureFrodDir();
+  const sizing = applySessionCap(cfg);
+  if (sizing.write) writeConfig(cfg);
+  for (const words of sizing.words) log.info(words);
   ClaudeAdapter.reapOrphans();
   const pruned = pruneRunDirs(cfg.workdir);
   if (pruned > 0) log.event("repo.runs_pruned", { count: pruned });
@@ -8250,7 +8563,7 @@ async function cmdRun() {
       });
       if (platform6() === "win32") {
         try {
-          const child = spawn6(process.execPath, [join11(CURRENT_LINK, "dist", "cli.js"), "run"], { detached: true, stdio: "ignore", env: process.env });
+          const child = spawn6(process.execPath, [join12(CURRENT_LINK, "dist", "cli.js"), "run"], { detached: true, stdio: "ignore", windowsHide: true, env: process.env });
           child.unref();
           log.info(`Windows: started ${to} detached (pid ${child.pid}).`);
         } catch (err) {
@@ -8319,7 +8632,8 @@ async function cmdStatus(argv) {
   }
   log.info(`This computer: "${cfg.name}" \u2014 ${cfg.person?.name ? `${cfg.person.name}'s computer` : "a computer"} in ${cfg.workspaceName ?? cfg.workspaceId} via ${cfg.apiUrl}`);
   if (cfg.dormant) log.warn(dormantWords(cfg.dormant, hostedAgentsWords(cfg)));
-  log.info(`Token: ${cfg.tokenStore}; settings ${CONFIG_PATH}; sessions under ${cfg.workdir}/sessions; up to ${cfg.maxSessions} at a time across every agent here.`);
+  const statusCap = resolveMaxSessions(cfg.maxSessions);
+  log.info(`Token: ${cfg.tokenStore}; settings ${CONFIG_PATH}; sessions under ${cfg.workdir}/sessions; up to ${statusCap.value} at a time across every agent here (this computer's memory carries ${statusCap.ceiling} at ${SESSION_RAM_MB} MB a session${statusCap.clamped ? `, so the ${cfg.maxSessions} in the settings file is not honoured` : ""}).`);
   log.info(`Working folders an agent may be given here: ${allowedRootsOf(cfg).join(", ")} (add more under "allowedRoots" in ${CONFIG_PATH}).`);
   const probes = probeAllRuntimes(DEFAULT_RUNTIME_PROBES, cfg);
   for (const runtime of RUNTIME_ORDER) {
@@ -8329,6 +8643,7 @@ async function cmdStatus(argv) {
   const loc = runLocation();
   log.info(`Software: ${VERSION}, running from ${loc.installedVersion ? `${VERSIONS_DIR}/${loc.installedVersion}` : `${loc.packageRoot} (not an installed version \u2014 it will not update itself; run \`npx @frod.io/bridge@latest install\`)`}; current \u2192 ${currentVersion() ?? "none"}.`);
   if (platform6() === "darwin") log.info(`Runs at login: ${launchdLoaded() ? "yes (launchd)" : "no \u2014 run install"}`);
+  if (platform6() === "win32") log.info(`Runs at logon: ${windowsTaskLoaded() ? "yes (scheduled task)" : "no \u2014 run install"}`);
   log.info("Which agent runs on which runtime is the platform's to say \u2014 attach or detach agents in Mission Control.");
   await reportGitAccess(arg("--repo", argv));
   const token = readToken(cfg.keychainAccount, cfg.tokenStore);
@@ -8412,6 +8727,7 @@ async function cmdInstall() {
   if (platform6() === "win32") {
     const r = installWindows(target);
     log.info(r.loaded ? r.detail : `NOT scheduled (${r.detail}).`);
+    if (r.loaded && !r.hidden) log.info(r.manual);
     if (!r.loaded) {
       log.info(r.manual);
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frod.io/bridge",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "type": "module",
   "description": "Your computer is a desk: hosts a Frod.io agent's sessions with your own Claude Code, Codex or Grok Build. Installs and updates itself.",
   "license": "UNLICENSED",