@archme/cli 0.7.0 → 0.8.0

package/dist/cli.js

@@ -720,11 +720,11 @@ var hasColors, format, reset, bold, dim, italic, underline, overline, inverse, h
 var init_base = __esm({
   "node_modules/yoctocolors/base.js"() {
     hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
-    format = (open2, close) => {
+    format = (open3, close) => {
       if (!hasColors) {
         return (input) => input;
       }
-      const openCode = `\x1B[${open2}m`;
+      const openCode = `\x1B[${open3}m`;
       const closeCode = `\x1B[${close}m`;
       return (input) => {
         const string = input + "";
@@ -4057,8 +4057,8 @@ function prettyMilliseconds(milliseconds, options) {
     const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
     return flooredValue.toFixed(decimalDigits);
   };
-  const add = (value, long, short4, valueString) => {
-    if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short4 === "m")) {
+  const add = (value, long, short5, valueString) => {
+    if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short5 === "m")) {
       return;
     }
     valueString ??= String(value);
@@ -4067,7 +4067,7 @@ function prettyMilliseconds(milliseconds, options) {
       const minLength = result.length > 0 ? 2 : 1;
       valueString = "0".repeat(Math.max(0, minLength - wholeDigits)) + valueString;
     } else {
-      valueString += options.verbose ? " " + pluralize(long, value) : short4;
+      valueString += options.verbose ? " " + pluralize(long, value) : short5;
     }
     result.push(valueString);
   };
@@ -8293,9 +8293,11 @@ var credentials_exports = {};
 __export(credentials_exports, {
   clearCredential: () => clearCredential,
   clearCredentials: () => clearCredentials,
+  credentialKind: () => credentialKind,
   describeCredentialSource: () => describeCredentialSource,
   loadAllCredentials: () => loadAllCredentials,
   loadCredentials: () => loadCredentials,
+  loadKeytar: () => loadKeytar,
   replaceUrlCredentials: () => replaceUrlCredentials,
   saveCredentials: () => saveCredentials
 });
@@ -8312,6 +8314,9 @@ function withStoreLock(fn) {
   });
   return run;
 }
+function credentialKind(c3) {
+  return c3.kind === "key" ? "key" : "oauth";
+}
 function isStored(x) {
   if (!x || typeof x !== "object") return false;
   const c3 = x;
@@ -8319,6 +8324,9 @@ function isStored(x) {
   if (c3.bindings !== void 0 && !Array.isArray(c3.bindings)) {
     c3.bindings = void 0;
   }
+  if (c3.kind !== void 0 && c3.kind !== "oauth" && c3.kind !== "key") {
+    delete c3.kind;
+  }
   return true;
 }
 function parseStore(raw) {
@@ -8361,9 +8369,10 @@ async function loadCredentials(supabaseUrl) {
   return { credentials: list[list.length - 1] ?? null, source, path: path7 };
 }
 function mergeBindings(incoming, prior) {
-  if (incoming.bindings?.length) return incoming;
-  if (prior?.bindings?.length) return { ...incoming, bindings: prior.bindings };
-  return incoming;
+  const withKind = incoming.kind === void 0 && prior?.kind !== void 0 ? { ...incoming, kind: prior.kind } : incoming;
+  if (withKind.bindings?.length) return withKind;
+  if (prior?.bindings?.length) return { ...withKind, bindings: prior.bindings };
+  return withKind;
 }
 async function saveCredentials(credentials) {
   return withStoreLock(async () => {
@@ -8480,6 +8489,156 @@ var init_credentials = __esm({
   }
 });
 
+// src/auth/keyRing.ts
+var keyRing_exports = {};
+__export(keyRing_exports, {
+  KeyRingUnreadableError: () => KeyRingUnreadableError,
+  findKey: () => findKey,
+  forgetKey: () => forgetKey,
+  keyRingLockPath: () => keyRingLockPath,
+  keyRingPath: () => keyRingPath,
+  listKeys: () => listKeys,
+  saveKey: () => saveKey
+});
+import { randomBytes } from "node:crypto";
+import { chmod as chmod2, mkdir as mkdir2, open, readFile as readFile2, rename, rm as rm2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { lock as lockFile } from "proper-lockfile";
+function keyRingPath() {
+  return process.env.ARCHME_KEYS_PATH ?? join2(homedir2(), ".archme", "keys.json");
+}
+function keyRingLockPath() {
+  return join2(dirname2(keyRingPath()), "keys.lock");
+}
+async function withFileLock(fn) {
+  const dir = dirname2(keyRingPath());
+  await mkdir2(dir, { recursive: true, mode: 448 });
+  const release = await lockFile(dir, {
+    lockfilePath: keyRingLockPath(),
+    realpath: false,
+    stale: 1e4,
+    retries: { retries: 100, minTimeout: 20, maxTimeout: 250 },
+    // The default throws from a timer, which kills the process mid-command.
+    onCompromised: () => {
+    }
+  });
+  try {
+    return await fn();
+  } finally {
+    await release().catch(() => {
+    });
+  }
+}
+function withRingLock(fn) {
+  const locked = () => withFileLock(fn);
+  const run = ringMutex.then(locked, locked);
+  ringMutex = run.then(() => {
+  }, () => {
+  });
+  return run;
+}
+function isSavedKey(x) {
+  if (!x || typeof x !== "object") return false;
+  const k = x;
+  return typeof k.user_id === "string" && !!k.user_id && typeof k.key === "string" && !!k.key && typeof k.handle === "string" && typeof k.saved_at === "string";
+}
+async function readEntries() {
+  const where = keyRingPath();
+  let raw;
+  try {
+    raw = await readFile2(where, "utf8");
+  } catch (err2) {
+    if (err2.code === "ENOENT") return [];
+    throw new KeyRingUnreadableError(where, err2.message);
+  }
+  let doc;
+  try {
+    doc = JSON.parse(raw);
+  } catch {
+    throw new KeyRingUnreadableError(where, raw === "" ? "it is empty" : "it is not valid JSON");
+  }
+  const d = doc;
+  if (!d || typeof d !== "object" || !Array.isArray(d.keys)) {
+    throw new KeyRingUnreadableError(where, "it is not a key ring");
+  }
+  if (d.v !== 1) throw new KeyRingUnreadableError(where, `it is version ${String(d.v)}; this archme reads version 1`);
+  return d.keys;
+}
+function isFileEntry(k) {
+  return isSavedKey(k) && typeof k.supabase_url === "string";
+}
+function isFor(k, supabaseUrl, userId) {
+  if (!k || typeof k !== "object") return false;
+  const e = k;
+  return e.user_id === userId && e.supabase_url === supabaseUrl;
+}
+async function writeEntries(entries) {
+  const path7 = keyRingPath();
+  if (entries.length === 0) {
+    await rm2(path7, { force: true });
+    return;
+  }
+  await mkdir2(dirname2(path7), { recursive: true, mode: 448 });
+  await chmod2(dirname2(path7), 448).catch(() => {
+  });
+  const tmp = join2(dirname2(path7), `.keys.json.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    const fh = await open(tmp, "wx", 384);
+    try {
+      await fh.writeFile(JSON.stringify({ v: 1, keys: entries }, null, 2));
+      await fh.chmod(384);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await rename(tmp, path7);
+  } catch (err2) {
+    await rm2(tmp, { force: true }).catch(() => {
+    });
+    throw err2;
+  }
+}
+function strip(e) {
+  return { user_id: e.user_id, key: e.key, handle: e.handle, saved_at: e.saved_at };
+}
+async function listKeys(supabaseUrl) {
+  return (await readEntries()).filter(isFileEntry).filter((e) => e.supabase_url === supabaseUrl).map(strip);
+}
+async function findKey(supabaseUrl, userId) {
+  return (await listKeys(supabaseUrl)).find((k) => k.user_id === userId) ?? null;
+}
+async function saveKey(supabaseUrl, toSave) {
+  const saved = { ...toSave, saved_at: (/* @__PURE__ */ new Date()).toISOString() };
+  return withRingLock(async () => {
+    const others = (await readEntries()).filter((k) => !isFor(k, supabaseUrl, saved.user_id));
+    await writeEntries([...others, { ...saved, supabase_url: supabaseUrl }]);
+    return saved;
+  });
+}
+async function forgetKey(supabaseUrl, userId) {
+  return withRingLock(async () => {
+    const all = await readEntries();
+    const remaining = all.filter((e) => !isFor(e, supabaseUrl, userId));
+    if (remaining.length === all.length) return false;
+    await writeEntries(remaining);
+    return true;
+  });
+}
+var ringMutex, KeyRingUnreadableError;
+var init_keyRing = __esm({
+  "src/auth/keyRing.ts"() {
+    "use strict";
+    ringMutex = Promise.resolve();
+    KeyRingUnreadableError = class extends Error {
+      constructor(where, why) {
+        super(`Your saved ArchMe keys in ${where} could not be read (${why}). Nothing was written. Fix or move it aside, then try again.`);
+        this.name = "KeyRingUnreadableError";
+      }
+    };
+  }
+});
+
 // src/config/defaults.ts
 var defaults_exports = {};
 __export(defaults_exports, {
@@ -8489,8 +8648,8 @@ __export(defaults_exports, {
   writeLocalConfig: () => writeLocalConfig
 });
 import { existsSync, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
 function readLocalConfig() {
   if (!existsSync(LOCAL_CONFIG_PATH)) return {};
   try {
@@ -8530,7 +8689,7 @@ function resolveConfig() {
   };
 }
 function writeLocalConfig(config2) {
-  mkdirSync(dirname2(LOCAL_CONFIG_PATH), { recursive: true });
+  mkdirSync(dirname3(LOCAL_CONFIG_PATH), { recursive: true });
   writeFileSync2(LOCAL_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", { mode: 384 });
   return LOCAL_CONFIG_PATH;
 }
@@ -8554,7 +8713,7 @@ var init_defaults = __esm({
         // ~/.archme/local-config.json (written by setup:local-daemon-oauth).
       }
     };
-    LOCAL_CONFIG_PATH = join2(homedir2(), ".archme", "local-config.json");
+    LOCAL_CONFIG_PATH = join3(homedir3(), ".archme", "local-config.json");
     MissingConfigError = class extends Error {
       archmeEnv;
       missing;
@@ -8571,10 +8730,332 @@ var init_defaults = __esm({
   }
 });
 
+// ../shared/accountKey.ts
+function keyedAccountEmail(handle) {
+  return `${handle}@${KEYED_EMAIL_DOMAIN}`;
+}
+function isKeyedAccountEmail(email) {
+  return !!email && email.toLowerCase().endsWith(`@${KEYED_EMAIL_DOMAIN}`);
+}
+function formatAccountKey(handle, secret) {
+  return `${ACCOUNT_KEY_PREFIX}${handle}_${secret}`;
+}
+function parseAccountKey(raw) {
+  const m = KEY_RE.exec((raw ?? "").trim());
+  if (!m) return null;
+  const handle = m[1];
+  return { handle, secret: m[2], email: keyedAccountEmail(handle) };
+}
+var KEYED_EMAIL_DOMAIN, ACCOUNT_KEY_PREFIX, KEY_RE;
+var init_accountKey = __esm({
+  "../shared/accountKey.ts"() {
+    KEYED_EMAIL_DOMAIN = "keys.archme.io";
+    ACCOUNT_KEY_PREFIX = "amk_";
+    KEY_RE = /^amk_([a-z0-9](?:[a-z0-9-]*[a-z0-9])?-[0-9a-f]{6})_([A-Za-z0-9_-]{43})$/;
+  }
+});
+
+// src/scan/oauthClient.ts
+var oauthClient_exports = {};
+__export(oauthClient_exports, {
+  DEFAULT_TOKEN_EXPIRES_IN_SECONDS: () => DEFAULT_TOKEN_EXPIRES_IN_SECONDS,
+  LoadStoredAndRefreshError: () => LoadStoredAndRefreshError,
+  REFRESH_RETRY_BACKOFF_MS: () => REFRESH_RETRY_BACKOFF_MS,
+  computeExpiresAt: () => computeExpiresAt,
+  fetchWithAuthRetry: () => fetchWithAuthRetry,
+  getOAuthUserInfoWith: () => getOAuthUserInfoWith,
+  isAuthError: () => isAuthError,
+  isPermanentRefreshError: () => isPermanentRefreshError,
+  parseJsonResponse: () => parseJsonResponse,
+  refreshOAuthCredentialsWith: () => refreshOAuthCredentialsWith,
+  resolveUserId: () => resolveUserId,
+  responseError: () => responseError,
+  withAuthRetry: () => withAuthRetry
+});
+function computeExpiresAt(expiresInSeconds) {
+  const seconds = expiresInSeconds ?? DEFAULT_TOKEN_EXPIRES_IN_SECONDS;
+  return Date.now() + seconds * 1e3;
+}
+function isPermanentRefreshError(body, status) {
+  if (status >= 500) return false;
+  if (body.error === "invalid_grant") return true;
+  const errorCode = typeof body.error_code === "string" ? body.error_code.toLowerCase() : "";
+  if (errorCode.startsWith("refresh_token")) return true;
+  const message = [body.error_description, body.msg, body.error, body.message].filter((v) => typeof v === "string").join(" ").toLowerCase();
+  return /invalid refresh token|refresh token not found|refresh token already used/.test(message);
+}
+async function refreshOAuthCredentialsWith(refreshToken, cfg) {
+  let response;
+  try {
+    response = await fetch(`${cfg.supabaseUrl}/auth/v1/oauth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        apikey: cfg.anonKey
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: cfg.clientId
+      })
+    });
+  } catch (err2) {
+    return {
+      ok: false,
+      permanent: false,
+      error: `network error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    };
+  }
+  const body = await parseJsonResponse(response);
+  if (!response.ok) {
+    return {
+      ok: false,
+      permanent: isPermanentRefreshError(body, response.status),
+      error: responseError(body, `refresh failed (${response.status})`)
+    };
+  }
+  if (typeof body.access_token !== "string" || !body.access_token) {
+    return { ok: false, permanent: false, error: "refresh response did not include an access token" };
+  }
+  return {
+    ok: true,
+    tokens: {
+      access_token: body.access_token,
+      refresh_token: typeof body.refresh_token === "string" ? body.refresh_token : void 0,
+      expires_in: typeof body.expires_in === "number" ? body.expires_in : Number(body.expires_in) || void 0,
+      token_type: typeof body.token_type === "string" ? body.token_type : void 0
+    }
+  };
+}
+async function getOAuthUserInfoWith(accessToken, cfg) {
+  const response = await fetch(`${cfg.supabaseUrl}/auth/v1/oauth/userinfo`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) return {};
+  return await parseJsonResponse(response);
+}
+function resolveUserId(userInfo2, storedUserId) {
+  return userInfo2.sub ?? storedUserId ?? null;
+}
+function isAuthError(err2) {
+  if (!err2 || typeof err2 !== "object") return false;
+  const msg = ("message" in err2 ? String(err2.message) : "").toLowerCase();
+  const code = ("code" in err2 ? String(err2.code) : "").toLowerCase();
+  const status = "status" in err2 ? Number(err2.status) : 0;
+  return status === 401 || code === "pgrst301" || msg.includes("jwt expired") || msg.includes("invalid jwt") || msg.includes("not authenticated");
+}
+async function withAuthRetry(label, fn, reLogin) {
+  const first = await fn();
+  if (!first.error || !isAuthError(first.error)) return first;
+  console.warn(`${label}: auth error on first attempt, re-logging in and retrying once`);
+  try {
+    await reLogin();
+  } catch (err2) {
+    console.error(`${label}: re-login failed:`, err2);
+    return first;
+  }
+  return await fn();
+}
+async function fetchWithAuthRetry(label, doFetch, reLogin) {
+  const first = await doFetch();
+  if (first.status !== 401) return first;
+  console.warn(`${label}: 401 on first attempt, re-logging in and retrying once`);
+  try {
+    await reLogin();
+  } catch (err2) {
+    console.error(`${label}: re-login failed:`, err2);
+    return first;
+  }
+  return await doFetch();
+}
+async function parseJsonResponse(response) {
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { error: text, error_description: text, msg: text };
+  }
+}
+function responseError(body, fallback) {
+  for (const key of ["error_description", "error", "msg"]) {
+    const value = body[key];
+    if (typeof value === "string" && value) return value;
+  }
+  return fallback;
+}
+var DEFAULT_TOKEN_EXPIRES_IN_SECONDS, REFRESH_RETRY_BACKOFF_MS, LoadStoredAndRefreshError;
+var init_oauthClient = __esm({
+  "src/scan/oauthClient.ts"() {
+    "use strict";
+    DEFAULT_TOKEN_EXPIRES_IN_SECONDS = 3600;
+    REFRESH_RETRY_BACKOFF_MS = 6e4;
+    LoadStoredAndRefreshError = class extends Error {
+      code;
+      permanent;
+      constructor(code, message) {
+        super(message);
+        this.name = "LoadStoredAndRefreshError";
+        this.code = code;
+        this.permanent = code !== "transient";
+      }
+    };
+  }
+});
+
+// src/scan/keySession.ts
+function isRejectedKeyError(body, status) {
+  if (status >= 500 || status === 429) return false;
+  if (body.error === "invalid_grant") return true;
+  const code = typeof body.error_code === "string" ? body.error_code.toLowerCase() : "";
+  if (REJECTED_CODES.has(code)) return true;
+  const message = [body.error_description, body.msg, body.message].filter((v) => typeof v === "string").join(" ");
+  return /invalid login credentials/i.test(message);
+}
+async function tokenGrant(grant, body, cfg, isPermanent) {
+  let response;
+  try {
+    response = await fetch(`${cfg.supabaseUrl}/auth/v1/token?grant_type=${grant}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", apikey: cfg.anonKey },
+      body: JSON.stringify(body)
+    });
+  } catch (err2) {
+    return { ok: false, permanent: false, error: `network error: ${err2 instanceof Error ? err2.message : String(err2)}` };
+  }
+  const parsed = await parseJsonResponse(response);
+  if (!response.ok) {
+    return {
+      ok: false,
+      permanent: isPermanent(parsed, response.status),
+      error: responseError(parsed, `${grant} grant failed (${response.status})`)
+    };
+  }
+  if (typeof parsed.access_token !== "string" || !parsed.access_token) {
+    return { ok: false, permanent: false, error: "token response did not include an access token" };
+  }
+  const user = parsed.user;
+  return {
+    ok: true,
+    tokens: {
+      access_token: parsed.access_token,
+      refresh_token: typeof parsed.refresh_token === "string" ? parsed.refresh_token : void 0,
+      expires_in: typeof parsed.expires_in === "number" ? parsed.expires_in : Number(parsed.expires_in) || void 0,
+      token_type: typeof parsed.token_type === "string" ? parsed.token_type : void 0
+    },
+    ...typeof user?.id === "string" ? { userId: user.id } : {}
+  };
+}
+function passwordGrant(email, secret, cfg) {
+  return tokenGrant("password", { email, password: secret }, cfg, isRejectedKeyError);
+}
+function refreshKeySession(refreshToken, cfg) {
+  return tokenGrant("refresh_token", { refresh_token: refreshToken }, cfg, isPermanentRefreshError);
+}
+async function fetchAuthUser(accessToken, cfg) {
+  try {
+    const response = await fetch(`${cfg.supabaseUrl}/auth/v1/user`, {
+      headers: { Authorization: `Bearer ${accessToken}`, apikey: cfg.anonKey }
+    });
+    if (!response.ok) return null;
+    const body = await parseJsonResponse(response);
+    return typeof body.id === "string" ? body : null;
+  } catch {
+    return null;
+  }
+}
+async function getKeyUserInfo(accessToken, cfg) {
+  const user = await fetchAuthUser(accessToken, cfg);
+  if (!user) return {};
+  return { sub: user.id, ...user.email ? { email: user.email } : {} };
+}
+var REJECTED_CODES;
+var init_keySession = __esm({
+  "src/scan/keySession.ts"() {
+    "use strict";
+    init_oauthClient();
+    REJECTED_CODES = /* @__PURE__ */ new Set(["invalid_credentials", "user_banned", "user_not_found", "email_not_confirmed"]);
+  }
+});
+
+// src/daemon/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  promptChoice: () => promptChoice,
+  promptLine: () => promptLine,
+  promptYesNo: () => promptYesNo,
+  stdinIsInteractive: () => stdinIsInteractive
+});
+import { createInterface } from "node:readline/promises";
+function stdinIsInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function withReadline(fn) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await fn(rl);
+  } finally {
+    rl.close();
+  }
+}
+async function promptLine(question) {
+  return await withReadline(async (rl) => {
+    try {
+      return await rl.question(`${question}: `);
+    } catch {
+      return "";
+    }
+  });
+}
+async function promptChoice(question, options) {
+  return await withReadline(async (rl) => {
+    console.log(`
+${question}
+`);
+    options.forEach((o2, i2) => console.log(`  ${i2 + 1}. ${o2.label}
+`));
+    for (let attempt = 0; attempt < 3; attempt++) {
+      let answer;
+      try {
+        answer = (await rl.question(`Choose 1-${options.length} [1]: `)).trim();
+      } catch {
+        return options[0].value;
+      }
+      if (answer === "") return options[0].value;
+      const n2 = Number.parseInt(answer, 10);
+      if (Number.isInteger(n2) && n2 >= 1 && n2 <= options.length) return options[n2 - 1].value;
+      console.log(`  "${answer}" isn't one of the options.`);
+    }
+    return options[0].value;
+  });
+}
+async function promptYesNo(question, opts = {}) {
+  const defaultYes = opts.defaultYes ?? true;
+  return await withReadline(async (rl) => {
+    try {
+      const answer = (await rl.question(`${question} ${defaultYes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+      if (answer === "") return defaultYes;
+      return answer === "y" || answer === "yes";
+    } catch {
+      return false;
+    }
+  });
+}
+var init_prompt = __esm({
+  "src/daemon/prompt.ts"() {
+    "use strict";
+  }
+});
+
 // src/auth/enroll.ts
 var enroll_exports = {};
 __export(enroll_exports, {
+  LoginError: () => LoginError,
+  decideLoginMethod: () => decideLoginMethod,
+  defaultDeviceName: () => defaultDeviceName,
+  parseLoginArgs: () => parseLoginArgs,
   reconcileEnrollment: () => reconcileEnrollment,
+  runGitHubPairing: () => runGitHubPairing,
   runLogin: () => runLogin
 });
 import { hostname, platform as platform2 } from "node:os";
@@ -8582,6 +9063,7 @@ async function reconcileEnrollment(supabaseUrl, poll) {
   const bindings = poll.devices?.length ? poll.devices : [{ org_id: poll.org_id, device_id: poll.device_id }];
   const primary = bindings[0];
   const source = await replaceUrlCredentials(supabaseUrl, [{
+    kind: "oauth",
     refresh_token: poll.refresh_token,
     access_token: poll.access_token,
     org_id: primary.org_id,
@@ -8592,17 +9074,7 @@ async function reconcileEnrollment(supabaseUrl, poll) {
   }]);
   return { bindings, source };
 }
-async function runLogin() {
-  let SUPABASE_URL2;
-  try {
-    SUPABASE_URL2 = resolveConfig().supabaseUrl;
-  } catch (err2) {
-    if (err2 instanceof MissingConfigError) {
-      console.error(err2.message);
-      process.exit(1);
-    }
-    throw err2;
-  }
+async function runGitHubPairing(SUPABASE_URL2) {
   function functionsBaseUrl() {
     return `${SUPABASE_URL2.replace(/\/$/, "")}/functions/v1/agents-device`;
   }
@@ -8615,57 +9087,312 @@ async function runLogin() {
     const data2 = await response.json();
     return { status: response.status, data: data2 };
   }
-  const deviceName = process.env.ARCHME_DAEMON_DEVICE_NAME || hostname();
+  const deviceName = defaultDeviceName();
   const { status, data } = await postJson("/start", {
     device_name: deviceName
   });
   if (status !== 200) {
     throw new Error(`Failed to start enrollment: ${JSON.stringify(data)}`);
   }
-  const bareUrl = data.verification_uri.split("?")[0] ?? data.verification_uri;
-  console.log("ArchitectMe daemon enrollment");
-  console.log("");
-  console.log(`  Device: ${deviceName}`);
-  console.log(`  Code: ${data.user_code.slice(0, 4)}-${data.user_code.slice(4)}`);
-  console.log(`  URL:  ${bareUrl}`);
-  console.log("");
-  console.log("Paste the code above into the pairing page.");
-  if (platform2() === "darwin" && !process.argv.includes("--no-open")) {
-    await execa("open", [bareUrl], { reject: false });
+  const bareUrl = data.verification_uri.split("?")[0] ?? data.verification_uri;
+  console.log("ArchitectMe daemon enrollment");
+  console.log("");
+  console.log(`  Device: ${deviceName}`);
+  console.log(`  Code: ${data.user_code.slice(0, 4)}-${data.user_code.slice(4)}`);
+  console.log(`  URL:  ${bareUrl}`);
+  console.log("");
+  console.log("Paste the code above into the pairing page.");
+  if (platform2() === "darwin" && !process.argv.includes("--no-open")) {
+    await execa("open", [bareUrl], { reject: false });
+  }
+  const expiresAt = Date.now() + data.expires_in * 1e3;
+  let intervalMs = Math.max(data.interval, 1) * 1e3;
+  while (Date.now() < expiresAt) {
+    await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+    const poll = await postJson("/poll", {
+      device_code: data.device_code
+    });
+    if (poll.status === 200 && "refresh_token" in poll.data) {
+      const { bindings, source } = await reconcileEnrollment(SUPABASE_URL2, poll.data);
+      console.log(`Enrollment complete. Credentials stored in ${describeCredentialSource(source)}.`);
+      console.log(`Daemon will serve 1 account across ${bindings.length} org(s).`);
+      return;
+    }
+    if (poll.status === 200 && "status" in poll.data && poll.data.status === "pending") {
+      continue;
+    }
+    if ("error" in poll.data && poll.data.error === "slow_down") {
+      intervalMs = Math.max(poll.data.interval ?? data.interval, data.interval) * 1e3;
+      continue;
+    }
+    if ("error" in poll.data && poll.data.error === "expired") {
+      throw new Error("Pairing code expired. Run `archme login` again.");
+    }
+    throw new Error(`Enrollment failed: ${JSON.stringify(poll.data)}`);
+  }
+  throw new Error("Pairing code expired. Run `archme login` again.");
+}
+function parseLoginArgs(argv) {
+  const opts = {};
+  const setMethod = (m, flag) => {
+    if (opts.method && opts.method !== m) return `${flag} cannot be combined with another sign-in option`;
+    opts.method = m;
+    return null;
+  };
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const arg = argv[i2];
+    if (arg === "--no-open") continue;
+    if (arg.startsWith("--key=")) {
+      const err2 = setMethod("key", "--key");
+      if (err2) return { ok: false, error: err2 };
+      opts.key = arg.slice("--key=".length);
+      continue;
+    }
+    const method = METHOD_FLAGS[arg];
+    if (method) {
+      const err2 = setMethod(method, arg);
+      if (err2) return { ok: false, error: err2 };
+      if (method === "key" && argv[i2 + 1] !== void 0 && !argv[i2 + 1].startsWith("-")) opts.key = argv[++i2];
+      continue;
+    }
+    return { ok: false, error: `unknown option \`${arg}\`` };
+  }
+  return { ok: true, opts };
+}
+function decideLoginMethod(input) {
+  if (input.opts.method) return { method: input.opts.method };
+  if (input.envKey) return { method: "key" };
+  const hasStored = input.hasActiveLogin || input.savedKeys > 0;
+  if (input.interactive) return { ask: hasStored ? ["github", "key"] : ["no-account", "github", "key"] };
+  if (!hasStored) return { method: "no-account" };
+  if (!input.hasActiveLogin && input.savedKeys === 1) return { method: "key" };
+  return { method: "github" };
+}
+function defaultDeviceName() {
+  return process.env.ARCHME_DAEMON_DEVICE_NAME || hostname();
+}
+async function defaultLoginDeps() {
+  let cfg;
+  try {
+    cfg = resolveConfig();
+  } catch (err2) {
+    if (err2 instanceof MissingConfigError) {
+      console.error(err2.message);
+      process.exit(1);
+    }
+    throw err2;
+  }
+  const { supabaseUrl, supabaseAnonKey } = cfg;
+  const { promptChoice: promptChoice2, promptLine: promptLine2, stdinIsInteractive: stdinIsInteractive2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
+  return {
+    supabaseUrl,
+    interactive: stdinIsInteractive2(),
+    deviceName: defaultDeviceName(),
+    hasActiveLogin: async () => (await loadAllCredentials(supabaseUrl)).credentials.length > 0,
+    listKeys,
+    saveKey,
+    replaceCredentials: replaceUrlCredentials,
+    passwordGrant: (email, secret) => passwordGrant(email, secret, { supabaseUrl, anonKey: supabaseAnonKey }),
+    postAgentsDevice: async (path7, body, bearer) => {
+      const response = await fetch(`${supabaseUrl.replace(/\/$/, "")}/functions/v1/agents-device${path7}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...bearer ? { Authorization: `Bearer ${bearer}` } : {}
+        },
+        body: JSON.stringify(body)
+      });
+      return { status: response.status, data: await parseJsonResponse(response) };
+    },
+    gitUserName: async () => {
+      const r = await execa("git", ["config", "user.name"], { reject: false });
+      return r.exitCode === 0 && r.stdout.trim() ? r.stdout.trim() : null;
+    },
+    choose: promptChoice2,
+    promptLine: promptLine2,
+    githubPairing: () => runGitHubPairing(supabaseUrl),
+    log: (msg) => console.log(msg),
+    envKey: process.env.ARCHME_KEY,
+    keyRingPath: keyRingPath()
+  };
+}
+async function runLogin(opts = {}, injected) {
+  const base = injected ?? await defaultLoginDeps();
+  const deps = opts.interactive === false ? { ...base, interactive: false } : base;
+  const envKey = deps.envKey || void 0;
+  const given = opts.method === "key" || !opts.method && envKey ? opts.key || envKey : void 0;
+  const ring = opts.method === "github" || given ? await deps.listKeys(deps.supabaseUrl).catch(() => []) : await deps.listKeys(deps.supabaseUrl);
+  const decision = decideLoginMethod({
+    opts,
+    interactive: deps.interactive,
+    hasActiveLogin: await deps.hasActiveLogin(),
+    savedKeys: ring.length,
+    envKey: !!envKey
+  });
+  const method = "method" in decision ? decision.method : await deps.choose(
+    "How do you want to sign in?",
+    decision.ask.map((m) => ({ label: METHOD_LABELS[m], value: m }))
+  );
+  if (method === "github") {
+    await deps.githubPairing();
+    return { method };
+  }
+  if (method === "no-account") return await mintKeyedAccount(deps);
+  const raw = given ?? await pickSavedKey(deps, ring);
+  const result = await signInWithKey(deps, raw);
+  if (!given && ring.some((k) => k.key === raw)) {
+    deps.log(`  Used the key saved on this machine for ${result.handle}. \`archme login --github\` signs in with GitHub instead.`);
+  }
+  return result;
+}
+function redactKey(data) {
+  const text = JSON.stringify(data && typeof data === "object" && "key" in data ? { ...data, key: "[redacted]" } : data);
+  return (text ?? String(data)).replace(/amk_[A-Za-z0-9_-]+/g, "[redacted]");
+}
+async function mintKeyedAccount(deps) {
+  const displayName = await deps.gitUserName();
+  const res = await deps.postAgentsDevice("/key-account", {
+    device_name: deps.deviceName,
+    ...displayName ? { display_name: displayName } : {}
+  });
+  const errorCode = res.data?.error;
+  if (res.status === 429 && errorCode === "busy") {
+    throw new LoginError(
+      "ArchMe is creating a lot of accounts right now. Try again in a few minutes, or sign in with GitHub: archme login --github"
+    );
+  }
+  if (res.status === 429) {
+    throw new LoginError(
+      "Too many accounts have been created from this network in the last hour. Sign in with GitHub instead: archme login --github"
+    );
+  }
+  if (res.status >= 500 && (errorCode === "not_configured" || errorCode === "rate_check_failed")) {
+    throw new LoginError(
+      `ArchMe couldn't create an account just now (a temporary server problem: ${errorCode}). Try again in a few minutes, or sign in with GitHub: archme login --github`
+    );
+  }
+  const data = res.data;
+  const parsed = parseAccountKey(data.key);
+  if (res.status !== 200 || !parsed || !data.user_id) {
+    throw new LoginError(`Could not create an account (${res.status}): ${redactKey(res.data)}`);
+  }
+  let saved = false;
+  try {
+    await deps.saveKey(deps.supabaseUrl, { user_id: data.user_id, key: data.key, handle: parsed.handle });
+    saved = true;
+  } catch (err2) {
+    deps.log(`! Created ${parsed.handle}, but its key could not be written to ${deps.keyRingPath}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    deps.log("  It is the only way back into this account. Save this now (a password manager is a good place):");
+    deps.log("");
+    deps.log(`    ${data.key}`);
+    deps.log("");
+    deps.log(`  Later, sign in with it: ${KEY_VIA_ENV}`);
+  }
+  const grant = await deps.passwordGrant(parsed.email, parsed.secret);
+  if (!grant.ok) {
+    throw new LoginError(
+      `Created ${parsed.handle}${saved ? " and saved its key" : ""}, but signing in failed: ${grant.error}. ` + (saved ? "Run `archme login --key` to try again." : `Try again with the key printed above: ${KEY_VIA_ENV}.`)
+    );
+  }
+  await storeKeyedLogin(deps, grant, data);
+  deps.log(`\u2713 Created your ArchMe account ${parsed.handle} \u2014 no email or password, just a key.`);
+  if (saved) {
+    deps.log(`  The key is saved in ${deps.keyRingPath}. Save it in your password manager too: it is the`);
+    deps.log("  only way back in, including from another computer. `archme key show` prints it.");
+  }
+  deps.log("  `archme open` opens your board, signed in.");
+  return { method: "no-account", userId: data.user_id, handle: parsed.handle };
+}
+async function pickSavedKey(deps, ring) {
+  if (ring.length === 1) return ring[0].key;
+  if (ring.length > 1) {
+    const newestFirst = [...ring].reverse();
+    if (!deps.interactive) {
+      throw new LoginError(
+        `Several keys are saved (${newestFirst.map((k) => k.handle).join(", ")}). Run \`archme login --key\` at a terminal to pick one, or pass it with ${KEY_VIA_ENV} (\`archme key show --handle <handle>\` prints it).`
+      );
+    }
+    return await deps.choose("Which account?", newestFirst.map((k) => ({ label: k.handle, value: k.key })));
+  }
+  if (!deps.interactive) {
+    throw new LoginError(
+      `No saved keys on this machine. Run \`archme login --key\` at a terminal to paste yours, or pass it with ${KEY_VIA_ENV}.`
+    );
   }
-  const expiresAt = Date.now() + data.expires_in * 1e3;
-  let intervalMs = Math.max(data.interval, 1) * 1e3;
-  while (Date.now() < expiresAt) {
-    await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
-    const poll = await postJson("/poll", {
-      device_code: data.device_code
+  return await deps.promptLine("Paste your key (amk_\u2026)");
+}
+async function signInWithKey(deps, raw) {
+  const parsed = parseAccountKey(raw);
+  if (!parsed) throw new LoginError("That doesn't look like an ArchMe key (amk_<handle>_<secret>).");
+  const grant = await deps.passwordGrant(parsed.email, parsed.secret);
+  if (!grant.ok) {
+    throw new LoginError(grant.permanent ? `The key for ${parsed.handle} was rejected. Check it and try again.` : `Could not sign in: ${grant.error}`);
+  }
+  const reg = await deps.postAgentsDevice("/register-device", { device_name: deps.deviceName }, grant.tokens.access_token);
+  const data = reg.data;
+  if (reg.status !== 200 || !data.user_id) {
+    throw new LoginError(`Could not register this machine (${reg.status}): ${redactKey(reg.data)}`);
+  }
+  try {
+    await deps.saveKey(deps.supabaseUrl, {
+      user_id: data.user_id,
+      key: formatAccountKey(parsed.handle, parsed.secret),
+      handle: parsed.handle
     });
-    if (poll.status === 200 && "refresh_token" in poll.data) {
-      const { bindings, source } = await reconcileEnrollment(SUPABASE_URL2, poll.data);
-      console.log(`Enrollment complete. Credentials stored in ${describeCredentialSource(source)}.`);
-      console.log(`Daemon will serve 1 account across ${bindings.length} org(s).`);
-      return;
-    }
-    if (poll.status === 200 && "status" in poll.data && poll.data.status === "pending") {
-      continue;
-    }
-    if ("error" in poll.data && poll.data.error === "slow_down") {
-      intervalMs = Math.max(poll.data.interval ?? data.interval, data.interval) * 1e3;
-      continue;
-    }
-    if ("error" in poll.data && poll.data.error === "expired") {
-      throw new Error("Pairing code expired. Run `archme login` again.");
-    }
-    throw new Error(`Enrollment failed: ${JSON.stringify(poll.data)}`);
+  } catch (err2) {
+    deps.log(
+      `! The key for ${parsed.handle} could not be saved on this machine (${err2 instanceof Error ? err2.message : String(err2)}). Signing in anyway; if the session lapses, sign in with the key again.`
+    );
   }
-  throw new Error("Pairing code expired. Run `archme login` again.");
+  await storeKeyedLogin(deps, grant, data);
+  deps.log(`\u2713 Signed in as keyed account ${parsed.handle}.`);
+  return { method: "key", userId: data.user_id, handle: parsed.handle };
+}
+async function storeKeyedLogin(deps, grant, account) {
+  const devices = account.devices ?? [];
+  const primary = devices.find((d) => d.org_id === account.org_id) ?? devices[0];
+  if (!primary || !grant.tokens.refresh_token) {
+    throw new LoginError("Sign-in succeeded but the server registered no device for this machine. Try `archme login` again.");
+  }
+  await deps.replaceCredentials(deps.supabaseUrl, [{
+    kind: "key",
+    refresh_token: grant.tokens.refresh_token,
+    access_token: grant.tokens.access_token,
+    user_id: account.user_id,
+    org_id: primary.org_id,
+    device_id: primary.device_id,
+    bindings: [primary, ...devices.filter((d) => d !== primary)],
+    supabase_url: deps.supabaseUrl
+  }]);
 }
+var LoginError, METHOD_FLAGS, METHOD_LABELS, KEY_VIA_ENV;
 var init_enroll = __esm({
   "src/auth/enroll.ts"() {
     "use strict";
     init_execa();
     init_credentials();
+    init_keyRing();
     init_defaults();
+    init_accountKey();
+    init_keySession();
+    init_oauthClient();
+    LoginError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "LoginError";
+      }
+    };
+    METHOD_FLAGS = {
+      "--no-account": "no-account",
+      "--github": "github",
+      "--key": "key"
+    };
+    METHOD_LABELS = {
+      "no-account": "Continue without an account \u2014 a key saved on this machine is your way back in (`archme key show` prints it).",
+      github: "Sign in with GitHub",
+      key: "Use an existing key"
+    };
+    KEY_VIA_ENV = "`ARCHME_KEY=\u2026 archme login --key`";
   }
 });
 
@@ -8679,7 +9406,7 @@ __export(paths_exports, {
   resolvePidfilePath: () => resolvePidfilePath,
   resolveUnitPath: () => resolveUnitPath
 });
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function home(env) {
   const h2 = env.HOME;
   if (!h2) throw new Error("HOME is not set");
@@ -8692,24 +9419,24 @@ function assertSupported(platform3) {
 }
 function resolveLogDir(platform3, env) {
   assertSupported(platform3);
-  if (platform3 === "darwin") return join3(home(env), "Library", "Logs", LABEL);
-  const xdgState = env.XDG_STATE_HOME ?? join3(home(env), ".local", "state");
-  return join3(xdgState, "archme", "logs");
+  if (platform3 === "darwin") return join4(home(env), "Library", "Logs", LABEL);
+  const xdgState = env.XDG_STATE_HOME ?? join4(home(env), ".local", "state");
+  return join4(xdgState, "archme", "logs");
 }
 function resolveLogPath(platform3, env) {
   const dir = resolveLogDir(platform3, env);
-  return { stdout: join3(dir, "daemon.log"), stderr: join3(dir, "daemon.err") };
+  return { stdout: join4(dir, "daemon.log"), stderr: join4(dir, "daemon.err") };
 }
 function resolveUnitPath(platform3, env) {
   assertSupported(platform3);
   if (platform3 === "darwin") {
-    return join3(home(env), "Library", "LaunchAgents", `${LABEL}.plist`);
+    return join4(home(env), "Library", "LaunchAgents", `${LABEL}.plist`);
   }
-  return join3(home(env), ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
+  return join4(home(env), ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 function resolvePidfilePath(env) {
   if (env.ARCHME_DAEMON_PIDFILE) return env.ARCHME_DAEMON_PIDFILE;
-  return join3(home(env), ".archme", "daemon.pid");
+  return join4(home(env), ".archme", "daemon.pid");
 }
 var LABEL, SYSTEMD_UNIT_NAME;
 var init_paths = __esm({
@@ -8833,8 +9560,8 @@ var init_unitFiles = __esm({
 });
 
 // src/daemon/service/controllers/launchctl.ts
-import { mkdir as mkdir2, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 var SERVICE_TARGET, DOMAIN, LaunchctlController;
 var init_launchctl = __esm({
   "src/daemon/service/controllers/launchctl.ts"() {
@@ -8847,17 +9574,17 @@ var init_launchctl = __esm({
         this.opts = opts;
       }
       async install(unitContent) {
-        await mkdir2(dirname3(this.opts.plistPath), { recursive: true });
+        await mkdir3(dirname4(this.opts.plistPath), { recursive: true });
         const tmp = `${this.opts.plistPath}.tmp`;
         await writeFile2(tmp, unitContent, { mode: 420 });
-        await rename(tmp, this.opts.plistPath);
+        await rename2(tmp, this.opts.plistPath);
       }
       async uninstall() {
-        await rm2(this.opts.plistPath, { force: true });
+        await rm3(this.opts.plistPath, { force: true });
       }
       async unitExists() {
         try {
-          await readFile2(this.opts.plistPath);
+          await readFile3(this.opts.plistPath);
           return true;
         } catch {
           return false;
@@ -8865,7 +9592,7 @@ var init_launchctl = __esm({
       }
       async readUnitContent() {
         try {
-          return await readFile2(this.opts.plistPath, "utf8");
+          return await readFile3(this.opts.plistPath, "utf8");
         } catch {
           return null;
         }
@@ -8932,8 +9659,8 @@ var init_launchctl = __esm({
 });
 
 // src/daemon/service/controllers/systemctl.ts
-import { mkdir as mkdir3, readFile as readFile3, rename as rename2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
 var SystemctlController;
 var init_systemctl = __esm({
   "src/daemon/service/controllers/systemctl.ts"() {
@@ -8950,20 +9677,20 @@ var init_systemctl = __esm({
         }
       }
       async install(unitContent) {
-        await mkdir3(dirname4(this.opts.unitPath), { recursive: true });
+        await mkdir4(dirname5(this.opts.unitPath), { recursive: true });
         const tmp = `${this.opts.unitPath}.tmp`;
         await writeFile3(tmp, unitContent, { mode: 420 });
-        await rename2(tmp, this.opts.unitPath);
+        await rename3(tmp, this.opts.unitPath);
         await this.sysctl(["daemon-reload"]);
       }
       async uninstall() {
         const existed = await this.unitExists();
-        await rm3(this.opts.unitPath, { force: true });
+        await rm4(this.opts.unitPath, { force: true });
         if (existed) await this.sysctl(["daemon-reload"]);
       }
       async unitExists() {
         try {
-          await readFile3(this.opts.unitPath);
+          await readFile4(this.opts.unitPath);
           return true;
         } catch {
           return false;
@@ -8971,7 +9698,7 @@ var init_systemctl = __esm({
       }
       async readUnitContent() {
         try {
-          return await readFile3(this.opts.unitPath, "utf8");
+          return await readFile4(this.opts.unitPath, "utf8");
         } catch {
           return null;
         }
@@ -9107,10 +9834,19 @@ var init_serviceController = __esm({
 });
 
 // src/daemon/service/install.ts
+var install_exports = {};
+__export(install_exports, {
+  NotSignedInError: () => NotSignedInError,
+  PUBLISHED_BIN_RELATIVE: () => PUBLISHED_BIN_RELATIVE,
+  ensureStartPrerequisites: () => ensureStartPrerequisites,
+  findPackageRoot: () => findPackageRoot,
+  pickCliEntry: () => pickCliEntry,
+  runStartFlow: () => runStartFlow
+});
 import { isatty } from "node:tty";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname5, join as join4 } from "node:path";
-import { mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname6, join as join5 } from "node:path";
+import { mkdir as mkdir5 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 function captureEnv(env) {
   const out = {};
@@ -9122,8 +9858,8 @@ function captureEnv(env) {
 function findPackageRoot(startDir, exists2) {
   let dir = startDir;
   for (; ; ) {
-    if (exists2(join4(dir, "package.json"))) return dir;
-    const parent = dirname5(dir);
+    if (exists2(join5(dir, "package.json"))) return dir;
+    const parent = dirname6(dir);
     if (parent === dir) {
       throw new Error(
         `could not locate the @archme/cli package root above ${startDir}`
@@ -9133,16 +9869,16 @@ function findPackageRoot(startDir, exists2) {
   }
 }
 function pickCliEntry(packageRoot, exists2) {
-  const bundle = join4(packageRoot, PUBLISHED_BIN_RELATIVE);
+  const bundle = join5(packageRoot, PUBLISHED_BIN_RELATIVE);
   if (exists2(bundle)) return bundle;
-  const shim = join4(packageRoot, DEV_SHIM_RELATIVE);
+  const shim = join5(packageRoot, DEV_SHIM_RELATIVE);
   if (exists2(shim)) return shim;
   throw new Error(
     `no runnable CLI entry under ${packageRoot} (looked for ${PUBLISHED_BIN_RELATIVE} and ${DEV_SHIM_RELATIVE}); run \`npm run build\` first`
   );
 }
 function resolveCliEntry() {
-  const here = dirname5(fileURLToPath3(import.meta.url));
+  const here = dirname6(fileURLToPath3(import.meta.url));
   return pickCliEntry(findPackageRoot(here, existsSync2), existsSync2);
 }
 async function ensureStartPrerequisites(opts = {}) {
@@ -9170,7 +9906,7 @@ async function runStartFlow(opts = {}) {
   const env = opts.env ?? process.env;
   await ensureStartPrerequisites(opts);
   const logPaths = resolveLogPath(platform3, env);
-  await mkdir4(resolveLogDir(platform3, env), { recursive: true });
+  await mkdir5(resolveLogDir(platform3, env), { recursive: true });
   const renderOpts = {
     nodeBin: process.execPath,
     cliEntry: resolveCliEntry(),
@@ -9232,8 +9968,8 @@ var init_install = __esm({
 
 // src/daemon/service/logs.ts
 import { createReadStream as createReadStream2, watch } from "node:fs";
-import { open, stat } from "node:fs/promises";
-import { basename, dirname as dirname6 } from "node:path";
+import { open as open2, stat } from "node:fs/promises";
+import { basename, dirname as dirname7 } from "node:path";
 async function tailLog(opts = {}) {
   const platform3 = opts.platform ?? process.platform;
   const env = opts.env ?? process.env;
@@ -9243,7 +9979,7 @@ async function tailLog(opts = {}) {
   let offset = 0;
   try {
     const st = await stat(path7);
-    const handle = await open(path7, "r");
+    const handle = await open2(path7, "r");
     try {
       const slice = Math.min(64 * 1024, st.size);
       const buf = Buffer.alloc(slice);
@@ -9269,7 +10005,7 @@ async function tailLog(opts = {}) {
   await new Promise((resolve6, reject) => {
     let fileWatcher = null;
     let dirWatcher = null;
-    const dir = dirname6(path7);
+    const dir = dirname7(path7);
     const name = basename(path7);
     const onChange = async () => {
       try {
@@ -9343,7 +10079,7 @@ var init_logs = __esm({
 });
 
 // src/daemon/service/status.ts
-import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile5, stat as stat2 } from "node:fs/promises";
 function renderStatus(s) {
   const lines = [];
   if (!s.unitInstalled) {
@@ -9408,7 +10144,7 @@ function formatDuration(ms, opts = {}) {
 async function readLastLogLine(platform3 = process.platform, env = process.env) {
   try {
     const { stdout } = resolveLogPath(platform3, env);
-    const buf = await readFile4(stdout, "utf8");
+    const buf = await readFile5(stdout, "utf8");
     const lines = buf.trimEnd().split("\n");
     return lines[lines.length - 1] ?? null;
   } catch {
@@ -9452,9 +10188,9 @@ var init_status = __esm({
 });
 
 // src/scan/mcp-config.ts
-import { mkdtemp, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdtemp, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function writeMcpConfig(opts) {
   const params = new URLSearchParams({
     project: opts.projectSlug,
@@ -9483,8 +10219,8 @@ async function writeMcpConfig(opts) {
     }
   }
   const url = `${opts.baseUrl}?${params.toString()}`;
-  const dir = await mkdtemp(join5(tmpdir(), "archme-mcp-"));
-  const configPath = join5(dir, "mcp.json");
+  const dir = await mkdtemp(join6(tmpdir(), "archme-mcp-"));
+  const configPath = join6(dir, "mcp.json");
   const headers = {
     Authorization: `Bearer ${opts.bearer}`
   };
@@ -9496,7 +10232,7 @@ async function writeMcpConfig(opts) {
   await writeFile4(configPath, JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: server } }, null, 2), {
     mode: 384
   });
-  return { configPath, cleanup: () => rm4(dir, { recursive: true, force: true }) };
+  return { configPath, cleanup: () => rm5(dir, { recursive: true, force: true }) };
 }
 var MCP_SERVER_NAME;
 var init_mcp_config = __esm({
@@ -9532,7 +10268,7 @@ var init_env_scrub = __esm({
 
 // src/preflight.ts
 import { accessSync, constants as constants4 } from "node:fs";
-import { delimiter as pathDelimiter, join as join6 } from "node:path";
+import { delimiter as pathDelimiter, join as join7 } from "node:path";
 function defaultIsExecutable(path7) {
   try {
     accessSync(path7, constants4.X_OK);
@@ -9550,7 +10286,7 @@ function findOnPath(name, opts = {}) {
   const exts = env.PATHEXT ? ["", ...env.PATHEXT.split(";").filter(Boolean)] : [""];
   for (const dir of dirs) {
     for (const ext2 of exts) {
-      const candidate = join6(dir, `${name}${ext2}`);
+      const candidate = join7(dir, `${name}${ext2}`);
       if (isExecutable(candidate)) return candidate;
     }
   }
@@ -9611,7 +10347,7 @@ var init_preflight = __esm({
 var DEFAULT_CLAUDE_MODEL;
 var init_daemonModel = __esm({
   "../shared/daemonModel.ts"() {
-    DEFAULT_CLAUDE_MODEL = "claude-opus-4-8";
+    DEFAULT_CLAUDE_MODEL = "claude-opus-5-5";
   }
 });
 
@@ -9866,9 +10602,9 @@ var init_digestPrompt = __esm({
 });
 
 // src/daemon/digest.ts
-import { mkdtemp as mkdtemp2, rm as rm5, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function isCleanDigestExit(res) {
   return !res.timedOut && res.signal == null && res.exitCode === 0;
 }
@@ -9902,12 +10638,12 @@ async function runDigestJob(ctx, job, deviceId, inFlight2, mcp) {
   }
   let dir;
   try {
-    dir = await mkdtemp2(join7(tmpdir2(), "archme-digest-"));
+    dir = await mkdtemp2(join8(tmpdir2(), "archme-digest-"));
     let mcpConfigPath;
     if (mcp) {
       mcpConfigPath = mcp.configPath;
     } else {
-      mcpConfigPath = join7(dir, "mcp.json");
+      mcpConfigPath = join8(dir, "mcp.json");
       await writeFile5(mcpConfigPath, JSON.stringify({ mcpServers: {} }));
     }
     const model = await resolveModelPin(ctx.supabase);
@@ -9942,7 +10678,7 @@ async function runDigestJob(ctx, job, deviceId, inFlight2, mcp) {
     await failDigest(ctx, job.id, deviceId, err2 instanceof Error ? err2.message : String(err2));
   } finally {
     inFlight2?.delete(job.id);
-    if (dir) await rm5(dir, { recursive: true, force: true }).catch(() => {
+    if (dir) await rm6(dir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -9996,37 +10732,37 @@ var init_heartbeatHealth = __esm({
 var balanced, maybeMatch, range;
 var init_esm = __esm({
   "node_modules/balanced-match/dist/esm/index.js"() {
-    balanced = (a2, b, str) => {
-      const ma = a2 instanceof RegExp ? maybeMatch(a2, str) : a2;
-      const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-      const r = ma !== null && mb != null && range(ma, mb, str);
+    balanced = (a2, b, str2) => {
+      const ma = a2 instanceof RegExp ? maybeMatch(a2, str2) : a2;
+      const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
+      const r = ma !== null && mb != null && range(ma, mb, str2);
       return r && {
         start: r[0],
         end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + ma.length, r[1]),
-        post: str.slice(r[1] + mb.length)
+        pre: str2.slice(0, r[0]),
+        body: str2.slice(r[0] + ma.length, r[1]),
+        post: str2.slice(r[1] + mb.length)
       };
     };
-    maybeMatch = (reg, str) => {
-      const m = str.match(reg);
+    maybeMatch = (reg, str2) => {
+      const m = str2.match(reg);
       return m ? m[0] : null;
     };
-    range = (a2, b, str) => {
+    range = (a2, b, str2) => {
       let begs, beg, left, right = void 0, result;
-      let ai = str.indexOf(a2);
-      let bi = str.indexOf(b, ai + 1);
+      let ai = str2.indexOf(a2);
+      let bi = str2.indexOf(b, ai + 1);
       let i2 = ai;
       if (ai >= 0 && bi > 0) {
         if (a2 === b) {
           return [ai, bi];
         }
         begs = [];
-        left = str.length;
+        left = str2.length;
         while (i2 >= 0 && !result) {
           if (i2 === ai) {
             begs.push(i2);
-            ai = str.indexOf(a2, i2 + 1);
+            ai = str2.indexOf(a2, i2 + 1);
           } else if (begs.length === 1) {
             const r = begs.pop();
             if (r !== void 0)
@@ -10037,7 +10773,7 @@ var init_esm = __esm({
               left = beg;
               right = bi;
             }
-            bi = str.indexOf(b, i2 + 1);
+            bi = str2.indexOf(b, i2 + 1);
           }
           i2 = ai < bi && ai >= 0 ? ai : bi;
         }
@@ -10051,23 +10787,23 @@ var init_esm = __esm({
 });
 
 // node_modules/brace-expansion/dist/esm/index.js
-function numeric(str) {
-  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+function numeric(str2) {
+  return !isNaN(str2) ? parseInt(str2, 10) : str2.charCodeAt(0);
 }
-function escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+function escapeBraces(str2) {
+  return str2.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
 }
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+function unescapeBraces(str2) {
+  return str2.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
 }
-function parseCommaParts(str) {
-  if (!str) {
+function parseCommaParts(str2) {
+  if (!str2) {
     return [""];
   }
   const parts = [];
-  const m = balanced("{", "}", str);
+  const m = balanced("{", "}", str2);
   if (!m) {
-    return str.split(",");
+    return str2.split(",");
   }
   const { pre, body, post } = m;
   const p = pre.split(",");
@@ -10081,18 +10817,18 @@ function parseCommaParts(str) {
   parts.push.apply(parts, p);
   return parts;
 }
-function expand(str, options = {}) {
-  if (!str) {
+function expand(str2, options = {}) {
+  if (!str2) {
     return [];
   }
   const { max = EXPANSION_MAX } = options;
-  if (str.slice(0, 2) === "{}") {
-    str = "\\{\\}" + str.slice(2);
+  if (str2.slice(0, 2) === "{}") {
+    str2 = "\\{\\}" + str2.slice(2);
   }
-  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+  return expand_(escapeBraces(str2), max, true).map(unescapeBraces);
 }
-function embrace(str) {
-  return "{" + str + "}";
+function embrace(str2) {
+  return "{" + str2 + "}";
 }
 function isPadded(el) {
   return /^-?0\d/.test(el);
@@ -10103,11 +10839,11 @@ function lte(i2, y) {
 function gte(i2, y) {
   return i2 >= y;
 }
-function expand_(str, max, isTop) {
+function expand_(str2, max, isTop) {
   const expansions = [];
-  const m = balanced("{", "}", str);
+  const m = balanced("{", "}", str2);
   if (!m)
-    return [str];
+    return [str2];
   const pre = m.pre;
   const post = m.post.length ? expand_(m.post, max, false) : [""];
   if (/\$$/.test(m.pre)) {
@@ -10122,10 +10858,10 @@ function expand_(str, max, isTop) {
     const isOptions = m.body.indexOf(",") >= 0;
     if (!isSequence && !isOptions) {
       if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str, max, true);
+        str2 = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str2, max, true);
       }
-      return [str];
+      return [str2];
     }
     let n2;
     if (isSequence) {
@@ -10570,7 +11306,7 @@ var init_ast = __esm({
         }
         return c3;
       }
-      static #parseAST(str, ast, pos, opt, extDepth) {
+      static #parseAST(str2, ast, pos, opt, extDepth) {
         const maxDepth = opt.maxExtglobRecursion ?? 2;
         let escaping = false;
         let inBrace = false;
@@ -10579,8 +11315,8 @@ var init_ast = __esm({
         if (ast.type === null) {
           let i3 = pos;
           let acc2 = "";
-          while (i3 < str.length) {
-            const c3 = str.charAt(i3++);
+          while (i3 < str2.length) {
+            const c3 = str2.charAt(i3++);
             if (escaping || c3 === "\\") {
               escaping = !escaping;
               acc2 += c3;
@@ -10603,12 +11339,12 @@ var init_ast = __esm({
               acc2 += c3;
               continue;
             }
-            const doRecurse = !opt.noext && isExtglobType(c3) && str.charAt(i3) === "(" && extDepth <= maxDepth;
+            const doRecurse = !opt.noext && isExtglobType(c3) && str2.charAt(i3) === "(" && extDepth <= maxDepth;
             if (doRecurse) {
               ast.push(acc2);
               acc2 = "";
               const ext2 = new _a(c3, ast);
-              i3 = _a.#parseAST(str, ext2, i3, opt, extDepth + 1);
+              i3 = _a.#parseAST(str2, ext2, i3, opt, extDepth + 1);
               ast.push(ext2);
               continue;
             }
@@ -10621,8 +11357,8 @@ var init_ast = __esm({
         let part = new _a(null, ast);
         const parts = [];
         let acc = "";
-        while (i2 < str.length) {
-          const c3 = str.charAt(i2++);
+        while (i2 < str2.length) {
+          const c3 = str2.charAt(i2++);
           if (escaping || c3 === "\\") {
             escaping = !escaping;
             acc += c3;
@@ -10645,7 +11381,7 @@ var init_ast = __esm({
             acc += c3;
             continue;
           }
-          const doRecurse = !opt.noext && isExtglobType(c3) && str.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+          const doRecurse = !opt.noext && isExtglobType(c3) && str2.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
           (extDepth <= maxDepth || ast && ast.#canAdoptType(c3));
           if (doRecurse) {
             const depthAdd = ast && ast.#canAdoptType(c3) ? 0 : 1;
@@ -10653,7 +11389,7 @@ var init_ast = __esm({
             acc = "";
             const ext2 = new _a(c3, part);
             part.push(ext2);
-            i2 = _a.#parseAST(str, ext2, i2, opt, extDepth + depthAdd);
+            i2 = _a.#parseAST(str2, ext2, i2, opt, extDepth + depthAdd);
             continue;
           }
           if (c3 === "|") {
@@ -10676,7 +11412,7 @@ var init_ast = __esm({
         }
         ast.type = null;
         ast.#hasMagic = void 0;
-        ast.#parts = [str.substring(pos - 1)];
+        ast.#parts = [str2.substring(pos - 1)];
         return i2;
       }
       #canAdoptWithSpace(child) {
@@ -11782,10 +12518,10 @@ var init_esm3 = __esm({
           }
           return filtered.join("/");
         }).join("|");
-        const [open2, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
-        re = "^" + open2 + re + close + "$";
+        const [open3, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+        re = "^" + open3 + re + close + "$";
         if (this.partial) {
-          re = "^(?:\\/|" + open2 + re.slice(1, -1) + close + ")$";
+          re = "^(?:\\/|" + open3 + re.slice(1, -1) + close + ")$";
         }
         if (this.negate)
           re = "^(?!" + re + ").+$";
@@ -12618,18 +13354,18 @@ var init_lang_detect = __esm({
 });
 
 // src/analyze/tree-sitter/cache.ts
-import { mkdir as mkdir5, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname7, join as join8 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { mkdir as mkdir6, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname8, join as join9 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import { createHash } from "node:crypto";
 function defaultCacheRoot() {
-  return process.env.ARCHME_TOOLS_DIR ?? join8(homedir3(), ".archme", "tools");
+  return process.env.ARCHME_TOOLS_DIR ?? join9(homedir4(), ".archme", "tools");
 }
 function grammarCacheDir(cacheRoot) {
-  return join8(cacheRoot, "grammars");
+  return join9(cacheRoot, "grammars");
 }
 function cachedGrammarPath(cacheRoot, lang, version) {
-  return join8(grammarCacheDir(cacheRoot), `${lang}-${version}.wasm`);
+  return join9(grammarCacheDir(cacheRoot), `${lang}-${version}.wasm`);
 }
 async function fileExists(path7) {
   try {
@@ -12650,7 +13386,7 @@ async function ensureGrammar(opts) {
   if (await fileExists(target)) {
     return { path: target, downloaded: false };
   }
-  await mkdir5(dirname7(target), { recursive: true });
+  await mkdir6(dirname8(target), { recursive: true });
   const url = `${opts.urlBase}/${opts.filename}`;
   process.stderr.write(`fetching grammar: ${opts.lang}@${opts.version} (${url})
 `);
@@ -12779,7 +13515,7 @@ var init_grammars = __esm({
 });
 
 // src/analyze/tree-sitter/parser.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { Parser, Language } from "web-tree-sitter";
 async function init() {
   if (initialized) return;
@@ -12802,7 +13538,7 @@ async function getLanguage(lang, cacheRoot = defaultCacheRoot()) {
     filename: entry.filename,
     sha256: entry.sha256
   });
-  const wasm = await readFile5(wasmPath);
+  const wasm = await readFile6(wasmPath);
   const language = await Language.load(wasm);
   languageCache.set(lang, language);
   return language;
@@ -13198,7 +13934,7 @@ var init_output2 = __esm({
 });
 
 // src/analyze/commands/outline.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 async function outlineSource(source, file) {
   const lang = detectLanguage(file);
   if (!lang) {
@@ -13251,7 +13987,7 @@ async function runOutline(file) {
   }
   let source;
   try {
-    source = await readFile6(file, "utf8");
+    source = await readFile7(file, "utf8");
   } catch (err2) {
     return envelope({
       tool: "file",
@@ -13535,7 +14271,7 @@ var require_ignore = __commonJS({
         // Zero, one or several directories
         // should not use '*', or it will be replaced by the next replacer
         // Check if it is not the last `'/**'`
-        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+        (_, index, str2) => index + 6 < str2.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
       ],
       // normal intermediate wildcards
       [
@@ -13634,12 +14370,12 @@ var require_ignore = __commonJS({
         return this._make(MODE_CHECK_IGNORE, key);
       }
       _make(mode, key) {
-        const str = this.regexPrefix.replace(
+        const str2 = this.regexPrefix.replace(
           REGEX_REPLACE_TRAILING_WILDCARD,
           // It does not need to bind pattern
           TRAILING_WILD_CARD_REPLACERS[mode]
         );
-        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        const regex = this.ignoreCase ? new RegExp(str2, "i") : new RegExp(str2);
         return define(this, key, regex);
       }
     };
@@ -13843,7 +14579,7 @@ var require_ignore = __commonJS({
     var factory = (options) => new Ignore(options);
     var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
     var setupWindows = () => {
-      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
       checkPath.isNotRelative = (path7) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
@@ -13862,12 +14598,12 @@ var require_ignore = __commonJS({
 });
 
 // src/analyze/repo-walk.ts
-import { readdir, readFile as readFile7, stat as stat4 } from "node:fs/promises";
-import { join as join9, relative } from "node:path";
+import { readdir, readFile as readFile8, stat as stat4 } from "node:fs/promises";
+import { join as join10, relative } from "node:path";
 async function loadGitignore(root) {
   const ig = (0, import_ignore.default)();
   try {
-    const text = await readFile7(join9(root, ".gitignore"), "utf8");
+    const text = await readFile8(join10(root, ".gitignore"), "utf8");
     ig.add(text);
   } catch {
     ig.add(["node_modules", "dist", "build", ".next", "coverage", ".turbo"]);
@@ -13881,7 +14617,7 @@ async function* walkRepoFiles(root, filter2 = {}) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const e of entries) {
       if (ALWAYS_SKIP.has(e.name)) continue;
-      const full = join9(dir, e.name);
+      const full = join10(dir, e.name);
       const rel = relative(root, full);
       if (e.isDirectory()) {
         if (ig.ignores(rel + "/")) continue;
@@ -13905,7 +14641,7 @@ async function collectRepoFiles(root, filter2 = {}) {
 }
 async function gitListFiles(root) {
   try {
-    await stat4(join9(root, ".git"));
+    await stat4(join10(root, ".git"));
   } catch {
     return null;
   }
@@ -13946,11 +14682,11 @@ var init_repo_walk = __esm({
 });
 
 // src/analyze/commands/repo.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 async function* walkRepo(root, opts = {}) {
   const files = await collectRepoFilesWithGit(root, opts);
   for (const rel of files) {
-    const env = await runOutline(join10(root, rel));
+    const env = await runOutline(join11(root, rel));
     yield env;
   }
 }
@@ -13964,9 +14700,9 @@ var init_repo = __esm({
 
 // src/analyze/matchers/file.ts
 import { stat as stat5 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function matchFileAnchor(anchor, repoRoot) {
-  const full = join11(repoRoot, anchor.path);
+  const full = join12(repoRoot, anchor.path);
   try {
     const s = await stat5(full);
     if (!s.isFile()) {
@@ -13997,9 +14733,9 @@ var init_file = __esm({
 
 // src/analyze/matchers/directory.ts
 import { stat as stat6 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function matchDirectoryAnchor(anchor, repoRoot) {
-  const full = join12(repoRoot, anchor.path);
+  const full = join13(repoRoot, anchor.path);
   try {
     const s = await stat6(full);
     if (!s.isDirectory()) {
@@ -14068,9 +14804,9 @@ var init_findSymbol = __esm({
 
 // src/analyze/matchers/symbol.ts
 import { stat as stat7 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function matchSymbolAnchor(anchor, repoRoot) {
-  const full = join13(repoRoot, anchor.path);
+  const full = join14(repoRoot, anchor.path);
   try {
     await stat7(full);
   } catch {
@@ -14194,7 +14930,7 @@ __export(dispatch_exports, {
   augmentChangesWithSymbolsAtSha: () => augmentChangesWithSymbolsAtSha,
   dispatchAnalyze: () => dispatchAnalyze
 });
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { resolve } from "node:path";
 async function dispatchAnalyze(args) {
   const sub = args[0];
@@ -14335,7 +15071,7 @@ async function cmdMatch(args) {
     console.error("archme analyze match: <anchor-spec.json> required");
     return 2;
   }
-  const text = await readFile8(path7, "utf8");
+  const text = await readFile9(path7, "utf8");
   const anchors = JSON.parse(text);
   if (!Array.isArray(anchors)) {
     console.error("archme analyze match: spec must be a JSON array of anchors");
@@ -14385,235 +15121,103 @@ var init_dispatch = __esm({
     init_match();
     init_prefetch();
     init_output2();
-  }
-});
-
-// src/daemon/service/singleInstanceLock.ts
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
-import { dirname as dirname8 } from "node:path";
-import { lock } from "proper-lockfile";
-async function acquireSingleInstanceLock(pidfile) {
-  await mkdir6(dirname8(pidfile), { recursive: true });
-  try {
-    await writeFile7(pidfile, String(process.pid), { flag: "wx" });
-  } catch (err2) {
-    if (err2.code !== "EEXIST") throw err2;
-  }
-  let release;
-  try {
-    release = await lock(pidfile, {
-      // `stale` here is proper-lockfile's own mtime-refresh window — unrelated
-      // to the daemon's Supabase heartbeat. Auto-released after 30s of mtime
-      // staleness if the previous holder crashed without releasing.
-      retries: 0,
-      stale: 3e4
-    });
-  } catch {
-    let heldByPid = null;
-    try {
-      heldByPid = Number((await readFile9(pidfile, "utf8")).trim()) || null;
-    } catch {
-      heldByPid = null;
-    }
-    throw new SingleInstanceLockedError(pidfile, heldByPid);
-  }
-  await writeFile7(pidfile, String(process.pid), { flag: "w" });
-  return {
-    async release() {
-      try {
-        await release();
-      } catch {
-      }
-    }
-  };
-}
-var SINGLE_INSTANCE_EXIT_CODE, LOCK_HELD_MESSAGE, SingleInstanceLockedError;
-var init_singleInstanceLock = __esm({
-  "src/daemon/service/singleInstanceLock.ts"() {
-    "use strict";
-    SINGLE_INSTANCE_EXIT_CODE = 64;
-    LOCK_HELD_MESSAGE = "already holds";
-    SingleInstanceLockedError = class extends Error {
-      heldByPid;
-      constructor(pidfile, heldByPid) {
-        super(
-          heldByPid != null ? `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile} (pid ${heldByPid})` : `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile}`
-        );
-        this.heldByPid = heldByPid;
-        this.name = "SingleInstanceLockedError";
-      }
-    };
-  }
-});
-
-// src/daemon/semaphore.ts
-var Semaphore;
-var init_semaphore = __esm({
-  "src/daemon/semaphore.ts"() {
-    "use strict";
-    Semaphore = class {
-      constructor(size) {
-        this.size = size;
-      }
-      inUse = 0;
-      waiters = [];
-      available() {
-        return Math.max(0, this.size - this.inUse);
-      }
-      tryAcquire() {
-        if (this.inUse >= this.size) return null;
-        this.inUse++;
-        return this.makeRelease();
-      }
-      acquire() {
-        const slot = this.tryAcquire();
-        if (slot) return Promise.resolve(slot);
-        return new Promise((resolve6) => this.waiters.push(resolve6));
-      }
-      makeRelease() {
-        let released = false;
-        return () => {
-          if (released) return;
-          released = true;
-          const next = this.waiters.shift();
-          if (next) {
-            next(this.makeRelease());
-          } else {
-            this.inUse--;
-          }
-        };
-      }
-    };
-  }
-});
-
-// src/scan/oauthClient.ts
-function computeExpiresAt(expiresInSeconds) {
-  const seconds = expiresInSeconds ?? DEFAULT_TOKEN_EXPIRES_IN_SECONDS;
-  return Date.now() + seconds * 1e3;
-}
-function isPermanentRefreshError(body, status) {
-  if (status >= 500) return false;
-  if (body.error === "invalid_grant") return true;
-  const errorCode = typeof body.error_code === "string" ? body.error_code.toLowerCase() : "";
-  if (errorCode.startsWith("refresh_token")) return true;
-  const message = [body.error_description, body.msg, body.error, body.message].filter((v) => typeof v === "string").join(" ").toLowerCase();
-  return /invalid refresh token|refresh token not found|refresh token already used/.test(message);
-}
-async function refreshOAuthCredentialsWith(refreshToken, cfg) {
-  let response;
-  try {
-    response = await fetch(`${cfg.supabaseUrl}/auth/v1/oauth/token`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        apikey: cfg.anonKey
-      },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: refreshToken,
-        client_id: cfg.clientId
-      })
-    });
-  } catch (err2) {
-    return {
-      ok: false,
-      permanent: false,
-      error: `network error: ${err2 instanceof Error ? err2.message : String(err2)}`
-    };
-  }
-  const body = await parseJsonResponse(response);
-  if (!response.ok) {
-    return {
-      ok: false,
-      permanent: isPermanentRefreshError(body, response.status),
-      error: responseError(body, `refresh failed (${response.status})`)
-    };
-  }
-  if (typeof body.access_token !== "string" || !body.access_token) {
-    return { ok: false, permanent: false, error: "refresh response did not include an access token" };
-  }
-  return {
-    ok: true,
-    tokens: {
-      access_token: body.access_token,
-      refresh_token: typeof body.refresh_token === "string" ? body.refresh_token : void 0,
-      expires_in: typeof body.expires_in === "number" ? body.expires_in : Number(body.expires_in) || void 0,
-      token_type: typeof body.token_type === "string" ? body.token_type : void 0
-    }
-  };
-}
-async function getOAuthUserInfoWith(accessToken, cfg) {
-  const response = await fetch(`${cfg.supabaseUrl}/auth/v1/oauth/userinfo`, {
-    headers: { Authorization: `Bearer ${accessToken}` }
-  });
-  if (!response.ok) return {};
-  return await parseJsonResponse(response);
-}
-function resolveUserId(userInfo2, storedUserId) {
-  return userInfo2.sub ?? storedUserId ?? null;
-}
-function isAuthError(err2) {
-  if (!err2 || typeof err2 !== "object") return false;
-  const msg = ("message" in err2 ? String(err2.message) : "").toLowerCase();
-  const code = ("code" in err2 ? String(err2.code) : "").toLowerCase();
-  const status = "status" in err2 ? Number(err2.status) : 0;
-  return status === 401 || code === "pgrst301" || msg.includes("jwt expired") || msg.includes("invalid jwt") || msg.includes("not authenticated");
-}
-async function withAuthRetry(label, fn, reLogin) {
-  const first = await fn();
-  if (!first.error || !isAuthError(first.error)) return first;
-  console.warn(`${label}: auth error on first attempt, re-logging in and retrying once`);
-  try {
-    await reLogin();
-  } catch (err2) {
-    console.error(`${label}: re-login failed:`, err2);
-    return first;
-  }
-  return await fn();
-}
-async function fetchWithAuthRetry(label, doFetch, reLogin) {
-  const first = await doFetch();
-  if (first.status !== 401) return first;
-  console.warn(`${label}: 401 on first attempt, re-logging in and retrying once`);
+  }
+});
+
+// src/daemon/service/singleInstanceLock.ts
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname9 } from "node:path";
+import { lock } from "proper-lockfile";
+async function acquireSingleInstanceLock(pidfile) {
+  await mkdir7(dirname9(pidfile), { recursive: true });
   try {
-    await reLogin();
+    await writeFile7(pidfile, String(process.pid), { flag: "wx" });
   } catch (err2) {
-    console.error(`${label}: re-login failed:`, err2);
-    return first;
+    if (err2.code !== "EEXIST") throw err2;
   }
-  return await doFetch();
-}
-async function parseJsonResponse(response) {
-  const text = await response.text();
-  if (!text) return {};
+  let release;
   try {
-    return JSON.parse(text);
+    release = await lock(pidfile, {
+      // `stale` here is proper-lockfile's own mtime-refresh window — unrelated
+      // to the daemon's Supabase heartbeat. Auto-released after 30s of mtime
+      // staleness if the previous holder crashed without releasing.
+      retries: 0,
+      stale: 3e4
+    });
   } catch {
-    return { error: text, error_description: text, msg: text };
+    let heldByPid = null;
+    try {
+      heldByPid = Number((await readFile10(pidfile, "utf8")).trim()) || null;
+    } catch {
+      heldByPid = null;
+    }
+    throw new SingleInstanceLockedError(pidfile, heldByPid);
   }
+  await writeFile7(pidfile, String(process.pid), { flag: "w" });
+  return {
+    async release() {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  };
 }
-function responseError(body, fallback) {
-  for (const key of ["error_description", "error", "msg"]) {
-    const value = body[key];
-    if (typeof value === "string" && value) return value;
+var SINGLE_INSTANCE_EXIT_CODE, LOCK_HELD_MESSAGE, SingleInstanceLockedError;
+var init_singleInstanceLock = __esm({
+  "src/daemon/service/singleInstanceLock.ts"() {
+    "use strict";
+    SINGLE_INSTANCE_EXIT_CODE = 64;
+    LOCK_HELD_MESSAGE = "already holds";
+    SingleInstanceLockedError = class extends Error {
+      heldByPid;
+      constructor(pidfile, heldByPid) {
+        super(
+          heldByPid != null ? `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile} (pid ${heldByPid})` : `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile}`
+        );
+        this.heldByPid = heldByPid;
+        this.name = "SingleInstanceLockedError";
+      }
+    };
   }
-  return fallback;
-}
-var DEFAULT_TOKEN_EXPIRES_IN_SECONDS, REFRESH_RETRY_BACKOFF_MS, LoadStoredAndRefreshError;
-var init_oauthClient = __esm({
-  "src/scan/oauthClient.ts"() {
+});
+
+// src/daemon/semaphore.ts
+var Semaphore;
+var init_semaphore = __esm({
+  "src/daemon/semaphore.ts"() {
     "use strict";
-    DEFAULT_TOKEN_EXPIRES_IN_SECONDS = 3600;
-    REFRESH_RETRY_BACKOFF_MS = 6e4;
-    LoadStoredAndRefreshError = class extends Error {
-      code;
-      permanent;
-      constructor(code, message) {
-        super(message);
-        this.name = "LoadStoredAndRefreshError";
-        this.code = code;
-        this.permanent = code !== "transient";
+    Semaphore = class {
+      constructor(size) {
+        this.size = size;
+      }
+      inUse = 0;
+      waiters = [];
+      available() {
+        return Math.max(0, this.size - this.inUse);
+      }
+      tryAcquire() {
+        if (this.inUse >= this.size) return null;
+        this.inUse++;
+        return this.makeRelease();
+      }
+      acquire() {
+        const slot = this.tryAcquire();
+        if (slot) return Promise.resolve(slot);
+        return new Promise((resolve6) => this.waiters.push(resolve6));
+      }
+      makeRelease() {
+        let released = false;
+        return () => {
+          if (released) return;
+          released = true;
+          const next = this.waiters.shift();
+          if (next) {
+            next(this.makeRelease());
+          } else {
+            this.inUse--;
+          }
+        };
       }
     };
   }
@@ -14625,6 +15229,9 @@ var init_sessionAuth = __esm({
   "src/scan/sessionAuth.ts"() {
     "use strict";
     init_credentials();
+    init_keyRing();
+    init_accountKey();
+    init_keySession();
     init_oauthClient();
     SessionAuth = class _SessionAuth {
       constructor(cfg) {
@@ -14637,6 +15244,9 @@ var init_sessionAuth = __esm({
       deviceId = null;
       orgId = null;
       userId = null;
+      // "key" sessions are plain GoTrue sessions (password grant); everything else
+      // is the OAuth server's. Set from the stored credential at sign-in.
+      kind = "oauth";
       // The userinfo resolved at first sign-in. The user_id is stable for the
       // session's lifetime, so once it's known we reuse this and skip the per-refresh
       // userinfo round-trip (the recurring refresh path discards the returned value;
@@ -14663,6 +15273,9 @@ var init_sessionAuth = __esm({
       getRefreshToken() {
         return this.refreshToken;
       }
+      getKind() {
+        return this.kind;
+      }
       onAccessTokenChange(listener) {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
@@ -14675,6 +15288,7 @@ var init_sessionAuth = __esm({
       }
       /** Test seam: seed state without going through the store. */
       __seedForTesting(state) {
+        if (state.kind !== void 0) this.kind = state.kind;
         if (state.accessToken !== void 0) this.accessToken = state.accessToken;
         if (state.accessTokenExpiresAtMs !== void 0) this.accessTokenExpiresAtMs = state.accessTokenExpiresAtMs;
         if (state.refreshToken !== void 0) this.refreshToken = state.refreshToken;
@@ -14712,11 +15326,12 @@ var init_sessionAuth = __esm({
         this.refreshToken = nextRefreshToken;
         let userInfo2 = this.lastUserInfo;
         if (this.userId === null || userInfo2 === null) {
-          userInfo2 = await getOAuthUserInfoWith(this.accessToken, this.cfg);
+          userInfo2 = this.kind === "key" ? await getKeyUserInfo(this.accessToken, this.cfg) : await getOAuthUserInfoWith(this.accessToken, this.cfg);
           this.userId = resolveUserId(userInfo2, ctx.fallbackUserId);
           this.lastUserInfo = userInfo2;
         }
         const saved = await saveCredentials({
+          kind: this.kind,
           refresh_token: nextRefreshToken,
           access_token: this.accessToken,
           org_id: ctx.orgId,
@@ -14813,14 +15428,14 @@ var init_sessionAuth = __esm({
           if (!refreshToken || !deviceId || !orgId) {
             throw new LoadStoredAndRefreshError("missing_device", "not signed in; cannot mint MCP bearer");
           }
-          const refreshed = await refreshOAuthCredentialsWith(refreshToken, this.cfg);
+          const refreshed = await this.refreshOrRecover(refreshToken, this.userId);
           if (!refreshed.ok) {
             if (refreshed.permanent) {
               await clearCredential(this.cfg.supabaseUrl, deviceId);
               this.clearTokensOnly();
               throw new LoadStoredAndRefreshError(
                 "invalid_grant",
-                `${errorPrefix} failed permanently: ${refreshed.error}. Run \`archme login\` to pair again.`
+                `${errorPrefix} failed permanently: ${refreshed.error}. ${this.reloginHint()}`
               );
             }
             throw new LoadStoredAndRefreshError("transient", `${errorPrefix} failed: ${refreshed.error}`);
@@ -14838,6 +15453,33 @@ var init_sessionAuth = __esm({
           if (this.refreshInFlight === p) this.refreshInFlight = null;
         });
       }
+      async refreshOrRecover(refreshToken, userId) {
+        if (this.kind !== "key") return refreshOAuthCredentialsWith(refreshToken, this.cfg);
+        const refreshed = await refreshKeySession(refreshToken, this.cfg);
+        if (refreshed.ok || !refreshed.permanent) return refreshed;
+        return this.signInWithSavedKey(userId, refreshed.error);
+      }
+      reloginHint() {
+        return this.kind === "key" ? "Run `archme login --key` to sign in with your key again." : "Run `archme login` to pair again.";
+      }
+      // A keyed account's refresh token can die (reuse detection, a long sleep) while
+      // its key is still good, so sign in again from the key ring rather than
+      // clearing. Permanent only when there is no saved key or the key is refused;
+      // the key ring itself is never modified here.
+      async signInWithSavedKey(userId, refreshError) {
+        let saved;
+        try {
+          saved = userId ? await findKey(this.cfg.supabaseUrl, userId) : null;
+        } catch (err2) {
+          return { ok: false, permanent: false, error: `${refreshError}; ${err2 instanceof Error ? err2.message : String(err2)}` };
+        }
+        const parsed = parseAccountKey(saved?.key);
+        if (!parsed) return { ok: false, permanent: true, error: `${refreshError}; no saved key for this account` };
+        console.error(`auth: refresh token rejected (${refreshError}); signing in again with the saved key for ${parsed.handle}`);
+        const granted = await passwordGrant(parsed.email, parsed.secret, this.cfg);
+        if (granted.ok) return granted;
+        return granted.permanent ? { ok: false, permanent: true, error: `the saved key for ${parsed.handle} was rejected: ${granted.error}` } : granted;
+      }
       async getMcpAccessToken() {
         if (this.accessToken && this.accessTokenExpiresAtMs - Date.now() >= this.cfg.preSpawnMinLifetimeMs) {
           return this.accessToken;
@@ -14857,13 +15499,14 @@ var init_sessionAuth = __esm({
             "stored archme credentials are missing device registration; run `archme login` again"
           );
         }
-        const refreshed = await refreshOAuthCredentialsWith(stored.refresh_token, this.cfg);
+        this.kind = credentialKind(stored);
+        const refreshed = await this.refreshOrRecover(stored.refresh_token, stored.user_id ?? null);
         if (!refreshed.ok) {
           if (refreshed.permanent) {
             await clearCredential(this.cfg.supabaseUrl, stored.device_id);
             throw new LoadStoredAndRefreshError(
               "invalid_grant",
-              `stored archme credentials are invalid or revoked: ${refreshed.error}. Run \`archme login\` to pair again.`
+              `stored archme credentials are invalid or revoked: ${refreshed.error}. ${this.reloginHint()}`
             );
           }
           throw new LoadStoredAndRefreshError("transient", `token refresh failed (transient): ${refreshed.error}`);
@@ -14876,6 +15519,7 @@ var init_sessionAuth = __esm({
         });
         return {
           user: userInfo2,
+          kind: this.kind,
           orgId: stored.org_id,
           deviceId: stored.device_id,
           source,
@@ -14900,6 +15544,41 @@ var init_sessionAuth = __esm({
 });
 
 // src/scan/bearer.ts
+var bearer_exports = {};
+__export(bearer_exports, {
+  LoadStoredAndRefreshError: () => LoadStoredAndRefreshError,
+  REFRESH_RETRY_BACKOFF_MS: () => REFRESH_RETRY_BACKOFF_MS,
+  __seedBearerForTesting: () => __seedBearerForTesting,
+  clearRefreshTimer: () => clearRefreshTimer,
+  computeExpiresAt: () => computeExpiresAt,
+  fetchWithAuthRetry: () => fetchWithAuthRetry,
+  getCurrentAccessToken: () => getCurrentAccessToken,
+  getCurrentDeviceId: () => getCurrentDeviceId,
+  getCurrentOrgId: () => getCurrentOrgId,
+  getCurrentRefreshToken: () => getCurrentRefreshToken,
+  getCurrentUserId: () => getCurrentUserId,
+  getMcpAccessToken: () => getMcpAccessToken,
+  getOAuthUserInfo: () => getOAuthUserInfo,
+  initBearer: () => initBearer,
+  isAuthError: () => isAuthError,
+  isPermanentRefreshError: () => isPermanentRefreshError,
+  loadStoredAndRefresh: () => loadStoredAndRefresh,
+  onAccessTokenChange: () => onAccessTokenChange,
+  parseJsonResponse: () => parseJsonResponse,
+  refreshOAuthCredentials: () => refreshOAuthCredentials,
+  resetBearer: () => resetBearer,
+  resolveUserId: () => resolveUserId,
+  responseError: () => responseError,
+  runScheduledRefresh: () => runScheduledRefresh,
+  scheduleCredentialRefresh: () => scheduleCredentialRefresh,
+  withAuthRetry: () => withAuthRetry
+});
+async function refreshOAuthCredentials(refreshToken) {
+  return refreshOAuthCredentialsWith(refreshToken, requireConfig());
+}
+async function getOAuthUserInfo(accessToken) {
+  return getOAuthUserInfoWith(accessToken, requireConfig());
+}
 function configsEqual(a2, b) {
   return a2.supabaseUrl === b.supabaseUrl && a2.anonKey === b.anonKey && a2.clientId === b.clientId && a2.preSpawnMinLifetimeMs === b.preSpawnMinLifetimeMs;
 }
@@ -14909,6 +15588,11 @@ function initBearer(cfg) {
   config = cfg;
   defaultSession = new SessionAuth(cfg);
 }
+function resetBearer() {
+  if (defaultSession) defaultSession.clearRefreshTimer();
+  config = null;
+  defaultSession = null;
+}
 function requireConfig() {
   if (!config) throw new Error("bearer module not initialized; call initBearer() first");
   return config;
@@ -14920,15 +15604,36 @@ function requireSession() {
 function getCurrentAccessToken() {
   return defaultSession?.getAccessToken() ?? null;
 }
+function getCurrentDeviceId() {
+  return defaultSession?.getDeviceId() ?? null;
+}
 function getCurrentOrgId() {
   return defaultSession?.getOrgId() ?? null;
 }
 function getCurrentUserId() {
   return defaultSession?.getUserId() ?? null;
 }
+function getCurrentRefreshToken() {
+  return defaultSession?.getRefreshToken() ?? null;
+}
+function clearRefreshTimer() {
+  defaultSession?.clearRefreshTimer();
+}
+function onAccessTokenChange(listener) {
+  return requireSession().onAccessTokenChange(listener);
+}
 function getMcpAccessToken() {
   return requireSession().getMcpAccessToken();
 }
+function scheduleCredentialRefresh(rt, d, o2, e) {
+  requireSession().scheduleCredentialRefresh(rt, d, o2, e);
+}
+function runScheduledRefresh(rt, d, o2) {
+  return requireSession().runScheduledRefresh(rt, d, o2);
+}
+function __seedBearerForTesting(state) {
+  requireSession().__seedForTesting(state);
+}
 async function loadStoredAndRefresh() {
   const cfg = requireConfig();
   const stored = await loadCredentials(cfg.supabaseUrl);
@@ -15158,22 +15863,22 @@ var init_rateLimit = __esm({
 
 // src/packageRoot.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname9, join as join14, parse } from "node:path";
+import { dirname as dirname10, join as join15, parse } from "node:path";
 function defaultReadFile(path7) {
   return readFileSync4(path7, "utf8");
 }
 function findPackageRoot2(startDir, opts = {}) {
-  const readFile14 = opts.readFile ?? defaultReadFile;
+  const readFile16 = opts.readFile ?? defaultReadFile;
   const stopAt = parse(startDir).root;
   let dir = startDir;
   for (; ; ) {
     try {
-      const parsed = JSON.parse(readFile14(join14(dir, "package.json")));
+      const parsed = JSON.parse(readFile16(join15(dir, "package.json")));
       if (parsed.name === PACKAGE_NAME) return dir;
     } catch {
     }
     if (dir === stopAt) return null;
-    const parent = dirname9(dir);
+    const parent = dirname10(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -15191,15 +15896,15 @@ var version_exports = {};
 __export(version_exports, {
   readDaemonVersion: () => readDaemonVersion
 });
-import { readFile as readFile10 } from "node:fs/promises";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { dirname as dirname11, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function readDaemonVersion() {
   try {
-    const here = dirname10(fileURLToPath4(import.meta.url));
+    const here = dirname11(fileURLToPath4(import.meta.url));
     const root = findPackageRoot2(here);
     if (!root) return null;
-    const raw = await readFile10(join15(root, "package.json"), "utf8");
+    const raw = await readFile11(join16(root, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -15214,8 +15919,8 @@ var init_version = __esm({
 });
 
 // src/daemon/materializeDiff.ts
-import { mkdir as mkdir7, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { mkdir as mkdir8, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 function splitPatchByFile(patch) {
   if (!patch.trim()) return [];
@@ -15300,18 +16005,18 @@ function buildManifest(files, rangeLabel) {
 }
 async function materializeDiff(worktreeDir, patch, rangeLabel) {
   const files = splitPatchByFile(patch);
-  const dir = join16(worktreeDir, CHANGES_DIR);
-  const byFileDir = join16(dir, "by-file");
-  await mkdir7(byFileDir, { recursive: true });
-  await writeFile8(join16(dir, "FULL.diff"), patch.endsWith("\n") ? patch : `${patch}
+  const dir = join17(worktreeDir, CHANGES_DIR);
+  const byFileDir = join17(dir, "by-file");
+  await mkdir8(byFileDir, { recursive: true });
+  await writeFile8(join17(dir, "FULL.diff"), patch.endsWith("\n") ? patch : `${patch}
 `, "utf8");
   for (const f of files) {
     const rel = `by-file/${hashPath(f.path)}.diff`;
     f.diffPath = rel;
-    await writeFile8(join16(dir, rel), f.diff.endsWith("\n") ? f.diff : `${f.diff}
+    await writeFile8(join17(dir, rel), f.diff.endsWith("\n") ? f.diff : `${f.diff}
 `, "utf8");
   }
-  await writeFile8(join16(dir, "MANIFEST.md"), buildManifest(files, rangeLabel), "utf8");
+  await writeFile8(join17(dir, "MANIFEST.md"), buildManifest(files, rangeLabel), "utf8");
   return { dir, fileCount: files.length };
 }
 var CHANGES_DIR, STATUS_LABEL;
@@ -15335,12 +16040,127 @@ var init_branchMarker = __esm({
   }
 });
 
+// src/daemon/localPrPoll.ts
+import { createHash as createHash3 } from "node:crypto";
+function observeGithubPull(p) {
+  return {
+    number: p.number,
+    state: p.merged_at ? "merged" : p.state === "closed" ? "closed" : "open",
+    headSha: p.head.sha,
+    baseSha: p.base.sha,
+    baseRef: p.base.ref,
+    title: p.title ?? null,
+    authorLogin: p.user?.login ?? null,
+    body: p.body ?? null,
+    createdAt: p.created_at ?? null,
+    updatedAt: p.updated_at ?? null,
+    mergedAt: p.merged_at ?? null,
+    closedAt: p.closed_at ?? null
+  };
+}
+function metaKey(o2) {
+  return createHash3("sha256").update(JSON.stringify([o2.title, o2.body])).digest("hex").slice(0, 16);
+}
+function record(o2, prev, action) {
+  const r = { head: o2.headSha, state: o2.state, meta: metaKey(o2) };
+  const seq = action === "synchronize" ? (prev?.seq ?? 0) + 1 : prev?.seq;
+  if (seq !== void 0) r.seq = seq;
+  return r;
+}
+function decideAction(prev, o2) {
+  if (!prev) return o2.state === "open" ? "opened" : null;
+  const wasOpen = prev.state === "open";
+  const isOpen = o2.state === "open";
+  if (wasOpen && !isOpen) return "closed";
+  if (!wasOpen && isOpen) return "reopened";
+  if (isOpen && prev.head !== o2.headSha) return "synchronize";
+  if (!isOpen && prev.state !== o2.state) return "edited";
+  if (prev.meta !== void 0 && prev.meta !== metaKey(o2)) return "edited";
+  return null;
+}
+function toItem(o2, action, sent) {
+  return {
+    number: o2.number,
+    action,
+    head_sha: o2.headSha,
+    base_sha: o2.baseSha,
+    base_ref: o2.baseRef,
+    title: o2.title,
+    author_login: o2.authorLogin,
+    created_at: o2.createdAt,
+    merged_at: o2.mergedAt,
+    closed_at: o2.closedAt,
+    body: o2.body,
+    ...action === "synchronize" && sent.seq !== void 0 ? { seq: sent.seq } : {}
+  };
+}
+function updatedMs(o2) {
+  const t = o2.updatedAt ? Date.parse(o2.updatedAt) : NaN;
+  return Number.isFinite(t) ? t : 0;
+}
+function planPrSync(input) {
+  const { state, observations, nowMs } = input;
+  const next = { prs: { ...state?.prs ?? {} } };
+  const candidates = [];
+  const backfill = !state || input.resumed ? new Set(
+    observations.filter((o2) => !state?.prs[String(o2.number)]).filter((o2) => o2.state === "open" && nowMs - updatedMs(o2) <= BACKFILL_WINDOW_MS).sort((a2, b) => updatedMs(b) - updatedMs(a2)).slice(0, BACKFILL_MAX).map((o2) => o2.number)
+  ) : null;
+  for (const o2 of observations) {
+    const prev = state?.prs[String(o2.number)];
+    if (!prev && backfill) {
+      if (backfill.has(o2.number)) candidates.push({ o: o2, action: "opened" });
+      else if (o2.state === "open") next.prs[String(o2.number)] = record(o2);
+      continue;
+    }
+    const action = decideAction(prev, o2);
+    if (action) candidates.push({ o: o2, action, prev });
+  }
+  const ranked = [
+    ...candidates.filter((c3) => c3.action !== "edited"),
+    ...candidates.filter((c3) => c3.action === "edited")
+  ].slice(0, MAX_PRS_PER_TICK);
+  const send = [];
+  for (const c3 of ranked) {
+    const sent = record(c3.o, c3.prev, c3.action);
+    next.prs[String(c3.o.number)] = sent;
+    send.push(toItem(c3.o, c3.action, sent));
+  }
+  return { send, next };
+}
+function parsePrPollState(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const o2 = raw;
+  const prs = {};
+  if (o2.prs && typeof o2.prs === "object" && !Array.isArray(o2.prs)) {
+    for (const [k, v] of Object.entries(o2.prs)) {
+      if (!/^\d+$/.test(k) || !v || typeof v !== "object") continue;
+      const r = v;
+      if (typeof r.head !== "string" || !STATES.has(r.state)) continue;
+      const entry = { head: r.head, state: r.state };
+      if (typeof r.meta === "string") entry.meta = r.meta;
+      if (Number.isInteger(r.seq) && r.seq > 0) entry.seq = r.seq;
+      prs[k] = entry;
+    }
+  }
+  return { prs };
+}
+var BACKFILL_WINDOW_MS, BACKFILL_MAX, MAX_PRS_PER_TICK, STATES;
+var init_localPrPoll = __esm({
+  "src/daemon/localPrPoll.ts"() {
+    "use strict";
+    BACKFILL_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+    BACKFILL_MAX = 5;
+    MAX_PRS_PER_TICK = 50;
+    STATES = /* @__PURE__ */ new Set(["open", "merged", "closed"]);
+  }
+});
+
 // src/daemon/localRepos.ts
-import { chmod as chmod2, mkdir as mkdir8, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { chmod as chmod3, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname12, join as join18 } from "node:path";
 function localReposPath(env = process.env) {
-  return env.ARCHME_LOCAL_REPOS_PATH ?? join17(homedir4(), ".archme", "repos.json");
+  return env.ARCHME_LOCAL_REPOS_PATH ?? join18(homedir5(), ".archme", "repos.json");
 }
 function isEntry(v) {
   if (!v || typeof v !== "object") return false;
@@ -15370,6 +16190,9 @@ function parseLocalRepos(raw) {
     if (typeof raw2.haltedAt === "string" && raw2.haltedAt) entry.haltedAt = raw2.haltedAt;
     if (typeof raw2.haltReason === "string" && raw2.haltReason) entry.haltReason = raw2.haltReason;
     if (typeof raw2.haltCode === "string" && raw2.haltCode) entry.haltCode = raw2.haltCode;
+    const prPoll = parsePrPollState(raw2.prPoll);
+    if (prPoll) entry.prPoll = prPoll;
+    if (typeof raw2.prPausedAt === "string" && raw2.prPausedAt) entry.prPausedAt = raw2.prPausedAt;
     return entry;
   });
 }
@@ -15401,6 +16224,16 @@ function markHalted(repos, watchedRepoId, reason, at, code) {
     (r) => r.watchedRepoId === watchedRepoId ? { ...r, haltedAt: at, haltReason: reason, haltCode: code } : r
   );
 }
+function setPrPollState(repos, watchedRepoId, prPoll) {
+  return repos.map((r) => {
+    if (r.watchedRepoId !== watchedRepoId) return r;
+    const { prPoll: _was, prPausedAt: _paused, ...rest } = r;
+    return prPoll ? { ...rest, prPoll } : rest;
+  });
+}
+function markPrPaused(repos, watchedRepoId, at) {
+  return repos.map((r) => r.watchedRepoId === watchedRepoId ? { ...r, prPausedAt: at } : r);
+}
 function clearHalt(repos, watchedRepoId) {
   return repos.map((r) => {
     if (r.watchedRepoId !== watchedRepoId) return r;
@@ -15417,16 +16250,16 @@ function findLocalRepoForJob(repos, job) {
 }
 async function loadLocalRepos(env = process.env) {
   try {
-    return parseLocalRepos(await readFile11(localReposPath(env), "utf8"));
+    return parseLocalRepos(await readFile12(localReposPath(env), "utf8"));
   } catch {
     return [];
   }
 }
 async function saveLocalRepos(repos, env = process.env) {
   const path7 = localReposPath(env);
-  await mkdir8(dirname11(path7), { recursive: true, mode: 448 });
+  await mkdir9(dirname12(path7), { recursive: true, mode: 448 });
   await writeFile9(path7, serializeLocalRepos(repos), { mode: 384 });
-  await chmod2(path7, 384).catch(() => {
+  await chmod3(path7, 384).catch(() => {
   });
 }
 async function registerLocalRepo(entry, env = process.env) {
@@ -15436,6 +16269,7 @@ var LOCAL_REPOS_VERSION, REQUIRED_KEYS;
 var init_localRepos = __esm({
   "src/daemon/localRepos.ts"() {
     "use strict";
+    init_localPrPoll();
     LOCAL_REPOS_VERSION = 1;
     REQUIRED_KEYS = [
       "watchedRepoId",
@@ -15447,6 +16281,59 @@ var init_localRepos = __esm({
   }
 });
 
+// src/daemon/localPrJob.ts
+function assertLocalJobShape(job) {
+  if (!SHA_RE.test(job.after_sha)) throw new LocalPrJobRejectedError(`after_sha ${job.after_sha} is not a 40-character git SHA`);
+  if (!job.repo_branch || job.repo_branch.startsWith("-")) {
+    throw new LocalPrJobRejectedError(`branch ${JSON.stringify(job.repo_branch)} is not a branch name`);
+  }
+  if (job.source_mode !== "pr_update") return;
+  if (!job.before_sha || !SHA_RE.test(job.before_sha)) {
+    throw new LocalPrJobRejectedError(`before_sha ${job.before_sha ?? "(null)"} is not a 40-character git SHA`);
+  }
+  if (!Number.isInteger(job.pr_number) || job.pr_number <= 0) {
+    throw new LocalPrJobRejectedError(`PR number ${String(job.pr_number)} is not a pull request number`);
+  }
+}
+async function verifyLocalPrJob(job, git4) {
+  const n2 = job.pr_number;
+  const before = job.before_sha;
+  const base = `refs/remotes/origin/${job.repo_branch}`;
+  const ref = `refs/archme/pull/${n2}/head`;
+  const fetched = await git4(["fetch", "--no-tags", "origin", `+refs/pull/${n2}/head:${ref}`]);
+  if (fetched.exitCode !== 0) throw new Error(`could not fetch PR #${n2}'s head from origin: ${fetched.stderr.trim()}`);
+  const head = (await git4(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])).stdout.trim();
+  if (head !== job.after_sha) {
+    throw new LocalPrJobRejectedError(
+      `after_sha ${short(job.after_sha)} is not PR #${n2}'s current head on origin (${head ? short(head) : "none"}); a newer push is reviewed by its own job`
+    );
+  }
+  if ((await git4(["merge-base", "--is-ancestor", before, base])).exitCode !== 0) {
+    throw new LocalPrJobRejectedError(`PR #${n2}'s base ${short(before)} is not on origin/${job.repo_branch}`);
+  }
+  const fromJob = (await git4(["merge-base", before, job.after_sha])).stdout.trim();
+  const fromBranch = (await git4(["merge-base", base, job.after_sha])).stdout.trim();
+  if (!fromJob || fromJob !== fromBranch) {
+    throw new LocalPrJobRejectedError(
+      `PR #${n2}'s base ${short(before)} is not where it branched from origin/${job.repo_branch} (${fromBranch ? short(fromBranch) : "no common commit"})`
+    );
+  }
+}
+var LocalPrJobRejectedError, SHA_RE, short;
+var init_localPrJob = __esm({
+  "src/daemon/localPrJob.ts"() {
+    "use strict";
+    LocalPrJobRejectedError = class extends Error {
+      constructor(message) {
+        super(`refusing local job: ${message}`);
+        this.name = "LocalPrJobRejectedError";
+      }
+    };
+    SHA_RE = /^[0-9a-f]{40}$/;
+    short = (sha) => sha.slice(0, 8);
+  }
+});
+
 // ../shared/commitAdvance.ts
 function planAdvance(input) {
   const { marker, upstreamTip, markerIsAncestorOfTip, tipIsAncestorOfMarker, firstParentShas } = input;
@@ -15479,21 +16366,21 @@ function decideGate(input) {
     return {
       action: "stop",
       code: "job-terminal",
-      reason: `job ${job.status} after ${job.attemptCount} attempt(s); marker did not advance \u2014 re-push commit ${short(targetSha)} (fresh delivery) or admin-requeue, do not fold forward`
+      reason: `job ${job.status} after ${job.attemptCount} attempt(s); marker did not advance \u2014 re-push commit ${short2(targetSha)} (fresh delivery) or admin-requeue, do not fold forward`
     };
   }
   if (!pushedNewRef && job === null && elapsedMs >= noopGraceMs) {
     return {
       action: "stop",
       code: "noop-push-no-job",
-      reason: `no webhook fired for ${short(targetSha)} (fork ref already there) and no job appeared in ${Math.round(noopGraceMs / 1e3)}s \u2014 likely a lost webhook or rolled-back job; re-push with a fresh delivery (ref-bounce) or admin-requeue`
+      reason: `no webhook fired for ${short2(targetSha)} (fork ref already there) and no job appeared in ${Math.round(noopGraceMs / 1e3)}s \u2014 likely a lost webhook or rolled-back job; re-push with a fresh delivery (ref-bounce) or admin-requeue`
     };
   }
   if (elapsedMs >= timeoutMs) {
     return {
       action: "stop",
       code: "timeout",
-      reason: `timed out after ${Math.round(elapsedMs / 1e3)}s waiting for marker to reach ${short(targetSha)} (job: ${job ? job.status : "not enqueued"})`
+      reason: `timed out after ${Math.round(elapsedMs / 1e3)}s waiting for marker to reach ${short2(targetSha)} (job: ${job ? job.status : "not enqueued"})`
     };
   }
   return {
@@ -15502,7 +16389,7 @@ function decideGate(input) {
     reason: job ? `job ${job.status}` : "job not enqueued yet"
   };
 }
-function short(sha) {
+function short2(sha) {
   return sha.slice(0, 7);
 }
 var init_commitGate = __esm({
@@ -15539,7 +16426,7 @@ function planPollTick(input) {
     case "upstream-behind":
       return {
         kind: "idle",
-        reason: `upstream is behind the marker (reset to ${short2(plan.tip)}); nothing to do`
+        reason: `upstream is behind the marker (reset to ${short3(plan.tip)}); nothing to do`
       };
     case "force-push":
       target = plan.tip;
@@ -15571,15 +16458,15 @@ function planPollTick(input) {
     case "advance":
       return { kind: "idle", reason: decision.reason };
     case "wait":
-      return { kind: "idle", reason: `${short2(target)}: ${decision.reason}` };
+      return { kind: "idle", reason: `${short3(target)}: ${decision.reason}` };
   }
 }
 function localHaltReason(decision, job, targetSha) {
   if (decision.code !== "job-terminal" || !job) return decision.reason;
-  return `commit ${short2(targetSha)} could not be processed (job ${job.status} after ${job.attemptCount} attempt(s)). Polling has stopped here rather than skipping it, because skipping would fold its changes into the next update.
+  return `commit ${short3(targetSha)} could not be processed (job ${job.status} after ${job.attemptCount} attempt(s)). Polling has stopped here rather than skipping it, because skipping would fold its changes into the next update.
 This one needs us \u2014 the failure is recorded against your account and visible to the ArchMe team. Get in touch if it is blocking you.`;
 }
-function short2(sha) {
+function short3(sha) {
   return sha.slice(0, 7);
 }
 var init_localPoll = __esm({
@@ -15625,8 +16512,8 @@ __export(localGit_exports, {
   revParse: () => revParse,
   setOriginUrl: () => setOriginUrl
 });
-import { mkdir as mkdir9 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { mkdir as mkdir10 } from "node:fs/promises";
+import { dirname as dirname13 } from "node:path";
 async function git(dir, args, opts = {}) {
   requireBinary("git");
   const res = await execa("git", args, {
@@ -15647,7 +16534,7 @@ async function git(dir, args, opts = {}) {
   return { exitCode, stdout: res.stdout || "", stderr: res.stderr || "" };
 }
 async function createMirrorClone(sourcePath, mirrorPath, originUrl) {
-  await mkdir9(dirname12(mirrorPath), { recursive: true });
+  await mkdir10(dirname13(mirrorPath), { recursive: true });
   await git(null, ["clone", "--local", "--no-hardlinks", sourcePath, mirrorPath]);
   await git(mirrorPath, ["remote", "set-url", "origin", originUrl]);
 }
@@ -15719,6 +16606,244 @@ var init_localGit = __esm({
   }
 });
 
+// src/daemon/localPrAdapters.ts
+function parseCredentialFill(stdout) {
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("password=")) return line.slice("password=".length).trim() || null;
+  }
+  return null;
+}
+async function resolveGithubTokens(deps = {}) {
+  const run = deps.run ?? defaultExec;
+  const ghPath = deps.ghPath ?? (() => findOnPath("gh"));
+  const tiers = [];
+  const clean = (t) => t && /^\S+$/.test(t) ? t : null;
+  if (ghPath()) {
+    try {
+      const r = await run("gh", ["auth", "token", "--hostname", "github.com"]);
+      const token = r.exitCode === 0 ? clean(r.stdout.trim()) : null;
+      if (token) tiers.push({ tier: "gh", token });
+    } catch {
+    }
+  }
+  try {
+    const r = await run("git", ["credential", "fill"], {
+      input: "protocol=https\nhost=github.com\n\n",
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "never",
+        GIT_ASKPASS: "",
+        SSH_ASKPASS: ""
+      }
+    });
+    const token = r.exitCode === 0 ? clean(parseCredentialFill(r.stdout)) : null;
+    if (token) tiers.push({ tier: "git-credential", token });
+  } catch {
+  }
+  tiers.push({ tier: "none", token: null });
+  return tiers;
+}
+async function listGithubPulls(args) {
+  const f = args.fetch ?? fetch;
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "archme-cli"
+  };
+  if (args.token) headers.Authorization = `Bearer ${args.token}`;
+  if (args.etag) headers["If-None-Match"] = args.etag;
+  const url = `https://api.github.com/repos/${encodeURIComponent(args.owner)}/${encodeURIComponent(args.name)}/pulls?state=all&sort=updated&direction=desc&per_page=100`;
+  const resp = await f(url, { headers, signal: AbortSignal.timeout(3e4) });
+  if (resp.status === 304) return { kind: "not-modified" };
+  if (resp.status === 429 || resp.status === 403 && resp.headers.get("x-ratelimit-remaining") === "0") {
+    const reset2 = Number(resp.headers.get("x-ratelimit-reset"));
+    return { kind: "rate-limited", untilMs: Number.isFinite(reset2) && reset2 > 0 ? reset2 * 1e3 : Date.now() + 60 * 6e4 };
+  }
+  if (resp.status === 401 || resp.status === 403 || resp.status === 404) {
+    return { kind: "denied", status: resp.status };
+  }
+  if (!resp.ok) throw new Error(`GitHub pulls list returned ${resp.status}`);
+  const body = await resp.json();
+  if (!Array.isArray(body)) throw new Error("GitHub pulls list was not an array");
+  return { kind: "ok", pulls: body, etag: resp.headers.get("etag") };
+}
+function rateLimitedReason(untilMs) {
+  return `GitHub's API rate limit is used up until ${new Date(untilMs).toISOString()}`;
+}
+async function listPrsFromGithub(args) {
+  const key = `${args.owner}/${args.name}`.toLowerCase();
+  const c3 = args.cache.get(key) ?? { denied: {} };
+  args.cache.set(key, c3);
+  const ok = (obs) => ({
+    kind: "ok",
+    observations: obs.filter((o2) => o2.baseRef === args.baseRef)
+  });
+  const bestTier = args.tiers.find((t) => (c3.denied[t.tier] ?? 0) <= args.nowMs)?.tier;
+  if (bestTier === "none" && c3.tier === "none" && c3.observations && args.nowMs - (c3.fetchedAtMs ?? 0) < UNAUTHENTICATED_MIN_INTERVAL_MS) {
+    return ok(c3.observations);
+  }
+  if (c3.rateLimitedUntil && args.nowMs < c3.rateLimitedUntil) {
+    return { kind: "unavailable", reason: rateLimitedReason(c3.rateLimitedUntil) };
+  }
+  for (const t of args.tiers) {
+    if ((c3.denied[t.tier] ?? 0) > args.nowMs) continue;
+    let r;
+    try {
+      r = await listGithubPulls({
+        owner: args.owner,
+        name: args.name,
+        token: t.token,
+        etag: c3.tier === t.tier && c3.observations ? c3.etag ?? null : null,
+        fetch: args.fetch
+      });
+    } catch (err2) {
+      return { kind: "unavailable", reason: `GitHub's API could not be reached (${err2.message})` };
+    }
+    if (r.kind === "ok") {
+      c3.tier = t.tier;
+      c3.etag = r.etag;
+      c3.observations = r.pulls.map(observeGithubPull);
+      c3.fetchedAtMs = args.nowMs;
+      return ok(c3.observations);
+    }
+    if (r.kind === "not-modified" && c3.observations) {
+      c3.fetchedAtMs = args.nowMs;
+      return ok(c3.observations);
+    }
+    if (r.kind === "rate-limited") {
+      c3.rateLimitedUntil = r.untilMs;
+      return { kind: "unavailable", reason: rateLimitedReason(r.untilMs) };
+    }
+    if (r.kind === "denied") c3.denied[t.tier] = args.nowMs + DENY_BACKOFF_MS;
+  }
+  return { kind: "unavailable", reason: DENIED_REASON };
+}
+async function postLocalPrSync(client, payload) {
+  const { data, error } = await client.functions.invoke("github/local-pr-sync", { body: payload });
+  if (error) {
+    let detail = error.message;
+    const ctx = error.context;
+    if (ctx instanceof Response) {
+      const body = await ctx.json().catch(() => null);
+      if (typeof body?.error === "string") detail = `${ctx.status} ${body.error}`;
+    }
+    throw new Error(`local-pr-sync: ${detail}`);
+  }
+  const results = data?.results;
+  if (!Array.isArray(results)) throw new Error("local-pr-sync: malformed response");
+  return results;
+}
+async function pollPrsOnce(entry, deps) {
+  const row = await deps.readWatchedRepo(entry.watchedRepoId);
+  if (row && row.prUpdateMode !== "auto") {
+    if (entry.prPoll && !entry.prPausedAt) await deps.pause(entry, new Date(deps.now()).toISOString());
+    return;
+  }
+  if (!row || row.sourceKind !== "local" || !row.enabled) return;
+  const repo = `${entry.repoOwner}/${entry.repoName}`;
+  const sameRepo = row.repoOwner?.toLowerCase() === entry.repoOwner.toLowerCase() && row.repoName?.toLowerCase() === entry.repoName.toLowerCase();
+  if (!sameRepo) {
+    deps.logOnChange(
+      `repo-mismatch:${entry.watchedRepoId}`,
+      true,
+      `  ${repo}: PR reviews skipped \u2014 the server now names ${row.repoOwner ?? "?"}/${row.repoName ?? "?"} for this watched repo, not the repo registered on this machine. Re-run \`archme local-watch\` in the right repo if that is intended.`
+    );
+    return;
+  }
+  const listing = await deps.listPrs(entry, row);
+  const unavailableKey = `pr-listing:${entry.watchedRepoId}`;
+  if (listing.kind === "unavailable") {
+    deps.logOnChange(
+      unavailableKey,
+      true,
+      `  ${repo}: PR reviews on hold \u2014 ${listing.reason}.`
+    );
+    return;
+  }
+  deps.logOnChange(unavailableKey, false, `  ${repo}: PR reviews resumed \u2014 GitHub's API answered again.`);
+  const resumed = entry.prPausedAt !== void 0;
+  const plan = planPrSync({ state: entry.prPoll, observations: listing.observations, nowMs: deps.now(), resumed });
+  if (plan.send.length > 0) {
+    const results = await deps.send(entry, plan.send);
+    const kinds = new Map(results.map((r) => [r.number, r.kind]));
+    for (const item of plan.send) {
+      const kind = kinds.get(item.number);
+      if (kind !== void 0) {
+        deps.log(`  ${repo}: PR #${item.number} ${item.action} \u2192 ${kind}`);
+      }
+      if (kind !== void 0 && !UNDELIVERED.has(kind)) continue;
+      const key = String(item.number);
+      const prev = entry.prPoll?.prs[key];
+      if (prev) plan.next.prs[key] = prev;
+      else delete plan.next.prs[key];
+    }
+  } else if (!resumed && JSON.stringify(plan.next) === JSON.stringify(entry.prPoll)) {
+    return;
+  }
+  await deps.saveState(entry, plan.next);
+}
+function makePrPollDeps(client, log, readWatchedRepo, io = {}) {
+  const cache2 = /* @__PURE__ */ new Map();
+  const on6 = /* @__PURE__ */ new Set();
+  return {
+    readWatchedRepo,
+    log,
+    logOnChange(key, value, msg) {
+      if (on6.has(key) === value) return;
+      if (value) on6.add(key);
+      else on6.delete(key);
+      log(msg);
+    },
+    now: () => Date.now(),
+    async listPrs(entry, row) {
+      return listPrsFromGithub({
+        owner: entry.repoOwner,
+        name: entry.repoName,
+        baseRef: row.repoBranch,
+        tiers: await (io.tiers ?? resolveGithubTokens)(),
+        cache: cache2,
+        nowMs: Date.now(),
+        fetch: io.fetch
+      });
+    },
+    send: (entry, items) => postLocalPrSync(client, { watched_repo_id: entry.watchedRepoId, prs: items }),
+    // Read-modify-write, as halts are: `local-watch` may have changed the
+    // registry since this tick read it.
+    async saveState(entry, state) {
+      await saveLocalRepos(setPrPollState(await loadLocalRepos(), entry.watchedRepoId, state));
+    },
+    async pause(entry, at) {
+      await saveLocalRepos(markPrPaused(await loadLocalRepos(), entry.watchedRepoId, at));
+    }
+  };
+}
+var TOKEN_TIMEOUT_MS, defaultExec, DENY_BACKOFF_MS, UNAUTHENTICATED_MIN_INTERVAL_MS, DENIED_REASON, UNDELIVERED;
+var init_localPrAdapters = __esm({
+  "src/daemon/localPrAdapters.ts"() {
+    "use strict";
+    init_execa();
+    init_preflight();
+    init_localPrPoll();
+    init_localRepos();
+    TOKEN_TIMEOUT_MS = 15e3;
+    defaultExec = async (cmd, args, opts) => {
+      const r = await execa(cmd, args, {
+        reject: false,
+        timeout: TOKEN_TIMEOUT_MS,
+        env: opts?.env,
+        input: opts?.input,
+        stdin: opts?.input === void 0 ? "ignore" : void 0
+      });
+      return { exitCode: r.exitCode ?? 1, stdout: typeof r.stdout === "string" ? r.stdout : "" };
+    };
+    DENY_BACKOFF_MS = 60 * 6e4;
+    UNAUTHENTICATED_MIN_INTERVAL_MS = 5 * 6e4;
+    DENIED_REASON = "no credential on this machine can read its pull requests from GitHub's API; a private repo needs `gh auth login` (or a GitHub credential in git's credential helper)";
+    UNDELIVERED = /* @__PURE__ */ new Set(["error", "invalid"]);
+  }
+});
+
 // src/daemon/localPoller.ts
 async function pollRepoOnce(entry, deps) {
   const repo = `${entry.repoOwner}/${entry.repoName}`;
@@ -15786,9 +16911,9 @@ async function pollRepoOnce(entry, deps) {
   if (decision.kind !== "enqueue") return decision;
   const result = await deps.enqueue(entry, row, decision.beforeSha, decision.afterSha);
   if (result.dedup) {
-    deps.log(`  ${repo}: ${short3(decision.afterSha)} already enqueued elsewhere`);
+    deps.log(`  ${repo}: ${short4(decision.afterSha)} already enqueued elsewhere`);
   } else {
-    deps.log(`  ${repo}: enqueued ${short3(decision.afterSha)} (job ${result.jobId ?? "?"})`);
+    deps.log(`  ${repo}: enqueued ${short4(decision.afterSha)} (job ${result.jobId ?? "?"})`);
   }
   return decision;
 }
@@ -15809,15 +16934,23 @@ async function pollAllRepos(repos, deps) {
     When the cause is fixed:  archme local-watch --resume ${entry.repoOwner}/${entry.repoName}
 `
         );
+        continue;
       }
     } catch (err2) {
       deps.log(`  local poll ${key} failed (will retry): ${err2.message}`);
+      continue;
+    }
+    if (!deps.pollPrs) continue;
+    try {
+      await deps.pollPrs(entry);
+    } catch (err2) {
+      deps.log(`  PR poll ${key} failed (will retry): ${err2.message}`);
     }
   }
 }
 function makePollerDeps(client, log, gateTimeoutMs) {
   const firstSeen = /* @__PURE__ */ new Map();
-  return {
+  const deps = {
     git: localGit_exports,
     log,
     now: () => Date.now(),
@@ -15835,7 +16968,7 @@ function makePollerDeps(client, log, gateTimeoutMs) {
       );
     },
     async readWatchedRepo(watchedRepoId) {
-      const { data, error } = await client.from("watched_repos").select("project_id, branch, commit_update_archme_branch, source_kind, enabled").eq("id", watchedRepoId).is("deleted_at", null).maybeSingle();
+      const { data, error } = await client.from("watched_repos").select("project_id, branch, commit_update_archme_branch, source_kind, enabled, pr_update_mode, repo_owner, repo_name").eq("id", watchedRepoId).is("deleted_at", null).maybeSingle();
       if (error || !data) return null;
       const r = data;
       return {
@@ -15845,7 +16978,10 @@ function makePollerDeps(client, log, gateTimeoutMs) {
         // branch`), so both producers resolve the same lane for the same row.
         archmeBranch: r.commit_update_archme_branch ?? r.branch,
         sourceKind: r.source_kind,
-        enabled: r.enabled
+        enabled: r.enabled,
+        prUpdateMode: r.pr_update_mode ?? "disabled",
+        repoOwner: r.repo_owner,
+        repoName: r.repo_name
       };
     },
     // Shared with the job runner and local-watch's readiness check: three
@@ -15883,8 +17019,11 @@ function makePollerDeps(client, log, gateTimeoutMs) {
       return data ?? {};
     }
   };
+  const prDeps = makePrPollDeps(client, log, (id) => deps.readWatchedRepo(id));
+  deps.pollPrs = (entry) => pollPrsOnce(entry, prDeps);
+  return deps;
 }
-function short3(sha) {
+function short4(sha) {
   return sha.slice(0, 7);
 }
 var DEFAULT_POLL_INTERVAL_MS, DEFAULT_GATE_TIMEOUT_MS;
@@ -15895,6 +17034,7 @@ var init_localPoller = __esm({
     init_localRepos();
     init_branchMarker();
     init_localGit();
+    init_localPrAdapters();
     DEFAULT_POLL_INTERVAL_MS = 6e4;
     DEFAULT_GATE_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
   }
@@ -15921,10 +17061,10 @@ __export(run_exports, {
 });
 import { createClient } from "@supabase/supabase-js";
 import { randomUUID } from "node:crypto";
-import { mkdtemp as mkdtemp3, mkdir as mkdir10, writeFile as writeFile10, rm as rm6, stat as stat8, chmod as chmod3 } from "node:fs/promises";
+import { mkdtemp as mkdtemp3, mkdir as mkdir11, writeFile as writeFile10, rm as rm7, stat as stat8, chmod as chmod4 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join18 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { join as join19 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 function attributeKillCause(result, recorded) {
   if (recorded) return recorded;
   if (result.signal === "SIGTERM") return "timeout";
@@ -15955,7 +17095,7 @@ async function lookupProjectSlug(client, projectId) {
   return `${orgSlug}/${data.slug}`;
 }
 function cloneDirFor(baseDir, owner, name) {
-  return join18(baseDir, owner, name);
+  return join19(baseDir, owner, name);
 }
 async function exists(p) {
   try {
@@ -16000,8 +17140,8 @@ async function getRepoCredentials(ctx, jobId, deviceId) {
   };
 }
 async function buildGitEnv(credentials) {
-  const dir = await mkdtemp3(join18(tmpdir3(), "archme-git-askpass-"));
-  const askpassPath = join18(dir, "askpass.sh");
+  const dir = await mkdtemp3(join19(tmpdir3(), "archme-git-askpass-"));
+  const askpassPath = join19(dir, "askpass.sh");
   await writeFile10(
     askpassPath,
     [
@@ -16015,7 +17155,7 @@ async function buildGitEnv(credentials) {
     ].join("\n"),
     { mode: 448 }
   );
-  await chmod3(askpassPath, 448).catch(() => {
+  await chmod4(askpassPath, 448).catch(() => {
   });
   const gitConfigEntries = [
     ["credential.helper", ""],
@@ -16037,23 +17177,32 @@ async function buildGitEnv(credentials) {
     GIT_USERNAME: credentials.username,
     GIT_PASSWORD: credentials.password
   };
-  return { env, cleanup: () => rm6(dir, { recursive: true, force: true }).catch(() => {
+  return { env, cleanup: () => rm7(dir, { recursive: true, force: true }).catch(() => {
   }) };
 }
 async function ensureLocalCloneAndFetch(job, entry) {
   const dir = entry.mirrorPath;
+  assertLocalJobShape(job);
   await cloneMutex.runExclusive(dir, async () => {
-    if (!await exists(join18(dir, ".git"))) {
+    if (!await exists(join19(dir, ".git"))) {
       throw new Error(
         `local mirror ${dir} is missing or not a git repo \u2014 re-run \`archme init ${entry.sourcePath}\``
       );
     }
     await execa("git", ["fetch", "--no-tags", "origin", job.repo_branch], { cwd: dir, reject: false });
+    if (job.source_mode === "pr_update") {
+      await verifyLocalPrJob(job, async (args) => {
+        const r = await execa("git", args, { cwd: dir, reject: false });
+        return { exitCode: r.exitCode ?? 1, stdout: String(r.stdout ?? ""), stderr: String(r.stderr ?? "") };
+      });
+      return;
+    }
     const afterCheck = await execa("git", ["cat-file", "-e", job.after_sha], { cwd: dir, reject: false });
     if (afterCheck.exitCode !== 0) {
       await execa("git", ["fetch", "origin"], { cwd: dir, reject: false });
     }
   }).catch((err2) => {
+    if (err2 instanceof LocalPrJobRejectedError) throw err2;
     const msg = err2 instanceof Error ? err2.message : String(err2);
     throw new Error(`local repo ${job.repo_owner}/${job.repo_name} is not usable: ${msg}`);
   });
@@ -16063,15 +17212,16 @@ async function ensureLocalCloneAndFetch(job, entry) {
 async function ensureCloneAndFetch(ctx, job, claimDeviceId) {
   const localEntry = findLocalRepoForJob(await loadLocalRepos(), job);
   if (localEntry) return await ensureLocalCloneAndFetch(job, localEntry);
+  assertLocalJobShape(job);
   const deviceId = claimDeviceId ?? ctx.deviceForOrg(job.org_id) ?? ctx.auth.getDeviceId();
   if (!deviceId) throw new Error("daemon is not signed in with a registered device");
   const credentials = await getRepoCredentials(ctx, job.id, deviceId);
-  await mkdir10(ctx.cloneBaseDir, { recursive: true });
+  await mkdir11(ctx.cloneBaseDir, { recursive: true });
   const dir = cloneDirFor(ctx.cloneBaseDir, job.repo_owner, job.repo_name);
   const { env, cleanup: cleanupGitEnv } = await buildGitEnv(credentials);
   await cloneMutex.runExclusive(dir, async () => {
-    if (!await exists(join18(dir, ".git"))) {
-      await mkdir10(join18(ctx.cloneBaseDir, job.repo_owner), { recursive: true });
+    if (!await exists(join19(dir, ".git"))) {
+      await mkdir11(join19(ctx.cloneBaseDir, job.repo_owner), { recursive: true });
       console.log(`  cloning ${job.repo_owner}/${job.repo_name} \u2192 ${dir}`);
       await execa("git", ["clone", "--no-tags", credentials.https_url, dir], { env, reject: true });
     } else {
@@ -16100,12 +17250,12 @@ async function ensureCloneAndFetch(ctx, job, claimDeviceId) {
   return { dir, gitEnv: env, cleanupGitEnv };
 }
 async function createJobWorktree(repoDir, job) {
-  const parentDir = await mkdtemp3(join18(tmpdir3(), "archme-job-worktree-"));
-  const worktreeDir = join18(parentDir, "repo");
+  const parentDir = await mkdtemp3(join19(tmpdir3(), "archme-job-worktree-"));
+  const worktreeDir = join19(parentDir, "repo");
   try {
     await cloneMutex.runExclusive(repoDir, () => execa("git", ["worktree", "add", "--detach", worktreeDir, job.after_sha], { cwd: repoDir, reject: true }));
   } catch (err2) {
-    await rm6(parentDir, { recursive: true, force: true }).catch(() => {
+    await rm7(parentDir, { recursive: true, force: true }).catch(() => {
     });
     throw err2;
   }
@@ -16116,7 +17266,7 @@ async function createJobWorktree(repoDir, job) {
         await execa("git", ["worktree", "remove", "--force", worktreeDir], { cwd: repoDir, reject: false });
         await execa("git", ["worktree", "prune"], { cwd: repoDir, reject: false });
       });
-      await rm6(parentDir, { recursive: true, force: true });
+      await rm7(parentDir, { recursive: true, force: true });
     }
   };
 }
@@ -16696,7 +17846,28 @@ async function runJob(ctx, job, claimDeviceId) {
   }, HEARTBEAT_INTERVAL_MS);
   try {
     const projectSlug = await lookupProjectSlug(ctx.supabase, job.project_id);
-    const { dir: repoDir, gitEnv, cleanupGitEnv } = await ensureCloneAndFetch(ctx, job, deviceId);
+    let clone;
+    try {
+      clone = await ensureCloneAndFetch(ctx, job, deviceId);
+    } catch (err2) {
+      if (!(err2 instanceof LocalPrJobRejectedError)) throw err2;
+      log(`${err2.message} \u2014 completing no_op without advancing the marker`);
+      markPhase("clone_fetch", { mode: "rejected" });
+      await rpcComplete(
+        ctx,
+        job.id,
+        deviceId,
+        err2.message,
+        "no_op",
+        false,
+        { mode: "rejected", durations_ms: timings },
+        { stdout: "", stderr: "" },
+        false
+        /* advance_marker */
+      );
+      return;
+    }
+    const { dir: repoDir, gitEnv, cleanupGitEnv } = clone;
     cleanupFns.push(cleanupGitEnv);
     activeCleanups.add(cleanupGitEnv);
     markPhase("clone_fetch");
@@ -16807,7 +17978,7 @@ async function runJob(ctx, job, claimDeviceId) {
         affectedForComplete = affected;
         const symbolsInFile = async (file) => {
           log(`parse ${file} (removed-symbol scan)`);
-          const outline = await runOutline(join18(worktreeDir, file));
+          const outline = await runOutline(join19(worktreeDir, file));
           if (outline.tier !== 2) return null;
           return outline.data.symbols.map((s) => s.name);
         };
@@ -17424,6 +18595,7 @@ var init_run = __esm({
     init_branchMarker();
     init_branchMarker();
     init_localRepos();
+    init_localPrJob();
     init_localPoller();
     HEARTBEAT_INTERVAL_MS = 6e4;
     CLAUDE_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -17445,7 +18617,7 @@ var init_run = __esm({
     MAX_CONCURRENT_JOBS = Math.max(1, Number(process.env.MAX_CONCURRENT_JOBS) || 3);
     ctxByJob = /* @__PURE__ */ new Map();
     deviceByJob = /* @__PURE__ */ new Map();
-    DEFAULT_CLONE_BASE_DIR = `${homedir5()}/.archme-job-runner/clones`;
+    DEFAULT_CLONE_BASE_DIR = `${homedir6()}/.archme-job-runner/clones`;
     INLINE_PATCH_BYTE_CAP = 2e5;
     GIT_SHA_RE = /^[0-9a-f]{40}$/;
     CURATOR_PREAMBLE = `## Your role
@@ -17573,6 +18745,7 @@ ${ANCHOR_VERIFICATION}`;
       claimedDeviceForJob(jobId) {
         return deviceByJob.get(jobId);
       },
+      runJob,
       // Exposes the clone/fetch entrypoint so a test can assert that the repo-token
       // mint (getRepoCredentials -> agents-device/repo-token, gated on
       // claimed_by_device_id) uses the CLAIM-time device rather than recomputing via
@@ -17622,7 +18795,7 @@ var dispatch_exports2 = {};
 __export(dispatch_exports2, {
   dispatchDaemon: () => dispatchDaemon
 });
-import { rm as rm7 } from "node:fs/promises";
+import { rm as rm8 } from "node:fs/promises";
 async function dispatchDaemon(route2) {
   switch (route2.action) {
     case "help":
@@ -17720,7 +18893,7 @@ async function dispatchDaemon(route2) {
       await orchestrateStop(c3);
       await c3.uninstall();
       if (route2.purge) {
-        await rm7(resolveLogDir(process.platform, process.env), { recursive: true, force: true });
+        await rm8(resolveLogDir(process.platform, process.env), { recursive: true, force: true });
       }
       console.log(
         route2.purge ? "Uninstalled. Logs purged." : "Uninstalled. Logs preserved (use --purge to remove)."
@@ -17761,8 +18934,8 @@ async function defaultLoadSupabaseState(_deviceId) {
 async function defaultLoadUptime(pid) {
   if (process.platform === "linux") {
     try {
-      const { readFile: readFile14 } = await import("node:fs/promises");
-      const stat11 = await readFile14(`/proc/${pid}/stat`, "utf8");
+      const { readFile: readFile16 } = await import("node:fs/promises");
+      const stat11 = await readFile16(`/proc/${pid}/stat`, "utf8");
       const parts = stat11.split(") ").pop()?.split(" ") ?? [];
       const ticks = Number(parts[19]);
       if (!Number.isFinite(ticks)) return null;
@@ -17818,7 +18991,47 @@ var init_dispatch2 = __esm({
   }
 });
 
+// src/auth/identity.ts
+function decodeJwtClaims(jwt) {
+  const segment = jwt?.split(".")[1];
+  if (!segment) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function str(v) {
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function describeAccount(input) {
+  const meta = input.claims?.user_metadata ?? {};
+  const email = str(input.email) ?? str(input.claims?.email);
+  const name = str(meta.name) ?? str(meta.full_name);
+  const keyed = input.kind === "key" || isKeyedAccountEmail(email) || input.claims?.app_metadata?.account_kind === "key";
+  if (keyed && email) {
+    const handle = email.slice(0, email.indexOf("@"));
+    return name ? `${name} (keyed account ${handle})` : `keyed account ${handle}`;
+  }
+  const login = str(meta.user_name) ?? str(meta.preferred_username);
+  if (login) return `${name ?? email ?? login} (GitHub @${login})`;
+  return email ?? str(input.sub) ?? str(input.claims?.sub) ?? "unknown account";
+}
+var init_identity = __esm({
+  "src/auth/identity.ts"() {
+    "use strict";
+    init_accountKey();
+  }
+});
+
 // src/scan/authedClient.ts
+var authedClient_exports = {};
+__export(authedClient_exports, {
+  SCAN_CLAUDE_TIMEOUT_MS: () => SCAN_CLAUDE_TIMEOUT_MS,
+  SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS: () => SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS,
+  createAuthedClient: () => createAuthedClient
+});
 import { createClient as createClient2 } from "@supabase/supabase-js";
 async function createAuthedClient(opts) {
   initBearer({
@@ -17844,7 +19057,13 @@ async function createAuthedClient(opts) {
     supabase,
     userId,
     orgId: getCurrentOrgId(),
-    identity: `${loaded.user.email ?? "OAuth user"} (${loaded.user.sub ?? "unknown"})`
+    identity: describeAccount({
+      kind: loaded.kind,
+      email: loaded.user.email,
+      sub: loaded.user.sub,
+      claims: decodeJwtClaims(getCurrentAccessToken())
+    }),
+    accountKind: loaded.kind ?? "oauth"
   };
 }
 var SCAN_CLAUDE_TIMEOUT_MS, SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS;
@@ -17852,12 +19071,18 @@ var init_authedClient = __esm({
   "src/scan/authedClient.ts"() {
     "use strict";
     init_bearer();
+    init_identity();
     SCAN_CLAUDE_TIMEOUT_MS = 45 * 60 * 1e3;
     SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS = SCAN_CLAUDE_TIMEOUT_MS + 5 * 60 * 1e3;
   }
 });
 
 // src/scan/web-url.ts
+var web_url_exports = {};
+__export(web_url_exports, {
+  buildWebUrl: () => buildWebUrl,
+  deriveWebOrigin: () => deriveWebOrigin
+});
 function deriveWebOrigin(apiUrl, onMalformed = "throw") {
   let parsed;
   try {
@@ -17883,6 +19108,277 @@ var init_web_url = __esm({
   }
 });
 
+// src/account/open.ts
+var open_exports = {};
+__export(open_exports, {
+  boardPathFromMcpJson: () => boardPathFromMcpJson,
+  buildKeyedOpenUrl: () => buildKeyedOpenUrl,
+  defaultOpenBrowser: () => defaultOpenBrowser,
+  defaultReadMcpJson: () => defaultReadMcpJson,
+  dispatchOpen: () => dispatchOpen,
+  freshAccessToken: () => freshAccessToken,
+  postBoardLinkWith: () => postBoardLinkWith,
+  runOpen: () => runOpen,
+  safeNextPath: () => safeNextPath
+});
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+function safeNextPath(path7) {
+  if (!path7 || !path7.startsWith("/") || path7.startsWith("//") || path7.startsWith("/\\")) return "/";
+  return path7;
+}
+function boardPathFromMcpJson(content) {
+  if (!content) return "/";
+  try {
+    const servers = JSON.parse(content).mcpServers ?? {};
+    const entry = Object.entries(servers).find(([name]) => /archme/i.test(name))?.[1];
+    if (typeof entry?.url !== "string") return "/";
+    const params = new URL(entry.url).searchParams;
+    const [org, slug, ...rest] = (params.get("project") ?? "").split("/");
+    if (!org || !slug || rest.length) return "/";
+    const branch = params.get("branch");
+    const segments = [org, slug, ...branch ? [branch] : []].map(encodeURIComponent);
+    return `/a/${segments.join("/")}`;
+  } catch {
+    return "/";
+  }
+}
+function buildKeyedOpenUrl(webOrigin, link, next) {
+  const fragment = new URLSearchParams({
+    token_hash: link.token_hash,
+    u: link.user_id,
+    label: link.handle,
+    next: safeNextPath(next)
+  });
+  return `${webOrigin.replace(/\/$/, "")}/auth/key#${fragment.toString()}`;
+}
+async function runOpen(opts, deps) {
+  const active = await deps.loadActive();
+  if (!active) {
+    deps.error("Not signed in. Run `archme login` first.");
+    return 1;
+  }
+  const next = safeNextPath(opts.next ?? boardPathFromMcpJson(await deps.readMcpJson(opts.cwd ?? process.cwd())));
+  const boardUrl = `${deps.webOrigin.replace(/\/$/, "")}${next}`;
+  if (credentialKind(active) !== "key") return await show(boardUrl, opts, deps, "Your board");
+  let link = null;
+  let failure = "";
+  try {
+    const res = await deps.postBoardLink(await deps.getAccessToken());
+    const data = res.data;
+    if (res.status === 200 && data.token_hash && data.user_id && data.handle) link = data;
+    else failure = `${res.status} ${data.error ?? JSON.stringify(res.data)}`;
+  } catch (err2) {
+    failure = err2 instanceof Error ? err2.message : String(err2);
+  }
+  if (!link) {
+    deps.error(`Could not create a sign-in link (${failure}). Opening the board without one.`);
+    await show(boardUrl, opts, deps, "Your board");
+    return 1;
+  }
+  const signedIn = buildKeyedOpenUrl(deps.webOrigin, link, next);
+  if (opts.hideLink) {
+    if (await deps.openBrowser(signedIn)) {
+      deps.log(`Opened your board in a browser, signed in as ${link.handle}.`);
+    } else {
+      deps.log(`Your board: ${boardUrl}`);
+      deps.log("  Run `archme open` to sign this browser in.");
+    }
+    return 0;
+  }
+  if (!opts.print && await deps.openBrowser(signedIn)) {
+    deps.log(`Opened your board in a browser, signed in as ${link.handle}.`);
+    return 0;
+  }
+  deps.log(`Your board, signed in as ${link.handle}: ${signedIn}`);
+  deps.log("  (The link signs you in once and expires soon. Don't share it.)");
+  return 0;
+}
+async function show(url, opts, deps, label) {
+  deps.log(`${label}: ${url}`);
+  if (!opts.print) await deps.openBrowser(url);
+  return 0;
+}
+async function defaultOpenBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : null;
+  if (!cmd) return false;
+  if (cmd === "xdg-open" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  const { execa: execa2 } = await Promise.resolve().then(() => (init_execa(), execa_exports));
+  const r = await execa2(cmd, [url], { reject: false, stdio: "ignore" });
+  return r.exitCode === 0;
+}
+async function defaultReadMcpJson(cwd) {
+  try {
+    return await readFile13(join20(cwd, ".mcp.json"), "utf8");
+  } catch {
+    return null;
+  }
+}
+async function postBoardLinkWith(supabaseUrl, accessToken) {
+  const { parseJsonResponse: parseJsonResponse2 } = await Promise.resolve().then(() => (init_oauthClient(), oauthClient_exports));
+  const response = await fetch(`${supabaseUrl.replace(/\/$/, "")}/functions/v1/agents-device/board-link`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+    body: "{}"
+  });
+  return { status: response.status, data: await parseJsonResponse2(response) };
+}
+async function freshAccessToken() {
+  const { resolveConfig: resolveConfig2 } = await Promise.resolve().then(() => (init_defaults(), defaults_exports));
+  const { createAuthedClient: createAuthedClient2, SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS2 } = await Promise.resolve().then(() => (init_authedClient(), authedClient_exports));
+  const { getCurrentAccessToken: getCurrentAccessToken2 } = await Promise.resolve().then(() => (init_bearer(), bearer_exports));
+  const cfg = resolveConfig2();
+  await createAuthedClient2({
+    supabaseUrl: cfg.supabaseUrl,
+    supabaseAnonKey: cfg.supabaseAnonKey,
+    clientId: cfg.archmeDaemonClientId,
+    preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS2
+  });
+  const token = getCurrentAccessToken2();
+  if (!token) throw new Error("signed in, but no access token was issued");
+  return token;
+}
+async function dispatchOpen(argv) {
+  const unknown = argv.filter((a2) => a2 !== "--print");
+  if (unknown.length) {
+    console.error(`archme open: unexpected argument \`${unknown[0]}\`
+Usage: archme open [--print]`);
+    return 2;
+  }
+  const { resolveConfig: resolveConfig2 } = await Promise.resolve().then(() => (init_defaults(), defaults_exports));
+  const { deriveWebOrigin: deriveWebOrigin2 } = await Promise.resolve().then(() => (init_web_url(), web_url_exports));
+  const cfg = resolveConfig2();
+  return await runOpen({ print: argv.includes("--print") }, {
+    webOrigin: deriveWebOrigin2(cfg.archmeMcpBaseUrl),
+    loadActive: async () => (await loadCredentials(cfg.supabaseUrl)).credentials,
+    getAccessToken: freshAccessToken,
+    postBoardLink: (token) => postBoardLinkWith(cfg.supabaseUrl, token),
+    readMcpJson: defaultReadMcpJson,
+    openBrowser: defaultOpenBrowser,
+    log: (m) => console.log(m),
+    error: (m) => console.error(m)
+  });
+}
+var init_open = __esm({
+  "src/account/open.ts"() {
+    "use strict";
+    init_credentials();
+  }
+});
+
+// src/account/key.ts
+var key_exports = {};
+__export(key_exports, {
+  dispatchKey: () => dispatchKey,
+  parseKeyArgs: () => parseKeyArgs,
+  runKey: () => runKey
+});
+function parseKeyArgs(argv) {
+  const cmd = { action: "list", yes: false };
+  let sawAction = false;
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const arg = argv[i2];
+    if (arg === "--yes") {
+      cmd.yes = true;
+      continue;
+    }
+    if (arg === "--handle" || arg.startsWith("--handle=")) {
+      const value = arg.startsWith("--handle=") ? arg.slice("--handle=".length) : argv[++i2];
+      if (!value || value.startsWith("-")) return { ok: false, error: "--handle requires a value" };
+      cmd.handle = value;
+      continue;
+    }
+    if (!sawAction && (arg === "list" || arg === "show" || arg === "forget")) {
+      cmd.action = arg;
+      sawAction = true;
+      continue;
+    }
+    return { ok: false, error: `unexpected argument \`${arg}\`` };
+  }
+  return { ok: true, cmd };
+}
+function pickKey(keys, handle, active) {
+  if (handle) return keys.find((k) => k.handle === handle) ?? `No saved key for ${handle}. \`archme key list\` shows what's saved.`;
+  const mine = keys.find((k) => k.user_id === active?.user_id);
+  if (mine) return mine;
+  if (keys.length === 1) return keys[0];
+  return `Several keys are saved (${keys.map((k) => k.handle).join(", ")}). Pick one with --handle <handle>.`;
+}
+async function runKey(cmd, deps) {
+  const keys = await deps.listKeys();
+  const active = await deps.loadActive();
+  if (cmd.action === "list") {
+    if (keys.length === 0) {
+      deps.log("No saved keys on this machine.");
+      return 0;
+    }
+    for (const k of [...keys].reverse()) {
+      const mark = k.user_id === active?.user_id ? "  (signed in)" : "";
+      deps.log(`${k.handle}  saved ${k.saved_at.slice(0, 10)}${mark}`);
+    }
+    return 0;
+  }
+  if (keys.length === 0) {
+    deps.error("No saved keys on this machine.");
+    return 1;
+  }
+  const picked = pickKey(keys, cmd.handle, active);
+  if (typeof picked === "string") {
+    deps.error(picked);
+    return 1;
+  }
+  if (cmd.action === "show") {
+    deps.log(picked.key);
+    return 0;
+  }
+  const signedInAsIt = active?.user_id === picked.user_id;
+  deps.error(
+    `Warning: this key is the only way into ${picked.handle} and its boards. Copy it somewhere safe first (\`archme key show --handle ` + picked.handle + "`)."
+  );
+  if (!cmd.yes) {
+    if (!deps.interactive) {
+      deps.error("Not forgetting without confirmation. Re-run with --yes.");
+      return 2;
+    }
+    const answer = (await deps.promptLine(`Forget the key for ${picked.handle}? [y/N]`)).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      deps.log("Kept.");
+      return 2;
+    }
+  }
+  await deps.forgetKey(picked.user_id);
+  deps.log(`Forgot the key for ${picked.handle}.`);
+  if (signedInAsIt) deps.log("You're still signed in as it on this machine until you `archme logout` or sign in as someone else.");
+  return 0;
+}
+async function dispatchKey(argv) {
+  const parsed = parseKeyArgs(argv);
+  if (!parsed.ok) {
+    console.error(`archme key: ${parsed.error}
+Usage: archme key [list|show|forget] [--handle <handle>] [--yes]`);
+    return 2;
+  }
+  const { resolveConfig: resolveConfig2 } = await Promise.resolve().then(() => (init_defaults(), defaults_exports));
+  const { listKeys: listKeys2, forgetKey: forgetKey2 } = await Promise.resolve().then(() => (init_keyRing(), keyRing_exports));
+  const { loadCredentials: loadCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { promptLine: promptLine2, stdinIsInteractive: stdinIsInteractive2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
+  const cfg = resolveConfig2();
+  return await runKey(parsed.cmd, {
+    listKeys: () => listKeys2(cfg.supabaseUrl),
+    forgetKey: (userId) => forgetKey2(cfg.supabaseUrl, userId),
+    loadActive: async () => (await loadCredentials2(cfg.supabaseUrl)).credentials,
+    interactive: stdinIsInteractive2(),
+    promptLine: promptLine2,
+    log: (m) => console.log(m),
+    error: (m) => console.error(m)
+  });
+}
+var init_key = __esm({
+  "src/account/key.ts"() {
+    "use strict";
+  }
+});
+
 // src/scan/architecture-detail.ts
 function tryParse2(s) {
   try {
@@ -18073,8 +19569,8 @@ var init_transcript_signals = __esm({
 });
 
 // src/scan/report.ts
-import { mkdir as mkdir11, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname13 } from "node:path";
+import { mkdir as mkdir12, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname14 } from "node:path";
 async function buildReport(input) {
   return {
     schema_version: REPORT_SCHEMA_VERSION,
@@ -18108,9 +19604,9 @@ async function buildReport(input) {
   };
 }
 async function writeReport(reportPath, orphansTxtPath, report, orphansFull) {
-  await mkdir11(dirname13(reportPath), { recursive: true });
+  await mkdir12(dirname14(reportPath), { recursive: true });
   await writeFile11(reportPath, JSON.stringify(report, null, 2) + "\n", "utf8");
-  await mkdir11(dirname13(orphansTxtPath), { recursive: true });
+  await mkdir12(dirname14(orphansTxtPath), { recursive: true });
   await writeFile11(
     orphansTxtPath,
     orphansFull.join("\n") + (orphansFull.length ? "\n" : ""),
@@ -18154,8 +19650,8 @@ var init_claimDefaultProject = __esm({
 
 // src/scan/run-scan.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile12 } from "node:fs/promises";
-import { basename as basename2, join as join19 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile14 } from "node:fs/promises";
+import { basename as basename2, join as join21 } from "node:path";
 function buildBootstrapPrompt(opts = {}) {
   const { promptVariant, interactive, briefing } = opts;
   let base = interactive ? briefing ? `${BOOTSTRAP_INTERACTIVE}
@@ -18183,6 +19679,16 @@ async function repoHeadSha(repoPath) {
   const { stdout } = await execa("git", ["rev-parse", "HEAD"], { cwd: repoPath });
   return stdout.trim();
 }
+async function buildScanSource(repoPath, repo, headSha) {
+  const { committedAt } = await readCommitMeta(repoPath, headSha);
+  const at = committedAt ? new Date(committedAt) : null;
+  return {
+    repo,
+    before_sha: null,
+    after_sha: headSha,
+    ...at && !Number.isNaN(at.getTime()) ? { committed_at: at.toISOString() } : {}
+  };
+}
 function defaultBranchName(headSha, date = todayDate()) {
   return `${date}-${headSha.slice(0, 7)}-scan`;
 }
@@ -18474,7 +19980,7 @@ async function runScan(opts, deps = {}) {
     // derives the `commits.source_sha` column from the very metadata it stores,
     // so the two can never disagree. A hand-written UPDATE that sets one and
     // not the other is what broke a deep link once.
-    ...sourceRepo ? { source: { repo: sourceRepo, before_sha: null, after_sha: headSha } } : {}
+    ...sourceRepo ? { source: await buildScanSource(opts.repoPath, sourceRepo, headSha) } : {}
   });
   try {
     const model = await resolveModelPin(supabase);
@@ -18503,9 +20009,9 @@ async function runScan(opts, deps = {}) {
       // Incompatible with an interactive TTY session.
       streamJson: !interactive
     });
-    const transcriptDir = join19(opts.repoPath, ".archme", "scan");
-    const transcriptPath = join19(transcriptDir, "transcript.log");
-    await mkdir12(transcriptDir, { recursive: true });
+    const transcriptDir = join21(opts.repoPath, ".archme", "scan");
+    const transcriptPath = join21(transcriptDir, "transcript.log");
+    await mkdir13(transcriptDir, { recursive: true });
     const transcriptStream = createWriteStream2(transcriptPath, { flags: "w" });
     let finalResultText = "";
     if (proc.stdout) {
@@ -18547,9 +20053,9 @@ async function runScan(opts, deps = {}) {
       await new Promise((resolve6, reject) => {
         transcriptStream.end((err2) => err2 ? reject(err2) : resolve6());
       });
-      const reportPath = join19(transcriptDir, "report.json");
-      const orphansTxtPath = join19(transcriptDir, "orphans.txt");
-      const transcript = await readFile12(transcriptPath, "utf8").catch(() => "");
+      const reportPath = join21(transcriptDir, "report.json");
+      const orphansTxtPath = join21(transcriptDir, "orphans.txt");
+      const transcript = await readFile14(transcriptPath, "utf8").catch(() => "");
       signals2 = extractTranscriptSignals(transcript);
       const architecture = await fetchArchitectureDetail(supabase, resolved2.projectId, branchName);
       const orphans = await classifyOrphans({
@@ -18621,6 +20127,7 @@ var init_run_scan = __esm({
     init_bearer();
     init_authedClient();
     init_mcp_config();
+    init_localGit();
     init_spawn_claude();
     init_model_pin();
     init_web_url();
@@ -18807,7 +20314,7 @@ var init_dispatch3 = __esm({
 
 // src/init/repoSize.ts
 import { stat as stat9 } from "node:fs/promises";
-import { extname, join as join20 } from "node:path";
+import { extname, join as join22 } from "node:path";
 async function measureRepo(repoPath) {
   const files = await gitListFiles(repoPath);
   if (!files) return { sourceFiles: 0, sourceBytes: 0, totalFiles: 0 };
@@ -18816,7 +20323,7 @@ async function measureRepo(repoPath) {
   for (const rel of files) {
     if (!SOURCE_EXTENSIONS.has(extname(rel).toLowerCase())) continue;
     try {
-      const s = await stat9(join20(repoPath, rel));
+      const s = await stat9(join22(repoPath, rel));
       if (!s.isFile()) continue;
       sourceFiles++;
       sourceBytes += s.size;
@@ -19025,7 +20532,7 @@ async function chooseKeepCurrent(deps) {
   if (deps.yes) {
     return { detection: deps.alreadyWatched ? "github-app" : "local-watch", runner: "self" };
   }
-  const detection = deps.alreadyWatched ? "github-app" : await deps.choose(
+  const detection = deps.alreadyWatched ? "github-app" : deps.keyed ? "local-watch" : await deps.choose(
     "How should ArchMe detect new commits?",
     DETECTION_OPTIONS
   );
@@ -19043,16 +20550,19 @@ function formatKeepCurrentPlan(plan, ctx) {
       command: "archme local-watch"
     });
   }
+  const costNotes = [
+    "Keep it running on a machine that stays on. Each update spends tokens",
+    "from your Claude subscription, the same way this scan did. Your code is",
+    "not sent to our servers \u2014 only the resulting architecture."
+  ];
   if (plan.runner === "self") {
-    steps.push({
-      title: "Start the daemon \u2014 nothing processes the queue until you do:",
-      command: "archme daemon start",
-      notes: [
-        "Keep it running on a machine that stays on. Each update spends tokens",
-        "from your Claude subscription, the same way this scan did. Your code is",
-        "not sent to our servers \u2014 only the resulting architecture."
-      ]
-    });
+    if (!ctx.daemonStarted) {
+      steps.push({
+        title: "Start the daemon \u2014 nothing processes the queue until you do:",
+        command: "archme daemon start",
+        notes: costNotes
+      });
+    }
   } else {
     steps.push({
       title: `Email ${CONTACT_EMAIL} and we'll set up the daemon for you.`,
@@ -19069,6 +20579,10 @@ function formatKeepCurrentPlan(plan, ctx) {
   if (ctx.localWatchRegistered) {
     lines.push("", `  \u2713 ${ctx.repoSlug ?? "This repo"} is registered \u2014 your machine is watching it.`);
   }
+  if (plan.runner === "self" && ctx.daemonStarted) {
+    lines.push("", "  \u2713 The daemon is running in the background (`archme daemon status`).", "");
+    for (const note of costNotes) lines.push(`    ${note}`);
+  }
   const numbered = steps.length > 1;
   steps.forEach((step, i2) => {
     const bullet = numbered ? `  ${i2 + 1}. ` : "  ";
@@ -19096,7 +20610,7 @@ var init_keepCurrent = __esm({
         value: "github-app"
       },
       {
-        label: "Local polling \u2014 no GitHub App and nobody's approval needed. This machine watches the repo instead. No pull-request awareness.",
+        label: "Local polling \u2014 no GitHub App and nobody's approval needed. This machine watches the repo instead. Pull requests are optional and, on a private repo, need `gh auth login`.",
         value: "local-watch"
       }
     ];
@@ -19215,66 +20729,6 @@ var init_githubAppSetup = __esm({
   }
 });
 
-// src/daemon/prompt.ts
-import { createInterface } from "node:readline/promises";
-function stdinIsInteractive() {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
-async function withReadline(fn) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return await fn(rl);
-  } finally {
-    rl.close();
-  }
-}
-async function promptLine(question) {
-  return await withReadline(async (rl) => {
-    try {
-      return await rl.question(`${question}: `);
-    } catch {
-      return "";
-    }
-  });
-}
-async function promptChoice(question, options) {
-  return await withReadline(async (rl) => {
-    console.log(`
-${question}
-`);
-    options.forEach((o2, i2) => console.log(`  ${i2 + 1}. ${o2.label}
-`));
-    for (let attempt = 0; attempt < 3; attempt++) {
-      let answer;
-      try {
-        answer = (await rl.question(`Choose 1-${options.length} [1]: `)).trim();
-      } catch {
-        return options[0].value;
-      }
-      if (answer === "") return options[0].value;
-      const n2 = Number.parseInt(answer, 10);
-      if (Number.isInteger(n2) && n2 >= 1 && n2 <= options.length) return options[n2 - 1].value;
-      console.log(`  "${answer}" isn't one of the options.`);
-    }
-    return options[0].value;
-  });
-}
-async function promptYesNo(question) {
-  return await withReadline(async (rl) => {
-    try {
-      const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase();
-      return answer === "" || answer === "y" || answer === "yes";
-    } catch {
-      return false;
-    }
-  });
-}
-var init_prompt = __esm({
-  "src/daemon/prompt.ts"() {
-    "use strict";
-  }
-});
-
 // src/daemon/watchReadiness.ts
 function evaluateWatchReadiness(input) {
   const { marker, repo, archmeBranch } = input;
@@ -19412,6 +20866,69 @@ var init_localWatchResolve = __esm({
   }
 });
 
+// src/daemon/localPrSetup.ts
+async function askForPrReviews(deps = {}) {
+  if (deps.flag !== void 0) return deps.flag;
+  if (deps.current === "auto") return null;
+  if (!(deps.interactive ?? stdinIsInteractive())) return null;
+  const confirm = deps.confirm ?? ((q) => promptYesNo(q, { defaultYes: false }));
+  return await confirm(PR_REVIEWS_QUESTION);
+}
+async function setPrReviewMode(supabase, watchedRepoId, enabled) {
+  const { data, error } = await supabase.from("watched_repos").update({ pr_update_mode: enabled ? "auto" : "disabled", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", watchedRepoId).select("id");
+  if (error || !Array.isArray(data) || data.length === 0) {
+    throw new Error(`could not update PR reviews for this repo: ${error?.message ?? "no access to the row"}`);
+  }
+}
+async function readPrReviewMode(supabase, watchedRepoId) {
+  const { data, error } = await supabase.from("watched_repos").select("pr_update_mode").eq("id", watchedRepoId).maybeSingle();
+  if (error || !data) return null;
+  return data.pr_update_mode ?? "disabled";
+}
+function ghInstallHint(platform3 = process.platform) {
+  if (platform3 === "darwin") return "brew install gh";
+  if (platform3 === "win32") return "winget install --id GitHub.cli";
+  return "see https://cli.github.com for your distribution";
+}
+async function ghLoginPrompt(deps = {}) {
+  if (!(deps.interactive ?? stdinIsInteractive())) return "non-interactive";
+  const log = deps.log ?? ((m) => console.log(m));
+  const hasToken = deps.hasToken ?? (async () => (await resolveGithubTokens()).some((t) => t.token !== null));
+  if (await hasToken()) return "has-token";
+  const ghPath = deps.ghPath ?? (() => findOnPath("gh"));
+  if (!ghPath()) {
+    log(`
+  ${NEEDS_TOKEN}`);
+    log(`  To sign in, install the GitHub CLI (${ghInstallHint(deps.platform)}), then run:  gh auth login`);
+    return "gh-missing";
+  }
+  log(`
+  ${NEEDS_TOKEN}`);
+  const confirm = deps.confirm ?? ((q) => promptYesNo(q));
+  if (!await confirm("Sign in with `gh auth login` now?")) {
+    log("  You can do it any time:  gh auth login");
+    return "declined";
+  }
+  const run = deps.runGhLogin ?? (async () => (await execa("gh", ["auth", "login", "--hostname", "github.com"], { stdio: "inherit", reject: false })).exitCode ?? 1);
+  const code = await run();
+  if (code === 0 && await hasToken()) return "logged-in";
+  log("  `gh auth login` did not finish \u2014 a private repo's pull requests can't be reviewed until it does.");
+  return "failed";
+}
+var PR_REVIEWS_QUESTION, PR_REVIEWS_ALREADY_ON, NEEDS_TOKEN;
+var init_localPrSetup = __esm({
+  "src/daemon/localPrSetup.ts"() {
+    "use strict";
+    init_execa();
+    init_preflight();
+    init_localPrAdapters();
+    init_prompt();
+    PR_REVIEWS_QUESTION = "Also review pull requests? Each PR push is one run on your Claude subscription.";
+    PR_REVIEWS_ALREADY_ON = "Pull requests are already reviewed for this repo (`--no-prs` turns that off).";
+    NEEDS_TOKEN = "PR reviews read pull requests from GitHub's API. Without a GitHub token only a public repo's can be read \u2014 a private repo needs `gh auth login` (or a GitHub credential in git's credential helper).";
+  }
+});
+
 // src/daemon/localWatch.ts
 var localWatch_exports = {};
 __export(localWatch_exports, {
@@ -19425,11 +20942,11 @@ __export(localWatch_exports, {
   runLocalWatchResume: () => runLocalWatchResume,
   runLocalWatchStop: () => runLocalWatchStop
 });
-import { homedir as homedir6 } from "node:os";
-import { join as join21, resolve as resolve3 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { join as join23, resolve as resolve3 } from "node:path";
 import { stat as stat10 } from "node:fs/promises";
 function mirrorPathFor(cloneBaseDir, owner, name) {
-  return join21(cloneBaseDir, owner, name);
+  return join23(cloneBaseDir, owner, name);
 }
 function resolveInitTarget(input) {
   if (!input.originUrl) {
@@ -19546,6 +21063,19 @@ async function runLocalWatch(opts) {
   }
   log(`
   \u2713 ${target.repo} is now watched locally.`);
+  const interactive = !opts.yes && stdinIsInteractive();
+  const current = await readPrReviewMode(supabase, registered.entry.watchedRepoId);
+  const reviewPrs = await askForPrReviews({ flag: opts.prs, interactive, current });
+  if (reviewPrs === null && current === "auto") log(`  \u2713 ${PR_REVIEWS_ALREADY_ON}`);
+  if (reviewPrs !== null) {
+    try {
+      await setPrReviewMode(supabase, registered.entry.watchedRepoId, reviewPrs);
+      log(reviewPrs ? "  \u2713 Pull requests will be reviewed too." : "  Pull requests will not be reviewed.");
+      if (reviewPrs) await ghLoginPrompt({ interactive, log });
+    } catch (err2) {
+      console.error(`archme local-watch: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+  }
   log(`
     Start the daemon if it isn't running:  archme daemon start`);
   log(`    New commits on ${target.repoBranch} will appear as ArchMe commits within a minute or two.`);
@@ -19585,7 +21115,7 @@ async function registerLocalWatch(args) {
     };
   }
   const mirrorPath = mirrorPathFor(cloneBaseDir, target.repoOwner, target.repoName);
-  const mirrorExists = await stat10(join21(mirrorPath, ".git")).then(() => true).catch(() => false);
+  const mirrorExists = await stat10(join23(mirrorPath, ".git")).then(() => true).catch(() => false);
   if (mirrorExists) {
     log(`  mirror:  ${mirrorPath} (reusing)`);
     await setOriginUrl(mirrorPath, originUrl);
@@ -19604,6 +21134,9 @@ async function registerLocalWatch(args) {
     repoOwner: target.repoOwner,
     repoName: target.repoName
   };
+  const prior = (await loadLocalRepos()).find((r) => r.watchedRepoId === watchedRepoId);
+  if (prior?.prPoll) entry.prPoll = prior.prPoll;
+  if (prior?.prPausedAt) entry.prPausedAt = prior.prPausedAt;
   await registerLocalRepo(entry);
   return { ok: true, entry };
 }
@@ -19674,7 +21207,8 @@ var init_localWatch = __esm({
     init_localWatchList();
     init_localWatchResolve();
     init_prompt();
-    DEFAULT_CLONE_BASE_DIR2 = join21(homedir6(), ".archme-job-runner", "clones");
+    init_localPrSetup();
+    DEFAULT_CLONE_BASE_DIR2 = join23(homedir7(), ".archme-job-runner", "clones");
   }
 });
 
@@ -19707,9 +21241,42 @@ var init_plan = __esm({
 });
 
 // src/init/run-init.ts
-import { mkdtemp as mkdtemp4, rm as rm8, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdtemp as mkdtemp4, rm as rm9, writeFile as writeFile12 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
+async function defaultStartDaemon() {
+  const { runStartFlow: runStartFlow2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+  const out = await runStartFlow2({ noLogin: true });
+  return `${out.result.actions.join(" \u2192 ")} (logs: ${out.logPath})`;
+}
+async function defaultOpenBoard(opts) {
+  const { runOpen: runOpen2, defaultOpenBrowser: defaultOpenBrowser2, defaultReadMcpJson: defaultReadMcpJson2, postBoardLinkWith: postBoardLinkWith2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+  const { loadCredentials: loadCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+  const { deriveWebOrigin: deriveWebOrigin2 } = await Promise.resolve().then(() => (init_web_url(), web_url_exports));
+  const cfg = resolveConfig();
+  return await runOpen2(opts, {
+    webOrigin: deriveWebOrigin2(cfg.archmeMcpBaseUrl),
+    loadActive: async () => (await loadCredentials2(cfg.supabaseUrl)).credentials,
+    // The session init just authenticated; refreshing again would only rotate it.
+    getAccessToken: async () => {
+      const token = getCurrentAccessToken();
+      if (!token) throw new Error("no active session");
+      return token;
+    },
+    postBoardLink: (token) => postBoardLinkWith2(cfg.supabaseUrl, token),
+    readMcpJson: defaultReadMcpJson2,
+    openBrowser: defaultOpenBrowser2,
+    log: (m) => console.log(m),
+    error: (m) => console.error(m)
+  });
+}
+function boardPath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return "/";
+  }
+}
 function initScanBranch(defaultBranch) {
   return normalizeScanBranchName(defaultBranch);
 }
@@ -19721,13 +21288,13 @@ async function defaultFetchInstallScript(url) {
   return await resp.text();
 }
 async function defaultRunInstallScript(script, cwd) {
-  const dir = await mkdtemp4(join22(tmpdir4(), "archme-init-"));
-  const scriptPath = join22(dir, "install-agent.sh");
+  const dir = await mkdtemp4(join24(tmpdir4(), "archme-init-"));
+  const scriptPath = join24(dir, "install-agent.sh");
   try {
     await writeFile12(scriptPath, script, { mode: 448 });
     await execa("sh", [scriptPath], { cwd, stdio: "inherit" });
   } finally {
-    await rm8(dir, { recursive: true, force: true });
+    await rm9(dir, { recursive: true, force: true });
   }
 }
 async function runInit(opts, deps = {}) {
@@ -19744,6 +21311,8 @@ async function runInit(opts, deps = {}) {
   const gitContext = deps.gitContext ?? resolveGitContext;
   const measure = deps.measure ?? measureRepo;
   const watchRepo = deps.watchRepo ?? watchRepoForProject;
+  const interactive = !opts.yes && (deps.interactive ?? stdinIsInteractive());
+  const openBoard = deps.openBoard ?? defaultOpenBoard;
   const cfg = resolveConfig();
   const git4 = await gitContext(opts.repoPath);
   const repoPath = git4.root;
@@ -19751,9 +21320,10 @@ async function runInit(opts, deps = {}) {
   const signedIn = credentials.length > 0;
   if (!signedIn) {
     log("\u2192 signing you in\u2026");
-    await login();
+    await login({ ...opts.login, ...opts.yes ? { interactive: false } : {} });
   } else {
     log("\u2713 already signed in");
+    if (opts.login?.method) log(`  (ignoring --${opts.login.method}: \`archme login\` switches accounts)`);
   }
   const authed2 = await authenticate({
     supabaseUrl: cfg.supabaseUrl,
@@ -19761,7 +21331,8 @@ async function runInit(opts, deps = {}) {
     clientId: cfg.archmeDaemonClientId,
     preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS
   });
-  log(`  signed in as ${authed2.identity}`);
+  log(`  signed in as ${authed2.identity} \u2014 not you? \`archme login\``);
+  const keyed = authed2.accountKind === "key";
   let fullSlug = opts.project;
   if (!fullSlug) {
     const orgId = authed2.orgId;
@@ -19832,6 +21403,7 @@ async function runInit(opts, deps = {}) {
     }
     log(`
 Your board: ${webUrl}`);
+    if (keyed) await openBoard({ next: boardPath(webUrl), hideLink: !interactive });
     return { exitCode: 0, project: fullSlug, branch: scanBranch, webUrl, ran };
   }
   const measurement = await measure(repoPath);
@@ -19860,10 +21432,12 @@ Your board: ${webUrl}`);
     const plan = await chooseKeepCurrent({
       alreadyWatched: watched.watched,
       yes: Boolean(opts.yes),
+      keyed,
       repoSlug: git4.repoSlug,
       choose: deps.choose ?? promptChoice,
       log
     });
+    const registered = { watchedRepoId: null };
     const outcome = await applyKeepCurrentPlan(
       plan,
       {
@@ -19911,12 +21485,38 @@ Your board: ${webUrl}`);
             target: target.target,
             log
           });
-          return res.ok ? { ok: true } : { ok: false, reason: res.reason };
+          if (!res.ok) return { ok: false, reason: res.reason };
+          registered.watchedRepoId = res.entry.watchedRepoId;
+          return { ok: true };
         },
         log
       },
       watched.watched
     );
+    if (outcome.localWatchRegistered && registered.watchedRepoId && deps.offerPrReviews) {
+      await deps.offerPrReviews({
+        supabase: authed2.supabase,
+        orgId: authed2.orgId,
+        projectId: project.projectId,
+        watchedRepoId: registered.watchedRepoId,
+        repoSlug: git4.repoSlug,
+        repoPath: git4.root,
+        interactive,
+        log
+      });
+    }
+    let daemonStarted = false;
+    if (plan.runner === "self" && interactive) {
+      if (await (deps.confirm ?? promptYesNo)(DAEMON_QUESTION)) {
+        try {
+          log("\u2192 starting the daemon\u2026");
+          log(`  \u2713 ${await (deps.startDaemon ?? defaultStartDaemon)()}`);
+          daemonStarted = true;
+        } catch (err2) {
+          log(`  Couldn't start the daemon: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        }
+      }
+    }
     if (!outcome.wired && outcome.reason) {
       log("");
       log("Not yet set up for automatic updates:");
@@ -19927,9 +21527,11 @@ Your board: ${webUrl}`);
       formatKeepCurrentPlan(plan, {
         repoSlug: git4.repoSlug,
         boardUrl: finalUrl,
-        localWatchRegistered: outcome.localWatchRegistered
+        localWatchRegistered: outcome.localWatchRegistered,
+        daemonStarted
       })
     );
+    if (keyed) await openBoard({ next: boardPath(finalUrl), hideLink: !interactive });
   }
   return {
     exitCode: result.exitCode,
@@ -19939,6 +21541,7 @@ Your board: ${webUrl}`);
     ran
   };
 }
+var DAEMON_QUESTION;
 var init_run_init = __esm({
   "src/init/run-init.ts"() {
     "use strict";
@@ -19960,6 +21563,36 @@ var init_run_init = __esm({
     init_prompt();
     init_localWatch();
     init_plan();
+    DAEMON_QUESTION = "Keep the board updating in the background?";
+  }
+});
+
+// src/init/prReviews.ts
+async function offerPrReviewsForInit(ctx, flag, deps = {}) {
+  const readMode = deps.readMode ?? readPrReviewMode;
+  const ask = deps.ask ?? askForPrReviews;
+  const setMode = deps.setMode ?? setPrReviewMode;
+  const ghLogin = deps.ghLogin ?? ghLoginPrompt;
+  const current = await readMode(ctx.supabase, ctx.watchedRepoId);
+  const want = await ask({ flag, interactive: ctx.interactive, current });
+  if (want === null) {
+    if (current === "auto") ctx.log(`\u2713 ${PR_REVIEWS_ALREADY_ON}`);
+    return;
+  }
+  try {
+    await setMode(ctx.supabase, ctx.watchedRepoId, want);
+  } catch (err2) {
+    ctx.log(`! ${err2 instanceof Error ? err2.message : String(err2)} \u2014 run \`archme local-watch --prs\` to try again.`);
+    return;
+  }
+  if (!want) return;
+  ctx.log("\u2713 Pull requests will be reviewed too.");
+  await ghLogin({ interactive: ctx.interactive, log: ctx.log });
+}
+var init_prReviews = __esm({
+  "src/init/prReviews.ts"() {
+    "use strict";
+    init_localPrSetup();
   }
 });
 
@@ -19979,6 +21612,25 @@ function parseInitArgs(argv) {
       args.help = true;
       return { ok: true, args };
     }
+    const loginFlag = arg.startsWith("--key=") ? "--key" : arg;
+    const loginMethod = LOGIN_FLAGS[loginFlag];
+    if (loginMethod) {
+      if (args.login && args.login.method !== loginMethod) {
+        return { ok: false, error: `${loginFlag} cannot be combined with another sign-in option` };
+      }
+      args.login = { method: loginMethod };
+      if (arg.startsWith("--key=")) args.login.key = arg.slice("--key=".length);
+      else if (loginMethod === "key" && argv[i2 + 1]?.startsWith("amk_")) args.login.key = argv[++i2];
+      continue;
+    }
+    if (arg === "--prs" || arg === "--no-prs") {
+      const value = arg === "--prs";
+      if (args.prs !== void 0 && args.prs !== value) {
+        return { ok: false, error: "--prs cannot be combined with --no-prs" };
+      }
+      args.prs = value;
+      continue;
+    }
     if (BOOLEAN_FLAGS.has(arg)) {
       if (arg === "--force") args.force = true;
       else if (arg === "--yes") args.yes = true;
@@ -20025,7 +21677,7 @@ function parseInitArgs(argv) {
   args.repoPath = positionals[0];
   return { ok: true, args };
 }
-var BOOLEAN_FLAGS, VALUE_FLAGS, HELP_FLAGS, PROJECT_SLUG_RE2;
+var BOOLEAN_FLAGS, VALUE_FLAGS, HELP_FLAGS, LOGIN_FLAGS, PROJECT_SLUG_RE2;
 var init_args = __esm({
   "src/init/args.ts"() {
     "use strict";
@@ -20037,6 +21689,11 @@ var init_args = __esm({
     ]);
     VALUE_FLAGS = /* @__PURE__ */ new Set(["--project", "--app-origin"]);
     HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h", "help"]);
+    LOGIN_FLAGS = {
+      "--no-account": "no-account",
+      "--github": "github",
+      "--key": "key"
+    };
     PROJECT_SLUG_RE2 = /^[^/\s]+\/[^/\s]+$/;
   }
 });
@@ -20054,9 +21711,10 @@ import { resolve as resolve4 } from "node:path";
 function printInitHelp() {
   console.log(`archme init \u2014 guided first-time setup for this repo
 
-Signs you in, creates a project named after the repo, installs agent config
-(.mcp.json, CLAUDE.md block, architecture skill), then hands over to an
-interactive Claude Code session that confirms the cost and runs the scan.
+Signs you in (or continues without an account), creates a project named after
+the repo, installs agent config (.mcp.json, CLAUDE.md block, architecture
+skill), then hands over to an interactive Claude Code session that confirms the
+cost and runs the scan.
 
 Usage:
   archme init [repo-path] [options]
@@ -20070,6 +21728,15 @@ Options:
   --yes                  Run unattended (headless scan, no questions)
   --no-interactive       Same as --yes; for automation
   --app-origin <url>     Origin serving /api/install-agent (local development)
+  --no-account           If not signed in: continue without an account (a key
+                         saved on this machine signs you in; archme key show
+                         prints it)
+  --github               If not signed in: sign in with GitHub
+  --key                  If not signed in: use an existing key (ARCHME_KEY, else
+                         the saved one). Implied when ARCHME_KEY is set
+  --prs / --no-prs       With local polling: also review pull requests (each PR
+                         push is one run on your Claude subscription; a private
+                         repo needs gh auth login)
   -h, --help             Show this help
 
 Requires Claude Code to be installed and authenticated \u2014 the scan runs on your
@@ -20093,7 +21760,10 @@ async function dispatchInit(argv) {
       appOrigin: parsed.args.appOrigin,
       force: parsed.args.force,
       skipScan: parsed.args.skipScan,
-      yes: parsed.args.yes || parsed.args.noInteractive
+      yes: parsed.args.yes || parsed.args.noInteractive,
+      login: parsed.args.login
+    }, {
+      offerPrReviews: (ctx) => offerPrReviewsForInit(ctx, parsed.args.prs)
     });
     return result.exitCode;
   } catch (err2) {
@@ -20106,6 +21776,7 @@ var init_dispatch4 = __esm({
   "src/init/dispatch.ts"() {
     "use strict";
     init_run_init();
+    init_prReviews();
     init_args();
     EX_OK2 = 0;
     EX_INFRA2 = 3;
@@ -20329,7 +22000,7 @@ __export(run_uninstall_exports, {
   runUninstall: () => runUninstall
 });
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 function readIfExists(path7) {
   try {
     return existsSync3(path7) ? readFileSync5(path7, "utf8") : null;
@@ -20355,7 +22026,7 @@ async function runUninstall(opts) {
   const backend = opts.backend ?? await defaultBackend();
   const repoPath = await backend.gitRoot(opts.repoPath).catch(() => null) ?? opts.repoPath;
   if (repoPath !== opts.repoPath) log(`Using the repo root: ${repoPath}`);
-  const abs = (rel) => join23(repoPath, rel);
+  const abs = (rel) => join25(repoPath, rel);
   const actions = [];
   const skipped = [];
   const mcpRaw = readIfExists(abs(".mcp.json"));
@@ -20698,6 +22369,7 @@ function parseLocalWatchArgs(argv) {
   let list = false;
   let stop;
   let resume;
+  let prs;
   for (let i2 = 0; i2 < argv.length; i2++) {
     const arg = argv[i2];
     const next = argv[i2 + 1];
@@ -20716,6 +22388,10 @@ function parseLocalWatchArgs(argv) {
       i2++;
     } else if (arg === "--yes" || arg === "--no-interactive") {
       yes = true;
+    } else if (arg === "--prs" || arg === "--no-prs") {
+      const want = arg === "--prs";
+      if (prs !== void 0 && prs !== want) return err("--prs and --no-prs contradict each other");
+      prs = want;
     } else if (arg === "--list") {
       list = true;
     } else if (arg === "--stop" || arg === "--resume") {
@@ -20741,7 +22417,7 @@ function parseLocalWatchArgs(argv) {
   if (list) return { kind: "list" };
   if (stop) return { kind: "stop", repo: stop };
   if (resume) return { kind: "resume", repo: resume };
-  return { kind: "register", repoPath, project, branch, yes };
+  return { kind: "register", repoPath, project, branch, yes, prs };
 }
 function printLocalWatchHelp() {
   console.log(`archme local-watch \u2014 keep ArchMe current without a GitHub App
@@ -20764,6 +22440,8 @@ Options:
   --project <org/slug>   Project to write to (default: derived from the repo name)
   --branch <name>        Branch to track (default: the repo's default branch)
   --yes                  Don't ask for confirmation (needs an explicit repo-path)
+  --prs / --no-prs       Also review pull requests (each PR push is one Claude run;
+                         a private repo needs gh auth login)
 
 Watching queues work; the daemon does it. After registering:  archme daemon start`);
 }
@@ -20803,8 +22481,8 @@ var init_localWatchDispatch = __esm({
 });
 
 // src/doctor/collect.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { join as join26 } from "node:path";
 function binaryPresent(name) {
   try {
     requireBinary(name);
@@ -20820,7 +22498,7 @@ async function git3(cwd, args) {
 async function readMcpPin(repoRoot) {
   const empty = { installed: false, pin: { project: null, branch: null } };
   try {
-    const raw = await readFile13(join24(repoRoot, ".mcp.json"), "utf8");
+    const raw = await readFile15(join26(repoRoot, ".mcp.json"), "utf8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers ?? {};
     const entry = Object.entries(servers).find(([name]) => /archme/i.test(name));
@@ -21169,7 +22847,8 @@ var init_prompt2 = __esm({
      whole team, nothing to keep running. Needs someone to grant repo read
      access.
    - **Local polling** (\`archme local-watch\`): this machine fetches the repo on
-     a timer. No GitHub App, no approvals, but no pull-request awareness.
+     a timer. No GitHub App, no approvals. Pull requests only with \`--prs\`,
+     and a private repo needs \`gh auth login\`.
 
 3. **Execution** \u2014 something has to PROCESS each detected commit. This is the
    step people miss. Detection only queues work; the queue does nothing on its
@@ -21193,9 +22872,9 @@ __export(dispatch_exports6, {
   parseDoctorArgs: () => parseDoctorArgs,
   printDoctorHelp: () => printDoctorHelp
 });
-import { mkdtemp as mkdtemp5, rm as rm9, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdtemp as mkdtemp5, rm as rm10, writeFile as writeFile13 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 function parseDoctorArgs(argv) {
   const args = { plain: false, help: false };
   for (const a2 of argv) {
@@ -21256,8 +22935,8 @@ async function dispatchDoctor(argv) {
     );
     return EX_OK6;
   }
-  const dir = await mkdtemp5(join25(tmpdir5(), "archme-doctor-"));
-  const mcpConfigPath = join25(dir, "mcp.json");
+  const dir = await mkdtemp5(join27(tmpdir5(), "archme-doctor-"));
+  const mcpConfigPath = join27(dir, "mcp.json");
   await writeFile13(mcpConfigPath, JSON.stringify({ mcpServers: {} }), { mode: 384 });
   try {
     const result = await spawnClaude({
@@ -21272,7 +22951,7 @@ async function dispatchDoctor(argv) {
     });
     return result.exitCode === 0 ? EX_OK6 : EX_INFRA5;
   } finally {
-    await rm9(dir, { recursive: true, force: true });
+    await rm10(dir, { recursive: true, force: true });
   }
 }
 var EX_OK6, EX_INFRA5, EX_USAGE6;
@@ -21314,6 +22993,7 @@ async function runLogout(args) {
   if (!target || args.includes("--all")) {
     await clearCredentials(url);
     console.log("Logged out: removed all stored identities.");
+    await mentionKeptKeys(url);
     return 0;
   }
   const all = (await loadAllCredentials(url)).credentials;
@@ -21324,24 +23004,36 @@ async function runLogout(args) {
   }
   for (const c3 of matches) await clearCredential(url, c3.device_id);
   console.log(`Logged out: removed ${matches.length} device(s) for "${target}".`);
+  await mentionKeptKeys(url);
   return 0;
 }
+async function mentionKeptKeys(url) {
+  const keys = await listKeys(url).catch(() => []);
+  if (keys.length === 0) return;
+  console.log(
+    `Saved keys are kept (${keys.map((k) => k.handle).join(", ")}): \`archme login --key\` signs back in, \`archme key list\` shows them.`
+  );
+}
 var init_logout = __esm({
   "src/auth/logout.ts"() {
     "use strict";
     init_defaults();
     init_credentials();
+    init_keyRing();
   }
 });
 
 // src/cli.ts
 init_enroll();
+init_keyRing();
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "daemon",
   "analyze",
   "login",
   "logout",
   "keys",
+  "key",
+  "open",
   "scan",
   "init",
   "uninstall",
@@ -21428,9 +23120,32 @@ async function main(argv) {
       console.log(v);
       return 0;
     }
-    case "login":
-      await runLogin();
+    case "login": {
+      const parsed = parseLoginArgs(r.args);
+      if (!parsed.ok) {
+        console.error(`archme login: ${parsed.error}
+Usage: archme login [--no-account | --github | --key]  (--key reads ARCHME_KEY, a saved key, or a prompt; ARCHME_KEY alone implies --key)`);
+        return 2;
+      }
+      try {
+        await runLogin(parsed.opts);
+      } catch (err2) {
+        if (err2 instanceof LoginError || err2 instanceof KeyRingUnreadableError) {
+          console.error(`archme login: ${err2.message}`);
+          return 1;
+        }
+        throw err2;
+      }
       return 0;
+    }
+    case "open": {
+      const { dispatchOpen: dispatchOpen2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+      return await dispatchOpen2(r.args);
+    }
+    case "key": {
+      const { dispatchKey: dispatchKey2 } = await Promise.resolve().then(() => (init_key(), key_exports));
+      return await dispatchKey2(r.args);
+    }
     case "analyze": {
       const { dispatchAnalyze: dispatchAnalyze2 } = await Promise.resolve().then(() => (init_dispatch(), dispatch_exports));
       return await dispatchAnalyze2(r.args);
@@ -21482,7 +23197,13 @@ Other commands:
   archme uninstall [repo-path]        Stop ArchitectMe for a repo: config,
                                       watching, and the daemon if it's now idle
   archme doctor                       Check this machine's setup and explain it
-  archme login | logout               Authenticate with archme
+  archme login [--no-account|--github|--key]
+                                      Sign in (or continue without an account);
+                                      --key reads ARCHME_KEY, a saved key, or a
+                                      prompt (ARCHME_KEY alone implies --key)
+  archme logout                       Sign out here (saved keys are kept)
+  archme open [--print]               Open your board in the browser, signed in
+  archme key [list|show|forget]       Account keys saved on this machine
   archme keys list|create|revoke      Manage MCP API keys
   archme --version                    Print the installed version