@jeiemgi/cckit 0.1.6

package/scripts/kit-routines.sh

@@ -0,0 +1,322 @@
+#!/usr/bin/env bash
+# kit-routines.sh — suggested-routines cron catalogue: accept / remove / list / verify (#377).
+#
+# THE PHILOSOPHY: the kit SUGGESTS routines; the user accepts; nothing is created without opt-in.
+# Accepted routines are stored in kit.config.json (.routines[]) and wired as OS cron jobs
+# (crontab entries) scoped to the project directory. Each entry is tagged with the kit's sentinel
+# comment so it can be identified and removed cleanly. The script NEVER auto-accepts anything.
+#
+# Operations:
+#   kit-routines.sh list                    # show the catalogue with status (accepted / available)
+#   kit-routines.sh accept <id> [--dir D]   # suggest -> add cron + record in kit.config.json
+#   kit-routines.sh remove <id> [--dir D]   # remove cron + clear from kit.config.json
+#   kit-routines.sh verify  [--dir D]       # check: config routines have matching cron entries
+#   kit-routines.sh remove-all [--dir D]    # remove every kit-managed cron for this project (used by kit-remove)
+#   KIT_DRY_RUN=1 kit-routines.sh ...       # preview any write op, write nothing
+#   KIT_ASSUME_YES=1 kit-routines.sh ...    # non-interactive (CI / batch)
+#
+# Cron sentinel format — one line per routine:
+#   # kit-managed:<project_slug>:<routine_id> <cron_expr> <command>
+# This makes grep-based remove exact and never matches unrelated crontab lines.
+#
+# Requires: jq (catalogue parse + config patch), crontab (OS-level cron).
+
+set -uo pipefail
+_rt_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+. "$_rt_dir/lib/kit-cli.sh"    # kit_is_main, kit_say, kit_warn, kit_die
+
+# Plugin root — prefer CLAUDE_PLUGIN_ROOT, fall back to two levels up.
+_kit_rt_plugin_root() {
+  if [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then printf '%s\n' "$CLAUDE_PLUGIN_ROOT"; return 0; fi
+  ( CDPATH='' cd -- "$_rt_dir/.." && pwd )
+}
+
+_kit_rt_catalogue() {
+  local f; f="$(_kit_rt_plugin_root)/routines/catalogue.json"
+  [ -f "$f" ] || kit_die "routines catalogue not found: $f"
+  cat "$f"
+}
+
+_kit_rt_dry()    { [ -n "${KIT_DRY_RUN:-}" ]; }
+_kit_rt_yes()    { [ -n "${KIT_ASSUME_YES:-}" ]; }
+_kit_rt_say()    { printf '%s\n' "$*" >&2; }
+
+# ── project-slug helper ─────────────────────────────────────────────────────
+# Derive a stable slug for cron sentinel tagging: use kit.config.json project.slug,
+# fall back to the current directory name.
+_kit_rt_slug() {
+  local dir="${1:-$PWD}" slug
+  slug="$(jq -r '.project.slug // empty' "$dir/.claude/kit.config.json" 2>/dev/null || true)"
+  [ -n "$slug" ] && { printf '%s\n' "$slug"; return 0; }
+  basename "$dir"
+}
+
+# ── catalogue helpers ────────────────────────────────────────────────────────
+# kit_routines_get_by_id <id> -> JSON object or empty
+kit_routines_get_by_id() {
+  _kit_rt_catalogue | jq --arg id "$1" '.routines[] | select(.id==$id)'
+}
+
+# kit_routines_accepted <dir> -> space-separated list of accepted routine ids from kit.config.json
+kit_routines_accepted() {
+  local dir="${1:-$PWD}" cfg
+  cfg="$dir/.claude/kit.config.json"
+  [ -f "$cfg" ] || { printf ''; return 0; }
+  jq -r '(.routines // [])[]' "$cfg" 2>/dev/null || true
+}
+
+# ── crontab helpers ──────────────────────────────────────────────────────────
+# Sentinel comment identifies a kit-managed line: "# kit-managed:<slug>:<id>"
+_kit_rt_sentinel() { printf '# kit-managed:%s:%s' "$1" "$2"; }
+
+# _kit_rt_cron_line <sentinel> <cron_expr> <command_expanded> -> the full crontab line pair
+_kit_rt_cron_line() {
+  local sentinel="$1" expr="$2" cmd="$3"
+  printf '%s\n%s %s\n' "$sentinel" "$expr" "$cmd"
+}
+
+# _kit_rt_expand_command <command_template> <scripts_dir> -> expanded command string
+_kit_rt_expand_command() {
+  local tmpl="$1" scripts="$2"
+  printf '%s' "$tmpl" | sed "s|\${KIT_SCRIPTS}|$scripts|g"
+}
+
+# kit_routines_cron_has <sentinel> -> rc 0 if present in crontab
+kit_routines_cron_has() {
+  local sentinel="$1"
+  crontab -l 2>/dev/null | grep -qF "$sentinel"
+}
+
+# kit_routines_cron_add <sentinel> <cron_line_pair>
+# Appends the two-line pair (sentinel + cron) to the crontab if not already present.
+kit_routines_cron_add() {
+  local sentinel="$1" pair="$2" tmp
+  if kit_routines_cron_has "$sentinel"; then
+    _kit_rt_say "  = cron already present ($sentinel)"; return 0
+  fi
+  if _kit_rt_dry; then
+    _kit_rt_say "  [dry-run] would add cron: $sentinel"; return 0
+  fi
+  tmp="$(mktemp)"
+  { crontab -l 2>/dev/null; printf '\n%s\n' "$pair"; } > "$tmp" || { rm -f "$tmp"; return 1; }
+  crontab "$tmp"; local rc=$?; rm -f "$tmp"
+  [ "$rc" -eq 0 ] && _kit_rt_say "  + cron added: $sentinel" || { _kit_rt_say "  error: crontab write failed"; return 1; }
+}
+
+# kit_routines_cron_remove <sentinel>
+# Removes every line whose PRECEDING line is the sentinel comment (the comment + cron line pair).
+kit_routines_cron_remove() {
+  local sentinel="$1" tmp
+  if ! kit_routines_cron_has "$sentinel"; then
+    _kit_rt_say "  = cron not found (already removed): $sentinel"; return 0
+  fi
+  if _kit_rt_dry; then
+    _kit_rt_say "  [dry-run] would remove cron: $sentinel"; return 0
+  fi
+  tmp="$(mktemp)"
+  # Strip the sentinel line AND the following non-empty cron line.
+  crontab -l 2>/dev/null | awk -v s="$sentinel" '
+    /^[[:space:]]*$/ { print; next }
+    $0 == s { skip=1; next }
+    skip { skip=0; next }
+    { print }
+  ' > "$tmp" || { rm -f "$tmp"; return 1; }
+  crontab "$tmp"; local rc=$?; rm -f "$tmp"
+  [ "$rc" -eq 0 ] && _kit_rt_say "  - cron removed: $sentinel" || { _kit_rt_say "  error: crontab write failed"; return 1; }
+}
+
+# ── config helpers ───────────────────────────────────────────────────────────
+# kit_routines_config_add <id> <dir>
+# Adds the routine id to kit.config.json .routines[] (idempotent).
+kit_routines_config_add() {
+  local id="$1" dir="${2:-$PWD}" cfg tmp
+  cfg="$dir/.claude/kit.config.json"
+  _kit_rt_dry && { _kit_rt_say "  [dry-run] would add '$id' to $cfg .routines[]"; return 0; }
+  [ -f "$cfg" ] || printf '{}\n' > "$cfg"
+  tmp="$(mktemp)"
+  jq --arg id "$id" '.routines = ((.routines // []) + [$id] | unique)' "$cfg" > "$tmp" \
+    && mv "$tmp" "$cfg" || { rm -f "$tmp"; return 1; }
+  _kit_rt_say "  + recorded '$id' in $cfg"
+}
+
+# kit_routines_config_remove <id> <dir>
+kit_routines_config_remove() {
+  local id="$1" dir="${2:-$PWD}" cfg tmp
+  cfg="$dir/.claude/kit.config.json"
+  [ -f "$cfg" ] || return 0
+  _kit_rt_dry && { _kit_rt_say "  [dry-run] would remove '$id' from $cfg .routines[]"; return 0; }
+  tmp="$(mktemp)"
+  jq --arg id "$id" '.routines = ((.routines // []) | map(select(. != $id)))' "$cfg" > "$tmp" \
+    && mv "$tmp" "$cfg" || { rm -f "$tmp"; return 1; }
+  _kit_rt_say "  - removed '$id' from $cfg"
+}
+
+# ── public operations ────────────────────────────────────────────────────────
+
+# kit_routines_list [dir] — print the catalogue table with acceptance status.
+kit_routines_list() {
+  local dir="${1:-$PWD}"
+  command -v jq >/dev/null 2>&1 || kit_die "jq required"
+  local cat accepted
+  cat="$(_kit_rt_catalogue)"
+  accepted="$(kit_routines_accepted "$dir")"
+
+  printf '%-22s  %-8s  %-8s  %-9s  %s\n' "ID" "CADENCE" "STATUS" "COST" "DESCRIPTION" >&2
+  printf '%s\n' "-----------------------------------------------------------------------" >&2
+
+  local n; n="$(printf '%s' "$cat" | jq '.routines | length')"
+  local i=0
+  while [ "$i" -lt "$n" ]; do
+    local id cad cost desc status
+    id="$(printf '%s' "$cat"   | jq -r ".routines[$i].id")"
+    cad="$(printf '%s' "$cat"  | jq -r ".routines[$i].cadence")"
+    cost="$(printf '%s' "$cat" | jq -r ".routines[$i].cost")"
+    desc="$(printf '%s' "$cat" | jq -r ".routines[$i].description" | cut -c1-50)"
+    if printf '%s\n' "$accepted" | grep -qx "$id" 2>/dev/null; then
+      status="accepted"
+    else
+      status="available"
+    fi
+    printf '%-22s  %-8s  %-8s  %-9s  %s\n' "$id" "$cad" "$status" "$cost" "$desc" >&2
+    i=$((i+1))
+  done
+}
+
+# kit_routines_accept <id> [dir]
+# Opt-in: look up the routine in the catalogue, add cron entry, record in config.
+kit_routines_accept() {
+  local id="$1" dir="${2:-$PWD}"
+  command -v jq >/dev/null 2>&1 || kit_die "jq required"
+  command -v crontab >/dev/null 2>&1 || kit_die "crontab required"
+
+  dir="$(cd "$dir" 2>/dev/null && pwd)" || kit_die "no such dir: $dir"
+
+  local entry; entry="$(kit_routines_get_by_id "$id")"
+  [ -n "$entry" ] || kit_die "unknown routine '$id' (run: kit-routines.sh list)"
+
+  local scripts; scripts="$(cd "$_rt_dir" && pwd)"
+  local cron_expr cmd_tmpl cmd_expanded sentinel pair slug
+  cron_expr="$(printf '%s' "$entry" | jq -r '.cron')"
+  cmd_tmpl="$(printf '%s' "$entry"  | jq -r '.command')"
+  cmd_expanded="$(_kit_rt_expand_command "$cmd_tmpl" "$scripts")"
+  slug="$(_kit_rt_slug "$dir")"
+  sentinel="$(_kit_rt_sentinel "$slug" "$id")"
+  pair="$(_kit_rt_cron_line "$sentinel" "$cron_expr" "$cmd_expanded")"
+
+  # One confirm unless non-interactive.
+  if ! _kit_rt_dry && ! _kit_rt_yes; then
+    local name; name="$(printf '%s' "$entry" | jq -r '.name')"
+    printf 'Accept routine "%s" (%s, %s)? [y/N] ' "$name" "$id" "$cron_expr" >&2
+    local reply=""; IFS= read -r reply || true
+    case "$reply" in y|Y|yes|YES) ;; *) _kit_rt_say "  skipped."; return 0;; esac
+  fi
+
+  kit_routines_cron_add "$sentinel" "$pair" || return 1
+  kit_routines_config_add "$id" "$dir" || return 1
+  _kit_rt_say "routine '$id' accepted."
+}
+
+# kit_routines_remove <id> [dir]
+kit_routines_remove() {
+  local id="$1" dir="${2:-$PWD}"
+  command -v jq >/dev/null 2>&1 || kit_die "jq required"
+  command -v crontab >/dev/null 2>&1 || kit_die "crontab required"
+
+  dir="$(cd "$dir" 2>/dev/null && pwd)" || kit_die "no such dir: $dir"
+  local slug; slug="$(_kit_rt_slug "$dir")"
+  local sentinel; sentinel="$(_kit_rt_sentinel "$slug" "$id")"
+
+  kit_routines_cron_remove "$sentinel" || return 1
+  kit_routines_config_remove "$id" "$dir" || return 1
+  _kit_rt_say "routine '$id' removed."
+}
+
+# kit_routines_verify [dir]
+# Check: every id in kit.config.json .routines[] has a matching crontab entry.
+# rc 0 = in sync; rc 1 = drift (missing or orphan crons).
+kit_routines_verify() {
+  local dir="${1:-$PWD}"
+  command -v jq >/dev/null 2>&1 || kit_die "jq required"
+
+  dir="$(cd "$dir" 2>/dev/null && pwd)" || kit_die "no such dir: $dir"
+  local accepted; accepted="$(kit_routines_accepted "$dir")"
+  local slug; slug="$(_kit_rt_slug "$dir")"
+
+  if [ -z "$accepted" ]; then
+    _kit_rt_say "kit-routines verify: no routines accepted — nothing to check."
+    return 0
+  fi
+
+  local drift=0 id sentinel
+  while IFS= read -r id; do
+    [ -z "$id" ] && continue
+    sentinel="$(_kit_rt_sentinel "$slug" "$id")"
+    if ! kit_routines_cron_has "$sentinel"; then
+      _kit_rt_say "  ! cron missing for routine '$id' (sentinel: $sentinel)"
+      drift=1
+    else
+      _kit_rt_say "  = cron present: $id"
+    fi
+  done <<EOF
+$accepted
+EOF
+
+  if [ "$drift" -eq 1 ]; then
+    _kit_rt_say "kit-routines verify: drift detected — run 'kit-routines.sh accept <id>' to repair."
+    return 1
+  fi
+  _kit_rt_say "kit-routines verify: all crons in sync."
+  return 0
+}
+
+# kit_routines_remove_all [dir]
+# Remove every kit-managed cron for this project. Called by kit-remove on uninstall.
+kit_routines_remove_all() {
+  local dir="${1:-$PWD}"
+  command -v jq >/dev/null 2>&1 || kit_die "jq required"
+  command -v crontab >/dev/null 2>&1 || { _kit_rt_say "kit-routines: crontab not found — skip cron cleanup."; return 0; }
+
+  dir="$(cd "$dir" 2>/dev/null && pwd)" || kit_die "no such dir: $dir"
+  local accepted; accepted="$(kit_routines_accepted "$dir")"
+  local slug; slug="$(_kit_rt_slug "$dir")"
+
+  if [ -z "$accepted" ]; then
+    _kit_rt_say "kit-routines remove-all: no routines to remove."; return 0
+  fi
+
+  local id
+  while IFS= read -r id; do
+    [ -z "$id" ] && continue
+    kit_routines_cron_remove "$(_kit_rt_sentinel "$slug" "$id")"
+  done <<EOF
+$accepted
+EOF
+  _kit_rt_say "kit-routines remove-all: done."
+}
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+if kit_is_main; then
+  command -v jq >/dev/null 2>&1 || { echo "kit-routines: jq required" >&2; exit 1; }
+  _sub="${1:-}"; shift 2>/dev/null || true
+  _id=""; _dir="$PWD"
+  while [ $# -gt 0 ]; do case "$1" in
+    --dir) _dir="$2"; shift 2;;
+    --dry-run) export KIT_DRY_RUN=1; shift;;
+    --yes|-y) export KIT_ASSUME_YES=1; shift;;
+    -h|--help)
+      echo "usage: kit-routines.sh list|accept <id>|remove <id>|verify|remove-all [--dir D] [--dry-run] [--yes]"
+      exit 0;;
+    -*) kit_die "unknown flag: $1";;
+    *) [ -z "$_id" ] && _id="$1" || kit_die "unexpected arg: $1"; shift;;
+  esac; done
+  case "$_sub" in
+    list)       kit_routines_list "$_dir";;
+    accept)     [ -n "$_id" ] || kit_die "usage: kit-routines.sh accept <id>"; kit_routines_accept "$_id" "$_dir";;
+    remove)     [ -n "$_id" ] || kit_die "usage: kit-routines.sh remove <id>"; kit_routines_remove "$_id" "$_dir";;
+    verify)     kit_routines_verify "$_dir";;
+    remove-all) kit_routines_remove_all "$_dir";;
+    -h|--help)  echo "usage: kit-routines.sh list|accept <id>|remove <id>|verify|remove-all [--dir D] [--dry-run] [--yes]"; exit 0;;
+    *) kit_die "usage: kit-routines.sh list|accept <id>|remove <id>|verify|remove-all [--dir D] [--dry-run] [--yes]";;
+  esac
+fi

package/scripts/kit-version-check.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# claude-kit — CLI-style update check. Compares a kit-initialized project's recorded kitVersion
+# against the installed plugin version, and prints a one-line notice when the project is behind.
+# Safe no-op when it can't determine either side. Used by the SessionStart hook and /kit-update.
+#
+# Usage: kit-version-check.sh [--target DIR] [--plugin-root DIR] [--quiet]
+set -uo pipefail
+
+TARGET="$PWD"; PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-}"; QUIET=0
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --target) TARGET="$2"; shift 2 ;;
+    --plugin-root) PLUGIN_ROOT="$2"; shift 2 ;;
+    --quiet) QUIET=1; shift ;;
+    *) shift ;;
+  esac
+done
+
+command -v jq >/dev/null 2>&1 || exit 0
+cfg="$TARGET/.claude/kit.config.json"
+[[ -f "$cfg" ]] || exit 0
+
+# Locate the installed plugin's plugin.json: explicit root → env → best-effort glob.
+pj=""
+[[ -n "$PLUGIN_ROOT" && -f "$PLUGIN_ROOT/.claude-plugin/plugin.json" ]] && pj="$PLUGIN_ROOT/.claude-plugin/plugin.json"
+if [[ -z "$pj" ]]; then
+  pj="$(ls -t "$HOME"/.claude/plugins/*/claude-kit*/.claude-plugin/plugin.json \
+            "$HOME"/.claude/plugins/*/*/claude-kit*/.claude-plugin/plugin.json \
+            "$HOME"/.claude/plugins/*/*/claude-kit*/*/.claude-plugin/plugin.json \
+            "$HOME"/.claude/plugins/*/*/*/claude-kit*/.claude-plugin/plugin.json 2>/dev/null | head -1 || true)"
+fi
+[[ -n "$pj" && -f "$pj" ]] || exit 0
+
+have="$(jq -r '.kitVersion // "0.0.0"' "$cfg" 2>/dev/null || echo 0.0.0)"
+latest="$(jq -r '.version // "0.0.0"' "$pj" 2>/dev/null || echo 0.0.0)"
+
+# Branded one-line status — ALWAYS shown (the banner is never silenced unless --quiet).
+# Renders the seed-head sigil when the brand lib is present; plain text otherwise.
+SIGIL="$TARGET/.claude/lib/kit-sigil.sh"
+banner() {  # banner <skill-slot> <note>
+  [[ $QUIET -eq 1 ]] && return 0
+  if [[ -f "$SIGIL" ]]; then
+    # shellcheck source=/dev/null
+    source "$SIGIL"; kit_sigil "$1" "$2"
+  else
+    echo "claude-kit${1:+ · $1}${2:+ · $2}"
+  fi
+}
+
+# Up to date — still announce it (no longer a silent no-op).
+if [[ "$have" == "$latest" ]]; then
+  banner "v$latest" "al día · up to date"
+  exit 0
+fi
+
+# Is `latest` strictly newer than `have`? We can't lean on `sort -V` for the whole string:
+# neither GNU nor BSD `sort -V` implements SemVer pre-release precedence (both rank
+# `0.7.0-beta.1` ABOVE `0.7.0`, which is wrong — a pre-release must be LOWER than its release).
+# So we split each version into a numeric CORE (x.y.z) and an optional PRE (after the first `-`),
+# and compare per SemVer §11:
+#   1. cores differ        → the higher core wins (sort -V is reliable on pure numeric cores)
+#   2. cores equal:
+#        stable  vs pre    → stable is newer (a release outranks any pre-release of same core)
+#        pre     vs pre    → compare the pre identifiers (sort -V, e.g. beta.1 < beta.2)
+# POSIX-ish: only bash parameter expansion + a tiny `sort -V` on suffix-free strings.
+ver_is_newer() {  # ver_is_newer HAVE LATEST → exit 0 if LATEST strictly newer than HAVE
+  local h="$1" l="$2"
+  [[ "$h" == "$l" ]] && return 1
+  local hcore="${h%%-*}" lcore="${l%%-*}" hpre="" lpre="" top
+  [[ "$h" == *-* ]] && hpre="${h#*-}"
+  [[ "$l" == *-* ]] && lpre="${l#*-}"
+  if [[ "$hcore" != "$lcore" ]]; then
+    top="$(printf '%s\n%s\n' "$hcore" "$lcore" | sort -V | tail -1)"
+    [[ "$top" == "$lcore" ]]; return
+  fi
+  # cores equal — decide on the pre-release component
+  [[ -z "$lpre" && -n "$hpre" ]] && return 0   # latest = release, have = pre  → newer
+  [[ -n "$lpre" && -z "$hpre" ]] && return 1   # latest = pre,     have = release → not newer
+  # both pre-release on the same core
+  top="$(printf '%s\n%s\n' "$hpre" "$lpre" | sort -V | tail -1)"
+  [[ "$top" == "$lpre" && "$hpre" != "$lpre" ]]
+}
+
+if ver_is_newer "$have" "$latest"; then
+  banner "update available" "$have -> $latest · run /kit-update to merge new features (your edits are preserved)"
+  exit 10  # signal: behind
+fi
+
+# have is NEWER than the installed plugin — local dev ahead of the release.
+banner "v$have" "ahead of plugin $latest"
+exit 0

package/scripts/kit-wire-test.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# kit-wire-test.sh — self-test for kit-wire (#369). Runs under bash AND zsh.
+# Run:  bash scripts/kit-wire-test.sh
+PLUGIN_DIR=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
+
+if [ -n "${KIT_WIRE_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_WIRE_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_WIRE_TEST_INNER): $1"; fi; }
+
+  proj="$(mktemp -d)"; trap 'rm -rf "$proj"' EXIT
+  cd "$proj"
+  export CLAUDE_PLUGIN_ROOT="$PLUGIN_DIR"   # so the shim + plugin-root resolve to our statusline
+  export KIT_ASSUME_YES=1
+
+  . "$PLUGIN_DIR/scripts/kit-wire.sh"
+
+  # converge
+  kit_wire >/dev/null 2>&1
+  t "shim created"        "$([ -f .claude/statusline.sh ] && echo yes || echo no)" "yes"
+  t "shim is a shim"      "$(grep -c 'claude-kit statusline shim' .claude/statusline.sh)" "1"
+  t "settings wired"      "$(jq -r '.statusLine.command' .claude/settings.json 2>/dev/null)" '$CLAUDE_PROJECT_DIR/.claude/statusline.sh'
+  t "shim tracked"        "$(. "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"; kit_manifest_verify .claude/statusline.sh)" "intact"
+  t "settings tracked"    "$(. "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"; kit_manifest_verify .claude/settings.json)" "intact"
+
+  # idempotent: second converge changes nothing, shim still intact
+  kit_wire >/dev/null 2>&1
+  t "idempotent shim"     "$(. "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"; kit_manifest_verify .claude/statusline.sh)" "intact"
+
+  # --check is clean after converge (rc 0)
+  if kit_wire_check >/dev/null 2>&1; then t "check clean rc" "0" "0"; else t "check clean rc" "$?" "0"; fi
+
+  # hook executability: drop a non-exec hook, converge, assert it became executable
+  mkdir -p .claude/hooks; printf '#!/usr/bin/env bash\n:\n' > .claude/hooks/demo.sh; chmod -x .claude/hooks/demo.sh
+  kit_wire >/dev/null 2>&1
+  t "hook chmod +x"       "$([ -x .claude/hooks/demo.sh ] && echo yes || echo no)" "yes"
+
+  # drift detection: user removes the shim -> --check reports drift (rc 1)
+  rm -f .claude/statusline.sh
+  if kit_wire_check >/dev/null 2>&1; then t "check detects drift" "0" "1"; else t "check detects drift" "1" "1"; fi
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_WIRE_TEST_INNER)"
+  exit "$fail"
+fi
+
+rc=0; ran=0
+for sh in bash zsh; do
+  command -v "$sh" >/dev/null 2>&1 || continue
+  ran=$((ran+1)); echo "--- $sh ---"
+  rcflag=""; [ "$sh" = "zsh" ] && rcflag="--no-rcs"
+  KIT_WIRE_TEST_INNER="$sh" PATH="$PATH" PLUGIN_DIR="$PLUGIN_DIR" "$sh" $rcflag "$0" || rc=1
+done
+[ "$ran" -eq 0 ] && { echo "no shell"; exit 1; }
+exit "$rc"

package/scripts/kit-wire.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# kit-wire.sh — idempotent "converge" that installs/repairs everything the kit must WIRE into a
+# project, and keeps it wired across updates (#369). Fixes the live class of bug where /kit-update
+# refreshes files but never re-runs the wiring, so settings drift and engine assets go stale.
+#
+# WHAT IT CONVERGES (each recorded in the F0 ownership manifest, so update/uninstall stay safe):
+#   1. statusline shim     .claude/statusline.sh  -> a STABLE file that exec's the plugin's
+#                          versioned kit-statusline.sh. The shim never changes, so a plugin bump
+#                          updates the statusline everywhere with zero local edits (kills the
+#                          "template drifted older than the project copy" bug).
+#   2. settings statusLine  ensures .claude/settings.json points its statusLine at the shim.
+#   3. hook executability    chmod +x on managed hooks so they actually run.
+#
+# Run:   scripts/kit-wire.sh            # converge (interactive confirms unless KIT_ASSUME_YES)
+#        scripts/kit-wire.sh --check    # report drift only, write nothing (rc 1 if drift) — self-heal
+#        KIT_ASSUME_YES=1 scripts/kit-wire.sh   # non-interactive (init/update/CI)
+#
+# Idempotent: a second run is a no-op. Honors KIT_DRY_RUN. Requires: jq.
+
+set -uo pipefail
+_wire_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+. "$_wire_dir/lib/kit-operate.sh"   # pulls in kit-manifest.sh too
+# shellcheck source=/dev/null
+. "$_wire_dir/lib/kit-cli.sh"       # kit_is_main
+
+# Where the running engine lives. As a Claude Code plugin, CLAUDE_PLUGIN_ROOT is set; otherwise
+# fall back to this script's plugin dir (two levels up from scripts/).
+kit_plugin_root() {
+  if [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then printf '%s\n' "$CLAUDE_PLUGIN_ROOT"; return 0; fi
+  ( CDPATH='' cd -- "$_wire_dir/.." && pwd )
+}
+
+# The shim is intentionally tiny and STABLE — its content never encodes a version, so it survives
+# plugin bumps. It resolves the newest installed kit plugin by glob and exec's its statusline.
+# (Falls back to a co-located plugin root for dev/source checkouts.)
+_kit_shim_content() {
+  cat <<'SHIM'
+#!/usr/bin/env bash
+# claude-kit statusline shim — DO NOT EDIT. Managed by `kit-wire` (kit.manifest.json).
+# Stable indirection: resolves the installed kit plugin and exec's its versioned statusline,
+# so a plugin update changes the statusline with no edit here. Fails soft (exit 0).
+set -uo pipefail
+_p="${CLAUDE_PLUGIN_ROOT:-}"
+if [ -z "$_p" ]; then
+  _p="$(ls -d "$HOME"/.claude/plugins/cache/*/claude-kit*/ 2>/dev/null | sort -V | tail -1)"
+fi
+_sl="$_p/statusline/kit-statusline.sh"
+[ -f "$_sl" ] || _sl="$_p/templates/statusline/kit-statusline.sh"
+if [ -f "$_sl" ]; then exec bash "$_sl" "$@"; fi
+cat >/dev/null 2>&1; exit 0   # no engine found: consume stdin, render nothing, never error
+SHIM
+}
+
+# Ensure .claude/settings.json has statusLine -> the shim. Uses jq; creates the file if absent.
+_kit_wire_settings() {
+  local settings=".claude/settings.json" shim=".claude/statusline.sh" cmd tmp cur want
+  cmd="\$CLAUDE_PROJECT_DIR/$shim"
+  if _kit_op_dry; then
+    cur="$(jq -r '.statusLine.command // empty' "$settings" 2>/dev/null || true)"
+    [ "$cur" = "$cmd" ] && { _kit_op_say "= settings.statusLine already wired"; return 0; }
+    _kit_op_say "~ would set settings.statusLine -> $cmd"; return 10
+  fi
+  [ -f "$settings" ] || printf '{}\n' > "$settings"
+  cur="$(jq -r '.statusLine.command // empty' "$settings" 2>/dev/null || true)"
+  if [ "$cur" = "$cmd" ]; then _kit_op_say "= settings.statusLine already wired"; return 0; fi
+  tmp="$(mktemp)" || return 1
+  jq --arg c "$cmd" '.statusLine = {type:"command", command:$c}' "$settings" > "$tmp" \
+    && mv "$tmp" "$settings" || { rm -f "$tmp"; return 1; }
+  kit_manifest_record "$settings" B wire >/dev/null 2>&1 || true
+  _kit_op_say "+ wired settings.statusLine -> $cmd"
+}
+
+# chmod +x any managed hooks present under .claude/hooks (so they actually run).
+_kit_wire_hook_exec() {
+  local h changed=0
+  [ -d ".claude/hooks" ] || return 0
+  for h in .claude/hooks/*.sh; do
+    [ -f "$h" ] || continue
+    if [ ! -x "$h" ]; then
+      _kit_op_dry && { _kit_op_say "~ would chmod +x $h"; changed=1; continue; }
+      chmod +x "$h" && _kit_op_say "+ chmod +x $h" && changed=1
+    fi
+  done
+  return 0
+}
+
+kit_wire() {
+  command -v jq >/dev/null 2>&1 || { echo "kit-wire: jq required" >&2; return 1; }
+  local proot shim=".claude/statusline.sh"
+  proot="$(kit_plugin_root)"
+  _kit_op_say "kit-wire: plugin root = $proot"
+  mkdir -p .claude
+  # 1. statusline shim (tier B — CLI only). kit_op_write_content runs the conffiles machine.
+  _kit_shim_content | kit_op_write_content "$shim" B wire || return 1
+  [ -f "$shim" ] && [ -z "${KIT_DRY_RUN:-}" ] && chmod +x "$shim"
+  # 2. settings statusLine -> shim
+  _kit_wire_settings || true
+  # 3. hook executability
+  _kit_wire_hook_exec || true
+}
+
+# --check: report drift, write nothing, rc 1 if anything is out of sync (for SessionStart self-heal)
+# Also verifies that every accepted routine in kit.config.json has a matching cron entry.
+kit_wire_check() {
+  local drift=0
+  # 1. standard wire drift
+  KIT_DRY_RUN=1 kit_wire >/tmp/.kitwire.$$ 2>&1
+  if grep -qE '^[~+]|would' /tmp/.kitwire.$$; then
+    sed 's/^/  /' /tmp/.kitwire.$$ >&2; drift=1
+  fi
+  rm -f /tmp/.kitwire.$$
+  # 2. routines: check accepted crons are installed (fail-soft — missing crontab is not an error)
+  if command -v crontab >/dev/null 2>&1; then
+    local rt_script; rt_script="$(kit_plugin_root)/scripts/kit-routines.sh"
+    if [ -f "$rt_script" ]; then
+      bash "$rt_script" verify 2>/tmp/.kiwire-rt.$$ || { sed 's/^/  /' /tmp/.kiwire-rt.$$ >&2; drift=1; }
+      rm -f /tmp/.kiwire-rt.$$
+    fi
+  fi
+  return "$drift"
+}
+
+# CLI (direct execution only; zsh-safe guard)
+# CLI (direct execution only)
+if kit_is_main; then
+  case "${1:-}" in
+    --check) kit_wire_check;;
+    -h|--help) echo "usage: kit-wire.sh [--check]   (env: KIT_ASSUME_YES, KIT_DRY_RUN)";;
+    *) kit_wire;;
+  esac
+fi