mandrel 2.54.0 → 2.56.0

package/.agents/scripts/single-story-close.js

@@ -44,6 +44,7 @@
  *                              [--no-auto-merge]
  *                              [--wait-merge | --no-wait-merge]
  *                              [--merge-watch-mode <sync|async>]
+ *                              [--rerun-advisory <n>]
  *                              [--override-review-block <reason>]
  *
  * `--override-review-block <reason>` is the one sanctioned way
@@ -225,6 +226,10 @@ runAsCli(import.meta.url, main, {
       ['--wait-merge', 'Force the in-close merge wait.'],
       ['--no-wait-merge', 'Return as soon as the PR is open; do not wait.'],
       ['--max-wait-seconds <n>', 'Per-invocation merge-wait bound.'],
+      [
+        '--rerun-advisory <n>',
+        'How many times this close may re-run a failed ADVISORY (non-required) workflow run before blocking on it. Overrides `delivery.ci.rerunAdvisory` for one invocation; BOTH default to 0, so close spends no CI minutes and issues no GitHub mutation on an advisory red unless you ask. At n > 0 the failed run(s) are re-run within that allowance and the merge wait keeps polling inside its existing budget, landing or blocking on the re-run verdict.',
+      ],
       [
         '--merge-watch-mode <sync|async>',
         'Override delivery.mergeWatch.mode for this invocation only. `async` caps the merge wait to a short probe window and returns the resumable `pending` terminal instead of holding the foreground slot — pass it on every close of a multi-Story run. An invalid value exits non-zero before any phase runs.',

package/.agents/scripts/stories-wave-tick.js

@@ -55,8 +55,8 @@
  *     inFlight: number,
  *     cycleError: string | null,
  *     wedged: { reason, stories: [{ id, unmetBlockers }] } | null,
- *     inFlightReservation: { available, withheld: [{ id, blockedBy, reason, source, paths }], note },
- *     footprintGuard: { mode, withheld: [{ id, blockedBy, scope, source, paths }], advisory, note }
+ *     inFlightReservation: { available, withheld: [{ id, blockedBy, reason, source, paths, attribution }], note },
+ *     footprintGuard: { mode, withheld: [{ id, blockedBy, scope, source, paths, attribution }], advisory, note }
  *   }
  *
  * `inFlightReservation` reports the cross-beat half of the co-dispatch guard
@@ -130,7 +130,10 @@ import { AGENT_LABELS } from './lib/label-constants.js';
 import { parseIds } from './lib/orchestration/resolve-stories.js';
 import { buildStoryAdjacency } from './lib/story-adjacency.js';
 import { expandIdList } from './lib/util/parse-id-list.js';
-import { OVERLAP_SOURCES } from './lib/wave-runner/footprint.js';
+import {
+  OVERLAP_SOURCES,
+  renderScrapeAttribution,
+} from './lib/wave-runner/footprint.js';
 import {
   createProbeContext,
   probeLiveState,
@@ -237,7 +240,10 @@ Output envelope:
           "blockedBy": 4949,
           "reason": "in-flight-earlier-beat",
           "source": "declared-overlap",
-          "paths": ["lib/shared.js"]
+          "paths": ["lib/shared.js"],
+          "attribution": [
+            { "path": "lib/shared.js", "declared": true, "fields": [] }
+          ]
         }
       ],
       "note": "..."
@@ -250,7 +256,14 @@ Output envelope:
           "blockedBy": 4951,
           "scope": "beat",
           "source": "scraped-overlap",
-          "paths": ["lib/other.js"]
+          "paths": ["lib/other.js"],
+          "attribution": [
+            {
+              "path": "lib/other.js",
+              "declared": false,
+              "fields": ["body:Verify"]
+            }
+          ]
         }
       ],
       "advisory": [],
@@ -268,7 +281,10 @@ footprintGuard names each Story withheld from THIS beat by a peer already
 admitted on it — the half that used to be an unreported skip — and every
 entry in either report carries the colliding paths plus a source tag
 (declared-overlap when both changes[] declarations named the path, else
-scraped-overlap from the text evidence). Its "mode" echoes
+scraped-overlap from the text evidence) and an "attribution" list naming, per
+path, the field the scrape read it from ("title", "spec", or "body:<section>"
+— so a path that reached the comparison only because every Story RUNS it in
+"## Verify" says so). Its "mode" echoes
 delivery.deliverRunner.footprintGuard: under "advisory" the collisions are
 detected and listed in "advisory" but never withhold, and dispatch follows the
 declared depends_on edges alone.
@@ -359,7 +375,7 @@ const RESERVATION_REASONS = Object.freeze({
  * @param {object[]|null|undefined} inFlightRecords
  * @param {Array<{id: number, blockedBy: number, source?: string, paths?: string[]}>} withheld
  * @param {Iterable<number>} [foreignHeldIds] Ids held by a foreign lease.
- * @returns {{ available: boolean, withheld: Array<{id: number, blockedBy: number, reason: string, source: string, paths: string[]}>, note: string|null }}
+ * @returns {{ available: boolean, withheld: Array<{id: number, blockedBy: number, reason: string, source: string, paths: string[], attribution: object[]}>, note: string|null }}
  */
 export function buildReservationReport(
   inFlightRecords,
@@ -390,6 +406,7 @@ export function buildReservationReport(
       : RESERVATION_REASONS.EARLIER_BEAT,
     source: w.source ?? OVERLAP_SOURCES.DECLARED,
     paths: w.paths ?? [],
+    attribution: w.attribution ?? [],
   }));
   return {
     available: true,
@@ -421,12 +438,16 @@ export function buildReservationReport(
  */
 export function buildFootprintGuardReport(footprintWithholds, mode) {
   const ledger = Array.isArray(footprintWithholds) ? footprintWithholds : [];
-  const project = ({ id, blockedBy, scope, source, paths }) => ({
+  const project = ({ id, blockedBy, scope, source, paths, attribution }) => ({
     id,
     blockedBy,
     scope,
     source,
     paths,
+    // Story #5265: the per-path field attribution rides the entry itself, so
+    // a consumer reading the envelope never has to re-derive where a scraped
+    // path came from (and cannot get a different answer than the note did).
+    attribution: attribution ?? [],
   });
   const beat = ledger
     .filter((w) => w.scope === WITHHOLD_SCOPES.BEAT && w.enforced)
@@ -453,10 +474,11 @@ export function buildFootprintGuardReport(footprintWithholds, mode) {
 function footprintGuardNote(beat, advisory, mode) {
   const detail = (entries) =>
     entries
-      .map(
-        (w) =>
-          `#${w.id} ← #${w.blockedBy} on ${w.paths.join(', ')} (${w.source})`,
-      )
+      .map((w) => {
+        const scraped = renderScrapeAttribution(w.attribution);
+        const provenance = scraped ? `, scraped from ${scraped}` : '';
+        return `#${w.id} ← #${w.blockedBy} on ${w.paths.join(', ')} (${w.source}${provenance})`;
+      })
       .join('; ');
   if (beat.length > 0) {
     return (
@@ -465,7 +487,9 @@ function footprintGuardNote(beat, advisory, mode) {
       `Each is still eligible and re-admits on a later beat once its peer ` +
       `lands. A ${OVERLAP_SOURCES.SCRAPED} source means the collision came ` +
       `from path evidence in the Story text rather than from either ` +
-      `changes[] declaration.`
+      `changes[] declaration — the 'scraped from' clause names the field ` +
+      `each such path was read out of, so a path only cited in '## Verify' ` +
+      `is distinguishable from an unpredicted edit target.`
     );
   }
   if (advisory.length > 0) {

package/.agents/templates/docs/audit-sweep-runbook.md

@@ -51,6 +51,17 @@ to that declared tally. A mismatch — or a missing tally line — means the rep
 is not trustworthy: a finding was malformed, a severity did not resolve onto the
 canonical scale, or the lens truncated its own output.
 
+The line is read **from the Executive Summary**, and a report declaring it more
+than once fails as `duplicate-tally` naming both lines rather than adopting
+whichever the scan reached first. Prose elsewhere in the report that quotes the
+tally format is a second declaration as far as the check is concerned; move it
+or reword it.
+
+A `###` heading with no severity axis and no field bullets is read as a
+**grouping header**, not as a finding — so a lens that emits `### Robust` with
+`_No findings._` under it contributes zero findings and still cross-checks
+against a zero tally.
+
 `--auto` **fails closed** on any such failure. It exits non-zero having opened
 no Issue and written no ledger, and names the offending report in
 `summary.reportFailures[]`. `--allow-missing-tally` is a `--scan` affordance
@@ -70,6 +81,10 @@ stop surprising you:
 node .agents/scripts/audit-to-stories.js --auto --dry-run
 ```
 
+`--severity` is validated against the canonical scale: a typo (`--severity Hgh`)
+exits non-zero naming the accepted levels rather than silently widening the run
+to every finding.
+
 `--dry-run` performs zero GitHub writes and skips the ledger write, printing
 only the run summary. Read `totals.create` before you let the sweep file
 anything: a first full-scope run over an un-audited repository can propose more
@@ -94,11 +109,24 @@ rejected.
 `--ledger-commit` closes that loop. After the run summary has printed, and only
 when the ledger actually changed, it:
 
-1. creates `chore/audit-ledger-<YYYY-MM-DD>` from the current HEAD,
-2. commits **only** the ledger file, subject
+1. refuses, naming its step, if HEAD is not the base branch or there is no
+   `origin` — before writing anything,
+2. creates `chore/audit-ledger-<YYYY-MM-DD>-<shortsha>` from `origin/<base>`,
+3. commits **only** the ledger file, subject
    `chore(audit): reconcile audit ledger <date>`,
-3. pushes the branch, and
-4. opens a PR against your base branch.
+4. pushes the branch,
+5. opens a PR against your base branch, and
+6. puts the checkout back on the branch it started from.
+
+It prints one line on stderr saying what happened: the branch and the PR URL on
+success, or the skip reason otherwise.
+
+**It is re-runnable.** The `<shortsha>` is the base commit, so a retry on the
+same day does not collide with the branch a failed run left behind — it
+recognises it. A ledger already committed on an **unpushed** ledger branch
+resumes at the push rather than reporting `ledger-unchanged` (the ledger file is
+clean: it is committed, just not pushed). Across a failed push and its retry you
+get exactly one PR.
 
 **Auto-merge is never requested.** The ledger records machine-derived lifecycle
 state, so a human glance before it lands is the point — nominate that reviewer
@@ -123,8 +151,10 @@ Those bodies are **audit prose**, not delivery-ready Specs: they describe a
 symptom and a recommendation, not a scoped change with acceptance criteria a
 worker can verify against.
 
-Do not point `/mandrel-deliver` at a freshly-filed audit Story. Route it through
-`/mandrel-plan` first — the planning pass is where the finding becomes a
+Do not point `/mandrel-deliver` at a freshly-filed audit Story — and as of the
+label guard below, you cannot: `resolve-stories.js` refuses a Story carrying no
+`agent::*` label, naming this step, unless `--allow-unlabelled` is passed. Route
+it through `/mandrel-plan` first — the planning pass is where the finding becomes a
 capability slice with a `## Spec`, real `acceptance[]` items and runnable
 `verify[]` lines. Planning is deliberately not automated here: deciding what a
 finding is worth, and how far the fix should reach, is the judgement the sweep
@@ -172,6 +202,10 @@ to mint labels no taxonomy defines.
 | --- | --- | --- |
 | Non-zero exit, `summary.reportFailures[]` populated | A lens report's tally is missing or disagrees with the parse | Re-run that lens; never downgrade with `--allow-missing-tally` |
 | `ledger.unpersisted: true` in the summary | No `origin`, or HEAD off the base branch | Re-run with `--ledger-commit`, or commit the ledger by hand |
-| `--ledger-commit failed at step "..."` | git or `gh` failed at the named step | Fix the remote/auth and re-run; the summary above it is still valid |
+| `--ledger-commit failed at step "..."` | git or `gh` failed at the named step | Fix the cause and re-run; a retry resumes rather than duplicating, and the summary above it is still valid |
+| `--ledger-commit failed at step "verify-base-branch"` | HEAD is on a feature branch | Check out the base branch and re-run; nothing was committed |
+| `[resolve-stories] ... carries no "agent::*" label` | An unenriched audit Story was named for delivery | Plan it (Step 5), or pass `--allow-unlabelled` deliberately |
+| `[audit-to-stories] --severity "..." is not a severity` | A typo in the floor | Use one of the canonical levels |
+| `duplicate-tally` in `summary.reportFailures[]` | The report declares the tally twice | Reword the prose copy; the Executive Summary line is the declaration |
 | Same findings re-proposed every cycle | The ledger is not being committed | Adopt Step 4 |
 | `totals.create` far larger than the team can absorb | Severity floor too low for a first full-scope run | Raise `--severity` and re-dry-run |

package/.agents/workflows/audit-accessibility.md

@@ -82,9 +82,9 @@ the project is configured.** Before any detection:
 - **Design tokens:** the colour tokens (`tailwind.config.*`, CSS custom
   properties, a theme object) whose literal values you need to compute contrast
   ratios statically.
-- **Runtime target (optional):** the `qa.environments` map (see
-  [_Runtime verification mode_](#step-2-runtime-verification-mode-optional-corroboration))
-  and the navigability route SSOT.
+- **Runtime target (optional):** whatever the shared runtime scaffold in
+  [`helpers/audit-lens-core.md`](helpers/audit-lens-core.md#runtime-pass)
+  resolves. Note only whether one exists; the scaffold owns how it is found.
 
 Record what exists. Every finding downstream is measured against _this
 discovered surface and config_, not a generic ideal. If **no** frontend surface
@@ -135,31 +135,16 @@ Cover every static WCAG dimension:
 
 ## Step 2: Runtime verification mode (optional corroboration)
 
-Static detection is the default and always runs. The runtime pass is
-**conditional** — it runs only when a live target is configured; its absence
-never blocks the static report.
-
-1. **Resolve the target from config — never a hardcoded URL.** Resolve the
-   target through the consumer's `qa.environments.<env>.baseUrl` (via
-   [`resolveQaEnvironment`](../scripts/lib/qa/resolve-qa-contract.js), the same
-   resolver `/qa-run` uses): an `<env>` argument resolves by exact name or
-   origin match; with no argument, enumerate `name → baseUrl` and let the
-   operator pick. If **no** `qa.environments` target is configured, **skip this
-   step** and note in the report that runtime corroboration was unavailable —
-   do not invent a URL and do not start an arbitrary dev server.
-2. **Sample routes from the navigability SSOT.** Draw the routes to exercise
-   from the consumer's route/nav registry (`planning.navigation.navRegistry` /
-   `routeGlobs` — the same SSOT [`/audit-navigability`](audit-navigability.md)
-   reads), sampling a representative set (key personas' landing routes plus any
-   route in the change-set scope) rather than a single hardcoded page.
-3. **Run an accessibility engine per sampled route.** Use the
-   `mcp__chrome-devtools__lighthouse_audit` tool's **Accessibility category**,
-   or run **axe** via the browser tooling, against each sampled `baseUrl`-rooted
-   route. Prefer a production-mode build.
-4. **Median-of-3 or provisional.** Any runtime score or metric is subject to
-   run-to-run variance: capture a **median-of-3** (three runs per route, report
-   the median) before treating a number as authoritative. A single-run value is
-   reported **provisional** and never drives a Critical/High verdict on its own.
+Run the shared runtime scaffold in
+[`helpers/audit-lens-core.md`](helpers/audit-lens-core.md#runtime-pass) — it
+owns target resolution, route sampling, median-of-3, and the two skip reasons
+(no configured target; browser tooling unavailable). This lens's probe is its
+step 3:
+
+- **Run an accessibility engine per sampled route.** Use the
+  `mcp__chrome-devtools__lighthouse_audit` tool's **Accessibility category**, or
+  run **axe** via the browser tooling, against each sampled `baseUrl`-rooted
+  route. Prefer a production-mode build.
 
 Corroborate static findings against the runtime results (a statically-flagged
 contrast defect confirmed by the engine graduates from provisional to
@@ -168,8 +153,8 @@ confirmed), and surface runtime-only violations the static pass could not see.
 ## Report additions
 
 Beyond the shared skeleton, the Executive Summary states the runtime mode's
-status (ran against `<env>` / skipped — no target configured), and the report
+status (ran against `<env>`, or the scaffold's skip reason), and the report
 ends with a **Runtime Verification** section: per-route median-of-3
-accessibility scores when the runtime mode ran, or "_Runtime corroboration
-unavailable — no `qa.environments` target configured._" Drop every claimed
+accessibility scores when the runtime mode ran, or that skip reason verbatim.
+Drop every claimed
 violation that names no concrete element and no specific WCAG success criterion.

package/.agents/workflows/audit-mobile.md

@@ -88,9 +88,9 @@ what they declare:
   explicit `viewport`, a Cypress `viewportWidth`/`viewportHeight`, a
   visual-regression viewport list. This is the project's own statement of which
   form factors it holds itself to.
-- **Runtime target (optional):** the `qa.environments` map (see
-  [*Runtime viewport pass*](#step-3-runtime-viewport-pass-optional-corroboration))
-  and the navigability route SSOT.
+- **Runtime target (optional):** whatever the shared runtime scaffold in
+  [`helpers/audit-lens-core.md`](helpers/audit-lens-core.md#runtime-pass)
+  resolves. Note only whether one exists; the scaffold owns how it is found.
 
 Record the breakpoints, the viewport contract, and the device matrix. Every
 finding downstream is measured against *this discovered baseline*. If the
@@ -192,37 +192,20 @@ fix is a new test, name the viewport and the assertion it should make, not just
 
 ## Step 3: Runtime viewport pass (optional corroboration)
 
-Static detection is the default and always runs. The runtime pass is
-**conditional** — it runs only when a live target is configured; its absence
-never blocks the static report.
-
-1. **Resolve the target from config — never a hardcoded URL.** Resolve the
-   target through the consumer's `qa.environments.<env>.baseUrl` (via
-   [`resolveQaEnvironment`](../scripts/lib/qa/resolve-qa-contract.js), the same
-   resolver `/qa-run` uses): an `<env>` argument resolves by exact name or
-   origin match; with no argument, enumerate `name → baseUrl` and let the
-   operator pick. If **no** `qa.environments` target is configured, **skip this
-   step** and note in the report that runtime corroboration was unavailable —
-   do not invent a URL and do not start an arbitrary dev server.
-2. **Sample routes from the navigability SSOT.** Draw the routes to exercise
-   from the consumer's route/nav registry (`planning.navigation.navRegistry` /
-   `routeGlobs` — the same SSOT [`/audit-navigability`](audit-navigability.md)
-   reads), sampling a representative set (key personas' landing routes plus any
-   route in the change-set scope) rather than a single hardcoded page.
-3. **Drive two form factors per route.** Emulate a **phone** and a **tablet**
-   viewport — `mcp__chrome-devtools__emulate` for a device profile, or
-   `resize_page` for an explicit width/height — then, per route and viewport:
-   take a screenshot, and evaluate the two observables static analysis cannot
-   resolve — whether `document.scrollingElement.scrollWidth` exceeds the
-   viewport width (horizontal overflow), and the rendered box of the
-   interactive controls Step 1 flagged as candidates. Reload after switching
-   form factor so load-time device gates re-run.
-4. **Median-of-3 or provisional.** Any runtime measurement is subject to
-   run-to-run variance: capture a **median-of-3** (three runs per route, report
-   the median) before treating a number as authoritative. A single-run value is
-   reported **provisional** and never drives a Critical/High verdict on its own.
-5. **Leave the viewport as you found it.** Reset the emulation before finishing
-   so a following lens or QA run does not inherit a phone viewport.
+Run the shared runtime scaffold in
+[`helpers/audit-lens-core.md`](helpers/audit-lens-core.md#runtime-pass) — it
+owns target resolution, route sampling, median-of-3, and the two skip reasons
+(no configured target; browser tooling unavailable). This lens's probe is its
+step 3:
+
+- **Drive two form factors per route.** Emulate a **phone** and a **tablet**
+  viewport — `mcp__chrome-devtools__emulate` for a device profile, or
+  `resize_page` for an explicit width/height — then, per route and viewport:
+  take a screenshot, and evaluate the two observables static analysis cannot
+  resolve — whether `document.scrollingElement.scrollWidth` exceeds the viewport
+  width (horizontal overflow), and the rendered box of the interactive controls
+  Step 1 flagged as candidates. Reload after switching form factor so load-time
+  device gates re-run.
 
 Corroborate static findings against the runtime observations (a statically
 flagged fixed width confirmed by a real horizontal overflow graduates from
@@ -233,10 +216,10 @@ that opens off-screen.
 ## Report additions
 
 Beyond the shared skeleton, the Executive Summary states the runtime mode's
-status (ran against `<env>` / skipped — no target configured) and names the
+status (ran against `<env>`, or the scaffold's skip reason) and names the
 narrowest breakpoint the project declares, so a reader can tell what "mobile"
 meant for this run. The report ends with a **Runtime Viewport Pass** section:
-per-route, per-form-factor observations when the runtime mode ran, or
-"*Runtime corroboration unavailable — no `qa.environments` target configured.*"
+per-route, per-form-factor observations when the runtime mode ran, or the
+scaffold's skip reason verbatim.
 Drop every claimed finding that names no concrete element, style rule, or test
 file.

package/.agents/workflows/audit-to-stories.md

@@ -181,6 +181,14 @@ persists, via `carryProvenanceFooters`
 The carry is additive, union-preserving and idempotent, so a resumed persist
 cannot stack footers and a hand-authored fingerprint is never dropped.
 
+**Persist records the ledger and the labels too.** It stamps the seed's
+`audit::<dimension>` labels — the dedup corpus is listed by them, and an indexed
+run answers lookups from that pool without reaching the provider, so a footer
+alone leaves a plan-path Story invisible — and records each Story's
+**attributed** identities. Union-only identities are not recorded: every sibling
+carries every fingerprint, so an owner would be a coin flip; persist says so on
+stderr. Author per-Story `provenance` to record them.
+
 This is deliberately not an authoring step. It used to be: the footers reached
 the seed and stopped there, leaving the authoring agent to notice HTML comments
 in a one-pager and copy them forward — a remembered step, which is to say no
@@ -243,6 +251,14 @@ every Story that has a resolvable blocker with a canonical
 GitHub `blocked_by` relations. An edge whose target was never opened (deduped,
 ledger-suppressed) drops rather than becoming a `blocked by #undefined`.
 
+**This pass also records the ledger.** The `--ids` map is the only artifact
+carrying the numbers just opened, so `--wire-edges` folds in the cross-run
+record: each mapped group's findings are written `filed` against its Issue
+(`--ledger <path>`, default `baselines/audit-ledger.json`; `--dry-run`
+suppresses the write). The record runs **before** the provider loads, so a host
+with no `gh` still remembers what it filed. Without it nothing ever writes
+`filed` and the ledger suppresses nothing.
+
 **Do not skip this.** `/mandrel-deliver` has no other source for this cohort's order:
 its footprint guard ignores the shared provenance footers, so an unwired cohort
 is genuinely unordered and `/mandrel-deliver` will co-dispatch Stories the edges say
@@ -277,31 +293,45 @@ the `classifications` array:
   is skipped by default; flag in the Phase 7 summary so the operator
   can decide whether to reopen.
 
-`routeFinding` is handed a `searchIssues` port adapted from the
-project's existing GitHub provider — the actual search runs against the
-repo's open + closed issues for each sha in the group, and the helper's
-footer-confirmation step filters out false-positive search hits whose
-body mentions the sha in prose without the canonical marker. The
-workflow owns **no** parallel dedup or footer-parsing code: the
-fingerprint, footer round-trip, and routing all live in that one shared
-module.
-
-Dedup runs in **two stages** when a provider resolves: a
-meaning-first **semantic candidate** pass (`searchCandidates`, wired to
-[`lib/findings/semantic-issue-search.js`](../scripts/lib/findings/semantic-issue-search.js))
-runs FIRST and widens the net across open + closed issues; the exact
-**fingerprint / semantic-key** confirmation runs SECOND. A finding whose title
-was reworded but whose *location* is unchanged still confirms against the Issue
-that already tracks that location, because the audit filers stamp a
-location-based `audit-semantic-keys` footer alongside the `audit-fingerprints`
-footer. Filings from the
+`routeFinding` reads open + closed issues through two ports, which **both run
+and union their pools** — the exact `searchIssues` lookup, and the meaning-first
+`searchCandidates` pass wired to
+[`lib/findings/semantic-issue-search.js`](../scripts/lib/findings/semantic-issue-search.js).
+Confirmation then filters that union by footer, dropping hits whose body
+mentions a sha in prose without the canonical marker. A finding reworded but
+unmoved still confirms, because the filers stamp a location-based
+`audit-semantic-keys` footer
+beside `audit-fingerprints`; so do
 [`retro-proposals-graduator`](../scripts/lib/feedback-loop/retro-proposals-graduator.js)
-carry the same canonical `audit-fingerprints` footer, so a sweep recognizes a
-graduator-filed issue and never re-files it.
+filings, which a sweep therefore never re-files.
+
+Where the corpus is pre-fetched — either off the list endpoint or from
+`--issues-file` — the exact lookup is answered from that local index and the
+search API is spent only on findings with no exact hit. The workflow owns **no**
+parallel dedup or footer-parsing code: fingerprint, footer round-trip, and
+routing all live in that one shared module.
+
+### When there is no `gh` CLI
+
+**No GitHub access** (air-gapped): pass `--no-provider` to `--scan`. Every
+group is classified `create` and the operator is told dedupe was skipped — a
+re-run opens duplicates.
+
+**Reachable, but not through `gh`** (a cloud sandbox: no `gh`, no direct API,
+MCP fine): fetch the corpus yourself. List every issue labelled `audit::*` at
+state `all` — `mcp__github__list_issues` or any other path — write the raw
+result as a JSON array, and pass it:
+
+```bash
+node .agents/scripts/audit-to-stories.js --scan --no-provider \
+  --issues-file temp/audits/issues.json --glob "temp/audits/audit-*-results.md"
+```
 
-When no provider is available (e.g. air-gapped dev environment), pass
-`--no-provider` to the `--scan` step — every group is classified
-`create` and the operator is informed that dedupe was skipped.
+Real `skip-open` / `skip-reoccurring` classifications come back. The corpus is
+normalised on load, so a raw list result works as-is; only `number` and `body`
+are read. An unreadable file is a hard error, never a silent fall-back to an
+unchecked run; an **empty** array — a valid first sweep — is reported with its
+count so it cannot pass for a failed fetch.
 
 ### Cross-run ledger
 
@@ -314,8 +344,12 @@ shape). Each entry is keyed by the finding's fingerprint plus a location-based
 (`new | filed | fixed | accepted-risk | regressed`). A finding whose tracking
 Issue was closed as `not_planned` becomes `accepted-risk` and is **suppressed**
 on every later scan; a `fixed` finding that re-appears becomes `regressed`. The
-ledger is written by the unattended `--auto` sweep and by any `--scan --ledger`
-run; the plain `--scan` path leaves it untouched.
+ledger is written by the unattended `--auto` sweep, by any `--scan --ledger`
+run, by the Phase 5c `--wire-edges` pass, and by `plan-persist` on the Phase 5a
+chained path — the two filing paths both record what they filed; the
+plain `--scan` path leaves it untouched. A finding whose resolved Issue is open
+is recorded `filed` and is known on re-detection; a closed Issue still outranks
+that.
 
 ## Phase 7 — Summary & cleanup
 
@@ -391,8 +425,10 @@ The routine shape is **lenses full-scope → dry-run → live with a ledger PR**
 from `delivery.auditToStories.severityFloor` (default `high`, overridable with
 `--severity`), applies the two-stage dedup, reconciles the cross-run ledger,
 and prints a run-summary JSON (create / skip-open / skip-reoccurring /
-suppressed-by-ledger tallies, plus the re-detected open Issue numbers an
-operator may want a "re-detected" comment on). `--dry-run` performs zero GitHub
+suppressed-by-ledger tallies, the `create`-classified group keys the `--ids`
+map is built from, plus the re-detected open Issue numbers an operator may want
+a "re-detected" comment on). It opens no Issues itself, so run Phase 5c after
+filing or the sweep's memory stays empty. `--dry-run` performs zero GitHub
 writes and skips the ledger write, emitting only the summary.
 
 `--auto` **fails closed on any `summary.reportFailures[]` entry** (Phase 1): an

package/.agents/workflows/git-cleanup.md

@@ -5,7 +5,7 @@ description: >-
   `git stash` entries — each step gated by operator confirmation.
 ---
 
-# /git-cleanup [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
+# /git-cleanup [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--include-content-merged] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
 
 `/git-cleanup` folds the four cleanup steps operators routinely run by hand
 after a busy session into a single pipeline with per-step confirmation. It is a
@@ -36,7 +36,7 @@ flags: `node .agents/scripts/git-cleanup.js --help`.
 | --- | --- | --- |
 | **fast-forward-main** | `git fetch origin <base>` then `git merge --ff-only origin/<base>`. | Skipped silently on a dirty tree or a non-fast-forward; otherwise prompts `Fast-forward main by N commit(s)?`. Checks out `<base>` first when HEAD is elsewhere and does **not** restore the prior branch. |
 | **prune-remotes** | `git fetch --prune origin` to drop `refs/remotes/origin/*` GitHub already deleted. | Prompts before pruning. Runs as its own phase regardless of `--remote`. |
-| **branches** | Reaps merged local branches (squash-aware: merged-PR, git-ancestry, and content-equivalence signals), removing an attached worktree first. Also enumerates **remote-only** merged branches. | Prints the candidate list, then prompts `Reap N merged branch(es)?`. `--remote` is required **on top of** `--execute` to delete any `origin/<branch>`. `content-merged` candidates carry a weaker-signal warning. |
+| **branches** | Reaps merged local branches (squash-aware: merged-PR, git-ancestry, and content-equivalence signals), removing an attached worktree first. Also enumerates **remote-only** merged branches. | Prints the candidate list, then prompts `Reap N merged branch(es)?`. `--remote` is required **on top of** `--execute` to delete any `origin/<branch>`. `content-merged` candidates carry a weaker-signal warning, and under `--yes` their **remote** ref is withheld unless `--include-content-merged` is passed (their local ref still goes — it is recoverable from the remote). |
 | **stashes** | Lists every stash and triages it. | Interactive: `drop / keep / quit` per entry (default `keep`). Under `--yes` / `--json`, drops require an explicit `--drop-stashes <ref>` allowlist (repeatable) — there is no "drop all". |
 
 ## Constraint
@@ -49,6 +49,14 @@ Two consequences the flag list alone does not carry: `--remote` deletions cannot
 be undone without re-pushing, and `--exclude '<pattern>'` is the **only** way to
 protect an in-scope merged-PR branch you want to keep.
 
+That irreversibility is why `--yes` and `content-merged` do not combine on their
+own. Content-equivalence says "applying this branch to the base changes nothing"
+— which is true of a squash-merged branch and equally true of one whose every
+change was reverted. An operator answering the prompt sees the weaker-signal
+note and decides; an unattended run has nobody to decide, so it withholds the
+remote delete and says so, and `--include-content-merged` is the decision made
+in advance.
+
 Do **not** run with `--execute` if there is unmerged work that needs saving. The
 fast-forward phase skips on a dirty tree (safe), but the branches phase reaps any
 merged-PR branch in scope unless `--exclude`d.
@@ -59,9 +67,15 @@ merged-PR branch in scope unless `--exclude`d.
 # Preview all four phases (no mutation).
 node .agents/scripts/git-cleanup.js
 
-# Run everything non-interactively, including origin refs.
+# Run everything non-interactively, including origin refs. Branches detected
+# only by content-equivalence keep their origin ref — see the note below.
 node .agents/scripts/git-cleanup.js --execute --remote --yes
 
+# Same, but also delete the origin refs of content-merged branches. Nobody is
+# watching, so opting in is the whole confirmation this delete ever gets.
+node .agents/scripts/git-cleanup.js --execute --remote --yes \
+  --include-content-merged
+
 # Only fast-forward main.
 node .agents/scripts/git-cleanup.js --fast-forward-main --execute
 

package/.agents/workflows/helpers/audit-lens-core.md

@@ -208,6 +208,51 @@ extracted and names any disagreement as a **report failure**
 report whose line is missing or wrong. A parse that silently drops findings is
 otherwise indistinguishable from a clean audit.
 
+## Runtime pass scaffold {#runtime-pass}
+
+Some lenses corroborate their static findings against a live target. Static
+detection is the default and always runs; the runtime pass is **conditional** —
+it runs only when a live target and the browser tooling are both available, and
+its absence never blocks the static report. The steps below are shared by every
+lens that has one, so a lens documents only its own probe.
+
+1. **Resolve the target from config — never a hardcoded URL.** Resolve through
+   the consumer's `qa.environments.<env>.baseUrl` (via
+   [`resolveQaEnvironment`](../../scripts/lib/qa/resolve-qa-contract.js), the
+   same resolver `/qa-run` uses): an `<env>` argument resolves by exact name or
+   origin match; with no argument, enumerate `name → baseUrl` and let the
+   operator pick.
+2. **Sample routes from the navigability SSOT.** Draw the routes to exercise
+   from the consumer's route/nav registry (`planning.navigation.navRegistry` /
+   `routeGlobs` — the same SSOT
+   [`/audit-navigability`](../audit-navigability.md) reads), sampling a
+   representative set (key personas' landing routes plus any route in the
+   change-set scope) rather than a single hardcoded page.
+3. **Run the lens's own probe** against each sampled route. That step, and only
+   that step, is the lens's to document.
+4. **Median-of-3 or provisional.** Any runtime measurement is subject to
+   run-to-run variance: capture a **median-of-3** (three runs per route, report
+   the median) before treating a number as authoritative. A single-run value is
+   reported **provisional** and never drives a Critical/High verdict on its own.
+5. **Leave the environment as you found it.** Reset any emulation — viewport,
+   device profile, colour scheme — before finishing, so a following lens or QA
+   run does not inherit it.
+
+**Skip reasons, and how to report them.** The pass is skipped, never faked, for
+either of two reasons, and the Executive Summary says which:
+
+| Condition | Reported as |
+| --- | --- |
+| No `qa.environments` target is configured | `skipped — no target configured` |
+| The browser tooling is unavailable in this runtime | `skipped — browser tooling unavailable` |
+
+The second is the one an unattended sweep meets: a scheduled run has no browser
+MCP server attached, so a lens that treated "cannot drive" as "nothing found"
+would report a clean runtime section it never ran. Do not invent a URL, do not
+start an arbitrary dev server, and do not fall back to a static-only claim
+dressed as a runtime one — name the skip and let the static findings stand on
+their own.
+
 ## Execution strategy {#execution-strategy}
 
 A lens is a self-contained, read-only unit of work — exactly the shape a

package/.agents/workflows/helpers/deliver-digest.md

@@ -107,11 +107,12 @@ Per-round mechanics: [`acceptance-self-eval.md`](acceptance-self-eval.md).
 
 ## 5. The one creditable full-suite run
 
-**After the self-eval loop's last fix commit, immediately before the push** —
-the credit is keyed on the tree, so any later commit invalidates it. Redraft
-rounds run scoped tests; only this final run needs credit, and a bare
-`npm test` / `pnpm run test` deposits **none**, so close re-runs it. Shape it
-by what `close-validation/gates.js` runs:
+**After the self-eval loop's last fix commit, immediately after the push** —
+the credit is keyed on the tree, not push state: a later commit voids it, a
+push does not, and the backgrounded capture (below) ends the turn. Redraft
+rounds run scoped tests; only this run needs credit, and a bare `npm test` /
+`pnpm run test` deposits **none**, so close re-runs it. Shape it by what
+`close-validation/gates.js` runs:
 
 ```bash
 # CRAP gate on (default) + a `test:coverage` script — writes close's stamp:
@@ -127,7 +128,7 @@ Dispatch it in the **background**: it outruns the host's sync Bash ceiling, and
 Rule 2).
 
 Read the **output**, not the exit code: capture skips — no test run, no
-credit — when nothing changed under the CRAP `targetDirs`. Run the scoped
+credit — when nothing changed under CRAP `targetDirs`. Run the scoped
 projects for the roots you changed plus `verify[]`, not the whole suite.
 
 `verify[]` is scoped entries **plus** this one run: an entry that is itself a