paneltir 0.8.0 → 0.10.0

package/CLAUDE_MD_SNIPPET.md

@@ -31,6 +31,13 @@ library shared with other projects. Rules:
   src/dashboard-theme.ts -->. Colour changes go there, never in the kit. The
   dashboard's **shape** is a `DashboardThemeForm` passed to the same provider
   (`panel` or `ledger`); it too is this project's choice, not the kit's.
+- **This project's theme goes to `PanelApp` as `extraThemes`, never as
+  `themes`.** `extraThemes` offers it alongside the four the kit ships;
+  `themes` means "exactly these and nothing else", so passing one theme there
+  deletes all four and the settings sheet ends up with a single row. That is
+  not hypothetical — it happened to two projects before the distinction
+  existed, and it looks like the kit having no themes rather than like a prop
+  being wrong.
 - **The panel's gate is this project's, not the library's.** `middleware.ts`,
   `lib/session.ts` and `api/login.ts` / `api/logout.ts` / `api/panel-state.ts`
   were copied here by `npx paneltir init`. They hold this project's password
@@ -38,12 +45,34 @@ library shared with other projects. Rules:
   change when the kit updates, and `paneltir init` will not overwrite them.
   The password, the GitHub token and the target repository are environment
   variables where this project is hosted — never in this repository.
+- **Those copied files do not update, so they have to be asked.** Run
+  `npx paneltir doctor` when the panel misbehaves for no visible reason: it
+  compares each copied file against the version installed now and separates
+  the three answers that need different actions — you edited it, the template
+  moved underneath you, or both. The second is the one no `git diff` can find,
+  because there is nothing in this project's history to diff against, and it is
+  how a fix released upstream stayed out of a project for two releases.
 - **The panel explains itself once.** New readers get a short guided tour the
-  first time they open the board; each note is dismissed and stays dismissed,
-  per browser. **Help** in the header reports what the panel needs — the
-  password, the GitHub token, the target repository — with what is missing and
-  the steps to fix it, asked from the server so it reports the truth rather
-  than a guess. "Show the guide again" in there brings the tour back.
+  first time they open the board; each note is dismissed and stays dismissed.
+  **Help** in the header reports what the panel needs — the password, the
+  GitHub token, the target repository — with what is missing and the steps to
+  fix it, asked from the server so it reports the truth rather than a guess.
+  "Show the guide again" in there brings the tour back.
+- **A panel nobody has used yet walks its own setup.** On a board with no
+  cards and no runs, the panel asks the server what is configured and, if
+  something is missing, opens a walkthrough that does one variable at a time
+  and checks each rather than asking anyone to tick it. Closing it is
+  remembered in this browser, because the board it would otherwise be written
+  to is the very thing that cannot be saved yet. On a board already in use it
+  is a banner instead — said before a save fails rather than after — and the
+  walkthrough waits behind **Help**. Its last screen carries the one thing no
+  screen can check for you: `/admin` and its bundle must both refuse a signed
+  out visitor.
+- **And it can hand the problem to Claude.** The walkthrough carries a line to
+  paste into a session in this repository. It names
+  `.claude/skills/panel/SKILL.md`, which `paneltir init` wrote, and that file
+  covers every variable the panel checks for — held together by a test, so the
+  prompt cannot come to point at a document that no longer answers it.
 - **Say which version the dashboard runs on.** `paneltirBuild.short` from
   `paneltir` renders as `vX.Y.Z · <first 12 of the fingerprint>`; keep it visible somewhere in
   the panel. `npx paneltir version` answers the same question from a terminal,

package/INSTALL.md

@@ -19,7 +19,7 @@ identity** — never another project's.
    npm install paneltir
 
    # or, without npm access, straight from the repository:
-   # npm install github:daifukus/paneltir#v0.8.0
+   # npm install github:daifukus/paneltir#v0.10.0
    ```
 
    (Use the tag you were given; never install without pinning a version.)
@@ -39,10 +39,11 @@ identity** — never another project's.
    not another project's theme.
 
 3. **If no palette is defined yet**, do not make up values: `paneltir` ships
-   base themes that are already designed and tested (`cyberpunkTheme`,
-   `midnightTheme`, `oldMoneyTheme`, all exported in `THEME_PRESETS`). Ask
-   which one fits the project best — and if the answer is not available right
-   now, use `midnightTheme`, the most neutral one, and say so explicitly.
+   base themes that are already designed and tested — `midnightTheme`,
+   `oldMoneyTheme`, `cyberpunkTheme` and `claudeTheme`, the only light one, all
+   exported in `THEME_PRESETS`. Ask which one fits the project best, and if the
+   answer is not available right now use `midnightTheme`, the most neutral one,
+   and say so explicitly.
    Store the decision in a new file (for example `src/dashboard-theme.ts`),
    re-exporting the chosen preset, or copying its values if they are expected
    to diverge:
@@ -138,18 +139,33 @@ identity** — never another project's.
    import 'paneltir/style.css'
    import { PanelApp } from 'paneltir'
    import board from './data/panel-state.json'
-
-   <PanelApp state={board} saveEndpoint="/admin/api/panel-state" showHistory />
+   import { dashboardTheme } from './dashboard-theme'
+
+   <PanelApp
+     state={board}
+     saveEndpoint="/admin/api/panel-state"
+     showHistory
+     // This project's identity, offered *alongside* the kit's presets. Use
+     // `extraThemes` and never `themes`: `themes` is the exact set, so passing
+     // one theme there deletes all four presets and the settings sheet ends up
+     // with a single row. That happened to two real projects.
+     extraThemes={{
+       thisProject: { label: 'This Project', tokens: dashboardTheme, note: 'derived from this repository' },
+     }}
+   />
    ```
 
    That is the whole page. `PanelApp` draws the board, the analysis, the card
-   sheet, the settings, the guide and the notifications, and it offers the
-   kit's themes with no further configuration. Everything a project wants
+   sheet, the settings, the guide and the notifications, and with no themes
+   passed at all it offers the kit's four. Everything a project wants
    differently is a prop rather than a fork:
 
    | Prop | What it changes |
    | --- | --- |
-   | `themes`, `defaultTheme` | The identities the settings sheet offers. Defaults to the kit's presets. |
+   | `extraThemes` | This project's own identities, offered **as well as** the kit's presets. Theirs come first, so the panel opens in one of them. This is the one you want. |
+   | `themes` | The exact set: these and nothing else, presets included. Only for a caller deliberately curating the list — it replaces rather than adds. |
+   | `defaultTheme` | Which one to draw before the board has said. Defaults to the first key. |
+   | `gate` | `.paneltir/gate.json` from this project, imported. With it the setup list gains a row saying whether the files `init` copied are still the ones this version ships; without it the panel says nothing about them rather than guessing. |
    | `brand` | What sits where a name goes in the header. Defaults to the board's `project`. |
    | `capabilities`, `extras` | Sections of the caller's own. Not drawn when absent. |
    | `links`, `footer`, `decoration`, `className` | Where else to go, what sits under the panel, and anything the caller draws behind it. |
@@ -169,19 +185,59 @@ identity** — never another project's.
    | `PANEL_FILE` | Where the board lives in it, if not `src/data/panel-state.json`. |
    | `SESSION_SECRET` | Optional. Defaults to `ADMIN_PASSWORD`, so changing the password ends every session already issued. |
 
+   None of that has to be done from a table. Open the panel on a board nobody
+   has worked yet and it walks the variables one at a time, checking each
+   against the server rather than asking anyone to tick it off — and if a step
+   does not land, it carries a line to paste into a Claude session in this
+   repository, which reads the skill `init` just wrote and takes it from
+   there. On a board already in use the same walkthrough is behind **Help**,
+   offered only while something is actually missing.
+
+   **The files `init` copied do not update, so ask them.** Everything under
+   `api/`, `lib/` and `middleware.ts` is this project's from the moment it is
+   copied — that is the point, since it holds this project's password rule —
+   and the cost is that a fix released upstream can be missing here while every
+   version number on screen looks current. It has happened: the `HTTP 500` on
+   saving was fixed in `template/api/panel-state.ts`, and projects installed
+   before that still had it.
+
+   ```bash
+   npx paneltir doctor
+   ```
+
+   **Commit `.paneltir/gate.json`.** `init` writes it to record what it copied
+   and what it copied it from, and it is provenance rather than a build
+   artifact: ignored by git it disappears on the next clone and every answer
+   below degrades to "differs", which is the one that cannot say who moved.
+
+   It separates the three answers that need different actions — *yours* (you
+   edited it), *BEHIND* (you did not touch it and the template moved), *BOTH* —
+   and the middle one is invisible to `git diff`, because this project's history
+   has nothing to compare against. `init --force` replaces the gate and never
+   the board; read the diff first where a file is marked BOTH, or the edit is
+   lost.
+
+   ```bash
+   npx paneltir run "what this pass did" --cards=a,b
+   ```
+
+   appends an entry to the board's `runs` so the record does not depend on
+   anyone remembering at the end of a session. It writes the file and commits
+   nothing.
+
    Two things to check before trusting it: `/admin` signed out must land on
    `/login`, and **the panel's own JavaScript bundle must answer 401 signed
    out**. If it does not, point the last entry of the matcher in
    `middleware.ts` at wherever this project's build emits it — protecting the
    page but not the bundle leaves the board readable by anyone who opens the
-   HTML.
+   HTML. The walkthrough's last screen says both, for the same reason.
 
 9. **Record the kit fingerprint.** The kit reports itself, so no one has to
    read `node_modules` to find out what is installed:
 
    ```bash
    npx paneltir version          # version, fingerprint, where it came from
-   npx paneltir check 0.8.0      # exits non-zero if that is not what is installed
+   npx paneltir check 0.10.0      # exits non-zero if that is not what is installed
    npx paneltir board            # read the board and say what is wrong with it
    ```
 

package/README.md

@@ -54,7 +54,7 @@ tag rather than a branch, so an unfinished push cannot reach a project:
 npm install paneltir
 
 # or, without npm access, straight from the repository:
-# npm install github:daifukus/paneltir#v0.8.0
+# npm install github:daifukus/paneltir#v0.10.0
 ```
 
 Installing from Git runs the `prepare` script, which builds `dist/`, so the

package/bin/paneltir.mjs

@@ -14,7 +14,8 @@
  * to the project: readable, editable, in its own git history. Re-running never
  * overwrites what is already there.
  */
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
@@ -110,6 +111,43 @@ function survey(target) {
   return found
 }
 
+/**
+ * Records the provenance of the gate now in the project.
+ *
+ * Merged rather than replaced: re-running `init` writes only the files that
+ * were missing, so a stamp that dropped the rest would forget where the
+ * majority of the gate came from. Only files this run actually wrote are
+ * re-stamped — for one it left alone we did not write it and cannot claim to
+ * know its origin, so the previous answer stands or there is none.
+ *
+ * The board is stamped like the rest and then deliberately ignored by
+ * `doctor`: it is meant to diverge from the seed on the first card, and a
+ * report that called that drift would be noise on every project that is
+ * working.
+ */
+function writeStamp(target, templateFiles, written) {
+  const previous = readStamp(target)
+  const files = { ...(previous?.files ?? {}) }
+  for (const file of written) files[file] = sha256(join(target, file))
+
+  const stamp = {
+    version: pkg.version,
+    templateHash: fingerprint.templateHash ?? '',
+    copiedAt: new Date().toISOString(),
+    files,
+  }
+  try {
+    mkdirSync(dirname(join(target, STAMP)), { recursive: true })
+    writeFileSync(join(target, STAMP), JSON.stringify(stamp, null, 2) + '\n')
+  } catch (error) {
+    // Never fatal. The gate is copied and working; the stamp only makes a
+    // later report sharper, and failing the install over bookkeeping would
+    // trade something that matters for something that does not.
+    console.error(`\npaneltir: could not write ${STAMP} (${error.message}).`)
+    console.error('The gate is in place; `paneltir doctor` will have less to go on.')
+  }
+}
+
 function reportSurvey(found) {
   const lines = []
 
@@ -149,6 +187,36 @@ Remove it once the board is moved over, or the project ships both.`)
 /** The board. Never replaced once it exists — see the loop below. */
 const BOARD_SEED = 'src/data/panel-state.json'
 
+/**
+ * Where `init` records what it copied and what it copied it from.
+ *
+ * The gate is the one part of this package that leaves as files a project
+ * keeps, and a kept file can never be told it is old. That has been paid for
+ * twice: the `HTTP 500` fix landed in `template/api/panel-state.ts`, so every
+ * project installed before it still has a save that cannot work, and the skill
+ * file is copied the same way, so a rule learned upstream never reaches the
+ * Claude that reads it.
+ *
+ * A plain diff cannot close that, because it cannot tell "you edited this"
+ * from "we changed this underneath you" — and those need opposite actions.
+ * Hashing each file as written is what separates them.
+ */
+const STAMP = '.paneltir/gate.json'
+
+function sha256(path) {
+  return createHash('sha256').update(readFileSync(path)).digest('hex')
+}
+
+function readStamp(target) {
+  try {
+    return JSON.parse(readFileSync(join(target, STAMP), 'utf8'))
+  } catch {
+    // Absent or unreadable is not a fault: every project installed before
+    // stamping existed is here, and `doctor` still compares the files.
+    return null
+  }
+}
+
 function init(args) {
   const force = args.includes('--force')
   const target = process.cwd()
@@ -180,6 +248,8 @@ function init(args) {
     written.push(file)
   }
 
+  writeStamp(target, files, written);
+
   console.log(`paneltir ${pkg.version} — the panel's gate, into ${target}\n`)
 
   const notes = reportSurvey(survey(target))
@@ -197,8 +267,20 @@ function init(args) {
     for (const file of kept) console.log(`  = ${file}`)
   }
 
+  // Written the gate versus found it already there is the honest first-install
+  // signal on this side, and it changes what is worth saying: somebody
+  // re-running this has read the rest once already.
   if (!written.length) {
     console.log('\nNothing to do — every file is already in place.')
+    console.log(`
+If the panel still will not save, open it and press Help: it asks the server
+what is actually set and reports whether, never the value. Or ask this
+project's own Claude:
+
+  Read .claude/skills/panel/SKILL.md and set up the Paneltir panel with me:
+  tell me each environment variable it needs, what it is for, where in this
+  project to put it, and check the ones already set.
+`)
     return
   }
 
@@ -232,6 +314,17 @@ Then check two things before trusting it:
      not, adjust the last entry of the matcher in middleware.ts to wherever
      this project's build emits it — protecting the page but not the bundle
      leaves the board readable by anyone who opens the HTML.
+
+None of that has to be done from here. Open the panel and it walks the
+variables one at a time, checking each against the server rather than asking
+you to tick it. And if a step does not land, the walkthrough carries a line to
+paste into a session in this repository:
+
+  Read .claude/skills/panel/SKILL.md and set up the Paneltir panel with me:
+  tell me each environment variable it needs, what it is for, where in this
+  project to put it, and check the ones already set.
+
+That skill was just written into this project, and it covers exactly this.
 `)
 }
 
@@ -276,7 +369,7 @@ function check(args) {
  * neither helps the person who has just edited the file by hand and wants to
  * know before they push. This is that answer, from the same check.
  */
-function board(args) {
+async function board(args) {
   const file = args.find((a) => !a.startsWith('-')) || process.env.PANEL_FILE || 'src/data/panel-state.json'
   const path = resolve(process.cwd(), file)
 
@@ -286,7 +379,7 @@ function board(args) {
     process.exit(1)
   }
 
-  const check = readBoard(readFileSync(path, 'utf8'))
+  const check = (await boardReader())(readFileSync(path, 'utf8'))
   if (check.ok) {
     const cards = check.board.cards.length
     console.log(`ok  ${file} — ${cards} card${cards === 1 ? '' : 's'}, ${check.board.columns.length} columns`)
@@ -305,7 +398,205 @@ function board(args) {
   process.exit(1)
 }
 
-const { readBoard } = await import(pathToFileURL(join(here, '../dist/index.js')).href)
+
+/**
+ * Says whether the files this project copied are still the files it shipped.
+ *
+ * The three answers it exists to tell apart:
+ *
+ *   - **yours** — you edited it. Nothing to do; the gate is meant to be edited,
+ *     and this is only here so the next line is believable.
+ *   - **behind** — you did not touch it and the template moved. This is the one
+ *     that has cost real money twice, and the one a bare `git diff` cannot see
+ *     at all, because there is nothing in the project's history to diff
+ *     against.
+ *   - **both** — you edited it *and* the template moved. The only case that
+ *     needs a person: `--force` would throw your edit away.
+ *
+ * It reports and never repairs, for the same reason the panel records a request
+ * instead of running it: replacing somebody's front door is a decision, and
+ * `init --force` is where a person makes it having read what changed.
+ */
+function doctor() {
+  const target = process.cwd()
+  const templateDir = join(packageRoot, 'template')
+  if (!existsSync(templateDir)) {
+    console.error('paneltir: this install has no template/ directory.')
+    process.exit(1)
+  }
+
+  const stamp = readStamp(target)
+  const files = walk(templateDir).sort()
+
+  console.log(`paneltir ${pkg.version} — the gate in ${target}\n`)
+
+  if (!stamp) {
+    console.log(`No ${STAMP}, so this gate was copied before stamping existed.`)
+    console.log('Files can still be compared; "you edited it" and "we changed it"')
+    console.log('cannot be told apart until the next `init` writes one.\n')
+  } else {
+    const behind = stamp.templateHash !== (fingerprint.templateHash ?? '')
+    console.log(`Copied from v${stamp.version} on ${String(stamp.copiedAt).slice(0, 10)}`)
+    console.log(behind ? 'The template has changed since.\n' : 'The template has not changed since.\n')
+  }
+
+  const rows = []
+  for (const file of files) {
+    // The board is meant to diverge: it stops being a template on the first
+    // card. Calling that drift would put a warning on every working project.
+    if (file === BOARD_SEED) {
+      rows.push([file, existsSync(join(target, file)) ? 'yours' : 'missing', 'the board — never compared'])
+      continue
+    }
+
+    const here = join(target, file)
+    if (!existsSync(here)) {
+      rows.push([file, 'missing', 'never copied; `paneltir init` writes it'])
+      continue
+    }
+
+    const mine = sha256(here)
+    const theirs = sha256(join(templateDir, file))
+    const stamped = stamp?.files?.[file]
+
+    if (mine === theirs) {
+      rows.push([file, 'current', ''])
+    } else if (!stamped) {
+      rows.push([file, 'differs', 'no stamp, so who moved cannot be said'])
+    } else if (mine === stamped) {
+      rows.push([file, 'BEHIND', 'you did not touch it; the template moved'])
+    } else if (stamped === theirs) {
+      rows.push([file, 'yours', 'you edited it; the template has not moved'])
+    } else {
+      rows.push([file, 'BOTH', 'you edited it AND the template moved — read both'])
+    }
+  }
+
+  const width = Math.max(...rows.map(([file]) => file.length))
+  for (const [file, state, note] of rows) {
+    console.log(`  ${state.padEnd(8)} ${file.padEnd(width)}${note ? `  ${note}` : ''}`)
+  }
+
+  const stale = rows.filter(([, state]) => state === 'BEHIND' || state === 'BOTH')
+  const missing = rows.filter(([, state]) => state === 'missing')
+
+  if (!stale.length && !missing.length) {
+    console.log('\nNothing to do.')
+    return
+  }
+
+  if (stale.length) {
+    console.log(`\n${stale.length} file(s) are older than the package they came from.`)
+    console.log('See what changed, then decide:')
+    console.log(`  diff -u <file> node_modules/paneltir/template/<file>`)
+    console.log('`paneltir init --force` replaces the gate and never the board.')
+    console.log('Anything marked BOTH would lose your edit — read that diff first.')
+  }
+  if (missing.length) {
+    console.log(`\n${missing.length} file(s) were never copied. \`paneltir init\` writes them.`)
+  }
+  // A gate that cannot work is a failure, not a remark: this runs in CI for
+  // some projects, and an exit code is the only part of it a script reads.
+  process.exit(1)
+}
+
+/**
+ * Appends a run to the board, so the record does not depend on remembering.
+ *
+ * `runs` is what each pass actually did, and until now it was written by hand
+ * — by Claude, into JSON, at the end of a session, from memory. That is the
+ * shape of record that is complete right up until the session that mattered.
+ * A command can be called the moment the work lands.
+ *
+ * It writes the file and nothing else: the board is committed by the panel's
+ * Save or by the project's own commit, and a CLI that pushed on somebody's
+ * behalf would be the second thing in this project writing to their
+ * repository.
+ */
+async function run(args) {
+  const flags = args.filter((a) => a.startsWith('--'))
+  const plain = args.filter((a) => !a.startsWith('--'))
+  const summary = plain[0]
+  const file = plain[1] ?? BOARD_SEED
+
+  if (!summary) {
+    console.error('paneltir run "what this pass did" [--cards a,b] [--by you] [board.json]')
+    process.exit(1)
+  }
+
+  const path = resolve(process.cwd(), file)
+  if (!existsSync(path)) {
+    console.error(`paneltir: no board at ${file}`)
+    process.exit(1)
+  }
+
+  const text = readFileSync(path, 'utf8')
+  const check = (await boardReader())(text)
+  if (!check.ok) {
+    // Refused before writing, not after: appending to a board that is already
+    // broken buries the fault under a change nobody asked for.
+    console.error(`paneltir: ${file} is not a board this kit can read, so nothing was appended.\n`)
+    for (const problem of check.problems) {
+      console.error(problem.at ? `  ${problem.at}\n    ${problem.says}` : `  ${problem.says}`)
+    }
+    process.exit(1)
+  }
+
+  const board = check.board
+  const cards = (flags.find((f) => f.startsWith('--cards='))?.slice(8) ?? '')
+    .split(',')
+    .map((id) => id.trim())
+    .filter(Boolean)
+
+  // A run naming a card the board does not have is a claim that cannot be
+  // checked, which is the only thing `cards` was for.
+  const known = new Set(board.cards.map((card) => card.id))
+  const unknown = cards.filter((id) => !known.has(id))
+  if (unknown.length) {
+    console.error(`paneltir: ${file} has no card called ${unknown.join(', ')}.`)
+    process.exit(1)
+  }
+
+  const by = flags.find((f) => f.startsWith('--by='))?.slice(5) === 'you' ? 'you' : 'claude'
+  const date = new Date().toISOString().slice(0, 10)
+  board.runs = Array.isArray(board.runs) ? board.runs : []
+  board.runs.unshift({
+    id: `run-${date}-${String(board.runs.length + 1).padStart(3, '0')}`,
+    date,
+    by,
+    summary,
+    cards,
+    fingerprint: shortHash,
+  })
+
+  writeFileSync(path, JSON.stringify(board, null, 2) + '\n')
+  console.log(`Appended to ${file}: ${summary}`)
+  console.log(`  ${cards.length ? `cards ${cards.join(', ')}` : 'no cards named'} · by ${by} · ${shortHash}`)
+  console.log('\nThe file is changed and not committed. The panel commits it on Save,')
+  console.log('or commit it yourself — this writes nothing to your repository.')
+}
+
+/**
+ * The board reader, loaded only by the commands that read a board.
+ *
+ * It used to be imported at module scope, which meant every command pulled in
+ * `dist/index.js` — and that bundle imports React, because it is a component
+ * library. So `paneltir init`, whose entire job is to copy seven files, and
+ * `paneltir doctor`, whose job is to hash them, both failed outright in a
+ * project that had not installed React yet. Which is exactly when somebody runs
+ * `init`.
+ *
+ * It is the same rule as the gate's, one layer up: a thing whose job is files
+ * does not carry a component library to do it. Here the fix is smaller than
+ * duplicating anything — the import just moves to where it is used.
+ */
+let readBoard
+async function boardReader() {
+  if (!readBoard) {
+    ;({ readBoard } = await import(pathToFileURL(join(here, '../dist/index.js')).href))
+  }
+  return readBoard
+}
 
 const [command, ...rest] = process.argv.slice(2)
 
@@ -320,7 +611,13 @@ switch (command) {
     check(rest)
     break
   case 'board':
-    board(rest)
+    await board(rest)
+    break
+  case 'doctor':
+    doctor()
+    break
+  case 'run':
+    await run(rest)
     break
   default:
     console.log(`paneltir v${pkg.version} · ${shortHash}
@@ -329,6 +626,8 @@ switch (command) {
   paneltir version          what is installed, and where it came from
   paneltir check [version]  fail if the installed version is not the one meant
   paneltir board [file]     read this project's board and say what is wrong
+  paneltir doctor           is the gate you copied still the gate we ship?
+  paneltir run "summary"    append what this pass did to the board's runs
 
 The components install as a library and are never edited. The gate — password,
 session, write-back — is copied in by init and belongs to the project.`)