cookbook-bridge 0.1.13 → 0.1.16

package/README.md

@@ -2,6 +2,9 @@
 
 ## Changelog
 
+**0.1.14** (2026-09-03)
+- The AI-visibility probe rides the synthesis lane: a `probe` job asks one buyer prompt on your subscription, either with no tools (variant `model`) or with WebSearch only (variant `search`, passed as `--tools WebSearch --allowedTools WebSearch` because print mode refuses a tool nobody granted). Capped at 120s per prompt, logged as `probe: <group> #<n> (<variant>)`, never with the prompt text.
+
 **0.1.13** (2026-09-02)
 - Pre-flight: the moment a grant this Bridge hosts becomes active, it runs `env`, the doctor, `cli_versions` and the shape of its own config (tokens stripped) once, locally and read-only, and posts the result as a host-initiated `preflight` call, so the visiting agent starts with what the machine already knows. Remembered per grant in `bridge.state.json`; a failed post is retried once per process.
 - One-click plans: a `plan` call carries `why` and an ordered list of steps. The Bridge recomputes the plan hash before running (a step added after the click is refused as `plan hash mismatch`), runs each step through the same authorization wall as a single call, with the plan's approval standing in for each write-class step's click, stops at the first failure, and reports every step with its duration. Plans cannot nest, cannot contain `preflight`, and run one at a time like every other call.

package/bridge.mjs

@@ -34,7 +34,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { callsFromStreamLine, foldCallEvent, wireCalls, shortTool, argFor } from "./live.mjs";
-import { planFromStreamLine, notePlan, planLine } from "./plan.mjs";
+import { planFromStreamLine, notePlan, planLine, noteAuth, isSignedOutError } from "./plan.mjs";
 
 // Node version guard: below 18 there is no global fetch and none of this runs. One
 // plain line beats a stack trace from the first `fetch(` call.
@@ -739,8 +739,8 @@ function failureHint(result) {
   const infra = String(err || "").toLowerCase();
   const tailSrc = `${err || display || (brace < 0 ? rawOut : "")}`.trim();
   const tail = tailSrc.split("\n").slice(-2).join(" ").slice(0, 240);
-  if (infra.includes("not logged in") || infra.includes("please log in"))
-    return "the agent CLI isn't logged in → run `claude auth login`";
+  if (isSignedOutError(infra))
+    return "Claude on this machine is signed out → open a terminal, run `claude`, and sign in; this Bridge picks it up on its own";
   // Kimi's own error strings (stderr: "error: failed to run prompt: provider.connection_error: …").
   if (infra.includes("provider.connection_error") || infra.includes("connection error"))
     return "the agent CLI can't reach its API (a network or DNS block on the vendor's hosts) → check the connection, then try `kimi -p hi` by hand";
@@ -1439,6 +1439,10 @@ async function processTask(cfg, ws, task, agent) {
       // turns a multi-hour debug into a one-glance fix.
       const hint = failureHint(result);
       const why = hint ? ` — ${hint}` : "";
+      if (/signed out/.test(hint) && isClaudeCommand && isClaudeCommand(agent.command)) {
+        if (noteAuth("claude", false)) log("! Claude is signed out on this machine → run `claude` in a terminal and sign in. Until then Claude work here falls back or waits.");
+        lastAuthCheck = Date.now() - AUTH_CHECK_MS + 60_000; // re-check in a minute
+      }
       if (holdDuringRun()) {
         shelveForHold(hint || "plan limit reached", result?.sessionId ?? null);
       } else if (n >= cfg.maxAttempts) {
@@ -2082,6 +2086,45 @@ async function pollOnce(cfg, onlyWorkspaceIds = null) {
 
 /** How often a RUNNING bridge re-checks the deploy manifest ("app updated → I update"). */
 const UPDATE_CHECK_MS = 6 * 60 * 60 * 1000;
+/** How often to ask the CLI whether it is still signed in (0100). */
+const AUTH_CHECK_MS = 10 * 60 * 1000;
+let lastAuthCheck = 0;
+
+/**
+ * Ask claude whether it is signed in (`claude auth status` prints JSON with
+ * `loggedIn`). Only claude has this today; other vendors are learned from their
+ * failures. Records the state (plan.mjs noteAuth) so the heartbeat advertises it,
+ * and logs once per change. Never throws; an unreadable answer changes nothing.
+ */
+async function checkClaudeAuth(cfg) {
+  const agent = (cfg?.agents ?? []).find((a) => a && a.enabled !== false && isClaudeCommand && isClaudeCommand(a.command));
+  if (!agent) return null;
+  const cmd = agent.command[0];
+  const env = typeof agentEnv === "function" ? agentEnv(cfg).env : process.env;
+  const out = await new Promise((resolve) => {
+    let text = "";
+    let done = false;
+    const finish = (v) => { if (!done) { done = true; resolve(v); } };
+    try {
+      const child = spawn(cmd, ["auth", "status"], { env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+      child.stdout.on("data", (d) => { text += d; });
+      child.stderr.on("data", (d) => { text += d; });
+      child.on("error", () => finish(null));
+      child.on("close", () => finish(text));
+      setTimeout(() => { try { child.kill(); } catch { /* gone */ } finish(null); }, 15_000).unref();
+    } catch { finish(null); }
+  });
+  if (out === null) return null;
+  let loggedIn = null;
+  const brace = out.indexOf("{");
+  if (brace >= 0) { try { const j = JSON.parse(out.slice(brace)); if (typeof j.loggedIn === "boolean") loggedIn = j.loggedIn; } catch { /* not JSON */ } }
+  if (loggedIn === null && isSignedOutError(out)) loggedIn = false;
+  if (loggedIn === null) return null;
+  const changed = noteAuth("claude", loggedIn);
+  if (changed && !loggedIn) log("! Claude is signed out on this machine → open a terminal, run `claude`, and sign in. This Bridge re-checks every 10 minutes.");
+  if (changed && loggedIn && lastAuthCheck > 0) log("✓ Claude is signed in again — Claude work resumes here.");
+  return loggedIn;
+}
 
 /**
  * WHO OWNS THIS INSTALL'S VERSION.
@@ -2116,6 +2159,39 @@ let updateNagged = false;
  * Check failures are non-fatal (offline is fine); a FAILED apply never breaks the
  * running code (verification happens before any write; originals in bridge.backup/).
  */
+/**
+ * Install the runtime + login service and wait for it to come up. Returns true
+ * when a Bridge is running under the service; false (with the reason printed) so
+ * the caller can fall back to a foreground run.
+ */
+async function installAsService(svc, { cookbookUrl, cfgPath }) {
+  const say = (m) => console.log(`  ${m}`);
+  try {
+    console.log("\nInstalling the Bridge as a background service…");
+    await svc.installRuntime({ cookbookUrl, log: say });
+    svc.installService({ config: cfgPath, log: say });
+    process.stdout.write("  Starting");
+    const pid = await svc.waitForBridge(cfgPath, { timeoutMs: 30_000 });
+    console.log("");
+    const st = svc.serviceState({ config: cfgPath });
+    if (pid) {
+      console.log(`\n  ✓ The Bridge is running in the background (pid ${pid}). It starts with your computer,`);
+      console.log("    updates itself from cookbook.team, and this window can close.");
+    } else {
+      console.log(`\n  ! The service is installed but the Bridge has not reported in yet. Its log: ${st.log}`);
+    }
+    console.log(`\n  Config:   ${cfgPath}`);
+    console.log(`  Log:      ${st.log}`);
+    console.log(`  Check:    ${cli("doctor")}`);
+    console.log(`  Restart:  ${cli("restart")}`);
+    console.log(`  Remove:   ${cli("uninstall")}\n`);
+    return true;
+  } catch (e) {
+    console.log(`\n  ! Could not install the service: ${e.message}`);
+    return false;
+  }
+}
+
 async function selfUpdate(cfg, { reexec }) {
   let check;
   try {
@@ -2140,6 +2216,10 @@ async function selfUpdate(cfg, { reexec }) {
   try {
     const replaced = await applyUpdate(cfg, HERE, check);
     log(`⬆ Bridge self-updated to deploy ${check.version} (${replaced.length} file(s), hash-verified; previous in bridge.backup/${check.version}/).`);
+    if (reexec && process.env.COOKBOOK_SERVICE === "1") {
+      log("↻ restarting on the new code (the service brings it back)…");
+      process.exit(0);
+    }
     if (reexec) {
       log("↻ restarting on the new code…");
       const { spawn } = await import("node:child_process");
@@ -2157,6 +2237,9 @@ async function main() {
   const cfg = loadConfig();
   log(`Cookbook Bridge started · ${cfg.cookbookUrl}`);
   log(`Managing: ${cfg.agents.map((a) => a.name).join(", ") || "(no agents enabled!)"} · polling every ${cfg.pollSeconds}s`);
+  // Is the CLI actually able to run? (0100) The answer rides the first heartbeat.
+  await checkClaudeAuth(cfg).catch(() => null);
+  lastAuthCheck = Date.now();
 
   // "When the app updates, so does the Bridge": check the deploy manifest now, then
   // every 6h while running. Set "autoUpdate": false in config to pin.
@@ -2333,6 +2416,13 @@ async function main() {
       log(`  Fix it in the app (Connect your agents), or run \`${cli("connect")}\`. The control API stays up so you can.`);
     } else {
       console.error(`\nCouldn't connect to Cookbook: ${e.message}`);
+      // Under a login service the supervisor restarts us at once; a dead token
+      // would then hit the server every 15 seconds forever. Say the fix, then
+      // wait before exiting so the loop is gentle (service.mjs, 2026-09-09).
+      if (process.env.COOKBOOK_SERVICE === "1") {
+        console.error(`  Fix: ${cli("connect")}   (reconnects; the service picks the new token up on its own). Retrying in 5 minutes.`);
+        await new Promise((r) => setTimeout(r, 5 * 60 * 1000));
+      }
       process.exit(1);
     }
   }
@@ -2402,11 +2492,19 @@ async function main() {
           } else {
             log("✗ Cookbook has rejected this token 5 polls in a row — it was likely revoked (a new login replaces old tokens) or expired.");
             log(`  Fix: ${cli("connect")}   (reconnects and starts the Bridge)`);
+            if (process.env.COOKBOOK_SERVICE === "1") {
+              log("  Running as a service: retrying in 5 minutes.");
+              await new Promise((r) => setTimeout(r, 5 * 60 * 1000));
+            }
             process.exit(1);
           }
         }
       }
     }
+    if (Date.now() - lastAuthCheck > AUTH_CHECK_MS) {
+      lastAuthCheck = Date.now();
+      void checkClaudeAuth(cfg).catch(() => null);
+    }
     if (Date.now() - lastUpdateCheck > UPDATE_CHECK_MS) {
       lastUpdateCheck = Date.now();
       await selfUpdate(cfg, { reexec: true });
@@ -2529,6 +2627,18 @@ async function doctorReport(args) {
     }
   }
 
+  // 2a½. The login service (2026-09-09): installed? running?
+  try {
+    const svc = await import("./service.mjs");
+    const st = svc.serviceState({ config: cfgPath });
+    if (!st.kind) ok("Login service: not available on this platform (run the Bridge in a terminal)");
+    else if (st.installed && st.pid) ok(`Login service: installed (${st.definition}) and running (pid ${st.pid})`);
+    else if (st.installed) warn(`Login service: installed (${st.definition}) but no Bridge is reporting in`, `look at ${st.log}, or \`${cli("restart")}\``);
+    else if (!IS_DESKTOP) warn("Login service: not installed, so the Bridge stops when this window closes", `\`${cli("install")}\` installs it and starts it now`);
+  } catch (e) {
+    ok(`Login service: could not check (${e.message})`);
+  }
+
   // 2b. Another Bridge on this machine? Two on one config fight over the same token
   // (a `connect` revokes the other's); one on a different config is the classic
   // "I connected but a stale Bridge is still running" trap.
@@ -2685,6 +2795,9 @@ async function doctorReport(args) {
       }
 
       if (isClaudeCommand && isClaudeCommand(agent.command)) {
+        const signedIn = await checkClaudeAuth({ ...cfg, agents: [agent] }).catch(() => null);
+        if (signedIn === false) bad(`${agent.name}: claude is SIGNED OUT on this machine`, "open a terminal, run `claude`, and sign in (or `claude auth login`)");
+        else if (signedIn === true) ok(`${agent.name}: claude is signed in`);
         if (agent.token) ok(`${agent.name}: runs carry their own Cookbook connection (per-agent token) — identity is this Bridge's member`);
         else warn(`${agent.name}: no per-agent token — runs use the claude CLI's OWN Cookbook login, which may be a different account and inherits stale claude.ai connectors`,
           `run \`${cli("connect")}\` (mints a token for this agent) or add "token" to this agent in ${cfgPath}`);
@@ -2853,13 +2966,24 @@ if (!IS_MAIN) {
     .then(async (m) => {
       const args = process.argv.slice(3);
       const noRun = args.includes("--no-run");
-      const r = await m.connectAgents(args.filter((a) => a !== "--no-run"), { willRun: !noRun });
+      // THE SERVICE (2026-09-09): after the approval the Bridge is installed as a
+      // login service and started, so the window can close and it survives reboots.
+      // `--no-service` keeps the foreground run; the desktop app supervises its own.
+      const svc = await import("./service.mjs");
+      const wantService = !noRun && !args.includes("--no-service") && !IS_DESKTOP && !!svc.serviceKind();
+      const passArgs = args.filter((a) => a !== "--no-run" && a !== "--no-service" && a !== "--no-signin").concat(args.includes("--no-signin") ? ["--no-signin"] : []);
+      const r = await m.connectAgents(passArgs, { willRun: !noRun, service: wantService });
       if (!r || !r.ok) {
         // Nothing to run (no agent CLI found): the doctor says what is missing and how to fix it.
         if (r && r.reason === "no-agents") await runDoctor(["--config", r.cfgPath]);
         return;
       }
       if (noRun || !r.startBridge) return;
+      if (wantService) {
+        const done = await installAsService(svc, { cookbookUrl: r.baseUrl, cfgPath: r.cfgPath });
+        if (done) return;
+        console.log("Falling back to running the Bridge here.\n");
+      }
       console.log("Connected. Running the Bridge now; leave this window open. Ctrl-C stops it.\n");
       process.argv = [process.argv[0], process.argv[1], r.cfgPath];
       await main();
@@ -2896,6 +3020,33 @@ if (!IS_MAIN) {
       console.error(e.message);
       process.exit(1);
     });
+} else if (sub === "install") {
+  // Runtime + login service + start, against an existing config (connect does this
+  // for you; `install` is for a machine that already has a config).
+  (async () => {
+    const svc = await import("./service.mjs");
+    const cfgPath = configPathFromArgs(process.argv.slice(3));
+    let cookbookUrl = "";
+    try { cookbookUrl = String(JSON.parse(fs.readFileSync(cfgPath, "utf8")).cookbookUrl || "").replace(/\/$/, ""); } catch { /* below */ }
+    if (!cookbookUrl) { console.error(`No config at ${cfgPath}. Run \`${cli("connect")}\` first.`); process.exit(1); }
+    const ok = await installAsService(svc, { cookbookUrl, cfgPath });
+    process.exit(ok ? 0 : 1);
+  })().catch((e) => { console.error(e.message); process.exit(1); });
+} else if (sub === "uninstall") {
+  (async () => {
+    const svc = await import("./service.mjs");
+    const cfgPath = configPathFromArgs(process.argv.slice(3));
+    const r = svc.uninstallService({ config: cfgPath, log: (m) => console.log(`  ${m}`) });
+    console.log(r.removed.length ? `Service removed (${r.removed.join(", ")}).` : "No service was installed.");
+    console.log(`Your config and token are untouched at ${cfgPath}. To revoke the Bridge's access, remove it under Account > Connected apps.`);
+  })().catch((e) => { console.error(e.message); process.exit(1); });
+} else if (sub === "restart") {
+  (async () => {
+    const svc = await import("./service.mjs");
+    const cfgPath = configPathFromArgs(process.argv.slice(3));
+    const ok = svc.restartService({ config: cfgPath });
+    console.log(ok ? "Restarting the Bridge service." : `No running service found for ${cfgPath}. Start one with \`${cli("install")}\`.`);
+  })().catch((e) => { console.error(e.message); process.exit(1); });
 } else if (sub === "status") {
   import("./device.mjs")
     .then((m) => m.status(process.argv.slice(3)))

package/cookbook.mjs

@@ -8,7 +8,7 @@
  *
  * Node built-ins only (global fetch, Node 18+). No dependencies.
  */
-import { planParam } from "./plan.mjs";
+import { planParam, signedOutParam } from "./plan.mjs";
 
 /** Call one Cookbook MCP tool. Returns the tool's body (structuredContent). */
 export async function callTool(cfg, name, args = {}) {
@@ -260,6 +260,9 @@ export function agentsQuery(cfg, plan = planParam) {
   // reported them to this Bridge (bridge/plan.mjs). Rides the same heartbeat.
   const p = typeof plan === "function" ? plan() : "";
   if (p) parts.push(p);
+  // `signed_out=…` — which of those agents' CLIs cannot run right now (0100).
+  const so = signedOutParam();
+  if (so) parts.push(so);
   return parts.length ? `?${parts.join("&")}` : "";
 }
 

package/device.mjs

@@ -582,7 +582,7 @@ function probeAgent(cmd) {
  * Codex (ChatGPT app), Kimi and OpenClaw; mints one named token per agent in the same
  * approval as the Bridge token; configures each via its official path.
  */
-export async function connectAgents(argv, { willRun = false } = {}) {
+export async function connectAgents(argv, { willRun = false, service = false } = {}) {
   const cfgPath = configPath(argv);
   const found = detectClis();
   if (found.length === 0) {
@@ -592,6 +592,13 @@ export async function connectAgents(argv, { willRun = false } = {}) {
   }
   console.log(`\nFound agent CLIs: ${found.map((c) => c.agent).join(", ")}`);
 
+  // ONE-CLICK SIGN-IN (2026-09-09). The Bridge can only run a CLI that is signed
+  // in, and "signed out" was the failure behind every dead task Texas Accelerate
+  // and Pierre hit. So before the Cookbook approval, sign the CLIs in right here:
+  // claude opens Anthropic's own login page; codex shows OpenAI's device code.
+  // Each token lands in that CLI's own store on this disk; Cookbook never sees it.
+  if (!argv.includes("--no-signin")) await ensureSignedIn(found);
+
   // One approval mints the bridge token + one named token per agent.
   const res = await login(argv, { agents: found.map((c) => c.agent), quietOutro: true });
   if (!res || !res.agentTokens) {
@@ -605,8 +612,77 @@ export async function connectAgents(argv, { willRun = false } = {}) {
     console.log(`  ${mark} ${r.agent}: ${r.detail}${r.ok && !r.warn ? ` (work will be attributed "${r.agent} · via you")` : ""}`);
   }
   await reportStaleness(res.baseUrl);
-  reportNextStep(res.cfgPath, { willRun });
-  return { ok: true, startBridge: true, cfgPath: res.cfgPath, agentTokens: true };
+  if (!service) reportNextStep(res.cfgPath, { willRun });
+  return { ok: true, startBridge: true, cfgPath: res.cfgPath, agentTokens: true, baseUrl: res.baseUrl, found };
+}
+
+/** `claude auth status` → true / false / null (unknown). Never throws. */
+export function claudeSignedIn(claudePath) {
+  try {
+    const argv = argvForSpawn([claudePath, "auth", "status"]);
+    const r = spawnSync(argv[0], argv.slice(1), { encoding: "utf8", timeout: 15_000, windowsHide: true });
+    const out = `${r.stdout || ""}${r.stderr || ""}`;
+    const brace = out.indexOf("{");
+    if (brace >= 0) { try { const j = JSON.parse(out.slice(brace)); if (typeof j.loggedIn === "boolean") return j.loggedIn; } catch { /* not JSON */ } }
+    if (/not logged in|please log in|expired|not authenticated/i.test(out)) return false;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Does codex have a login on this machine? (`~/.codex/auth.json` is what `codex login` writes.) */
+export function codexSignedIn(home = os.homedir()) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(home, ".codex", "auth.json"), "utf8"));
+    return !!(j && (j.tokens || j.OPENAI_API_KEY || j.access_token));
+  } catch {
+    return false;
+  }
+}
+
+/** Run a CLI's own interactive sign-in in this terminal and wait for it. */
+function runInteractive(bin, args) {
+  return new Promise((resolve) => {
+    try {
+      const argv = argvForSpawn([bin, ...args]);
+      const child = spawn(argv[0], argv.slice(1), { stdio: "inherit" });
+      child.on("error", () => resolve(false));
+      child.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+/**
+ * Sign in every detected CLI that is signed out, in the terminal, before anything
+ * else. Claude: Anthropic's browser login (`claude auth login`). Codex: OpenAI's
+ * device code (`codex login --device-auth`). Skipped for CLIs we cannot check.
+ */
+export async function ensureSignedIn(found, { log = console.log } = {}) {
+  const outcome = [];
+  for (const c of found) {
+    if (c.vendor === "claude") {
+      const state = claudeSignedIn(c.path);
+      if (state === false) {
+        log("\n  Claude Code is signed out on this machine. Sign in with the account you use in the browser:\n");
+        const ok = await runInteractive(c.path, ["auth", "login"]);
+        const after = claudeSignedIn(c.path);
+        log(after ? "\n  ✓ Claude Code is signed in.\n" : "\n  ! Claude Code still looks signed out. Run `claude` in a terminal and sign in, then re-run connect.\n");
+        outcome.push({ agent: "Claude", signedIn: !!after, ran: ok });
+      } else outcome.push({ agent: "Claude", signedIn: state !== false, ran: false });
+    } else if (c.vendor === "codex" && c.kind === "codex" && !/ChatGPT\.app/i.test(String(c.path))) {
+      if (!codexSignedIn()) {
+        log("\n  Codex has no ChatGPT login on this machine. Enter the code OpenAI shows you:\n");
+        const ok = await runInteractive(c.path, ["login", "--device-auth"]);
+        const after = codexSignedIn();
+        log(after ? "\n  ✓ Codex is signed in with your ChatGPT account.\n" : "\n  ! Codex still has no login. Run `codex login` in a terminal, then re-run connect.\n");
+        outcome.push({ agent: "Codex", signedIn: after, ran: ok });
+      } else outcome.push({ agent: "Codex", signedIn: true, ran: false });
+    }
+  }
+  return outcome;
 }
 
 /** The same manifest comparison the running Bridge does at startup, printed with the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cookbook-bridge",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "Run your own Claude, Codex and Gemini subscriptions against your Cookbook workspaces. One approval connects every agent CLI on your machine, with a receipt for every run.",
   "type": "module",
   "bin": {
@@ -33,6 +33,7 @@
     "synthesis.mjs",
     "thread-runner.mjs",
     "update.mjs",
+    "service.mjs",
     "usage.mjs",
     "volunteer.mjs"
   ],
@@ -40,7 +41,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test test/local.test.mjs test/review.test.mjs test/home.test.mjs test/kimi.test.mjs test/hands.test.mjs"
+    "test": "node --test test/local.test.mjs test/review.test.mjs test/home.test.mjs test/kimi.test.mjs test/hands.test.mjs test/probe.test.mjs"
   },
   "keywords": [
     "cookbook",
@@ -55,11 +56,10 @@
   "homepage": "https://cookbook.team",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/dpro10/cookbook.git",
-    "directory": "bridge"
+    "url": "git+https://github.com/dpro10/cookbook-bridge.git"
   },
   "bugs": {
-    "url": "https://cookbook.team"
+    "url": "https://github.com/dpro10/cookbook-bridge/issues"
   },
   "license": "MIT",
   "publishConfig": {

package/plan.mjs

@@ -123,3 +123,44 @@ export function planLine(vendor, entry) {
   if (s) parts.push(`${s} of week`);
   return `${vendor}${entry?.plan ? ` (${entry.plan})` : ""}: ${parts.join(" · ") || "no windows"}`;
 }
+
+// ── SIGNED OUT (0100, 2026-09-07) ─────────────────────────────────────────────
+// A Bridge used to advertise an agent because its CLI was installed; whether the
+// CLI could actually run was learned one failed task at a time ("OAuth session
+// expired and could not be refreshed", every run, Pierre's Mac). The Bridge now
+// asks the CLI (`claude auth status`) at boot, every ten minutes, and right after
+// an auth failure, and rides the answer on the same heartbeat as `agents=`.
+const auth = new Map(); // vendor -> { ok: boolean, at }
+const SIGNED_OUT_NAME = { claude: "Claude", codex: "Codex", gemini: "Gemini", openclaw: "OpenClaw" };
+
+/** Record a vendor's sign-in state. Returns true when it CHANGED (log once, not per beat). */
+export function noteAuth(vendor, ok, now = Date.now()) {
+  if (!VENDORS.has(vendor)) return false;
+  const prev = auth.get(vendor);
+  auth.set(vendor, { ok: !!ok, at: now });
+  return !prev || prev.ok !== !!ok;
+}
+
+/** Vendors currently known to be signed out. */
+export function signedOutVendors() {
+  return [...auth].filter(([, v]) => !v.ok).map(([k]) => k);
+}
+
+/** `signed_out=Claude` once auth has been checked ("signed_out=" when everything is
+ *  signed in, so the server clears the flag the moment the member signs back in);
+ *  "" before any check, so an unchecked Bridge leaves the column alone. */
+export function signedOutParam() {
+  if (!auth.size) return "";
+  return `signed_out=${encodeURIComponent(signedOutVendors().map((v) => SIGNED_OUT_NAME[v] ?? v).join(","))}`;
+}
+
+/** For tests. */
+export function resetAuth() {
+  auth.clear();
+}
+
+/** Does this CLI failure text mean "signed out"? Judged on stderr, never on the model's answer. */
+export function isSignedOutError(text) {
+  const t = String(text ?? "").toLowerCase();
+  return /oauth session expired|could not be refreshed|failed to authenticate|not logged in|please log in|login required|not authenticated/.test(t);
+}

package/service.mjs

@@ -0,0 +1,343 @@
+/**
+ * THE BRIDGE AS A SERVICE (2026-09-09) — install once, runs from login, updates itself.
+ *
+ * Before this, the terminal path ended with "leave this window open": close the
+ * window or reboot and the Bridge was gone, and an npx-run copy could never update
+ * itself (npm owns those files). Texas Accelerate's first Bridge lived for ninety
+ * seconds. This module makes `connect` end differently:
+ *
+ *   1. RUNTIME  the current Bridge is downloaded from the deploy into
+ *               ~/.cookbook/bridge (hash-verified against /api/bridge/manifest by
+ *               update.mjs). Nothing runs from the npx cache, so the running copy
+ *               is on the "self" update channel and tracks every deploy on its own.
+ *   2. SERVICE  a login service runs `node ~/.cookbook/bridge/bridge.mjs <config>`
+ *               with COOKBOOK_SERVICE=1 and restarts it if it exits:
+ *                 macOS    a LaunchAgent in ~/Library/LaunchAgents (KeepAlive)
+ *                 Windows  a hidden launcher in the user's Startup folder that
+ *                          loops node until a stop file appears (no admin, no schtasks)
+ *                 Linux    a systemd --user unit (Restart=always)
+ *   3. START    it is started right away; `connect` waits for the Bridge's
+ *               local.json to say it is up before printing the pid.
+ *
+ * Under a service, a self-update just exits: the supervisor restarts the new code
+ * (bridge.mjs selfUpdate checks COOKBOOK_SERVICE). The config and token are never
+ * touched by any of this. Everything that builds a file or a command is pure and
+ * exported for scripts/test-bridge-service.ts; the I/O sits in install/uninstall.
+ *
+ * Why ~/.cookbook and not the app folder or the Desktop: launchd agents pointed at
+ * a TCC-protected folder (Desktop, Documents) die with EX_CONFIG before spawning
+ * (25 silent crash-loops on 2026-08-24). The home dot-folder is always allowed.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { configHome, defaultConfigPath, checkForUpdate, applyUpdate } from "./update.mjs";
+
+export const SERVICE_LABEL = "team.cookbook.bridge";
+export const WINDOWS_TASK_NAME = "Cookbook Bridge";
+
+/** `~/.cookbook/bridge`: the runtime the service runs. */
+export function runtimeDir(home = os.homedir()) {
+  return path.join(configHome(home), "bridge");
+}
+/** `~/.cookbook/bridge.log`: everything the service's Bridge prints. */
+export function serviceLogPath(home = os.homedir()) {
+  return path.join(configHome(home), "bridge.log");
+}
+/** `~/.cookbook/service.stop`: Windows only, tells the launcher loop to end. */
+export function stopFilePath(home = os.homedir()) {
+  return path.join(configHome(home), "service.stop");
+}
+
+// ── macOS ─────────────────────────────────────────────────────────────────────
+
+export function launchdPlistPath(home = os.homedir()) {
+  return path.join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+
+function xmlEscape(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+/** The LaunchAgent. PATH carries node's own folder first so a version-managed node resolves. */
+export function launchdPlist({ node, script, config, home, logPath, pathEnv = process.env.PATH || "" }) {
+  const pathParts = [path.dirname(node), ...String(pathEnv).split(":"), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"]
+    .filter((p, i, arr) => p && arr.indexOf(p) === i);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <!-- Cookbook Bridge: runs your agents for your team, on your subscriptions.
+       Installed by \`npx cookbook-bridge@latest connect\`; remove with
+       \`npx cookbook-bridge@latest uninstall\`. It updates itself from cookbook.team. -->
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(node)}</string>
+    <string>${xmlEscape(script)}</string>
+    <string>${xmlEscape(config)}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xmlEscape(path.dirname(script))}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${xmlEscape(pathParts.join(":"))}</string>
+    <key>HOME</key>
+    <string>${xmlEscape(home)}</string>
+    <key>COOKBOOK_SERVICE</key>
+    <string>1</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>15</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath)}</string>
+</dict>
+</plist>
+`;
+}
+
+// ── Linux ─────────────────────────────────────────────────────────────────────
+
+export function systemdUnitPath(home = os.homedir()) {
+  return path.join(home, ".config", "systemd", "user", "cookbook-bridge.service");
+}
+
+export function systemdUnit({ node, script, config, home, logPath, pathEnv = process.env.PATH || "" }) {
+  const pathParts = [path.dirname(node), ...String(pathEnv).split(":"), "/usr/local/bin", "/usr/bin", "/bin"]
+    .filter((p, i, arr) => p && arr.indexOf(p) === i);
+  const q = (s) => `"${String(s).replace(/"/g, '\\"')}"`;
+  return `[Unit]
+Description=Cookbook Bridge (runs your agents for your team, on your subscriptions)
+After=network-online.target
+
+[Service]
+ExecStart=${q(node)} ${q(script)} ${q(config)}
+WorkingDirectory=${path.dirname(script)}
+Environment=COOKBOOK_SERVICE=1
+Environment=HOME=${home}
+Environment=PATH=${pathParts.join(":")}
+Restart=always
+RestartSec=15
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+// ── Windows ───────────────────────────────────────────────────────────────────
+
+/** The Startup folder: anything here runs at logon for this user, no admin needed. */
+export function windowsStartupDir(env = process.env) {
+  const appData = env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  return path.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+}
+export function windowsLauncherPaths(home = os.homedir(), env = process.env) {
+  return {
+    cmd: path.join(configHome(home), "bridge-service.cmd"),
+    vbs: path.join(configHome(home), "bridge-service.vbs"),
+    startup: path.join(windowsStartupDir(env), `${WINDOWS_TASK_NAME}.vbs`),
+  };
+}
+
+/** The loop: run the Bridge, wait 15s, run again, until the stop file exists. */
+export function windowsCmdScript({ node, script, config, logPath, stopFile }) {
+  return `@echo off
+rem Cookbook Bridge service loop. Installed by "npx cookbook-bridge@latest connect";
+rem remove with "npx cookbook-bridge@latest uninstall". The Bridge updates itself.
+set COOKBOOK_SERVICE=1
+:loop
+if exist "${stopFile}" exit /b 0
+"${node}" "${script}" "${config}" >> "${logPath}" 2>&1
+if exist "${stopFile}" exit /b 0
+timeout /t 15 /nobreak >nul
+goto loop
+`;
+}
+
+/** Runs the .cmd with no window. */
+export function windowsVbsScript({ cmdPath }) {
+  return `Set sh = CreateObject("WScript.Shell")
+sh.Run "cmd.exe /c """ & "${cmdPath.replace(/"/g, '""')}" & """", 0, False
+`;
+}
+
+// ── what this machine has ─────────────────────────────────────────────────────
+
+export function serviceKind(platform = process.platform) {
+  if (platform === "darwin") return "launchd";
+  if (platform === "win32") return "startup";
+  if (platform === "linux") return "systemd";
+  return null;
+}
+
+/** The files a service install would write, per platform. Pure. */
+export function servicePaths({ platform = process.platform, home = os.homedir(), env = process.env } = {}) {
+  const kind = serviceKind(platform);
+  if (kind === "launchd") return { kind, definition: launchdPlistPath(home) };
+  if (kind === "systemd") return { kind, definition: systemdUnitPath(home) };
+  if (kind === "startup") return { kind, definition: windowsLauncherPaths(home, env).startup };
+  return { kind: null, definition: null };
+}
+
+/** pid from the running Bridge's local.json next to the config, if that pid is alive. */
+export function runningPid(config) {
+  try {
+    const local = JSON.parse(fs.readFileSync(path.join(path.dirname(config), "local.json"), "utf8"));
+    const pid = Number(local.pid);
+    if (!pid) return null;
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}
+
+/** Installed? Running? One object for `status`, `doctor` and `connect`. */
+export function serviceState({ platform = process.platform, home = os.homedir(), env = process.env, config = defaultConfigPath(home) } = {}) {
+  const sp = servicePaths({ platform, home, env });
+  const installed = !!sp.definition && fs.existsSync(sp.definition);
+  return { kind: sp.kind, definition: sp.definition, installed, pid: runningPid(config), runtime: runtimeDir(home), log: serviceLogPath(home) };
+}
+
+// ── I/O ───────────────────────────────────────────────────────────────────────
+
+function run(cmd, args, { allowFail = false } = {}) {
+  const r = spawnSync(cmd, args, { encoding: "utf8", windowsHide: true });
+  if (r.error) { if (allowFail) return r; throw new Error(`${cmd} ${args.join(" ")}: ${r.error.message}`); }
+  if (r.status !== 0 && !allowFail) throw new Error(`${cmd} ${args.join(" ")} exited ${r.status}: ${(r.stderr || r.stdout || "").trim().slice(0, 300)}`);
+  return r;
+}
+
+/**
+ * Download (or refresh) the runtime into ~/.cookbook/bridge from the deploy. Uses
+ * the same manifest + tar + hash verification as a self-update, so a first install
+ * is just "every file is outdated". Returns { dir, version, replaced }.
+ */
+export async function installRuntime({ cookbookUrl, home = os.homedir(), log = () => {} } = {}) {
+  const dir = runtimeDir(home);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const cfg = { cookbookUrl: String(cookbookUrl || "https://cookbook.team").replace(/\/$/, "") };
+  const check = await checkForUpdate(cfg, dir);
+  if (check.changed.length === 0) {
+    log(`Runtime is current (deploy ${check.version}) at ${dir}`);
+    return { dir, version: check.version, replaced: [] };
+  }
+  const replaced = await applyUpdate(cfg, dir, check);
+  log(`Runtime installed (deploy ${check.version}, ${replaced.length} file${replaced.length === 1 ? "" : "s"}, hash-verified) at ${dir}`);
+  return { dir, version: check.version, replaced };
+}
+
+/**
+ * Write the service definition, register it, and start it now. Throws with a
+ * one-line reason when the platform has no supported service; callers fall back
+ * to a foreground run. Never touches the config.
+ */
+export function installService({ platform = process.platform, home = os.homedir(), env = process.env, node = process.execPath, config = defaultConfigPath(home), log = () => {} } = {}) {
+  const kind = serviceKind(platform);
+  if (!kind) throw new Error(`no login service for ${platform}; run the Bridge in a terminal instead`);
+  const script = path.join(runtimeDir(home), "bridge.mjs");
+  if (!fs.existsSync(script)) throw new Error(`runtime missing at ${script}; install it first`);
+  const logPath = serviceLogPath(home);
+  fs.mkdirSync(configHome(home), { recursive: true, mode: 0o700 });
+
+  if (kind === "launchd") {
+    const plistPath = launchdPlistPath(home);
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+    fs.writeFileSync(plistPath, launchdPlist({ node, script, config, home, logPath, pathEnv: env.PATH }), { mode: 0o644 });
+    const domain = `gui/${typeof process.getuid === "function" ? process.getuid() : 501}`;
+    run("launchctl", ["bootout", `${domain}/${SERVICE_LABEL}`], { allowFail: true }); // replace a previous install
+    run("launchctl", ["bootstrap", domain, plistPath]);
+    run("launchctl", ["kickstart", "-k", `${domain}/${SERVICE_LABEL}`], { allowFail: true });
+    log(`LaunchAgent installed: ${plistPath}`);
+    return { kind, definition: plistPath, log: logPath };
+  }
+  if (kind === "systemd") {
+    const unitPath = systemdUnitPath(home);
+    fs.mkdirSync(path.dirname(unitPath), { recursive: true });
+    fs.writeFileSync(unitPath, systemdUnit({ node, script, config, home, logPath, pathEnv: env.PATH }), { mode: 0o644 });
+    run("systemctl", ["--user", "daemon-reload"]);
+    run("systemctl", ["--user", "enable", "--now", "cookbook-bridge.service"]);
+    run("systemctl", ["--user", "restart", "cookbook-bridge.service"], { allowFail: true });
+    log(`systemd user unit installed: ${unitPath} (run \`loginctl enable-linger $USER\` once if this machine has no desktop session)`);
+    return { kind, definition: unitPath, log: logPath };
+  }
+  // Windows: a hidden launcher in the Startup folder. No admin, no Task Scheduler.
+  const p = windowsLauncherPaths(home, env);
+  try { fs.rmSync(stopFilePath(home), { force: true }); } catch { /* none */ }
+  fs.writeFileSync(p.cmd, windowsCmdScript({ node, script, config, logPath, stopFile: stopFilePath(home) }));
+  fs.writeFileSync(p.vbs, windowsVbsScript({ cmdPath: p.cmd }));
+  fs.mkdirSync(path.dirname(p.startup), { recursive: true });
+  fs.copyFileSync(p.vbs, p.startup);
+  // Start it now, detached and windowless, the same way the Startup folder will.
+  const child = spawn("wscript.exe", ["//B", p.vbs], { detached: true, stdio: "ignore", windowsHide: true });
+  child.on("error", () => {});
+  child.unref();
+  log(`Startup launcher installed: ${p.startup}`);
+  return { kind, definition: p.startup, log: logPath };
+}
+
+/** Stop the service and remove its definition. Leaves the runtime, config and log. */
+export function uninstallService({ platform = process.platform, home = os.homedir(), env = process.env, config = defaultConfigPath(home), log = () => {} } = {}) {
+  const kind = serviceKind(platform);
+  const removed = [];
+  if (kind === "launchd") {
+    const domain = `gui/${typeof process.getuid === "function" ? process.getuid() : 501}`;
+    run("launchctl", ["bootout", `${domain}/${SERVICE_LABEL}`], { allowFail: true });
+    const plistPath = launchdPlistPath(home);
+    if (fs.existsSync(plistPath)) { fs.rmSync(plistPath, { force: true }); removed.push(plistPath); }
+  } else if (kind === "systemd") {
+    run("systemctl", ["--user", "disable", "--now", "cookbook-bridge.service"], { allowFail: true });
+    const unitPath = systemdUnitPath(home);
+    if (fs.existsSync(unitPath)) { fs.rmSync(unitPath, { force: true }); removed.push(unitPath); }
+    run("systemctl", ["--user", "daemon-reload"], { allowFail: true });
+  } else if (kind === "startup") {
+    const p = windowsLauncherPaths(home, env);
+    fs.writeFileSync(stopFilePath(home), String(Date.now())); // the loop exits on its next turn
+    for (const f of [p.startup, p.vbs, p.cmd]) if (fs.existsSync(f)) { fs.rmSync(f, { force: true }); removed.push(f); }
+  }
+  const pid = runningPid(config);
+  if (pid) {
+    try {
+      if (platform === "win32") run("taskkill", ["/PID", String(pid), "/T", "/F"], { allowFail: true });
+      else process.kill(pid, "SIGTERM");
+      log(`Stopped the running Bridge (pid ${pid}).`);
+    } catch { /* already gone */ }
+  }
+  return { kind, removed };
+}
+
+/** Restart the supervised Bridge (the supervisor brings it back on the new code/config). */
+export function restartService({ platform = process.platform, home = os.homedir(), config = defaultConfigPath(home) } = {}) {
+  const kind = serviceKind(platform);
+  if (kind === "launchd") {
+    const domain = `gui/${typeof process.getuid === "function" ? process.getuid() : 501}`;
+    run("launchctl", ["kickstart", "-k", `${domain}/${SERVICE_LABEL}`]);
+    return true;
+  }
+  if (kind === "systemd") { run("systemctl", ["--user", "restart", "cookbook-bridge.service"]); return true; }
+  const pid = runningPid(config);
+  if (pid) { run("taskkill", ["/PID", String(pid), "/T", "/F"], { allowFail: true }); return true; }
+  return false;
+}
+
+/** Wait for the service's Bridge to write local.json with a live pid. */
+export async function waitForBridge(config, { timeoutMs = 25_000, everyMs = 500 } = {}) {
+  const until = Date.now() + timeoutMs;
+  while (Date.now() < until) {
+    const pid = runningPid(config);
+    if (pid) return pid;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+  return null;
+}

package/synthesis.mjs

@@ -3,7 +3,7 @@
  *
  * The server composes a prompt and queues it; this Bridge claimed it on a pull
  * and now runs it through the claude CLI (your plan, your machine) and posts
- * the text back. Four kinds share one lane:
+ * the text back. Five kinds share one lane:
  *
  *   summary  workspace summary        text in, text out, no tools
  *   caption  file captions            text in, text out, no tools
@@ -12,6 +12,10 @@
  *                                     folder, claude runs with cwd = that folder
  *                                     and ONLY the Read tool, the folder is
  *                                     deleted afterwards (always, even on timeout)
+ *   probe    one AI-visibility sample a buyer prompt; variant "model" runs with
+ *                                     no tools, variant "search" with WebSearch
+ *                                     only (allowed up front: print mode denies
+ *                                     any tool that is not on --allowedTools)
  *
  * `--strict-mcp-config` with an empty set removes every MCP server; `--tools ""`
  * removes every built-in tool (Read, Bash, Write, WebFetch...) for the text
@@ -23,6 +27,7 @@
  * Jobs are queued FIFO and drained one at a time. A pull that lands while a run
  * is in progress only enqueues; nothing is dropped. Zero dependencies.
  */
+import { isSignedOutError } from "./plan.mjs";
 import { spawn } from "node:child_process";
 import fsp from "node:fs/promises";
 import os from "node:os";
@@ -30,9 +35,11 @@ import path from "node:path";
 
 export const SYNTHESIS_TIMEOUT_MS = 180_000;
 export const VISION_TIMEOUT_MS = 240_000;
+export const PROBE_TIMEOUT_MS = 120_000;
 export const RESULT_MAX_CHARS = 8_000;
 export const IMAGE_MAX_BYTES_DEFAULT = 5 * 1024 * 1024;
-export const KINDS = ["summary", "caption", "vision", "answer"];
+export const KINDS = ["summary", "caption", "vision", "answer", "probe"];
+export const PROBE_VARIANTS = ["model", "search"];
 export const MODELS = ["haiku", "sonnet"];
 export const DEFAULT_MODEL = "haiku";
 export const IMAGE_PLACEHOLDER = "{{IMAGE_FILE}}";
@@ -68,9 +75,16 @@ export function modelFor(job) {
   return MODELS.includes(job?.model) ? job.model : DEFAULT_MODEL;
 }
 
-/** Wall clock per kind: a picture takes longer to read. Pure. */
+/** Wall clock per kind: a picture takes longer to read, a probe is capped short. Pure. */
 export function timeoutForKind(kind) {
-  return kind === "vision" ? VISION_TIMEOUT_MS : SYNTHESIS_TIMEOUT_MS;
+  if (kind === "vision") return VISION_TIMEOUT_MS;
+  if (kind === "probe") return PROBE_TIMEOUT_MS;
+  return SYNTHESIS_TIMEOUT_MS;
+}
+
+/** A probe job's variant, or null when it is not one of the two lanes. Pure. */
+export function variantOf(job) {
+  return PROBE_VARIANTS.includes(job?.variant) ? job.variant : null;
 }
 
 /** File extension for an image MIME type; null for anything we will not write to disk. Pure. */
@@ -97,11 +111,15 @@ export function scrubUrls(text) {
 }
 
 /** The argv a synthesis run gets: print mode, text out, no MCP, and either no
- *  built-in tools (text kinds) or Read only (vision). The prompt travels on
- *  stdin (never argv: no length limit, no shell quoting). Pure. */
-export function argsForKind(kind, { model } = {}) {
+ *  built-in tools (text kinds), Read only (vision), or WebSearch only (a probe
+ *  in its "search" variant; `--allowedTools` too, because print mode refuses a
+ *  tool nobody granted). The prompt travels on stdin (never argv: no length
+ *  limit, no shell quoting). Pure. */
+export function argsForKind(kind, { model, variant } = {}) {
   const args = ["-p", "--output-format", "text", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}'];
-  args.push("--tools", kind === "vision" ? "Read" : "");
+  if (kind === "vision") args.push("--tools", "Read");
+  else if (kind === "probe" && variant === "search") args.push("--tools", "WebSearch", "--allowedTools", "WebSearch");
+  else args.push("--tools", "");
   if (model) args.push("--model", model);
   return args;
 }
@@ -118,6 +136,7 @@ export function validateJob(job) {
   if (typeof job.prompt !== "string" || !job.prompt) return "job has no prompt";
   const kind = kindOf(job);
   if (!KINDS.includes(kind)) return `unsupported synthesis kind: ${kind}`;
+  if (kind === "probe") return variantOf(job) ? null : `probe job has no variant (model or search)`;
   if (kind !== "vision") return null;
   const img = job.image;
   if (!img || typeof img !== "object") return "vision job has no image";
@@ -138,6 +157,11 @@ export function imageMaxBytes(image) {
 /** One log line per job. Never includes the prompt or the image URL. Pure. */
 export function describeJob(job) {
   const kind = kindOf(job);
+  if (kind === "probe") {
+    const group = String(job?.group ?? "?").slice(0, 8);
+    const id = Number.isInteger(Number(job?.prompt_id)) ? Number(job.prompt_id) : "?";
+    return `probe: ${group} #${id} (${variantOf(job) ?? "?"})`;
+  }
   const n = Number(job?.files);
   const files = Number.isInteger(n) && n > 0 ? ` (${n} file${n === 1 ? "" : "s"})` : "";
   return `${kind}${files}`;
@@ -162,6 +186,7 @@ function runClaude(bin, prompt, { args, env, cwd, timeoutMs } = {}) {
       const text = trimResult(out);
       if (timedOut) resolve({ ok: false, timedOut: true, error: `timed out after ${Math.round((timeoutMs ?? SYNTHESIS_TIMEOUT_MS) / 1000)}s` });
       else if (code === 0 && text) resolve({ ok: true, text });
+      else if (isSignedOutError(err)) resolve({ ok: false, error: "Claude is signed out on this machine: open a terminal, run `claude`, and sign in" });
       else resolve({ ok: false, error: `exit ${code}: ${err.trim().slice(0, 300) || "(no stderr)"}` });
     });
     child.stdin.write(String(prompt));
@@ -172,11 +197,29 @@ function runClaude(bin, prompt, { args, env, cwd, timeoutMs } = {}) {
 /** Run with the requested model alias; if the CLI rejects it (non-zero exit,
  *  e.g. an older CLI that does not know the alias) run once more without
  *  --model. A timeout is not a rejected alias, so it is not retried. */
-async function runWithFallback(bin, prompt, { kind, model, env, cwd }) {
+async function runWithFallback(bin, prompt, { kind, model, variant, env, cwd }) {
   const timeoutMs = timeoutForKind(kind);
-  let r = await runClaude(bin, prompt, { args: argsForKind(kind, { model }), env, cwd, timeoutMs });
-  if (!r.ok && !r.timedOut && model) r = await runClaude(bin, prompt, { args: argsForKind(kind), env, cwd, timeoutMs });
-  return r;
+  // A probe measures what a STRANGER's Claude would say, so it must run in a
+  // fresh empty directory: Claude Code loads its per-directory auto-memory and
+  // any CLAUDE.md from the cwd, and the Bridge's own cwd is full of Cookbook.
+  // (The 2026-09-03 baseline run leaked "your existing Cookbook setup" this way.)
+  let scratch = null;
+  if (kind === "probe" && !cwd) {
+    scratch = await fsp.mkdtemp(path.join(os.tmpdir(), "cookbook-probe-"));
+    cwd = scratch;
+  }
+  try {
+    let r = await runClaude(bin, prompt, { args: argsForKind(kind, { model, variant }), env, cwd, timeoutMs });
+    if (!r.ok && !r.timedOut && model) r = await runClaude(bin, prompt, { args: argsForKind(kind, { variant }), env, cwd, timeoutMs });
+    return r;
+  } finally {
+    if (scratch) await fsp.rm(scratch, { recursive: true, force: true }).catch(() => { /* best effort */ });
+  }
+}
+
+/** Where a probe runs: a fresh temp dir, never the Bridge's own cwd. Pure. */
+export function probeNeedsScratchCwd(kind, cwd) {
+  return kind === "probe" && !cwd;
 }
 
 /** Download the job's image into `dir` as image.<ext>. Refuses non-https, unknown
@@ -225,7 +268,8 @@ async function defaultRun(job, { cfg, env }) {
   if (!bin) return { ok: false, error: "no Claude CLI configured on this Bridge" };
   const kind = kindOf(job);
   const model = modelFor(job);
-  if (kind !== "vision") return runWithFallback(bin, job.prompt, { kind, model, env });
+  const variant = variantOf(job);
+  if (kind !== "vision") return runWithFallback(bin, job.prompt, { kind, model, variant, env });
   let dir = null;
   try {
     dir = await fsp.mkdtemp(path.join(os.tmpdir(), "cookbook-vision-"));
@@ -275,13 +319,15 @@ async function runOne(entry) {
   const run = opts.run ?? defaultRun;
   const report = opts.report ?? defaultReport;
   const label = describeJob(job);
+  // A probe announces itself as "probe: A #3 (search)"; the rest as "synthesis: <kind>".
+  const head = kindOf(job) === "probe" ? label : `synthesis: ${label}`;
   const invalid = validateJob(job);
   if (invalid) {
     await report(cfg, job.id, { error: invalid });
-    log?.(`! synthesis ${label} refused: ${invalid}`);
+    log?.(`! ${head} refused: ${invalid}`);
     return;
   }
-  log?.(`◇ synthesis: ${label} on your subscription`);
+  log?.(`◇ ${head} on your subscription`);
   const t0 = Date.now();
   let r;
   try {
@@ -292,11 +338,11 @@ async function runOne(entry) {
   const secs = Math.round((Date.now() - t0) / 1000);
   if (r?.ok) {
     const posted = await report(cfg, job.id, { result: trimResult(r.text) });
-    log?.(`◇ synthesis: ${label} done in ${secs}s${posted ? "" : " (post failed)"}`);
+    log?.(`◇ ${head} done in ${secs}s${posted ? "" : " (post failed)"}`);
   } else {
     const error = scrubUrls(r?.error ?? "unknown error");
     await report(cfg, job.id, { error });
-    log?.(`! synthesis ${label} failed after ${secs}s: ${error}`);
+    log?.(`! ${head} failed after ${secs}s: ${error}`);
   }
 }
 

package/update.mjs

@@ -117,6 +117,9 @@ export function locateConfig(args = [], opts = {}) {
 export function installLayout(here = HERE) {
   const n = String(here).replace(/\\/g, "/") + "/";
   if (n.includes("/_npx/") || n.includes("/node_modules/cookbook-bridge/")) return "npm";
+  // The service runtime (~/.cookbook/bridge, service.mjs) is reached through npx too:
+  // its hints must read `npx cookbook-bridge@latest …`, never `node bridge/bridge.mjs`.
+  if (n.endsWith("/.cookbook/bridge/")) return "npm";
   return "tarball";
 }