@erclx/canon 5.13.0 → 5.14.1

package/claude/skills/role-orchestrator/scripts/watch.sh

@@ -1,181 +0,0 @@
-#!/usr/bin/env bash
-# Reports worker and pull request transitions as they happen. Reads only.
-#
-# The poll answers "what moved since the last run" on a schedule the session
-# holds. This answers "what just changed" on a loop of its own, and it exists
-# because the two readings a dispatch needs are not one reading: a worker that
-# finishes goes idle and a worker that crashes vanishes, so a watch matching
-# only the pull request list stays silent through the second. A third case is
-# neither: a worker that stops on a question or a prompt neither finishes nor
-# crashes, and sits reading "waiting" beside the two statuses that resolve on
-# their own until something reports it, which is the WORKER-STOPPED line
-# below, or WORKER-UNMEASURABLE for a "waiting" row too old to carry a stamp
-# this reads.
-#
-# `set -e` is deliberately not set. This runs for hours, and one transient `gh`
-# failure aborting the loop is a silent stop rather than a reported one. Every
-# read below states its own failure instead.
-set -uo pipefail
-
-# Seconds between passes. A pass costs two cheap reads and the transitions it
-# watches take minutes, so the number trades staleness against little. Raise it
-# in a project whose workers run long.
-INTERVAL=60
-
-# Seconds a worker can sit in "waiting" before this reports it as stopped
-# rather than folding it into the ordinary status-change lines below. "busy"
-# and "idle" resolve on their own; "waiting" does not, so a dwell that keeps
-# growing there is a session blocked on something outside itself.
-#
-# Measured against the live session registry: 341 usable records carried a
-# status at all, and exactly one carried "waiting", too sparse a sample to fit
-# a distribution. The number is picked from the two bounds the measurement can
-# still name rather than from a round guess: well above INTERVAL, so a handful
-# of passes confirm the row before it reports rather than one slow tool call
-# tripping it, and well inside the ten-to-thirty-minute span a dispatched build
-# ordinarily runs, so a real stall is caught with most of that window still
-# open to act on it.
-#
-# That one record carried `waitingFor: "approve Bash"`, a permission prompt
-# rather than a question, and the two clear on different schedules: a prompt
-# resolves the moment a person approves it, where a question can sit
-# legitimately while a controller finishes a turn. This number is defensible
-# for the second and generous for the first, and the gap stays open rather
-# than splitting the constant on a sample of one.
-STALL_THRESHOLD_S=300
-
-# Resolving the main worktree root rather than this file's folder keeps a watch
-# started from a linked worktree reading the same repository as one started from
-# main. The repository field on a roster row is that root's `.git`.
-MAIN_ROOT="$(git worktree list --porcelain 2>/dev/null | awk '/^worktree /{print $2; exit}')"
-if [ -z "$MAIN_ROOT" ]; then
-  echo "watch: not a git repository, so nothing is watched" >&2
-  exit 1
-fi
-REPOSITORY="$MAIN_ROOT/.git"
-
-# The base branch is read rather than assumed, since this ships to projects that
-# do not all call it `main`. It is what separates a worker from the controlling
-# session, which sits on the base branch in the main worktree.
-BASE_REF="$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null || true)"
-if [ -z "$BASE_REF" ]; then
-  BASE_REF="origin/$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name 2>/dev/null || echo main)"
-fi
-BASE_BRANCH="${BASE_REF#origin/}"
-
-# Every session in this repository holding a branch other than the base one is a
-# worker, whoever launched it. The prototype matched the `orchestrator-` prefix
-# instead, which reads a dispatched worker and misses every hand-launched one,
-# and those are the ordinary shape whenever the operator is launching.
-#
-# The row goes out tab-separated and comes back read with IFS set to a tab. A
-# name this client actually writes carries spaces, `Update session markdown
-# and check runnable commands (3)` among them, and splitting on whitespace
-# took that one apart into a wrong name, branch, status, and dwell.
-read_workers() {
-  canon sessions list --json 2>/dev/null | tail -1 | jq -r \
-    --arg repository "$REPOSITORY" --arg base "$BASE_BRANCH" '
-      .sessions[]?
-      | select(.repository == $repository)
-      | select(.branch != null and .branch != $base)
-      | [.name, .branch, .status, (.statusDwellMs // -1 | tostring)]
-      | @tsv
-    ' 2>/dev/null | sort
-}
-
-read_pulls() {
-  gh pr list --state open --json number,headRefName,title --jq \
-    '.[] | "PR-OPEN #\(.number) \(.headRefName) \(.title)"' 2>/dev/null | sort
-}
-
-# A failed read is reported and the previous baseline kept. Reading an empty
-# result as the current state would report every worker gone and every pull
-# request new on the pass after, which is the one failure that makes a detection
-# tool worth less than no tool.
-#
-# The two sources carry a baseline flag apiece rather than sharing one. A read
-# that fails on the first pass leaves its baseline empty while the other source
-# establishes one, and a single flag would then report that source's whole list
-# as new on the pass after it recovers.
-prev_pulls=""
-prev_workers=""
-prev_names=""
-pulls_seen=0
-workers_seen=0
-
-# One row per worker name currently reported, waiting past STALL_THRESHOLD_S
-# or waiting with no stamp to measure, so a reader watching the log is told
-# once rather than on every remaining pass. The prototype for that shape is
-# the WORKER-GONE/WORKER pair above, tracked in the same state a status change
-# is: a name drops out the pass it stops reading "waiting", which lets the
-# same worker report a second stall later in its life rather than being
-# marked forever by its first one.
-declare -A stalled
-
-while true; do
-  pulls="$(read_pulls)"
-  pulls_read=$?
-  workers="$(read_workers)"
-  workers_read=$?
-
-  if [ "$pulls_read" -ne 0 ]; then
-    echo "watch: the open pull request list failed to load, so none is classified this pass"
-  fi
-  if [ "$workers_read" -ne 0 ]; then
-    echo "watch: the session roster failed to load, so no worker is classified this pass"
-  fi
-
-  names="$(printf '%s\n' "$workers" | awk -F'\t' 'NF {print $1}' | sort -u)"
-
-  if [ "$pulls_seen" -eq 1 ] && [ "$pulls_read" -eq 0 ]; then
-    comm -13 <(printf '%s\n' "$prev_pulls") <(printf '%s\n' "$pulls") | grep . || true
-  fi
-
-  if [ "$workers_seen" -eq 1 ] && [ "$workers_read" -eq 0 ]; then
-    comm -13 <(printf '%s\n' "$prev_workers") <(printf '%s\n' "$workers") |
-      grep . | sed 's/^/WORKER /' || true
-    comm -23 <(printf '%s\n' "$prev_names") <(printf '%s\n' "$names") |
-      grep . | sed 's/^/WORKER-GONE /' || true
-  fi
-
-  if [ "$workers_read" -eq 0 ]; then
-    while IFS=$'\t' read -r w_name w_branch w_status w_dwell_ms; do
-      [ -z "$w_name" ] && continue
-
-      if [ "$w_status" != "waiting" ]; then
-        unset "stalled[$w_name]"
-        continue
-      fi
-
-      if [ "$w_dwell_ms" = "-1" ]; then
-        if [ -z "${stalled[$w_name]:-}" ]; then
-          echo "WORKER-UNMEASURABLE $w_name $w_branch"
-          stalled[$w_name]=1
-        fi
-        continue
-      fi
-
-      w_dwell_s=$((w_dwell_ms / 1000))
-      if [ "$w_dwell_s" -ge "$STALL_THRESHOLD_S" ]; then
-        if [ -z "${stalled[$w_name]:-}" ]; then
-          echo "WORKER-STOPPED $w_name $w_branch ${w_dwell_s}s"
-          stalled[$w_name]=1
-        fi
-      else
-        unset "stalled[$w_name]"
-      fi
-    done <<<"$workers"
-  fi
-
-  if [ "$pulls_read" -eq 0 ]; then
-    prev_pulls="$pulls"
-    pulls_seen=1
-  fi
-  if [ "$workers_read" -eq 0 ]; then
-    prev_workers="$workers"
-    prev_names="$names"
-    workers_seen=1
-  fi
-
-  sleep "$INTERVAL"
-done

package/scripts/core/check-capability-seeding.sh

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-shopt -s nullglob
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-TOOLING_ROOT="$PROJECT_ROOT/tooling"
-MARKER="canon-no-seed:"
-
-# `find` writes to stderr and returns non-zero for a missing root, inside a
-# process substitution whose status nothing reads. Without this the walk covers
-# nothing and the check reports every capability seeded having never read one.
-if [ ! -d "$TOOLING_ROOT" ]; then
-  echo "No tooling root at ${TOOLING_ROOT#"$PROJECT_ROOT/"}, capability seeding unverifiable." >&2
-  exit 1
-fi
-
-failures=""
-
-# A comment naming the marker anywhere in the source file is the recorded
-# reason a capability withholds itself from every destination it was compared
-# against. The reason's own prose is free-form, so only the marker is tested.
-has_reason() {
-  grep -q "$MARKER" "$1"
-}
-
-# Compares one source directory's files against the basenames already
-# expanded from a set of destination paths. Presence on either side clears a
-# name; a source file reaching neither the destination nor a marked reason is
-# a capability answered on one side of the seed or config boundary and not
-# the other.
-check_capability() {
-  local label="$1" src_dir="$2"
-  shift 2
-
-  [ -d "$src_dir" ] || return 0
-
-  local dest_names=" "
-  local dest
-  for dest in "$@"; do
-    [ -f "$dest" ] || continue
-    dest_names="$dest_names$(basename "$dest") "
-  done
-
-  local src_file name
-  for src_file in "$src_dir"/*; do
-    [ -f "$src_file" ] || continue
-    name=$(basename "$src_file")
-    case "$dest_names" in
-    *" $name "*) continue ;;
-    esac
-    has_reason "$src_file" && continue
-    failures="$failures  $label: ${src_file#"$PROJECT_ROOT/"} reaches no seed or config and carries no $MARKER reason"$'\n'
-  done
-}
-
-check_capability "Hooks" "$PROJECT_ROOT/.claude/hooks" \
-  "$PROJECT_ROOT"/tooling/claude/seeds/.claude/hooks/*
-
-check_capability "Workflows" "$PROJECT_ROOT/.github/workflows" \
-  "$PROJECT_ROOT"/tooling/*/configs/.github/workflows/* \
-  "$PROJECT_ROOT"/tooling/*/seeds/.github/workflows/*
-
-check_capability "Husky" "$PROJECT_ROOT/.husky" \
-  "$PROJECT_ROOT"/tooling/base/configs/.husky/*
-
-# The reverse direction: a destination file whose source here is gone reaches
-# neither check_capability above nor the wiring pass below, both of which read
-# forward from the source, and it ships a target a hook, workflow, or husky
-# script this repository has already deleted. A destination carrying the same
-# marker clears just as a source does, which is the escape hatch a target-only
-# capability needs, such as a stack-specific workflow with no root counterpart
-# by design.
-check_orphans() {
-  local label="$1" src_dir="$2" dest_dir="$3"
-
-  [ -d "$dest_dir" ] || return 0
-
-  local dest_file name
-  for dest_file in "$dest_dir"/*; do
-    [ -f "$dest_file" ] || continue
-    name=$(basename "$dest_file")
-    [ -f "$src_dir/$name" ] && continue
-    has_reason "$dest_file" && continue
-    failures="$failures  $label: ${dest_file#"$PROJECT_ROOT/"} is seeded or configured with no source at ${src_dir#"$PROJECT_ROOT/"}/$name"$'\n'
-  done
-}
-
-check_orphans "Hooks" "$PROJECT_ROOT/.claude/hooks" \
-  "$PROJECT_ROOT/tooling/claude/seeds/.claude/hooks"
-
-for dir in "$PROJECT_ROOT"/tooling/*/configs/.github/workflows \
-  "$PROJECT_ROOT"/tooling/*/seeds/.github/workflows; do
-  check_orphans "Workflows" "$PROJECT_ROOT/.github/workflows" "$dir"
-done
-
-check_orphans "Husky" "$PROJECT_ROOT/.husky" \
-  "$PROJECT_ROOT/tooling/base/configs/.husky"
-
-# A hook that reached the seed tree with no wiring in the seeded settings.json
-# is installed dead, which fails the same way an unseeded hook does.
-SEED_HOOKS_DIR="$PROJECT_ROOT/tooling/claude/seeds/.claude/hooks"
-SEED_SETTINGS="$PROJECT_ROOT/tooling/claude/seeds/.claude/settings.json"
-
-if [ -d "$SEED_HOOKS_DIR" ]; then
-  if [ ! -f "$SEED_SETTINGS" ]; then
-    failures="$failures  Seed settings: no settings.json at ${SEED_SETTINGS#"$PROJECT_ROOT/"} to confirm a seeded hook is wired"$'\n'
-  elif ! command -v jq >/dev/null 2>&1; then
-    failures="$failures  Seed settings: jq is not installed, seeded-hook wiring unverifiable"$'\n'
-  else
-    # Every wired command as its own path segment set, rather than a substring
-    # search over the raw file, so a hook name that is a substring of another
-    # hook's filename (`log.sh` inside `pr-create-log.sh`) cannot pass on a
-    # neighbor's wiring.
-    wired=" $(jq -r '.. | .command? // empty' "$SEED_SETTINGS" | tr '/\n' '  ') "
-    for hook_file in "$SEED_HOOKS_DIR"/*.sh; do
-      [ -f "$hook_file" ] || continue
-      name=$(basename "$hook_file")
-      case "$wired" in
-      *" $name "*) continue ;;
-      esac
-      failures="$failures  Seed settings: $name is seeded and wired into no command in ${SEED_SETTINGS#"$PROJECT_ROOT/"}"$'\n'
-    done
-  fi
-fi
-
-if [ -n "$failures" ]; then
-  echo "A capability reaches one side of the seed or config boundary and not the other:" >&2
-  printf '%s' "$failures" >&2
-  echo "Seed or configure the capability, or mark the source line with # $MARKER <reason>." >&2
-  exit 1
-fi

package/scripts/core/check-ignore-parity.sh

@@ -1,141 +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)}"
-
-GITIGNORE="$PROJECT_ROOT/.gitignore"
-MANIFEST="$PROJECT_ROOT/tooling/claude/manifest.toml"
-SECTION="# Claude"
-
-# Parity is exact, with no exception list behind it, and the move to `.canon/`
-# is what removed the one there was. Its two members each named a path inside
-# `.claude/` that this repository ignored and the manifest withheld, so a target
-# kept tracking it. A single root entry can withhold nothing inside itself: git
-# does not descend into an excluded directory, so a re-inclusion like
-# `!.canon/diagrams/` matches nothing. Retiring both is what buys the one line.
-#
-# The diagrams divergence is the one that cost something. A target used to track
-# its diagrams and keep the context audit's default coverage of them, and it now
-# ignores them with the rest of its records, so that coverage is gone unless the
-# project names the folder itself. `canon/context/tooling/manifests.md` carries the
-# narrative.
-#
-# An exception mechanism is not kept against a future divergence, because an
-# empty one cannot be exercised and a check nobody can test is a check nobody
-# should trust. It comes back with its first real member or not at all.
-
-if [ ! -f "$GITIGNORE" ]; then
-  echo "No .gitignore at ${GITIGNORE#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
-  exit 1
-fi
-
-if [ ! -f "$MANIFEST" ]; then
-  echo "No claude manifest at ${MANIFEST#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
-  exit 1
-fi
-
-# A gitignore pattern and a manifest entry describe the same folder whether or
-# not either spells the trailing slash, so presence is compared with it dropped.
-# No live pair differs that way now that both lists carry the same two entries,
-# and the normalization stays because either side may be written without one.
-normalize() {
-  printf '%s\n' "${1%/}"
-}
-
-# Every pattern the file carries, comments and blank lines dropped. The whole
-# file rather than one header, since a claude-scoped entry filed under a header
-# of its own would otherwise read as missing from a list that carries it.
-gitignore_patterns() {
-  awk '{ sub(/[[:space:]]+$/, "") } $0 ~ /^[[:space:]]*#/ || $0 == "" { next } { print }' "$GITIGNORE"
-}
-
-# Every entry of the named array in the manifest's `[gitignore]` table. The
-# array is accumulated to its closing bracket before the quoted strings are read
-# out, so a formatter wrapping it across lines does not silently empty this.
-manifest_entries() {
-  awk -v key="\"$SECTION\"" '
-    /^\[/ { table = $0 }
-    table != "[gitignore]" { next }
-    index($0, key) == 1 { collecting = 1; buf = "" }
-    collecting { buf = buf $0 }
-    collecting && index($0, "]") > 0 {
-      collecting = 0
-      buf = substr(buf, index(buf, "["))
-      count = split(buf, parts, "\"")
-      for (i = 2; i <= count; i += 2) print parts[i]
-    }
-  ' "$MANIFEST"
-}
-
-contains() {
-  local needle=$1
-  shift
-  local candidate
-  for candidate in "$@"; do
-    [ "$candidate" = "$needle" ] || continue
-    return 0
-  done
-  return 1
-}
-
-ignored=()
-while IFS= read -r pattern; do
-  [ -n "$pattern" ] || continue
-  ignored+=("$(normalize "$pattern")")
-done < <(gitignore_patterns)
-
-shipped=()
-while IFS= read -r entry; do
-  [ -n "$entry" ] || continue
-  shipped+=("$(normalize "$entry")")
-done < <(manifest_entries)
-
-# An empty read on either side is a parse that failed rather than a repository
-# ignoring nothing, and reporting parity off it would say the two lists agree
-# having compared none of their entries.
-if [ ${#ignored[@]} -eq 0 ]; then
-  echo "No patterns read from .gitignore, ignore parity unverifiable." >&2
-  exit 1
-fi
-
-if [ ${#shipped[@]} -eq 0 ]; then
-  echo "No entries read from the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"}, ignore parity unverifiable." >&2
-  exit 1
-fi
-
-failures=""
-
-# Entries the manifest ships that this repository does not ignore. A target is
-# told to ignore a folder the toolkit itself tracks, which no decision sanctions,
-# so this direction carries no exception list.
-for entry in "${shipped[@]}"; do
-  contains "$entry" "${ignored[@]}" && continue
-  failures="$failures  $entry is shipped by the manifest and absent from .gitignore"$'\n'
-done
-
-# Claude-scoped patterns this repository ignores that the manifest does not
-# ship. Scoped to the two record roots because the manifest is the claude stack
-# and says nothing about `node_modules/` or `.env`.
-#
-# `.canon` is read as a bare root as well as a prefix, since it is one line
-# covering a whole tree where `.claude/` names a folder inside a root that also
-# holds tracked content. Leaving it out is what would let a new entry sit outside
-# the only stage comparing the two lists, which is the direction that goes
-# silently blind.
-for pattern in "${ignored[@]}"; do
-  case "$pattern" in
-  .claude/* | .canon | .canon/*) ;;
-  *) continue ;;
-  esac
-  contains "$pattern" "${shipped[@]}" && continue
-  failures="$failures  $pattern is ignored here and absent from the manifest"$'\n'
-done
-
-if [ -n "$failures" ]; then
-  echo "The ignore set a target receives disagrees with this repository's own:" >&2
-  printf '%s' "$failures" >&2
-  echo "Add the entry to the \"$SECTION\" array in ${MANIFEST#"$PROJECT_ROOT/"} and to .gitignore. The two lists are compared exactly, and nothing here records an exception." >&2
-  exit 1
-fi

package/scripts/core/check-plugin-boundary.sh

@@ -1,45 +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)}"
-
-INTERNAL_ROOT="$PROJECT_ROOT/internal"
-PLUGIN_ROOT="$PROJECT_ROOT/claude"
-
-# `find` writes to stderr and returns non-zero for a missing root, inside a
-# process substitution whose status nothing reads. Without this the walk covers
-# nothing and the check reports the boundary clean having never measured it.
-if [ ! -d "$PLUGIN_ROOT" ]; then
-  echo "No plugin root at ${PLUGIN_ROOT#"$PROJECT_ROOT/"}, boundary unverifiable." >&2
-  exit 1
-fi
-
-# `realpath` resolves each walked path below. Absent, `set -e` aborts on the
-# substitution and the stage reports a leak for a tool that is not installed,
-# which is the same unmeasured-tree-with-a-verdict shape the guard above closes.
-if ! command -v realpath >/dev/null 2>&1; then
-  echo "realpath is not installed, boundary unverifiable." >&2
-  exit 1
-fi
-
-# The plugin reaches `standards/` through a symlink, which an
-# installer dereferences with no code in the path to filter. Walking the plugin
-# tree with symlinks followed is what an install actually copies, so resolving
-# each file and rejecting anything under `internal/` asserts the boundary at the
-# only place it can be measured.
-leaked=""
-while IFS= read -r file; do
-  resolved=$(realpath "$file")
-  case "$resolved" in
-  "$INTERNAL_ROOT"/*) leaked="$leaked  ${file#"$PROJECT_ROOT/"} -> ${resolved#"$PROJECT_ROOT/"}"$'\n' ;;
-  esac
-done < <(find -L "$PLUGIN_ROOT" -type f)
-
-if [ -n "$leaked" ]; then
-  echo "Plugin ships toolkit-internal content:" >&2
-  printf '%s' "$leaked" >&2
-  echo "Author internal content under internal/, which nothing under claude/ reaches." >&2
-  exit 1
-fi

package/scripts/core/check-seed-independence.sh

@@ -1,62 +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/tooling.sh"
-
-TOOLKIT_TOKEN="canon"
-TOOLING_ROOT="$PROJECT_ROOT/tooling"
-
-# `find` writes to stderr and returns non-zero for a missing root, inside a
-# process substitution whose status nothing reads. Without this the walk covers
-# nothing and the check reports the seeds independent having never read one.
-if [ ! -d "$TOOLING_ROOT" ]; then
-  echo "No tooling root at ${TOOLING_ROOT#"$PROJECT_ROOT/"}, seed independence unverifiable." >&2
-  exit 1
-fi
-
-# An empty discovery is a real state rather than a broken walk, and the Seed
-# standards stage already reports it as a skip. Failing here would have the two
-# stages disagree about what the same condition means.
-seed_roots=$(collect_seed_roots)
-if [ -z "$seed_roots" ]; then
-  echo "No seed root carries .claude/ or canon/, nothing to check." >&2
-  exit 0
-fi
-
-# Markdown alone. The seed tree also ships hooks that call the toolkit CLI on
-# purpose, each reporting a named stale-index warning when the binary is absent,
-# and scoping by extension leaves them outside this walk without an exemption
-# list that would have to be maintained against them.
-cited=""
-measured=0
-while IFS= read -r seed_root; do
-  while IFS= read -r file; do
-    measured=$((measured + 1))
-    # A token followed by `/` is the tracked surface root, a folder the seed
-    # itself installs, rather than the binary. Every other spelling still
-    # reports, which keeps a verb, a plugin skill prefix, and a bare mention in.
-    while IFS= read -r hit; do
-      cited="$cited  ${file#"$PROJECT_ROOT/"}:$hit"$'\n'
-    done < <(grep -nE "${TOOLKIT_TOKEN}([^/]|$)" "$file" || true)
-  done < <(find "$PROJECT_ROOT/$seed_root" -type f -name '*.md')
-done <<<"$seed_roots"
-
-# Roots resolved and no markdown under any of them is a walk that covered
-# nothing, which is the verdict-without-a-measurement the guards above refuse for
-# a missing tree. Reporting a pass here would say the seeds cite no CLI on the
-# strength of having read no prose.
-if [ "$measured" -eq 0 ]; then
-  echo "Seed roots resolved but carry no markdown, seed independence unverifiable." >&2
-  exit 1
-fi
-
-if [ -n "$cited" ]; then
-  echo "Seed prose cites the toolkit CLI:" >&2
-  printf '%s' "$cited" >&2
-  echo "A scaffolded project may not have $TOOLKIT_TOKEN installed. State the capability the line needs rather than the binary that supplies it." >&2
-  exit 1
-fi

package/scripts/core/check-skill-paths.sh

@@ -1,24 +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)}"
-
-SKILLS_DIR="$PROJECT_ROOT/claude/skills"
-
-# A shipped skill runs from a target project, where the toolkit's own wiki/ does
-# not exist. Anchoring on a non-path character keeps a target's .claude/wiki/ legal.
-BANNED_PATH_PATTERN='(^|[^[:alnum:]._/-])wiki/'
-
-[ -d "$SKILLS_DIR" ] || exit 0
-
-matches=$(grep -rnE "$BANNED_PATH_PATTERN" "$SKILLS_DIR" || true)
-
-[ -z "$matches" ] && exit 0
-
-echo "Shipped skills reference a repo-local path that does not exist in a target project:"
-echo "$matches" | sed "s|^$PROJECT_ROOT/||"
-echo
-echo "Reach supporting prose through a canon docs command, a standard cited at the flat root, or inlined text."
-exit 1

package/scripts/core/list-seed-roots.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-# Prints every seed root carrying a `.claude/` or a `canon/`, one per line and
-# relative to the project root.
-#
-# The discovery rule has one definition, `collect_seed_roots` in
-# `scripts/lib/tooling.sh`, which `check-seed-independence.sh` already reads.
-# This file is the route a caller outside bash takes to that same answer, so a
-# stack seeding either root later reaches both readers and the two stages
-# measuring seed content cannot disagree about which roots exist.
-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/tooling.sh"
-
-collect_seed_roots

package/scripts/lib/tooling.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-TOOLING_STACK_EXCLUDE=("claude")
-
-is_tooling_stack_excluded() {
-  local name="$1"
-  local excluded
-  for excluded in "${TOOLING_STACK_EXCLUDE[@]}"; do
-    if [ "$name" = "$excluded" ]; then
-      return 0
-    fi
-  done
-  return 1
-}
-
-list_tooling_stacks() {
-  local tooling_dir="${1:-$PROJECT_ROOT/tooling}"
-  local name
-  while IFS= read -r entry; do
-    name=$(basename "$entry")
-    is_tooling_stack_excluded "$name" && continue
-    echo "$name"
-  done < <(find "$tooling_dir" -mindepth 1 -maxdepth 1 -type d | sort)
-}
-
-# Seed roots that carry a `.claude/` or a `canon/`, emitted relative to
-# `PROJECT_ROOT`. Every stage measuring seed content discovers through this
-# rather than naming a stack, so a stack seeding either root later arrives
-# covered with no edit to any caller. A stack seeding only tracked surfaces
-# carries `canon/` alone, which a `.claude/` test would drop from both stages.
-collect_seed_roots() {
-  local dir
-  for dir in "$PROJECT_ROOT"/tooling/*/seeds; do
-    [ -d "$dir/.claude" ] || [ -d "$dir/canon" ] || continue
-    printf '%s\n' "${dir#"$PROJECT_ROOT"/}"
-  done
-}