azclaude-copilot 0.1.0

package/templates/commands/migrate.md

@@ -0,0 +1,119 @@
+---
+name: migrate
+description: >
+  Upgrade dependencies, frameworks, or language versions safely.
+  Reads changelogs, finds breaking changes, applies fixes, runs tests.
+  Triggers on: "upgrade", "migrate", "update dependency", "bump version",
+  "move to React 19", "upgrade Node", "update packages", "breaking changes".
+argument-hint: "[what to upgrade — package name, framework, or 'all']"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /migrate — Safe Dependency & Framework Migration
+
+$ARGUMENTS
+
+Load: shared/completion-rule.md
+
+---
+
+## Phase 1: Assess Current State
+
+If $ARGUMENTS is blank, use **AskUserQuestion**:
+- What needs upgrading? (specific package, framework, or language version)
+- What target version?
+
+1. Read current versions:
+```bash
+# Node.js / npm
+cat package.json | head -30
+npm outdated 2>&1 | head -20
+
+# Python
+cat requirements.txt 2>/dev/null || cat pyproject.toml 2>/dev/null | head -30
+pip list --outdated 2>&1 | head -20
+```
+
+2. Run tests BEFORE migration:
+```bash
+{test command}; EXIT=$?
+echo "BEFORE migration — Exit: $EXIT"
+```
+
+**If tests fail before migration: STOP.** Fix first with `/fix`.
+
+---
+
+## Phase 2: Research Breaking Changes
+
+For each package being upgraded:
+```bash
+# Check changelog / release notes
+npm view {package} versions --json 2>/dev/null | tail -5
+```
+
+Use **WebSearch** for major version upgrades:
+- `"{package} migration guide v{old} to v{new}"`
+- `"{package} breaking changes v{new}"`
+
+Build a migration checklist:
+```
+Package:         {name} {old} → {new}
+Breaking changes: {list each one}
+Files affected:  {grep for usage}
+Migration steps: {ordered list}
+```
+
+---
+
+## Phase 3: Apply Migration
+
+**For major version upgrades**: use **EnterWorktree** to isolate.
+
+1. Update the dependency:
+```bash
+# npm
+npm install {package}@{version}
+# pip
+pip install {package}=={version}
+```
+
+2. Apply breaking change fixes — one at a time:
+   - Fix each breaking change
+   - Reference: `file:line — what changed and why`
+   - Run tests after each fix
+
+3. Check for deprecation warnings:
+```bash
+{test command} 2>&1 | grep -i "deprecat\|warning" | head -10
+```
+
+---
+
+## Phase 4: Verify
+
+Run the full test suite AFTER migration:
+```bash
+{test command}; EXIT=$?
+echo "AFTER migration — Exit: $EXIT"
+if [ $EXIT -ne 0 ]; then echo "MIGRATION BROKE SOMETHING — check breaking changes"; fi
+```
+
+Check:
+- All tests pass
+- No new deprecation warnings
+- Lock file updated (package-lock.json / poetry.lock)
+- No leftover old version references
+
+---
+
+## Completion Rule
+
+Show:
+1. Before: package versions and test output
+2. Breaking changes found and how each was resolved
+3. After: updated versions and test output
+4. Lock file changes: `git diff --stat`
+
+Do not say "migration complete" without showing both test runs.

package/templates/commands/persist.md

@@ -0,0 +1,73 @@
+---
+name: persist
+description: End the session — update goals.md, write friction log, append session summary. Run before closing.
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit
+---
+
+# /persist — Session End
+
+Load: shared/session-rhythm.md + shared/friction-log.md
+
+---
+
+## Step 1: Update goals.md
+
+Read `.claude/memory/goals.md`. Update these sections:
+
+**Current threads** — what is still in progress (not done, not blocked)
+**Done this session** — what was completed (specific, not vague)
+**Next actions** — top 3 concrete next steps only
+**Open blockers** — anything that blocked progress
+
+Write the updated file back. Do NOT skip even if the session was short.
+
+---
+
+## Step 2: Write Friction Log (only if there's real friction)
+
+Review the session. If ANY of the four categories below apply, write `ops/observations/{YYYY-MM-DD}-{slug}-friction.md`:
+```
+---
+date: {ISO date}
+type: friction
+---
+
+## Harder than it should be
+{what was harder}
+
+## Repeated from last session
+{what repeated}
+
+## Took longer than expected
+{what was slow}
+
+## Environment is missing something
+{what's missing}
+```
+
+If ALL four categories are "None" — skip this file entirely. No friction = no file.
+Only write when there's a real signal worth capturing.
+
+---
+
+## Step 3: Append Session Summary
+
+Append to `.claude/memory/sessions/{date}-session.md`:
+```yaml
+---
+date: {ISO date}
+topics: [{what was worked on}]
+---
+
+{2-3 sentences: what changed, what was learned, what's next}
+```
+
+---
+
+## Completion Rule — NON-NEGOTIABLE
+
+Print the updated goals.md content.
+Print the friction log content.
+Show both files as proof.
+Do not say "session saved" without showing the actual file content.

package/templates/commands/pulse.md

@@ -0,0 +1,87 @@
+---
+name: pulse
+description: Quick project overview — health check, recent changes, current level, next steps from goals.md.
+allowed-tools: Read, Bash, Grep
+---
+
+# /pulse — Project Overview
+
+Recent git activity:
+!`git log --oneline -5 2>/dev/null || echo 'no git history'`
+
+Uncommitted changes:
+!`git status --short 2>/dev/null || echo 'not a git repo'`
+
+Keep it short and visual. No walls of text.
+
+---
+
+## 1. Project Health
+
+**IDE diagnostics** — use `mcp__ide__getDiagnostics` if available.
+If available, report count and severity:
+```
+✓ IDE: 0 errors, 0 warnings   or   ✗ IDE: 3 errors, 7 warnings — run /fix
+```
+If unavailable: skip this line.
+
+Then detect the start command and try running it:
+- `package.json` → check `scripts.start` or `scripts.dev`
+- `pyproject.toml` / `Makefile` → detect equivalent
+- Check for missing dependencies, missing env vars, broken config
+
+Report:
+```
+✓ App starts cleanly   or   ✗ App fails: {error in one line}
+✓ Dependencies installed   or   ✗ Missing: {what}
+✓ Config complete   or   ✗ Missing: {what}
+```
+
+---
+
+## 2. What Changed
+```bash
+git status --short
+git diff --stat HEAD~1 2>/dev/null || git diff --stat
+```
+
+Show files changed — not the full diff.
+
+---
+
+## 3. Current Level
+Check environment level (same detection as /level-up Step 1).
+One line: "Environment: Level N / 7"
+
+---
+
+## 4. Intelligence Health
+
+Quick check on the learning and boundary systems:
+
+```bash
+# Copilot status
+[ -f .claude/plan.md ] && echo "Copilot: plan.md exists" && grep -c "Status:" .claude/plan.md 2>/dev/null | xargs -I{} echo "  {} milestones" || echo "Copilot: no plan"
+
+# Reflex health
+OBS=".claude/memory/reflexes/observations.jsonl"
+[ -f "$OBS" ] && echo "Reflexes: $(wc -l < "$OBS" | tr -d ' ') observations" || echo "Reflexes: no observations"
+ls .claude/memory/reflexes/project/*.md 2>/dev/null | wc -l | xargs -I{} echo "  {} project reflexes"
+
+# Boundary health
+[ -f .claude/memory/metrics/boundaries.json ] && echo "Boundaries: $(cat .claude/memory/metrics/boundaries.json 2>/dev/null | grep -o '"warn":[0-9]*' | head -1)" || echo "Boundaries: not scanned"
+
+# Blocker count
+[ -f .claude/memory/blockers.md ] && echo "Blockers: $(grep -c "^###" .claude/memory/blockers.md 2>/dev/null || echo 0)" || echo "Blockers: none"
+
+# Evolution history
+[ -f ops/evolution-log.md ] && echo "Evolve: $(tail -1 ops/evolution-log.md 2>/dev/null | cut -d'|' -f2 | tr -d ' ')" || echo "Evolve: never run"
+```
+
+---
+
+## 5. Next Steps
+Based on what you see — suggest 2-3 things to work on next.
+Be specific. Not "improve the code" — "fix the failing test in auth.test.js:47".
+
+Read `.claude/memory/goals.md` if it exists — surface the current thread and next action.

package/templates/commands/refactor.md

@@ -0,0 +1,97 @@
+---
+name: refactor
+description: >
+  Restructure code without changing behavior. Rename, extract, move, simplify.
+  Runs tests before AND after to prove nothing broke. Never changes behavior.
+  Triggers on: "refactor", "rename", "extract", "move this", "simplify",
+  "clean up", "restructure", "split this file", "too long", "DRY this up".
+argument-hint: "[what to refactor — file, function, or pattern]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /refactor — Safe Code Restructuring
+
+$ARGUMENTS
+
+Load: shared/completion-rule.md
+
+---
+
+## Phase 1: Understand Current State
+
+If $ARGUMENTS is blank, use **AskUserQuestion**:
+- What specifically needs refactoring?
+- What's the goal? (readability, DRY, modularity, rename)
+
+1. Read the target code and all files that import/use it:
+```bash
+grep -r "{target}" --include="*.ts" --include="*.py" --include="*.js" -l | head -20
+```
+2. Map all references — every file that will need updating
+3. Run the full test suite BEFORE any changes:
+```bash
+{test command}; EXIT=$?
+echo "BEFORE refactor — Exit: $EXIT"
+```
+4. Record the test output — this is your safety net
+
+**If tests fail before refactoring: STOP.** Fix tests first with `/fix`. Never refactor on a red test suite.
+
+---
+
+## Phase 2: Plan the Change
+
+Write a refactoring plan before touching any code:
+
+```
+Target:     {file:line — what's being refactored}
+Type:       {rename | extract function | extract file | move | simplify | inline}
+Files:      {list of all files that will change}
+Risk:       {low — rename only | medium — logic restructure | high — cross-file move}
+```
+
+For **high risk**: use **EnterWorktree** — isolate the refactor. Merge only if tests pass.
+
+---
+
+## Phase 3: Apply
+
+Execute the refactoring. Reference every change as `file:line — what changed`.
+
+Rules:
+- Change structure, never behavior
+- Update ALL references — grep to verify none were missed:
+```bash
+grep -r "{old_name}" --include="*.ts" --include="*.py" --include="*.js" | head -10
+```
+- If any references remain: fix them before proceeding
+- Update imports, exports, type references, tests, docs
+
+---
+
+## Phase 4: Verify
+
+Run the full test suite AFTER changes:
+```bash
+{test command}; EXIT=$?
+echo "AFTER refactor — Exit: $EXIT"
+if [ $EXIT -ne 0 ]; then echo "REFACTOR BROKE SOMETHING — revert or fix"; fi
+```
+
+Compare before/after:
+- Same number of tests passing
+- No new failures
+- No new warnings
+
+---
+
+## Completion Rule
+
+Show:
+1. Before test output (passing)
+2. List of changes: `file:line — what changed`
+3. After test output (passing)
+4. Grep proof that no stale references remain
+
+Do not say "refactoring complete" without showing both test runs.

package/templates/commands/reflect.md

@@ -0,0 +1,107 @@
+# /reflect — Self-Improving CLAUDE.md
+
+**Purpose**: Analyze conversation patterns and friction to propose improvements to CLAUDE.md rules.
+Unlike /evolve (which improves the environment structure), /reflect improves Claude's *behavior* by
+updating the instructions that guide it.
+
+---
+
+## Step 1: Gather Evidence
+
+Read these files to find friction patterns:
+
+1. **Friction logs** — `ops/observations/*-friction.md` (last 5 files)
+2. **goals.md** — look for repeated blockers or stalled threads
+3. **Session logs** — `.claude/memory/sessions/` (last 3 sessions)
+4. **Current CLAUDE.md** — the rules file being evaluated
+
+If friction logs are empty or don't exist, analyze the current conversation transcript instead:
+- Where did you hesitate, backtrack, or give a wrong answer?
+- Where did the user correct you?
+- Where did you over-engineer or under-deliver?
+
+---
+
+## Step 2: Identify Patterns
+
+Look for these categories:
+
+| Category | Signal | Example |
+|----------|--------|---------|
+| **Missing rule** | Same mistake repeated across sessions | Always forgetting to run tests |
+| **Vague rule** | Rule exists but doesn't prevent the mistake | "Write good tests" doesn't say which framework |
+| **Contradicting rules** | Two rules conflict | "Be concise" vs "Explain thoroughly" |
+| **Dead rule** | Rule refers to something that no longer exists | References a deleted file or old convention |
+| **Missing routing** | Task type has no dispatch entry | User asks for something not in Quick dispatch |
+
+---
+
+## Step 3: Propose Changes
+
+For each finding, propose a specific CLAUDE.md edit:
+
+```
+Finding: [what's wrong]
+Evidence: [which friction log / conversation turn showed this]
+Proposed change:
+
+  ## Rules
+  + 5. **Tests** — Run `npm test` before every commit. Never skip.
+
+  OR
+
+  Quick dispatch:
+  + - /reflect → commands/reflect.md (self-improving CLAUDE.md)
+```
+
+**Rules for proposals:**
+- One finding = one change. Don't bundle.
+- Show the exact text to add/remove/modify.
+- Never remove a rule the user explicitly added.
+- Never add a rule that contradicts an existing one without flagging the conflict.
+
+---
+
+## Step 4: Review with User
+
+Present all findings as a numbered list. Wait for approval.
+
+```
+Reflection found 3 improvements:
+
+1. MISSING RULE — No test framework specified
+   Evidence: 3 sessions used Jest, 1 used Vitest by mistake
+   Proposed: Add "5. **Tests** — Use Jest. Run `npm test` before commits."
+
+2. DEAD RULE — Rule 4 references `shared-skills/` which was removed
+   Proposed: Remove rule 4.
+
+3. MISSING ROUTING — /reflect not in Quick dispatch
+   Proposed: Add routing entry.
+
+Apply which? (all / 1,2 / none)
+```
+
+---
+
+## Step 5: Apply
+
+For each approved change:
+1. Edit CLAUDE.md with the exact proposed text
+2. If a routing entry was added, verify the command file exists
+3. Run tests if the project has them
+
+---
+
+## Step 6: Log
+
+Append to `ops/observations/{date}-reflect.md`:
+
+```markdown
+# Reflection — {date}
+Applied {N} of {M} proposed changes.
+
+## Changes
+- [applied] {finding 1 summary}
+- [skipped] {finding 2 summary} — reason: {user said no / conflict}
+```

package/templates/commands/reflexes.md

@@ -0,0 +1,141 @@
+---
+name: reflexes
+description: >
+  View, analyze, and manage learned reflexes. Shows what patterns the system has
+  detected from session observations with confidence scoring.
+  Triggers on: "reflexes", "what have you learned", "show learned patterns",
+  "reflex status", "analyze observations", "promote reflex".
+argument-hint: "[status | analyze | promote | clear]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# /reflexes — Learned Behavioral Patterns
+
+$ARGUMENTS
+
+Load: capabilities/shared/reflexes.md
+
+---
+
+## Subcommand: status (default)
+
+Show all learned reflexes with confidence scores + observation health.
+
+```bash
+# Observation health
+OBS_FILE=".claude/memory/reflexes/observations.jsonl"
+if [ -f "$OBS_FILE" ]; then
+  OBS_COUNT=$(wc -l < "$OBS_FILE" 2>/dev/null | tr -d ' ')
+  LATEST=$(tail -1 "$OBS_FILE" 2>/dev/null | grep -o '"ts":"[^"]*"' | head -1)
+  echo "Observations: $OBS_COUNT total, latest: $LATEST"
+  # Check capture recency (warn if > 24h since last observation)
+  echo "Health: $([ "$OBS_COUNT" -gt 10 ] && echo 'good' || echo 'low — hooks may not be capturing')"
+else
+  echo "Observations: none — hooks not capturing yet"
+fi
+
+# Count project reflexes
+ls .claude/memory/reflexes/project/*.md 2>/dev/null || echo "No project reflexes yet"
+
+# Count global reflexes
+ls .claude/memory/reflexes/global/*.md 2>/dev/null || echo "No global reflexes yet"
+```
+
+For each reflex file, read and display:
+```
+| ID | Trigger | Confidence | Domain | Scope | Evidence |
+|----|---------|-----------|--------|-------|----------|
+```
+
+Sort by confidence (highest first).
+
+---
+
+## Subcommand: analyze
+
+Analyze observations.jsonl to detect new patterns and create/update reflexes.
+
+1. Read `.claude/memory/reflexes/observations.jsonl` (last 500 lines)
+2. Detect patterns with 3+ occurrences:
+   - **Tool sequences**: same chain of tools used repeatedly
+   - **File co-access**: files always accessed together
+   - **Error → fix pairs**: same error resolved the same way
+   - **Naming patterns**: consistent naming in created files
+3. For each detected pattern:
+   - Check if reflex already exists → update confidence (+0.05 per new observation)
+   - If new → create reflex file with initial confidence based on count
+4. Write reflex files to `.claude/memory/reflexes/project/`
+
+### Reflex File Format
+
+```markdown
+---
+id: {kebab-case-name}
+trigger: "{when condition}"
+action: "{what to do}"
+confidence: {0.3-0.95}
+domain: {code-style|testing|git|debugging|workflow|file-patterns|security}
+scope: {project|global}
+evidence_count: {N}
+last_observed: {YYYY-MM-DD}
+---
+
+# {Title}
+
+## Evidence
+- Observed {N} times across {M} sessions
+- Pattern: {description}
+- Last observed: {date}
+```
+
+---
+
+## Subcommand: promote
+
+Promote a project reflex to global scope.
+
+```bash
+# If specific ID given
+# Move .claude/memory/reflexes/project/{id}.md → .claude/memory/reflexes/global/{id}.md
+# Update scope field in frontmatter to "global"
+
+# If no ID given — auto-promote all qualifying
+# Criteria: confidence >= 0.8 AND domain in (security, workflow, git)
+```
+
+Show what was promoted and why.
+
+---
+
+## Subcommand: clear
+
+Clear stale observations (older than 30 days) and low-confidence reflexes (< 0.3).
+
+```bash
+# Archive old observations
+mv .claude/memory/reflexes/observations.jsonl .claude/memory/reflexes/observations-$(date +%Y%m%d).archive.jsonl
+
+# Remove reflexes with confidence < 0.3
+# List what would be removed, then confirm
+```
+
+---
+
+## Copilot Mode
+
+When running inside `/copilot`:
+- Skip user confirmation for promote and clear
+- Auto-run `analyze` every 3 milestones (alongside /evolve)
+- Feed strong reflexes (confidence >= 0.7) into /add behavior
+
+---
+
+## Completion Rule
+
+Show:
+1. Reflex table (ID, trigger, confidence, domain, scope)
+2. Observation count
+3. Any new reflexes created or updated
+
+Do not say "reflexes analyzed" without showing the table.