azclaude-copilot 0.4.0 → 0.4.2

package/README.md

@@ -469,7 +469,7 @@ azclaude-copilot/
 ├── DOCS.md                          <- full user guide
 ├── SECURITY.md                      <- security policy + architecture
 ├── tests/
-│   └── test-features.sh          ← 1096 tests
+│   └── test-features.sh          ← 1135 tests
 ```
 
 ---
@@ -495,11 +495,11 @@ The runner is stateless. These files ARE the state.
 
 ## Verified
 
-1096 tests. Every template, command, capability, agent, and CLI feature verified.
+1135 tests. Every template, command, capability, agent, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1096 passed, 0 failed, 1096 total
+# Results: 1135 passed, 0 failed, 1135 total
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "AI coding environment — 26 commands, 8 skills, 10 agents, memory, reflexes, evolution. Install once, works on any stack.",
   "bin": {
     "azclaude": "./bin/cli.js",

package/templates/capabilities/manifest.md

@@ -25,6 +25,7 @@ Load only the files that match the current task. Never load the full list.
 | shared/context-artifacts.md | Project has DB schemas, API specs, infra configs, or knowledge/ dir — discover and use non-code knowledge before implementing | ~200 |
 | shared/semantic-boundary-check.md | /evolve Cycle 3 or boundary validator warns — detect deeper behavioral duplication across extension types that grep misses | ~300 |
 | shared/domain-advisor-generator.md | Non-tech domain detected (compliance, marketing, finance, medical, legal, research) — generates domain-specific advisor skill | ~400 |
+| shared/intelligent-dispatch.md | About to build, fix, refactor, audit, or ship — non-trivial scope (3+ files or structural) — pre-flight analysis via problem-architect | ~300 |
 
 ## Level Builders — load ONE at a time
 | File | When to load | Tokens |

package/templates/capabilities/shared/intelligent-dispatch.md

@@ -0,0 +1,79 @@
+# Intelligent Dispatch — Pre-Flight Protocol
+
+Load before any non-trivial build, fix, refactor, audit, or plan task.
+Invokes problem-architect for structured analysis BEFORE touching code.
+
+---
+
+## When to Run Problem-Architect
+
+Run pre-analysis if ANY of these is true:
+- Task will touch 3+ files
+- Task involves a structural change (schema, API contract, auth, architecture)
+- Task crosses directory boundaries (multiple modules or layers)
+- First time working in this part of the codebase this session
+
+Skip if:
+- Only 1-2 files, clearly scoped
+- Pure config/docs change with no code impact
+- Already in copilot mode with annotated plan.md (milestones already have Team Spec)
+
+---
+
+## How to Invoke
+
+```bash
+ls .claude/agents/problem-architect.md 2>/dev/null && echo "ARCHITECT_AVAILABLE" || echo "NOT_INSTALLED"
+```
+
+If ARCHITECT_AVAILABLE — spawn problem-architect with:
+```
+Task: {command name} — {what you're doing}
+Current state: {what files/dirs exist relevant to this task}
+Available agents: {output of: ls .claude/agents/ 2>/dev/null}
+Available skills: {output of: ls .claude/skills/ 2>/dev/null}
+```
+
+---
+
+## What to Do with the Returned Team Spec
+
+| Field | Action |
+|-------|--------|
+| Skills to Load | Load each skill before implementing |
+| Pre-Read Files | Read every file listed, in order: schema → source → tests → patterns → antipatterns |
+| Pre-Conditions | Verify each; STOP if any unmet |
+| Files Written | Note for parallel safety — no concurrent work on same files |
+| Structural Decision: YES | Run /debate before proceeding; log result to `.claude/memory/decisions.md` |
+| Risks | Read mitigation; apply to implementation approach |
+
+---
+
+## Implementation Protocol (milestone-builder)
+
+For any implementation task (3+ files or MEDIUM/COMPLEX):
+
+1. **Pre-read** all files from Team Spec — no exceptions
+2. **Implement** following patterns.md exactly — never invent patterns
+3. **Verify** — run full test suite, show actual output (never summarize)
+4. **Self-correct** — re-read error + check antipatterns.md → ONE alternative approach
+5. **Budget** — 2 fix attempts for SIMPLE/MEDIUM, 3 for COMPLEX
+   - Budget exhausted → report exact error + what was tried → do not guess again
+
+---
+
+## When to Escalate to Orchestrator
+
+If `.claude/agents/orchestrator.md` exists:
+- Task spans 2+ milestones in plan.md → delegate to orchestrator
+- Multiple independent workstreams → orchestrator manages parallel dispatch
+- Structural decision needed → orchestrator triggers /debate
+
+---
+
+## Rules
+
+- NEVER skip pre-read. Context-blind implementation is the most common failure mode.
+- NEVER invent patterns. patterns.md says use X → use X.
+- NEVER exceed fix attempt budget. Stop and report when exhausted.
+- ALWAYS show test output. Never say "tests should pass."

package/templates/commands/add.md

@@ -18,6 +18,19 @@ Load: shared/tdd.md + shared/completion-rule.md
 
 ---
 
+## Pre-Flight Analysis (intelligent-dispatch)
+
+Load `shared/intelligent-dispatch.md`.
+
+If task will touch 3+ files OR crosses module boundaries:
+→ Spawn problem-architect (see intelligent-dispatch protocol)
+→ Use returned Team Spec: load skills, pre-read files, check pre-conditions, note risks
+→ If Structural Decision: YES → run /debate before Phase 4
+
+If problem-architect not installed: proceed with Phase 1 as normal (manual scan in Phase 2).
+
+---
+
 ## Copilot Mode Detection
 
 ```bash

package/templates/commands/audit.md

@@ -48,6 +48,27 @@ If `COPILOT_MODE`:
 
 ---
 
+## Step 1b: Structural Context (intelligent-dispatch)
+
+Load `shared/intelligent-dispatch.md`.
+
+If problem-architect available — spawn it before reviewing:
+```
+Task: audit — structural context for spec compliance review
+Current state: {what's changed, what the diff covers}
+Available agents: {list}
+Available skills: {list}
+```
+Use returned Team Spec to inject:
+- `decisions.md` rulings to check against (architectural commitments)
+- `patterns.md` conventions the code should follow
+- `antipatterns.md` known failure patterns to scan for
+- Risks flagged by architect → include in audit checklist
+
+If problem-architect not installed: proceed with manual review using available memory files.
+
+---
+
 ## Step 2: Spec Compliance (REQUIRED FIRST)
 
 **Assume the implementation may be incomplete or optimistic. Verify independently.**

package/templates/commands/blueprint.md

@@ -104,7 +104,33 @@ When running inside `/copilot` (detected by: `.claude/copilot-intent.md` exists)
 - Include `Files:` with expected paths
 - Include `Commit:` with conventional commit format
 - Write `## Summary` with counts at the bottom
-- After writing plan.md, return control to /copilot
+
+### Problem-Architect Validation (if available)
+
+After writing plan.md, check:
+```bash
+ls .claude/agents/problem-architect.md 2>/dev/null
+```
+
+If problem-architect.md exists — spawn it for EACH milestone in plan.md:
+```
+Analyze this milestone for the Team Spec:
+Milestone: {description from plan.md}
+Current state: {what files exist in the project}
+Available agents: {list of .claude/agents/}
+Available skills: {list of .claude/skills/}
+```
+
+For each milestone, append the returned Team Spec fields directly into plan.md:
+- `Complexity:` SIMPLE / MEDIUM / COMPLEX
+- `Files Written:` exact paths the builder will touch (critical for parallel safety)
+- `Pre-conditions:` checklist before starting
+- `Risks:` and mitigation
+- `Structural Decision:` YES/NO (if YES → orchestrator must /debate before dispatching)
+
+This pre-annotation makes orchestrator dispatch faster and prevents parallel file collision.
+
+After all milestones annotated — return control to /copilot.
 
 ---
 

package/templates/commands/dream.md

@@ -57,6 +57,23 @@ Read `.claude/capabilities/manifest.md` if it exists.
 
 Detect current level (0–7) from what's present.
 
+**Existing project deep scan (intelligent-dispatch):**
+
+If `.claude` directory exists and project has code files — load `shared/intelligent-dispatch.md` and spawn problem-architect:
+```
+Task: dream — analyze existing codebase before generating vision
+Current state: {what files, agents, skills already exist}
+Available agents: {list}
+Available skills: {list}
+```
+Use returned Team Spec to understand:
+- What agents/skills already cover (don't regenerate what exists)
+- Co-change clusters (candidate future agents)
+- Established patterns (vision must not conflict with them)
+- Structural decisions already made (decisions.md)
+
+If clean slate (no .claude dir): skip problem-architect, proceed to Phase 3.
+
 **ExitPlanMode** — ready to build.
 
 ---

package/templates/commands/evolve.md

@@ -203,6 +203,26 @@ ls .claude/commands/*.md .claude/agents/*.md .claude/skills/*/SKILL.md 2>/dev/nu
 Skip creation if a skill/agent already covers the same workflow.
 Update existing ones if they're missing steps discovered in recent sessions.
 
+### 7e: Orchestrator re-evaluation (if intelligent copilot installed)
+
+After generating new agents/skills, check:
+```bash
+ls .claude/agents/orchestrator.md .claude/plan.md 2>/dev/null
+```
+
+If BOTH exist — spawn orchestrator with:
+```
+Re-evaluate plan.md after /evolve created new agents and skills.
+Focus on: which blocked milestones can now be unblocked?
+New agents available: {list of newly created agents}
+New skills available: {list of newly created skills}
+Check blockers.md for each blocked milestone — does a new agent cover the missing capability?
+Update plan.md status for any milestone that is now unblockable (blocked → pending).
+Report: milestones unblocked + reason.
+```
+
+This closes the loop: /evolve creates capability → orchestrator immediately re-routes blocked work.
+
 ---
 
 ## Step 8: Promote GENERAL Skills

package/templates/commands/fix.md

@@ -14,6 +14,20 @@ Load: shared/tdd.md + shared/completion-rule.md before starting.
 
 ---
 
+## Pre-Flight Analysis (intelligent-dispatch)
+
+Load `shared/intelligent-dispatch.md`.
+
+After reproducing the error — before investigating — spawn problem-architect if available:
+→ Task: "fix — {error description}"
+→ Current state: {files involved in the failure}
+→ Use returned Team Spec: pre-read the affected files, load patterns/antipatterns for this area
+→ Pre-conditions check prevents fixing a symptom instead of the root cause
+
+If problem-architect not installed: proceed with Phase 2 manual investigation as normal.
+
+---
+
 ## Phase 1: REPRODUCE
 
 **First: check IDE diagnostics (instant, no build needed)**

package/templates/commands/refactor.md

@@ -18,6 +18,27 @@ Load: shared/completion-rule.md
 
 ---
 
+## Pre-Flight Analysis (intelligent-dispatch)
+
+Load `shared/intelligent-dispatch.md`.
+
+Spawn problem-architect before any scan:
+```
+Task: refactor — {what's being refactored}
+Current state: {target file/function + surrounding directory}
+Available agents: {list}
+Available skills: {list}
+```
+Use returned Team Spec:
+- Pre-Read Files → read these BEFORE grepping for references (architect already knows the dependency graph)
+- Risks → structural risks the refactor may trigger (e.g., type exports used downstream)
+- Files Written → exhaustive list of files the refactor will touch
+- If Structural Decision: YES → run /debate (refactors sometimes expose architectural choices)
+
+If problem-architect not installed: proceed with Phase 1 manual scan.
+
+---
+
 ## Phase 1: Understand Current State
 
 If $ARGUMENTS is blank, use **AskUserQuestion**:

package/templates/commands/setup.md

@@ -121,6 +121,27 @@ Read `.claude/capabilities/level-builders/level5-agents.md` for agent design gui
 
 Skip if project has < 10 files or < 5 commits.
 
+### Problem-Architect Supplement (new projects with zero git history)
+
+If the project has < 5 commits (no co-change data), check:
+```bash
+ls .claude/agents/problem-architect.md 2>/dev/null
+```
+
+If problem-architect.md exists — spawn it to analyze the project structure directly:
+```
+Analyze this project to recommend agents and skills.
+No git history available — use file structure and stack signals instead.
+Project stack: {from env-scan.sh output}
+Files found: {top-level structure}
+Domain: {from CLAUDE.md}
+Available agents already installed: {list .claude/agents/}
+Return: recommended cc- agents (with directory claims) + skills to generate
+```
+
+Use the returned recommendations as the basis for agent/skill generation.
+This fills the gap when git history is too thin for co-change analysis.
+
 ---
 
 ## Step 7: Quality Gate

package/templates/commands/ship.md

@@ -15,6 +15,26 @@ $ARGUMENTS
 
 ---
 
+## Step 0: Risk Scan (intelligent-dispatch)
+
+Load `shared/intelligent-dispatch.md`.
+
+If problem-architect available — spawn it for a pre-ship risk scan:
+```
+Task: ship — pre-ship risk assessment
+Current state: {output of: git diff --stat HEAD}
+Available agents: {list}
+Available skills: {list}
+```
+Use returned Team Spec:
+- Risks → must address before shipping (not suggestions)
+- Structural Decision: YES → a decision was made without /debate → log it to decisions.md now
+- Pre-Conditions → any unmet condition blocks ship (e.g., migration not run, env var not set)
+
+If problem-architect not installed OR git diff is only docs/config: skip and proceed to Pre-Ship Gate.
+
+---
+
 ## Pre-Ship Gate (runs before any commit)
 
 **1. IDE diagnostics** — use `mcp__ide__getDiagnostics` if available.