azclaude-copilot 0.4.23 → 0.4.24

package/README.md

@@ -807,11 +807,11 @@ Run `/level-up` at any time to see your current level and build the next one.
 
 ## Verified
 
-1407 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+1421 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1407 passed, 0 failed, 1407 total
+# Results: 1421 passed, 0 failed, 1421 total
 ```
 
 ---

package/package.json

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

package/templates/agents/milestone-builder.md

@@ -40,15 +40,19 @@ If any item is missing → ask orchestrator before proceeding.
 
 Read every file in the pre-read list. Order matters:
 1. `.claude/constitution.md` — non-negotiables (if present — read FIRST, constraints before code)
-2. Schema / config files (structural constraints)
-3. Related source files (existing patterns to match)
-4. Related test files (test framework + naming conventions)
-5. patterns.md entries for this area
-6. antipatterns.md entries for this area
+2. `.claude/code-rules.md` — coding standards contract (if present — read SECOND, style rules before code)
+3. Schema / config files (structural constraints)
+4. Related source files (existing patterns to match)
+5. Related test files (test framework + naming conventions)
+6. patterns.md entries for this area
+7. antipatterns.md entries for this area
 
 If constitution.md exists: keep its Non-Negotiables visible throughout implementation.
 Flag any implementation choice that would violate them BEFORE writing — do not discover violations after the fact.
 
+If code-rules.md exists: apply the relevant sections (naming, language, framework, testing) throughout implementation.
+Flag any implementation choice that would violate a rule BEFORE writing the code.
+
 Do NOT skip pre-reads. Context-blind implementation is the most common failure mode.
 
 ---

package/templates/commands/audit.md

@@ -121,8 +121,14 @@ Report violations only — no code quality feedback until spec is clean.
 If unavailable or empty: skip — proceed to manual checks.
 If returns results: include errors and warnings in the report.
 
+```bash
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
+```
+
+**If code-rules found:** read `.claude/code-rules.md` — use it as the primary convention checklist for this step (naming, style, testing, git). It overrides generic CLAUDE.md conventions for style questions.
+
 Check:
-- Follows project conventions from CLAUDE.md
+- Follows project conventions from CLAUDE.md (and code-rules.md if present)
 - No security anti-patterns (see shared/security.md)
 - If developer domain: tests exist for new behavior (TDD Iron Law)
 - Minimum necessary complexity — no over-engineering

package/templates/commands/blueprint.md

@@ -101,11 +101,12 @@ State the risk level. If risk = high → recommend `EnterWorktree` during implem
 
 ---
 
-## Step 3b: Constitution Check + Task Graph
+## Step 3b: Constitution + Code Rules Check + Task Graph
 
 After writing the plan (Step 3), check:
 ```bash
 [ -f .claude/constitution.md ] && echo "constitution=found" || echo "no constitution"
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
 ```
 
 If constitution found → scan plan steps against non-negotiables:
@@ -113,6 +114,11 @@ 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
+- Add note: `⚠ Code rules: this step should follow {architecture pattern} — verify approach before implementing`
+
 Then run `/tasks` to show dependency waves:
 ```
 Next: Run /tasks to see which plan steps can run in parallel

package/templates/commands/doc.md

@@ -16,6 +16,18 @@ $ARGUMENTS
 
 ---
 
+## Pre-Flight: Code Rules Check
+
+```bash
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
+```
+
+If code-rules found: read the `## Documentation` section.
+It defines the required doc style (JSDoc on all public functions / inline comments only / none).
+This overrides inferred style — code-rules is the authoritative answer for this project.
+
+---
+
 ## Phase 1: Detect Scope
 
 If $ARGUMENTS is blank, use **AskUserQuestion**:

package/templates/commands/refactor.md

@@ -18,16 +18,21 @@ Load: shared/completion-rule.md
 
 ---
 
-## Pre-Flight: Constitution Check
+## Pre-Flight: Constitution + Code Rules Check
 
 ```bash
 [ -f .claude/constitution.md ] && echo "constitution=found" || echo "no constitution"
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
 ```
 
-If found: read `## Architectural Commitments` and `## Required Patterns`.
+If constitution found: read `## Architectural Commitments` and `## Required Patterns`.
 Refactoring often changes structure — ensure the refactor moves TOWARD required patterns, not away from them.
 If the refactor would conflict with an architectural commitment → flag before starting Phase 1. Do not proceed silently.
 
+If code-rules found: read `.claude/code-rules.md` — the refactor must move code TOWARD these rules, not away from them.
+The style, naming, and architecture sections define the TARGET state. Use them as the direction of the refactor.
+If the current code violates a rule, the refactor is an opportunity to fix it — note the correction explicitly.
+
 ---
 
 ## Pre-Flight Analysis (intelligent-dispatch)

package/templates/commands/setup.md

@@ -185,6 +185,17 @@ If constitution missing:
     Copilot checks this before every milestone implementation.
 ```
 
+If no coding rules found:
+```bash
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "code-rules=missing"
+```
+```
+  · No coding rules contract found.
+    Run: /driven
+    Why: generates .claude/code-rules.md — your project's coding standards.
+    Every /add, /fix, /refactor, /audit, /test, /doc, /blueprint reads this before writing code.
+```
+
 If no specs found:
 ```
   · No feature specs found.
@@ -193,9 +204,9 @@ If no specs found:
     Spec-first workflow: /spec → /clarify → /blueprint → /copilot
 ```
 
-If both exist:
+If all three exist:
 ```
-  ✓ Constitution and specs found. Ready for /copilot.
+  ✓ Constitution, coding rules, and specs found. Ready for /copilot.
 ```
 
 ---

package/templates/commands/test.md

@@ -16,6 +16,18 @@ $ARGUMENTS
 
 ---
 
+## Pre-Flight: Code Rules Check
+
+```bash
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
+```
+
+If code-rules found: read the `## Testing` section before writing or interpreting any tests.
+Apply: TDD philosophy (mandatory / optional / test-after), test naming convention, coverage targets.
+If writing new tests: follow the naming pattern from code-rules, not generic conventions.
+
+---
+
 ## Step 1: IDE Diagnostics First
 
 Use `mcp__ide__getDiagnostics` if available.