@rm0nroe/coach-claw 1.0.6

package/npm/coach-claw.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const ROOT = path.resolve(__dirname, "..");
+const VERSION = require(path.join(ROOT, "package.json")).version;
+
+function usage() {
+  console.log(`Coach Claw ${VERSION}
+
+Usage:
+  coach-claw doctor
+  coach-claw install [--seed | --no-seed] [--fresh] [--no-prune-backups]
+  coach-claw launchd
+  coach-claw config <set|preview|wizard> [...]
+  coach-claw help
+
+Examples:
+  coach-claw doctor
+  coach-claw install --seed
+  coach-claw install --no-seed
+  coach-claw launchd
+  coach-claw config wizard
+  coach-claw config preview
+  coach-claw config set --theme ocean --statusline pips
+  coach-claw config set --elo 1200 2800
+
+The /config slash command inside Claude Code edits the same file.`);
+}
+
+function fail(message) {
+  console.error(`ERROR: ${message}`);
+  process.exit(1);
+}
+
+function warn(message) {
+  console.error(`WARN: ${message}`);
+}
+
+function ok(message) {
+  console.log(`OK: ${message}`);
+}
+
+function isSupportedPlatform() {
+  return process.platform === "darwin" || process.platform === "linux";
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    cwd: ROOT,
+    encoding: "utf8",
+    stdio: options.stdio || "pipe",
+    env: options.env || process.env
+  });
+}
+
+function commandExists(command) {
+  const result = run("sh", ["-c", `command -v ${quoteForShell(command)}`]);
+  return result.status === 0;
+}
+
+function quoteForShell(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function pythonVersion() {
+  const probe = [
+    "import sys",
+    "print(f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}')"
+  ].join("; ");
+  const result = run("python3", ["-c", probe]);
+  if (result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+
+function pythonIsAdequate(version) {
+  if (!version) {
+    return false;
+  }
+  const parts = version.split(".").map((part) => Number(part));
+  if (parts.length < 2 || parts.some((part) => Number.isNaN(part))) {
+    return false;
+  }
+  return parts[0] > 3 || (parts[0] === 3 && parts[1] >= 8);
+}
+
+function claudeDir() {
+  return process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude");
+}
+
+function ensureWritableClaudeDir() {
+  const dir = claudeDir();
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function doctor({ fatal = false } = {}) {
+  let failures = 0;
+  const recordFailure = (message) => {
+    failures += 1;
+    if (fatal) {
+      fail(message);
+    }
+    console.error(`FAIL: ${message}`);
+  };
+
+  if (isSupportedPlatform()) {
+    ok(`supported OS: ${process.platform}`);
+  } else {
+    recordFailure("Coach Claw supports macOS/Linux only.");
+  }
+
+  if (commandExists("bash")) {
+    ok("bash available");
+  } else {
+    recordFailure("bash not found in PATH.");
+  }
+
+  if (commandExists("git")) {
+    ok("git available");
+  } else {
+    recordFailure("git not found in PATH.");
+  }
+
+  if (commandExists("python3")) {
+    const version = pythonVersion();
+    if (pythonIsAdequate(version)) {
+      ok(`python3 ${version} available`);
+    } else {
+      recordFailure("Coach Claw needs python3 >= 3.8. Install Python 3, then retry.");
+    }
+  } else {
+    recordFailure("Coach Claw needs python3 >= 3.8. Install Python 3, then retry.");
+  }
+
+  if (ensureWritableClaudeDir()) {
+    ok(`Claude dir writable: ${claudeDir()}`);
+  } else {
+    recordFailure(`Claude dir is not writable: ${claudeDir()}`);
+  }
+
+  if (commandExists("claude")) {
+    ok("claude CLI available for weekly /coach-insights refresh");
+  } else {
+    warn("claude CLI not found; install still works, but weekly /coach-insights refresh needs Claude Code on PATH.");
+  }
+
+  const installScript = path.join(ROOT, "install.sh");
+  if (fs.existsSync(installScript)) {
+    ok("install.sh present");
+  } else {
+    recordFailure("package is missing install.sh.");
+  }
+
+  const liveCoach = path.join(claudeDir(), "coach");
+  const liveSessionHook = path.join(claudeDir(), "hooks", "coach-session-start.py");
+  const livePromptHook = path.join(claudeDir(), "hooks", "coach-user-prompt.py");
+  if (fs.existsSync(liveCoach)) {
+    ok(`installed coach dir present: ${liveCoach}`);
+  } else {
+    warn("Coach is not installed yet; run `coach-claw install --seed`.");
+  }
+  if (fs.existsSync(liveSessionHook) && fs.existsSync(livePromptHook)) {
+    ok("installed hooks present");
+  } else {
+    warn("installed hooks not found yet; run `coach-claw install --seed`.");
+  }
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+function runInstall(args) {
+  doctor({ fatal: true });
+  const script = path.join(ROOT, "install.sh");
+  const result = run("bash", [script, ...args], { stdio: "inherit" });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+function runLaunchd() {
+  if (process.platform !== "darwin") {
+    fail(
+      "launchd is macOS-only. On Linux, add this cron entry: " +
+      "0 4 * * * $HOME/.claude/coach/bin/insights.sh 1d >> /tmp/claude-coach.log 2>&1"
+    );
+  }
+  doctor({ fatal: true });
+  const script = path.join(ROOT, "install-launchd.sh");
+  const result = run("bash", [script], { stdio: "inherit" });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+function runConfig(args) {
+  // configure.py lives in the LIVE install (claudeDir()/coach/bin/), not
+  // the npm package — the npx cache is read-only and the script needs
+  // to import its sibling modules (themes, statusline_variants,
+  // user_config) which only exist in the install target.
+  const script = path.join(claudeDir(), "coach", "bin", "configure.py");
+  if (!fs.existsSync(script)) {
+    fail(
+      "coach-claw config: Coach Claw isn't installed yet. " +
+      "Run: npx @rm0nroe/coach-claw@latest install"
+    );
+  }
+  // If the user has CLAUDE_DIR set (custom install location), propagate
+  // COACH_CONFIG_DIR so user_config.py writes to the matching coach dir
+  // instead of falling back to ~/.claude/coach.
+  const env = { ...process.env };
+  if (process.env.CLAUDE_DIR) {
+    env.COACH_CONFIG_DIR = path.join(process.env.CLAUDE_DIR, "coach");
+  }
+  const result = spawnSync("python3", [script, ...args], {
+    stdio: "inherit",
+    env,
+  });
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+switch (command || "help") {
+  case "doctor":
+    doctor();
+    break;
+  case "install":
+    runInstall(args);
+    break;
+  case "launchd":
+    runLaunchd();
+    break;
+  case "config":
+    runConfig(args);
+    break;
+  case "--version":
+  case "-v":
+  case "version":
+    console.log(VERSION);
+    break;
+  case "--help":
+  case "-h":
+  case "help":
+    usage();
+    break;
+  default:
+    usage();
+    fail(`unknown command: ${command}`);
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@rm0nroe/coach-claw",
+  "version": "1.0.6",
+  "description": "A self-evolving coaching layer for Claude Code.",
+  "license": "MIT",
+  "homepage": "https://rm0nroe.github.io/coach-claw/",
+  "bugs": {
+    "url": "https://github.com/rm0nroe/coach-claw/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rm0nroe/coach-claw.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "coach-claw": "npm/coach-claw.js"
+  },
+  "files": [
+    "coach/",
+    "hooks/",
+    "skills/",
+    "launchd/",
+    "npm/",
+    "install.sh",
+    "install-launchd.sh",
+    "settings-snippet.json",
+    "requirements.txt",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "doctor": "node npm/coach-claw.js doctor",
+    "test": "python3 -m pytest coach/tests",
+    "pack:dry": "npm pack --dry-run --json"
+  },
+  "keywords": [
+    "claude-code",
+    "coach",
+    "claude",
+    "hooks",
+    "cli"
+  ]
+}

package/requirements.txt

@@ -0,0 +1,11 @@
+# Claude Code Coach dependencies.
+#
+# install.sh installs these automatically via `python3 -m pip install --user`.
+# Listed here for transparency.
+
+# Required at runtime (merge.py, stats.py, status.py, bank.py, hooks)
+pyyaml>=5.4
+
+# Required only to run the test suite (coach/tests/).
+# pytest isn't installed by default — add with: python3 -m pip install --user pytest
+# pytest>=7.0

package/settings-snippet.json

@@ -0,0 +1,31 @@
+{
+  "_comment": "Merge the 'hooks' block below into your ~/.claude/settings.json. Optionally add the statusLine block too if you do not already have a custom statusline. ./install.sh does this automatically for hooks, rewrites `python3` to the absolute path it resolved at install time, substitutes that path into the statusline wrapper, and adds statusLine only when one is absent. If you are merging by hand, replace `python3` in the hook command strings with the full path from `command -v python3` — settings.json runs in a non-interactive shell where PATH is not guaranteed to include Homebrew / pyenv. Do NOT replace your whole settings.json — add these keys alongside your existing 'enabledPlugins', 'permissions', etc.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/coach-session-start.py",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/coach-user-prompt.py",
+            "timeout": 2
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "bash ~/.claude/coach/default-statusline-command.sh"
+  }
+}

package/skills/coach/SKILL.md

@@ -0,0 +1,107 @@
+---
+description: "Toggle the autonomous Coach Claw on/off, inspect state, or uninstall. Usage: /coach <on|off|status|uninstall>"
+---
+
+The Coach is an autonomous system: `/coach-insights` runs daily and maintains
+`~/.claude/coach/profile.yaml`; a `SessionStart` hook injects the active
+profile as context so Claude can append at most one observational footnote
+per session when your behavior matches a tracked pattern.
+
+This skill is the **control surface** for that system. It does NOT review
+proposed changes, approve deltas, or edit entries by hand. It only toggles
+and inspects. Profile updates happen autonomously through `/coach-insights`.
+
+## Argument
+
+The argument after `/coach` is one of: `on` | `off` | `status` | `uninstall`.
+If no argument is provided, default to `status`.
+
+## Behavior per argument
+
+### `off`
+1. Create `~/.claude/coach/.disabled` as an empty flag file.
+2. Confirm with one line: "Coach disabled. Hook will exit silently on SessionStart."
+
+### `on`
+1. Remove `~/.claude/coach/.disabled` if present.
+2. Confirm with one line: "Coach enabled."
+
+### `status` (default)
+Invoke `~/.claude/coach/bin/status.py` via Bash and print its output verbatim.
+The script emits an ANSI-colored breakdown:
+
+- Current level, XP total, wide progress bar, distance to next level
+- Lifetime XP breakdown (graduations, longest active clean streak, banked
+  session XP with 10:1 discount)
+- Session XP breakdown (test runs, commits, unique skills invoked in the
+  current session — live from the most recently modified transcript)
+- "How to earn more" cheat sheet
+- Profile state (active / probationary / retired counts + probationary
+  streak values)
+- Last `/coach-insights` run summary
+
+Then, as a separate short line below the report, also surface:
+- Whether `.disabled` is present (`Coach disabled` / `Coach enabled`)
+- Whether `COACH_DISABLE=1` env is set (note the override)
+
+Use only `python3 ~/.claude/coach/bin/status.py` and bash existence
+checks for `.disabled` / env var. Do not mutate anything.
+
+### `uninstall`
+This is a reversible but disruptive action. Compute `TS=$(date +%Y%m%d-%H%M%S)`
+once and reuse it for every `.bak.<ts>` / `.uninstalled.<ts>` suffix below so
+the whole uninstall is one timestamped batch. Before doing anything:
+1. Ask the user for explicit confirmation ("This will move `~/.claude/coach/`
+   to `~/.claude/coach.bak.<TS>/`, move both coach hook scripts to
+   `.uninstalled.<TS>` (reversible rename), remove the coach
+   `SessionStart` + `UserPromptSubmit` hook entries from `settings.json`,
+   and unload + rename the daily-insights launchd plist (macOS) or print
+   the cron line for you to remove (Linux). Proceed?").
+2. Only on explicit "yes":
+   a. `mv ~/.claude/coach ~/.claude/coach.bak.<TS>` — **never `rm`**.
+      Investigate before deleting any application-data directory; prefer
+      a reversible rename to preserve the data.
+   b. Move the hook scripts so the live `~/.claude/hooks/` no longer
+      carries dead coach hooks (settings.json no longer references them
+      after step d, but stale files are confusing in any future debug):
+      - `mv ~/.claude/hooks/coach-session-start.py ~/.claude/hooks/coach-session-start.py.uninstalled.<TS>`
+      - `mv ~/.claude/hooks/coach-user-prompt.py ~/.claude/hooks/coach-user-prompt.py.uninstalled.<TS>`
+      Skip silently if a file isn't present.
+   c. Back up settings: `cp ~/.claude/settings.json ~/.claude/settings.json.bak.<TS>`.
+   d. Edit `~/.claude/settings.json` to remove only coach hook entries:
+      `hooks.SessionStart` commands containing `coach-session-start.py` and
+      `hooks.UserPromptSubmit` commands containing `coach-user-prompt.py`.
+      Preserve all other hooks and the rest of the file verbatim. Validate
+      the result is still valid JSON (`python3 -c "import json; json.load(open('...'))"`).
+   e. Unregister the daily Coach insights scheduler.
+      - macOS: if `~/Library/LaunchAgents/com.local.claude-coach.plist` exists,
+        `launchctl unload ~/Library/LaunchAgents/com.local.claude-coach.plist 2>/dev/null`
+        then `mv ~/Library/LaunchAgents/com.local.claude-coach.plist
+        ~/Library/LaunchAgents/com.local.claude-coach.plist.uninstalled.<TS>`.
+        The unload is best-effort (already-unloaded plists return non-zero
+        but cause no harm); the `mv` is the load-bearing step that prevents
+        the next `launchctl bootstrap` from re-loading it.
+      - Linux: `crontab` cannot be safely edited from a skill (the user's
+        crontab may have many lines we shouldn't touch). Print:
+        "Run `crontab -e` and remove the line containing
+        `coach/bin/insights.sh`."
+   f. Confirm with: "Coach uninstalled. Backups at:
+      `~/.claude/coach.bak.<TS>/`,
+      `~/.claude/hooks/coach-*.py.uninstalled.<TS>`,
+      `~/.claude/settings.json.bak.<TS>`,
+      `~/Library/LaunchAgents/com.local.claude-coach.plist.uninstalled.<TS>` (macOS).
+      To restore: `mv` each backup back to its original path and re-run
+      `launchctl load ...plist` (macOS) or re-add the cron line (Linux)."
+
+## Rules
+
+- Never edit `profile.yaml` entries by hand from this skill. The autonomous
+  loop is the point; hand-edits create drift.
+- Never `rm -rf` anything. Use `mv` to a `.bak` path.
+- Never touch the `enabledPlugins`, `permissions`, or `env` blocks of
+  `settings.json`. Only the `hooks` block.
+- If the user asks to change nudge wording, cooldown, decay rate, cap,
+  or thresholds, point them at the constants at the top of
+  `~/.claude/hooks/coach-session-start.py` (hook-side) or
+  `~/.claude/skills/coach-insights/SKILL.md` (runner-side). Don't invent a config
+  file — the constants are the config.

package/skills/coach-insights/SKILL.md

@@ -0,0 +1,78 @@
+---
+description: "Run an LLM-driven Coach insights pass — refreshes /insights facets, aggregates structured friction/wins, merges into profile. Usage: /coach-insights [--dry-run]"
+disable-model-invocation: true
+---
+
+Thin wrapper around `~/.claude/coach/bin/insights-llm.sh --force`. The
+underlying script (also fired automatically by the SessionStart hook on
+a 7-day cadence) refreshes the `/insights` facets sidecars, aggregates
+their stable enum keys deterministically, and hands detections to
+`merge.py`. `--force` bypasses the 7-day cooldown so a manual run
+always does work.
+
+## What this does
+
+1. Spawns `claude -p "/insights"` with `COACH_DISABLE=1` to refresh
+   `~/.claude/usage-data/facets/<uuid>.json` sidecars. The CLI's stdout
+   is discarded — we run it for the side effect on disk only.
+2. Pipes the facets directory through `aggregate_facets.py` to convert
+   stable enum keys (`friction_counts.*`, `primary_success`) into
+   detections JSON with kebab-case ids (`misunderstood_request` →
+   `misunderstood-request`). Threshold-gated: ≥25% of sessions for
+   negatives, ≥60% for positives. Capped at 8 detections per run.
+3. Hands detections to `merge.py` with `--run-id "insights-weekly-<ts>"`
+   so downstream consumers can distinguish from the daily deterministic
+   path's `insights-<ts>` runs.
+4. Auto-commits the profile change and touches
+   `~/.claude/coach/.last_weekly_insights` to throttle the next
+   automatic trigger.
+
+## Privacy
+
+- **Daily cron path: local-only, zero network.** `analyze.py +
+  redact.py` over redacted transcripts. Zero LLM cost.
+- **Weekly path + on-demand `/coach-insights`:** triggers Anthropic-side
+  `/insights` once per 7 days (via `claude -p`) to refresh structured
+  facets data. Coach itself does not independently upload transcripts;
+  the nested `/insights` refresh is an Anthropic-side Claude Code
+  operation that runs inside the user's existing authenticated session
+  and writes only to local sidecar files. Coach reads those local
+  `facets/*.json` files. The LLM call's output is discarded; only the
+  sidecar JSON refresh matters. `profile.yaml` stays local.
+
+## Arguments
+
+- `--dry-run` (optional): aggregate facets and print the detections
+  JSON without invoking `merge.py` or touching the throttle marker.
+
+## Steps
+
+```bash
+~/.claude/coach/bin/insights-llm.sh --force "$@"
+```
+
+That's it. Pass `--dry-run` through if the user supplied it.
+
+Capture the script's stdout, then summarize for the user:
+
+```
+/coach-insights <run_id>
+  detections: <N>
+  → <changelog line from merge.py stdout>
+```
+
+If `--dry-run`, report the dry-run banner instead and skip the changelog
+line.
+
+## Rules
+
+- **Never invent detections.** Zero is a valid output. The aggregator
+  emits `[]` when no enum key crosses its threshold; do not pad.
+- **Never edit `profile.yaml` directly.** Only `merge.py` mutates it.
+- **No translation, no fuzzy matching.** The aggregator consumes
+  facets enum keys 1:1 (Anthropic's data contract), so the manual
+  path and the auto-spawned weekly path always emit the same ids
+  for the same evidence.
+- **One run per `RUN_ID`.** The script generates a unique
+  `insights-weekly-<ts>` per invocation; do not re-run with the same
+  id.

package/skills/config/SKILL.md

@@ -0,0 +1,149 @@
+---
+description: "Customize the Coach Claw display — statusline variant, rank-name theme, ELO range. Usage: /config [show|preview|statusline <variant>|theme <name>|elo <min> <max>|reset]"
+---
+
+The Coach reads `~/.claude/coach/.user_config.json` at every render. This
+skill is the slash-command surface for editing it without touching files
+by hand. Three things are tunable:
+
+- **Statusline variant** — how the trailing coach segment renders. Four
+  options: `crystal`, `pips`, `slash`, `forge`.
+- **Theme** — the 50-name level ladder. Twelve options: `craft`
+  (default), `forge`, `cosmic`, `ocean`, `skyrim`, `marvel`, `dc`,
+  `finalfantasy`, `military`, `lotr`, `starwars`, `hacker`.
+- **ELO range** — `elo_min` and `elo_max` (defaults 1000 → 2800). The
+  rating is linearly interpolated across the 50-level ladder.
+
+The threshold curve (XP per level) is not configurable — keeping it
+fixed means existing XP totals never trigger retroactive level-ups.
+
+## Argument
+
+The argument after `/config` is one of:
+`show` | `preview` | `statusline <variant>` | `theme <name>` |
+`elo <min> <max>` | `reset`. If no argument is provided, default to `show`.
+
+## Behavior per argument
+
+### `show` (default)
+
+Read the current config and print a tidy summary. No mutations.
+
+```bash
+python3 - <<'PY'
+import os, sys
+sys.path.insert(0, os.path.expanduser("~/.claude/coach/bin"))
+from user_config import load
+from statusline_variants import list_variants
+from themes import list_themes
+cfg = load()
+print(f"  Variant : {cfg['statusline_variant']}  (options: {', '.join(list_variants())})")
+print(f"  Theme   : {cfg['theme']}  (options: {', '.join(list_themes())})")
+print(f"  ELO     : {cfg['elo_min']} → {cfg['elo_max']}")
+PY
+```
+
+### `preview`
+
+Render every variant × the user's current theme, plus every theme name
+at L1 / L25 / L50, so the user can see what the options look like
+side-by-side before committing. Pure read — no mutations.
+
+Delegates to `coach/bin/configure.py preview` so the slash command and
+the `npx coach-claw config preview` terminal command run literally the
+same code — output is byte-identical, no drift surface.
+
+```bash
+python3 ~/.claude/coach/bin/configure.py preview
+```
+
+### `statusline <variant>`
+
+Set `statusline_variant`. Validate against the registered set; on a
+typo, print the valid options and exit without mutating.
+
+```bash
+VARIANT="$1"  # the second word from the user's /config invocation
+python3 - "$VARIANT" <<'PY'
+import os, sys
+sys.path.insert(0, os.path.expanduser("~/.claude/coach/bin"))
+from user_config import update, VALID_VARIANTS
+v = sys.argv[1] if len(sys.argv) > 1 else ""
+if v not in VALID_VARIANTS:
+    print(f"unknown variant {v!r}. valid: {sorted(VALID_VARIANTS)}")
+    sys.exit(1)
+update(statusline_variant=v)
+print(f"statusline → {v}")
+PY
+```
+
+Confirm with one line: `Statusline updated to <variant>. Open a new prompt to see it.`
+
+### `theme <name>`
+
+Set `theme` analogously. Same shape as `statusline` — validate, update,
+confirm.
+
+```bash
+THEME="$1"
+python3 - "$THEME" <<'PY'
+import os, sys
+sys.path.insert(0, os.path.expanduser("~/.claude/coach/bin"))
+from user_config import update, VALID_THEMES
+t = sys.argv[1] if len(sys.argv) > 1 else ""
+if t not in VALID_THEMES:
+    print(f"unknown theme {t!r}. valid: {sorted(VALID_THEMES)}")
+    sys.exit(1)
+update(theme=t)
+print(f"theme → {t}")
+PY
+```
+
+### `elo <min> <max>`
+
+Set the ELO interpolation range. Validate `0 < min < max`. Same
+update + confirm shape.
+
+```bash
+MIN="$1"; MAX="$2"
+python3 - "$MIN" "$MAX" <<'PY'
+import os, sys
+sys.path.insert(0, os.path.expanduser("~/.claude/coach/bin"))
+from user_config import update
+try:
+    emin = int(sys.argv[1]); emax = int(sys.argv[2])
+except (IndexError, ValueError):
+    print("usage: /config elo <min> <max>"); sys.exit(1)
+if not (0 < emin < emax):
+    print(f"elo_min ({emin}) must be a positive int less than elo_max ({emax})")
+    sys.exit(1)
+update(elo_min=emin, elo_max=emax)
+print(f"elo → {emin} → {emax}")
+PY
+```
+
+### `reset`
+
+Delete `~/.claude/coach/.user_config.json` so all settings revert to
+their defaults (`crystal` + `craft` + `1000–2800`). Ask for explicit
+confirmation first.
+
+```bash
+rm -f "$HOME/.claude/coach/.user_config.json"
+echo "Config reset. Defaults: crystal + craft + 1000-2800."
+```
+
+## Rules
+
+- Never edit `profile.yaml`, `banked_sessions.json`, or any `.pending_*`
+  marker via this skill — those are autonomous-loop state, not user
+  config.
+- Never invent new variant or theme names. The validators in
+  `user_config.py` reject unknown values; show the user the registered
+  options instead.
+- For `elo`: the threshold curve is hardcoded; only the ELO
+  interpolation range is user-tunable. If asked to change XP-per-level
+  thresholds, point at `coach/bin/stats.py:_build_level_ladder` and
+  warn that doing so retroactively shifts existing user levels.
+- After any mutation, remind the user: "Open a new prompt or restart
+  Claude Code to see the new statusline render."