@jeiemgi/cckit 0.1.6

package/scripts/install.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# install.sh — put cckit on your PATH. Symlinks bin/cckit into a bin dir (no copy, no build).
+# Usage: ./scripts/install.sh [target-bin-dir]   (default: ~/.local/bin, then /usr/local/bin)
+set -euo pipefail
+
+root="$(cd "$(dirname "$0")/.." && pwd)"
+src="$root/bin/cckit"
+[ -x "$src" ] || { echo "cckit: $src not found or not executable" >&2; exit 1; }
+
+# Pick a writable bin dir on PATH.
+target="${1:-}"
+if [ -z "$target" ]; then
+  for d in "$HOME/.local/bin" "/usr/local/bin" "$HOME/bin"; do
+    if [ -d "$d" ] && [ -w "$d" ]; then target="$d"; break; fi
+  done
+  [ -z "$target" ] && { mkdir -p "$HOME/.local/bin"; target="$HOME/.local/bin"; }
+fi
+
+ln -sf "$src" "$target/cckit"
+echo "cckit: linked $target/cckit -> $src"
+case ":$PATH:" in
+  *":$target:"*) echo "cckit: '$target' is on your PATH. Run: cckit help" ;;
+  *) echo "cckit: add '$target' to your PATH, then run: cckit help" ;;
+esac

package/scripts/kit-add-test.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# kit-add-test.sh — self-test for kit-add module stacking (#372). Runs under bash AND zsh.
+# Run:  bash scripts/kit-add-test.sh
+dir=$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)
+
+if [ -n "${KIT_ADD_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_ADD_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_ADD_TEST_INNER): $1"; fi; }
+  ADD="$dir/kit-add.sh"
+
+  export KIT_PROFILE_HOME="$(mktemp -d)"
+  export KIT_ASSUME_YES=1 KIT_VERSION=9.9.9
+  ws="$(mktemp -d)"; trap 'rm -rf "$KIT_PROFILE_HOME" "$ws"' EXIT
+  mkdir -p "$ws/myapp"
+  printf '%s\n' '{"workspace":{"name":"ws"},"mode":"guided"}' > "$ws/kit.workspace.json"
+  parent_before="$(cat "$ws/kit.workspace.json")"
+
+  # unknown module fails
+  "$ADD" doesnotexist --dir "$ws/myapp" >/dev/null 2>&1; t "unknown module rc" "$?" "1"
+
+  # add software (defaults) — island config created
+  "$ADD" software --dir "$ws/myapp" >/dev/null 2>&1; t "add rc" "$?" "0"
+  cfg="$ws/myapp/.claude/kit.config.json"
+  t "island created"   "$([ -f "$cfg" ] && echo yes)"                  "yes"
+  t "modules"          "$(jq -c .modules "$cfg")"                      '["software"]'
+  t "github wizard"    "$(jq -r .github.projectsV2 "$cfg")"            "true"
+  t "ci wizard"        "$(jq -r .ci.provider "$cfg")"                  "github-actions"
+  t "manifest tracks"  "$(jq -r '.entries["'.claude/kit.config.json'"] | has("hash")' "$ws/myapp/.claude/kit.manifest.json")" "true"
+
+  # parent workspace untouched
+  t "parent untouched" "$(cat "$ws/kit.workspace.json")" "$parent_before"
+
+  # idempotent: a 2nd identical run leaves the file byte-identical
+  before="$(cat "$cfg")"
+  "$ADD" software --dir "$ws/myapp" >/dev/null 2>&1
+  t "idempotent file"  "$(cat "$cfg")" "$before"
+
+  # --set override changes only that field; modules stay deduped
+  "$ADD" software --dir "$ws/myapp" --set deploy=vercel >/dev/null 2>&1
+  t "override deploy"  "$(jq -r .deploy.target "$cfg")" "vercel"
+  t "modules still one" "$(jq -c .modules "$cfg")" '["software"]'
+
+  # dry-run writes nothing new
+  fresh="$(mktemp -d)"; mkdir -p "$fresh/app"
+  KIT_DRY_RUN=1 "$ADD" software --dir "$fresh/app" >/dev/null 2>&1
+  t "dry-run no write" "$([ -f "$fresh/app/.claude/kit.config.json" ] && echo wrote || echo clean)" "clean"
+  rm -rf "$fresh"
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_ADD_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_ADD_TEST_INNER="$sh" PATH="$PATH" "$sh" $rcflag "$0" || rc=1
+done
+[ "$ran" -eq 0 ] && { echo "no shell"; exit 1; }
+exit "$rc"

package/scripts/kit-add.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# kit-add.sh — stack a MODULE onto a project (D1 "modules apilables", #372).  e.g. `kit add software`.
+#
+# THE MOMENT: a free workspace ("build me an app") becomes a GitHub-managed software island WITHOUT
+# restructuring anything above it (D4/D17). A module is identity, not a file dump (D14): kit-add
+# writes the island's .claude/kit.config.json (modules[] + wizard answers) through the F0 operation
+# machine, so it is manifest-tracked, idempotent (2x = no-op), dry-runnable, and removable. The
+# engine (agents/skills) is the installed plugin singleton — it is never copied per project.
+#
+# The ASKING (the wizard) is interactive and portable, so the kit-onboard skill / the /kit-add
+# command render it via AskUserQuestion and pass answers here as a file. This script also takes a
+# minimal terminal fallback so it stands alone.
+#
+# Run:
+#   scripts/kit-add.sh software [--dir DIR] --answers FILE     # non-interactive (skill/CI/tests)
+#   scripts/kit-add.sh software --set versioning=github --set deploy=vercel --set ci=github-actions
+#   KIT_ASSUME_YES=1 scripts/kit-add.sh software               # accept every recommended default
+#   KIT_DRY_RUN=1 scripts/kit-add.sh software                  # preview only
+# Requires: jq.
+
+set -uo pipefail
+_add_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+. "$_add_dir/lib/kit-interview.sh"   # catalog/apply (pulls kit-cli + kit-profile)
+# shellcheck source=/dev/null
+. "$_add_dir/lib/kit-operate.sh"     # four-beat machine + manifest
+
+# kit_add_module_exists <module> -> rc 0 if a module spec is installed
+kit_add_module_exists() { [ -f "$(kit_interview_catalog_file "$1")" ]; }
+
+# kit_add <module> <answersfile> [targetdir]
+# Merges the module's wizard answers onto the island config and persists via kit-operate.
+kit_add() {
+  command -v jq >/dev/null 2>&1 || { kit_die "jq required"; }
+  local module="$1" answers="$2" target="${3:-$PWD}"
+  [ -n "$module" ] || kit_die "usage: kit-add.sh <module> [--dir DIR] [--answers FILE | --set k=v ...]"
+  kit_add_module_exists "$module" || kit_die "unknown module '$module' (no $(kit_interview_catalog_file "$module"))"
+  [ -f "$answers" ] || kit_die "internal: answers file missing ($answers)"
+
+  # Operate + manifest are relative to the island root — work from there.
+  target="$(cd "$target" 2>/dev/null && pwd)" || kit_die "no such dir: $target"
+  cd "$target" || kit_die "cannot enter $target"
+
+  local cfg=".claude/kit.config.json" base merged tmp
+  base=""; [ -f "$cfg" ] && base="$cfg"
+  merged="$(kit_interview_apply "$module" "$answers" "$base")" || kit_die "deriving module config failed"
+  # Belt-and-suspenders: guarantee the module name is in modules[] even if the spec omitted it.
+  merged="$(printf '%s' "$merged" | jq --arg m "$module" '.modules = ((.modules // []) + [$m] | unique)')"
+
+  kit_say "kit add $module  ->  $target/$cfg"
+  printf '%s\n' "$merged" | kit_op_write_content "$cfg" A "add:$module"
+  local rc=$?
+  case $rc in
+    0)  kit_say "module '$module' active here. modules: $(printf '%s' "$merged" | jq -c '.modules')";;
+    10) kit_say "no change (already applied / declined / dry-run).";;
+    *)  kit_die "failed to write $cfg";;
+  esac
+  return 0
+}
+
+# --- collect answers from flags / env / minimal terminal fallback ---------
+# Builds a {key:value} JSON. Precedence: --answers FILE, then --set overrides, then for any unset
+# question: KIT_ASSUME_YES/non-tty -> default; tty -> ask once with the recommended default.
+_kit_add_collect() {
+  local module="$1" answers_file="$2"; shift 2
+  # All locals up front — a bare `local x` re-run in a loop prints the var under zsh (typeset-like).
+  local sets=("$@")
+  local catalog acc kv k v tmp nq i key def have pick qtext r
+  catalog="$(kit_interview_catalog "$module")" || return 1
+  acc="$(mktemp)"
+  if [ -n "$answers_file" ] && [ -f "$answers_file" ]; then cp "$answers_file" "$acc"; else printf '{}\n' > "$acc"; fi
+  # apply --set k=v
+  for kv in ${sets[@]+"${sets[@]}"}; do
+    k="${kv%%=*}"; v="${kv#*=}"
+    tmp="$(mktemp)"; jq --arg k "$k" --arg v "$v" '.[$k]=$v' "$acc" > "$tmp" && mv "$tmp" "$acc"
+  done
+  # fill the rest
+  nq="$(printf '%s' "$catalog" | jq '.questions | length')"; i=0
+  while [ "$i" -lt "$nq" ]; do
+    key="$(printf '%s' "$catalog" | jq -r ".questions[$i].key")"
+    def="$(printf '%s' "$catalog" | jq -r ".questions[$i].default // \"\"")"
+    have="$(jq -r --arg k "$key" '.[$k] // empty' "$acc")"
+    if [ -z "$have" ]; then
+      pick="$def"
+      if [ -z "${KIT_ASSUME_YES:-}" ] && [ -z "${KIT_DRY_RUN:-}" ] && [ -t 0 ]; then
+        qtext="$(printf '%s' "$catalog" | jq -r ".questions[$i].question")"
+        printf '%s [%s] ' "$qtext" "$def" >&2
+        r=""; IFS= read -r r </dev/tty 2>/dev/null || r=""
+        [ -n "$r" ] && pick="$r"
+      fi
+      tmp="$(mktemp)"; jq --arg k "$key" --arg v "$pick" '.[$k]=$v' "$acc" > "$tmp" && mv "$tmp" "$acc"
+    fi
+    i=$((i+1))
+  done
+  printf '%s\n' "$acc"   # caller reads the path, then removes it
+}
+
+# CLI
+if kit_is_main; then
+  _module=""; _target="$PWD"; _answers=""; _sets=()
+  while [ $# -gt 0 ]; do case "$1" in
+    --dir) _target="$2"; shift 2;;
+    --answers) _answers="$2"; shift 2;;
+    --set) _sets+=("$2"); shift 2;;
+    -h|--help) echo "usage: kit-add.sh <module> [--dir DIR] [--answers FILE] [--set k=v ...]   (env: KIT_ASSUME_YES, KIT_DRY_RUN)"; exit 0;;
+    -*) kit_die "unknown flag: $1";;
+    *) [ -z "$_module" ] && _module="$1" || kit_die "unexpected arg: $1"; shift;;
+  esac; done
+  [ -n "$_module" ] || kit_die "usage: kit-add.sh <module> [--dir DIR] [--answers FILE] [--set k=v ...]"
+  kit_add_module_exists "$_module" || kit_die "unknown module '$_module'"
+  _af="$(_kit_add_collect "$_module" "$_answers" ${_sets[@]+"${_sets[@]}"})" || kit_die "collecting answers failed"
+  kit_add "$_module" "$_af" "$_target"; _rc=$?
+  rm -f "$_af"
+  exit $_rc
+fi

package/scripts/kit-adopt-test.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# kit-adopt-test.sh — self-test for kit-adopt (#373). Runs under bash AND zsh.
+# Run:  bash scripts/kit-adopt-test.sh
+PLUGIN_DIR=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
+
+if [ -n "${KIT_ADOPT_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_ADOPT_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_ADOPT_TEST_INNER): $1"; fi; }
+
+  proj="$(mktemp -d)"; trap 'rm -rf "$proj"' EXIT
+  cd "$proj"
+  . "$PLUGIN_DIR/scripts/kit-adopt.sh"
+  . "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"
+
+  # A project that imported kit files by hand: skills + a rule + statusline (unmanaged) + user content.
+  mkdir -p .claude/skills/kit-task-pr .claude/rules knowledge
+  printf 'pr skill\n'   > .claude/skills/kit-task-pr/SKILL.md
+  printf 'a rule\n'     > .claude/rules/branch-naming.md
+  printf '#!/bin/sh\n'  > .claude/statusline.sh
+  printf 'my notes\n'   > knowledge/doc.md     # user content — must NEVER be a candidate
+
+  # --check: 3 kit-shaped files unmanaged -> rc 1, knowledge/ excluded.
+  out="$(kit_adopt_check 2>&1)"; rc=$?
+  t "check rc=1 when unmanaged exist" "$rc" "1"
+  t "check counts the 3 kit files"    "$(printf '%s' "$out" | grep -c '?')" "3"
+  t "check never lists knowledge/"    "$(printf '%s' "$out" | grep -c 'knowledge/')" "0"
+
+  # dry-run records nothing.
+  KIT_DRY_RUN=1 kit_adopt_all >/dev/null 2>&1
+  t "dry-run writes no manifest" "$([ -f .claude/kit.manifest.json ] && echo yes || echo no)" "no"
+
+  # real adopt (assume-yes): all 3 recorded, knowledge untouched.
+  KIT_ASSUME_YES=1 kit_adopt_all >/dev/null 2>&1
+  t "skill now tracked"     "$(kit_manifest_verify .claude/skills/kit-task-pr/SKILL.md)" "intact"
+  t "rule now tracked"      "$(kit_manifest_verify .claude/rules/branch-naming.md)" "intact"
+  t "statusline now tracked" "$(kit_manifest_verify .claude/statusline.sh)" "intact"
+  t "statusline tier=B"     "$(kit_manifest_get .claude/statusline.sh | jq -r .tier)" "B"
+  t "skill tier=A"          "$(kit_manifest_get .claude/skills/kit-task-pr/SKILL.md | jq -r .tier)" "A"
+  t "op=adopt"              "$(kit_manifest_get .claude/rules/branch-naming.md | jq -r .op)" "adopt"
+  t "knowledge NOT tracked" "$(kit_manifest_verify knowledge/doc.md)" "untracked"
+
+  # idempotent: a second adopt finds nothing new; --check is clean (rc 0).
+  out2="$(KIT_ASSUME_YES=1 kit_adopt_all 2>&1)"
+  t "2nd adopt no-op"  "$(printf '%s' "$out2" | grep -c 'nothing to adopt')" "1"
+  kit_adopt_check >/dev/null 2>&1
+  t "check clean after adopt rc=0" "$?" "0"
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_ADOPT_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_ADOPT_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-adopt.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# kit-adopt.sh — adopt kit-shaped files a project ALREADY has into the ownership manifest (#373).
+#
+# THE MOMENT: a project imported the kit by hand (copied a .claude/ from another repo, ran an old
+# init, or a teammate pasted skills/rules in) — the files are PRESENT but the manifest doesn't know
+# them, so update/remove can't manage them safely (kit_manifest_verify says `untracked` -> "never
+# touch"). kit-adopt walks the kit-shaped paths that exist on disk, shows what it would adopt
+# (dry-run diff), and — on confirm — RECORDS each into the manifest at its current hash. It writes
+# NO file content; it only takes ownership of what's already there. After adopting, /kit-update can
+# refresh them and kit-remove can leave clean.
+#
+# It is the read-only counterpart to kit-wire: wire WRITES the kit's own files; adopt CLAIMS files
+# the project brought. It never claims a file that is not kit-shaped (your knowledge/, plans/,
+# drafts/, app code are off-limits) and never overwrites — adoption is hash-recording only.
+#
+# Run:
+#   scripts/kit-adopt.sh             # interactive: list candidates, confirm, record
+#   scripts/kit-adopt.sh --dry-run   # preview only
+#   scripts/kit-adopt.sh --check     # report unmanaged kit-shaped files, write nothing (rc 1 if any)
+#   KIT_ASSUME_YES=1 scripts/kit-adopt.sh   # non-interactive (init/CI/Cowork)
+# Requires: jq + a sha256 tool.
+
+set -uo pipefail
+_adopt_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+. "$_adopt_dir/lib/kit-operate.sh"   # four-beat machine + kit-manifest.sh
+# shellcheck source=/dev/null
+. "$_adopt_dir/lib/kit-cli.sh"       # kit_is_main
+
+# Tier-classify a kit-shaped path. Statusline shim + settings + hooks are CLI-only (tier B); the
+# portable skills/rules/agents/commands are tier A (work in Cowork/claude.ai too). Mirrors kit-wire.
+_kit_adopt_tier() {
+  case "$1" in
+    .claude/statusline.sh|.claude/settings.json|.claude/hooks/*|.claude/lib/*) printf 'B' ;;
+    *) printf 'A' ;;
+  esac
+}
+
+# Emit the set of kit-shaped paths that EXIST under the project but are NOT yet in the manifest.
+# "kit-shaped" = the directories the kit owns (skills/rules/agents/commands/hooks/lib) + the two
+# wired singletons. Never the user's content trees (knowledge/, plans/, drafts/, apps/, src/).
+# One relpath per line.
+kit_adopt_candidates() {
+  local p verdict
+  # Files under the kit-owned .claude subtrees.
+  while IFS= read -r p; do
+    [ -n "$p" ] || continue
+    p="${p#./}"
+    verdict="$(kit_manifest_verify "$p" 2>/dev/null || true)"
+    [ "$verdict" = "untracked" ] && printf '%s\n' "$p"
+  done < <(
+    find .claude/skills .claude/rules .claude/agents .claude/commands \
+         .claude/hooks .claude/lib -type f 2>/dev/null
+  )
+  # The two wired singletons, if present.
+  for p in .claude/statusline.sh .claude/settings.json; do
+    [ -f "$p" ] || continue
+    verdict="$(kit_manifest_verify "$p" 2>/dev/null || true)"
+    [ "$verdict" = "untracked" ] && printf '%s\n' "$p"
+  done
+}
+
+# kit_adopt_all — record every unmanaged kit-shaped file into the manifest at its current hash.
+# Honors KIT_DRY_RUN (report only) and KIT_ASSUME_YES (skip the confirm). Returns 0 always (a clean
+# project with nothing to adopt is success).
+kit_adopt_all() {
+  command -v jq >/dev/null 2>&1 || { echo "kit-adopt: jq required" >&2; return 1; }
+
+  # Collect candidates into an array first (a per-file confirm's read must not eat the loop's stdin).
+  local arr=() line
+  while IFS= read -r line; do [ -n "$line" ] && arr+=("$line"); done < <(kit_adopt_candidates)
+
+  local n="${#arr[@]}"
+  if [ "$n" -eq 0 ]; then _kit_op_say "kit-adopt: nothing to adopt — every kit-shaped file is already tracked (or none present)."; return 0; fi
+
+  _kit_op_say "kit-adopt: $n unmanaged kit-shaped file(s) found:"
+  local p; for p in ${arr[@]+"${arr[@]}"}; do _kit_op_say "  + adopt $p ($(_kit_adopt_tier "$p"))"; done
+
+  if _kit_op_dry; then _kit_op_say "  [dry-run] would record $n file(s) into the manifest"; return 0; fi
+
+  if [ -z "${KIT_ASSUME_YES:-}" ]; then
+    printf 'kit-adopt: take ownership of these %s file(s) in the manifest? [y/N] ' "$n" >&2
+    local _c=""; IFS= read -r _c </dev/tty 2>/dev/null || IFS= read -r _c 2>/dev/null || _c=""
+    case "$_c" in y|Y|yes|YES) ;; *) _kit_op_say "kit-adopt: aborted (nothing recorded)."; return 0;; esac
+  fi
+
+  kit_manifest_init || return 1
+  local adopted=0
+  for p in ${arr[@]+"${arr[@]}"}; do
+    kit_manifest_record "$p" "$(_kit_adopt_tier "$p")" adopt >/dev/null && {
+      adopted=$((adopted+1)); _kit_op_say "  adopted: $p"
+    }
+  done
+  _kit_op_say "kit-adopt: $adopted file(s) now manifest-managed (update/remove can handle them safely)."
+}
+
+# --check: report unmanaged kit-shaped files, write nothing, rc 1 if any exist (SessionStart nudge).
+kit_adopt_check() {
+  local arr=() line
+  while IFS= read -r line; do [ -n "$line" ] && arr+=("$line"); done < <(kit_adopt_candidates)
+  local n="${#arr[@]}"
+  [ "$n" -eq 0 ] && return 0
+  _kit_op_say "kit-adopt --check: $n kit-shaped file(s) present but unmanaged — run 'kit-adopt' to take ownership:"
+  local p; for p in ${arr[@]+"${arr[@]}"}; do _kit_op_say "  ? $p"; done
+  return 1
+}
+
+# CLI (direct execution only)
+if kit_is_main; then
+  _mode=run
+  while [ $# -gt 0 ]; do case "$1" in
+    --dry-run) export KIT_DRY_RUN=1; shift;;
+    --yes|-y)  export KIT_ASSUME_YES=1; shift;;
+    --check)   _mode=check; shift;;
+    -h|--help) echo "usage: kit-adopt.sh [--check] [--dry-run] [--yes]   (env: KIT_ASSUME_YES, KIT_DRY_RUN)"; exit 0;;
+    *) echo "unknown arg: $1" >&2; exit 2;;
+  esac; done
+  case "$_mode" in
+    check) kit_adopt_check;;
+    *)     kit_adopt_all;;
+  esac
+fi

package/scripts/kit-bump-version.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# Bump the claude-kit plugin version in EVERY place that must stay in sync:
+#   <plugin>/.claude-plugin/plugin.json        .version
+#   <plugin>/.claude-plugin/version.json        .version + .channels.<beta|stable>.version
+#   <plugin>/package.json                       .version
+#   <plugin>/.claude-plugin/marketplace.json    .metadata.version + .plugins[claude-kit].version
+#   <repo-root>/.claude-plugin/marketplace.json (when present) — same two fields
+#
+# Usage: kit-bump-version.sh [beta|patch|minor|<explicit-version>]
+#   beta  (default)  0.7.0-beta.1 -> 0.7.0-beta.2 ; 0.7.0 -> 0.7.1-beta.1   (-> channels.beta)
+#   patch            0.7.0-beta.N -> 0.7.0        ; 0.7.0 -> 0.7.1           (-> channels.stable)
+#   minor            0.7.x[-*]    -> 0.8.0                                   (-> channels.stable)
+#   1.2.3-rc.1       set verbatim
+#
+# version.json is the canonical channel descriptor: a `-beta.N` build advances channels.beta,
+# a clean release advances channels.stable. /kit-dev ship runs this so the installed plugin
+# (deduped by version) sees every release.
+set -euo pipefail
+
+# Resolve the plugin dir from this script's location (BASH_SOURCE), so it works run from the
+# plugin checkout OR the monorepo. Repo root is best-effort (for the optional root marketplace).
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+plugin_dir="$(cd "$script_dir/.." && pwd)"
+repo_root="$(git -C "$plugin_dir" rev-parse --show-toplevel 2>/dev/null || true)"
+
+plugin_json="$plugin_dir/.claude-plugin/plugin.json"
+version_json="$plugin_dir/.claude-plugin/version.json"
+package_json="$plugin_dir/package.json"
+sub_marketplace_json="$plugin_dir/.claude-plugin/marketplace.json"
+root_marketplace_json="${repo_root:+$repo_root/.claude-plugin/marketplace.json}"
+[[ -f $plugin_json ]] || { echo "✗ plugin.json not found at $plugin_json" >&2; exit 1; }
+
+mode="${1:-beta}"
+current="$(jq -r .version "$plugin_json")"
+
+core="${current%%-*}"
+pre=""; [[ $current == *-* ]] && pre="${current#*-}"
+IFS=. read -r maj min pat <<<"$core"
+
+channel="stable"   # which channel this bump advances
+case "$mode" in
+  beta)
+    channel="beta"
+    if [[ $pre == beta.* ]]; then
+      next="$core-beta.$(( ${pre#beta.} + 1 ))"
+    else
+      next="$maj.$min.$((pat + 1))-beta.1"
+    fi
+    ;;
+  patch)
+    if [[ -n $pre ]]; then next="$core"; else next="$maj.$min.$((pat + 1))"; fi
+    ;;
+  minor)
+    next="$maj.$((min + 1)).0"
+    ;;
+  *)
+    [[ $mode =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z0-9.]+)?$ ]] || { echo "✗ '$mode' is not beta|patch|minor or a semver" >&2; exit 1; }
+    next="$mode"
+    [[ $next == *-* ]] && channel="beta"
+    ;;
+esac
+
+_set() { local f="$1" filter="$2"; [[ -f "$f" ]] || return 0; local t; t="$(mktemp)"; jq "$filter" "$f" >"$t" && mv "$t" "$f"; }
+
+_set "$plugin_json"  '.version = "'"$next"'"'
+_set "$package_json" '.version = "'"$next"'"'
+# version.json: top-level version + the advancing channel's version.
+_set "$version_json" '.version = "'"$next"'" | .channels.'"$channel"'.version = "'"$next"'"'
+
+mkt_bumped=0
+for mkt in "$root_marketplace_json" "$sub_marketplace_json"; do
+  [[ -n "$mkt" && -f "$mkt" ]] || continue
+  t="$(mktemp)"
+  jq --arg v "$next" '.metadata.version = $v | (.plugins[] | select(.name == "claude-kit") | .version) = $v' \
+    "$mkt" >"$t" && mv "$t" "$mkt"
+  mkt_bumped=$((mkt_bumped + 1))
+done
+
+echo "✓ claude-kit $current -> $next (channel: $channel; plugin.json + version.json + package.json + $mkt_bumped marketplace.json)"

package/scripts/kit-digest.sh

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# kit-digest.sh — pre-digest long inputs (transcripts, CI logs, big files, YouTube URLs)
+# with the LOCAL model (scripts/lib/kit-local.sh + mlx_lm.server) so the Claude session
+# reads a <=1500-token digest + a pointer to the original instead of the full content.
+#
+# Usage:
+#   ./scripts/kit-digest.sh <path|url> [--focus "<topic>"] [--lang es|en]
+#
+# Exit codes: 0 digest printed · 2 local server down (caller falls back to reading the
+# original directly) · 1 input/usage error.
+#
+# Chunking: inputs are split into ~2500-word chunks (map), each digested locally, then
+# merged in a final reduce pass when there is more than one chunk.
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Plugin-direct: stay in the caller's CWD so the project's .claude/kit.config.json
+# (.local model/port) is read; the helper + inputs resolve by absolute path.
+
+# shellcheck source=lib/kit-local.sh
+source "$SCRIPT_DIR/lib/kit-local.sh"
+
+INPUT="${1:-}"
+FOCUS=""
+LANG_OUT="es"
+shift || true
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --focus) FOCUS="$2"; shift 2 ;;
+    --lang)  LANG_OUT="$2"; shift 2 ;;
+    *) echo "kit-digest: unknown flag $1" >&2; exit 1 ;;
+  esac
+done
+
+[[ -z "$INPUT" ]] && { echo "usage: kit-digest.sh <path|url> [--focus \"<topic>\"] [--lang es|en]" >&2; exit 1; }
+
+if ! kit_local_alive; then
+  echo "kit-digest: local server down (mlx_lm.server :${KIT_LOCAL_PORT}) — read the original directly instead." >&2
+  echo "  start it: mlx_lm.server --model ${KIT_LOCAL_MODEL} --port ${KIT_LOCAL_PORT}" >&2
+  exit 2
+fi
+
+# ---------------------------------------------------------------------------
+# Acquire text
+# ---------------------------------------------------------------------------
+WORK="$(mktemp -d /tmp/kit-digest.XXXXXX)" || exit 1
+trap 'rm -rf "$WORK"' EXIT
+TEXT="$WORK/input.txt"
+SOURCE_DESC="$INPUT"
+
+vtt_to_text() {  # stdin: VTT -> stdout: deduped plain text
+  python3 -c '
+import re, sys
+out, prev = [], ""
+for l in sys.stdin:
+    l = l.strip()
+    if not l or "-->" in l or l.startswith(("WEBVTT", "Kind:", "Language:")) or re.match(r"^\d+$", l):
+        continue
+    l = re.sub(r"<[^>]+>", "", l)
+    if l != prev:
+        out.append(l); prev = l
+print(re.sub(r"\s+", " ", " ".join(out)))'
+}
+
+if [[ "$INPUT" =~ ^https?://(www\.)?(youtube\.com|youtu\.be)/ ]]; then
+  command -v yt-dlp >/dev/null 2>&1 || { echo "kit-digest: yt-dlp required for YouTube URLs (brew install yt-dlp)" >&2; exit 1; }
+  TITLE="$(yt-dlp --skip-download --print '%(title)s' "$INPUT" 2>/dev/null | head -1 || true)"
+  SOURCE_DESC="${TITLE:-$INPUT} ($INPUT)"
+  yt-dlp --skip-download --write-auto-subs --write-subs --sub-langs "en.*,es.*" --sub-format vtt \
+    -o "$WORK/yt" "$INPUT" >/dev/null 2>&1 || true
+  VTT="$(ls "$WORK"/yt*.vtt 2>/dev/null | head -1 || true)"
+  [[ -z "$VTT" ]] && { echo "kit-digest: no subtitles found for $INPUT" >&2; exit 1; }
+  vtt_to_text < "$VTT" > "$TEXT"
+elif [[ "$INPUT" =~ ^https?:// ]]; then
+  curl -sfL -m 30 "$INPUT" 2>/dev/null \
+    | perl -0pe 's/<script\b.*?<\/script>//gs; s/<style\b.*?<\/style>//gs; s/<[^>]+>/ /gs' \
+    | tr -s ' \t\n' ' ' > "$TEXT" || { echo "kit-digest: fetch failed: $INPUT" >&2; exit 1; }
+else
+  [[ -f "$INPUT" ]] || { echo "kit-digest: file not found: $INPUT" >&2; exit 1; }
+  case "$INPUT" in
+    *.vtt) vtt_to_text < "$INPUT" > "$TEXT" ;;
+    *)     cat "$INPUT" > "$TEXT" ;;
+  esac
+fi
+
+WORDS=$(wc -w < "$TEXT" | tr -d ' ')
+[[ "${WORDS:-0}" -eq 0 ]] && { echo "kit-digest: empty input" >&2; exit 1; }
+
+# ---------------------------------------------------------------------------
+# Map (digest per ~2500-word chunk) -> reduce (merge)
+# ---------------------------------------------------------------------------
+CHUNK_WORDS=2500
+if [[ "$LANG_OUT" == "en" ]]; then
+  SYS_MAP="You summarize for an engineering audience. Extract the key points, decisions, numbers and names from this fragment as tight bullets. No intro, no closing."
+  SYS_REDUCE="Merge these partial digests into ONE digest of at most 1500 tokens: tight bullets grouped by theme, keep concrete numbers/names/refs. No intro, no closing."
+else
+  SYS_MAP="Resumes para una audiencia de ingenieria. Extrae los puntos clave, decisiones, numeros y nombres de este fragmento en bullets apretados. Sin intro ni cierre."
+  SYS_REDUCE="Fusiona estos digests parciales en UN digest de maximo 1500 tokens: bullets apretados agrupados por tema, conserva numeros/nombres/refs concretos. Sin intro ni cierre."
+fi
+[[ -n "$FOCUS" ]] && SYS_MAP="$SYS_MAP Prioriza todo lo relacionado con: $FOCUS."
+
+# One chunk per line, CHUNK_WORDS words each (awk: xargs would choke on quotes).
+awk -v n="$CHUNK_WORDS" '{for(i=1;i<=NF;i++){printf "%s%s",$i,(++c%n==0?"\n":" ")}}END{if(c%n!=0)print ""}' \
+  "$TEXT" > "$WORK/wrapped.txt"
+split -l 1 "$WORK/wrapped.txt" "$WORK/chunk." 2>/dev/null
+
+PARTS=()
+for c in "$WORK"/chunk.*; do
+  [[ -s "$c" ]] || continue
+  part="$(kit_local_chat "$SYS_MAP" "$(cat "$c")" 700)" || { echo "kit-digest: local chat failed mid-run" >&2; exit 2; }
+  PARTS+=("$part")
+done
+
+if [[ ${#PARTS[@]} -eq 1 ]]; then
+  DIGEST="${PARTS[0]}"
+else
+  ALL="$(printf '%s\n\n' "${PARTS[@]}")"
+  DIGEST="$(kit_local_chat "$SYS_REDUCE" "$ALL" 1500)" || DIGEST="$ALL"
+fi
+
+echo "# Digest (local: $(kit_local_model_tag)) — $SOURCE_DESC"
+echo
+printf '%s\n' "$DIGEST"
+echo
+echo "---"
+echo "Original: $INPUT ($WORDS palabras, ${#PARTS[@]} chunk(s)) — para deep-dive selectivo, lee el original."