@erclx/canon 5.26.0 → 5.28.0

package/src/pr/evidence.ts

@@ -10,18 +10,36 @@ const SHORT_SHA_LENGTH = 7
 /** Prefix of the trailing marker this module writes and reads back. */
 const MARKER_PREFIX = '<!-- pr-evidence:'
 
-/** How the first line of a body names the branch's preview deployment. */
+/** How the address line names the branch's preview deployment. */
 const PREVIEW_PREFIX = '**Preview:**'
 
-/** How the opening block names the branch's server on the operator's own machine, under any hosted preview line. */
-export const LOCAL_PREFIX = '**Local preview:**'
+/** How the address line names the branch's server on the operator's own machine, after any hosted segment. */
+const LOCAL_PREFIX = '**Local preview:**'
+
+/** What joins the hosted and local segments on the one address line. */
+const ADDRESS_SEPARATOR = ' · '
+
+/** The heading every body opens with. */
+const EVIDENCE_HEADING = '## Evidence'
+
+/** How the visible commit line opens. */
+const BASE_PREFIX = '**Base:**'
 
 /** The heading the checklist sits under, printed outside the delimiters so a carried checklist never doubles it. */
 const CHECKLIST_HEADING = '## What to look at'
 
 /** Delimiters around the checklist, so a re-render can read back what a reviewer has already ticked. */
-const CHECKLIST_START = '<!-- pr-checklist:start -->'
-const CHECKLIST_END = '<!-- pr-checklist:end -->'
+export const CHECKLIST_START = '<!-- pr-checklist:start -->'
+export const CHECKLIST_END = '<!-- pr-checklist:end -->'
+
+/** One checklist line, a list marker then a box that GitHub renders for `x` in either case. */
+const BOX_LINE = /^(\s*[-*+] \[)([ xX])(\] )(.*)$/
+
+/** The trailing segment a tick carries, naming the commit the box passed at. Matched only at the end of a line, so a box whose own text says `passed at` is left alone. */
+const STAMP = / · passed at `([0-9a-f]{7,40})`$/
+
+/** What ends the text of a box that a person has to judge by eye. */
+const TASTE_SUFFIX = '(taste)'
 
 /** A `#issuecomment-<id>` suffix, which is the REST comment id `gh pr view` never returns directly. */
 const ISSUE_COMMENT_ID = /#issuecomment-(\d+)$/
@@ -29,8 +47,8 @@ const ISSUE_COMMENT_ID = /#issuecomment-(\d+)$/
 /**
  * The image extensions this module embeds. An `evidence/` folder holds
  * whatever else a project keeps beside its captures, such as a README, a
- * capture script, or a raw data file, and none of those render as
- * `![](url)` without producing a broken embed.
+ * capture script, or a raw data file, and none of those render as an
+ * `<img>` without producing a broken embed.
  */
 const IMAGE_EXTENSION = /\.(png|jpe?g|gif|webp|avif|svg)$/i
 
@@ -121,6 +139,35 @@ function rawUrl(repo: string, sha: string, path: string): string {
   return `https://github.com/${repo}/blob/${sha}/${path}?raw=true`
 }
 
+/**
+ * The pixel width every screenshot asks for. GitHub sizes a comment table to
+ * its content and clamps an image to its cell, so a width past any comment
+ * fills the cell, where `width="100%"` leaves a narrow screenshot narrow.
+ */
+const IMAGE_WIDTH = 1000
+
+/** A table cell and an attribute value share one escape, since a stem is a path segment placed in both. */
+function escapeCell(text: string): string {
+  return text
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll('|', '&#124;')
+}
+
+function evidenceImage(url: string, alt: string): string {
+  return `<img src="${url}" width="${IMAGE_WIDTH}" alt="${alt}">`
+}
+
+const EVIDENCE_IMAGE = String.raw`(?:!\[\]\([^)]*\)|<img [^>]*>)`
+
+/** A case row in any shape a render has posted: a Base cell before the head image, or the head image alone. */
+const EVIDENCE_ROW_PATTERN = new RegExp(
+  String.raw`^\| .+ \| (?:(?:\*\(new\)\*|${EVIDENCE_IMAGE}) \| )?${EVIDENCE_IMAGE} \|$`,
+  'gm',
+)
+
 export function evidenceMarker(head: string): string {
   return `${MARKER_PREFIX} head=${head} -->`
 }
@@ -135,15 +182,15 @@ export function evidenceMarker(head: string): string {
  * pinned to a commit sha rather than a branch, so the comment keeps showing
  * what it claimed even after the branch moves.
  *
- * A preview address opens the body, and with no states it is the whole body
- * apart from the marker, so a pull request whose screenshots did not change
- * still gets one comment a later call can find and edit in place.
+ * The body opens with `## Evidence` and, under it, one address line joining
+ * whichever of the hosted and local previews apply, so the comment reads as
+ * evidence first and a preview never stands where the heading should. With no
+ * states the heading and the address are the whole body apart from the
+ * marker, so a pull request whose screenshots did not change still gets one
+ * comment a later call can find and edit in place.
  *
  * A checklist closes the body, below the comparison it annotates, so one
- * comment carries the preview address, the screenshots, and what to look at.
- *
- * A local address sits under the hosted one, never above it, so the hosted
- * line keeps the first-line position `findEvidencePreview` reads.
+ * comment carries the addresses, the screenshots, and what to look at.
  */
 export function renderEvidenceBody(
   states: readonly EvidenceState[],
@@ -154,11 +201,15 @@ export function renderEvidenceBody(
   checklist?: string,
   local?: string,
 ): string {
-  const addresses = [
+  const segments = [
     ...(preview === undefined ? [] : [`${PREVIEW_PREFIX} ${preview}`]),
     ...(local === undefined ? [] : [`${LOCAL_PREFIX} ${local}`]),
   ]
-  const opening = addresses.length === 0 ? [] : [...addresses, '']
+  const opening = [
+    EVIDENCE_HEADING,
+    '',
+    ...(segments.length === 0 ? [] : [segments.join(ADDRESS_SEPARATOR), '']),
+  ]
   const closing =
     checklist === undefined
       ? []
@@ -176,20 +227,24 @@ export function renderEvidenceBody(
     imageCount <= EVIDENCE_OPEN_LIMIT ? '<details open>' : '<details>'
 
   const sections = states.map((entry) => {
+    const hasBase = entry.items.some((item) => !item.added)
     const rows = entry.items.map((item) => {
+      const stem = escapeCell(item.stem)
       const before = item.added
         ? '*(new)*'
-        : `![](${rawUrl(repo, base, item.path)})`
-      const after = `![](${rawUrl(repo, head, item.path)})`
-      return `| ${item.stem} | ${before} | ${after} |`
+        : evidenceImage(rawUrl(repo, base, item.path), `${stem} base`)
+      const after = evidenceImage(rawUrl(repo, head, item.path), `${stem} head`)
+      return hasBase
+        ? `| ${stem} | ${before} | ${after} |`
+        : `| ${stem} | ${after} |`
     })
 
     return [
       opener,
       `<summary>${entry.state === '' ? 'evidence' : entry.state} (${entry.items.length})</summary>`,
       '',
-      '| Case | Base | Head |',
-      '| --- | --- | --- |',
+      hasBase ? '| Case | Base | Head |' : '| Case | Head |',
+      hasBase ? '| --- | --- | --- |' : '| --- | --- |',
       ...rows,
       '',
       '</details>',
@@ -198,9 +253,7 @@ export function renderEvidenceBody(
 
   return [
     ...opening,
-    '## Evidence',
-    '',
-    `**Base:** \`${base.slice(0, SHORT_SHA_LENGTH)}\` · **Head:** \`${head.slice(0, SHORT_SHA_LENGTH)}\``,
+    `${BASE_PREFIX} \`${base.slice(0, SHORT_SHA_LENGTH)}\` · **Head:** \`${head.slice(0, SHORT_SHA_LENGTH)}\``,
     '',
     ...sections,
     '',
@@ -210,16 +263,14 @@ export function renderEvidenceBody(
 }
 
 /**
- * How many case rows a rendered body carries, read off the same row shape
+ * How many case rows a rendered body carries, read off the row shapes
  * `renderEvidenceBody` writes. A row always ends in a head image, which a
- * checklist line or a preview address never does.
+ * checklist line or a preview address never does. The pattern also reads the
+ * `![](url)` three-column shape an earlier render posted, so a comment posted
+ * before the change still counts its cases and the `would-empty` guard holds.
  */
 export function countEvidenceCases(body: string): number {
-  return (
-    body.match(
-      /^\| .+ \| (?:\*\(new\)\*|!\[\]\([^)]*\)) \| !\[\]\([^)]*\) \|$/gm,
-    )?.length ?? 0
-  )
+  return body.match(EVIDENCE_ROW_PATTERN)?.length ?? 0
 }
 
 export interface EvidenceComment {
@@ -249,7 +300,8 @@ export interface OwedInput {
   readonly hasEvidenceChange: boolean
   readonly hasMarkedComment: boolean
   readonly carriedPreview: boolean
-  readonly deployWorkflowFound: boolean
+  /** A deploy workflow resolves and its push filter matches a path the pull request changed. */
+  readonly deployServesChange: boolean
 }
 
 /**
@@ -262,7 +314,7 @@ export function readOwed(input: OwedInput): OwedStep[] {
   if (input.hasEvidenceChange && !input.hasMarkedComment) owed.push('evidence')
   if (
     (input.hasMarkedComment || input.hasEvidenceChange) &&
-    input.deployWorkflowFound &&
+    input.deployServesChange &&
     !input.carriedPreview
   ) {
     owed.push('preview')
@@ -295,33 +347,78 @@ export function findEvidenceCaseCount(
   return marked === undefined ? 0 : countEvidenceCases(marked.body)
 }
 
+/** Lines that close the address region, being whatever a body carries below its addresses. */
+const REGION_ENDS = [
+  BASE_PREFIX,
+  CHECKLIST_HEADING,
+  '<details',
+  CHECKLIST_START,
+  MARKER_PREFIX,
+]
+
+export interface AddressReading {
+  /** Indexes of the lines carrying a hosted or local segment. */
+  readonly lines: readonly number[]
+  readonly preview?: string
+  readonly local?: string
+}
+
+function readSegment(segment: string, prefix: string): string | undefined {
+  return segment.startsWith(prefix)
+    ? segment.slice(prefix.length).trim() || undefined
+    : undefined
+}
+
 /**
- * The preview address the marked comment already opens with. A re-render
- * after a later push passes no address of its own, and carrying this one
- * forward keeps that edit from deleting the link a reviewer is using.
+ * Reads the addresses a body carries in the region above its commit line,
+ * checklist, comparison, or marker, matching each prefix wherever it sits in
+ * that region. One reader covers the layout that opens on the addresses as
+ * well as the one that opens on the heading, so an open pull request keeps
+ * its links across the first re-render, and a line quoted further down in a
+ * checklist is never taken for an address.
  */
-export function findEvidencePreview(
+export function readAddresses(body: string): AddressReading {
+  const lines: number[] = []
+  let preview: string | undefined
+  let local: string | undefined
+  const bodyLines = body.split('\n')
+  for (let index = 0; index < bodyLines.length; index += 1) {
+    const line = (bodyLines[index] ?? '').trim()
+    if (REGION_ENDS.some((end) => line.startsWith(end))) break
+    let isAddress = false
+    for (const segment of line.split(ADDRESS_SEPARATOR.trim())) {
+      const trimmed = segment.trim()
+      const hosted = readSegment(trimmed, PREVIEW_PREFIX)
+      const own = readSegment(trimmed, LOCAL_PREFIX)
+      if (hosted !== undefined) preview ??= hosted
+      if (own !== undefined) local ??= own
+      if (hosted !== undefined || own !== undefined) isAddress = true
+    }
+    if (isAddress) lines.push(index)
+  }
+  return {
+    lines,
+    ...(preview !== undefined && { preview }),
+    ...(local !== undefined && { local }),
+  }
+}
+
+function findMarked(
   comments: readonly EvidenceComment[],
-): string | undefined {
-  const marked = comments.find((comment) => hasEvidenceMarker(comment.body))
-  const first = marked?.body.split('\n')[0]?.trim() ?? ''
-  if (!first.startsWith(PREVIEW_PREFIX)) return undefined
-  return first.slice(PREVIEW_PREFIX.length).trim() || undefined
+): EvidenceComment | undefined {
+  return comments.find((comment) => hasEvidenceMarker(comment.body))
 }
 
 /**
- * Where the local address line sits in a body, searched only through the
- * opening block above the first blank line, so a line quoted further down in
- * a checklist is never taken for it. -1 when the block carries none.
+ * The preview address the marked comment already carries. A re-render after
+ * a later push passes no address of its own, and carrying this one forward
+ * keeps that edit from deleting the link a reviewer is using.
  */
-export function findLocalLineIndex(body: string): number {
-  const lines = body.split('\n')
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = (lines[index] ?? '').trim()
-    if (line === '') return -1
-    if (line.startsWith(LOCAL_PREFIX)) return index
-  }
-  return -1
+export function findEvidencePreview(
+  comments: readonly EvidenceComment[],
+): string | undefined {
+  const marked = findMarked(comments)
+  return marked === undefined ? undefined : readAddresses(marked.body).preview
 }
 
 /**
@@ -331,12 +428,8 @@ export function findLocalLineIndex(body: string): number {
 export function findEvidenceLocal(
   comments: readonly EvidenceComment[],
 ): string | undefined {
-  const marked = comments.find((comment) => hasEvidenceMarker(comment.body))
-  if (marked === undefined) return undefined
-  const index = findLocalLineIndex(marked.body)
-  if (index === -1) return undefined
-  const line = marked.body.split('\n')[index]?.trim() ?? ''
-  return line.slice(LOCAL_PREFIX.length).trim() || undefined
+  const marked = findMarked(comments)
+  return marked === undefined ? undefined : readAddresses(marked.body).local
 }
 
 /**
@@ -357,3 +450,101 @@ export function findEvidenceChecklist(
     marked.body.slice(start + CHECKLIST_START.length, end).trim() || undefined
   )
 }
+
+export interface ChecklistBox {
+  /** One-based position among the checklist's boxes, in the order they appear. */
+  readonly number: number
+  /** Index of the box's line within the checklist. */
+  readonly line: number
+  /** The box text with any stamp removed. */
+  readonly text: string
+  readonly isTicked: boolean
+  /** The short sha a tick names, absent on an empty box or a tick nothing stamped. */
+  readonly stamp?: string
+  /** Whether the box ends in `(taste)`, which no driver ticks. */
+  readonly isTaste: boolean
+}
+
+export interface BoxLine {
+  readonly before: string
+  readonly isTicked: boolean
+  readonly text: string
+  readonly stamp?: string
+}
+
+/** Splits one checklist line into its box parts, or undefined when the line is not a box. */
+export function parseBoxLine(line: string): BoxLine | undefined {
+  const match = BOX_LINE.exec(line)
+  if (match === null) return undefined
+  const rest = (match[4] ?? '').trimEnd()
+  const stamped = STAMP.exec(rest)
+  return {
+    before: match[1] ?? '',
+    isTicked: (match[2] ?? ' ') !== ' ',
+    text: stamped === null ? rest : rest.slice(0, stamped.index),
+    ...(stamped?.[1] !== undefined && { stamp: stamped[1] }),
+  }
+}
+
+/** The box line for the given parts, written back in the one shape the reader accepts. */
+export function writeBoxLine(
+  box: Pick<BoxLine, 'before' | 'text'>,
+  stampedAt?: string,
+): string {
+  return stampedAt === undefined
+    ? `${box.before} ] ${box.text}`
+    : `${box.before}x] ${box.text} · passed at \`${stampedAt.slice(0, SHORT_SHA_LENGTH)}\``
+}
+
+/** Every box of a checklist in order, numbered the way `canon pr tick` takes them. */
+export function readChecklistBoxes(checklist: string): ChecklistBox[] {
+  const boxes: ChecklistBox[] = []
+  checklist.split('\n').forEach((line, index) => {
+    const parsed = parseBoxLine(line)
+    if (parsed === undefined) return
+    boxes.push({
+      number: boxes.length + 1,
+      line: index,
+      text: parsed.text,
+      isTicked: parsed.isTicked,
+      ...(parsed.stamp !== undefined && { stamp: parsed.stamp }),
+      isTaste: parsed.text.endsWith(TASTE_SUFFIX),
+    })
+  })
+  return boxes
+}
+
+/** The head the marked comment's trailing marker names. */
+export function findEvidenceHead(
+  comments: readonly EvidenceComment[],
+): string | undefined {
+  const marked = comments.find((comment) => hasEvidenceMarker(comment.body))
+  if (marked === undefined) return undefined
+  const lines = marked.body.trimEnd().split('\n')
+  const match = /head=(\S+)/.exec(lines[lines.length - 1] ?? '')
+  return match?.[1]
+}
+
+/**
+ * Clears every tick the render's head has not earned. A stamped tick stays
+ * while its sha is a prefix of the head. An unstamped one names no head, so
+ * it stays only while the comment it came from described this same head.
+ */
+export function settleChecklist(
+  checklist: string,
+  head: string,
+  carriedHead: string | undefined,
+): string {
+  return checklist
+    .split('\n')
+    .map((line) => {
+      const parsed = parseBoxLine(line)
+      if (parsed === undefined || !parsed.isTicked) return line
+      const isEarned =
+        parsed.stamp === undefined
+          ? carriedHead === head
+          : head.startsWith(parsed.stamp)
+      return isEarned ? line : writeBoxLine(parsed)
+    })
+    .join('\n')
+}

package/src/pr/local.ts

@@ -1,4 +1,4 @@
-import { findLocalLineIndex } from '@/pr/evidence'
+import { readAddresses } from '@/pr/evidence'
 
 /**
  * The folder linked worktrees sit under. A listener there belongs to another
@@ -111,15 +111,21 @@ export function parseProcNetTcp(text: string): ProcSocket[] {
 }
 
 /**
- * Replaces the local address line of a marked body with `note`, leaving
- * every other byte in place so the trailing marker, the checklist delimiters,
- * and any ticked box survive. Undefined when the body carries no such line,
- * which is also what a second strip of the same body returns.
+ * Drops the address line of a marked body, hosted and local segments alike,
+ * since the close that runs this also deletes the branch's preview
+ * deployments and a link left behind points at nothing. Every other byte stays
+ * in place, so the trailing marker, the checklist delimiters, and any ticked
+ * box survive, and the blank line the address sat on is dropped with it so no
+ * gap doubles. Undefined when the body carries no address, which is also what
+ * a second drop of the same body returns.
  */
-export function stripLocalLine(body: string, note: string): string | undefined {
-  const index = findLocalLineIndex(body)
-  if (index === -1) return undefined
-  const lines = body.split('\n')
-  lines[index] = note
+export function dropAddressLine(body: string): string | undefined {
+  const { lines: indexes } = readAddresses(body)
+  const first = indexes[0]
+  if (first === undefined) return undefined
+  const dropped = new Set(indexes)
+  const lines = body.split('\n').filter((_, index) => !dropped.has(index))
+  const isGapAbove = first === 0 || (lines[first - 1] ?? '').trim() === ''
+  if (isGapAbove && (lines[first] ?? '').trim() === '') lines.splice(first, 1)
   return lines.join('\n')
 }

package/src/pr/preview.ts

@@ -16,6 +16,7 @@ const BRANCH_FENCE = '--branch=${{ github.ref_name }}'
 
 export type PreviewRefusal =
   | 'no-deploy'
+  | 'unserved'
   | 'unfenced'
   | 'no-alias'
   | 'gh-failed'
@@ -27,8 +28,77 @@ export interface WorkflowFile {
   readonly text: string
 }
 
+/**
+ * Which changed paths a deploy builds from, read off its own push trigger, so
+ * the workflow that decides when production deploys is also the one statement
+ * of what a branch preview serves.
+ */
+export type ServedFilter =
+  | { readonly kind: 'all' }
+  | { readonly kind: 'paths'; readonly patterns: readonly string[] }
+  | { readonly kind: 'paths-ignore'; readonly patterns: readonly string[] }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function readPatterns(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  return value.filter((entry): entry is string => typeof entry === 'string')
+}
+
+/**
+ * Reads `on.push.paths` or `on.push.paths-ignore`. A workflow with neither,
+ * with no push trigger, or that does not parse serves every change, since
+ * reading unserved by mistake stops every reader asking for a preview.
+ */
+export function readServedPaths(workflowText: string): ServedFilter {
+  let parsed: unknown
+  try {
+    parsed = Bun.YAML.parse(workflowText)
+  } catch {
+    return { kind: 'all' }
+  }
+  const on = isRecord(parsed) ? parsed.on : undefined
+  const push = isRecord(on) ? on.push : undefined
+  if (!isRecord(push)) return { kind: 'all' }
+
+  const paths = readPatterns(push.paths)
+  if (paths !== undefined) return { kind: 'paths', patterns: paths }
+  const ignored = readPatterns(push['paths-ignore'])
+  if (ignored !== undefined) return { kind: 'paths-ignore', patterns: ignored }
+  return { kind: 'all' }
+}
+
+/** Whether the patterns match a path, applied in order so a later `!` pattern overrides an earlier one, as GitHub applies them. */
+function matchesInOrder(patterns: readonly string[], path: string): boolean {
+  let isMatched = false
+  for (const pattern of patterns) {
+    const isNegated = pattern.startsWith('!')
+    const glob = new Bun.Glob(isNegated ? pattern.slice(1) : pattern)
+    if (glob.match(path)) isMatched = !isNegated
+  }
+  return isMatched
+}
+
+/** Whether a push carrying `changedPaths` would run the deploy, by the filter its trigger declares. */
+export function servesChange(
+  filter: ServedFilter,
+  changedPaths: readonly string[],
+): boolean {
+  if (filter.kind === 'all') return true
+  if (filter.kind === 'paths') {
+    return changedPaths.some((path) => matchesInOrder(filter.patterns, path))
+  }
+  return changedPaths.some((path) => !matchesInOrder(filter.patterns, path))
+}
+
 export type WorkflowPick =
-  | { readonly kind: 'found'; readonly path: string }
+  | {
+      readonly kind: 'found'
+      readonly path: string
+      readonly filter: ServedFilter
+    }
   | {
       readonly kind: 'refused'
       readonly reason: 'no-deploy' | 'unfenced' | 'no-alias'
@@ -36,6 +106,7 @@ export type WorkflowPick =
 
 interface WorkflowShape {
   readonly path: string
+  readonly text: string
   readonly deployLines: readonly string[]
   readonly isDispatchable: boolean
   readonly hasMarker: boolean
@@ -51,6 +122,7 @@ function readShape(file: WorkflowFile): WorkflowShape {
     .filter((line) => !line.trimStart().startsWith('#'))
   return {
     path: file.path,
+    text: file.text,
     deployLines: lines.filter((line) => line.includes('pages deploy')),
     isDispatchable: lines.some((line) => /^\s*workflow_dispatch:/.test(line)),
     hasMarker: lines.some((line) => line.includes(ALIAS_MARKER)),
@@ -80,7 +152,11 @@ export function findDeployWorkflow(
   const marked = fenced.find((shape) => shape.hasMarker)
   if (marked === undefined) return { kind: 'refused', reason: 'no-alias' }
 
-  return { kind: 'found', path: marked.path }
+  return {
+    kind: 'found',
+    path: marked.path,
+    filter: readServedPaths(marked.text),
+  }
 }
 
 export function readPreviewAlias(log: string): string | undefined {

package/src/pr/tick.ts

@@ -0,0 +1,56 @@
+import {
+  CHECKLIST_END,
+  CHECKLIST_START,
+  parseBoxLine,
+  readChecklistBoxes,
+  writeBoxLine,
+} from '@/pr/evidence'
+
+export type TickRefusal = 'no-checklist' | 'no-box' | 'taste-box'
+
+export type TickResult =
+  | { readonly kind: 'ticked'; readonly body: string }
+  | { readonly kind: 'refused'; readonly reason: TickRefusal }
+
+/**
+ * Ticks the named boxes of a marked body's checklist and stamps each with the
+ * commit it passed at. A refusal writes nothing, so a taste box named among
+ * passed ones leaves every box as it was. A box already ticked is restamped,
+ * which makes a repeat at one head a no-op.
+ */
+export function tickBoxes(
+  body: string,
+  numbers: readonly number[],
+  head: string,
+): TickResult {
+  const start = body.indexOf(CHECKLIST_START)
+  const end = body.indexOf(CHECKLIST_END, start)
+  if (start === -1 || end === -1) {
+    return { kind: 'refused', reason: 'no-checklist' }
+  }
+
+  const from = start + CHECKLIST_START.length
+  const region = body.slice(from, end)
+  const boxes = readChecklistBoxes(region)
+
+  const named = numbers.map((number) =>
+    boxes.find((box) => box.number === number),
+  )
+  if (named.some((box) => box === undefined)) {
+    return { kind: 'refused', reason: 'no-box' }
+  }
+  if (named.some((box) => box?.isTaste === true)) {
+    return { kind: 'refused', reason: 'taste-box' }
+  }
+
+  const lines = region.split('\n')
+  for (const box of named) {
+    if (box === undefined) continue
+    const parsed = parseBoxLine(lines[box.line] ?? '')
+    if (parsed !== undefined) lines[box.line] = writeBoxLine(parsed, head)
+  }
+  return {
+    kind: 'ticked',
+    body: `${body.slice(0, from)}${lines.join('\n')}${body.slice(end)}`,
+  }
+}

package/src/process/harness.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from 'node:child_process'
 import { readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
-import { PROJECT_ROOT } from '@/project-root'
+import { PROJECT_ROOT } from '@/roots/project'
 import { stateDir } from '@/targets/registry'
 
 const CLI = join(PROJECT_ROOT, 'src/cli.ts')

package/src/records/backup.ts

@@ -1,8 +1,8 @@
 import { existsSync, lstatSync, readdirSync } from 'node:fs'
 import { basename, join, relative, resolve } from 'node:path'
 import { $ } from 'bun'
-import { gitEnv } from '@/git-env'
-import { RECORD_ROOTS, recordRoot, SCRATCH } from '@/record-root'
+import { gitEnv } from '@/git/env'
+import { RECORD_ROOTS, recordRoot, SCRATCH } from '@/roots/record'
 import { type BlockedPath, guardPayload } from '@/records/push-guard'
 
 /**

package/src/records/ordinal.ts

@@ -1,6 +1,6 @@
 import { mkdir, readdir, rm, stat } from 'node:fs/promises'
 import { extractOrdinal } from '@/intake/folder'
-import { recordDir } from '@/record-root'
+import { recordDir } from '@/roots/record'
 
 /**
  * The two record folders that share one ordinal sequence, per

package/src/records/prune.ts

@@ -3,7 +3,7 @@ import { readdir, rm, stat } from 'node:fs/promises'
 import { join, relative } from 'node:path'
 import { RECORD_LAYOUT_MOVES } from '@/migrate/record-layout'
 import { PROMOTED_FOLDERS } from '@/migrate/scratch-evidence'
-import { RECORD_ROOTS, recordDir, SCRATCH } from '@/record-root'
+import { RECORD_ROOTS, recordDir, SCRATCH } from '@/roots/record'
 import { day, newestMtime } from '@/records/size'
 
 const DAY_MS = 24 * 60 * 60 * 1000