diff --git a/GLOSSARY.md b/GLOSSARY.md
index 86c51361f..94bd5c353 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -49,6 +49,7 @@ _Avoid_: Claim limit (former name), WIP limit, concurrency (it counts issues wai
 
 **Command limit**:
 The number of live **Commands** on one repository on one machine at which a **Pass** there is skipped, set in the **User config**, one by default. Every live Command counts, a Ticket run started by hand on an **Issue URL** included, together with the Spec run or Ticket run each Pass dispatched, but only a Pass is ever skipped for it: a Command a person types always runs. Passes of different kinds may run side by side up to the limit, but never two **Architect runs** or two **Security runs** on one repository at once. It counts no other repository; load across a machine is the **User config**'s memory and load waits.
+An Experiment independently holds back every Pass of its OS account across the machine's repositories, including while it waits for live Runs to end.
 _Avoid_: Pass lock (former, one-wide form), concurrency limit, parallel
 
 **Sweep**:
@@ -147,7 +148,8 @@ One **Command** that investigates a **Report** or an existing open issue by a **
 _Avoid_: intake
 
 **Pass**:
-An **Architect run**, a **Pickup run**, a **Security run**, a **Review run** started with `--author`, a **Fix run** started with no pull request, a **Triage run** started with neither a **Report** nor an **Issue URL**, or a **Custom process** started with no issue and neither an Issue-branch nor a Spec-branch worktree: a **Command** started with no **Issue URL**, which decides before any work whether it is skipped. Such a Custom process is skipped when the repository is at its **Command limit** on the machine, and it does not take an Architect run's Ready-issue or Architect-idea gates; a file declaring either branch worktree needs an issue, and a Custom process started with an issue is not a Pass. Every Pass is skipped while an **Experiment** is live on its machine, including one still waiting for live Runs to end.
+An **Architect run**, a **Pickup run**, a **Security run**, a **Review run** started with `--author`, a **Fix run** started with no pull request, a **Triage run** started with neither a **Report** nor an **Issue URL**, or a **Custom process** started with no issue and neither an Issue-branch nor a Spec-branch worktree: a **Command** started with no **Issue URL**, which decides before any work whether it is skipped. Such a Custom process is skipped when the repository is at its **Command limit** on the machine, and it does not take an Architect run's Ready-issue or Architect-idea gates; a file declaring either branch worktree needs an issue, and a Custom process started with an issue is not a Pass.
+Every Pass is skipped while an **Experiment** is live on its machine for the same OS account, including one still waiting for live Runs to end. A Command started on an Issue URL still runs, with a warning that it competes with the Experiment's Trials.
 _Avoid_: tick, cycle
 
 **Process**:
@@ -432,7 +434,7 @@ What a **Grader** decides about one **Trial** against its **Eval task**'s succes
 _Avoid_: grade, rating, feedback
 
 **Experiment**:
-The **Command** that compares a **Baseline arm** with a **Candidate arm** on the **Eval suites** a change touches, against a **Bar** fixed before it starts, and ends in a **Verdict**. It shows whether the change makes the agents better or worse before it reaches production.
+The **Command** that compares a **Baseline arm** with a **Candidate arm** on the **Eval suites** a change touches, against a **Bar** fixed before it starts, and ends in a **Verdict**. It waits for the same OS account's other live Commands on its machine before starting Trials, including on resume; the Day shift can bypass the wait, with the number of competing Commands recorded beside the Verdict.
 _Avoid_: replay, eval run, benchmark run, A/B test
 
 **Bar**:
diff --git a/console/tests/experiments.test.cjs b/console/tests/experiments.test.cjs
index 0f4cca443..e296f9366 100644
--- a/console/tests/experiments.test.cjs
+++ b/console/tests/experiments.test.cjs
@@ -2,12 +2,68 @@ const { test, before, after } = require('node:test');
 const assert = require('node:assert/strict');
 const { spawn, execFileSync } = require('node:child_process');
 const { once } = require('node:events');
-const { mkdtemp, mkdir, writeFile, rm } = require('node:fs/promises');
-const { tmpdir } = require('node:os');
+const { mkdtemp, mkdir, readFile, writeFile, rm } = require('node:fs/promises');
+const { tmpdir, hostname } = require('node:os');
 const { join, resolve } = require('node:path');
 const { createInterface } = require('node:readline');
 const { chromium } = require('./playwright.cjs');
 const fixture = require('./fixtures/experiments.cjs');
+const { replaceRecord } = require('./records.cjs');
+
+test('the Inbox names the Commands blocking a waiting Experiment', async t => {
+  const folder = join(home, '.thirdshift/logs/acme/widgets/commands/experiment');
+  await mkdir(folder, { recursive: true });
+  const stat = await readFile(`/proc/${process.pid}/stat`, 'utf8');
+  const start = `${(await readFile('/proc/sys/kernel/random/boot_id', 'utf8')).trim()}:${stat.slice(stat.lastIndexOf(') ') + 2).trim().split(/\s+/)[19]}`;
+  const now = new Date().toISOString();
+  const path = join(folder, 'host-wait.command.json');
+  await replaceRecord(path, JSON.stringify({
+    version: 1, kind: 'Experiment', repository: 'acme/widgets', name: 'host-wait', issue: null,
+    hostname: hostname(), process_id: process.pid, process_start: start, harness: 'claude',
+    model: null, effort: null, started_at: now, ended_at: null, outcome: null, cause: null,
+    session_log: null, issue_branch: null, pull_request: null,
+    stages: [{ name: 'Waiting for Commands', began_at: now, session_log: null }],
+    waiting_for: ['Ticket run unique/blocker#7 <script>']
+  }));
+  t.after(() => rm(folder, { recursive: true, force: true }));
+  for (const viewport of [{ width: 1440, height: 900 }, { width: 390, height: 844 }]) {
+    const context = await browser.newContext({ viewport });
+    try {
+      const page = await context.newPage();
+      await page.goto(origin);
+      const row = page.locator('.command').filter({ hasText: 'host-wait' }).first();
+      assert.match(await row.locator('.now').textContent(), /Waiting for Commands.*Ticket run unique\/blocker#7 <script>/);
+      assert.equal(await row.locator('script').count(), 0);
+      assert.equal(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth), true);
+    } finally { await context.close(); }
+  }
+});
+
+test('host waits and bypassed Command counts appear on Experiment pages and lists', async t => {
+  t.after(() => fixture.save(home, fixture.record()));
+  for (const viewport of [{ width: 1440, height: 900 }, { width: 390, height: 844 }]) {
+    const context = await browser.newContext({ viewport });
+    try {
+      const page = await context.newPage();
+      const waiting = fixture.record();
+      waiting.waiting_for = ['Ticket run acme/widgets#7 <script>'];
+      await fixture.save(home, waiting);
+      await page.goto(`${origin}/experiments/${fixture.id}`);
+      assert.match(await page.locator('.experiment-lead').textContent(), /Waiting for Commands: Ticket run acme\/widgets#7 <script>/);
+      assert.equal(await page.locator('.experiment-lead script').count(), 0);
+      await page.goto(`${origin}/experiments`);
+      assert.match(await page.locator('.experiment-row .now').textContent(), /Waiting for Commands: Ticket run acme\/widgets#7/);
+      const completed = fixture.finish(fixture.record());
+      Object.assign(completed, { no_wait: true, commands_at_start: 2 });
+      await fixture.save(home, completed);
+      for (const route of [`/experiments/${fixture.id}`, '/experiments']) {
+        await page.goto(`${origin}${route}`);
+        assert.equal(await page.locator('.experiment-contention').textContent(), 'Started with --no-wait: 2 other Commands live at start');
+        assert.equal(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth), true);
+      }
+    } finally { await context.close(); }
+  }
+});
 
 test('passing cheaper Candidates share the Verdict line with JSON and text on desktop and phone', async t => {
   const value = fixture.finish(fixture.record());
diff --git a/docs/experiment-results.md b/docs/experiment-results.md
index 0d7621119..830e94bf4 100644
--- a/docs/experiment-results.md
+++ b/docs/experiment-results.md
@@ -1,4 +1,4 @@
-# Experiment results (format 10)
+# Experiment results (format 11)
 
 `thirdshift experiments <id> --json` emits one UTF-8 JSON object matching
 `Experiment` below. `thirdshift experiments --json` emits an array of those
@@ -9,8 +9,8 @@ These results complement the [Eval task input format](eval-tasks.md) and
 
 ## Stability and versioning
 
-`format: 10` identifies this result contract. All fields and types below, their
-presence/null rules, enum values and meanings are stable within format 10.
+`format: 11` identifies this result contract. All fields and types below, their
+presence/null rules, enum values and meanings are stable within format 11.
 Adding, removing, renaming or retyping a field, changing its meaning or presence
 rules, or changing an enum requires a new format number and an updated document
 and drift test in the same change. Readers should reject unsupported formats.
@@ -20,6 +20,9 @@ Model names and Void causes) vary with the Experiment. Unknown measurements are
 `null`, never zero. Timestamps are RFC 3339 strings; paths are JSON strings local
 to the machine retaining the Experiment.
 
+Format 11 adds `waiting_for`, `no_wait` and `commands_at_start`: the live host
+wait and the number of other live Commands at a start using `--no-wait`.
+
 The private `experiment.json` already has `format: 1`. The CLI view projects its
 metadata and retained evidence; it is not a copy of that internal storage file.
 Older CLI builds without a `format` field predate this documented contract.
@@ -213,6 +216,13 @@ change in any state without changing the Experiment's identity, Bar or results.
 true on later resumes. These fields do not participate in Experiment identity
 or the Bar.
 
+`waiting_for` lists the other live Commands this invocation is waiting for on
+the same machine and OS account; it is empty outside that wait. `no_wait` says
+whether the latest invocation bypassed the wait. `commands_at_start` counts its
+other live Commands at startup with `--no-wait`, zero otherwise. These facts
+are saved on each start or resume and displayed beside the Verdict; older
+Experiments default to an empty list, false and zero.
+
 `running_trials` gives active Trial IDs and start times. `sessions` inventories
 retained Trial Sessions: opaque Session ID, Trial ID, zero-based attempt index
 and whether the readable file is an OTLP trace. Read one with
@@ -433,7 +443,7 @@ Trial files, rejecting undocumented, missing and retyped fields recursively.
     }
   },
   "Experiment": {
-    "format": 10,
+    "format": 11,
     "name": "string",
     "name_set": "boolean",
     "id": "string",
@@ -453,6 +463,9 @@ Trial files, rejecting undocumented, missing and retyped fields recursively.
     "resume_command": "string?",
     "command_log": "string?",
     "release": "boolean",
+    "waiting_for": ["string"],
+    "no_wait": "boolean",
+    "commands_at_start": "integer",
     "created_at": "string",
     "tasks": [{"suite": "string", "name": "string"}],
     "running_trials": [{"id": "string", "started_at": "string"}],
diff --git a/docs/guide.md b/docs/guide.md
index 997169926..d4d5840ac 100644
--- a/docs/guide.md
+++ b/docs/guide.md
@@ -22,6 +22,15 @@ A [Ticket run](#what-a-ticket-run-does), one issue in and one pull request out,
 
 Architect, Pickup and Security runs, `review --author <login>`, and `fix` with no PR target are **Passes**, as is a Custom process started with no issue and no Issue-branch worktree: they take no Issue URL, so your operating system's scheduler can start them. A Custom process started with an issue is not a Pass. A file that declares an Issue-branch worktree is refused when no issue is given, before any session, rather than skipped. See [A Pickup run on a schedule](#a-pickup-run-on-a-schedule), [Architect runs every few minutes](#architect-runs-every-few-minutes) for Architect runs, and [Security runs on a schedule, with fixing allowed](#security-runs-on-a-schedule-with-fixing-allowed) for Security runs.
 
+Every Pass, including Triage with no Report or Issue URL and a Custom process
+started with no issue, skips before work while an Experiment of the same OS
+account is live on this machine, across all repositories. A waiting Experiment
+counts too. The Activity log names the Experiment, once per change of reason,
+and the Pass exits successfully. This includes the nightly Security run.
+Commands started on an Issue or pull request URL still run, with a warning on
+stderr that they will compete with the Experiment's Trials. Existing Runs keep
+running; Passes on other machines carry on.
+
 Every session runs on the **Harness** you choose: Claude Code by default, or Codex, Antigravity CLI, Grok Build, Muse Code, OpenCode or Kimi Code. See [Harness, Model and Effort](#harness-model-and-effort).
 
 ## What a Ticket run does
@@ -1216,6 +1225,21 @@ Harness, Model or Effort comparison with the same build in both Arms.
 Before building either Arm, an Experiment names every selected approved Eval
 task missing a `[trial]` table. This check also precedes the release Baseline probe.
 
+At startup and on resume, an Experiment becomes live, so every Pass of the same
+OS account on this machine skips. Before starting Trials, it waits for that
+account's other live Commands across repositories to end. Its Command log,
+`status` and the Console name the Commands it waits on and refresh the list as
+they end. Stop or interrupt during the wait ends the Experiment cleanly as
+interrupted; resuming waits again. Multiple waiting Experiments take turns once
+the other Commands have ended.
+
+Use `thirdshift experiment <candidate> --no-wait` to start immediately. Results
+record `no_wait: true` and `commands_at_start`, the number of other live Commands
+at this invocation's start, displayed beside the Verdict in text and the Console.
+A normal invocation records `no_wait: false` and zero. `waiting_for` names the
+current blockers and is empty after the wait. These fields do not change the Bar
+or Experiment identity. The structured Console API option is `no_wait: true`.
+
 For an **A/A Experiment**, use one commit and the same flags in both Arms.
 This measures how often the Arms disagree when nothing differs, so you can
 assess ordinary Trial variation before weighing a change. For example:
@@ -1747,7 +1771,7 @@ That includes a changed discriminating list or any changed Difficulty reading
 for its retained Eval tasks, even when the new reading stays inside the band.
 `thirdshift experiments --json` lists them and `thirdshift experiments <id>
 --json` shows one. Both use the versioned
-[Experiment results format](experiment-results.md), identified by `format: 10`.
+[Experiment results format](experiment-results.md), identified by `format: 11`.
 The starting command's `--json` ends with one JSON line
 containing the Verdict and suite intervals alongside the Trial results and Arm
 minutes. Both views also show each Arm's tokens by observed Model and its cost
@@ -1805,7 +1829,7 @@ versions or end times where those facts were not retained.
 Each invocation that does work keeps a Command record, Command log and Activity
 log lines under `<logs.dir>/JacobStephens2/thirdshift/commands/experiment/`
 (the Activity log is at the repository level). The record names both Arms and
-the Bar and moves through Arm builds, Eval tasks and Trials. It appears in the
+the Bar and moves through Waiting for Commands when needed, Arm builds, Eval tasks and Trials. A waiting Command record includes `waiting_for`, an array of Command names; it is omitted when empty. It appears in the
 Inbox: a pass goes in Done, and a fail, inconclusive Verdict or waiting rechecks
 go in Needs you. Rechecking a Score updates the latest invocation's Command
 outcome and Inbox group alongside the saved Verdict, keeping its completion time.
diff --git a/site/architecture/index.html b/site/architecture/index.html
index 33b448293..330647724 100644
--- a/site/architecture/index.html
+++ b/site/architecture/index.html
@@ -265,6 +265,7 @@ <h1>Architecture</h1>
       <p>The Console's Scores and Bug origins pages read the CLI's retained weekly samples and origin views. Human Scores use the same validation, machine lock and atomic checkpoint write as <code>scores &lt;pull request&gt; --mine</code>; model Scores are withheld from the form response until all five human Scores are saved. Bug-origin Confirm, Correct and Reject call the CLI settlement operation, including its Eval-task proposals and withdrawals. Both pages keep the Console's sign-in, CSRF checks and Themes, and start no work.</p>
       <p>For Evals, the hidden <code>--trial</code> flag runs one Code review, Spec review or Built-in or Custom process through the same session code in a prepared repository. A Code review reviews the historical diff and keeps both axis reports without fixing or publishing anything. A process Trial runs its Steps through the local Ticket source, stopping before its first publishing Step. Its Arm names a Process or <code>.toml</code> file, defaulting to <code>ticket-run</code>; Processes needing GitHub before publication are refused at start. Preparation freezes each Process and its referenced home skills by SHA-256, records every Step's Harness, Model and Effort, and checks the frozen files before every Trial. Each Trial gets its own copies in its fresh home. Steps, sessions, times and usage stay under the Experiment and join its Trace. A delivered Trial passes only when its code Grader passes both fail-to-pass and pass-to-pass selectors on the final commit with the reference fix’s tests and changed shared fakes overlaid. Python selectors search the repository after the standard library, so a committed module cannot replace one. Checks run offline in bwrap under the Bar’s timeout; failed Scores retain the failing selector. Stopped-to-ask and failed do not pass, with outcome counts beside the Verdict. Its versioned JSON result and separate output folder keep Trials out of the Inbox and the Usual ranges. <a href="https://github.com/JacobStephens2/thirdshift/blob/main/docs/trial.md">Trial protocol</a>.</p>
       <p><code>thirdshift experiment <wbr>&lt;candidate&gt;</code> owns the two Arms, the fixed Bar and an alternating Trial queue with two workers. Before building an Arm, apart from the release Baseline probe, it shows the remaining Trials, their worst case under the Bar's timeout and an estimate from earlier Experiments' completed Trials per suite and exact Arm setup: build, Harness, Model, Effort and Process. Estimates include priced dollars when that history has complete accounting. It asks on a terminal unless given <code>--yes</code>. Code Graders retain mechanical Scores; fresh model Graders score written criteria from shuffled blind packets on a configured Model outside both Arms when available. One retained-call module owns expected panel identities, capture, pending counts, executable work, complete report inputs and durable publication. Estimates and resume reject unreadable or malformed saved calls with pair, seat and order context before paid work, including later calls behind missing orders. A Grader panel fixed in the Bar grades each pair of process Trials with fresh sessions per seat and presentation order, and reports each seat's calls and the family or per-Model majority beside the Verdict, or counts its merge calls when the Bar does; its estimate per seat and its spend, priced from the frozen table, stay apart from the Arms' cost, and its optional per-run spending limit pauses grading; the Bar's people setting can count readers' blind merge calls on seeded queues instead, with the panel standing in on unread pairs when both are counted. Scores retain reasons, wrong findings and borderline marks. The Verdict module computes paired suite intervals, with borderline counts, Arm minutes, tokens by Model, reported cost and Void counts and causes shown beside the Experiment's Verdict. Trial and model Grader Session traces and code Grader spans share its Command's Trace. Void Trials retry fresh up to twice under the Bar's cause rules, exhausted tasks leave both Arms, and more than a tenth dropped makes the Verdict inconclusive. Repeated Trial-only memory-cap stops produce an Arm finding. Its Command outcome puts a pass in Done and a fail or inconclusive Verdict in Needs you. Its Command record and logs live under thirdshift's repository; private Trial results and Grader artifacts stay under <code>~/.thirdshift/<wbr>evals/<wbr>experiments/</code>. Both workers stop scheduling at a Claude or Codex quota window at 85%, or a Claude rejection, and a Trial cut short is void. A Claude warning with no readable utilization also pauses the Experiment. It supports resume after that pause or interruption, Inbox observation and Stop. <a href="/docs/#experiments">Experiments</a>.</p>
+      <p>Every Pass checks for a live Experiment of the same OS account on this machine before its Command limit and before work. It skips with the Experiment named in its Activity log, including while the Experiment waits for existing Commands across repositories to end. Manually targeted Commands still run with a warning. The Experiment publishes its live record before waiting, names the remaining Commands in its log, status and Console, and starts Arm builds and Trials after they end. Stop interrupts this wait cleanly. <code>--no-wait</code> bypasses it and saves the competing Command count beside the Verdict. Existing Runs and other machines carry on.</p>
       <p>Each Experiment freezes a dated token price table, using the bundled standard rates or <code>--prices &lt;file.json&gt;</code>. Every session is priced by observed Model and attributed to its starting Step, including Resumes and fallbacks. Missing usage or a missing price makes the Trial Void with an accounting-gap cause. Retained accounting reports Trial, role and Arm costs and times, with paired median Candidate-to-Baseline ratios from complete, non-Void Trials. Usage-limit pauses between invocations add no Trial time. Frozen comparison prices remain separate from Harness-reported costs.</p>
       <p><code>evals propose-process &lt;repository&gt;</code> retains merged Ticket fixes as private proposed process Eval tasks. Separate test overlays, shared fakes and command-vector selectors stay with each manifest. Host preparation screens fail-to-pass selectors against disposable base and merge checkouts with network access and refuses changed inline Rust tests. Trial preparation exposes neither the fix nor its tests. The process suite declares three Trials and dependencies on its five Factory skills, Built-in processes and the shared Session prompt, Harness, Model and Effort sources.</p>
       <p>A prepared Trial runner owns retries, pauses and ordered publication; the two workers submit an Eval task, Arm and Trial index. Fresh execution and recovery follow the saved Bar's cause list and remaining retry budget. Recovery publishes already terminal pending history without another attempt, including after a publication failure, and never replays a retained pause. Attempt results, pending history and terminal results publish while the Trial's execution evidence remains live.</p>
diff --git a/site/docs/index.html b/site/docs/index.html
index 19efe72f5..948487acc 100644
--- a/site/docs/index.html
+++ b/site/docs/index.html
@@ -71,6 +71,14 @@
 <li><strong><a href="#triage-runs">Triage run</a></strong>, <code>thirdshift triage</code>: investigates a <strong>Report</strong> and files shaped issues, or recommends them with <code>--recommend-only</code>.</li>
 </ul>
 <p>Architect, Pickup and Security runs, <code>review --author &lt;login&gt;</code>, and <code>fix</code> with no PR target are <strong>Passes</strong>, as is a Custom process started with no issue and no Issue-branch worktree: they take no Issue URL, so your operating system&#39;s scheduler can start them. A Custom process started with an issue is not a Pass. A file that declares an Issue-branch worktree is refused when no issue is given, before any session, rather than skipped. See <a href="#a-pickup-run-on-a-schedule">A Pickup run on a schedule</a>, <a href="#architect-runs-every-few-minutes">Architect runs every few minutes</a> for Architect runs, and <a href="#security-runs-on-a-schedule-with-fixing-allowed">Security runs on a schedule, with fixing allowed</a> for Security runs.</p>
+<p>Every Pass, including Triage with no Report or Issue URL and a Custom process
+started with no issue, skips before work while an Experiment of the same OS
+account is live on this machine, across all repositories. A waiting Experiment
+counts too. The Activity log names the Experiment, once per change of reason,
+and the Pass exits successfully. This includes the nightly Security run.
+Commands started on an Issue or pull request URL still run, with a warning on
+stderr that they will compete with the Experiment&#39;s Trials. Existing Runs keep
+running; Passes on other machines carry on.</p>
 <p>Every session runs on the <strong>Harness</strong> you choose: Claude Code by default, or Codex, Antigravity CLI, Grok Build, Muse Code, OpenCode or Kimi Code. See <a href="#harness-model-and-effort">Harness, Model and Effort</a>.</p>
 </div></details>
 <details class="fold"><summary><h2>What a Ticket run does</h2></summary>
@@ -1315,6 +1323,19 @@
 Harness, Model or Effort comparison with the same build in both Arms.
 Before building either Arm, an Experiment names every selected approved Eval
 task missing a <code>[trial]</code> table. This check also precedes the release Baseline probe.</p>
+<p>At startup and on resume, an Experiment becomes live, so every Pass of the same
+OS account on this machine skips. Before starting Trials, it waits for that
+account&#39;s other live Commands across repositories to end. Its Command log,
+<code>status</code> and the Console name the Commands it waits on and refresh the list as
+they end. Stop or interrupt during the wait ends the Experiment cleanly as
+interrupted; resuming waits again. Multiple waiting Experiments take turns once
+the other Commands have ended.</p>
+<p>Use <code>thirdshift experiment &lt;candidate&gt; --no-wait</code> to start immediately. Results
+record <code>no_wait: true</code> and <code>commands_at_start</code>, the number of other live Commands
+at this invocation&#39;s start, displayed beside the Verdict in text and the Console.
+A normal invocation records <code>no_wait: false</code> and zero. <code>waiting_for</code> names the
+current blockers and is empty after the wait. These fields do not change the Bar
+or Experiment identity. The structured Console API option is <code>no_wait: true</code>.</p>
 <p>For an <strong>A/A Experiment</strong>, use one commit and the same flags in both Arms.
 This measures how often the Arms disagree when nothing differs, so you can
 assess ordinary Trial variation before weighing a change. For example:</p>
@@ -1844,7 +1865,7 @@
 That includes a changed discriminating list or any changed Difficulty reading
 for its retained Eval tasks, even when the new reading stays inside the band.
 <code>thirdshift experiments --json</code> lists them and <code>thirdshift experiments &lt;id&gt; --json</code> shows one. Both use the versioned
-<a href="https://github.com/JacobStephens2/thirdshift/blob/main/docs/experiment-results.md">Experiment results format</a>, identified by <code>format: 10</code>.
+<a href="https://github.com/JacobStephens2/thirdshift/blob/main/docs/experiment-results.md">Experiment results format</a>, identified by <code>format: 11</code>.
 The starting command&#39;s <code>--json</code> ends with one JSON line
 containing the Verdict and suite intervals alongside the Trial results and Arm
 minutes. Both views also show each Arm&#39;s tokens by observed Model and its cost
@@ -1899,7 +1920,7 @@
 <p>Each invocation that does work keeps a Command record, Command log and Activity
 log lines under <code>&lt;logs.dir&gt;/JacobStephens2/thirdshift/commands/experiment/</code>
 (the Activity log is at the repository level). The record names both Arms and
-the Bar and moves through Arm builds, Eval tasks and Trials. It appears in the
+the Bar and moves through Waiting for Commands when needed, Arm builds, Eval tasks and Trials. A waiting Command record includes <code>waiting_for</code>, an array of Command names; it is omitted when empty. It appears in the
 Inbox: a pass goes in Done, and a fail, inconclusive Verdict or waiting rechecks
 go in Needs you. Rechecking a Score updates the latest invocation&#39;s Command
 outcome and Inbox group alongside the saved Verdict, keeping its completion time.
diff --git a/site/how-it-works/index.html b/site/how-it-works/index.html
index b6fbdedf6..47382cb90 100644
--- a/site/how-it-works/index.html
+++ b/site/how-it-works/index.html
@@ -311,7 +311,8 @@ <h1>How thirdshift works</h1>
       <p>A suite with fewer than 20 discriminating Eval tasks is an <strong>Advisory suite</strong>: it keeps its Verdict and intervals, but cannot pass or block a release. The Bar saves this minimum before the first Trial; <code>--min-discriminating-tasks</code> sets it for one Experiment, and changing it refuses resume. Only suites that are not advisory decide the overall Verdict, Void dropout guard and required rechecks. When every suite is advisory, the Verdict is inconclusive. CLI text, JSON and the Console mark Advisory suites; the Console also shows judged and measurement counts. The release summary lists each Advisory suite and its Verdict, and asks whether to release when the overall Verdict is fail or inconclusive, including when all suites are advisory. Saved Experiments without the minimum keep their original Bar and Verdict.</p>
       <p>Each process Trial's Session traces are checked for the real fix's identifiers. Pending hits hold the Verdict for your decision in the Console or with <code>thirdshift experiments &lt;id&gt; --leak &lt;hit-id&gt; confirm|dismiss --reason '…'</code>. Dismissals keep the Trial and remain auditable; confirmation makes it Void. Decisions retain the reviewer, time and reason.</p>
       <p>Optional <code>--cost-ceiling</code> and <code>--time-ceiling</code> fix Candidate/Baseline ratio limits in the Bar before Trials. Both default off; a paired median above either ceiling fails the Experiment. The Verdict also reports credibly cheaper or faster Candidates, or higher cost or time, alongside the unchanged quality decision.</p>
-      <p>Experiment JSON identifies its documented result contract with <code>format: 10</code>. The <a href="https://github.com/JacobStephens2/thirdshift/blob/main/docs/experiment-results.md">Experiment results format</a> covers retained Trial files, leak decisions, pair evidence, the Grader panel's calls, people's blind pairwise calls, Scores, recheck history, suite Verdicts and the Bar.</p>
+      <p>Every Pass skips across repositories while an Experiment of the same OS account is live on this machine, including nightly Security and a Custom process with no issue; the Activity log names the Experiment. Manually targeted Commands still run and warn that they compete with its Trials. On start or resume, an Experiment waits for other live Commands before building Arms or starting Trials. Its log, status and the Console show the wait and the remaining Commands. Stop interrupts the wait cleanly. <code>--no-wait</code> starts immediately and records the competing Command count beside the Verdict. Existing Runs finish and other machines carry on.</p>
+      <p>Experiment JSON identifies its documented result contract with <code>format: 11</code>. The <a href="https://github.com/JacobStephens2/thirdshift/blob/main/docs/experiment-results.md">Experiment results format</a> covers retained Trial files, leak decisions, pair evidence, the Grader panel's calls, people's blind pairwise calls, Scores, recheck history, suite Verdicts and the Bar.</p>
       <p>Review commits, local-origin pushes and repository reports do not void a Trial. Changing its issue text, declared inputs or commits under review does. Review Trials' mechanical checks grade a private copy of the prepared repository captured before the session.</p>
       <p>The Console's Experiments list groups Running, Needs you and Done, newest first. Open one to watch Trials fill in, then see the Verdict by suite. The page compares Arms, folds the Bar and opens a Trial or Eval task in the Peek with Grader reasons and links to Session logs or Session traces. Details stays beside the Trials grid as you scroll on desktop and opens at the bottom on phones. Rechecks stay in the CLI, with copyable commands and a filter for their Eval tasks.</p>
       <p>The Bar has a pass level and a fail level, 70% and 95% by default. Set them with <code>--pass-level</code> and <code>--fail-level</code> before the first Trial. Each metric fails if its interval at the fail level is wholly below zero; otherwise it passes if its interval at the pass level sits above the margin, and is otherwise inconclusive. A pass whose pass-level interval lies wholly below zero is marked worse, within the margin, without changing the decision. The Verdict shows both intervals, and the forecast uses the same decision. Saved Experiments retain their original Bar and Verdict, including the older rule that a pass also reach zero. At the 70% default, a simulated A/A Experiment passes about 67% of the time on today's 10 code-review Eval tasks and 56% on 30 Spec-review tasks; reaching 80% needs about 20 and about 80 tasks.</p>
diff --git a/site/index.html b/site/index.html
index 56483710b..7b9c5921f 100644
--- a/site/index.html
+++ b/site/index.html
@@ -504,6 +504,7 @@ <h2 id="grows-title">Seven workflows</h2>
         <details class="workflow">
           <summary>Experiments</summary>
           <div class="workflow-content">
+            <p>While an Experiment of the same OS account is live on this machine, every Pass skips across repositories, including nightly Security and an issue-less Custom process. Its Activity log names the Experiment. Manually targeted Commands still run with a warning. Experiments wait for other live Commands before building Arms or starting Trials; status and the Console name the wait. <code>--no-wait</code> bypasses it and records the competing Command count beside the Verdict. Existing Runs finish, and other machines carry on.</p>
             <p>Custom process and home-skill content identifies each Arm. Editing either starts a new Experiment with separate estimate history; unchanged inputs resume their frozen Experiment. Process grading shares one Bar timeout across snapshot preparation and all test selectors.</p>
             <p>After each process Trial, a leak check searches its Session traces for the real fix's identifiers. Review pending hits in the Console or with <code>thirdshift experiments &lt;id&gt; --leak &lt;hit-id&gt; confirm|dismiss --reason '…'</code>. The Verdict waits for your decisions. Dismissals keep the Trial on an auditable false-positive list; confirmation makes it Void. Each decision names its reviewer.</p>
             <p><a href="/docs/#experiments">Experiments</a> compare a Candidate with a Baseline on private Eval suites. <code>thirdshift experiment <wbr>&lt;candidate&gt;</code> shows its Trials’ worst-case session-minutes, with an estimate where this machine has history, and asks on a terminal unless given <code>--yes</code>, then builds both Arms and runs interleaved Trials with two workers, a fixed Bar and resume after interruption or a Paused Command outcome at a quota stop (85% for Claude and Codex, a Claude rejection, or a Claude warning with no readable utilization). Trials and Graders run in bwrap sandboxes. Code Graders score mechanical checks offline from report packets and a private grading repository, then fresh model Graders score written criteria from blind packets with provider-only access. Graders cannot read raw Trial logs, Arm mappings or the Experiment’s other files. Results show the Verdict, wrong findings, borderline marks, paired intervals, each Arm's minutes, tokens by Model, reported cost and Void causes. Trials and Graders join the Command's Trace. Void Trials retry fresh up to twice; an exhausted task drops out of both Arms. More than a tenth of judged tasks dropped in suites that are not advisory makes the overall Verdict inconclusive.</p>
diff --git a/src/command_limit.rs b/src/command_limit.rs
index b138a3bb8..2c5f0a14a 100644
--- a/src/command_limit.rs
+++ b/src/command_limit.rs
@@ -13,8 +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 live Experiment, then quota admission, comes before any GitHub call,
+//! remote preparation and slot acquisition. Either 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
@@ -85,6 +86,7 @@ impl NotAdmitted {
 
 #[derive(Debug)]
 enum Why {
+    Experiment(String),
     QuotaWait(String),
     /// `running` Commands are running, at or over the limit.
     AtLimit {
@@ -100,12 +102,13 @@ enum Why {
 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),
+        match &self.why {
+            Why::Experiment(id) => write!(f, "Experiment {id} is live on this machine"),
+            Why::QuotaWait(reason) => f.write_str(reason),
             Why::AtLimit { running } => write!(
                 f,
                 "at the Command limit on {repo}: {}, pass.command_limit is {limit}",
-                commands_running(running)
+                commands_running(*running)
             ),
             Why::SameKind(kind) => write!(f, "{} is already running on {repo}", kind.name()),
             Why::Older => write!(f, "an older thirdshift's Pass is running on {repo}"),
@@ -113,16 +116,28 @@ impl fmt::Display for NotAdmitted {
     }
 }
 
-/// 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> {
+/// Check for a live Experiment, then quota, before any GitHub call, remote
+/// preparation or Command-limit slot. A failed Experiment read is left to
+/// [`hold_pass`]; probe failures other than exhaustion preserve the existing
+/// admission behavior.
+pub fn early_skip(repo: &Repo, limit: NonZeroUsize) -> Option<NotAdmitted> {
+    let why = match live_experiment().ok().flatten() {
+        Some(id) => Why::Experiment(id),
+        None => Why::QuotaWait(crate::github::GitHub::new().pass_quota_wait()?),
+    };
     Some(NotAdmitted {
         repo: repo.clone(),
         limit,
-        why: Why::QuotaWait(crate::github::GitHub::new().pass_quota_wait()?),
+        why,
     })
 }
 
+fn live_experiment() -> Result<Option<String>> {
+    Ok(crate::logs::live_commands()?
+        .into_iter()
+        .find_map(|command| command.experiment))
+}
+
 /// "1 Command is running", or "`n` Commands are running".
 fn commands_running(n: usize) -> String {
     match n {
@@ -137,6 +152,12 @@ fn commands_running(n: usize) -> String {
 /// Command runs all the same, only Passes don't count it.
 pub fn hold_slot(repo: &Repo) {
     let taken = (|| {
+        hold(crate::host_work::hold_command()?);
+        if let Some(id) = live_experiment()? {
+            crate::progress::step(format!(
+                "warning: Experiment {id} is live on this machine; this Command will compete with its Trials"
+            ));
+        }
         let slots = Slots::of(repo)?;
         let _counting = slots.counting()?;
         let free = slots.count()?.free;
@@ -160,6 +181,14 @@ pub fn hold_pass(
     limit: NonZeroUsize,
     sharing: Sharing,
 ) -> Result<Option<NotAdmitted>> {
+    let work = crate::host_work::hold_command()?;
+    if let Some(id) = live_experiment()? {
+        return Ok(Some(NotAdmitted {
+            repo: repo.clone(),
+            limit,
+            why: Why::Experiment(id),
+        }));
+    }
     let slots = Slots::of(repo)?;
     let _counting = slots.counting()?;
     let skipped = |why| {
@@ -195,6 +224,7 @@ pub fn hold_pass(
         hold(lock);
     }
     hold(legacy);
+    hold(work);
     Ok(None)
 }
 
diff --git a/src/console/experiments/render.rs b/src/console/experiments/render.rs
index b2f7c098f..43c3ab5c0 100644
--- a/src/console/experiments/render.rs
+++ b/src/console/experiments/render.rs
@@ -24,6 +24,13 @@ struct Status {
 }
 
 fn status(view: &View) -> Status {
+    if active(view) && !view.details.waiting_for.is_empty() {
+        return Status {
+            label: "Waiting for Commands",
+            tone: "working",
+            group: 0,
+        };
+    }
     match view.verdict.as_ref().map(|v| &v.verdict) {
         Some(Conclusion::WaitingOnLeaks) => Status {
             label: "Waiting on leak decisions",
@@ -87,6 +94,12 @@ fn total(view: &View) -> usize {
         .sum()
 }
 fn now(view: &View) -> String {
+    if active(view) && !view.details.waiting_for.is_empty() {
+        return format!(
+            "Waiting for Commands: {}",
+            view.details.waiting_for.join(", ")
+        );
+    }
     let Some(verdict) = &view.verdict else {
         return format!(
             "Trials {} of {}, {} running{}",
@@ -199,13 +212,19 @@ pub(super) fn list(views: &[View]) -> String {
                 .as_ref()
                 .map(|path| path.to_string_lossy().into_owned())
                 .unwrap_or_default();
-            html.push_str(&format!("<li class=\"command experiment-row\" tabindex=\"0\" id=\"experiment-{id}\" data-tone=\"{}\" data-command=\"{}\" data-peek=\"{}\"><div class=\"row-head\">{} <span class=\"subject\"><a href=\"/experiments/{id}\">{}</a></span><span class=\"issue-title\">{}</span><time class=\"age\">{}</time></div><p class=\"now\">{}</p>{}<p class=\"harness\">{}</p><p><a href=\"/experiments/{id}\">Experiment</a> · {}</p></li>", tone(view), esc(&command), esc(&crate::logs::status::inspect::url("/peek", &command, None)), tag(view), esc(&view.name), esc(view.details.title.as_deref().unwrap_or("")), when(view.details.ended_at.as_deref().unwrap_or(&view.created_at)), esc(&now(view)), list_intervals(view), builds(view), command_links(view)));
+            html.push_str(&format!("<li class=\"command experiment-row\" tabindex=\"0\" id=\"experiment-{id}\" data-tone=\"{}\" data-command=\"{}\" data-peek=\"{}\"><div class=\"row-head\">{} <span class=\"subject\"><a href=\"/experiments/{id}\">{}</a></span><span class=\"issue-title\">{}</span><time class=\"age\">{}</time></div><p class=\"now\">{}</p>{}{}<p class=\"harness\">{}</p><p><a href=\"/experiments/{id}\">Experiment</a> · {}</p></li>", tone(view), esc(&command), esc(&crate::logs::status::inspect::url("/peek", &command, None)), tag(view), esc(&view.name), esc(view.details.title.as_deref().unwrap_or("")), when(view.details.ended_at.as_deref().unwrap_or(&view.created_at)), esc(&now(view)), contention(view), list_intervals(view), builds(view), command_links(view)));
         }
         html.push_str("</ul></details>");
     }
     html
 }
 
+fn contention(view: &View) -> String {
+    view.details.contention().map_or_else(String::new, |line| {
+        format!("<p class=\"experiment-contention\">{}</p>", esc(&line))
+    })
+}
+
 /// What the Experiment asks, in words: the change between its arms, the suites
 /// it is judged on and what counts as worse, or that it tests no change at all.
 fn question(view: &View) -> String {
@@ -298,6 +317,7 @@ pub(super) fn detail(view: &View, csrf: &str, can_act: bool) -> String {
         }
     }
     html.push_str(&leaks(view, csrf, can_act));
+    html.push_str(&contention(view));
     html.push_str(&verdict(view));
     html.push_str(&people(view));
     if view.description.baseline.process.is_some() || view.description.candidate.process.is_some() {
diff --git a/src/console/openapi.rs b/src/console/openapi.rs
index 9619349ad..055786521 100644
--- a/src/console/openapi.rs
+++ b/src/console/openapi.rs
@@ -535,7 +535,9 @@ fn span() -> Value {
 
 fn experiment() -> Value {
     object(json!({
-        "format": {"type": "integer", "const": 10}, "id": {"type": "string"},
+        "format": {"type": "integer", "const": 11}, "id": {"type": "string"},
+        "waiting_for": array(json!({"type":"string"})),
+        "no_wait": {"type":"boolean"}, "commands_at_start": {"type":"integer"},
         "name": {"type": "string"}, "state": {"type": "string"}, "created_at": {"type": "string"},
         "tasks": array(json!({"type": "object"})), "results": array(json!({"type": "object"})),
         "sessions": array(json!({"type": "object"})), "running_trials": array(json!({"type": "object"}))
diff --git a/src/console/start/experiment.rs b/src/console/start/experiment.rs
index 11bd76290..0367ea181 100644
--- a/src/console/start/experiment.rs
+++ b/src/console/start/experiment.rs
@@ -50,7 +50,7 @@ pub(in crate::console) fn properties() -> Value {
     ] {
         properties.insert(key.into(), json!({"type":"integer"}));
     }
-    for key in ["release", "yes"] {
+    for key in ["release", "yes", "no_wait"] {
         properties.insert(key.into(), json!({"type":"boolean"}));
     }
     for key in ["suite", "panel_seat", "people_reader"] {
@@ -89,7 +89,7 @@ pub(super) fn arguments(options: Option<&BTreeMap<String, Value>>) -> Result<Vec
             args.push(candidate.into());
         } else if value.is_boolean() {
             if value == true {
-                args.push(format!("--{key}"));
+                args.push(format!("--{}", key.replace('_', "-")));
             }
         } else if let Some(items) = value.as_array() {
             let flag = format!("--{}", key.replace('_', "-"));
diff --git a/src/evals/experiment.rs b/src/evals/experiment.rs
index 3fb9ee3dc..2e20c879c 100644
--- a/src/evals/experiment.rs
+++ b/src/evals/experiment.rs
@@ -2,6 +2,7 @@
 //! recording stays in the ordinary logs; private Eval data stays here.
 
 mod accounting;
+mod coordination;
 mod cost;
 pub(crate) mod deciders;
 mod difficulty;
@@ -422,6 +423,7 @@ pub fn run(options: Options) -> Result<()> {
     let result = (|| {
         experiment.state = State::Running;
         experiment.save()?;
+        coordination::start(&mut experiment, options.no_wait)?;
         logs::stage(logs::Stage::ArmBuilds);
         if experiment.description.prepared.is_none() {
             let description = &experiment.description;
@@ -476,6 +478,8 @@ pub fn run(options: Options) -> Result<()> {
         .as_ref()
         .err()
         .map(|error: &anyhow::Error| format!("{error:#}"));
+    logs::waiting_for(&[]);
+    experiment.details.waiting_for.clear();
     if result.is_err() {
         experiment.state = if interrupt::requested() {
             State::Interrupted
@@ -613,7 +617,9 @@ const PAIR_USAGE: &str = "experiments <id> --pair <pair-id> [--merge <ready|not-
 fn resume_args(mut args: impl Iterator<Item = String>) -> Vec<String> {
     let mut kept = Vec::new();
     while let Some(arg) = args.next() {
-        if arg == "--json" || arg == "--release" || !arg.starts_with("--") {
+        if matches!(arg.as_str(), "--json" | "--release" | "--yes" | "--no-wait")
+            || !arg.starts_with("--")
+        {
             kept.push(arg);
         } else if arg == "--name" {
             args.next();
diff --git a/src/evals/experiment/coordination.rs b/src/evals/experiment/coordination.rs
new file mode 100644
index 000000000..903ce8f56
--- /dev/null
+++ b/src/evals/experiment/coordination.rs
@@ -0,0 +1,62 @@
+//! Publish the Experiment before draining host work, so all new Passes skip.
+use std::time::{Duration, Instant};
+
+use anyhow::Result;
+
+use super::store::Stored;
+use crate::{interrupt, logs, poll, progress};
+
+pub(super) fn start(experiment: &mut Stored, no_wait: bool) -> Result<()> {
+    experiment.details.no_wait = no_wait;
+    experiment.details.commands_at_start = if no_wait {
+        logs::live_commands()?.len()
+    } else {
+        0
+    };
+    experiment.details.waiting_for.clear();
+    experiment.save()?;
+    if no_wait {
+        progress::step(experiment.details.contention().unwrap());
+        return Ok(());
+    }
+    let mut previous = Vec::new();
+    let mut last_line = Instant::now();
+    loop {
+        interrupt::check()?;
+        let mut commands = logs::live_commands()?;
+        let busy = crate::host_work::busy()?;
+        // Waiting Experiments must not wait on one another forever. Once
+        // ordinary work has drained, a stable order admits exactly one; the
+        // others keep waiting until its Trials and Graders have finished.
+        if !busy
+            && commands.iter().all(|command| {
+                command.experiment.is_some()
+                    && command.waiting
+                    && std::process::id() < command.process_id
+            })
+        {
+            commands.clear();
+        }
+        let mut waiting: Vec<_> = commands.into_iter().map(|command| command.name).collect();
+        if waiting.is_empty() && busy {
+            waiting.push("Commands starting or ending on this machine".into());
+        }
+        waiting.sort();
+        if waiting.is_empty() {
+            logs::waiting_for(&[]);
+            experiment.details.waiting_for.clear();
+            experiment.save()?;
+            return Ok(());
+        }
+        if waiting != previous || last_line.elapsed() >= Duration::from_secs(30) {
+            logs::stage(logs::Stage::WaitingForCommands);
+            progress::step(format!("Waiting for Commands: {}", waiting.join(", ")));
+            logs::waiting_for(&waiting);
+            experiment.details.waiting_for = waiting.clone();
+            experiment.save()?;
+            previous = waiting;
+            last_line = Instant::now();
+        }
+        poll::sleep(Duration::from_secs(1))?;
+    }
+}
diff --git a/src/evals/experiment/options.rs b/src/evals/experiment/options.rs
index baccc2e98..3fe90dddf 100644
--- a/src/evals/experiment/options.rs
+++ b/src/evals/experiment/options.rs
@@ -19,6 +19,7 @@ pub struct Options {
     pub(super) json: bool,
     pub(super) release: bool,
     pub(super) yes: bool,
+    pub(super) no_wait: bool,
     pub(super) name: Option<String>,
     pub(super) prices: Option<std::path::PathBuf>,
 }
@@ -58,6 +59,7 @@ enum ArgumentKind {
     Json,
     Release,
     Yes,
+    NoWait,
     ValuedFlag,
     Positional,
 }
@@ -67,6 +69,7 @@ fn argument_kind(word: &str) -> ArgumentKind {
         "--json" => ArgumentKind::Json,
         "--release" => ArgumentKind::Release,
         "--yes" => ArgumentKind::Yes,
+        "--no-wait" => ArgumentKind::NoWait,
         flag if flag.starts_with("--") => ArgumentKind::ValuedFlag,
         _ => ArgumentKind::Positional,
     }
@@ -124,6 +127,7 @@ pub fn parse(args: &[String]) -> Result<Options> {
     let mut json = false;
     let mut release = false;
     let mut yes = false;
+    let mut no_wait = false;
     let mut args = args.iter();
     while let Some(arg) = args.next() {
         match argument_kind(arg) {
@@ -139,6 +143,10 @@ pub fn parse(args: &[String]) -> Result<Options> {
                 ensure!(!yes, "repeated --yes");
                 yes = true;
             }
+            ArgumentKind::NoWait => {
+                ensure!(!no_wait, "repeated --no-wait");
+                no_wait = true;
+            }
             ArgumentKind::ValuedFlag => {
                 let value = args
                     .next()
@@ -263,7 +271,7 @@ pub fn parse(args: &[String]) -> Result<Options> {
     }
     Ok(Options {
         candidate: candidate.context(
-            "usage: thirdshift experiment <candidate> [--baseline <ref>] [--suite <name>] [--json] [--yes]",
+            "usage: thirdshift experiment <candidate> [--baseline <ref>] [--suite <name>] [--json] [--yes] [--no-wait]",
         )?,
         baseline,
         baseline_setup,
@@ -274,6 +282,7 @@ pub fn parse(args: &[String]) -> Result<Options> {
         json,
         release,
         yes,
+        no_wait,
         name,
         prices,
     })
diff --git a/src/evals/experiment/reading.rs b/src/evals/experiment/reading.rs
index dbf087b1f..4221289ee 100644
--- a/src/evals/experiment/reading.rs
+++ b/src/evals/experiment/reading.rs
@@ -121,7 +121,7 @@ impl Observation {
     // and the Experiment metadata already loaded by Stored.
     fn project(self, stored: &Stored) -> View {
         View {
-            format: 10,
+            format: 11,
             name: stored.name(),
             name_set: stored.name.is_some(),
             description: stored.description.clone(),
diff --git a/src/evals/experiment/store.rs b/src/evals/experiment/store.rs
index b3e8d9b7d..41c335f13 100644
--- a/src/evals/experiment/store.rs
+++ b/src/evals/experiment/store.rs
@@ -79,6 +79,12 @@ pub(crate) struct View {
 /// Facts for readers; these never participate in Experiment identity or the Bar.
 #[derive(Clone, Default, Serialize, Deserialize)]
 pub(crate) struct Details {
+    #[serde(default)]
+    pub waiting_for: Vec<String>,
+    #[serde(default)]
+    pub no_wait: bool,
+    #[serde(default)]
+    pub commands_at_start: usize,
     #[serde(default)]
     pub baseline_ref: Option<String>,
     #[serde(default)]
@@ -97,6 +103,18 @@ pub(crate) struct Details {
     pub release: bool,
 }
 
+impl Details {
+    pub(crate) fn contention(&self) -> Option<String> {
+        self.no_wait.then(|| {
+            format!(
+                "Started with --no-wait: {} other Command{} live at start",
+                self.commands_at_start,
+                if self.commands_at_start == 1 { "" } else { "s" }
+            )
+        })
+    }
+}
+
 #[derive(Serialize)]
 pub(crate) struct TaskName {
     pub suite: String,
@@ -523,6 +541,15 @@ impl Stored {
                 .verdict
                 .as_ref()
                 .map_or(String::new(), |verdict| verdict.selection_report());
+            if !view.details.waiting_for.is_empty() {
+                selection.push_str(&format!(
+                    "\nWaiting for Commands: {}",
+                    view.details.waiting_for.join(", ")
+                ));
+            }
+            if let Some(contention) = view.details.contention() {
+                selection.push_str(&format!("\n{contention}"));
+            }
             if self.description.baseline.process.is_some()
                 || self.description.candidate.process.is_some()
             {
diff --git a/src/host_work.rs b/src/host_work.rs
new file mode 100644
index 000000000..2f952986a
--- /dev/null
+++ b/src/host_work.rs
@@ -0,0 +1,33 @@
+//! A Command holds a shared host lock from admission through exit. Experiments
+//! probe it while draining work, covering admitted Commands before their records
+//! are published. It imposes no limit and never refuses a hand-started Command.
+use std::fs::{File, TryLockError};
+
+use anyhow::{Context, Result};
+
+fn open() -> Result<File> {
+    let root = crate::config::home()?.join(".thirdshift");
+    std::fs::create_dir_all(&root)?;
+    let path = root.join("experiment-work.lock");
+    File::options()
+        .create(true)
+        .truncate(false)
+        .write(true)
+        .open(&path)
+        .with_context(|| format!("can't open {}", path.display()))
+}
+
+pub(crate) fn hold_command() -> Result<File> {
+    let lock = open()?;
+    lock.lock_shared()?;
+    Ok(lock)
+}
+
+pub(crate) fn busy() -> Result<bool> {
+    let lock = open()?;
+    match lock.try_lock() {
+        Ok(()) => Ok(false),
+        Err(TryLockError::WouldBlock) => Ok(true),
+        Err(TryLockError::Error(error)) => Err(error.into()),
+    }
+}
diff --git a/src/launch.rs b/src/launch.rs
index 0a9066e47..daa515f9d 100644
--- a/src/launch.rs
+++ b/src/launch.rs
@@ -356,7 +356,7 @@ 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) {
+    if let Some(skipped) = command_limit::early_skip(&repo, limit) {
         return Ok(Start::NotAdmitted(skipped));
     }
     directory.check_identity()?;
diff --git a/src/logs.rs b/src/logs.rs
index df564231f..1705d21ca 100644
--- a/src/logs.rs
+++ b/src/logs.rs
@@ -18,6 +18,8 @@ mod activity;
 mod command_record;
 pub mod dismiss;
 mod effects;
+mod live;
+pub(crate) use live::Command as LiveCommand;
 pub mod export;
 pub(crate) mod github;
 pub mod metrics;
@@ -56,6 +58,17 @@ pub(crate) use command_record::{Issue, TicketRecord, TicketState, experiment_rec
 use effects::OnMachine;
 use recording::Record;
 
+/// Live Commands of this OS account, across repositories, excluding this process.
+pub(crate) fn live_commands() -> anyhow::Result<Vec<LiveCommand>> {
+    // An issue-targeted Custom process takes its slot before recording begins.
+    let configured = record().logs_directory();
+    let root = match configured {
+        Some(root) => root,
+        None => UserConfig::load()?.logs_dir,
+    };
+    live::read(&root)
+}
+
 /// Find only a retained record owned by the process this Console just spawned.
 pub(crate) fn command_for_process(
     config: &UserConfig,
@@ -424,6 +437,10 @@ pub fn stage(stage: Stage) {
     record().stage(stage, None);
 }
 
+pub(crate) fn waiting_for(commands: &[String]) {
+    record().waiting_for(commands);
+}
+
 /// Temporarily overlay the active stage without resetting its timing.
 pub(crate) fn quota_wait(until: Option<&str>) {
     if until.is_some() && record().needs_quota_repo() {
diff --git a/src/logs/command_record.rs b/src/logs/command_record.rs
index 594e1ee3c..4605de6d4 100644
--- a/src/logs/command_record.rs
+++ b/src/logs/command_record.rs
@@ -111,6 +111,8 @@ pub(super) struct CommandRecord {
     #[serde(default)]
     pub run_metrics: Option<super::run_metrics::RunMetrics>,
     pub cause: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub waiting_for: Vec<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub limit: Option<crate::session::limits::Limit>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -245,6 +247,7 @@ stage_names! {
     /// A fixed finding's proof-of-concept recheck against the merged Base
     /// branch, before its private record is closed.
     SecurityCloseCheck => "Security close check",
+    WaitingForCommands => "Waiting for Commands",
     ArmBuilds => "Arm builds",
     EvalTasks => "Eval tasks",
     Trials => "Trials",
@@ -461,6 +464,7 @@ impl CommandRecord {
             outcome: None,
             run_metrics: None,
             cause: None,
+            waiting_for: Vec::new(),
             limit: None,
             resume_command: None,
             issue_branch: None,
diff --git a/src/logs/live.rs b/src/logs/live.rs
new file mode 100644
index 000000000..7898797c7
--- /dev/null
+++ b/src/logs/live.rs
@@ -0,0 +1,35 @@
+//! Same-account, same-machine Commands, counted once through their outer tree.
+use anyhow::Result;
+use chrono::Local;
+
+pub(crate) struct Command {
+    pub name: String,
+    pub experiment: Option<String>,
+    pub process_id: u32,
+    pub waiting: bool,
+}
+
+pub(super) fn read(root: &std::path::Path) -> Result<Vec<Command>> {
+    let commands = super::reading::live_commands(root, Local::now())?;
+    let host = crate::host::name().unwrap_or_else(|| "unknown".into());
+    Ok(commands
+        .iter()
+        .filter_map(|command| {
+            let record = &command.record;
+            if record.hostname != host || record.process_id == std::process::id() {
+                return None;
+            }
+            Some(Command {
+                name: format!("{} {}", super::display_name(&record.kind), record.name),
+                process_id: record.process_id,
+                waiting: !record.waiting_for.is_empty(),
+                experiment: (record.kind == "Experiment").then(|| {
+                    record
+                        .experiment
+                        .as_ref()
+                        .map_or_else(|| record.name.clone(), |experiment| experiment.id.clone())
+                }),
+            })
+        })
+        .collect())
+}
diff --git a/src/logs/reading.rs b/src/logs/reading.rs
index bdabb539f..1557e9281 100644
--- a/src/logs/reading.rs
+++ b/src/logs/reading.rs
@@ -207,17 +207,11 @@ impl Snapshot {
             );
         }
         let ranges = super::usual_range::UsualRanges::from_records(&records);
-        let roots: Vec<_> = records
-            .iter()
-            .filter(|(_, tree)| {
-                let record = &tree.command;
-                record.parent_record.is_none()
-            })
-            .map(|(path, _)| path.clone())
-            .collect();
-        commands.extend(roots.into_iter().map(|path| {
-            Entry::Record(Box::new(tree(&inventory, &path, None, &mut records, &now)))
-        }));
+        commands.extend(
+            command_trees(&inventory, &mut records, &now)
+                .into_iter()
+                .map(|command| Entry::Record(Box::new(command))),
+        );
         for entry in &mut commands {
             if let Entry::Record(command) = entry {
                 health::observe(command, &now, silent, &ranges);
@@ -251,6 +245,38 @@ impl Snapshot {
     }
 }
 
+/// Admission needs only retained Command trees and process identities. In
+/// particular, an unreadable Activity log must not prevent taking a slot.
+pub(super) fn live_commands(root: &Path, now: DateTime<Local>) -> Result<Vec<Command>> {
+    let inventory = Arc::new(Inventory::capture(Arc::new(inventory::Native), root)?);
+    let mut records = BTreeMap::new();
+    for repo in inventory.repositories() {
+        for folder in &repo.folders {
+            records.extend(read_records(&inventory, folder, false)?);
+        }
+    }
+    Ok(command_trees(&inventory, &mut records, &now)
+        .into_iter()
+        .filter(inbox::active)
+        .collect())
+}
+
+fn command_trees(
+    inventory: &Arc<Inventory>,
+    records: &mut BTreeMap<PathBuf, CommandTree>,
+    now: &DateTime<Local>,
+) -> Vec<Command> {
+    let roots: Vec<_> = records
+        .iter()
+        .filter(|(_, tree)| tree.command.parent_record.is_none())
+        .map(|(path, _)| path.clone())
+        .collect();
+    roots
+        .into_iter()
+        .map(|path| tree(inventory, &path, None, records, now))
+        .collect()
+}
+
 /// The Command log `show` and the Console may read for a Process's Steps.
 /// An Other-account log is read only when its canonical path stays under the
 /// accepted log directory, and that canonical path is what is opened. The
diff --git a/src/logs/reading/inbox.rs b/src/logs/reading/inbox.rs
index 1560347fe..45d0321cd 100644
--- a/src/logs/reading/inbox.rs
+++ b/src/logs/reading/inbox.rs
@@ -926,7 +926,7 @@ pub(super) fn active_runs(entries: &[Entry]) -> usize {
         .count()
 }
 
-fn active(command: &Command) -> bool {
+pub(super) fn active(command: &Command) -> bool {
     command.state == "live"
         || command
             .dispatched
diff --git a/src/logs/recording.rs b/src/logs/recording.rs
index 75885e142..f13deeb22 100644
--- a/src/logs/recording.rs
+++ b/src/logs/recording.rs
@@ -176,6 +176,10 @@ impl<O: Outside> Record<O> {
         }
     }
 
+    pub(super) fn logs_directory(&self) -> Option<PathBuf> {
+        self.logs_dir.clone()
+    }
+
     pub(super) fn preflight_repo(&mut self, repo: Option<Repo>) {
         if self.preflight_repo.is_none() {
             self.preflight_repo = repo;
@@ -598,6 +602,13 @@ impl<O: Outside> Record<O> {
         }
     }
 
+    pub(super) fn waiting_for(&mut self, commands: &[String]) {
+        if let Some((_, tree)) = &mut self.command_record {
+            tree.command.waiting_for = commands.to_vec();
+            self.write_record();
+        }
+    }
+
     pub(super) fn resumable(&mut self, command: &str) {
         if let Some((_, tree)) = &mut self.command_record {
             tree.command.resume_command = Some(command.into());
diff --git a/src/logs/status.rs b/src/logs/status.rs
index 49326d7b2..3acfa0a38 100644
--- a/src/logs/status.rs
+++ b/src/logs/status.rs
@@ -281,6 +281,7 @@ pub(super) fn stage_text(command: &Command) -> String {
         command.state,
         command.stage.as_ref(),
         command.health.as_ref(),
+        &command.record.waiting_for,
     )
 }
 
@@ -289,6 +290,7 @@ fn stage_details(
     state: &str,
     stage: Option<&super::reading::CurrentStage>,
     health: Option<&super::reading::Health>,
+    waiting_for: &[String],
 ) -> String {
     if let Some(outcome) = outcome {
         return outcome.to_owned();
@@ -313,6 +315,9 @@ fn stage_details(
             }
         },
     );
+    if state == "live" && !waiting_for.is_empty() {
+        text.push_str(&format!(" · {}", waiting_for.join(", ")));
+    }
     if let Some(health) = health.and_then(super::reading::Health::text) {
         text.push_str(&format!(" · {health}"));
     }
diff --git a/src/logs/status/inbox.rs b/src/logs/status/inbox.rs
index 3addea989..d53f8a298 100644
--- a/src/logs/status/inbox.rs
+++ b/src/logs/status/inbox.rs
@@ -337,6 +337,8 @@ fn present(value: &serde_json::Value, now: DateTime<Local>) -> Result<Row> {
         effort: Option<String>,
         stage: Option<crate::logs::reading::CurrentStage>,
         health: Option<Health>,
+        #[serde(default)]
+        waiting_for: Vec<String>,
         resume_command: Option<String>,
         process_name: Option<String>,
         github_ci: Option<crate::github::InboxCi>,
@@ -462,6 +464,7 @@ fn present(value: &serde_json::Value, now: DateTime<Local>) -> Result<Row> {
             &facts.state,
             facts.stage.as_ref(),
             facts.health.as_ref(),
+            &facts.waiting_for,
         ),
         timing: Timing::new(live, &facts.started_at, facts.ended_at.as_deref(), now),
         count: value["count"].as_u64().unwrap_or(1) as usize,
diff --git a/src/logs/status/text.rs b/src/logs/status/text.rs
index 1a0255504..73a946e2e 100644
--- a/src/logs/status/text.rs
+++ b/src/logs/status/text.rs
@@ -107,6 +107,7 @@ impl Command {
                     &record.view.state,
                     record.view.stage.as_ref(),
                     record.view.health.as_ref(),
+                    &record.facts.waiting_for,
                 );
                 super::print_command_line(
                     &record.facts,
diff --git a/src/main.rs b/src/main.rs
index 7ee978b4c..78c76fce2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -51,6 +51,8 @@ mod harness;
 #[cfg(target_os = "linux")]
 mod host;
 #[cfg(target_os = "linux")]
+mod host_work;
+#[cfg(target_os = "linux")]
 mod implement;
 #[cfg(target_os = "linux")]
 mod interrupt;
@@ -195,10 +197,10 @@ usage: thirdshift <Issue URL>                         Run the factory on the iss
        thirdshift email-test [<address>]              Send a test email through Resend
        thirdshift setup                               Choose defaults and write the User config
        thirdshift evals <action>                      Manage Eval data and Arms, including import-replays; see the manual
-       thirdshift experiment [--release] <candidate> [options]  Compare Arms; --release uses the last tag
+       thirdshift experiment [--release] <candidate> [--no-wait] [options]  Compare Arms after Commands end; --no-wait skips the wait and records competing Command count; --release uses the last tag
        thirdshift experiments [<id>] [--json]        List Experiments or show one; --name renames, --record-difficulty records A/A Difficulty, --leak decides Session evidence hits, --pair reads a pair blind and records your calls
        thirdshift recheck <id> <trial>|--pending|--batch ...  Review or record Score rechecks; see the manual
-       thirdshift status [--all] [--json] [--machine <name> | --local]  List Fleet or local Commands
+       thirdshift status [--all] [--json] [--machine <name> | --local]  List Fleet or local Commands and named Experiment waits, also shown in the Console
        thirdshift cronjobs [--fleet] [--json] | launch-directories [--json]  List schedules or Launch directories
        thirdshift resources [--json]                  Show host memory, CPU load and session limits
        thirdshift start <owner/repo> <issue> [options] [--machine <name>]  Start detached work on a known repository
@@ -233,7 +235,7 @@ Shared options (before or after the Issue URL or number, or after a Pass command
   harness <name>, model <name>, effort <level>  Choose Harness (claude, codex, agy, grok, muse, opencode, kimi), Model and Effort
   security-review / no-security-review  Enable / disable a Ticket or Review run's Security review
   security-fix / no-security-fix     Allow / forbid fixing reproduced Security findings (security-close / no-security-close: closing after merge defaults on)
-Pass commands: architect, pickup, secure, review --author <login>, fix, triage (no supplied work). For architect, pickup, secure, fix and triage, base <branch> selects an origin branch; fix also accepts author <login>.
+Pass commands (no supplied work): architect, pickup, secure, review --author <login>, fix, triage, process <name> without issue. All skip for a live Experiment on this OS account/host; targeted Commands run with a warning. base <branch>: architect/pickup/secure/fix/triage; author <login>: fix.
   --plan-only                        architect or a Custom process's architecture-review; publish and stop (architect: only base and email flags apply)
 Defaults: ~/.thirdshift/config.toml; thirdshift setup writes every setting; commands override User config defaults. Full manual:
   https://thirdshift.app/docs/
diff --git a/src/processes.rs b/src/processes.rs
index 10e120078..3f2252c6a 100644
--- a/src/processes.rs
+++ b/src/processes.rs
@@ -666,7 +666,7 @@ fn run(command: &ProcessRun) -> Result<String> {
             logs::skipped_process(&repo, name, &choice, reason);
             String::new()
         };
-        if let Some(skipped) = command_limit::quota_wait(&repo, config.command_limit) {
+        if let Some(skipped) = command_limit::early_skip(&repo, config.command_limit) {
             return Ok(skip(&skipped));
         }
         let base = match launch::checked_out_base() {
diff --git a/src/processes/review.rs b/src/processes/review.rs
index 44cd55331..35030b325 100644
--- a/src/processes/review.rs
+++ b/src/processes/review.rs
@@ -30,7 +30,7 @@ pub(crate) fn run(command: ReviewArgs) -> Result<String> {
                 progress::step(reason);
                 String::new()
             };
-            if let Some(skipped) = command_limit::quota_wait(&repo, config.command_limit) {
+            if let Some(skipped) = command_limit::early_skip(&repo, config.command_limit) {
                 return Ok(skip(&skipped));
             }
             if let Some(running) = command_limit::hold_pass(
diff --git a/tests/console/start.rs b/tests/console/start.rs
index e06cc1de9..87d117f94 100644
--- a/tests/console/start.rs
+++ b/tests/console/start.rs
@@ -267,7 +267,7 @@ fn api_repeated_completed_experiment_is_successful() {
         &json!({
             "repository":"acme/widgets", "command":"experiment", "experiment": {
                 "candidate":"HEAD", "baseline":"HEAD", "baseline_harness":"claude", "candidate_harness":"codex",
-                "suite":["code-review"], "pass_level":0.95, "fail_level":0.95, "draws":100
+                "suite":["code-review"], "pass_level":0.95, "fail_level":0.95, "draws":100, "no_wait":true
             }
         }),
     );
diff --git a/tests/experiments.rs b/tests/experiments.rs
index c1d56e5d2..7411ea256 100644
--- a/tests/experiments.rs
+++ b/tests/experiments.rs
@@ -66,6 +66,9 @@ mod pairs;
 #[path = "experiments/panel.rs"]
 mod panel;
 
+#[path = "experiments/host.rs"]
+mod host;
+
 #[path = "experiments/update.rs"]
 mod update;
 
@@ -1833,6 +1836,9 @@ fn experiment_records_both_arms_the_bar_logs_stages_and_each_trial() {
     assert_eq!(result.stdout.lines().count(), 1);
     let experiment: Value = serde_json::from_str(&result.stdout).unwrap();
     assert_eq!(experiment["state"], "completed");
+    assert_eq!(experiment["commands_at_start"], 0);
+    assert_eq!(experiment["no_wait"], false);
+    assert_eq!(experiment["waiting_for"], json!([]));
     assert_eq!(experiment["baseline_ref"], "main (merge base)");
     assert_eq!(experiment["candidate_ref"], "candidate");
     assert_eq!(experiment["title"], "Candidate");
diff --git a/tests/experiments/host.rs b/tests/experiments/host.rs
new file mode 100644
index 000000000..311bcbd8d
--- /dev/null
+++ b/tests/experiments/host.rs
@@ -0,0 +1,364 @@
+//! Host-wide Experiment isolation through the public CLI and fake Harnesses.
+use super::*;
+
+fn hold_trials(fixture: &Fixture) -> support::HeldRun {
+    fixture.scenario.agent_does(&format!(
+        "case \"$PWD\" in *--baseline--*) {} ;; *) {} ;; esac",
+        support::concurrency::waits_on("baseline"),
+        support::concurrency::waits_on("candidate")
+    ));
+    let experiment = fixture.scenario.run_until(
+        &Fixture::experiment_args(&[]),
+        &NO_SANDBOX,
+        "started-baseline",
+    );
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while !fixture.scenario.path("started-candidate").exists() {
+        assert!(
+            std::time::Instant::now() < deadline,
+            "both Trials did not start"
+        );
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    experiment
+}
+
+fn waiting_command(fixture: &Fixture, count: usize) -> Value {
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    loop {
+        let status = fixture.scenario.run(&["status", "--json"]);
+        assert_eq!(status.code, Some(0), "{}", status.stderr);
+        let view: Value = serde_json::from_str(&status.stdout).unwrap();
+        if let Some(command) = view["commands"].as_array().unwrap().iter().find(|command| {
+            command["kind"] == "Experiment"
+                && command["state"] == "live"
+                && command["waiting_for"]
+                    .as_array()
+                    .is_some_and(|names| names.len() == count)
+        }) {
+            return command.clone();
+        }
+        assert!(
+            std::time::Instant::now() < deadline,
+            "Experiment did not show {count} waiting Commands: {}",
+            status.stdout
+        );
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+}
+
+#[test]
+fn stop_during_the_host_wait_interrupts_cleanly_and_resume_waits_again() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    fixture
+        .scenario
+        .agent_does_for(7, &support::concurrency::waits_on("ticket"));
+    let mut ticket = fixture.scenario.run_until(&["7"], &[], "started-ticket");
+    let args = Fixture::experiment_args(&[]);
+    let experiment = fixture.scenario.start(&args, &NO_SANDBOX);
+    let waiting = waiting_command(&fixture, 1);
+    let stopped = fixture
+        .scenario
+        .run(&["stop", waiting["name"].as_str().unwrap(), "--json"]);
+    assert_eq!(stopped.code, Some(0), "{}", stopped.stderr);
+    let ended = experiment.finish();
+    assert_eq!(ended.code, Some(1), "{}", ended.stderr);
+    let view = fixture.experiment();
+    assert_eq!(view["state"], "interrupted");
+    assert_eq!(view["results"], json!([]));
+    assert_eq!(view["waiting_for"], json!([]));
+    let mut resumed = fixture.scenario.start(&args, &NO_SANDBOX);
+    waiting_command(&fixture, 1);
+    assert_eq!(
+        fixture.scenario.claude_calls().len(),
+        1,
+        "a Trial started during either wait"
+    );
+    resumed.signal("INT");
+    assert_eq!(resumed.finish().code, Some(1));
+    ticket.signal("TERM");
+    ticket.finish();
+}
+
+#[test]
+fn no_wait_runs_trials_immediately_and_keeps_the_competing_command_count_with_the_verdict() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    fixture.scenario.agent_does_for(
+        7,
+        &format!(
+            "case \"$PWD\" in */trials/*) ;; *) {} ;; esac",
+            support::concurrency::waits_on("ticket")
+        ),
+    );
+    let mut ticket = fixture.scenario.run_until(&["7"], &[], "started-ticket");
+    let result = fixture.run(&["--no-wait"]);
+    assert_eq!(result.code, Some(0), "{}", result.stderr);
+    let view: Value = serde_json::from_str(&result.stdout).unwrap();
+    assert_eq!(view["commands_at_start"], 1);
+    assert_eq!(view["no_wait"], true);
+    assert_eq!(view["results"].as_array().unwrap().len(), 2);
+    let text = fixture
+        .scenario
+        .run(&["experiments", view["id"].as_str().unwrap()]);
+    assert!(
+        text.stdout
+            .contains("--no-wait: 1 other Command live at start"),
+        "{}",
+        text.stdout
+    );
+    ticket.signal("TERM");
+    ticket.finish();
+}
+
+#[test]
+fn an_experiment_waits_visibly_for_a_live_ticket_and_skips_passes_until_it_ends() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    fixture.scenario.agent_does_for(
+        7,
+        &format!(
+            "case \"$PWD\" in */trials/*) {} ;; *) {} ;; esac",
+            support::concurrency::waits_on("trial"),
+            support::concurrency::waits_on("ticket")
+        ),
+    );
+    let mut ticket = fixture.scenario.run_until(&["7"], &[], "started-ticket");
+    fixture
+        .scenario
+        .agent_does(&support::concurrency::waits_on("trial"));
+    fixture
+        .scenario
+        .agent_does_for(9, &support::concurrency::waits_on("ticket9"));
+    fixture.scenario.issue_is(9, "OPEN");
+    let mut second = fixture.scenario.run_until(&["9"], &[], "started-ticket9");
+    let mut experiment = fixture
+        .scenario
+        .start(&Fixture::experiment_args(&[]), &NO_SANDBOX);
+    let waiting = waiting_command(&fixture, 2);
+    assert_eq!(
+        fixture.scenario.claude_calls().len(),
+        2,
+        "a Trial started before the live Commands ended"
+    );
+    assert_eq!(waiting["stage"]["name"], "Waiting for Commands");
+    assert!(
+        waiting["waiting_for"][0]
+            .as_str()
+            .unwrap()
+            .contains("acme/widgets#7")
+    );
+    let text = fixture.scenario.run(&["status"]);
+    let experiment_row = text
+        .stdout
+        .lines()
+        .find(|line| line.starts_with("Experiment "))
+        .unwrap();
+    assert!(
+        experiment_row.contains("Waiting for Commands")
+            && experiment_row.contains("acme/widgets#7")
+            && experiment_row.contains("acme/widgets#9"),
+        "{}",
+        text.stdout
+    );
+    let log = fs::read_to_string(waiting["command_log"].as_str().unwrap()).unwrap();
+    assert!(
+        log.contains("Waiting for Commands") && log.contains("acme/widgets#7"),
+        "{log}"
+    );
+    second.signal("TERM");
+    second.finish();
+    let refreshed = waiting_command(&fixture, 1);
+    assert!(
+        refreshed["waiting_for"][0]
+            .as_str()
+            .unwrap()
+            .contains("acme/widgets#7")
+    );
+    assert_eq!(
+        fixture.scenario.claude_calls().len(),
+        2,
+        "a Trial started while one Command remained"
+    );
+    let pass = fixture.scenario.run(&["pickup"]);
+    assert_eq!(pass.code, Some(0), "{}", pass.stderr);
+    assert!(pass.stderr.contains("Experiment"), "{}", pass.stderr);
+    ticket.signal("TERM");
+    ticket.finish();
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while !fixture.scenario.path("started-trial").exists() {
+        if std::time::Instant::now() >= deadline {
+            experiment.signal("TERM");
+            let ended = experiment.finish();
+            panic!(
+                "Trials did not start after the other Command ended: {}",
+                ended.stderr
+            );
+        }
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    experiment.signal("TERM");
+    experiment.finish();
+}
+
+#[test]
+fn waiting_experiments_take_turns_after_the_live_ticket_ends() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    fixture.scenario.agent_does_for(
+        7,
+        &format!(
+            "case \"$PWD\" in */trials/*) {} ;; *) {} ;; esac",
+            support::concurrency::waits_on("trial"),
+            support::concurrency::waits_on("ticket")
+        ),
+    );
+    let mut ticket = fixture.scenario.run_until(&["7"], &[], "started-ticket");
+    let mut first = fixture
+        .scenario
+        .start(&Fixture::experiment_args(&[]), &NO_SANDBOX);
+    waiting_command(&fixture, 1);
+    let mut second = fixture.scenario.start(
+        &Fixture::experiment_args(&["--candidate-model", "fixture-model"]),
+        &NO_SANDBOX,
+    );
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    loop {
+        let result = fixture.scenario.run(&["status", "--json"]);
+        let view: Value = serde_json::from_str(&result.stdout).unwrap();
+        let waiting = view["commands"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|c| {
+                c["kind"] == "Experiment"
+                    && c["state"] == "live"
+                    && c["waiting_for"].as_array().is_some_and(|v| v.len() >= 2)
+            })
+            .count();
+        if waiting == 2 {
+            break;
+        }
+        assert!(std::time::Instant::now() < deadline, "{}", result.stdout);
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    ticket.signal("TERM");
+    ticket.finish();
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while !fixture.scenario.path("started-trial").exists() && std::time::Instant::now() < deadline {
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    let progressed = fixture.scenario.path("started-trial").exists();
+    let result = fixture.scenario.run(&["status", "--json"]);
+    let view: Value = serde_json::from_str(&result.stdout).unwrap();
+    let waiting = view["commands"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter(|c| {
+            c["kind"] == "Experiment"
+                && c["state"] == "live"
+                && c["stage"]["name"] == "Waiting for Commands"
+        })
+        .count();
+    first.signal("TERM");
+    second.signal("TERM");
+    first.finish();
+    second.finish();
+    assert!(
+        progressed,
+        "neither Experiment started a Trial: {}",
+        result.stdout
+    );
+    assert_eq!(
+        waiting, 1,
+        "waiting Experiments started competing Trials: {}",
+        result.stdout
+    );
+}
+
+#[test]
+fn a_ticket_started_by_hand_runs_and_warns_about_the_live_experiment() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    let mut experiment = hold_trials(&fixture);
+    fixture
+        .scenario
+        .agent_does_for(7, &support::concurrency::waits_on("ticket"));
+    let mut ticket = fixture.scenario.run_until(&["7"], &[], "started-ticket");
+    ticket.signal("TERM");
+    let ended = ticket.finish();
+    assert!(
+        ended.stderr.contains("warning: Experiment")
+            && ended.stderr.contains("will compete with its Trials"),
+        "{}",
+        ended.stderr
+    );
+    experiment.signal("TERM");
+    experiment.finish();
+}
+
+#[test]
+fn every_pass_skips_a_live_experiment_on_another_repository_before_github_or_sessions() {
+    let fixture = Fixture::new();
+    fixture.scenario.launch_git(&["checkout", "main"]);
+    let mut experiment = hold_trials(&fixture);
+    fs::create_dir_all(fixture.scenario.path("home/.thirdshift/processes")).unwrap();
+    fs::write(fixture.scenario.path("home/.thirdshift/processes/host-check.toml"),
+        "version = 1\ndescription = \"Check host\"\n[[steps]]\nname = \"check\"\ncommand = \"printf manual-work\"\n").unwrap();
+    let github = fixture.scenario.gh_state();
+    let calls = fixture.scenario.gh_calls();
+    let sessions = fixture.scenario.claude_calls().len();
+    for args in [
+        vec!["pickup"],
+        vec!["architect"],
+        vec!["secure"],
+        vec!["review", "--author", "acme"],
+        vec!["fix"],
+        vec!["triage"],
+        vec!["process", "host-check"],
+    ] {
+        for _ in 0..2 {
+            let result = fixture.scenario.run(&args);
+            assert_eq!(result.code, Some(0), "{args:?}: {}", result.stderr);
+            assert!(
+                result.stderr.contains("Experiment")
+                    && result.stderr.contains("live on this machine"),
+                "{args:?}: {}",
+                result.stderr
+            );
+            assert!(result.stdout.is_empty(), "{args:?}: {}", result.stdout);
+        }
+    }
+    assert_eq!(fixture.scenario.gh_state(), github);
+    assert_eq!(fixture.scenario.gh_calls(), calls);
+    assert_eq!(fixture.scenario.claude_calls().len(), sessions);
+    let activity = fs::read_to_string(
+        fixture
+            .scenario
+            .path("home/.thirdshift/logs/acme/widgets/activity.log"),
+    )
+    .unwrap();
+    assert_eq!(
+        activity
+            .lines()
+            .filter(|line| line.contains("skipped:") && line.contains("Experiment"))
+            .count(),
+        7,
+        "{activity}"
+    );
+    let manual = fixture
+        .scenario
+        .run(&["process", "host-check", "issue", "7"]);
+    assert_eq!(manual.code, Some(0), "{}", manual.stderr);
+    assert!(
+        manual.stderr.contains("warning: Experiment")
+            && manual.stderr.contains("will compete with its Trials"),
+        "{}",
+        manual.stderr
+    );
+    assert_eq!(manual.stdout, "manual-work\n");
+    experiment.signal("TERM");
+    experiment.finish();
+}
diff --git a/tests/experiments/result_format.rs b/tests/experiments/result_format.rs
index 023595e7a..a0d3c442c 100644
--- a/tests/experiments/result_format.rs
+++ b/tests/experiments/result_format.rs
@@ -91,8 +91,8 @@ fn documented_format_matches_real_experiment_results() {
     assert_eq!(run.code, Some(0), "{}", run.stderr);
     let experiment = fixture.experiment();
     assert_eq!(
-        experiment["format"], 10,
-        "format 10 adds the Grader panel, each pair's diffs and people's blind pairwise calls"
+        experiment["format"], 11,
+        "format 11 adds the host wait and competing Commands at start"
     );
     assert_documented("Experiment", &serde_json::from_str(&run.stdout).unwrap());
     assert!(
diff --git a/tests/support/mod.rs b/tests/support/mod.rs
index 59c8c60a6..61ed6621b 100644
--- a/tests/support/mod.rs
+++ b/tests/support/mod.rs
@@ -620,6 +620,18 @@ impl Scenario {
         self.run_from_until(&self.launch_dir(), args, env, started)
     }
 
+    /// Start a Command whose observable wait may precede any fake session.
+    pub fn start(&self, args: &[&str], env: &[(&str, &str)]) -> HeldRun {
+        let mut command = self.command(args);
+        command.envs(env.iter().copied());
+        HeldRun {
+            child: self
+                .runs
+                .spawn(command.stdout(Stdio::piped()).stderr(Stdio::piped())),
+            exited: false,
+        }
+    }
+
     /// Hold a Run from another clone, sharing this scenario's origin and GitHub.
     pub fn run_from_until(
         &self,