@erclx/canon 5.68.0 → 5.70.0

package/src/commands/gov.ts

@@ -34,6 +34,7 @@ import {
 } from '@/gov/restated'
 import {
   auditExit,
+  CORE_FOLDERS,
   hasFinding,
   PRACTICE_FOLDERS,
   readRuleAudit,
@@ -62,6 +63,11 @@ import {
   readTestOrder,
   type TestOrderReport,
 } from '@/gov/test-order'
+import {
+  type ChangedSet,
+  collectChangedFiles,
+  commandRunner,
+} from '@/gate/sequencer'
 import { recordStamp, runDomainSync } from '@/sync/engine'
 import { detectRules } from '@/gov/detect'
 import { writeChainStamp } from '@/sync/stamp'
@@ -138,6 +144,7 @@ interface AuditOptions {
   readonly root?: string
   readonly json?: boolean
   readonly gate?: boolean
+  readonly touched?: boolean
 }
 
 /** What a reader does about each way the sweep produced no reading. */
@@ -613,6 +620,10 @@ export function register(program: Command): void {
       '--gate',
       'Set 2 only for a finding in a gated folder, which the push stage reads',
     )
+    .option(
+      '--touched',
+      'Owe a ledger for each core rule the branch changed against origin/main',
+    )
     .addHelpText(
       'after',
       [
@@ -632,6 +643,9 @@ export function register(program: Command): void {
         `  asks a ledger of each rule under ${PRACTICE_FOLDERS.join(', ')}`,
         '  at governance/ledger/<folder>/<slug>.md, one table row per bullet',
         '  under a heading of the same name.',
+        `  A rule under ${CORE_FOLDERS.join(', ')} has its ledger checked where`,
+        '  one exists, and under --touched owes one once the branch changed it.',
+        '  With no baseline against main, --touched reads no rule as touched.',
         '  Any other tree reads .claude/rules/project/ alone and asks no ledger.',
         '  .claude/rules/canon/ is fixed at the toolkit source and never read',
         '  unless named. A named path resolves against --root and must sit',
@@ -654,6 +668,7 @@ export function register(program: Command): void {
         '  canon gov audit',
         '  canon gov audit .claude/rules/project/api.md',
         '  canon gov audit --json',
+        '  canon gov audit --gate --touched',
         '',
       ].join('\n'),
     )
@@ -672,7 +687,13 @@ async function runAudit(
   opts: AuditOptions,
 ): Promise<number> {
   const root = resolve(opts.root ?? process.cwd())
-  const report = await readRuleAudit(root, paths)
+  const changed = opts.touched
+    ? await collectChangedFiles(commandRunner(root))
+    : undefined
+  // An unscoped set lists nothing, and reading it as every file would owe a
+  // ledger of every core rule on a branch that touched none of them.
+  const touched = changed?.scoped ? changed.files : []
+  const report = await readRuleAudit(root, paths, { touched })
   const emitJson = opts.json ?? false
 
   if (report.kind === 'unreadable') {
@@ -690,7 +711,7 @@ async function runAudit(
     return 1
   }
 
-  reportAudit(report, root, paths.length > 0)
+  reportAudit(report, root, paths.length > 0, changed)
 
   if (emitJson) {
     process.stdout.write(
@@ -700,6 +721,9 @@ async function runAudit(
         limits: RULE_LIMITS,
         gated: RULE_GATED_FOLDERS,
         exempt: RULE_GATE_EXEMPT,
+        ...(changed === undefined
+          ? {}
+          : { touched: { scoped: changed.scoped } }),
         ...report,
       })}\n`,
     )
@@ -728,6 +752,7 @@ function reportAudit(
   report: Extract<RuleAuditReport, { kind: 'measured' }>,
   root: string,
   named: boolean,
+  changed: ChangedSet | undefined,
 ): void {
   intro('canon gov audit')
 
@@ -761,10 +786,15 @@ function reportAudit(
   }
 
   logStep('Ledgers')
+  if (changed !== undefined && !changed.scoped) {
+    logInfo(
+      'no baseline against main, so --touched reads no core rule as touched',
+    )
+  }
   if (report.scope === 'target') {
     logInfo('not read, since ledgers live in the toolkit and never ship')
   } else if (ledgers.length === 0) {
-    logInfo('every outside-practice rule has a ledger row per bullet')
+    logInfo('every rule owing a ledger has one, with a row per bullet')
   } else {
     for (const line of ledgers) logWarn(line)
   }

package/src/commands/migrate.ts

@@ -1309,6 +1309,13 @@ export function register(program: Command): void {
         'any ordinal evidence/ already carries. The dry run labels every',
         'derived destination, so check the split before passing --write.',
         '',
+        'Moves the design board to the folder Frameboard names:',
+        '  canvas/                         -> board/',
+        '',
+        'Stop a frameboard serve on canvas/ before --write. A project holding',
+        'both folders gets a collision, and a design.toml board key naming',
+        '.canon/canvas is left for you to update.',
+        '',
         'A citation reaching into a moved folder or naming a moved file is',
         'repointed, live or archived. A bare mention of an emptied folder, such',
         'as review/evidence/ with no slug, matches no row and stays as written.',
@@ -1389,8 +1396,11 @@ export function register(program: Command): void {
         `It also carries ${Object.keys(SKILL_CITATION_MAP).length} namespaced-only rows for a skill renamed from a single word.`,
         'The seven draft- skills move onto verb-first names, such as',
         // The old spellings below are the rename itself. canon-keep-retired
-        'draft-doc to write-doc and draft-and-pick to pick-by-eye, and a',
-        'pointer left under each old name is never moved.',
+        'draft-doc to write-doc and draft-slides to make-deck, and a',
+        'pointer left under each old name is never moved. Four skills then',
+        'moved into the family their job belongs to, such as',
+        // canon-keep-retired
+        'ux-audit to ui-audit and pick-by-eye to design-pick.',
         'It takes no scope. The skill folders it moves are authored in the',
         'toolkit and no target holds a copy of that catalog, so in a target it',
         'rewrites citations of a renamed skill and moves nothing.',

package/src/commands/records.ts

@@ -110,8 +110,9 @@ export function register(program: Command): void {
         '',
         'Structure, under `structure` and never in the exit:',
         "  S1 to S5 from the plan standard, read on plans, a track's README and",
-        '  numbered files, and intake clusters, plus intake-spill for content under',
-        '  a field. A record written before the criteria misses S1, so it reports alone.',
+        "  numbered files, intake clusters, and an intake folder's",
+        '  evidence/drive-log.md, plus intake-spill for content under a field.',
+        '  A record written before the criteria misses S1, so it reports alone.',
         '',
         'Refusals, read off `reason`:',
         "  no-folder     none of the kind's directories exist at either record root",

package/src/commands/sandbox.ts

@@ -25,7 +25,7 @@ import {
   type RunEnvelope,
   type Verdict,
 } from '@/sandbox/expect'
-import { runHeadless } from '@/sandbox/headless/run'
+import { runHeadless, runSettings } from '@/sandbox/headless/run'
 import { runSandbox } from '@/sandbox/provision'
 import {
   EXPECTED_FILE,
@@ -120,7 +120,12 @@ function showProvisionHelp(): void {
 }
 
 /** A run that reported nothing counts as clean, so only real signals fail. */
-const CLEAN_ENVELOPE: RunEnvelope = { isError: false, turns: 0, denials: 0 }
+const CLEAN_ENVELOPE: RunEnvelope = {
+  isError: false,
+  isTruncated: false,
+  turns: 0,
+  denials: 0,
+}
 
 interface CheckOptions {
   readonly envelope?: string
@@ -190,6 +195,8 @@ function readEnvelope(path: string | undefined): RunEnvelope | undefined {
 
     return {
       isError: parsed.is_error === true,
+      isTruncated: parsed.subtype === 'error_max_turns',
+      turnCap: Number(runSettings(process.env).maxTurns),
       turns: typeof parsed.num_turns === 'number' ? parsed.num_turns : 0,
       denials: Array.isArray(denials) ? denials.length : 0,
       reply: typeof parsed.result === 'string' ? parsed.result : undefined,

package/src/commands/take.ts

@@ -1,7 +1,9 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import type { Command } from 'commander'
 import { INSTALL_BROWSER, isEngineMissing } from '@/browser/engine'
+import { cameraTrack, readRate } from '@/take/camera'
+import { readTakeLog } from '@/take/log'
 import { readTakePlan } from '@/take/plan'
 import type { TakePlanRefusal } from '@/take/plan'
 import type { TakeRefusal } from '@/take/film'
@@ -24,11 +26,17 @@ import {
 type Take = typeof import('@/take/film')
 
 interface RunOptions {
-  readonly out: string
+  readonly out?: string
   readonly reel?: string
   readonly json?: boolean
 }
 
+interface CameraOptions {
+  readonly out?: string
+  readonly rate?: string
+  readonly json?: boolean
+}
+
 const INSTALL_FFMPEG =
   'install FFmpeg from your package manager, such as apt install ffmpeg or brew install ffmpeg'
 
@@ -40,7 +48,8 @@ const PLAN_REFUSALS: Record<TakePlanRefusal, string> = {
   'bad-beat':
     'A beat is missing its name or carries a setup that is not a list.',
   'no-steps': 'A beat names no step, so its take would film nothing.',
-  'unknown-route': 'A beat names a route this build does not record on.',
+  'unknown-route':
+    'The plan or a beat names a route this build does not record on.',
   'bad-step': 'A step is missing something the take needs to perform it.',
 }
 
@@ -53,14 +62,19 @@ const TAKE_REFUSALS: Record<TakeRefusal, string> = {
 }
 
 export function register(program: Command): void {
-  program
+  const take = program
     .command('take')
     .description(
       'Film a web app beat by beat with a click log and camera track',
     )
     .argument('<url>', 'Address to film')
     .argument('<plan>', 'JSON file naming the beats and their steps')
-    .requiredOption('--out <dir>', 'Folder the clips, logs, and tracks land in')
+    // Checked in the action rather than required here, since commander checks
+    // a parent's required options on every subcommand, `camera` included.
+    .option('--out <dir>', 'Folder the clips, logs, and tracks land in')
+    // Keeps this command's options ahead of `camera`, which reuses --out and
+    // --json for its own.
+    .enablePositionalOptions()
     .helpOption('-h, --help', 'Show this help message')
     .option(
       '--reel <file>',
@@ -106,12 +120,33 @@ export function register(program: Command): void {
         'Step kinds:',
         '  move <target>|<x,y>    glide the pointer to a target or a point',
         '  click <target>         glide to the target and press it',
+        '  dblclick <target>      glide to the target and press it twice',
+        '  drag <from> <to>       press the from target, glide held, release on to',
+        '  key <keys>             press a combination such as Control+K',
         '  fill <target> <text>   press the target and type the text',
         '  scroll <target> <dy>   glide to the target and wheel dy pixels',
         '  wait <ms>              hold, for a state the page reaches on its own',
         '',
-        'A target is a CSS selector, or text=<words> for the innermost element',
-        'whose whole text is those words. Setup steps run before the first kept',
+        'click, dblclick, and drag take modifiers, a list of Alt, Control, Meta,',
+        'and Shift held through the press, as in "modifiers": ["Shift"]. keys',
+        'names those modifiers joined by + ahead of one character or a named key:',
+        'Enter, Tab, Escape, Backspace, Delete, Insert, Space, Home, End, PageUp,',
+        'PageDown, the four arrows as ArrowUp and the like, and F1 to F12. A key',
+        'moves no pointer, so the camera neither aims at it nor ends a zoom.',
+        '',
+        'drag drives pointer events, the kind a canvas board listens for. It',
+        'starts no native HTML5 drag of a draggable element on the stepped route,',
+        'so a beat needing one films the same only on the screencast route.',
+        '',
+        'A top-level route sets the route of every beat that names none of its',
+        'own. A beat carrying push: false keeps its camera on the whole page,',
+        'with the cursor and click ring still in the track, and its log.json',
+        'records push: false. Each log.json carries clip, the clip size in',
+        'pixels, which caps the zoom depth so a 1920-wide screencast stays sharp.',
+        '',
+        'A target is a CSS selector, or text=<words> for the first innermost',
+        'element with a size whose whole text is those words, so a hidden copy',
+        'earlier in the page is skipped. Setup steps run before the first kept',
         'frame. Every beat opens and closes on a 0.6 s hold.',
         '',
         'Needs a reachable page, FFmpeg, and the headless shell. Install with:',
@@ -123,7 +158,8 @@ export function register(program: Command): void {
         '  no-beats            the plan names no beat',
         '  bad-beat            a beat has no name or a setup that is not a list',
         '  no-steps            a beat names no step',
-        '  unknown-route       a beat names a route other than step or screencast',
+        '  unknown-route       the plan or a beat names a route other than step or',
+        '                      screencast',
         '  bad-step            a step is missing what the take needs to perform it',
         '  engine-missing      the browser engine is not installed in this project',
         '  ffmpeg-missing      FFmpeg is not on the PATH',
@@ -133,6 +169,13 @@ export function register(program: Command): void {
         '  take-failed         the take failed against a reachable page',
         '  reel-failed         every beat was filmed and the reel did not encode',
         '',
+        'A refusal in a beat carries beat. target-missing carries still when the',
+        "page answered a capture, the beat folder's still.jpg as the step met it. A",
+        'beat that fell back to the screencast before refusing carries fallback,',
+        'the reason it fell back. The screencast opens the address a second time,',
+        'so a single-use link is spent by then: check the access before the',
+        'selector.',
+        '',
         'Exit codes:',
         '  0  every beat was filmed, and the reel written when asked for',
         '  1  refused, with the reason on stderr or in the JSON record',
@@ -144,15 +187,113 @@ export function register(program: Command): void {
         '',
       ].join('\n'),
     )
-    .action(async (url: string, plan: string, opts: RunOptions) => {
-      process.exitCode = await runTake(url, plan, opts)
+    .action(
+      async (url: string, plan: string, opts: RunOptions, command: Command) => {
+        if (!opts.out)
+          command.error("error: required option '--out <dir>' not specified")
+        process.exitCode = await runTake(url, plan, { ...opts, out: opts.out })
+      },
+    )
+
+  take
+    .command('camera')
+    .description("Build a camera track from a take's log.json")
+    .argument('<log>', "A beat's log.json, as a take wrote it")
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--out <file>', 'Write the track to a file rather than stdout')
+    .option(
+      '--rate <n>',
+      'How many times faster the edit plays the clip, 1 by default',
+    )
+    .option('--json', 'Add a machine-readable record on stdout with --out')
+    .addHelpText(
+      'after',
+      [
+        '',
+        "Builds the same camera track a take writes beside each beat's clip, from",
+        'the log alone, so a track can be rebuilt for a clip the edit plays at',
+        'another speed. With no --out the track is the data on stdout, one line,',
+        'and a refusal under --json is the record there instead.',
+        '',
+        '--rate <n> builds the track on the playback clock of a clip sped up n',
+        'times, dividing every time in the log by n, so a zoom settles at the',
+        'speed a viewer sees rather than pumping several times a beat.',
+        '',
+        "The zoom depth is capped by the clip's resolution, read from the log's",
+        'clip field, or from its route on a log written before that field. A log',
+        'carrying push: false holds the whole page with the cursor and ring.',
+        '',
+        'Reasons:',
+        '  no-log-file     nothing readable at the log path',
+        "  unreadable-log  the file is not a take's log.json",
+        '  bad-rate        --rate is not a positive number',
+        '',
+        'Exit codes:',
+        '  0  the track was written',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '',
+        'Examples:',
+        "  canon take camera takes/01-open/log.json | jq '.frames | length'",
+        '  canon take camera takes/01-open/log.json --rate 2 --out camera-2x.json',
+        '',
+      ].join('\n'),
+    )
+    .action((log: string, opts: CameraOptions) => {
+      process.exitCode = runCamera(log, opts)
     })
 }
 
+function runCamera(logPath: string, opts: CameraOptions): number {
+  const emitJson = opts.json ?? false
+  const path = resolve(logPath)
+  const refuseCamera = (reason: string, message: string): number => {
+    logWarn(message)
+    emit(emitJson, { log: path, reason, message })
+    return 1
+  }
+
+  const rate = opts.rate === undefined ? 1 : readRate(opts.rate)
+  if (rate === undefined) {
+    return refuseCamera(
+      'bad-rate',
+      `--rate ${opts.rate} is not a positive number, such as 1.5 or 2.`,
+    )
+  }
+
+  let source: string
+  try {
+    source = readFileSync(path, 'utf8')
+  } catch (error) {
+    return refuseCamera(
+      'no-log-file',
+      `No log file at ${path}. ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+  const read = readTakeLog(source)
+  if (read.kind === 'refused') {
+    return refuseCamera(
+      'unreadable-log',
+      `${path} is not a take's log.json, being the file beside a beat's clip.mp4. ${read.detail}`,
+    )
+  }
+
+  const track = cameraTrack(read.log, { rate })
+  const line = `${JSON.stringify(track)}\n`
+  if (!opts.out) {
+    process.stdout.write(line)
+    return 0
+  }
+  const out = resolve(opts.out)
+  writeFileSync(out, line)
+  logInfo(`${out}  ${plural(track.frames.length, 'frame')}  rate ${rate}`)
+  emit(emitJson, { log: path, out, frames: track.frames.length, rate })
+  return 0
+}
+
 async function runTake(
   url: string,
   planPath: string,
-  opts: RunOptions,
+  opts: RunOptions & { readonly out: string },
 ): Promise<number> {
   const emitJson = opts.json ?? false
   const path = resolve(planPath)
@@ -209,6 +350,11 @@ async function runTake(
     logStep('Refused')
     logWarn(TAKE_REFUSALS[result.reason])
     if (result.beat) logWarn(`in beat ${result.beat}`)
+    if (result.fallback) {
+      logWarn(
+        `after falling back to a screencast, which opened the address again: ${result.fallback}`,
+      )
+    }
     if (result.reason === 'server-unreachable') {
       logWarn(`Start whatever serves ${url}, then run this again.`)
     }
@@ -224,6 +370,8 @@ async function runTake(
       reason: result.reason,
       message: result.message,
       ...(result.beat ? { beat: result.beat } : {}),
+      ...(result.fallback ? { fallback: result.fallback } : {}),
+      ...(result.still ? { still: result.still } : {}),
       ...(result.reason === 'browser-missing'
         ? { install: INSTALL_BROWSER }
         : {}),

package/src/commands/tasks.ts

@@ -3,6 +3,13 @@ import type { Command } from 'commander'
 import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { type AnswersOutcome, planAnswers } from '@/tasks/answers'
+import {
+  DEFAULT_LAUNCH_WAIT_SECONDS,
+  type LaunchOutcome,
+  type LaunchWait,
+  readLaunchable,
+  waitForLaunchable,
+} from '@/tasks/launch-wait'
 import {
   type BoardOutcome,
   type BoardRefused,
@@ -112,6 +119,12 @@ interface AnswersCommandOptions {
   readonly root?: string
 }
 
+interface LaunchableCommandOptions {
+  readonly json?: boolean
+  readonly root?: string
+  readonly wait?: string | true
+}
+
 interface BranchCommandOptions {
   readonly json?: boolean
   readonly root?: string
@@ -414,6 +427,72 @@ export function register(program: Command): void {
       process.exitCode = await runAnswers(plan, opts)
     })
 
+  tasks
+    .command('launchable')
+    .description(
+      'Report whether a row has a linked plan the dispatch may launch',
+    )
+    .argument('<task>', 'Task filename stem, as in v28.1-trigger-escalation')
+    .helpOption('-h, --help', 'Show this help message')
+    .option('--json', 'Emit a machine-readable record on stdout')
+    .option('--root <path>', 'Board root, defaulting to the main worktree')
+    .option(
+      '--wait [seconds]',
+      `Hold until the row is launchable, default ${DEFAULT_LAUNCH_WAIT_SECONDS}`,
+    )
+    .addHelpText(
+      'after',
+      [
+        '',
+        "Resolves the task's Plan: line and runs the plan-answers gate on the",
+        'plan it names, in one read. It keys on the line rather than on the',
+        'plan file, since a planner links a plan only after it validates, so a',
+        'plan still being written never reads as landed. It answers planning',
+        'alone: the branch and claim checks stay in the dispatch runbook.',
+        '',
+        'The record carries task, plan, launchable, and open, the last three',
+        'named as plan-answers names them. Read `reason`:',
+        '  unlinked    the task carries no Plan: line yet',
+        '  open        the plan still holds a question for the operator',
+        '  launchable  the plan waits on nobody',
+        '',
+        '`--wait [seconds]` re-reads every 30 seconds until the row is',
+        'launchable or the deadline passes. `reason` then reads `launchable`',
+        'or `timeout`, the record carries the last reading, and',
+        '`waitedSeconds` is added. A refusal ends the wait at once. A wait',
+        'past 600 seconds outlasts a foreground shell call, so run it in the',
+        'background and act on the wake.',
+        '',
+        'Refusals, read off `reason`:',
+        '  no-board       the project carries no .canon/tasks/',
+        '  no-match       no task carries that stem exactly',
+        '  ambiguous      several tasks start with the name, so pass one in full',
+        '  several-plans  the Plan: line links more than one plan',
+        '  no-plan        the Plan: line names no file',
+        '  archived       the Plan: line points into the plans archive',
+        '  bad-input      the Plan: line carries an empty target',
+        '  bad-wait       --wait takes a whole number of seconds above zero',
+        '',
+        'Exit codes:',
+        '  0  the row is launchable',
+        '  1  refused, with the reason on stderr or in the JSON record',
+        '  2  the row is unlinked or open, or the wait reached its deadline',
+        '',
+        'It reports and never writes. Branch on `reason` rather than on the',
+        'exit code, which a shell function wrapping canon can flatten to zero.',
+        '',
+        'Examples:',
+        '  canon tasks launchable v28.1-trigger-escalation',
+        '  canon tasks launchable v28.1-trigger-escalation --json',
+        '  canon tasks launchable v28.1-trigger-escalation --wait --json',
+        '  canon tasks launchable v28.1-trigger-escalation --wait 900 --json',
+        '',
+      ].join('\n'),
+    )
+    .action(async (task: string, opts: LaunchableCommandOptions) => {
+      process.exitCode = await runLaunchable(task, opts)
+    })
+
   tasks
     .command('plan-branch')
     .description('Derive the branch name a dispatch and a worker both take')
@@ -1827,6 +1906,110 @@ function reportAnswers(
   return EXIT_FINDINGS
 }
 
+const BAD_WAIT = '--wait takes a whole number of seconds above zero.'
+
+interface BadWait {
+  readonly ok: false
+  readonly reason: 'bad-wait'
+  readonly message: string
+}
+
+async function runLaunchable(
+  task: string,
+  opts: LaunchableCommandOptions,
+): Promise<number> {
+  const emitJson = opts.json ?? false
+  const root = opts.root ?? (await mainWorktreeRoot())
+
+  let waitSeconds: number | undefined
+  if (opts.wait === true) {
+    waitSeconds = DEFAULT_LAUNCH_WAIT_SECONDS
+  } else if (opts.wait !== undefined) {
+    if (!/^\d+$/.test(opts.wait) || Number(opts.wait) === 0) {
+      const refused: BadWait = {
+        ok: false,
+        reason: 'bad-wait',
+        message: BAD_WAIT,
+      }
+      return reportLaunchable(refused, emitJson, root)
+    }
+    waitSeconds = Number(opts.wait)
+  }
+
+  const outcome =
+    waitSeconds === undefined
+      ? await readLaunchable(root, task)
+      : await waitForLaunchable(root, task, {
+          waitSeconds,
+          clock: {
+            now: () => Date.now(),
+            sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
+          },
+        })
+
+  return reportLaunchable(outcome, emitJson, root)
+}
+
+function reportLaunchable(
+  outcome: LaunchOutcome | LaunchWait | BadWait,
+  emitJson: boolean,
+  root: string,
+): number {
+  if (!outcome.ok) {
+    intro('canon tasks launchable')
+    logStep('Refused')
+    logError(outcome.message)
+    outro()
+
+    if (emitJson) {
+      process.stdout.write(
+        `${JSON.stringify({
+          ok: false,
+          reason: outcome.reason,
+          message: outcome.message,
+          ...('waitedSeconds' in outcome && {
+            waitedSeconds: outcome.waitedSeconds,
+          }),
+          root,
+        })}\n`,
+      )
+    }
+    return 1
+  }
+
+  const code = outcome.launchable ? 0 : EXIT_FINDINGS
+
+  if (emitJson) {
+    process.stdout.write(`${JSON.stringify({ ...outcome, root })}\n`)
+    return code
+  }
+
+  intro('canon tasks launchable')
+  logStep(outcome.task)
+
+  if (outcome.plan === undefined) {
+    logWarn('carries no Plan: line yet, so no plan has landed.')
+  } else if (outcome.launchable) {
+    logInfo(`${outcome.plan} waits on nobody, so the dispatch may launch it.`)
+  } else {
+    for (const question of outcome.open) {
+      logWarn(`${question.label} ${question.why}`)
+    }
+    logError(`${outcome.plan} still waits on the operator.`)
+  }
+
+  if ('waitedSeconds' in outcome) {
+    logInfo(
+      outcome.reason === 'timeout'
+        ? `not launchable within ${outcome.waitedSeconds}s`
+        : `launchable after ${outcome.waitedSeconds}s`,
+    )
+  }
+
+  outro()
+  return code
+}
+
 async function runBranch(
   plan: string,
   opts: BranchCommandOptions,