@@ -1187,6 +1187,15 @@ export function extractTriggerPaths(workflowText) {
  * of it before the red lands on `main`. Refusing it would drop the console and
  * dogfood leads this function exists to give. Any other event term, a reordered
  * clause or one event alone is still refused whole.
+ *
+ * ⛔ Stripped is not FORGOTTEN (#24073). The clause decides nothing about paths,
+ * but it decides WHEN: such a job never runs on the PR or in the merge queue.
+ * `jobIfReading` below returns that fact beside the refs, and every row a
+ * path-scheduled job renders carries it to the line the reader reads. Measured
+ * before it did: a `packages/runtime/src/route-ledger.ts` change derived the
+ * Dogfood Regression Gate as "scheduled BY YOUR PATHS" with nothing saying the
+ * PR would never run it, and the first run of its pins was `main`'s push
+ * battery, red.
  */
 const JOB_IF_STATUS_TERM = /(?:^|\s)!\s*cancelled\(\)\s*&&\s*/g;
 const JOB_IF_FULL_BATTERY_TERM =
@@ -1201,12 +1210,27 @@ const JOB_FILTER_OUTPUT_TERM =
  * family keeps whatever verdict it had before.
  */
 export function jobFilterOutputRefs(ifExpression) {
+  return jobIfReading(ifExpression)?.refs ?? null;
+}
+
+/**
+ * The whole reading of a job `if:` — `{ refs, fullBatteryOnly }`, or null on
+ * exactly the refusals `jobFilterOutputRefs` makes, because that function IS
+ * this one with the second half dropped. `fullBatteryOnly` is true when the
+ * full-battery clause was stripped as the last conjunct: the job runs on
+ * `main`'s push and hourly runs and NEVER on a `pull_request` or `merge_group`
+ * event. It is read in the same pass as the refs, from the same text, so the
+ * population and the event fact cannot describe two different `if:`s.
+ */
+export function jobIfReading(ifExpression) {
   if (typeof ifExpression !== 'string') return null;
   let expr = ifExpression.trim();
   const wrapped = /^\$\{\{([\s\S]*)\}\}$/.exec(expr);
   if (wrapped) expr = wrapped[1].trim();
   expr = expr.replace(JOB_IF_STATUS_TERM, ' ').trim();
-  expr = expr.replace(JOB_IF_FULL_BATTERY_TERM, '').trim();
+  const eventFree = expr.replace(JOB_IF_FULL_BATTERY_TERM, '').trim();
+  const fullBatteryOnly = eventFree !== expr;
+  expr = eventFree;
   // One balanced outer paren pair at a time — `(A || B)` is the live spelling.
   for (;;) {
     if (!expr.startsWith('(') || !expr.endsWith(')')) break;
@@ -1227,7 +1251,7 @@ export function jobFilterOutputRefs(ifExpression) {
     if (!m) return null;
     refs.push({ job: m[1], output: m[2] });
   }
-  return refs.length ? refs : null;
+  return refs.length ? { refs, fullBatteryOnly } : null;
 }
 
 /**
@@ -1426,12 +1450,15 @@ const EXTGLOB_CONSTRUCT = /[!?*+@]\(/;
  * The path population a job's `if:` resolves to, or null — the whole of
  * direction 1, assembled from the three readings above.
  *
- * Returns `{ paths, outputs, dropped }`. `paths` is a UNION: the `if:` is an OR
- * of filter outputs, so CI schedules the job when ANY of them matched.
+ * Returns `{ paths, outputs, dropped, fullBatteryOnly }`. `paths` is a UNION:
+ * the `if:` is an OR of filter outputs, so CI schedules the job when ANY of them
+ * matched. `fullBatteryOnly` is `jobIfReading`'s event fact, carried so a row
+ * built from this population can say WHEN CI schedules it (#24073).
  */
 export function jobFilterPopulation(job, filterStepsByOutputSource) {
-  const refs = jobFilterOutputRefs(job.if);
-  if (!refs) return null;
+  const reading = jobIfReading(job.if);
+  if (!reading) return null;
+  const { refs, fullBatteryOnly } = reading;
   const paths = [];
   const outputs = [];
   let dropped = 0;
@@ -1450,12 +1477,12 @@ export function jobFilterPopulation(job, filterStepsByOutputSource) {
     }
     outputs.push(`${ref.job}.${ref.output}`);
   }
-  return paths.length ? { paths, outputs, dropped } : null;
+  return paths.length ? { paths, outputs, dropped, fullBatteryOnly } : null;
 }
 
 /**
  * Every job in one workflow whose `if:` resolves to a path population, WITH the
- * job's own text: `[{ job, name, text, outputs, paths, dropped }]`.
+ * job's own text: `[{ job, name, text, outputs, paths, dropped, fullBatteryOnly }]`.
  *
  * ⛔ No check filter here, and that is the whole reason this is its own
  * function. The caller below drops a job that invokes no discoverable check
@@ -2811,6 +2838,13 @@ export function alwaysRunSteps(entries) {
  * of it runs a command no discovered family accounts for. Both halves are
  * read off the workflow text on every run; nothing here is listed.
  *
+ * ⭐ And WHEN it is scheduled (#24073). A row whose job `if:` ended in the
+ * full-battery clause carries `fullBatteryOnly: true`, read by `jobIfReading`
+ * in the same pass as the population: CI schedules that job for your path on
+ * `main`'s push and hourly runs ONLY — never on this PR, never in the merge
+ * queue. Both renderings print it on the row's own line, so "scheduled BY YOUR
+ * PATHS" cannot be read as "this PR runs it".
+ *
  * ⛔ NOT claimed: that a row is a test, a build or a setup step.
  * `alwaysRunLines` refuses that classification for its own rows and the reason
  * carries unchanged — every rule that separates them is a guess about a step's
@@ -2896,7 +2930,10 @@ export function jobFilteredSteps(entries, paths) {
       }
       if (steps.length === 0) continue;
       counts.named += 1;
-      rows.push({ workflow: file, job: job.name, outputs: job.outputs, hits, dropped: job.dropped, steps });
+      rows.push({
+        workflow: file, job: job.name, outputs: job.outputs, hits, dropped: job.dropped,
+        fullBatteryOnly: job.fullBatteryOnly === true, steps,
+      });
     }
   }
   return { rows, counts };
@@ -11460,6 +11497,37 @@ export function alwaysRunLines(rows, counts) {
   return lines;
 }
 
+/**
+ * The WHEN of a path-scheduled job row, as the one clause both renderings print
+ * on that row's own line (#24073) — or the empty string when the row's job runs
+ * on the PR like any other.
+ *
+ * Read off `row.fullBatteryOnly`, the fact `jobIfReading` took from the job's
+ * own `if:`; ⛔ never keyed on a job name, so a job that gains or loses the
+ * full-battery clause gains or loses the clause here with nothing to update.
+ * The reader it exists for: a dev whose path schedules the Dogfood Regression
+ * Gate, told only "scheduled BY YOUR PATHS", inferred that the PR would run its
+ * pins — and the first run was `main`'s push battery, red.
+ */
+export function fullBatteryOnlyClause(row) {
+  if (row?.fullBatteryOnly !== true) return '';
+  return '⛔ does NOT run on this PR or in the merge queue: its `if:` excludes the pull_request and merge_group events,' +
+    " so its first run on this change is `main`'s push battery, AFTER the merge";
+}
+
+/**
+ * One path-scheduled job row as `--commands` / `--json` print it on stderr — a
+ * named reader rather than an inline template so the line a dispatch is built
+ * from is the line the self-test pins. The WHEN clause sits directly after the
+ * job name, ahead of the step list, because a long step list is where a
+ * trailing clause goes unread.
+ */
+export function jobFilteredNotMeasuredLine(row) {
+  const when = fullBatteryOnlyClause(row);
+  return `      ⊘ NOT MEASURED — [${row.workflow} · ${row.job}]${when ? ` ${when} —` : ''} ${row.steps.length} step(s):` +
+    ` ${row.steps.map((s) => s.step).join(' · ')}`;
+}
+
 /**
  * The path-scheduled CI jobs, rendered (#16285) — printed BELOW the
  * reconciliation, because everything under that total names something OUTSIDE
@@ -11502,8 +11570,9 @@ export function jobFilteredStepLines(rows, counts) {
     '  ⛔ NOT runnable and ⛔ NOT in --commands: every row is CI\'s own shell in CI\'s environment. They sit OUTSIDE the runnable',
     '    total above — running every family named there does NOT cover them, which is the gap this block exists to close.',
     '  ⛔ NOT classified into tests, builds and setup — the same refusal the always-runs tail makes, for the same reason: every rule',
-    '    that tells them apart is a guess about a step\'s intent. What is claimed for a row is only what was measured — YOUR path puts',
-    '    this job on the PR, and nothing above names a family for this step. The reader judges the rest.',
+    '    that tells them apart is a guess about a step\'s intent. What is claimed for a row is only what was measured — YOUR path',
+    '    schedules this job (on this PR unless its row says it does NOT), and nothing above names a family for this step.',
+    '    The reader judges the rest.',
     '  ⇒ The always-runs tail below is the OTHER half of this partition: it reads the jobs CI cannot narrow by path, this one reads',
     '    the jobs your paths narrow it TO — and a job carrying an `if:` is excluded there, which is every job on this list.',
   ];
@@ -11516,8 +11585,10 @@ export function jobFilteredStepLines(rows, counts) {
   for (const row of rows) {
     const via = row.hits.map((h) => `${h.path} ⇢ '${h.pattern}'`).join('; ');
     const dropped = row.dropped ? `, ${row.dropped} glob(s) of it untranslatable and dropped` : '';
+    const when = fullBatteryOnlyClause(row);
     lines.push(
-      `  - [${row.workflow} · ${row.job}]   scheduled by ${via}   (job \`if:\` reads ${row.outputs.join(', ')}${dropped})`,
+      `  - [${row.workflow} · ${row.job}]   scheduled by ${via}   (job \`if:\` reads ${row.outputs.join(', ')}${dropped})` +
+        `${when ? `   ${when}` : ''}`,
     );
     for (const { step, commands } of row.steps) {
       lines.push(`      · ${step}`);
@@ -14346,12 +14417,7 @@ export function machineReadableOutput(mode, { paths, size = null, matchedRows, k
         ` — ${mode === 'json' ? 'under jobFilteredSteps, not in commands' : 'NOT above'}. They are CI's own shell in CI's environment,` +
         ' so there is no local invocation to hand you, and running every command on stdout does ⛔ NOT cover them.',
     );
-    for (const row of jobFiltered.rows) {
-      console.error(
-        `      ⊘ NOT MEASURED — [${row.workflow} · ${row.job}] ${row.steps.length} step(s):` +
-          ` ${row.steps.map((s) => s.step).join(' · ')}`,
-      );
-    }
+    for (const row of jobFiltered.rows) console.error(jobFilteredNotMeasuredLine(row));
     console.error('      ⇒ Run without --commands/--json to see each step printed as CI spells it.');
   }
   // ⭐ The SEVENTH thing stdout deliberately omits (#19172) — and the lane this