@erclx/canon 5.27.0 → 5.29.0

package/src/commands/pr.ts

@@ -29,12 +29,19 @@ import {
   findEvidenceCaseCount,
   findEvidenceChecklist,
   findEvidenceCommentId,
+  findEvidenceHead,
   findEvidenceLocal,
   findEvidencePreview,
+  type EvidenceItem,
+  type EvidenceReading,
   groupEvidence,
   hasMarkedEvidenceComment,
+  PNG_HEADER_BYTES,
+  readChecklistBoxes,
   readOwed,
+  readPngWidth,
   renderEvidenceBody,
+  settleChecklist,
 } from '@/pr/evidence'
 import {
   dropFrames,
@@ -71,6 +78,7 @@ import {
   servesChange,
   type WorkflowFile,
 } from '@/pr/preview'
+import { type TickRefusal, tickBoxes } from '@/pr/tick'
 import {
   commentRowOf,
   identityOf,
@@ -83,7 +91,7 @@ import {
   selectBranchPull,
 } from '@/pr/rest'
 import { resolveReviewScope } from '@/pr/review-scope'
-import { intro, logInfo, logStep, logWarn, outro, plural } from '@/ui'
+import { intro, logInfo, logStep, logWarn, outro, plural } from '@/cli/ui'
 
 const GH_TIMEOUT_MS = 30_000
 
@@ -113,6 +121,28 @@ interface LocalOptions extends ReadOptions {
   readonly remove?: boolean
 }
 
+interface TickOptions extends ReadOptions {
+  readonly boxes?: string
+  readonly head?: string
+}
+
+type TickReason = TickRefusal | 'stale-head' | 'bad-boxes' | 'no-comment'
+
+const TICK_REFUSALS: Record<TickReason | 'gh-failed', string> = {
+  'stale-head':
+    'The head named is not the branch tip on the remote, so a tick would claim a pass on a commit that is no longer the pull request. Re-drive the checklist at the tip.',
+  'bad-boxes':
+    '--boxes takes box numbers as a comma-separated list of positive whole numbers, such as 1,3, and --head takes the commit that was driven.',
+  'no-comment': 'No comment on this pull request carries the evidence marker.',
+  'no-checklist': 'The evidence comment carries no checklist to tick.',
+  'no-box':
+    'A named box is past the end of the checklist. Number boxes off `canon pr evidence --json`.',
+  'taste-box':
+    'A named box ends in (taste), which no driver passes. Nothing was written.',
+  'gh-failed':
+    'gh could not read or edit the marked comment on this pull request.',
+}
+
 /** Shared by every verb that resolves a pull request from the checkout's branch. */
 const AMBIGUOUS_PULL =
   'More than one pull request is open on this branch, each against another base. Name the pull request number.'
@@ -563,10 +593,12 @@ export function register(program: Command): void {
         '--checklist closes the body with a visual checklist, below the',
         'comparison it annotates. A checklist the marked comment already',
         'carries is read back and carried forward the same way the preview',
-        'address is, which keeps a re-render from wiping ticked boxes. It',
-        'turns no-evidence into ok: a branch with a checklist and no evidence',
-        'image renders a marked body holding the checklist, so a later call',
-        'finds and edits that comment.',
+        'address is. A tick survives only a render at the head it names: one',
+        'stamped `passed at <sha>` for another head is cleared and unstamped,',
+        'and so is one carrying no stamp when the comment described another',
+        'head. A checklist, supplied or carried, turns no-evidence into ok: a',
+        'branch with a checklist and no evidence image renders a marked body',
+        'holding the checklist, so a later call finds and edits that comment.',
         '',
         '--local adds a **Local preview:** segment after any hosted one on the',
         'address line, or carries the line alone, and is carried forward the',
@@ -580,6 +612,8 @@ export function register(program: Command): void {
         '  preview    the hosted **Preview:** address the comment carries',
         '  local      the **Local preview:** address beside it',
         '  checklist  the checklist between its delimiters, ticks included',
+        '  boxes      each checklist box with its number, tick, stamp, and taste',
+        '             mark, the numbering `canon pr tick` takes',
         'These come from the comment already posted, never from the flags this',
         'call passed. A checklist the caller posted raw after a refused render',
         'carries no marker, so the record reports none of the three for it. An',
@@ -741,6 +775,51 @@ export function register(program: Command): void {
           : await runLocal(opts)
     })
 
+  pr.command('tick')
+    .description(
+      "Tick the checklist boxes a UI pass drove, stamping each with the commit it passed at, on the pull request's evidence comment",
+    )
+    .argument('[number]', 'Pull request to edit, defaulting to this branch')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--root <path>', 'Repository to read, defaulting to the cwd')
+    .option('--json', 'Add a machine-readable record on stdout')
+    .requiredOption(
+      '--boxes <list>',
+      'Box numbers to tick, comma-separated, as `canon pr evidence --json` numbers them',
+    )
+    .requiredOption('--head <sha>', 'The commit the boxes were driven at')
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Edits the marked evidence comment in place, so a skill never',
+        'hand-edits a comment body. Each named box becomes',
+        '`- [x] <box> · passed at <short sha>`. Ticking a box again restamps',
+        'it. A later render at another head clears a tick whose stamp names',
+        'a different commit.',
+        '',
+        'Read `reason` on the JSON record:',
+        '  ticked       the boxes were ticked, with the tip in `head`',
+        '  stale-head   --head is not the remote branch tip, nothing written',
+        '  taste-box    a named box ends in (taste), nothing written',
+        '  no-box       a named number is past the checklist, nothing written',
+        '  no-checklist the evidence comment carries no checklist',
+        '  no-comment   no comment carries the evidence marker',
+        '  bad-boxes    --boxes or --head is malformed',
+        '',
+        'Exit codes:',
+        '  0  the boxes were ticked',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '',
+        'Examples:',
+        '  canon pr tick 1341 --boxes 1,2,4 --head 1a2b3c4 --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (number: string | undefined, opts: TickOptions) => {
+      process.exitCode = await runTick(number, opts)
+    })
+
   pr.command('frames')
     .description(
       `Push a UI review frame to the never-merged ${FRAMES_BRANCH} branch and return its embed link, or drop frames from it`,
@@ -1671,6 +1750,134 @@ async function readPullMergeBase(
   return sha === null || sha.trim() === '' ? undefined : sha.trim()
 }
 
+/** How many width reads run at once, since each downloads a whole image. */
+const WIDTH_READ_CONCURRENCY = 4
+
+type WidthRead =
+  | { readonly kind: 'read'; readonly width?: number }
+  | { readonly kind: 'failed' }
+
+/**
+ * The pixel width of a PNG at `sha`, read over the contents API like every
+ * other evidence read. The endpoint ignores a `Range` header, so the whole
+ * file arrives and only its first bytes are read. A format other than PNG
+ * reads without a width, and a refused or timed-out call reads as failed, so
+ * the caller can keep the ceiling width and still report the cause.
+ */
+async function readImageWidth(
+  cwd: string,
+  path: string,
+  sha: string,
+): Promise<WidthRead> {
+  if (!/\.png$/i.test(path)) return { kind: 'read' }
+  try {
+    const result = await execa(
+      'gh',
+      [
+        'api',
+        '-H',
+        'Accept: application/vnd.github.raw',
+        `repos/{owner}/{repo}/contents/${path.split('/').map(encodeURIComponent).join('/')}?ref=${sha}`,
+      ],
+      {
+        cwd,
+        timeout: GH_TIMEOUT_MS,
+        env: gitEnv(),
+        extendEnv: false,
+        encoding: 'buffer',
+      },
+    )
+    const width = readPngWidth(result.stdout.subarray(0, PNG_HEADER_BYTES))
+    return width === undefined ? { kind: 'read' } : { kind: 'read', width }
+  } catch {
+    return { kind: 'failed' }
+  }
+}
+
+/** Runs `task` over `inputs` with at most `limit` in flight, keeping input order. */
+async function mapPool<T, R>(
+  inputs: readonly T[],
+  limit: number,
+  task: (input: T) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = new Array(inputs.length)
+  let next = 0
+  const lane = async (): Promise<void> => {
+    while (next < inputs.length) {
+      const index = next++
+      results[index] = await task(inputs[index] as T)
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, inputs.length) }, lane),
+  )
+  return results
+}
+
+interface SizedEvidence {
+  readonly reading: EvidenceReading
+  /** Each image whose width read failed, as `head:<path>` or `base:<path>`, which rendered at the ceiling. */
+  readonly unread: readonly string[]
+}
+
+/** Each item with the pixel width of its head image and, when it has one, its base image. */
+async function withImageWidths(
+  cwd: string,
+  reading: EvidenceReading,
+  base: string | undefined,
+  head: string,
+): Promise<SizedEvidence> {
+  if (reading.kind === 'refused') return { reading, unread: [] }
+  const jobs = reading.states.flatMap((entry, stateIndex) =>
+    entry.items.flatMap((item, itemIndex) => [
+      {
+        stateIndex,
+        itemIndex,
+        side: 'head' as const,
+        path: item.path,
+        sha: head,
+      },
+      ...(item.added || base === undefined
+        ? []
+        : [
+            {
+              stateIndex,
+              itemIndex,
+              side: 'base' as const,
+              path: item.path,
+              sha: base,
+            },
+          ]),
+    ]),
+  )
+  const reads = await mapPool(jobs, WIDTH_READ_CONCURRENCY, (job) =>
+    readImageWidth(cwd, job.path, job.sha),
+  )
+  const unread: string[] = []
+  const states = reading.states.map((entry, stateIndex) => ({
+    ...entry,
+    items: entry.items.map((item, itemIndex): EvidenceItem => {
+      const widths: { width?: number; baseWidth?: number } = {}
+      jobs.forEach((job, index) => {
+        const read = reads[index]
+        if (
+          job.stateIndex !== stateIndex ||
+          job.itemIndex !== itemIndex ||
+          read === undefined
+        ) {
+          return
+        }
+        if (read.kind === 'failed') unread.push(`${job.side}:${job.path}`)
+        else if (read.width !== undefined) {
+          widths[job.side === 'head' ? 'width' : 'baseWidth'] = read.width
+        }
+      })
+      return { ...item, ...widths }
+    }),
+  }))
+  return { reading: { kind: 'read', states }, unread }
+}
+
 async function runEvidence(
   number: string | undefined,
   opts: EvidenceOptions,
@@ -1786,7 +1993,10 @@ async function runEvidence(
   const carried = {
     ...(carriedPreview !== undefined && { preview: carriedPreview }),
     ...(carriedLocal !== undefined && { local: carriedLocal }),
-    ...(carriedChecklist !== undefined && { checklist: carriedChecklist }),
+    ...(carriedChecklist !== undefined && {
+      checklist: carriedChecklist,
+      boxes: readChecklistBoxes(carriedChecklist),
+    }),
   }
 
   // A deploy that resolves and does not build from any changed path makes a
@@ -1834,7 +2044,8 @@ async function runEvidence(
   // comment a later call edits. A local address rides on a checklist or a
   // hosted preview and never opens one alone, so a docs-only branch with a
   // server up posts nothing.
-  const hasChecklist = suppliedChecklist !== undefined
+  const hasChecklist =
+    suppliedChecklist !== undefined || carriedChecklist !== undefined
   if (
     grouped.kind === 'refused' &&
     opts.preview === undefined &&
@@ -1870,8 +2081,13 @@ async function runEvidence(
 
   const preview = opts.preview ?? (isUnserved ? undefined : carriedPreview)
   const local = opts.local ?? carriedLocal
-  const checklist = suppliedChecklist ?? carriedChecklist
-  const states = grouped.kind === 'read' ? grouped.states : []
+  const unsettled = suppliedChecklist ?? carriedChecklist
+  const checklist =
+    unsettled === undefined
+      ? undefined
+      : settleChecklist(unsettled, identity.head, findEvidenceHead(comments))
+  const sized = await withImageWidths(root, grouped, base, identity.head)
+  const states = sized.reading.kind === 'read' ? sized.reading.states : []
   const body = renderEvidenceBody(
     states,
     repo,
@@ -1910,6 +2126,11 @@ async function runEvidence(
   logInfo(
     `${plural(caseCount, 'case')} across ${plural(states.length, 'state')}`,
   )
+  if (sized.unread.length > 0) {
+    logWarn(
+      `width unread for ${plural(sized.unread.length, 'image')}, rendered at 1000: ${sized.unread.join(', ')}`,
+    )
+  }
   if (preview !== undefined) logInfo(`preview ${preview}`)
   if (local !== undefined) logInfo(`local preview ${local}`)
   if (checklist !== undefined) {
@@ -1932,6 +2153,7 @@ async function runEvidence(
         head: identity.head,
         body,
         states,
+        ...(sized.unread.length > 0 && { widthUnread: sized.unread }),
         ...(commentId !== undefined && { commentId }),
         ...carried,
       })}\n`,
@@ -2402,6 +2624,99 @@ async function runLocalRemove(
 
 const POSITIVE_WHOLE = /^[1-9]\d*$/
 
+const MIN_TICK_HEAD_LENGTH = 7
+
+/**
+ * Ticks the named boxes on the marked comment. It refuses a head that is not
+ * the remote tip and a taste box before writing, so both rules hold as checks
+ * rather than as prose a driver can talk itself out of.
+ */
+async function runTick(
+  number: string | undefined,
+  opts: TickOptions,
+): Promise<number> {
+  const root = resolve(opts.root ?? process.cwd())
+  const emitJson = opts.json ?? false
+
+  intro('canon pr tick')
+
+  const refuseTick = (reason: TickReason | 'gh-failed'): number =>
+    refuseWith(reason, TICK_REFUSALS[reason], emitJson, root)
+
+  const numbers = (opts.boxes ?? '').split(',').map((part) => part.trim())
+  const head = (opts.head ?? '').trim()
+  if (
+    numbers.length === 0 ||
+    !numbers.every((part) => POSITIVE_WHOLE.test(part)) ||
+    !/^[0-9a-f]+$/.test(head) ||
+    head.length < MIN_TICK_HEAD_LENGTH
+  ) {
+    return refuseTick('bad-boxes')
+  }
+
+  const read = await readIdentity(root, number)
+  if (read.kind === 'refused') {
+    return refuseWith(read.reason, PULL_REFUSALS[read.reason], emitJson, root)
+  }
+  const { identity } = read
+  if (identity.number === undefined) return refuseTick('gh-failed')
+
+  const reading = await resolveTip(identity.branch, refReader(root))
+  if (reading.kind === 'refused') {
+    return refuseWith(
+      reading.reason,
+      PULL_REFUSALS[reading.reason],
+      emitJson,
+      root,
+    )
+  }
+  if (!reading.tip.startsWith(head)) return refuseTick('stale-head')
+
+  const comments = await listComments(root, String(identity.number))
+  if (comments === undefined) return refuseTick('gh-failed')
+  const commentId = findEvidenceCommentId(comments)
+  const marked = comments.find((comment) =>
+    comment.url?.endsWith(`#issuecomment-${commentId}`),
+  )
+  if (commentId === undefined || marked === undefined) {
+    return refuseTick('no-comment')
+  }
+
+  const result = tickBoxes(marked.body, numbers.map(Number), reading.tip)
+  if (result.kind === 'refused') return refuseTick(result.reason)
+
+  if (result.body !== marked.body) {
+    const patched = await gh(root, [
+      'api',
+      '-X',
+      'PATCH',
+      `repos/{owner}/{repo}/issues/comments/${commentId}`,
+      '-f',
+      `body=${result.body}`,
+    ])
+    if (patched === null) return refuseTick('gh-failed')
+  }
+
+  logStep('Ticked')
+  logInfo(
+    `${plural(numbers.length, 'box')} at ${reading.tip.slice(0, 7)} on comment ${commentId}`,
+  )
+  outro()
+  if (emitJson) {
+    process.stdout.write(
+      `${JSON.stringify({
+        root,
+        number: identity.number,
+        reason: 'ticked',
+        head: reading.tip,
+        boxes: numbers.map(Number),
+        commentId,
+      })}\n`,
+    )
+  }
+  return 0
+}
+
 /** One `gh api` call, keeping the HTTP status of a failure so a refused write can be told from a missing ref. */
 type ApiCall =
   | { readonly ok: true; readonly data: unknown }

package/src/commands/records.ts

@@ -55,7 +55,7 @@ import {
   outro,
   pipeOutput,
   plural,
-} from '@/ui'
+} from '@/cli/ui'
 import { currentWorktreeRoot, mainWorktreeRoot } from '@/git/worktree'
 
 /** Returned when a record carries a finding, which is the gating result. */

package/src/commands/repo.ts

@@ -17,7 +17,7 @@ import {
   logStep,
   logWarn,
   outro,
-} from '@/ui'
+} from '@/cli/ui'
 
 const GH_TIMEOUT_MS = 30_000
 

package/src/commands/sandbox.ts

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import type { Command } from 'commander'
-import { checkoutMismatchWarning, PROJECT_ROOT } from '@/project-root'
+import { checkoutMismatchWarning, PROJECT_ROOT } from '@/roots/project'
 import {
   assertedPercent,
   collectCensus,
@@ -27,6 +27,7 @@ import {
 } from '@/sandbox/expect'
 import { runHeadless } from '@/sandbox/headless/run'
 import { runSandbox } from '@/sandbox/provision'
+import { listCategories, listScenarioFiles } from '@/sandbox/scenario'
 import { sandboxTree } from '@/sandbox/tree'
 import {
   frameError,
@@ -39,7 +40,7 @@ import {
   outro,
   palette,
   select,
-} from '@/ui'
+} from '@/cli/ui'
 
 const SANDBOX_DIR = join(PROJECT_ROOT, 'sandbox')
 
@@ -71,9 +72,6 @@ function reportAbsentScenarioTree(): boolean {
   return true
 }
 
-/** Holds fixture content for scenarios rather than scenarios of its own. */
-const FIXTURES_DIR = 'fixtures'
-
 /**
  * The provision verb takes positional words rather than options, since `reset`
  * and `clean` share its slot with a target, so its usage is written out here
@@ -125,17 +123,16 @@ interface CoverageOptions {
 }
 
 function getCategories(): string[] {
-  return readdirSync(SANDBOX_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && d.name !== FIXTURES_DIR)
-    .map((d) => d.name)
-    .sort()
+  return listCategories(SANDBOX_DIR)
 }
 
+/** Lists a stem in both forms too, so picking it reaches the refusal that names it. */
 function getCommands(category: string): string[] {
-  return readdirSync(join(SANDBOX_DIR, category), { withFileTypes: true })
-    .filter((f) => f.isFile() && f.name.endsWith('.sh'))
-    .map((f) => f.name.replace(/\.sh$/, ''))
-    .sort()
+  const { scenarios, ambiguous } = listScenarioFiles(
+    join(SANDBOX_DIR, category),
+  )
+
+  return [...scenarios.map((s) => s.command), ...ambiguous].sort()
 }
 
 async function interactivePicker(): Promise<string> {

package/src/commands/secrets.ts

@@ -1,7 +1,15 @@
 import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { type ScanRefusal, scanShippedTree } from '@/secrets/scan'
-import { intro, logError, logInfo, logStep, logWarn, outro, plural } from '@/ui'
+import {
+  intro,
+  logError,
+  logInfo,
+  logStep,
+  logWarn,
+  outro,
+  plural,
+} from '@/cli/ui'
 
 interface ScanCommandOptions {
   readonly json?: boolean

package/src/commands/sessions.ts

@@ -23,7 +23,7 @@ import {
   outro,
   pipeOutput,
   plural,
-} from '@/ui'
+} from '@/cli/ui'
 import { mainWorktreeRoot } from '@/git/worktree'
 
 interface ListCommandOptions {

package/src/commands/slides.ts

@@ -1,10 +1,10 @@
 import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { INSTALL_BROWSER } from '@/browser/engine'
-import { creationRel, SCRATCH } from '@/record-root'
+import { creationRel, SCRATCH } from '@/roots/record'
 import { listDecks, resolveDeck, SLIDES_FOLDER } from '@/slides/decks'
 import { openDeck } from '@/slides/open'
-import { intro, outro, palette } from '@/ui'
+import { intro, outro, palette } from '@/cli/ui'
 
 const SLIDES_AT = creationRel(process.cwd(), SLIDES_FOLDER)
 

package/src/commands/standards.ts

@@ -17,7 +17,7 @@ import {
   outro,
   pipeOutput,
   plural,
-} from '@/ui'
+} from '@/cli/ui'
 
 interface StandardsListOptions {
   readonly json?: boolean

package/src/commands/sync.ts

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import type { Command } from 'commander'
-import { cliPath, cliRun } from '@/cli-run'
-import { PROJECT_ROOT } from '@/project-root'
+import { cliPath, cliRun } from '@/cli/run'
+import { PROJECT_ROOT } from '@/roots/project'
 import {
   buildCheckReport,
   type CheckReport,
@@ -30,7 +30,7 @@ import {
   logWarn,
   outro,
   palette,
-} from '@/ui'
+} from '@/cli/ui'
 import { describeSkew } from '@/version/skew'
 
 const SYNC_ARGS: Record<SyncDomain, readonly string[]> = {

package/src/commands/targets.ts

@@ -17,7 +17,7 @@ import {
   outro,
   pipeOutput,
   plural,
-} from '@/ui'
+} from '@/cli/ui'
 
 interface ListOptions {
   readonly json?: boolean

package/src/commands/tasks.ts

@@ -42,6 +42,7 @@ import {
 import {
   type Finding,
   type FolderClaim,
+  type SharedFiles,
   type WideToken,
   type Unplaced,
   type Untested,
@@ -58,7 +59,7 @@ import {
   logWarn,
   outro,
   pipeOutput,
-} from '@/ui'
+} from '@/cli/ui'
 import { mainWorktreeRoot } from '@/git/worktree'
 
 /** Returned when the board carries a finding, which is the gating result. */
@@ -239,7 +240,8 @@ export function register(program: Command): void {
         '  no Needs a plan row has a live plan, and every Up next row has one',
         '  every task file carries a board row or a backlog line, never both',
         '  no task carries more than one row',
-        '  no two Run now rows touch the same file',
+        '  every Run now row names the files it touches',
+        '  a file two Run now rows share is listed, never failed',
         '',
         'Exit codes:',
         '  0  every check passed',
@@ -1383,7 +1385,7 @@ function reportValidation(
     logStep(outcome.findings.length === 0 ? 'Clean' : 'Findings')
     if (outcome.findings.length === 0) {
       logInfo(
-        'every row resolves, every task sits on one surface, and each touches its own files',
+        'every row resolves, every task sits on one surface, and each run now row names its files',
       )
     } else {
       for (const finding of outcome.findings) logWarn(describe(finding))
@@ -1412,6 +1414,16 @@ function reportValidation(
       for (const claim of outcome.claims) logWarn(describeClaim(claim))
     }
 
+    // A shared file holds nothing under the dispatch gate, so the pairs report
+    // with the warn glyph and move no exit code. They stay listed for merge
+    // order and for the holds a Touches cell cannot state.
+    logStep('Shared files')
+    if (outcome.shared.length === 0) {
+      logInfo('no two run now rows name the same file')
+    } else {
+      for (const pair of outcome.shared) logWarn(describeShared(pair))
+    }
+
     // The width limit is a heuristic over one preview pane, so a wide token
     // reports and moves no exit code, and a measure failing on a cell that
     // fits would teach a reader to skip it.
@@ -1447,6 +1459,7 @@ function reportValidation(
         findings: outcome.findings,
         untested: outcome.untested,
         claims: outcome.claims,
+        shared: outcome.shared,
         wide: outcome.wide,
         unplaced: outcome.unplaced,
       })}\n`,
@@ -1469,6 +1482,10 @@ function describeClaim(claim: FolderClaim): string {
   return `${claim.group}: ${claim.subject} ${claim.message}`
 }
 
+function describeShared(pair: SharedFiles): string {
+  return `${pair.group}: ${pair.subject} ${pair.message}`
+}
+
 function describeWide(token: WideToken): string {
   return `${token.group}: ${token.subject} ${token.message}`
 }

package/src/commands/teach.ts

@@ -42,7 +42,7 @@ import {
   logWarn,
   outro,
   pipeOutput,
-} from '@/ui'
+} from '@/cli/ui'
 import { mainWorktreeRoot } from '@/git/worktree'
 
 /**