all-for-claudecode 2.0.0

package/commands/resume.md

@@ -0,0 +1,81 @@
+---
+name: afc:resume
+description: "Restore session"
+argument-hint: "[no arguments]"
+disable-model-invocation: true
+model: haiku
+allowed-tools:
+  - Read
+  - Glob
+  - Bash
+---
+
+# /afc:resume — Restore Session
+
+> Restores the previous session state from .claude/afc/memory/checkpoint.md and resumes work.
+
+## Arguments
+
+- `$ARGUMENTS` — (optional) none
+
+## Execution Steps
+
+### 1. Load Checkpoint
+
+Read `.claude/afc/memory/checkpoint.md`:
+- If not found: output "No saved checkpoint found." then **stop**
+- If found: parse the full contents
+
+### 2. Validate Environment
+
+Compare the checkpoint state against the current environment:
+
+1. **Branch check**: Does the checkpoint branch match the current branch?
+   - If different: warn + suggest switching
+2. **File state**: Have any files changed since the checkpoint?
+   - Check for new commits with `git log {checkpoint hash}..HEAD --oneline`
+3. **Feature directory**: Does .claude/afc/specs/{feature}/ still exist?
+
+### 3. Report State
+
+```markdown
+## Session Restore
+
+### Previous Checkpoint
+- **Saved at**: {time}
+- **Message**: {checkpoint message}
+- **Branch**: {branch} {(matches current ✓ / differs ⚠)}
+
+### Active Features
+| Feature | Status | Progress |
+|---------|--------|----------|
+| {name} | {status} | {progress} |
+
+### Changes Since Checkpoint
+{list of new commits if any, or "No changes"}
+
+### Incomplete Work
+{incomplete work list from checkpoint.md}
+
+### Recommended Next Steps
+{recommended commands based on state}
+- Tasks in progress → resume `/afc:implement`
+- Plan complete → `/afc:tasks`
+- Spec only → `/afc:plan`
+```
+
+### 4. Final Output
+
+```
+Session restored
+├─ Checkpoint: {time}
+├─ Feature: {name} ({status})
+├─ Progress: {completed}/{total}
+└─ Recommended: {next command}
+```
+
+## Notes
+
+- **Read-only**: Does not modify the environment (branch switching is suggested only; user must confirm).
+- **Mismatch warning**: Clearly warn if checkpoint and current environment differ.
+- **Context restore**: Always display the "Context Notes" from the checkpoint to aid memory.

package/commands/review.md

@@ -0,0 +1,205 @@
+---
+name: afc:review
+description: "Code review"
+argument-hint: "[scope: file path, PR number, or staged]"
+allowed-tools:
+  - Read
+  - Write
+  - Grep
+  - Glob
+  - Bash
+  - Task
+model: sonnet
+---
+
+# /afc:review — Code Review
+
+> Performs a comprehensive review of changed code (quality, security, performance, architecture compliance).
+> Validates completeness of the review itself with convergence-based Critic Loop.
+
+## Arguments
+
+- `$ARGUMENTS` — (optional) Review scope (file path, PR number, or "staged")
+  - If not specified: full `git diff` of current branch (unstaged + staged)
+
+## Project Config (auto-loaded)
+
+!`cat .claude/afc.config.md 2>/dev/null || echo "[CONFIG NOT FOUND] .claude/afc.config.md not found. Create it with /afc:init."`
+
+## Config Load
+
+**Always** read `.claude/afc.config.md` first (read manually if not auto-loaded above). Abort if config file is missing.
+
+## Execution Steps
+
+### 1. Collect Review Targets
+
+1. **Determine scope**:
+   - `$ARGUMENTS` = file path → that file only
+   - `$ARGUMENTS` = PR number → run `gh pr diff {number}`
+   - `$ARGUMENTS` = "staged" → `git diff --cached`
+   - Not specified → `git diff HEAD` (all uncommitted changes)
+2. Extract **list of changed files**
+3. Read **full content** of each changed file (not just the diff — full context)
+
+### 2. Parallel Review (scaled by file count)
+
+Choose review orchestration based on the number of changed files:
+
+#### 5 or fewer files: Direct review
+Review all files directly in the current context (no delegation).
+
+#### 6–10 files: Parallel Batch
+Distribute to parallel review agents (2–3 files per agent) in a **single message**:
+```
+Task("Review: {file1, file2}", subagent_type: "general-purpose")
+Task("Review: {file3, file4}", subagent_type: "general-purpose")
+```
+Read each agent's returned output, then write consolidated review.
+
+#### 11+ files: Review Swarm
+Create a review task pool and spawn self-organizing review workers:
+```
+// 1. Register each file as a review task via TaskCreate
+TaskCreate({ subject: "Review: src/auth/login.ts", description: "Review for quality, security, architecture, performance..." })
+TaskCreate({ subject: "Review: src/auth/session.ts", ... })
+// ... for all changed files
+
+// 2. Spawn N review workers in a single message (N = min(5, file count / 2))
+Task("Review Worker 1", subagent_type: "general-purpose",
+  prompt: "You are a review worker. Loop: TaskList → claim pending → read file + diff → review → record findings → repeat until empty.
+  Review criteria: {config.code_style}, {config.architecture}, security, performance.
+  Output findings as: severity (Critical/Warning/Info), file:line, issue, suggested fix.")
+```
+Collect all worker outputs, then write consolidated review.
+
+### 3. Perform Review
+
+For each changed file, examine from the following perspectives:
+
+#### A. Code Quality
+- {config.code_style} compliance (any usage, missing types)
+- Naming conventions (handleX, isX, UPPER_SNAKE)
+- Duplicate code
+- Unnecessary complexity
+
+#### B. {config.architecture}
+- Layer dependency direction violations (lower→upper imports)
+- Segment rules (api/, model/, ui/, lib/)
+- Appropriate layer placement
+
+#### C. Security
+- XSS vulnerabilities (dangerouslySetInnerHTML, unvalidated user input)
+- Sensitive data exposure
+- SQL/Command injection
+
+#### D. Performance
+- Unnecessary re-renders (missing useCallback/useMemo)
+- Infinite loop potential (useEffect dependencies)
+- Large data processing
+
+#### E. Project Pattern Compliance
+- {config.state_management} usage patterns
+- Server/client state management patterns (see {config.state_management})
+- Component structure (Props type location, hook order)
+
+### 4. Review Output
+
+```markdown
+## Code Review Results
+
+### Summary
+| Severity | Count | Items |
+|----------|-------|-------|
+| Critical | {N} | {summary} |
+| Warning | {N} | {summary} |
+| Info | {N} | {summary} |
+
+### Detailed Findings
+
+#### C-{N}: {title}
+- **File**: {path}:{line}
+- **Issue**: {description}
+- **Suggested fix**: {code example}
+
+#### W-{N}: {title}
+{same format}
+
+#### I-{N}: {title}
+{same format}
+
+### Positives
+- {1-2 things done well}
+```
+
+### 5. Retrospective Check
+
+If `.claude/afc/memory/retrospectives/` directory exists, load retrospective files and check:
+- Were there recurring Critical finding categories in past reviews? Prioritize those perspectives.
+- Were there false positives that wasted effort? Reduce sensitivity for those patterns.
+
+### 6. Critic Loop
+
+> **Always** read `${CLAUDE_PLUGIN_ROOT}/docs/critic-loop-rules.md` first and follow it.
+
+Run the critic loop until convergence. Safety cap: 5 passes.
+
+| Criterion | Validation |
+|-----------|------------|
+| **COMPLETENESS** | Were all changed files reviewed? Are there any missed perspectives? |
+| **PRECISION** | Are the findings actual issues, not false positives? |
+
+**On FAIL**: auto-fix and continue to next pass.
+**On ESCALATE**: pause, present options to user, apply choice, resume.
+**On DEFER**: record reason, mark criterion clean, continue.
+**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
+**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+
+### 7. Retrospective Entry (if new pattern found)
+
+If this review reveals a recurring pattern not previously documented in `.claude/afc/memory/retrospectives/`:
+
+Append to `.claude/afc/memory/retrospectives/{YYYY-MM-DD}.md`:
+```markdown
+## Pattern: {category}
+**What happened**: {concrete description}
+**Root cause**: {why this keeps occurring}
+**Prevention rule**: {actionable rule — usable in future plan/implement phases}
+**Severity**: Critical | Warning
+```
+
+Only write if the pattern is new and actionable. Generic observations are prohibited.
+
+### 8. Archive Review Report
+
+When running inside a pipeline (.claude/afc/specs/{feature}/ exists), persist the review results:
+
+1. Write full review output (Summary table + Detailed Findings + Positives) to `.claude/afc/specs/{feature}/review-report.md`
+2. Include metadata header:
+   ```markdown
+   # Review Report: {feature name}
+   > Date: {YYYY-MM-DD}
+   > Files reviewed: {count}
+   > Findings: Critical {N} / Warning {N} / Info {N}
+   ```
+3. This file survives Clean phase (copied to `.claude/afc/memory/reviews/{feature}-{date}.md` before .claude/afc/specs/ deletion)
+
+When running standalone (no active pipeline), skip archiving — display results in console only.
+
+### 9. Final Output
+
+```
+Review complete
+├─ Files: {changed file count}
+├─ Found: Critical {N} / Warning {N} / Info {N}
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
+└─ Conclusion: {one-line summary}
+```
+
+## Notes
+
+- **Read-only**: do not modify code. Report findings only.
+- **Full context**: read the entire file, not just the diff lines, to understand context before reviewing.
+- **Avoid false positives**: classify uncertain issues as Info.
+- **Respect patterns**: do not flag code simply because it differs from other patterns. Use CLAUDE.md and afc.config.md as the standard.
+- **NEVER use `run_in_background: true` on Task calls**: review agents must run in foreground so results are returned before consolidation.

package/commands/security.md

@@ -0,0 +1,131 @@
+---
+name: afc:security
+description: "Security scan (read-only)"
+argument-hint: "[scan scope: file/directory path or full]"
+disable-model-invocation: true
+context: fork
+agent: afc-security
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Task
+  - WebSearch
+model: sonnet
+---
+
+# /afc:security — Security Scan
+
+> Detects and reports security vulnerabilities in the codebase.
+> Inspects against OWASP Top 10. **Read-only** — does not modify code.
+
+## Arguments
+
+- `$ARGUMENTS` — (optional) scan scope (file/directory path, or "full" for full scan)
+  - If not specified: scans only files changed in the current branch
+
+## Config Load
+
+Read the following settings from `CLAUDE.md` or `.claude/CLAUDE.md` at the project root and assign to the `config` variable:
+
+```
+config.framework  = the framework used in the project
+                    (e.g., "Next.js", "Nuxt", "SvelteKit", "Express", "NestJS")
+                    → Framework specified in CLAUDE.md. Assume "unknown" if not present.
+config.auditCmd   = dependency audit command
+                    (e.g., "yarn audit", "npm audit", "pnpm audit")
+                    → Infer from the packageManager field in package.json or the lockfile.
+```
+
+## Execution Steps
+
+### 1. Determine Scan Scope
+
+- `$ARGUMENTS` = path → that path only
+- `$ARGUMENTS` = "full" → entire `src/`
+- Not specified → changed files from `git diff --name-only HEAD`
+
+### 2. Agent Teams (if more than 10 files)
+
+Use parallel agents for wide-scope scans:
+```
+Task("Security scan: src/features/", subagent_type: general-purpose)
+Task("Security scan: src/shared/api/", subagent_type: general-purpose)
+```
+
+### 3. Security Check Items
+
+#### A. Injection (A03:2021)
+- Uses of `dangerouslySetInnerHTML`
+- User input inserted directly into DOM/URL/queries
+- Uses of `eval()`, `new Function()`
+
+#### B. Broken Authentication (A07:2021)
+- Hardcoded tokens or credentials
+- API routes accessible without authentication
+- Session management vulnerabilities
+
+#### C. Sensitive Data Exposure (A02:2021)
+- `.env` values exposed to the client (check framework-specific public env variables for {config.framework})
+- Sensitive information printed via console.log
+- Internal details exposed in error messages
+
+#### D. Security Misconfiguration (A05:2021)
+- CORS configuration
+- CSP headers
+- Unnecessary debug mode enabled
+
+#### E. XSS (A03:2021)
+- Patterns that bypass React's default escaping
+- URL parameters rendered without validation
+- Dynamic injection of iframes or scripts
+
+#### F. Dependencies (A06:2021)
+- Packages with known vulnerabilities (dependency audit tool results)
+- Outdated dependencies
+
+### 4. Output Results
+
+```markdown
+## Security Scan Results
+
+### Summary
+| Severity | Count |
+|----------|-------|
+| Critical | {N} |
+| High | {N} |
+| Medium | {N} |
+| Low | {N} |
+
+### Findings
+
+#### SEC-{NNN}: {title}
+- **Category**: {OWASP code}
+- **File**: {path}:{line}
+- **Description**: {vulnerability details}
+- **Impact**: {impact if exploited}
+- **Mitigation**: {how to fix}
+
+### Dependency Audit
+{config.auditCmd} result summary — if executable
+
+### Recommended Actions
+{prioritized fix suggestions}
+```
+
+### 5. Final Output
+
+```
+Security scan complete
+├─ Scope: {file count} files
+├─ Found: Critical {N} / High {N} / Medium {N} / Low {N}
+└─ Recommended: {most urgent action}
+```
+
+## Notes
+
+- **Read-only**: Does not modify code. Reports security issues only.
+- **Minimize false positives**: Account for React's default XSS defenses. Report only genuinely dangerous patterns.
+- **Handle sensitive data carefully**: Do not include actual token or password values in scan results.
+- **Consider context**: Reflect security specifics for the {config.framework} environment.

package/commands/spec.md

@@ -0,0 +1,149 @@
+---
+name: afc:spec
+description: "Generate feature specification"
+argument-hint: "[feature description in natural language]"
+model: sonnet
+---
+# /afc:spec — Generate Feature Specification
+
+> Converts a natural language feature description into a structured specification (spec.md).
+> Validates completeness with convergence-based Critic Loop. Operates on pure prompts without external scripts.
+
+## Arguments
+
+- `$ARGUMENTS` — (required) Feature description in natural language
+
+## Project Config (auto-loaded)
+
+!`cat .claude/afc.config.md 2>/dev/null || echo "[CONFIG NOT FOUND] .claude/afc.config.md not found. Create it with /afc:init."`
+
+## Config Load
+
+**Always** read `.claude/afc.config.md` first (read manually if not auto-loaded above). Abort if config file is missing.
+
+## Execution Steps
+
+### 1. Set Up Feature Directory
+
+1. Check **current branch** → `BRANCH_NAME`
+2. Determine **feature name**:
+   - Extract 2-3 key keywords from `$ARGUMENTS`
+   - Convert to kebab-case (e.g., "add user authentication" → `user-auth`)
+3. **Create directory**: `.claude/afc/specs/{feature-name}/` (create parent `.claude/afc/specs/` directory if it does not exist)
+4. If already exists, confirm with user: "Overwrite existing spec?"
+
+### 2. Explore Codebase
+
+Before writing the spec, understand the current project structure:
+
+1. Check key directories by `{config.architecture}` layer
+2. Explore existing code related to the feature description (Grep/Glob)
+3. Identify related type definitions, APIs, and components
+
+### 3. Write Spec
+
+Create `.claude/afc/specs/{feature-name}/spec.md`:
+
+```markdown
+# Feature Spec: {feature name}
+
+> Created: {YYYY-MM-DD}
+> Branch: {BRANCH_NAME}
+> Status: Draft
+
+## Overview
+{2-3 sentences on the purpose and background of the feature}
+
+## User Stories
+
+### US1: {story title} [P1]
+**Description**: {feature description from user perspective}
+**Priority rationale**: {why this order}
+**Independent testability**: {whether this story can be tested on its own}
+
+#### Acceptance Scenarios
+- [ ] Given {precondition}, When {action}, Then {result}
+- [ ] Given {precondition}, When {action}, Then {result}
+
+### US2: {story title} [P2]
+{same format}
+
+## Requirements
+
+### Functional Requirements
+- **FR-001**: {requirement}
+- **FR-002**: {requirement}
+
+### Non-Functional Requirements
+- **NFR-001**: {performance/security/accessibility etc.}
+
+### Auto-Suggested NFRs
+{Load `${CLAUDE_PLUGIN_ROOT}/docs/nfr-templates.md` and select 3-5 relevant NFRs based on the project type detected from afc.config.md}
+- **NFR-A01** [AUTO-SUGGESTED]: {suggestion from matching project type template}
+- **NFR-A02** [AUTO-SUGGESTED]: {suggestion}
+- **NFR-A03** [AUTO-SUGGESTED]: {suggestion}
+{Tag each with [AUTO-SUGGESTED]. Users may accept, modify, or remove.}
+
+### Key Entities
+| Entity | Description | Related Existing Code |
+|--------|-------------|-----------------------|
+| {name} | {description} | {path or "new"} |
+
+## Success Criteria
+- **SC-001**: {measurable success indicator}
+- **SC-002**: {measurable success indicator}
+
+## Edge Cases
+- {edge case 1}
+- {edge case 2}
+
+## Constraints
+- {technical/business constraints}
+
+## [NEEDS CLARIFICATION]
+- {uncertain items — record if any, remove section if none}
+```
+
+### 4. Retrospective Check
+
+If `.claude/afc/memory/retrospectives/` directory exists, load retrospective files and check:
+- Were there previous `[AUTO-RESOLVED]` items that turned out wrong? Flag similar patterns.
+- Were there scope-related issues in past specs? Warn about similar ambiguities.
+
+### 5. Critic Loop
+
+> **Always** read `${CLAUDE_PLUGIN_ROOT}/docs/critic-loop-rules.md` first and follow it.
+
+Run the critic loop until convergence. Safety cap: 5 passes.
+
+| Criterion | Validation |
+|-----------|------------|
+| **COMPLETENESS** | Does every User Story have acceptance scenarios? Are any requirements missing? |
+| **MEASURABILITY** | Are the success criteria measurable, not subjective? |
+| **INDEPENDENCE** | Are implementation details (code, library names) absent from the spec? |
+| **EDGE_CASES** | Are at least 2 edge cases identified? Any missing boundary conditions? |
+
+**On FAIL**: auto-fix and continue to next pass.
+**On ESCALATE**: pause, present options to user, apply choice, resume.
+**On DEFER**: record reason, mark criterion clean, continue.
+**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
+**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+
+### 6. Final Output
+
+```
+Spec generated
+├─ .claude/afc/specs/{feature-name}/spec.md
+├─ User Stories: {count}
+├─ Requirements: FR {count}, NFR {count}
+├─ Unresolved: {[NEEDS CLARIFICATION] count}
+└─ Next step: /afc:clarify (if unresolved) or /afc:plan
+```
+
+## Notes
+
+- Do **not** write implementation details in the spec. Expressions like "manage with Zustand" belong in plan.md.
+- Specify **actual paths** for entities related to existing code.
+- If `$ARGUMENTS` is empty, ask user for a feature description.
+- Do not pack too many features into one spec. Suggest splitting if User Stories exceed 5.
+- When running `/afc:auto`, `[AUTO-SUGGESTED]` NFRs are included automatically. Review after completion is recommended.

package/commands/tasks.md

@@ -0,0 +1,137 @@
+---
+name: afc:tasks
+description: "Task decomposition"
+argument-hint: "[constraints/priority directives]"
+user-invocable: false
+model: sonnet
+---
+# /afc:tasks — Task Decomposition
+
+> Generates an executable task list (tasks.md) based on plan.md.
+> Validates coverage with convergence-based Critic Loop.
+
+## Arguments
+
+- `$ARGUMENTS` — (optional) additional constraints or priority directives
+
+## Config Load
+
+**Must** read `.claude/afc.config.md` first. Stop if the config file is not present.
+
+## Execution Steps
+
+### 1. Load Context
+
+1. Load from `.claude/afc/specs/{feature}/`:
+   - **plan.md** (required) — stop if missing: "Run /afc:plan first."
+   - **spec.md** (required)
+   - **research.md** (if present)
+2. Extract from plan.md:
+   - Phase breakdown
+   - File Change Map
+   - Architecture decisions
+
+### 2. Decompose Tasks
+
+Decompose tasks per Phase defined in plan.md.
+
+#### Task Format (required)
+
+```markdown
+- [ ] T{NNN} {[P]} {[US*]} {description} `{file path}` {depends: [TXXX, TXXX]}
+```
+
+| Component | Required | Description |
+|-----------|----------|-------------|
+| `T{NNN}` | Yes | 3-digit sequential ID (T001, T002, ...) |
+| `[P]` | No | Parallelizable — no file overlap with other [P] tasks in the same phase |
+| `[US*]` | No | User Story label (US1, US2, ... from spec.md) |
+| description | Yes | Clear task description (start with a verb) |
+| file path | Yes | Primary target file (wrapped in backticks) |
+| `depends:` | No | Explicit dependency list — task cannot start until all listed tasks complete |
+
+#### Phase Structure
+
+```markdown
+# Tasks: {feature name}
+
+## Phase 1: Setup
+{type definitions, configuration, directory structure}
+
+## Phase 2: Core
+{core business logic, store, API}
+
+## Phase 3: UI
+{components, interactions}
+
+## Phase 4: Integration & Polish
+{integration, error handling, optimization}
+```
+
+#### Decomposition Principles
+
+1. **1 task = 1 file** principle (where possible)
+2. **Same file = sequential**, **different files = [P] candidate**
+3. **Explicit dependencies**: Use `depends: [T001, T002]` to declare blocking dependencies. Tasks without `depends:` and with [P] marker are immediately parallelizable.
+4. **[P] physical validation**: Before finalizing tasks.md, run `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-parallel-validate.sh" .claude/afc/specs/{feature}/tasks.md` to verify no file path overlaps exist among [P] tasks within the same phase. Fix any conflicts before proceeding.
+5. **Dependency graph must be a DAG**: no circular dependencies allowed. Validate before output.
+6. **Test tasks**: Include a verification task for each testable unit
+7. **Phase gate**: Add a `{config.gate}` validation task at the end of each Phase
+
+### 3. Retrospective Check
+
+If `.claude/afc/memory/retrospectives/` directory exists, load retrospective files and check:
+- Were there previous parallel conflict issues ([P] file overlaps)? Flag similar file patterns.
+- Were there tasks that were over-decomposed or under-decomposed? Adjust granularity.
+
+### 4. Critic Loop
+
+> **Always** read `${CLAUDE_PLUGIN_ROOT}/docs/critic-loop-rules.md` first and follow it.
+
+Run the critic loop until convergence. Safety cap: 5 passes.
+
+| Criterion | Validation |
+|-----------|------------|
+| **COVERAGE** | Are all files in plan.md's File Change Map included in tasks? Are all FR-* in spec.md covered? |
+| **DEPENDENCIES** | Is the dependency graph a valid DAG? Do [P] tasks within the same phase have no file overlaps? Are all `depends:` targets valid task IDs? For physical validation of [P] file overlaps, reference the validation script: `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-parallel-validate.sh"` can be called with the tasks.md path to verify no conflicts exist. |
+
+**On FAIL**: auto-fix and continue to next pass.
+**On ESCALATE**: pause, present options to user, apply choice, resume.
+**On DEFER**: record reason, mark criterion clean, continue.
+**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
+**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+
+### 5. Coverage Mapping
+
+```markdown
+## Coverage Mapping
+| Requirement | Tasks |
+|-------------|-------|
+| FR-001 | T003, T007 |
+| FR-002 | T005, T008 |
+| NFR-001 | T012 |
+```
+
+Every FR-*/NFR-* must be mapped to at least one task.
+
+### 6. Final Output
+
+Save to `.claude/afc/specs/{feature}/tasks.md`, then:
+
+```
+Tasks generated
+├─ .claude/afc/specs/{feature}/tasks.md
+├─ Tasks: {total count} ({[P] count} parallelizable)
+├─ Phases: {phase count}
+├─ Coverage: FR {coverage}%, NFR {coverage}%
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
+└─ Next step: /afc:analyze (optional) or /afc:implement
+```
+
+## Notes
+
+- **Do not write implementation code**: Write task descriptions only. Actual code is the responsibility of /afc:implement.
+- **No over-decomposition**: Do not create separate tasks for single-line changes.
+- **Accurate file paths**: Use paths based on the actual project structure (no guessing).
+- **Use [P] sparingly**: Mark [P] only for truly independent tasks. When in doubt, keep sequential.
+- **Dependencies unlock swarm**: explicit `depends:` enables /afc:implement to use native task orchestration with automatic dependency resolution. Tasks without dependencies can be claimed by parallel workers immediately.