@diottodev/runic 1.0.0 → 1.1.0

package/engineering/chaos-engineering/skills/chaos-engineering/scripts/blast_radius_calculator.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Compute blast radius and risk score for a chaos experiment.
+
+Inputs: traffic share affected, user population, duration, baseline availability,
+expected impacted availability. Outputs expected affected users, error budget
+consumed, and a GREEN / YELLOW / RED risk score with PROCEED / REDUCE / ABORT
+recommendation.
+"""
+import argparse
+import json
+import sys
+
+
+def calculate(traffic_share, user_pop, duration_min, baseline_avail, impacted_avail, monthly_budget_min):
+    if not 0 <= traffic_share <= 1:
+        raise ValueError("traffic-share must be between 0 and 1")
+    if not 0 < impacted_avail <= 1:
+        raise ValueError("impacted-availability must be between 0 (exclusive) and 1")
+    if not 0 < baseline_avail <= 1:
+        raise ValueError("baseline-availability must be between 0 (exclusive) and 1")
+    affected_users = int(user_pop * traffic_share)
+    delta_avail = max(baseline_avail - impacted_avail, 0.0)
+    error_budget_consumed_min = round(duration_min * traffic_share * delta_avail, 4)
+    pct_of_monthly_budget = round(100 * error_budget_consumed_min / monthly_budget_min, 2) if monthly_budget_min > 0 else 0
+    if pct_of_monthly_budget < 1:
+        risk = "GREEN"
+        recommendation = "PROCEED"
+    elif pct_of_monthly_budget < 10:
+        risk = "YELLOW"
+        recommendation = "PROCEED with explicit owner sign-off; consider reducing traffic share"
+    else:
+        risk = "RED"
+        recommendation = "ABORT or REDUCE — blast radius exceeds 10% of monthly error budget"
+    return {
+        "inputs": {
+            "traffic_share": traffic_share,
+            "user_pop": user_pop,
+            "duration_min": duration_min,
+            "baseline_availability": baseline_avail,
+            "impacted_availability": impacted_avail,
+            "monthly_budget_min": monthly_budget_min,
+        },
+        "expected_affected_users": affected_users,
+        "expected_availability_delta": round(delta_avail, 4),
+        "error_budget_consumed_min": error_budget_consumed_min,
+        "pct_of_monthly_budget": pct_of_monthly_budget,
+        "risk": risk,
+        "recommendation": recommendation,
+    }
+
+
+def render_text(result):
+    print("Blast Radius Calculator")
+    print("=" * 40)
+    i = result["inputs"]
+    print(f"Traffic share affected:   {i['traffic_share'] * 100:.2f}%")
+    print(f"User population:          {i['user_pop']:,}")
+    print(f"Duration:                 {i['duration_min']} min")
+    print(f"Baseline availability:    {i['baseline_availability']}")
+    print(f"Impacted availability:    {i['impacted_availability']}")
+    print(f"Monthly error budget:     {i['monthly_budget_min']} min")
+    print("")
+    print(f"Expected affected users:  {result['expected_affected_users']:,}")
+    print(f"Availability delta:       {result['expected_availability_delta']}")
+    print(f"Error budget consumed:    {result['error_budget_consumed_min']} min ({result['pct_of_monthly_budget']}% of monthly)")
+    print("")
+    print(f"Risk:           {result['risk']}")
+    print(f"Recommendation: {result['recommendation']}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--traffic-share", type=float, required=True, help="Fraction (0-1) of traffic affected")
+    ap.add_argument("--user-pop", type=int, required=True, help="Total user population")
+    ap.add_argument("--duration-min", type=int, required=True, help="Experiment duration in minutes")
+    ap.add_argument("--baseline-availability", type=float, default=0.999, help="Baseline availability (default: 0.999)")
+    ap.add_argument("--expected-impact-availability", type=float, default=0.95, dest="impact_avail",
+                    help="Availability under fault (default: 0.95)")
+    ap.add_argument("--monthly-budget-min", type=float, default=43.2,
+                    help="Monthly error budget in minutes (default: 43.2 for 99.9%% on 30 days)")
+    ap.add_argument("--format", choices=["text", "json"], default="text")
+    args = ap.parse_args()
+
+    try:
+        result = calculate(
+            args.traffic_share, args.user_pop, args.duration_min,
+            args.baseline_availability, args.impact_avail, args.monthly_budget_min,
+        )
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 2
+
+    if args.format == "json":
+        print(json.dumps(result, indent=2))
+    else:
+        render_text(result)
+    return 0 if result["risk"] != "RED" else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/engineering/chaos-engineering/skills/chaos-engineering/scripts/experiment_designer.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""Generate a structured chaos engineering experiment plan.
+
+Enforces the required sections (hypothesis, steady-state metric, blast radius,
+abort criteria, rollback). Output is markdown by default; JSON available for
+piping into experiment_postmortem.py.
+"""
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+
+ATTACK_DEFAULTS = {
+    "latency": {"magnitude_hint": "+200ms", "tooling_hint": "tc / Chaos Mesh NetworkChaos"},
+    "error": {"magnitude_hint": "10% of requests return 5xx", "tooling_hint": "Toxiproxy / Chaos Mesh HTTPChaos"},
+    "cpu": {"magnitude_hint": "80% sustained", "tooling_hint": "stress-ng / Chaos Mesh StressChaos"},
+    "memory": {"magnitude_hint": "+1GiB pressure", "tooling_hint": "stress-ng / Chaos Mesh StressChaos"},
+    "disk": {"magnitude_hint": "fill /var to 95%", "tooling_hint": "stress-ng / Chaos Mesh IOChaos"},
+    "network-partition": {"magnitude_hint": "drop 100% to peer X", "tooling_hint": "Chaos Mesh NetworkChaos partition"},
+    "dependency-failure": {"magnitude_hint": "100% timeout to dependency", "tooling_hint": "service mesh fault injection"},
+    "time-skew": {"magnitude_hint": "+5 minutes", "tooling_hint": "libfaketime / Chaos Mesh TimeChaos"},
+    "kill-instance": {"magnitude_hint": "1 of N instances", "tooling_hint": "AWS FIS / Chaos Monkey"},
+}
+
+
+def build_plan(args):
+    attack_meta = ATTACK_DEFAULTS.get(args.attack, {})
+    magnitude = args.magnitude or attack_meta.get("magnitude_hint", "<set magnitude>")
+    tooling = args.tooling or attack_meta.get("tooling_hint", "<set tooling>")
+    plan = {
+        "experiment_id": f"chaos-{args.target}-{args.attack}-{int(datetime.now(timezone.utc).timestamp())}",
+        "created": datetime.now(timezone.utc).isoformat(),
+        "target": args.target,
+        "hypothesis": args.hypothesis,
+        "steady_state": {
+            "metric": args.steady_metric or "<must define before experiment>",
+            "baseline_window": "5 minutes pre-experiment",
+            "tolerance": args.tolerance or "within ±5% of baseline",
+        },
+        "attack": {
+            "type": args.attack,
+            "magnitude": magnitude,
+            "duration_min": args.duration_min,
+            "tooling": tooling,
+        },
+        "blast_radius": {
+            "scope": args.blast_radius or "<must define before experiment>",
+            "rollback_immediately_if": args.abort_if or "<must define abort criteria>",
+        },
+        "abort_criteria": _parse_abort_criteria(args.abort_if),
+        "rollback_procedure": args.rollback or "Disable fault injection; verify steady state recovers within 2 minutes.",
+        "monitoring_dashboard": args.dashboard or "<paste dashboard URL>",
+        "owner": args.owner or "<assign owner>",
+        "on_call_acknowledged": False,
+        "learning_question": args.learning or "What did we learn that we did not know before?",
+    }
+    return plan
+
+
+def _parse_abort_criteria(raw):
+    if not raw:
+        return []
+    parts = [p.strip() for p in raw.split(" OR ")]
+    return [{"signal": p, "action": "abort"} for p in parts if p]
+
+
+def render_markdown(plan):
+    lines = []
+    lines.append(f"# Chaos Experiment: {plan['experiment_id']}")
+    lines.append("")
+    lines.append(f"- **Target:** `{plan['target']}`")
+    lines.append(f"- **Created:** {plan['created']}")
+    lines.append(f"- **Owner:** {plan['owner']}")
+    lines.append("")
+    lines.append("## Hypothesis")
+    lines.append(f"> {plan['hypothesis']}")
+    lines.append("")
+    lines.append("## Steady-state metric")
+    lines.append(f"- **Metric:** {plan['steady_state']['metric']}")
+    lines.append(f"- **Baseline window:** {plan['steady_state']['baseline_window']}")
+    lines.append(f"- **Tolerance:** {plan['steady_state']['tolerance']}")
+    lines.append("")
+    lines.append("## Attack")
+    a = plan["attack"]
+    lines.append(f"- **Type:** {a['type']}")
+    lines.append(f"- **Magnitude:** {a['magnitude']}")
+    lines.append(f"- **Duration:** {a['duration_min']} minutes")
+    lines.append(f"- **Tooling:** {a['tooling']}")
+    lines.append("")
+    lines.append("## Blast radius")
+    lines.append(f"- **Scope:** {plan['blast_radius']['scope']}")
+    lines.append("")
+    lines.append("## Abort criteria")
+    if plan["abort_criteria"]:
+        for c in plan["abort_criteria"]:
+            lines.append(f"- {c['signal']}")
+    else:
+        lines.append("- **WARNING: no abort criteria defined — DO NOT RUN**")
+    lines.append("")
+    lines.append("## Rollback procedure")
+    lines.append(plan["rollback_procedure"])
+    lines.append("")
+    lines.append("## Monitoring")
+    lines.append(f"- Dashboard: {plan['monitoring_dashboard']}")
+    lines.append("")
+    lines.append("## Learning question")
+    lines.append(f"> {plan['learning_question']}")
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--target", required=True, help="Target system or service")
+    ap.add_argument("--hypothesis", required=True, help='Hypothesis: "When X, metric Y stays Z"')
+    ap.add_argument("--attack", required=True, choices=list(ATTACK_DEFAULTS.keys()))
+    ap.add_argument("--magnitude", help="Attack magnitude (default: per-attack hint)")
+    ap.add_argument("--duration-min", type=int, default=15)
+    ap.add_argument("--steady-metric", help="Steady-state metric name (e.g., 'p99 latency')")
+    ap.add_argument("--tolerance", help="Tolerance vs baseline (e.g., 'within ±5%%')")
+    ap.add_argument("--blast-radius", help="Blast radius (e.g., '5%% of US traffic')")
+    ap.add_argument("--abort-if", dest="abort_if", help='Abort criteria, OR-separated (e.g., "p99 > 1000ms OR error_rate > +1pp")')
+    ap.add_argument("--rollback", help="Rollback procedure")
+    ap.add_argument("--tooling", help="Chaos tool to use (default: per-attack hint)")
+    ap.add_argument("--dashboard", help="Monitoring dashboard URL")
+    ap.add_argument("--owner", help="Experiment owner")
+    ap.add_argument("--learning", help="Learning question")
+    ap.add_argument("--format", choices=["markdown", "json"], default="markdown")
+    args = ap.parse_args()
+
+    plan = build_plan(args)
+    if args.format == "json":
+        print(json.dumps(plan, indent=2))
+    else:
+        print(render_markdown(plan))
+    return 0 if plan["abort_criteria"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/engineering/chaos-engineering/skills/chaos-engineering/scripts/experiment_postmortem.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Generate a structured chaos experiment postmortem.
+
+Takes an experiment plan (JSON from experiment_designer.py) plus a results
+file (free-form text or structured key=value lines), and produces a markdown
+postmortem with hypothesis verdict, learning, surprises, and follow-up actions.
+Catches common postmortem failure modes: no learning, no follow-up, blame-laden
+language.
+"""
+import argparse
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+
+BLAME_PHRASES = [
+    "fault of",
+    "should have known",
+    "stupid",
+    "incompetent",
+    "obvious",
+    "lazy",
+    "didn't bother",
+]
+
+REQUIRED_RESULT_FIELDS = {
+    "outcome": "Did the hypothesis hold? (held|refuted|inconclusive)",
+    "duration_actual_min": "Actual experiment duration in minutes",
+    "aborted": "Was the experiment aborted? (true|false)",
+}
+
+
+def _parse_results(path):
+    """Parse a results file. Lines like 'key=value' OR free text. Returns dict."""
+    if not os.path.isfile(path):
+        return {"_raw_text": ""}
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        text = f.read()
+    parsed = {}
+    for line in text.splitlines():
+        m = re.match(r"^\s*([\w_.\-]+)\s*=\s*(.+?)\s*$", line)
+        if m:
+            parsed[m.group(1)] = m.group(2)
+    parsed["_raw_text"] = text
+    return parsed
+
+
+def _check_blame(text):
+    found = []
+    low = text.lower()
+    for phrase in BLAME_PHRASES:
+        if phrase in low:
+            found.append(phrase)
+    return found
+
+
+def build_postmortem(plan, results, follow_ups):
+    raw_text = results.get("_raw_text", "")
+    blame = _check_blame(raw_text)
+    pm = {
+        "experiment_id": plan.get("experiment_id", "?"),
+        "target": plan.get("target", "?"),
+        "created": datetime.now(timezone.utc).isoformat(),
+        "hypothesis": plan.get("hypothesis", "?"),
+        "outcome": results.get("outcome", "<UNRECORDED — must record>"),
+        "aborted": results.get("aborted", "<unrecorded>"),
+        "duration_actual_min": results.get("duration_actual_min", "<unrecorded>"),
+        "duration_planned_min": plan.get("attack", {}).get("duration_min", "?"),
+        "what_we_learned": results.get("learned", "<UNRECORDED — must record at least one learning>"),
+        "what_surprised_us": results.get("surprised", "<unrecorded>"),
+        "what_failed": results.get("failed", "<none recorded>"),
+        "what_held": results.get("held", "<none recorded>"),
+        "follow_ups": follow_ups,
+        "blame_warnings": blame,
+        "raw_results_excerpt": raw_text[:500],
+    }
+    return pm
+
+
+def render_markdown(pm):
+    lines = []
+    lines.append(f"# Postmortem: {pm['experiment_id']}")
+    lines.append("")
+    lines.append(f"- **Target:** `{pm['target']}`")
+    lines.append(f"- **Postmortem date:** {pm['created']}")
+    lines.append(f"- **Outcome:** {pm['outcome']}")
+    lines.append(f"- **Aborted:** {pm['aborted']}")
+    lines.append(f"- **Duration:** planned={pm['duration_planned_min']}min, actual={pm['duration_actual_min']}min")
+    lines.append("")
+    lines.append("## Hypothesis")
+    lines.append(f"> {pm['hypothesis']}")
+    lines.append("")
+    lines.append("## What we learned")
+    lines.append(pm["what_we_learned"])
+    lines.append("")
+    lines.append("## What surprised us")
+    lines.append(pm["what_surprised_us"])
+    lines.append("")
+    lines.append("## What failed")
+    lines.append(pm["what_failed"])
+    lines.append("")
+    lines.append("## What held")
+    lines.append(pm["what_held"])
+    lines.append("")
+    lines.append("## Follow-up actions")
+    if pm["follow_ups"]:
+        for f in pm["follow_ups"]:
+            lines.append(f"- [ ] {f}")
+    else:
+        lines.append("- _none recorded — every experiment should produce ≥1 follow-up_")
+    if pm["blame_warnings"]:
+        lines.append("")
+        lines.append("## ⚠️ Blame warning")
+        lines.append("Blame-laden language detected — postmortems should be blameless.")
+        for b in pm["blame_warnings"]:
+            lines.append(f"- '{b}'")
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--plan", required=True, help="Path to experiment plan JSON (from experiment_designer.py --format json)")
+    ap.add_argument("--result-log", required=True, help="Path to result log (free-form text OR key=value lines)")
+    ap.add_argument("--follow-up", action="append", default=[], help="A follow-up action; repeat for multiple")
+    ap.add_argument("--format", choices=["markdown", "json"], default="markdown")
+    args = ap.parse_args()
+
+    if not os.path.isfile(args.plan):
+        print(f"ERROR: plan not found: {args.plan}", file=sys.stderr)
+        return 2
+    with open(args.plan, "r", encoding="utf-8") as f:
+        plan = json.load(f)
+    results = _parse_results(args.result_log)
+    pm = build_postmortem(plan, results, args.follow_up)
+    if args.format == "json":
+        print(json.dumps(pm, indent=2))
+    else:
+        print(render_markdown(pm))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/engineering/claude-coach/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "claude-coach",
+  "description": "Personal Claude power-user coach. On first activation, delivers a personalized, ranked cheat-code glossary filtered to the user's use cases. On every subsequent turn, scans for missed power-user opportunities and surfaces at most ONE \u26a1 tip when a tip would genuinely 10x the next attempt. Silence is the default. Ships SKILL.md, cheat-codes glossary, coaching-rules decision tree, and three stdlib Python tools (cheat-code filter, prompt rater, 5-gate tip classifier). Includes cs-claude-coach agent persona and /cs:claude-coach slash command.",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/engineering/claude-coach",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills/claude-coach"
+  ]
+}

package/engineering/claude-coach/README.md

@@ -0,0 +1,39 @@
+# Claude Coach
+
+A personal coach that teaches you to use Claude at its full capability — without getting in your way.
+
+## What it does
+
+- **Teaches** — On first use, gives you a personalized cheat-code glossary ranked by impact
+- **Coaches** — Quietly watches your prompts and surfaces ONE tip per response when it spots an easy win
+- **Levels you up** — Rates your prompts on request and shows you a better version
+
+## Installation
+
+1. Place the `claude-coach/` folder in your skills directory
+2. Start a new conversation
+3. Say one of:
+   - "Coach me on Claude"
+   - "Teach me the Claude cheat codes"
+   - "Make me a Claude power user"
+
+The skill activates and stays on for the rest of the conversation.
+
+## Usage
+
+Once activated, just chat normally. The coach will:
+
+- Stay silent on most turns (that is intentional)
+- Append a ⚡ **Power-user tip** at the end of a response when it spots an easy win
+- Rate your prompt when you ask "rate that prompt"
+- Give a progress check when you ask "how am I doing"
+
+To turn it off mid-conversation, say "stop with the tips" and it goes quiet.
+
+## Philosophy
+
+Most coaching tools are annoying because they interrupt. This one answers your actual question first, then adds at most one observation. If there is nothing genuinely useful to add, it says nothing.
+
+## License
+
+MIT

package/engineering/claude-coach/agents/cs-claude-coach.md

@@ -0,0 +1,50 @@
+---
+name: cs-claude-coach
+description: Use proactively after any user message in a Claude.ai or Claude Code session where the user is learning to prompt better or has explicitly activated coaching. Default persona for the claude-coach skill. Watches each turn for missed power-user opportunities and surfaces at most one ⚡ tip when a tip would genuinely 10x the next attempt.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+# cs-claude-coach — Power-User Coach Persona
+
+You are the persona behind the `claude-coach` skill. Your job is to teach the user to use Claude at full capability, then quietly reinforce the lesson by spotting missed opportunities in real time.
+
+## Operating discipline
+
+1. **Answer first, coach second.** The user's actual request is the deliverable. Coaching is additive, never blocking.
+2. **One tip per response, maximum.** If you have several observations, pick the single highest-impact one and save the rest.
+3. **Silence is the default.** Most turns produce no tip. If a tip would be obvious, condescending, or interrupt deep work, stay silent.
+4. **Tip format is fixed.** Append at the end of the response:
+
+   ```
+   ---
+
+   ⚡ **Power-user tip:** [one sentence]
+
+   [Optional: one-line example showing the improved approach]
+   ```
+
+5. **Push-back stops you immediately.** If the user says "stop with the tips" or signals tips are unwelcome, go quiet and stay quiet until they re-activate the skill.
+
+## When to invoke
+
+Activate on first explicit request to learn Claude ("coach me", "make me a power user", "Claude cheat codes"). Stay on for the remainder of the conversation. On every subsequent turn, run the 5-gate decision tree from `references/coaching-rules.md` before deciding whether to surface a tip.
+
+## On-demand modes
+
+- `"rate that prompt"` → return a structured rating: score, what worked, what to improve, better version.
+- `"how am I doing"` → return a brief progress check: techniques used, techniques still untried, one suggestion.
+
+## Tools at your disposal
+
+The skill ships three Python helpers under `skills/claude-coach/scripts/`:
+
+- `cheat_code_filter.py` — filter the glossary by use case keywords
+- `prompt_rater.py` — score a prompt 0-10 across clarity / constraint / format / audience
+- `coach_tip_classifier.py` — run the 5-gate decision tree on a turn
+
+Invoke them when the heuristic decision is non-obvious. Stdlib-only, fast, deterministic.
+
+## Voice
+
+Senior practitioner next to a junior one. Direct, generous, never condescending. No emojis except the ⚡ tip marker. No corporate-coach language ("Great question!", "Wonderful!", "On your prompting journey!").

package/engineering/claude-coach/commands/cs-claude-coach.md

@@ -0,0 +1,32 @@
+---
+description: Activate the claude-coach skill — personal Claude power-user coaching for the rest of the conversation.
+argument-hint: "[use cases, e.g. 'writing, coding']"
+---
+
+# /cs:claude-coach
+
+Activates the `claude-coach` skill. From this point on, the conversation gains:
+
+- A personalized cheat-code glossary delivered on the first turn (ranked by impact, filtered to your use cases)
+- At most one ⚡ power-user tip per response, only when a tip would genuinely 10x your next attempt
+- On-demand `"rate that prompt"` and `"how am I doing"` feedback
+
+## What happens when this command fires
+
+1. If `$ARGUMENTS` contains use cases (e.g. `writing, coding`), skip the use-case question and proceed.
+2. Otherwise, ask exactly one question: **"What are your top 2-3 use cases for Claude?"** and wait.
+3. Load `engineering/claude-coach/skills/claude-coach/references/cheat-codes.md`, rank techniques against the stated use cases, and present the top 5-7 with one-line explanations and one concrete example each.
+4. End with: *"I'll watch your prompts going forward and surface tips when I spot an easy win — max one per response. Ask me 'rate that prompt' anytime for direct feedback."*
+5. Stay active for the rest of the conversation. On every subsequent turn, run the 5-gate decision tree from `references/coaching-rules.md` before deciding whether to surface a tip.
+
+## Examples
+
+```
+/cs:claude-coach
+/cs:claude-coach writing, coding
+/cs:claude-coach research, learning
+```
+
+## To turn it off
+
+Say "stop with the tips" or "no more coaching" mid-conversation and the persona goes silent until re-activated.

package/engineering/claude-coach/skills/claude-coach/README.md

@@ -0,0 +1,14 @@
+# claude-coach — Inner Skill
+
+This is the SKILL.md-bearing folder for the `claude-coach` plugin. Plugin manifest, persona agent, and slash command live one level up.
+
+## Contents
+
+- `SKILL.md` — main skill instructions
+- `references/cheat-codes.md` — ranked glossary of Claude power-user techniques
+- `references/coaching-rules.md` — 5-gate decision tree for when to coach
+- `scripts/cheat_code_filter.py` — filter the glossary by use case
+- `scripts/prompt_rater.py` — score a prompt 0-10
+- `scripts/coach_tip_classifier.py` — run the 5-gate decision tree on a turn
+
+For end-user installation and usage, see the README at the plugin root.