all-for-claudecode 2.0.0 → 2.2.0

package/.claude-plugin/marketplace.json

@@ -5,15 +5,15 @@
     "email": "relee6203@gmail.com"
   },
   "metadata": {
-    "description": "Automated pipeline for Claude Code — spec → plan → tasks → implement → review → clean",
-    "version": "2.0.0"
+    "description": "Automated pipeline for Claude Code — spec → plan → implement → review → clean",
+    "version": "2.2.0"
   },
   "plugins": [
     {
       "name": "afc",
       "source": "./",
-      "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
-      "version": "2.0.0",
+      "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → implement → review → clean.",
+      "version": "2.2.0",
       "category": "automation",
       "tags": ["pipeline", "automation", "spec", "plan", "implement", "review", "critic-loop"]
     }

package/.claude-plugin/plugin.json

@@ -1,12 +1,11 @@
 {
   "name": "afc",
-  "version": "2.0.0",
-  "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
+  "version": "2.2.0",
+  "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → implement → review → clean.",
   "author": { "name": "jhlee0409", "email": "relee6203@gmail.com" },
   "homepage": "https://github.com/jhlee0409/all-for-claudecode",
   "repository": "https://github.com/jhlee0409/all-for-claudecode",
   "license": "MIT",
   "keywords": ["pipeline", "automation", "spec", "plan", "implement", "review", "critic-loop"],
-  "commands": "./commands/",
-  "hooks": "./hooks/hooks.json"
+  "commands": "./commands/"
 }

package/MIGRATION.md

@@ -2,7 +2,7 @@
 
 ## v2.0 — Rebrand: selfish-pipeline → all-for-claudecode
 
-> All-for-ClaudeCode v2.0 renames the package, plugin prefix, scripts, agents, and state files from `selfish` to `afc`.
+> all-for-claudecode v2.0 renames the package, plugin prefix, scripts, agents, and state files from `selfish` to `afc`.
 
 ### What Changed
 
@@ -13,7 +13,7 @@
 | Command prefix | `/selfish:spec` | `/afc:spec` |
 | Script prefix | `selfish-*.sh` | `afc-*.sh` |
 | Agent names | `selfish-architect`, `selfish-security` | `afc-architect`, `afc-security` |
-| State files | `.selfish-active`, `.selfish-phase`, etc. | `.afc-active`, `.afc-phase`, etc. |
+| State files | `.selfish-active`, `.selfish-phase`, etc. | `.claude/.afc-state.json` (single consolidated file) |
 | Config file | `selfish.config.md` | `afc.config.md` |
 | Git tags | `selfish/pre-auto` | `afc/pre-auto` |
 | CLAUDE.md block | `SELFISH:START` / `SELFISH:END` | `AFC:START` / `AFC:END` |
@@ -55,15 +55,18 @@ Replace the `SELFISH:START` / `SELFISH:END` block in your project's CLAUDE.md:
 
 Or simply run `/afc:init` to regenerate the block.
 
-#### 4. Rename state files (if pipeline was active)
+#### 4. Migrate state files (if pipeline was active)
+
+v2.0 consolidated multiple state flag files (`.selfish-active`, `.selfish-phase`, `.selfish-ci-passed`, `.selfish-changes.log`) into a single JSON file (`.claude/.afc-state.json`). If you had an active pipeline:
 
 ```bash
 cd .claude
-for f in .selfish-*; do
-  [ -f "$f" ] && mv "$f" "${f/.selfish-/.afc-}"
-done
+# Remove old individual flag files
+rm -f .selfish-active .selfish-phase .selfish-ci-passed .selfish-changes.log
+# Rename directories
 [ -d selfish ] && mv selfish afc
 [ -f selfish.config.md ] && mv selfish.config.md afc.config.md
+# Note: .afc-state.json is created automatically on next pipeline start
 ```
 
 #### 5. Update git tags
@@ -159,9 +162,9 @@ For new projects, you can auto-generate it with `/afc:init`.
 ## What Stays the Same
 
 - `.claude/afc.config.md` file format and path
-- `.afc-*` state file paths
 - `git tag afc/pre-*` safety tags
 - Internal logic of hook scripts
+- Pipeline state concept (now consolidated in `.claude/.afc-state.json`)
 
 ## What Changed (v1.2.2+)
 

package/README.md

@@ -1,99 +1,73 @@
-# All-for-ClaudeCode
+<div align="center">                                                                                                                                        
+  <img src="https://github.com/user-attachments/assets/9e23029e-e326-4cfa-b329-3bdd1006aecd" alt="all-for-claudecode" width="640" />                        
+</div>
 
-**Claude Code plugin that automates the full development cycle — spec → plan → tasks → implement → review → clean.**
+# all-for-claudecode
+
+**Claude Code plugin that automates the full development cycle — spec → plan → implement → review → clean.**
 
 [![npm version](https://img.shields.io/npm/v/all-for-claudecode)](https://www.npmjs.com/package/all-for-claudecode)
+[![npm downloads](https://img.shields.io/npm/dm/all-for-claudecode)](https://www.npmjs.com/package/all-for-claudecode)
 [![license](https://img.shields.io/github/license/jhlee0409/all-for-claudecode)](./LICENSE)
-[![test](https://img.shields.io/badge/tests-161%20passed-brightgreen)](#how-it-works)
-[![hooks](https://img.shields.io/badge/hooks-15%20events-blue)](#15-hook-events)
-[![commands](https://img.shields.io/badge/commands-18-orange)](#18-slash-commands)
-
-> Zero-dependency automation pipeline for Claude Code. One command (`/afc:auto`) runs the entire cycle: write specs, design plans, break into tasks, implement code, review quality, and clean up — all with built-in CI gates and critic loops.
-
-## What is All-for-ClaudeCode?
+[![test](https://img.shields.io/badge/tests-passing-brightgreen)](#how-it-works)
 
-All-for-ClaudeCode is a **Claude Code plugin** that transforms your development workflow into a fully automated pipeline. Instead of manually prompting Claude through each development phase, you run a single command and the pipeline handles everything — from writing feature specifications to final code review.
-
-- **18 slash commands** for every phase of development
-- **15 hook events** with 3 handler types (shell scripts, LLM prompts, subagents)
-- **5 project presets** for popular stacks (Next.js, React SPA, Express API, Monorepo)
-- **Persistent memory agents** that learn across sessions
-- **Built-in CI gates** that physically prevent skipping quality checks
+> One command (`/afc:auto`) runs the entire cycle. Zero runtime dependencies — pure markdown commands + bash hook scripts.
 
 ## Quick Start
 
-### Option A: Inside Claude Code (`/plugin`)
-
-```
+```bash
+# Option A: Inside Claude Code
 /plugin marketplace add jhlee0409/all-for-claudecode
 /plugin install afc@all-for-claudecode
-```
-
-Or use the interactive UI: type `/plugin` → Manage → Add marketplace → `jhlee0409/all-for-claudecode` → Discover → install **afc**.
 
-### Option B: One-line install (via npx)
-
-```bash
+# Option B: npx
 npx all-for-claudecode
 ```
 
-Interactive installer — choose scope (user / project / local) and done.
-
-### Option C: Claude Code CLI
-
-```bash
-claude plugin marketplace add jhlee0409/all-for-claudecode
-claude plugin install afc@all-for-claudecode --scope user
-```
-
-### Then, inside Claude Code:
+Then:
 
 ```
 /afc:init                              # Detect your stack, generate config
 /afc:auto "Add user authentication"    # Run the full pipeline
 ```
 
-That's it. The pipeline will:
+The pipeline will:
 1. Write a feature spec with acceptance criteria
 2. Design an implementation plan with file change map
-3. Break the plan into parallelizable tasks
-4. Implement each task with CI verification
-5. Run a code review with security scan
-6. Clean up artifacts and prepare for commit
-
-## Features
-
-### Full Auto Pipeline
+3. Implement tasks with CI gates (auto task decomposition + parallel execution)
+4. Run code review with architecture/security agent analysis
+5. Clean up artifacts and prepare for commit
 
-```
-/afc:auto "feature description"
-```
-
-Runs all 6 phases automatically with **Critic Loop** quality checks at each gate:
+## How It Works
 
 ```
-Spec (1/6) → Plan (2/6) → Tasks (3/6) → Implement (4/6) → Review (5/6) → Clean (6/6)
+/afc:auto "Add feature X"
+
+Spec (1/5) → Plan (2/5) → Implement (3/5) → Review (4/5) → Clean (5/5)
+  │              │              │                │              │
+  │              │              │                │              └─ Artifact cleanup
+  │              │              │                └─ 8 perspectives + agent review
+  │              │              └─ Auto task decomposition, parallel execution, CI gates
+  │              └─ File change map, ADR recording, research persistence
+  └─ Acceptance criteria, pre-implementation gates
+
+Hooks run automatically at each step.
+CI failure → debug-based RCA (not blind retry).
+Critic Loops verify quality at each gate until convergence.
 ```
 
-### 18 Slash Commands
-
-**User and model (unrestricted):**
+## Slash Commands
 
 | Command | Description |
 |---|---|
-| `/afc:auto` | Full Auto pipeline — runs all 6 phases |
+| `/afc:auto` | Full Auto pipeline — runs all 5 phases |
 | `/afc:spec` | Write feature specification with acceptance criteria |
 | `/afc:plan` | Design implementation plan with file change map |
 | `/afc:implement` | Execute code implementation with CI gates |
 | `/afc:test` | Test strategy planning and test writing |
-| `/afc:review` | Code review with security scanning |
+| `/afc:review` | Code review with architecture/security scanning |
 | `/afc:research` | Technical research with persistent storage |
 | `/afc:debug` | Bug diagnosis and fix |
-
-**User-only** (`disable-model-invocation: true`):
-
-| Command | Description |
-|---|---|
 | `/afc:init` | Project setup — detects stack and generates config |
 | `/afc:doctor` | Diagnose project health and plugin setup |
 | `/afc:architect` | Architecture analysis (persistent memory) |
@@ -101,16 +75,11 @@ Spec (1/6) → Plan (2/6) → Tasks (3/6) → Implement (4/6) → Review (5/6)
 | `/afc:principles` | Project principles management |
 | `/afc:checkpoint` | Save session state |
 | `/afc:resume` | Restore session state |
-
-**Model-only** (`user-invocable: false`):
-
-| Command | Description |
-|---|---|
-| `/afc:tasks` | Break plan into parallelizable tasks |
+| `/afc:tasks` | Task decomposition (auto-generated by implement) |
 | `/afc:analyze` | Verify artifact consistency |
 | `/afc:clarify` | Resolve spec ambiguities |
 
-### 15 Hook Events
+## Hook Events
 
 Every hook fires automatically — no configuration needed after install.
 
@@ -121,7 +90,7 @@ Every hook fires automatically — no configuration needed after install.
 | `PreToolUse` | Blocks dangerous commands (`push --force`, `reset --hard`) |
 | `PostToolUse` | Tracks file changes + auto-formats code |
 | `SubagentStart` | Injects pipeline context into subagents |
-| `Stop` | CI gate (shell) + code completeness check (AI agent) |
+| `Stop` | CI gate (shell) + code completeness check (agent) |
 | `SessionEnd` | Warns about unfinished pipeline |
 | `PostToolUseFailure` | Diagnostic hints for known error patterns |
 | `Notification` | Desktop alerts (macOS/Linux) |
@@ -131,25 +100,32 @@ Every hook fires automatically — no configuration needed after install.
 | `PermissionRequest` | Auto-allows CI commands during implement/review |
 | `ConfigChange` | Audits/blocks settings changes during active pipeline |
 | `TeammateIdle` | Prevents Agent Teams idle during implement/review |
+| `WorktreeCreate` | Sets up worktree isolation for parallel workers |
+| `WorktreeRemove` | Cleans up worktree after worker completion |
+
+Handler types: `command` (shell scripts, all events), `prompt` (LLM single-turn, TaskCompleted), `agent` (subagent with tools, Stop).
 
-### 3 Hook Handler Types
+## Persistent Memory Agents
 
-| Type | Description | Use Case |
-|---|---|---|
-| `command` | Shell script execution (deterministic) | All 15 events |
-| `prompt` | LLM single-turn evaluation (haiku) | TaskCompleted |
-| `agent` | Subagent with file access tools | Stop |
+| Agent | Role |
+|---|---|
+| `afc-architect` | Remembers ADR decisions and architecture patterns across sessions. Auto-invoked during Plan (ADR recording) and Review (architecture compliance). |
+| `afc-security` | Remembers vulnerability patterns and false positives across sessions. Auto-invoked during Review (security scanning). Runs in isolated worktree. |
+| `afc-impl-worker` | Parallel implementation worker. Receives pre-assigned tasks from orchestrator. Ephemeral (no memory). |
+
+## Task Orchestration
 
-### Persistent Memory Agents
+The implement phase automatically selects execution strategy:
 
-Two custom agents that **learn across sessions**:
+| Parallel tasks in phase | Mode |
+|---|---|
+| 0 | Sequential — one task at a time |
+| 1–5 | Parallel Batch — concurrent Task() calls |
+| 6+ | Swarm — orchestrator pre-assigns tasks to worker agents (max 5) |
 
-| Agent | Role | Memory |
-|---|---|---|
-| `afc-architect` | Architecture analysis — remembers ADR decisions and patterns | `.claude/agent-memory/afc-architect/` |
-| `afc-security` | Security scan — remembers vulnerability patterns and false positives | `.claude/agent-memory/afc-security/` |
+Dependencies are tracked via DAG. CI gate + Mini-Review + Auto-Checkpoint run at each phase boundary.
 
-### Project Presets
+## Project Presets
 
 | Preset | Stack |
 |---|---|
@@ -159,57 +135,30 @@ Two custom agents that **learn across sessions**:
 | `express-api` | Express + TypeScript + Prisma + Jest |
 | `monorepo` | Turborepo + pnpm workspace |
 
-## How It Works
-
-```
-┌─────────────────────────────────────────────┐
-│  /afc:auto "Add feature X"              │
-├─────────────────────────────────────────────┤
-│  Phase 1: Spec    → Critic Loop → Gate ✓    │
-│  Phase 2: Plan    → Critic Loop → Gate ✓    │
-│  Phase 3: Tasks   → Critic Loop → Gate ✓    │
-│  Phase 4: Implement → CI Gate → Gate ✓      │
-│  Phase 5: Review  → Security Scan → Gate ✓  │
-│  Phase 6: Clean   → Artifacts removed       │
-├─────────────────────────────────────────────┤
-│  15 hooks run automatically at each step    │
-│  Stop/TaskCompleted gates block if CI fails │
-└─────────────────────────────────────────────┘
-```
-
 ## Configuration
 
-Initialize your project:
-
-```bash
+```
 /afc:init
 ```
 
-This detects your tech stack and generates `.claude/afc.config.md` with:
-- CI/lint/test commands
-- Architecture style and layers
-- Framework-specific settings
-- Code style conventions
+Detects your tech stack and generates `.claude/afc.config.md` with CI/lint/test commands, architecture rules, framework settings, and code style conventions.
 
 ## FAQ
 
-### What is all-for-claudecode?
-A Claude Code plugin that automates the entire development cycle (spec → plan → tasks → implement → review → clean) through 18 slash commands and 15 hook events.
-
-### How does it compare to manual Claude Code workflows?
-Instead of manually prompting each step, all-for-claudecode orchestrates the full cycle with built-in quality gates that physically prevent skipping CI or security checks.
-
 ### Does it work with any project?
-Yes. Run `/afc:init` to auto-detect your stack, or use one of the 5 presets (Next.js, React SPA, Express API, Monorepo, or generic template).
+Yes. Run `/afc:init` to auto-detect your stack, or pick a preset.
 
 ### Does it require any dependencies?
-No. Zero runtime dependencies — pure markdown commands + bash hook scripts.
+No. Pure markdown commands + bash hook scripts.
+
+### What happens if CI fails during the pipeline?
+Debug-based RCA: traces the error, forms a hypothesis, applies a targeted fix. Halts after 3 failed attempts with full diagnosis.
 
-### How do I install it?
-Inside Claude Code, run `/plugin marketplace add jhlee0409/all-for-claudecode` then `/plugin install afc@all-for-claudecode`. Alternatively, run `npx all-for-claudecode` from your terminal for a guided install.
+### Can I run individual phases?
+Yes. Each phase has its own command (`/afc:spec`, `/afc:plan`, `/afc:implement`, `/afc:review`). `/afc:auto` runs them all.
 
-### What Claude Code version is required?
-Claude Code with plugin support (2025+). The plugin uses standard hooks, commands, and agents APIs.
+### What are Critic Loops?
+Convergence-based quality checks after each phase. They evaluate output against criteria (completeness, feasibility, architecture compliance) and auto-fix issues until stable. 4 verdicts: PASS, FAIL, ESCALATE (asks user), DEFER.
 
 ## License
 

package/agents/afc-architect.md

@@ -18,6 +18,22 @@ skills:
 
 You are an architecture analysis agent for the current project.
 
+## Pipeline Integration
+
+This agent is invoked automatically during the auto pipeline at two points:
+
+### Plan Phase — ADR Recording
+- **Input**: Architecture Decision + File Change Map sections from plan.md
+- **Task**: Check for conflicts with existing ADRs, record new decisions
+- **Output**: `{ decisions_recorded: N, conflicts: [{ existing: "...", new: "...", reason: "..." }] }`
+- If conflicts found: orchestrator ESCALATEs to user
+
+### Review Phase — Architecture Review (Perspective B)
+- **Input**: List of changed files from `git diff`
+- **Task**: Review files for architecture compliance, cross-reference with ADRs
+- **Output**: Findings as `severity (Critical/Warning/Info), file:line, issue, suggested fix`
+- Findings are merged into the consolidated review report
+
 ## Reference Documents
 
 Before performing analysis, read these shared reference documents:

package/agents/afc-impl-worker.md

@@ -0,0 +1,40 @@
+---
+name: afc-impl-worker
+description: "Parallel implementation worker — executes assigned tasks from the pipeline task pool with worktree isolation support."
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+model: sonnet
+---
+
+You are a parallel implementation worker for the all-for-claudecode pipeline.
+
+## Workflow
+
+The orchestrator pre-assigns tasks to you via the prompt. Do NOT self-claim tasks via TaskList/TaskUpdate — this avoids last-write-wins race conditions.
+
+1. Read the **Implementation Context** section in your prompt first — this contains the feature objective, constraints, edge cases, and prohibitions from the original spec/plan
+2. Read the task list provided in your prompt (orchestrator pre-assigned)
+3. For each assigned task, in order:
+   a. Read all files you need to modify BEFORE making changes
+   b. Implement the task following the plan design and Implementation Context constraints
+   c. Verify with the project's gate command if applicable
+4. Return a structured summary of completed work:
+   - Files changed (with paths)
+   - Key decisions made during implementation
+   - Issues encountered or concerns
+   - Gate command result
+5. Do NOT call TaskList or TaskUpdate — the orchestrator handles task state management
+
+## Rules
+
+- Always read existing files before modifying them
+- Follow the project's shell script conventions: `set -euo pipefail`, `trap cleanup EXIT`, jq-first parsing
+- Use `printf '%s\n' "$VAR"` instead of `echo "$VAR"` for external data
+- All scripts must pass shellcheck
+- Do not modify files outside your assigned task's scope
+- If a task fails, report the error and move to the next task

package/agents/afc-security.md

@@ -18,6 +18,17 @@ skills:
 
 You are a security scanning agent for the current project.
 
+## Pipeline Integration
+
+This agent is invoked automatically during the auto pipeline:
+
+### Review Phase — Security Review (Perspective C)
+- **Input**: List of changed files from `git diff`
+- **Task**: Scan for security vulnerabilities, filter known false positives from memory
+- **Output**: Findings as `severity (Critical/Warning/Info), file:line, issue, suggested fix`
+- Findings are merged into the consolidated review report
+- Check for: command injection, path traversal, unvalidated input, sensitive data exposure, shell escaping issues
+
 ## Reference Documents
 
 Before performing scans, read these shared reference documents:

package/bin/cli.mjs

@@ -40,7 +40,7 @@ function run(cmd) {
 
 async function main() {
   console.log();
-  console.log("  All-for-ClaudeCode — Claude Code Plugin Installer");
+  console.log("  all-for-claudecode — Claude Code Plugin Installer");
   console.log("  ===================================================");
   console.log();
 

package/commands/analyze.md

@@ -22,13 +22,12 @@ model: haiku
 
 ## Config Load
 
-Read the following settings from `CLAUDE.md` or `.claude/CLAUDE.md` at the project root and assign to the `config` variable:
+**Always** read `.claude/afc.config.md` first. This file contains free-form markdown sections:
+- `## Architecture` — architecture pattern, layers, import rules (primary reference for this command)
+- `## Code Style` — language, naming conventions, lint rules
+- `## Project Context` — framework, state management, testing, etc.
 
-```
-config.architecture = the architecture pattern used in the project
-                      (e.g., "FSD", "Clean Architecture", "Layered", "Modular Monolith")
-                      → Architecture standard specified in CLAUDE.md. Assume "Layered Architecture" if not present.
-```
+If config file is missing: read `CLAUDE.md` for architecture info. Assume "Layered Architecture" if neither source has it.
 
 ## Execution Steps
 
@@ -123,4 +122,4 @@ Analysis complete
 
 - **Read-only**: Do not modify any files. Report only.
 - **Avoid false positives**: Do not over-flag ambiguity. Consider context.
-- **Optional**: Not required in the pipeline. Can proceed plan → tasks → implement directly.
+- **Optional**: Not required in the pipeline. Can proceed plan → implement directly.

package/commands/architect.md

@@ -2,7 +2,6 @@
 name: afc:architect
 description: "Architecture analysis and design advice"
 argument-hint: "[analysis target or design question]"
-disable-model-invocation: true
 context: fork
 agent: afc-architect
 allowed-tools:
@@ -27,13 +26,12 @@ model: sonnet
 
 ## Config Load
 
-Read the following settings from `CLAUDE.md` or `.claude/CLAUDE.md` at the project root and assign to the `config` variable:
+**Always** read `.claude/afc.config.md` first. This file contains free-form markdown sections:
+- `## Architecture` — architecture pattern, layers, import rules (primary reference for this command)
+- `## Code Style` — language, naming conventions, lint rules
+- `## Project Context` — framework, state management, testing, etc.
 
-```
-config.architecture = the architecture pattern used in the project
-                      (e.g., "FSD", "Clean Architecture", "Layered", "Modular Monolith")
-                      → Architecture standard specified in CLAUDE.md. Assume "Layered Architecture" if not present.
-```
+If config file is missing: read `CLAUDE.md` for architecture info. Assume "Layered Architecture" if neither source has it.
 
 ## Execution Steps