@@ -1766,17 +1766,24 @@ async function main(argv) {
 }
 
 function rearmThroughProxy(args) {
+  // `guard` is THIS tool's own variable (#18939). Without it the plan read the
+  // patrol's shared name straight out of `process.env`, so a sibling
+  // instrument's inherited guard answered "already re-armed" here — silently —
+  // and the un-re-armed run then bypassed the proxy and answered 401 Bad
+  // credentials, a false story about the credential. The own-guard `if` that
+  // used to sit below was never reached for that case; the plan's own branch
+  // now covers it, and PRINTS the variable through `plan.hint`.
   const plan = proxyRearmPlan({
     env: process.env,
     execArgv: process.execArgv,
     flagSupported: process.allowedNodeEnvironmentFlags.has(PROXY_FLAG),
+    guard: PROXY_REARM_GUARD,
   });
   if (plan.hint) {
     console.error(`ℹ️  ${plan.reason}. A refusal below may be about the route, not this container.`);
     return null;
   }
   if (!plan.rearm) return null;
-  if (process.env[PROXY_REARM_GUARD] === '1') return null;
   console.error(`ℹ️  re-exec with ${plan.flag}: ${plan.reason}.`);
   const quiet = process.allowedNodeEnvironmentFlags.has('--disable-warning') ? ['--disable-warning=UNDICI-EHPA'] : [];
   const child = spawnSync(process.execPath, [plan.flag, ...quiet, SELF_PATH, ...args], {
@@ -1888,6 +1895,7 @@ function measuredHistoryManifest(over = {}) {
 }
 
 const SELF_TEST_BATTERIES = Object.freeze({
+  'the re-exec guard: the name this tool sets, and the patrol name that must not silence it': 11,
   'the record shapes: fixed key order, declared absence': 9,
   'the page walk: only a short page ends it': 10,
   'the walk plan: the open board first, then the closed history, then incremental': 15,
@@ -1900,7 +1908,7 @@ const SELF_TEST_BATTERIES = Object.freeze({
   'the delta walk, driven: the archive catches up with the live board': 19,
   'the freshness row: a stale archive is never a green run': 18,
 });
-const SELF_TEST_BATTERY_FLOOR = 10;
+const SELF_TEST_BATTERY_FLOOR = 12;
 const UNATTRIBUTED_BATTERY = '(unattributed)';
 
 let selfTestReachedVerdict = false;
@@ -1945,6 +1953,31 @@ export async function selfTest() {
   });
 
   // -- the record shapes -----------------------------------------------------
+  // ── the re-exec guard (#18939) ────────────────────────────────────────────
+  // The plan reads the guard name THIS file sets, never a shared one. A sibling
+  // instrument's inherited guard used to answer 'already re-armed' here, and the
+  // un-re-armed run then bypassed the proxy and answered 401 Bad credentials —
+  // a false story about the credential, printed nowhere at all.
+  battery('the re-exec guard: the name this tool sets, and the patrol name that must not silence it');
+  {
+    const PATROL_GUARD = 'OS_HALF_STATES_PROXY_REARMED';
+    const proxied = { HTTPS_PROXY: 'http://127.0.0.1:40309' };
+    const rearm = (env) => proxyRearmPlan({ env, guard: PROXY_REARM_GUARD, flagSupported: true });
+    const own = { ...proxied, [PROXY_REARM_GUARD]: '1' };
+    const ownSource = readFileSync(SELF_PATH, 'utf8');
+    t('this tool\'s guard is its own name, never the patrol\'s', PROXY_REARM_GUARD !== PATROL_GUARD);
+    t('…and the patrol name pinned here IS the plan\'s default, so a rename reds this battery', proxyRearmPlan({ env: { ...proxied, [PATROL_GUARD]: '1' } }).guarded === PATROL_GUARD);
+    t('a proxied run with no guard set re-execs', rearm(proxied).rearm === true);
+    t('…this tool\'s OWN guard is what stops the loop', rearm(own).rearm === false);
+    t('…while the patrol\'s inherited guard does NOT suppress it', rearm({ ...proxied, [PATROL_GUARD]: '1' }).rearm === true);
+    t('a suppressed run SPEAKS — silence is the whole cost of this chain', rearm(own).hint === true);
+    t('…naming the variable a reader has to unset', rearm(own).reason.includes(PROXY_REARM_GUARD));
+    t('…and naming the 401 the silence would otherwise be read as', rearm(own).reason.includes('401 Bad credentials'));
+    t('the Actions-runner leg is unchanged: no proxy, no re-exec, no extra line', rearm({ [PROXY_REARM_GUARD]: '1' }).rearm === false && rearm({ [PROXY_REARM_GUARD]: '1' }).hint === false);
+    t('structural: the dispatch really hands the plan THIS file\'s guard', /\n\s+guard: PROXY_REARM_GUARD,\n/.test(ownSource));
+    t('structural: the plan is imported, not restated here', /\bproxyRearmPlan\b/.test(ownSource) && !/function\s+proxyRearmPlan\b/.test(ownSource));
+  }
+
   battery('the record shapes: fixed key order, declared absence');
   const record = issueRecord(RAW());
   t('the key order is the one this file writes, not the order GitHub answered in',
 
@@ -19653,6 +19653,12 @@ export const EXIT_PREREQUISITE_NOT_MET = 3;
  * identically — both are read at process START, which is the whole reason this
  * is a re-exec rather than an assignment (header, "Routing node through the
  * session proxy").
+ *
+ * `PROXY_REARM_GUARD` is THIS file's OWN guard and the plan's DEFAULT — it is
+ * not a name every instrument shares (#18939). A consumer that sets its own
+ * variable on the child it spawns passes that name to `proxyRearmPlan` as
+ * `guard`; the consumers that instead map their own name ONTO this one before
+ * calling keep working through the default, unchanged.
  */
 export const PROXY_FLAG = '--use-env-proxy';
 export const PROXY_REARM_GUARD = 'OS_HALF_STATES_PROXY_REARMED';
@@ -19684,16 +19690,46 @@ export function proxyRoute({ env = {}, execArgv = [] } = {}) {
  * VERBATIM into a sibling repo (#11217): a GitHub Actions runner carries no
  * proxy env, so it never re-execs and behaves exactly as it did before.
  *
- * @param {{ env?: Record<string,string|undefined>, execArgv?: string[], flagSupported?: boolean }} [ctx]
- * @returns {{ rearm: boolean, hint: boolean, flag?: string, reason: string }}
- */
-export function proxyRearmPlan({ env = {}, execArgv = [], flagSupported = true } = {}) {
+ * ## The guard is a NAME, and it belongs to the CALLER (#18939)
+ *
+ * Every consumer sets its OWN variable on the child it re-execs, but this plan
+ * read ONE hard-coded name — this file's. So ANY sibling instrument's guard,
+ * once inherited, answered "already re-armed" for a tool that had never
+ * re-armed; the suppressed run then took the bypassed route and answered 401
+ * Bad credentials on every endpoint, `/rate_limit` included. A uniform 401 is a
+ * self-consistent story — the credential is dead — and it was read as one for
+ * about an hour against a channel that was alive the whole time. `guard` is
+ * therefore a parameter: a caller passes the name it actually sets, and only
+ * its own guard can stop its own re-exec.
+ *
+ * And a suppressed run must not be a SILENT one. `rearm: false, hint: false`
+ * prints nothing at any consumer, so the suppression left no line anywhere in
+ * the run log, which is the whole cost of that chain. This branch therefore
+ * sets `hint: true` — the one branch every consumer already prints — and its
+ * reason names the variable, the route and the 401 it would be mistaken for.
+ * It can only fire on the anomaly: a real re-exec's child carries `PROXY_FLAG`
+ * in its `execArgv` and is answered by the `routed` branch above, never here.
+ *
+ * @param {{ env?: Record<string,string|undefined>, execArgv?: string[], flagSupported?: boolean, guard?: string }} [ctx]
+ * @returns {{ rearm: boolean, hint: boolean, flag?: string, guarded?: string, reason: string }}
+ */
+export function proxyRearmPlan({ env = {}, execArgv = [], flagSupported = true, guard = PROXY_REARM_GUARD } = {}) {
   const { proxy, routed } = proxyRoute({ env, execArgv });
   if (!proxy) {
     return { rearm: false, hint: false, reason: 'no HTTPS_PROXY in the environment — node fetch reaches api.github.com directly' };
   }
   if (routed) return { rearm: false, hint: false, reason: `already routed through the proxy (${PROXY_FLAG} / NODE_USE_ENV_PROXY=1)` };
-  if (env[PROXY_REARM_GUARD] === '1') return { rearm: false, hint: false, reason: 'already re-armed once this run' };
+  if (env[guard] === '1') {
+    return {
+      rearm: false,
+      hint: true,
+      guarded: guard,
+      reason:
+        `${guard}=1 is set and this process is NOT routed through ${proxy}, so the one re-exec this run allows ` +
+        `was already spent and every request below bypasses the proxy — if they answer 401 Bad credentials, that ` +
+        `inherited guard is why, and unsetting ${guard} is the fix rather than a new token`,
+    };
+  }
   if (!flagSupported) {
     return { rearm: false, hint: true, reason: `this node does not accept ${PROXY_FLAG}; every request will bypass ${proxy}` };
   }
@@ -35334,6 +35370,32 @@ Doubles as the fire's **write self-check** (step 0). \`201\` is not the reading.
   t('proxy: …in NODE_OPTIONS, likewise', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', NODE_OPTIONS: `--enable-source-maps ${PROXY_FLAG}` } }).rearm, false);
   t('proxy: …and the env spelling NODE_USE_ENV_PROXY=1, likewise', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', NODE_USE_ENV_PROXY: '1' } }).rearm, false);
   t('proxy: the guard env stops an infinite re-exec loop', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).rearm, false);
+  // -- #18939: the guard is a NAME, and the plan reads the CALLER's. A sibling
+  // -- instrument's inherited guard answering "already re-armed" for a tool
+  // -- that never re-armed is how one variable replays the recorded
+  // -- "the credential is dead" hour: the suppressed run bypasses the proxy and
+  // -- answers 401 on every endpoint, and nothing is printed to say why.
+  t('proxy: the default guard is still THIS file\'s own name, so its own re-exec is unchanged', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).guarded, PROXY_REARM_GUARD);
+  t('proxy: a caller that names its OWN guard is suppressed by that one', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', OS_SIBLING_PROXY_REARMED: '1' }, guard: 'OS_SIBLING_PROXY_REARMED' }).rearm, false);
+  t('proxy: …and this file\'s name does NOT suppress it — the cross-suppression is gone', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' }, guard: 'OS_SIBLING_PROXY_REARMED' }).rearm, true);
+  t('proxy: …reported machine-readably, so a caller can name the variable to unset', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', OS_SIBLING_PROXY_REARMED: '1' }, guard: 'OS_SIBLING_PROXY_REARMED' }).guarded, 'OS_SIBLING_PROXY_REARMED');
+  // The landed mapper shape (`check-single-claim-paths.mjs`, `check-expected-skips.mjs`,
+  // `check-prior-rulings.mjs`) folds its own name onto the default and passes no
+  // `guard`. Both of its directions are pinned here, because the DEFAULT is what
+  // it relies on.
+  t('proxy: a mapper that maps its own name onto the default still suppresses', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).rearm, false);
+  t('proxy: …and maps an UNSET own name to undefined, which suppresses nothing', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: undefined } }).rearm, true);
+  // Silence is the whole cost of this chain: `rearm:false, hint:false` prints
+  // nothing at any consumer. The guard branch HINTS, which every consumer
+  // already prints — the ones that pass no `guard` of their own included.
+  t('proxy: a guard that suppresses SPEAKS rather than closing the route silently', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).hint, true);
+  t('proxy: …the line names the variable a reader has to unset', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).reason.includes(PROXY_REARM_GUARD), true);
+  t('proxy: …and names the 401 the silence would otherwise be read as', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' } }).reason.includes('401 Bad credentials'), true);
+  t('proxy: …and the proxy the request was supposed to take', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://127.0.0.1:40309', [PROXY_REARM_GUARD]: '1' } }).reason.includes('http://127.0.0.1:40309'), true);
+  // The runner leg, re-pinned ACROSS the new branch: a guard set where no proxy
+  // is configured must still spawn nothing, hint nothing and print nothing.
+  t('proxy: with no proxy configured the guard is inert (the Actions runner leg)', proxyRearmPlan({ env: { [PROXY_REARM_GUARD]: '1' } }).hint, false);
+  t('proxy: …and an already-routed run is answered by the ROUTE, not by the guard', Boolean(proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x', [PROXY_REARM_GUARD]: '1' }, execArgv: [PROXY_FLAG] }).guarded), false);
   // An older node gets a printed hint, never a bad-option crash.
   t('proxy: an unsupported flag hints instead of re-execing', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x' }, flagSupported: false }).hint, true);
   t('proxy: …and does not re-exec', proxyRearmPlan({ env: { HTTPS_PROXY: 'http://x' }, flagSupported: false }).rearm, false);
 
@@ -99,6 +99,7 @@
 
 import process from 'node:process';
 import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 import { isEntrypoint } from '../invoked-as.mjs';
@@ -788,6 +789,7 @@ async function driveOffline(argv, boardInit = {}) {
 // that stops registering cases is the bug; a pinned TOTAL would hide it the
 // moment a sibling battery grows (#13489, the shape post-stamped.mjs carries).
 const SELF_TEST_BATTERIES = Object.freeze({
+  'the re-exec guard: the name this tool sets, and the patrol name that must not silence it': 11,
   'the arithmetic: union, difference, and the two idempotent no-ops': 12,
   'the ONE-OF refusal, and the one declared exception': 6,
   'the read-back verdict: three buckets, three different meanings': 7,
@@ -797,7 +799,7 @@ const SELF_TEST_BATTERIES = Object.freeze({
   'the remaining exits: refusal, mismatch, the ONE-OF block and the dry run': 5,
   'the CLI: what a typo must never be allowed to mean': 8,
 });
-const SELF_TEST_BATTERY_FLOOR = 8;
+const SELF_TEST_BATTERY_FLOOR = 9;
 const UNATTRIBUTED_BATTERY = '(unattributed)';
 
 const batteryCases = new Map();
@@ -817,6 +819,31 @@ export async function selfTest() {
   };
 
   // ── the arithmetic ────────────────────────────────────────────────────────
+  // ── the re-exec guard (#18939) ────────────────────────────────────────────
+  // The plan reads the guard name THIS file sets, never a shared one. A sibling
+  // instrument's inherited guard used to answer 'already re-armed' here, and the
+  // un-re-armed run then bypassed the proxy and answered 401 Bad credentials —
+  // a false story about the credential, printed nowhere at all.
+  battery('the re-exec guard: the name this tool sets, and the patrol name that must not silence it');
+  {
+    const PATROL_GUARD = 'OS_HALF_STATES_PROXY_REARMED';
+    const proxied = { HTTPS_PROXY: 'http://127.0.0.1:40309' };
+    const rearm = (env) => proxyRearmPlan({ env, guard: PROXY_REARM_GUARD, flagSupported: true });
+    const own = { ...proxied, [PROXY_REARM_GUARD]: '1' };
+    const ownSource = readFileSync(SELF_PATH, 'utf8');
+    t('this tool\'s guard is its own name, never the patrol\'s', PROXY_REARM_GUARD !== PATROL_GUARD);
+    t('…and the patrol name pinned here IS the plan\'s default, so a rename reds this battery', proxyRearmPlan({ env: { ...proxied, [PATROL_GUARD]: '1' } }).guarded === PATROL_GUARD);
+    t('a proxied run with no guard set re-execs', rearm(proxied).rearm === true);
+    t('…this tool\'s OWN guard is what stops the loop', rearm(own).rearm === false);
+    t('…while the patrol\'s inherited guard does NOT suppress it', rearm({ ...proxied, [PATROL_GUARD]: '1' }).rearm === true);
+    t('a suppressed run SPEAKS — silence is the whole cost of this chain', rearm(own).hint === true);
+    t('…naming the variable a reader has to unset', rearm(own).reason.includes(PROXY_REARM_GUARD));
+    t('…and naming the 401 the silence would otherwise be read as', rearm(own).reason.includes('401 Bad credentials'));
+    t('the Actions-runner leg is unchanged: no proxy, no re-exec, no extra line', rearm({ [PROXY_REARM_GUARD]: '1' }).rearm === false && rearm({ [PROXY_REARM_GUARD]: '1' }).hint === false);
+    t('structural: the dispatch really hands the plan THIS file\'s guard', /\n\s+guard: PROXY_REARM_GUARD,\n/.test(ownSource));
+    t('structural: the plan is imported, not restated here', /\bproxyRearmPlan\b/.test(ownSource) && !/function\s+proxyRearmPlan\b/.test(ownSource));
+  }
+
   battery('the arithmetic: union, difference, and the two idempotent no-ops');
   const a1 = computeLabelTarget({ current: ['x', 'pm:queue'], add: ['pm:dispatched'], remove: ['pm:queue'] });
   t('target = (current ∪ add) − remove', a1.target, ['x', 'pm:dispatched']);
@@ -1012,17 +1039,24 @@ export async function selfTest() {
  * credential problem and is not one.
  */
 function rearmThroughProxy(args) {
+  // `guard` is THIS tool's own variable (#18939). Without it the plan read the
+  // patrol's shared name straight out of `process.env`, so a sibling
+  // instrument's inherited guard answered "already re-armed" here — silently —
+  // and the un-re-armed run then bypassed the proxy and answered 401 Bad
+  // credentials, a false story about the credential. The own-guard `if` that
+  // used to sit below was never reached for that case; the plan's own branch
+  // now covers it, and PRINTS the variable through `plan.hint`.
   const plan = proxyRearmPlan({
     env: process.env,
     execArgv: process.execArgv,
     flagSupported: process.allowedNodeEnvironmentFlags.has(PROXY_FLAG),
+    guard: PROXY_REARM_GUARD,
   });
   if (plan.hint) {
     console.error(`ℹ️  ${plan.reason}. A refusal below may be about the route, not this container.`);
     return null;
   }
   if (!plan.rearm) return null;
-  if (process.env[PROXY_REARM_GUARD] === '1') return null;
   console.error(`ℹ️  re-exec with ${plan.flag}: ${plan.reason}.`);
   const quiet = process.allowedNodeEnvironmentFlags.has('--disable-warning') ? ['--disable-warning=UNDICI-EHPA'] : [];
   const child = spawnSync(process.execPath, [plan.flag, ...quiet, SELF_PATH, ...args], {