azclaude-copilot 0.4.22 → 0.4.24

package/.claude-plugin/marketplace.json

@@ -8,8 +8,8 @@
   "plugins": [
     {
       "name": "azclaude",
-      "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 33 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 — 102-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.22",
+      "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 34 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 — 102-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.23",
       "source": {
         "source": "github",
         "repo": "haytamAroui/AZ-CLAUDE-COPILOT",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "azclaude",
-  "version": "0.4.22",
-  "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 33 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 — 102-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.23",
+  "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 34 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 — 102-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",
     "url": "https://github.com/haytamAroui"

package/README.md

@@ -61,7 +61,7 @@ AZCLAUDE inverts this. **You start with almost nothing. The environment builds i
 npx azclaude-copilot@latest   # one command. that's it.
 ```
 
-No agent files to write. No skills to configure. No prompt engineering. `npx azclaude-copilot` installs 33 commands, 4 hooks, memory structure, and a manifest. The rest is generated from your actual codebase as you work. Run the same command again later — it auto-detects whether to skip, install, or upgrade.
+No agent files to write. No skills to configure. No prompt engineering. `npx azclaude-copilot` installs 34 commands, 4 hooks, memory structure, and a manifest. The rest is generated from your actual codebase as you work. Run the same command again later — it auto-detects whether to skip, install, or upgrade.
 
 **What the environment looks like across sessions:**
 
@@ -117,7 +117,7 @@ npx azclaude-copilot@latest
 ```
 
 That's it. One command, no flags. Auto-detects whether this is a fresh install or an upgrade:
-- **First time** → full install (33 commands, 4 hooks, 15 agents, 9 skills, memory, reflexes)
+- **First time** → full install (34 commands, 4 hooks, 15 agents, 9 skills, memory, reflexes)
 - **Already installed, older version** → auto-upgrades everything to latest templates
 - **Already up to date** → verifies, no overwrites
 
@@ -129,7 +129,7 @@ npx azclaude-copilot@latest doctor   # 32 checks — verify everything is wired
 
 ## What You Get
 
-**33 commands** · **9 auto-invoked skills** · **15 agents** · **4 hooks** · **memory across sessions** · **learned reflexes** · **self-evolving environment**
+**34 commands** · **9 auto-invoked skills** · **15 agents** · **4 hooks** · **memory across sessions** · **learned reflexes** · **self-evolving environment**
 
 ```
 .claude/
@@ -807,11 +807,11 @@ Run `/level-up` at any time to see your current level and build the next one.
 
 ## Verified
 
-1388 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: 1388 passed, 0 failed, 1388 total
+# Results: 1421 passed, 0 failed, 1421 total
 ```
 
 ---

package/bin/cli.js

@@ -8,7 +8,7 @@ const { execSync }  = require('child_process');
 
 const TEMPLATE_DIR = path.join(__dirname, '..', 'templates');
 const CORE_COMMANDS     = ['setup', 'fix', 'add', 'audit', 'test', 'blueprint', 'ship', 'pulse', 'explain', 'snapshot', 'persist'];
-const EXTENDED_COMMANDS = ['dream', 'refactor', 'doc', 'loop', 'migrate', 'deps', 'find', 'create', 'reflect', 'hookify', 'sentinel', 'clarify', 'spec', 'analyze', 'constitute', 'tasks', 'issues'];
+const EXTENDED_COMMANDS = ['dream', 'refactor', 'doc', 'loop', 'migrate', 'deps', 'find', 'create', 'reflect', 'hookify', 'sentinel', 'clarify', 'spec', 'analyze', 'constitute', 'tasks', 'issues', 'driven'];
 const ADVANCED_COMMANDS = ['evolve', 'debate', 'level-up', 'copilot', 'reflexes'];
 const COMMANDS          = [...CORE_COMMANDS, ...EXTENDED_COMMANDS, ...ADVANCED_COMMANDS];
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.4.22",
-  "description": "AI coding environment — 33 commands, 9 skills, 15 agents, memory, reflexes, evolution. Install: npx azclaude-copilot@latest, then open Claude Code.",
+  "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",
     "azclaude-copilot": "bin/copilot.js"

package/templates/CLAUDE.md

@@ -39,6 +39,7 @@ Extended (load command file on use):
   - /analyze: cross-artifact consistency check (ghost milestones, spec vs. code drift)
   - /tasks: dependency graph + parallel wave groups from plan.md
   - /issues: convert plan.md milestones to GitHub Issues
+- Standards: /driven → generates .claude/code-rules.md (coding contract for /add and /fix)
 
 Advanced (Level 5+):
 - /evolve · /debate · /level-up
@@ -52,4 +53,4 @@ When priorities conflict:
 3. {{PRIORITY_3}}
 
 ## Available Commands
-/dream · /setup · /fix · /add · /audit · /test · /blueprint · /evolve · /debate · /snapshot · /persist · /level-up · /ship · /pulse · /explain · /loop · /refactor · /doc · /migrate · /deps · /find · /create · /reflect · /hookify · /spec · /clarify · /analyze · /constitute · /tasks · /issues
+/dream · /setup · /fix · /add · /audit · /test · /blueprint · /evolve · /debate · /snapshot · /persist · /level-up · /ship · /pulse · /explain · /loop · /refactor · /doc · /migrate · /deps · /find · /create · /reflect · /hookify · /spec · /clarify · /analyze · /constitute · /tasks · /issues · /driven

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/add.md

@@ -18,12 +18,15 @@ Load: shared/tdd.md + shared/completion-rule.md
 
 ---
 
-## Pre-Flight: Constitution + Spec Check
+## Pre-Flight: Constitution + Code Rules + Spec Check
 
 ```bash
 # Check constitution
 [ -f .claude/constitution.md ] && echo "constitution=found" || echo "no constitution"
 
+# Check coding contract
+[ -f .claude/code-rules.md ] && echo "code-rules=found" || echo "no code-rules"
+
 # Check if $ARGUMENTS is a spec file
 [ -f "$ARGUMENTS" ] && grep -q "Acceptance Criteria" "$ARGUMENTS" && echo "spec-mode" || echo "inline-mode"
 ```
@@ -32,6 +35,10 @@ Load: shared/tdd.md + shared/completion-rule.md
 Read `## Non-Negotiables` and `## Required Patterns` before implementing.
 Keep these rules visible throughout Phases 2-4. Flag any implementation choice that would violate them.
 
+**If code-rules found:**
+Read `.claude/code-rules.md` — apply the relevant sections (language, framework, testing, naming) while implementing.
+If a coding choice would violate a rule, flag it before writing the code — do not silently deviate.
+
 **If spec file provided** (e.g., `/add .claude/specs/02-payment.md`):
 - Skip Phase 1 clarification — the spec IS the clarification
 - Load acceptance criteria as the implementation checklist

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/driven.md

@@ -0,0 +1,228 @@
+---
+name: driven
+description: >
+  Generate or update the project coding rules contract (.claude/code-rules.md).
+  Asks 6 questions about architecture, testing, code style, strictness, documentation,
+  and git conventions — then generates a precise DO/DO NOT rule file tailored to
+  the detected stack. Every /add and /fix reads this file before writing code.
+  Triggers on: "coding rules", "code rules", "set coding standards", "define standards",
+  "project standards", "how should we write code", "coding conventions", "code style",
+  "what are the rules", "driven development", "project coding contract", "style guide",
+  "coding contract", "define conventions", "set our rules", "project rules for code".
+  Do NOT trigger for: governance/ethics/security rules (use /constitute), security audit (use /sentinel).
+argument-hint: "[blank to create | 'update' to modify a section | 'show' to print current rules]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Bash, Glob, Grep
+---
+
+# /driven — Build the Project Coding Contract
+
+$ARGUMENTS
+
+---
+
+## Purpose
+
+`.claude/code-rules.md` is the coding standards contract for this project.
+It is written once, updated explicitly, and read by every `/add` and `/fix` before writing code.
+
+**Precedence hierarchy — when conflicts arise:**
+```
+constitution.md  ← governance wins (security, architecture, forbidden deps)
+code-rules.md    ← style wins (syntax, naming, testing patterns, git format)
+```
+
+If a rule in `code-rules.md` contradicts `constitution.md` — flag the conflict to the user. Never resolve silently.
+
+---
+
+## Step 1: Check Existing State
+
+```bash
+# Check for existing rules
+cat .claude/code-rules.md 2>/dev/null | head -8
+
+# Read stack from CLAUDE.md
+grep -i "stack:" CLAUDE.md 2>/dev/null | head -3
+```
+
+**If $ARGUMENTS = "show":**
+Print `.claude/code-rules.md` in full and stop.
+
+**If $ARGUMENTS = "update":**
+- Show current `.claude/code-rules.md`
+- Use **AskUserQuestion**: "Which section to update? (architecture / testing / style / strictness / docs / git / naming)"
+- Re-run only that section's interview question
+- Overwrite only that section — leave the rest unchanged
+- Show the diff and stop
+
+**If `code-rules.md` exists and $ARGUMENTS is blank:**
+Use **AskUserQuestion**: "`.claude/code-rules.md` already exists. Regenerate from scratch, or run `/driven update` to modify one section?"
+- Regenerate → proceed to Step 2
+- Update → switch to update flow above
+
+**If no `code-rules.md`:** proceed to Step 2.
+
+---
+
+## Step 2: Detect Stack
+
+Read `CLAUDE.md` Stack field. If empty or missing, run detection:
+
+```bash
+[ -f package.json ] && node -e "const p=require('./package.json');const d={...p.dependencies,...p.devDependencies};console.log(Object.keys(d).join(' '))" 2>/dev/null | tr ' ' '\n' | grep -E "^react$|^next$|^express$|^fastify$|typescript" | head -5
+[ -f pyproject.toml ] && echo "python=yes"
+[ -f requirements.txt ] && echo "python=yes"
+```
+
+State the detected stack before starting the interview. Example:
+```
+Detected stack: React 19, TypeScript, Node/Express, PostgreSQL
+```
+
+---
+
+## Step 3: Interview — 6 Questions
+
+Use **AskUserQuestion** — one question at a time. Never ask all at once.
+Every question includes a **Default** option. If selected, use the industry-standard for the detected stack and note it in the file header.
+
+**Q1 — Architecture:**
+"What architecture pattern should this project follow?
+  1. Clean Architecture (layers: domain / use-cases / infrastructure)
+  2. DDD — Domain-Driven Design (aggregates, value objects, bounded contexts)
+  3. MVC (models / views / controllers)
+  4. Feature-based (co-locate everything per feature)
+  5. Hexagonal / Ports & Adapters
+  6. Default (recommended for your stack)"
+
+**Q2 — Testing:**
+"What is the testing philosophy?
+  1. TDD mandatory — write the failing test first, always
+  2. TDD optional — follow existing signals (CLAUDE.md rule + test files present)
+  3. Test-after — implement first, test after
+  4. No tests
+  5. Default"
+
+**Q3 — Code style:**
+"Functional, OOP, or mixed?
+  1. Functional — prefer pure functions, avoid classes, immutable data
+  2. OOP — class-based patterns, encapsulation, inheritance where appropriate
+  3. Mixed — functions for business logic, classes for infrastructure/services
+  4. Default"
+
+**Q4 — Strictness:**
+"How strict are the type/lint rules?
+  1. Strict — no `any`, all types explicit, no lint suppressions
+  2. Moderate — types where it matters, `any` allowed at boundaries
+  3. Pragmatic — types at system boundaries only
+  4. Default"
+
+**Q5 — Documentation:**
+"What documentation is required in code?
+  1. JSDoc / docstrings on all public functions and classes
+  2. Inline comments for complex logic only
+  3. None
+  4. Default"
+
+**Q6 — Git commit format:**
+"What commit message format?
+  1. Conventional commits — feat/fix/docs/refactor/test/chore(scope): description
+  2. Free-form — no enforced format
+  3. Custom — I'll specify the format
+  4. Default"
+
+If user selects Custom on Q6 → ask one follow-up: "What is your commit format? (example format)"
+
+---
+
+## Step 4: Conflict Check
+
+```bash
+[ -f .claude/constitution.md ] && echo "constitution=found" || echo "no constitution"
+```
+
+If constitution found: read `## Non-Negotiables` and `## Required Patterns`.
+Cross-check each interview answer against those sections.
+
+If conflict found, state it before generating:
+```
+CONFLICT DETECTED:
+  constitution.md requires: {X}
+  Your answer to Q{N}: {Y}
+
+Resolve before continuing:
+  (a) Keep the constitutional rule — I'll override your Q{N} answer
+  (b) Update /constitute to allow {Y} — run /constitute after this
+```
+
+Wait for user resolution before proceeding to Step 5.
+
+---
+
+## Step 5: Generate `.claude/code-rules.md`
+
+Write the file using answers from Step 3:
+
+```markdown
+# Code Rules — v1 (Generated {date})
+# Stack: {detected stack}
+# Architecture: {Q1} | Testing: {Q2} | Style: {Q3} | Strictness: {Q4}
+# NOTE: These rules guide AI generation. Align your linters/CI to match.
+# To update a section: /driven update | To regenerate: /driven
+
+---
+
+## Naming Conventions
+{stack-specific — e.g., for TypeScript/React:}
+- DO: variables and functions → camelCase
+- DO: components and classes → PascalCase
+- DO: constants → UPPER_SNAKE_CASE
+- DO: database tables and columns → snake_case
+- DO NOT: mix naming conventions within a layer
+
+## {Primary language — TypeScript / Python / etc.}
+{DO / DO NOT rules matching Q4 strictness}
+{Max 8 rules}
+
+## {Primary framework — React / Express / FastAPI / etc.}
+{DO / DO NOT rules matching Q1 architecture + Q3 style}
+{Max 8 rules}
+
+## Testing
+{DO / DO NOT rules matching Q2 philosophy}
+{Max 6 rules}
+
+## Documentation
+{DO / DO NOT rules matching Q5}
+{Max 4 rules}
+
+## Git
+{DO / DO NOT rules matching Q6}
+{Max 4 rules}
+```
+
+Rules for generation:
+- One rule per line. `DO:` or `DO NOT:` prefix only — no prose, no explanations.
+- Maximum 8 rules per section. If more exist, keep the 8 highest-impact ones.
+- Use the actual detected stack for section headings — not generic labels.
+- Default answers: use the industry standard for the detected stack, note `# Default` in the header.
+
+---
+
+## Step 6: Confirm
+
+Show:
+```
+Code rules written: .claude/code-rules.md
+Stack: {detected}
+Sections: {N} — naming · {lang} · {framework} · testing · docs · git
+Total rules: {count}
+Architecture: {Q1} | Testing: {Q2} | Style: {Q3}
+
+Every /add and /fix will now read this file before writing code.
+
+Suggested commit (do not run — confirm first):
+  git add .claude/code-rules.md
+  git commit -m "chore: add project coding rules contract"
+```

package/templates/commands/fix.md

@@ -14,16 +14,20 @@ Load: shared/tdd.md + shared/completion-rule.md before starting.
 
 ---
 
-## 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 `## Non-Negotiables` before fixing.
+If constitution found: read `## Non-Negotiables` before fixing.
 The fix must not violate a non-negotiable — a "fix" that breaks a project rule is not a fix.
 Flag any conflict explicitly before proceeding to Phase 1.
 
+If code-rules found: read `.claude/code-rules.md`.
+The fix must not introduce violations. If the bug itself was caused by a rule violation, note that in the root-cause checkpoint.
+
 ---
 
 ## Pre-Flight Analysis (intelligent-dispatch)

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.