cc-devflow 1.0.1

package/.claude/skills/constitution-guardian/SKILL.md

@@ -0,0 +1,306 @@
+---
+name: constitution-guardian
+description: Real-time Constitution compliance checker for devflow documents. Blocks partial implementations and hardcoded secrets during file editing.
+---
+
+# Constitution Guardian
+
+## Purpose
+Enforce CC-DevFlow Constitution compliance by detecting violations in real-time during document editing, preventing non-compliant content from being saved.
+
+**Trigger**: PreToolUse hook when editing devflow documents (PRD.md, EPIC.md, TASKS.md, TECH_DESIGN.md)
+
+## Enforcement Scope
+
+**Focus Articles** (Real-time prevention):
+- **Article I.1**: Quality First - No Partial Implementation
+- **Article III.1**: Security First - No Hardcoded Secrets
+
+**Note**: Full Constitution has 10 Articles. This guardrail focuses on the most critical real-time violations. Batch validation by `validate-constitution.sh` covers all Articles.
+
+## Violation Patterns
+
+### Article I.1: No Partial Implementation
+
+#### Pattern 1: TODO placeholders
+```markdown
+# ❌ BLOCKED
+## User Stories
+### US1: User Registration
+TODO later: Add email verification flow
+FIXME: Implement password strength validation
+```
+
+**Regex Patterns**:
+- `TODO.*later`
+- `FIXME`
+- `\[placeholder\]`
+- `// TODO:.*later`
+- `# FIXME:.*`
+
+#### Pattern 2: Simplified/Partial notes
+```markdown
+# ❌ BLOCKED
+## Implementation Notes
+This is simplified for now, complete implementation would require...
+```
+
+**Regex Pattern**: `simplified for now`
+
+#### Pattern 3: Version deferral
+```markdown
+# ❌ BLOCKED
+## Acceptance Criteria
+- [ ] Basic login (v1)
+- [ ] Remember me (defer to v2)
+```
+
+**Regex Pattern**: `defer to v\d|will complete in v\d`
+
+### Article III.1: No Hardcoded Secrets
+
+#### Pattern 1: Environment variables with secrets
+```markdown
+# ❌ BLOCKED
+## Configuration
+API_KEY=sk-abc123def456
+JWT_SECRET=mysecretkey123
+PASSWORD=admin123
+```
+
+**Regex Patterns**:
+- `API_KEY\s*=\s*['"]?[a-zA-Z0-9_-]{10,}`
+- `SECRET\s*=\s*['"]?[a-zA-Z0-9_-]+`
+- `PASSWORD\s*=\s*['"]?[^\s]+`
+- `TOKEN\s*=\s*['"]?[a-zA-Z0-9_-]{10,}`
+
+#### Pattern 2: Code snippets with hardcoded secrets
+```typescript
+// ❌ BLOCKED
+const config = {
+  apiKey: "sk-abc123def456",
+  dbPassword: "postgres123"
+};
+```
+
+**Regex Patterns**:
+- `apiKey:\s*['"][^'"]+['"]`
+- `password:\s*['"][^'"]+['"]`
+- `secret:\s*['"][^'"]+['"]`
+
+## Blocking Message
+
+When violation detected, PreToolUse hook returns **exit code 2** (blocks file save):
+
+```
+⚠️ BLOCKED - Constitution Violation
+
+Detected:
+- [Line 42] TODO placeholder (Article I.1 - No Partial Implementation)
+- [Line 58] Hardcoded API key (Article III.1 - No Hardcoded Secrets)
+
+📋 ACTION:
+1. Complete all TODOs/FIXMEs before saving
+2. Move secrets to environment variables (.env, not committed)
+3. Review .claude/constitution/project-constitution.md v2.0.0
+4. Run /flow-verify for comprehensive check
+
+Source: Constitution Articles I.1, III.1
+File: {file_path}
+
+Constitutional Basis:
+  Article I.1: "NO PARTIAL IMPLEMENTATION: Complete implementation or no implementation"
+  Article III.1: "NO HARDCODED SECRETS: Use environment variables or secret management"
+
+💡 SKIP: Add `@constitution-verified` comment or set SKIP_CONSTITUTION_CHECK=1
+```
+
+## Constitutional Basis
+
+### Article I: Quality First
+
+```yaml
+I.1 Complete Implementation Mandate:
+  Prohibition: Any form of partial implementation or placeholder code
+  Requirement: Complete implementation or no implementation
+  Examples:
+    ❌ Forbidden: "// TODO: Implement this later"
+    ❌ Forbidden: "// Simplified for now, will complete in v2"
+    ✅ Required: Fully functional, production-ready code
+```
+
+**Enforcement**:
+- **Generation time**: prd-writer, tech-architect, planner agents check output
+- **Edit time**: constitution-guardian guardrail blocks save (this skill)
+- **Phase completion**: validate-constitution.sh batch validation
+
+### Article III: Security First
+
+```yaml
+III.1 No Hardcoded Secrets:
+  Prohibited:
+    ❌ API_KEY = "sk-abc123..." in source code
+    ❌ PASSWORD = "admin123" in config files
+    ❌ JWT_SECRET embedded in code
+
+  Required:
+    ✅ Environment variables (.env files, not committed)
+    ✅ Secret management services (AWS Secrets Manager, etc.)
+    ✅ Configuration injection at runtime
+
+  Detection: Pre-push guard scans for secret patterns
+```
+
+**Enforcement**:
+- **Generation time**: All agents avoid secrets in generated docs
+- **Edit time**: constitution-guardian guardrail blocks save (this skill)
+- **Pre-push**: Git pre-push hook scans for secrets
+
+## Skip Conditions
+
+Users can bypass Constitution guardian in specific scenarios:
+
+### 1. Session Skip (One-time per session)
+- **Mechanism**: `sessionSkillUsed: true` in skill-rules.json
+- **Behavior**: Guardrail only triggers once per Claude session
+- **Use case**: User acknowledged violation, working on fix
+
+### 2. File Marker (Permanent skip for specific file)
+- **Marker**: Add `@constitution-verified` comment in document
+- **Example**:
+  ```markdown
+  <!-- @constitution-verified: Legacy doc migration, compliance review completed -->
+  ```
+- **Use case**: Legacy documentation, special cases
+
+### 3. Environment Variable (Temporary global skip)
+- **Variable**: `SKIP_CONSTITUTION_CHECK=1`
+- **Scope**: Current terminal session
+- **Use case**: Bulk imports, automated migrations
+
+## Relationship with Other Components
+
+### validate-constitution.sh (Script)
+- **Purpose**: Batch validation of all 10 Constitutional Articles
+- **Scope**: Complete document/codebase scan
+- **Timing**: Phase completion (e.g., /flow-prd Exit Gate)
+- **Articles**: I, II, III, IV, V, VI, VII, VIII, IX, X
+
+### constitution-guardian (Guardrail)
+- **Purpose**: Real-time prevention of critical violations
+- **Scope**: Single document being edited
+- **Timing**: During file editing (PreToolUse hook)
+- **Articles**: Focus on I.1, III.1 (most critical for documents)
+
+**Relationship**: **Complementary (互补)**
+- Guardrail: Real-time prevention (write-time, partial Articles)
+- Script: Batch validation (phase-time, all Articles)
+- Double insurance: Guardrail catches most issues, Script catches remaining
+
+### Constitution Document
+- **Source of Truth**: `.claude/constitution/project-constitution.md` v2.0.0
+- **Contains**: All 10 Articles with detailed rules
+- **This guardrail**: Extracts Articles I.1, III.1 prohibition rules only
+
+## Configuration
+
+In `.claude/skills/skill-rules.json`:
+
+```json
+{
+  "constitution-guardian": {
+    "type": "guardrail",
+    "enforcement": "block",
+    "priority": "critical",
+    "description": "Real-time Constitution compliance, extracted from Constitution v2.0.0",
+    "fileTriggers": {
+      "pathPatterns": [
+        "devflow/requirements/**/PRD.md",
+        "devflow/requirements/**/EPIC.md",
+        "devflow/requirements/**/TASKS.md",
+        "devflow/requirements/**/TECH_DESIGN.md",
+        "devflow/requirements/**/contracts/**/*.yaml",
+        "devflow/requirements/**/data-model.md"
+      ],
+      "contentPatterns": [
+        "TODO.*later",
+        "FIXME",
+        "\\[placeholder\\]",
+        "simplified for now",
+        "defer to v\\d",
+        "API_KEY\\s*=\\s*['\"]?[a-zA-Z0-9_-]{10,}",
+        "SECRET\\s*=\\s*['\"]?[a-zA-Z0-9_-]+",
+        "PASSWORD\\s*=\\s*['\"]?[^\\s]+",
+        "TOKEN\\s*=\\s*['\"]?[a-zA-Z0-9_-]{10,}",
+        "apiKey:\\s*['\"][^'\"]+['\"]",
+        "password:\\s*['\"][^'\"]+['\"]"
+      ]
+    },
+    "blockMessage": "⚠️ BLOCKED - Constitution Violation\n\nDetected:\n- Partial implementation (Article I.1)\n- Hardcoded secrets (Article III.1)\n\n📋 ACTION:\n1. Complete all TODOs/FIXMEs\n2. Move secrets to config system\n3. Run /flow-verify\n\nSource: .claude/constitution/project-constitution.md v2.0.0",
+    "skipConditions": {
+      "sessionSkillUsed": true,
+      "fileMarkers": ["@constitution-verified"],
+      "envOverride": "SKIP_CONSTITUTION_CHECK"
+    }
+  }
+}
+```
+
+## Line Number Reporting (Enhancement)
+
+**Goal**: Precise violation location reporting
+
+**Implementation** (in PreToolUse hook):
+```typescript
+function detectViolations(content: string, patterns: string[]) {
+  const lines = content.split('\n');
+  const violations: Array<{line: number, pattern: string, text: string}> = [];
+
+  lines.forEach((line, index) => {
+    patterns.forEach(pattern => {
+      if (new RegExp(pattern, 'i').test(line)) {
+        violations.push({
+          line: index + 1,
+          pattern: pattern,
+          text: line.trim()
+        });
+      }
+    });
+  });
+
+  return violations;
+}
+```
+
+**Enhanced Blocking Message**:
+```
+⚠️ BLOCKED - Constitution Violation
+
+Detected 3 violations:
+  [Line 42] TODO placeholder (Article I.1)
+    → "TODO later: Add email verification"
+
+  [Line 58] Hardcoded API key (Article III.1)
+    → "API_KEY=sk-abc123def456"
+
+  [Line 73] FIXME comment (Article I.1)
+    → "FIXME: Complete error handling"
+
+📋 ACTION: ...
+```
+
+## Design Principle
+
+**This guardrail does NOT contain**:
+- ❌ Complete Constitution (all 10 Articles are in project-constitution.md)
+- ❌ All violation patterns (only Articles I.1, III.1)
+- ❌ Batch validation logic (that's in validate-constitution.sh)
+
+**This guardrail ONLY contains**:
+- ✅ Articles I.1, III.1 prohibition rule extraction
+- ✅ Real-time violation detection (content pattern matching)
+- ✅ Blocking mechanism (PreToolUse hook, exit code 2)
+- ✅ Precise line number reporting
+- ✅ Links to full Constitution document
+
+**Rationale**: Avoid duplication ("不重不漏" principle). Constitution document owns full text, guardrail owns real-time enforcement of critical rules.

package/.claude/skills/devflow-constitution-quick-ref/SKILL.md

@@ -0,0 +1,374 @@
+---
+name: devflow-constitution-quick-ref
+description: Quick reference guide to CC-DevFlow Constitution v2.0.0 with links to full text. Covers all 10 Articles and Phase -1 Gates.
+---
+
+# DevFlow Constitution Quick Reference
+
+## Purpose
+Provide quick summaries of all 10 Constitutional Articles with links to full Constitution document. This skill does NOT duplicate the complete Constitution text.
+
+**Full Constitution**: [.claude/constitution/project-constitution.md](.claude/constitution/project-constitution.md) v2.0.0
+
+## Constitution Overview
+
+**Version**: v2.0.0
+**Effective Date**: 2025-01-10
+**Authority**: Supreme Priority, Inviolable, Persistent, Universal
+**Scope**: All requirements, all stages, all agents
+
+## Article I: Quality First (质量至上)
+
+### Summary
+Quality is the non-negotiable baseline.
+
+### Key Rules
+- **I.1**: NO PARTIAL IMPLEMENTATION (no TODO/FIXME placeholders)
+- **I.2**: Test coverage ≥80%
+- **I.3**: No "simplified for now" excuses
+- **I.4**: Must pass type checking, linting, security scanning, build verification
+
+### Enforcement
+- **Real-time**: constitution-guardian guardrail (blocks TODOs/FIXMEs)
+- **Batch**: validate-constitution.sh --type all
+- **Pre-push**: pre-push-guard.sh
+
+### Example Violations
+```markdown
+❌ "TODO later: Add email verification"
+❌ "// Simplified for now, will complete in v2"
+❌ "defer to v2"
+```
+
+**For Details**: See [Constitution Article I](.claude/constitution/project-constitution.md#article-i-quality-first-质量至上)
+
+---
+
+## Article II: Architectural Consistency (架构一致性)
+
+### Summary
+Maintain codebase uniformity and predictability.
+
+### Key Rules
+- **II.1**: No code duplication (search existing codebase first)
+- **II.2**: Consistent naming (follow existing patterns)
+- **II.3**: Anti-over-engineering (no BaseController, AbstractService)
+- **II.4**: Single responsibility (≤500 lines per file)
+
+### Enforcement
+- **Phase -1 Gates**: planner agent checks before EPIC generation
+- **Code review**: code-reviewer agent
+
+### Example Violations
+```typescript
+❌ class BaseController {}       // Over-abstraction
+❌ function helperManager() {}   // Vague naming
+❌ 800-line file                 // Exceeds limit
+```
+
+**For Details**: See [Constitution Article II](.claude/constitution/project-constitution.md#article-ii-architectural-consistency-架构一致性)
+
+---
+
+## Article III: Security First (安全优先)
+
+### Summary
+Security is foundational, not an afterthought.
+
+### Key Rules
+- **III.1**: NO HARDCODED SECRETS (use env variables)
+- **III.2**: All inputs must be validated BEFORE processing
+- **III.3**: Principle of least privilege (deny by default)
+- **III.4**: Secure by default (HTTPS, CORS whitelist, auth required)
+
+### Enforcement
+- **Real-time**: constitution-guardian guardrail (blocks hardcoded secrets)
+- **Pre-push**: pre-push-guard.sh scans for secret patterns
+- **QA**: security-reviewer agent
+
+### Example Violations
+```typescript
+❌ const API_KEY = "sk-abc123..."    // Hardcoded
+❌ const PASSWORD = "admin123"       // Hardcoded
+```
+
+**For Details**: See [Constitution Article III](.claude/constitution/project-constitution.md#article-iii-security-first-安全优先)
+
+---
+
+## Article IV: Performance Accountability (性能责任)
+
+### Summary
+Performance is user experience; proactive optimization required.
+
+### Key Rules
+- **IV.1**: No resource leaks (always close connections)
+- **IV.2**: Algorithm efficiency (avoid O(n²) when O(n) exists)
+- **IV.3**: Lazy loading (pagination for large datasets)
+- **IV.4**: Intelligent caching (with TTL and invalidation)
+
+### Enforcement
+- **QA**: qa-tester agent includes performance profiling
+- **Code review**: code-reviewer agent checks resource management
+
+### Example Violations
+```typescript
+❌ loadAllUsers()                    // Loads 1M users into memory
+❌ nested loops over same dataset    // O(n²)
+❌ no connection.close()             // Resource leak
+```
+
+**For Details**: See [Constitution Article IV](.claude/constitution/project-constitution.md#article-iv-performance-accountability-性能责任)
+
+---
+
+## Article V: Maintainability (可维护性)
+
+### Summary
+Code must be understandable, modifiable, and extensible.
+
+### Key Rules
+- **V.1**: No dead code (delete unused imports, commented code)
+- **V.2**: Separation of concerns (models, services, controllers, views)
+- **V.3**: Documentation mandate (complex algorithms, business logic)
+- **V.4**: File size limits (≤500 lines per file, ≤50 lines per function)
+
+### Enforcement
+- **Linting**: ESLint, Pylint rules
+- **Code review**: code-reviewer agent
+
+### Example Violations
+```typescript
+❌ // Commented-out code block    // Dead code
+❌ Unused import statements         // Dead code
+❌ 800-line function               // Exceeds limit
+```
+
+**For Details**: See [Constitution Article V](.claude/constitution/project-constitution.md#article-v-maintainability-可维护性)
+
+---
+
+## Article VI: Test-First Development (测试优先开发)
+
+### Summary
+Tests define behavior; implementation makes tests pass.
+
+### Key Rules
+- **VI.1**: TDD mandate (write tests FIRST, tests MUST fail initially)
+- **VI.2**: Test independence (each test runs in isolation)
+- **VI.3**: Meaningful tests (no `assert True`, test actual behavior)
+
+### Enforcement
+- **Real-time**: devflow-tdd-enforcer guardrail (blocks TDD violations)
+- **TASKS.md**: TEST VERIFICATION CHECKPOINT between Phase 2 and Phase 3
+- **planner agent**: Generates TASKS.md with TDD order
+
+### TDD Sequence
+```
+Phase 2: Write Tests FIRST ⚠️
+  → All tests MUST fail initially
+  → TEST VERIFICATION CHECKPOINT
+
+Phase 3: Write Implementation
+  → Goal: Make tests pass
+```
+
+**For Details**: See [Constitution Article VI](.claude/constitution/project-constitution.md#article-vi-test-first-development-测试优先开发)
+
+---
+
+## Article VII: Simplicity Gate (简单性闸门)
+
+### Summary
+Default to simplicity; complexity requires justification.
+
+### Key Rules (Phase -1 Gates)
+- **VII.1**: Maximum project count ≤3 simultaneously
+- **VII.2**: Minimal dependencies (use standard library when possible)
+- **VII.3**: Vertical slice first (full feature before next feature)
+- **VII.4**: Direct framework usage (avoid custom abstractions)
+
+### Enforcement
+- **Phase -1 Gates**: planner agent enforces BEFORE generating EPIC
+- **EPIC.md**: Contains "Phase -1 Simplicity Gate" check section
+
+### Example Violations
+```yaml
+❌ 5 projects in scope                    # Exceeds limit
+❌ Adding new framework for simple task   # Over-dependency
+❌ Custom ORM wrapper                     # Unnecessary abstraction
+```
+
+**For Details**: See [Constitution Article VII](.claude/constitution/project-constitution.md#article-vii-simplicity-gate-简单性闸门)
+
+---
+
+## Article VIII: Anti-Abstraction (反抽象化)
+
+### Summary
+Prefer concrete code over abstractions until three+ use cases proven.
+
+### Key Rules (Phase -1 Gates)
+- **VIII.1**: No premature abstraction (Rule of Three)
+- **VIII.2**: No generic layers (no GenericService<T>)
+- **VIII.3**: Direct framework usage (Express, FastAPI, Flask)
+- **VIII.4**: Inline before extract (copy-paste OK until 3rd repetition)
+
+### Enforcement
+- **Phase -1 Gates**: planner agent enforces BEFORE generating EPIC
+- **EPIC.md**: Contains "Phase -1 Anti-Abstraction Gate" check section
+
+### Example Violations
+```typescript
+❌ class BaseController {}              // Premature abstraction
+❌ GenericRepository<T>                 // Generic layer
+❌ Custom framework wrapper             // Over-abstraction
+```
+
+**For Details**: See [Constitution Article VIII](.claude/constitution/project-constitution.md#article-viii-anti-abstraction-反抽象化)
+
+---
+
+## Article IX: Integration-First Testing (集成优先测试)
+
+### Summary
+Test contracts/integrations before internal logic.
+
+### Key Rules (Phase -1 Gates)
+- **IX.1**: Contract tests first (API contracts, GraphQL schemas)
+- **IX.2**: Integration tests before unit tests (test boundaries first)
+- **IX.3**: Test external dependencies (database, APIs, queues)
+- **IX.4**: E2E critical paths (happy path + error path)
+
+### Enforcement
+- **Phase -1 Gates**: planner agent enforces BEFORE generating EPIC
+- **TASKS.md Phase 2**: Lists contract/integration tests FIRST
+- **TEST VERIFICATION CHECKPOINT**: Ensures Phase 2 tests run before Phase 3
+
+### Test Order
+```
+1. Contract tests (API contracts, GraphQL)
+2. Integration tests (DB, external APIs)
+3. E2E tests (critical user paths)
+4. Unit tests (internal logic)
+```
+
+**For Details**: See [Constitution Article IX](.claude/constitution/project-constitution.md#article-ix-integration-first-testing-集成优先测试)
+
+---
+
+## Article X: Requirement Boundary (需求边界)
+
+### Summary
+Prevent scope creep; enforce strict requirement boundaries.
+
+### Key Rules
+- **X.1**: One REQ-ID, one bounded context (no "also add X")
+- **X.2**: No feature expansion during implementation
+- **X.3**: Separate REQ-IDs for separate concerns
+- **X.4**: Explicit scope documentation in PRD.md
+
+### Enforcement
+- **PRD generation**: prd-writer agent enforces Anti-Expansion mandate
+- **Scope validation**: validate-scope-boundary.sh
+- **Code review**: code-reviewer agent checks for scope violations
+
+### Example Violations
+```markdown
+❌ PRD.md: "User Registration (also add social login)"    # Scope creep
+❌ Adding unplanned features during /flow-dev             # Feature expansion
+```
+
+**For Details**: See [Constitution Article X](.claude/constitution/project-constitution.md#article-x-requirement-boundary-需求边界)
+
+---
+
+## Phase -1 Gates
+
+**Executed by**: planner agent BEFORE generating EPIC and TASKS
+
+### Gate 1: Simplicity Check (Article VII)
+- [ ] Project count ≤3
+- [ ] Minimal dependencies
+- [ ] Vertical slice approach
+- [ ] Direct framework usage
+
+### Gate 2: Anti-Abstraction Check (Article VIII)
+- [ ] No premature abstractions
+- [ ] No generic layers
+- [ ] Inline before extract
+- [ ] Direct framework calls
+
+### Gate 3: Integration-First Check (Article IX)
+- [ ] Contract tests listed first
+- [ ] Integration tests before unit tests
+- [ ] External dependency tests included
+- [ ] E2E critical paths covered
+
+**Documented in**: EPIC.md contains "Phase -1 Gates" check section
+
+**For Details**: See [planner agent](.claude/agents/planner.md) Phase -1 Gates Enforcement Sequence
+
+---
+
+## Enforcement Summary
+
+| Article | Real-time Guardrail | Phase Gate | Batch Validation | Pre-push |
+|---------|---------------------|------------|------------------|----------|
+| I       | constitution-guardian | prd/tech/epic Exit | validate-constitution.sh | ✓ |
+| II      | —                   | Phase -1 (planner) | validate-constitution.sh | — |
+| III     | constitution-guardian | — | validate-constitution.sh | ✓ |
+| IV      | —                   | — | validate-constitution.sh (QA) | — |
+| V       | —                   | — | Linting + code review | — |
+| VI      | devflow-tdd-enforcer | TEST VERIFICATION | validate-constitution.sh | — |
+| VII     | —                   | Phase -1 (planner) | validate-constitution.sh | — |
+| VIII    | —                   | Phase -1 (planner) | validate-constitution.sh | — |
+| IX      | —                   | Phase -1 (planner) | validate-constitution.sh | — |
+| X       | —                   | PRD generation | validate-scope-boundary.sh | — |
+
+---
+
+## Quick Lookup by Scenario
+
+### Scenario: "Can I add TODO for later?"
+**Answer**: ❌ NO (Article I.1 - No Partial Implementation)
+**Guardrail**: constitution-guardian blocks save
+**Alternative**: Complete implementation now, or remove from scope
+
+### Scenario: "Should I create BaseController?"
+**Answer**: ❌ NO (Article II.3, VIII.2 - Anti-Abstraction)
+**Phase Gate**: Phase -1 Gates block EPIC generation
+**Alternative**: Use framework directly (Express, FastAPI)
+
+### Scenario: "Can I hardcode API_KEY for testing?"
+**Answer**: ❌ NO (Article III.1 - No Hardcoded Secrets)
+**Guardrail**: constitution-guardian blocks save
+**Alternative**: Use .env file with dotenv library
+
+### Scenario: "Should I write implementation first?"
+**Answer**: ❌ NO (Article VI.1 - TDD Mandate)
+**Guardrail**: devflow-tdd-enforcer blocks TASKS.md edit
+**Sequence**: Write failing test FIRST, then implementation
+
+### Scenario: "Can I add social login to user registration?"
+**Answer**: ❌ NO (Article X.1 - Requirement Boundary)
+**Enforcement**: prd-writer agent Anti-Expansion mandate
+**Alternative**: Create separate REQ-ID for social login
+
+---
+
+## Design Principle
+
+**This skill does NOT contain**:
+- ❌ Complete Constitution text (that's in project-constitution.md)
+- ❌ Detailed Article explanations (that's in full Constitution)
+- ❌ Implementation guidelines (those are in agent files)
+
+**This skill ONLY contains**:
+- ✅ Article summaries (quick reference)
+- ✅ Key rules and examples
+- ✅ Enforcement mechanisms
+- ✅ Links to full Constitution document
+- ✅ Quick lookup by scenario
+
+**Rationale**: Avoid duplication ("不重不漏" principle). Constitution document owns full text, this skill owns quick reference and routing.