cc-devflow 1.0.3 → 2.4.0

package/.claude/skills/flow-tdd/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: flow-tdd
+description: "Enforces TDD Iron Law in flow-dev. NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST."
+---
+
+# Flow TDD - Test-Driven Development Enforcement
+
+## The Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+This is NON-NEGOTIABLE. No exceptions. No "just this once."
+
+## The TDD Cycle
+
+```
+RED:    Write a failing test
+        → Run it
+        → Confirm it FAILS
+        → If it passes immediately → ERROR (invalid test)
+
+GREEN:  Write minimal code to pass
+        → Only enough to make the test pass
+        → No extra features
+        → No "while I'm here" additions
+
+REFACTOR: Clean up
+        → Keep tests green
+        → Improve structure
+        → Remove duplication
+```
+
+## Enforcement in flow-dev
+
+### Phase 2: Tests First
+
+```yaml
+TASKS.md Phase 2 (Tests):
+  - Write contract tests
+  - Write integration tests
+  - Write unit tests
+  - Run all tests → ALL MUST FAIL
+
+⚠️ TEST VERIFICATION CHECKPOINT:
+  → Run: npm test (or equivalent)
+  → Expected: All new tests FAIL
+  → If any test passes immediately → STOP
+  → Passing test = invalid test or code already exists
+```
+
+### Phase 3: Implementation
+
+```yaml
+TASKS.md Phase 3 (Implementation):
+  - Implement to make tests pass
+  - One test at a time
+  - Minimal code only
+
+After each implementation:
+  → Run tests
+  → Verify previously failing test now passes
+  → Verify no regressions
+```
+
+## What If Code Already Exists?
+
+If you've written code before tests:
+
+```yaml
+Option A: DELETE AND RESTART (Recommended)
+  1. Delete the implementation code
+  2. Keep only the interface/contract
+  3. Write failing tests
+  4. Re-implement with TDD
+
+Option B: WRITE TESTS THAT FAIL FIRST
+  1. Comment out the implementation
+  2. Write tests
+  3. Run tests → verify they fail
+  4. Uncomment implementation
+  5. Run tests → verify they pass
+
+NEVER: Keep code and write passing tests
+  → This is "testing after" disguised as TDD
+  → Tests that pass immediately prove nothing
+```
+
+## Rationalization Prevention
+
+| Excuse | Reality |
+|--------|---------|
+| "Too simple to test" | Simple code breaks. Test takes 30 seconds. |
+| "I'll test after" | Tests passing immediately prove nothing. |
+| "Tests after achieve same goals" | Tests-after = "what does this do?" Tests-first = "what should this do?" |
+| "Already manually tested" | Ad-hoc ≠ systematic. No record, can't re-run. |
+| "Deleting X hours is wasteful" | Sunk cost fallacy. Keeping unverified code is technical debt. |
+| "Keep as reference, write tests first" | You'll adapt it. That's testing after. Delete means delete. |
+| "Need to explore first" | Fine. Throw away exploration, start with TDD. |
+| "Test hard = design unclear" | Listen to test. Hard to test = hard to use. |
+| "TDD slows me down" | TDD faster than debugging. Pragmatic = test-first. |
+| "This is different because..." | No. This is rationalization. Follow the law. |
+| "Spirit not letter" | Violating letter IS violating spirit. No loopholes. |
+| "I'm being pragmatic, not dogmatic" | TDD IS pragmatic. Shortcuts = debugging in production = slower. |
+| "Just this once" | No exceptions. Rules exist for this exact moment. |
+
+## Red Flags - STOP
+
+If you find yourself:
+- Writing code before tests
+- Tests passing immediately
+- Saying "just this once"
+- Keeping "exploration" code
+- Writing tests that describe existing code
+
+**STOP. Delete the code. Write the test first.**
+
+## Test Quality Requirements
+
+```yaml
+Good Tests:
+  ✅ Test behavior, not implementation
+  ✅ Use realistic data
+  ✅ Cover edge cases
+  ✅ Independent (no shared state)
+  ✅ Fast (< 1 second each)
+  ✅ Descriptive names
+
+Bad Tests (Cheater Tests):
+  ❌ assert True
+  ❌ assert result is not None
+  ❌ Mock everything, test nothing
+  ❌ Test implementation details
+  ❌ Depend on execution order
+```
+
+## Error Recording Protocol
+
+当测试失败或构建错误发生时，必须立即记录到 ERROR_LOG.md:
+
+```yaml
+Error Recording Workflow:
+  1. Capture Error Context:
+     - Phase (flow-dev / T###)
+     - Error Type (Test Failure | Build Error | Runtime Error)
+     - Full error message
+     - Timestamp
+
+  2. Create ERROR_LOG.md if not exists:
+     → Use .claude/docs/templates/ERROR_LOG_TEMPLATE.md
+     → Location: devflow/requirements/${REQ_ID}/ERROR_LOG.md
+
+  3. Append Error Record:
+     ## [TIMESTAMP] E###: TITLE
+     **Phase**: flow-dev / T###
+     **Error Type**: Test Failure
+     **Error Message**:
+     ```
+     [完整错误信息]
+     ```
+     **Root Cause**: [分析后填写]
+     **Resolution**: [解决后填写]
+     **Prevention**: [可选]
+
+  4. Debug with Error Context:
+     → Read ERROR_LOG.md for similar past errors
+     → Apply attention refresh (Protocol 4)
+     → Fix the root cause, not symptoms
+
+  5. Update Record After Fix:
+     → Fill Root Cause
+     → Fill Resolution
+     → Add Prevention if applicable
+```
+
+### Error Recording Example
+
+```markdown
+## [2026-01-08T14:30:00] E001: Test Failure - User Login Validation
+
+**Phase**: flow-dev / T005
+**Error Type**: Test Failure
+**Error Message**:
+\`\`\`
+FAIL src/auth/login.test.ts
+  × should reject invalid email format
+    Expected: false
+    Received: true
+\`\`\`
+
+**Root Cause**: 正则表达式 `/^.+@.+$/` 过于宽松，接受了 `user@` 这样的无效邮箱
+**Resolution**: 更新正则为 `/^[^\s@]+@[^\s@]+\.[^\s@]+$/` 要求至少有域名和顶级域
+**Prevention**: 扩充测试用例，添加边界情况（无域名、无顶级域、特殊字符等）
+```
+
+## Integration with Constitution
+
+- **Article I**: Complete implementation includes tests
+- **Article VI**: TDD Mandate (this skill)
+- **Article IX**: Integration-first testing
+
+## Integration with Attention Refresh
+
+- **Protocol 4**: Error Recovery 时读取 ERROR_LOG.md
+- 避免重复犯相同错误
+- 从历史错误中学习
+
+## Cross-Reference
+
+- [flow-attention-refresh](../flow-attention-refresh/SKILL.md) - Protocol 4
+- [ERROR_LOG_TEMPLATE.md](../../docs/templates/ERROR_LOG_TEMPLATE.md)
+- [rationalization-library.md](../../rules/rationalization-library.md#article-vi-test-first-development---rationalization-table)
+- [project-constitution.md](../../rules/project-constitution.md#article-vi-test-first-development-测试优先开发)
+
+---
+
+**[PROTOCOL]**: 变更时更新此头部，然后检查 CLAUDE.md

package/.claude/skills/fractal-docs-generator/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: fractal-docs-generator
+description: 目录级 CLAUDE.md 生成。触发：mkdir、create directory、目录结构变更。
+---
+
+# 分形文档生成器
+
+触发：创建/移动/重命名目录，目录内文件变化。
+
+## 模板
+
+```markdown
+<!-- 若此目录变更，立即更新本文件 -->
+# {目录名} - {一句话定位}
+
+| 文件 | 地位 | 职责 |
+|------|------|------|
+| foo.ts | 入口 | 对外唯一接口 |
+```
+
+## 地位
+
+| 地位 | 典型文件 |
+|------|----------|
+| 入口 | index.ts, main.ts |
+| 核心 | service.ts, engine.ts |
+| 辅助 | utils.ts, helpers.ts |
+| 类型 | types.ts |
+| 配置 | config.ts |
+| 测试 | *.test.ts |
+
+## 示例
+
+```markdown
+<!-- 若此目录变更，立即更新本文件 -->
+# auth - 认证授权
+
+| 文件 | 地位 | 职责 |
+|------|------|------|
+| index.ts | 入口 | 导出 AuthService |
+| auth.service.ts | 核心 | 登录、令牌刷新 |
+| jwt.helper.ts | 辅助 | JWT 签发验证 |
+```
+
+协作：本 skill 管目录，file-header-guardian 管文件。

package/.claude/skills/skill-rules.json

@@ -129,6 +129,81 @@
                 "envOverride": "SKIP_CONSTITUTION_CHECK"
             }
         },
+        "fractal-docs-generator": {
+            "type": "domain",
+            "enforcement": "suggest",
+            "priority": "high",
+            "description": "分形文档生成器。创建目录时自动生成目录级 CLAUDE.md，实现 GEB 式递归架构文档",
+            "promptTriggers": {
+                "keywords": [
+                    "创建目录",
+                    "新建文件夹",
+                    "mkdir",
+                    "add folder",
+                    "create directory",
+                    "目录结构",
+                    "CLAUDE.md",
+                    "架构文档",
+                    "分形文档"
+                ],
+                "intentPatterns": [
+                    "(创建|新建|添加).*?(目录|文件夹|folder|directory)",
+                    "(mkdir|create|add).*?(folder|directory|dir)",
+                    "目录.*?(结构|变更|调整)",
+                    "(更新|同步).*?CLAUDE\\.md"
+                ]
+            },
+            "fileTriggers": {
+                "pathPatterns": [
+                    "**/CLAUDE.md"
+                ]
+            }
+        },
+        "file-header-guardian": {
+            "type": "domain",
+            "enforcement": "suggest",
+            "priority": "high",
+            "description": "文件头注释守护者。创建/修改代码文件时确保 @input/@output/@pos 三行契约注释存在",
+            "promptTriggers": {
+                "keywords": [
+                    "创建文件",
+                    "新建文件",
+                    "write file",
+                    "create file",
+                    "add file",
+                    "文件头注释",
+                    "头注释",
+                    "@input",
+                    "@output",
+                    "@pos"
+                ],
+                "intentPatterns": [
+                    "(创建|新建|添加|编写).*?(文件|模块|组件)",
+                    "(create|write|add).*?(file|module|component)",
+                    "(检查|更新|添加).*?(头注释|header comment)",
+                    "文件.*?(注释|documentation)"
+                ]
+            },
+            "fileTriggers": {
+                "pathPatterns": [
+                    "**/*.ts",
+                    "**/*.tsx",
+                    "**/*.js",
+                    "**/*.jsx",
+                    "**/*.py",
+                    "**/*.go",
+                    "**/*.rs",
+                    "**/*.sh"
+                ],
+                "pathExclusions": [
+                    "**/*.test.ts",
+                    "**/*.spec.ts",
+                    "**/*.d.ts",
+                    "**/node_modules/**",
+                    "**/.claude/**"
+                ]
+            }
+        },
         "devflow-file-standards": {
             "type": "domain",
             "enforcement": "suggest",

package/.claude/skills/verification-before-completion/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: verification-before-completion
+description: "Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always"
+---
+
+# Verification Before Completion
+
+## Overview
+
+This skill enforces a critical discipline: **never claim completion without fresh verification evidence**.
+
+The most common failure mode for AI agents is claiming success without actually verifying. This skill prevents that by requiring explicit verification steps before any completion claim.
+
+## The Iron Law
+
+```
+NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
+```
+
+## The Process
+
+### Before ANY Completion Claim
+
+```
+1. IDENTIFY: What command proves this claim?
+   → "Tests pass" requires: npm test / pytest / go test
+   → "Build succeeds" requires: npm run build / make
+   → "Lint clean" requires: npm run lint / eslint
+   → "Type check passes" requires: tsc --noEmit / mypy
+
+2. RUN: Execute the FULL command (fresh, complete)
+   → Not cached results
+   → Not partial output
+   → Not "I ran it earlier"
+
+3. READ: Full output, check exit code, count failures
+   → Exit code 0 = success
+   → Exit code non-zero = failure
+   → Count actual pass/fail numbers
+
+4. VERIFY: Does output confirm the claim?
+   → "All tests pass" = 0 failures in output
+   → "Build succeeds" = no errors, artifacts created
+   → "No lint errors" = 0 problems found
+
+5. ONLY THEN: Make the claim with evidence
+   → Quote the relevant output
+   → Include exit code
+   → Show pass/fail counts
+```
+
+## Verification Commands by Context
+
+### Flow Exit Gates
+
+| Flow | Verification Command | Success Criteria |
+|------|---------------------|------------------|
+| /flow-prd | `validate-constitution --type prd` | Exit 0, no violations |
+| /flow-epic | `validate-constitution --type epic` | Exit 0, no violations |
+| /flow-dev | `npm test && npm run build` | All tests pass, build succeeds |
+| /flow-qa | `npm test && npm run lint` | All pass, no blockers |
+| /flow-release | `gh pr checks` | All checks pass |
+
+### Common Development Tasks
+
+| Claim | Required Verification |
+|-------|----------------------|
+| "Tests pass" | Run full test suite, show output |
+| "Build succeeds" | Run build command, show output |
+| "Lint clean" | Run linter, show 0 errors |
+| "Type check passes" | Run type checker, show output |
+| "No regressions" | Run affected tests, compare before/after |
+| "Bug fixed" | Show failing test → fix → passing test |
+
+## Rationalization Prevention
+
+| Excuse | Reality |
+|--------|---------|
+| "I just ran it" | Run it again. Fresh evidence required. |
+| "It was passing before" | Before ≠ now. Verify current state. |
+| "The change is trivial" | Trivial changes break things. Verify. |
+| "I'm confident it works" | Confidence ≠ evidence. Run the command. |
+| "Tests are slow" | Slow tests > broken production. Run them. |
+| "I'll verify after commit" | Verify BEFORE commit. Always. |
+| "The CI will catch it" | You catch it first. Don't waste CI cycles. |
+| "It's just documentation" | Doc changes can break builds. Verify. |
+
+## Red Flags - STOP
+
+If you find yourself:
+- Saying "should work" without running verification
+- Claiming "tests pass" without showing output
+- Saying "I believe" instead of "I verified"
+- Skipping verification "just this once"
+- Trusting cached or stale results
+
+**STOP. Run the verification command. Show the evidence.**
+
+## Evidence Format
+
+When claiming completion, always include:
+
+```markdown
+## Verification Evidence
+
+**Command**: `npm test`
+**Exit Code**: 0
+**Output Summary**:
+- Tests: 42 passed, 0 failed
+- Coverage: 85%
+- Duration: 12.3s
+
+**Conclusion**: All tests pass. Ready for commit.
+```
+
+## Integration with CC-DevFlow
+
+### Every Flow Exit Gate
+
+```yaml
+Exit Gate Verification:
+  1. Identify required verification commands
+  2. Run each command fresh
+  3. Capture full output
+  4. Verify success criteria met
+  5. Document evidence in EXECUTION_LOG.md
+  6. Only then proceed to next stage
+```
+
+### Task Completion
+
+```yaml
+Task Completion Verification:
+  1. Run task-specific tests
+  2. Verify acceptance criteria met
+  3. Show evidence in task completion message
+  4. Mark task complete only with evidence
+```
+
+## The Discipline
+
+This skill is about **intellectual honesty**. It's easy to believe something works. It's harder to prove it.
+
+The discipline is:
+1. **Assume nothing** - Don't trust memory or intuition
+2. **Verify everything** - Run the actual commands
+3. **Show evidence** - Quote output, not beliefs
+4. **Fresh results only** - No stale or cached data
+
+## Cross-Reference
+
+- Constitution Article I: Quality First (complete implementation)
+- Constitution Article VI: Test-First Development (TDD)
+- rationalization-library.md: Cross-Article rationalizations
+
+---
+
+**[PROTOCOL]**: 变更时更新此头部，然后检查 CLAUDE.md

package/README.md

@@ -29,6 +29,7 @@ Complete automated workflow from PRD generation to code delivery with `/flow-new
 - 🔍 **Consistency Verification** - Enterprise-grade consistency checking with intelligent conflict detection
 - 🧪 **TDD Enforced** - Strict Test-Driven Development with TEST VERIFICATION CHECKPOINT
 - 📜 **Constitution** - 10 Articles governing quality, security, and architecture
+- 🔄 **Autonomous Development** - Ralph × Manus Integration for memory-enhanced continuous iteration
 - 🔌 **Multi-Platform Support** - Compile workflows for Codex, Cursor, Qwen, Antigravity via `npm run adapt`
 
 ---
@@ -239,6 +240,8 @@ bash .claude/tests/constitution/run_all_constitution_tests.sh
 | `/flow-init` | 📦 Initialize Requirement | `/flow-init "REQ-123\|Feature"` | [→](docs/commands/flow-init.md) |
 | `/flow-clarify` | 🔎 Clarify Ambiguities | `/flow-clarify "REQ-123"` | [→](.claude/commands/flow-clarify.md) |
 | `/flow-checklist` | ✅ Requirement Quality Check | `/flow-checklist --type ux` | [→](.claude/commands/flow-checklist.md) |
+| `/flow-review` | �� Two-Stage Code Review | `/flow-review "REQ-123"` | [→](.claude/commands/flow-review.md) |
+| `/flow-fix` | 🐛 Systematic Bug Fix | `/flow-fix "BUG-123\|Description"` | [→](.claude/commands/flow-fix.md) |
 | `/flow-verify` | 🔍 Verify Consistency | `/flow-verify "REQ-123"` | [→](docs/commands/flow-verify.md) |
 | `/flow-qa` | 🧪 Quality Assurance | `/flow-qa "REQ-123"` | [→](docs/commands/flow-qa.md) |
 | `/flow-release` | 🚢 Create Release | `/flow-release "REQ-123"` | [→](docs/commands/flow-release.md) |
@@ -275,42 +278,44 @@ The following Mermaid diagram illustrates the complete cc-devflow workflow, incl
 ```mermaid
 graph TB
     Start([Start Project]) --> ProjectLevel{Project-Level Setup}
-    
+
     ProjectLevel --> CoreRoadmap["/core-roadmap<br/>ROADMAP.md & BACKLOG.md"]
     ProjectLevel --> CoreArch["/core-architecture<br/>ARCHITECTURE.md"]
     ProjectLevel --> CoreGuidelines["/core-guidelines<br/>frontend/backend guidelines"]
     ProjectLevel --> CoreStyle["/core-style<br/>STYLE.md"]
-    
+
     CoreRoadmap --> ReqLevel
     CoreArch --> ReqLevel
     CoreGuidelines --> ReqLevel
     CoreStyle --> ReqLevel
-    
-    ReqLevel([Requirement-Level Development]) --> FlowInit["/flow-init<br/>research.md & tasks.json"]
-    
+
+    ReqLevel([Requirement-Level Development]) --> FlowInit["/flow-init<br/>research.md & BRAINSTORM.md"]
+
     FlowInit --> FlowClarify["/flow-clarify<br/>clarifications/*.md<br/>Optional"]
-    FlowClarify --> FlowPRD["/flow-prd<br/>PRD.md"]
+    FlowClarify --> FlowPRD["/flow-prd<br/>PRD.md<br/>BRAINSTORM alignment"]
     FlowInit -.->|Skip clarify| FlowPRD
     FlowPRD --> FlowChecklist["/flow-checklist<br/>checklists/*.md<br/>80% Gate"]
     FlowPRD --> FlowTech["/flow-tech<br/>TECH_DESIGN.md & data-model"]
     FlowPRD --> FlowUI["/flow-ui<br/>UI_PROTOTYPE.html<br/>Optional"]
 
     FlowChecklist --> FlowEpic
-    FlowTech --> FlowEpic["/flow-epic<br/>EPIC.md & TASKS.md"]
+    FlowTech --> FlowEpic["/flow-epic<br/>EPIC.md & TASKS.md<br/>bite-sized tasks"]
     FlowUI --> FlowEpic
-    
-    FlowEpic --> FlowDev["/flow-dev<br/>TASKS.md execution<br/>TDD enforced"]
-    
-    FlowDev --> FlowQA["/flow-qa<br/>QA reports & Security"]
-    
-    FlowQA --> FlowRelease["/flow-release<br/>PR creation & Deployment"]
-    
+
+    FlowEpic --> FlowDev["/flow-dev<br/>TASKS.md execution<br/>TDD Checkpoint"]
+
+    FlowDev --> FlowReview["/flow-review<br/>Two-Stage Review<br/>Spec → Quality"]
+
+    FlowReview --> FlowQA["/flow-qa<br/>QA reports & Security"]
+
+    FlowQA --> FlowRelease["/flow-release<br/>PR creation<br/>Branch decision"]
+
     FlowRelease --> FlowVerify["/flow-verify<br/>Consistency check"]
-    
+
     FlowVerify --> End([Release Complete])
-    
+
     FlowVerify -.->|Can be called at any stage| ReqLevel
-    
+
     style ProjectLevel fill:#e1f5ff
     style ReqLevel fill:#fff4e1
     style FlowInit fill:#e8f5e9
@@ -321,6 +326,7 @@ graph TB
     style FlowUI fill:#fff9c4
     style FlowEpic fill:#e8f5e9
     style FlowDev fill:#f3e5f5
+    style FlowReview fill:#e1bee7
     style FlowQA fill:#fce4ec
     style FlowRelease fill:#e0f2f1
     style FlowVerify fill:#e3f2fd
@@ -329,10 +335,12 @@ graph TB
 **Workflow Notes**:
 - **Project-Level Commands** (light blue): Execute once at project initialization, establish global standards (SSOT)
 - **Requirement-Level Commands** (light orange): Execute once per requirement (REQ-XXX)
+- **Brainstorming** (v2.3.0): `/flow-init` now generates `BRAINSTORM.md` as requirement "North Star"
+- **Two-Stage Review** (v2.3.0): `/flow-review` validates Spec Compliance before Code Quality
 - **Optional Steps** (yellow): `/flow-clarify` and `/flow-ui` are optional; clarify can be skipped if requirements are clear
 - **Quality Gate** (orange): `/flow-checklist` validates requirement quality with 80% completion threshold before `/flow-epic`
+- **TDD Checkpoint** (v2.3.0): `/flow-dev` includes mandatory TDD checkpoint (tests must FAIL first)
 - **Quality Gates**: Each stage has entry/exit gates ensuring document quality and Constitution compliance
-- **TDD Enforcement**: `/flow-dev` strictly enforces Test-Driven Development order
 - **Consistency Check**: `/flow-verify` can be called at any stage to ensure document consistency
 
 ---
@@ -476,7 +484,84 @@ bash .claude/tests/run-all-tests.sh --scripts
 
 ## 📝 Version History
 
-### v2.2.0 (2025-12-19) - Latest Release
+### v2.3.0 (2026-01-08) - Latest Release
+
+**🛡️ Discipline System: Iron Law + Rationalization Defense + Pressure Testing**
+
+v2.3.0 upgrades the Constitution from a "document" to an "executable discipline system", borrowing best practices from superpowers project:
+
+- **Iron Law + Rationalization Tables** - Pre-block AI Agent rationalization attempts
+  - Each of 10 Constitution Articles now has an Iron Law (absolute prohibition)
+  - Rationalization Tables with `| Excuse | Reality |` format
+  - Red Flags for AI self-check triggers
+  - Centralized `rationalization-library.md` for all rationalizations
+
+- **Two-Stage Code Review** - `/flow-review` command (NEW)
+  - Stage 1: Spec Compliance (don't trust implementer reports, read code directly)
+  - Stage 2: Code Quality (only runs after Stage 1 passes)
+  - `spec-reviewer.md` and `code-quality-reviewer.md` agents
+
+- **Verification Before Completion** - Evidence before assertions
+  - `verification-before-completion` skill
+  - `verify-gate.sh` script for all flow exit gates
+  - No completion claims without fresh verification evidence
+
+- **Systematic Debugging** - `/flow-fix` enhanced with 4-phase debugging
+  - Phase 1: Root Cause Investigation (NO FIXES YET)
+  - Phase 2: Pattern Analysis
+  - Phase 3: Hypothesis and Testing
+  - Phase 4: TDD Implementation
+  - `flow-debugging` and `flow-tdd` skills
+
+- **Brainstorming Integration** - `/flow-init` now includes brainstorming
+  - `BRAINSTORM.md` as requirement "North Star"
+  - `/flow-prd` requires BRAINSTORM alignment check
+  - `flow-brainstorming` skill
+
+- **Pressure Testing Framework** - TDD for Skills
+  - `tests/pressure-scenarios/` with 4 scenarios
+  - Tests AI behavior under time/sunk cost/authority/exhaustion pressure
+  - `run-pressure-tests.sh` runner
+
+- **Skills Fusion** - Superpowers skills migrated to local
+  - `flow-tdd`, `flow-debugging`, `flow-receiving-review`, `flow-finishing-branch`
+  - All `superpowers:xxx` references replaced with local skills
+
+- **Ralph × Manus Integration** - Autonomous development with memory (NEW)
+  - Merged into `/flow-dev` (Autonomous by default)
+  - `flow-attention-refresh` skill with 4 refresh protocols
+  - `ERROR_LOG.md` structured error tracking
+  - `research/attempts/` failure trace recording
+  - Stop Hook for self-referential loops
+  - Manus method in `/flow-init` Stage 2.5 Research
+  - Target: ≥85% task completion rate without human intervention
+
+**📋 Constitution v2.1.0**:
+- All 10 Articles now have Iron Law + Rationalization Defense + Red Flags
+- Cross-reference to `rationalization-library.md`
+
+**📁 New Files**:
+- `.claude/commands/cancel-ralph.md` - Cancel Ralph loop command
+- `.claude/skills/flow-attention-refresh/SKILL.md` - 4 attention refresh protocols
+- `.claude/hooks/ralph-stop-hook.sh` - Stop Hook for self-referential loops
+- `.claude/hooks/hooks.json` - Hook registration configuration
+- `.claude/scripts/setup-ralph-loop.sh` - Ralph state initialization script
+- `.claude/docs/templates/ERROR_LOG_TEMPLATE.md` - Execution error log format
+- `.claude/docs/templates/ATTEMPT_TEMPLATE.md` - Research attempt log format
+- `.claude/agents/spec-reviewer.md` - Stage 1 spec compliance reviewer
+- `.claude/agents/code-quality-reviewer.md` - Stage 2 code quality reviewer
+- `.claude/commands/flow-review.md` - Two-stage review command
+- `.claude/rules/rationalization-library.md` - Centralized rationalization defense
+- `.claude/scripts/verify-gate.sh` - Exit gate verification script
+- `.claude/skills/flow-brainstorming/` - Brainstorming skill
+- `.claude/skills/flow-debugging/` - Systematic debugging skill
+- `.claude/skills/flow-tdd/` - TDD enforcement skill
+- `.claude/skills/flow-receiving-review/` - Review feedback handling skill
+- `.claude/skills/flow-finishing-branch/` - Branch completion decision skill
+- `.claude/skills/verification-before-completion/` - Completion verification skill
+- `tests/` - Pressure testing framework
+
+### v2.2.0 (2025-12-19)
 
 **🔌 Multi-Platform Adaptation: Agent Adapter Architecture + Command Emitter**