diff --git a/GLOSSARY.md b/GLOSSARY.md
index f7788f99..f4189ddd 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -305,7 +305,7 @@ _Avoid_: cron log, output log, run log (a **Ticket run** is one kind of command)
 The retained Command logs and Session traces available to list on a machine, each naming an exact file under the User config's log folder. A Command's referenced Session traces may include files outside that inventory.
 
 **Activity log**:
-One running record per repository of what the factory did there: a line when a **Ticket run**, **Spec run**, **Architect run**, **Pickup run**, **Security run**, **Triage run** or **Custom process** starts work, naming its **Command log**, a line when it is given a **Stop** or a **Dismissal**, or a Dismissal is taken back, naming who asked and whether from the CLI or the **Console**, and a line when it ends, with its outcome. A Custom process's lines name it as Process `<name>`. A skipped Architect run, Pickup run, Security run or Triage Pass writes a line only when its reason differs from the last one recorded for its kind, so a repository that sits idle shows one line, not one per pass. A skipped Custom process started with no issue writes `Process <name> skipped: <reason>` when that is not already the last Process line. A warning about the **User config**, such as a setting it ignores, is written once per change. It is what thirdshift writes about a scheduled pass, in place of output to the scheduler.
+One running record per repository of what the factory did there: a line when a **Ticket run**, **Spec run**, **Architect run**, **Pickup run**, **Security run**, **Triage run** or **Custom process** starts work, naming its **Command log**, a line when it is given a **Stop** or a **Dismissal**, or a Dismissal is taken back, naming who asked and whether from the CLI or the **Console**, and a line when it ends, with its outcome. A Custom process's lines name it as Process `<name>`. A skipped Architect run, Pickup run, Security run or Triage Pass writes a line only when its reason differs from the last one recorded for its kind, so a repository that sits idle shows one line, not one per pass. A skipped Custom process started with no issue writes `Process <name> skipped: <reason>` when that is not already the last Process line. During a **Quota wait**, each named Custom process compares its own last reason instead, so alternating processes do not repeat an unchanged quota skip. A warning about the **User config**, such as a setting it ignores, is written once per change. It is what thirdshift writes about a scheduled pass, in place of output to the scheduler.
 _Avoid_: cron log, pass log, history
 
 **Command record**:
diff --git a/docs/guide.md b/docs/guide.md
index e3824b73..5ff75f83 100644
--- a/docs/guide.md
+++ b/docs/guide.md
@@ -164,7 +164,7 @@ For each repository and kind of Pass whose latest Activity log line is a skip, s
 Architect run idle on acme/widgets: Ready issue #7 "Make widgets" goes first: https://github.com/acme/widgets/issues/7
 ```
 
-`status` and the Console Inbox also show `Pickup last fired <age> ago on <owner>/<repo>` (and the equivalent for Architect and Security), even when repeated Passes skip for the same reason. Every Pass saves its start once its repository is known, before launch checks and the Command limit, in `<logs.dir>/<owner>/<repo>/<pickup|architect|secure|review|fix|triage>.last-fired`. This replaces the previous time without adding Activity log lines. A repository with no saved start has no last-fired entry; older Activity log times are not used as evidence that the scheduler recently fired.
+`status` and the Console Inbox also show `Pickup last fired <age> ago on <owner>/<repo>` (and the equivalent for Architect and Security), even when repeated Passes skip for the same reason. Beside those lines, `GitHub Quota wait until <time>` appears while this machine has a Quota wait and disappears after its reset. Every Pass saves its start once its repository is known, before launch checks and the Command limit, in `<logs.dir>/<owner>/<repo>/<pickup|architect|secure|review|fix|triage>.last-fired`. This replaces the previous time without adding Activity log lines. A repository with no saved start has no last-fired entry; older Activity log times are not used as evidence that the scheduler recently fired.
 
 When no Commands are running, each bullet in the Inbox's **Last recorded skipped Passes** and **Last fired Passes** starts with its recorded date and time. A skipped reason uses its Activity log time, which repeated skips do not advance; a last-fired entry uses the saved Pass start and keeps its relative age. An unreadable skip time shows **Time unknown**.
 
@@ -3625,6 +3625,7 @@ The `PATH` line, the `cd` and `base main` and the logins are as in [On a schedul
 
 Most passes are skipped, and that is what paces frequent Architect runs. A pass is skipped while:
 
+- **GitHub is in a Quota wait or below the reserve**: every Pass checks the machine's Quota wait record, then `gh api rate_limit`, before any other GitHub work or taking a Command-limit slot. Either fewer than 500 REST requests or fewer than 500 GraphQL points records a Quota wait until that resource resets. This covers Pickup, Architect, Security, Triage without a Report or issue, Review with `--author`, Fix without a pull request, and a Custom process without an issue, whether started by cron or by a person. A quota check that fails for a reason other than exhaustion lets the Pass proceed. A quota skip exits `0`, prints nothing on stdout and sends no Run notification. Its Activity log reason, `skipped: GitHub Quota wait until <time> (<resource>: <n> left)`, is recorded only when it changes for that kind;
 - **a run is still going**: the repository is at its Command limit, a Pass's Spec run or Ticket run counted, or another Architect run is running there ([The Command limit](#the-command-limit));
 - **an Architect plan is open**: one whose pull request waits for review, one whose run failed, or one published with `--plan-only` and not yet built ([One Architect plan at a time](#one-architect-plan-at-a-time));
 - **an Architect idea waits for triage**, since the factory has run out of Strong ideas ([An Architect idea waits for triage](#an-architect-idea-waits-for-triage));
@@ -3848,9 +3849,10 @@ PATH=/home/you/.local/bin:/home/you/.cargo/bin:/usr/local/bin:/usr/bin:/bin
 
 The `PATH` line, the `cd` and `base main`, the log file's directory, the logins the Harness's CLI and `gh` need, and schedulers other than cron are as for an Architect run: see its [On a schedule](#on-a-schedule). What differs for a Pickup run:
 
+- **Budget per GitHub user across hosts.** Every host authenticated as the same GitHub user shares one quota across repositories. Budget Pass frequency per user across all those hosts, rather than giving each host or repository a separate quota budget. A machine's Quota wait record is local; the shared GitHub quota still applies everywhere.
 - **The interval** sets how soon a Ready issue is taken and how much work is started: a pass takes one issue, so `*/30` starts at most one every half hour. A pass lasts as long as the run it dispatched, and the passes that fire meanwhile are skipped, so at the default [Command limit](#the-command-limit) of 1 the schedule builds one issue of a repository at a time on a machine, and the first pass after it ends takes the next, unless the repository is by then at its [Failure limit](#the-failure-limit): at 3 failures left for you, or the `pickup.failure_limit` you set, the passes take nothing until you have dealt with one. A pull request left for review never holds them back. An issue you have just labelled also waits five minutes by default, or the `pickup.wait_minutes` you set, until it is settled. A Ticket run you start by hand on an Issue URL never waits for a pass, but it fills a slot, so at the limit it makes one skip. Raise `pass.command_limit` to let a repository's passes overlap.
 - **One line per repository.** thirdshift keeps no list of repositories. Each Pass on one repository skips at its [Command limit](#the-command-limit), 1 by default, so both lines can go in one crontab and, by default, two Passes never build that repository at once. Passes on different repositories do run at the same time: give their lines different minutes, such as `15,45`, if they would compete for the machine.
-- **A pass is skipped** when the repository is at its [Command limit](#the-command-limit), when the repository has no Ready issue, and when it is at its Failure limit. A skip exits `0`, so the scheduler sees no failure, and sends no email, even with Run notifications on. The repository's [Activity log](#logs) records a skip when its reason changes. Unless `activity.quiet_skips` is set, the log file holds each skip's line too, and before the line of a pass that found no Ready issue, as before the line of one that took an issue, [why each issue was passed over](#why-an-issue-was-passed-over). A pass skipped for the Command limit or the Failure limit looks at no issue, so it has no such lines.
+- **A pass is skipped** during a GitHub Quota wait or below the 500-unit reserve, when the repository is at its [Command limit](#the-command-limit), when the repository has no Ready issue, and when it is at its Failure limit. A skip exits `0`, so the scheduler sees no failure, and sends no email, even with Run notifications on. The repository's [Activity log](#logs) records a skip when its reason changes. Unless `activity.quiet_skips` is set, the log file holds each skip's line too, and before the line of a pass that found no Ready issue, as before the line of one that took an issue, [why each issue was passed over](#why-an-issue-was-passed-over). A pass skipped for quota, the Command limit or the Failure limit looks at no issue, so it has no such lines.
 - **A Run notification**, by `email.always = true` or `email.unless_merged = true` in the [User config](#user-config), or `email` or `email-unless-merged` on the line, is sent [only for an issue taken](#one-run-notification-for-the-issue-taken). So a day without email doesn't say the passes are running: a pass that fails before it takes an issue, on a broken User config, a missing Resend key or a failed check, shows up only in the log file.
 
 A whole crontab with both frequent Architect runs and a Pickup run on one repository looks like this, with `activity.quiet_skips = true` in the User config, every line sending its output to the one log file, which catches only what went wrong, so `tail ~/.thirdshift/logs/acme/widgets/activity.log` shows what the factory has been doing on the repository lately:
diff --git a/site/architecture/index.html b/site/architecture/index.html
index 743eb1d5..726b5787 100644
--- a/site/architecture/index.html
+++ b/site/architecture/index.html
@@ -553,6 +553,7 @@ <h1>Architecture</h1>
   <section class="sec arch-sec" id="passes" aria-labelledby="passes-title">
     <div class="wrap">
       <div class="sec-head"><p class="eyebrow">Figure 5 · <code>thirdshift pickup</code>, <code>architect</code>, <code>secure</code></p><h2 id="passes-title">The Passes: the factory finds its own work</h2></div>
+      <p>Quota admission precedes every Pass's other GitHub work and Command-limit slot: consult the machine's Quota wait record, then <code>gh api rate_limit</code>. Either a current wait or fewer than 500 REST requests or GraphQL points skips the Pass; a low resource records a wait until reset. Non-quota probe failures let work proceed. This applies to Pickup, Architect, Security, Triage without input, Review with <code>--author</code>, Fix without a pull request and issue-less Custom processes, from cron or by hand. Skips exit zero without stdout or notifications and deduplicate the Activity log reason per kind. The Inbox and <code>status</code> show the wait beside last-fired Passes until reset. Frequency is a budget per GitHub user across hosts and repositories sharing that quota.</p>
       <p>Before selecting a Ready issue, Pickup immediately requests one re-run of failed jobs in the Base branch's latest push CI. Green on re-run files a Flaky-test Ticket with the recorded failure as evidence; its Ticket run goes straight to implementation. Red again files an ordinary bug Ticket after 30 minutes from that attempt's completion. That ticket's title, body and comments leave job names and log lines out, and it waits until you write the task and apply <code>ready-for-agent</code>. A CI-red Ticket in <code>needs-info</code> does not block new reports; another open CI-red Ticket receives new failing commits as comments, once per commit. Concurrent hosts reserve evidence reads, re-running, filing and commenting on origin. CI read failures warn and leave Pickup running; this check does not hold Self-merges.</p>
       <p>Once a Pickup run, an Architect run or a Security run knows its repository, it replaces that kind's last-fired time under the repository's log folder, before launch checks or the Command limit. Repeated skips update the time without adding Activity log lines. <code>thirdshift status</code>, <code>thirdshift cronjobs</code> and their Console views read the same per-repository times; no reader starts work. A Custom process started with no issue, and neither an Issue-branch nor a Spec-branch worktree, counts toward the Command limit, runs beside other Passes up to it, takes no lock of a kind, and does not record a last-fired time. A file that declares either branch worktree is refused when no issue is given, before the Command limit.</p>
       <p class="lede">A <strong>Pass</strong> takes no Issue URL, so your operating system's scheduler can start it; thirdshift never schedules itself. A Pass is skipped while its repository is at its Command limit, <code>[pass] command_limit</code>, 1 by default: every live Command on the repository on the machine counts, a Ticket run started on an Issue URL included, but only a Pass is skipped. Passes of different kinds share a repository up to the limit, but never two Architect runs or two Security runs at once: each of those holds a lock of its kind and a review worktree of its own, and reserves the plan or fix it dispatches on <code>origin</code>, as a Pickup run reserves its Ready issue. A Pass with nothing to do is skipped, not failed. Architect and Security runs wait while a Ready issue is open, so work you shaped goes first. A Custom process started with no issue is a Pass for that rule and does not wait on a Ready issue or an Architect idea, unless the file declares either branch worktree: that is refused before any session, rather than skipped. One started with an issue is not a Pass. Your scheduler can start <a href="/docs/#architect-runs-every-few-minutes">Architect runs every few minutes</a> and <a href="/docs/#security-runs-on-a-schedule-with-fixing-allowed">Security runs on a schedule, with fixing allowed</a>.</p>
diff --git a/site/docs/index.html b/site/docs/index.html
index 4a311db0..0d88e348 100644
--- a/site/docs/index.html
+++ b/site/docs/index.html
@@ -193,7 +193,7 @@
 <p>For each repository and kind of Pass whose latest Activity log line is a skip, status also shows that Pass as idle with its reason, even when the skip is older than another kind&#39;s activity. A later start or end for that kind clears its idle entry. For example:</p>
 <pre><code class="language-text">Architect run idle on acme/widgets: Ready issue #7 &quot;Make widgets&quot; goes first: https://github.com/acme/widgets/issues/7
 </code></pre>
-<p><code>status</code> and the Console Inbox also show <code>Pickup last fired &lt;age&gt; ago on &lt;owner&gt;/&lt;repo&gt;</code> (and the equivalent for Architect and Security), even when repeated Passes skip for the same reason. Every Pass saves its start once its repository is known, before launch checks and the Command limit, in <code>&lt;logs.dir&gt;/&lt;owner&gt;/&lt;repo&gt;/&lt;pickup|architect|secure|review|fix|triage&gt;.last-fired</code>. This replaces the previous time without adding Activity log lines. A repository with no saved start has no last-fired entry; older Activity log times are not used as evidence that the scheduler recently fired.</p>
+<p><code>status</code> and the Console Inbox also show <code>Pickup last fired &lt;age&gt; ago on &lt;owner&gt;/&lt;repo&gt;</code> (and the equivalent for Architect and Security), even when repeated Passes skip for the same reason. Beside those lines, <code>GitHub Quota wait until &lt;time&gt;</code> appears while this machine has a Quota wait and disappears after its reset. Every Pass saves its start once its repository is known, before launch checks and the Command limit, in <code>&lt;logs.dir&gt;/&lt;owner&gt;/&lt;repo&gt;/&lt;pickup|architect|secure|review|fix|triage&gt;.last-fired</code>. This replaces the previous time without adding Activity log lines. A repository with no saved start has no last-fired entry; older Activity log times are not used as evidence that the scheduler recently fired.</p>
 <p>When no Commands are running, each bullet in the Inbox&#39;s <strong>Last recorded skipped Passes</strong> and <strong>Last fired Passes</strong> starts with its recorded date and time. A skipped reason uses its Activity log time, which repeated skips do not advance; a last-fired entry uses the saved Pass start and keeps its relative age. An unreadable skip time shows <strong>Time unknown</strong>.</p>
 <p><code>thirdshift cronjobs</code> and the Console&#39;s Cron jobs page group this account&#39;s thirdshift crontab entries alphabetically by full <code>owner/repo</code>, preserving crontab order and duplicate jobs within each group. A literal <code>cd &lt;directory&gt; &amp;&amp; ... thirdshift ...</code> command is associated through that directory&#39;s GitHub <code>origin</code> remote on the owning machine, using the same quoted and home paths as Launch directory discovery. Unresolved entries stay visible in a trailing <strong>Other</strong> group. Cron command text is never executed. The page gives each group its own terminal-style block, with <strong>Run Passes now</strong> and <strong>Last fired by repository</strong> kept separately below.</p>
 <p><code>cronjobs --json</code> and <code>/api/v1/cronjobs</code> retain the object with a flat <code>jobs</code> array in group order (each entry&#39;s <code>schedule</code>, <code>command</code> and nullable <code>repository</code>) and independent <code>pass_starts</code>. A selected Fleet machine supplies its own repository associations; older inventories without that metadata display under <strong>Other</strong>. The starts include manually launched Passes and other schedulers; they do not prove a particular cron entry fired. Both this inventory and <code>status --json</code> expose <code>pass_starts</code> entries with <code>repository</code>, <code>kind</code>, RFC 3339 <code>last_fired_at</code> and nonnegative <code>age_seconds</code>.</p>
@@ -3448,6 +3448,7 @@
 <p>The <code>PATH</code> line, the <code>cd</code> and <code>base main</code> and the logins are as in <a href="#on-a-schedule">On a schedule</a>. Set <code>activity.quiet_skips = true</code> in the User config too, so the skips leave the log file alone: each is in the repository&#39;s <a href="#logs">Activity log</a>, once per change of reason.</p>
 <p>Most passes are skipped, and that is what paces frequent Architect runs. A pass is skipped while:</p>
 <ul>
+<li><strong>GitHub is in a Quota wait or below the reserve</strong>: every Pass checks the machine&#39;s Quota wait record, then <code>gh api rate_limit</code>, before any other GitHub work or taking a Command-limit slot. Either fewer than 500 REST requests or fewer than 500 GraphQL points records a Quota wait until that resource resets. This covers Pickup, Architect, Security, Triage without a Report or issue, Review with <code>--author</code>, Fix without a pull request, and a Custom process without an issue, whether started by cron or by a person. A quota check that fails for a reason other than exhaustion lets the Pass proceed. A quota skip exits <code>0</code>, prints nothing on stdout and sends no Run notification. Its Activity log reason, <code>skipped: GitHub Quota wait until &lt;time&gt; (&lt;resource&gt;: &lt;n&gt; left)</code>, is recorded only when it changes for that kind;</li>
 <li><strong>a run is still going</strong>: the repository is at its Command limit, a Pass&#39;s Spec run or Ticket run counted, or another Architect run is running there (<a href="#the-command-limit">The Command limit</a>);</li>
 <li><strong>an Architect plan is open</strong>: one whose pull request waits for review, one whose run failed, or one published with <code>--plan-only</code> and not yet built (<a href="#one-architect-plan-at-a-time">One Architect plan at a time</a>);</li>
 <li><strong>an Architect idea waits for triage</strong>, since the factory has run out of Strong ideas (<a href="#an-architect-idea-waits-for-triage">An Architect idea waits for triage</a>);</li>
@@ -3621,9 +3622,10 @@
 </code></pre>
 <p>The <code>PATH</code> line, the <code>cd</code> and <code>base main</code>, the log file&#39;s directory, the logins the Harness&#39;s CLI and <code>gh</code> need, and schedulers other than cron are as for an Architect run: see its <a href="#on-a-schedule">On a schedule</a>. What differs for a Pickup run:</p>
 <ul>
+<li><strong>Budget per GitHub user across hosts.</strong> Every host authenticated as the same GitHub user shares one quota across repositories. Budget Pass frequency per user across all those hosts, rather than giving each host or repository a separate quota budget. A machine&#39;s Quota wait record is local; the shared GitHub quota still applies everywhere.</li>
 <li><strong>The interval</strong> sets how soon a Ready issue is taken and how much work is started: a pass takes one issue, so <code>*/30</code> starts at most one every half hour. A pass lasts as long as the run it dispatched, and the passes that fire meanwhile are skipped, so at the default <a href="#the-command-limit">Command limit</a> of 1 the schedule builds one issue of a repository at a time on a machine, and the first pass after it ends takes the next, unless the repository is by then at its <a href="#the-failure-limit">Failure limit</a>: at 3 failures left for you, or the <code>pickup.failure_limit</code> you set, the passes take nothing until you have dealt with one. A pull request left for review never holds them back. An issue you have just labelled also waits five minutes by default, or the <code>pickup.wait_minutes</code> you set, until it is settled. A Ticket run you start by hand on an Issue URL never waits for a pass, but it fills a slot, so at the limit it makes one skip. Raise <code>pass.command_limit</code> to let a repository&#39;s passes overlap.</li>
 <li><strong>One line per repository.</strong> thirdshift keeps no list of repositories. Each Pass on one repository skips at its <a href="#the-command-limit">Command limit</a>, 1 by default, so both lines can go in one crontab and, by default, two Passes never build that repository at once. Passes on different repositories do run at the same time: give their lines different minutes, such as <code>15,45</code>, if they would compete for the machine.</li>
-<li><strong>A pass is skipped</strong> when the repository is at its <a href="#the-command-limit">Command limit</a>, when the repository has no Ready issue, and when it is at its Failure limit. A skip exits <code>0</code>, so the scheduler sees no failure, and sends no email, even with Run notifications on. The repository&#39;s <a href="#logs">Activity log</a> records a skip when its reason changes. Unless <code>activity.quiet_skips</code> is set, the log file holds each skip&#39;s line too, and before the line of a pass that found no Ready issue, as before the line of one that took an issue, <a href="#why-an-issue-was-passed-over">why each issue was passed over</a>. A pass skipped for the Command limit or the Failure limit looks at no issue, so it has no such lines.</li>
+<li><strong>A pass is skipped</strong> during a GitHub Quota wait or below the 500-unit reserve, when the repository is at its <a href="#the-command-limit">Command limit</a>, when the repository has no Ready issue, and when it is at its Failure limit. A skip exits <code>0</code>, so the scheduler sees no failure, and sends no email, even with Run notifications on. The repository&#39;s <a href="#logs">Activity log</a> records a skip when its reason changes. Unless <code>activity.quiet_skips</code> is set, the log file holds each skip&#39;s line too, and before the line of a pass that found no Ready issue, as before the line of one that took an issue, <a href="#why-an-issue-was-passed-over">why each issue was passed over</a>. A pass skipped for quota, the Command limit or the Failure limit looks at no issue, so it has no such lines.</li>
 <li><strong>A Run notification</strong>, by <code>email.always = true</code> or <code>email.unless_merged = true</code> in the <a href="#user-config">User config</a>, or <code>email</code> or <code>email-unless-merged</code> on the line, is sent <a href="#one-run-notification-for-the-issue-taken">only for an issue taken</a>. So a day without email doesn&#39;t say the passes are running: a pass that fails before it takes an issue, on a broken User config, a missing Resend key or a failed check, shows up only in the log file.</li>
 </ul>
 <p>A whole crontab with both frequent Architect runs and a Pickup run on one repository looks like this, with <code>activity.quiet_skips = true</code> in the User config, every line sending its output to the one log file, which catches only what went wrong, so <code>tail ~/.thirdshift/logs/acme/widgets/activity.log</code> shows what the factory has been doing on the repository lately:</p>
diff --git a/site/how-it-works/index.html b/site/how-it-works/index.html
index 9f3c4b24..1b8aa4fe 100644
--- a/site/how-it-works/index.html
+++ b/site/how-it-works/index.html
@@ -242,6 +242,7 @@ <h1>How thirdshift works</h1>
   <section class="sec" aria-labelledby="scheduled-title">
     <details class="wrap guide-section fold">
       <summary class="sec-head"><p class="eyebrow">07 / Where the next issue comes from</p><h2 id="scheduled-title">Choose how the next work starts</h2></summary>
+      <p>Every Pass checks the machine's GitHub Quota wait, then the quota, before other GitHub work or taking a Command-limit slot. It skips during a wait or below 500 REST requests or GraphQL points, with no stdout or Run notification. Pickup, Architect, Security, Triage without input, Review with <code>--author</code>, Fix without a pull request and issue-less Custom processes all follow this rule, from cron or by hand. The Activity log records each kind's changed reason; <code>status</code> and the Inbox show the wait beside last-fired Passes until reset. Budget Pass frequency per GitHub user across all hosts and repositories sharing that user's quota.</p>
       <div class="guide-content" id="scheduled">
       <p>Review Passes recognize reviewed and pushed heads only in comments by the GitHub account thirdshift acts as. When an upper pull request lacks Review run fixes delivered to its base, its comment says it needs updating before merge; the author updates the stack.</p>
       <p>A Review retry recovers its clean retained checkout only after verifying ownership, the same captured PR head and descendant commits. Other local conflicts stay preserved: author Passes notify once per state and scan later waiting pull requests; explicit PR targets fail with recovery advice.</p>
diff --git a/site/index.html b/site/index.html
index e9647991..35525537 100644
--- a/site/index.html
+++ b/site/index.html
@@ -461,6 +461,7 @@ <h2 id="grows-title">Seven workflows</h2>
         <details class="workflow">
           <summary>Schedules and passes</summary>
           <div class="workflow-content">
+            <p>Every Pass skips during a GitHub Quota wait or below 500 REST requests or GraphQL points, before other GitHub work and without taking a Command-limit slot or sending a Run notification. This includes Review with <code>--author</code>, Fix without a pull request and issue-less Custom processes, whether started by cron or by hand. The Activity log records the reason only when it changes for that kind; <code>status</code> and the Console Inbox show the Quota wait beside the last-fired lines until reset. Budget Pass frequency per GitHub user across hosts and repositories: hosts authenticated as the same user share one quota.</p>
             <p>Start passes with <code>thirdshift architect base main</code>, <code>thirdshift pickup base main</code>, <code>thirdshift triage base main</code> or <code>thirdshift secure base main</code>. A Custom process started with no issue, and neither an Issue-branch nor a Spec-branch worktree, follows the same <a href="/docs/#the-command-limit">Command limit</a>, running beside other Passes up to it, and does not wait on a Ready issue or an Architect idea. A file that declares either branch worktree is refused when no issue is given, before any session. Your operating system schedules them. <code>[pass] command_limit</code>, 1 by default, is how many Commands on one repository on the machine skip a Pass there; raise it to let Passes overlap: Pickup runs, one Architect run and one Security run side by side, never two Architect runs or two Security runs. A Ticket run you start on an Issue URL counts toward it, but is never refused. <code>thirdshift status</code>, <code>thirdshift cronjobs</code> and the Console show when each repository's Pickup, Architect and Security Pass last fired, including repeated skips. <a href="/docs/#architect-runs-every-few-minutes">Architect runs every few minutes</a> and <a href="/docs/#security-runs-on-a-schedule-with-fixing-allowed">Security runs on a schedule, with fixing allowed</a>. Both yield to work the Day shift shaped, and pause when a decision needs you.</p>
           </div>
         </details>
diff --git a/src/architect.rs b/src/architect.rs
index 4511ffc9..436f0364 100644
--- a/src/architect.rs
+++ b/src/architect.rs
@@ -27,7 +27,7 @@ use anyhow::{Context, Result, bail};
 use chrono::{DateTime, Utc};
 
 use crate::asks::Flags;
-use crate::command_limit::{AlreadyRunning, PassKind, Sharing};
+use crate::command_limit::{NotAdmitted, PassKind, Sharing};
 use crate::config::UserConfig;
 use crate::failed_run::FailedRun;
 use crate::github::{Issue, ListedIssue};
@@ -83,10 +83,11 @@ pub enum Outcome {
 /// skipped run's progress line gives it.
 #[derive(Debug)]
 pub enum Skipped {
-    /// Its repository is at its Command limit on this machine, the Spec run
+    /// GitHub is in a Quota wait, or its repository is at its Command limit
+    /// on this machine, the Spec run
     /// or Run each Pass dispatched counted, or another Architect run is
     /// still running there.
-    AlreadyRunning(AlreadyRunning),
+    NotAdmitted(NotAdmitted),
     /// These Architect plans are still open on this repository: at least
     /// one.
     OpenPlans(Vec<ListedIssue>),
@@ -106,7 +107,7 @@ impl Skipped {
     /// its start, at the Command limit or beside another Architect run.
     pub fn urls(&self) -> Vec<&str> {
         match self {
-            Self::AlreadyRunning(_) => Vec::new(),
+            Self::NotAdmitted(_) => Vec::new(),
             Self::OpenPlans(issues) | Self::IdeasWaiting(issues) => issues
                 .iter()
                 .map(|listed| listed.issue.url.as_str())
@@ -121,7 +122,7 @@ impl Skipped {
 impl fmt::Display for Skipped {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::AlreadyRunning(running) => running.fmt(f),
+            Self::NotAdmitted(running) => running.fmt(f),
             Self::OpenPlans(plans) => write_joined(f, plans, |plan, title| {
                 format!(
                     "Architect plan #{} \"{title}\" is still open: pick it up with thirdshift {}",
@@ -313,9 +314,9 @@ pub fn run(
         Sharing::OneOfAKind(PassKind::Architect),
     ) {
         Ok(Start::Clear(launch)) => launch,
-        Ok(Start::AlreadyRunning(running)) => {
+        Ok(Start::NotAdmitted(running)) => {
             logs::skipped(Pass::Architect, &running.repo, &running);
-            return Outcome::Skipped(Skipped::AlreadyRunning(running));
+            return Outcome::Skipped(Skipped::NotAdmitted(running));
         }
         Err(error) => return failed(error.into()),
     };
diff --git a/src/command_limit.rs b/src/command_limit.rs
index 0e6e47ec..b138a3bb 100644
--- a/src/command_limit.rs
+++ b/src/command_limit.rs
@@ -13,6 +13,9 @@
 //! one repository at once. A Pickup run or an issue-less Custom process
 //! takes no lock of a kind.
 //!
+//! Quota admission comes before remote preparation and slot acquisition.
+//! A Quota wait skips every Pass without holding any of these locks.
+//!
 //! A Pass also tries a shared lock on the file a thirdshift from before the
 //! Command limit locks exclusively. Every overlapping newer Pass keeps its
 //! shared lock until it ends, so an older Pass cannot start until they all
@@ -65,19 +68,28 @@ impl PassKind {
     }
 }
 
-/// Why a Pass is skipped at its start, on `repo`, at the Command `limit`.
+/// Why a Pass is skipped at admission, on `repo`.
 /// Its `Display` is the reason, as the skipped run gives it.
 #[derive(Debug)]
-pub struct AlreadyRunning {
+pub struct NotAdmitted {
     pub repo: Repo,
     limit: NonZeroUsize,
     why: Why,
 }
 
+impl NotAdmitted {
+    pub fn is_quota_wait(&self) -> bool {
+        matches!(self.why, Why::QuotaWait(_))
+    }
+}
+
 #[derive(Debug)]
 enum Why {
+    QuotaWait(String),
     /// `running` Commands are running, at or over the limit.
-    AtLimit { running: usize },
+    AtLimit {
+        running: usize,
+    },
     /// Another Pass of this one's kind is running.
     SameKind(PassKind),
     /// A thirdshift from before the Command limit is running an exclusive
@@ -85,10 +97,11 @@ enum Why {
     Older,
 }
 
-impl fmt::Display for AlreadyRunning {
+impl fmt::Display for NotAdmitted {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let (repo, limit) = (self.repo.slug(), self.limit);
         match self.why {
+            Why::QuotaWait(ref reason) => f.write_str(reason),
             Why::AtLimit { running } => write!(
                 f,
                 "at the Command limit on {repo}: {}, pass.command_limit is {limit}",
@@ -100,6 +113,16 @@ impl fmt::Display for AlreadyRunning {
     }
 }
 
+/// Check quota before any remote preparation or Command-limit slot. Probe
+/// failures other than exhaustion preserve the existing admission behavior.
+pub fn quota_wait(repo: &Repo, limit: NonZeroUsize) -> Option<NotAdmitted> {
+    Some(NotAdmitted {
+        repo: repo.clone(),
+        limit,
+        why: Why::QuotaWait(crate::github::GitHub::new().pass_quota_wait()?),
+    })
+}
+
 /// "1 Command is running", or "`n` Commands are running".
 fn commands_running(n: usize) -> String {
     match n {
@@ -136,11 +159,11 @@ pub fn hold_pass(
     repo: &Repo,
     limit: NonZeroUsize,
     sharing: Sharing,
-) -> Result<Option<AlreadyRunning>> {
+) -> Result<Option<NotAdmitted>> {
     let slots = Slots::of(repo)?;
     let _counting = slots.counting()?;
     let skipped = |why| {
-        Ok(Some(AlreadyRunning {
+        Ok(Some(NotAdmitted {
             repo: repo.clone(),
             limit,
             why,
diff --git a/src/console/changes.rs b/src/console/changes.rs
index 883183cf..b5c96fff 100644
--- a/src/console/changes.rs
+++ b/src/console/changes.rs
@@ -10,6 +10,8 @@ use anyhow::Result;
 use notify::{Event, EventKind, RecursiveMode, Watcher};
 use tokio::sync::watch;
 
+use crate::github::{GitHub, QuotaWait};
+
 #[derive(Clone, Copy, Default, PartialEq)]
 pub(super) struct Revision {
     pub commands: u64,
@@ -70,6 +72,7 @@ struct Paths {
     other_logs: Vec<PathBuf>,
     executable: PathBuf,
     assets: Option<PathBuf>,
+    quota_warning: Mutex<Option<String>>,
 }
 
 impl Paths {
@@ -80,6 +83,7 @@ impl Paths {
             other_logs: Vec::new(),
             executable: observed_path(&executable),
             assets: None,
+            quota_warning: Mutex::new(None),
         }
     }
 
@@ -140,6 +144,16 @@ impl Paths {
             if path == self.root.join("console-accounts.json") {
                 revision.accounts += 1;
             }
+            if path == self.root.join("github-quota.json") {
+                // Identity-cache bookkeeping shares this file with waits.
+                // Wake readers only when their displayed quota state changes.
+                let current = quota_warning();
+                let mut previous = self.quota_warning.lock().unwrap();
+                if *previous != current {
+                    *previous = current;
+                    revision.commands += 1;
+                }
+            }
             if path.starts_with(&self.logs)
                 || self.logs.starts_with(&path)
                 || self
@@ -207,6 +221,10 @@ impl Paths {
     }
 }
 
+fn quota_warning() -> Option<String> {
+    QuotaWait::warning(&GitHub::new().quota_waits().unwrap_or_default())
+}
+
 // Native backends may report canonical paths.
 // Resolve the existing ancestor so roots created later use the same spelling.
 pub(super) fn observed_path(path: &std::path::Path) -> PathBuf {
@@ -228,6 +246,7 @@ pub(super) fn observe(
         config.logs_dir.clone(),
         executable.path.clone(),
     );
+    paths.quota_warning = Mutex::new(quota_warning());
     paths.assets = assets.directory().map(PathBuf::from);
     paths.other_logs = crate::logs::accounts::discover(config)
         .logs
@@ -298,6 +317,10 @@ pub(super) fn observe(
             }
             reconcile(&mut watcher, &mut watched, &paths.read().unwrap());
             reconcile(&mut recovery, &mut recovered, &paths.read().unwrap());
+            if revision.commands != previous.commands {
+                // Clock-driven notices also advance the displayed quota state.
+                *paths.read().unwrap().quota_warning.lock().unwrap() = quota_warning();
+            }
             sender.send_if_modified(|current| {
                 let before = *current;
                 if revision.commands != previous.commands {
diff --git a/src/console/inbox.html b/src/console/inbox.html
index d7812cb2..bca1cc2e 100644
--- a/src/console/inbox.html
+++ b/src/console/inbox.html
@@ -63,6 +63,7 @@ <h3>{% if machines.len() > 1 %}No Commands are running in this Fleet.{% else %}N
       {% endif %}
     </section>
     {% endif %}
+    {% match inbox.github_quota_wait %}{% when Some with (wait) %}<p class="github-quota-wait" role="status">{{ wait }}</p>{% when None %}{% endmatch %}
     {% for section in inbox.sections %}
     <details id="group-{{ loop.index }}" class="group" data-group="{{ section.group }}" aria-label="{{ section.title }}"{% if self.in_overview(section.group) %} data-overview{% endif %}{% if !self.shown(section.group) %} hidden{% endif %} open>
       <summary><h3>{{ section.title }} <span class="count">{{ section.rows.len() }}</span></h3></summary>
diff --git a/src/fix.rs b/src/fix.rs
index d024f31e..b6175ce2 100644
--- a/src/fix.rs
+++ b/src/fix.rs
@@ -44,7 +44,7 @@ pub(crate) fn run(
                 crate::command_limit::Sharing::UpToTheLimit,
             )? {
                 crate::launch::Start::Clear(launch) => launch,
-                crate::launch::Start::AlreadyRunning(running) => {
+                crate::launch::Start::NotAdmitted(running) => {
                     return Ok(skipped(&running.repo, running.to_string()));
                 }
             };
diff --git a/src/github/quota.rs b/src/github/quota.rs
index 87437e8d..5993e51b 100644
--- a/src/github/quota.rs
+++ b/src/github/quota.rs
@@ -1,5 +1,4 @@
-//! Shared machine-local Quota waits. Observing a wait does not yet change how
-//! Passes or running Commands execute.
+//! Shared machine-local Quota waits and Pass admission.
 use anyhow::{Context, Result};
 use chrono::{DateTime, SecondsFormat, Utc};
 use serde::{Deserialize, Serialize};
@@ -76,6 +75,20 @@ impl Quota {
 }
 
 impl QuotaWait {
+    /// One stable reason, held until the last depleted resource resets.
+    pub fn pass_reason(waits: &[Self]) -> Option<String> {
+        let wait = waits
+            .iter()
+            .filter(|wait| wait.reset_at() > Utc::now())
+            .max_by_key(|wait| wait.reset_at())?;
+        Some(format!(
+            "GitHub Quota wait until {} ({}: {} left)",
+            wait.reset_at().to_rfc3339_opts(SecondsFormat::Secs, true),
+            wait.resource.name(),
+            wait.remaining(),
+        ))
+    }
+
     pub fn reset_at(&self) -> DateTime<Utc> {
         self.quota.reset_at
     }
@@ -110,6 +123,18 @@ impl QuotaWait {
 }
 
 impl GitHub {
+    /// A known wait needs no probe. Non-quota probe failures fail open;
+    /// exhaustion recorded by a failed probe still skips this Pass.
+    pub(crate) fn pass_quota_wait(&self) -> Option<String> {
+        if let Some(reason) = QuotaWait::pass_reason(&self.quota_waits().unwrap_or_default()) {
+            return Some(reason);
+        }
+        let waits = self
+            .inbox_quotas()
+            .unwrap_or_else(|_| self.quota_waits().unwrap_or_default());
+        QuotaWait::pass_reason(&waits)
+    }
+
     // Quota probes deliberately bypass failure recording: learning a reset or
     // identity must never recursively probe another failure.
     fn quota_json(&self, args: &[&str]) -> Result<Value> {
diff --git a/src/github/quota/store.rs b/src/github/quota/store.rs
index df23bb01..6916d5b4 100644
--- a/src/github/quota/store.rs
+++ b/src/github/quota/store.rs
@@ -154,9 +154,16 @@ impl Store {
             .open(self.path.with_extension("lock"))?;
         lock.lock()?;
         let mut record = self.read()?;
+        let previous = serde_json::to_vec(&record)?;
         change(&mut record);
+        let bytes = serde_json::to_vec(&record)?;
+        // The Console watches this record: unchanged quota observations
+        // must not wake open Inbox pages.
+        if bytes == previous {
+            return Ok(());
+        }
         let mut tmp = tempfile::NamedTempFile::new_in(dir)?;
-        tmp.write_all(&serde_json::to_vec(&record)?)?;
+        tmp.write_all(&bytes)?;
         tmp.persist(&self.path)?;
         Ok(())
     }
diff --git a/src/launch.rs b/src/launch.rs
index a3b53de9..0a9066e4 100644
--- a/src/launch.rs
+++ b/src/launch.rs
@@ -19,7 +19,7 @@ use std::path::PathBuf;
 use anyhow::{Context, Result, bail};
 
 use crate::command_limit;
-use crate::command_limit::{AlreadyRunning, Sharing};
+use crate::command_limit::{NotAdmitted, Sharing};
 use crate::git::Git;
 use crate::github::GitHub;
 use crate::issue::{IssueInput, IssueUrl, Repo};
@@ -338,7 +338,7 @@ pub enum Start {
     /// Its checks passed and it holds a slot on its repository.
     Clear(Launch),
     /// It is skipped, with nothing done.
-    AlreadyRunning(AlreadyRunning),
+    NotAdmitted(NotAdmitted),
 }
 
 /// Start a run with no Issue URL from the Launch directory, the current
@@ -346,8 +346,9 @@ pub enum Start {
 /// whatever the Launch directory has checked out, or without one the branch
 /// checked out there, so a detached HEAD with neither fails it.
 ///
-/// Once the preflight checks pass, the run is [`AlreadyRunning`], with
-/// nothing done, if its repository is at its Command `limit` on this
+/// A Quota wait skips the Pass before remote preparation. Once the preflight
+/// checks pass, the run is also [`NotAdmitted`], with nothing done, if its
+/// repository is at its Command `limit` on this
 /// machine, or, as `sharing` says, another Pass of its kind runs there.
 /// Otherwise this process holds a slot there, and the lock of its kind if it
 /// has one, until it exits, through whatever it dispatches.
@@ -355,10 +356,13 @@ pub fn start(base: Option<&str>, limit: NonZeroUsize, sharing: Sharing) -> Resul
     let directory = LaunchDirectory::open(current_dir()?, Opening::Pass)?;
     let repo = directory.repo()?;
     crate::logs::pass_fired(&repo);
+    if let Some(skipped) = command_limit::quota_wait(&repo, limit) {
+        return Ok(Start::NotAdmitted(skipped));
+    }
     directory.check_identity()?;
     let base = directory.prepare_base_branch(base)?;
     if let Some(running) = command_limit::hold_pass(&repo, limit, sharing)? {
-        return Ok(Start::AlreadyRunning(running));
+        return Ok(Start::NotAdmitted(running));
     }
     Ok(Start::Clear(Launch {
         directory,
diff --git a/src/logs.rs b/src/logs.rs
index 934dbb53..def7380f 100644
--- a/src/logs.rs
+++ b/src/logs.rs
@@ -355,7 +355,8 @@ pub fn skipped(pass: Pass, repo: &Repo, reason: impl Display) {
 
 /// Record that the Custom process `name`, started with no issue, was skipped
 /// on `repo` for `reason`. The Activity log keeps `Process <name> skipped:
-/// <reason>` unless that is already its last Process line. Unlike the other
+/// <reason>` unless that is already its last Process line (its own named
+/// Process's last skip during a Quota wait). Unlike the other
 /// Passes, it also keeps a Command record whose outcome is `skipped`: the
 /// Process's record shows that ending. `harness` is the choice it would have
 /// run on; the skip does not check that it can run.
@@ -363,9 +364,9 @@ pub fn skipped_process(
     repo: &Repo,
     name: &str,
     harness: &crate::harness::Choice,
-    reason: impl Display,
+    reason: &crate::command_limit::NotAdmitted,
 ) {
-    record().skipped_process(repo, name, harness, &reason.to_string());
+    record().skipped_process(repo, name, harness, reason);
 }
 
 /// Add an observation to the running command's repository Activity log.
diff --git a/src/logs/activity.rs b/src/logs/activity.rs
index 6bdb6c85..5ce78e5a 100644
--- a/src/logs/activity.rs
+++ b/src/logs/activity.rs
@@ -76,10 +76,26 @@ pub(super) fn tail(path: &Path, limit: u64) -> Result<Tail> {
 /// The time and unstamped text of the last line of `kind` in the tail.
 pub(super) fn last_of(tail: &str, kind: Kind) -> Option<(&str, &str)> {
     let kind = kind.to_string();
-    tail.lines().rev().find_map(|line| {
-        let unstamped = line.get(TIME_FORMAT_LENGTH + 1..)?;
-        let rest = unstamped.strip_prefix(&kind)?;
-        (rest.starts_with(' ') || rest.starts_with(':'))
-            .then_some((line.get(..TIME_FORMAT_LENGTH)?, unstamped))
+    lines(tail).rev().find(|(_, text)| {
+        text.strip_prefix(&kind)
+            .is_some_and(|rest| rest.starts_with(' ') || rest.starts_with(':'))
+    })
+}
+
+/// Compare the complete Process name: names can contain spaces and colons.
+pub(super) fn last_process_skip<'a>(tail: &'a str, name: &str) -> Option<(&'a str, &'a str)> {
+    lines(tail).rev().find(|(_, text)| {
+        text.rsplit_once(" skipped: ")
+            .and_then(|(subject, _)| subject.strip_prefix("Process "))
+            == Some(name)
+    })
+}
+
+fn lines(tail: &str) -> impl DoubleEndedIterator<Item = (&str, &str)> {
+    tail.lines().filter_map(|line| {
+        Some((
+            line.get(..TIME_FORMAT_LENGTH)?,
+            line.get(TIME_FORMAT_LENGTH + 1..)?,
+        ))
     })
 }
diff --git a/src/logs/github.rs b/src/logs/github.rs
index 6a363c4d..6a28cd38 100644
--- a/src/logs/github.rs
+++ b/src/logs/github.rs
@@ -183,6 +183,10 @@ impl Kept {
             .map(|at| at.to_rfc3339_opts(SecondsFormat::Secs, true))
     }
 
+    pub fn quota_wait(&self) -> Option<String> {
+        QuotaWait::pass_reason(&self.waits)
+    }
+
     pub fn warning(&self) -> Option<String> {
         let mut reasons = Vec::new();
         if let Some(reason) = QuotaWait::warning(&self.waits) {
@@ -206,10 +210,23 @@ impl Kept {
         })
     }
 
-    /// An open Inbox must also learn when a failed answer becomes stale.
+    /// An open Inbox must learn when an answer becomes stale or a Quota wait resets.
     pub fn next_warning_change(&self) -> Option<Duration> {
-        let age = self.age?;
-        (age <= FRESH_FOR).then(|| FRESH_FOR - age + Duration::from_millis(1))
+        let freshness = self
+            .age
+            .and_then(|age| (age <= FRESH_FOR).then(|| FRESH_FOR - age + Duration::from_millis(1)));
+        let now = Utc::now();
+        let reset = self
+            .waits
+            .iter()
+            .filter_map(|wait| {
+                (wait.reset_at() - now)
+                    .to_std()
+                    .ok()
+                    .filter(|delay| !delay.is_zero())
+            })
+            .min();
+        freshness.into_iter().chain(reset).min()
     }
 
     fn state(&self, row: &str, url: &str) -> Option<&InboxState> {
diff --git a/src/logs/recording.rs b/src/logs/recording.rs
index 4a257f07..42eeb431 100644
--- a/src/logs/recording.rs
+++ b/src/logs/recording.rs
@@ -69,6 +69,11 @@ struct Started {
     process: Option<String>,
 }
 
+enum History<'a> {
+    Kind(Kind),
+    ProcessSkip(&'a str),
+}
+
 impl Started {
     fn subject(&self) -> String {
         if let Some(name) = &self.process {
@@ -190,7 +195,7 @@ impl<O: Outside> Record<O> {
             self.activity_write(
                 root,
                 &format!("{} warning: {warning}", Kind::UserConfig),
-                Some(Kind::UserConfig),
+                Some(History::Kind(Kind::UserConfig)),
             );
         }
     }
@@ -388,7 +393,7 @@ impl<O: Outside> Record<O> {
         self.activity_write(
             &self.root(repo),
             &format!("{kind} skipped: {reason}"),
-            Some(kind),
+            Some(History::Kind(kind)),
         );
     }
 
@@ -400,21 +405,28 @@ impl<O: Outside> Record<O> {
         repo: &Repo,
         name: &str,
         harness: &Choice,
-        reason: &str,
+        reason: &crate::command_limit::NotAdmitted,
     ) {
         let root = self.root(repo);
         self.record_config_warnings(&root);
+        // Quota waits compare this named Process's last reason even when
+        // another Custom process fires between its Passes.
+        let history = if reason.is_quota_wait() {
+            History::ProcessSkip(name)
+        } else {
+            History::Kind(Kind::Process)
+        };
         self.activity_write(
             &root,
             &format!("Process {name} skipped: {reason}"),
-            Some(Kind::Process),
+            Some(history),
         );
         let stamp = self.stamp();
         // Leave held lines unshown, so a quiet skip prints nothing. They are
         // still the Command log.
         self.retain(&root, Work::Process { repo, name }, &stamp, false);
         self.start_record(Work::Process { repo, name }, harness);
-        self.outcome("skipped", Some(reason));
+        self.outcome("skipped", Some(&reason.to_string()));
     }
 
     pub(super) fn activity(&mut self, message: impl Display) {
@@ -810,7 +822,7 @@ impl<O: Outside> Record<O> {
         }
     }
 
-    fn activity_write(&mut self, root: &Path, line: &str, unless_last_of: Option<Kind>) {
+    fn activity_write(&mut self, root: &Path, line: &str, unless_last_of: Option<History<'_>>) {
         let appended = self.activity_append(&root.join(activity::FILE), line, unless_last_of);
         if let Err(error) = appended
             && !self.activity_warned
@@ -827,9 +839,9 @@ impl<O: Outside> Record<O> {
         &mut self,
         path: &Path,
         line: &str,
-        unless_last_of: Option<Kind>,
+        unless_last_of: Option<History<'_>>,
     ) -> Result<()> {
-        if let Some(kind) = unless_last_of {
+        if let Some(history) = unless_last_of {
             let tail = self.outside.activity_tail(path, activity::TAIL)?;
             let text = String::from_utf8_lossy(&tail.bytes);
             let whole = if tail.from > 0 {
@@ -837,7 +849,11 @@ impl<O: Outside> Record<O> {
             } else {
                 &text
             };
-            if activity::last_of(whole, kind).map(|(_, text)| text) == Some(line) {
+            let last = match history {
+                History::Kind(kind) => activity::last_of(whole, kind),
+                History::ProcessSkip(name) => activity::last_process_skip(whole, name),
+            };
+            if last.map(|(_, text)| text) == Some(line) {
                 return Ok(());
             }
         }
diff --git a/src/logs/status.rs b/src/logs/status.rs
index 2261e9fa..49326d7b 100644
--- a/src/logs/status.rs
+++ b/src/logs/status.rs
@@ -29,6 +29,7 @@ struct Status<'a> {
     commands: Vec<InboxItem<'a>>,
     idle_passes: &'a [IdlePass],
     pass_starts: &'a [PassStart],
+    github_quota_wait: Option<String>,
     /// How old the Inbox's kept GitHub answer is, in seconds. `None` where
     /// no answer is kept: with no ready pull requests to read, or before
     /// the first read.
@@ -71,6 +72,7 @@ impl Read {
                 .into_rows(all),
             idle_passes: &self.snapshot.idle_passes,
             pass_starts: &self.snapshot.pass_starts,
+            github_quota_wait: self.kept.quota_wait(),
             github_answer_age_seconds: self.kept.age.map(|age| age.as_secs()),
             github_last_answered_at: self.kept.last_answered_at(),
             github_failure: self.kept.failure.as_deref(),
@@ -261,6 +263,9 @@ pub fn show(json: bool, all: bool, machine: Option<&str>, local_only: bool) -> R
         for pass in status.pass_starts.iter().filter(|_| include_local) {
             println!("{}", pass.line());
         }
+        if include_local && let Some(wait) = status.github_quota_wait {
+            println!("{wait}");
+        }
     }
     Ok(())
 }
diff --git a/src/logs/status/inbox.rs b/src/logs/status/inbox.rs
index 4d0a90a9..08210efc 100644
--- a/src/logs/status/inbox.rs
+++ b/src/logs/status/inbox.rs
@@ -16,6 +16,7 @@ pub(crate) struct Inbox {
     pub sections: Vec<Section>,
     pub idle_passes: Vec<IdlePass>,
     pub pass_starts: Vec<PassStart>,
+    pub github_quota_wait: Option<String>,
     pub warning: Option<&'static str>,
     pub github_warning: Option<String>,
 }
@@ -736,6 +737,7 @@ pub(super) fn from_read(
         github_warning: kept.warning(),
         idle_passes: snapshot.idle_passes.clone(),
         pass_starts: snapshot.pass_starts.clone(),
+        github_quota_wait: kept.quota_wait(),
         warning: (config.effective_waiting_line_interval() != config.waiting_line_interval).then_some(
             "logs.waiting_line_minutes must be less than inbox.silent_minutes; using half the silent time for waiting lines"),
     })
@@ -1028,6 +1030,7 @@ mod tests {
             ],
             idle_passes: Vec::new(),
             pass_starts: Vec::new(),
+            github_quota_wait: None,
             warning: None,
             github_warning: None,
         };
diff --git a/src/pickup.rs b/src/pickup.rs
index 1d15a1c1..f8d0e2f0 100644
--- a/src/pickup.rs
+++ b/src/pickup.rs
@@ -19,7 +19,7 @@ use anyhow::Result;
 
 use crate::asks::Flags;
 use crate::claim;
-use crate::command_limit::{AlreadyRunning, Sharing};
+use crate::command_limit::{NotAdmitted, Sharing};
 use crate::config::UserConfig;
 use crate::github::{GitHub, ListedIssue};
 use crate::harness::Choice;
@@ -54,9 +54,10 @@ pub struct Took {
 /// Why a Pickup run was skipped. Its `Display` is the reason, as the skipped
 /// run's one line gives it.
 pub enum Skipped {
-    /// The repository is at its Command limit on this machine, each Pass's
+    /// GitHub is in a Quota wait, or the repository is at its Command limit
+    /// on this machine, each Pass's
     /// dispatched Spec run or Run counted as part of it.
-    AlreadyRunning(AlreadyRunning),
+    NotAdmitted(NotAdmitted),
     /// The repository is at its Failure limit: `failed` lists the open
     /// issues labelled `agent-failed` that still wait for the Day shift,
     /// lowest number first, and `limit` or more stop a Pickup run from
@@ -77,7 +78,7 @@ pub enum Skipped {
 impl fmt::Display for Skipped {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::AlreadyRunning(running) => running.fmt(f),
+            Self::NotAdmitted(running) => running.fmt(f),
             Self::AtFailureLimit {
                 repo,
                 failed,
@@ -172,9 +173,9 @@ pub fn run(
         base,
     } = match launch::start(base, config.command_limit, Sharing::UpToTheLimit)? {
         Start::Clear(launch) => launch,
-        Start::AlreadyRunning(running) => {
+        Start::NotAdmitted(running) => {
             logs::skipped(Pass::Pickup, &running.repo, &running);
-            return Ok(Outcome::Skipped(Skipped::AlreadyRunning(running)));
+            return Ok(Outcome::Skipped(Skipped::NotAdmitted(running)));
         }
     };
     // Only Pickup handles Base branch CI reporting. A CI or publication failure
diff --git a/src/processes.rs b/src/processes.rs
index 57d0f471..7dfec0df 100644
--- a/src/processes.rs
+++ b/src/processes.rs
@@ -648,25 +648,30 @@ fn run(command: &ProcessRun) -> Result<String> {
     if issue.is_none() {
         logs::begin(Begin::Process { name, pass: true });
         logs::configured(&config);
-        let base = match launch::checked_out_base() {
-            Ok(base) => base,
-            Err(error) => return Err(failed_before_steps(notification, error)),
-        };
         let repo = match launch::repo() {
             Ok(repo) => repo,
             Err(error) => return Err(failed_before_steps(notification, error)),
         };
+        let skip = |reason: &command_limit::NotAdmitted| {
+            let choice = Choice::of(&command.asked, &config.harness);
+            progress::step(reason);
+            logs::skipped_process(&repo, name, &choice, reason);
+            String::new()
+        };
+        if let Some(skipped) = command_limit::quota_wait(&repo, config.command_limit) {
+            return Ok(skip(&skipped));
+        }
+        let base = match launch::checked_out_base() {
+            Ok(base) => base,
+            Err(error) => return Err(failed_before_steps(notification, error)),
+        };
         match command_limit::hold_pass(
             &repo,
             config.command_limit,
             command_limit::Sharing::UpToTheLimit,
         ) {
             Ok(Some(running)) => {
-                let reason = running.to_string();
-                let choice = Choice::of(&command.asked, &config.harness);
-                progress::step(&reason);
-                logs::skipped_process(&repo, name, &choice, &reason);
-                return Ok(String::new());
+                return Ok(skip(&running));
             }
             Ok(None) => {}
             Err(error) => return Err(failed_before_steps(notification, error)),
diff --git a/src/processes/review.rs b/src/processes/review.rs
index 1272e696..44cd5533 100644
--- a/src/processes/review.rs
+++ b/src/processes/review.rs
@@ -25,14 +25,20 @@ pub(crate) fn run(command: ReviewArgs) -> Result<String> {
                 crate::issue::Repo::of_origin(&launch.run(&["config", "remote.origin.url"])?)
                     .context("review --author needs a GitHub origin")?;
             logs::pass_fired(&repo);
+            let skip = |reason: &dyn std::fmt::Display| {
+                logs::skipped(logs::Pass::Review, &repo, reason);
+                progress::step(reason);
+                String::new()
+            };
+            if let Some(skipped) = command_limit::quota_wait(&repo, config.command_limit) {
+                return Ok(skip(&skipped));
+            }
             if let Some(running) = command_limit::hold_pass(
                 &repo,
                 config.command_limit,
                 command_limit::Sharing::UpToTheLimit,
             )? {
-                logs::skipped(logs::Pass::Review, &repo, &running);
-                progress::step(&running);
-                return Ok(String::new());
+                return Ok(skip(&running));
             }
             let github = GitHub::new();
             let mut selected = None;
@@ -49,9 +55,7 @@ pub(crate) fn run(command: ReviewArgs) -> Result<String> {
             }
             let Some(selected) = selected else {
                 let reason = format!("no waiting pull request by {author} on {}", repo.slug());
-                logs::skipped(logs::Pass::Review, &repo, &reason);
-                progress::step(reason);
-                return Ok(String::new());
+                return Ok(skip(&reason));
             };
             selected
         }
diff --git a/src/security.rs b/src/security.rs
index b8d321bb..a7ec97d1 100644
--- a/src/security.rs
+++ b/src/security.rs
@@ -7,7 +7,7 @@ use anyhow::Result;
 
 use crate::asks::Flags;
 use crate::base_fix::Advice;
-use crate::command_limit::{AlreadyRunning, PassKind, Sharing};
+use crate::command_limit::{NotAdmitted, PassKind, Sharing};
 use crate::config::UserConfig;
 use crate::failed_run::FailedRun;
 use crate::github::ListedIssue;
@@ -95,7 +95,7 @@ impl From<anyhow::Error> for Ended {
 pub use crate::github::RecordedFinding;
 
 pub enum Skipped {
-    AlreadyRunning(AlreadyRunning),
+    NotAdmitted(NotAdmitted),
     ReadyIssue(ListedIssue),
     FailedFix(crate::issue::IssueUrl),
     UnchangedBase(String),
@@ -104,7 +104,7 @@ pub enum Skipped {
 impl fmt::Display for Skipped {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::AlreadyRunning(running) => running.fmt(f),
+            Self::NotAdmitted(running) => running.fmt(f),
             Self::ReadyIssue(listed) => write!(
                 f,
                 "Ready issue #{} \"{}\" goes first: {}",
@@ -157,9 +157,9 @@ pub fn run(
         Sharing::OneOfAKind(PassKind::Security),
     ) {
         Ok(Start::Clear(launch)) => launch,
-        Ok(Start::AlreadyRunning(running)) => {
+        Ok(Start::NotAdmitted(running)) => {
             logs::skipped(Pass::Security, &running.repo, &running);
-            return Outcome::Skipped(Skipped::AlreadyRunning(running));
+            return Outcome::Skipped(Skipped::NotAdmitted(running));
         }
         Err(error) => return Outcome::Audited(error.into()),
     };
diff --git a/src/triage/pass.rs b/src/triage/pass.rs
index c489ff63..0879c820 100644
--- a/src/triage/pass.rs
+++ b/src/triage/pass.rs
@@ -44,7 +44,7 @@ pub fn run(
         base,
     } = match launch::start(base, config.command_limit, Sharing::UpToTheLimit)? {
         Start::Clear(launch) => launch,
-        Start::AlreadyRunning(running) => return Ok(skipped(&running.repo, &running)),
+        Start::NotAdmitted(running) => return Ok(skipped(&running.repo, &running)),
     };
     let failed = crate::pickup::failures(&mut LaunchAndGitHub {
         launch: directory.git(),
diff --git a/tests/architect_run.rs b/tests/architect_run.rs
index c8e2e4fc..40379659 100644
--- a/tests/architect_run.rs
+++ b/tests/architect_run.rs
@@ -2055,7 +2055,10 @@ fn a_second_architect_run_on_the_repository_is_skipped_while_the_first_is_mid_re
     );
     assert_eq!(scenario.entries("work"), [REPO, "widgets-architect"]);
     assert_eq!(scenario.gh_state(), github);
-    assert_eq!(scenario.gh_calls(), gh_calls);
+    assert_eq!(
+        scenario.gh_calls(),
+        [gh_calls, vec![vec!["api".into(), "rate_limit".into()]]].concat()
+    );
 
     release(&scenario);
     let first = first.finish();
diff --git a/tests/console/github.rs b/tests/console/github.rs
index 0bf3b002..046812c5 100644
--- a/tests/console/github.rs
+++ b/tests/console/github.rs
@@ -10,7 +10,9 @@ fn start_binary(scenario: &Scenario, binary: &Path) -> Console {
     let mut command = Command::new(binary);
     command
         .args(["console", "--no-sign-in"])
+        .env_clear()
         .env("HOME", scenario.path("home"))
+        .env("XDG_CONFIG_HOME", scenario.path("home/.config"))
         .env(
             "PATH",
             format!(
@@ -622,3 +624,97 @@ fn console_and_status_share_both_quota_reserves_and_resume_at_reset() {
         assert!(!scenario.run(&["status"]).stdout.contains("Warning:"));
     }
 }
+
+#[test]
+fn inbox_shows_a_pass_quota_wait_and_updates_when_the_machine_record_expires() {
+    let scenario = Scenario::new();
+    configure(&scenario.path("home"));
+    let mut gh = scenario.gh_state();
+    gh["rate_limits"]["core"] = json!({
+        "remaining": 499,
+        "reset": (chrono::Utc::now() + chrono::Duration::hours(1)).timestamp(),
+    });
+    scenario.write_gh_state(&gh);
+    assert_eq!(scenario.run(&["pickup"]).code, Some(0));
+    let console = start(&scenario);
+    let page = console.get("/").text().unwrap();
+    assert!(page.contains("Pickup last fired"), "{page}");
+    assert!(page.contains("class=\"github-quota-wait\""), "{page}");
+    assert!(page.contains("GitHub Quota wait until"), "{page}");
+    let response = reqwest::blocking::Client::builder()
+        .timeout(Duration::from_secs(20))
+        .build()
+        .unwrap()
+        .get(format!("{}/events", console.address))
+        .send()
+        .unwrap();
+    let mut stream = BufReader::new(response);
+    assert!(sse_event(&mut stream).contains("event: commands"));
+    assert_idle_events(&console, Duration::from_secs(1));
+    let path = scenario.path("home/.thirdshift/github-quota.json");
+    let mut record: Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
+    for wait in record["waits"].as_array_mut().unwrap() {
+        wait["reset_at"] = json!((chrono::Utc::now() + chrono::Duration::seconds(6)).to_rfc3339());
+    }
+    fs::write(path, serde_json::to_vec(&record).unwrap()).unwrap();
+    loop {
+        let event = sse_event(&mut stream);
+        assert!(event.contains("event: commands"));
+        if !console
+            .get("/")
+            .text()
+            .unwrap()
+            .contains("class=\"github-quota-wait\"")
+        {
+            break;
+        }
+    }
+    assert!(
+        !console
+            .get("/")
+            .text()
+            .unwrap()
+            .contains("class=\"github-quota-wait\"")
+    );
+    drop(stream);
+    drop(console);
+}
+
+#[test]
+fn relearning_quota_identity_without_a_wait_keeps_the_inbox_idle() {
+    let scenario = Scenario::new();
+    let home = scenario.path("home");
+    configure(&home);
+    record(&home, 81, Some("failed"), 10);
+    scenario.issue_is(81, "OPEN");
+    let console = start(&scenario);
+    let mut first = events(&console);
+    wait_for(&console, &mut first, "needs you");
+    assert_idle_events(&console, Duration::from_secs(1));
+    // Keep the first subscription alive so this one does not restart the observer.
+    let mut stream = events(&console);
+    assert!(sse_event(&mut stream).contains("event: commands"));
+    let path = scenario.path("home/.thirdshift/github-quota.json");
+    assert!(path.exists());
+    fs::remove_file(&path).unwrap();
+    let began = std::time::Instant::now();
+    loop {
+        let mut line = String::new();
+        match stream.read_line(&mut line) {
+            Ok(0) => panic!("Inbox stream closed"),
+            Ok(_) => assert!(
+                !line.starts_with("event: commands"),
+                "identity bookkeeping woke the Inbox: {line}"
+            ),
+            Err(_) => {
+                assert!(began.elapsed() >= Duration::from_secs(2));
+                break;
+            }
+        }
+    }
+    assert!(path.exists(), "the quota identity was not relearned");
+    assert!(scenario.gh_calls_of("api", "user").len() >= 2);
+    drop(stream);
+    drop(first);
+    drop(console);
+}
diff --git a/tests/pass_quota.rs b/tests/pass_quota.rs
new file mode 100644
index 00000000..d3e81b4e
--- /dev/null
+++ b/tests/pass_quota.rs
@@ -0,0 +1,318 @@
+//! Every Pass shares GitHub quota admission before its first GitHub read.
+mod support;
+
+use serde_json::json;
+use support::Scenario;
+use support::resend::ResendStandIn;
+
+fn commands() -> Vec<Vec<&'static str>> {
+    vec![
+        vec!["pickup"],
+        vec!["architect"],
+        vec!["secure"],
+        vec!["triage"],
+        vec!["review", "--author", "factory"],
+        vec!["fix"],
+        vec!["process", "notes"],
+    ]
+}
+
+fn setup(scenario: &Scenario) {
+    let dir = scenario.path("home/.thirdshift/processes");
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(
+        dir.join("notes.toml"),
+        "version = 1\ndescription = \"Notes\"\n[[steps]]\nname = \"notes\"\nskill = \"code-review\"\n",
+    )
+    .unwrap();
+}
+
+fn expire_wait(scenario: &Scenario) {
+    let path = scenario.path("home/.thirdshift/github-quota.json");
+    let mut record: serde_json::Value =
+        serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
+    for wait in record["waits"].as_array_mut().unwrap() {
+        wait["reset_at"] = json!("2000-01-01T00:00:00Z");
+    }
+    std::fs::write(path, serde_json::to_vec(&record).unwrap()).unwrap();
+}
+
+#[test]
+fn status_shows_the_machine_quota_wait_beside_pass_starts_until_reset() {
+    let scenario = Scenario::new();
+    let mut gh = scenario.gh_state();
+    gh["rate_limits"]["graphql"] = json!({
+        "remaining": 42,
+        "reset": (chrono::Utc::now() + chrono::Duration::hours(1)).timestamp(),
+    });
+    scenario.write_gh_state(&gh);
+    assert_eq!(scenario.run(&["pickup"]).code, Some(0));
+    let before = scenario.gh_calls();
+    let status = scenario.run(&["status"]);
+    assert_eq!(status.code, Some(0), "{}", status.stderr);
+    assert!(
+        status.stdout.contains("Pickup last fired"),
+        "{}",
+        status.stdout
+    );
+    assert!(
+        status
+            .stdout
+            .lines()
+            .any(|line| line.starts_with("GitHub Quota wait until")),
+        "{}",
+        status.stdout
+    );
+    assert!(
+        status.stdout.contains("graphql: 42 left"),
+        "{}",
+        status.stdout
+    );
+    assert_eq!(scenario.gh_calls(), before);
+    expire_wait(&scenario);
+    assert!(
+        !scenario
+            .run(&["status"])
+            .stdout
+            .lines()
+            .any(|line| line.starts_with("GitHub Quota wait until"))
+    );
+}
+
+#[test]
+fn each_pass_checks_live_quota_before_work_and_admits_exactly_500() {
+    for resource in ["core", "graphql"] {
+        for args in commands() {
+            let scenario = Scenario::new();
+            setup(&scenario);
+            let reset = (chrono::Utc::now() + chrono::Duration::hours(1)).timestamp();
+            let mut gh = scenario.gh_state();
+            gh["rate_limits"][resource] = json!({"remaining": 499, "reset": reset});
+            scenario.write_gh_state(&gh);
+            let output = scenario.run(&args);
+            assert_eq!(output.code, Some(0), "{args:?}: {}", output.stderr);
+            assert!(output.stdout.is_empty(), "{args:?}: {}", output.stdout);
+            assert!(
+                output.stderr.contains("GitHub Quota wait until"),
+                "{args:?}: {}",
+                output.stderr
+            );
+            assert!(scenario.gh_calls().iter().all(|call| {
+                call.starts_with(&["api".into(), "rate_limit".into()])
+                    || call.starts_with(&["api".into(), "user".into()])
+            }));
+            assert!(scenario.claude_calls().is_empty());
+            assert!(
+                !scenario
+                    .path("home/.thirdshift/command-slots/acme/widgets/0.slot")
+                    .exists()
+            );
+            expire_wait(&scenario);
+            gh["rate_limits"][resource]["remaining"] = json!(500);
+            scenario.write_gh_state(&gh);
+            let calls = scenario.gh_calls().len();
+            let output = scenario.run(&args);
+            assert!(
+                !output.stderr.contains("GitHub Quota wait until"),
+                "{args:?}: {}",
+                output.stderr
+            );
+            assert!(
+                scenario.gh_calls()[calls..]
+                    .iter()
+                    .any(|call| { !call.starts_with(&["api".into(), "rate_limit".into()]) })
+                    || !scenario.claude_calls().is_empty(),
+                "no work after reset: {args:?}"
+            );
+        }
+    }
+}
+
+#[test]
+fn a_non_quota_probe_failure_admits_every_pass_but_exhaustion_records_a_wait() {
+    for args in commands() {
+        let scenario = Scenario::new();
+        setup(&scenario);
+        scenario.gh_fails("api rate_limit");
+        let output = scenario.run(&args);
+        assert!(
+            !output.stderr.contains("GitHub Quota wait until"),
+            "{args:?}: {}",
+            output.stderr
+        );
+        assert!(
+            scenario
+                .gh_calls()
+                .iter()
+                .any(|call| { !call.starts_with(&["api".into(), "rate_limit".into()]) })
+                || !scenario.claude_calls().is_empty(),
+            "{args:?}"
+        );
+    }
+    for diagnostic in [
+        "HTTP 403: API rate limit exceeded for factory",
+        "GraphQL: API rate limit already exceeded (RATE_LIMITED)",
+    ] {
+        let scenario = Scenario::new();
+        let mut gh = scenario.gh_state();
+        gh["failing"] = json!(["api rate_limit"]);
+        gh["failing_stderr"] = json!(diagnostic);
+        scenario.write_gh_state(&gh);
+        let skipped = scenario.run(&["pickup"]);
+        assert_eq!(skipped.code, Some(0), "{}", skipped.stderr);
+        assert!(skipped.stdout.is_empty());
+        assert!(
+            skipped.stderr.contains("GitHub Quota wait until"),
+            "{}",
+            skipped.stderr
+        );
+        let before = scenario.gh_calls();
+        assert_eq!(scenario.run(&["pickup"]).code, Some(0));
+        assert_eq!(scenario.gh_calls(), before);
+        assert!(
+            !scenario
+                .path("home/.thirdshift/command-slots/acme/widgets/0.slot")
+                .exists()
+        );
+    }
+}
+
+#[test]
+fn unchanged_quota_wait_deduplicates_alternating_custom_processes() {
+    let scenario = Scenario::new();
+    setup(&scenario);
+    std::fs::copy(
+        scenario.path("home/.thirdshift/processes/notes.toml"),
+        scenario.path("home/.thirdshift/processes/other-notes.toml"),
+    )
+    .unwrap();
+    let mut gh = scenario.gh_state();
+    gh["rate_limits"]["core"] = json!({
+        "remaining": 499,
+        "reset": (chrono::Utc::now() + chrono::Duration::hours(1)).timestamp(),
+    });
+    scenario.write_gh_state(&gh);
+    for _ in 0..3 {
+        for name in ["notes", "other-notes"] {
+            let output = scenario.run(&["process", name]);
+            assert_eq!(output.code, Some(0), "{name}: {}", output.stderr);
+            assert!(output.stdout.is_empty(), "{name}: {}", output.stdout);
+        }
+    }
+    let activity =
+        std::fs::read_to_string(scenario.path("home/.thirdshift/logs/acme/widgets/activity.log"))
+            .unwrap();
+    for name in ["notes", "other-notes"] {
+        let prefix = format!("Process {name} skipped: GitHub Quota wait until");
+        assert_eq!(
+            activity
+                .lines()
+                .filter(|line| line.contains(&prefix))
+                .count(),
+            1,
+            "unchanged quota reason repeated for {name}:\n{activity}"
+        );
+    }
+}
+
+#[test]
+fn unchanged_quota_wait_deduplicates_process_names_with_spaces() {
+    let scenario = Scenario::new();
+    setup(&scenario);
+    std::fs::copy(
+        scenario.path("home/.thirdshift/processes/notes.toml"),
+        scenario.path("home/.thirdshift/processes/notes daily.toml"),
+    )
+    .unwrap();
+    let mut gh = scenario.gh_state();
+    gh["rate_limits"]["core"] = json!({
+        "remaining": 499,
+        "reset": (chrono::Utc::now() + chrono::Duration::hours(1)).timestamp(),
+    });
+    scenario.write_gh_state(&gh);
+    for _ in 0..3 {
+        for name in ["notes", "notes daily"] {
+            let output = scenario.run(&["process", name]);
+            assert_eq!(output.code, Some(0), "{name}: {}", output.stderr);
+            assert!(output.stdout.is_empty(), "{name}: {}", output.stdout);
+        }
+    }
+    let activity =
+        std::fs::read_to_string(scenario.path("home/.thirdshift/logs/acme/widgets/activity.log"))
+            .unwrap();
+    for name in ["notes", "notes daily"] {
+        let prefix = format!("Process {name} skipped: GitHub Quota wait until");
+        assert_eq!(
+            activity
+                .lines()
+                .filter(|line| line.contains(&prefix))
+                .count(),
+            1,
+            "unchanged quota reason repeated for {name}:\n{activity}"
+        );
+    }
+}
+
+#[test]
+fn every_pass_skips_below_either_reserve_and_reuses_the_wait_without_notifications() {
+    for resource in ["core", "graphql"] {
+        let scenario = Scenario::new();
+        setup(&scenario);
+        let reset = chrono::Utc::now() + chrono::Duration::hours(1);
+        let mut gh = scenario.gh_state();
+        gh["rate_limits"][resource] = json!({"remaining": 499, "reset": reset.timestamp()});
+        // A healthy subsequent observation must not bypass the recorded wait.
+        gh["next_rate_limits"] = json!({});
+        scenario.write_gh_state(&gh);
+        let resend = ResendStandIn::replying(200, "{}");
+        scenario.user_config_is("[email]\nalways = true\nto = \"operator@example.test\"\n");
+        for _ in 0..3 {
+            for args in commands() {
+                let output = scenario.run_with_env(
+                    &args,
+                    &[
+                        ("RESEND_API_KEY", "re_test_123"),
+                        ("THIRDSHIFT_RESEND_URL", resend.url()),
+                    ],
+                );
+                assert_eq!(output.code, Some(0), "{args:?}: {}", output.stderr);
+                assert!(output.stdout.is_empty(), "{args:?}: {}", output.stdout);
+            }
+        }
+        let calls = scenario.gh_calls();
+        assert_eq!(
+            calls
+                .iter()
+                .filter(|call| call.starts_with(&["api".into(), "rate_limit".into()]))
+                .count(),
+            1,
+            "{calls:?}"
+        );
+        assert!(
+            calls.iter().all(
+                |call| call.starts_with(&["api".into(), "rate_limit".into()])
+                    || call.starts_with(&["api".into(), "user".into()])
+            ),
+            "GitHub work after skip: {calls:?}"
+        );
+        assert!(scenario.claude_calls().is_empty());
+        assert!(resend.requests().is_empty());
+        let activity = std::fs::read_to_string(
+            scenario.path("home/.thirdshift/logs/acme/widgets/activity.log"),
+        )
+        .unwrap();
+        assert_eq!(activity.lines().count(), 7, "{activity}");
+        assert!(
+            activity
+                .lines()
+                .all(|line| line.contains("skipped: GitHub Quota wait until")
+                    && line.contains(&format!("({resource}: 499 left)"))),
+            "{activity}"
+        );
+        assert!(
+            !scenario
+                .path("home/.thirdshift/command-slots/acme/widgets/0.slot")
+                .exists()
+        );
+    }
+}
diff --git a/tests/pickup_run.rs b/tests/pickup_run.rs
index 2625fb53..a4d38e16 100644
--- a/tests/pickup_run.rs
+++ b/tests/pickup_run.rs
@@ -1785,12 +1785,21 @@ fn base_makes_the_named_branch_the_dispatched_spec_runs_base_branch() {
 }
 
 /// Assert the Pickup run was stopped by a preflight check with `message`,
-/// exit 1, before any work: no session, and no call to GitHub, so no label
-/// was read or changed.
+/// exit 1, before any work: no session or issue read/change. Quota admission
+/// may have checked the resource and authenticated account first.
 fn assert_stopped_by_preflight(scenario: &Scenario, result: &RunResult, message: &str) {
     scenario.assert_rejected_before_any_work(result, message);
     assert_eq!(result.code, Some(1), "stderr: {}", result.stderr);
-    assert_eq!(scenario.gh_calls(), Vec::<Vec<String>>::new());
+    let calls = scenario.gh_calls();
+    assert!(
+        calls.is_empty()
+            || calls
+                == [
+                    vec!["api", "rate_limit"],
+                    vec!["api", "user", "--hostname", "github.com"]
+                ],
+        "GitHub work beyond quota admission: {calls:?}"
+    );
     assert_eq!(scenario.issue_labels(7), [READY_FOR_AGENT]);
 }
 
@@ -1896,7 +1905,10 @@ fn a_pickup_run_is_skipped_while_an_architect_run_on_the_repository_is_still_run
     assert_eq!(result.stdout, "");
     assert_eq!(scenario.claude_calls().len(), 1, "a session was started");
     assert_eq!(scenario.gh_state(), github);
-    assert_eq!(scenario.gh_calls(), gh_calls);
+    assert_eq!(
+        scenario.gh_calls(),
+        [gh_calls, vec![vec!["api".into(), "rate_limit".into()]]].concat()
+    );
     assert_eq!(scenario.entries("work"), [REPO, "widgets-architect"]);
     release(&scenario);
     architect.finish();
@@ -1929,7 +1941,10 @@ fn a_pickup_run_or_an_architect_run_is_skipped_while_a_pickup_runs_dispatched_ru
         assert_eq!(skipped.stdout, "");
         assert_eq!(scenario.claude_calls().len(), 1, "a session was started");
         assert_eq!(scenario.gh_state(), github);
-        assert_eq!(scenario.gh_calls(), gh_calls);
+        assert_eq!(
+            scenario.gh_calls(),
+            [gh_calls, vec![vec!["api".into(), "rate_limit".into()]]].concat()
+        );
         release(&scenario);
         let first = first.finish();
         assert_ended_with_pr(&first, &pr_from(&scenario, "issue-7"), "ready for review");
@@ -2000,7 +2015,10 @@ fn at_a_command_limit_of_2_two_pickup_runs_run_at_once_and_a_third_is_skipped_na
         assert_eq!(skipped.stdout, "");
     }
     assert_eq!(scenario.gh_state(), github);
-    assert_eq!(scenario.gh_calls(), gh_calls);
+    assert_eq!(
+        scenario.gh_calls(),
+        [gh_calls, vec![vec!["api".into(), "rate_limit".into()]; 2]].concat()
+    );
     let reason = "Pickup run skipped: at the Command limit on acme/widgets: \
                   2 Commands are running, pass.command_limit is 2";
     assert_eq!(
@@ -2795,6 +2813,13 @@ fn a_failure_limit_skip_names_every_failure_lowest_first_without_extra_github_re
     assert_eq!(
         scenario.gh_calls(),
         [
+            vec!["api".to_string(), "rate_limit".into()],
+            vec![
+                "api".to_string(),
+                "user".into(),
+                "--hostname".into(),
+                "github.com".into()
+            ],
             vec![
                 "api".to_string(),
                 "repos/acme/widgets/actions/runs?branch=main&event=push&per_page=1".into(),
diff --git a/tests/process.rs b/tests/process.rs
index 242a3965..ecd1fff2 100644
--- a/tests/process.rs
+++ b/tests/process.rs
@@ -3246,7 +3246,10 @@ fn a_pickup_run_is_skipped_while_a_process_with_no_issue_is_still_running() {
     );
     assert!(scenario.claude_calls().is_empty(), "a session started");
     assert_eq!(scenario.gh_state(), github);
-    assert_eq!(scenario.gh_calls(), gh_calls);
+    assert_eq!(
+        scenario.gh_calls(),
+        [gh_calls, vec![vec!["api".into(), "rate_limit".into()]]].concat()
+    );
     assert_eq!(scenario.issue_labels(7), ["ready-for-agent"]);
     release(&scenario);
     let process = process.finish();