@erclx/canon 5.54.0 → 5.56.0

package/src/commands/transcripts.ts

@@ -2,7 +2,7 @@ import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { recordDir } from '@/roots/record'
 import { ensureYtDlp, fetchOne } from '@/transcripts/fetch'
-import { palette } from '@/cli/ui'
+import { intro, logError, logInfo, outro } from '@/cli/ui'
 import { mainWorktreeRoot } from '@/git/worktree'
 
 interface TranscriptOptions {
@@ -37,10 +37,7 @@ export function register(program: Command): void {
     )
     .action(async (url: string, opts: TranscriptOptions) => {
       const outDir = await resolveOutDir(opts)
-      const { GREEN, GREY, NC, RED, WHITE } = palette(process.stderr)
-      process.stderr.write(
-        `${GREY}┌${NC}\n${GREY}│${NC} ${WHITE}canon transcripts${NC}\n`,
-      )
+      intro('canon transcripts')
       try {
         ensureYtDlp()
         const target = await fetchOne(url, {
@@ -48,14 +45,12 @@ export function register(program: Command): void {
           keepTimestamps: opts.keepTimestamps ?? false,
         })
         process.stdout.write(`${target}\n`)
-        process.stderr.write(
-          `${GREY}│${NC} ${GREEN}✓${NC} ${target}\n${GREY}└${NC}\n`,
-        )
+        logInfo(target)
+        outro()
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
-        process.stderr.write(
-          `${GREY}│${NC} ${RED}✗${NC} ${message}\n${GREY}└${NC}\n`,
-        )
+        logError(message)
+        outro()
         process.exitCode = 1
       }
     })

package/src/gate/sequencer.ts

@@ -525,7 +525,7 @@ async function spawn(
     cwd,
     reject: false,
     all: true,
-    env: { ...gitEnv(), CANON_NON_INTERACTIVE: '1', ...env },
+    env: { ...gitEnv(), ...env },
     extendEnv: false,
   })
 

package/src/gate/stages.ts

@@ -119,12 +119,6 @@ const TESTS_SCOPE = new RegExp(
   ].join('|'),
 )
 
-const script = (name: string, failure: string): Check => ({
-  kind: 'command',
-  argv: ['bash', `scripts/core/${name}`],
-  failure,
-})
-
 /**
  * Every stage the gate runs, in the order it runs them.
  *
@@ -530,10 +524,6 @@ export const STAGES: readonly Stage[] = [
         argv: ['bun', 'run', 'check:shell'],
         failure: 'Shell check failed',
       },
-      script(
-        'check-color-source.sh',
-        'A color escape is defined outside scripts/lib/ui.sh.',
-      ),
     ],
     success: 'Shell check passed',
   },

package/src/hooks/post-merge.ts

@@ -359,11 +359,8 @@ export async function runPostMerge(input: PostMergeInput): Promise<void> {
   }
 
   if (!isSkipped('CANON_SKIP_UPGRADE')) {
-    await step(
-      input,
-      at([...STEP_VERBS.upgrade, '--json'], { CANON_NON_INTERACTIVE: '1' }),
-      (result, fields) =>
-        moveLines(result, fields, '⬆️  ', 'CLI not upgraded', []),
+    await step(input, at([...STEP_VERBS.upgrade, '--json']), (result, fields) =>
+      moveLines(result, fields, '⬆️  ', 'CLI not upgraded', []),
     )
   }
 

package/src/labels/density.ts

@@ -1,10 +1,6 @@
-import {
-  type DensityFinding,
-  type DensityKind,
-  densityFindings,
-} from '@/markdown/density'
-import { type BodyLine, bodyLines, visibleText } from '@/markdown/scan'
-import { CHECKPOINTS, LIST_ITEM } from '@/markdown/structure'
+import { type DensityKind, densityFindings } from '@/markdown/density'
+import { type BodyLine, bodyLines } from '@/markdown/scan'
+import { LIST_ITEM } from '@/markdown/structure'
 
 /**
  * The four counted limits a pull request section carries. The heading limits
@@ -119,7 +115,6 @@ export interface PostDensityFinding extends Omit<BodyDensityFinding, 'kind'> {
 }
 
 const LENGTHS: readonly DensityKind[] = ['paragraph-length', 'bullet-length']
-const NESTED_ITEM = /^(\s+)(?:[-*+]|\d+\.)\s+(.*)$/
 const CHECKBOX = /^\s*[-*+]\s+\[[ xX]\]/
 const FOOTER = /^🤖/
 
@@ -134,8 +129,8 @@ const FOOTER = /^🤖/
  * 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.
+ * A nested item is measured as a bullet of its own by `densityFindings()`, which
+ * leaves it 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) =>
@@ -153,7 +148,6 @@ export function postDensity(body: string): PostDensityFinding[] {
         (chunk) => densityFindings(chunk),
       ),
       ...densityFindings(inside).filter(({ kind }) => LENGTHS.includes(kind)),
-      ...nestedLengths(section.lines),
     ]
 
     for (const finding of measured) {
@@ -214,41 +208,6 @@ function foldedApart(lines: readonly BodyLine[]): {
   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[] } = {

package/src/markdown/density.ts

@@ -22,6 +22,8 @@ export type DensityKind =
   | 'bullet-run'
   | 'heading-depth'
   | 'h3-opening'
+  | 'table-cell'
+  | 'table-then-list'
 
 export interface DensityFinding {
   readonly kind: DensityKind
@@ -52,14 +54,16 @@ type Block =
  * here it belongs to the item: it counts toward the bullet's length and never
  * toward a paragraph run, since a reader sees it inside the list.
  *
- * A nested item is left out of its parent, as `heavyBullets` leaves it, and so
- * is everything indented under the nested item. An indented fence inside an
- * item stays with the item, and a column-zero one ends it.
+ * A nested item is a block of its own, taking the lines indented past its
+ * marker, and its parent leaves it out along with everything indented under it.
+ * An indented fence inside an item joins neither and ends the nested item, and
+ * a column-zero one ends both.
  */
 function blocksOf(lines: readonly BodyLine[]): Block[] {
   const blocks: Block[] = []
   let paragraph: { line: number; parts: string[] } | undefined
   let item: { line: number; parts: string[]; nested: boolean } | undefined
+  let child: { line: number; parts: string[]; indent: number } | undefined
   let inFence = false
   let afterBlank = false
 
@@ -74,7 +78,19 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
     paragraph = undefined
   }
 
+  const closeChild = (): void => {
+    if (child) {
+      blocks.push({
+        kind: 'item',
+        line: child.line,
+        text: child.parts.join(' '),
+      })
+    }
+    child = undefined
+  }
+
   const closeItem = (): void => {
+    closeChild()
     if (item) {
       blocks.push({ kind: 'item', line: item.line, text: item.parts.join(' ') })
     }
@@ -95,7 +111,8 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
       // The opening delimiter decides who owns the block. `bodyLines` marks a
       // delimiter and the body alike, so the opener is the first fenced line.
       if (!inFence) {
-        if (!(item && indented)) {
+        if (item && indented) closeChild()
+        else {
           closeAll()
           blocks.push({ kind: 'other', line: line.number, table: false })
         }
@@ -108,13 +125,27 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
 
     if (text === '') {
       closeParagraph()
+      closeChild()
       afterBlank = true
       continue
     }
 
     if (indented && item) {
-      if (LIST_ITEM.test(raw)) item.nested = true
-      else if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      const lead = leadOf(raw)
+      if (LIST_ITEM.test(raw)) {
+        closeChild()
+        item.nested = true
+        child = {
+          line: line.number,
+          parts: [text.replace(LIST_ITEM, '')],
+          indent: lead,
+        }
+      } else if (child && lead > child.indent) {
+        if (!TABLE_ROW.test(raw)) child.parts.push(text)
+      } else {
+        closeChild()
+        if (!item.nested && !TABLE_ROW.test(raw)) item.parts.push(text)
+      }
       afterBlank = false
       continue
     }
@@ -163,6 +194,10 @@ function blocksOf(lines: readonly BodyLine[]): Block[] {
   return blocks
 }
 
+function leadOf(raw: string): number {
+  return raw.length - raw.trimStart().length
+}
+
 /**
  * Every breach of the six density limits, in line order.
  *

package/src/markdown/scope.ts

@@ -4,6 +4,7 @@ import {
   densityFindings,
 } from '@/markdown/density'
 import type { BodyLine } from '@/markdown/scan'
+import { tableDensityFindings } from '@/markdown/tables'
 
 /** The surfaces the retired bullet-stacks stage held, per `ALWAYS_GATED`. */
 const BULLET_RUN_SCOPE = [
@@ -68,12 +69,16 @@ function keyPathsSection(lines: readonly BodyLine[]): readonly BodyLine[] {
  * The density findings a path takes, being every finding on a density-scope
  * file and the Key paths findings on a `CLAUDE.md`. The audit, the init probe,
  * and `canon claude sync` all read this, so the three agree on what counts.
+ * The table cell and trailing-list findings join on a density-scope path only,
+ * since `densityFindings` stays what its direct callers grade.
  */
 export function scopedDensityFindings(
   rel: string,
   lines: readonly BodyLine[],
 ): DensityFinding[] {
-  if (inDensityScope(rel)) return densityFindings(lines)
+  if (inDensityScope(rel)) {
+    return [...densityFindings(lines), ...tableDensityFindings(lines)]
+  }
   if (!KEY_PATHS_SCOPE.test(rel)) return []
   return densityFindings(keyPathsSection(lines)).filter((finding) =>
     KEY_PATHS_KINDS.includes(finding.kind),

package/src/markdown/structure.ts

@@ -415,10 +415,10 @@ export function longestRun(
 }
 
 /**
- * Finds the top-level bullets carrying more than a decision.
+ * Finds the bullets carrying more than a decision, nested ones included.
  *
- * A nested item is left out rather than folded into its parent, since the
- * checkpoint asks what one bullet carries and a child carries its own. Lines
+ * A nested item is measured on its own and never folded into its parent, since
+ * the checkpoint asks what one bullet carries and a child carries its own. Lines
  * continuing a bullet do fold in, so a heavy bullet cannot fall under the
  * checkpoint by being wrapped across two source lines. A fenced line closes the
  * open bullet, which keeps a bullet from absorbing the example below it.
@@ -436,6 +436,8 @@ export function heavyBullets(
 interface FoldedBullet extends BulletFinding {
   /** The bullet's source lines joined by the space a wrap would have carried. */
   readonly text: string
+  /** The width of the indent before the marker, which a continuation must pass. */
+  readonly indent: number
 }
 
 /** The walk `heavyBullets` reports from. */
@@ -459,18 +461,18 @@ function foldBullets(
 
     const item = line.text.match(LIST_ITEM)
     const text = line.text.trim()
+    const lead = line.text.length - line.text.trimStart().length
 
     // Structure is read off the raw line and only the weight is masked. A line
     // carrying nothing but an autolink has no visible text at all, and reading
     // its masked form as blank would close the bullet it continues.
     if (item) {
       close()
-      if (item[1].length === 0) {
-        open = {
-          line: line.number,
-          characters: visibleText(text).length,
-          text,
-        }
+      open = {
+        line: line.number,
+        characters: visibleText(text).length,
+        text,
+        indent: item[1].length,
       }
       continue
     }
@@ -480,6 +482,13 @@ function foldBullets(
       continue
     }
 
+    // An indented line that does not pass the marker's indent belongs to a
+    // parent or to nothing, so it ends a nested item rather than extending it.
+    if (open && lead > 0 && lead <= open.indent) {
+      close()
+      continue
+    }
+
     // The joining space a wrapped line would have carried, so folding two
     // source lines measures what one unwrapped line would have.
     if (open)

package/src/markdown/tables.ts

@@ -1,3 +1,4 @@
+import type { DensityFinding } from '@/markdown/density'
 import { type BodyLine, visibleText } from '@/markdown/scan'
 import { LIST_ITEM, TABLE_ROW, TABLE_SEPARATOR } from '@/markdown/structure'
 
@@ -10,19 +11,14 @@ export const TABLE_ROWS = 8
 /** The longest unbroken run a code span in a table cell may carry. */
 export const TABLE_TOKEN = 30
 
-export type TableKind =
-  | 'table-cell'
-  | 'table-rows'
-  | 'table-then-list'
-  | 'table-token'
+export type TableKind = 'table-rows' | 'table-token'
 
 export interface TableFinding {
   readonly kind: TableKind
-  /** The row holding the cell or span, the header for a row count, or the list's first item. */
+  /** The span's row, or the header for a row count. */
   readonly line: number
-  /** What was measured, or null for a trailing list, which is a shape rather than a count. */
-  readonly value: number | null
-  readonly limit: number | null
+  readonly value: number
+  readonly limit: number
 }
 
 /**
@@ -55,16 +51,22 @@ function cellsOf(row: string): string[] {
 }
 
 /**
- * Every breach of the four table limits, in line order.
+ * Every breach of the four table limits, in line order, split by whether it
+ * gates.
  *
  * A table is a run of pipe rows whose second row is a delimiter, the shape a
  * renderer draws. Pipe lines with no delimiter render as paragraph text, and a
  * fenced line is an example, so neither is measured. The limits are a
  * 120-character cell, 8 body rows, a list as the next block, and a code span
- * holding a run past 30 characters. Every finding reports and none gates.
+ * holding a run past 30 characters. The cell and the trailing list are density
+ * findings, and the row count and the wide token report and never gate.
  */
-export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
-  const found: TableFinding[] = []
+function measureTables(lines: readonly BodyLine[]): {
+  reported: TableFinding[]
+  density: DensityFinding[]
+} {
+  const reported: TableFinding[] = []
+  const density: DensityFinding[] = []
   let index = 0
 
   while (index < lines.length) {
@@ -96,7 +98,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       for (const cell of cellsOf(row.text)) {
         const length = visibleText(cell).length
         if (length > TABLE_CELL) {
-          found.push({
+          density.push({
             kind: 'table-cell',
             line: row.number,
             value: length,
@@ -106,7 +108,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
         for (const span of codeSpans(cell)) {
           const run = unbrokenRun(span)
           if (run > TABLE_TOKEN) {
-            found.push({
+            reported.push({
               kind: 'table-token',
               line: row.number,
               value: run,
@@ -119,7 +121,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
 
     const bodyRows = tableRows.length - 1
     if (bodyRows > TABLE_ROWS) {
-      found.push({
+      reported.push({
         kind: 'table-rows',
         line: header.number,
         value: bodyRows,
@@ -135,7 +137,7 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
       !following.fenced &&
       LIST_ITEM.test(following.text)
     ) {
-      found.push({
+      density.push({
         kind: 'table-then-list',
         line: following.number,
         value: null,
@@ -146,5 +148,17 @@ export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
     index = end
   }
 
-  return found.sort((a, b) => a.line - b.line)
+  return { reported, density }
+}
+
+/** The row count and wide token findings, which report and never gate. */
+export function tableFindings(lines: readonly BodyLine[]): TableFinding[] {
+  return measureTables(lines).reported.sort((a, b) => a.line - b.line)
+}
+
+/** The cell and trailing-list findings, which gate as density kinds do. */
+export function tableDensityFindings(
+  lines: readonly BodyLine[],
+): DensityFinding[] {
+  return measureTables(lines).density.sort((a, b) => a.line - b.line)
 }

package/src/process/harness.ts

@@ -9,6 +9,13 @@ const CLI = join(PROJECT_ROOT, 'src/cli.ts')
 /** No case has ever needed longer, and a blocked verb should fail fast. */
 const DEFAULT_TIMEOUT_MS = 10_000
 
+/**
+ * A spawn that reaches `bun add` fails at once against this unreachable
+ * address, so an unseeded install is a loud defect rather than a test that
+ * passes or fails with the network. `options.env` still wins.
+ */
+const DEAD_REGISTRY = 'http://127.0.0.1:9'
+
 export interface ProcessRun {
   readonly status: number | null
   readonly stdout: string
@@ -90,8 +97,7 @@ export function snapshotStateDir(): string {
  *
  * A git hook exports `GIT_DIR`, which would resolve a fixture's git-aware
  * reads against this checkout instead of the temporary directory a case
- * builds, so every spawn drops the `GIT_` prefix before adding the headless
- * flag every case needs to avoid a picker blocking on stdin.
+ * builds, so every spawn drops the `GIT_` prefix.
  *
  * `CANON_STATE_DIR` and `CANON_SANDBOX_DIR` get the same treatment as `GIT_DIR`,
  * each pointed at a folder under the case's own `cwd` rather than dropped,
@@ -99,7 +105,8 @@ export function snapshotStateDir(): string {
  * `HOME` to this machine's real `~/.local/state/canon`. `stateDir()` and
  * `sandboxTree()` resolve the same three ways and share that parent, so both
  * overrides move together. A case explicitly passing its own value through
- * `options.env` still wins, matching `CANON_NON_INTERACTIVE` below.
+ * `options.env` still wins. The child's stdin is a pipe rather than a
+ * terminal, so every case runs headless.
  *
  * The `stateDir()` snapshot before and after the spawn is what actually
  * catches an escape past that redirection, since a default can be wrong in a
@@ -125,9 +132,9 @@ export function runCli(
     timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     env: {
       ...inherited,
-      CANON_NON_INTERACTIVE: '1',
       CANON_STATE_DIR: join(options.cwd, '.canon-state'),
       CANON_SANDBOX_DIR: join(options.cwd, '.canon-state', 'sandbox'),
+      BUN_CONFIG_REGISTRY: DEAD_REGISTRY,
       ...options.env,
     },
   })

package/src/process/seeded-package.ts

@@ -0,0 +1,21 @@
+import { existsSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { PROJECT_ROOT } from '@/roots/project'
+import { resolveChain } from '@/tooling/manifest'
+import { collectDeps, parseSpec } from '@/tooling/package'
+
+// A write run into a folder with no package.json would run `bun add -D` against
+// the registry. A package.json already naming the stack's packages leaves
+// nothing to install, so a test not about the manifest stays offline.
+export const seedPackage = (dir: string, stack: string): void => {
+  const path = join(dir, 'package.json')
+  if (existsSync(path)) return
+
+  const devDependencies = Object.fromEntries(
+    collectDeps(resolveChain(PROJECT_ROOT, stack), {}).map((dep) => [
+      dep.name,
+      parseSpec(dep.spec).pin || '*',
+    ]),
+  )
+  writeFileSync(path, JSON.stringify({ devDependencies }))
+}

package/src/sandbox/equivalence.ts

@@ -517,7 +517,6 @@ function provisionEnv(
 ): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = {
     ...process.env,
-    CANON_NON_INTERACTIVE: '1',
     CANON_SANDBOX_DIR: dir,
     CANON_SANDBOX_RUN_ID: PINNED_RUN_ID,
     CLAUDE_CONFIG_DIR: configDirFor(dir),

package/src/sandbox/provision.ts

@@ -27,7 +27,7 @@ import {
   logStep,
   logWarn,
   outro,
-  palette,
+  outroSuccess,
   select,
 } from '@/cli/ui'
 
@@ -99,9 +99,7 @@ function readGit(cwd: string, args: string[]): string | undefined {
 }
 
 function finish(message: string): void {
-  const { GREEN, NC } = palette(process.stderr)
-  outro()
-  process.stderr.write(`\n${GREEN}${message}${NC}\n`)
+  outroSuccess(message)
 }
 
 function stageAnchorTree(
@@ -210,7 +208,7 @@ function install(
   env: NodeJS.ProcessEnv,
 ): void {
   const result = spawnSync('bun', [join(root, 'src', 'cli.ts'), ...args], {
-    env: { ...env, CANON_NON_INTERACTIVE: '1' },
+    env,
     encoding: 'utf8',
     stdio: ['ignore', 'ignore', 'pipe'],
   })
@@ -432,10 +430,7 @@ async function provisionScenario(
   baseEnv: NodeJS.ProcessEnv,
 ): Promise<void> {
   const env: NodeJS.ProcessEnv = { ...baseEnv }
-  if (scenario.arm !== undefined) {
-    env.SANDBOX_SCENARIO = scenario.arm
-    env.CANON_NON_INTERACTIVE = '1'
-  }
+  if (scenario.arm !== undefined) env.SANDBOX_SCENARIO = scenario.arm
 
   const sandboxDir = join(root, 'sandbox')
   const declared = declareScenario(root, scenario, env)
@@ -475,14 +470,14 @@ async function provisionScenario(
   must(commitScenarioChanges(sandbox, isSkipAutoCommit, env))
   tagBaseline(sandbox, env)
 
-  finish('✓ Sandbox Ready')
+  finish('Sandbox Ready')
 }
 
 function cleanSandbox(sandbox: string): void {
   logStep('Removing sandbox')
   rmSync(sandbox, { recursive: true, force: true })
   logRemove(sandbox)
-  finish('✓ Sandbox clean')
+  finish('Sandbox clean')
 }
 
 function isAtBaseline(sandbox: string): boolean {
@@ -520,7 +515,7 @@ async function resetSandbox(sandbox: string): Promise<void> {
 
   if (isAtBaseline(sandbox)) {
     logInfo('At baseline')
-    finish('✓ Sandbox at baseline')
+    finish('Sandbox at baseline')
     return
   }
 
@@ -556,7 +551,7 @@ async function resetSandbox(sandbox: string): Promise<void> {
     must(run('git', ['checkout-index', '-a', '-f'], quiet))
   }
   logInfo('Sandbox reset to baseline')
-  finish('✓ Sandbox reset complete')
+  finish('Sandbox reset complete')
 }
 
 /**

package/src/sandbox/scenario.ts

@@ -13,6 +13,7 @@ import {
 import { createRequire } from 'node:module'
 import { dirname, join, relative } from 'node:path'
 import {
+  isNonInteractive,
   logError,
   logInfo,
   logStep,
@@ -580,8 +581,9 @@ export function createStageContext(options: ContextOptions): StageContext {
 }
 
 /**
- * Picks the arm: a routed name first,
- * echoed on the frame, then the first arm for a headless caller, then a prompt.
+ * Picks the arm: a routed name first, echoed on the frame, then a prompt. A
+ * headless caller naming no arm is refused rather than handed the first one,
+ * since a verdict on an arm nobody chose reads as a verdict on the scenario.
  */
 async function routeArm(
   names: readonly string[],
@@ -600,17 +602,9 @@ async function routeArm(
   const routed = env.SANDBOX_SCENARIO ?? ''
   if (routed !== '') return echo(routed)
 
-  // Read off the scenario's environment rather than this process's, as
-  // `is_non_interactive` read the shell it ran in.
-  const isHeadless =
-    env.CANON_NON_INTERACTIVE === '1' ||
-    // canon-keep-retired
-    env.AITK_NON_INTERACTIVE === '1'
-  if (isHeadless) return echo(names[0] ?? DEFAULT_ARM_NAME)
-
-  if (!process.stdin.isTTY) {
+  if (isNonInteractive()) {
     logError(
-      `${prompt} requires a TTY. Pass an argument or set CANON_NON_INTERACTIVE=1.`,
+      `${prompt} requires a TTY. Pass the arm as the scenario argument, one of: ${names.join(', ')}.`,
     )
     throw new ScenarioStop(1, 'exited')
   }