@drunkcoding/agents-and-skills 0.0.28 → 0.0.30

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "tech-graph",
       "source": "./plugins/tech-graph",
       "description": "6-step wizard for technical diagrams (SVG/PNG) via fireworks-tech-graph",
-      "version": "0.0.28",
+      "version": "0.0.30",
       "category": "diagram",
       "keywords": [
         "diagram",
@@ -26,7 +26,7 @@
       "name": "html-effectiveness",
       "source": "./plugins/html-effectiveness",
       "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
-      "version": "0.0.28",
+      "version": "0.0.30",
       "category": "reports",
       "keywords": [
         "html",
@@ -41,7 +41,7 @@
       "name": "plugin-validator",
       "source": "./plugins/plugin-validator",
       "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
-      "version": "0.0.28",
+      "version": "0.0.30",
       "category": "tooling",
       "keywords": [
         "validation",
@@ -56,14 +56,15 @@
     {
       "name": "team-share",
       "source": "./plugins/team-share",
-      "description": "Share Claude plugin settings with a team, scaffold CLAUDE.md when needed, refresh the Understand-Anything graph, and stage the onboarding artifacts for review.",
-      "version": "0.0.28",
+      "description": "Onboard your team with an interactive setup menu: install CodeGraph, build the Understand-Anything knowledge graph, and share Claude Code settings — run any combination, all idempotent.",
+      "version": "0.0.30",
       "category": "tooling",
       "keywords": [
         "onboarding",
         "team",
         "claude",
         "settings",
+        "codegraph",
         "understand-anything",
         "git-lfs"
       ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Personal collection of Claude Code skills and agents, installable via `npx skills`.",
   "keywords": [
     "claude-code",

package/plugins/html-effectiveness/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "html-effectiveness",
   "displayName": "HTML Effectiveness Reports",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
   "author": {
     "name": "Steven Hoang"

package/plugins/plugin-validator/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plugin-validator",
   "displayName": "Plugin Validator",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
   "author": {
     "name": "Steven Hoang"

package/plugins/team-share/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "team-share",
   "displayName": "Team Share",
-  "version": "0.0.28",
-  "description": "Share Claude plugin settings with a team, scaffold CLAUDE.md when needed, refresh the Understand-Anything graph, and stage the onboarding artifacts for review.",
+  "version": "0.0.30",
+  "description": "Onboard your team with an interactive setup menu: install CodeGraph, build the Understand-Anything knowledge graph, and share Claude Code settings — run any combination, all idempotent.",
   "author": {
     "name": "Steven Hoang"
   },
@@ -11,6 +11,7 @@
     "team",
     "claude",
     "settings",
+    "codegraph",
     "understand-anything",
     "git-lfs"
   ]

package/plugins/team-share/README.md

@@ -1,30 +1,46 @@
 # team-share
 
-Share repo-level Claude Code onboarding artifacts with your team in one pass.
+Onboard your team with an interactive setup menu. Run `/team-share` and choose which actions to execute — only selected actions run.
 
 ## What it does
 
-The `team-share` agent prepares a repository for teammates by:
+The `team-share` agent presents a multi-select menu with four options:
 
-1. Writing a shareable `.claude/settings.json` from the maintainer's enabled plugins and marketplaces.
-2. Ensuring `CLAUDE.md` exists when the project does not already have one.
-3. Refreshing the Understand-Anything knowledge graph with auto-update enabled.
-4. Tracking the graph with `git-lfs` and staging the resulting onboarding files for human review.
+| Option | What runs |
+|--------|-----------|
+| **Default (CodeGraph + Claude config)** *(Recommended)* | `codegraph-setup` + `claude-config` |
+| Setup CodeGraph | `codegraph-setup` |
+| Setup Understand-Anything | `understand-setup` |
+| Setup team Claude config | `claude-config` |
 
-It is designed to be idempotent and intentionally stops short of committing or pushing.
+## Skills (independently invocable)
 
-## Usage
+Each action is also available as a standalone skill:
+
+### `/codegraph-setup`
+
+Installs the [CodeGraph](https://github.com/colbymchenry/codegraph) CLI, wires it to Claude Code via MCP (`codegraph install`), and initialises the current project (`codegraph init`). Works on macOS, Linux, and Windows.
+
+### `/understand-setup`
 
-Run:
+Installs the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin, builds the knowledge graph with `--auto-update`, generates `docs/wiki`, git-lfs tracks the graph, and stages all artefacts.
+
+### `/claude-config`
+
+Merges `enabledPlugins` and `extraKnownMarketplaces` from the maintainer's user settings into `.claude/settings.json`, scaffolds `CLAUDE.md` when missing, injects the Understand-Anything code-research section, and stages the result.
+
+## Usage
 
 ```text
 /team-share [--force] [--language <lang>]
 ```
 
-Arguments are passed through to `/understand` alongside the default `--auto-update` behavior.
+Arguments are forwarded to `/understand` when `understand-setup` is selected.
 
 ## Notes
 
-- The command expects `git-lfs` and `jq` to be installed.
-- It stages files for review but does not create commits.
-- The knowledge graph flow depends on the `understand-anything` plugin being available to teammates.
+- `codegraph-setup` requires internet access to download the CLI.
+- `understand-setup` requires `git-lfs` and `jq` to be installed.
+- `claude-config` requires `jq` to be installed.
+- All skills stage files but never commit or push — a human reviews and commits.
+- All skills are idempotent — safe to re-run.

package/plugins/team-share/agents/team-share.md

@@ -1,228 +1,53 @@
 ---
 name: team-share
 description: Share Claude plugin settings with the team, build or refresh the Understand-Anything knowledge graph, initialize the docs wiki, and git-lfs track it before staging everything for review.
-argument-hint: "[--force] [--language <lang>] (passed through to /understand)"
-allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill
+argument-hint: "[--force] [--language <lang>] (forwarded to understand-setup → /understand)"
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, Skill, AskUserQuestion
 ---
 
 # /team-share
 
-Make this repo onboarding-ready for the team in one pass:
+Make this repo onboarding-ready for the team in one pass. Choose which setup actions to run.
 
-1. Generate a **shareable `.claude/settings.json`** (plugins + marketplaces) from the maintainer's live setup.
-2. Build/refresh the **Understand-Anything knowledge graph** with auto-update enabled.
-3. Initialize the **docs wiki** for Understand-Anything under `docs/wiki`.
-4. **git-lfs track** the graph and **stage** everything — leaving the commit to a human.
+## Step 0 — Interactive menu
 
-This command is **idempotent** — safe to re-run. It **never commits or pushes**; it only stages.
-`$ARGUMENTS` (e.g. `--force`, `--language zh`) is forwarded to `/understand`.
+Before any work begins, use AskUserQuestion with `multiSelect: true` and these four options:
 
-Plugin source: Understand-Anything (Egonex fork) — <https://github.com/Egonex-AI/Understand-Anything>
+| Label | Description |
+|-------|-------------|
+| Default (CodeGraph + Claude config) *(Recommended)* | Install CodeGraph CLI + init project, then share .claude/settings.json and scaffold CLAUDE.md. Best starting point for most repos. |
+| Setup CodeGraph | Install the CodeGraph CLI, wire it to Claude Code MCP, and run codegraph init in this project. |
+| Setup Understand-Anything | Install the Understand-Anything plugin, build the knowledge graph with auto-update, and generate docs/wiki. |
+| Setup team Claude config | Merge enabledPlugins + marketplaces into .claude/settings.json, scaffold CLAUDE.md, and stage. |
 
----
-
-## Step 0 — Preconditions (stop on any failure, fail loud)
-
-```bash
-git rev-parse --is-inside-work-tree                 # must be a git repo
-git rev-parse --abbrev-ref HEAD                      # report branch; warn if it is the default/protected branch
-command -v git-lfs || echo "MISSING: git-lfs — install it (brew install git-lfs) before continuing"
-command -v jq      || echo "MISSING: jq — install it (brew install jq) before continuing"
-```
+If the user selects nothing, print `"Nothing selected — exiting."` and stop immediately.
 
-- If not a git repo, or `git-lfs`/`jq` are missing → **report and STOP**. Do not partially apply.
-- If on a protected branch (e.g. `develop`/`main`), warn and ask the user to switch to a feature branch first.
+## Step 1 — Build run-list
 
----
-
-## Step 1 — Generate the shareable `.claude/settings.json` **and ensure `CLAUDE.md` exists**
-
-Goal: teammates who clone the repo get the **same plugins + marketplaces** the maintainer uses, with **no machine-specific data leaked** — *and* a project-level `CLAUDE.md` is scaffolded if it is missing.
-
-### 1a — Merge plugin + marketplace settings
-
-Copy **only** `enabledPlugins` and `extraKnownMarketplaces` from the maintainer's user settings into the repo settings. Do **NOT** copy `hooks`, `permissions`, `env`, or any key holding absolute paths or machine-local secrets.
-
-```bash
-USER_SETTINGS="$HOME/.claude/settings.json"
-REPO_SETTINGS=".claude/settings.json"
-
-mkdir -p .claude
-[ -f "$REPO_SETTINGS" ] || echo '{}' > "$REPO_SETTINGS"
-
-# Merge: repo settings win on scalar keys; the two plugin maps are unioned
-# (user entries layered on top of any existing repo entries). Only these two
-# keys are taken from user settings — nothing else crosses over.
-jq -s '
-  .[0] as $repo | .[1] as $user
-  | $repo
-  + { enabledPlugins:        (($repo.enabledPlugins        // {}) + ($user.enabledPlugins        // {})) }
-  + { extraKnownMarketplaces: (($repo.extraKnownMarketplaces // {}) + ($user.extraKnownMarketplaces // {})) }
-' "$REPO_SETTINGS" "$USER_SETTINGS" > "$REPO_SETTINGS.tmp" && mv "$REPO_SETTINGS.tmp" "$REPO_SETTINGS"
-
-jq '{enabledPlugins, extraKnownMarketplaces}' "$REPO_SETTINGS"   # show the result for review
-```
-
-Notes:
-- This shares **currently-enabled** plugins (the in-use set). It does not pull disabled-but-installed plugins.
-- Some marketplaces may be **private** (require repo/org access). Flag any private marketplace so the user can confirm teammates can reach it.
-- Confirm `understand-anything@understand-anything` is present in `enabledPlugins` (needed for Step 2's auto-update hook to work on teammates' machines). If absent, tell the user to install it:
-  `/plugin marketplace add Egonex-AI/Understand-Anything` then `/plugin install understand-anything`.
-
-### 1b — Scaffold `CLAUDE.md` if missing
-
-The `claude-code-setup` plugin (from the `claude-plugins-official` marketplace) generates a project-savvy `CLAUDE.md` when one does not yet exist. Running the install command is **idempotent** — if the file already exists, this step is skipped.
-
-```bash
-# Only create CLAUDE.md when it does not already exist.
-if [ -f CLAUDE.md ]; then
-  echo "✅ CLAUDE.md already exists — skipping plugin install."
-else
-  echo "📝 CLAUDE.md not found — installing claude-code-setup plugin to scaffold it…"
-  claude plugin install claude-code-setup@claude-plugins-official
-  if [ -f CLAUDE.md ]; then
-    echo "✅ CLAUDE.md created by claude-code-setup."
-  else
-    echo "⚠️  claude-code-setup did not produce CLAUDE.md — you may need to run it manually or create the file yourself."
-  fi
-fi
-```
-
-Notes:
-- The plugin must already be available in the `claude-plugins-official` marketplace (it is already listed in `enabledPlugins` in the repo settings).
-- If the team prefers a custom `CLAUDE.md` template, commit one *before* running this command so the guard `[ -f CLAUDE.md ]` skips the plugin step.
-
-### 1c — Inject the Understand-Anything code-research section into `CLAUDE.md`
-
-Goal: every teammate's AI assistant knows to use the Understand-Anything commands when doing code research, without duplicating the section on re-runs.
-
-```bash
-# Only append when the section marker is not already present (idempotent).
-if grep -qF '## Code research with Understand-Anything' CLAUDE.md 2>/dev/null; then
-  echo "✅ Understand-Anything section already in CLAUDE.md — skipping."
-else
-  cat >> CLAUDE.md << 'EOF'
-
-## Code research with Understand-Anything
-
-This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw file-by-file exploration when doing code research:**
-
-| Goal | Command |
-|------|---------|
-| Explore the full codebase graph | `/understand` |
-| Ask a free-form question about the code | `/understand-chat <question>` |
-| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
-| See impact of your current changes before committing | `/understand-diff` |
-| Open the interactive visual dashboard | `/understand-dashboard` |
-| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
-| Generate an onboarding guide for new teammates | `/understand-onboard` |
-| Generate or refresh wiki knowledge under `docs/wiki` | `/understand-knowledge docs/wiki` |
-
-The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force the graph to catch up, and re-run `/understand-knowledge docs/wiki` when you want to refresh the generated wiki content.
-EOF
-  echo "✅ Understand-Anything code-research section appended to CLAUDE.md."
-fi
-```
-
-Notes:
-- The section is appended at the end of `CLAUDE.md` so it does not disturb existing content.
-- The marker string `## Code research with Understand-Anything` is used as the idempotency guard — do not rename the heading without updating the guard.
-- If `MIRRORS.md` / `AGENTS.md` or other agent-config files exist alongside `CLAUDE.md` (e.g. for non-Claude runtimes), apply the same append to them so all agent runtimes get the guidance. The loop below appends the same section only when missing.
-
-```bash
-# Mirror to AGENTS.md / MIRRORS.md if they exist (non-Claude runtimes).
-for f in AGENTS.md MIRRORS.md; do
-  if [ -f "$f" ] && ! grep -qF '## Code research with Understand-Anything' "$f" 2>/dev/null; then
-    cat >> "$f" << 'EOF'
-
-## Code research with Understand-Anything
-
-This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw file-by-file exploration when doing code research:**
-
-| Goal | Command |
-|------|---------|
-| Explore the full codebase graph | `/understand` |
-| Ask a free-form question about the code | `/understand-chat <question>` |
-| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
-| See impact of your current changes before committing | `/understand-diff` |
-| Open the interactive visual dashboard | `/understand-dashboard` |
-| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
-| Generate an onboarding guide for new teammates | `/understand-onboard` |
-| Generate or refresh wiki knowledge under `docs/wiki` | `/understand-knowledge docs/wiki` |
-
-The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force the graph to catch up, and re-run `/understand-knowledge docs/wiki` when you want to refresh the generated wiki content.
-EOF
-    echo "✅ Understand-Anything section also appended to $f."
-  fi
-done
-```
+From the selected options, assemble a deduplicated run-list. Mapping:
 
----
+- "Default (CodeGraph + Claude config)" → `codegraph-setup`, `claude-config`
+- "Setup CodeGraph" → `codegraph-setup`
+- "Setup Understand-Anything" → `understand-setup`
+- "Setup team Claude config" → `claude-config`
 
-## Step 2 — Build / refresh the knowledge graph (auto-update on)
-
-Run the skill **in the main thread** (it dispatches its own analyzer subagents — do not wrap it in a subagent):
-
-```
-/understand --auto-update $ARGUMENTS
-```
-
-- `--auto-update` writes `{"autoUpdate": true}` to `.understand-anything/config.json`. The plugin's bundled hook then incrementally patches the graph whenever a `git commit` is made (and on stale Session resume, depending on the plugin version).
-- If a graph already exists, `/understand` runs incrementally. Pass `--force` (via `$ARGUMENTS`) to rebuild from scratch.
-- After it finishes, confirm these exist: `.understand-anything/knowledge-graph.json`, `.understand-anything/meta.json`, `.understand-anything/config.json` (with `autoUpdate: true`).
-
----
+Deduplication: if a skill appears more than once (e.g. "Default" + "Setup CodeGraph" both selected), keep it once. Final order is always: `codegraph-setup` → `understand-setup` → `claude-config`.
 
-## Step 3 — Initialize the docs wiki from Understand-Anything
+## Step 2 — Dispatch
 
-Create the wiki folder if needed, then generate or refresh the wiki content in the main thread:
+Invoke each skill in the run-list in order using the Skill tool:
 
-```bash
-mkdir -p docs/wiki
-```
+- `codegraph-setup`  → `team-share:codegraph-setup` (no arguments)
+- `understand-setup` → `team-share:understand-setup` with `$ARGUMENTS` forwarded
+- `claude-config`    → `team-share:claude-config` (no arguments)
 
-```
-/understand-knowledge docs/wiki
-```
+The agent does no implementation work itself — all logic lives in the skills.
 
-- `mkdir -p docs/wiki` is idempotent and ensures the target directory exists before wiki generation.
-- Re-running `/understand-knowledge docs/wiki` should refresh the generated wiki content in place.
-- After it finishes, confirm `docs/wiki/` exists and contains generated wiki files before staging.
-
----
-
-## Step 4 — Ignore scratch, git-lfs track the graph, and stage
-
-Scratch outputs must stay local (never committed):
-
-```bash
-# .gitignore — append only if missing (idempotent)
-for p in ".understand-anything/intermediate/" ".understand-anything/tmp/" ".understand-anything/diff-overlay.json"; do
-  grep -qxF "$p" .gitignore 2>/dev/null || echo "$p" >> .gitignore
-done
-
-# Large graphs (10 MB+) belong in LFS; tracking is harmless for small ones too.
-git lfs install
-git lfs track ".understand-anything/*.json"
-
-# Stage — but DO NOT commit. A human reviews and commits.
-git add .gitattributes .gitignore .claude/settings.json .understand-anything/ docs/wiki/ CLAUDE.md
-# Also stage AGENTS.md / MIRRORS.md if they were modified.
-for f in AGENTS.md MIRRORS.md; do [ -f "$f" ] && git add "$f"; done
-
-git status
-git lfs ls-files          # confirm the graph json is LFS-tracked
-```
-
----
+## Done — summary
 
-## Done — report, do not commit
+After all selected skills complete, print a summary:
 
-Summarize for the user:
-- Which plugins/marketplaces were written into `.claude/settings.json` (call out any private ones).
-- `CLAUDE.md` status: already existed vs created by `claude-code-setup`; Understand-Anything section added vs already present.
-- `AGENTS.md` status (if applicable): Understand-Anything section added vs already present / not found.
-- Graph status: created vs incrementally updated; `autoUpdate` on/off.
-- Wiki status: `docs/wiki` created vs already existed; `/understand-knowledge docs/wiki` run successfully vs failed.
-- What is staged and confirmed LFS-tracked.
-- Remind them: **review, then commit yourself** (e.g. `git commit -m "chore: share team onboarding (claude settings + CLAUDE.md + understand graph + wiki)"`). The auto-update hook keeps the graph fresh on every future commit, and the wiki can be refreshed by re-running `/understand-knowledge docs/wiki` whenever needed.
+- Which actions ran (in order).
+- Any failures or warnings reported by individual skills.
+- Reminder: **review staged changes, then commit yourself** — for example:
+  `git commit -m "chore: team onboarding setup (codegraph + claude config)"`

package/plugins/team-share/skills/claude-config/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: claude-config
+description: Write a shareable .claude/settings.json from the maintainer's enabled plugins and marketplaces, scaffold CLAUDE.md when missing, inject the Understand-Anything code-research section, and stage the result. Idempotent — safe to re-run.
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# claude-config
+
+Set up repo-level Claude Code configuration for teammates.
+
+## Preconditions (stop on any failure)
+
+```bash
+git rev-parse --is-inside-work-tree || { echo "ERROR: not a git repo"; exit 1; }
+command -v jq || echo "MISSING: jq — install it (brew install jq / apt install jq / choco install jq) before continuing"
+```
+
+If not a git repo or `jq` is missing → report and STOP. Do not partially apply.
+
+Check current branch and warn if on a protected branch:
+
+```bash
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+case "$BRANCH" in
+  main|master|develop|dev)
+    echo "⚠️  You are on branch '$BRANCH'. Consider switching to a feature branch before continuing."
+    ;;
+esac
+```
+
+## Step 1 — Merge plugin + marketplace settings
+
+Copy only `enabledPlugins` and `extraKnownMarketplaces` from the maintainer's user settings into the repo settings. Do NOT copy `hooks`, `permissions`, `env`, or any key with absolute paths.
+
+```bash
+USER_SETTINGS="$HOME/.claude/settings.json"
+REPO_SETTINGS=".claude/settings.json"
+
+mkdir -p .claude
+[ -f "$REPO_SETTINGS" ] || echo '{}' > "$REPO_SETTINGS"
+
+jq -s '
+  .[0] as $repo | .[1] as $user
+  | $repo
+  + { enabledPlugins:         (($repo.enabledPlugins         // {}) + ($user.enabledPlugins         // {})) }
+  + { extraKnownMarketplaces: (($repo.extraKnownMarketplaces // {}) + ($user.extraKnownMarketplaces // {})) }
+' "$REPO_SETTINGS" "$USER_SETTINGS" > "$REPO_SETTINGS.tmp" && mv "$REPO_SETTINGS.tmp" "$REPO_SETTINGS"
+
+jq '{enabledPlugins, extraKnownMarketplaces}' "$REPO_SETTINGS"
+```
+
+Inspect the result: flag any marketplace URL that looks private (contains org names, auth tokens, or is not a well-known public registry).
+
+## Step 2 — Scaffold CLAUDE.md if missing
+
+```bash
+if [ -f CLAUDE.md ]; then
+  echo "✅ CLAUDE.md already exists — skipping."
+else
+  echo "📝 CLAUDE.md not found — installing claude-code-setup plugin to scaffold it…"
+  claude plugin install claude-code-setup@claude-plugins-official
+  if [ -f CLAUDE.md ]; then
+    echo "✅ CLAUDE.md created by claude-code-setup."
+  else
+    echo "⚠️  claude-code-setup did not produce CLAUDE.md — create it manually or commit a template first."
+  fi
+fi
+```
+
+## Step 3 — Inject Understand-Anything section into CLAUDE.md
+
+Append only when the section marker is absent (idempotent guard):
+
+```bash
+if grep -qF '## Code research with Understand-Anything' CLAUDE.md 2>/dev/null; then
+  echo "✅ Understand-Anything section already in CLAUDE.md — skipping."
+else
+  cat >> CLAUDE.md << 'UASECTION'
+
+## Code research with Understand-Anything
+
+This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw file-by-file exploration when doing code research:**
+
+| Goal | Command |
+|------|---------|
+| Explore the full codebase graph | `/understand` |
+| Ask a free-form question about the code | `/understand-chat <question>` |
+| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
+| See impact of your current changes before committing | `/understand-diff` |
+| Open the interactive visual dashboard | `/understand-dashboard` |
+| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
+| Generate an onboarding guide for new teammates | `/understand-onboard` |
+| Generate or refresh wiki knowledge under `docs/wiki` | `/understand-knowledge docs/wiki` |
+
+The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force a rebuild, and `/understand-knowledge docs/wiki` to refresh the wiki.
+UASECTION
+  echo "✅ Understand-Anything section appended to CLAUDE.md."
+fi
+```
+
+Mirror to AGENTS.md / MIRRORS.md if they exist:
+
+```bash
+for f in AGENTS.md MIRRORS.md; do
+  if [ -f "$f" ] && ! grep -qF '## Code research with Understand-Anything' "$f" 2>/dev/null; then
+    cat >> "$f" << 'UASECTION'
+
+## Code research with Understand-Anything
+
+This project uses the [Understand-Anything](https://github.com/Egonex-AI/Understand-Anything) plugin to maintain an interactive knowledge graph of the codebase. **Always prefer these commands over raw file-by-file exploration when doing code research:**
+
+| Goal | Command |
+|------|---------|
+| Explore the full codebase graph | `/understand` |
+| Ask a free-form question about the code | `/understand-chat <question>` |
+| Deep-dive into a specific file or function | `/understand-explain <path/symbol>` |
+| See impact of your current changes before committing | `/understand-diff` |
+| Open the interactive visual dashboard | `/understand-dashboard` |
+| Extract business-domain knowledge (domains, flows, steps) | `/understand-domain` |
+| Generate an onboarding guide for new teammates | `/understand-onboard` |
+| Generate or refresh wiki knowledge under `docs/wiki` | `/understand-knowledge docs/wiki` |
+
+The knowledge graph lives in `.understand-anything/knowledge-graph.json` and is kept up-to-date automatically on every commit (auto-update is enabled). Re-run `/understand` after large refactors to force a rebuild, and `/understand-knowledge docs/wiki` to refresh the wiki.
+UASECTION
+    echo "✅ Section also appended to $f."
+  fi
+done
+```
+
+## Step 4 — Stage
+
+```bash
+git add .claude/settings.json CLAUDE.md
+for f in AGENTS.md MIRRORS.md; do [ -f "$f" ] && git add "$f"; done
+git status
+```
+
+## Done — report
+
+- Which plugins/marketplaces were written to `.claude/settings.json` (flag any private ones).
+- `CLAUDE.md` status: already existed vs created; Understand-Anything section added vs already present.
+- `AGENTS.md` / `MIRRORS.md` status (if applicable).
+- Files staged. Remind: **review then commit yourself.**

package/plugins/team-share/skills/codegraph-setup/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: codegraph-setup
+description: Install the CodeGraph CLI, wire it to Claude Code via MCP (codegraph install), and initialise the current project (codegraph init). Works on macOS, Linux, and Windows (Git Bash / PowerShell). Idempotent — skips install if codegraph is already in PATH.
+allowed-tools: Bash
+---
+
+# codegraph-setup
+
+Install CodeGraph and initialise it for this project.
+
+## Precondition
+
+Must be inside a git repo:
+
+```bash
+git rev-parse --is-inside-work-tree || { echo "ERROR: not a git repo — run this from your project root"; exit 1; }
+```
+
+## Step 1 — Install CLI if not present (OS-aware, idempotent)
+
+Run this as a single bash block so variables persist:
+
+```bash
+if command -v codegraph >/dev/null 2>&1; then
+  echo "✅ codegraph already installed: $(codegraph --version 2>/dev/null || echo 'version unknown')"
+  echo "Skipping install — proceeding to wire and init."
+else
+  if command -v uname >/dev/null 2>&1; then
+    _OS=$(uname -s)
+  else
+    _OS="Windows"
+  fi
+
+  case "$_OS" in
+    Darwin|Linux)
+      curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh
+      ;;
+    *)
+      _PS=$(command -v pwsh 2>/dev/null || command -v powershell 2>/dev/null)
+      if [ -n "$_PS" ]; then
+        "$_PS" -Command "irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex"
+      else
+        echo "ERROR: cannot detect OS or find PowerShell."
+        echo "Install manually: https://github.com/colbymchenry/codegraph#installation"
+        exit 1
+      fi
+      ;;
+  esac
+
+  command -v codegraph >/dev/null 2>&1 || { echo "ERROR: codegraph install failed — not found in PATH after install"; exit 1; }
+  echo "✅ codegraph installed: $(codegraph --version 2>/dev/null || echo 'version unknown')"
+fi
+```
+
+Note: on Windows with Git Bash, `uname -s` returns `MINGW64_NT-*` or similar, which falls through to the `*)` case and attempts PowerShell. This is correct behaviour.
+
+## Step 3 — Wire to Claude Code
+
+Register the CodeGraph MCP server with Claude Code:
+
+```bash
+codegraph install
+```
+
+This makes CodeGraph's context tools available inside Claude Code sessions.
+
+## Step 4 — Initialise the project
+
+Build the code knowledge graph for this repo:
+
+```bash
+codegraph init
+```
+
+This creates a local SQLite index of symbols, dependencies, and cross-file relationships.
+
+## Done — report
+
+- Install: new install vs already present (version).
+- Wire: `codegraph install` output.
+- Init: `codegraph init` output, any errors.

package/plugins/team-share/skills/understand-setup/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: understand-setup
+description: Install the Understand-Anything plugin, build the knowledge graph with auto-update enabled, generate docs/wiki, git-lfs track the graph, and stage all artefacts. Idempotent — safe to re-run.
+argument-hint: "[--force] [--language <lang>] (passed through to /understand)"
+allowed-tools: Bash, Read, Write, Edit, Skill
+---
+
+# understand-setup
+
+Install Understand-Anything and build the knowledge graph for this repo.
+
+## Preconditions (stop on any failure)
+
+```bash
+git rev-parse --is-inside-work-tree || { echo "ERROR: not a git repo"; exit 1; }
+command -v git-lfs || echo "MISSING: git-lfs — install it (brew install git-lfs / apt install git-lfs) before continuing"
+command -v jq      || echo "MISSING: jq — install it (brew install jq / apt install jq / choco install jq) before continuing"
+```
+
+If not a git repo, or `git-lfs`/`jq` are missing → report and STOP. Do not partially apply.
+
+Check current branch and warn if on a protected branch:
+
+```bash
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+case "$BRANCH" in
+  main|master|develop|dev)
+    echo "⚠️  You are on branch '$BRANCH'. Consider switching to a feature branch first."
+    ;;
+esac
+```
+
+## Step 1 — Install the plugin
+
+Install via the Claude Code plugin system (idempotent):
+
+```
+/plugin marketplace add Egonex-AI/Understand-Anything
+/plugin install understand-anything
+```
+
+After install, confirm `understand-anything@understand-anything` appears in `.claude/settings.json`:
+
+```bash
+jq '.enabledPlugins["understand-anything@understand-anything"]' .claude/settings.json 2>/dev/null || echo "⚠️  understand-anything not found in .claude/settings.json — teammates may need to install manually."
+```
+
+## Step 2 — Build / refresh the knowledge graph
+
+Run the skill **in the main thread** (it dispatches its own analyzer subagents — do not wrap it in a subagent):
+
+```
+/understand --auto-update $ARGUMENTS
+```
+
+- `--auto-update` writes `{"autoUpdate": true}` to `.understand-anything/config.json`.
+- If a graph already exists, `/understand` runs incrementally. Pass `--force` (via `$ARGUMENTS`) to rebuild from scratch.
+
+After it finishes, confirm these files exist:
+
+```bash
+test -f .understand-anything/knowledge-graph.json && echo "✅ knowledge-graph.json" || echo "❌ knowledge-graph.json missing"
+test -f .understand-anything/meta.json            && echo "✅ meta.json"            || echo "❌ meta.json missing"
+jq '.autoUpdate' .understand-anything/config.json 2>/dev/null | grep -q true && echo "✅ autoUpdate: true" || echo "❌ autoUpdate not set"
+```
+
+## Step 3 — Initialize the docs wiki
+
+```bash
+mkdir -p docs/wiki
+```
+
+Run wiki generation in the main thread:
+
+```
+/understand-knowledge docs/wiki
+```
+
+After it finishes, confirm `docs/wiki/` contains generated files:
+
+```bash
+ls docs/wiki/ | head -5 || echo "❌ docs/wiki is empty or missing"
+```
+
+## Step 4 — Ignore scratch outputs, git-lfs track, and stage
+
+Append scratch paths to .gitignore (idempotent):
+
+```bash
+for p in ".understand-anything/intermediate/" ".understand-anything/tmp/" ".understand-anything/diff-overlay.json"; do
+  grep -qxF "$p" .gitignore 2>/dev/null || echo "$p" >> .gitignore
+done
+```
+
+Track large graph files with git-lfs (harmless for small graphs):
+
+```bash
+git lfs install
+git lfs track ".understand-anything/*.json"
+```
+
+Stage all artefacts:
+
+```bash
+git add .gitattributes .gitignore .understand-anything/ docs/wiki/
+git status
+git lfs ls-files
+```
+
+## Done — report
+
+- Graph status: created vs incrementally updated; `autoUpdate` on/off.
+- Wiki status: `docs/wiki/` created vs already existed; generation successful vs failed.
+- Staged files; LFS-tracked files confirmed.
+- Remind: **review then commit yourself.**

package/plugins/tech-graph/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tech-graph",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"