xtrm-tools 0.7.0 → 0.7.1

package/project-skills/service-skills-set/.claude/skills/using-service-skills/scripts/skill_activator.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-PreToolUse hook: skill activator.
-
-Fires before Read, Write, Edit, Glob, Grep, or Bash operations.
-Checks whether the operation touches a registered service territory.
-If it does, injects additionalContext telling Claude to load the skill
-before proceeding — ensuring expert knowledge is always applied.
-
-Configured in .claude/settings.json PreToolUse hook.
-Must be fast: pure file I/O + string matching, no subprocess.
-"""
-
-import fnmatch
-import json
-import sys
-from pathlib import Path
-
-BOOTSTRAP_DIR = Path(__file__).parent.parent.parent / "creating-service-skills" / "scripts"
-sys.path.insert(0, str(BOOTSTRAP_DIR))
-
-from bootstrap import RootResolutionError, get_project_root, load_registry  # noqa: E402  # type: ignore[import-not-found]
-
-
-def match_territory(file_path: str, territory: list[str], project_root: Path) -> bool:
-    """Check if a file path matches any territory glob pattern."""
-    # Normalize to relative path
-    fp = Path(file_path)
-    if fp.is_absolute():
-        try:
-            fp = fp.relative_to(project_root)
-        except ValueError:
-            return False
-    rel = str(fp)
-
-    for pattern in territory:
-        # fnmatch handles * and ?, but not ** — handle ** manually
-        if "**" in pattern:
-            # Split on **/ and check prefix + suffix
-            parts = pattern.split("**/")
-            if len(parts) == 2:
-                prefix, suffix = parts
-                rel_check = rel[len(prefix) :] if rel.startswith(prefix) else rel
-                if fnmatch.fnmatch(rel_check, suffix) or fnmatch.fnmatch(
-                    rel, f"{prefix}*/{suffix}"
-                ):
-                    return True
-                # Also check if file is anywhere under the prefix dir
-                if prefix and rel.startswith(prefix.rstrip("/")):
-                    return True
-        else:
-            if fnmatch.fnmatch(rel, pattern):
-                return True
-        # Direct prefix match for broad patterns
-        base = pattern.split("/*")[0].split("/**")[0]
-        if base and (rel.startswith(base + "/") or rel == base):
-            return True
-
-    return False
-
-
-def find_service_for_file(
-    file_path: str, services: dict, project_root: Path
-) -> tuple[str, dict] | None:
-    """Return (service_id, service_data) if file is in any territory, else None."""
-    for service_id, data in services.items():
-        if match_territory(file_path, data.get("territory", []), project_root):
-            return service_id, data
-    return None
-
-
-def find_service_for_command(command: str, services: dict) -> tuple[str, dict] | None:
-    """Return (service_id, service_data) if command mentions a service name."""
-    cmd_lower = command.lower()
-    for service_id, data in services.items():
-        # Match service_id directly or as a container name in docker commands
-        if service_id in cmd_lower:
-            return service_id, data
-        # Match the container name pattern (service name with dashes/underscores)
-        if data.get("name") and data.get("name", "").lower().replace(" ", "-") in cmd_lower:
-            return service_id, data
-    return None
-
-
-def build_context(service_id: str, data: dict) -> str:
-    skill_path = data.get("skill_path", f".claude/skills/{service_id}/SKILL.md")
-    desc = data.get("description", "")
-    desc_line = f"\n  What it covers: {desc}" if desc else ""
-
-    return (
-        f"[Service Skill] You are about to work with the '{service_id}' service territory."
-        f"{desc_line}\n"
-        f"  Load the expert skill before proceeding: Read {skill_path}\n"
-        f"  The skill contains: operational knowledge, failure modes, diagnostic scripts, "
-        f"and the correct methods for managing this service.\n"
-        f"  Do not use ad-hoc approaches (raw SQL, improvised docker commands) "
-        f"when the skill defines the correct method."
-    )
-
-
-def main() -> None:
-    try:
-        data = json.load(sys.stdin)
-    except (json.JSONDecodeError, EOFError):
-        sys.exit(0)
-
-    tool_name = data.get("tool_name", "")
-    tool_input = data.get("tool_input", {})
-
-    try:
-        project_root = Path(get_project_root())
-        services = load_registry().get("services", {})
-    except (RootResolutionError, Exception):
-        sys.exit(0)
-
-    if not services:
-        sys.exit(0)
-
-    match = None
-
-    # File-based tools: check file_path against territory
-    if tool_name in ("Read", "Write", "Edit", "Glob", "Grep", "NotebookRead", "NotebookEdit"):
-        file_path = (
-            tool_input.get("file_path")
-            or tool_input.get("path")
-            or tool_input.get("notebook_path")
-            or ""
-        )
-        if file_path:
-            match = find_service_for_file(file_path, services, project_root)
-
-    # Bash: check command string for service names
-    elif tool_name == "Bash":
-        command = tool_input.get("command", "")
-        if command:
-            match = find_service_for_command(command, services)
-
-    if match:
-        service_id, service_data = match
-        output = {
-            "hookSpecificOutput": {
-                "hookEventName": "PreToolUse",
-                "additionalContext": build_context(service_id, service_data),
-            }
-        }
-        print(json.dumps(output))
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/project-skills/service-skills-set/README.md

@@ -1,93 +0,0 @@
-# Service Skills Set
-
-**Service Skills** give Claude persistent, project-specific operational knowledge about your Docker services. Instead of re-explaining your architecture every session, each service gets a dedicated skill package that Claude loads on demand.
-
-## What It Does
-
-### Three Workflow Skills (Trinity)
-
-| Skill | Role | Invocation |
-|-------|------|------------|
-| `creating-service-skills` | Builds new skill packages via 3-phase workflow | `/creating-service-skills` |
-| `using-service-skills` | Discovers and activates expert personas | Auto (SessionStart hook) |
-| `updating-service-skills` | Detects drift when code changes | Auto (PostToolUse hook) |
-
-### Five Hooks
-
-| Hook | Type | Trigger | Effect |
-|------|------|---------|--------|
-| `SessionStart` | Claude Code | Session opens | Injects service catalog (~150 tokens) |
-| `PreToolUse` | Claude Code | Read/Write/Edit/Grep/Glob/Bash | Checks service territory, activates skills |
-| `PostToolUse` | Claude Code | Write/Edit | Detects drift, notifies to sync docs |
-| `pre-commit` | Git | `git commit` | Warns if source changed without SSOT update |
-| `pre-push` | Git | `git push` | Warns if service skills are stale |
-
-## Installation
-
-```bash
-# From your project directory
-xtrm install project service-skills-set
-```
-
-**Post-install:** The Service Skills Set requires Python scripts to be executable. The installer will:
-1. Copy skills to `.claude/skills/`
-2. Wire `settings.json` hooks
-3. Activate git hooks (`pre-commit`, `pre-push`)
-
-## Creating a Service Skill
-
-After installation, invoke the skill in Claude Code:
-
-```bash
-/creating-service-skills
-```
-
-This runs a 3-phase workflow:
-
-### Phase 1: Automated Skeleton
-- Reads `docker-compose*.yml`, `Dockerfile`, dependency files
-- Produces `SKILL.md` with `[PENDING RESEARCH]` markers
-- Generates script stubs in `scripts/`
-- Creates entry in `.claude/skills/service-registry.json`
-
-### Phase 2: Agentic Deep Dive
-- Uses Serena LSP for codebase research (75-80% token savings)
-- Fills `[PENDING RESEARCH]` markers with actual knowledge
-- Sources troubleshooting tables from real failure modes
-
-### Phase 3: Hook Registration
-- Verifies `PreToolUse` hook in `settings.json`
-- Confirms service territory globs in registry
-- Skill now auto-activates on territory file access
-
-## Generated Skill Structure
-
-```
-.claude/skills/<service-name>/
-├── SKILL.md                  — architecture, failure modes, operations
-├── scripts/
-│   ├── health_probe.py       — container status check
-│   ├── log_hunter.py         — log pattern analysis
-│   ├── data_explorer.py      — read-only DB inspection
-│   └── <specialist>.py       — service-type inspector
-└── references/
-    ├── deep_dive.md          — Phase 2 research notes
-    └── architecture_ssot.md  — link to project SSOT
-```
-
-## Auto-Activation
-
-Skills activate automatically when Claude:
-- Operates on files matching territory globs (e.g., `src/auth/**/*.py`)
-- Runs Bash commands mentioning service/container name
-
-## Requirements
-
-- Python 3.8+
-- Git repository
-- Docker Compose project
-
-## Documentation
-
-- Full guide: `.claude/docs/service-skills-set-readme.md`
-- Original: `project-skills/service-skills-set/service-skills-readme.md`

package/project-skills/service-skills-set/install-service-skills.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-"""
-Install the Service Skill Trinity into the current project.
-
-Run from inside your target project directory:
-    python3 /path/to/jaggers-agent-tools/project-skills/install-service-skills.py
-
-Installs:
-  .claude/skills/creating-service-skills/   — scaffold new service skills
-  .claude/skills/using-service-skills/      — session-start catalog injection
-  .claude/skills/updating-service-skills/   — drift detection on file writes
-  .claude/skills/scoping-service-skills/    — task intake and service routing
-  .claude/settings.json                     — SessionStart + PostToolUse hooks
-  .githooks/pre-commit                      — doc-reminder (non-blocking)
-  .githooks/pre-push                        — skill-staleness (non-blocking)
-  .git/hooks/pre-commit + pre-push          — activated
-
-Idempotent. Safe to re-run.
-"""
-
-import json
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-SCRIPT_DIR = Path(__file__).parent.resolve()            # project-skills/service-skills-set/
-REPO_ROOT  = SCRIPT_DIR.parent.parent.resolve()         # jaggers-agent-tools/
-SKILLS_SRC = SCRIPT_DIR / ".claude"                     # service-skills-set/.claude/<skill>/
-GIT_HOOKS  = SKILLS_SRC / "git-hooks"                   # service-skills-set/.claude/git-hooks/
-
-GREEN  = "\033[0;32m"
-YELLOW = "\033[1;33m"
-NC     = "\033[0m"
-
-TRINITY = ["creating-service-skills", "using-service-skills", "updating-service-skills", "scoping-service-skills"]
-
-SETTINGS_HOOKS = {
-    "SessionStart": [
-        {"hooks": [{"type": "command",
-            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/cataloger.py\""}]}
-    ],
-    "PreToolUse": [
-        {"matcher": "Read|Write|Edit|Glob|Grep|Bash|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-         "hooks": [{"type": "command",
-             "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/skill_activator.py\""}]}
-    ],
-    "PostToolUse": [
-        {"matcher": "Write|Edit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-         "hooks": [{"type": "command",
-             "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/updating-service-skills/scripts/drift_detector.py\" check-hook",
-             "timeout": 10}]}
-    ]
-}
-
-MARKER_DOC       = "# [jaggers] doc-reminder"
-MARKER_STALENESS = "# [jaggers] skill-staleness"
-MARKER_CHAIN     = "# [jaggers] chain-githooks"
-
-
-def get_project_root() -> Path:
-    try:
-        r = subprocess.run(["git", "rev-parse", "--show-toplevel"],
-                           capture_output=True, text=True, check=True, timeout=5)
-        root = Path(r.stdout.strip())
-        if root == REPO_ROOT:
-            print("Error: run this from inside your TARGET project, not jaggers-agent-tools itself.")
-            sys.exit(1)
-        return root
-    except subprocess.CalledProcessError:
-        print("Error: not inside a git repository.")
-        sys.exit(1)
-
-
-def install_skills(project_root: Path) -> None:
-    print("\n── Skills ──────────────────────────────")
-    for skill in TRINITY:
-        src  = SKILLS_SRC / skill
-        dest = project_root / ".claude" / "skills" / skill
-        if dest.exists():
-            shutil.rmtree(dest)
-        shutil.copytree(src, dest, ignore=shutil.ignore_patterns("*.Zone.Identifier"))
-        print(f"{GREEN}  ✓{NC} .claude/skills/{skill}/")
-
-
-def install_settings(project_root: Path) -> None:
-    print("\n── settings.json ───────────────────────")
-    path = project_root / ".claude" / "settings.json"
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    existing = {}
-    if path.exists():
-        try:
-            existing = json.loads(path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError:
-            pass
-
-    hooks = existing.setdefault("hooks", {})
-    for event, config in SETTINGS_HOOKS.items():
-        if event not in hooks:
-            hooks[event] = config
-            print(f"{GREEN}  ✓{NC} added hook: {event}")
-        else:
-            print(f"{YELLOW}  ○{NC} hook already present: {event} (not overwritten)")
-
-    path.write_text(json.dumps(existing, indent=2) + "\n", encoding="utf-8")
-
-
-def install_git_hooks(project_root: Path) -> None:
-    print("\n── Git hooks ───────────────────────────")
-    doc_script      = GIT_HOOKS / "doc_reminder.py"
-    staleness_script = GIT_HOOKS / "skill_staleness.py"
-
-    pre_commit = project_root / ".githooks" / "pre-commit"
-    pre_push   = project_root / ".githooks" / "pre-push"
-
-    for hp in (pre_commit, pre_push):
-        if not hp.exists():
-            hp.parent.mkdir(parents=True, exist_ok=True)
-            hp.write_text("#!/usr/bin/env bash\n", encoding="utf-8")
-            hp.chmod(0o755)
-
-    snippets = [
-        (pre_commit, MARKER_DOC,
-         f"\n{MARKER_DOC}\nif command -v python3 &>/dev/null && [ -f \"{doc_script}\" ]; then\n    python3 \"{doc_script}\" || true\nfi\n"),
-        (pre_push, MARKER_STALENESS,
-         f"\n{MARKER_STALENESS}\nif command -v python3 &>/dev/null && [ -f \"{staleness_script}\" ]; then\n    python3 \"{staleness_script}\" || true\nfi\n"),
-    ]
-
-    for hook_path, marker, snippet in snippets:
-        content = hook_path.read_text(encoding="utf-8")
-        if marker not in content:
-            hook_path.write_text(content + snippet, encoding="utf-8")
-            print(f"{GREEN}  ✓{NC} {hook_path.relative_to(project_root)}")
-        else:
-            print(f"{YELLOW}  ○{NC} already installed: {hook_path.name}")
-
-    hooks_path = ""
-    try:
-        r = subprocess.run(
-            ["git", "config", "--get", "core.hooksPath"],
-            cwd=project_root,
-            capture_output=True,
-            text=True,
-            timeout=5,
-            check=False,
-        )
-        if r.returncode == 0:
-            hooks_path = r.stdout.strip()
-    except Exception:
-        hooks_path = ""
-
-    active_hooks_dir = (Path(hooks_path) if Path(hooks_path).is_absolute() else project_root / hooks_path) if hooks_path else (project_root / ".git" / "hooks")
-    activation_targets = {project_root / ".git" / "hooks", active_hooks_dir}
-
-    for hooks_dir in activation_targets:
-        hooks_dir.mkdir(parents=True, exist_ok=True)
-        for name, source_hook in (("pre-commit", pre_commit), ("pre-push", pre_push)):
-            target_hook = hooks_dir / name
-            if not target_hook.exists():
-                target_hook.write_text("#!/usr/bin/env bash\n", encoding="utf-8")
-            target_hook.chmod(0o755)
-
-            if target_hook.resolve() == source_hook.resolve():
-                continue
-
-            chain_snippet = (
-                f"\n{MARKER_CHAIN}\n"
-                f"if [ -x \"{source_hook}\" ]; then\n"
-                f"    \"{source_hook}\" \"$@\"\n"
-                "fi\n"
-            )
-            target_content = target_hook.read_text(encoding="utf-8")
-            if MARKER_CHAIN not in target_content:
-                target_hook.write_text(target_content + chain_snippet, encoding="utf-8")
-
-    print(f"{GREEN}  ✓{NC} activated in .git/hooks/")
-
-
-def main() -> None:
-    project_root = get_project_root()
-    print(f"Installing into: {project_root}")
-
-    install_skills(project_root)
-    install_settings(project_root)
-    install_git_hooks(project_root)
-
-    print(f"\n{GREEN}Done.{NC}")
-    print(f"  Hooks active: SessionStart (catalog) · PreToolUse (skill activator) · PostToolUse (drift) · pre-commit · pre-push")
-
-
-if __name__ == "__main__":
-    main()

package/project-skills/service-skills-set/service-skills-readme.md

@@ -1,236 +0,0 @@
-# Service Skills
-
-A system that gives Claude persistent, project-specific operational knowledge about your Docker services. Instead of re-explaining your architecture every session, each service has a dedicated skill package that Claude loads on demand.
-
----
-
-## What It Does
-
-**Three workflow skills** form the trinity:
-
-| Skill | Role | When it runs |
-|---|---|---|
-| `creating-service-skills` | Builds new skill packages via 3-phase workflow (scaffold + Serena deep dive + hook registration) | Manually via `/creating-service-skills` |
-| `using-service-skills` | Discovers and activates expert personas | Automatically at session start |
-| `updating-service-skills` | Detects drift when code changes | Automatically on every file write |
-
-**Five hooks** keep everything wired together:
-
-| Hook | Type | Trigger | Effect |
-|---|---|---|---|
-| `SessionStart` | Claude Code | Session opens | Injects lightweight service catalog into context (~150 tokens) |
-| `PreToolUse` | Claude Code | Any Read/Write/Edit/Grep/Glob/Bash | Checks if the operation touches a service territory; injects skill load reminder and enforcement |
-| `PostToolUse` | Claude Code | Any Write/Edit | Checks if modified file belongs to a registered service; notifies Claude to sync docs |
-| `pre-commit` | Git | `git commit` | Warns if source files changed without SSOT documentation update (non-blocking) |
-| `pre-push` | Git | `git push` | Warns if service skills are older than the source files being pushed (non-blocking) |
-
-**Each generated skill package** for a service contains:
-
-```
-.claude/skills/<service-name>/
-├── SKILL.md                  — architecture, data flows, failure modes, common operations
-├── scripts/
-│   ├── health_probe.py       — container status + table freshness check
-│   ├── log_hunter.py         — service-specific log pattern analysis
-│   ├── data_explorer.py      — read-only DB inspection
-│   └── <specialist>.py       — service-type-specific inspector
-└── references/
-    ├── deep_dive.md          — Phase 2 research notes
-    └── architecture_ssot.md  — link to project SSOT if available
-```
-
----
-
-## Installation
-
-Run once, from inside your target project directory:
-
-```bash
-cd ~/projects/my-project
-python3 /path/to/jaggers-agent-tools/project-skills/service-skills-set/install-service-skills.py
-```
-
-This installs the three workflow skills, wires `settings.json` hooks, and activates git hooks. Idempotent — safe to re-run after updates.
-
----
-
-## Creating a Service Skill
-
-```bash
-# In Claude Code, invoke the skill:
-/creating-service-skills
-```
-
-The skill runs a **mandatory three-phase workflow**:
-
-### Phase 1 — Automated Skeleton
-
-```bash
-python3 "$CLAUDE_PROJECT_DIR/.claude/skills/creating-service-skills/scripts/scaffolder.py" \
-  create <service-id> <territory-path> "<description>"
-```
-
-Reads `docker-compose*.yml`, `Dockerfile`, and dependency files. Produces:
-- `SKILL.md` with `[PENDING RESEARCH]` markers
-- Script stubs in `scripts/`
-- Official documentation links auto-detected from image tags and package files
-- Entry in `.claude/skills/service-registry.json`
-
-### Phase 2 — Agentic Deep Dive
-
-Claude reads the actual source code to fill every `[PENDING RESEARCH]` marker.
-Uses Serena LSP tools (not raw file reads) for efficiency:
-
-```
-get_symbols_overview   → map module structure
-find_symbol            → read specific functions
-search_for_pattern     → find log strings, SQL queries, env vars
-find_referencing_symbols → trace data flows
-```
-
-### Phase 3 — Hook Registration
-
-After the deep dive is complete, Claude verifies the auto-activation infrastructure:
-
-1. Confirms the `PreToolUse` hook is present in `.claude/settings.json` (pointing to `skill_activator.py`)
-2. Verifies the service entry in `.claude/skills/service-registry.json` has territory globs set
-3. Informs you that the skill will now auto-activate whenever Claude:
-   - Operates on a file matching the service's territory globs
-   - Runs a Bash command that mentions the service name or container name
-
-No manual registration step is needed — the installer wires the hooks at project setup time. Phase 3 is a verification and communication step only.
-
-A skill is **complete** only when:
-- No `[PENDING RESEARCH]` markers remain
-- `health_probe.py` queries real tables with correct stale thresholds
-- `log_hunter.py` patterns sourced from actual codebase error strings
-- Troubleshooting table has ≥5 rows from real failure modes
-- All scripts support `--json` output
-- `PreToolUse` skill activator hook confirmed in `.claude/settings.json`
-- Service territory globs verified in `.claude/skills/service-registry.json`
-- You have been informed: skill auto-activates on territory file access and service-name commands
-
----
-
-## Using a Service Skill
-
-At session start, Claude receives:
-
-```xml
-<project_service_catalog>
-Available expert personas:
-- db-expert: SQL & schema optimization (Path: .claude/skills/db-expert/SKILL.md)
-- auth-service: JWT authentication expert (Path: .claude/skills/auth-service/SKILL.md)
-</project_service_catalog>
-```
-
-Claude automatically loads the relevant skill when you ask about a covered service. You can also invoke explicitly:
-
-```
-Read .claude/skills/<service-name>/SKILL.md
-```
-
-### Auto-activation
-
-Once a service skill is registered, you don't need to load it manually.
-The `PreToolUse` hook (`skill_activator.py`) fires automatically whenever
-Claude operates on a file in the service's territory or runs a Bash command
-mentioning the service name. It injects:
-
-```
-[Service Skill] You are about to work with the 'auth-service' service territory.
-  Load the expert skill before proceeding: Read .claude/skills/auth-service/SKILL.md
-  Do not use ad-hoc approaches (raw SQL, improvised docker commands) when the
-  skill defines the correct method.
-```
-
-This enforces that Claude uses the skill's defined diagnostic scripts and
-operational procedures rather than improvising — e.g. running `health_probe.py`
-instead of issuing direct `psql` queries, or checking `log_hunter.py` patterns
-before reading raw docker logs.
-
-### Run scripts directly
-
-```bash
-python3 .claude/skills/<service-name>/scripts/health_probe.py
-python3 .claude/skills/<service-name>/scripts/log_hunter.py --errors-only
-python3 .claude/skills/<service-name>/scripts/data_explorer.py --limit 20 --json
-```
-
----
-
-## Updating a Service Skill
-
-When you modify service source code, the `PostToolUse` hook fires automatically and Claude sees:
-
-```
-[Skill Sync]: Implementation drift detected in 'auth-service'.
-File 'src/auth/jwt.py' was modified.
-Use '/updating-service-skills' to sync the Auth Service documentation.
-```
-
-To sync:
-
-```bash
-/updating-service-skills
-```
-
-To mark a service as synced after manual update:
-
-```bash
-python3 .claude/skills/updating-service-skills/scripts/drift_detector.py sync <service-id>
-```
-
-To scan all services for drift:
-
-```bash
-python3 .claude/skills/updating-service-skills/scripts/drift_detector.py scan
-```
-
----
-
-## Registry
-
-`.claude/skills/service-registry.json` is the source of truth for registered services:
-
-```json
-{
-  "services": {
-    "auth-service": {
-      "name": "Auth Service",
-      "territory": ["src/auth/**/*.py"],
-      "skill_path": ".claude/skills/auth-service/SKILL.md",
-      "description": "JWT authentication and session management",
-      "last_sync": "2026-02-23T19:00:00Z"
-    }
-  }
-}
-```
-
-The `territory` globs determine which file paths trigger drift detection and skill auto-activation.
-
----
-
-## Project Structure
-
-```
-project-skills/service-skills-set/      — this repository's source
-├── install-service-skills.py           — installer (run from inside target project)
-└── .claude/
-    ├── settings.json                   — settings template with all 3 hook events
-    ├── git-hooks/
-    │   ├── doc_reminder.py             — pre-commit: SSOT reminder
-    │   └── skill_staleness.py          — pre-push: stale skill warning
-    ├── creating-service-skills/        — workflow skill: build new service skills
-    ├── using-service-skills/           — workflow skill: catalog injection + skill activation
-    └── updating-service-skills/        — workflow skill: drift detection
-
-.claude/                                — installed into your project
-├── settings.json                       — SessionStart + PreToolUse + PostToolUse hooks
-└── skills/
-    ├── service-registry.json
-    ├── creating-service-skills/
-    ├── using-service-skills/
-    ├── updating-service-skills/
-    └── <generated-service-skills>/
-```