azclaude-copilot 0.1.0

package/templates/commands/evolve.md

@@ -0,0 +1,170 @@
+---
+name: evolve
+description: >
+  Scan environment for gaps, generate improvements, consolidate knowledge.
+  /evolve quick — detect only (~500 tokens, no fixes). Use after small sessions.
+  /evolve — full cycle with fixes. Run after significant work or end of week.
+disable-model-invocation: true
+context: fork
+---
+
+# /evolve — Environment Evolution
+
+$ARGUMENTS
+
+## Step 0: Scope Gate
+
+If $ARGUMENTS == "quick":
+- Run DETECT only (read detect.md, output PLAN)
+- Skip GENERATE, EVALUATE, Cycle 2, Cycle 3
+- Skip EnterWorktree
+- Output: gap list with file:line references — no fixes applied
+- Cost: ~500 tokens. Use after small sessions or quick checks.
+- Print: `PLAN (quick mode — gaps listed, not fixed):`
+
+If $ARGUMENTS is blank or "full": run all cycles below.
+
+---
+
+## Step 0b: Check for Loop Controller (Level 10)
+
+```bash
+ls .claude/agents/loop-controller.md 2>/dev/null
+```
+
+**If loop-controller.md exists**: delegate ALL evolution work to it via Agent tool:
+```
+Run a full evolution cycle: re-derivation check, then Cycle 1 (detect/generate/evaluate),
+Cycle 2 (knowledge consolidation if 3+ sessions), Cycle 3 (topology if friction detected).
+Show the full cycle report when done.
+```
+**STOP HERE** — do not run the steps below.
+
+---
+
+**If loop-controller.md does not exist** (Levels 3–9): run manually below.
+
+---
+
+## Step 1: Isolate (Worktree)
+
+Use **EnterWorktree** — create branch `azclaude/evolve-{date}`.
+All cycle work happens here. Environment changes do not touch main until evaluated.
+
+---
+
+## Cycle 0.5: Structural Analysis (before detection)
+
+Run both analysis scripts for structural insight:
+```bash
+bash .claude/scripts/import-graph.sh
+bash .claude/scripts/validate-boundaries.sh
+```
+
+**import-graph.sh** outputs: most-imported files, circular dependency warnings, co-change clusters.
+**validate-boundaries.sh** outputs: manifest completeness, description overlap between extensions, orphaned agents, Claude Code collision check.
+
+Feed these signals into Cycle 1 detection:
+- Circular deps → architectural gaps
+- Co-change clusters → agent candidates
+- Description overlap → merge or split extensions
+- Orphaned agents → remove or wire into commands
+
+---
+
+## Cycle 1: Detect → Generate → Evaluate
+
+**Step 1**: Read `capabilities/evolution/detect.md` and run DETECT.
+Include import-graph output as input. Circular deps = high-priority gaps.
+Outputs: PLAN (list of gaps, rot types, sequence candidates)
+
+**Step 2**: If PLAN has items → read `capabilities/evolution/generate.md` and run GENERATE.
+Outputs: new or updated capability files
+
+**Step 3**: Read `capabilities/evolution/evaluate.md` and run EVALUATE.
+Outputs: quality-gated files, tagged as GENERAL or NARROW
+
+If PLAN is empty: skip to Cycle 2.
+
+---
+
+## Cycle 2: Knowledge Consolidation (if sessions ≥ 3 since last consolidation)
+
+Read `capabilities/evolution/cycle2-knowledge.md` and run.
+Outputs: consolidated patterns, pruned stale memory, enriched knowledge-index
+
+---
+
+## Cycle 3: Topology (if /level-up or topology friction detected)
+
+Read `capabilities/evolution/cycle3-topology.md` and run.
+Outputs: optimized pipeline map, pruned obsolete agents, updated manifest token estimates
+
+After topology optimization, run semantic boundary check:
+1. If `validate-boundaries.sh` reported warnings → load `capabilities/shared/semantic-boundary-check.md`
+2. Classify all flagged pairs as REDUNDANT / OVERLAPPING / COMPLEMENTARY / CLEAN
+3. Apply fixes: merge redundant, extract shared, clarify complementary
+4. Record decisions in `.claude/memory/decisions.md`
+
+---
+
+## Re-Derivation Check (run before any cycle if friction is high)
+
+```bash
+ls ops/observations/ | wc -l
+```
+If ≥ 10 friction logs AND grep shows same pattern in ≥ 5:
+Read `capabilities/evolution/re-derivation.md` and run BEFORE any generate.
+
+---
+
+## Completion: Merge or Discard
+
+After Evaluate passes all quality gates:
+- **ExitWorktree** and merge to main
+- If evaluate failed: ExitWorktree (discard) — no partial improvements on main
+
+Then offer scheduling:
+```
+Schedule /evolve to run automatically?
+Use CronCreate — weekly (Sunday 9am) recommended.
+```
+Use **CronList** to check if a schedule already exists before creating a new one.
+
+---
+
+## Step 6: Log Evolution History
+
+Append to `ops/evolution-log.md` (create if missing):
+```
+| {date} | {before score}/100 | {after score}/100 | {+delta} | {1-line summary of what changed} |
+```
+
+If the file doesn't exist, create it with this header:
+```
+# Evolution History
+
+| Date | Before | After | Delta | Summary |
+|------|--------|-------|-------|---------|
+```
+
+---
+
+## Step 7: Promote GENERAL Skills
+
+For any fix tagged GENERAL in EVALUATE:
+1. Copy to `~/shared-skills/{name}.md`
+2. Add `discovered_in: {project}` to frontmatter
+3. Update `~/shared-skills/.checksums` with sha256 hash
+4. Print: `Promoted to ~/shared-skills/{name}.md`
+
+Skip this step if all fixes were tagged NARROW.
+
+---
+
+## Completion Rule
+Print the PLAN that was detected.
+Print the list of files created or updated.
+Print the updated goals.md.
+Print the evolution-log.md entry.
+Show the files — do not say "evolution complete" without showing output.

package/templates/commands/explain.md

@@ -0,0 +1,25 @@
+---
+name: explain
+description: Explain code, errors, or concepts in plain language — no jargon, 2-3 paragraphs max.
+argument-hint: "[code snippet, error message, file name, or concept]"
+allowed-tools: Read, Grep
+---
+
+# /explain — Plain Language Explanation
+
+Explain this to me like I'm not a developer:
+
+$ARGUMENTS
+
+---
+
+Rules:
+- Simple, everyday language — no jargon
+- If code was pasted: explain what it does step by step
+- If an error was pasted: explain what went wrong and how to fix it
+- If a file or folder was named: read it and explain what it's for
+- If a concept was asked: explain it with a real-world analogy
+- Keep it short — 2-3 paragraphs max unless more detail is asked for
+
+If nothing was provided above, ask:
+"What would you like me to explain? You can paste code, an error message, a file name, or ask about any concept."

package/templates/commands/find.md

@@ -0,0 +1,100 @@
+---
+name: find
+description: >
+  Search for reusable skills across ~/shared-skills/ and project commands.
+  Triggers on: "find skill", "is there a skill for", "search commands",
+  "what skills exist", "find a command for", "do we have a skill that".
+argument-hint: "[what you're looking for — e.g. 'testing', 'deploy', 'review']"
+disable-model-invocation: true
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# /find — Skill Discovery
+
+$ARGUMENTS
+
+---
+
+## Step 1: Search Local Skills
+
+Search project commands first — they're tailored to this project:
+
+```bash
+# List all project commands with descriptions
+for f in .claude/commands/*.md; do
+  name=$(basename "$f" .md)
+  desc=$(grep -A1 "^description:" "$f" | tail -1 | sed 's/^ *//')
+  echo "  /$name — $desc"
+done
+```
+
+If $ARGUMENTS provided, filter by keyword:
+```bash
+grep -li "$ARGUMENTS" .claude/commands/*.md 2>/dev/null
+```
+
+---
+
+## Step 2: Search Shared Skills
+
+Search `~/shared-skills/` — portable skills that work across projects:
+
+```bash
+ls ~/shared-skills/*.md 2>/dev/null | while read f; do
+  name=$(basename "$f" .md)
+  desc=$(grep -A1 "^description:" "$f" | tail -1 | sed 's/^ *//')
+  echo "  $name — $desc"
+done
+```
+
+If $ARGUMENTS provided:
+```bash
+grep -li "$ARGUMENTS" ~/shared-skills/*.md 2>/dev/null
+```
+
+---
+
+## Step 3: Search Capabilities
+
+Some functionality lives in capabilities, not commands:
+
+```bash
+grep -i "$ARGUMENTS" .claude/capabilities/manifest.md 2>/dev/null
+```
+
+---
+
+## Step 4: Present Results
+
+Format results as a table:
+
+```
+## Skills matching "{query}"
+
+### Project Commands (this project)
+| Command | Description | File |
+|---------|-------------|------|
+
+### Shared Skills (all projects)
+| Skill | Description | File |
+|-------|-------------|------|
+
+### Capabilities
+| Capability | When to load | Tokens |
+|------------|-------------|--------|
+```
+
+If no results found:
+```
+No skills found matching "{query}".
+
+Options:
+1. Run /create {query} — build a new command for this
+2. Check ~/shared-skills/ — portable skills from other projects
+3. Ask: "I need a skill that does X" — and I'll help you build one
+```
+
+---
+
+## Completion Rule
+Show the results table. Do not say "search complete" without showing matches.

package/templates/commands/fix.md

@@ -0,0 +1,122 @@
+---
+name: fix
+description: Reproduce → investigate root cause → hypothesize → fix and verify. Never guesses. Never says "should work".
+argument-hint: "[error message, failing test, or bug description]"
+disable-model-invocation: true
+allowed-tools: Read, Grep, Bash, Edit, Write
+---
+
+# /fix — 4-Phase Debugging Protocol
+
+$ARGUMENTS
+
+Load: shared/tdd.md + shared/completion-rule.md before starting.
+
+---
+
+## Phase 1: REPRODUCE
+
+**First: check IDE diagnostics (instant, no build needed)**
+Use `mcp__ide__getDiagnostics` — if available and returns errors, treat those as the reproduction.
+Map each diagnostic to `file:line:message` and carry it directly into Phase 2.
+
+**If IDE diagnostics unavailable or empty**: run the failing test or command exactly as described.
+- Paste the actual output — never summarize it
+- If you cannot reproduce it: stop. Use **AskUserQuestion** to ask for exact steps. Do not guess.
+
+No investigation before reproduction. No fix before root cause.
+
+---
+
+## Phase 2: INVESTIGATE
+
+Read the code. Do not guess.
+- Locate the failure point: `file:line`
+- Read the actual code at that location
+- Read what calls it and what it calls
+- Check recent changes: `git log --oneline -10 -- {file}`
+- Read test framework config: `package.json` / `requirements.txt` / `Cargo.toml`
+
+Antipattern check — if `antipatterns.md` exists, read it before proceeding.
+
+Rules:
+- No fix hypothesis before root cause is confirmed in code
+- No "I think the problem is" without reading the actual file
+- No changes to files not involved in the failure
+
+---
+
+## Phase 3: HYPOTHESIZE
+
+One root cause. Not a list.
+
+Fill this checkpoint before writing any code:
+```
+Root cause: [file:line]
+Mechanism:  [why it breaks — the cause, not the symptom]
+Fix:        [what you will change — described before touching any file]
+Confidence: [high / medium / low]
+```
+
+**If confidence = low → do not proceed to Phase 4.**
+Go back to Phase 2. Read more code. You do not understand the problem yet.
+
+**If confidence = medium**: Use **EnterWorktree** before making any changes.
+The fix is uncertain — isolate it. Merge to main only if tests pass.
+If tests fail: ExitWorktree (discard), go back to Phase 2.
+
+If you have multiple hypotheses: pick the most likely one. Test it first.
+Do not write multiple fixes speculatively.
+
+---
+
+## Phase 4: FIX
+
+1. Write the minimal change that addresses the root cause
+2. Run the test with an exit-code gate:
+```bash
+{test command}; EXIT=$?
+echo "Exit: $EXIT"
+if [ $EXIT -ne 0 ]; then echo "FAILED — do not proceed"; fi
+```
+3. If EXIT ≠ 0: do NOT say "should work" — go to Self-Correction Loop
+4. If EXIT = 0: run the full test suite — paste the output
+5. Reference every change as `file:line — what changed and why`
+
+---
+
+## Self-Correction Loop
+
+**Attempt 2 — gate before asking the user:**
+
+Re-read the error. Classify it:
+- **Different error** → new failure point → go back to Phase 2 with the new `file:line`
+- **Same error** → wrong root cause → re-read the code at the failure point, find what you missed
+
+If the error references a third-party library and no local docs exist:
+**WebSearch** `"{library} {error message}"` — use the result to inform Attempt 2. One search, not a loop.
+
+Make one targeted change. Run the exit-code gate again. Paste the output.
+
+**After 2 failed attempts — structured escalation:**
+
+Do not guess a third time. Report exactly:
+```
+Attempt 1: [file:line — what was changed]
+Result 1:  [exact error output — not a summary]
+
+Attempt 2: [file:line — what was changed]
+Result 2:  [exact error output — not a summary]
+
+Stuck at:  [file:line]
+Need:      [specific information or decision that would unblock this]
+```
+
+The user is the last resort, not the first.
+
+---
+
+**Completion Rule — NON-NEGOTIABLE:**
+Never say "this should be fixed", "probably works now", "I think this resolves it."
+Show the passing test output. If tests aren't passing: stay in progress.
+"Show the output or stay in progress."

package/templates/commands/hookify.md

@@ -0,0 +1,100 @@
+---
+name: hookify
+description: >
+  Generate hooks from conversation friction. Analyzes recent session patterns
+  to create PreToolUse or PostToolUse hooks that prevent unwanted behaviors.
+  Triggers on: "hookify", "create a hook", "make a hook", "prevent this",
+  "stop doing that", "block this pattern", "warn when", "never do X again".
+argument-hint: "[behavior to prevent — or blank to scan conversation]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /hookify — Generate Hooks From Friction
+
+$ARGUMENTS
+
+---
+
+## Step 1: Identify the Pattern
+
+**If $ARGUMENTS is provided:** Use the explicit description as the pattern.
+
+**If $ARGUMENTS is blank:** Scan recent conversation for friction signals:
+- User corrections: "no, not that", "don't do X", "I said Y not Z"
+- Repeated undos: same edit reverted 2+ times
+- Explicit frustration: "stop", "again?", "why does it keep"
+
+Present detected patterns and ask which to hookify.
+
+---
+
+## Step 2: Classify the Hook Type
+
+| Pattern Type | Hook Event | Action |
+|---|---|---|
+| Dangerous command (rm -rf, force push) | PreToolUse, matcher: Bash | Block or warn |
+| Unsafe code pattern (eval, exec, pickle) | PreToolUse, matcher: Edit\|Write | Warn |
+| File protection (.env, credentials) | PreToolUse, matcher: Write\|Edit | Block |
+| Missing step (forgot tests, forgot lint) | PostToolUse, matcher: Write\|Edit | Remind |
+| Session behavior (too verbose, skipping) | UserPromptSubmit | Inject reminder |
+
+---
+
+## Step 3: Generate the Hook
+
+Create the hook script in `.claude/hooks/`:
+
+```bash
+#!/usr/bin/env bash
+# .claude/hooks/{action}-{pattern-name}.sh
+# Purpose: {what this prevents}
+# Generated by /hookify on {date}
+set -euo pipefail
+
+# Read tool input from stdin
+INPUT=$(cat)
+
+# Check for the pattern
+if echo "$INPUT" | grep -qE '{PATTERN_REGEX}'; then
+  echo "⚠ {WARNING_MESSAGE}"
+  # For blocking hooks, exit with non-zero:
+  # exit 1
+fi
+```
+
+---
+
+## Step 4: Register the Hook
+
+Add to `.claude/settings.json` or project hooks config:
+
+```json
+{
+  "hooks": {
+    "{EVENT_TYPE}": [{
+      "matcher": "{TOOL_MATCHER}",
+      "hooks": [{"type": "command", "command": "bash .claude/hooks/{script-name}.sh"}]
+    }]
+  }
+}
+```
+
+---
+
+## Step 5: Verify
+
+Show the user:
+1. What pattern was detected
+2. What hook was generated
+3. How to test it: "Try the action that was causing the problem"
+4. How to disable it: "Delete the hook file or remove from settings"
+
+---
+
+## Rules
+- Warn by default, block only for dangerous operations (rm -rf, secrets, force push)
+- One hook per behavior — never combine unrelated patterns
+- Always show the hook script to the user before activating
+- Include a comment header with purpose and generation date
+- If the pattern requires reasoning (not just matching), suggest a skill instead

package/templates/commands/level-up.md

@@ -0,0 +1,48 @@
+---
+name: level-up
+description: Scan current environment level (0–10), show what exists and what's missing, then build the next level.
+disable-model-invocation: true
+---
+
+# /level-up — Scan and Build Next Level
+
+Scan the current environment, then build what's missing.
+
+---
+
+## Step 1: Detect Current Level
+
+Check what exists:
+```bash
+[ -f CLAUDE.md ] && echo "L1: CLAUDE.md ✓" || echo "L1: CLAUDE.md ✗"
+[ -f .mcp.json ] && echo "L2: MCP ✓" || echo "L2: MCP ✗"
+[ -d .claude/commands ] && ls .claude/commands/*.md 2>/dev/null | wc -l | xargs -I{} echo "L3: {} skill(s) ✓" || echo "L3: Skills ✗"
+[ -f .claude/memory/goals.md ] && echo "L4: Memory ✓" || echo "L4: Memory ✗"
+[ -d .claude/agents ] && ls .claude/agents/*.md 2>/dev/null | wc -l | xargs -I{} echo "L5: {} agent(s) ✓" || echo "L5: Agents ✗"
+[ -f ~/.claude/settings.json ] && grep -q "_azclaude" ~/.claude/settings.json && echo "L6: Hooks ✓" || echo "L6: Hooks ✗"
+[ -f .mcp.json ] && grep -q "external\|browser\|database" .mcp.json 2>/dev/null && echo "L7: External MCP ✓" || echo "L7: External MCP ✗"
+```
+
+Show result as a visual checklist. State current level clearly:
+"You are at Level N. Next: Level N+1."
+
+---
+
+## Step 2: Build Next Level
+
+**TaskCreate**: `Build Level {N+1} — {level name}` with status `in_progress`.
+
+Read `.claude/capabilities/manifest.md`, find the matching `level-builders/level{N+1}.md`, load it, and build that level.
+
+Load ONE level builder at a time — not all of them.
+
+**TaskUpdate → completed** when the level builder finishes.
+
+If already at Level 7: run `/evolve` instead. The environment is built — now improve what's inside it.
+
+---
+
+## Completion Rule
+Show what was created.
+Show the updated level checklist.
+Do not say "level complete" without showing the new files.

package/templates/commands/loop.md

@@ -0,0 +1,62 @@
+---
+name: loop
+description: Run a command or prompt on a recurring schedule using native Claude Code cron.
+argument-hint: "[interval: 5m/10m/30m/1h/daily/weekly] [command or prompt]"
+disable-model-invocation: true
+allowed-tools: Bash
+---
+
+# /loop — Recurring Task
+
+$ARGUMENTS
+
+---
+
+## Step 1: Parse Arguments
+
+Extract from $ARGUMENTS:
+- **Interval**: `5m`, `10m`, `30m`, `1h`, `daily`, `weekly` — default `10m` if not specified
+- **Command**: everything after the interval token (e.g. `/pulse`, `/fix`, a prompt)
+
+If blank, use **AskUserQuestion**:
+- What should run? (e.g. `/pulse`, `/fix`, `check if the deploy succeeded`)
+- How often? (5m / 10m / 30m / 1h / daily / weekly)
+
+---
+
+## Step 2: Map Interval to Cron Expression
+
+| Argument | Cron expression |
+|----------|----------------|
+| `5m`     | `*/5 * * * *`  |
+| `10m`    | `*/10 * * * *` |
+| `30m`    | `*/30 * * * *` |
+| `1h`     | `0 * * * *`    |
+| `daily`  | `0 9 * * *`    |
+| `weekly` | `0 9 * * 1`    |
+
+---
+
+## Step 3: Create the Cron Job
+
+Use **CronCreate** with:
+- The mapped cron expression
+- The command or prompt from Step 1
+
+Run the command once immediately so the user sees it working.
+
+Then confirm:
+```
+Scheduled: {command} every {interval}
+Use CronList to view active schedules.
+Use CronDelete to cancel.
+```
+
+---
+
+## Stopping
+
+If $ARGUMENTS contains `stop` or `cancel`:
+1. **CronList** — show active schedules
+2. **CronDelete** the matching entry
+3. Confirm: "Cancelled: {command}"