starbridge 0.1.0 → 0.1.1

package/dist/starbridge.js

@@ -4056,7 +4056,7 @@ var require_png = __commonJS(function(exports) {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 import { parseArgs } from "node:util";
 
 // ../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
@@ -9651,7 +9651,7 @@ function duration2(params) {
 }
 // ../packages/protocol/src/client.ts
 var CLIENT_HEADER = "starbridge-client";
-var CLIENT_NAMES = ["cli", "android", "web", "mod"];
+var CLIENT_NAMES = ["cli", "android", "web", "mod", "desktop"];
 function clientHeader(name, version) {
   return `${name}/${version}`;
 }
@@ -13901,30 +13901,65 @@ function activeMembers(dir, role) {
   return [...dir.members.values()].filter((e) => e.active && e.member.role === role).map((e) => e.member);
 }
 // ../packages/protocol/src/heads.ts
+function revocationOf(entries, id) {
+  for (const raw of entries) {
+    const env = SignedEnvelope.safeParse(raw);
+    if (!env.success)
+      continue;
+    const body = JSON.parse(env.data.body);
+    if (body.op === "revoke" && body.id === id)
+      return { id, by: env.data.signer, at: body.at ?? "" };
+  }
+  return;
+}
+function removed(dir, entries, id) {
+  if (dir.members.get(id)?.active !== false)
+    return false;
+  let revokedAt = -1;
+  let recoveredAt = -1;
+  entries.forEach((raw, i) => {
+    const env = SignedEnvelope.safeParse(raw);
+    if (!env.success)
+      return;
+    const body = JSON.parse(env.data.body);
+    if (body.op === "revoke" && body.id === id)
+      revokedAt = i;
+    if (body.op === "recover")
+      recoveredAt = i;
+  });
+  return recoveredAt > revokedAt;
+}
 function noteHead(heads, signer, head, entries, dir) {
   if (!head)
     return false;
   const by = head.by && head.by !== signer ? head.by : undefined;
+  if (by && dir?.members.get(by)?.active === false)
+    return false;
   const key = !by ? signer : dir && !dir.members.has(by) ? `${signer}/?` : `${signer}/${by}`;
   const known = heads[key];
-  const dropped = !!known?.by && dir?.members.get(known.by)?.active === false;
+  const dropped = !!known?.by && !!dir && removed(dir, entries, known.by);
   const replace = !known || dropped || head.length > known.length || holdsHead(entries, known) && !holdsHead(entries, head);
   if (replace)
     heads[key] = head;
   return replace;
 }
 function withheldBy(heads, dir, entries) {
+  let fork;
   for (const [key, head] of Object.entries(heads)) {
     const id = key.split("/")[0];
     const by = head.by && head.by !== id ? head.by : undefined;
-    if (!dir.members.get(id)?.active)
+    if (!dir.members.has(id) || removed(dir, entries, id))
       continue;
-    if (by && dir.members.get(by)?.active === false)
+    if (by && removed(dir, entries, by))
       continue;
-    if (!holdsHead(entries, head))
+    if (holdsHead(entries, head))
+      continue;
+    const revoked = (dir.members.get(id)?.active ? undefined : revocationOf(entries, id)) ?? (by && dir.members.get(by)?.active === false ? revocationOf(entries, by) : undefined);
+    if (!revoked)
       return { id, ...by ? { by } : {}, head };
+    fork ??= { id, ...by ? { by } : {}, head, revoked };
   }
-  return;
+  return fork;
 }
 // ../packages/protocol/src/images.ts
 var label = concat(utf8("starbridge/v1/image"), new Uint8Array([0]));
@@ -13966,7 +14001,19 @@ function formatPairingCode(code) {
   return (code.rendezvous + code.secret).match(/.{4}/g)?.join("-") ?? "";
 }
 function pairingLink(server, code) {
-  return `${server.replace(/\/+$/, "")}/pair#${formatPairingCode(code)}`;
+  let end = server.length;
+  while (end > 0 && server[end - 1] === "/")
+    end--;
+  return `${server.slice(0, end)}/pair#${formatPairingCode(code)}`;
+}
+function appPairingLink(server, code, checkKey) {
+  let end = server.length;
+  while (end > 0 && server[end - 1] === "/")
+    end--;
+  return `starbridge://pair?server=${encodeURIComponent(server.slice(0, end))}&k=${checkKey}#${formatPairingCode(code)}`;
+}
+function newCheckKey() {
+  return encodeCrockford(libsodium_wrappers_default.randombytes_buf(10));
 }
 function newClaimSecret() {
   return toB64(libsodium_wrappers_default.randombytes_buf(32));
@@ -13993,7 +14040,8 @@ var PairingApprovalBody = object({
   account: Id,
   length: number2().int().positive(),
   head: B64,
-  approver: Id
+  approver: Id,
+  check: B64.optional()
 });
 var PairingMessage = object({ body: string2(), mac: B64 });
 function macMessage(kind, body) {
@@ -14035,6 +14083,33 @@ function checkJoined(dir, me) {
   if (!entry?.active || entry.member.role !== me.role || entry.member.boxPk !== me.boxPk || entry.member.signPk !== me.signPk)
     throw new ProtocolError("unknown-member", "the directory does not hold my keys");
 }
+function checkInput(entries, id) {
+  const nul = new Uint8Array([0]);
+  for (const e of entries) {
+    const { body, sig } = e ?? {};
+    if (typeof body !== "string" || typeof sig !== "string")
+      continue;
+    const parsed = JSON.parse(body);
+    if (parsed.op !== "add" || parsed.member?.id !== id)
+      continue;
+    return concat(utf8("starbridge/v1/check"), nul, utf8(body), nul, utf8(sig));
+  }
+  throw new ProtocolError("unknown-member", `no add entry for ${id}`);
+}
+function checkCode(entries, id) {
+  const hash = libsodium_wrappers_default.crypto_generichash(32, checkInput(entries, id), null);
+  return encodeCrockford(hash.subarray(0, 10)).match(/.{4}/g).join("-");
+}
+function checkKeyBytes(key) {
+  return libsodium_wrappers_default.crypto_generichash(32, concat(utf8("starbridge/v1/check-key"), new Uint8Array([0]), utf8(key)), null);
+}
+function verifyCheckProof(entries, id, key, proof) {
+  try {
+    return libsodium_wrappers_default.crypto_auth_verify(fromB64(proof), checkInput(entries, id), checkKeyBytes(key));
+  } catch {
+    return false;
+  }
+}
 
 // ../packages/protocol/src/join.ts
 var JoinRequestBody = object({
@@ -14171,6 +14246,17 @@ function checkPermissionAnswer(asked, answer, device, now = Date.now()) {
   if (now > Date.parse(asked.expiresAt))
     throw new ProtocolError("expired");
 }
+// ../packages/protocol/src/presence.ts
+var PRESENCE_INPUT_MS = 60000;
+var PRESENCE_BEAT_MS = 30000;
+var Presence = object({ present: boolean2() });
+var PUSH_HOLD_MAX = 300;
+var AccountSettings = object({
+  pushHold: number2().int().min(0).max(PUSH_HOLD_MAX)
+});
+function isPresent(screen) {
+  return !screen.locked && screen.idleMs >= 0 && screen.idleMs < PRESENCE_INPUT_MS;
+}
 // src/agent/client.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
@@ -14273,7 +14359,7 @@ function processAlive(pid) {
 // package.json
 var package_default = {
   name: "starbridge",
-  version: "0.1.0",
+  version: "0.1.1",
   description: "Post decisions to your Starbridge devices and upload quota windows from CodexBar",
   license: "MIT",
   repository: {
@@ -14344,8 +14430,9 @@ function configDir(env) {
 }
 var PROMPTS_OPEN = "permissions-open";
 var CLI_PATH = "cli-path";
+var PICKER_MAX_MS = 86400000;
 function promptsMark(s, now = Date.now()) {
-  const open = Object.values(s.permissions ?? {}).some((p) => !p.settled && Date.parse(p.permission.expiresAt) > now);
+  const open = Object.values(s.permissions ?? {}).some((p) => !p.settled && Date.parse(p.permission.expiresAt) > now) || Object.entries(s.asked).some(([id, a]) => a.picker && !a.settled && !s.answers[id] && Date.parse(a.askedAt) > now - PICKER_MAX_MS);
   return open ? "open" : "";
 }
 var STATE_VERSION = 1;
@@ -14800,6 +14887,9 @@ class Api {
     const r = await this.call("GET", "/quota/senders", { signal: AbortSignal.timeout(15000) });
     return r.json.senders;
   }
+  async presence(present, signal) {
+    await this.call("PUT", "/presence", { body: { present }, ...signal ? { signal } : {} });
+  }
   async postItem(item, signal) {
     await this.call("POST", "/items", { body: item, ...signal ? { signal } : {} });
   }
@@ -14865,20 +14955,12 @@ function signedHead(dir) {
   return { length: dir.length, head: dir.head };
 }
 function withheld(st, dir, entries) {
-  const heads = st.heads ?? {};
-  const held = withheldBy(heads, dir, entries);
-  if (held)
-    return `the server is holding back directory entries ${held.id} has seen (${held.head.length}, this machine has ${dir.length})`;
-  for (const [id, head] of Object.entries(heads))
-    if (!holdsHead(entries, head) && revokes(entries, id))
-      return `${id} signed a chain this machine does not hold (${head.length}), and this machine's chain revokes it: the server may be serving a fork. If you revoked ${id} because it was compromised, run \`starbridge pair --force\``;
-  return;
-}
-function revokes(entries, id) {
-  return entries.some((e) => {
-    const body = JSON.parse(e.body);
-    return body.op === "revoke" && body.id === id;
-  });
+  const held = withheldBy(st.heads ?? {}, dir, entries);
+  if (!held)
+    return;
+  if (held.revoked)
+    return `${held.id} signed a chain this machine does not hold (${held.head.length}), and this machine's chain revokes it: the server may be serving a fork. If you revoked ${held.id} because it was compromised, run \`starbridge pair --force\``;
+  return `the server is holding back directory entries ${held.id} has seen (${held.head.length}, this machine has ${dir.length})`;
 }
 function devices(ctx, dir) {
   const behind = withheld(ctx.store.state(), dir, ctx.store.directory().slice(0, dir.length));
@@ -15621,6 +15703,7 @@ function prune(st, now) {
     if (Date.parse(p.permission.expiresAt) + KEEP_MS < now)
       delete st.permissions?.[id];
 }
+var LATE_REPORT_MS = 5000;
 async function postPermission(ctx, s, hook, opts, signal) {
   const dir = await refreshDirectory(ctx, s, signal);
   const to = devices(ctx, dir);
@@ -15648,7 +15731,9 @@ async function postPermission(ctx, s, hook, opts, signal) {
     await s.api.postItem(item, signal);
   } catch (e) {
     const keyboard = signal?.aborted && signal.reason?.name !== "TimeoutError";
-    markSettled(ctx, permission.id, keyboard ? "keyboard" : "timeout");
+    const how = markSettled(ctx, permission.id, keyboard ? "keyboard" : "timeout");
+    if (how)
+      await postSettled(ctx, s, permission.id, how, AbortSignal.timeout(LATE_REPORT_MS)).catch(() => {});
     throw e;
   }
   return permission.id;
@@ -15871,7 +15956,8 @@ async function postDecision(ctx, s, input) {
       ...decision.done ? { done: true } : {},
       ...input.codex && decision.source.session ? { codex: input.codex } : {},
       ...input.extensionAnswers && decision.source.session ? { extensionAnswers: true } : {},
-      ...input.held ? { held: true } : {}
+      ...input.held ? { held: true } : {},
+      ...input.picker ? { picker: input.picker } : {}
     };
   });
   if (input.waiting)
@@ -16993,6 +17079,11 @@ starbridge run --title 'Mac e2e' --reason 'takes over your screen and keyboard'
 
 Wrap the whole command, chained or not. \`--reason\` is required: what it
 blocks, or the rule it matches. Output and exit code are the command's own.
+
+In Codex, ask to run \`starbridge run\` outside the sandbox on the first call
+(escalated permissions, justified by the network the report needs). In the
+sandbox the command runs but no device hears of it, and it runs again once
+the escalation is approved.
 `;
 
 // src/setup/marker.ts
@@ -17027,7 +17118,7 @@ import { configDir } from "./poller.ts";
 
 /** The agent API revision this mod speaks, sent in the \`starbridge-api\` header. */
 export const API = 1;
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.1";
 const CLIENT = \`starbridge-mod/\${VERSION}\`;
 
 /** Event types this mod submits; others are skipped and left unconfirmed, as the API asks. */
@@ -17817,6 +17908,19 @@ var switch_default = `/**
 import type { AgentLoop } from "./agent.ts";
 import type { Poller } from "./poller.ts";
 
+/** Entry points of a run that ends with its last turn: \`claude -p\` and Agent SDK scripts. */
+const ONE_SHOT = new Set(["sdk-cli", "sdk-ts", "sdk-py"]);
+
+/**
+ * Whether a session gets an answer loop: one under the REPL, or one a host such as Claude
+ * desktop's Code tab or an IDE keeps open for a person (#863). The engine calls those not
+ * interactive, as it does a \`claude -p\` run, so the host's \`CLAUDE_CODE_ENTRYPOINT\` tells them
+ * apart; a run with none set is \`claude -p\`'s own.
+ */
+export function wantsLoop(isInteractive: boolean, entrypoint: string | undefined): boolean {
+  return isInteractive || (!!entrypoint && !ONE_SHOT.has(entrypoint));
+}
+
 export interface Paths {
   /** True when an agent answers \`GET /v1/status\` with a 2xx. */
   agentUp(): Promise<boolean>;
@@ -18524,6 +18628,7 @@ function run(sys, cmd, args, opts = {}) {
     const child = spawn3(start.file, start.args, {
       windowsVerbatimArguments: start.windowsVerbatimArguments,
       env: { ...sys.ctx.env, ...opts.env },
+      ...opts.cwd ? { cwd: opts.cwd } : {},
       stdio: [
         opts.input === undefined ? "ignore" : "pipe",
         opts.inherit ? "inherit" : "pipe",
@@ -18649,6 +18754,7 @@ var PI_PACKAGE = piSource(VERSION);
 function hasPi(sys) {
   return which(sys.ctx.env, "pi") !== undefined;
 }
+var STARBRIDGE_PI = /github\.com[/:]T0mSIlver\/starbridge(?:\.git)?\/?(?:@.*)?$/i;
 function piPackage(sys) {
   const dir = sys.ctx.env.PI_CODING_AGENT_DIR || join7(sys.home, ".pi", "agent");
   let packages;
@@ -18661,7 +18767,7 @@ function piPackage(sys) {
     return;
   for (const p of packages) {
     const source = typeof p === "string" ? p : p?.source;
-    if (typeof source === "string" && /github\.com[/:]T0mSIlver\/starbridge\b/i.test(source))
+    if (typeof source === "string" && STARBRIDGE_PI.test(source))
       return source;
   }
   return;
@@ -19561,16 +19667,234 @@ class Permissions {
   }
 }
 
+// src/screen.ts
+import { execFile, spawn as spawn4 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
+var TIMEOUT_MS = 5000;
+var exec = (cmd, args) => new Promise((resolve) => {
+  execFile(cmd, args, { timeout: TIMEOUT_MS, windowsHide: true }, (err, stdout) => resolve(err ? undefined : String(stdout)));
+});
+function macIdleMs(ioreg) {
+  const m = /"HIDIdleTime"\s*=\s*(\d+)/.exec(ioreg);
+  return m ? Number(m[1]) / 1e6 : undefined;
+}
+function macLocked(ioreg) {
+  return /"CGSSessionScreenIsLocked"\s*=\s*Yes/.test(ioreg);
+}
+async function readMac(run) {
+  const [hid, root] = await Promise.all([
+    run("ioreg", ["-c", "IOHIDSystem", "-d", "4", "-r", "-k", "HIDIdleTime"]),
+    run("ioreg", ["-n", "Root", "-d1"])
+  ]);
+  const idleMs = hid === undefined ? undefined : macIdleMs(hid);
+  if (idleMs === undefined || root === undefined)
+    return;
+  return { locked: macLocked(root), idleMs };
+}
+function properties(text) {
+  const out = {};
+  for (const line of text.split(`
+`)) {
+    const i = line.indexOf("=");
+    if (i > 0)
+      out[line.slice(0, i)] = line.slice(i + 1).trim();
+  }
+  return out;
+}
+function graphical(sessions) {
+  return sessions.map(properties).filter((p) => p.Active === "yes" && (p.Type === "x11" || p.Type === "wayland") && p.Class === "user").map((p) => ({ locked: p.LockedHint === "yes" }));
+}
+function linuxIdleMs(text) {
+  const m = /^\(?(?:uint64\s+)?(\d+),?\)?\s*$/.exec(text.trim());
+  return m ? Number(m[1]) : undefined;
+}
+async function readLinux(run) {
+  const list = await run("loginctl", ["list-sessions", "--no-legend", "--no-pager"]);
+  const ids = (list ?? "").split(`
+`).map((l) => l.trim().split(/\s+/)[0]).filter((id) => !!id);
+  const shown = await Promise.all(ids.map((id) => run("loginctl", [
+    "show-session",
+    id,
+    "-p",
+    "Type",
+    "-p",
+    "Active",
+    "-p",
+    "Class",
+    "-p",
+    "LockedHint"
+  ])));
+  const screens = graphical(shown.filter((s) => s !== undefined));
+  if (screens.length === 0)
+    return;
+  const idle = await run("gdbus", [
+    "call",
+    "--session",
+    "--dest",
+    "org.gnome.Mutter.IdleMonitor",
+    "--object-path",
+    "/org/gnome/Mutter/IdleMonitor/Core",
+    "--method",
+    "org.gnome.Mutter.IdleMonitor.GetIdletime"
+  ]) ?? await run("xprintidle", []);
+  const idleMs = idle === undefined ? undefined : linuxIdleMs(idle);
+  if (idleMs === undefined)
+    return;
+  return { locked: screens.every((s) => s.locked), idleMs };
+}
+var WINDOWS_SCRIPT = `
+Add-Type @'
+using System; using System.Runtime.InteropServices;
+public static class Idle {
+  [StructLayout(LayoutKind.Sequential)] struct LASTINPUTINFO { public uint cbSize; public uint dwTime; }
+  [DllImport("user32.dll")] static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
+  public static long Ms() {
+    var i = new LASTINPUTINFO(); i.cbSize = (uint)Marshal.SizeOf(i);
+    if (!GetLastInputInfo(ref i)) return -1;
+    return (long)unchecked((uint)Environment.TickCount - i.dwTime);
+  }
+}
+'@
+$session = (Get-Process -Id $PID).SessionId
+while ($null -ne [Console]::In.ReadLine()) {
+  $locked = @(Get-Process LogonUI -ErrorAction SilentlyContinue | Where-Object { $_.SessionId -eq $session }).Count -gt 0
+  [Console]::Out.WriteLine("$([Idle]::Ms()) $locked")
+}
+`;
+function windowsScreen(line) {
+  const m = /^(-?\d+) (True|False)$/.exec(line.trim());
+  if (!m || Number(m[1]) < 0)
+    return;
+  return { idleMs: Number(m[1]), locked: m[2] === "True" };
+}
+
+class WindowsReader {
+  child;
+  pending = [];
+  read() {
+    const child = this.start();
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => done(undefined), TIMEOUT_MS);
+      const done = (line) => {
+        clearTimeout(timer);
+        resolve(line === undefined ? undefined : windowsScreen(line));
+      };
+      this.pending.push(done);
+      child.stdin?.write(`
+`);
+    });
+  }
+  start() {
+    if (this.child && this.child.exitCode === null)
+      return this.child;
+    const child = spawn4("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "-"], { stdio: ["pipe", "pipe", "ignore"], windowsHide: true });
+    child.stdin?.write(`${WINDOWS_SCRIPT}
+`);
+    createInterface2({ input: child.stdout }).on("line", (line) => this.pending.shift()?.(line));
+    const gone = () => {
+      if (this.child === child)
+        this.child = undefined;
+      for (const p of this.pending.splice(0))
+        p(undefined);
+    };
+    child.on("exit", gone);
+    child.on("error", gone);
+    this.child = child;
+    return child;
+  }
+  stop() {
+    this.child?.kill();
+    this.child = undefined;
+  }
+}
+function screenReader(platform = process.platform, run = exec) {
+  if (platform === "darwin")
+    return { read: () => readMac(run), stop: () => {} };
+  if (platform === "linux")
+    return { read: () => readLinux(run), stop: () => {} };
+  if (platform === "win32") {
+    const reader = new WindowsReader;
+    return { read: () => reader.read(), stop: () => reader.stop() };
+  }
+  return { read: async () => {
+    return;
+  }, stop: () => {} };
+}
+
+// src/agent/presence.ts
+var READ_MS = 1e4;
+function presenceEnabled(hub) {
+  return hub.ctx.store.agentConfig().presence?.enabled === true;
+}
+
+class Presence2 {
+  hub;
+  reader;
+  sent;
+  lastError;
+  constructor(hub, reader = screenReader()) {
+    this.hub = hub;
+    this.reader = reader;
+  }
+  status(into) {
+    into.presence = {
+      enabled: presenceEnabled(this.hub),
+      present: this.sent?.present === true,
+      ...this.lastError ? { lastError: this.lastError } : {}
+    };
+  }
+  async send(present, signal) {
+    const ctx = this.hub.ctx;
+    if (!ctx.store.machine())
+      return;
+    try {
+      await session(ctx).api.presence(present, signal ?? AbortSignal.timeout(1e4));
+      this.sent = { present, at: Date.now() };
+      this.lastError = undefined;
+    } catch (e) {
+      this.lastError = e.message;
+    }
+  }
+  async tick(now = Date.now()) {
+    const screen = presenceEnabled(this.hub) ? await this.reader.read() : undefined;
+    const present = screen !== undefined && isPresent(screen);
+    if (present) {
+      if (!this.sent?.present || now - this.sent.at >= PRESENCE_BEAT_MS)
+        await this.send(true);
+    } else if (this.sent?.present)
+      await this.send(false);
+  }
+  async run(signal) {
+    while (!signal.aborted) {
+      await this.tick();
+      await pause(READ_MS, signal);
+    }
+    if (this.sent?.present)
+      await this.send(false, AbortSignal.timeout(3000));
+    this.reader.stop();
+  }
+}
+
 // src/quota.ts
 import { randomBytes as randomBytes6 } from "node:crypto";
 
 // src/codexbar.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var RUN_TIMEOUT_MS = 120000;
 function runCodexbar(bin, provider, timeoutMs = RUN_TIMEOUT_MS) {
   const args = ["usage", "--format", "json", ...provider ? ["--provider", provider] : []];
   return new Promise((resolve) => {
-    const child = spawn4(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let start;
+    try {
+      start = spawnable(bin, args);
+    } catch (e) {
+      return resolve({ code: null, stdout: "", stderr: e.message });
+    }
+    const child = spawn5(start.file, start.args, {
+      windowsVerbatimArguments: start.windowsVerbatimArguments,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => {
@@ -19579,7 +19903,7 @@ function runCodexbar(bin, provider, timeoutMs = RUN_TIMEOUT_MS) {
     child.stderr.on("data", (d) => {
       stderr += d;
     });
-    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    const timer = setTimeout(() => killTree(child), timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
       resolve({ code: null, stdout, stderr: e.message });
@@ -19935,7 +20259,7 @@ class Quota {
 }
 
 // src/run.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { randomBytes as randomBytes7 } from "node:crypto";
 import { constants as constants2 } from "node:os";
 var PROGRESS_MS = 1e4;
@@ -20039,6 +20363,8 @@ class Reporter {
   ctx;
   timing;
   progress;
+  progressSent = false;
+  dirty = false;
   exit;
   lastPost = Number.NEGATIVE_INFINITY;
   inflight;
@@ -20060,7 +20386,8 @@ class Reporter {
     if (JSON.stringify(next) === JSON.stringify(this.progress))
       return;
     this.progress = next;
-    this.schedule(this.timing.progressMs);
+    this.dirty = true;
+    this.schedule(this.progressGap());
   }
   async finish(code) {
     this.exit = { code, at: iso2(this.ctx.now()) };
@@ -20074,6 +20401,9 @@ class Reporter {
     await Promise.race([settled, new Promise((r) => t = setTimeout(r, FINAL_MS))]);
     clearTimeout(t);
   }
+  progressGap() {
+    return this.progressSent ? this.timing.progressMs : 0;
+  }
   schedule(gap) {
     if (this.off || this.exit)
       return;
@@ -20091,11 +20421,14 @@ class Reporter {
     }
     const input = {
       ...this.base,
-      at: iso2(this.ctx.now()),
+      at: this.ctx.now().toISOString(),
       ...this.progress ? { progress: this.progress } : {},
       ...this.exit ? { exit: this.exit } : {}
     };
     this.lastPost = this.ctx.now().getTime();
+    if (this.progress)
+      this.progressSent = true;
+    this.dirty = false;
     this.inflight = this.post(input).catch((e) => {
       if (e instanceof UsageError && !(e instanceof WithheldError))
         this.off = true;
@@ -20108,7 +20441,7 @@ class Reporter {
         this.queued = false;
         this.send();
       } else
-        this.schedule(this.timing.heartbeatMs);
+        this.schedule(this.dirty ? this.progressGap() : this.timing.heartbeatMs);
     });
   }
 }
@@ -20156,7 +20489,7 @@ async function runCommand(ctx, opts) {
   }, opts.post ?? makePoster(ctx), ctx);
   const stdout = opts.stdout ?? process.stdout;
   const stderr = opts.stderr ?? process.stderr;
-  const child = spawn5(start.file, start.args, {
+  const child = spawn6(start.file, start.args, {
     stdio: ["inherit", "pipe", "pipe"],
     windowsVerbatimArguments: start.windowsVerbatimArguments
   });
@@ -20218,7 +20551,13 @@ function makeAgent(ctx, opts = {}) {
   const quota = { providers, intervalMs, ...codexbar ? { codexbar } : {} };
   const agent = new Agent2(ctx, socket, (hub) => {
     const q = new Quota(hub, quota);
-    return [new Decisions(hub, (why) => q.now(why)), q, new Permissions(hub), new Runs(hub)];
+    return [
+      new Decisions(hub, (why) => q.now(why)),
+      q,
+      new Permissions(hub),
+      new Runs(hub),
+      new Presence2(hub)
+    ];
   });
   return agent;
 }
@@ -20260,6 +20599,109 @@ async function runAgent(ctx, opts) {
 
 // src/hook.ts
 import { basename as basename3 } from "node:path";
+
+// src/ran.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
+var RUN_CHECK_MS = 500;
+var SHELLS = new Set(["sh", "dash", "bash", "zsh", "ash", "ksh", "fish", "busybox"]);
+function evalForm(command) {
+  return `eval '${command.replaceAll("'", `'"'"'`)}'`;
+}
+function program(p) {
+  return (p.argv[0] ?? "").split(/\s/)[0]?.split("/").pop() ?? "";
+}
+function runs(p, command) {
+  const quoted = evalForm(command);
+  return SHELLS.has(program(p)) && p.argv.some((a) => a.includes(quoted));
+}
+function descends(pid, root, byPid) {
+  const seen = new Set;
+  for (let p = byPid.get(pid);p && !seen.has(p.pid); p = byPid.get(p.ppid)) {
+    if (p.ppid === root)
+      return true;
+    seen.add(p.pid);
+  }
+  return false;
+}
+function procLinux() {
+  const out = [];
+  for (const name of readdirSync3("/proc")) {
+    const pid = Number(name);
+    if (!Number.isInteger(pid))
+      continue;
+    try {
+      const stat = readFileSync9(`/proc/${pid}/stat`, "utf8");
+      const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      const argv = readFileSync9(`/proc/${pid}/cmdline`, "utf8").split("\x00").filter(Boolean);
+      out.push({ pid, ppid, argv });
+    } catch {}
+  }
+  return out;
+}
+function procPs() {
+  return new Promise((resolve) => execFile2("ps", ["-A", "-ww", "-o", "pid=,ppid=,args="], { maxBuffer: 16 * 1024 * 1024, timeout: 5000 }, (e, stdout) => {
+    if (e)
+      return resolve([]);
+    resolve(stdout.split(`
+`).flatMap((line) => {
+      const m = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line);
+      return m ? [{ pid: Number(m[1]), ppid: Number(m[2]), argv: [m[3]] }] : [];
+    }));
+  }));
+}
+async function processes(platform = process.platform) {
+  if (platform === "linux")
+    return procLinux();
+  if (platform === "win32")
+    return [];
+  return procPs();
+}
+function agentPid(procs, from = process.ppid) {
+  const byPid = new Map(procs.map((p) => [p.pid, p]));
+  for (let pid = from, hops = 0;hops < 4; hops++) {
+    const p = byPid.get(pid);
+    if (!p)
+      return;
+    if (!SHELLS.has(program(p)))
+      return pid;
+    pid = p.ppid;
+  }
+  return;
+}
+function untilRan(signal, command, list = processes, from = process.ppid) {
+  const ran = new AbortController;
+  let timer;
+  let stopped = false;
+  const watch = async () => {
+    const first = await list().catch(() => []);
+    const root = agentPid(first, from);
+    if (root === undefined)
+      return;
+    const before = new Set(first.map((p) => p.pid));
+    const tick = async () => {
+      if (stopped)
+        return;
+      const now = await list().catch(() => []);
+      const byPid = new Map(now.map((p) => [p.pid, p]));
+      if (now.some((p) => !before.has(p.pid) && runs(p, command) && descends(p.pid, root, byPid)))
+        return ran.abort();
+      timer = setTimeout(tick, RUN_CHECK_MS);
+      timer.unref?.();
+    };
+    await tick();
+  };
+  watch();
+  return {
+    signal: signal ? AbortSignal.any([signal, ran.signal]) : ran.signal,
+    stop: () => {
+      stopped = true;
+      clearTimeout(timer);
+    }
+  };
+}
+
+// src/hook.ts
 var SLACK_MS2 = 15000;
 var DIRECT_POLL_SECONDS = 5;
 var REPORT_MS = 5000;
@@ -20288,14 +20730,22 @@ function untilOrphaned(signal, ppid = () => process.ppid) {
     stop: () => clearInterval(timer)
   };
 }
-async function hookPermission(outer, stdin, opts) {
+async function hookPermission(outer, stdin, opts, ran = untilRan) {
   const watch = untilOrphaned(outer.signal);
-  const ctx = { ...outer, signal: watch.signal };
+  let ctx = { ...outer, signal: watch.signal };
+  let started;
   try {
+    const hook = parseHook(stdin);
+    if (hook.tool_name === "AskUserQuestion" && opts.agent === "claude-code")
+      return await racePicker(ctx, outer, hook, opts.wait);
     if (!permissionsEnabled(ctx))
       return 0;
     const agent = agentName(opts.agent);
-    const hook = parseHook(stdin);
+    const command = hook.tool_input?.command;
+    if (agent === "claude-code" && hook.tool_name === "Bash" && typeof command === "string") {
+      started = ran(ctx.signal, command);
+      ctx = { ...ctx, signal: started.signal };
+    }
     const waitMs = opts.wait ? parseDuration(opts.wait) : DEFAULT_WAIT_MS;
     const deadline = ctx.now().getTime() + waitMs;
     const source = permissionSource(hook, ctx.env);
@@ -20305,6 +20755,7 @@ async function hookPermission(outer, stdin, opts) {
   } catch (e) {
     ctx.err(`starbridge: permission prompt not sent: ${e.message}`);
   } finally {
+    started?.stop();
     watch.stop();
   }
   return 0;
@@ -20406,7 +20857,11 @@ async function hookSettle(ctx, stdin, opts) {
     const st = ctx.store.state();
     if (ctx.store.promptsMarkStale(st))
       ctx.store.updateState(() => {});
-    if (!sessionId || waitingFor(st, sessionId).length === 0)
+    if (!sessionId)
+      return 0;
+    if (hook.tool_name === "AskUserQuestion" || hook.tool_input === undefined)
+      await settlePicker(ctx, sessionId, "elsewhere");
+    if (waitingFor(ctx.store.state(), sessionId).length === 0)
       return 0;
     const inputHash = hook.tool_input !== undefined ? inputHashOf(session(ctx).keys, hook.tool_input) : undefined;
     if (waitingFor(ctx.store.state(), sessionId, inputHash).length === 0)
@@ -20425,41 +20880,77 @@ async function hookSettle(ctx, stdin, opts) {
   }
   return 0;
 }
-var ASK_USER_REASON = "Not answered here: the user is away from this terminal, so ask through Starbridge instead. Run `starbridge ask` with the question, the context they need to answer it cold, the options and what each one changes, your recommendation first, as the `starbridge` skill says. Then keep working on what does not depend on the answer.";
-var REACH_MS = 3000;
-async function hookAskUser(ctx, stdin) {
-  try {
-    const machine = ctx.store.machine();
-    if (!machine)
-      return 0;
-    const res = await fetch(`${machine.server.replace(/\/+$/, "")}/healthz`, {
-      signal: AbortSignal.timeout(REACH_MS)
-    });
-    if (!res.ok)
-      return 0;
-  } catch {
+function pickerQuestions(input) {
+  const questions = input?.questions;
+  if (!Array.isArray(questions) || questions.length === 0 || !questions.every((q) => typeof q?.question === "string"))
+    return;
+  return questions;
+}
+function pickerOpen(st, session) {
+  return Object.entries(st.asked).filter(([id, a]) => a.picker === session && !a.settled && !st.answers[id]).map(([id]) => id);
+}
+async function settlePicker(ctx, session, outcome) {
+  await Promise.all(pickerOpen(ctx.store.state(), session).map((id) => settle2({ ...ctx, signal: undefined }, { id, outcome }).catch((e) => ctx.err(`starbridge: could not settle ${id}: ${e.message}`))));
+}
+async function racePicker(ctx, outer, hook, waitText) {
+  const questions = pickerQuestions(hook.tool_input);
+  const sessionId = typeof hook.session_id === "string" ? hook.session_id : "";
+  if (!questions || !sessionId)
+    return 0;
+  const s = session(ctx);
+  const waitMs = waitText ? parseDuration(waitText) : DEFAULT_WAIT_MS;
+  const cwd = typeof hook.cwd === "string" && hook.cwd ? hook.cwd : process.cwd();
+  const deadline = AbortSignal.timeout(waitMs);
+  const failed = new AbortController;
+  const signal = AbortSignal.any([
+    ctx.signal ?? new AbortController().signal,
+    deadline,
+    failed.signal
+  ]);
+  const results = await Promise.allSettled(questions.map(async (q) => {
+    const sub = { ...ctx, signal, err: () => {} };
+    const input = {
+      ...questionInput({ ...q, multiple: q.multiSelect }),
+      agent: "claude-code",
+      session: sessionId,
+      project: basename3(cwd),
+      held: true,
+      picker: sessionId,
+      waiting: true
+    };
+    let id;
+    try {
+      ({ id } = await postDecision(sub, s, resolveSource(input, ctx.env, cwd)));
+    } catch (e) {
+      failed.abort();
+      throw e;
+    }
+    while (true) {
+      const lines = [];
+      const code = await wait({ ...sub, out: (l) => lines.push(l) }, { id, json: true, "no-mark": true }, s);
+      if (code === 0 && lines[0])
+        return opencodeAnswer(JSON.parse(lines[0]), { ...q, multiple: q.multiSelect });
+      if (code !== EXIT_SNOOZED)
+        return;
+    }
+  }));
+  const picked = results.map((r) => r.status === "fulfilled" ? r.value : undefined);
+  const error = results.find((r) => r.status === "rejected");
+  if (error && !signal.aborted)
+    ctx.err(`starbridge: question not sent: ${error.reason.message}`);
+  if (picked.every((p) => p !== undefined) && !signal.aborted) {
+    const answers = Object.fromEntries(questions.map((q, i) => [q.question, picked[i].join(", ")]));
+    const decision = {
+      behavior: "allow",
+      updatedInput: { ...hook.tool_input, answers }
+    };
+    ctx.out(JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision } }));
     return 0;
   }
-  let input;
-  try {
-    const parsed = JSON.parse(stdin);
-    const questions = parsed.tool_input?.questions;
-    if (Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q?.question === "string"))
-      input = parsed.tool_input;
-  } catch {}
-  const hookSpecificOutput = input ? {
-    hookEventName: "PreToolUse",
-    permissionDecision: "allow",
-    updatedInput: {
-      ...input,
-      answers: Object.fromEntries(input.questions.map((q) => [q.question, ASK_USER_REASON]))
-    }
-  } : {
-    hookEventName: "PreToolUse",
-    permissionDecision: "deny",
-    permissionDecisionReason: ASK_USER_REASON
-  };
-  ctx.out(JSON.stringify({ hookSpecificOutput }));
+  await settlePicker(ctx, sessionId, outer.signal?.aborted ? "elsewhere" : "withdrawn");
+  return 0;
+}
+function hookAskUser() {
   return 0;
 }
 var QUESTION_CHARS = 300;
@@ -20545,7 +21036,10 @@ async function hookQuestion(outer, stdin, opts) {
 
 // src/pair.ts
 import { randomBytes as randomBytes8 } from "node:crypto";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { hostname } from "node:os";
+import { join as join8 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline";
 
 // ../node_modules/.pnpm/uqr@0.1.3/node_modules/uqr/dist/index.mjs
 var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
@@ -21148,7 +21642,7 @@ function terminalQr(text) {
 
 // src/settings.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4 } from "node:fs";
 function detectMachineKind(env, platform = process.platform) {
   if (env.CLAUDE_CODE_REMOTE === "true" || env.CODESPACES === "true" || env.GITPOD_WORKSPACE_ID)
     return "cloud";
@@ -21162,7 +21656,7 @@ function hasBattery(platform) {
   try {
     if (platform === "linux") {
       const dir = "/sys/class/power_supply";
-      return existsSync4(dir) && readdirSync3(dir).some((n) => n.startsWith("BAT"));
+      return existsSync4(dir) && readdirSync4(dir).some((n) => n.startsWith("BAT"));
     }
     if (platform === "darwin")
       return spawnSync2("pmset", ["-g", "batt"], { encoding: "utf8" }).stdout.includes("InternalBattery");
@@ -21230,7 +21724,7 @@ async function offerPiAllow(ctx, prompt, quiet = false) {
   } else
     ctx.out(`Pi: pi-permission-system will ask before each \`starbridge ask\`; to allow them later, ${how}.`);
 }
-var USAGE = "usage: starbridge config [permissions on|off] [machine-kind server|desktop|laptop|cloud]";
+var USAGE = "usage: starbridge config [permissions on|off] [presence on|off] [machine-kind server|desktop|laptop|cloud]";
 async function configCommand(ctx, args, prompt) {
   const [key, value, ...extra] = args;
   if (extra.length > 0 || key !== undefined && value === undefined)
@@ -21243,6 +21737,11 @@ async function configCommand(ctx, args, prompt) {
       await offerPiChain(ctx, prompt);
       await offerPiAllow(ctx, prompt, true);
     }
+  } else if (key === "presence") {
+    if (value !== "on" && value !== "off")
+      throw new UsageError(USAGE);
+    const config = ctx.store.agentConfig();
+    ctx.store.saveAgentConfig({ ...config, presence: { enabled: value === "on" } });
   } else if (key === "machine-kind") {
     const kind = MachineKind.safeParse(value);
     if (!kind.success)
@@ -21252,6 +21751,7 @@ async function configCommand(ctx, args, prompt) {
     throw new UsageError(USAGE);
   }
   ctx.out(`permissions   ${permissionsEnabled(ctx) ? "on" : "off"}`);
+  ctx.out(`presence      ${ctx.store.agentConfig().presence?.enabled ? "on" : "off"}`);
   ctx.out(`machine-kind  ${ctx.store.agentConfig().machineKind ?? "not set"}`);
   return 0;
 }
@@ -21270,6 +21770,7 @@ async function pair(ctx, opts) {
   const id = `m_${randomBytes8(9).toString("base64url")}`;
   const name = opts.name ?? previous?.name ?? hostname();
   const claim = newClaimSecret();
+  const checkKey = newCheckKey();
   const deadline = ctx.now().getTime() + CODE_LIFETIME_MS;
   const expired = () => new UsageError(`the pairing code expired; run \`${opts.again ?? "starbridge pair"}\` again`);
   let code = newPairingCode();
@@ -21294,10 +21795,10 @@ async function pair(ctx, opts) {
   }
   const link = pairingLink(server, code);
   ctx.out(`Pairing code: ${formatPairingCode(code)}`);
-  ctx.out("  Scan this with your phone's camera or the Starbridge app:");
-  for (const line of terminalQr(link))
+  ctx.out("  Scan this with the Starbridge Android app or your phone's camera:");
+  for (const line of terminalQr(appPairingLink(server, code, checkKey)))
     ctx.out(line);
-  ctx.out(`  Or open  ${link}`);
+  ctx.out(`  No app? Open  ${link}`);
   ctx.out("  Or type the code under Devices in the app or web page. It expires in 10 minutes.");
   let result;
   while (!result) {
@@ -21325,6 +21826,20 @@ async function pair(ctx, opts) {
   const pin = { length: approval.length, head: approval.head };
   const dir = verifyDirectory(entries, { account: approval.account, pin });
   checkJoined(dir, { id, role: "machine", ...publicKeys(keys) });
+  const again = opts.again ?? "starbridge pair";
+  const check = checkCode(entries, id);
+  if (approval.check !== undefined) {
+    if (!verifyCheckProof(entries, id, checkKey, approval.check))
+      throw new UsageError(`the Android app that scanned the QR code saw another check code, so a server may have paired this machine into an account it controls. Nothing is saved: revoke "${name}" under Devices, then run \`${again}\` again`);
+  } else {
+    const answer = await confirmCheck(ctx, check, name);
+    if (ctx.signal?.aborted)
+      return 130;
+    if (answer === "no")
+      throw new UsageError(`the codes differ, so this machine is not paired. A server may have read the pairing code. Revoke "${name}" under Devices, then run \`${again}\` again`);
+    if (answer === undefined)
+      throw new UsageError(`the check code was not confirmed within 10 minutes, so this machine is not paired. Revoke "${name}" under Devices, then run \`${again}\` again`);
+  }
   const token = result.token;
   ctx.store.locked(() => {
     ctx.store.saveDirectory(entries);
@@ -21357,14 +21872,78 @@ async function pair(ctx, opts) {
 function addedAt(entries, id) {
   for (const e of entries) {
     const body = JSON.parse(e.body);
-    if (body.op === "add" && body.member?.id === id)
-      return new Date(body.at).toLocaleString(undefined, {
-        month: "short",
-        day: "numeric",
+    if (body.op === "add" && body.member?.id === id) {
+      const at = new Date(body.at);
+      const day = at.toLocaleDateString(undefined, { month: "short", day: "numeric" });
+      const time = at.toLocaleTimeString(undefined, {
         hour: "2-digit",
         minute: "2-digit",
         timeZoneName: "short"
       });
+      return `${day}, ${time}`;
+    }
+  }
+}
+var CONFIRM_MS = 10 * 60000;
+var waitingFile = (ctx) => join8(ctx.store.dir, "pair-waiting");
+var answerFile = (ctx, code) => join8(ctx.store.dir, `pair-answer.${code}`);
+function writeWhole(path, text) {
+  const tmp = `${path}.${process.pid}`;
+  rmSync3(tmp, { force: true });
+  writeFileSync5(tmp, text, { mode: 384, flag: "wx" });
+  renameSync3(tmp, path);
+}
+function sendConfirm(ctx, same) {
+  let code;
+  try {
+    code = readFileSync10(waitingFile(ctx), "utf8").trim();
+  } catch {
+    throw new UsageError("no `starbridge pair` is waiting for its check code to be confirmed");
+  }
+  if (!/^[0-9A-Z]{4}(-[0-9A-Z]{4}){3}$/.test(code))
+    throw new UsageError("no `starbridge pair` is waiting for its check code to be confirmed");
+  writeWhole(answerFile(ctx, code), same ? "yes" : "no");
+  ctx.out(`${same ? "Confirmed" : "Rejected"} check code ${code} for the waiting \`starbridge pair\`.`);
+  return 0;
+}
+async function confirmCheck(ctx, code, name) {
+  const file = answerFile(ctx, code);
+  rmSync3(file, { force: true });
+  mkdirSync6(ctx.store.dir, { recursive: true, mode: 448 });
+  writeWhole(waitingFile(ctx), code);
+  const tty = process.stdin.isTTY;
+  ctx.out(`Check code: ${code}`);
+  ctx.out(`  The Starbridge Android app shows "${name}" under Devices with its check code. A browser shows what the server sends, so compare with the app if you have it. An app that shows no code needs updating.`);
+  ctx.out(tty ? "Same code? [Y/n]" : "  Same code? Run `starbridge pair --confirm` if so, `starbridge pair --reject` if not.");
+  const typed = [];
+  const shown = Date.now();
+  const rl = tty ? createInterface3({ input: process.stdin }).on("line", (l) => {
+    if (Date.now() - shown > 500)
+      typed.push(l);
+  }) : undefined;
+  try {
+    const until = ctx.now().getTime() + CONFIRM_MS;
+    for (;; ) {
+      if (ctx.signal?.aborted || ctx.now().getTime() > until)
+        return;
+      const line = typed.shift();
+      if (line !== undefined)
+        return /^\s*(y(es)?)?\s*$/i.test(line) ? "yes" : "no";
+      try {
+        const answer = readFileSync10(file, "utf8");
+        rmSync3(file, { force: true });
+        return answer === "yes" ? "yes" : "no";
+      } catch {
+        await ctx.sleep(500);
+      }
+    }
+  } finally {
+    rl?.close();
+    rmSync3(file, { force: true });
+    try {
+      if (readFileSync10(waitingFile(ctx), "utf8") === code)
+        rmSync3(waitingFile(ctx), { force: true });
+    } catch {}
   }
 }
 
@@ -21484,8 +22063,8 @@ function installKind() {
 }
 
 // src/setup/plugins.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
 var MARKETPLACE = "starbridge";
 var MARKETPLACE_SOURCE = "T0mSIlver/starbridge";
 var PLUGINS = [`starbridge@${MARKETPLACE}`, `starbridge-mod@${MARKETPLACE}`];
@@ -21493,9 +22072,9 @@ function hasClaude(sys) {
   return which(sys.ctx.env, "claude") !== undefined;
 }
 function claudeDir(sys) {
-  return sys.ctx.env.CLAUDE_CONFIG_DIR || join8(sys.home, ".claude");
+  return sys.ctx.env.CLAUDE_CONFIG_DIR || join9(sys.home, ".claude");
 }
-var claude = (sys, ...args) => run(sys, "claude", args, { timeoutMs: 180000 });
+var claude = (sys, ...args) => run(sys, "claude", args, { timeoutMs: 180000, cwd: sys.home });
 async function listJson(sys, ...args) {
   const r = await claude(sys, ...args, "--json");
   const why = `\`claude ${args.join(" ")} --json\` failed`;
@@ -21565,7 +22144,7 @@ async function installPlugins(sys, state) {
     throw new Error(foreign);
   const done = [];
   if (!state.marketplace) {
-    const r = await claude(sys, "plugin", "marketplace", "add", MARKETPLACE_SOURCE);
+    const r = await claude(sys, "plugin", "marketplace", "add", MARKETPLACE_SOURCE, "--scope", "user");
     if (r?.code !== 0)
       throw new Error(`claude plugin marketplace add ${MARKETPLACE_SOURCE}: ${failure2(r)}`);
     done.push(`Added the ${MARKETPLACE} marketplace.`);
@@ -21581,6 +22160,8 @@ async function installPlugins(sys, state) {
   return done;
 }
 async function removePlugins(sys, state) {
+  if (state.foreign)
+    return [`Left the ${MARKETPLACE} marketplace from ${state.foreign} and its plugins alone.`];
   const done = [];
   for (const id of PLUGINS) {
     if (!state.plugins[id])
@@ -21595,17 +22176,17 @@ async function removePlugins(sys, state) {
   return done;
 }
 function settingsPath(sys) {
-  return join8(claudeDir(sys), "settings.json");
+  return join9(claudeDir(sys), "settings.json");
 }
 function readSettings(sys) {
   try {
-    return JSON.parse(readFileSync9(settingsPath(sys), "utf8"));
+    return JSON.parse(readFileSync11(settingsPath(sys), "utf8"));
   } catch {
     return;
   }
 }
 function writeSettings(sys, s) {
-  writeFileSync5(settingsPath(sys), `${JSON.stringify(s, null, 2)}
+  writeFileSync6(settingsPath(sys), `${JSON.stringify(s, null, 2)}
 `);
 }
 function autoUpdate(sys) {
@@ -21646,7 +22227,7 @@ function addAllowRules(sys) {
     ...s.permissions,
     allow: [...allow, ...ALLOW_RULES.filter((r) => !allow.includes(r))]
   };
-  mkdirSync6(claudeDir(sys), { recursive: true });
+  mkdirSync7(claudeDir(sys), { recursive: true });
   writeSettings(sys, s);
   return true;
 }
@@ -21858,24 +22439,39 @@ import {
   closeSync as closeSync2,
   existsSync as existsSync6,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync as openSync2,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync10,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync12,
   realpathSync as realpathSync4,
-  renameSync as renameSync3,
-  rmSync as rmSync3,
+  renameSync as renameSync4,
+  rmSync as rmSync4,
   symlinkSync,
   unlinkSync as unlinkSync4,
   writeSync
 } from "node:fs";
-import { dirname as dirname5, join as join9 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
+// src/setup/codexbar-pin.json
+var codexbar_pin_default = {
+  version: "0.73.0",
+  sha256: {
+    "macos-arm64": "cd8f853779f8faec003f53d5fc2a1614aef577ec9f603cbd58a9559b54e159b9",
+    "macos-x86_64": "19e7059de688e62be98790bc10198257f5d326e4a3f4191183c23106eb91780a",
+    "linux-aarch64": "ae6f9be046b09dc9d17210b661c25e2ee8a0150edb047b917d9eb17c295c7094",
+    "linux-x86_64": "a84f556c7ecebc8e606e0a34ee0d121626f72d7afc1e3adf5746410bc10f9611",
+    "linux-musl-aarch64": "a4007dfa6577a436eaeb6b46601982c69548c6e20730b3eb9133d4266d5ea92b",
+    "linux-musl-x86_64": "75fd9cfc00784eef8badd6e76f4f74cbdf7c13db0b7f9ca6e105ddb793e6e8f8"
+  }
+};
+
+// src/setup/codexbar.ts
+var PIN = codexbar_pin_default;
 var RELEASES = "https://github.com/steipete/CodexBar/releases";
 var PROBE_TIMEOUT_MS = 20000;
 var PROGRESS_MS2 = 5000;
 var APP_HELPERS = (home) => [
   "/Applications/CodexBar.app/Contents/Helpers/CodexBarCLI",
-  join9(home, "Applications/CodexBar.app/Contents/Helpers/CodexBarCLI")
+  join10(home, "Applications/CodexBar.app/Contents/Helpers/CodexBarCLI")
 ];
 function findCodexbar(sys, configured) {
   for (const p of [configured, sys.ctx.env.STARBRIDGE_CODEXBAR])
@@ -21884,7 +22480,7 @@ function findCodexbar(sys, configured) {
   const onPath = which(sys.ctx.env, "codexbar");
   if (onPath)
     return { path: onPath };
-  const opt = join9(sys.home, ".local/opt/codexbar/codexbar");
+  const opt = join10(sys.home, ".local/opt/codexbar/codexbar");
   if (existsSync6(opt))
     return { path: opt };
   if (sys.platform === "darwin") {
@@ -21907,7 +22503,7 @@ function tarballKey(sys, musl = isMusl()) {
 function isMusl() {
   const has = (dir, prefix) => {
     try {
-      return readdirSync4(dir).some((f) => f.startsWith(prefix));
+      return readdirSync5(dir).some((f) => f.startsWith(prefix));
     } catch {
       return false;
     }
@@ -21924,9 +22520,9 @@ function isMusl() {
   return !libs.some((d) => has(d, "libcurl.so.4"));
 }
 function linkIntoLocalBin(sys, target) {
-  const bin = join9(sys.home, ".local/bin");
-  const link = join9(bin, "codexbar");
-  mkdirSync7(bin, { recursive: true });
+  const bin = join10(sys.home, ".local/bin");
+  const link = join10(bin, "codexbar");
+  mkdirSync8(bin, { recursive: true });
   try {
     if (!lstatSync2(link).isSymbolicLink())
       return;
@@ -21935,7 +22531,7 @@ function linkIntoLocalBin(sys, target) {
   symlinkSync(target, link);
   return link;
 }
-var optDir = (sys) => join9(sys.home, ".local/opt/codexbar");
+var optDir = (sys) => join10(sys.home, ".local/opt/codexbar");
 function releaseVersion(v) {
   const m = /^v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?)$/.exec(v.trim());
   if (!m)
@@ -21953,19 +22549,28 @@ async function fetchRelease(url, init, what) {
     throw new Error(`${what}: GitHub is limiting requests from this address (${res.status}); try again in an hour`);
   return res;
 }
-async function latestCodexbar(sys) {
-  const releases = sys.ctx.env.STARBRIDGE_CODEXBAR_RELEASES ?? RELEASES;
-  const what = "finding CodexBar's latest release";
-  const res = await fetchRelease(`${releases}/latest`, { redirect: "manual", signal: AbortSignal.timeout(60000) }, what);
-  const tag = /\/tag\/([^/?#]+)$/.exec(res.headers.get("location") ?? "")?.[1];
-  if (!tag)
-    throw new Error(`${what}: ${res.status}, no release tag`);
-  return releaseVersion(decodeURIComponent(tag));
+function compareCodexbar(a, b) {
+  const parse = (v) => {
+    const [main = "", pre] = releaseVersion(v).split(/-(.*)/);
+    return { nums: main.split(".").map(Number), pre };
+  };
+  const x = parse(a);
+  const y = parse(b);
+  for (let i = 0;i < 3; i++)
+    if (x.nums[i] !== y.nums[i])
+      return x.nums[i] < y.nums[i] ? -1 : 1;
+  if (x.pre === y.pre)
+    return 0;
+  if (x.pre === undefined)
+    return 1;
+  if (y.pre === undefined)
+    return -1;
+  return Math.sign(x.pre.localeCompare(y.pre, "en", { numeric: true }));
 }
 var size = (bytes) => bytes >= 1e6 ? `${Math.round(bytes / 1e6)} MB` : `${Math.max(1, Math.round(bytes / 1000))} kB`;
 function installedVersion(sys) {
   try {
-    return readFileSync10(join9(optDir(sys), "VERSION"), "utf8").trim() || undefined;
+    return readFileSync12(join10(optDir(sys), "VERSION"), "utf8").trim() || undefined;
   } catch {
     return;
   }
@@ -21973,40 +22578,43 @@ function installedVersion(sys) {
 
 class NoChecksum extends Error {
 }
-async function installTarball(sys, key, version) {
+async function installTarball(sys, key, version, sha256) {
   const base = `${sys.ctx.env.STARBRIDGE_CODEXBAR_RELEASES ?? RELEASES}/download`;
   const name = `CodexBarCLI-v${version}-${key}.tar.gz`;
   const url = `${base}/v${version}/${name}`;
   const signal = AbortSignal.timeout(10 * 60000);
-  const sums = await fetchRelease(`${url}.sha256`, { signal }, `downloading ${name}.sha256`);
-  if (!sums.ok)
-    throw new NoChecksum(`no checksum for ${name} (${sums.status}): not installed`);
-  const want = /^[0-9a-f]{64}\b/i.exec((await sums.text()).trim())?.[0].toLowerCase();
-  if (!want)
-    throw new Error(`${name}.sha256 holds no SHA-256: not installed`);
+  let want = sha256;
+  if (!want) {
+    const sums = await fetchRelease(`${url}.sha256`, { signal }, `downloading ${name}.sha256`);
+    if (!sums.ok)
+      throw new NoChecksum(`no checksum for ${name} (${sums.status}): not installed`);
+    want = /^[0-9a-f]{64}\b/i.exec((await sums.text()).trim())?.[0].toLowerCase();
+    if (!want)
+      throw new Error(`${name}.sha256 holds no SHA-256: not installed`);
+  }
   const res = await fetchRelease(url, { signal }, `downloading ${name}`);
   if (!res.ok || !res.body)
     throw new Error(`downloading ${name}: ${res.status}`);
   const dest = optDir(sys);
   const opt = dirname5(dest);
-  const fresh = join9(opt, `.codexbar.${process.pid}`);
+  const fresh = join10(opt, `.codexbar.${process.pid}`);
   const file = `${fresh}.tar.gz`;
   const old = `${fresh}.old`;
-  mkdirSync7(fresh, { recursive: true });
+  mkdirSync8(fresh, { recursive: true });
   try {
     await download(sys, res, file, want, name, `CodexBar ${version} (${key})`);
     const r = await run(sys, "tar", ["-xzf", file, "-C", fresh]);
     if (r?.code !== 0)
       throw new Error(`could not unpack ${name} into ${opt}; is the disk full? (${failure2(r)})`);
     if (existsSync6(dest))
-      renameSync3(dest, old);
-    renameSync3(fresh, dest);
+      renameSync4(dest, old);
+    renameSync4(fresh, dest);
   } finally {
-    rmSync3(file, { force: true });
-    rmSync3(fresh, { recursive: true, force: true });
-    rmSync3(old, { recursive: true, force: true });
+    rmSync4(file, { force: true });
+    rmSync4(fresh, { recursive: true, force: true });
+    rmSync4(old, { recursive: true, force: true });
   }
-  return join9(dest, "codexbar");
+  return join10(dest, "codexbar");
 }
 async function download(sys, res, file, want, name, label) {
   const total = Number(res.headers.get("content-length")) || undefined;
@@ -22035,12 +22643,15 @@ async function download(sys, res, file, want, name, label) {
   if (sha !== want)
     throw new Error(`${name} has SHA-256 ${sha}, expected ${want}: not installed`);
 }
-async function installRelease(sys, version) {
+async function installRelease(sys, version, pin = PIN) {
   const key = tarballKey(sys);
   if (!key)
     throw new Error(`no CodexBar build for ${sys.platform} ${sys.arch}`);
-  const v = version ? releaseVersion(version) : await latestCodexbar(sys);
-  const path = await installTarball(sys, key, v);
+  const v = version ? releaseVersion(version) : pin.version;
+  const sha = v === pin.version ? pin.sha256[key] : undefined;
+  if (v === pin.version && !sha)
+    throw new Error(`no checksum pinned for CodexBar ${v} (${key})`);
+  const path = await installTarball(sys, key, v, sha);
   const link = linkIntoLocalBin(sys, path);
   sys.ctx.out(`Installed CodexBar ${v} to ${optDir(sys)}${link ? `, linked as ${link}` : ""}.`);
   return path;
@@ -22087,10 +22698,10 @@ async function listProviders(sys, bin) {
 }
 function probeSet(sys, list, named) {
   const set = new Set([...list.filter((p) => p.enabled).map((p) => p.provider), ...named]);
-  const claude = existsSync6(join9(sys.home, ".claude/.credentials.json")) || which(sys.ctx.env, "claude");
+  const claude = existsSync6(join10(sys.home, ".claude/.credentials.json")) || which(sys.ctx.env, "claude");
   if (claude)
     set.add("claude");
-  if (existsSync6(join9(sys.home, ".codex/auth.json")))
+  if (existsSync6(join10(sys.home, ".codex/auth.json")))
     set.add("codex");
   return [...set];
 }
@@ -22121,7 +22732,7 @@ async function probe(bin, providers, list) {
     }
   }));
 }
-async function updateCodexbar(sys, configured, version) {
+async function updateCodexbar(sys, configured, version, pin = PIN) {
   const out = sys.ctx.out;
   const found = findCodexbar(sys, configured);
   if (!found) {
@@ -22141,20 +22752,19 @@ async function updateCodexbar(sys, configured, version) {
     return version ? 1 : 0;
   }
   const have = installedVersion(sys);
-  let want;
   try {
-    want = version ? releaseVersion(version) : await latestCodexbar(sys);
+    const want = version ? releaseVersion(version) : pin.version;
     if (have === want) {
       out(`CodexBar ${have} is ${version ? "installed" : "up to date"}.`);
       return 0;
     }
-    await installRelease(sys, want);
-    return 0;
-  } catch (e) {
-    if (!version && e instanceof NoChecksum) {
-      out(`CodexBar ${want}'s build for this machine is not published yet: kept ${have ?? "the installed one"}.`);
+    if (!version && have && compareCodexbar(have, want) > 0) {
+      out(`CodexBar ${have} is newer than the ${want} this release installs: kept.`);
       return 0;
     }
+    await installRelease(sys, want, pin);
+    return 0;
+  } catch (e) {
     out(`Could not update CodexBar: ${e.message}`);
     return 1;
   }
@@ -22165,23 +22775,23 @@ import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync3,
   existsSync as existsSync7,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   openSync as openSync3,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync13,
   readSync as readSync2,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync6
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { basename as basename4, delimiter, dirname as dirname6, join as join10 } from "node:path";
+import { delimiter, dirname as dirname6, join as join11 } from "node:path";
 function recordSelf(sys) {
-  const file = join10(sys.ctx.store.dir, CLI_PATH);
+  const file = join11(sys.ctx.store.dir, CLI_PATH);
   if (sys.self.length !== 1 || script(sys.self[0])) {
-    rmSync4(file, { force: true });
+    rmSync5(file, { force: true });
     return;
   }
-  mkdirSync8(dirname6(file), { recursive: true, mode: 448 });
+  mkdirSync9(dirname6(file), { recursive: true, mode: 448 });
   const self2 = sys.self[0];
-  writeFileSync6(file, `${sys.platform === "win32" ? self2.replace(/\\/g, "/") : self2}
+  writeFileSync7(file, `${sys.platform === "win32" ? self2.replace(/\\/g, "/") : self2}
 `);
 }
 function script(path) {
@@ -22198,7 +22808,8 @@ function script(path) {
 function missingDir(sys) {
   if (sys.self.length !== 1)
     return;
-  const dir = dirname6(sys.self[0]);
+  const { dirname } = pathFor(sys.platform);
+  const dir = dirname(sys.self[0]);
   const norm = (p) => {
     const bare = p.replace(/[/\\]+$/, "");
     return sys.platform === "win32" ? bare.toLowerCase() : bare;
@@ -22207,20 +22818,21 @@ function missingDir(sys) {
   return path.includes(norm(dir)) ? undefined : dir;
 }
 function shellProfile(sys, dir) {
-  const shell = basename4(sys.ctx.env.SHELL ?? "");
+  const { basename, join } = pathFor(sys.platform);
+  const shell = basename(sys.ctx.env.SHELL ?? "");
   const shown = dir.startsWith(`${sys.home}/`) ? `$HOME${dir.slice(sys.home.length)}` : dir;
   const exported = `export PATH="${shown}:$PATH"`;
   if (shell === "fish")
-    return { file: join10(sys.home, ".config", "fish", "config.fish"), line: `fish_add_path ${dir}` };
+    return { file: join(sys.home, ".config", "fish", "config.fish"), line: `fish_add_path ${dir}` };
   if (shell === "zsh")
-    return { file: join10(sys.ctx.env.ZDOTDIR || sys.home, ".zshrc"), line: exported };
+    return { file: join(sys.ctx.env.ZDOTDIR || sys.home, ".zshrc"), line: exported };
   if (shell === "bash") {
     if (sys.platform !== "darwin")
-      return { file: join10(sys.home, ".bashrc"), line: exported };
-    const login = [".bash_profile", ".bash_login"].map((f) => join10(sys.home, f)).find(existsSync7);
-    return { file: login ?? join10(sys.home, ".profile"), line: exported };
+      return { file: join(sys.home, ".bashrc"), line: exported };
+    const login = [".bash_profile", ".bash_login"].map((f) => join(sys.home, f)).find(existsSync7);
+    return { file: login ?? join(sys.home, ".profile"), line: exported };
   }
-  return { file: join10(sys.home, ".profile"), line: exported };
+  return { file: join(sys.home, ".profile"), line: exported };
 }
 async function pathStep(sys) {
   const dir = missingDir(sys);
@@ -22236,12 +22848,13 @@ async function pathStep(sys) {
     ];
   }
   const { file, line } = shellProfile(sys, dir);
+  const { dirname } = pathFor(sys.platform);
   const shown = file.startsWith(`${sys.home}/`) ? `~${file.slice(sys.home.length)}` : file;
-  const text = existsSync7(file) ? readFileSync11(file, "utf8") : "";
+  const text = existsSync7(file) ? readFileSync13(file, "utf8") : "";
   const rest = dir.startsWith(`${sys.home}/`) ? dir.slice(sys.home.length) : undefined;
   const has = [dir, line, ...rest ? [`$HOME${rest}`, `\${HOME}${rest}`, `~${rest}`] : []].some((spelled) => text.includes(spelled));
   if (!has && await prompt.confirm(`Add ${dir} to your PATH in ${shown}?`, true)) {
-    mkdirSync8(dirname6(file), { recursive: true });
+    mkdirSync9(dirname(file), { recursive: true });
     appendFileSync2(file, `${text === "" || text.endsWith(`
 `) ? "" : `
 `}
@@ -22262,9 +22875,9 @@ ${line}
 }
 
 // src/setup/service.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync12, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync10, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import { userInfo as userInfo2 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname7, join as join11 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname7, join as join12 } from "node:path";
 var UNIT = "starbridge-agent.service";
 var LABEL = "run.starbridge.agent";
 var TASK = "starbridge-agent";
@@ -22272,25 +22885,25 @@ function kind(sys) {
   return { linux: "systemd", darwin: "launchd", win32: "task" }[sys.platform];
 }
 function localDir(sys) {
-  return join11(sys.ctx.env.LOCALAPPDATA || join11(sys.home, "AppData", "Local"), "starbridge");
+  return join12(sys.ctx.env.LOCALAPPDATA || join12(sys.home, "AppData", "Local"), "starbridge");
 }
-var agentLog = (sys) => kind(sys) === "task" ? join11(localDir(sys), "agent.log") : join11(sys.home, "Library/Logs/starbridge-agent.log");
+var agentLog = (sys) => kind(sys) === "task" ? join12(localDir(sys), "agent.log") : join12(sys.home, "Library/Logs/starbridge-agent.log");
 function unitDir(sys) {
-  return join11(sys.home, ".config/systemd/user");
+  return join12(sys.home, ".config/systemd/user");
 }
 function servicePath(sys) {
   const k = kind(sys);
   if (k === "systemd")
-    return join11(unitDir(sys), UNIT);
+    return join12(unitDir(sys), UNIT);
   if (k === "launchd")
-    return join11(sys.home, "Library/LaunchAgents", `${LABEL}.plist`);
+    return join12(sys.home, "Library/LaunchAgents", `${LABEL}.plist`);
   if (k === "task")
-    return join11(localDir(sys), `${TASK}.xml`);
+    return join12(localDir(sys), `${TASK}.xml`);
   return;
 }
 function servicePathVar(sys) {
   const extra = [
-    join11(sys.home, ".local/bin"),
+    join12(sys.home, ".local/bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -22386,12 +22999,12 @@ ${env}
 </plist>
 `;
 }
-var winArg = (s) => /[\s"]/.test(s) ? `"${s.replace(/"/g, "\\\"")}"` : s;
+var winArg = (s) => /[\s"]/.test(s) ? `"${s.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\+)$/, "$1$1")}"` : s;
 function taskXml(sys) {
   const env = sys.ctx.env;
   const name = env.USERNAME || userInfo2().username;
   const user = env.USERDOMAIN ? `${env.USERDOMAIN}\\${name}` : name;
-  const conhost = join11(env.SystemRoot || env.SYSTEMROOT || "C:\\Windows", "System32", "conhost.exe");
+  const conhost = join12(env.SystemRoot || env.SYSTEMROOT || "C:\\Windows", "System32", "conhost.exe");
   const args = ["--headless", ...sys.self, "agent", "--log", agentLog(sys)].map(winArg).join(" ");
   return `<?xml version="1.0" encoding="UTF-16"?>
 ${marker("<!--", "-->")}
@@ -22443,7 +23056,7 @@ ${marker("<!--", "-->")}
 </Task>
 `;
 }
-var powershell = (sys, script, env = {}) => run(sys, join11(sys.ctx.env.SystemRoot || sys.ctx.env.SYSTEMROOT || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], { timeoutMs: 60000, env });
+var powershell = (sys, script, env = {}) => run(sys, join12(sys.ctx.env.SystemRoot || sys.ctx.env.SYSTEMROOT || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"), ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], { timeoutMs: 60000, env });
 async function stopTask(sys) {
   let pid;
   const socket = socketPath(sys.ctx.env, sys.ctx.store.dir, sys.platform);
@@ -22489,7 +23102,7 @@ async function unavailable(sys) {
 }
 function readText2(path) {
   try {
-    const bytes = readFileSync12(path);
+    const bytes = readFileSync14(path);
     if (bytes[0] === 255 && bytes[1] === 254)
       return bytes.toString("utf16le").slice(1);
     return bytes.toString("utf8");
@@ -22507,12 +23120,12 @@ async function installService(sys, restart) {
   const before = readText2(path);
   if (before !== undefined && !ours(before))
     throw new Error(`${path} was not written by setup: remove it to install the agent`);
-  mkdirSync9(dirname7(path), { recursive: true });
+  mkdirSync10(dirname7(path), { recursive: true });
   const k = kind(sys);
   const text = k === "systemd" ? unitText(sys) : k === "launchd" ? plistText(sys) : taskXml(sys);
   const changed = readText2(path) !== text;
   if (changed)
-    writeFileSync7(path, k === "task" ? `\uFEFF${text}` : text, k === "task" ? "utf16le" : "utf8");
+    writeFileSync8(path, k === "task" ? `\uFEFF${text}` : text, k === "task" ? "utf16le" : "utf8");
   const running = /^(active|running)$/i.test((await serviceState(sys)).state);
   const go = changed || restart || !running;
   if (k === "task") {
@@ -22555,16 +23168,16 @@ async function removeService(sys) {
     const r = await powershell(sys, `Unregister-ScheduledTask -TaskName ${TASK} -Confirm:$false -ErrorAction SilentlyContinue; if (Get-ScheduledTask -TaskName ${TASK} -ErrorAction SilentlyContinue) { exit 1 }`);
     if (r?.code !== 0)
       throw new Error(`Unregister-ScheduledTask: ${failure2(r)}`);
-    rmSync5(path, { force: true });
+    rmSync6(path, { force: true });
   } else if (kind(sys) === "systemd") {
     await stopUnit(sys, UNIT);
-    rmSync5(path, { force: true });
+    rmSync6(path, { force: true });
     await systemctl(sys, "daemon-reload");
   } else {
     const r = await launchctl(sys, "bootout", `gui/${sys.uid}/${LABEL}`);
     if (r?.code !== 0 && r?.code !== 3 && r?.code !== 113)
       throw new Error(`launchctl bootout: ${failure2(r)}`);
-    rmSync5(path, { force: true });
+    rmSync6(path, { force: true });
   }
   return true;
 }
@@ -22771,6 +23384,7 @@ async function setup(sys, opts) {
   for (const line of commandTable([
     ["Check it", "starbridge status"],
     ...permissionsEnabled(ctx) ? [] : [["Send permission prompts", "starbridge config permissions on"]],
+    ...ctx.store.agentConfig().presence?.enabled || !["desktop", "laptop"].includes(ctx.store.agentConfig().machineKind ?? "") ? [] : [["Quiet the phone while here", "starbridge config presence on"]],
     ["Remove from one agent", `starbridge uninstall --agent ${one}`],
     ["Remove everything", "starbridge uninstall"]
   ]))
@@ -23137,6 +23751,9 @@ async function status(sys) {
     out(`Sessions: ${agent.sessions.length}`);
     for (const x of agent.sessions)
       out(`  ${x.id}${x.title ? ` "${x.title}"` : ""}${x.client ? ` ${x.client}` : ""}, last seen ${x.lastSeenAt}`);
+    const own = ctx.env.CLAUDECODE === "1" ? ctx.env.CLAUDE_CODE_SESSION_ID : undefined;
+    if (own && ctx.env.CLAUDE_CODE_SESSION_ATTENDED !== "0" && !agent.sessions.some((x) => x.id === own))
+      out(`  Not this session (${own}): no Starbridge mod runs in it, so answers come back only through \`starbridge wait\``);
   }
   const svc = await serviceState(sys);
   out(svc.installed ? `Service: ${svc.state}${svc.enabled === undefined ? "" : svc.enabled ? ", enabled" : ", not enabled"}` : "Service: not installed");
@@ -23192,14 +23809,14 @@ async function status(sys) {
 }
 
 // src/setup/uninstall.ts
-import { existsSync as existsSync10, realpathSync as realpathSync5, rmSync as rmSync7 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync5, rmSync as rmSync8 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/update.ts
-import { spawn as spawn6, spawnSync as spawnSync3 } from "node:child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync9, readdirSync as readdirSync5, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { spawn as spawn7, spawnSync as spawnSync3 } from "node:child_process";
+import { chmodSync as chmodSync3, existsSync as existsSync9, readdirSync as readdirSync6, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename5, dirname as dirname8, join as join12 } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join13 } from "node:path";
 var MANAGED = {
   brew: {
     update: "brew upgrade starbridge, then starbridge setup --refresh",
@@ -23235,8 +23852,8 @@ async function restartAgent(ctx) {
     return;
   }
   const home = ctx.env.HOME ?? homedir5();
-  const linux = join12(home, ".config/systemd/user/starbridge-agent.service");
-  const mac = join12(home, "Library/LaunchAgents/run.starbridge.agent.plist");
+  const linux = join13(home, ".config/systemd/user/starbridge-agent.service");
+  const mac = join13(home, "Library/LaunchAgents/run.starbridge.agent.plist");
   const r = existsSync9(linux) ? sh(ctx, "systemctl", ["--user", "try-restart", "starbridge-agent.service"]) : existsSync9(mac) ? sh(ctx, "launchctl", ["kickstart", "-k", `gui/${process.getuid?.()}/run.starbridge.agent`]) : undefined;
   if (r === undefined)
     return;
@@ -23272,7 +23889,14 @@ async function update(ctx, install, pubkey = RELEASE_KEY, codexbar) {
     return updateCodexbar(sys, configured, codexbar);
   let self2 = 0;
   try {
-    await updateSelf(ctx, install, pubkey);
+    if (await updateSelf(ctx, install, pubkey) && install.kind === "binary") {
+      const r = spawnSync3(install.path, ["update"], {
+        env: ctx.env,
+        stdio: ["ignore", "inherit", "inherit"],
+        timeout: 15 * 60000
+      });
+      return r.status ?? 1;
+    }
   } catch (e) {
     if (e instanceof ReleaseError && !(e instanceof DownloadError))
       throw e;
@@ -23286,17 +23910,17 @@ async function update(ctx, install, pubkey = RELEASE_KEY, codexbar) {
 async function updateSelf(ctx, install, pubkey) {
   if (install.kind !== "binary") {
     ctx.out(`starbridge was installed with ${install.kind}: run ${MANAGED[install.kind].update}`);
-    return;
+    return false;
   }
   const releases = ctx.env.STARBRIDGE_RELEASES_URL ?? RELEASES_URL;
   const latest = await latestVersion(releases);
   if (compareVersions(latest, VERSION) <= 0) {
     ctx.out(`starbridge ${VERSION} is up to date.`);
-    return;
+    return false;
   }
   const bytes = await downloadVerified(latest, platformAsset(), { releases, pubkey });
-  const next = join12(dirname8(install.path), ".starbridge.new");
-  writeFileSync8(next, bytes, { mode: 493 });
+  const next = join13(dirname8(install.path), ".starbridge.new");
+  writeFileSync9(next, bytes, { mode: 493 });
   chmodSync3(next, 493);
   replaceBinary(next, install.path);
   ctx.out(`Updated starbridge ${VERSION} to ${latest} in ${install.path}.`);
@@ -23315,28 +23939,29 @@ async function updateSelf(ctx, install, pubkey) {
   }
   updatePlugins(ctx);
   movePiPackage(ctx, latest);
+  return true;
 }
 function replaceBinary(next, target, platform = process.platform) {
   if (platform !== "win32")
-    return renameSync4(next, target);
+    return renameSync5(next, target);
   let aside = `${target}.old`;
   try {
-    rmSync6(aside, { force: true });
+    rmSync7(aside, { force: true });
   } catch {
     aside = `${target}.${process.pid}.old`;
   }
-  renameSync4(target, aside);
+  renameSync5(target, aside);
   try {
-    renameSync4(next, target);
+    renameSync5(next, target);
   } catch (e) {
-    renameSync4(aside, target);
+    renameSync5(aside, target);
     throw e;
   }
   const dir = dirname8(target);
-  const leftover = (f) => f.startsWith(`${basename5(target)}.`) && f.endsWith(".old");
-  for (const f of readdirSync5(dir).filter(leftover))
+  const leftover = (f) => f.startsWith(`${basename4(target)}.`) && f.endsWith(".old");
+  for (const f of readdirSync6(dir).filter(leftover))
     try {
-      rmSync6(join12(dir, f), { force: true });
+      rmSync7(join13(dir, f), { force: true });
     } catch {}
 }
 function removeBinary(ctx, install) {
@@ -23346,7 +23971,7 @@ function removeBinary(ctx, install) {
   }
   if (process.platform === "win32")
     return removeRunningExe(ctx, install.path);
-  rmSync6(install.path, { force: true });
+  rmSync7(install.path, { force: true });
   ctx.out(`Removed ${install.path}.`);
   return 0;
 }
@@ -23356,7 +23981,7 @@ function removeRunningExe(ctx, path) {
     return 0;
   }
   const del = `ping -n 3 127.0.0.1 >nul & del /f /q "${path}" "${path}.old" "${path}.*.old"`;
-  spawn6(ctx.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${del}"`], {
+  spawn7(ctx.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${del}"`], {
     detached: true,
     stdio: "ignore",
     windowsHide: true,
@@ -23403,7 +24028,7 @@ async function uninstall(sys, opts) {
     ctx.out(`Kept ${dir}: a service still uses it. Stop it, then rerun \`starbridge uninstall\`.`);
   } else if (existsSync10(dir)) {
     if (opts.purge || await prompt.confirm(`Delete ${dir} (this machine's keys and state)?`, false)) {
-      rmSync7(dir, { recursive: true, force: true });
+      rmSync8(dir, { recursive: true, force: true });
       ctx.out(`Deleted ${dir}.`);
     } else
       ctx.out(`Kept ${dir}: \`starbridge setup\` reuses it.`);
@@ -23412,8 +24037,8 @@ async function uninstall(sys, opts) {
     ctx.out(`Revoke "${machine.name}" under Devices in the Starbridge app or web page.`);
   const cb = findCodexbar(sys);
   if (cb) {
-    const opt = join13(sys.home, ".local/opt/codexbar");
-    const how = cb.inApp ? "brew uninstall --cask codexbar (or drag CodexBar.app to the Bin)" : realpathSync5(cb.path).startsWith(opt) ? `rm -rf ${opt} ${join13(sys.home, ".local/bin/codexbar")}` : "your package manager";
+    const opt = join14(sys.home, ".local/opt/codexbar");
+    const how = cb.inApp ? "brew uninstall --cask codexbar (or drag CodexBar.app to the Bin)" : realpathSync5(cb.path).startsWith(opt) ? `rm -rf ${opt} ${join14(sys.home, ".local/bin/codexbar")}` : "your package manager";
     ctx.out(`CodexBar stays installed (${cb.path}); remove it with ${how}.`);
   }
   if (opts.install && stopped)
@@ -23468,7 +24093,10 @@ var HELP = `starbridge: post decisions to your devices, report runs, upload quot
       setup leaves it out until \`setup --agent\` brings it back.
 
   starbridge pair [--server <url>] [--name <name>] [--force]
-      Make this machine's keys and print a pairing code to type on a device.
+      Make this machine's keys and print a pairing code to type on a device. Unless the
+      Starbridge Android app scanned the QR code, confirm that its check code matches.
+  starbridge pair --confirm | --reject
+      Answer that for a waiting \`pair\` or \`setup\` that has no terminal.
       --server <url>          a self-hosted server (default: $STARBRIDGE_SERVER, else
                               https://starbridge.run)
 
@@ -23559,24 +24187,29 @@ var HELP = `starbridge: post decisions to your devices, report runs, upload quot
       The commands above go through it when it runs, and to the server directly when not
       (or with STARBRIDGE_NO_AGENT=1).
 
-  starbridge config [permissions on|off] [machine-kind server|desktop|laptop|cloud]
+  starbridge config [permissions on|off] [presence on|off] [machine-kind server|desktop|laptop|cloud]
       Print this machine's settings, or change one. permissions: send its Claude Code
       permission prompts to your devices, where they can be allowed or denied; the prompt
       stays open at the keyboard and the first answer wins. Off by default; while off, the
-      starbridge plugin's permission hook exits at once. machine-kind: the icon devices
-      show, detected by setup.
+      starbridge plugin's permission hook exits at once. presence: while this machine's
+      screen is unlocked and had keyboard or mouse input in the last minute, notifications
+      on your other devices wait a few seconds, so a question you answer here doesn't buzz
+      your phone; the server hears only yes or no. Off by default. machine-kind: the icon
+      devices show, detected by setup.
 
   starbridge hook permission --agent claude-code|pi|opencode [--wait 570s]
   starbridge hook settle --agent claude-code
-      For Claude Code's PermissionRequest hook, and for its PostToolUse, PermissionDenied,
-      Stop and SessionEnd hooks: hook JSON on stdin; prints the hook's decision, or nothing
+      For Claude Code's PermissionRequest hook, and for its PostToolUse, PostToolUseFailure,
+      PermissionDenied, Stop and SessionEnd hooks: hook JSON on stdin; prints the hook's decision, or nothing
       to leave the prompt to the keyboard. The Starbridge Pi extension runs it with --agent pi
-      for pi-permission-system's prompts, the opencode plugin with --agent opencode.
+      for pi-permission-system's prompts, the opencode plugin with --agent opencode. On
+      Claude Code's AskUserQuestion it posts each question to your devices, whatever the
+      permissions setting, and prints the first device answers as the picker's; an answer
+      in the picker settles them.
 
   starbridge hook ask-user
-      For Claude Code's PreToolUse hook on AskUserQuestion: hook JSON on stdin; answers each
-      question by telling the agent to use \`starbridge ask\`; prints nothing, which lets it
-      through, when this machine is not paired or the server does not answer.
+      For Claude Code's PreToolUse hook on AskUserQuestion, from older plugins: prints
+      nothing, so the picker opens and hook permission races it.
 
   starbridge hook question --agent opencode
       For the Starbridge opencode plugin, on each call of opencode's question tool: posts each
@@ -23586,9 +24219,9 @@ var HELP = `starbridge: post decisions to your devices, report runs, upload quot
 
   starbridge update [--codexbar <version>]
       Install the latest release once its signature checks out, then \`setup --refresh\` (brew
-      and npm installs: use their manager, then \`starbridge setup --refresh\`); then CodexBar's
-      latest release if setup installed it. --codexbar installs that CodexBar release instead,
-      and only that.
+      and npm installs: use their manager, then \`starbridge setup --refresh\`); then the
+      CodexBar release this Starbridge release pins, if setup installed CodexBar. --codexbar
+      installs that CodexBar release instead, and only that; update keeps it if it is newer.
 
   starbridge --version
 
@@ -23610,7 +24243,7 @@ function parseSessionLink(text) {
 }
 function readText3(path) {
   try {
-    return readFileSync13(path === "-" ? 0 : path, "utf8");
+    return readFileSync15(path === "-" ? 0 : path, "utf8");
   } catch (e) {
     throw new UsageError(`cannot read ${path === "-" ? "stdin" : path}: ${e.message}`);
   }
@@ -23644,9 +24277,13 @@ async function run2(argv, ctx) {
           options: {
             server: { type: "string" },
             name: { type: "string" },
-            force: { type: "boolean" }
+            force: { type: "boolean" },
+            confirm: { type: "boolean" },
+            reject: { type: "boolean" }
           }
         });
+        if (values.confirm || values.reject)
+          return sendConfirm(ctx, !values.reject);
         return await pair(ctx, values);
       }
       case "ask": {
@@ -23892,7 +24529,7 @@ async function run2(argv, ctx) {
         if (sub === "settle")
           return await hookSettle(ctx, readText3("-"), values);
         if (sub === "ask-user")
-          return await hookAskUser(ctx, readText3("-"));
+          return hookAskUser();
         if (sub === "question")
           return await hookQuestion(ctx, readText3("-"), values);
         throw new UsageError("usage: starbridge hook permission|settle --agent claude-code, starbridge hook ask-user, or starbridge hook question --agent opencode");