@erclx/canon 5.11.0 → 5.12.0

package/src/tasks/validate.ts

@@ -6,7 +6,6 @@ import {
   declinedDir,
   isReservedStem,
   readOutcomes,
-  readPlanTarget,
   readPlanTargets,
   readPullRequest,
   resolveLivePlan,
@@ -731,11 +730,8 @@ async function planDisagreement(
   if (!existsSync(file)) return undefined
 
   const text = await readFile(file, 'utf8')
-  const target = readPlanTarget(text)
-  if (!target) {
-    const several = severalPlans(text, 'Run now', subject)
-    if (several) return several
-
+  const targets = readPlanTargets(text)
+  if (targets.length === 0) {
     return {
       kind: 'plan-uncited',
       group: 'Run now',
@@ -744,15 +740,22 @@ async function planDisagreement(
     }
   }
 
+  const twice = duplicatePlans(targets, 'Run now', subject, dir, root)
+  if (twice) return twice
+
   const rowed = planPath(row.plan, dir, root)
-  const cited = planPath(target, dir, root)
-  if (rowed === cited) return undefined
+  if (targets.some((target) => planPath(target, dir, root) === rowed)) {
+    return undefined
+  }
 
   return {
     kind: 'plan-mismatched',
     group: 'Run now',
     subject,
-    message: `is rowed against ${row.plan} and cites ${target} in its own Plan: line. One task names one plan.`,
+    message:
+      targets.length === 1
+        ? `is rowed against ${row.plan} and cites ${targets[0]} in its own Plan: line. One task names one plan.`
+        : `is rowed against ${row.plan}, which is none of the links on its own Plan: line (${targets.join(', ')}).`,
   }
 }
 
@@ -794,14 +797,15 @@ async function groupClaimFinding(
   if (!existsSync(file)) return undefined
 
   const text = await readFile(file, 'utf8')
-  const target = readPlanTarget(text)
-  if (!target) {
-    const several = severalPlans(text, row.group, row.stem)
-    if (several) return several
-  }
+  const targets = readPlanTargets(text)
+  const twice = duplicatePlans(targets, row.group, row.stem, dir, root)
+  if (twice) return twice
 
-  const live = target ? resolveLivePlan(target, dir, root) : undefined
-  const hasLivePlan = live !== undefined && existsSync(live)
+  const target = targets.find((link) => {
+    const live = resolveLivePlan(link, dir, root)
+    return live !== undefined && existsSync(live)
+  })
+  const hasLivePlan = target !== undefined
 
   if (row.group === 'Needs a plan' && hasLivePlan) {
     return {
@@ -817,9 +821,12 @@ async function groupClaimFinding(
       kind: 'plan-absent',
       group: row.group,
       subject: row.stem,
-      message: target
-        ? `sits under ${row.group}, which claims a written plan, and its task cites ${target}, which is not a live plan.`
-        : `sits under ${row.group}, which claims a written plan, and its task carries no Plan: line.`,
+      message:
+        targets.length > 1
+          ? `sits under ${row.group}, which claims a written plan, and its task cites ${targets.join(', ')}, none of which is a live plan.`
+          : targets.length === 1
+            ? `sits under ${row.group}, which claims a written plan, and its task cites ${targets[0]}, which is not a live plan.`
+            : `sits under ${row.group}, which claims a written plan, and its task carries no Plan: line.`,
     }
   }
 
@@ -827,23 +834,26 @@ async function groupClaimFinding(
 }
 
 /**
- * Reports a `Plan:` line linking more than one plan. `readPlanTarget` reads
- * such a line as naming nothing, so without this a caller would report the
- * line as absent when it is there and breaks the one-plan rule instead.
+ * Reports a `Plan:` line linking one plan more than once. Links to distinct
+ * plans are the shape a sliced task carries, so only a repeat is a finding.
+ * Links compare by the file they resolve to, so `../plans/x.md` beside
+ * `.canon/plans/x.md` is one plan listed twice.
  */
-function severalPlans(
-  text: string,
+function duplicatePlans(
+  targets: readonly string[],
   group: Finding['group'],
   subject: string,
+  dir: string,
+  root: string,
 ): Finding | undefined {
-  const targets = readPlanTargets(text)
-  if (targets.length < 2) return undefined
+  const paths = targets.map((target) => planPath(target, dir, root))
+  if (new Set(paths).size === paths.length) return undefined
 
   return {
     kind: 'plan-several',
     group,
     subject,
-    message: `cites ${targets.length} plans on its Plan: line (${targets.join(', ')}). One task names one plan, so split the task or drop the extra links.`,
+    message: `lists the same plan twice on its Plan: line (${targets.join(', ')}). Drop the repeat, or link a distinct plan per slice.`,
   }
 }
 

package/standards/tasks.md

@@ -124,7 +124,7 @@ An intake folder answers that direction at folder scope rather than item scope.
 
 A project that archived plans before the folder nested under `.canon/plans/` holds closed tasks pointing at `../plans-archive/` or `../.tmp/plans-archive/`. Leave those pointers where they are, since each resolves against the files it names and a task retargeted without its plan moving leads nowhere.
 
-One plan per task, or one per slice on a sliced task. A plan cited by two tasks is a misfile rather than a shape to design for.
+One plan per task, or one per slice, which the board check reads as distinct plans on one line. A plan cited by two tasks is a misfile.
 
 `canon tasks plan-link <task> <plan>` writes or corrects the `Plan:` line, and `--add` appends a slice's plan, so the line is never hand-edited.
 

package/tooling/base/configs/.husky/post-merge

@@ -1,92 +1,45 @@
 #!/usr/bin/env sh
 
-# Names archive candidates after a pull merges work in.
+# Runs the post-merge steps through `canon hooks post-merge`: archive the task a
+# merged pull request closed, push the records, reclaim merged worktrees,
+# reinstall the CLI, and update the plugin cache. The verb owns the order and
+# each line it prints.
 #
-# Every step before the merge fires from a chain and the archive fires when a
-# person remembers, so shipped tasks accumulate on a board that reads as ready
-# to hand a worker. This is the only event that lands after a merge.
+# CANON_SKIP_RECLAIM=1 turns off the worktree reclaim.
+# CANON_SKIP_UPGRADE=1 turns off the CLI reinstall.
+# CANON_SKIP_PLUGIN_UPDATE=1 turns off the plugin cache update.
 #
-# Candidates rather than closed tasks, because an all-`[x]` board entry does not
-# mean the work merged. `context-fold` marks outcomes on the branch as step 1 of
-# the ship chain, so a task can read closed while its pull request is still open
-# or already abandoned. The board is gitignored and an archived task has nothing
-# to recover it, so `task-board` confirms the work is on `main` before moving
-# anything and this output says so rather than implying the check is done.
+# The reclaim reads merge state through `gh`, so a machine without it on PATH
+# reclaims nothing and says nothing. Install `gh` to turn it on.
 #
-# It announces and never moves a file. The board is gitignored, so a shell-side
-# archive leaves no diff to review with nobody watching, and `index.md` is
-# regenerated by a session-scoped hook that a `mv` from a shell never fires.
-#
-# Husky runs this as `sh -e`, so the shebang is advisory and any bare command
-# returning non-zero aborts the hook and prints a husky failure. Keep every
-# test inside an `if` condition, which errexit exempts.
+# Husky runs this as `sh -e`, and `post-rewrite` sources it on a rebase, so
+# every test sits inside an `if` or an `||` and nothing here exits non-zero.
 
 root=$(git worktree list --porcelain 2>/dev/null | grep -m 1 '^worktree ' | cut -d' ' -f2-) || root=''
 [ -n "$root" ] || exit 0
 
 # The board is shared scratch at the main worktree root, and `git worktree
-# list` puts that root first. A pull inside a linked worktree fires this same
-# hook, so trusting the working directory would read a board that is not there.
-board="$root/.canon/tasks"
-[ -d "$board" ] || exit 0
-
-closed=""
-count=0
-
-for file in "$board"/*.md; do
-  [ -f "$file" ] || continue
+# list` puts that root first. A checkout with no board runs none of the steps.
+[ -d "$root/.canon/tasks" ] || exit 0
 
-  case "$file" in
-  */index.md | */priority.md) continue ;;
-  esac
-
-  # Gate on the same condition both archive verbs gate on: at least one closed
-  # outcome and none open. A file carrying no outcomes at all falls out here,
-  # which is what keeps notes on the board from being announced as tasks.
-  if grep -q '^- \[ \]' "$file"; then
-    continue
-  fi
+if ! command -v canon >/dev/null 2>&1; then
+  exit 0
+fi
 
-  if grep -q '^- \[x\]' "$file"; then
-    closed="$closed  $(basename "$file" .md)
-"
-    count=$((count + 1))
+# A global binary older than the verb cannot run it, and the verb carries the
+# only step that would update it, so reinstall here and probe again. The probe
+# reads the verb's own usage line rather than the exit, since an older binary
+# answers an unknown command's `--help` with its root help and exits zero.
+has_verb() {
+  canon hooks post-merge --help 2>/dev/null | grep -q '^Usage: canon hooks post-merge'
+}
+
+if ! has_verb; then
+  if [ -z "$CANON_SKIP_UPGRADE" ]; then
+    CANON_NON_INTERACTIVE=1 canon upgrade >/dev/null 2>&1 || true
   fi
-done
-
-[ "$count" -gt 0 ] || exit 0
-
-printf '\n📋 %s archive candidate(s) on the board:\n%s\n' "$count" "$closed"
-printf 'Outcomes are marked on the branch, so each still needs its work confirmed\n'
-printf 'on main. Run /task-board, which checks that and sweeps the plan first.\n\n'
-
-# The gitignored record folders live on one disk and nowhere else, and a merge
-# is the event that changes them most. This runs on every merge rather than
-# only on one that closes a task, since a review report and a memory entry
-# both land on runs that archive nothing.
-#
-# Sits last so a slow or unreachable remote delays no candidate announcement,
-# and inside an `if` so a push failing offline, or a machine that never ran
-# the one-time setup, still leaves this hook exiting zero. Guarded by its own
-# `command -v canon` check, since this file carries none above it.
-if command -v canon >/dev/null 2>&1; then
-  if backup=$(canon records push --root "$root" --json 2>/dev/null); then
-    changed=$(printf '%s' "$backup" | sed -n 's/.*"changed":\([0-9][0-9]*\).*/\1/p')
-    if [ -n "$changed" ] && [ "$changed" != "0" ]; then
-      printf '\n🗄️  Backed up %s record path(s).\n\n' "$changed"
-    fi
-  else
-    reason=$(printf '%s' "$backup" | sed -n 's/.*"reason":"\([^"]*\)".*/\1/p')
+fi
 
-    # No records history on this machine, which is every checkout that never
-    # ran the one-time setup. Nothing to report.
-    if [ "$reason" != "no-repository" ]; then
-      printf '\n🗄️  Records not backed up: %s\n' "${reason:-unknown}"
-      if [ "$reason" = "unsafe-payload" ]; then
-        printf 'Run canon records push to see the blocked paths.\n\n'
-      else
-        printf 'Run canon records push when the remote is reachable.\n\n'
-      fi
-    fi
-  fi
+if has_verb; then
+  canon hooks post-merge --root "$root" || true
 fi

package/tooling/base/configs/.husky/post-rewrite

@@ -1,6 +1,6 @@
 #!/usr/bin/env sh
 
-# Runs the `post-merge` board check for anyone pulling with rebase.
+# Runs the `post-merge` steps for anyone pulling with rebase.
 #
 # `git pull` under `pull.rebase=true` runs `git rebase`, which fires this event
 # and never `post-merge`. Without this the trigger is a silent no-op on that
@@ -9,8 +9,8 @@
 # target, where the pull style is not something this repository controls.
 #
 # Only the `rebase` argument delegates. `post-rewrite` also fires on
-# `commit --amend`, which rewrites nothing on the board and would print the
-# candidate list on an ordinary amend.
+# `commit --amend`, which rewrites nothing on the board and would run the
+# archive, reclaim, and upgrade steps on an ordinary amend.
 
 [ "$1" = "rebase" ] || exit 0
 

package/tooling/base/reference.md

@@ -52,7 +52,7 @@ Seeds live in `tooling/base/seeds/`. Sync drops each once on first install and n
 - `pre-commit` runs `bunx lint-staged`.
 - `commit-msg` runs `bunx commitlint --edit "$1"`.
 - `pre-push` runs `bun run check`.
-- `post-merge` names `.canon/tasks/` archive candidates, staying silent otherwise and when the board is absent.
+- `post-merge` runs `canon hooks post-merge`: archive the task a merged pull request closed, push the records, reclaim merged worktrees, reinstall the CLI, and update the plugin. It does nothing when the board is absent. `CANON_SKIP_RECLAIM`, `CANON_SKIP_UPGRADE`, and `CANON_SKIP_PLUGIN_UPDATE` turn off the three steps that act on the machine. Read `canon docs hooks` for the contract.
 - `post-rewrite` delegates to `post-merge` on `rebase`, so a `pull.rebase=true` machine still gets the check.
 
 ## lint-staged

package/scripts/core/clean.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-check_dependencies() {
-  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
-}
-
-main() {
-  check_dependencies
-
-  echo -e "${GREY}┌${NC}"
-
-  echo -e "${GREY}├${NC} ${WHITE}Cleaning artifacts${NC}"
-  rm -rf node_modules
-
-  log_rem "node_modules/"
-
-  log_step "Cleaning cache"
-  bun pm cache rm
-  log_info "Package manager cache cleared"
-
-  log_step "Rehydrating project"
-  bun install
-  log_info "Dependencies installed"
-
-  echo -e "${GREY}└${NC}\n"
-  echo -e "${GREEN}✓ Clean complete${NC}"
-}
-
-main "$@"

package/scripts/core/regen-agent-fixture.sh

@@ -1,235 +0,0 @@
-#!/usr/bin/env bash
-# Writes web/src/fixtures/agent-view.json from a real `canon sessions list
-# --json` read of this repository's own sessions.
-#
-# The page it feeds re-creates an orchestrator dispatching workers, which is the
-# one thing this toolkit does that no other surface here shows. A re-creation
-# earns nothing if the rows behind it are invented, so the session half is a
-# live listing and never a literal.
-#
-# Every role in the roster appears, not the workers alone. The controlling
-# session is pinned above the bands and planners sit in them beside workers,
-# which is what the surface being re-created does. An earlier version of this
-# script filtered the listing down to sessions holding a feature branch, and
-# that dropped the orchestrator and every planner, since a controlling session
-# and a planning session both sit on the default branch. A page about a dispatch
-# that excludes the dispatcher is the defect that filter shipped.
-#
-# Two fields cannot come from the listing and are transcribed by hand into the
-# table below. The activity text is written by Claude Code into its own status
-# line and no verb here reports it. The pull request number sits on a task file
-# with nothing joining a session record to it, which the plan behind this script
-# took as a trade rather than building the join. Both are recorded as
-# transcribed in the fixture's own header, so a reader of the committed file can
-# tell which half was measured and which was typed.
-#
-# The honesty cost this leaves open is the one assets/captures/install.html.tmpl
-# already documents for the terminal frames: a hand-edit after generation
-# defeats the discipline silently, and nothing here detects one.
-#
-# Clone-only. It reads this repository's own sessions, and a registry install
-# carries no such listing.
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-OUT="$PROJECT_ROOT/web/src/fixtures/agent-view.json"
-
-# Transcribed half, keyed by session name. The name is the only key that reaches
-# every row: a controlling session and a planning session both sit on the
-# default branch, so a branch cannot tell them apart or from each other. A
-# dispatched session is named `<role>-<project>-<slug>` after the work it was
-# given rather than after what it turned out to be doing, which is what makes
-# the name stable enough to key on here.
-#
-# Each row is `name|activity|pullRequest|state|age`. The state is `pinned`,
-# `working`, or `completed`, and it is where the row renders. An empty pull
-# request field is a session that had not reached its ship step when the
-# snapshot was taken.
-#
-# A pinned or working row has to appear in the live listing or this refuses, and
-# its age comes from the listing rather than the table, so the trailing field is
-# empty for those. A completed row names a session that has already exited, so
-# no listing carries it, its age is transcribed with the rest of the row, and
-# leaving that field blank would print an empty column on half the list.
-# Re-transcribe this table against a fresh listing rather than editing the
-# generated file.
-#
-# A planner belongs in this table as much as a worker does. `role-planner`
-# forbids entering a worktree, so a planner registers on the default branch at
-# launch and stays there for its whole life, which is why the branch filter this
-# script used to carry dropped every one of them permanently rather than
-# occasionally.
-ROWS=(
-  "orchestrator-canon-lead|dispatching the planners that need a plan||pinned|"
-  "worker-canon-agent-view-and-deploy|PR #1510 open (landing page)|1510|working|" # canon-allow-reference: transcribed status text
-  "planner-canon-context-wireframe-draft|drafting the context and wireframe plan||working|"
-  "planner-canon-skill-coverage-pointers|reading the skill coverage pointers||working|"
-  "planner-canon-screenshot-trap-guard|planning the screenshot trap guard||working|"
-  "planner-canon-write-route-hook-bypass|plan written; tested write probe||completed|32m"
-  "planner-canon-indexes-list-lookup|plan and task board consistent||completed|13m"
-  "worker-canon-labels-scan-body-file|address-review pass finished|1508|completed|21m"
-  "worker-canon-web-context-entry|PR #1507 addressed with commit|1507|completed|20m" # canon-allow-reference: transcribed status text
-)
-
-# The listing reports a session's repository as the main `.git` directory, which
-# is what this resolves whether the script runs from the main checkout or from a
-# linked worktree. Comparing against PROJECT_ROOT instead would match nothing
-# from a worktree, where the two differ.
-MAIN_GIT_DIR="$(cd "$PROJECT_ROOT" && git rev-parse --path-format=absolute --git-common-dir)"
-
-# `bun src/cli.ts` rather than `canon`, since a globally linked binary resolves
-# to the main checkout no matter which worktree is running, and this script is
-# run from a worktree as often as not.
-SESSIONS_JSON="$(cd "$PROJECT_ROOT" && CANON_NON_INTERACTIVE=1 bun src/cli.ts sessions list --json 2>/dev/null)"
-
-if [ -z "$SESSIONS_JSON" ]; then
-  echo "regen-agent-fixture: the session listing returned nothing, refusing to write an empty fixture" >&2
-  exit 1
-fi
-
-# The listing crosses into the eval as a file rather than an environment entry,
-# since Linux caps a single env string at 128KB and a machine running many
-# sessions can cross it, which fails the exec with E2BIG before any check can
-# report a thing.
-SESSIONS_FILE="$(mktemp)"
-trap 'rm -f "$SESSIONS_FILE"' EXIT
-printf '%s' "$SESSIONS_JSON" >"$SESSIONS_FILE"
-
-TRANSCRIBED_ROWS="$(printf '%s\n' "${ROWS[@]}")"
-READ_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-
-export SESSIONS_FILE OUT PROJECT_ROOT READ_AT TRANSCRIBED_ROWS MAIN_GIT_DIR
-
-bun --eval '
-const { readFileSync } = require("node:fs")
-
-const { SESSIONS_FILE, OUT, PROJECT_ROOT, READ_AT, TRANSCRIBED_ROWS, MAIN_GIT_DIR } =
-  process.env
-
-const listing = JSON.parse(readFileSync(SESSIONS_FILE, "utf8"))
-
-const rows = TRANSCRIBED_ROWS.split("\n")
-  .map((line) => line.replace(/\s*#\s*canon-allow-reference:.*$/, "").trim())
-  .filter((line) => line !== "")
-  .map((line) => {
-    const [name, activity, pullRequest, state, age] = line.split("|")
-    return {
-      name,
-      activity,
-      pullRequest: pullRequest ? Number(pullRequest) : null,
-      state,
-      age: age || null,
-    }
-  })
-
-// Narrowed to this repository, and the reason is disclosure rather than scope.
-// `canon sessions list` is machine-wide, so an unfiltered read carries the
-// session names and worktree paths of every other project on the machine, which
-// here includes paths under a folder named `private` and several client names.
-// This fixture renders on a public page, so the filter is what keeps them off
-// it. The cost is a fidelity gap stated plainly: the real surface is
-// machine-wide and the depiction is one repository, and that is a deliberate
-// narrowing rather than an oversight.
-//
-// Keyed by name for the reason the shell comment gives: a session on the
-// default branch has no other identity, and the orchestrator and every planner
-// sit there.
-const live = new Map(
-  listing.sessions
-    .filter((session) => session.repository === MAIN_GIT_DIR)
-    .map((session) => [session.name, session]),
-)
-
-// The real surface shows an age per row, so the fixture carries one. It is
-// frozen at the read rather than live, which the rendered provenance line dates
-// so a reader is never told a stale figure is current.
-const ageLabel = (startedAt) => {
-  const minutes = Math.round(
-    (Date.parse(READ_AT) - Date.parse(startedAt)) / 60000,
-  )
-  if (!Number.isFinite(minutes) || minutes < 1) return "now"
-  if (minutes < 60) return `${minutes}m`
-  const hours = Math.round(minutes / 60)
-  return hours < 24 ? `${hours}h` : `${Math.round(hours / 24)}d`
-}
-
-// A row the page shows as running has to be running. Transcribing one that is
-// not is the failure the live half exists to prevent, so it refuses rather than
-// rendering.
-const absent = rows.filter(
-  (row) => row.state !== "completed" && !live.has(row.name),
-)
-if (absent.length > 0) {
-  console.error(
-    "regen-agent-fixture: no live session for " +
-      absent.map((row) => row.name).join(", ") +
-      ". Re-transcribe the table in this script against a fresh listing rather than editing the generated fixture.",
-  )
-  process.exit(1)
-}
-
-const sessions = rows.map((row) => {
-  const session = live.get(row.name)
-  return {
-    name: row.name,
-    branch: session ? session.branch : null,
-    state: row.state,
-    activity: row.activity,
-    pullRequest: row.pullRequest,
-    age: session ? ageLabel(session.startedAt) : row.age,
-  }
-})
-
-const ageless = sessions.filter((entry) => !entry.age)
-if (ageless.length > 0) {
-  console.error(
-    "regen-agent-fixture: no age for " +
-      ageless.map((entry) => entry.name).join(", ") +
-      ". A completed row carries its age in the table, since the session has exited and no listing reports one.",
-  )
-  process.exit(1)
-}
-
-// What the real surface prints above its own list. The remainder is every
-// session on the machine this page has no room to show, which is a real count.
-const summary = {
-  working: sessions.filter((entry) => entry.state === "working").length,
-  completed: sessions.filter((entry) => entry.state === "completed").length,
-  more: Math.max(0, listing.sessions.length - live.size),
-}
-
-const fixture = {
-  // Read by web/src/components/agent-view.astro. Every field below is either a
-  // live read or a hand transcription, and this header is what says which.
-  generatedBy: "scripts/core/regen-agent-fixture.sh",
-  readAt: READ_AT,
-  source: {
-    command: "canon sessions list --json",
-    live: [
-      "name",
-      "branch",
-      "age",
-      "that every pinned and working row is running",
-      "the remainder count",
-    ],
-    transcribed: {
-      activity:
-        "written by Claude Code into its own status line, which no verb here reports",
-      pullRequest:
-        "read off a task file by hand, since nothing joins a session record to one",
-      state:
-        "a completed session has already exited, so no listing carries the row at all",
-    },
-  },
-  summary,
-  sessions,
-}
-
-await Bun.write(OUT, JSON.stringify(fixture, null, 2) + "\n")
-console.error(
-  `regen-agent-fixture: wrote ${sessions.length} session rows to ${OUT.replace(PROJECT_ROOT + "/", "")}`,
-)
-'

package/scripts/core/regen-claude-copies.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-# `.claude/rules/` is a subset rather than a mirror, so it resolves through the
-# stack machinery. The record naming the subset is `internal/governance.toml`.
-bun "$PROJECT_ROOT/src/cli.ts" gov regen --root "$PROJECT_ROOT"

package/scripts/core/regen-indexes.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-bun "$PROJECT_ROOT/src/cli.ts" indexes regen --root "$PROJECT_ROOT" --json >/dev/null