@erclx/canon 5.72.1 → 5.74.0

package/src/claude/skills-audit.ts

@@ -119,7 +119,12 @@ export const BULLET_LEDGER_SKILLS: Readonly<Record<string, BulletLedgerScope>> =
     },
     [join(SHIPPED_CORPUS, 'teach-craft')]: { exempt: [], body: true },
     [join(SHIPPED_CORPUS, 'test-craft')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'test-first')]: { exempt: [], body: true },
     [join(SHIPPED_CORPUS, 'codebase-layout')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'search-craft')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'write-human')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'systematic-debugging')]: { exempt: [], body: true },
+    [join(SHIPPED_CORPUS, 'build-in-slices')]: { exempt: [], body: true },
   }
 
 /** Where a per-bullet ledger lives, as `<skill>/<file>.md` below it. */
@@ -161,6 +166,9 @@ export const PRACTICE_LEDGER = join('references', 'adopted.md')
  */
 const EXTERNAL_LINK = /\]\(\s*https?:\/\/|<https?:\/\//
 
+/** The address an inline link or an autolink cites, captured for comparison. */
+const EXTERNAL_ADDRESS = /\]\(\s*(https?:\/\/[^)\s]+)|<(https?:\/\/[^>\s]+)>/g
+
 /**
  * A table cell opening on the marker the governance ledgers already use for a
  * rule the toolkit chose, so one check reads every ledger alike.
@@ -277,6 +285,8 @@ interface ReferenceLedger {
   readonly ledgerRel: string
   /** Undefined when the ledger file is absent. */
   readonly mismatches: readonly LedgerMismatch[] | undefined
+  /** Every source the ledger links, normalized by `sourceKey`. */
+  readonly sources: readonly string[]
 }
 
 interface SkillText {
@@ -453,13 +463,22 @@ async function readReferenceLedgers(
     files.map(async ({ path, text }) => {
       const ledgerRel = skillLedgerPath(folder, path)
       const ledgerPath = join(root, ledgerRel)
-      const mismatches = existsSync(ledgerPath)
-        ? compareLedger(
-            ledgerGroups(text, path === 'SKILL.md'),
-            countLedgerRows(await Bun.file(ledgerPath).text()),
-          )
+      const ledger = existsSync(ledgerPath)
+        ? await Bun.file(ledgerPath).text()
         : undefined
-      return { rel: join(skillRel, path), ledgerRel, mismatches }
+      const mismatches =
+        ledger === undefined
+          ? undefined
+          : compareLedger(
+              ledgerGroups(text, path === 'SKILL.md'),
+              countLedgerRows(ledger),
+            )
+      return {
+        rel: join(skillRel, path),
+        ledgerRel,
+        mismatches,
+        sources: ledger === undefined ? [] : linkedSources(ledger),
+      }
     }),
   )
 }
@@ -681,6 +700,7 @@ function practiceFindings(source: SkillSource): SkillFinding[] {
   return [
     ...sections,
     ...ledgerFindings(source),
+    ...duplicateFindings(source),
     ...source.referenceLedgers.flatMap(referenceLedgerFindings),
     ...source.staleExemptions.map((rel) => ({
       rel,
@@ -710,17 +730,78 @@ function ledgerFindings(source: SkillSource): SkillFinding[] {
     return [{ rel: source.rel, detail: `missing ledger: ${PRACTICE_LEDGER}` }]
   }
 
-  const cites = bodyLines(source.ledger)
-    .filter((line) => !line.fenced)
+  const lines = bodyLines(source.ledger).filter((line) => !line.fenced)
+  const cites = lines
     .map((line) => maskCodeSpans(line.text))
     .some((text) => EXTERNAL_LINK.test(text) || HOUSE_CHOICE.test(text))
   if (cites) return []
+  if (pointsAtLedgers(source, lines)) return []
 
   return [
     { rel: source.rel, detail: `ledger cites nothing: ${PRACTICE_LEDGER}` },
   ]
 }
 
+/**
+ * A skill on the per-bullet list cites its sources in its ledger folder, so a
+ * record whose every link moved there is left pointing at the folder instead.
+ * A skill off the list has nowhere else for a source to live.
+ */
+function pointsAtLedgers(
+  source: SkillSource,
+  lines: readonly { text: string }[],
+): boolean {
+  if (BULLET_LEDGER_SKILLS[source.rel] === undefined) return false
+  const folder = `${join(SKILL_LEDGERS, source.folder)}/`
+  return lines.some((line) => line.text.includes(folder))
+}
+
+/**
+ * The source record keeps a source no ledger row cites, so a link in both
+ * places is a second copy that drifts on the first edit to either.
+ */
+function duplicateFindings(source: SkillSource): SkillFinding[] {
+  if (source.ledger === undefined) return []
+  if (BULLET_LEDGER_SKILLS[source.rel] === undefined) return []
+
+  const ledgered = new Map<string, string>()
+  for (const entry of source.referenceLedgers) {
+    for (const key of entry.sources) {
+      if (!ledgered.has(key)) ledgered.set(key, entry.ledgerRel)
+    }
+  }
+
+  return [...new Set(linkedSources(source.ledger))].flatMap((key) => {
+    const ledgerRel = ledgered.get(key)
+    if (ledgerRel === undefined) return []
+    return [
+      {
+        rel: join(source.rel, PRACTICE_LEDGER),
+        detail: `duplicate source: ${key} in ${ledgerRel}`,
+      },
+    ]
+  })
+}
+
+/** Every external address a text links outside fences and code spans. */
+function linkedSources(text: string): string[] {
+  return bodyLines(text)
+    .filter((line) => !line.fenced)
+    .flatMap((line) =>
+      [...maskCodeSpans(line.text).matchAll(EXTERNAL_ADDRESS)].map((match) =>
+        sourceKey(match[1] ?? match[2] ?? ''),
+      ),
+    )
+}
+
+/**
+ * An anchor and a trailing slash reach the same page, so both drop. A commit
+ * pin names a different version, so the path stays as written.
+ */
+function sourceKey(address: string): string {
+  return address.replace(/#.*$/, '').replace(/\/+$/, '')
+}
+
 /**
  * Asks only the shipped corpus for a family, since the family names the skill
  * map group a skill's row sits under and an internal skill takes no row.

package/src/commands/intake.ts

@@ -186,6 +186,8 @@ export function register(program: Command): void {
         '  strayEvidence    an evidence path outside the folder evidence/',
         '  missingEvidence  an evidence path that holds no file',
         '  worktreeLeft     the drive worktree the record names, still on disk',
+        '  undrawn          a decision in evidence/drive-log.md with no Drawn',
+        '                   path and no skipped reason',
         '',
         'A goal matches by its text with any bold label and trailing period',
         'dropped. A changed path is named and never reverted.',
@@ -553,6 +555,7 @@ const FINDING_LABELS: Record<keyof DriveFindings, string> = {
   strayEvidence: 'Evidence outside evidence/',
   missingEvidence: 'Evidence holding no file',
   worktreeLeft: 'Drive worktree still on disk',
+  undrawn: 'Decisions with nothing drawn',
 }
 
 function reportDriveCheck(
@@ -585,7 +588,7 @@ function reportDriveCheck(
   if (outcome.reason === 'clean') {
     logStep('Clean')
     logInfo(
-      `${outcome.goals} goal(s) mapped, the checkout untouched, the evidence in place.`,
+      `${outcome.goals} goal(s) mapped, the checkout untouched, the evidence in place, every decision drawn.`,
     )
     outro()
     return code

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/intake/drive-check.ts

@@ -16,6 +16,9 @@ export const DRIVE_RECORD = 'drive.json'
 /** The one folder inside an intake folder that evidence may live in. */
 export const EVIDENCE_DIR = 'evidence'
 
+/** The log a person reads, which the `undrawn` axis parses by its labels. */
+export const DRIVE_LOG = join(EVIDENCE_DIR, 'drive-log.md')
+
 const SCRATCH = join('.canon', 'tmp', 'app-drive')
 
 /**
@@ -63,6 +66,15 @@ export interface DriveFindings {
   readonly missingEvidence: readonly string[]
   /** The drive's worktree, when the record names one still on disk. */
   readonly worktreeLeft: readonly string[]
+  /** Logged findings the operator decided with no drawn outcome. */
+  readonly undrawn: readonly string[]
+}
+
+export interface DrawnReading {
+  /** Each decided finding's heading, as `<nn>. <title>`, with nothing drawn. */
+  readonly undrawn: readonly string[]
+  /** Every path a `Drawn` field cites, for the evidence tests. */
+  readonly paths: readonly string[]
 }
 
 export interface DriveChecked {
@@ -159,6 +171,57 @@ export function readGoals(source: string): string[] {
   return goals
 }
 
+const FINDING_HEADING = /^##\s+(\d+\.\s.*?)\s*$/
+const LOG_FIELD = /^[-*]\s+\*\*([^*]+):\*\*\s*(.*)$/
+const DECISION_LABEL = 'Decision (operator)'
+const DRAWN_LABEL = 'Drawn'
+
+/**
+ * Reads the drive log's numbered findings for a decision with nothing drawn.
+ * A decision reading `see <nn>` was drawn under the finding it names, and a
+ * `ref-<nn>` heading or a finding with no decision carries nothing to draw. A
+ * `Drawn` field passes when it cites a path in a code span or reads
+ * `skipped, <reason>`, so a bare `skipped` still lists the finding. A skip
+ * cites no path, since its reason may code-span a flag or a format.
+ */
+export function readDrawn(source: string): DrawnReading {
+  const undrawn: string[] = []
+  const paths: string[] = []
+  let finding: string | undefined
+  let decision: string | undefined
+  let drawn: string | undefined
+
+  const close = () => {
+    if (finding !== undefined && decision && !/^see\s+\d+/i.test(decision)) {
+      const field = drawn ?? ''
+      if (/^skipped\b/i.test(field)) {
+        if (!/^skipped\s*,\s*\S/i.test(field)) undrawn.push(finding)
+      } else {
+        const cited = [...field.matchAll(/`([^`]+)`/g)].map((match) => match[1])
+        paths.push(...cited)
+        if (cited.length === 0) undrawn.push(finding)
+      }
+    }
+    finding = decision = drawn = undefined
+  }
+
+  for (const line of bodyLines(source)) {
+    if (line.fenced) continue
+    if (/^#{1,2}\s/.test(line.text)) {
+      close()
+      finding = FINDING_HEADING.exec(line.text)?.[1]
+      continue
+    }
+    const field = LOG_FIELD.exec(line.text)
+    if (finding === undefined || !field) continue
+    if (field[1] === DECISION_LABEL) decision = field[2].trim()
+    if (field[1] === DRAWN_LABEL) drawn = field[2].trim()
+  }
+  close()
+
+  return { undrawn, paths }
+}
+
 function parseRecord(raw: string): DriveRecord | string {
   let parsed: unknown
   try {
@@ -271,8 +334,9 @@ export async function recordBaseline(
 /**
  * Checks a finished drive against its intake folder's `drive.json`: every
  * goal mapped or skipped with a reason, the main checkout unchanged since the
- * baseline, the evidence inside the folder's `evidence/`, and the drive's
- * worktree gone. It reports what failed and never reverts a changed path,
+ * baseline, the evidence inside the folder's `evidence/`, every decision in
+ * the drive log drawn, and the drive's worktree gone. A folder with no log
+ * reads as nothing undrawn. It reports what failed and never reverts a changed path,
  * since only the operator knows which of them to keep.
  */
 export async function checkDrive(
@@ -318,6 +382,12 @@ export async function checkDrive(
     return refuse('unreadable-tree', `git cannot read the status of ${root}.`)
   }
 
+  const logPath = join(folder, DRIVE_LOG)
+  const drawn: DrawnReading = existsSync(logPath)
+    ? readDrawn(await readFile(logPath, 'utf8'))
+    : { undrawn: [], paths: [] }
+  const evidence = [...new Set([...record.evidence, ...drawn.paths])]
+
   const entries = new Map(
     record.goals.map((entry) => [normalizeGoal(entry.goal), entry]),
   )
@@ -334,14 +404,15 @@ export async function checkDrive(
       .filter((entry) => !known.has(normalizeGoal(entry.goal)))
       .map((entry) => entry.goal),
     changed: changedSince(baseline, current),
-    strayEvidence: record.evidence.filter((path) => !isEvidencePath(path)),
-    missingEvidence: record.evidence.filter(
+    strayEvidence: evidence.filter((path) => !isEvidencePath(path)),
+    missingEvidence: evidence.filter(
       (path) => isEvidencePath(path) && !existsSync(join(folder, path)),
     ),
     worktreeLeft:
       record.worktree !== undefined && existsSync(record.worktree)
         ? [record.worktree]
         : [],
+    undrawn: drawn.undrawn,
   }
   const failed = Object.values(findings).some((list) => list.length > 0)
 

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',