@erclx/canon 4.98.0 → 4.99.0

package/src/commands/pr.ts

@@ -22,6 +22,7 @@ import {
 } from '@/pr/bijection'
 import { type CheckRunListing, collapseChecks } from '@/pr/checks'
 import {
+  findEvidenceChecklist,
   findEvidenceCommentId,
   findEvidencePreview,
   groupEvidence,
@@ -70,6 +71,7 @@ interface ReadOptions {
 
 interface EvidenceOptions extends ReadOptions {
   readonly preview?: string
+  readonly checklist?: string
 }
 
 interface PreviewOptions extends ReadOptions {
@@ -137,10 +139,13 @@ type EvidenceRefusal =
   | 'no-base'
   | 'unreadable-tree'
   | 'unreadable-changes'
+  | 'unreadable-checklist'
 
 const EVIDENCE_REFUSALS: Record<EvidenceRefusal, string> = {
   'gh-failed':
     'gh could not answer for this repository. Name the pull request number.',
+  'unreadable-checklist':
+    'The file named by --checklist could not be read, or holds nothing. Rendering without it would drop the only copy, since the caller deletes the handoff once a post reports success.',
   'no-base': 'No base resolves against the trunk. Fetch origin and re-run.',
   'unreadable-tree':
     'git could not read the tree at the base commit, so no path could be judged added or changed.',
@@ -369,6 +374,10 @@ export function register(program: Command): void {
       '--preview <url>',
       'Open the body with this preview address, from canon pr preview',
     )
+    .option(
+      '--checklist <path>',
+      'Close the body with this visual checklist file, from canon:ui-checklist',
+    )
     .addHelpText(
       'after',
       [
@@ -393,6 +402,14 @@ export function register(program: Command): void {
         'Without --preview, an address the marked comment already opens with',
         'is carried into the new body, so a re-render after a push keeps it.',
         '',
+        '--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 does',
+        'not decide no-evidence: a branch with a checklist and no evidence',
+        'image still reports no-evidence, and the caller posts the checklist',
+        'on its own.',
+        '',
         'Exit codes:',
         '  0  read, whether it produced a body or reported no-evidence',
         '  1  refused, with the reason on stderr or in the JSON record',
@@ -401,6 +418,7 @@ export function register(program: Command): void {
         '  canon pr evidence --json',
         '  canon pr evidence 1341 --json',
         '  canon pr evidence 1341 --preview https://feat-x.site.pages.dev --json',
+        '  canon pr evidence 1341 --checklist .canon/tmp/handoff/ui-checklist/x.md --json',
         '',
       ].join('\n'),
     )
@@ -1214,6 +1232,23 @@ async function runEvidence(
 
   intro('canon pr evidence')
 
+  // Read ahead of anything else, so a bad path refuses before a `gh` round
+  // trip rather than after one.
+  let suppliedChecklist: string | undefined
+  if (opts.checklist !== undefined) {
+    suppliedChecklist = await readFile(resolve(root, opts.checklist), 'utf8')
+      .then((text) => text.trim() || undefined)
+      .catch(() => undefined)
+    if (suppliedChecklist === undefined) {
+      return refuseWith(
+        'unreadable-checklist',
+        EVIDENCE_REFUSALS['unreadable-checklist'],
+        emitJson,
+        root,
+      )
+    }
+  }
+
   const read = await readIdentity(root, number)
   if (read.kind === 'refused') {
     return refuseWith(read.reason, PULL_REFUSALS[read.reason], emitJson, root)
@@ -1294,6 +1329,7 @@ async function runEvidence(
 
   let commentId: number | undefined
   let carriedPreview: string | undefined
+  let carriedChecklist: string | undefined
   if (identity.number !== undefined) {
     const commentsRow = await gh(root, [
       'pr',
@@ -1327,11 +1363,20 @@ async function runEvidence(
     }
     commentId = findEvidenceCommentId(comments)
     carriedPreview = findEvidencePreview(comments)
+    carriedChecklist = findEvidenceChecklist(comments)
   }
 
   const preview = opts.preview ?? carriedPreview
+  const checklist = suppliedChecklist ?? carriedChecklist
   const states = grouped.kind === 'read' ? grouped.states : []
-  const body = renderEvidenceBody(states, repo, base, identity.head, preview)
+  const body = renderEvidenceBody(
+    states,
+    repo,
+    base,
+    identity.head,
+    preview,
+    checklist,
+  )
 
   const caseCount = states.reduce((n, s) => n + s.items.length, 0)
 
@@ -1340,6 +1385,13 @@ async function runEvidence(
     `${plural(caseCount, 'case')} across ${plural(states.length, 'state')}`,
   )
   if (preview !== undefined) logInfo(`preview ${preview}`)
+  if (checklist !== undefined) {
+    logInfo(
+      suppliedChecklist === undefined
+        ? 'checklist carried forward from the marked comment'
+        : 'checklist folded in below the comparison',
+    )
+  }
 
   outro()
 

package/src/commands/tasks.ts

@@ -146,6 +146,11 @@ export function register(program: Command): void {
         'plan, and the archived task keeps a working Plan: pointer at the new',
         'path. A plan several tasks share stays where it is.',
         '',
+        'The ready folder the task names moves to .canon/ready/archive/ with its',
+        'plan, and the Ready: line and the plan path to it are retargeted. A',
+        'folder that does not resolve, or a destination already taken, moves',
+        'nothing and refuses nothing.',
+        '',
         'Exit codes:',
         '  0  the task was archived',
         '  1  refused, with the reason on stderr or in the JSON record',
@@ -1310,6 +1315,11 @@ function report(
     logAdd(relative(root, outcome.plan.to))
     logInfo('retargeted the Plan: line')
   }
+  if (outcome.ready) {
+    logRemove(relative(root, outcome.ready.from))
+    logAdd(relative(root, outcome.ready.to))
+    logInfo('retargeted the Ready: line')
+  }
   if (outcome.priorityRowRemoved) logInfo('cleared the ordering row')
   if (outcome.indexRegenerated) logInfo('regenerated index.md')
   if (outcome.cut > 0) logInfo(`${outcome.cut} outcome(s) cut`)
@@ -1344,6 +1354,12 @@ function recordFor(
           to: relative(root, outcome.plan.to),
         }
       : null,
+    ready: outcome.ready
+      ? {
+          from: relative(root, outcome.ready.from),
+          to: relative(root, outcome.ready.to),
+        }
+      : null,
     closed: outcome.closed,
     cut: outcome.cut,
   }

package/src/demo/compile.ts

@@ -107,11 +107,14 @@ export interface DemoStep {
   readonly note?: string
 }
 
+export type ColorScheme = 'light' | 'dark'
+
 export interface DemoPlan {
   readonly slug: string
   readonly title: string
   readonly url: string
   readonly viewport: { readonly width: number; readonly height: number }
+  readonly colorScheme?: ColorScheme
   readonly output: { readonly video: string; readonly still: string }
   readonly pointer: { readonly travelMs: number; readonly typeDelayMs: number }
   readonly annotations: typeof ANNOTATIONS
@@ -229,6 +232,9 @@ export function parsePlan(text: string): PlanParse {
     steps.push(step.step)
   }
 
+  const colorScheme = parseColorScheme(raw.colorScheme)
+  if (colorScheme.status === 'failed') return colorScheme
+
   const slug = asText(raw.slug)
   const output = isRecord(raw.output) ? raw.output : {}
   const pointer = isRecord(raw.pointer) ? raw.pointer : {}
@@ -244,6 +250,7 @@ export function parsePlan(text: string): PlanParse {
         width: asNumber(viewport.width, VIEWPORT.width),
         height: asNumber(viewport.height, VIEWPORT.height),
       },
+      ...(colorScheme.value && { colorScheme: colorScheme.value }),
       output: {
         video: asText(output.video) || `demos/${slug || 'demo'}.webm`,
         still: asText(output.still) || `demos/${slug || 'demo'}.png`,
@@ -258,6 +265,19 @@ export function parsePlan(text: string): PlanParse {
   }
 }
 
+function parseColorScheme(
+  value: unknown,
+):
+  | { status: 'ok'; value?: ColorScheme }
+  | { status: 'failed'; reason: string } {
+  if (value === undefined) return { status: 'ok' }
+  if (value === 'light' || value === 'dark') return { status: 'ok', value }
+  return {
+    status: 'failed',
+    reason: `colorScheme is ${JSON.stringify(value)}, which is not light or dark`,
+  }
+}
+
 function parseStep(
   entry: unknown,
   index: number,

package/src/demo/drive.ts

@@ -118,6 +118,7 @@ export async function drive(options: DriveOptions): Promise<DriveResult> {
 
     context = await browser.value.newContext({
       viewport: plan.viewport,
+      ...(plan.colorScheme && { colorScheme: plan.colorScheme }),
       // Pointed the opposite way from a test. A recording wants the motion the
       // interface was designed with, where a test wants it suppressed.
       reducedMotion: 'no-preference',

package/src/migrate/skill-names.ts

@@ -21,6 +21,13 @@ import { defineRenameRules, type RenameRules } from '@/migrate/rename'
  * reading in sequence with `draft-screencast` as one three-step pipeline with
  * no prefix forcing that reading.
  *
+ * One row renames a skill rather than retiring a prefix. `ui-test` became
+ * `ui-checklist` when the skill stopped writing tests and shrank to the
+ * checklist a reviewer reads, so the old name described a job it no longer
+ * does. `claude-ui-test` is retargeted onto the same destination rather than
+ * left pointing at the retired name, which lands a target on the oldest
+ * spelling in one pass instead of two.
+ *
  * Every name takes two words. Ten of these would have landed as a bare single
  * word under a plain strip, and a bare word such as `review` or `docs` is a
  * substring of ordinary prose with no token left for a later sweep to find.
@@ -56,7 +63,8 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
   'claude-standards-audit': 'standards-audit',
   'claude-tasks': 'task-board',
   'claude-teach': 'teach-workspace',
-  'claude-ui-test': 'ui-test',
+  'claude-ui-test': 'ui-checklist',
+  'ui-test': 'ui-checklist',
   'claude-ux-audit': 'ux-audit',
   'claude-ux-measure': 'ux-measure',
   'claude-worker': 'role-worker',
@@ -72,11 +80,11 @@ export const SKILL_NAME_MAP: Readonly<Record<string, string>> = {
  *
  * It protects nothing. The `aitk` sweep had to guard a sibling repository
  * whose name contained the token, and no string here contains a skill name
- * while meaning something else: the one overlap in the map is
- * `claude-intake` inside `claude-intake-answer`, which the longest-first
- * ordering settles rather than a protected form. Reading that off the output
- * would report a pass either way, since both rows land on a name opening with
- * `plan-intake`, so the ordering is asserted directly.
+ * while meaning something else. Two rows overlap another row: `claude-intake`
+ * inside `claude-intake-answer`, and `ui-test` inside `claude-ui-test`. The
+ * longest-first ordering settles both rather than a protected form. Reading
+ * either off the output would report a pass anyway, since each pair lands on
+ * one destination, so the ordering is asserted directly.
  *
  * It matches whole tokens. A skill name is a complete name rather than a word
  * stem, and the corpus holds one word that opens with a name and means

package/src/pr/evidence.ts

@@ -7,6 +7,13 @@ const MARKER_PREFIX = '<!-- pr-evidence:'
 /** How the first line of a body names the branch's preview deployment. */
 const PREVIEW_PREFIX = '**Preview:**'
 
+/** The heading the checklist sits under, printed outside the delimiters so a carried checklist never doubles it. */
+const CHECKLIST_HEADING = '## What to look at'
+
+/** Delimiters around the checklist, so a re-render can read back what a reviewer has already ticked. */
+const CHECKLIST_START = '<!-- pr-checklist:start -->'
+const CHECKLIST_END = '<!-- pr-checklist:end -->'
+
 /** A `#issuecomment-<id>` suffix, which is the REST comment id `gh pr view` never returns directly. */
 const ISSUE_COMMENT_ID = /#issuecomment-(\d+)$/
 
@@ -116,6 +123,9 @@ export function evidenceMarker(head: string): string {
  * A preview address opens the body, and with no states it is the whole body
  * apart from the marker, so a pull request whose screenshots did not change
  * still gets one comment a later call can find and edit in place.
+ *
+ * A checklist closes the body, below the comparison it annotates, so one
+ * comment carries the preview address, the screenshots, and what to look at.
  */
 export function renderEvidenceBody(
   states: readonly EvidenceState[],
@@ -123,11 +133,16 @@ export function renderEvidenceBody(
   base: string,
   head: string,
   preview?: string,
+  checklist?: string,
 ): string {
   const opening =
     preview === undefined ? [] : [`${PREVIEW_PREFIX} ${preview}`, '']
+  const closing =
+    checklist === undefined
+      ? []
+      : [CHECKLIST_HEADING, '', CHECKLIST_START, checklist, CHECKLIST_END, '']
   if (states.length === 0) {
-    return [...opening, evidenceMarker(head)].join('\n')
+    return [...opening, ...closing, evidenceMarker(head)].join('\n')
   }
 
   const sections = states.map((entry) => {
@@ -157,6 +172,7 @@ export function renderEvidenceBody(
     '',
     ...sections,
     '',
+    ...closing,
     evidenceMarker(head),
   ].join('\n')
 }
@@ -204,3 +220,22 @@ export function findEvidencePreview(
   if (!first.startsWith(PREVIEW_PREFIX)) return undefined
   return first.slice(PREVIEW_PREFIX.length).trim() || undefined
 }
+
+/**
+ * The checklist the marked comment already carries, read back out of its
+ * delimiters. The handoff file is deleted once posted, so every later render
+ * passes no checklist of its own, and carrying this one forward is what keeps
+ * a re-render after a push from wiping the boxes a reviewer has ticked.
+ */
+export function findEvidenceChecklist(
+  comments: readonly EvidenceComment[],
+): string | undefined {
+  const marked = comments.find((comment) => hasEvidenceMarker(comment.body))
+  if (marked === undefined) return undefined
+  const start = marked.body.indexOf(CHECKLIST_START)
+  const end = marked.body.indexOf(CHECKLIST_END, start)
+  if (start === -1 || end === -1) return undefined
+  return (
+    marked.body.slice(start + CHECKLIST_START.length, end).trim() || undefined
+  )
+}

package/src/sandbox/expect.ts

@@ -178,7 +178,8 @@ function contentArray(value: unknown): ContentAssertion[] {
     // A bare key written below a `[[content]]` header belongs to that table in
     // TOML, not to the document, so a declaration listing `manual` or
     // `max_turns` after its content blocks parses clean and silently asserts
-    // neither. The `claude/ui-test` arm shipped that way: a turn ceiling that
+    // neither. The arm then named `claude/ui-test`, now
+    // `claude/ui-checklist`, shipped that way: a turn ceiling that
     // never ran and five manual entries that never reached the unchecked count,
     // while `canon sandbox coverage` counted the arm as armed. Nothing at the
     // top level can see the difference, so the check belongs here.

package/src/tasks/archive.ts

@@ -7,6 +7,7 @@ import { recordDir, recordDirs } from '@/record-root'
 
 const TASKS = 'tasks'
 const PLANS = 'plans'
+const READY = 'ready'
 const ARCHIVE = 'archive'
 const DECLINED = 'declined'
 const BACKLOG = 'backlog.md'
@@ -75,6 +76,12 @@ export interface PlanMove {
   readonly to: string
 }
 
+/** A ready folder carried into the archive alongside the plan that is its verbatim source. */
+export interface ReadyMove {
+  readonly from: string
+  readonly to: string
+}
+
 export interface ArchiveSuccess {
   readonly ok: true
   readonly stem: string
@@ -84,6 +91,8 @@ export interface ArchiveSuccess {
   readonly indexRegenerated: boolean
   /** Undefined when the task cited no live plan, or when another task still holds it. */
   readonly plan: PlanMove | undefined
+  /** Undefined when the plan stays, or when no ready folder resolves and can move. */
+  readonly ready: ReadyMove | undefined
   readonly closed: number
   readonly cut: number
 }
@@ -280,6 +289,32 @@ export function retargetPlanLine(text: string, target: string): string {
   return text.replace(PLAN_PATTERN, () => planLine(target))
 }
 
+/** The `Ready:` line in either form, matched the way `PLAN_PATTERN` matches `Plan:`. */
+const READY_PATTERN = /^Ready:[ \t]*(?:\[[^\]]*\]\(([^)]+)\)|(\S+))[ \t]*$/m
+
+/** A ready folder path as a plan's constraints write it, the folder name captured. */
+const READY_PATH_PATTERN = /(\.(?:canon|claude)\/ready\/)([^\s/`)]+)(?=\/)/g
+
+export function readReadyTarget(text: string): string | undefined {
+  const match = READY_PATTERN.exec(text)
+  if (!match) return undefined
+  return match[1] ?? match[2]
+}
+
+/**
+ * Builds a `Ready:` line as a link whose target keeps the trailing slash a
+ * folder carries, the label taken from the folder's own name.
+ */
+export function readyLine(target: string): string {
+  const folder = target.replace(/\/+$/, '')
+
+  return `Ready: [${basename(folder)}](${folder}/)`
+}
+
+export function retargetReadyLine(text: string, target: string): string {
+  return text.replace(READY_PATTERN, () => readyLine(target))
+}
+
 /**
  * Builds the `Declined:` line recording why a task was decided against and by
  * whom. Free prose after the colon, since the line names no file to link,
@@ -731,22 +766,41 @@ export async function archiveTask(
   }
 
   const plan = await planToArchive(dir, root, stem, text)
+  const ready = plan && (await readyToArchive(dir, root, text, plan))
   const destination = archiveDir(root)
   const to = join(destination, `${stem}.md`)
 
   // The plan moves first so the line written below describes a file already at
   // its new path. Writing the retarget first and failing the move would leave a
   // pointer at a folder holding nothing, and `.canon/plans/` is gitignored, so
-  // no history recovers the target it named.
+  // no history recovers the target it named. The folder follows the plan and
+  // both precede the task, so a failed rename never leaves the task archived
+  // with its folder live, which the unattended post-merge hook cannot repair.
   if (plan) {
     await mkdir(dirname(plan.to), { recursive: true })
     await rename(plan.from, plan.to)
   }
 
+  if (ready) {
+    await mkdir(dirname(ready.to), { recursive: true })
+    await rename(ready.from, ready.to)
+    await writeFile(
+      plan.to,
+      retargetReadyPaths(await readFile(plan.to, 'utf8'), basename(ready.from)),
+    )
+  }
+
   await mkdir(destination, { recursive: true })
   await rename(from, to)
-  if (plan)
-    await writeFile(to, retargetPlanLine(text, linkTo(destination, plan.to)))
+  if (plan) {
+    const retargeted = retargetPlanLine(text, linkTo(destination, plan.to))
+    await writeFile(
+      to,
+      ready
+        ? retargetReadyLine(retargeted, `${linkTo(destination, ready.to)}/`)
+        : retargeted,
+    )
+  }
 
   const priorityRowRemoved = await clearPriorityRow(dir, stem)
   const regen = await regenOne(dir, { dryRun: false })
@@ -759,6 +813,7 @@ export async function archiveTask(
     priorityRowRemoved,
     indexRegenerated: regen.action === 'written',
     plan,
+    ready: ready || undefined,
     closed: closed.length,
     cut: cut.length,
   }
@@ -797,6 +852,63 @@ async function planToArchive(
   }
 }
 
+/**
+ * The ready folder that travels with the plan, or nothing. It is read from the
+ * task's `Ready:` line, falling back to a folder path in the plan's own text for
+ * a task written before the line was defined. It moves only with its plan,
+ * since the folder is the plan's verbatim source and a plan another task still
+ * cites still needs it, so the caller passes the plan `planToArchive` settled.
+ *
+ * A target naming no folder, one already archived, or a destination taken
+ * yields nothing and refuses nothing, the way a mistyped `Plan:` does.
+ */
+async function readyToArchive(
+  dir: string,
+  root: string,
+  text: string,
+  plan: PlanMove,
+): Promise<ReadyMove | undefined> {
+  const live =
+    readyFolder(dir, root, text) ??
+    readyFolder(dir, root, await readFile(plan.from, 'utf8'))
+  if (!live) return undefined
+
+  const to = join(recordDir(root, READY, ARCHIVE), basename(live))
+  if (existsSync(to)) return undefined
+
+  return { from: live, to }
+}
+
+function readyFolder(
+  dir: string,
+  root: string,
+  text: string,
+): string | undefined {
+  const target = readReadyTarget(text)
+  const named = target ? [resolve(dir, target), resolve(root, target)] : []
+  const constrained = [...text.matchAll(READY_PATH_PATTERN)].map(([, , name]) =>
+    join(recordDir(root, READY), name),
+  )
+  const archives = recordDirs(root, READY, ARCHIVE)
+
+  return [...named, ...constrained].find(
+    (path) =>
+      recordDirs(root, READY).some((base) => dirname(path) === base) &&
+      basename(path) !== ARCHIVE &&
+      !archives.some((base) => isUnder(path, base)) &&
+      existsSync(path),
+  )
+}
+
+/** Points the plan's literal folder paths at `ready/archive/`, since the folder no longer sits where they say. */
+function retargetReadyPaths(text: string, folder: string): string {
+  return text.replace(
+    READY_PATH_PATTERN,
+    (whole: string, prefix: string, name: string) =>
+      name === folder ? `${prefix}${ARCHIVE}/${name}` : whole,
+  )
+}
+
 /**
  * The archived plan as the archived task cites it. Both halves land a folder
  * deeper than the live pair, so the link is measured between the two

package/standards/ready.md

@@ -78,7 +78,7 @@ Below the frontmatter, state in prose what the worker still owns beyond copying
 ## Lifecycle
 
 - Write the ready folder in the same session that writes the files it carries. A folder assembled later from memory is a plan with extra steps, not a handoff.
-- Move the folder to `.canon/ready/archive/<nn>-<slug>/` by hand when the task that shipped it archives. No board verb currently automates this move. `canon tasks archive` moves the task and its plan and leaves the ready folder where it is.
+- Leave the move to `canon tasks archive`, which carries the folder to `.canon/ready/archive/<nn>-<slug>/` with its plan when the task that shipped it archives, and retargets the task's `Ready:` line. A plan another live task still cites keeps its folder.
 - Never delete a ready folder. The archived copy sits beside the merged pull request as the exact text that shipped, the way an archived plan sits beside the reasoning that produced it.
 
 ## Anti-patterns
@@ -86,7 +86,7 @@ Below the frontmatter, state in prose what the worker still owns beyond copying
 - **The folder with an undeclared destination.** A file the plan's `**Files to touch:**` does not list passes the collision check unseen, and a second track can write the same path without either side finding out.
 - **The rewritten copy.** A worker that reads the folder's files as inspiration and writes its own version loses the exact text the handoff exists to carry.
 - **The folder as scratch.** Notes, alternates, or draft passages left in the folder beside the real files leave the worker guessing which is the source.
-- **The folder left live after shipping.** A ready folder nobody moves to the archive reads as unshipped work to the next session that lists the live folder.
+- **The folder left live after shipping.** A ready folder the archive verb did not move reads as unshipped work to the next session that lists the live folder. The verb skips one whose task carries no `Ready:` line and cites no folder path in its plan.
 
 ## Template
 

package/standards/tasks.md

@@ -213,7 +213,9 @@ A task with no origin is either lost context or work nobody decided to do. The i
 
 An intake folder answers that direction at folder scope rather than item scope, since one dump dispositions many items and most close without ever becoming a task. What names a folder is every item answered and no task citing it, on the board or in the archive. That is a dump nobody acted on. Counting the archive and declined folder beside the board is what separates it from one already promoted and settled, and a check reading the board alone calls every finished folder abandoned.
 
-`Plan:`, `Groundwork:`, and `Intake:` name their target as a markdown link whose text is the file or folder stem, so the line resolves on a ctrl-click the way `priority.md` rows already do. Write the path relative to `.canon/tasks/`, which makes it `../plans/`, `../groundwork/`, and `../intake/`. A path written from the project root renders as a link and resolves to nothing in an editor rooted at the project. `Issue:` stays a bare `#NNN`, since an issue number is not a path and a full URL would write the remote into a gitignored file.
+`Plan:`, `Groundwork:`, and `Intake:` name their target as a markdown link whose text is the file or folder stem, so the line resolves on a ctrl-click the way `priority.md` rows already do. Write the path relative to `.canon/tasks/`, which makes it `../plans/`, `../groundwork/`, and `../intake/`. A path written from the project root renders as a link and resolves to nothing in an editor rooted at the project. `Ready:` names the ready folder a task's plan copies from, as a link to `../ready/<nn>-<slug>/` with the trailing slash a folder carries. Include it only when the folder exists. `canon tasks archive` reads it to move the folder, and falls back to a `.canon/ready/<nn>-<slug>/` path in the plan when a task carries no line.
+
+`Issue:` stays a bare `#NNN`, since an issue number is not a path and a full URL would write the remote into a gitignored file.
 
 Phase-label format and where labels may appear are governed by `standards/versioning.md`.
 
@@ -257,7 +259,7 @@ The archive nests inside `.canon/tasks/` rather than sitting beside it as a flat
 
 One destination rather than a per-project choice is what lets the move happen without asking. It mirrors the plans archive at `.canon/plans/archive/`, sitting inside the folder it archives the same way, and it inherits the board's own ignore entry rather than needing one of its own. The cost is that an archived task does not appear in diffs, which is the cost the live board already carries.
 
-Archiving a task archives its plan alongside it, when the closing task is that plan's last live citation. The archived task's `Plan:` line is retargeted at `../../plans/archive/feature-<slug>.md`, a folder deeper than the live task wrote it, so a completed task still leads to the reasoning behind it. A plan several tasks share stays live and the task archives anyway, since moving it on the first task to close strands every sibling's pointer at a path that has gone.
+Archiving a task archives its plan alongside it, when the closing task is that plan's last live citation. The archived task's `Plan:` line is retargeted at `../../plans/archive/feature-<slug>.md`, a folder deeper than the live task wrote it, so a completed task still leads to the reasoning behind it. The ready folder the task's `Ready:` line names moves with the plan to `.canon/ready/archive/<nn>-<slug>/`, and the `Ready:` line and the plan's path to the folder are retargeted, since the folder is the plan's verbatim source. A plan several tasks share stays live and the task archives anyway, since moving it on the first task to close strands every sibling's pointer at a path that has gone. Its ready folder stays with it.
 
 One act rather than two is what makes the pair safe. The merge is the event that settles a plan, and a `post-merge` hook reaching the archive with nobody watching cannot act on a warning, so a second call after it would be a second failure point leaving the task archived and the plan live.
 

package/claude/skills/ui-test/REQUIREMENT.md

@@ -1,48 +0,0 @@
----
-name: ui-test
-description: Why UI changes split into what a browser can assert and what only an eye can judge, and why the visual half is written to disk rather than printed
----
-
-# UI test requirement
-
-## Gap
-
-Without this skill, UI work ships on the confidence of the session that wrote it. What verification does happen mixes the two kinds without noticing, so a checklist item about spacing sits beside one about a form submission, and neither is done properly because they need different work from different people. Tests get written against a config the project does not use, or duplicate what a component test already covers.
-
-The automatable half fails the other way. Sending every interaction, state, and form to Playwright leaves the layers unrouted, so a loading state lands in a full browser run and the end to end suite grows on each UI change. A state a component test reaches costs a browser to check, and the cost recurs on every later run.
-
-The visual half is where the record is lost. A checklist printed into chat scrolls away before anyone verifies it, so the ship step has nothing to gate on and the work reads as verified because a list was produced. Written from a linked worktree against `pwd`, the file lands where the caller does not look.
-
-Writing the checklist correctly to disk does not close the gap either. The file sits under a gitignored folder on the machine that authored it, so a pull request reviewer, on that machine or another, never sees it. A record that only the author can open reads as verified for the same reason a record that never existed does.
-
-## Must
-
-- Split every change into visual-only and automatable before writing anything, then route each automatable one to its layer through `test-craft`
-- Write end to end only for a journey or a behavior only a real browser renders, and component or unit tests for the rest
-- Name a missing component runner in the output and put the state on the checklist
-- Read the project's existing test config and patterns before writing a test against them
-- Assert a user action and its outcome per test, covering the happy path and the key edge cases
-- Run the tests after writing them and fix what fails
-- Write a produced checklist to the `.canon/tmp/handoff/ui-checklist/<slug>.md` handoff at the main worktree root, overwriting
-- Report that everything is covered rather than manufacturing a checklist to show work
-
-## Must not
-
-- Try to assert a visual property programmatically
-- Re-test what unit or component tests written during implementation already cover
-- Route a state a component test reaches into end to end, or fall back to end to end silently when no runner exists
-- Repeat the full checklist in chat, which is what made it evaporate
-- Stage or commit the checklist, which is gitignored scratch
-- Talk to GitHub directly. Posting the checklist to a pull request belongs to `git-pr`, the sole consumer of the handoff file
-
-## Guards
-
-- No implementation context in the session: stop, since there is nothing to derive tests from
-- Every change automatable: skip the file write and report the coverage
-
-## Out of scope
-
-- Judging whether the UI is any good, which `ux-audit` owns
-- The rules for choosing a layer, which `test-craft` owns
-- Deciding whether an outstanding checklist blocks the ship, which the calling pipeline gates on
-- Performing the visual verification, which needs a person