@erclx/canon 5.71.0 → 5.72.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [5.72.1](https://github.com/erclx/canon/compare/v5.72.0...v5.72.1) (2026-10-27)
+
+
+### Reverts
+
+* **playwright:** drop the apt archive cache from [#2809](https://github.com/erclx/canon/issues/2809) ([#2810](https://github.com/erclx/canon/issues/2810)) ([2833270](https://github.com/erclx/canon/commit/2833270559d3afbd098caecbfcc395b7082f4570))
+
+## [5.72.0](https://github.com/erclx/canon/compare/v5.71.0...v5.72.0) (2026-10-27)
+
+
+### Features
+
+* **feedback:** post a checked follow-up on an open feedback issue ([#2805](https://github.com/erclx/canon/issues/2805)) ([b014d5e](https://github.com/erclx/canon/commit/b014d5ed5a5501b0902aa4adf794dd50d715d7aa))
+* **feedback:** read each issue's comments in triage ([#2802](https://github.com/erclx/canon/issues/2802)) ([ab2c761](https://github.com/erclx/canon/commit/ab2c7616c094ba43f4045c48f9fdbbe7bfb5b976))
+* **intake:** offer to close an issue when its item is declined ([#2807](https://github.com/erclx/canon/issues/2807)) ([95df7da](https://github.com/erclx/canon/commit/95df7da6e6769b240e2565e24b12dc35f9233993))
+* **pr:** carry a UI close only across pushes no box can observe ([#2804](https://github.com/erclx/canon/issues/2804)) ([c5102ea](https://github.com/erclx/canon/commit/c5102eaf5e6367b7335b8b66650ad03ca06dad41))
+* **ui-film:** film one beat per group and skip negative boxes ([#2806](https://github.com/erclx/canon/issues/2806)) ([fb24ed3](https://github.com/erclx/canon/commit/fb24ed36c23e1e3bcb5c34b3d89c2321707873cd))
+
+
+### Bug Fixes
+
+* **pr:** drive rendered markdown outside doc folders in carry rule ([#2808](https://github.com/erclx/canon/issues/2808)) ([c1f1582](https://github.com/erclx/canon/commit/c1f1582b284eb25ed359915223e52182af073d97))
+
 ## [5.71.0](https://github.com/erclx/canon/compare/v5.70.0...v5.71.0) (2026-10-27)
 
 

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "canon",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
-  "version": "5.71.0",
+  "version": "5.72.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/canon-feedback/REQUIREMENT.md

@@ -14,7 +14,7 @@ Asked to report, a session also starts diagnosing, which spends the context the
 ## Must
 
 - Build the report from what the session already holds, name the surface and its type, and write the stated fallback for a field it cannot fill
-- Carry the whole request in the issue body alone, since a body and a comment that differ leave triage choosing
+- Carry the whole request in the issue body, and what came after filing in a follow-up the CLI checks for links and for whether the fix still holds, never a hand-written comment
 - Open a GitHub issue on the toolkit repository through the CLI and print the returned URL on its own line
 - Surface the block and the reason when the issue call fails or the CLI is absent, so the report still exists
 - Hold a report the operator marks sensitive, since the issue is public

package/claude/skills/canon-feedback/SKILL.md

@@ -17,6 +17,19 @@ Format a `## Toolkit feedback` block from the current session, then open it as a
 
 ## Step 1: build the block
 
+### A follow-up or a new issue
+
+Pick the form before filling any field, from what the session already holds.
+
+- A follow-up, when the session cites an open feedback issue and the new case sits on its surface, such as a fix landing elsewhere, a second instance, or a finding that overturns the proposed fix
+- A new issue, when no feedback issue is cited or the case sits on a different surface
+
+For a follow-up, fill the `## Toolkit feedback follow-up` block in `${CLAUDE_SKILL_DIR}/references/template.md` and go to Step 2. For a new issue, build the report below.
+
+A follow-up carries `### Observed`, `### Changes the fix`, and `### Links`, and the CLI refuses one missing any of them. `### Changes the fix` opens with yes or no, since a yes tells triage the body's fix no longer stands. `### Links` holds at least one URL or issue reference such as `frameboard#156`, never a bare name.
+
+### The report fields
+
 From the conversation so far, identify:
 
 - Target project name or kind, never its path, which names one machine's folder and nothing triage routes on. Name a private project by kind, such as `a Next.js app`, since reports leave the machine.
@@ -56,7 +69,7 @@ Keep Observed and Expected to one or two lines each, so the report scans. Length
 
 A GitHub issue form renders a submitted field as `### <label>`, so one shape reaches the toolkit whichever route a report takes, and the CLI parses both with one parser. The retired `**Surface:**` form is refused, so a block carrying it has to be rewritten.
 
-The issue body is the request. Put everything the toolkit needs to act on it there, since a comment is easy to miss and a body and a comment that differ leave triage choosing. A comment carries only what happens after filing.
+The issue body is the request. Put everything the toolkit needs to act on it there, since a comment is easy to miss and a body and a comment that differ leave triage choosing. A comment carries only what happens after filing, and goes out as a follow-up through `canon feedback --on`, never a hand-written `gh issue comment`.
 
 ## Step 2: ship to the toolkit
 
@@ -78,14 +91,25 @@ cat <<'EOF' | canon feedback
 EOF
 ```
 
+A follow-up pipes the same way with the issue number, and the CLI refuses a closed issue or one without the `feedback` label before posting anything:
+
+```bash
+cat <<'EOF' | canon feedback --on <issue>
+## Toolkit feedback follow-up
+
+...
+EOF
+```
+
 The CLI opens a GitHub issue on the toolkit repo, labeled `feedback` and each domain label the surface type names, such as `skills` for a plugin skill, and prints the issue URL for this skill to report on its own line. It needs `gh` authenticated, and `git-issue` is not the route, since it files on the current repository.
 
 ### Reading the outcome
 
 Read the outcome off stdout, never off the exit code, since a shell wrapper can flatten it. Stdout takes one of three shapes:
 
-- A line opening with `https://` is the filed issue. Report the URL.
+- A line opening with `https://` is the filed issue, or the posted comment for a follow-up. Report the URL.
 - A block opening with `## Toolkit feedback` is a failed call. Show it in chat with the stderr reason and `📋 Paste this into an issue at https://github.com/erclx/canon/issues/new`.
+- The same block on a follow-up is a failed comment. Show it the same way, pointing the paste line at the issue's own URL.
 - Empty stdout is a refusal. Step 3 says how to repair it from stderr.
 
 If `canon` is not on PATH, fall back: print the block in chat and tell the user `📋 Copy the block above into a toolkit-repo session.`
@@ -95,4 +119,5 @@ If `canon` is not on PATH, fall back: print the block in chat and tell the user
 A report that was not filed reads one of two ways on stdout, and stderr carries the reason in both:
 
 - Empty stdout, with a named missing field on stderr. Add that heading with a real value or its stated fallback, then re-run. Do not report the defect as filed.
+- Empty stdout on a follow-up naming a field, an unreadable number, a closed issue, or a missing label. Repair the field or number, or file a new issue for a closed or unlabeled one.
 - The block on stdout, with `gh` absent or its call failed on stderr, which names which, since the two repairs differ. Show the block in chat with the reason and the paste line from Step 2.

package/claude/skills/canon-feedback/references/template.md

@@ -51,3 +51,25 @@ Step 1 of `canon-feedback`. The session reads this file on reaching the point wh
 
 <one link per line>
 ```
+
+## Follow-up block
+
+Step 1 fills this block instead of the report when the new case sits on an open feedback issue's surface, and Step 2 pipes it to `canon feedback --on <issue>`.
+
+```markdown
+## Toolkit feedback follow-up
+
+### Observed
+
+<one or two lines on what happened after filing>
+
+### Changes the fix
+
+<yes or no, then one line on what replaces the proposed fix when yes>
+
+### Links
+
+<one URL or issue reference per line, such as frameboard#156>
+```
+
+Keep Observed to one or two lines, as in the report. The CLI checks the fields and their openings but not their length, so the density is this template's rule alone.

package/claude/skills/plan-intake-answer/REQUIREMENT.md

@@ -15,15 +15,16 @@ The write fails where no prose rule catches it. A worker's file-editing tools re
 
 - Offer every item with an empty slot, batched by cluster in the folder's numbering and capped at four items, so a stop leaves whole clusters unread
 - Open each question with a lead-in an operator who has not opened the file can follow, then rank the item's own suggestion first and give every option its cost
-- Land each selection through a verb that resolves the root in-process and rewrites the whole line, one cluster per call
-- Pass the cluster and the label exactly as the heading spells them, letter suffix included
+- Land each selection through a verb that resolves the root in-process and rewrites the whole line, one cluster per call, with the label as the heading spells it
 - Report what stays unread by count after each cluster, and stop when there is no folder or no unread item
+- Offer to close the issue an item headed `(#NNN)` names once its answer begins `decline`, with the drafted comment shown first, so closing takes one word
 
 ## Must not
 
 - Fill a slot the operator did not answer, or infer an answer from the conversation having happened
 - Overwrite a slot already carrying an answer
-- Write anywhere but an item's answer slot, the index included
+- Write anywhere but an item's answer slot, the index included, bar one exception, which is closing a declined item's issue on GitHub after a yes given for that issue in the turn its draft was shown
+- Close an issue when the operator says no to the offer, gives no answer, or when the only yes came from another issue
 
 ## Out of scope
 

package/claude/skills/plan-intake-answer/SKILL.md

@@ -21,7 +21,7 @@ Read `${CLAUDE_SKILL_DIR}/../plan-intake/references/intake.md` before writing an
 - If the named folder has no unread item, stop: `❌ Every item in <slug> carries an answer. Nothing to ask.`
 - Never fill a slot the operator did not answer. An abandoned batch leaves every unreached item unread, which is what the empty slot already means.
 - Never infer an answer from the conversation having happened. A selection reaches the file through the verb or not at all.
-- Do not promote an item, edit a verdict, or write outside the answer slots. Promoting runs through `task-board` after the answers land.
+- Do not promote an item, edit a verdict, or write outside the answer slots, bar the close Step 5 offers on an explicit yes. Promoting runs through `task-board` after the answers land.
 
 ## Step 1: pick the folder
 
@@ -72,7 +72,37 @@ canon intake answer <slug> --cluster <file> --set <label>=<answer> --set <label>
 
 The verb refuses the whole batch when any item in it already carries an answer, since a filled slot is a decision already made. On that refusal, drop the named item and send the rest.
 
-## Step 5: continue or stop
+## Step 5: offer to close declined issues
+
+Run this after Step 4 lands a cluster, over the items that batch just answered. Closing is a public write, so each close waits on a yes given for that issue.
+
+An item qualifies when both hold:
+
+- The answer's first word is `decline`. Whatever follows it, as in `decline, but ask frameboard first`, stays on the item and still qualifies.
+- The title ends in `(#NNN)`. Read that trailing number alone, so a title naming two issues, or a number sitting in prose, gets no offer.
+
+Skip the whole step and say why when `gh auth status` fails or `gh` is absent. The answers already landed stay.
+
+For each qualifying item:
+
+1. Run `gh issue view <NNN> --json state --jq .state`. When it reads `CLOSED`, name the issue as already closed and offer nothing.
+2. Draft the comment as one or two sentences condensed from the item's `problem` and `fix`, giving the reason and a pointer to what covers it.
+3. Run the scan in `${CLAUDE_SKILL_DIR}/../git-pr/references/publish.md` against the draft, since nothing else checks text on its way to the remote.
+4. Show the draft and ask for a yes or no on that issue in the same turn, through the question surface Step 3 used.
+5. On a yes, close with the draft passed through a quoted heredoc. On a no, or no answer, leave the issue open.
+
+```bash
+gh issue close <NNN> --reason "not planned" --comment "$(cat <<'EOF'
+<comment>
+EOF
+)"
+```
+
+The quoted heredoc matters because `problem` and `fix` carry file paths in code spans. Inside a double-quoted argument the shell would run each backtick pair as a command and post a comment with the paths missing.
+
+Never carry a yes from one issue or one turn to another.
+
+## Step 6: continue or stop
 
 After each cluster, state how many clusters still carry unread items and continue to the next. Stop when the operator says to stop, and report what is left rather than pressing on.
 
@@ -85,10 +115,13 @@ Report per cluster as it lands, then close with the folder's state:
 ```plaintext
 ✅ <N> answered in <file>
 <label>. <answer>
+🔒 Closed #<NNN>, or left open: #<NNN>
 
 📋 <N> cluster(s) still carrying unread items in <slug>
 ```
 
+Omit the 🔒 line for a cluster that offered no close.
+
 Close the run with the path so the reader can open what changed:
 
 ```plaintext

package/claude/skills/review-ui/SKILL.md

@@ -26,7 +26,7 @@ A pass stops rather than repeat a verdict that already covers the head.
 - An open verdict at the head stops the same way, unless a `## Review response` or `## Post-review findings` comment is newer, the launch names an address, or it drove no box, as `post.md` defines
 - The hosted preview was not built from the head: stop and post nothing, naming `built`, `tip`, and `canon pr preview <number> --json` for the dispatcher
 - Post, then run `canon pr lift <number>` on a close. Never merge or ready the PR by hand, and edit the evidence comment only through `canon pr tick`.
-- A push after a close owes a re-drive only when it changed a painted path, since the lift carries the close across the rest.
+- A push after a close owes a re-drive unless every path it changed is inert, the list `references/tick.md` gives, since the lift carries the close across those alone.
 
 ## Step 1: resolve the pull request
 

package/claude/skills/review-ui/references/tick.md

@@ -1,6 +1,6 @@
 ---
 title: Tick the passed boxes
-description: Step 8 of review-ui, which ticks each box that passed through canon pr tick once the verdict has posted, and reports a stale head instead of retrying
+description: Step 8 of review-ui, which ticks each box that passed through canon pr tick once the verdict has posted, and reports an owed re-drive or a stale head instead of retrying
 ---
 
 # Tick the passed boxes
@@ -15,14 +15,26 @@ canon pr tick <number> --boxes <n,...> --head <head> --json
 
 Number the boxes off the `boxes` field Step 2 kept. Leave a box that failed, needs eyes, or was not driven empty.
 
-The verb refuses a taste box and a head that is no longer the remote tip, writing nothing in either case. Branch on the record's `reason`, which reads `ticked` on success.
+## When the tip moved
+
+A push that landed while this pass drove carries the ticks to the tip when it changed only paths no box observes. The record then reads `ticked` with the head it came from in `carriedFrom`.
+
+- Tests, stories, snapshots, evidence captures, and `canon/design/` carry.
+- Markdown carries only in the root and under `canon/`, `.claude/`, `.github/`, and `docs/`.
+- Markdown anywhere else, such as a page a stack renders, is driven.
+
+The verb refuses a taste box and a head the tip moved past in any other way, writing nothing in either case. Branch on the record's `reason`.
 
 - `count-mismatch`: nothing was written. With `ticked` below `passed`, re-run once with every passed box. With it above, a box ticked earlier has failed, so report it on `Ticks:` for the operator.
-- `stale-head`: a push landed while this pass drove. Report it on the `Ticks:` line of Step 10 and never retry at the new tip, since the boxes were driven at the old one.
+- `redrive-owed`: a push since `<head>` changed a path a box can observe. Report `driven`, `head`, and `drivenPaths` on the `Ticks:` line of Step 10, and never retry at the tip.
+- `stale-head`: the driven head was rewritten away, by a force-push or a rebase, or the gap could not be read. Report it on the `Ticks:` line and never retry at the new tip.
 - `body-refused`: the comment is ticked and the body is not. Retry the same call once, then report the partial result on the `Ticks:` line rather than claiming both.
 - Any other refusal: report the `reason` on the `Ticks:` line and tick nothing further.
-- A binary whose `canon pr` lacks `tick` predates the verb. Report that on the `Ticks:` line and tick nothing.
 
-The record's `countCheck` reads `matched` when the verdict's passed count agreed with the ticks, and `unchecked` when the verdict did not cover the head or carried no count line. Report an `unchecked` on the `Ticks:` line.
+A binary whose `canon pr` lacks `tick` predates the verb. Report that on the `Ticks:` line and tick nothing.
+
+## What a tick reports
+
+The record's `countCheck` reads `matched` when the verdict's passed count agreed with the ticks, and `unchecked` when the verdict covered neither the tip nor the head a carry came from, or carried no count line. Report an `unchecked` on the `Ticks:` line.
 
 The same call also writes the one UI pass line in the body's `## Testing`, such as `UI pass, 17 of 17 boxes passed at <sha>, 1 taste box left to the operator`, so the operator sees the result without opening the evidence comment. Never edit that line by hand.

package/claude/skills/role-orchestrator/scripts/poll.ts

@@ -200,7 +200,7 @@ export const scopeFallback = (payload: Payload, now: number): Scope => {
 
 /**
  * Reads the UI family off the verb's record, so the poll and the lift agree on
- * which head a close covers, a close carried across unpainted pushes included.
+ * which head a close covers, a close carried across inert pushes included.
  * A record carrying no `ui` object is a refusal or a CLI predating the field,
  * and reads as unread, which leaves the baseline's value standing.
  */

package/claude/skills/role-reviewer/SKILL.md

@@ -74,6 +74,10 @@ Run `canon pr lift <number> --json` after posting `## Review closed` or `## UI r
 
 Skip that message when the reason names the other review as open or missing, since the other reviewer's close runs the verb again.
 
+### A re-drive owed
+
+Message the controller when `canon pr tick` refuses `redrive-owed`, naming the driven commit, the tip in `head`, and the `drivenPaths`. A push the boxes can observe landed after the pass drove, so the next UI pass is a dispatch only the controller orders.
+
 ### Every other message
 
 The rest of the channel is what this session never sends.

package/claude/skills/ui-film/references/pr-clip.md

@@ -30,13 +30,37 @@ The mode holds only while the caller names it. An ordinary run that finds a pull
 
 ## Choose the beats
 
-Take a beat from each checklist box that asks the reviewer to click, fill, or scroll something, in checklist order, up to three beats.
+Film where motion is the claim. Filter the boxes first, then spend the three beats so each feature area shows its change once before any area shows two.
+
+### Filter the boxes
+
+A box is filmable when it asks the reviewer to click, fill, or scroll something and its result is a visible change.
 
 - Skip a box ending in `(taste)`, since no driver judges it
 - Skip a box that asks only to look at a state the page opens on, since a screenshot already shows it
+- Skip a negative box, one asserting that something does not happen, such as "no drop line draws", since footage of nothing shows nothing
+
+Read the box's text for the negative. A box asserting an unchanged result, such as "the board goes to all projects as before", is not negative, since the action still produces a visible change. Rank it behind a box in the same group that names new behavior.
+
+### Order the beats
+
+A group is the bold feature-area label above at most five boxes, as `ui-checklist` defines it.
+
+1. Take one beat per group in checklist order, from the highest-ranked filmable box of each group, up to three beats.
+2. When beats remain after every group has one, take a second pass in checklist order over the boxes left, highest-ranked first within each group, up to three beats in all.
+
+A checklist with one group gives up to three beats from it. A checklist with four groups gives three beats, one from each of the first three.
+
+### Plan the beats
+
+Write one plan entry for each beat chosen, then skip when none was.
+
 - Name each beat after its box's text, cut to the action
 - Write the plan per `${CLAUDE_SKILL_DIR}/references/take-craft.md`, finding each target on the served page rather than guessing it
-- With no box left, skip as `no-interactive-box` and film nothing
+- With no interactive box, skip as `no-interactive-box` and film nothing
+- With interactive boxes that the filter removed, whether negative, static, or marked `(taste)`, skip as `no-visible-change` and film nothing
+
+The negative test is a judgment over the box's text. A misread box costs a weaker reel and never a wrong pass, since the still check below guards the footage and the UI reviewer drives every box regardless.
 
 Keep the whole reel at or under 12 seconds. Each beat opens and closes on a 0.6 s hold, so give each action's `wait` only what its result needs to settle.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "5.71.0",
+  "version": "5.72.1",
   "description": "Runs your agent's work and keeps its code good, on one setup for every repo.",
   "license": "MIT",
   "bin": {

package/src/commands/feedback.ts

@@ -2,11 +2,20 @@ import { Option, type Command } from 'commander'
 import {
   deriveDomainLabels,
   deriveTitle,
+  followUpProblem,
   missingField,
   missingFieldMessage,
 } from '@/feedback/body'
-import { createGithubIssue } from '@/feedback/github'
-import { issueFailureMessage } from '@/feedback/github-format'
+import {
+  createGithubIssue,
+  postIssueComment,
+  readFeedbackIssue,
+} from '@/feedback/github'
+import {
+  commentFailureMessage,
+  issueFailureMessage,
+  issueReadFailureMessage,
+} from '@/feedback/github-format'
 import { frameError, frameSuccess } from '@/cli/ui'
 
 function readStdin(): Promise<string> {
@@ -20,6 +29,61 @@ function readStdin(): Promise<string> {
   })
 }
 
+/**
+ * Triage lists open `feedback` issues only, so a comment anywhere else is
+ * never read. Both checks run before the post, since a public comment cannot
+ * be taken back by a later refusal.
+ */
+async function postFollowUp(issue: number, body: string): Promise<void> {
+  const problem = followUpProblem(body)
+  if (problem) {
+    frameError(problem)
+    process.exitCode = 1
+    return
+  }
+
+  // An absent gh can post nothing, so the block goes out for a hand paste. A
+  // failed read is a refusal to repair, since the number may name no issue.
+  const read = await readFeedbackIssue(issue)
+  if (!read.ok && read.reason === 'missing-binary') {
+    frameError(commentFailureMessage(read, issue))
+    process.stdout.write(`${body}\n`)
+    process.exitCode = 1
+    return
+  }
+  if (!read.ok) {
+    frameError(issueReadFailureMessage(read, issue))
+    process.exitCode = 1
+    return
+  }
+  if (read.state !== 'OPEN') {
+    frameError(
+      `Issue #${issue} is ${read.state.toLowerCase()}, and triage reads open feedback issues only. File a new report instead.`,
+    )
+    process.exitCode = 1
+    return
+  }
+  if (!read.labels.includes('feedback')) {
+    frameError(
+      `Issue #${issue} carries no feedback label, so it is not a toolkit feedback report. Check the number and re-run.`,
+    )
+    process.exitCode = 1
+    return
+  }
+
+  const result = await postIssueComment(issue, body)
+  if (result.ok) {
+    frameSuccess('canon feedback', result.url)
+    process.stdout.write(`${result.url}\n`)
+    return
+  }
+  frameError(commentFailureMessage(result, issue))
+  process.stdout.write(`${body}\n`)
+  process.exitCode = 1
+}
+
+const ISSUE_NUMBER = /^[1-9]\d*$/
+
 export function register(program: Command): void {
   program
     .command('feedback')
@@ -27,10 +91,21 @@ export function register(program: Command): void {
     .description(
       'Open a GitHub issue on the toolkit repo from a feedback block on stdin',
     )
+    .option(
+      '--on <issue>',
+      'Post a follow-up block as a comment on an open feedback issue instead',
+    )
     // A cached plugin still pipes `--github`, and commander rejects an unknown
     // option, so the flag stays accepted and hidden for one release.
     .addOption(new Option('--github').hideHelp())
-    .action(async () => {
+    .action(async (opts: { on?: string }) => {
+      if (opts.on !== undefined && !ISSUE_NUMBER.test(opts.on)) {
+        frameError(
+          `--on takes an issue number, such as --on 2801, not "${opts.on}".`,
+        )
+        process.exitCode = 1
+        return
+      }
       if (process.stdin.isTTY) {
         frameError(
           'No feedback on stdin. Pipe a markdown block: pbpaste | canon feedback',
@@ -45,6 +120,11 @@ export function register(program: Command): void {
         return
       }
 
+      if (opts.on !== undefined) {
+        await postFollowUp(Number(opts.on), body)
+        return
+      }
+
       // A report missing its surface is no more useful in the tracker than
       // anywhere else, so validation runs before any `gh` call.
       const absent = missingField(body)

package/src/commands/pr.ts

@@ -98,6 +98,7 @@ import {
 } from '@/git/status'
 import { machineListenerReader } from '@/listeners/machine'
 import { loadPaintedPatterns } from '@/pr/painted'
+import { readCarry } from '@/pr/carry'
 import { LOCAL_CONFIG_REL, readHealthPaths } from '@/pr/health'
 import {
   dropAddressLine,
@@ -228,6 +229,7 @@ type TickReason =
   | TickRefusal
   | 'count-mismatch'
   | 'stale-head'
+  | 'redrive-owed'
   | 'bad-boxes'
   | 'no-comment'
   | 'body-refused'
@@ -236,7 +238,9 @@ const TICK_REFUSALS: Record<TickReason | 'gh-failed', string> = {
   'body-refused':
     'The boxes are ticked on the evidence comment, but gh could not edit the pull request body, so its UI pass line still shows the earlier result. Re-run the tick to retry the body.',
   'stale-head':
-    'The head named is not the branch tip on the remote, so a tick would claim a pass on a commit that is no longer the pull request. Re-drive the checklist at the tip.',
+    'The head named is not the branch tip on the remote, and the tip does not descend from it or the gap could not be read, so a tick would claim a pass on a commit that is no longer the pull request. Re-drive the checklist at the tip.',
+  'redrive-owed':
+    'A push since the driven head changed a path a box can observe, so the pass does not carry to the tip. Nothing was written. Re-drive the checklist at the tip rather than retrying the tick there.',
   'bad-boxes':
     '--boxes takes box numbers as a comma-separated list of positive whole numbers, such as 1,3, and --head takes the commit that was driven.',
   'count-mismatch':
@@ -700,8 +704,9 @@ export function register(program: Command): void {
         '',
         '`ui` also carries the newest `## UI review` pass (`heading`, `state`,',
         '`commit`, `source`), `isBound`, which is whether the evidence comment',
-        'carries a checklist, and `carriedFrom` or `paintedPaths` when the lift',
-        'carried a close forward or refused to. An unbound family reads covered.',
+        'carries a checklist, and `carriedFrom` when the lift carried a close',
+        'forward, or `drivenPaths` and the painted subset `paintedPaths` when it',
+        'refused to. An unbound family reads covered.',
         '',
         'Both families post as pull request reviews, so this reads',
         '`pulls/<n>/reviews` alone, as the lift does. Issue comments are not',
@@ -944,11 +949,15 @@ export function register(program: Command): void {
         '  ui        the newest `## UI review` is closed at the head, bound only',
         '            where `canon pr evidence --check` carries a checklist. A close',
         '            on an earlier commit still holds when it is an ancestor of the',
-        '            head and no painted path changed since, and the record names',
-        '            it as `carriedFrom`. A painted change refuses `ui-behind` and',
-        '            lists the paths as `paintedPaths`. A close whose count line',
-        '            shows boxes not driven and none passed, failed, or needing',
-        '            eyes refuses `ui-undriven`, carried or not',
+        '            head and every path changed since is one no box can observe,',
+        '            being tests, stories, snapshots, markdown in the root and in',
+        '            `canon/`, `.claude/`, `.github/`, and `docs/`, evidence captures,',
+        '            and `canon/design/`, and the record names it as `carriedFrom`.',
+        '            Any other change refuses `ui-behind`, listing the paths as',
+        '            `drivenPaths` and the painted subset as `paintedPaths`, since',
+        '            a box drives behavior a `.ts` file holds too. A close whose',
+        '            count line shows boxes not driven and none passed, failed,',
+        '            or needing eyes refuses `ui-undriven`, carried or not',
         '  evidence  the evidence check reads settled',
         '  standing  the head is fresh against the base, not stale or conflicted',
         '  ci        every check run on the tip passed, waited on up to --wait',
@@ -1295,14 +1304,23 @@ export function register(program: Command): void {
         'driver can run is ticked, counts taste boxes apart, and is the only',
         'body text this verb writes, so hand edits elsewhere survive.',
         '',
-        'Before writing it reads the newest UI verdict. One that covers the tip',
-        'and carries a count line must match the ticks this call leaves at the',
-        'tip, so a re-drive passes every box that passed, since a new head',
-        'clears the older ticks. Any other verdict leaves the check unrun.',
+        'A --head behind the remote tip carries to the tip when every path',
+        'changed since is one no box can observe, being tests, stories,',
+        'snapshots, markdown in the root and in `canon/`, `.claude/`,',
+        '`.github/`, and `docs/`, evidence captures, and `canon/design/`. The',
+        'boxes are then stamped at the tip and the record names `carriedFrom`.',
+        'Any other changed path, markdown elsewhere included, owes a re-drive.',
+        '',
+        'Before writing it reads the newest UI verdict. One that covers the tip,',
+        'or the driven head on a carry, and carries a count line must match the',
+        'ticks this call leaves at the tip, so a re-drive passes every box that',
+        'passed, since a new head clears the older ticks. Any other verdict',
+        'leaves the check unrun.',
         '',
         'Read `reason` on the JSON record:',
         '  ticked       the boxes were ticked and the body line written, with the',
-        '               tip in `head` and `countCheck` as matched or unchecked',
+        '               tip in `head`, `countCheck` as matched or unchecked, and',
+        '               `carriedFrom` when --head was carried to the tip',
         '  count-mismatch the verdict passed a different number of boxes than',
         '               this call leaves ticked at the tip, nothing written,',
         '               `passed` and `ticked` carry the two counts. Fewer ticks',
@@ -1310,7 +1328,10 @@ export function register(program: Command): void {
         '               operator an untick of a box that has since failed',
         '  body-refused the comment is ticked but gh could not edit the body,',
         '               exit 1 with `commentTicked`. Re-run to retry the body.',
-        '  stale-head   --head is not the remote branch tip, nothing written',
+        '  redrive-owed a push since --head changed a path a box can observe,',
+        '               nothing written, with `driven`, `head`, and `drivenPaths`',
+        '  stale-head   --head is behind the tip with no readable linear gap,',
+        '               as a force-push or a rebase leaves, nothing written',
         '  taste-box    a named box ends in (taste), nothing written',
         '  no-box       a named number is past the checklist, nothing written',
         '  no-checklist the evidence comment carries no checklist',
@@ -3475,9 +3496,9 @@ const POSITIVE_WHOLE = /^[1-9]\d*$/
 const MIN_TICK_HEAD_LENGTH = 7
 
 /**
- * Ticks the named boxes on the marked comment. It refuses a head that is not
- * the remote tip and a taste box before writing, so both rules hold as checks
- * rather than as prose a driver can talk itself out of.
+ * Ticks the named boxes on the marked comment. It refuses a head the tip moved
+ * past in a way a box can observe, and a taste box, before writing, so both
+ * rules hold as checks rather than as prose a driver can talk itself out of.
  */
 async function runTick(
   number: string | undefined,
@@ -3518,7 +3539,26 @@ async function runTick(
       root,
     )
   }
-  if (!reading.tip.startsWith(head)) return refuseTick('stale-head')
+  const carry = await readCarry(
+    (from, to) => readChangedPaths(gitRunner(root), from, to),
+    head,
+    reading.tip,
+  )
+  if (carry.kind === 'moved') {
+    return refuseWith(
+      'redrive-owed',
+      TICK_REFUSALS['redrive-owed'],
+      emitJson,
+      root,
+      { driven: head, head: reading.tip, drivenPaths: carry.drivenPaths },
+    )
+  }
+  // A gap that could not be read refuses as a rewrite does, which is what the
+  // verb answered for every moved tip before the carry.
+  if (carry.kind === 'not-ancestor' || carry.kind === 'failed') {
+    return refuseTick('stale-head')
+  }
+  const carriedFrom = carry.kind === 'carried' ? carry.carriedFrom : undefined
 
   const comments = await listComments(root, String(identity.number))
   if (comments === undefined) return refuseTick('gh-failed')
@@ -3534,8 +3574,9 @@ async function runTick(
   if (result.kind === 'refused') return refuseTick(result.reason)
 
   // Read ahead of the write so a short list refuses before it leaves the
-  // comment half ticked. A verdict that does not cover the tip, carries no
-  // count line, or cannot be read leaves the check unrun and says so.
+  // comment half ticked. A verdict that covers neither the tip nor the head a
+  // carry came from, carries no count line, or cannot be read leaves the check
+  // unrun and says so.
   const ticked = countTicksAtHead(
     readChecklistBoxes(findEvidenceChecklist([{ body: result.body }]) ?? ''),
     reading.tip,
@@ -3547,7 +3588,10 @@ async function runTick(
   const isCounted =
     verdict.counts !== undefined &&
     verdict.commit !== undefined &&
-    coversHead(verdict.commit, reading.tip)
+    (coversHead(verdict.commit, reading.tip) ||
+      (carriedFrom !== undefined &&
+        (coversHead(verdict.commit, carriedFrom) ||
+          coversHead(carriedFrom, verdict.commit))))
   if (isCounted && verdict.counts.passed !== ticked) {
     return refuseWith(
       'count-mismatch',
@@ -3622,6 +3666,7 @@ async function runTick(
         reason: 'ticked',
         countCheck,
         head: reading.tip,
+        ...(carriedFrom !== undefined && { carriedFrom }),
         boxes: numbers.map(Number),
         commentId,
       })}\n`,

package/src/feedback/body.ts

@@ -94,6 +94,56 @@ export function missingFieldMessage(field: string): string {
   return `Feedback report is missing its "### ${field}" section. Every report needs ${REQUIRED_FIELDS.map((name) => `### ${name}`).join(', ')}.`
 }
 
+/**
+ * The fields a follow-up comment carries. A follow-up reports what happened
+ * after filing, so it names no surface and proposes no fix of its own. It says
+ * whether the body's fix still stands, since triage reads the body as the
+ * request and a silent overturn leaves it acting on the old one.
+ */
+export const FOLLOW_UP_FIELDS = [
+  'Observed',
+  'Changes the fix',
+  'Links',
+] as const
+
+const YES_OR_NO = /^(?:yes|no)\b/i
+
+/**
+ * A URL, or an issue reference such as `#2801`, `frameboard#156`, or
+ * `erclx/canon#2801`. A bare name is what the hand-written follow-up carried,
+ * and nothing a reader can open from it.
+ */
+const REFERENCE = /https?:\/\/\S+|(?:^|[\s(])(?:[\w.-]+\/)?[\w.-]*#\d+\b/
+
+export function missingFollowUpField(body: string): string | undefined {
+  const sections = parseSections(body)
+  for (const field of FOLLOW_UP_FIELDS) {
+    const value = sections.get(field.toLowerCase())
+    if (!value) return field
+  }
+  return undefined
+}
+
+/**
+ * The sentence a refused follow-up reads, or `undefined` when it carries every
+ * field in a checkable shape. One problem at a time, as `missingField` does.
+ */
+export function followUpProblem(body: string): string | undefined {
+  const absent = missingFollowUpField(body)
+  if (absent) {
+    return `Follow-up is missing its "### ${absent}" section. Every follow-up needs ${FOLLOW_UP_FIELDS.map((name) => `### ${name}`).join(', ')}.`
+  }
+  const changes = readField(body, 'Changes the fix') ?? ''
+  if (!YES_OR_NO.test(changes)) {
+    return 'Follow-up "### Changes the fix" must open with yes or no, so triage can tell whether the issue body still holds.'
+  }
+  const links = readField(body, 'Links') ?? ''
+  if (!REFERENCE.test(links)) {
+    return 'Follow-up "### Links" carries no URL or issue reference. Write each as a URL or as owner/repo#number.'
+  }
+  return undefined
+}
+
 function surfaceField(body: string): string | undefined {
   return readField(body, 'Surface')?.split('\n')[0]?.trim()
 }

package/src/feedback/github-format.ts

@@ -37,6 +37,61 @@ export function buildIssueArgs(opts: CreateIssueOptions): string[] {
   return args
 }
 
+export function buildCommentArgs(issue: number, body: string): string[] {
+  return ['issue', 'comment', String(issue), '--body', body, '--repo', REPO]
+}
+
+export function buildIssueReadArgs(issue: number): string[] {
+  return [
+    'issue',
+    'view',
+    String(issue),
+    '--json',
+    'state,labels',
+    '--repo',
+    REPO,
+  ]
+}
+
+export interface IssueRead {
+  readonly ok: true
+  readonly state: string
+  readonly labels: readonly string[]
+}
+
+/**
+ * Reads the `gh issue view --json state,labels` record. A record of any other
+ * shape is a failed read rather than an issue with no labels, since the caller
+ * refuses on a missing label and that refusal would then name the wrong cause.
+ */
+export function parseIssueRead(stdout: string): IssueRead | IssueFailure {
+  let record: unknown
+  try {
+    record = JSON.parse(stdout)
+  } catch {
+    return {
+      ok: false,
+      reason: 'command-failed',
+      detail: 'gh printed no JSON issue record',
+    }
+  }
+  const { state, labels } = (record ?? {}) as {
+    state?: unknown
+    labels?: unknown
+  }
+  if (typeof state !== 'string' || !Array.isArray(labels)) {
+    return {
+      ok: false,
+      reason: 'command-failed',
+      detail: 'gh printed an issue record with no state or labels',
+    }
+  }
+  const names = labels
+    .map((label: unknown) => (label as { name?: unknown } | null)?.name)
+    .filter((name): name is string => typeof name === 'string')
+  return { ok: true, state, labels: names }
+}
+
 /**
  * Collapses to one line. Both callers write the detail inside a framed error or
  * a colored warning, and a newline in the middle of either breaks the frame and
@@ -75,3 +130,25 @@ export function issueFailureMessage(failure: IssueFailure): string {
   }
   return `gh could not file the issue: ${failure.detail ?? 'no diagnostic on stderr'}. File it manually at ${ISSUE_URL} instead.`
 }
+
+export function commentFailureMessage(
+  failure: IssueFailure,
+  issue: number,
+): string {
+  const target = `https://github.com/${REPO}/issues/${issue}`
+  if (failure.reason === 'missing-binary') {
+    return `gh is not installed, so no follow-up was posted. Install gh, or comment at ${target}`
+  }
+  return `gh could not post the follow-up: ${failure.detail ?? 'no diagnostic on stderr'}. Comment manually at ${target} instead.`
+}
+
+/**
+ * A read that `gh` ran and failed is most often a number naming no issue, so
+ * the sentence asks for the number rather than pointing a paste at it.
+ */
+export function issueReadFailureMessage(
+  failure: IssueFailure,
+  issue: number,
+): string {
+  return `gh could not read issue #${issue}: ${failure.detail ?? 'no diagnostic on stderr'}. Check the number and re-run.`
+}

package/src/feedback/github.ts

@@ -2,34 +2,73 @@ import { execa } from 'execa'
 import { gitEnv } from '@/git/env'
 import { PROJECT_ROOT } from '@/roots/project'
 import {
+  buildCommentArgs,
   buildIssueArgs,
+  buildIssueReadArgs,
   failureDetail,
+  parseIssueRead,
   type CreateIssueOptions,
   type CreateIssueResult,
+  type IssueFailure,
+  type IssueRead,
 } from '@/feedback/github-format'
 
 const GH_TIMEOUT_MS = 30_000
 
-export async function createGithubIssue(
-  opts: CreateIssueOptions,
-): Promise<CreateIssueResult> {
+/**
+ * Runs `gh` and returns its trimmed stdout, or the failure the operator reads.
+ * See src/worktrees/reclaim.ts for why gh needs the stripped environment.
+ */
+async function runGh(
+  args: string[],
+): Promise<{ ok: true; stdout: string } | IssueFailure> {
   if (Bun.which('gh') === null) return { ok: false, reason: 'missing-binary' }
   try {
-    // See src/worktrees/reclaim.ts for why gh needs the stripped environment.
-    const result = await execa('gh', buildIssueArgs(opts), {
+    const result = await execa('gh', args, {
       cwd: PROJECT_ROOT,
       timeout: GH_TIMEOUT_MS,
       env: gitEnv(),
       extendEnv: false,
     })
-    const url = result.stdout.trim()
-    if (url) return { ok: true, url }
-    return {
-      ok: false,
-      reason: 'command-failed',
-      detail: 'gh exited zero and printed no issue URL',
-    }
+    return { ok: true, stdout: result.stdout.trim() }
   } catch (error) {
     return { ok: false, reason: 'command-failed', detail: failureDetail(error) }
   }
 }
+
+async function runForUrl(
+  args: string[],
+  emptyDetail: string,
+): Promise<CreateIssueResult> {
+  const result = await runGh(args)
+  if (!result.ok) return result
+  if (result.stdout) return { ok: true, url: result.stdout }
+  return { ok: false, reason: 'command-failed', detail: emptyDetail }
+}
+
+export function createGithubIssue(
+  opts: CreateIssueOptions,
+): Promise<CreateIssueResult> {
+  return runForUrl(
+    buildIssueArgs(opts),
+    'gh exited zero and printed no issue URL',
+  )
+}
+
+export async function readFeedbackIssue(
+  issue: number,
+): Promise<IssueRead | IssueFailure> {
+  const result = await runGh(buildIssueReadArgs(issue))
+  if (!result.ok) return result
+  return parseIssueRead(result.stdout)
+}
+
+export function postIssueComment(
+  issue: number,
+  body: string,
+): Promise<CreateIssueResult> {
+  return runForUrl(
+    buildCommentArgs(issue, body),
+    'gh exited zero and printed no comment URL',
+  )
+}

package/src/pr/carry.ts

@@ -0,0 +1,64 @@
+import { DESIGN_FOLDER, isEvidencePath } from '@/pr/evidence'
+import type { ChangedRead } from '@/pr/lift'
+import { DEFAULT_PAINTED } from '@/pr/painted'
+import { coversHead } from '@/pr/review-scope'
+
+/**
+ * The globs no checklist box can observe: tests, stories, snapshots, and
+ * markdown where a project keeps docs. The rule lists what is inert rather than
+ * what is driven, so a kind nobody listed, such as a `.json` data file, fails
+ * closed. Markdown elsewhere, such as an Astro page or content entry, renders,
+ * so it is driven like `.mdx`.
+ */
+export const DEFAULT_INERT: readonly string[] = [
+  ...DEFAULT_PAINTED.unpainted,
+  '*.md',
+  'canon/**/*.md',
+  '.claude/**/*.md',
+  '.github/**/*.md',
+  'docs/**/*.md',
+]
+
+/**
+ * An evidence capture and a design record are inert too, the two paths
+ * `readUncaptured` skips, since a recapture or a design note changes no
+ * behavior a box drives.
+ */
+export function isInert(path: string): boolean {
+  return (
+    isEvidencePath(path) ||
+    path.startsWith(DESIGN_FOLDER) ||
+    DEFAULT_INERT.some((glob) => new Bun.Glob(glob).match(path))
+  )
+}
+
+/** Whether a UI verdict at one commit still holds at a later one. */
+export type Carry =
+  | { readonly kind: 'covered' }
+  | { readonly kind: 'carried'; readonly carriedFrom: string }
+  | { readonly kind: 'moved'; readonly drivenPaths: readonly string[] }
+  | { readonly kind: 'not-ancestor' }
+  | { readonly kind: 'failed' }
+
+/**
+ * Carries a verdict driven at `from` to `to` only across a gap that changed
+ * nothing a box drives. A box drives behavior, which lives in any source file
+ * and not only in a painted one, so every path outside the inert set moves the
+ * verdict. A `from` that `to` does not descend from never carries.
+ */
+export async function readCarry(
+  readChanged: (from: string, to: string) => Promise<ChangedRead | undefined>,
+  from: string,
+  to: string,
+): Promise<Carry> {
+  if (coversHead(from, to)) return { kind: 'covered' }
+
+  const changed = await readChanged(from, to)
+  if (changed === undefined) return { kind: 'failed' }
+  if (!changed.isAncestor) return { kind: 'not-ancestor' }
+
+  const drivenPaths = changed.paths.filter((path) => !isInert(path))
+  return drivenPaths.length > 0
+    ? { kind: 'moved', drivenPaths }
+    : { kind: 'carried', carriedFrom: from }
+}

package/src/pr/evidence.ts

@@ -607,7 +607,7 @@ export function readOwed(input: OwedInput): OwedStep[] {
  * Design references are redrawn rather than captured, so recapturing them
  * neither owes nor stands in for an evidence capture.
  */
-const DESIGN_FOLDER = 'canon/design/'
+export const DESIGN_FOLDER = 'canon/design/'
 
 /**
  * The painted paths a pull request changed while no evidence image did, in a

package/src/pr/lift.ts

@@ -6,6 +6,7 @@ import {
   resolveUiScope,
   type UiCounts,
 } from '@/pr/review-scope'
+import { readCarry } from '@/pr/carry'
 import { DEFAULT_PAINTED, isPainted, type PaintedPatterns } from '@/pr/painted'
 
 /** How long `--wait` holds for a pending CI run, in seconds, when none is named. */
@@ -49,6 +50,8 @@ export interface GateResult {
   readonly carriedFrom?: string
   /** The painted paths that kept a UI close from carrying forward. */
   readonly paintedPaths?: readonly string[]
+  /** Every path a box can observe that kept a UI close from carrying forward. */
+  readonly drivenPaths?: readonly string[]
 }
 
 /** How an earlier commit sits against the head, and what changed since. */
@@ -125,6 +128,7 @@ export interface LiftRecord {
   readonly failed?: LiftRefusal
   readonly carriedFrom?: string
   readonly paintedPaths?: readonly string[]
+  readonly drivenPaths?: readonly string[]
   readonly isLifted: boolean
   /** Whether the caller can treat the pull request as ready afterwards. */
   readonly isOk: boolean
@@ -164,11 +168,13 @@ export function reviewGate(
 function carried(gates: readonly GateResult[]): {
   carriedFrom?: string
   paintedPaths?: readonly string[]
+  drivenPaths?: readonly string[]
 } {
   const ui = gates.find((gate) => gate.gate === 'ui')
   return {
     ...(ui?.carriedFrom !== undefined && { carriedFrom: ui.carriedFrom }),
     ...(ui?.paintedPaths !== undefined && { paintedPaths: ui.paintedPaths }),
+    ...(ui?.drivenPaths !== undefined && { drivenPaths: ui.drivenPaths }),
   }
 }
 
@@ -189,10 +195,11 @@ function droveNothing(counts: UiCounts | undefined): boolean {
 /**
  * Binds only where the evidence record carries a checklist to drive.
  *
- * A close behind the head still holds when it is an ancestor of the head and
- * no painted path changed since, since a push that paints nothing leaves the
- * checklist the reviewer drove as true as it was. A close that is not an
- * ancestor, which a force-push or a rebase leaves, never carries.
+ * A close behind the head still holds across the gap `readCarry` carries,
+ * one changing no path a box can observe. A box drives behavior, so a push to
+ * a non-painted source file moves the verdict too, and `drivenPaths` names
+ * every such path while `paintedPaths` keeps the painted subset. A close that
+ * is not an ancestor, which a force-push or a rebase leaves, never carries.
  */
 export async function uiGate(
   api: Pick<LiftApi, 'readChanged'>,
@@ -211,17 +218,27 @@ export async function uiGate(
   // Ahead of the head test so a close carried across commits is refused too.
   // A verdict whose count line did not parse reads as unchecked and goes on.
   if (droveNothing(scope.counts)) return fail('ui', 'ui-undriven')
-  if (coversHead(scope.commit, head)) return pass('ui')
 
-  const changed = await api.readChanged(scope.commit, head)
-  if (changed === undefined) return fail('ui', 'gh-failed')
-  if (!changed.isAncestor) return fail('ui', 'ui-behind')
+  const carry = await readCarry(
+    (from, to) => api.readChanged(from, to),
+    scope.commit,
+    head,
+  )
+  if (carry.kind === 'covered') return pass('ui')
+  if (carry.kind === 'failed') return fail('ui', 'gh-failed')
+  if (carry.kind === 'not-ancestor') return fail('ui', 'ui-behind')
+  if (carry.kind === 'carried') {
+    return { ...pass('ui'), carriedFrom: carry.carriedFrom }
+  }
 
-  const paintedPaths = changed.paths.filter((path) => isPainted(path, painted))
-  if (paintedPaths.length > 0) {
-    return { ...fail('ui', 'ui-behind'), paintedPaths }
+  const paintedPaths = carry.drivenPaths.filter((path) =>
+    isPainted(path, painted),
+  )
+  return {
+    ...fail('ui', 'ui-behind'),
+    ...(paintedPaths.length > 0 && { paintedPaths }),
+    drivenPaths: carry.drivenPaths,
   }
-  return { ...pass('ui'), carriedFrom: scope.commit }
 }
 
 function standingGate(standing: Standing): GateResult {

package/src/pr/review-state.ts

@@ -47,6 +47,7 @@ export interface UiState extends UiScope, FamilyState {
   readonly isBound: boolean
   readonly carriedFrom?: string
   readonly paintedPaths?: readonly string[]
+  readonly drivenPaths?: readonly string[]
 }
 
 export interface ReviewStateRecord {
@@ -119,6 +120,7 @@ async function readAt(
         isBound: hasChecklist,
         ...(ui.carriedFrom !== undefined && { carriedFrom: ui.carriedFrom }),
         ...(ui.paintedPaths !== undefined && { paintedPaths: ui.paintedPaths }),
+        ...(ui.drivenPaths !== undefined && { drivenPaths: ui.drivenPaths }),
       },
     },
   }