@erclx/canon 5.46.0 → 5.48.0

package/src/commands/tasks.ts

@@ -680,7 +680,9 @@ export function register(program: Command): void {
         '                  the last listed, so a later number closes the issue',
         '  lookup-failed   the pull request lookup failed while the task already',
         '                  lists a pull request, so an earlier slice cannot be ruled out',
-        '  open-outcomes   an outcome is still open, so a later slice closes it',
+        '  open-outcomes   an outcome is still open, so a later slice closes it.',
+        '                  A `- [ ] Operator check: <outcome>` line holds nothing open and',
+        '                  is listed under `operatorChecks`',
         '  pending-branch  another branch is on `Pending branch:`',
         '  no-outcomes     the task carries no outcomes',
         '',
@@ -1544,6 +1546,7 @@ function reportCloses(
         issues: outcome.issues,
         closing: outcome.closing,
         reason: outcome.reason,
+        operatorChecks: outcome.operatorChecks ?? [],
       })}\n`,
     )
     return 0
@@ -1556,6 +1559,9 @@ function reportCloses(
       ? `${outcome.stem} names ${outcome.issues.map((n) => `#${n}`).join(', ')}, ${outcome.reason}`
       : `${outcome.stem} names no issue`,
   )
+  for (const check of outcome.operatorChecks ?? []) {
+    logInfo(`operator check: ${check}`)
+  }
   outro()
 
   return 0
@@ -2195,9 +2201,11 @@ function report(
     logInfo('retargeted the Ready: line')
   }
   if (outcome.priorityRowRemoved) logInfo('cleared the ordering row')
+  if (outcome.backlogRowRemoved) logInfo('cleared the backlog row')
   logRelinked(outcome.relinked, outcome.relinkFailed, root)
   if (outcome.indexRegenerated) logInfo('regenerated index.md')
   if (outcome.cut > 0) logInfo(`${outcome.cut} outcome(s) cut`)
+  for (const check of outcome.operatorChecks) logInfo(check)
   outro()
 
   return 0
@@ -2277,6 +2285,7 @@ function recordFor(
     from: relative(root, outcome.from),
     to: relative(root, outcome.to),
     priorityRowRemoved: outcome.priorityRowRemoved,
+    backlogRowRemoved: outcome.backlogRowRemoved,
     indexRegenerated: outcome.indexRegenerated,
     plans: planMovesFor(outcome.plans, root),
     ready: outcome.ready
@@ -2287,6 +2296,7 @@ function recordFor(
       : null,
     closed: outcome.closed,
     cut: outcome.cut,
+    operatorChecks: outcome.operatorChecks,
     relinked: relinkedFor(outcome.relinked, root),
     relinkFailed: relinkFailedFor(outcome.relinkFailed, root),
   }

package/src/labels/density.ts

@@ -0,0 +1,363 @@
+import {
+  type DensityFinding,
+  type DensityKind,
+  densityFindings,
+} from '@/markdown/density'
+import { type BodyLine, bodyLines, visibleText } from '@/markdown/scan'
+import { CHECKPOINTS, LIST_ITEM } from '@/markdown/structure'
+
+/**
+ * The four counted limits a pull request section carries. The heading limits
+ * of `densityFindings()` are left out, since a body takes no subheading at all
+ * and `subheading` reports that once.
+ */
+const COUNTED = [
+  'paragraph-length',
+  'paragraph-run',
+  'bullet-length',
+  'bullet-run',
+] as const satisfies readonly DensityKind[]
+
+type CountedKind = (typeof COUNTED)[number]
+
+export type BodyDensityKind = CountedKind | 'subheading' | 'mixed-form'
+
+function isCounted(kind: DensityKind): kind is CountedKind {
+  return (COUNTED as readonly DensityKind[]).includes(kind)
+}
+
+export interface BodyDensityFinding {
+  /** The H2 the finding sits under, without its hashes, or null before the first. */
+  readonly section: string | null
+  readonly kind: BodyDensityKind
+  /** The line in the whole body, not in its section. */
+  readonly line: number
+  readonly value: number | null
+  readonly limit: number | null
+}
+
+const H2 = /^##\s+(.*?)\s*$/
+const SUBHEADING = /^(#{3,6})\s/
+const BOLD_ONLY = /^(\*\*|__)[^*_].*\1\s*$/
+const BOLD_LED = /^(\*\*|__)\S/
+
+interface Section {
+  readonly name: string | null
+  readonly lines: readonly BodyLine[]
+}
+
+/**
+ * Every density breach in a pull request body, graded per H2 section after
+ * the shape `claude/skills/git-pr/references/pr.md` states.
+ *
+ * `densityFindings()` stays the docs measure, so the PR exemptions live here
+ * as splits around it rather than as options on it. Testing takes no counted
+ * limit, since its checkboxes count as a bullet run. Key changes splits at
+ * each bold label alone on its own block, whatever its length, and Technical context
+ * at each bold-led paragraph, so a lead-in starts a new run. Technical
+ * context also reports mixing bullets with paragraphs.
+ */
+export function bodyDensity(body: string): BodyDensityFinding[] {
+  const found: BodyDensityFinding[] = []
+
+  for (const section of sectionsOf(bodyLines(body))) {
+    found.push(...subheadings(section))
+    if (section.name === 'Testing') continue
+
+    const chunks =
+      section.name === 'Key changes'
+        ? splitAt(section.lines, opensBlock(section.lines, BOLD_ONLY), true)
+        : section.name === 'Technical context'
+          ? splitAt(section.lines, opensBlock(section.lines, BOLD_LED), false)
+          : [section.lines]
+
+    for (const chunk of chunks) {
+      for (const finding of densityFindings(chunk)) {
+        const { kind } = finding
+        if (!isCounted(kind)) continue
+        found.push({ section: section.name, ...finding, kind })
+      }
+    }
+
+    if (section.name === 'Technical context') {
+      const mixed = mixedForm(section.lines)
+      if (mixed !== undefined) {
+        found.push({
+          section: section.name,
+          kind: 'mixed-form',
+          line: mixed,
+          value: null,
+          limit: null,
+        })
+      }
+    }
+  }
+
+  return found.sort((a, b) => a.line - b.line)
+}
+
+/**
+ * The opening headings of the posts a canon skill writes to a pull request,
+ * after `.canon/groundwork/170-github-comment-density/04-post-catalog.md`. A
+ * body opening on any other heading is not a post this reader grades.
+ */
+export const POST_HEADINGS = [
+  'Evidence',
+  'Review',
+  'Review closed',
+  'UI review',
+  'UI review closed',
+  'Review response',
+  'Post-review findings',
+  'Rebase',
+] as const
+
+export type PostDensityKind = CountedKind | 'heading-depth'
+
+export interface PostDensityFinding extends Omit<BodyDensityFinding, 'kind'> {
+  readonly kind: PostDensityKind
+}
+
+const LENGTHS: readonly DensityKind[] = ['paragraph-length', 'bullet-length']
+const NESTED_ITEM = /^(\s+)(?:[-*+]|\d+\.)\s+(.*)$/
+const CHECKBOX = /^\s*[-*+]\s+\[[ xX]\]/
+const FOOTER = /^🤖/
+
+/**
+ * Every density breach in a post a skill writes to a pull request, keyed on
+ * its opening H2, or none when that heading is not in `POST_HEADINGS`.
+ *
+ * A post allows H3s, which the UI review groups its verdicts under, so only a
+ * heading past H3 reports. The `🤖` footer and the marker never report, and a
+ * table never does. Inside `<details>` a block takes the length limits alone,
+ * since a reader opens it on purpose. A bold-led paragraph starts a new
+ * paragraph run, and a checklist box under `What to look at` takes no length
+ * limit, since a driver needs its route, action, and result.
+ *
+ * A nested item is measured as a bullet of its own, which `densityFindings()`
+ * leaves out of its parent, so a finding's subject and its evidence never sum.
+ */
+export function postDensity(body: string): PostDensityFinding[] {
+  const lines = bodyLines(body).map((line) =>
+    !line.fenced && FOOTER.test(line.text) ? { ...line, text: '' } : line,
+  )
+  if (!opensOnPostHeading(lines)) return []
+
+  const found: PostDensityFinding[] = []
+  const text = new Map(lines.map((line) => [line.number, line.text]))
+
+  for (const section of sectionsOf(lines)) {
+    const { outside, inside } = foldedApart(section.lines)
+    const measured = [
+      ...splitAt(outside, opensBlock(outside, BOLD_LED), false).flatMap(
+        (chunk) => densityFindings(chunk),
+      ),
+      ...densityFindings(inside).filter(({ kind }) => LENGTHS.includes(kind)),
+      ...nestedLengths(section.lines),
+    ]
+
+    for (const finding of measured) {
+      const { kind } = finding
+      if (!isCounted(kind) && kind !== 'heading-depth') continue
+      if (
+        section.name === 'What to look at' &&
+        kind === 'bullet-length' &&
+        CHECKBOX.test(text.get(finding.line) ?? '')
+      ) {
+        continue
+      }
+      found.push({ section: section.name, ...finding, kind })
+    }
+  }
+
+  return found.sort((a, b) => a.line - b.line)
+}
+
+/** Whether the body's first H2 outside a fence is one of `POST_HEADINGS`. */
+export function isPost(body: string): boolean {
+  return opensOnPostHeading(bodyLines(body))
+}
+
+function opensOnPostHeading(lines: readonly BodyLine[]): boolean {
+  const opening = lines.find((line) => !line.fenced && H2.test(line.text))
+  const heading = opening && H2.exec(opening.text)?.[1]
+  return (POST_HEADINGS as readonly string[]).includes(heading ?? '')
+}
+
+/**
+ * Parts a section into the lines outside `<details>` and the lines inside it.
+ * The tags stay outside, where each breaks a paragraph run as raw HTML does.
+ */
+function foldedApart(lines: readonly BodyLine[]): {
+  outside: BodyLine[]
+  inside: BodyLine[]
+} {
+  const outside: BodyLine[] = []
+  const inside: BodyLine[] = []
+  let depth = 0
+
+  for (const line of lines) {
+    const tag = line.fenced ? '' : line.text.trim()
+    if (tag.startsWith('<details')) {
+      depth++
+      outside.push(line)
+    } else if (tag.startsWith('</details')) {
+      depth = Math.max(0, depth - 1)
+      outside.push(line)
+    } else if (depth > 0) {
+      inside.push(line)
+    } else {
+      outside.push(line)
+    }
+  }
+
+  return { outside, inside }
+}
+
+/**
+ * A `bullet-length` finding for each nested item past the bullet limit, its
+ * length taken over the item and the lines indented under it that open no
+ * item of their own.
+ */
+function nestedLengths(lines: readonly BodyLine[]): DensityFinding[] {
+  const found: DensityFinding[] = []
+
+  for (const [index, line] of lines.entries()) {
+    const match = line.fenced ? null : NESTED_ITEM.exec(line.text)
+    if (!match) continue
+
+    const indent = match[1].length
+    const parts = [match[2].trim()]
+    for (const next of lines.slice(index + 1)) {
+      const lead = /^\s*/.exec(next.text)?.[0].length ?? 0
+      if (next.fenced || next.text.trim() === '' || lead <= indent) break
+      if (LIST_ITEM.test(next.text)) break
+      parts.push(next.text.trim())
+    }
+
+    const length = visibleText(parts.join(' ')).length
+    if (length > CHECKPOINTS.bullet) {
+      found.push({
+        kind: 'bullet-length',
+        line: line.number,
+        value: length,
+        limit: CHECKPOINTS.bullet,
+      })
+    }
+  }
+
+  return found
+}
+
+function sectionsOf(lines: readonly BodyLine[]): Section[] {
+  const sections: Section[] = []
+  let current: { name: string | null; lines: BodyLine[] } = {
+    name: null,
+    lines: [],
+  }
+
+  for (const line of lines) {
+    const heading = line.fenced ? null : H2.exec(line.text)
+    if (heading) {
+      sections.push(current)
+      current = { name: heading[1], lines: [] }
+    } else {
+      current.lines.push(line)
+    }
+  }
+  sections.push(current)
+
+  return sections.filter((section) => section.lines.length > 0)
+}
+
+function subheadings(section: Section): BodyDensityFinding[] {
+  return section.lines.flatMap((line) => {
+    const match = line.fenced ? null : SUBHEADING.exec(line.text)
+    if (!match) return []
+    return [
+      {
+        section: section.name,
+        kind: 'subheading' as const,
+        line: line.number,
+        value: match[1].length,
+        limit: 2,
+      },
+    ]
+  })
+}
+
+/**
+ * Cuts a section into chunks at each line the test picks, never inside a
+ * fence. `drop` leaves the picked line out of both chunks, as a bold label
+ * that only names the group below it.
+ */
+function splitAt(
+  lines: readonly BodyLine[],
+  breaks: (line: BodyLine, index: number) => boolean,
+  drop: boolean,
+): BodyLine[][] {
+  const chunks: BodyLine[][] = [[]]
+
+  for (const [index, line] of lines.entries()) {
+    if (!line.fenced && breaks(line, index)) {
+      chunks.push(drop ? [] : [line])
+    } else {
+      chunks[chunks.length - 1].push(line)
+    }
+  }
+
+  return chunks
+}
+
+/**
+ * Picks a line matching the pattern that opens a block, after a blank line or
+ * at the section start. A line directly under a bullet or a paragraph renders
+ * as its lazy continuation, so it breaks nothing.
+ */
+function opensBlock(
+  lines: readonly BodyLine[],
+  pattern: RegExp,
+): (line: BodyLine, index: number) => boolean {
+  return (line, index) =>
+    pattern.test(line.text) &&
+    (index === 0 || lines[index - 1].text.trim() === '')
+}
+
+/**
+ * The line of the first block of whichever form appears second, when a
+ * section carries both bullets and paragraphs, else undefined.
+ *
+ * A column-zero line directly under an item with no blank between is a lazy
+ * continuation of that item, not a paragraph.
+ */
+function mixedForm(lines: readonly BodyLine[]): number | undefined {
+  let firstItem: number | undefined
+  let firstParagraph: number | undefined
+  let previous: 'blank' | 'item' | 'paragraph' | 'other' = 'blank'
+
+  for (const line of lines) {
+    const text = line.text
+    if (line.fenced) {
+      previous = 'other'
+      continue
+    }
+    if (text.trim() === '') {
+      previous = 'blank'
+      continue
+    }
+    if (/^\s/.test(text)) continue
+
+    if (LIST_ITEM.test(text)) {
+      firstItem ??= line.number
+      previous = 'item'
+    } else if (/^(#|\||>|<)/.test(text)) {
+      previous = 'other'
+    } else if (previous === 'blank' || previous === 'other') {
+      firstParagraph ??= line.number
+      previous = 'paragraph'
+    }
+  }
+
+  if (firstItem === undefined || firstParagraph === undefined) return undefined
+  return Math.max(firstItem, firstParagraph)
+}

package/src/migrate/session-defaults.ts

@@ -1,6 +1,7 @@
 /**
  * Adds the session defaults the seeded `.claude/settings.json` carries to a
- * target that was seeded before them.
+ * target that was seeded before them: the subagent deny, the memory default, and
+ * the merge deny entries.
  *
  * `canon claude init` copies a seed only when the file is absent, so a target
  * holding its own settings never sees a later seed change. This verb adds each
@@ -21,6 +22,12 @@ import {
 /** Both names, since `Task` is the tool's name before Claude Code renamed it. */
 export const DENIED_TOOLS: readonly string[] = ['Agent', 'Task']
 
+/** The merge entries the seeded deny list carries, so a session cannot merge. */
+export const MERGE_DENIED: readonly string[] = [
+  'Bash(canon pr merge:*)',
+  'Bash(gh pr merge:*)',
+]
+
 export interface SessionDefaultsPlan {
   readonly keys: readonly SettingsKey[]
   readonly next: SettingsRecord
@@ -31,6 +38,8 @@ export interface SessionDefaultsPlan {
    * on purpose, which is how an operator opts back into subagents.
    */
   readonly predates: boolean
+  /** True when the deny list lacks any merge entry, whatever else it holds. */
+  readonly lacksMergeDeny: boolean
 }
 
 export type SessionDefaultsRead =
@@ -52,8 +61,8 @@ function isRecord(value: unknown): value is SettingsRecord {
 }
 
 /**
- * Appends the denied tools a list lacks, keeping the list's own order, so the
- * diff a person reads is the added entries alone.
+ * Appends the denied tools and merge entries a list lacks, keeping the list's
+ * own order, so the diff a person reads is the added entries alone.
  */
 export function planSessionDefaults(
   current: SettingsRecord,
@@ -62,7 +71,9 @@ export function planSessionDefaults(
   const permissions = isRecord(current.permissions) ? current.permissions : {}
   const deny = Array.isArray(permissions.deny) ? permissions.deny : []
 
-  const missing = DENIED_TOOLS.filter((tool) => !deny.includes(tool))
+  const subagentsMissing = DENIED_TOOLS.filter((tool) => !deny.includes(tool))
+  const mergeMissing = MERGE_DENIED.filter((entry) => !deny.includes(entry))
+  const missing = [...subagentsMissing, ...mergeMissing]
   if (missing.length > 0) {
     next.permissions = { ...permissions, deny: [...deny, ...missing] }
   }
@@ -78,7 +89,11 @@ export function planSessionDefaults(
     keys,
     next,
     changed: keys.some((key) => key.changed),
-    predates: memoryAbsent && missing.length === DENIED_TOOLS.length,
+    predates:
+      memoryAbsent &&
+      subagentsMissing.length === DENIED_TOOLS.length &&
+      mergeMissing.length === MERGE_DENIED.length,
+    lacksMergeDeny: mergeMissing.length > 0,
   }
 }
 

package/src/pr/evidence.ts

@@ -5,7 +5,7 @@ const EVIDENCE_SEGMENT = 'evidence'
 const EVIDENCE_OPEN_LIMIT = 6
 
 /** Length of the commit names the visible line shows, the width `git` abbreviates to. */
-const SHORT_SHA_LENGTH = 7
+export const SHORT_SHA_LENGTH = 7
 
 /** Prefix of the trailing marker this module writes and reads back. */
 const MARKER_PREFIX = '<!-- pr-evidence:'

package/src/pr/lift.ts

@@ -4,6 +4,7 @@ import {
   type ReviewRow,
   resolveReviewScope,
   resolveUiScope,
+  type UiCounts,
 } from '@/pr/review-scope'
 import { DEFAULT_PAINTED, isPainted, type PaintedPatterns } from '@/pr/painted'
 
@@ -24,6 +25,7 @@ export type LiftRefusal =
   | 'ui-open'
   | 'ui-unmarked'
   | 'ui-behind'
+  | 'ui-undriven'
   | 'evidence-owed'
   | 'standing-stale'
   | 'standing-conflict'
@@ -170,6 +172,20 @@ function carried(gates: readonly GateResult[]): {
   }
 }
 
+/**
+ * Whether a verdict's counts show boxes left undriven and none driven. An empty
+ * pass, with nothing not driven either, looked at no box because none was owed.
+ */
+function droveNothing(counts: UiCounts | undefined): boolean {
+  return (
+    counts !== undefined &&
+    counts.failed === 0 &&
+    counts.eyes === 0 &&
+    counts.passed === 0 &&
+    counts.notDriven > 0
+  )
+}
+
 /**
  * Binds only where the evidence record carries a checklist to drive.
  *
@@ -192,6 +208,9 @@ export async function uiGate(
   if (scope.state === 'open') return fail('ui', 'ui-open')
   if (scope.source !== 'marker') return fail('ui', 'ui-unmarked')
   if (scope.commit === undefined) return fail('ui', 'ui-behind')
+  // Ahead of the head test so a close carried across commits is refused too.
+  // A verdict whose count line did not parse reads as unchecked and goes on.
+  if (droveNothing(scope.counts)) return fail('ui', 'ui-undriven')
   if (coversHead(scope.commit, head)) return pass('ui')
 
   const changed = await api.readChanged(scope.commit, head)