@jeiemgi/cckit 0.1.6

package/scripts/kit-export-project-test.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# kit-export-project-test.sh — self-test for kit-export-project (#376). Runs under bash AND zsh.
+# Run:  bash scripts/kit-export-project-test.sh
+PLUGIN_DIR=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
+
+if [ -n "${KIT_EXPORT_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_EXPORT_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_EXPORT_TEST_INNER): $1"; fi; }
+
+  proj="$(mktemp -d)"; trap 'rm -rf "$proj"' EXIT
+  cd "$proj"
+  . "$PLUGIN_DIR/scripts/kit-export-project.sh"
+  . "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"
+
+  # A kit project: CLAUDE.md importing a tier-A rule + a tier-B hook; a knowledge corpus.
+  mkdir -p .claude/rules .claude/hooks .claude/agents knowledge
+  printf '# My Project\n\nRules:\n@.claude/rules/branch-naming.md\n\nHooks:\n@.claude/hooks/guard.sh\n' > CLAUDE.md
+  printf 'BRANCH RULE BODY\n'  > .claude/rules/branch-naming.md
+  printf '#!/bin/sh\nguard\n'  > .claude/hooks/guard.sh
+  printf 'AGENT BODY\n'        > .claude/agents/pm.md
+  printf 'KNOWLEDGE DOC\n'     > knowledge/doc.md
+
+  # Tier classification: rule = A, hook = B (heuristic, no manifest yet).
+  t "rule is tier A"  "$(kit_export_tier .claude/rules/branch-naming.md)" "A"
+  t "hook is tier B"  "$(kit_export_tier .claude/hooks/guard.sh)" "B"
+
+  # --verify: a tier-B import that CLAUDE.md requires is a portability defect -> rc 1.
+  kit_export_verify CLAUDE.md >/dev/null 2>&1
+  t "verify flags tier-B require (rc 1)" "$?" "1"
+
+  # Flattened instructions: inline the tier-A rule body, SKIP the tier-B hook (note it).
+  flat="$(kit_export_flatten_instructions CLAUDE.md)"
+  t "inlines tier-A rule body"     "$(printf '%s' "$flat" | grep -c 'BRANCH RULE BODY')" "1"
+  t "marks tier-A inline"          "$(printf '%s' "$flat" | grep -c 'tier A')" "1"
+  t "skips tier-B hook body"       "$(printf '%s' "$flat" | grep -c 'guard$')" "0"
+  t "notes tier-B skip"            "$(printf '%s' "$flat" | grep -c 'tier B')" "1"
+  t "keeps non-import prose"       "$(printf '%s' "$flat" | grep -c 'My Project')" "1"
+
+  # dry-run writes nothing.
+  KIT_DRY_RUN=1 kit_export_all .kit-export knowledge >/dev/null 2>&1
+  t "dry-run writes no out dir" "$([ -d .kit-export ] && echo yes || echo no)" "no"
+
+  # real export: instructions + knowledge copy + matrix all present; knowledge content carried.
+  kit_export_all .kit-export knowledge >/dev/null 2>&1
+  t "instructions written"  "$([ -f .kit-export/claude-instructions.md ] && echo yes || echo no)" "yes"
+  t "matrix written"        "$([ -f .kit-export/SUPPORT-MATRIX.md ] && echo yes || echo no)" "yes"
+  t "knowledge copied"      "$([ -f .kit-export/project-knowledge/knowledge/doc.md ] && echo yes || echo no)" "yes"
+  t "tier-A agents copied"  "$([ -f .kit-export/project-knowledge/agents/pm.md ] && echo yes || echo no)" "yes"
+  t "tier-B hook NOT in instructions" "$(grep -c 'guard$' .kit-export/claude-instructions.md)" "0"
+
+  # matrix has the three surfaces.
+  m="$(kit_export_matrix)"
+  t "matrix names claude.ai"  "$(printf '%s' "$m" | grep -qi 'claude.ai' && echo yes || echo no)" "yes"
+  t "matrix names Cowork"     "$(printf '%s' "$m" | grep -qi 'Cowork'    && echo yes || echo no)" "yes"
+  t "matrix names Terminal"   "$(printf '%s' "$m" | grep -qi 'Terminal'  && echo yes || echo no)" "yes"
+
+  # Now make the hook tier-A via the manifest: --verify should pass (portable).
+  kit_manifest_record .claude/rules/branch-naming.md A wire >/dev/null 2>&1
+  kit_manifest_record .claude/hooks/guard.sh A wire >/dev/null 2>&1   # force A to simulate a portable file
+  t "manifest tier wins over heuristic" "$(kit_export_tier .claude/hooks/guard.sh)" "A"
+  kit_export_verify CLAUDE.md >/dev/null 2>&1
+  t "verify passes when all imports tier-A (rc 0)" "$?" "0"
+
+  # A missing import is a defect on every surface.
+  printf '\n@.claude/rules/gone.md\n' >> CLAUDE.md
+  kit_export_verify CLAUDE.md >/dev/null 2>&1
+  t "verify flags a missing import (rc 1)" "$?" "1"
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_EXPORT_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_EXPORT_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-export-project.sh

@@ -0,0 +1,245 @@
+#!/usr/bin/env bash
+# kit-export-project.sh — export a kit project to the two non-terminal Claude surfaces (#376).
+#
+# THE GOAL (the acceptance gate): the SAME project runs in three places with NO hand edits —
+#   1. terminal   — Claude Code reads CLAUDE.md + .claude/ natively (the home surface).
+#   2. Cowork     — Claude Code in the cloud; reads the same CLAUDE.md + .claude/ tree natively.
+#   3. claude.ai  — a Project has TWO slots (no .claude/ tree): "custom instructions" (one text box)
+#                   + "project knowledge" (uploaded files). It cannot run scripts.
+#
+# Terminal + Cowork need NOTHING from this tool — they read the repo as-is. The only surface that
+# needs a transform is claude.ai, because it has no filesystem: we FLATTEN CLAUDE.md (resolving its
+# @-imports of .claude/rules/*) into ONE instructions file, and COPY the knowledge corpus into an
+# upload-ready folder. We also VERIFY Cowork compat (every file the project leans on is tier-A
+# portable, not a tier-B CLI-only shim) and print a support matrix.
+#
+# TIER MODEL (#373, recorded in .claude/kit.manifest.json):
+#   tier A = portable  — skills/rules/agents/commands; meaningful in Cowork AND claude.ai.
+#   tier B = CLI-only  — statusline.sh / settings.json / hooks/ / lib/ ; need a terminal+filesystem.
+# The export carries ONLY tier-A semantics to claude.ai; a tier-B file the project REQUIRES to
+# function is a portability defect we flag (it would silently no-op off-terminal).
+#
+# OUTPUT (default .kit-export/, override with --out DIR):
+#   claude-instructions.md   the flattened CLAUDE.md + inlined @.claude/rules/* — paste into the
+#                            claude.ai Project's "custom instructions" box.
+#   project-knowledge/       knowledge/** (+ agents/ + rules/ as reference) — upload as Project knowledge.
+#   SUPPORT-MATRIX.md        terminal / Cowork / claude.ai feature support, generated from the manifest.
+#
+# Run:
+#   scripts/kit-export-project.sh                 # full export to .kit-export/
+#   scripts/kit-export-project.sh --out build/x   # custom output dir
+#   scripts/kit-export-project.sh --verify        # Cowork+claude.ai compat check only, write nothing (rc 1 on defect)
+#   scripts/kit-export-project.sh --matrix        # print the support matrix to stdout, write nothing
+#   scripts/kit-export-project.sh --dry-run       # report what it would write, write nothing
+# Requires: jq + a sha256 tool (for tier lookups via the manifest).
+
+set -uo pipefail
+_export_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+. "$_export_dir/lib/kit-cli.sh"        # kit_is_main
+# shellcheck source=/dev/null
+. "$_export_dir/lib/kit-manifest.sh"   # tier lookups
+
+_kex_say() { printf '%s\n' "$*" >&2; }
+
+# Tier-classify a kit-shaped path the same way kit-wire/kit-adopt do — manifest first (authoritative,
+# carries the tier the file was wired with), heuristic fallback when the file isn't manifest-tracked
+# (e.g. a hand-imported project that never ran kit-adopt).
+kit_export_tier() {
+  local p="$1" t
+  t="$(kit_manifest_get "$p" 2>/dev/null | jq -r '.tier // empty' 2>/dev/null || true)"
+  if [ -n "$t" ]; then printf '%s\n' "$t"; return 0; fi
+  case "$p" in
+    .claude/statusline.sh|.claude/settings.json|.claude/settings.local.json|.claude/hooks/*|.claude/lib/*) printf 'B\n' ;;
+    *) printf 'A\n' ;;
+  esac
+}
+
+# Resolve a Claude `@path` import to a relpath. Claude Code imports are written `@.claude/rules/x.md`
+# or `@./KIT.md`; strip the leading @ and any ./ — return empty for a non-import line.
+_kex_import_path() {
+  case "$1" in
+    @*) printf '%s\n' "${1#@}" | sed 's#^\./##' ;;
+    *)  printf '\n' ;;
+  esac
+}
+
+# Flatten CLAUDE.md into a single instructions document for claude.ai. We INLINE every @-import
+# (the .claude/rules/* and any @./KIT.md) so the one text box carries the whole instruction set —
+# claude.ai can't follow an @ to a file it doesn't have. Imports are inlined ONCE (dedup) and only
+# tier-A files are inlined (a tier-B shim has no meaning without a terminal). Non-import lines pass
+# through verbatim. Recurses one level into imported rule files (they rarely chain, but we guard a
+# seen-set so a cycle can't loop).
+kit_export_flatten_instructions() {
+  local claude_md="${1:-CLAUDE.md}"
+  [ -f "$claude_md" ] || { _kex_say "kit-export: $claude_md not found"; return 1; }
+
+  # seen-set for dedup/cycle-guard (newline-delimited paths already inlined)
+  local seen=""
+  _kex_emit_file() {  # <relpath> <depth>
+    local f="$1" depth="$2" line ip tier
+    case "$seen" in *"|$f|"*) return 0 ;; esac
+    seen="$seen|$f|"
+    while IFS= read -r line || [ -n "$line" ]; do
+      ip="$(_kex_import_path "$line")"
+      if [ -n "$ip" ] && [ -f "$ip" ] && [ "$depth" -lt 4 ]; then
+        tier="$(kit_export_tier "$ip")"
+        if [ "$tier" = "A" ]; then
+          printf '\n<!-- inlined from %s (tier A) -->\n' "$ip"
+          _kex_emit_file "$ip" $((depth + 1))
+        else
+          printf '\n<!-- skipped %s (tier B — CLI-only, no meaning on claude.ai) -->\n' "$ip"
+        fi
+      else
+        printf '%s\n' "$line"
+      fi
+    done < "$f"
+  }
+
+  printf '<!-- Generated by kit-export-project (#376) — paste into the claude.ai Project custom-instructions box. -->\n'
+  printf '<!-- Source: %s + inlined @.claude/rules/* (tier-A). Terminal/Cowork read the repo directly. -->\n\n' "$claude_md"
+  _kex_emit_file "$claude_md" 0
+}
+
+# Cowork + claude.ai compat verdict. Cowork runs Claude Code natively, so the question is: does the
+# project FUNCTION when only the portable (tier-A) surface is honored? Any file CLAUDE.md imports
+# that is tier-B is a portability defect (it silently no-ops off-terminal). rc 0 = portable, 1 = defect.
+kit_export_verify() {
+  local claude_md="${1:-CLAUDE.md}" defects=0 line ip tier
+  if [ ! -f "$claude_md" ]; then _kex_say "kit-export --verify: $claude_md not found"; return 1; fi
+  _kex_say "kit-export --verify: checking that the portable surface is self-sufficient..."
+  while IFS= read -r line || [ -n "$line" ]; do
+    ip="$(_kex_import_path "$line")"
+    [ -n "$ip" ] || continue
+    if [ ! -f "$ip" ]; then
+      _kex_say "  ! CLAUDE.md imports $ip but it is MISSING — broken on every surface"
+      defects=$((defects + 1)); continue
+    fi
+    tier="$(kit_export_tier "$ip")"
+    if [ "$tier" = "B" ]; then
+      _kex_say "  ! CLAUDE.md requires $ip (tier B / CLI-only) — silently no-ops in Cowork/claude.ai"
+      defects=$((defects + 1))
+    else
+      _kex_say "  ok $ip (tier A — portable)"
+    fi
+  done < "$claude_md"
+  if [ "$defects" -eq 0 ]; then
+    _kex_say "kit-export --verify: PORTABLE — the same project runs in terminal / Cowork / claude.ai with no hand edits."
+    return 0
+  fi
+  _kex_say "kit-export --verify: $defects portability defect(s) — fix before relying on the non-terminal surfaces."
+  return 1
+}
+
+# The support matrix — what each surface can do, generated from the manifest tiers present.
+kit_export_matrix() {
+  local a_count b_count
+  a_count="$(kit_manifest_list A 2>/dev/null | grep -c . || true)"
+  b_count="$(kit_manifest_list B 2>/dev/null | grep -c . || true)"
+  cat <<MATRIX
+# claude-kit surface support matrix
+
+Generated by kit-export-project (#376). The kit project runs on three Claude surfaces; this table
+records what each supports and how the project gets there.
+
+| Capability                          | Terminal (Claude Code) | Cowork (cloud Claude Code) | claude.ai Project |
+| ----------------------------------- | :--------------------: | :------------------------: | :---------------: |
+| Reads CLAUDE.md + .claude/ natively |           yes          |             yes            |  no (no FS)       |
+| Tier-A skills / rules / agents      |           yes          |             yes            |  via export*      |
+| Tier-B statusline / hooks / settings|           yes          |          partial**         |  no               |
+| Runs \`kit\` / \`scripts/*\` verbs     |           yes          |             yes            |  no (can't shell) |
+| GitHub lifecycle (gh, worktrees)    |           yes          |             yes            |  no               |
+| Knowledge corpus available          |        in repo         |           in repo          |  via export*      |
+
+\* claude.ai has no filesystem: run \`kit-export-project\` → paste \`claude-instructions.md\` into the
+  Project custom-instructions box and upload \`project-knowledge/\` as Project knowledge.
+\*\* Cowork runs Claude Code but a shim like the statusline / a guard hook may be inert in that
+  environment; the PROJECT still functions because tier-B files are conveniences, not requirements
+  (verified by \`kit-export-project --verify\`).
+
+## This project's manifest tiering
+- Tier A (portable): ${a_count} file(s)
+- Tier B (CLI-only): ${b_count} file(s)
+
+Tier A = portable to Cowork AND claude.ai. Tier B = needs a terminal + filesystem. The export
+carries only tier-A semantics off-terminal; a tier-B file the project *requires* is a defect
+\`--verify\` flags.
+MATRIX
+}
+
+# Copy the knowledge corpus + portable reference files into an upload-ready folder for claude.ai.
+# Honors KIT_DRY_RUN. Knowledge dir is config-resolved (defaults to knowledge/).
+kit_export_knowledge() {
+  local out="$1" kdir="${2:-knowledge}" copied=0
+  local dest="$out/project-knowledge"
+  if [ -n "${KIT_DRY_RUN:-}" ]; then
+    [ -d "$kdir" ] && _kex_say "  [dry-run] would copy $kdir/** -> $dest/"
+    _kex_say "  [dry-run] would copy .claude/rules/ + .claude/agents/ (tier-A reference) -> $dest/"
+    return 0
+  fi
+  mkdir -p "$dest"
+  if [ -d "$kdir" ]; then
+    # -R preserves the knowledge/ tree under the dest; portable on bash + zsh, macOS + linux cp.
+    cp -R "$kdir" "$dest/" && copied=1
+  fi
+  # Carry tier-A reference material (rules + agents) so a claude.ai Project has the same context.
+  [ -d .claude/rules ]  && cp -R .claude/rules  "$dest/" 2>/dev/null && copied=1
+  [ -d .claude/agents ] && cp -R .claude/agents "$dest/" 2>/dev/null && copied=1
+  if [ "$copied" -eq 1 ]; then
+    _kex_say "  knowledge + tier-A reference copied -> $dest/"
+  else
+    _kex_say "  (no knowledge/ or tier-A reference found to copy)"
+  fi
+}
+
+# Full export: instructions + knowledge + matrix into OUT.
+kit_export_all() {
+  local out="$1" kdir="${2:-knowledge}"
+  command -v jq >/dev/null 2>&1 || { _kex_say "kit-export: jq required"; return 1; }
+  [ -f CLAUDE.md ] || { _kex_say "kit-export: no CLAUDE.md here — run from the project root (or /kit-init first)."; return 1; }
+
+  _kex_say "kit-export: exporting to $out/ (terminal/Cowork read the repo directly; this is for claude.ai)"
+
+  if [ -n "${KIT_DRY_RUN:-}" ]; then
+    _kex_say "  [dry-run] would write $out/claude-instructions.md (flattened CLAUDE.md + tier-A rules)"
+    kit_export_knowledge "$out" "$kdir"
+    _kex_say "  [dry-run] would write $out/SUPPORT-MATRIX.md"
+    return 0
+  fi
+
+  mkdir -p "$out"
+  kit_export_flatten_instructions CLAUDE.md > "$out/claude-instructions.md" \
+    && _kex_say "  wrote $out/claude-instructions.md"
+  kit_export_knowledge "$out" "$kdir"
+  kit_export_matrix > "$out/SUPPORT-MATRIX.md" && _kex_say "  wrote $out/SUPPORT-MATRIX.md"
+
+  _kex_say "kit-export: done."
+  _kex_say "  -> paste $out/claude-instructions.md into the claude.ai Project custom-instructions box"
+  _kex_say "  -> upload $out/project-knowledge/ as the Project's knowledge"
+  # A portability nudge: report (don't fail) if the verify check finds defects.
+  kit_export_verify CLAUDE.md >/dev/null 2>&1 || _kex_say "  note: run --verify — the portable surface has defect(s)."
+}
+
+# CLI (direct execution only; sourcing exposes the functions for tests)
+if kit_is_main; then
+  _mode=export _out=".kit-export" _kdir="knowledge"
+  # config-resolve the knowledge dir if available (kit-config.sh ships alongside in scripts/lib)
+  if [ -f "$_export_dir/lib/kit-config.sh" ]; then
+    # shellcheck source=/dev/null
+    . "$_export_dir/lib/kit-config.sh"
+    load_kit_config >/dev/null 2>&1 && _kdir="${KIT_KNOWLEDGE_DIR:-knowledge}" || true
+  fi
+  while [ $# -gt 0 ]; do case "$1" in
+    --out)     _out="${2:?--out needs a dir}"; shift 2;;
+    --verify)  _mode=verify; shift;;
+    --matrix)  _mode=matrix; shift;;
+    --dry-run) export KIT_DRY_RUN=1; shift;;
+    -h|--help) sed -n '/^# Run:/,/^# Requires:/p' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
+    *) echo "unknown arg: $1" >&2; exit 2;;
+  esac; done
+  case "$_mode" in
+    verify) kit_export_verify CLAUDE.md;;
+    matrix) kit_export_matrix;;
+    *)      kit_export_all "$_out" "$_kdir";;
+  esac
+fi

package/scripts/kit-export-training-test.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# kit-export-training-test.sh — self-test for kit-export-training (#881). Runs under bash AND zsh.
+# Proves the dataset-builder path is config-driven (NOT hardcoded): --builder > env > sibling discovery.
+# Run:  bash scripts/kit-export-training-test.sh
+PLUGIN_DIR=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
+
+if [ -n "${KIT_XT_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_XT_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_XT_TEST_INNER): $1"; fi; }
+
+  # Source the script: exposes functions, never runs main (verified by the source guard).
+  . "$PLUGIN_DIR/scripts/kit-export-training.sh"
+  t "resolver is defined" "$(command -v _kxt_resolve_builder >/dev/null && echo yes || echo no)" "yes"
+
+  # 1) explicit --builder value wins over everything.
+  KIT_DATASET_BUILDER="/env/build_dataset.py" \
+    t "explicit --builder wins" "$(_kxt_resolve_builder /explicit/build_dataset.py)" "/explicit/build_dataset.py"
+
+  # 2) KIT_DATASET_BUILDER env is used when no explicit value.
+  t "env var used when no flag" "$(KIT_DATASET_BUILDER=/env/build_dataset.py _kxt_resolve_builder '')" "/env/build_dataset.py"
+
+  # 3) sibling-repo discovery: a chat-datasets/build_dataset.py beside the git repo root is found,
+  #    with NO hardcoded user path. Build a fake parent dir holding a repo + a sibling builder.
+  parent="$(mktemp -d)"; trap 'rm -rf "$parent"' EXIT
+  parent="$(cd "$parent" && pwd -P)"   # canonicalize (macOS /var -> /private/var) to match git rev-parse
+  mkdir -p "$parent/myrepo" "$parent/chat-datasets"
+  ( cd "$parent/myrepo" && git init -q )
+  printf '#!/usr/bin/env python3\n' > "$parent/chat-datasets/build_dataset.py"
+  got="$(cd "$parent/myrepo" && unset KIT_DATASET_BUILDER 2>/dev/null; _kxt_resolve_builder '')"
+  t "sibling discovery off repo root" "$got" "$parent/chat-datasets/build_dataset.py"
+
+  # 4) returns non-zero when nothing resolves (no flag, no env, no sibling).
+  empty="$(mktemp -d)"; mkdir -p "$empty/solo"; ( cd "$empty/solo" && git init -q )
+  ( cd "$empty/solo" && unset KIT_DATASET_BUILDER 2>/dev/null; _kxt_resolve_builder '' >/dev/null 2>&1 )
+  t "fails closed when unresolved (rc 1)" "$?" "1"
+  rm -rf "$empty"
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_XT_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_XT_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-export-training.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+# kit-export-training.sh — OPT-IN export of your Claude Code sessions to redacted training JSONL.
+#
+# Fine-tuning a local model on your own work only helps if the data leaves the machine clean. This
+# handler is the consent gate in front of a dataset builder (chat-datasets/build_dataset.py): it
+# lets a builder pick which sessions to export, ALWAYS runs the builder with redaction ON
+# (secret/key/email masking is the builder's default — there is deliberately NO --no-redact
+# passthrough here), and prints exactly where it wrote plus a reminder that redaction must be
+# verified before sharing.
+#
+# Nothing here is automatic — it runs only when explicitly invoked, and it never uploads anything.
+# The output is plain JSONL on disk for the training pipeline; what you do with it is your call.
+#
+# Run:
+#   scripts/kit-export-training.sh [--builder PATH] [--match KEY ...] [--dirs DIR ...]
+#                                  [--sessions FILE ...] [--out PATH] [--split FRAC]
+#                                  [--final-only] [--drop-narration]
+# Selection (pick one; default = the current git project, matched by its slug):
+#   --match KEY ...     project-dir name substrings under ~/.claude/projects (e.g. my-app acme)
+#   --dirs  DIR ...     explicit ~/.claude/projects/<dir> session directories
+#   --sessions FILE ... individual *.jsonl transcript files to export (symlinked into a temp dir)
+# Options:
+#   --builder PATH      path to build_dataset.py (overrides KIT_DATASET_BUILDER + auto-discovery)
+#   --out PATH          output JSONL (default: ~/.claude/exports/<slug>-training.jsonl)
+#   --split FRAC        also emit train.jsonl/valid.jsonl with FRAC held out (e.g. 0.1)
+#   --final-only        keep only the last assistant message per turn
+#   --drop-narration    drop short process-narration openers
+# Env:
+#   KIT_DATASET_BUILDER  path to build_dataset.py (used when --builder is not given)
+#   KIT_PROJECTS_ROOT    sessions root (default: ~/.claude/projects)
+#   KIT_ASSUME_YES       skip the final confirm (for batch/CI).
+#
+# Builder discovery (config-driven, NO hardcoded user path): --builder > KIT_DATASET_BUILDER >
+# a sibling `chat-datasets/build_dataset.py` next to the git repo root (then $PWD). If none resolve,
+# the script stops and tells you to pass --builder or set KIT_DATASET_BUILDER.
+#
+# Redaction is ALWAYS on here — the builder masks by default and this script never passes --no-redact.
+set -uo pipefail
+
+# ---- locate self + optional shared cli helpers ----------------------------
+_kxt_dir="$(CDPATH='' cd -- "$(dirname -- "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# shellcheck source=/dev/null
+[ -f "$_kxt_dir/lib/kit-cli.sh" ] && . "$_kxt_dir/lib/kit-cli.sh"   # provides kit_is_main (optional)
+
+PROJECTS_ROOT="${KIT_PROJECTS_ROOT:-$HOME/.claude/projects}"
+
+# Staged-sessions temp dir, cleaned on exit. Script-global so the EXIT trap can read it
+# after _kxt_main returns (a function-local would be out of scope under `set -u`).
+_KXT_TMP_SEL=""
+_kxt_cleanup() { [ -n "${_KXT_TMP_SEL:-}" ] && rm -rf "$_KXT_TMP_SEL"; return 0; }
+
+# ---- minimal logging ------------------------------------------------------
+if [ -t 2 ]; then _AZ=$'\033[38;2;201;122;44m'; _RD=$'\033[38;2;194;87;56m'; _GR=$'\033[38;2;120;160;90m'; _DM=$'\033[2m'; _RS=$'\033[0m'
+else _AZ=''; _RD=''; _GR=''; _DM=''; _RS=''; fi
+_kxt_say()  { printf '%s->%s %s\n' "$_AZ" "$_RS" "$*" >&2; }
+_kxt_warn() { printf '%s!%s %s\n'  "$_RD" "$_RS" "$*" >&2; }
+_kxt_err()  { printf '%sx%s %s\n'  "$_RD" "$_RS" "$*" >&2; }
+_kxt_die()  { _kxt_err "$*"; exit 1; }
+
+# ---- builder resolution (config-driven, generalized off any one machine) ---
+# $1 = explicit --builder value (may be empty). Priority: explicit > env > sibling discovery.
+_kxt_resolve_builder() {
+  local explicit="${1:-}"
+  [ -n "$explicit" ] && { printf '%s\n' "$explicit"; return 0; }
+  [ -n "${KIT_DATASET_BUILDER:-}" ] && { printf '%s\n' "$KIT_DATASET_BUILDER"; return 0; }
+  local rel="chat-datasets/build_dataset.py" root="" rootp="" base="" cand=""
+  root="$(git -C "$PWD" rev-parse --show-toplevel 2>/dev/null || true)"
+  [ -n "$root" ] && rootp="$(dirname "$root")"
+  for base in "$rootp" "$PWD" "$(dirname "$PWD")"; do
+    [ -n "$base" ] || continue
+    cand="$base/$rel"
+    [ -f "$cand" ] && { printf '%s\n' "$cand"; return 0; }
+  done
+  return 1
+}
+
+# ---- main (direct execution only; sourcing exposes the functions for tests) ---
+_kxt_main() {
+  local BUILDER_FLAG="" OUT="" SPLIT="" SLUG="export" BUILDER="" _root=""
+  local -a MATCH=() DIRS=() SESSIONS=() EXTRA=() SEL=() SPLIT_ARGS=()
+  while [ $# -gt 0 ]; do case "$1" in
+    --builder)      BUILDER_FLAG="${2:-}"; shift 2 ;;
+    --match)        shift; while [ $# -gt 0 ] && [ "${1#--}" = "$1" ]; do MATCH+=("$1"); shift; done ;;
+    --dirs)         shift; while [ $# -gt 0 ] && [ "${1#--}" = "$1" ]; do DIRS+=("$1"); shift; done ;;
+    --sessions)     shift; while [ $# -gt 0 ] && [ "${1#--}" = "$1" ]; do SESSIONS+=("$1"); shift; done ;;
+    --out)          OUT="${2:-}"; shift 2 ;;
+    --split)        SPLIT="${2:-}"; shift 2 ;;
+    --final-only)   EXTRA+=(--final-only); shift ;;
+    --drop-narration) EXTRA+=(--drop-narration); shift ;;
+    -h|--help)      sed -n '13,33p' "$0" | sed 's/^# \{0,1\}//'; return 0 ;;
+    *) _kxt_die "unknown flag: $1" ;;
+  esac; done
+
+  # ---- preflight ----------------------------------------------------------
+  command -v python3 >/dev/null 2>&1 || _kxt_die "python3 is required."
+  BUILDER="$(_kxt_resolve_builder "$BUILDER_FLAG")" || _kxt_die \
+    "dataset builder not found — pass --builder PATH or set KIT_DATASET_BUILDER (looked for chat-datasets/build_dataset.py beside the repo root)."
+  [ -f "$BUILDER" ] || _kxt_die "dataset builder not found: $BUILDER"
+
+  # ---- resolve a default selection from the current git project -----------
+  if [ ${#MATCH[@]} -eq 0 ] && [ ${#DIRS[@]} -eq 0 ] && [ ${#SESSIONS[@]} -eq 0 ]; then
+    _root="$(git -C "$PWD" rev-parse --show-toplevel 2>/dev/null || true)"
+    [ -n "$_root" ] || _kxt_die "no selection given and not inside a git repo — pass --match/--dirs/--sessions."
+    SLUG="$(basename "$_root" | tr '[:upper:]' '[:lower:]')"
+    MATCH=("$SLUG")
+    _kxt_say "no selection given — defaulting to the current project (match: $SLUG)"
+  elif [ ${#MATCH[@]} -gt 0 ]; then
+    SLUG="$(printf '%s' "${MATCH[0]}" | tr '[:upper:]' '[:lower:]')"
+  fi
+
+  # ---- default output path ------------------------------------------------
+  if [ -z "$OUT" ]; then
+    mkdir -p "$HOME/.claude/exports"
+    OUT="$HOME/.claude/exports/${SLUG}-training.jsonl"
+  fi
+  mkdir -p "$(dirname "$OUT")"
+
+  # ---- build the selection args for the builder ---------------------------
+  # --sessions: stage the chosen transcript files into a temp dir and pass via --dirs,
+  # since build_dataset.py selects at directory granularity.
+  local f=""
+  trap _kxt_cleanup EXIT
+
+  if [ ${#SESSIONS[@]} -gt 0 ]; then
+    _KXT_TMP_SEL="$(mktemp -d)"
+    for f in "${SESSIONS[@]}"; do
+      [ -f "$f" ] || _kxt_die "session file not found: $f"
+      ln -s "$(cd "$(dirname "$f")" && pwd)/$(basename "$f")" "$_KXT_TMP_SEL/$(basename "$f")"
+    done
+    SEL=(--dirs "$_KXT_TMP_SEL")
+    _kxt_say "exporting ${#SESSIONS[@]} selected session file(s)"
+  elif [ ${#DIRS[@]} -gt 0 ]; then
+    SEL=(--dirs "${DIRS[@]}")
+    _kxt_say "exporting from ${#DIRS[@]} session director(ies)"
+  else
+    SEL=(--match "${MATCH[@]}")
+    _kxt_say "exporting sessions matching: ${MATCH[*]}"
+  fi
+
+  [ -d "$PROJECTS_ROOT" ] || _kxt_warn "sessions root $PROJECTS_ROOT not found — the export may be empty."
+
+  # ---- confirm (opt-in) ---------------------------------------------------
+  if [ -z "${KIT_ASSUME_YES:-}" ] && [ -t 0 ]; then
+    printf '%sExport redacted training JSONL to %s ? [y/N] %s' "$_DM" "$OUT" "$_RS" >&2
+    local _c=""; read -r _c < /dev/tty || true
+    case "$_c" in y|Y|yes|YES) ;; *) _kxt_die "aborted — nothing was written." ;; esac
+  fi
+
+  # ---- run the builder with redaction ON (always) -------------------------
+  [ -n "$SPLIT" ] && SPLIT_ARGS=(--split "$SPLIT")
+  _kxt_say "running build_dataset.py (redaction ON): $BUILDER"
+  python3 "$BUILDER" "${SEL[@]}" --out "$OUT" ${EXTRA[@]+"${EXTRA[@]}"} ${SPLIT_ARGS[@]+"${SPLIT_ARGS[@]}"} \
+    || _kxt_die "build_dataset.py failed — nothing trustworthy was written."
+
+  # ---- report -------------------------------------------------------------
+  local STATS="${OUT%.jsonl}.stats.json"
+  printf '\n' >&2
+  _kxt_say "Wrote training data:"
+  printf '    %sJSONL:%s %s\n' "$_GR" "$_RS" "$OUT" >&2
+  [ -f "$STATS" ] && printf '    %sstats:%s %s\n' "$_GR" "$_RS" "$STATS" >&2
+  if [ -n "$SPLIT" ]; then
+    printf '    %ssplit:%s %s/train.jsonl + valid.jsonl\n' "$_GR" "$_RS" "$(dirname "$OUT")" >&2
+  fi
+  printf '\n' >&2
+  _kxt_warn "Redaction was applied automatically, but it is NOT a guarantee."
+  _kxt_warn "VERIFY the output for any leftover secrets, tokens, private names, or customer data"
+  _kxt_warn "BEFORE sharing it or feeding it into the training pipeline."
+}
+
+# Run only on direct execution; `source`-ing the file just defines the functions (for tests).
+if command -v kit_is_main >/dev/null 2>&1; then
+  kit_is_main && _kxt_main "$@"
+else
+  [ "${BASH_SOURCE[0]:-$0}" = "${0}" ] && _kxt_main "$@"
+fi

package/scripts/kit-migrate-test.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# kit-migrate-test.sh — self-test for kit-migrate (#373). Runs under bash AND zsh.
+# Asserts the acceptance gate: migrate twice = no-op; old paths registered (survives /kit-update);
+# manifest re-keyed; docs rewritten; .claude/ backed up.
+# Run:  bash scripts/kit-migrate-test.sh
+PLUGIN_DIR=$(CDPATH='' cd -- "$(dirname -- "$0")/.." && pwd)
+
+if [ -n "${KIT_MIGRATE_TEST_INNER:-}" ]; then
+  set -u
+  fail=0
+  t() { if [ "$2" != "$3" ]; then echo "FAIL($KIT_MIGRATE_TEST_INNER): $1 -> got '[$2]' want '[$3]'"; fail=1; else echo "ok($KIT_MIGRATE_TEST_INNER): $1"; fi; }
+
+  proj="$(mktemp -d)"; trap 'rm -rf "$proj"' EXIT
+  cd "$proj"
+  export KIT_ASSUME_YES=1
+  . "$PLUGIN_DIR/scripts/kit-migrate.sh"
+  . "$PLUGIN_DIR/scripts/lib/kit-manifest.sh"
+
+  # Old-layout project: task-* skills, a CLAUDE.md referencing /task-pr, a manifest tracking the old
+  # skill path, a kit.config.json with no upgrade map yet.
+  mkdir -p .claude/skills/task-pr .claude/skills/task-gc .claude/rules
+  printf 'pr skill body\n' > .claude/skills/task-pr/SKILL.md
+  printf 'gc skill body\n' > .claude/skills/task-gc/SKILL.md
+  printf 'Run /task-pr then /task-pr-merge; sweep with /task-gc.\n' > CLAUDE.md
+  printf '{ "schema":1 }\n' > .claude/kit.config.json
+  kit_manifest_record .claude/skills/task-pr/SKILL.md A wire 1 2026-01-01T00:00:00Z
+
+  # --- run 1: the real migration ---
+  kit_migrate_all >/dev/null 2>&1
+
+  t "old task-pr gone"          "$([ -e .claude/skills/task-pr ] && echo yes || echo no)" "no"
+  t "new kit-task-pr present"   "$([ -f .claude/skills/kit-task-pr/SKILL.md ] && echo yes || echo no)" "yes"
+  t "content preserved"         "$(cat .claude/skills/kit-task-pr/SKILL.md)" "pr skill body"
+  t "task-gc -> kit-gc"         "$([ -f .claude/skills/kit-gc/SKILL.md ] && echo yes || echo no)" "yes"
+  t "backup taken"              "$(find . -maxdepth 1 -name ".claude.bak.*" 2>/dev/null | grep -c .)" "1"
+
+  # resurrection guard: old path registered in upgrade.renamed{} -> /kit-update skips it.
+  t "rename registered"         "$(jq -r '.upgrade.renamed[".claude/skills/task-pr"] // "MISS"' .claude/kit.config.json)" ".claude/skills/kit-task-pr"
+  t "gc rename registered"      "$(jq -r '.upgrade.renamed[".claude/skills/task-gc"] // "MISS"' .claude/kit.config.json)" ".claude/skills/kit-gc"
+
+  # manifest re-keyed to the v2 path.
+  t "manifest re-keyed"         "$(kit_manifest_verify .claude/skills/kit-task-pr/SKILL.md)" "intact"
+  t "old manifest entry dropped" "$(kit_manifest_verify .claude/skills/task-pr/SKILL.md)" "untracked"
+
+  # CLAUDE.md surgery: /task-pr -> /kit-task-pr (no bare /task- left).
+  t "doc rewritten kit-task-pr" "$(grep -c '/kit-task-pr' CLAUDE.md)" "1"
+  t "doc rewritten kit-gc"      "$(grep -c '/kit-gc' CLAUDE.md)" "1"
+  t "no bare /task- left"       "$(grep -Ec '/task-(pr|gc|new)' CLAUDE.md)" "0"
+
+  # --- run 2: idempotency — migrate twice = no-op (nothing moves, no second backup) ---
+  out2="$(kit_migrate_all 2>&1)"
+  t "2nd run is no-op"          "$(printf '%s' "$out2" | grep -c 'already on v2')" "1"
+  t "still ONE backup"          "$(find . -maxdepth 1 -name ".claude.bak.*" 2>/dev/null | grep -c .)" "1"
+  t "kit-task-pr still there"   "$([ -f .claude/skills/kit-task-pr/SKILL.md ] && echo yes || echo no)" "yes"
+  t "old still absent"          "$([ -e .claude/skills/task-pr ] && echo yes || echo no)" "no"
+
+  # --- dry-run on a fresh old project moves nothing ---
+  proj2="$(mktemp -d)"; cd "$proj2"
+  mkdir -p .claude/skills/task-pr
+  printf 'x\n' > .claude/skills/task-pr/SKILL.md
+  printf '{ "schema":1 }\n' > .claude/kit.config.json
+  KIT_DRY_RUN=1 kit_migrate_all >/dev/null 2>&1
+  t "dry-run does not move"     "$([ -e .claude/skills/task-pr ] && echo yes || echo no)" "yes"
+  t "dry-run no new dir"        "$([ -e .claude/skills/kit-task-pr ] && echo yes || echo no)" "no"
+  t "dry-run no backup"         "$(find . -maxdepth 1 -name ".claude.bak.*" 2>/dev/null | grep -c .)" "0"
+  t "dry-run no registry write" "$(jq -r '.upgrade // "NONE"' .claude/kit.config.json)" "NONE"
+
+  [ "$fail" -eq 0 ] && echo "ALL OK($KIT_MIGRATE_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_MIGRATE_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"