@erclx/canon 5.53.0 → 5.55.0

package/governance/detect.toml

@@ -9,8 +9,7 @@
 # root and in every folder to depth two. `files` are globs matched against the
 # target's git-listed paths to depth two, and against each folder on those
 # paths, so `.github/workflows` matches a folder holding a workflow. A glob with
-# no wildcard is also tested on disk, which reaches a gitignored path such as
-# `.canon/canvas`.
+# no wildcard is also tested on disk, which reaches a gitignored path.
 #
 # Every rule no stack reaches needs a table here, which the `unreferenced-rules`
 # gate stage checks, along with every key naming a live rule. A table for a rule
@@ -201,10 +200,6 @@ files = ["index.html", "*/index.html"]
 deps = ["react", "vue", "svelte", "astro", "next", "solid-js", "preact"]
 files = ["index.html", "*/index.html"]
 
-["canvas"]
-deps = []
-files = [".canon/canvas"]
-
 ["design-reference"]
 deps = []
 files = ["canon/design/*/"]

package/governance/renames.toml

@@ -73,4 +73,3 @@
 "460-design-taste" = "design-taste"
 "465-interface-casing" = "interface-casing"
 "470-motion" = "motion"
-"480-canvas" = "canvas"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "5.53.0",
+  "version": "5.55.0",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
   "license": "MIT",
   "bin": {
@@ -51,11 +51,9 @@
     "web:e2e": "cd web && playwright test"
   },
   "dependencies": {
-    "@preact/signals": "^2.11.3",
     "commander": "^13.1.0",
     "execa": "^9.5.2",
-    "playwright-core": "1.64.1",
-    "preact": "^11.0.0"
+    "playwright-core": "1.64.1"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.8",
@@ -68,7 +66,6 @@
     "@types/bun": "^1.2.10",
     "@types/micromatch": "^4.0.10",
     "astro": "^6.1.9",
-    "happy-dom": "^20.14.5",
     "husky": "^9.1.7",
     "micromatch": "^4.0.8",
     "oxfmt": "0.73.0",

package/scripts/core/install-check.sh

@@ -88,7 +88,7 @@ mkdir -p "$TARGET_DIR"
 log_info "Initialized git in $TARGET_DIR"
 
 log_step "Run canon init"
-(cd "$TARGET_DIR" && CANON_NON_INTERACTIVE=1 bun run "$EXTRACT_DIR/src/cli.ts" init --stack base 2>&1 | pipe_output) || log_error "canon init failed"
+(cd "$TARGET_DIR" && bun run "$EXTRACT_DIR/src/cli.ts" init --stack base </dev/null 2>&1 | pipe_output) || log_error "canon init failed"
 log_info "canon init completed"
 
 log_step "Assert scaffold"

package/scripts/lib/ui.sh

@@ -6,93 +6,40 @@ if [ "${BASH_VERSINFO[0]:-0}" -lt 4 ]; then
   exit 1
 fi
 
-# `NO_COLOR` follows the published convention, where any non-empty value turns
-# color off whatever the value says.
-supports_color() {
-  [ -z "${NO_COLOR:-}" ] && [ -t "$1" ]
-}
-
-# Assigns the six palette names for one file descriptor. The blank palette keeps
-# every frame character and drops only the escapes, so a captured run still
-# reads as one block.
-#
-# Bash returns a string and nothing richer, so the palette arrives through the
-# caller's own scope. A writer declaring all six `local` before calling this
-# keeps the assignment to itself, which is what leaves the source-time answer
-# below standing for anything that sources this file.
-set_palette() {
-  if supports_color "$1"; then
-    GREEN='\033[0;32m'
-    RED='\033[0;31m'
-    YELLOW='\033[0;33m'
-    WHITE='\033[1;37m'
-    GREY='\033[0;90m'
-    NC='\033[0m'
-  else
-    GREEN=''
-    RED=''
-    YELLOW=''
-    WHITE=''
-    GREY=''
-    NC=''
-  fi
-}
-
-# Every writer below frames to stderr and asks about that stream at write time,
-# so no answer is frozen before a caller's redirect is in place. This one answers
-# for stdout instead, because it is read by a sourcing script writing its own
-# frame with a bare `echo`, and that is the stream a bare `echo` reaches.
-set_palette 1
+# The frame writes no color. The scripts left on it run as setup and gate steps,
+# where a pipe or a log reads the output more often than a terminal does.
 
 log_info() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC} ${GREEN}✓${NC} $1" >&2
+  echo -e "│ ✓ $1" >&2
 }
 log_warn() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC} ${YELLOW}!${NC} $1" >&2
+  echo -e "│ ! $1" >&2
 }
 log_error() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC} ${RED}✗${NC} $1" >&2
+  echo -e "│ ✗ $1" >&2
   exit 1
 }
 log_step() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC}\n${GREY}├${NC} ${WHITE}$1${NC}" >&2
+  echo -e "│\n├ $1" >&2
 }
 log_add() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC} ${GREEN}+${NC} $1" >&2
+  echo -e "│ + $1" >&2
 }
 log_rem() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}│${NC} ${RED}-${NC} $1" >&2
+  echo -e "│ - $1" >&2
 }
 
 pipe_output() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  while IFS= read -r line; do echo -e "${GREY}│${NC}  $line" >&2; done
+  while IFS= read -r line; do echo -e "│  $line" >&2; done
 }
 
 open_timeline() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}┌${NC}" >&2
+  echo -e "┌" >&2
   if [ -n "${1:-}" ]; then
-    echo -e "${GREY}│${NC} ${WHITE}$1${NC}" >&2
+    echo -e "│ $1" >&2
   fi
 }
 
 close_timeline() {
-  local GREEN RED YELLOW WHITE GREY NC
-  set_palette 2
-  echo -e "${GREY}└${NC}" >&2
+  echo -e "└" >&2
 }

package/src/audits/run.ts

@@ -74,7 +74,7 @@ export function spawnAudit(root: string): Spawn {
       // extending it. Spreading `process.env` alongside would put back the very
       // variables it strips, and a hook's `GIT_DIR` would then point every
       // history-reading verb at a repository nobody asked about.
-      env: { ...gitEnv(), CANON_NON_INTERACTIVE: '1' },
+      env: gitEnv(),
       extendEnv: false,
     })
 

package/src/claude/cases/misc.ts

@@ -22,11 +22,6 @@ export const MISC_CASES: readonly SkillCase[] = [
       'This project has no logo yet. Draft one and give me a social card to go with it.',
     expect: 'design-identity',
   },
-  {
-    prompt:
-      'Draw the signup screen as a frame on the canvas, then restyle the element I just selected there.',
-    expect: 'canvas-board',
-  },
   {
     prompt:
       'The operator picked the new settings panel, so land it in canon/design with an index row for it.',

package/src/claude/routing.ts

@@ -9,7 +9,7 @@ const TOKEN = /`([^`\s]+)`/g
 
 /**
  * A path a reader could open. Admits no `$`, `*`, or `=`, so an assignment
- * (`CANON_NON_INTERACTIVE=1`) and a variable are both excluded.
+ * (`NAME=value`) and a variable are both excluded.
  */
 const PATH_TOKEN = /^[.A-Za-z0-9_][A-Za-z0-9._/-]*$/
 

package/src/claude/skills-audit.ts

@@ -55,6 +55,7 @@ export const PRACTICE_SKILLS: readonly string[] = [
   join(SHIPPED_CORPUS, 'build-in-slices'),
   join(SHIPPED_CORPUS, 'deprecation-migration'),
   join(SHIPPED_CORPUS, 'search-craft'),
+  join(SHIPPED_CORPUS, 'teach-craft'),
 ]
 
 /**

package/src/cli/help.ts

@@ -43,7 +43,6 @@ export const COMMAND_GROUPS: { title: string; rows: CommandRow[] }[] = [
       ['inventory [subj]', 'Report one computed property across every route'],
       ['drive <url> <run>', 'Walk a page through interactions, measure each'],
       ['transcripts <url>', 'Fetch a YouTube transcript with frontmatter'],
-      ['canvas [cmd]', 'Local canvas of pages and frames'],
     ],
   },
   {
@@ -98,8 +97,6 @@ const EXAMPLES = [
   'canon indexes regen --dry-run --json',
   'canon docs list --json',
   'canon docs agents',
-  'canon design render',
-  'canon canvas list --json',
   'canon capture assets/captures/install.html --selector .window --out assets/frames',
   'canon inventory focus --json',
   'canon drive http://localhost:4173 run.json --json',

package/src/cli/run.ts

@@ -2,7 +2,7 @@ import { join } from 'node:path'
 import { execa } from 'execa'
 
 export interface CliRunOptions {
-  /** Sets `CANON_NON_INTERACTIVE=1` for the child. Defaults to false. */
+  /** Closes the child's stdin, which makes it headless. Defaults to false. */
   readonly nonInteractive?: boolean
   /** Defaults to `inherit`, so a child prompt still reaches the operator. */
   readonly stdin?: 'ignore' | 'inherit'
@@ -28,13 +28,12 @@ export function cliRun(
   options: CliRunOptions = {},
 ): () => Promise<boolean> {
   return async () => {
-    const env = options.nonInteractive
-      ? { ...process.env, CANON_NON_INTERACTIVE: '1' }
-      : process.env
+    const stdin = options.nonInteractive
+      ? 'ignore'
+      : (options.stdin ?? 'inherit')
 
     const result = await execa('bun', [path, ...args], {
-      stdio: [options.stdin ?? 'inherit', 'inherit', 'inherit'],
-      env,
+      stdio: [stdin, 'inherit', 'inherit'],
       reject: false,
     })
 

package/src/cli/ui.ts

@@ -53,7 +53,38 @@ export function palette(stream: { isTTY?: boolean }): Palette {
   return supportsColor(stream) ? COLOR : PLAIN
 }
 
+let quiet = false
+
+/**
+ * Silences the progress frame for a caller that asked for a record, since an
+ * agent reads both streams and the frame outweighed the data. Warnings and
+ * errors still write, since diagnostics reach stderr in every mode.
+ */
+export function setQuiet(on: boolean): void {
+  quiet = on
+}
+
+/**
+ * The frame is drawn only for a terminal. A pipe or a file gets each line's
+ * mark alone, since a reader there gains nothing from `┌ │ ├ └` and an agent
+ * pays for every one of them.
+ */
+function framed(): boolean {
+  return process.stderr.isTTY === true
+}
+
+function markLine(color: keyof Palette, mark: string, message: string): string {
+  if (!framed()) return `${mark} ${message}\n`
+  const { GREY, NC, [color]: tint } = palette(process.stderr)
+  return `${GREY}│${NC} ${tint}${mark}${NC} ${message}\n`
+}
+
 export function intro(title: string): void {
+  if (quiet) return
+  if (!framed()) {
+    process.stderr.write(`${title}\n`)
+    return
+  }
   const { GREY, NC, WHITE } = palette(process.stderr)
   process.stderr.write(`${GREY}┌${NC}\n${GREY}│${NC} ${WHITE}${title}${NC}\n`)
 }
@@ -64,23 +95,22 @@ export function intro(title: string): void {
  * leaving stdout clean for JSON and lists.
  */
 export function logInfo(message: string): void {
-  const { GREEN, GREY, NC } = palette(process.stderr)
-  process.stderr.write(`${GREY}│${NC} ${GREEN}✓${NC} ${message}\n`)
+  if (quiet) return
+  process.stderr.write(markLine('GREEN', '✓', message))
 }
 
 export function logWarn(message: string): void {
-  const { GREY, NC, YELLOW } = palette(process.stderr)
-  process.stderr.write(`${GREY}│${NC} ${YELLOW}!${NC} ${message}\n`)
+  process.stderr.write(markLine('YELLOW', '!', message))
 }
 
 export function logAdd(message: string): void {
-  const { GREEN, GREY, NC } = palette(process.stderr)
-  process.stderr.write(`${GREY}│${NC} ${GREEN}+${NC} ${message}\n`)
+  if (quiet) return
+  process.stderr.write(markLine('GREEN', '+', message))
 }
 
 export function logRemove(message: string): void {
-  const { GREY, NC, RED } = palette(process.stderr)
-  process.stderr.write(`${GREY}│${NC} ${RED}-${NC} ${message}\n`)
+  if (quiet) return
+  process.stderr.write(markLine('RED', '-', message))
 }
 
 /**
@@ -89,31 +119,48 @@ export function logRemove(message: string): void {
  * exit code rather than terminating mid-write.
  */
 export function logError(message: string): void {
-  const { GREY, NC, RED } = palette(process.stderr)
-  process.stderr.write(`${GREY}│${NC} ${RED}✗${NC} ${message}\n`)
+  process.stderr.write(markLine('RED', '✗', message))
 }
 
 export function logStep(message: string): void {
+  if (quiet) return
+  if (!framed()) {
+    process.stderr.write(`${message}\n`)
+    return
+  }
   const { GREY, NC, WHITE } = palette(process.stderr)
   process.stderr.write(`${GREY}│${NC}\n${GREY}├${NC} ${WHITE}${message}${NC}\n`)
 }
 
 export function outro(): void {
+  if (quiet || !framed()) return
   const { GREY, NC } = palette(process.stderr)
   process.stderr.write(`${GREY}└${NC}\n`)
 }
 
+/**
+ * Closes the frame on the green line a command ends a success on. The line
+ * sits below the frame rather than inside it, and a quiet run writes neither.
+ */
+export function outroSuccess(message: string, detail?: string): void {
+  if (quiet) return
+  outro()
+  const { GREEN, GREY, NC } = palette(process.stderr)
+  const suffix = detail === undefined ? '' : ` ${GREY}${detail}${NC}`
+  process.stderr.write(`${GREEN}✓ ${message}${NC}${suffix}\n`)
+}
+
 /**
  * Indents borrowed output inside an open frame, matching `pipe_output` in
  * `scripts/lib/ui.sh`. Used for a document the command did not compose itself,
  * such as a pull request body or the output of a git mutation.
  */
 export function pipeOutput(text: string): void {
+  if (quiet) return
   const { GREY, NC } = palette(process.stderr)
+  const bar = framed() ? `${GREY}│${NC}` : ''
   const lines = text.replace(/\n$/, '').split('\n')
-  process.stderr.write(
-    `${lines.map((line) => `${GREY}│${NC}  ${line}`).join('\n')}\n`,
-  )
+  process.stderr.write(`${lines.map((line) => `${bar}  ${line}`).join('\n')}\n`)
 }
 
 /** Counts a noun for a report line, where the plural is the bare `s` form. */
@@ -122,6 +169,10 @@ export function plural(count: number, noun: string): string {
 }
 
 export function frameError(message: string): void {
+  if (!framed()) {
+    process.stderr.write(`✗ ${message}\n`)
+    return
+  }
   const { GREY, NC, RED } = palette(process.stderr)
   process.stderr.write(
     `${GREY}┌${NC}\n${GREY}│${NC} ${RED}✗${NC} ${message}\n${GREY}└${NC}\n`,
@@ -129,6 +180,11 @@ export function frameError(message: string): void {
 }
 
 export function frameSuccess(command: string, target: string): void {
+  if (quiet) return
+  if (!framed()) {
+    process.stderr.write(`${command}\n✓ ${target}\n`)
+    return
+  }
   const { GREEN, GREY, NC, WHITE } = palette(process.stderr)
   process.stderr.write(
     `${GREY}┌${NC}\n${GREY}│${NC} ${WHITE}${command}${NC}\n${GREY}│${NC}\n${GREY}│${NC} ${GREEN}✓${NC} ${target}\n${GREY}└${NC}\n`,
@@ -136,17 +192,17 @@ export function frameSuccess(command: string, target: string): void {
 }
 
 /**
- * The retired spelling is still honored, and permanently.
+ * A caller with no terminal on stdin is headless, since nobody can answer a
+ * prompt there.
  *
- * This variable is the documented way to drive any command headlessly, so
- * every skill body, CI job, and operator script already written sets the old
- * name. Those callers live in other repositories and in plugin caches this
- * release cannot reach, and the failure mode of dropping the fallback is a
- * command that quietly waits for a TTY nobody is watching rather than one that
- * refuses and says why.
+ * Both variables are retired overrides that force headless on a terminal and
+ * stay readable permanently. Skill bodies, CI jobs, and operator scripts in
+ * other repositories and plugin caches this release cannot reach still set
+ * them, and dropping the read turns their call into a prompt nobody watches.
  */
 export function isNonInteractive(): boolean {
   return (
+    !process.stdin.isTTY ||
     process.env.CANON_NON_INTERACTIVE === '1' ||
     // canon-keep-retired
     process.env.AITK_NON_INTERACTIVE === '1'
@@ -155,8 +211,8 @@ export function isNonInteractive(): boolean {
 
 /**
  * `nonInteractiveDefault` opts a prompt into resolving to its first option
- * under `CANON_NON_INTERACTIVE=1` instead of failing. Callers that would rather fail loudly than pick
- * for the user leave it off.
+ * when the caller is headless instead of failing. Callers that would rather
+ * fail loudly than pick for the user leave it off.
  */
 export async function select<Value>(opts: {
   message: string
@@ -171,9 +227,11 @@ export async function select<Value>(opts: {
   let cursor = 0
 
   if (opts.nonInteractiveDefault && isNonInteractive()) {
-    process.stderr.write(
-      `${GREY}│${NC}\n${GREY}◇${NC} ${message} ${WHITE}${options[0].label}${NC}\n`,
-    )
+    if (!quiet) {
+      process.stderr.write(
+        markLine('GREY', '◇', `${message} ${options[0].label}`),
+      )
+    }
     return options[0].value
   }
 
@@ -196,10 +254,11 @@ export async function select<Value>(opts: {
   }
 
   return new Promise<Value>((resolve) => {
-    if (!process.stdin.isTTY) {
-      process.stderr.write(
-        `${GREY}│${NC} ${RED}✗${NC} ${message} requires a TTY. ${opts.ttyHint ?? 'Pass an argument'} or set CANON_NON_INTERACTIVE=1.\n${GREY}└${NC}\n`,
+    if (isNonInteractive()) {
+      logError(
+        `${message} requires a TTY. ${opts.ttyHint ?? 'Pass an argument'}.`,
       )
+      outro()
       process.exit(1)
     }
 

package/src/cli.ts

@@ -18,7 +18,6 @@ import { register as feedback } from '@/commands/feedback'
 import { register as transcripts } from '@/commands/transcripts'
 import { register as tasks } from '@/commands/tasks'
 import { register as intake } from '@/commands/intake'
-import { register as canvas } from '@/commands/canvas'
 import { register as comments } from '@/commands/comments'
 import { register as context } from '@/commands/context'
 import { register as markdown } from '@/commands/markdown'
@@ -41,6 +40,7 @@ import { register as changelog } from '@/commands/changelog'
 import { readInstalled, UNKNOWN_LABEL } from '@/version/installed'
 import { renderHelp } from '@/cli/help'
 import { renderAll, routeHelp } from '@/cli/help-all'
+import { setQuiet } from '@/cli/ui'
 
 function showHelp(): void {
   console.log(renderHelp(process.stdout))
@@ -58,6 +58,11 @@ program.on('option:help', () => {
   process.exit(0)
 })
 program.option('-h, --help', 'Show help')
+// A caller asking for a record reads it from stdout, so the frame on stderr is
+// noise it pays for. Warnings and errors still write.
+program.hook('preAction', (_program, action) => {
+  if (action.opts().json === true) setQuiet(true)
+})
 
 init(program)
 sandbox(program)
@@ -76,7 +81,6 @@ feedback(program)
 transcripts(program)
 tasks(program)
 intake(program)
-canvas(program)
 comments(program)
 context(program)
 markdown(program)

package/src/commands/claude.ts

@@ -91,6 +91,7 @@ import {
   logStep,
   logWarn,
   outro,
+  outroSuccess,
   palette,
   pipeOutput,
   plural,
@@ -604,9 +605,7 @@ export function register(program: Command): void {
 }
 
 function succeed(message: string): number {
-  const { GREEN, NC } = palette(process.stderr)
-  outro()
-  process.stderr.write(`${GREEN}✓ ${message}${NC}\n`)
+  outroSuccess(message)
   return 0
 }