@erclx/canon 5.73.0 → 5.74.0

package/src/commands/pr.ts

@@ -23,6 +23,8 @@ import {
 import {
   type CheckRunListing,
   collapseChecks,
+  type RawStatus,
+  requiredChecks,
   withMergeState,
 } from '@/pr/checks'
 import {
@@ -33,6 +35,7 @@ import {
   findEvidenceLocal,
   findEvidencePreview,
   findEvidenceReel,
+  findEvidenceSkips,
   type EvidenceItem,
   type EvidenceReading,
   groupEvidence,
@@ -171,6 +174,8 @@ interface EvidenceOptions extends ReadOptions {
   readonly checklist?: string
   readonly local?: string
   readonly reel?: string
+  readonly localSkip?: string
+  readonly reelSkip?: string
   readonly check?: boolean
 }
 
@@ -433,7 +438,7 @@ type EvidenceRefusal =
 
 const EVIDENCE_REFUSALS: Record<EvidenceRefusal, string> = {
   'check-writes':
-    '--check is a read and renders no body, so it takes none of --preview, --local, --checklist, or --reel. Run the check and the render as two calls.',
+    '--check is a read and renders no body, so it takes none of --preview, --local, --checklist, --reel, --local-skip, or --reel-skip. Run the check and the render as two calls.',
   'gh-failed':
     'gh could not answer for this repository. Name the pull request number.',
   'unreadable-checklist':
@@ -775,6 +780,14 @@ export function register(program: Command): void {
       '--reel <link>',
       'Embed this reel under the address line, filmed at the head, from canon pr frames --reel',
     )
+    .option(
+      '--local-skip <reason>',
+      'Name why no local address is posted, from the reason pr-evidence holds for canon pr local',
+    )
+    .option(
+      '--reel-skip <reason>',
+      'Name why no reel is embedded, from the reason pr-evidence holds for canon pr frames --reel',
+    )
     .option(
       '--check',
       'Report which post-pull-request steps the thread is still owed, rendering nothing',
@@ -854,6 +867,17 @@ export function register(program: Command): void {
         'current, and a passed one replaces it. Like --local it rides on a',
         'checklist or a comparison and never opens a comment alone.',
         '',
+        '--local-skip and --reel-skip each put one line under the addresses,',
+        '**No local preview:** or **No reel:** followed by the text passed, a',
+        'reason code and any one-line message joined to it, folded onto one',
+        'line. Without the flag, a skip line the marked comment already carries',
+        'is carried forward. A skip line is dropped whenever its address or',
+        'reel renders, passed or carried, so a later run that posts the link or',
+        'films the reel replaces it. A passed --local-skip drops a carried',
+        'local address, since that line names no head and would read as live,',
+        'while a carried reel names its head and stays beside --reel-skip. Like',
+        '--local, neither opens a comment alone.',
+        '',
         "A render at a new head also resets the pull request body's UI pass",
         'line, the one `canon pr tick` writes under ## Testing, to unchecked',
         'naming that head. It touches no other body text, leaves a line already',
@@ -893,7 +917,8 @@ export function register(program: Command): void {
         'request changed, and the marked comment carries no **Preview:**',
         'address. A failed deploy reads the same as a skipped one.',
         'The record carries `owed` and the same marked fields. --check refuses',
-        'with --preview, --local, --checklist, or --reel as check-writes.',
+        'with --preview, --local, --checklist, --reel, --local-skip, or',
+        '--reel-skip as check-writes.',
         '',
         'Refusals, read off `reason`:',
         '  unreadable-checklist  --checklist named a path that could not be read,',
@@ -917,6 +942,7 @@ export function register(program: Command): void {
         '  canon pr evidence 1341 --checklist .canon/tmp/handoff/ui-checklist/x.md --json',
         '  canon pr evidence 1341 --local http://localhost:5173 --json',
         '  canon pr evidence 1341 --reel <link from canon pr frames --reel> --json',
+        "  canon pr evidence 1341 --reel-skip 'no-server: <message>' --json",
         '  canon pr evidence 1341 --check --json',
         '',
       ].join('\n'),
@@ -960,7 +986,12 @@ export function register(program: Command): void {
         '            or needing eyes refuses `ui-undriven`, carried or not',
         '  evidence  the evidence check reads settled',
         '  standing  the head is fresh against the base, not stale or conflicted',
-        '  ci        every check run on the tip passed, waited on up to --wait',
+        '  ci        every required check run on the tip passed, waited on up to --wait',
+        '',
+        "The required checks are the ones the base branch's rules list. A",
+        'check outside them is waited on by nobody, and one that failed is',
+        'named in the record as `advisory` without blocking. Rules that do not',
+        'read, or that list no check, gate by every check run on the tip.',
         '',
         'Review state, UI state, evidence, and standing are read before the CI',
         'wait, so a reviewer whose partner is still driving refuses at once. The',
@@ -1039,6 +1070,10 @@ export function register(program: Command): void {
         'request already passed `canon pr lift`. It does not wait on checks or',
         'delete the branch.',
         '',
+        "The checks gate by the ones the base branch's rules require, the way",
+        '`canon pr lift` reads them. A failing check outside that set is named',
+        'in the record as `advisory` and does not refuse the merge.',
+        '',
         'Reasons:',
         '  merged, dry-run (--dry-run)',
         '  pull-closed, pull-draft, missing-summary, missing-key-changes,',
@@ -2658,7 +2693,9 @@ async function runEvidence(
     (opts.preview !== undefined ||
       opts.local !== undefined ||
       opts.checklist !== undefined ||
-      opts.reel !== undefined)
+      opts.reel !== undefined ||
+      opts.localSkip !== undefined ||
+      opts.reelSkip !== undefined)
   ) {
     return refuseWith(
       'check-writes',
@@ -2868,8 +2905,17 @@ async function runEvidence(
   }
 
   const preview = opts.preview ?? (isUnserved ? undefined : carriedPreview)
-  const local = opts.local ?? carriedLocal
+  // A carried local line names no head and reads as live, so a passed skip
+  // drops it the way a passed address replaces it. A carried reel names the
+  // head it was filmed at, so it stays beside a passed skip.
+  const local =
+    opts.local ?? (opts.localSkip === undefined ? carriedLocal : undefined)
   const reel = nextEvidenceReel(opts.reel, identity.head, comments)
+  const carriedSkips = findEvidenceSkips(comments)
+  const skips = {
+    local: opts.localSkip ?? carriedSkips.local,
+    reel: opts.reelSkip ?? carriedSkips.reel,
+  }
   const unsettled = suppliedChecklist ?? carriedChecklist
   const checklist =
     unsettled === undefined
@@ -2886,6 +2932,7 @@ async function runEvidence(
     checklist,
     local,
     reel,
+    skips,
   )
 
   const caseCount = states.reduce((n, s) => n + s.items.length, 0)
@@ -4209,24 +4256,64 @@ async function readChecksGate(
   number: string,
   tip: string,
 ): Promise<ChecksGate | undefined> {
-  const [listed, pulled] = await Promise.all([
+  // A status read that fails leaves a required status context unseen, which
+  // reads pending rather than passing, so it needs no refusal of its own.
+  const [listed, pulled, combined] = await Promise.all([
     gh(root, [
       'api',
       `repos/{owner}/{repo}/commits/${tip}/check-runs?per_page=100`,
     ]),
     gh(root, ['api', `repos/{owner}/{repo}/pulls/${number}`]),
+    gh(root, [
+      'api',
+      `repos/{owner}/{repo}/commits/${tip}/status?per_page=100`,
+    ]),
   ])
   if (listed === null) return undefined
   try {
-    const mergeState =
-      pulled === null
-        ? undefined
-        : mergeStateOf((JSON.parse(pulled) as RestPull).mergeable_state)
+    const row = pulled === null ? undefined : (JSON.parse(pulled) as RestPull)
+    const required = await readRequiredChecks(root, row?.base?.ref)
+    const statuses =
+      combined === null
+        ? []
+        : ((JSON.parse(combined) as { statuses?: readonly RawStatus[] })
+            .statuses ?? [])
     const reading = withMergeState(
-      mergeState,
-      collapseChecks(tip, JSON.parse(listed) as CheckRunListing),
+      mergeStateOf(row?.mergeable_state),
+      collapseChecks(
+        tip,
+        JSON.parse(listed) as CheckRunListing,
+        required,
+        statuses,
+      ),
     )
-    return { state: reading.state, isConflicted: reading.conflicted }
+    return {
+      state: reading.state,
+      isConflicted: reading.conflicted,
+      ...(reading.advisory !== undefined && { advisory: reading.advisory }),
+    }
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The checks the base branch's rules require, so a check they leave out runs
+ * without holding the gate. Undefined on any read that fails, which gates by
+ * every check as the verbs did before the rules were read.
+ */
+async function readRequiredChecks(
+  root: string,
+  base: string | undefined,
+): Promise<ReadonlySet<string> | undefined> {
+  if (base === undefined || base === '') return undefined
+  const rules = await gh(root, [
+    'api',
+    `repos/{owner}/{repo}/rules/branches/${base}`,
+  ])
+  if (rules === null) return undefined
+  try {
+    return requiredChecks(JSON.parse(rules))
   } catch {
     return undefined
   }
@@ -4360,6 +4447,7 @@ async function runLift(
   for (const gate of record.gates) {
     if (!gate.isOk) logWarn(`${gate.gate}: ${gate.reason ?? 'not clear'}`)
   }
+  warnAdvisory(record.advisory)
   outro()
 
   if (emitJson) {
@@ -4371,6 +4459,14 @@ async function runLift(
   return record.isOk ? 0 : 1
 }
 
+function warnAdvisory(advisory: readonly string[] | undefined): void {
+  for (const name of advisory ?? []) {
+    logWarn(
+      `advisory: ${name} failed, which the base's rules do not require, so it did not block`,
+    )
+  }
+}
+
 const MERGE_REFUSALS: Record<MergeRefusal | 'gh-missing', string> = {
   'gh-missing': PULL_REFUSALS['gh-missing'],
   'pull-closed': 'The pull request is closed, so there is nothing to merge.',
@@ -4516,6 +4612,7 @@ async function runMerge(
         ? `#${record.number} would merge with the message below`
         : MERGE_REFUSALS[record.reason],
   )
+  warnAdvisory(record.advisory)
   outro()
 
   if (emitJson) {

package/src/gate/measures.ts

@@ -1111,7 +1111,7 @@ const VISUAL_ONLY_GLOBS: readonly string[] = ['tooling/web/configs/e2e/**']
 
 /**
  * `deploy-site.yml` and `pr-visual-checks.yml` each carry their own literal
- * copy of the eight path globs a landing-page change should trigger on, plus
+ * copy of the five path globs a landing-page change should trigger on, plus
  * the `VISUAL_ONLY_GLOBS` the visual workflow adds for itself, per
  * Question 2 in `.canon/plans/archive/feature-render-visibility.md`. A YAML
  * anchor cannot cross files here, so the two copies are read live and compared

package/src/gate/sequencer.ts

@@ -386,7 +386,13 @@ async function runCheck(
   }
 
   const run = check.kind === 'cli' ? ctx.cli : ctx.run
-  const result = await run(check.argv, env)
+  const argv =
+    check.kind === 'command' &&
+    check.changedArgv !== undefined &&
+    ctx.changed !== undefined
+      ? check.changedArgv(ctx.changed)
+      : check.argv
+  const result = await run(argv, env)
   return {
     emissions: [{ kind: 'output', text: result.all }],
     failure: result.exitCode === 0 ? undefined : check.failure,

package/src/gate/stages.ts

@@ -45,6 +45,12 @@ export type Check =
   | {
       readonly kind: 'command'
       readonly argv: readonly string[]
+      /**
+       * Builds the argv from the changed set when scoping is on. `argv` runs
+       * where it is off, so `--all` and every widening fallback keep the full
+       * command.
+       */
+      readonly changedArgv?: (changed: readonly string[]) => readonly string[]
       readonly failure: string
     }
   /** This checkout's own CLI, so a worktree gate never reads the main tree. */
@@ -92,33 +98,36 @@ export interface Stage {
 }
 
 /**
- * Corpora a `src/` test asserts over from outside `src/`. Nothing compares
- * this list to the tests reading those paths, so a test that starts reading a
- * new corpus joins it here in the same change, or a branch touching only that
- * corpus skips the Tests stage. The first four are directory prefixes because
- * their tests walk the tree whole, which is what reaches a rule or a skill a
- * branch adds rather than edits.
+ * Files a scoped run hands to `vitest related`, which follows imports from
+ * them to the tests that reach them. A corpus a test reads from disk is not
+ * among them, so a Markdown-only push runs no tests locally and CI's full run
+ * is what catches a broken corpus reader.
  */
-export const TEST_CORPORA_PATTERNS = [
-  '^claude/skills/',
-  '^governance/rules/',
-  '^\\.claude/hooks/',
-  '^tooling/claude/seeds/\\.claude/hooks/',
-  '^tooling/base/reference\\.md$',
-  '^tooling/web/configs/scripts/worktree-port\\.sh$',
-]
+const RELATED_SOURCES = /\.tsx?$|^commitlint\.config\.js$/
+
+/** Files every test depends on without importing, so no related run sees them. */
+const FULL_SUITE_TRIGGERS =
+  /^vitest\.(config|setup|global-setup)\.ts$|^tsconfig\.json$|^package\.json$/
 
 const TESTS_SCOPE = new RegExp(
-  [
-    '^src/',
-    '^vitest\\.config\\.ts$',
-    '^tsconfig\\.json$',
-    '^package\\.json$',
-    '^commitlint\\.config\\.(js|test\\.ts)$',
-    ...TEST_CORPORA_PATTERNS,
-  ].join('|'),
+  `${RELATED_SOURCES.source}|${FULL_SUITE_TRIGGERS.source}`,
 )
 
+const FULL_SUITE = ['bun', 'run', 'test']
+
+function relatedTests(changed: readonly string[]): readonly string[] {
+  if (changed.some((file) => FULL_SUITE_TRIGGERS.test(file))) return FULL_SUITE
+  return [
+    'bun',
+    '--bun',
+    'vitest',
+    'related',
+    '--run',
+    '--passWithNoTests',
+    ...changed.filter((file) => RELATED_SOURCES.test(file)),
+  ]
+}
+
 /**
  * Every stage the gate runs, in the order it runs them.
  *
@@ -590,14 +599,17 @@ export const STAGES: readonly Stage[] = [
     id: 'tests',
     label: 'Tests',
     scope: TESTS_SCOPE,
-    skipped: 'Skipped, no TypeScript or asserted-corpus changes',
+    skipped: 'Skipped, no TypeScript or test config changes',
     // Concurrent suites from a wave of worktrees starve each other's spawn
     // and browser tests past their timeouts, so the box runs one at a time.
+    // A related run can still reach a spawn or browser test, so it holds the
+    // lock too.
     lock: 'tests',
     checks: [
       {
         kind: 'command',
-        argv: ['bun', 'run', 'test'],
+        argv: FULL_SUITE,
+        changedArgv: relatedTests,
         failure: 'Tests failed',
       },
     ],

package/src/markdown/scope.ts

@@ -280,6 +280,8 @@ export const GATED_PATHS: readonly string[] = [
   'claude/skills/pr-evidence/REQUIREMENT.md',
   'claude/skills/pr-evidence/SKILL.md',
   'claude/skills/pr-evidence/references/evidence.md',
+  'claude/skills/proposal-critique/REQUIREMENT.md',
+  'claude/skills/proposal-critique/SKILL.md',
   'claude/skills/review-address/REQUIREMENT.md',
   'claude/skills/review-address/SKILL.md',
   'claude/skills/review-address/references/post-review-findings.md',

package/src/pr/checks.ts

@@ -1,4 +1,8 @@
-import { type ChecksState, type RawCheck, rollup } from '@/targets/pulls'
+import {
+  type ChecksState,
+  type RawCheck,
+  rollupRequired,
+} from '@/targets/pulls'
 
 /** One row of `repos/{owner}/{repo}/commits/<sha>/check-runs`. */
 export interface RawCheckRun {
@@ -9,6 +13,12 @@ export interface RawCheckRun {
   readonly id?: number
 }
 
+/** One row of `repos/{owner}/{repo}/commits/<sha>/status`, newest per context already. */
+export interface RawStatus {
+  readonly context?: string
+  readonly state?: string
+}
+
 /** What that endpoint returns, count and rows apart. */
 export interface CheckRunListing {
   readonly total_count?: number
@@ -27,6 +37,41 @@ export interface ChecksReading {
   readonly reported: number
   /** Runs `matched` carried for a check name this reading already kept a newer run for. */
   readonly collapsed: number
+  /**
+   * Failing checks outside the required set, present only when a required set
+   * was read, so a reading over every check keeps its old shape.
+   */
+  readonly advisory?: readonly string[]
+}
+
+/**
+ * Reads the check names a base branch's rules require, from
+ * `repos/{owner}/{repo}/rules/branches/<base>`.
+ *
+ * Undefined when the answer is not a rule list, which a repository without
+ * rulesets or a refused read returns, so the caller falls back to every check.
+ * Classic branch protection is not read, and falls back the same way.
+ */
+export function requiredChecks(
+  rules: unknown,
+): ReadonlySet<string> | undefined {
+  if (!Array.isArray(rules)) return undefined
+
+  const names = new Set<string>()
+  for (const rule of rules as readonly RequiredRule[]) {
+    if (rule?.type !== 'required_status_checks') continue
+    for (const check of rule.parameters?.required_status_checks ?? []) {
+      if (typeof check.context === 'string') names.add(check.context)
+    }
+  }
+  return names
+}
+
+interface RequiredRule {
+  readonly type?: string
+  readonly parameters?: {
+    readonly required_status_checks?: readonly { readonly context?: unknown }[]
+  }
 }
 
 export interface ConflictedReading extends ChecksReading {
@@ -68,6 +113,7 @@ export function withMergeState(
  */
 function adapt(run: RawCheckRun): RawCheck {
   return {
+    ...(run.name !== undefined && { name: run.name }),
     ...(run.status !== undefined && { status: run.status.toUpperCase() }),
     ...(run.conclusion !== undefined &&
       run.conclusion !== null && {
@@ -125,10 +171,22 @@ function newestPerCheck(runs: readonly RawCheckRun[]): {
  * rolls up from `newestPerCheck`'s kept rows rather than from `matched`
  * directly, so a stale failing run left behind by a rerun no longer outvotes
  * the passing run beside it.
+ *
+ * A required set narrows only that last rollup. The foreign and partial
+ * listing guards still read every run, since either says the set in hand is
+ * incomplete whichever checks gate.
+ *
+ * A ruleset can require a commit status, which the check-run listing never
+ * carries, so the statuses join the rollup by `context` once a non-empty
+ * required set was read. An unread or empty set keeps them out, since the
+ * every-check fallback is the reading these verbs gave before rules were read
+ * and it saw no status.
  */
 export function collapseChecks(
   tip: string,
   listing: CheckRunListing,
+  required?: ReadonlySet<string>,
+  statuses: readonly RawStatus[] = [],
 ): ChecksReading {
   const runs = listing.check_runs ?? []
   const matched = runs.filter((run) => run.head_sha === tip)
@@ -139,6 +197,7 @@ export function collapseChecks(
     foreign: runs.length - matched.length,
     reported: listing.total_count ?? runs.length,
     collapsed,
+    ...(required !== undefined && { advisory: [] }),
   }
 
   if (reading.foreign > 0) return { ...reading, state: 'pending' }
@@ -149,7 +208,20 @@ export function collapseChecks(
   // sitting outside of, which is the false green keyed on a sha alone.
   if (reading.reported > runs.length) return { ...reading, state: 'pending' }
 
-  if (matched.length === 0) return { ...reading, state: 'pending' }
+  const statusRows: RawCheck[] =
+    required === undefined || required.size === 0
+      ? []
+      : statuses.map((status) => ({
+          ...(status.context !== undefined && { name: status.context }),
+          state: (status.state ?? '').toUpperCase(),
+        }))
+  const rows = [...kept.map(adapt), ...statusRows]
+  if (rows.length === 0) return { ...reading, state: 'pending' }
 
-  return { ...reading, state: rollup(kept.map(adapt)) ?? 'pending' }
+  const { state, advisory } = rollupRequired(rows, required)
+  return {
+    ...reading,
+    state: state ?? 'pending',
+    ...(required !== undefined && { advisory }),
+  }
 }

package/src/pr/evidence.ts

@@ -25,6 +25,12 @@ const REEL_PREFIX = '**Reel** filmed at'
 const REEL_LINE =
   /^\*\*Reel\*\* filmed at `([0-9a-f]{7,40})`:<br><img src="([^"]+)"/
 
+/** How the line naming why no local address was posted opens. */
+const LOCAL_SKIP_PREFIX = '**No local preview:**'
+
+/** How the line naming why no reel was filmed opens. */
+const REEL_SKIP_PREFIX = '**No reel:**'
+
 /** The width a reel is filmed at, which it asks for in the comment. */
 const REEL_WIDTH = 960
 
@@ -198,6 +204,15 @@ function escapeCell(text: string): string {
     .replaceAll('|', '&#124;')
 }
 
+function unescapeCell(text: string): string {
+  return text
+    .replaceAll('&#124;', '|')
+    .replaceAll('&quot;', '"')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&lt;', '<')
+    .replaceAll('&amp;', '&')
+}
+
 function evidenceImage(url: string, alt: string, width?: number): string {
   const shown = Math.min(width ?? IMAGE_WIDTH, IMAGE_WIDTH)
   return `<img src="${url}" width="${shown}" alt="${alt}">`
@@ -449,6 +464,18 @@ function reelLine(reel: EvidenceReel): string {
   return `${REEL_PREFIX} \`${head}\`:<br><img src="${escapeCell(reel.link)}" width="${REEL_WIDTH}" alt="reel filmed at ${head}">`
 }
 
+/** Why a render carries no local address or no reel, each a reason code and any one-line message the caller joined to it. */
+export interface EvidenceSkips {
+  readonly local?: string
+  readonly reel?: string
+}
+
+/** A skip line, or nothing for an empty reason. A reason is folded onto one line, since a line break would end the address region early. */
+function skipLines(prefix: string, reason: string | undefined): string[] {
+  const text = reason?.replace(/\s+/g, ' ').trim() ?? ''
+  return text === '' ? [] : [`${prefix} ${escapeCell(text)}`, '']
+}
+
 export function evidenceMarker(head: string): string {
   return `${MARKER_PREFIX} head=${head} -->`
 }
@@ -480,6 +507,10 @@ export function evidenceMarker(head: string): string {
  *
  * A reel sits on its own line under the addresses, labeled with the head it
  * was filmed at, so a reel carried past a later push never reads as current.
+ *
+ * A skip names why the local address or the reel is missing, on its own line
+ * where that address or reel would sit. Each is dropped whenever its address
+ * or reel renders, carried or passed, so a skip never outlives its cause.
  */
 export function renderEvidenceBody(
   states: readonly EvidenceState[],
@@ -490,6 +521,7 @@ export function renderEvidenceBody(
   checklist?: string,
   local?: string,
   reel?: EvidenceReel,
+  skips: EvidenceSkips = {},
 ): string {
   const segments = [
     ...(preview === undefined ? [] : [`${PREVIEW_PREFIX} ${preview}`]),
@@ -499,7 +531,10 @@ export function renderEvidenceBody(
     EVIDENCE_HEADING,
     '',
     ...(segments.length === 0 ? [] : [segments.join(ADDRESS_SEPARATOR), '']),
-    ...(reel === undefined ? [] : [reelLine(reel), '']),
+    ...(local === undefined ? skipLines(LOCAL_SKIP_PREFIX, skips.local) : []),
+    ...(reel === undefined
+      ? skipLines(REEL_SKIP_PREFIX, skips.reel)
+      : [reelLine(reel), '']),
   ]
   const closing =
     checklist === undefined
@@ -756,6 +791,32 @@ export function findEvidenceReel(
   return undefined
 }
 
+/**
+ * The skips the marked comment already carries, read from the address region
+ * only, so a line quoted in a checklist is never taken for one. A re-render
+ * passing no skip carries these forward the way it carries an address.
+ */
+export function findEvidenceSkips(
+  comments: readonly EvidenceComment[],
+): EvidenceSkips {
+  const marked = findMarked(comments)
+  if (marked === undefined) return {}
+  let local: string | undefined
+  let reel: string | undefined
+  for (const raw of marked.body.split('\n')) {
+    const line = raw.trim()
+    if (REGION_ENDS.some((end) => line.startsWith(end))) break
+    const ownSkip = readSegment(line, LOCAL_SKIP_PREFIX)
+    const reelSkip = readSegment(line, REEL_SKIP_PREFIX)
+    if (ownSkip !== undefined) local ??= unescapeCell(ownSkip)
+    if (reelSkip !== undefined) reel ??= unescapeCell(reelSkip)
+  }
+  return {
+    ...(local !== undefined && { local }),
+    ...(reel !== undefined && { reel }),
+  }
+}
+
 /**
  * The reel a render embeds: a passed link, filmed at this head, replaces
  * whatever the comment carries, and with none passed the posted reel carries

package/src/pr/lift.ts

@@ -83,8 +83,19 @@ export interface EvidenceGate {
 }
 
 export interface ChecksGate {
+  /** The state over the checks the base requires, or every check when none were read. */
   readonly state: ChecksState
   readonly isConflicted: boolean
+  /** Failing checks outside the required set, which are reported and never gate. */
+  readonly advisory?: readonly string[]
+}
+
+/** The advisory field a record carries, absent when no advisory check failed. */
+export function advisoryOf(reading: ChecksGate): {
+  advisory?: readonly string[]
+} {
+  const advisory = reading.advisory ?? []
+  return advisory.length > 0 ? { advisory } : {}
 }
 
 /**
@@ -129,6 +140,8 @@ export interface LiftRecord {
   readonly carriedFrom?: string
   readonly paintedPaths?: readonly string[]
   readonly drivenPaths?: readonly string[]
+  /** Failing checks the base does not require, named so a reader sees them before merging. */
+  readonly advisory?: readonly string[]
   readonly isLifted: boolean
   /** Whether the caller can treat the pull request as ready afterwards. */
   readonly isOk: boolean
@@ -247,7 +260,11 @@ function standingGate(standing: Standing): GateResult {
 }
 
 type CiOutcome =
-  | { readonly kind: 'passing'; readonly waited: number }
+  | {
+      readonly kind: 'passing'
+      readonly waited: number
+      readonly reading: ChecksGate
+    }
   | {
       readonly kind: 'refused'
       readonly reason: LiftRefusal
@@ -274,7 +291,9 @@ async function waitForChecks(
     if (reading === undefined) {
       return { kind: 'refused', reason: 'gh-failed', waited }
     }
-    if (reading.state === 'passing') return { kind: 'passing', waited }
+    if (reading.state === 'passing') {
+      return { kind: 'passing', waited, reading }
+    }
     if (reading.state === 'failing') {
       return { kind: 'refused', reason: 'ci-failing', waited }
     }
@@ -422,6 +441,7 @@ export async function lift(
       gates: all,
       waitedSeconds: 0,
       ...carried(all),
+      ...advisoryOf(reading),
     }
   }
 
@@ -485,6 +505,7 @@ export async function lift(
     gates: cleared,
     waitedSeconds: ci.waited,
     ...carried(cleared),
+    ...advisoryOf(ci.reading),
   }
 }