selfish-pipeline 1.1.1 → 1.2.0

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Automated pipeline for Claude Code — spec → plan → tasks → implement → review → clean",
-    "version": "1.1.1"
+    "version": "1.2.0"
   },
   "plugins": [
     {
       "name": "selfish",
       "source": "./",
       "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
-      "version": "1.1.1",
+      "version": "1.2.0",
       "category": "automation",
       "tags": ["pipeline", "automation", "spec", "plan", "implement", "review", "critic-loop"]
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "selfish",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
   "author": { "name": "jhlee0409", "email": "relee6203@gmail.com" },
   "homepage": "https://github.com/jhlee0409/selfish-pipeline",

package/README.md

@@ -4,7 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/selfish-pipeline)](https://www.npmjs.com/package/selfish-pipeline)
 [![license](https://img.shields.io/github/license/jhlee0409/selfish-pipeline)](./LICENSE)
-[![test](https://img.shields.io/badge/tests-118%20passed-brightgreen)](#how-it-works)
+[![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)
 

package/commands/architect.md

@@ -18,7 +18,7 @@ model: sonnet
 # /selfish:architect — Architecture Analysis and Design Advice
 
 > Analyzes the codebase architecture and records design decisions.
-> Ensures design quality through 3 Critic Loop iterations. **Read-only** — does not modify code.
+> Ensures design quality through convergence-based Critic Loop. **Read-only** — does not modify code.
 
 ## Arguments
 
@@ -89,10 +89,12 @@ Structure analysis results and **print to console**:
 {config.architecture} rule violations, import direction validation
 ```
 
-### 4. Critic Loop (3 iterations)
+### 4. Critic Loop
 
 > **Always** read `docs/critic-loop-rules.md` first and follow it.
 
+Run the critic loop until convergence. Safety cap: 7 passes.
+
 | Criterion | Validation |
 |-----------|------------|
 | **FEASIBILITY** | Is the suggestion achievable in the current codebase? |
@@ -100,10 +102,11 @@ Structure analysis results and **print to console**:
 | **COMPATIBILITY** | Is it compatible with existing code? Are there breaking changes? |
 | **ARCHITECTURE** | Does it comply with {config.architecture} rules? |
 
-Output rules:
-- FAIL: `⚠ {criterion}: {issue}. Revising...`
-- PASS: `✓ Critic {N}/3 passed`
-- Final: `Critic Loop complete ({N} iterations). Key revisions: {summary}`
+**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. Save ADR (for design decisions)
 
@@ -125,7 +128,7 @@ If ADR type, save to `memory/decisions/{YYYY-MM-DD}-{topic}.md`:
 Architecture analysis complete
 ├─ Type: {structure analysis | design question | ADR | refactoring evaluation}
 ├─ Findings: {count}
-├─ Critic: {N} iterations complete
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 ├─ ADR: {saved | n/a}
 └─ Suggestion: {key suggestion in one line}
 ```

package/commands/auto.md

@@ -35,7 +35,7 @@ If config file is missing: print "`.claude/selfish.config.md` not found. Create
 ## Critic Loop Rules (common to all phases)
 
 > **Always** read `docs/critic-loop-rules.md` first and follow it.
-> Core: minimum 1 concern per criterion + mandatory Adversarial failure scenario each pass + quantitative evidence required. "PASS" as a single word is prohibited.
+> Core: minimum 1 concern per criterion + mandatory Adversarial failure scenario each pass + quantitative evidence required. "PASS" as a single word is prohibited. Uses convergence-based termination with 4 verdicts (PASS/FAIL/ESCALATE/DEFER). On ESCALATE: pause and present options to user even in auto mode.
 
 ---
 
@@ -46,6 +46,12 @@ If config file is missing: print "`.claude/selfish.config.md` not found. Create
 1. If `$ARGUMENTS` is empty → print "Please enter a feature description." and abort
 2. Check current branch → `BRANCH_NAME`
 3. Determine feature name (2-3 keywords → kebab-case)
+3.5. **Preflight Check**:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/selfish-preflight-check.sh"
+   ```
+   - If exit 1 (hard failure) → print error and **abort**
+   - If warnings only (exit 0) → print warnings and continue
 4. **Activate Pipeline Flag** (hook integration):
    ```bash
    "${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" start {feature}
@@ -53,6 +59,7 @@ If config file is missing: print "`.claude/selfish.config.md` not found. Create
    - Safety Snapshot created automatically (`selfish/pre-auto` git tag)
    - Stop Gate Hook activated (blocks response termination on CI failure)
    - File change tracking started
+   - Timeline log: `"${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" log pipeline-start "Auto pipeline: {feature}"`
 5. Create `specs/{feature}/` directory → **record path as `PIPELINE_ARTIFACT_DIR`** (for Clean scope)
 6. Start notification:
    ```
@@ -71,13 +78,16 @@ Execute `/selfish:spec` logic inline:
 2. Create `specs/{feature}/spec.md`
 3. `[NEEDS CLARIFICATION]` items are **auto-resolved with best-guess** (clarify skipped)
    - Tag auto-resolved items with `[AUTO-RESOLVED]`
-4. **Critic Loop 1 pass** (follow Critic Loop rules):
+4. **Retrospective check**: if `memory/retrospectives/` exists, load 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 until convergence** (safety cap: 5, follow Critic Loop rules):
    - COMPLETENESS: does every User Story have acceptance scenarios? Any missing requirements?
    - MEASURABILITY: are success criteria measurable, not subjective? **Is quantitative evidence provided for numerical targets?**
    - INDEPENDENCE: are implementation details (code, library names) absent from the spec?
    - EDGE_CASES: are at least 2 identified? Any missing boundary conditions?
-   - FAIL items → auto-fix and update spec.md
-5. Progress: `✓ 1/6 Spec complete (US: {N}, FR: {N}, Critic: {FAIL count} fixed)`
+   - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
+6. Progress: `✓ 1/6 Spec complete (US: {N}, FR: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
 
 ### Phase 2: Plan (2/6)
 
@@ -89,7 +99,7 @@ Execute `/selfish:plan` logic inline:
 2. If technical uncertainties exist → auto-resolve via WebSearch/code exploration → create research.md
 3. Create `specs/{feature}/plan.md`
    - **If setting numerical targets (line counts etc.), include structure-analysis-based estimates** (e.g., "function A ~50 lines, component B ~80 lines → total ~130 lines")
-4. **Critic Loop 3 passes** (follow Critic Loop rules):
+4. **Critic Loop until convergence** (safety cap: 7, follow Critic Loop rules):
    - Criteria: COMPLETENESS, FEASIBILITY, ARCHITECTURE, RISK, PRINCIPLES
    - **RISK criterion mandatory checks**:
      - Enumerate **at least 3** `{config.ci}` failure scenarios and describe mitigation
@@ -97,7 +107,8 @@ Execute `/selfish:plan` logic inline:
      - Consider `{config.framework}` characteristics (server/client boundary etc.)
    - **ARCHITECTURE criterion**: explicitly describe import paths for moved/created files and pre-validate against `{config.architecture}` rules
    - Each pass must **explicitly explore what was missed in the previous pass** ("Pass 2: {X} was missed in pass 1. Further review: ...")
-5. Progress: `✓ 2/6 Plan complete (Critic: {total FAIL fixes}, files: {N})`
+   - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
+5. Progress: `✓ 2/6 Plan complete (Critic: converged ({N} passes, {M} fixes, {E} escalations), files: {N})`
 
 ### Phase 3: Tasks (3/6)
 
@@ -113,11 +124,15 @@ Execute `/selfish:tasks` logic inline:
    - Validate dependency graph is a DAG (no circular references)
    - [P] tasks **must be executed in parallel** in Phase 4 (declaring [P] then running sequentially is prohibited)
 4. Coverage mapping (FR → Task)
-5. **Critic Loop 1 pass** (follow Critic Loop rules):
+5. **Retrospective check**: if `memory/retrospectives/` exists, load 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.
+6. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
    - COVERAGE: is every FR/NFR mapped to at least 1 task?
    - DEPENDENCIES: is the dependency graph a valid DAG? Do [P] tasks have no file overlaps?
-6. Create `specs/{feature}/tasks.md`
-7. Progress: `✓ 3/6 Tasks complete (tasks: {N}, parallel: {N})`
+   - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
+7. Create `specs/{feature}/tasks.md`
+8. Progress: `✓ 3/6 Tasks complete (tasks: {N}, parallel: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
 
 ### Phase 4: Implement (4/6)
 
@@ -157,6 +172,7 @@ Execute `/selfish:implement` logic inline with **dependency-aware orchestration*
    ```
 
 6. Perform **3-step gate** on each Implementation Phase completion — **always** read `docs/phase-gate-protocol.md` first. Cannot advance to next phase without passing the gate.
+   - On gate pass: create phase rollback point `"${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" phase-tag {phase_number}`
 7. Real-time `[x]` updates in tasks.md
 8. After full completion, run `{config.ci}` final verification
    - On pass: `"${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" ci-pass` (releases Stop Gate)
@@ -171,13 +187,17 @@ Execute `/selfish:review` logic inline:
 
 1. Review implemented changed files (`git diff HEAD`)
 2. Check code quality, `{config.architecture}` rules, security, performance, `{config.code_style}` pattern compliance
-3. **Critic Loop 1 pass** (follow Critic Loop rules):
+3. **Retrospective check**: if `memory/retrospectives/` exists, load 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.
+4. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
    - COMPLETENESS: cross-check every SC (success criterion) from spec.md one by one. Provide specific metrics if falling short.
    - PRECISION: are there unnecessary changes? Are there out-of-scope modifications?
-4. **Handling SC shortfalls**:
+   - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
+5. **Handling SC shortfalls**:
    - Fixable → attempt auto-fix → re-run `{config.ci}` verification
    - Not fixable → state in final report with reason (no post-hoc rationalization; record as Plan-phase target-setting error)
-5. Progress: `✓ 5/6 Review complete (Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N})`
+6. Progress: `✓ 5/6 Review complete (Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N})`
 
 ### Phase 6: Clean (6/6)
 
@@ -199,24 +219,47 @@ Artifact cleanup and codebase hygiene check after implementation and review:
 4. **Memory update** (if applicable):
    - Reusable patterns found during pipeline → record in `memory/`
    - If there were `[AUTO-RESOLVED]` items → record decisions in `memory/decisions/`
-   - **If retrospective.md exists** → record as patterns missed by the Plan phase Critic Loop in `memory/` (reuse as RISK checklist items in future runs)
-5. **Checkpoint reset**:
+   - **If retrospective.md exists** → record as patterns missed by the Plan phase Critic Loop in `memory/retrospectives/` (reuse as RISK checklist items in future runs)
+   - **If review-report.md exists** → copy to `memory/reviews/{feature}-{date}.md` before specs/ deletion
+5. **Quality report** (structured pipeline metrics):
+   - Generate `memory/quality-history/{feature}-{date}.json` with the following structure:
+     ```json
+     {
+       "feature": "{feature}",
+       "date": "{YYYY-MM-DD}",
+       "phases": {
+         "spec": { "user_stories": N, "requirements": { "FR": N, "NFR": N }, "auto_resolved": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
+         "plan": { "files_planned": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
+         "tasks": { "total": N, "parallel": N, "phases": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
+         "implement": { "completed": N, "total": N, "ci_passes": N, "ci_failures": N },
+         "review": { "critical": N, "warning": N, "info": N, "sc_shortfalls": N, "critic_passes": N, "critic_fixes": N, "escalations": N }
+       },
+       "totals": { "changed_files": N, "auto_resolved": N, "escalations": N }
+     }
+     ```
+   - Create `memory/quality-history/` directory if it does not exist
+6. **Checkpoint reset**:
    - Clear `memory/checkpoint.md` (pipeline complete = session goal achieved)
-6. **Release Pipeline Flag** (hook integration):
+7. **Timeline finalize**:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" log pipeline-end "Pipeline complete: {feature}"
+   ```
+8. **Release Pipeline Flag** (hook integration):
    ```bash
    "${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" end
    ```
    - Stop Gate Hook deactivated
    - Change tracking log deleted
    - Safety tag removed (successful completion)
-7. Progress: `✓ 6/6 Clean complete (deleted: {N}, dead code: {N}, CI: ✓)`
+   - Phase rollback tags removed (handled automatically by pipeline end)
+9. Progress: `✓ 6/6 Clean complete (deleted: {N}, dead code: {N}, CI: ✓)`
 
 ### Final Output
 
 ```
 Auto pipeline complete: {feature}
 ├─ Spec: US {N}, FR {N}
-├─ Plan: Critic {FAIL fixes}, research {present/absent}
+├─ Plan: Critic converged ({N} passes, {M} fixes, {E} escalations), research {present/absent}
 ├─ Tasks: {total} (parallel {N})
 ├─ Implement: {completed}/{total} tasks, CI ✓, Checkpoint ✓
 ├─ Review: Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N}
@@ -253,7 +296,8 @@ Pipeline aborted (Phase {N}/6)
 - **Large feature warning**: warn before starting if more than 5 User Stories are expected.
 - **Read existing code first**: always read existing files before modifying. Do not blindly generate code.
 - **Follow project rules**: project rules in `selfish.config.md` and `CLAUDE.md` take priority.
-- **Critic Loop is not a ritual**: a single "PASS" line is equivalent to not running Critic at all. Always follow the format in the Critic Loop rules section.
+- **Critic Loop is not a ritual**: a single "PASS" line is equivalent to not running Critic at all. Always follow the format in the Critic Loop rules section. Critic uses convergence-based termination — it may finish in 1 pass or take several, depending on the output quality.
+- **ESCALATE pauses auto mode**: when a Critic finds an ambiguous issue requiring user judgment, the pipeline pauses and presents options via AskUserQuestion. Auto mode automates clear decisions but escalates ambiguous ones.
 - **[P] parallel is mandatory**: if a [P] marker is assigned in tasks.md, it must be executed in parallel. Orchestration mode (batch vs swarm) is selected automatically based on task count. Sequential substitution is prohibited.
 - **Swarm mode is automatic**: when a phase has 6+ [P] tasks, swarm workers self-organize via TaskList/TaskUpdate. Do not manually batch.
 - **No out-of-scope deletion**: do not delete files/directories in Clean that were not created by the current pipeline.

package/commands/debug.md

@@ -8,7 +8,7 @@ model: sonnet
 # /selfish:debug — Bug Diagnosis and Fix
 
 > Analyzes the root cause of a bug and fixes it.
-> Validates the safety and accuracy of the fix with 2 Critic Loop passes.
+> Validates the safety and accuracy of the fix with convergence-based Critic Loop.
 
 ## Arguments
 
@@ -59,18 +59,22 @@ Verify starting from highest probability.
 2. **Impact analysis**: verify what effect the fix has on other code
 3. **Apply fix**
 
-### 5. Critic Loop (2 passes)
+### 5. Critic Loop
 
 > **Always** read `docs/critic-loop-rules.md` first and follow it.
 
+Run the critic loop until convergence. Safety cap: 5 passes.
+
 | Criterion | Validation |
 |-----------|------------|
 | **SAFETY** | Does the fix break any other functionality? Any side effects? |
 | **CORRECTNESS** | Does it actually resolve the root cause? Or just mask the symptom? |
 
-On FAIL:
-- SAFETY fail → check and fix impacted code
-- CORRECTNESS fail → revisit hypotheses, move to next hypothesis
+**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. Verification
 
@@ -86,7 +90,7 @@ Retry after fixing on failure (max 3 attempts).
 Debug complete
 ├─ Root cause: {one-line summary}
 ├─ Fixed files: {file list}
-├─ Critic: {N} passes complete
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 ├─ Verified: typecheck + lint passed
 └─ Impact scope: {affected components/features}
 ```

package/commands/implement.md

@@ -124,6 +124,17 @@ When a phase has more than 5 parallelizable tasks, use the **self-organizing swa
 4. **Wait for all workers to exit** — workers naturally terminate when the pool is empty
 5. **Verify**: check TaskList for any incomplete tasks → re-spawn workers if needed
 
+#### Swarm Worker Failure Recovery
+
+When a worker agent exits with error (non-zero return or timeout):
+1. Scan TaskList for tasks with status `in_progress` that have no active worker
+2. Reset each orphaned task: `TaskUpdate(taskId, status: "pending", owner: "")`
+3. Track retry count per task (max 2 retries)
+4. If a task fails 3 times → mark as `failed`, report to user: `"T{ID} failed after 3 attempts: {last error}"`
+5. Re-spawn replacement workers for remaining tasks
+
+> Workers should wrap their implement-complete loop in error handling so a single task failure doesn't crash the entire worker.
+
 > Swarm workers self-balance: fast workers claim more tasks. No batch boundaries needed.
 
 #### Dependency Resolution
@@ -137,6 +148,12 @@ When a phase has more than 5 parallelizable tasks, use the **self-organizing swa
 > **Always** read `docs/phase-gate-protocol.md` first and perform the 3 steps (CI gate → Mini-Review → Auto-Checkpoint) in order.
 > Cannot advance to the next phase without passing the gate. Abort and report to user after 3 consecutive CI failures.
 
+After passing the gate, create a phase rollback point:
+```bash
+"${CLAUDE_PLUGIN_ROOT}/scripts/selfish-pipeline-manage.sh" phase-tag {phase_number}
+```
+This enables granular rollback: `git reset --hard selfish/phase-{N}` restores state after Phase N completed.
+
 ### 4. Task Execution Pattern
 
 For each task:

package/commands/plan.md

@@ -7,7 +7,7 @@ model: sonnet
 # /selfish:plan — Implementation Design
 
 > Generates an implementation plan (plan.md) based on the feature specification (spec.md).
-> Ensures quality with 3 Critic Loop passes and runs research in parallel when needed.
+> Ensures quality with convergence-based Critic Loop and runs research in parallel when needed.
 
 ## Arguments
 
@@ -110,6 +110,21 @@ Create `specs/{feature}/plan.md`. **Must** follow the structure below:
 |------|--------|------------|
 | {risk} | {H/M/L} | {approach} |
 
+## Alternative Design
+### Approach A: {chosen approach name}
+{Brief description — this is the approach detailed above}
+
+### Approach B: {alternative approach name}
+{Brief description of a meaningfully different approach}
+
+| Criterion | Approach A | Approach B |
+|-----------|-----------|-----------|
+| Complexity | {evaluation} | {evaluation} |
+| Risk | {evaluation} | {evaluation} |
+| Maintainability | {evaluation} | {evaluation} |
+
+**Decision**: Approach {A/B} — {1-sentence rationale}
+
 ## Phase Breakdown
 ### Phase 1: Setup
 {project structure, type definitions, configuration}
@@ -124,26 +139,25 @@ Create `specs/{feature}/plan.md`. **Must** follow the structure below:
 {error handling, performance optimization, tests}
 ```
 
-### 5. Critic Loop (3 passes)
+### 5. Critic Loop
 
 > **Always** read `docs/critic-loop-rules.md` first and follow it.
 
-After drafting plan.md, perform **up to 3 self-critique passes**.
-
-Validate against these 5 criteria each pass:
+Run the critic loop until convergence. Safety cap: 7 passes.
 
 | Criterion | Validation |
 |-----------|------------|
 | **COMPLETENESS** | Are all requirements (FR-*) from spec.md reflected in the plan? |
 | **FEASIBILITY** | Is it compatible with the existing codebase? Are dependencies available? |
 | **ARCHITECTURE** | Does it comply with {config.architecture} rules? |
-| **RISK** | Are there any unidentified risks? |
+| **RISK** | Are there any unidentified risks? Additionally, if `memory/retrospectives/` directory contains files from previous pipeline runs, load each file and check whether the current plan addresses the patterns recorded there. Tag matched patterns with `[RETRO-CHECKED]`. |
 | **PRINCIPLES** | Does it not violate the MUST principles in principles.md? |
 
-**Output rules**:
-- **If there are FAIL items**: display `⚠ {criterion}: {issue summary}. Fixing...` → update plan.md → proceed to next pass
-- **If no FAIL items**: display `✓ Critic {N}/3 passed`
-- **Final**: `Critic Loop complete ({N} passes). Key changes: {change summary}` or `Critic Loop complete (1 pass). No changes.`
+**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. Agent Teams (if needed)
 
@@ -161,7 +175,7 @@ Task("Research: {topic2}", subagent_type: "general-purpose")
 Plan generated
 ├─ specs/{feature}/plan.md
 ├─ specs/{feature}/research.md (if research was performed)
-├─ Critic: {N} passes, key changes: {summary}
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 └─ Next step: /selfish:tasks
 ```
 

package/commands/review.md

@@ -14,7 +14,7 @@ model: sonnet
 # /selfish:review — Code Review
 
 > Performs a comprehensive review of changed code (quality, security, performance, architecture compliance).
-> Validates completeness of the review itself with 1 Critic Loop pass.
+> Validates completeness of the review itself with convergence-based Critic Loop.
 
 ## Arguments
 
@@ -131,24 +131,52 @@ For each changed file, examine from the following perspectives:
 - {1-2 things done well}
 ```
 
-### 5. Critic Loop (1 pass)
+### 5. Retrospective Check
+
+If `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 `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: revise review and update final output.
+**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. Archive Review Report
+
+When running inside a pipeline (specs/{feature}/ exists), persist the review results:
+
+1. Write full review output (Summary table + Detailed Findings + Positives) to `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 `memory/reviews/{feature}-{date}.md` before specs/ deletion)
+
+When running standalone (no active pipeline), skip archiving — display results in console only.
 
-### 6. Final Output
+### 8. Final Output
 
 ```
 Review complete
 ├─ Files: {changed file count}
 ├─ Found: Critical {N} / Warning {N} / Info {N}
-├─ Critic: 1 pass complete
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 └─ Conclusion: {one-line summary}
 ```
 

package/commands/spec.md

@@ -7,7 +7,7 @@ model: sonnet
 # /selfish:spec — Generate Feature Specification
 
 > Converts a natural language feature description into a structured specification (spec.md).
-> Operates on pure prompts without external scripts.
+> Validates completeness with convergence-based Critic Loop. Operates on pure prompts without external scripts.
 
 ## Arguments
 
@@ -77,6 +77,13 @@ Create `specs/{feature-name}/spec.md`:
 ### Non-Functional Requirements
 - **NFR-001**: {performance/security/accessibility etc.}
 
+### Auto-Suggested NFRs
+{Load `docs/nfr-templates.md` and select 3-5 relevant NFRs based on the project type detected from selfish.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 |
 |--------|-------------|-----------------------|
@@ -97,26 +104,32 @@ Create `specs/{feature-name}/spec.md`:
 - {uncertain items — record if any, remove section if none}
 ```
 
-### 4. Critic Loop (1 pass)
+### 4. Retrospective Check
+
+If `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 `docs/critic-loop-rules.md` first and follow it.
 
-After writing, perform a **self-critique loop** once:
+Run the critic loop until convergence. Safety cap: 5 passes.
 
-```
-=== CRITIC PASS 1/1 ===
-[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?
-```
+| 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 spec.md → notify user of changes
-  - e.g., `⚠ COMPLETENESS: US3 missing acceptance scenarios. Adding...`
-- **ALL PASS**: display `✓ Critic passed`
-- Complete FAIL → fix → re-validate cycle before proceeding to the next step
+**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. Final Output
+### 6. Final Output
 
 ```
 Spec generated
@@ -133,3 +146,4 @@ Spec generated
 - 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 `/selfish:auto`, `[AUTO-SUGGESTED]` NFRs are included automatically. Review after completion is recommended.

package/commands/tasks.md

@@ -8,7 +8,7 @@ model: sonnet
 # /selfish:tasks — Task Decomposition
 
 > Generates an executable task list (tasks.md) based on plan.md.
-> Validates coverage with 1 Critic Loop iteration.
+> Validates coverage with convergence-based Critic Loop.
 
 ## Arguments
 
@@ -73,22 +73,35 @@ Decompose tasks per Phase defined in plan.md.
 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. **Dependency graph must be a DAG**: no circular dependencies allowed. Validate before output.
-5. **Test tasks**: Include a verification task for each testable unit
-6. **Phase gate**: Add a `{config.gate}` validation task at the end of each Phase
+4. **[P] physical validation**: Before finalizing tasks.md, run `"${CLAUDE_PLUGIN_ROOT}/scripts/selfish-parallel-validate.sh" 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. Critic Loop (1 pass)
+### 3. Retrospective Check
+
+If `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 `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? |
+| **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/selfish-parallel-validate.sh"` can be called with the tasks.md path to verify no conflicts exist. |
 
-On FAIL: add missing items and re-check.
+**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.`
 
-### 4. Coverage Mapping
+### 5. Coverage Mapping
 
 ```markdown
 ## Coverage Mapping
@@ -101,7 +114,7 @@ On FAIL: add missing items and re-check.
 
 Every FR-*/NFR-* must be mapped to at least one task.
 
-### 5. Final Output
+### 6. Final Output
 
 Save to `specs/{feature}/tasks.md`, then:
 
@@ -111,7 +124,7 @@ Tasks generated
 ├─ Tasks: {total count} ({[P] count} parallelizable)
 ├─ Phases: {phase count}
 ├─ Coverage: FR {coverage}%, NFR {coverage}%
-├─ Critic: 1 iteration complete
+├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 └─ Next step: /selfish:analyze (optional) or /selfish:implement
 ```