azclaude-copilot 0.4.36 → 0.4.37

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "azclaude",
       "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 37 commands, 9 auto-invoked skills, 15 specialized agents, 4 hooks, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
-      "version": "0.4.36",
+      "version": "0.4.37",
       "source": {
         "source": "github",
         "repo": "haytamAroui/AZ-CLAUDE-COPILOT",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude",
-  "version": "0.4.36",
+  "version": "0.4.37",
   "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 37 commands, 9 auto-invoked skills, 15 specialized agents, 4 hooks, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
   "author": {
     "name": "haytamAroui",

package/README.md

@@ -649,7 +649,7 @@ M1 (schema) → done
 /parallel M2 M3 M4 M5    # dispatch these milestones simultaneously
 ```
 
-**Three-layer safety:** `/blueprint` checks directory isolation + shared-utility imports before writing plan.md (Layer 1 — no agents spawned). `problem-architect` returns exact `Files Written:` and `Parallel Safe:` per milestone after plan.md (Layer 2). The orchestrator checks file overlap again at dispatch time (Layer 3 — final gate, cannot be bypassed).
+**Four-layer safety:** Before creating any milestones, `/blueprint` runs a **Task Classifier** (Layer 0) — groups coupled work (same schema table, same config file, same utility module) into single milestones so conflicts are impossible by design. Then: directory isolation + shared-utility grep (Layer 1, no agents spawned). `problem-architect` returns exact `Files Written:` and `Parallel Safe:` per milestone (Layer 2). Orchestrator re-checks file overlap at dispatch time (Layer 3 — unconditional final gate).
 
 See `docs/parallel-feature.md` for the complete reference.
 
@@ -865,11 +865,11 @@ Run `/level-up` at any time to see your current level and build the next one.
 
 ## Verified
 
-1558 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+1578 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1558 passed, 0 failed, 1558 total
+# Results: 1578 passed, 0 failed, 1578 total
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.4.36",
+  "version": "0.4.37",
   "description": "AI coding environment — 37 commands, 10 skills, 15 agents, memory, reflexes, evolution. Install: npx azclaude-copilot@latest, then open Claude Code.",
   "bin": {
     "azclaude": "bin/cli.js",

package/templates/commands/blueprint.md

@@ -114,9 +114,9 @@ If constitution found → scan plan steps against non-negotiables:
 - Flag any plan step that could violate a rule
 - Add a note to flagged steps: `⚠ Constitution check: may conflict with "{rule}" — verify before implementing`
 
-If code-rules found → read `## Architecture` section:
-- The plan must respect the declared architecture pattern (Clean Architecture / DDD / MVC / etc.)
-- If a plan step would introduce a pattern that conflicts with the architecture rule — flag it
+If code-rules found → read the file header line (`# Architecture: {pattern}`):
+- The plan must respect the declared architecture pattern (Clean Architecture / DDD / MVC / feature-based / etc.)
+- If a plan step would introduce a pattern that conflicts with the declared architecture — flag it
 - Add note: `⚠ Code rules: this step should follow {architecture pattern} — verify approach before implementing`
 
 Then run `/tasks` to show dependency waves:
@@ -127,69 +127,50 @@ Next: Run /tasks to see which plan steps can run in parallel
 
 ---
 
-## Step 4: Approval Gate
-
-**ExitPlanMode**
-
-Present the plan and STOP. Do not write any code.
-
-Ask the user: **"Approve this plan? (yes / change step N / cancel)"**
+## Parallel Planning — Task Classifier + Wave Assignment (ALL modes)
 
-- `yes` → create TaskCreate for each step, then state: "Run /add to execute each task."
-- `change step N` → revise that step, re-present, ask again
-- `cancel` → discard, no tasks created
+**Runs in both interactive and copilot mode.**
+Produces the milestone set and wave structure that Step 3c visualizes.
+In copilot mode, the orchestrator dispatches directly from this output.
 
-Tasks are only created after explicit approval. This is the point of /blueprint.
+**Mode detection:**
+```bash
+[ -f .claude/copilot-intent.md ] && echo "COPILOT_MODE" || echo "INTERACTIVE_MODE"
+```
 
----
+### Task Classifier — Zero-Conflict Milestone Design (REQUIRED before wave assignment)
 
-## Feature-Scoped Mode (Optional)
-
-When $ARGUMENTS points to a spec file (`.claude/specs/*.md`) OR contains a named feature:
+**Run this BEFORE creating milestones.** Groups coupled work together so parallel dispatch is safe by construction — not by detection after the fact.
 
+**Step 0: Greenfield check**
 ```bash
-# Detect spec file
-[ -f "$ARGUMENTS" ] && echo "spec-mode" || echo "inline-mode"
-
-# Determine next feature number
-NEXT_N=$(ls .claude/features/ 2>/dev/null | grep -c '^' || echo 0)
-N=$(printf '%02d' $((NEXT_N + 1)))
-SLUG=$(basename "$ARGUMENTS" .md 2>/dev/null || echo "$ARGUMENTS" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-' | cut -c1-40)
-FEATURE_DIR=".claude/features/${N}-${SLUG}"
+SRC_COUNT=$(find src/ app/ lib/ -type f 2>/dev/null | wc -l 2>/dev/null || echo 0)
+echo "source_files=$SRC_COUNT"
 ```
+If source_files < 10 → greenfield project. Force Wave 1 = all foundation work (schema, config, shared utils, types) as a SINGLE milestone regardless of feature count. Parallel only unlocks from Wave 2 onward, after the foundation exists and greps have real files to scan.
 
-If spec file provided → create a feature-scoped directory:
-```bash
-mkdir -p "$FEATURE_DIR"
-cp "$ARGUMENTS" "$FEATURE_DIR/spec.md"
-```
+**Step 1: List raw work items**
+From the intent/spec, enumerate ALL features, endpoints, models, UI pages, and background jobs as raw items. Do not group yet — just list everything the project needs.
 
-Write the plan to `$FEATURE_DIR/plan.md` (same format as `.claude/plan.md`).
-Also write a summary entry to `.claude/plan.md` linking to the feature:
-```markdown
-## Feature: {N}-{slug}
-Files: .claude/features/{N}-{slug}/plan.md
-Status: pending
-```
+**Step 2: Coupling analysis — merge rule**
+For each pair of raw work items, check if they share ANY of:
+- Same database table (both CREATE or ALTER the same table)
+- Same config file (`package.json`, `tsconfig.json`, `prisma/schema.prisma`, `docker-compose.yml`, `go.mod`, `Cargo.toml`)
+- Same utility module (both CREATE or MODIFY files in `utils/`, `shared/`, `common/`, `lib/`, `helpers/`)
+- Same API contract (one produces an endpoint, the other consumes it within the same feature boundary)
 
-This keeps the global plan.md as the tracker while feature details live in their own directory.
-Each feature directory is self-contained: `spec.md` + `plan.md` + any generated artifacts.
+If any coupling exists → merge those two items into ONE milestone. Repeat until no same-wave pair shares any resource.
 
-**When NOT to use feature mode:** quick fixes, single-file changes, copilot mode (uses global plan.md).
+**Step 3: Independence check — split rule**
+Work items that share NONE of the above → separate milestones, `Parallel: yes` candidate.
 
----
+**Result:** Every milestone is either:
+- **Fat milestone** — all coupled work together. One agent handles everything that would otherwise conflict. Larger task, zero parallel risk.
+- **Thin milestone** — fully independent. Parallel-safe by construction, not by detection.
 
-## Copilot Mode — Structured plan.md Output
+Proceed to Layer 1 with these merged milestones — not with raw work items.
 
-When running inside `/copilot` (detected by: `.claude/copilot-intent.md` exists):
-- Skip the approval gate (Step 4) — copilot operates autonomously
-- Write the plan to `.claude/plan.md` in the structured format defined in `plan-tracker.md`
-- Read `.claude/capabilities/shared/plan-tracker.md` for the exact format
-- Each milestone = one logical unit of work (1-3 files, one commit)
-- Include `Depends:` for milestones that require prior work
-- Include `Files:` with expected paths
-- Include `Commit:` with conventional commit format
-- Write `## Summary` with counts at the bottom
+---
 
 ### Parallel Optimization Pass — Layer 1 (REQUIRED before writing plan.md)
 
@@ -231,7 +212,7 @@ both need to CREATE or MODIFY files there → set `Parallel: no` for both and ad
 **Do NOT spawn problem-architect here.** The grep is sufficient for Layer 1. Problem-architect
 runs after plan.md is written and handles the cases Layer 1 misses.
 
-**Step 4: Set Dirs: and Parallel: fields, write plan.md**
+**Step 4: Set Dirs: and Parallel: fields**
 
 ```
 - Dirs:     top-level directories this milestone exclusively owns
@@ -249,6 +230,140 @@ Wave 3: M6 (integration/E2E) — Parallel: no
 
 ---
 
+## Step 3c: Parallel Dispatch Visualization
+
+After classifier + Layer 1 complete, render the dispatch map:
+
+```
+══════════════════════════════════════════════════════
+  Parallel Dispatch Plan
+══════════════════════════════════════════════════════
+
+  Wave 1 (sequential — foundation)
+  ┌─────────────────────────────────────────────────┐
+  │  M1: {title}                                    │
+  │      Dirs: {dirs}                               │
+  │      Parallel: no  (foundation — must run first)│
+  └─────────────────────────────────────────────────┘
+                         │
+                         ▼
+  Wave 2 (parallel — {N} agents simultaneously)
+  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
+  │ M2: {title}  │ │ M3: {title}  │ │ M4: {title}  │
+  │ {dirs}       │ │ {dirs}       │ │ {dirs}        │
+  │ Parallel: ✓  │ │ Parallel: ✓  │ │ Parallel: ✓  │
+  └──────────────┘ └──────────────┘ └──────────────┘
+                         │
+                         ▼
+  (continue for each wave)
+
+  ══════════════════════════════════════════════════
+  Summary
+  ──────────────────────────────────────────────────
+  Total milestones:    {N}
+  Waves:               {N}
+  Max parallel:        {N} agents (Wave {N})
+  Sequential estimate: {total} sessions (~{total×30}min)
+  Parallel estimate:   {waves} waves  (~{waves×30}min)
+  Time saved:          ~{pct}%
+
+  Merged by classifier:
+    • {item A} + {item B} → {MN}  ({reason — e.g. shared schema.prisma})
+
+  Split for parallelism:
+    • {item} split from {other item}  ({reason — e.g. different dirs, no shared files})
+  ══════════════════════════════════════════════════
+```
+
+**Rules:**
+- Show every wave, even single-milestone waves
+- Side-by-side boxes for parallel milestones in the same wave; single wide box for sequential
+- "Sequential estimate" = `total milestones × 30min`; "Parallel estimate" = `wave count × 30min`
+- Time saved % = `(sequential - parallel) / sequential × 100`
+- "Merged by classifier" lists only merges that changed the plan (not items that were always single)
+- "Split for parallelism" lists items the classifier separated into different milestones
+
+**In copilot mode:** write the visualization as a comment block at the top of plan.md:
+```markdown
+<!-- Parallel Dispatch Plan
+Wave 1 (seq): M1 — foundation
+Wave 2 (parallel, 4 agents): M2 M3 M4 M5
+Wave 3 (parallel, 3 agents): M6 M7 M8
+Wave 4 (seq): M9 — integration
+Sequential: ~270min | Parallel: ~120min | Saved: ~56%
+-->
+```
+
+**In interactive mode:** show the visualization before the approval gate.
+Let the user adjust wave grouping: "move M5 to Wave 3" → adjust Depends:, re-render, re-present.
+
+---
+
+## Step 4: Approval Gate
+
+**ExitPlanMode**
+
+Present the plan and STOP. Do not write any code.
+
+Ask the user: **"Approve this plan? (yes / change step N / cancel)"**
+
+- `yes` → create TaskCreate for each step, then state: "Run /add to execute each task."
+- `change step N` → revise that step, re-present, ask again
+- `cancel` → discard, no tasks created
+
+Tasks are only created after explicit approval. This is the point of /blueprint.
+
+---
+
+## Feature-Scoped Mode (Optional)
+
+When $ARGUMENTS points to a spec file (`.claude/specs/*.md`) OR contains a named feature:
+
+```bash
+# Detect spec file
+[ -f "$ARGUMENTS" ] && echo "spec-mode" || echo "inline-mode"
+
+# Determine next feature number
+NEXT_N=$(ls .claude/features/ 2>/dev/null | grep -c '^' || echo 0)
+N=$(printf '%02d' $((NEXT_N + 1)))
+SLUG=$(basename "$ARGUMENTS" .md 2>/dev/null || echo "$ARGUMENTS" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd 'a-z0-9-' | cut -c1-40)
+FEATURE_DIR=".claude/features/${N}-${SLUG}"
+```
+
+If spec file provided → create a feature-scoped directory:
+```bash
+mkdir -p "$FEATURE_DIR"
+cp "$ARGUMENTS" "$FEATURE_DIR/spec.md"
+```
+
+Write the plan to `$FEATURE_DIR/plan.md` (same format as `.claude/plan.md`).
+Also write a summary entry to `.claude/plan.md` linking to the feature:
+```markdown
+## Feature: {N}-{slug}
+Files: .claude/features/{N}-{slug}/plan.md
+Status: pending
+```
+
+This keeps the global plan.md as the tracker while feature details live in their own directory.
+Each feature directory is self-contained: `spec.md` + `plan.md` + any generated artifacts.
+
+**When NOT to use feature mode:** quick fixes, single-file changes, copilot mode (uses global plan.md).
+
+---
+
+## Copilot Mode — plan.md Format + Layer 2 Validation
+
+When running inside `/copilot` (detected by: `.claude/copilot-intent.md` exists):
+- Skip the approval gate (Step 4) — copilot operates autonomously
+- Task Classifier + Layer 1 already ran in the "Parallel Planning" section above
+- Write the plan to `.claude/plan.md` using the classified milestones
+- Read `.claude/capabilities/shared/plan-tracker.md` for the exact format
+- Each milestone = one logical unit of work (1-3 files, one commit)
+- Include `Depends:` for milestones that require prior work
+- Include `Files:` with expected paths
+- Include `Commit:` with conventional commit format
+- Write `## Summary` with counts at the bottom
+
 ### Problem-Architect Validation — Layer 2 (after plan.md is written)
 
 Layer 2 refines Layer 1 with exact file-level analysis. Catches shared utilities that