@archme/cli 0.16.0 → 0.17.1

package/dist/cli.js

@@ -8649,11 +8649,11 @@ 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() };
+  const saved2 = { ...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;
+    const others = (await readEntries()).filter((k) => !isFor(k, supabaseUrl, saved2.user_id));
+    await writeEntries([...others, { ...saved2, supabase_url: supabaseUrl }]);
+    return saved2;
   });
 }
 async function forgetKey(supabaseUrl, userId) {
@@ -9316,10 +9316,10 @@ async function mintKeyedAccount(deps) {
   if (res.status !== 200 || !parsed || !data.user_id) {
     throw new LoginError(`Could not create an account (${res.status}): ${redactKey(res.data)}`);
   }
-  let saved = false;
+  let saved2 = false;
   try {
     await deps.saveKey(deps.supabaseUrl, { user_id: data.user_id, key: data.key, handle: parsed.handle });
-    saved = true;
+    saved2 = true;
   } catch (err4) {
     deps.log(`! Created ${parsed.handle}, but its key could not be written to ${deps.keyRingPath}: ${err4 instanceof Error ? err4.message : String(err4)}`);
     deps.log("  It is the only way back into this account. Save this now (a password manager is a good place):");
@@ -9331,7 +9331,7 @@ async function mintKeyedAccount(deps) {
   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}.`)
+      `Created ${parsed.handle}${saved2 ? " and saved its key" : ""}, but signing in failed: ${grant.error}. ` + (saved2 ? "Run `archme login --key` to try again." : `Try again with the key printed above: ${KEY_VIA_ENV}.`)
     );
   }
   try {
@@ -9339,11 +9339,11 @@ async function mintKeyedAccount(deps) {
   } catch (err4) {
     if (!(err4 instanceof CredentialStoreError)) throw err4;
     throw new LoginError(
-      `${err4.message} Your account ${parsed.handle} was created${saved ? " and its key saved" : ""}; once that's fixed, sign in with it: ${saved ? "`archme login --key`" : KEY_VIA_ENV}.`
+      `${err4.message} Your account ${parsed.handle} was created${saved2 ? " and its key saved" : ""}; once that's fixed, sign in with it: ${saved2 ? "`archme login --key`" : KEY_VIA_ENV}.`
     );
   }
   deps.log(`\u2713 Created your ArchMe account ${parsed.handle} \u2014 no email or password, just a key.`);
-  if (saved) {
+  if (saved2) {
     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.");
   }
@@ -10692,7 +10692,7 @@ __export(install_exports, {
 import { isatty } from "node:tty";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { dirname as dirname6, join as join5 } from "node:path";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir5 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 function bakedSystemdEnv(unit) {
   const out = {};
@@ -10771,12 +10771,16 @@ Starting the installed service anyway; it reads its own sign-in when it boots.`)
     }
   }
 }
+async function ensurePrivateDir(dir) {
+  await mkdir5(dir, { recursive: true, mode: 448 });
+  await chmod3(dir, 448);
+}
 async function runStartFlow(opts = {}) {
   const platform3 = opts.platform ?? process.platform;
   const env = opts.env ?? process.env;
   await ensureStartPrerequisites(opts);
   const logPaths = resolveLogPath(platform3, env);
-  await mkdir5(resolveLogDir(platform3, env), { recursive: true });
+  await ensurePrivateDir(resolveLogDir(platform3, env));
   const controller = opts.controller ?? pickController(platform3, env);
   const installed = await controller.readUnitContent();
   const unitEnv2 = installed === null ? {} : platform3 === "darwin" ? bakedUnitEnv(installed) : bakedSystemdEnv(installed);
@@ -13691,6 +13695,89 @@ var init_repoContainer = __esm({
   }
 });
 
+// ../shared/seedArchitecture.ts
+function seedArchitectureFromRows(rows) {
+  const components = [];
+  const stories = [];
+  for (const row of rows) {
+    const compPath = componentPathFromFilePath(row.path);
+    if (compPath !== null) {
+      const parsed = tryParse(row.content);
+      components.push({
+        path: compPath,
+        anchors: parsed?.anchors ?? [],
+        unanchored: parsed?.unanchored === true ? true : void 0
+      });
+      continue;
+    }
+    const scope = storyScopeFromFilePath(row.path);
+    if (scope !== null) {
+      const parsed = tryParse(row.content);
+      if (!parsed) continue;
+      collectSeedStories(parsed, scope, row.path, stories);
+    }
+  }
+  return { components, stories };
+}
+function tryParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+function componentPathFromFilePath(p) {
+  if (!p.endsWith("/component.json")) return null;
+  const inner = p.slice(0, -"/component.json".length);
+  if (inner.length === 0) return null;
+  const segments = inner.split("/");
+  if (segments.length % 2 !== 0) return null;
+  const ids = [];
+  for (let i2 = 0; i2 < segments.length; i2 += 2) {
+    if (segments[i2] !== "components") return null;
+    const id = segments[i2 + 1];
+    if (!id) return null;
+    ids.push(id);
+  }
+  return `root.${ids.join(".")}`;
+}
+function storyScopeFromFilePath(p) {
+  if (!STORY_PATH_RE.test(p)) return null;
+  const prefix = p.slice(0, p.lastIndexOf("stories/"));
+  if (prefix.length === 0) return [];
+  const segments = prefix.split("/").filter(Boolean);
+  const ids = [];
+  for (let i2 = 0; i2 < segments.length; i2 += 2) {
+    if (segments[i2] !== "components") return null;
+    const id = segments[i2 + 1];
+    if (!id) return null;
+    ids.push(id);
+  }
+  return ids;
+}
+function collectSeedStories(raw, scope, fileFallbackId, out, parentId) {
+  const id = raw.id ?? fileFallbackId;
+  out.push({
+    id,
+    title: raw.title ?? id,
+    sequence: raw.sequence ?? "",
+    draft: raw.draft === true ? true : void 0,
+    scope,
+    parentId
+  });
+  if (Array.isArray(raw.userStories)) {
+    for (const child of raw.userStories) {
+      collectSeedStories(child, scope, fileFallbackId, out, id);
+    }
+  }
+}
+var STORY_PATH_RE;
+var init_seedArchitecture = __esm({
+  "../shared/seedArchitecture.ts"() {
+    STORY_PATH_RE = /^(?:components\/[^/]+\/)*stories\/[^/]+\.json$/;
+  }
+});
+
 // src/scan/affected.ts
 function normalizePath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "");
@@ -13904,42 +13991,6 @@ function formatAffectedSeed(result, removedSymbols = [], allStories) {
   }
   return lines.join("\n");
 }
-function tryParse(s) {
-  try {
-    return JSON.parse(s);
-  } catch {
-    return null;
-  }
-}
-function componentPathFromFilePath(p) {
-  if (!p.endsWith("/component.json")) return null;
-  const inner = p.slice(0, -"/component.json".length);
-  if (inner.length === 0) return null;
-  const segments = inner.split("/");
-  if (segments.length % 2 !== 0) return null;
-  const ids = [];
-  for (let i2 = 0; i2 < segments.length; i2 += 2) {
-    if (segments[i2] !== "components") return null;
-    const id = segments[i2 + 1];
-    if (!id) return null;
-    ids.push(id);
-  }
-  return `root.${ids.join(".")}`;
-}
-function storyScopeFromFilePath(p) {
-  if (!STORY_PATH_RE.test(p)) return null;
-  const prefix = p.slice(0, p.lastIndexOf("stories/"));
-  if (prefix.length === 0) return [];
-  const segments = prefix.split("/").filter(Boolean);
-  const ids = [];
-  for (let i2 = 0; i2 < segments.length; i2 += 2) {
-    if (segments[i2] !== "components") return null;
-    const id = segments[i2 + 1];
-    if (!id) return null;
-    ids.push(id);
-  }
-  return ids;
-}
 async function loadArchitectureForSeeding(supabase, projectId, branch) {
   const PAGE_SIZE2 = 1e3;
   const rows = [];
@@ -13950,54 +14001,18 @@ async function loadArchitectureForSeeding(supabase, projectId, branch) {
     rows.push(...data);
     if (data.length < PAGE_SIZE2) break;
   }
-  const components = [];
-  const stories = [];
-  for (const row of rows) {
-    const compPath = componentPathFromFilePath(row.path);
-    if (compPath !== null) {
-      const parsed = tryParse(row.content);
-      components.push({
-        path: compPath,
-        anchors: parsed?.anchors ?? [],
-        unanchored: parsed?.unanchored === true ? true : void 0
-      });
-      continue;
-    }
-    const scope = storyScopeFromFilePath(row.path);
-    if (scope !== null) {
-      const parsed = tryParse(row.content);
-      if (!parsed) continue;
-      collectSeedStories(parsed, scope, row.path, stories);
-    }
-  }
-  return { components, stories };
+  return seedArchitectureFromRows(rows);
 }
-function collectSeedStories(raw, scope, fileFallbackId, out, parentId) {
-  const id = raw.id ?? fileFallbackId;
-  out.push({
-    id,
-    title: raw.title ?? id,
-    sequence: raw.sequence ?? "",
-    draft: raw.draft === true ? true : void 0,
-    scope,
-    parentId
-  });
-  if (Array.isArray(raw.userStories)) {
-    for (const child of raw.userStories) {
-      collectSeedStories(child, scope, fileFallbackId, out, id);
-    }
-  }
-}
-var MESSAGE_RE, PARTICIPANT_RE, DISPLAY_FILE_CAP, STORY_PATH_RE;
+var MESSAGE_RE, PARTICIPANT_RE, DISPLAY_FILE_CAP;
 var init_affected = __esm({
   "src/scan/affected.ts"() {
     "use strict";
     init_esm3();
     init_repoContainer();
+    init_seedArchitecture();
     MESSAGE_RE = /^\s*(\{[^}]+\}|\S+?)\s*(--?>>|--?>|->|-->|-x|-\))\s*(\{[^}]+\}|\S+?)\s*:\s*(.*)$/;
     PARTICIPANT_RE = /^\s*participant\s+(\S+?)(?:\s+as\s+.+)?$/;
     DISPLAY_FILE_CAP = 200;
-    STORY_PATH_RE = /^(?:components\/[^/]+\/)*stories\/[^/]+\.json$/;
   }
 });
 
@@ -16251,10 +16266,11 @@ function buildBugReportGuidance(bugsFolderId) {
 
 ${folderMechanic}`;
 }
-var BUGS_FOLDER_TITLE, BUG_REPORT_CORE;
+var BUGS_FOLDER_TITLE, BUGS_FOLDER_DESCRIPTION, BUG_REPORT_CORE;
 var init_bugReport = __esm({
   "../shared/bugReport.ts"() {
     BUGS_FOLDER_TITLE = "Bugs found by ArchMe";
+    BUGS_FOLDER_DESCRIPTION = "Bugs noticed by scan/diff agents in the code while updating the architecture. Prose-only proposals; humans triage.";
     BUG_REPORT_CORE = "**Bugs you happen to notice.** Don't hunt for bugs \u2014 stay on the architecture task \u2014 but don't ignore an obvious, real one that surfaces while you read the code (a null-deref, a missing `await`, an unhandled error path, a broken invariant). Have any sub-agents you dispatch report a suspect back to you (a one-line `possible bug: <what> at <file:line>`) rather than filing it themselves. When suspects come back, dispatch ONE bug-validation sub-agent \u2014 it reads code and calls `create_proposal`, exactly like the build sub-agent, and never modifies the user's code \u2014 and have it: verify each suspect against the code, and for every one it confirms as a real defect, FILE it itself as a prose-only proposal (`create_proposal` with `kind: 'proposal'`, `stage: 'backlog'`, an empty graph delta, and a one-paragraph `body`: what is wrong, where by file:line or symbol, and why), `about` the component it lives in (`{ component: '<root.\u2026 path>' }` \u2014 find_components_for_paths maps the file to it), else the user story whose flow it breaks (`{ story: '<id>' }`). It skips anything it can't confirm, and searches the folder by title first to skip anything already logged. Keep the bar high \u2014 obvious, confirmed defects only, a few per run at most, never speculation, style, or a design opinion; record, never fix. Logging a bug is orthogonal to your architecture task and does NOT replace your completion signal \u2014 still call `update_architecture` or `report_no_change` exactly as you otherwise would.";
   }
 });
@@ -16685,7 +16701,11 @@ var init_validationCodes = __esm({
       WALKTHROUGH_COVERAGE_CHAPTER_NOT_COVERED: "walkthrough.coverage.chapter-not-covered",
       /** The delta added, removed or modified a component no step names. */
       WALKTHROUGH_COVERAGE_COMPONENT_NOT_COVERED: "walkthrough.coverage.component-not-covered",
-      /** The delta changed a connection no step names, joins, or draws. */
+      /**
+       * The delta changed a connection no step names, joins, or draws.
+       * @deprecated Retired: connections show up through the stories that draw
+       * them, so coverage no longer requires them.
+       */
       WALKTHROUGH_COVERAGE_CONNECTION_NOT_COVERED: "walkthrough.coverage.connection-not-covered",
       // ──────────────────────────────────────────────────────────────────────────
       // mcp — request-level rules applied before any tool handler runs
@@ -16742,7 +16762,7 @@ var init_walkthroughGuidance = __esm({
     init_walkthrough();
     WALKTHROUGH_GUIDANCE = `A walkthrough breaks a change into bite-sized chunks a reviewer can step through. Each step names the elements it is about; the review surface filters the sequence diagram and the component graph down to just those, so the reader sees one chunk at a time instead of a forty-element diff at once.
 
-- **Every step must name what it is about** \u2014 the stories, chapters, components and/or connections it covers. A step with only prose is rejected: there is nothing to filter the diagrams by, and an explanation a reader cannot check against the change is exactly what this view exists to avoid.
+- **Every step must name what it is about** \u2014 the stories, chapters, components and/or connections it covers. A step with only prose is rejected: there is nothing to filter the diagrams by, and an explanation a reader cannot check against the change is exactly what this view exists to avoid. Name a connection inside a component as \`<component path>::<id>\` (\`daemon::session_auth->key_account\`); a root connection by its plain id.
 - **Steps are in reading order, not build order.** This is not an implementation plan and not a restatement of your sequencing section \u2014 start where a reviewer should start, and put each step where it makes the next one make sense.
 - **Group by idea.** One step is one coherent change, usually 3\u20138 elements. A one-element step is fine and often valuable: an independent fix that would otherwise be lost among the rest. Aim for a handful of steps; the cap is ${MAX_WALKTHROUGH_STEPS}.
 - **Titles are terse** \u2014 a handle, not a summary. Under ${MAX_STEP_TITLE_CHARS} characters. \`Markers move per-repo\`, not \`This step explains how the source marker moves onto a per-repo table\`.
@@ -16754,7 +16774,7 @@ var init_walkthroughGuidance = __esm({
   - Don't use the change's OWN new vocabulary undefined. If the step introduces a term, say what it means in the same breath or use plain words.
   - Bad: \`A correctness item, not a phase-3 nicety: anchors are repo-relative paths, so two repos with the same conventional layout collide silently and seed stories from the wrong one.\`
   - Good: \`With two repos in one project a path like src/index.ts exists in both, so looking up which component owns a changed file can return the wrong repo's. Each repo now records the container its code lives under, and lookups search only that subtree.\`
-- **Cover every change** \u2014 every story, component and connection the change touches \u2014 or \`set_walkthrough\` rejects the walkthrough and lists what is missing. Guided mode walks the steps and nothing after them, so anything no step reaches is a change the reviewer never sees. A connection is covered when a step names it, names both of its components, or names a story page that draws it as an arrow. Name a connection inside a component as \`<component path>::<id>\` (\`daemon::session_auth->key_account\`); a root connection by its plain id.
+- **Cover every change** \u2014 every story and component the change touches \u2014 or \`set_walkthrough\` rejects the walkthrough and lists what is missing. Guided mode walks the steps and nothing after them, so anything no step reaches is a change the reviewer never sees. Connections need no step of their own: they show up through the stories that draw them.
 - **Skip it for a small change.** A handful of elements needs no walkthrough; omit it rather than writing a step per element.
 - **Prefer CHAPTERS to narrow a diagram.** If a story's sequence carries \`%% chapter: <id> | <Label>\` markers, name the ones your step covers as \`chapters: [{ story, chapter }]\`, using the **id**, never the label \u2014 ids are stable across a rename, labels are not. A chapter is a page break the story's author already wrote, so it is sharper than naming components, where one hub the step mentions decides the whole view.`;
   }
@@ -16865,12 +16885,11 @@ async function ensureBugsFolder(client, projectId) {
     return null;
   }
 }
-var BUGS_FOLDER_DESCRIPTION, cache;
+var cache;
 var init_bugsFolder = __esm({
   "src/daemon/bugsFolder.ts"() {
     "use strict";
     init_bugReport();
-    BUGS_FOLDER_DESCRIPTION = "Bugs noticed by scan/diff agents in the code while updating the architecture. Prose-only proposals; humans triage.";
     cache = /* @__PURE__ */ new Map();
   }
 });
@@ -17406,9 +17425,9 @@ var init_sessionAuth = __esm({
           this.userId = resolveUserId(userInfo2, ctx.fallbackUserId);
           this.lastUserInfo = userInfo2;
         }
-        let saved = null;
+        let saved2 = null;
         try {
-          saved = await saveCredentials({
+          saved2 = await saveCredentials({
             kind: this.kind,
             refresh_token: nextRefreshToken,
             access_token: this.accessToken,
@@ -17423,7 +17442,7 @@ var init_sessionAuth = __esm({
             `auth: ${err4.message} The refreshed sign-in was NOT saved: this process keeps working, but the saved one is now out of date. If this process ends before a later refresh saves it, sign in again then. ${this.reloginHint()}`
           );
         }
-        return { userInfo: userInfo2, saved, nextRefreshToken };
+        return { userInfo: userInfo2, saved: saved2, nextRefreshToken };
       }
       // The timer closure reads the LIVE this.refreshToken/deviceId/orgId at fire
       // time (via runScheduledRefresh), never a captured value, so an out-of-band
@@ -17524,13 +17543,13 @@ var init_sessionAuth = __esm({
             }
             throw new LoadStoredAndRefreshError("transient", `${errorPrefix} failed: ${refreshed.error}`);
           }
-          const { saved } = await this.applyRefreshedTokens(refreshed, {
+          const { saved: saved2 } = await this.applyRefreshedTokens(refreshed, {
             prevRefreshToken: refreshToken,
             deviceId,
             orgId,
             fallbackUserId: this.userId ?? void 0
           });
-          if (saved) console.log(`auth: persisted refreshed token to ${describeCredentialSource(saved)}`);
+          if (saved2) console.log(`auth: persisted refreshed token to ${describeCredentialSource(saved2)}`);
         })();
         this.refreshInFlight = p;
         return p.finally(() => {
@@ -17563,13 +17582,13 @@ var init_sessionAuth = __esm({
       // 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;
+        let saved2;
         try {
-          saved = userId ? await findKey(this.cfg.supabaseUrl, userId) : null;
+          saved2 = userId ? await findKey(this.cfg.supabaseUrl, userId) : null;
         } catch (err4) {
           return { ok: false, permanent: false, error: `${refreshError}; ${err4 instanceof Error ? err4.message : String(err4)}` };
         }
-        const parsed = parseAccountKey(saved?.key);
+        const parsed = parseAccountKey(saved2?.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);
@@ -17902,7 +17921,10 @@ function rateLimitPauseUntil(text, nowMs = Date.now(), defaultTimeZone = localTi
   if (!info) return null;
   return {
     info,
-    pauseUntil: new Date(info.resetAt.getTime() + RATE_LIMIT_PAUSE_PADDING_MS)
+    // The reset is text the run reported (a box can forge it, and a dated one a
+    // week past rolls a year forward), and the pause stalls the whole account:
+    // never longer than a day. A job still limited then just defers again.
+    pauseUntil: new Date(Math.min(info.resetAt.getTime() + RATE_LIMIT_PAUSE_PADDING_MS, nowMs + RATE_LIMIT_MAX_PAUSE_MS))
   };
 }
 function looksLikeRateLimit(text) {
@@ -17943,7 +17965,7 @@ function claudeErrorDeferPlan(error, nowMs, defaultTimeZone) {
   }
   return null;
 }
-var RATE_LIMIT_RE, MONTHS, RATE_LIMIT_TENTATIVE_PAUSE_MS, DATED_RESET_ROLLOVER_GRACE_MS, RATE_LIMIT_PAUSE_PADDING_MS, RATE_LIMIT_SHAPED_RE;
+var RATE_LIMIT_RE, MONTHS, RATE_LIMIT_TENTATIVE_PAUSE_MS, DATED_RESET_ROLLOVER_GRACE_MS, RATE_LIMIT_PAUSE_PADDING_MS, RATE_LIMIT_MAX_PAUSE_MS, RATE_LIMIT_SHAPED_RE;
 var init_rateLimit = __esm({
   "src/daemon/rateLimit.ts"() {
     "use strict";
@@ -17965,6 +17987,7 @@ var init_rateLimit = __esm({
     RATE_LIMIT_TENTATIVE_PAUSE_MS = 60 * 60 * 1e3;
     DATED_RESET_ROLLOVER_GRACE_MS = 7 * 24 * 60 * 60 * 1e3;
     RATE_LIMIT_PAUSE_PADDING_MS = 9e4;
+    RATE_LIMIT_MAX_PAUSE_MS = 24 * 60 * 60 * 1e3;
     RATE_LIMIT_SHAPED_RE = /(\brate[ -]?limit\b|\blimit\b.{0,40}\bresets?\b|\bresets?\b.{0,40}\blimit\b|\b429\b|\bquota\b|\busage[ -]?limit\b)/i;
   }
 });
@@ -18298,7 +18321,7 @@ var init_localPrPoll = __esm({
 });
 
 // src/daemon/localRepos.ts
-import { chmod as chmod3, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { chmod as chmod4, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { dirname as dirname12, join as join19 } from "node:path";
 function localReposPath(env = process.env) {
@@ -18401,7 +18424,7 @@ async function saveLocalRepos(repos, env = process.env) {
   const path7 = localReposPath(env);
   await mkdir9(dirname12(path7), { recursive: true, mode: 448 });
   await writeFile9(path7, serializeLocalRepos(repos), { mode: 384 });
-  await chmod3(path7, 384).catch(() => {
+  await chmod4(path7, 384).catch(() => {
   });
 }
 async function registerLocalRepo(entry, env = process.env) {
@@ -18634,6 +18657,21 @@ var init_defaultBranch = __esm({
   }
 });
 
+// src/daemon/sshAgent.ts
+function detachSshAgent(env = process.env) {
+  if (env.SSH_AUTH_SOCK !== void 0) saved = env.SSH_AUTH_SOCK;
+  delete env.SSH_AUTH_SOCK;
+}
+function localGitEnv() {
+  return saved === void 0 ? process.env : { ...process.env, SSH_AUTH_SOCK: saved };
+}
+var saved;
+var init_sshAgent = __esm({
+  "src/daemon/sshAgent.ts"() {
+    "use strict";
+  }
+});
+
 // ../shared/prRefs.ts
 function parsePrRefs(message2) {
   if (!message2) return [];
@@ -18686,7 +18724,8 @@ async function git(dir, args, opts = {}) {
   requireBinary("git");
   const res = await execa("git", args, {
     cwd: dir ?? void 0,
-    env: opts.env,
+    // The SSH agent the daemon detached at boot (sshAgent.ts): origin may be ssh.
+    env: { ...localGitEnv(), ...opts.env },
     reject: false,
     timeout: GIT_TIMEOUT_MS,
     // Kill the whole process group: a hung `git fetch` has spawned helper
@@ -18792,6 +18831,7 @@ var init_localGit = __esm({
     init_execa();
     init_preflight();
     init_defaultBranch();
+    init_sshAgent();
     init_prRefs();
     GIT_TIMEOUT_MS = 10 * 60 * 1e3;
   }
@@ -19496,7 +19536,7 @@ var init_setting = __esm({
   }
 });
 
-// src/scan/architectureCounts.ts
+// ../shared/architectureCounts.ts
 function countFromPaths(paths) {
   let components = 0;
   let stories = 0;
@@ -19510,6 +19550,12 @@ function countFromPaths(paths) {
   }
   return { components, stories, rootStories };
 }
+var init_architectureCounts = __esm({
+  "../shared/architectureCounts.ts"() {
+  }
+});
+
+// src/scan/architectureCounts.ts
 async function countArchitecture(supabase, projectId, branch) {
   const PAGE_SIZE2 = 1e3;
   const paths = [];
@@ -19529,9 +19575,10 @@ function firstScanGate(counts) {
     reason: `first scan incomplete: the branch holds ${counts.components} component(s) and ${counts.rootStories} root story(ies); needs at least one of each`
   };
 }
-var init_architectureCounts = __esm({
+var init_architectureCounts2 = __esm({
   "src/scan/architectureCounts.ts"() {
     "use strict";
+    init_architectureCounts();
   }
 });
 
@@ -19646,6 +19693,103 @@ var init_platformDevices = __esm({
   }
 });
 
+// src/daemon/jobReads.ts
+async function lookupProjectSlug(client, projectId) {
+  const { data, error } = await client.from("projects").select("slug, organizations(slug)").eq("id", projectId).single();
+  if (error || !data) throw new Error(`Project ${projectId} not found: ${error?.message}`);
+  const orgSlug = data.organizations?.slug;
+  if (!orgSlug) throw new Error(`Project ${projectId} has no org slug`);
+  return `${orgSlug}/${data.slug}`;
+}
+async function detectWritesByPhase(client, projectId, archmeBranch, jobId) {
+  const { data, error } = await client.from("commits").select("structural_changeset").eq("project_id", projectId).eq("branch", archmeBranch).eq("metadata->source->>job_id", jobId);
+  if (error) {
+    console.error("commits lookup error:", error.message);
+    return { total: 0, diffWrites: 0, structuralWrites: 0 };
+  }
+  let diffWrites = 0;
+  let structuralWrites = 0;
+  for (const row of data ?? []) {
+    if (row.structural_changeset == null) diffWrites++;
+    else structuralWrites++;
+  }
+  return { total: diffWrites + structuralWrites, diffWrites, structuralWrites };
+}
+async function detectMcpActivity(client, jobId) {
+  const { data, error } = await client.from("archme_jobs").select("meaningful_tool_calls, no_change_reason").eq("id", jobId).maybeSingle();
+  if (error) {
+    console.error("mcp_activity lookup error:", error.message);
+    return { reads: void 0, noChange: false };
+  }
+  if (!data) return { reads: void 0, noChange: false };
+  const row = data;
+  return { reads: row.meaningful_tool_calls, noChange: row.no_change_reason != null };
+}
+function sessionJobReads(client, job) {
+  return {
+    projectSlug: () => lookupProjectSlug(client, job.project_id),
+    marker: (repo) => readBranchMarker(client, job.project_id, job.archme_branch, repo),
+    repoMappings: (log) => loadRepoMappings(client, job.project_id, log),
+    seedArchitecture: () => loadArchitectureForSeeding(client, job.project_id, job.archme_branch),
+    bugsFolderId: () => ensureBugsFolder(client, job.project_id),
+    writesByPhase: () => detectWritesByPhase(client, job.project_id, job.archme_branch, job.id),
+    mcpActivity: () => detectMcpActivity(client, job.id),
+    architectureCounts: () => countArchitecture(client, job.project_id, job.archme_branch)
+  };
+}
+function hostedJobReads(post) {
+  let prefetch = null;
+  let outcome = null;
+  const pre = () => prefetch ??= post("prefetch");
+  const out = () => outcome ??= post("outcome");
+  return {
+    projectSlug: async () => {
+      const slug = (await pre()).project_slug;
+      if (typeof slug !== "string") throw new Error("job-context returned no project slug");
+      return slug;
+    },
+    marker: async () => (await pre()).marker,
+    repoMappings: async (log) => {
+      const mappings = (await pre()).repo_mappings;
+      if (mappings === null) log("repo mappings unreadable (proceeding without repo scoping)");
+      return mappings;
+    },
+    seedArchitecture: async () => {
+      const p = await pre();
+      if (!p.seed_architecture) throw new Error(p.seed_error ?? "seed architecture unavailable");
+      return p.seed_architecture;
+    },
+    bugsFolderId: async () => (await pre()).bugs_folder_id,
+    // Fails closed, unlike the session readers: a platform job has no session read to fall back on.
+    writesByPhase: async () => {
+      const { total, diff, structural } = (await out()).writes;
+      return { total, diffWrites: diff, structuralWrites: structural };
+    },
+    mcpActivity: async () => {
+      const { reads, no_change } = (await out()).mcp;
+      return { reads: reads ?? void 0, noChange: no_change };
+    },
+    architectureCounts: async () => {
+      const counts = (await out()).architecture_counts;
+      if (!counts) throw new Error("job-context returned no architecture counts");
+      return counts;
+    }
+  };
+}
+function jobReadsFor(deps, job) {
+  return deps.isPlatformDevice ? hostedJobReads(deps.post) : sessionJobReads(deps.client, job);
+}
+var init_jobReads = __esm({
+  "src/daemon/jobReads.ts"() {
+    "use strict";
+    init_architectureCounts2();
+    init_affected();
+    init_bugsFolder();
+    init_branchMarker();
+    init_repoMappings();
+  }
+});
+
 // src/daemon/sandboxJob/result.ts
 import { readFile as readFile13 } from "node:fs/promises";
 function isValidNonce(nonce) {
@@ -19773,7 +19917,7 @@ var init_result2 = __esm({
 });
 
 // src/daemon/sandbox/inputDir.ts
-import { mkdtemp as mkdtemp3, readdir as readdir2, rm as rm7, writeFile as writeFile10, chmod as chmod4 } from "node:fs/promises";
+import { mkdtemp as mkdtemp3, readdir as readdir2, rm as rm7, writeFile as writeFile10, chmod as chmod5 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join22 } from "node:path";
 async function writeInputDir(step, input, base = tmpdir3()) {
@@ -19781,7 +19925,7 @@ async function writeInputDir(step, input, base = tmpdir3()) {
   const cleanup = () => rm7(dir, { recursive: true, force: true }).catch(() => {
   });
   try {
-    await chmod4(dir, 448);
+    await chmod5(dir, 448);
     await writeFile10(join22(dir, "input.json"), JSON.stringify(input), { mode: 384, flag: "wx" });
   } catch (e) {
     await cleanup();
@@ -19993,7 +20137,7 @@ var init_confinement = __esm({
 
 // src/daemon/sandbox/claudeToken.ts
 import { constants as fsConstants } from "node:fs";
-import { chmod as chmod5, mkdir as mkdir11, open as open3 } from "node:fs/promises";
+import { chmod as chmod6, mkdir as mkdir11, open as open3 } from "node:fs/promises";
 import { dirname as dirname15 } from "node:path";
 function assertTokenShape(raw, where) {
   const token = raw.trim();
@@ -20066,7 +20210,7 @@ async function storeSandboxClaudeToken(raw, opts) {
   } finally {
     await fh.close();
   }
-  await chmod5(opts.path, 384);
+  await chmod6(opts.path, 384);
   return { source: "file", note };
 }
 async function checkClaudeToken(token, fetchFn = fetch) {
@@ -20492,24 +20636,28 @@ var init_runSandboxedJob = __esm({
 
 // src/daemon/sandbox/classifySandboxExit.ts
 function classifySandboxExit(input) {
-  const { counters, exitCode, stderr, stepFailure } = input;
-  if ((counters?.cap_hits ?? 0) > 0 || stderr.includes(SANDBOX_CAP_BODY)) {
+  const { counters, exitCode, stepFailure, claudeIsError } = input;
+  if ((counters?.cap_hits ?? 0) > 0) {
     return {
       kind: "terminal",
       reason: SANDBOX_REQUEST_CAP_REASON,
       message: `${SANDBOX_REQUEST_CAP_REASON}: the job exceeded the sandbox model-request cap` + (counters ? ` (${counters.model_requests} requests, ${counters.cap_hits} refused)` : "")
     };
   }
-  if (stepFailure == null && exitCode !== null && exitCode !== 0 && counters?.last_upstream_status === 429) {
-    return { kind: "upstream_rate_limit" };
+  if (stepFailure == null && exitCode !== null && (exitCode !== 0 || claudeIsError === true)) {
+    const status = counters?.last_upstream_status;
+    if (status === 429) return { kind: "upstream_rate_limit" };
+    if (status === 401 || status === 403) return { kind: "upstream_auth_failure" };
   }
   return { kind: "normal" };
 }
 function routeSandboxFailure(verdict, planFor, nowMs = Date.now()) {
-  if (verdict?.kind === "terminal") return { kind: "terminal", message: verdict.message };
-  const plan = planFor();
-  if (plan) return { kind: "defer", plan };
-  if (verdict?.kind === "upstream_rate_limit") {
+  if (verdict === null) {
+    const plan = planFor();
+    return plan ? { kind: "defer", plan } : { kind: "fail" };
+  }
+  if (verdict.kind === "terminal") return { kind: "terminal", message: verdict.message };
+  if (verdict.kind === "upstream_rate_limit") {
     return {
       kind: "defer",
       plan: { parsed: false, pauseUntil: new Date(nowMs + RATE_LIMIT_TENTATIVE_PAUSE_MS), info: null }
@@ -20522,7 +20670,6 @@ var init_classifySandboxExit = __esm({
   "src/daemon/sandbox/classifySandboxExit.ts"() {
     "use strict";
     init_rateLimit();
-    init_types();
     SANDBOX_REQUEST_CAP_REASON = "sandbox_request_cap";
     SandboxExitError = class extends Error {
       constructor(message2, verdict) {
@@ -22248,9 +22395,9 @@ var init_run_scan = __esm({
     init_transcript_signals();
     init_report();
     init_github_remote();
-    init_architectureCounts();
+    init_architectureCounts2();
     init_claimDefaultProject();
-    init_architectureCounts();
+    init_architectureCounts2();
     BOOTSTRAP_HEADLESS = `Run the \`scan\` MCP prompt now and follow it to completion. This is a non-interactive automated run \u2014 skip any steps that pause for user confirmation (e.g. "does this hierarchy look right?"). Proceed with your best-judgement decisions rather than waiting for human input.`;
     BOOTSTRAP_INTERACTIVE = `Run the \`scan\` MCP prompt now and follow it to completion. The user is at an interactive terminal \u2014 ask them when the prompt says to, and wait for their answer.
 
@@ -22376,15 +22523,15 @@ async function runCloneStep(input, deps = {}) {
   }
 }
 function applyEnv(env) {
-  const saved = /* @__PURE__ */ new Map();
+  const saved2 = /* @__PURE__ */ new Map();
   for (const [k, v] of Object.entries(env)) {
     if (process.env[k] === v) continue;
-    saved.set(k, process.env[k]);
+    saved2.set(k, process.env[k]);
     if (v === void 0) delete process.env[k];
     else process.env[k] = v;
   }
   return () => {
-    for (const [k, v] of saved) {
+    for (const [k, v] of saved2) {
       if (v === void 0) delete process.env[k];
       else process.env[k] = v;
     }
@@ -22528,7 +22675,9 @@ async function runAgentStep(input, deps = {}) {
     cwd: repoDir,
     timeoutMs: input.timeoutMs,
     model: input.model,
-    ...firstScan ? { allowedTools: FIRST_SCAN_ALLOWED_TOOLS } : {},
+    // Diff/PR: no Bash. `-p` mode does not bind built-ins to --allowedTools,
+    // and a build step run through Bash can forge claude's stderr (BUG-143).
+    ...firstScan ? { allowedTools: FIRST_SCAN_ALLOWED_TOOLS } : { builtinTools: ["Read", "Glob", "Grep", "Agent"] },
     jsonOutput: true,
     settingSources: "user",
     // A box is Linux: a prompt over 128 KiB cannot be one argv string.
@@ -22678,7 +22827,7 @@ __export(run_exports, {
 });
 import { createClient as createClient2 } from "@supabase/supabase-js";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdtemp as mkdtemp4, mkdir as mkdir16, writeFile as writeFile15, rm as rm8, stat as stat8, chmod as chmod6 } from "node:fs/promises";
+import { mkdtemp as mkdtemp4, mkdir as mkdir16, writeFile as writeFile15, rm as rm8, stat as stat8, chmod as chmod7 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join25 } from "node:path";
 import { homedir as homedir8, networkInterfaces as networkInterfaces2 } from "node:os";
@@ -22739,13 +22888,6 @@ async function routeShutdownInterrupt(id, cancelled2, fail2, exitCode) {
     console.error(`  shutdown retry-route failed for ${id}: ${e instanceof Error ? e.message : e}`);
   }
 }
-async function lookupProjectSlug(client, projectId) {
-  const { data, error } = await client.from("projects").select("slug, organizations(slug)").eq("id", projectId).single();
-  if (error || !data) throw new Error(`Project ${projectId} not found: ${error?.message}`);
-  const orgSlug = data.organizations?.slug;
-  if (!orgSlug) throw new Error(`Project ${projectId} has no org slug`);
-  return `${orgSlug}/${data.slug}`;
-}
 function cloneDirFor(baseDir, owner, name) {
   return join25(baseDir, owner, name);
 }
@@ -22857,7 +22999,7 @@ async function buildGitEnv(credentials) {
     ].join("\n"),
     { mode: 448 }
   );
-  await chmod6(askpassPath, 448).catch(() => {
+  await chmod7(askpassPath, 448).catch(() => {
   });
   const gitConfigEntries = [
     ["credential.helper", ""],
@@ -22891,24 +23033,24 @@ async function ensureLocalCloneAndFetch(job, entry) {
         `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 });
+    await execa("git", ["fetch", "--no-tags", "origin", job.repo_branch], { cwd: dir, env: localGitEnv(), reject: false });
     if (job.source_mode === "pr_update") {
       await verifyLocalPrJob(job, async (args) => {
-        const r = await execa("git", args, { cwd: dir, reject: false });
+        const r = await execa("git", args, { cwd: dir, env: localGitEnv(), 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 });
+    const afterCheck = await execa("git", ["cat-file", "-e", job.after_sha], { cwd: dir, env: localGitEnv(), reject: false });
     if (afterCheck.exitCode !== 0) {
-      await execa("git", ["fetch", "origin"], { cwd: dir, reject: false });
+      await execa("git", ["fetch", "origin"], { cwd: dir, env: localGitEnv(), reject: false });
     }
   }).catch((err4) => {
     if (err4 instanceof LocalPrJobRejectedError) throw err4;
     const msg = err4 instanceof Error ? err4.message : String(err4);
     throw new Error(`local repo ${job.repo_owner}/${job.repo_name} is not usable: ${msg}`);
   });
-  return { dir, gitEnv: process.env, cleanupGitEnv: async () => {
+  return { dir, gitEnv: localGitEnv(), cleanupGitEnv: async () => {
   } };
 }
 async function ensureCloneAndFetch(ctx, job, claimDeviceId) {
@@ -23221,30 +23363,6 @@ async function rpcComplete(ctx, jobId, deviceId, summary2, kind, changed, metric
 function affectedFieldForComplete(sourceMode, affected) {
   return sourceMode === "pr_update" && affected ? affected : void 0;
 }
-async function detectWritesByPhase(client, projectId, archmeBranch, jobId) {
-  const { data, error } = await client.from("commits").select("structural_changeset").eq("project_id", projectId).eq("branch", archmeBranch).eq("metadata->source->>job_id", jobId);
-  if (error) {
-    console.error("commits lookup error:", error.message);
-    return { total: 0, diffWrites: 0, structuralWrites: 0 };
-  }
-  let diffWrites = 0;
-  let structuralWrites = 0;
-  for (const row of data ?? []) {
-    if (row.structural_changeset == null) diffWrites++;
-    else structuralWrites++;
-  }
-  return { total: diffWrites + structuralWrites, diffWrites, structuralWrites };
-}
-async function detectMcpActivity(client, jobId) {
-  const { data, error } = await client.from("archme_jobs").select("meaningful_tool_calls, no_change_reason").eq("id", jobId).maybeSingle();
-  if (error) {
-    console.error("mcp_activity lookup error:", error.message);
-    return { reads: void 0, noChange: false };
-  }
-  if (!data) return { reads: void 0, noChange: false };
-  const row = data;
-  return { reads: row.meaningful_tool_calls, noChange: row.no_change_reason != null };
-}
 function setLocalPause(untilMs) {
   if (!Number.isFinite(untilMs) || untilMs <= Date.now()) return;
   if (pauseUntilMs != null && pauseUntilMs >= untilMs) return;
@@ -23518,11 +23636,36 @@ async function setupDigestMcp(ctx, job, deviceId) {
     return {};
   }
 }
+function readsFor(ctx, job, deviceId) {
+  return jobReadsFor(
+    { client: ctx.supabase, post: (part) => postJobContext(ctx, job.id, deviceId, part), isPlatformDevice: platformDevices.has(deviceId) },
+    job
+  );
+}
+async function postJobContext(ctx, jobId, deviceId, part) {
+  const response = await fetchWithAuthRetry(
+    "job-context",
+    () => {
+      const accessToken = ctx.auth.getAccessToken();
+      if (!accessToken) throw new Error("daemon is not signed in with a registered device");
+      return fetch(`${ctx.supabaseUrl.replace(/\/$/, "")}/functions/v1/agents-device/job-context`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+        body: JSON.stringify({ device_id: deviceId, job_id: jobId, part })
+      });
+    },
+    ctx.reLogin
+  );
+  const body = await parseJsonResponse(response);
+  if (!response.ok) throw new Error(`job-context ${part} failed: ${responseError(body, `status ${response.status}`)}`);
+  return body;
+}
 async function prefetchJobContext(ctx, job, deviceId, repoCredentials = getRepoCredentials) {
   const log = (msg) => console.log(`[${job.id}] ${msg}`);
   const firstScan = job.job_kind === "first_scan";
   assertLocalJobShape(firstScan ? { ...job, after_sha: job.scan_ref ?? "" } : job);
-  const projectSlug = await lookupProjectSlug(ctx.supabase, job.project_id);
+  const reads = readsFor(ctx, job, deviceId);
+  const projectSlug = await reads.projectSlug();
   const jobToken = await mintJobToken(ctx, job.id, deviceId);
   const probe = await probeMcpAuth(
     `${ctx.mcpBaseUrl}?project=${encodeURIComponent(projectSlug)}&branch=${encodeURIComponent(job.archme_branch)}`,
@@ -23533,15 +23676,15 @@ async function prefetchJobContext(ctx, job, deviceId, repoCredentials = getRepoC
       `MCP auth preflight failed after ${probe.attempts} attempt(s) (last status ${probe.lastStatus ?? "n/a"}): ${probe.detail}. Not starting the sandbox \u2014 failing the job so it retries with a freshly minted token.`
     );
   }
-  const marker = job.source_mode === "pr_update" || firstScan ? { sha: null, repo: null } : await readBranchMarker(ctx.supabase, job.project_id, job.archme_branch, `${job.repo_owner}/${job.repo_name}`);
+  const marker = job.source_mode === "pr_update" || firstScan ? { sha: null, repo: null } : await reads.marker(`${job.repo_owner}/${job.repo_name}`);
   const jobRepo = `${job.repo_owner}/${job.repo_name}`;
-  const mappings = await loadRepoMappings(ctx.supabase, job.project_id, log);
+  const mappings = await reads.repoMappings(log);
   let jobScope = jobRepoScope(mappings, jobRepo);
   if (!jobScope) log("repo mappings unreadable: proceeding unseeded");
   let seedArch = null;
   if (mappings && jobScope && !firstScan) {
     try {
-      seedArch = await loadArchitectureForSeeding(ctx.supabase, job.project_id, job.archme_branch);
+      seedArch = await reads.seedArchitecture();
       if (job.source_mode === "pr_update") {
         jobScope = forkRepoScope(mappings, jobRepo, new Set(seedArch.components.map((c3) => c3.path)));
       }
@@ -23549,7 +23692,7 @@ async function prefetchJobContext(ctx, job, deviceId, repoCredentials = getRepoC
       log(`seed architecture unavailable (the agent runs unseeded): ${e.message}`);
     }
   }
-  const bugsFolderId = await ensureBugsFolder(ctx.supabase, job.project_id);
+  const bugsFolderId = await reads.bugsFolderId();
   const model = await resolveRunnableModel(ctx.supabase, { warn: log });
   const credentials = await repoCredentials(ctx, job.id, deviceId);
   return {
@@ -23594,8 +23737,9 @@ async function completeClaudeRun(ctx, job, deviceId, run) {
     throw new ClaudeRunError(
       `claude reported is_error in its JSON result (no successful completion)`,
       runResult.summary.trim().slice(-FAILURE_DETAIL_MAX) || null,
-      isClaudeAuthFailure(claudeErrorResult(run.stdout), run.stderr),
-      claudeErrorDetails(run.stdout)
+      run.sandboxVerdict ? run.sandboxVerdict.kind === "upstream_auth_failure" : isClaudeAuthFailure(claudeErrorResult(run.stdout), run.stderr),
+      claudeErrorDetails(run.stdout),
+      run.sandboxVerdict ?? null
     );
   }
   const summary2 = runResult.summary.trim().slice(0, 4e3);
@@ -23603,8 +23747,9 @@ async function completeClaudeRun(ctx, job, deviceId, run) {
   metrics.model_served = runResult.modelServed;
   metrics.usage = runResult.usage;
   metrics.cost_usd = runResult.costUsd;
-  const { total: writes, diffWrites, structuralWrites } = await detectWritesByPhase(ctx.supabase, job.project_id, job.archme_branch, job.id);
-  const { reads, noChange } = await detectMcpActivity(ctx.supabase, job.id);
+  const jobReads = run.reads ?? readsFor(ctx, job, deviceId);
+  const { total: writes, diffWrites, structuralWrites } = await jobReads.writesByPhase();
+  const { reads, noChange } = await jobReads.mcpActivity();
   markPhase("write_detect", {
     commits: writes,
     diff_writes: diffWrites,
@@ -23860,7 +24005,12 @@ async function runJob(ctx, job, claimDeviceId) {
           await rpcRollback(ctx, job.id, deviceId);
           return;
         }
-        const verdict = classifySandboxExit({ counters: sandboxMetrics, exitCode: outcome.exitCode, stderr: outcome.stderr });
+        const verdict = classifySandboxExit({
+          counters: sandboxMetrics,
+          exitCode: outcome.exitCode,
+          stderr: outcome.stderr,
+          claudeIsError: parseClaudeResult(outcome.claudeStdout).isError
+        });
         if (verdict.kind === "terminal") throw new SandboxExitError(verdict.message, verdict);
         if (outcome.exitCode !== 0) {
           const detail = claudeFailureDetail(outcome.stderr, outcome.claudeStdout);
@@ -23868,13 +24018,24 @@ async function runJob(ctx, job, claimDeviceId) {
           throw new ClaudeRunError(
             buildClaudeExitMessage(outcome.exitCode, outcome.signal ? ` (${outcome.signal})` : "", outcome.stderr),
             detail,
-            isClaudeAuthFailure(claudeErrorResult(outcome.claudeStdout), outcome.stderr),
+            // The gate's own 401/403, never the box's text (BUG-143).
+            verdict.kind === "upstream_auth_failure",
             claudeErrorDetails(outcome.claudeStdout),
             verdict
           );
         }
+        const jobReads = readsFor(ctx, job, deviceId);
         if (firstScan) {
-          const gate = firstScanGate(await countArchitecture(ctx.supabase, job.project_id, job.archme_branch));
+          if (verdict.kind === "upstream_rate_limit" || verdict.kind === "upstream_auth_failure") {
+            throw new ClaudeRunError(
+              `claude reported is_error in its JSON result (no successful completion)`,
+              null,
+              verdict.kind === "upstream_auth_failure",
+              claudeErrorDetails(outcome.claudeStdout),
+              verdict
+            );
+          }
+          const gate = firstScanGate(await jobReads.architectureCounts());
           if (!gate.ok) throw new Error(gate.reason);
         }
         await completeClaudeRun(ctx, job, deviceId, {
@@ -23885,7 +24046,9 @@ async function runJob(ctx, job, claimDeviceId) {
           affected: outcome.affected,
           startedAt,
           markPhase,
-          log
+          log,
+          reads: jobReads,
+          sandboxVerdict: verdict
         });
         return;
       }
@@ -24155,8 +24318,9 @@ async function runJob(ctx, job, claimDeviceId) {
     const runErr = err4 instanceof ClaudeRunError ? err4 : null;
     const haystack = stripPromptEcho(`${msg}
 ${logs.stderr}`, sentPrompt);
+    const boxed = boxedJobs.has(job.id);
     const route2 = routeSandboxFailure(
-      err4 instanceof SandboxExitError ? err4.verdict : runErr?.sandboxVerdict ?? null,
+      err4 instanceof SandboxExitError ? err4.verdict : runErr?.sandboxVerdict ?? (boxed ? { kind: "normal" } : null),
       () => rateLimitDeferPlanForExit({
         message: msg,
         stderr: logs.stderr,
@@ -24173,7 +24337,7 @@ ${logs.stderr}`, sentPrompt);
     const plan = route2.kind === "defer" ? route2.plan : null;
     if (plan) {
       const { parsed, pauseUntil, info } = plan;
-      if (!parsed) {
+      if (!parsed && !boxed) {
         await rpcReportEvent(ctx, job, deviceId, "rate_limit_unmatched_exit", {
           job_id: job.id,
           excerpt: [runErr?.claudeError?.text, haystack].filter(Boolean).join("\n").slice(0, 500)
@@ -24205,8 +24369,12 @@ ${logs.stderr}`, sentPrompt);
       const notice = authFailureNotice(boxedJobs.has(job.id), runErr.detail);
       console.error(`[${job.id}] ${notice.message} Deferring job + pausing daemon until ${pauseUntil.toISOString()}.`);
       const detail = { job_id: job.id, claude_said: runErr.detail };
-      await rpcSetDaemonPause(ctx, pauseUntil, notice.reason, detail);
-      setLocalPause(pauseUntil.getTime());
+      if (job.job_kind !== "first_scan") {
+        await rpcSetDaemonPause(ctx, pauseUntil, notice.reason, detail);
+        setLocalPause(pauseUntil.getTime());
+      } else {
+        firstScanPauseUntilMs = Math.max(firstScanPauseUntilMs, pauseUntil.getTime());
+      }
       const deferred = await rpcDefer(ctx, job.id, deviceId, notice.reason, detail);
       if (deferred) return;
       console.warn(`[${job.id}] defer no-op \u2014 falling through to fail`);
@@ -24401,6 +24569,7 @@ function exitDaemon(code) {
   process.exit(resolveExitCode(code, process.env));
 }
 async function runDaemon() {
+  detachSshAgent();
   let lockHandle = null;
   try {
     lockHandle = await acquireSingleInstanceLock(resolvePidfilePath(process.env));
@@ -24766,14 +24935,16 @@ var init_run = __esm({
     init_localPrJob();
     init_localPoller();
     init_setting();
-    init_architectureCounts();
+    init_architectureCounts2();
     init_imageManifest();
     init_claimStance();
     init_platformDevices();
+    init_jobReads();
     init_claudeVersion();
     init_host();
     init_runSandboxedJob();
     init_inputDir();
+    init_sshAgent();
     init_classifySandboxExit();
     HEARTBEAT_INTERVAL_MS = 6e4;
     CLAUDE_TIMEOUT_MS = 30 * 60 * 1e3;
@@ -30597,7 +30768,7 @@ async function runConciergeToken(opts, deps) {
 async function reserveStdout(fn) {
   const stdout = process.stdout;
   const realWrite = stdout.write;
-  const saved = { log: console.log, info: console.info, debug: console.debug };
+  const saved2 = { log: console.log, info: console.info, debug: console.debug };
   const toStderr = (...args) => console.error(...args);
   console.log = toStderr;
   console.info = toStderr;
@@ -30609,9 +30780,9 @@ async function reserveStdout(fn) {
     });
   } finally {
     stdout.write = realWrite;
-    console.log = saved.log;
-    console.info = saved.info;
-    console.debug = saved.debug;
+    console.log = saved2.log;
+    console.info = saved2.info;
+    console.debug = saved2.debug;
   }
 }
 async function postConciergeTokenWith(supabaseUrl, accessToken, body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archme/cli",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Map your codebase into a living architecture diagram: run `archme init` in a repo to scan it, `archme daemon start` to keep it current on every commit.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",

package/sandbox-image.json

@@ -1,4 +1,4 @@
 {
   "image": "ghcr.io/architectme/archme-job",
-  "digest": "sha256:3f8b289540503cc18a2794fa9de858e75a4ceb2d3cf709d814cf816569c36a96"
+  "digest": "sha256:bedd452cb1fb7f0474d06296b8033b426c4a808e762ee61c9043b19d723fb43b"
 }